@tulex-cli/tulex-code 0.1.1

package/dist/src/ui/hooks/vim.test.js

@@ -0,0 +1,1975 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useVim } from './vim.js';
+import { textBufferReducer } from '../components/shared/text-buffer.js';
+// Prevent real system clipboard commands (clip, pbpaste, xclip, etc.) from
+// spawning during tests — they hang or fail in headless CI environments.
+vi.mock('child_process');
+const makeKey = (sequence, name = '') => ({
+    sequence,
+    name,
+    ctrl: false,
+    meta: false,
+    shift: false,
+    paste: false,
+});
+// Mock the VimModeContext
+const mockVimContext = {
+    vimEnabled: true,
+    vimMode: 'NORMAL',
+    toggleVimEnabled: vi.fn(),
+    setVimMode: vi.fn(),
+};
+vi.mock('../contexts/VimModeContext.js', () => ({
+    useVimModeState: () => ({
+        vimEnabled: mockVimContext.vimEnabled,
+        vimMode: mockVimContext.vimMode,
+    }),
+    useVimModeActions: () => ({
+        toggleVimEnabled: mockVimContext.toggleVimEnabled,
+        setVimMode: mockVimContext.setVimMode,
+    }),
+    useVimMode: () => mockVimContext,
+    VimModeProvider: ({ children }) => children,
+}));
+// Test constants
+const TEST_SEQUENCES = {
+    ESCAPE: makeKey('\u001b', 'escape'),
+    LEFT: makeKey('h'),
+    RIGHT: makeKey('l'),
+    UP: makeKey('k'),
+    DOWN: makeKey('j'),
+    INSERT: makeKey('i'),
+    APPEND: makeKey('a'),
+    DELETE_CHAR: makeKey('x'),
+    DELETE: makeKey('d'),
+    CHANGE: makeKey('c'),
+    WORD_FORWARD: makeKey('w'),
+    WORD_BACKWARD: makeKey('b'),
+    WORD_END: makeKey('e'),
+    LINE_START: makeKey('0'),
+    LINE_END: makeKey('$'),
+    REPEAT: makeKey('.'),
+};
+describe('useVim hook', () => {
+    let mockBuffer;
+    let mockHandleFinalSubmit;
+    const createMockBuffer = (text = 'hello world', cursor = [0, 5]) => {
+        const cursorState = { pos: cursor };
+        const lines = text.split('\n');
+        return {
+            lines,
+            get cursor() {
+                return cursorState.pos;
+            },
+            set cursor(newPos) {
+                cursorState.pos = newPos;
+            },
+            text,
+            move: vi.fn().mockImplementation((direction) => {
+                let [row, col] = cursorState.pos;
+                const line = lines[row] || '';
+                if (direction === 'left') {
+                    col = Math.max(0, col - 1);
+                }
+                else if (direction === 'right') {
+                    col = Math.min(line.length, col + 1);
+                }
+                else if (direction === 'home') {
+                    col = 0;
+                }
+                else if (direction === 'end') {
+                    col = line.length;
+                }
+                cursorState.pos = [row, col];
+            }),
+            del: vi.fn(),
+            moveToOffset: vi.fn(),
+            insert: vi.fn(),
+            newline: vi.fn(),
+            replaceRangeByOffset: vi.fn(),
+            replaceRange: vi.fn(),
+            handleInput: vi.fn(),
+            setText: vi.fn(),
+            undo: vi.fn(),
+            redo: vi.fn(),
+            // Vim-specific methods
+            vimDeleteWordForward: vi.fn(),
+            vimDeleteWordBackward: vi.fn(),
+            vimDeleteWordEnd: vi.fn(),
+            vimChangeWordForward: vi.fn(),
+            vimChangeWordBackward: vi.fn(),
+            vimChangeWordEnd: vi.fn(),
+            vimDeleteLine: vi.fn(),
+            vimChangeLine: vi.fn(),
+            vimDeleteToEndOfLine: vi.fn(),
+            vimChangeToEndOfLine: vi.fn(),
+            vimChangeMovement: vi.fn(),
+            vimDeleteMovement: vi.fn(),
+            vimMoveLeft: vi.fn().mockImplementation((count = 1) => {
+                const [row, col] = cursorState.pos;
+                cursorState.pos = [row, Math.max(0, col - count)];
+            }),
+            vimMoveRight: vi.fn().mockImplementation((count = 1) => {
+                const [row, col] = cursorState.pos;
+                const line = lines[row] || '';
+                cursorState.pos = [row, Math.min(line.length, col + count)];
+            }),
+            vimMoveUp: vi.fn().mockImplementation((count = 1) => {
+                const [row, col] = cursorState.pos;
+                cursorState.pos = [Math.max(0, row - count), col];
+            }),
+            vimMoveDown: vi.fn().mockImplementation((count = 1) => {
+                const [row, col] = cursorState.pos;
+                cursorState.pos = [Math.min(lines.length - 1, row + count), col];
+            }),
+            vimMoveWordForward: vi.fn(),
+            vimMoveWordBackward: vi.fn(),
+            vimMoveWordEnd: vi.fn(),
+            vimDeleteChar: vi.fn(),
+            vimInsertAtCursor: vi.fn(),
+            vimAppendAtCursor: vi.fn().mockImplementation(() => {
+                // Append moves cursor right (vim 'a' behavior - position after current char)
+                const [row, col] = cursorState.pos;
+                // In vim, 'a' moves cursor to position after current character
+                // This allows inserting at the end of the line
+                cursorState.pos = [row, col + 1];
+            }),
+            vimOpenLineBelow: vi.fn(),
+            vimOpenLineAbove: vi.fn(),
+            vimAppendAtLineEnd: vi.fn(),
+            vimInsertAtLineStart: vi.fn(),
+            vimMoveToLineStart: vi.fn().mockImplementation(() => {
+                const [row] = cursorState.pos;
+                cursorState.pos = [row, 0];
+            }),
+            vimMoveToLineEnd: vi.fn().mockImplementation(() => {
+                const [row] = cursorState.pos;
+                const line = lines[row] || '';
+                cursorState.pos = [row, line.length];
+            }),
+            vimMoveToFirstNonWhitespace: vi.fn().mockImplementation(() => {
+                const [row] = cursorState.pos;
+                const line = lines[row] || '';
+                const match = line.match(/\S/);
+                cursorState.pos = [row, match ? match.index : 0];
+            }),
+            vimMoveToFirstLine: vi.fn().mockImplementation(() => {
+                cursorState.pos = [0, 0];
+            }),
+            vimMoveToLastLine: vi.fn().mockImplementation(() => {
+                cursorState.pos = [lines.length - 1, 0];
+            }),
+            vimMoveToLine: vi.fn().mockImplementation((lineNum) => {
+                cursorState.pos = [
+                    Math.min(lines.length - 1, Math.max(0, lineNum - 1)),
+                    0,
+                ];
+            }),
+            vimEscapeInsertMode: vi.fn().mockImplementation(() => {
+                // Escape moves cursor left unless at beginning of line
+                const [row, col] = cursorState.pos;
+                if (col > 0) {
+                    cursorState.pos = [row, col - 1];
+                }
+            }),
+        };
+    };
+    const renderVimHook = (buffer) => renderHook(() => useVim((buffer || mockBuffer), mockHandleFinalSubmit));
+    const exitInsertMode = (result) => {
+        act(() => {
+            result.current.handleInput(makeKey('\u001b', 'escape'));
+        });
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockHandleFinalSubmit = vi.fn();
+        mockBuffer = createMockBuffer();
+        // Reset mock context to default state
+        mockVimContext.vimEnabled = true;
+        mockVimContext.vimMode = 'NORMAL';
+        mockVimContext.toggleVimEnabled.mockClear();
+        mockVimContext.setVimMode.mockClear();
+    });
+    describe('Mode switching', () => {
+        it('should start in NORMAL mode', () => {
+            const { result } = renderVimHook();
+            expect(result.current.mode).toBe('NORMAL');
+        });
+        it('should switch to INSERT mode with i command', () => {
+            const { result } = renderVimHook();
+            act(() => {
+                result.current.handleInput(TEST_SEQUENCES.INSERT);
+            });
+            expect(result.current.mode).toBe('INSERT');
+            expect(mockVimContext.setVimMode).toHaveBeenCalledWith('INSERT');
+        });
+        it('should switch back to NORMAL mode with Escape', () => {
+            const { result } = renderVimHook();
+            act(() => {
+                result.current.handleInput(TEST_SEQUENCES.INSERT);
+            });
+            expect(result.current.mode).toBe('INSERT');
+            exitInsertMode(result);
+            expect(result.current.mode).toBe('NORMAL');
+        });
+        it('should properly handle escape followed immediately by a command', () => {
+            const testBuffer = createMockBuffer('hello world test', [0, 6]);
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('i'));
+            });
+            expect(result.current.mode).toBe('INSERT');
+            vi.clearAllMocks();
+            exitInsertMode(result);
+            expect(result.current.mode).toBe('NORMAL');
+            act(() => {
+                result.current.handleInput(makeKey('b'));
+            });
+            expect(testBuffer.vimMoveWordBackward).toHaveBeenCalledWith(1);
+        });
+        it('should pass through ? in NORMAL mode when the buffer is empty', () => {
+            const emptyBuffer = createMockBuffer('', [0, 0]);
+            emptyBuffer.lines = [''];
+            emptyBuffer.text = '';
+            const { result } = renderVimHook(emptyBuffer);
+            let handled = true;
+            act(() => {
+                handled = result.current.handleInput(makeKey('?', ''));
+            });
+            expect(handled).toBe(false);
+        });
+        it('should still handle ? in NORMAL mode when the buffer is not empty', () => {
+            const { result } = renderVimHook();
+            let handled = false;
+            act(() => {
+                handled = result.current.handleInput(makeKey('?', ''));
+            });
+            expect(handled).toBe(true);
+        });
+    });
+    describe('Navigation commands', () => {
+        it('should handle h (left movement)', () => {
+            const { result } = renderVimHook();
+            act(() => {
+                result.current.handleInput(makeKey('h'));
+            });
+            expect(mockBuffer.vimMoveLeft).toHaveBeenCalledWith(1);
+        });
+        it('should handle l (right movement)', () => {
+            const { result } = renderVimHook();
+            act(() => {
+                result.current.handleInput(makeKey('l'));
+            });
+            expect(mockBuffer.vimMoveRight).toHaveBeenCalledWith(1);
+        });
+        it('should handle j (down movement)', () => {
+            const testBuffer = createMockBuffer('first line\nsecond line');
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('j'));
+            });
+            expect(testBuffer.vimMoveDown).toHaveBeenCalledWith(1);
+        });
+        it('should handle k (up movement)', () => {
+            const testBuffer = createMockBuffer('first line\nsecond line');
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('k'));
+            });
+            expect(testBuffer.vimMoveUp).toHaveBeenCalledWith(1);
+        });
+        it('should handle 0 (move to start of line)', () => {
+            const { result } = renderVimHook();
+            act(() => {
+                result.current.handleInput(makeKey('0'));
+            });
+            expect(mockBuffer.vimMoveToLineStart).toHaveBeenCalled();
+        });
+        it('should handle $ (move to end of line)', () => {
+            const { result } = renderVimHook();
+            act(() => {
+                result.current.handleInput(makeKey('$'));
+            });
+            expect(mockBuffer.vimMoveToLineEnd).toHaveBeenCalled();
+        });
+    });
+    describe('Mode switching commands', () => {
+        it('should handle a (append after cursor)', () => {
+            const { result } = renderVimHook();
+            act(() => {
+                result.current.handleInput(makeKey('a'));
+            });
+            expect(mockBuffer.vimAppendAtCursor).toHaveBeenCalled();
+            expect(result.current.mode).toBe('INSERT');
+        });
+        it('should handle A (append at end of line)', () => {
+            const { result } = renderVimHook();
+            act(() => {
+                result.current.handleInput(makeKey('A'));
+            });
+            expect(mockBuffer.vimAppendAtLineEnd).toHaveBeenCalled();
+            expect(result.current.mode).toBe('INSERT');
+        });
+        it('should handle o (open line below)', () => {
+            const { result } = renderVimHook();
+            act(() => {
+                result.current.handleInput(makeKey('o'));
+            });
+            expect(mockBuffer.vimOpenLineBelow).toHaveBeenCalled();
+            expect(result.current.mode).toBe('INSERT');
+        });
+        it('should handle O (open line above)', () => {
+            const { result } = renderVimHook();
+            act(() => {
+                result.current.handleInput(makeKey('O'));
+            });
+            expect(mockBuffer.vimOpenLineAbove).toHaveBeenCalled();
+            expect(result.current.mode).toBe('INSERT');
+        });
+    });
+    describe('Edit commands', () => {
+        it('should handle x (delete character)', () => {
+            const { result } = renderVimHook();
+            vi.clearAllMocks();
+            act(() => {
+                result.current.handleInput(makeKey('x'));
+            });
+            expect(mockBuffer.vimDeleteChar).toHaveBeenCalledWith(1);
+        });
+        it('should move cursor left when deleting last character on line (vim behavior)', () => {
+            const testBuffer = createMockBuffer('hello', [0, 4]);
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('x'));
+            });
+            expect(testBuffer.vimDeleteChar).toHaveBeenCalledWith(1);
+        });
+        it('should handle first d key (sets pending state)', () => {
+            const { result } = renderVimHook();
+            act(() => {
+                result.current.handleInput(makeKey('d'));
+            });
+            expect(mockBuffer.replaceRangeByOffset).not.toHaveBeenCalled();
+        });
+    });
+    describe('Count handling', () => {
+        it('should handle count input and return to count 0 after command', () => {
+            const { result } = renderVimHook();
+            act(() => {
+                const handled = result.current.handleInput(makeKey('3'));
+                expect(handled).toBe(true);
+            });
+            act(() => {
+                const handled = result.current.handleInput(makeKey('h'));
+                expect(handled).toBe(true);
+            });
+            expect(mockBuffer.vimMoveLeft).toHaveBeenCalledWith(3);
+        });
+        it('should only delete 1 character with x command when no count is specified', () => {
+            const testBuffer = createMockBuffer();
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('x'));
+            });
+            expect(testBuffer.vimDeleteChar).toHaveBeenCalledWith(1);
+        });
+    });
+    describe('Word movement', () => {
+        it('should properly initialize vim hook with word movement support', () => {
+            const testBuffer = createMockBuffer('cat elephant mouse', [0, 0]);
+            const { result } = renderVimHook(testBuffer);
+            expect(result.current.vimModeEnabled).toBe(true);
+            expect(result.current.mode).toBe('NORMAL');
+            expect(result.current.handleInput).toBeDefined();
+        });
+        it('should support vim mode and basic operations across multiple lines', () => {
+            const testBuffer = createMockBuffer('first line word\nsecond line word', [0, 11]);
+            const { result } = renderVimHook(testBuffer);
+            expect(result.current.vimModeEnabled).toBe(true);
+            expect(result.current.mode).toBe('NORMAL');
+            expect(result.current.handleInput).toBeDefined();
+            expect(testBuffer.replaceRangeByOffset).toBeDefined();
+            expect(testBuffer.moveToOffset).toBeDefined();
+        });
+        it('should handle w (next word)', () => {
+            const testBuffer = createMockBuffer('hello world test');
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('w'));
+            });
+            expect(testBuffer.vimMoveWordForward).toHaveBeenCalledWith(1);
+        });
+        it('should handle b (previous word)', () => {
+            const testBuffer = createMockBuffer('hello world test', [0, 6]);
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('b'));
+            });
+            expect(testBuffer.vimMoveWordBackward).toHaveBeenCalledWith(1);
+        });
+        it('should handle e (end of word)', () => {
+            const testBuffer = createMockBuffer('hello world test');
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('e'));
+            });
+            expect(testBuffer.vimMoveWordEnd).toHaveBeenCalledWith(1);
+        });
+        it('should handle w when cursor is on the last word', () => {
+            const testBuffer = createMockBuffer('hello world', [0, 8]);
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('w'));
+            });
+            expect(testBuffer.vimMoveWordForward).toHaveBeenCalledWith(1);
+        });
+        it('should handle first c key (sets pending change state)', () => {
+            const { result } = renderVimHook();
+            act(() => {
+                result.current.handleInput(makeKey('c'));
+            });
+            expect(result.current.mode).toBe('NORMAL');
+            expect(mockBuffer.del).not.toHaveBeenCalled();
+        });
+        it('should clear pending state on invalid command sequence (df)', () => {
+            const { result } = renderVimHook();
+            act(() => {
+                result.current.handleInput(makeKey('d'));
+                result.current.handleInput(makeKey('f'));
+            });
+            expect(mockBuffer.replaceRangeByOffset).not.toHaveBeenCalled();
+            expect(mockBuffer.del).not.toHaveBeenCalled();
+        });
+        it('should clear pending state with Escape in NORMAL mode', () => {
+            const { result } = renderVimHook();
+            act(() => {
+                result.current.handleInput(makeKey('d'));
+            });
+            exitInsertMode(result);
+            expect(mockBuffer.replaceRangeByOffset).not.toHaveBeenCalled();
+        });
+    });
+    describe('Disabled vim mode', () => {
+        it('should not respond to vim commands when disabled', () => {
+            mockVimContext.vimEnabled = false;
+            const { result } = renderVimHook(mockBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('h'));
+            });
+            expect(mockBuffer.move).not.toHaveBeenCalled();
+        });
+    });
+    // These tests are no longer applicable at the hook level
+    describe('Command repeat system', () => {
+        it('should repeat x command from current cursor position', () => {
+            const testBuffer = createMockBuffer('abcd\nefgh\nijkl', [0, 1]);
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('x'));
+            });
+            expect(testBuffer.vimDeleteChar).toHaveBeenCalledWith(1);
+            testBuffer.cursor = [1, 2];
+            act(() => {
+                result.current.handleInput(makeKey('.'));
+            });
+            expect(testBuffer.vimDeleteChar).toHaveBeenCalledWith(1);
+        });
+        it('should repeat dd command from current position', () => {
+            const testBuffer = createMockBuffer('line1\nline2\nline3', [1, 0]);
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('d'));
+            });
+            act(() => {
+                result.current.handleInput(makeKey('d'));
+            });
+            expect(testBuffer.vimDeleteLine).toHaveBeenCalledTimes(1);
+            testBuffer.cursor = [0, 0];
+            act(() => {
+                result.current.handleInput(makeKey('.'));
+            });
+            expect(testBuffer.vimDeleteLine).toHaveBeenCalledTimes(2);
+        });
+        it('should repeat ce command from current position', () => {
+            const testBuffer = createMockBuffer('word', [0, 0]);
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('c'));
+            });
+            act(() => {
+                result.current.handleInput(makeKey('e'));
+            });
+            expect(testBuffer.vimChangeWordEnd).toHaveBeenCalledTimes(1);
+            // Exit INSERT mode to complete the command
+            exitInsertMode(result);
+            testBuffer.cursor = [0, 2];
+            act(() => {
+                result.current.handleInput(makeKey('.'));
+            });
+            expect(testBuffer.vimChangeWordEnd).toHaveBeenCalledTimes(2);
+        });
+        it('should repeat cc command from current position', () => {
+            const testBuffer = createMockBuffer('line1\nline2\nline3', [1, 2]);
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('c'));
+            });
+            act(() => {
+                result.current.handleInput(makeKey('c'));
+            });
+            expect(testBuffer.vimChangeLine).toHaveBeenCalledTimes(1);
+            // Exit INSERT mode to complete the command
+            exitInsertMode(result);
+            testBuffer.cursor = [0, 1];
+            act(() => {
+                result.current.handleInput(makeKey('.'));
+            });
+            expect(testBuffer.vimChangeLine).toHaveBeenCalledTimes(2);
+        });
+        it('should repeat cw command from current position', () => {
+            const testBuffer = createMockBuffer('hello world test', [0, 6]);
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('c'));
+            });
+            act(() => {
+                result.current.handleInput(makeKey('w'));
+            });
+            expect(testBuffer.vimChangeWordForward).toHaveBeenCalledTimes(1);
+            // Exit INSERT mode to complete the command
+            exitInsertMode(result);
+            testBuffer.cursor = [0, 0];
+            act(() => {
+                result.current.handleInput(makeKey('.'));
+            });
+            expect(testBuffer.vimChangeWordForward).toHaveBeenCalledTimes(2);
+        });
+        it('should repeat D command from current position', () => {
+            const testBuffer = createMockBuffer('hello world test', [0, 6]);
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('D'));
+            });
+            expect(testBuffer.vimDeleteToEndOfLine).toHaveBeenCalledTimes(1);
+            testBuffer.cursor = [0, 2];
+            vi.clearAllMocks(); // Clear all mocks instead of just one method
+            act(() => {
+                result.current.handleInput(makeKey('.'));
+            });
+            expect(testBuffer.vimDeleteToEndOfLine).toHaveBeenCalledTimes(1);
+        });
+        it('should repeat C command from current position', () => {
+            const testBuffer = createMockBuffer('hello world test', [0, 6]);
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('C'));
+            });
+            expect(testBuffer.vimChangeToEndOfLine).toHaveBeenCalledTimes(1);
+            // Exit INSERT mode to complete the command
+            exitInsertMode(result);
+            testBuffer.cursor = [0, 2];
+            act(() => {
+                result.current.handleInput(makeKey('.'));
+            });
+            expect(testBuffer.vimChangeToEndOfLine).toHaveBeenCalledTimes(2);
+        });
+        it('should repeat command after cursor movement', () => {
+            const testBuffer = createMockBuffer('test text', [0, 0]);
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('x'));
+            });
+            expect(testBuffer.vimDeleteChar).toHaveBeenCalledWith(1);
+            testBuffer.cursor = [0, 2];
+            act(() => {
+                result.current.handleInput(makeKey('.'));
+            });
+            expect(testBuffer.vimDeleteChar).toHaveBeenCalledWith(1);
+        });
+        it('should move cursor to the correct position after exiting INSERT mode with "a"', () => {
+            const testBuffer = createMockBuffer('hello world', [0, 10]);
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('a'));
+            });
+            expect(result.current.mode).toBe('INSERT');
+            expect(testBuffer.cursor).toEqual([0, 11]);
+            exitInsertMode(result);
+            expect(result.current.mode).toBe('NORMAL');
+            expect(testBuffer.cursor).toEqual([0, 10]);
+        });
+    });
+    describe('Special characters and edge cases', () => {
+        it('should handle ^ (move to first non-whitespace character)', () => {
+            const testBuffer = createMockBuffer('   hello world', [0, 5]);
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('^'));
+            });
+            expect(testBuffer.vimMoveToFirstNonWhitespace).toHaveBeenCalled();
+        });
+        it('should handle G without count (go to last line)', () => {
+            const testBuffer = createMockBuffer('line1\nline2\nline3', [0, 0]);
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('G'));
+            });
+            expect(testBuffer.vimMoveToLastLine).toHaveBeenCalled();
+        });
+        it('should handle gg (go to first line)', () => {
+            const testBuffer = createMockBuffer('line1\nline2\nline3', [2, 0]);
+            const { result } = renderVimHook(testBuffer);
+            // First 'g' sets pending state
+            act(() => {
+                result.current.handleInput(makeKey('g'));
+            });
+            // Second 'g' executes the command
+            act(() => {
+                result.current.handleInput(makeKey('g'));
+            });
+            expect(testBuffer.vimMoveToFirstLine).toHaveBeenCalled();
+        });
+        it('should handle count with movement commands', () => {
+            const testBuffer = createMockBuffer('hello world test', [0, 0]);
+            const { result } = renderVimHook(testBuffer);
+            act(() => {
+                result.current.handleInput(makeKey('3'));
+            });
+            act(() => {
+                result.current.handleInput(TEST_SEQUENCES.WORD_FORWARD);
+            });
+            expect(testBuffer.vimMoveWordForward).toHaveBeenCalledWith(3);
+        });
+    });
+    describe('Vim word operations', () => {
+        describe('dw (delete word forward)', () => {
+            it('should delete from cursor to start of next word', () => {
+                const testBuffer = createMockBuffer('hello world test', [0, 0]);
+                const { result } = renderVimHook(testBuffer);
+                act(() => {
+                    result.current.handleInput(makeKey('d'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('w'));
+                });
+                expect(testBuffer.vimDeleteWordForward).toHaveBeenCalledWith(1);
+            });
+            it('should actually delete the complete word including trailing space', () => {
+                // This test uses the real text-buffer reducer instead of mocks
+                const initialState = {
+                    lines: ['hello world test'],
+                    cursorRow: 0,
+                    cursorCol: 0,
+                    preferredCol: null,
+                    undoStack: [],
+                    redoStack: [],
+                    clipboard: null,
+                    selectionAnchor: null,
+                    viewportWidth: 80,
+                    viewportHeight: 24,
+                    visualLayout: {
+                        visualLines: [],
+                        logicalToVisualMap: [],
+                        visualToLogicalMap: [],
+                    },
+                };
+                const result = textBufferReducer(initialState, {
+                    type: 'vim_delete_word_forward',
+                    payload: { count: 1 },
+                });
+                // Should delete "hello " (word + space), leaving "world test"
+                expect(result.lines).toEqual(['world test']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(0);
+            });
+            it('should delete word from middle of word correctly', () => {
+                const initialState = {
+                    lines: ['hello world test'],
+                    cursorRow: 0,
+                    cursorCol: 2, // cursor on 'l' in "hello"
+                    preferredCol: null,
+                    undoStack: [],
+                    redoStack: [],
+                    clipboard: null,
+                    selectionAnchor: null,
+                    viewportWidth: 80,
+                    viewportHeight: 24,
+                    visualLayout: {
+                        visualLines: [],
+                        logicalToVisualMap: [],
+                        visualToLogicalMap: [],
+                    },
+                };
+                const result = textBufferReducer(initialState, {
+                    type: 'vim_delete_word_forward',
+                    payload: { count: 1 },
+                });
+                // Should delete "llo " (rest of word + space), leaving "he world test"
+                expect(result.lines).toEqual(['heworld test']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(2);
+            });
+            it('should handle dw at end of line', () => {
+                const initialState = {
+                    lines: ['hello world'],
+                    cursorRow: 0,
+                    cursorCol: 6, // cursor on 'w' in "world"
+                    preferredCol: null,
+                    undoStack: [],
+                    redoStack: [],
+                    clipboard: null,
+                    selectionAnchor: null,
+                    viewportWidth: 80,
+                    viewportHeight: 24,
+                    visualLayout: {
+                        visualLines: [],
+                        logicalToVisualMap: [],
+                        visualToLogicalMap: [],
+                    },
+                };
+                const result = textBufferReducer(initialState, {
+                    type: 'vim_delete_word_forward',
+                    payload: { count: 1 },
+                });
+                // Should delete "world" (no trailing space at end), leaving "hello "
+                expect(result.lines).toEqual(['hello ']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(6);
+            });
+            it('should delete multiple words with count', () => {
+                const testBuffer = createMockBuffer('one two three four', [0, 0]);
+                const { result } = renderVimHook(testBuffer);
+                act(() => {
+                    result.current.handleInput(makeKey('2'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('d'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('w'));
+                });
+                expect(testBuffer.vimDeleteWordForward).toHaveBeenCalledWith(2);
+            });
+            it('should record command for repeat with dot', () => {
+                const testBuffer = createMockBuffer('hello world test', [0, 0]);
+                const { result } = renderVimHook(testBuffer);
+                // Execute dw
+                act(() => {
+                    result.current.handleInput(makeKey('d'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('w'));
+                });
+                vi.clearAllMocks();
+                // Execute dot repeat
+                act(() => {
+                    result.current.handleInput(makeKey('.'));
+                });
+                expect(testBuffer.vimDeleteWordForward).toHaveBeenCalledWith(1);
+            });
+        });
+        describe('de (delete word end)', () => {
+            it('should delete from cursor to end of current word', () => {
+                const testBuffer = createMockBuffer('hello world test', [0, 1]);
+                const { result } = renderVimHook(testBuffer);
+                act(() => {
+                    result.current.handleInput(makeKey('d'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('e'));
+                });
+                expect(testBuffer.vimDeleteWordEnd).toHaveBeenCalledWith(1);
+            });
+            it('should handle count with de', () => {
+                const testBuffer = createMockBuffer('one two three four', [0, 0]);
+                const { result } = renderVimHook(testBuffer);
+                act(() => {
+                    result.current.handleInput(makeKey('3'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('d'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('e'));
+                });
+                expect(testBuffer.vimDeleteWordEnd).toHaveBeenCalledWith(3);
+            });
+        });
+        describe('cw (change word forward)', () => {
+            it('should change from cursor to start of next word and enter INSERT mode', () => {
+                const testBuffer = createMockBuffer('hello world test', [0, 0]);
+                const { result } = renderVimHook(testBuffer);
+                act(() => {
+                    result.current.handleInput(makeKey('c'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('w'));
+                });
+                expect(testBuffer.vimChangeWordForward).toHaveBeenCalledWith(1);
+                expect(result.current.mode).toBe('INSERT');
+                expect(mockVimContext.setVimMode).toHaveBeenCalledWith('INSERT');
+            });
+            it('should handle count with cw', () => {
+                const testBuffer = createMockBuffer('one two three four', [0, 0]);
+                const { result } = renderVimHook(testBuffer);
+                act(() => {
+                    result.current.handleInput(makeKey('2'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('c'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('w'));
+                });
+                expect(testBuffer.vimChangeWordForward).toHaveBeenCalledWith(2);
+                expect(result.current.mode).toBe('INSERT');
+            });
+            it('should be repeatable with dot', () => {
+                const testBuffer = createMockBuffer('hello world test more', [0, 0]);
+                const { result } = renderVimHook(testBuffer);
+                // Execute cw
+                act(() => {
+                    result.current.handleInput(makeKey('c'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('w'));
+                });
+                // Exit INSERT mode
+                exitInsertMode(result);
+                vi.clearAllMocks();
+                mockVimContext.setVimMode.mockClear();
+                // Execute dot repeat
+                act(() => {
+                    result.current.handleInput(makeKey('.'));
+                });
+                expect(testBuffer.vimChangeWordForward).toHaveBeenCalledWith(1);
+                expect(result.current.mode).toBe('INSERT');
+            });
+        });
+        describe('ce (change word end)', () => {
+            it('should change from cursor to end of word and enter INSERT mode', () => {
+                const testBuffer = createMockBuffer('hello world test', [0, 1]);
+                const { result } = renderVimHook(testBuffer);
+                act(() => {
+                    result.current.handleInput(makeKey('c'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('e'));
+                });
+                expect(testBuffer.vimChangeWordEnd).toHaveBeenCalledWith(1);
+                expect(result.current.mode).toBe('INSERT');
+            });
+            it('should handle count with ce', () => {
+                const testBuffer = createMockBuffer('one two three four', [0, 0]);
+                const { result } = renderVimHook(testBuffer);
+                act(() => {
+                    result.current.handleInput(makeKey('2'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('c'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('e'));
+                });
+                expect(testBuffer.vimChangeWordEnd).toHaveBeenCalledWith(2);
+                expect(result.current.mode).toBe('INSERT');
+            });
+        });
+        describe('cc (change line)', () => {
+            it('should change entire line and enter INSERT mode', () => {
+                const testBuffer = createMockBuffer('hello world\nsecond line', [0, 5]);
+                const { result } = renderVimHook(testBuffer);
+                act(() => {
+                    result.current.handleInput(makeKey('c'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('c'));
+                });
+                expect(testBuffer.vimChangeLine).toHaveBeenCalledWith(1);
+                expect(result.current.mode).toBe('INSERT');
+            });
+            it('should change multiple lines with count', () => {
+                const testBuffer = createMockBuffer('line1\nline2\nline3\nline4', [1, 0]);
+                const { result } = renderVimHook(testBuffer);
+                act(() => {
+                    result.current.handleInput(makeKey('3'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('c'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('c'));
+                });
+                expect(testBuffer.vimChangeLine).toHaveBeenCalledWith(3);
+                expect(result.current.mode).toBe('INSERT');
+            });
+            it('should be repeatable with dot', () => {
+                const testBuffer = createMockBuffer('line1\nline2\nline3', [0, 0]);
+                const { result } = renderVimHook(testBuffer);
+                // Execute cc
+                act(() => {
+                    result.current.handleInput(makeKey('c'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('c'));
+                });
+                // Exit INSERT mode
+                exitInsertMode(result);
+                vi.clearAllMocks();
+                mockVimContext.setVimMode.mockClear();
+                // Execute dot repeat
+                act(() => {
+                    result.current.handleInput(makeKey('.'));
+                });
+                expect(testBuffer.vimChangeLine).toHaveBeenCalledWith(1);
+                expect(result.current.mode).toBe('INSERT');
+            });
+        });
+        describe('db (delete word backward)', () => {
+            it('should delete from cursor to start of previous word', () => {
+                const testBuffer = createMockBuffer('hello world test', [0, 11]);
+                const { result } = renderVimHook(testBuffer);
+                act(() => {
+                    result.current.handleInput(makeKey('d'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('b'));
+                });
+                expect(testBuffer.vimDeleteWordBackward).toHaveBeenCalledWith(1);
+            });
+            it('should handle count with db', () => {
+                const testBuffer = createMockBuffer('one two three four', [0, 18]);
+                const { result } = renderVimHook(testBuffer);
+                act(() => {
+                    result.current.handleInput(makeKey('2'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('d'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('b'));
+                });
+                expect(testBuffer.vimDeleteWordBackward).toHaveBeenCalledWith(2);
+            });
+        });
+        describe('cb (change word backward)', () => {
+            it('should change from cursor to start of previous word and enter INSERT mode', () => {
+                const testBuffer = createMockBuffer('hello world test', [0, 11]);
+                const { result } = renderVimHook(testBuffer);
+                act(() => {
+                    result.current.handleInput(makeKey('c'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('b'));
+                });
+                expect(testBuffer.vimChangeWordBackward).toHaveBeenCalledWith(1);
+                expect(result.current.mode).toBe('INSERT');
+            });
+            it('should handle count with cb', () => {
+                const testBuffer = createMockBuffer('one two three four', [0, 18]);
+                const { result } = renderVimHook(testBuffer);
+                act(() => {
+                    result.current.handleInput(makeKey('3'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('c'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('b'));
+                });
+                expect(testBuffer.vimChangeWordBackward).toHaveBeenCalledWith(3);
+                expect(result.current.mode).toBe('INSERT');
+            });
+        });
+        describe('Pending state handling', () => {
+            it('should clear pending delete state after dw', () => {
+                const testBuffer = createMockBuffer('hello world', [0, 0]);
+                const { result } = renderVimHook(testBuffer);
+                // Press 'd' to enter pending delete state
+                act(() => {
+                    result.current.handleInput(makeKey('d'));
+                });
+                // Complete with 'w'
+                act(() => {
+                    result.current.handleInput(makeKey('w'));
+                });
+                // Next 'd' should start a new pending state, not continue the previous one
+                act(() => {
+                    result.current.handleInput(makeKey('d'));
+                });
+                // This should trigger dd (delete line), not an error
+                act(() => {
+                    result.current.handleInput(makeKey('d'));
+                });
+                expect(testBuffer.vimDeleteLine).toHaveBeenCalledWith(1);
+            });
+            it('should clear pending change state after cw', () => {
+                const testBuffer = createMockBuffer('hello world', [0, 0]);
+                const { result } = renderVimHook(testBuffer);
+                // Execute cw
+                act(() => {
+                    result.current.handleInput(makeKey('c'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('w'));
+                });
+                // Exit INSERT mode
+                exitInsertMode(result);
+                // Next 'c' should start a new pending state
+                act(() => {
+                    result.current.handleInput(makeKey('c'));
+                });
+                act(() => {
+                    result.current.handleInput(makeKey('c'));
+                });
+                expect(testBuffer.vimChangeLine).toHaveBeenCalledWith(1);
+            });
+            it('should clear pending state with escape', () => {
+                const testBuffer = createMockBuffer('hello world', [0, 0]);
+                const { result } = renderVimHook(testBuffer);
+                // Enter pending delete state
+                act(() => {
+                    result.current.handleInput(makeKey('d'));
+                });
+                // Press escape to clear pending state
+                act(() => {
+                    result.current.handleInput(makeKey('\u001b', 'escape'));
+                });
+                // Now 'w' should just move cursor, not delete
+                act(() => {
+                    result.current.handleInput(makeKey('w'));
+                });
+                expect(testBuffer.vimDeleteWordForward).not.toHaveBeenCalled();
+                // w should move to next word after clearing pending state
+                expect(testBuffer.vimMoveWordForward).toHaveBeenCalledWith(1);
+            });
+        });
+        describe('NORMAL mode escape behavior', () => {
+            it('should pass escape through when no pending operator is active', () => {
+                mockVimContext.vimMode = 'NORMAL';
+                const { result } = renderVimHook();
+                const handled = result.current.handleInput(makeKey('\u001b', 'escape'));
+                expect(handled).toBe(false);
+            });
+            it('should handle escape and clear pending operator', () => {
+                mockVimContext.vimMode = 'NORMAL';
+                const { result } = renderVimHook();
+                act(() => {
+                    result.current.handleInput(makeKey('d'));
+                });
+                let handled;
+                act(() => {
+                    handled = result.current.handleInput(makeKey('\u001b', 'escape'));
+                });
+                expect(handled).toBe(true);
+            });
+        });
+    });
+    describe('Shell command pass-through', () => {
+        it('should pass through ctrl+r in INSERT mode', () => {
+            mockVimContext.vimMode = 'INSERT';
+            const { result } = renderVimHook();
+            const handled = result.current.handleInput({
+                ...makeKey('r', 'r'),
+                ctrl: true,
+            });
+            expect(handled).toBe(false);
+        });
+        it('should pass through ! in INSERT mode when buffer is empty', () => {
+            mockVimContext.vimMode = 'INSERT';
+            const emptyBuffer = createMockBuffer('');
+            const { result } = renderVimHook(emptyBuffer);
+            const handled = result.current.handleInput(makeKey('!'));
+            expect(handled).toBe(false);
+        });
+        it('should handle ! as input in INSERT mode when buffer is not empty', () => {
+            mockVimContext.vimMode = 'INSERT';
+            const nonEmptyBuffer = createMockBuffer('not empty');
+            const { result } = renderVimHook(nonEmptyBuffer);
+            const key = makeKey('!', '!');
+            act(() => {
+                result.current.handleInput(key);
+            });
+            expect(nonEmptyBuffer.handleInput).toHaveBeenCalledWith(expect.objectContaining(key));
+        });
+    });
+    // Line operations (dd, cc) are tested in text-buffer.test.ts
+    describe('Reducer-based integration tests', () => {
+        describe('de (delete word end)', () => {
+            it('should delete from cursor to end of current word', () => {
+                const initialState = {
+                    lines: ['hello world test'],
+                    cursorRow: 0,
+                    cursorCol: 1, // cursor on 'e' in "hello"
+                    preferredCol: null,
+                    undoStack: [],
+                    redoStack: [],
+                    clipboard: null,
+                    selectionAnchor: null,
+                    viewportWidth: 80,
+                    viewportHeight: 24,
+                    visualLayout: {
+                        visualLines: [],
+                        logicalToVisualMap: [],
+                        visualToLogicalMap: [],
+                    },
+                };
+                const result = textBufferReducer(initialState, {
+                    type: 'vim_delete_word_end',
+                    payload: { count: 1 },
+                });
+                // Should delete "ello" (from cursor to end of word), leaving "h world test"
+                expect(result.lines).toEqual(['h world test']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(1);
+            });
+            it('should delete multiple word ends with count', () => {
+                const initialState = {
+                    lines: ['hello world test more'],
+                    cursorRow: 0,
+                    cursorCol: 1, // cursor on 'e' in "hello"
+                    preferredCol: null,
+                    undoStack: [],
+                    redoStack: [],
+                    clipboard: null,
+                    selectionAnchor: null,
+                    viewportWidth: 80,
+                    viewportHeight: 24,
+                    visualLayout: {
+                        visualLines: [],
+                        logicalToVisualMap: [],
+                        visualToLogicalMap: [],
+                    },
+                };
+                const result = textBufferReducer(initialState, {
+                    type: 'vim_delete_word_end',
+                    payload: { count: 2 },
+                });
+                // Should delete "ello world" (to end of second word), leaving "h test more"
+                expect(result.lines).toEqual(['h test more']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(1);
+            });
+        });
+        describe('db (delete word backward)', () => {
+            it('should delete from cursor to start of previous word', () => {
+                const initialState = {
+                    lines: ['hello world test'],
+                    cursorRow: 0,
+                    cursorCol: 11, // cursor on 't' in "test"
+                    preferredCol: null,
+                    undoStack: [],
+                    redoStack: [],
+                    clipboard: null,
+                    selectionAnchor: null,
+                    viewportWidth: 80,
+                    viewportHeight: 24,
+                    visualLayout: {
+                        visualLines: [],
+                        logicalToVisualMap: [],
+                        visualToLogicalMap: [],
+                    },
+                };
+                const result = textBufferReducer(initialState, {
+                    type: 'vim_delete_word_backward',
+                    payload: { count: 1 },
+                });
+                // Should delete "world" (previous word only), leaving "hello  test"
+                expect(result.lines).toEqual(['hello  test']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(6);
+            });
+            it('should delete multiple words backward with count', () => {
+                const initialState = {
+                    lines: ['hello world test more'],
+                    cursorRow: 0,
+                    cursorCol: 17, // cursor on 'm' in "more"
+                    preferredCol: null,
+                    undoStack: [],
+                    redoStack: [],
+                    clipboard: null,
+                    selectionAnchor: null,
+                    viewportWidth: 80,
+                    viewportHeight: 24,
+                    visualLayout: {
+                        visualLines: [],
+                        logicalToVisualMap: [],
+                        visualToLogicalMap: [],
+                    },
+                };
+                const result = textBufferReducer(initialState, {
+                    type: 'vim_delete_word_backward',
+                    payload: { count: 2 },
+                });
+                // Should delete "world test " (two words backward), leaving "hello more"
+                expect(result.lines).toEqual(['hello more']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(6);
+            });
+        });
+        describe('cw (change word forward)', () => {
+            it('should delete from cursor to start of next word', () => {
+                const initialState = {
+                    lines: ['hello world test'],
+                    cursorRow: 0,
+                    cursorCol: 0, // cursor on 'h' in "hello"
+                    preferredCol: null,
+                    undoStack: [],
+                    redoStack: [],
+                    clipboard: null,
+                    selectionAnchor: null,
+                    viewportWidth: 80,
+                    viewportHeight: 24,
+                    visualLayout: {
+                        visualLines: [],
+                        logicalToVisualMap: [],
+                        visualToLogicalMap: [],
+                    },
+                };
+                const result = textBufferReducer(initialState, {
+                    type: 'vim_change_word_forward',
+                    payload: { count: 1 },
+                });
+                // Should delete "hello " (word + space), leaving "world test"
+                expect(result.lines).toEqual(['world test']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(0);
+            });
+            it('should change multiple words with count', () => {
+                const initialState = {
+                    lines: ['hello world test more'],
+                    cursorRow: 0,
+                    cursorCol: 0,
+                    preferredCol: null,
+                    undoStack: [],
+                    redoStack: [],
+                    clipboard: null,
+                    selectionAnchor: null,
+                    viewportWidth: 80,
+                    viewportHeight: 24,
+                    visualLayout: {
+                        visualLines: [],
+                        logicalToVisualMap: [],
+                        visualToLogicalMap: [],
+                    },
+                };
+                const result = textBufferReducer(initialState, {
+                    type: 'vim_change_word_forward',
+                    payload: { count: 2 },
+                });
+                // Should delete "hello world " (two words), leaving "test more"
+                expect(result.lines).toEqual(['test more']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(0);
+            });
+        });
+        describe('ce (change word end)', () => {
+            it('should change from cursor to end of current word', () => {
+                const initialState = {
+                    lines: ['hello world test'],
+                    cursorRow: 0,
+                    cursorCol: 1, // cursor on 'e' in "hello"
+                    preferredCol: null,
+                    undoStack: [],
+                    redoStack: [],
+                    clipboard: null,
+                    selectionAnchor: null,
+                    viewportWidth: 80,
+                    viewportHeight: 24,
+                    visualLayout: {
+                        visualLines: [],
+                        logicalToVisualMap: [],
+                        visualToLogicalMap: [],
+                    },
+                };
+                const result = textBufferReducer(initialState, {
+                    type: 'vim_change_word_end',
+                    payload: { count: 1 },
+                });
+                // Should delete "ello" (from cursor to end of word), leaving "h world test"
+                expect(result.lines).toEqual(['h world test']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(1);
+            });
+            it('should change multiple word ends with count', () => {
+                const initialState = {
+                    lines: ['hello world test'],
+                    cursorRow: 0,
+                    cursorCol: 1, // cursor on 'e' in "hello"
+                    preferredCol: null,
+                    undoStack: [],
+                    redoStack: [],
+                    clipboard: null,
+                    selectionAnchor: null,
+                    viewportWidth: 80,
+                    viewportHeight: 24,
+                    visualLayout: {
+                        visualLines: [],
+                        logicalToVisualMap: [],
+                        visualToLogicalMap: [],
+                    },
+                };
+                const result = textBufferReducer(initialState, {
+                    type: 'vim_change_word_end',
+                    payload: { count: 2 },
+                });
+                // Should delete "ello world" (to end of second word), leaving "h test"
+                expect(result.lines).toEqual(['h test']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(1);
+            });
+        });
+        describe('cb (change word backward)', () => {
+            it('should change from cursor to start of previous word', () => {
+                const initialState = {
+                    lines: ['hello world test'],
+                    cursorRow: 0,
+                    cursorCol: 11, // cursor on 't' in "test"
+                    preferredCol: null,
+                    undoStack: [],
+                    redoStack: [],
+                    clipboard: null,
+                    selectionAnchor: null,
+                    viewportWidth: 80,
+                    viewportHeight: 24,
+                    visualLayout: {
+                        visualLines: [],
+                        logicalToVisualMap: [],
+                        visualToLogicalMap: [],
+                    },
+                };
+                const result = textBufferReducer(initialState, {
+                    type: 'vim_change_word_backward',
+                    payload: { count: 1 },
+                });
+                // Should delete "world" (previous word only), leaving "hello  test"
+                expect(result.lines).toEqual(['hello  test']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(6);
+            });
+        });
+        describe('cc (change line)', () => {
+            it('should clear the line and place cursor at the start', () => {
+                const initialState = {
+                    lines: ['  hello world'],
+                    cursorRow: 0,
+                    cursorCol: 5, // cursor on 'o'
+                    preferredCol: null,
+                    undoStack: [],
+                    redoStack: [],
+                    clipboard: null,
+                    selectionAnchor: null,
+                    viewportWidth: 80,
+                    viewportHeight: 24,
+                    visualLayout: {
+                        visualLines: [],
+                        logicalToVisualMap: [],
+                        visualToLogicalMap: [],
+                    },
+                };
+                const result = textBufferReducer(initialState, {
+                    type: 'vim_change_line',
+                    payload: { count: 1 },
+                });
+                expect(result.lines).toEqual(['']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(0);
+            });
+        });
+        describe('dd (delete line)', () => {
+            it('should delete the current line', () => {
+                const initialState = {
+                    lines: ['line1', 'line2', 'line3'],
+                    cursorRow: 1,
+                    cursorCol: 2,
+                    preferredCol: null,
+                    undoStack: [],
+                    redoStack: [],
+                    clipboard: null,
+                    selectionAnchor: null,
+                    viewportWidth: 80,
+                    viewportHeight: 24,
+                    visualLayout: {
+                        visualLines: [],
+                        logicalToVisualMap: [],
+                        visualToLogicalMap: [],
+                    },
+                };
+                const result = textBufferReducer(initialState, {
+                    type: 'vim_delete_line',
+                    payload: { count: 1 },
+                });
+                expect(result.lines).toEqual(['line1', 'line3']);
+                expect(result.cursorRow).toBe(1);
+                expect(result.cursorCol).toBe(0);
+            });
+            it('should delete multiple lines with count', () => {
+                const initialState = {
+                    lines: ['line1', 'line2', 'line3', 'line4'],
+                    cursorRow: 1,
+                    cursorCol: 2,
+                    preferredCol: null,
+                    undoStack: [],
+                    redoStack: [],
+                    clipboard: null,
+                    selectionAnchor: null,
+                    viewportWidth: 80,
+                    viewportHeight: 24,
+                    visualLayout: {
+                        visualLines: [],
+                        logicalToVisualMap: [],
+                        visualToLogicalMap: [],
+                    },
+                };
+                const result = textBufferReducer(initialState, {
+                    type: 'vim_delete_line',
+                    payload: { count: 2 },
+                });
+                // Should delete lines 1 and 2
+                expect(result.lines).toEqual(['line1', 'line4']);
+                expect(result.cursorRow).toBe(1);
+                expect(result.cursorCol).toBe(0);
+            });
+            it('should handle deleting last line', () => {
+                const initialState = {
+                    lines: ['only line'],
+                    cursorRow: 0,
+                    cursorCol: 3,
+                    preferredCol: null,
+                    undoStack: [],
+                    redoStack: [],
+                    clipboard: null,
+                    selectionAnchor: null,
+                    viewportWidth: 80,
+                    viewportHeight: 24,
+                    visualLayout: {
+                        visualLines: [],
+                        logicalToVisualMap: [],
+                        visualToLogicalMap: [],
+                    },
+                };
+                const result = textBufferReducer(initialState, {
+                    type: 'vim_delete_line',
+                    payload: { count: 1 },
+                });
+                // Should leave an empty line when deleting the only line
+                expect(result.lines).toEqual(['']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(0);
+            });
+        });
+        describe('D (delete to end of line)', () => {
+            it('should delete from cursor to end of line', () => {
+                const initialState = {
+                    lines: ['hello world test'],
+                    cursorRow: 0,
+                    cursorCol: 6, // cursor on 'w' in "world"
+                    preferredCol: null,
+                    undoStack: [],
+                    redoStack: [],
+                    clipboard: null,
+                    selectionAnchor: null,
+                    viewportWidth: 80,
+                    viewportHeight: 24,
+                    visualLayout: {
+                        visualLines: [],
+                        logicalToVisualMap: [],
+                        visualToLogicalMap: [],
+                    },
+                };
+                const result = textBufferReducer(initialState, {
+                    type: 'vim_delete_to_end_of_line',
+                });
+                // Should delete "world test", leaving "hello "
+                expect(result.lines).toEqual(['hello ']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(6);
+            });
+            it('should handle D at end of line', () => {
+                const initialState = {
+                    lines: ['hello world'],
+                    cursorRow: 0,
+                    cursorCol: 11, // cursor at end
+                    preferredCol: null,
+                    undoStack: [],
+                    redoStack: [],
+                    clipboard: null,
+                    selectionAnchor: null,
+                    viewportWidth: 80,
+                    viewportHeight: 24,
+                    visualLayout: {
+                        visualLines: [],
+                        logicalToVisualMap: [],
+                        visualToLogicalMap: [],
+                    },
+                };
+                const result = textBufferReducer(initialState, {
+                    type: 'vim_delete_to_end_of_line',
+                });
+                // Should not change anything when at end of line
+                expect(result.lines).toEqual(['hello world']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(11);
+            });
+        });
+        describe('C (change to end of line)', () => {
+            it('should change from cursor to end of line', () => {
+                const initialState = {
+                    lines: ['hello world test'],
+                    cursorRow: 0,
+                    cursorCol: 6, // cursor on 'w' in "world"
+                    preferredCol: null,
+                    undoStack: [],
+                    redoStack: [],
+                    clipboard: null,
+                    selectionAnchor: null,
+                    viewportWidth: 80,
+                    viewportHeight: 24,
+                    visualLayout: {
+                        visualLines: [],
+                        logicalToVisualMap: [],
+                        visualToLogicalMap: [],
+                    },
+                };
+                const result = textBufferReducer(initialState, {
+                    type: 'vim_change_to_end_of_line',
+                });
+                // Should delete "world test", leaving "hello "
+                expect(result.lines).toEqual(['hello ']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(6);
+            });
+            it('should handle C at beginning of line', () => {
+                const initialState = {
+                    lines: ['hello world'],
+                    cursorRow: 0,
+                    cursorCol: 0,
+                    preferredCol: null,
+                    undoStack: [],
+                    redoStack: [],
+                    clipboard: null,
+                    selectionAnchor: null,
+                    viewportWidth: 80,
+                    viewportHeight: 24,
+                    visualLayout: {
+                        visualLines: [],
+                        logicalToVisualMap: [],
+                        visualToLogicalMap: [],
+                    },
+                };
+                const result = textBufferReducer(initialState, {
+                    type: 'vim_change_to_end_of_line',
+                });
+                // Should delete entire line content
+                expect(result.lines).toEqual(['']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(0);
+            });
+        });
+    });
+    describe('New vim commands', () => {
+        describe('u (undo)', () => {
+            it('should undo last operation', () => {
+                const buffer = createMockBuffer('hello world');
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                act(() => result.current.handleInput(makeKey('x')));
+                act(() => result.current.handleInput(makeKey('u')));
+                // Undo should call buffer.undo()
+                expect(buffer.undo).toHaveBeenCalled();
+            });
+        });
+        describe('r (replace char)', () => {
+            it('should replace character under cursor', () => {
+                const buffer = createMockBuffer('hello world', [0, 0]);
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                act(() => result.current.handleInput(makeKey('r')));
+                act(() => result.current.handleInput(makeKey('x')));
+                // Should replace 'h' with 'x' using replaceRange
+                expect(buffer.replaceRange).toHaveBeenCalledWith(0, 0, 0, 1, 'x');
+            });
+        });
+        describe('~ (toggle case)', () => {
+            it('should toggle case of character under cursor', () => {
+                const buffer = createMockBuffer('Hello', [0, 0]);
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                act(() => result.current.handleInput(makeKey('~')));
+                // Should replace 'H' with 'h' and move cursor right
+                expect(buffer.replaceRange).toHaveBeenCalledWith(0, 0, 0, 1, 'h');
+            });
+        });
+        describe('J (join lines)', () => {
+            it('should join current line with next line', () => {
+                const buffer = createMockBuffer('hello\nworld', [0, 5]);
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                act(() => result.current.handleInput(makeKey('J')));
+                // Should call replaceRange to join lines
+                expect(buffer.replaceRange).toHaveBeenCalledWith(0, 0, 1, 5, 'hello world');
+            });
+        });
+        describe('>> (indent line)', () => {
+            it('should indent current line', () => {
+                const buffer = createMockBuffer('hello', [0, 0]);
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                act(() => result.current.handleInput(makeKey('>')));
+                act(() => result.current.handleInput(makeKey('>')));
+                // Should replace entire line with indented version (atomic operation)
+                expect(buffer.replaceRange).toHaveBeenCalledWith(0, 0, 0, 5, '  hello');
+            });
+        });
+        describe('<< (unindent line)', () => {
+            it('should unindent current line', () => {
+                const buffer = createMockBuffer('  hello', [0, 2]);
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                act(() => result.current.handleInput(makeKey('<')));
+                act(() => result.current.handleInput(makeKey('<')));
+                // Should replace entire line with outdented version (atomic operation)
+                expect(buffer.replaceRange).toHaveBeenCalledWith(0, 0, 0, 7, 'hello');
+            });
+        });
+        describe('W (big word forward)', () => {
+            it('should move to next big word', () => {
+                const buffer = createMockBuffer('hello.world test', [0, 0]);
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                act(() => result.current.handleInput(makeKey('W')));
+                // Should move to start of 'test' (col 12)
+                expect(buffer.vimMoveToLineStart).toHaveBeenCalled();
+                expect(buffer.vimMoveRight).toHaveBeenCalledWith(12);
+            });
+        });
+        describe('B (big word backward)', () => {
+            it('should move to previous big word', () => {
+                const buffer = createMockBuffer('hello.world test', [0, 12]);
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                act(() => result.current.handleInput(makeKey('B')));
+                // Should move to start of 'hello.world' (col 0)
+                expect(buffer.vimMoveToLineStart).toHaveBeenCalled();
+                expect(buffer.vimMoveRight).toHaveBeenCalledWith(0);
+            });
+        });
+        describe('E (big word end)', () => {
+            it('should move to end of big word', () => {
+                const buffer = createMockBuffer('hello.world test', [0, 0]);
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                act(() => result.current.handleInput(makeKey('E')));
+                // Should move to end of 'hello.world' (col 10)
+                expect(buffer.vimMoveToLineStart).toHaveBeenCalled();
+                expect(buffer.vimMoveRight).toHaveBeenCalledWith(10);
+            });
+        });
+        describe('f (find char forward)', () => {
+            it('should find character forward on line', () => {
+                const buffer = createMockBuffer('hello world', [0, 0]);
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                act(() => result.current.handleInput(makeKey('f')));
+                act(() => result.current.handleInput(makeKey('o')));
+                // Should set cursor to first 'o' (position 4)
+                expect(buffer.cursor[1]).toBe(4);
+            });
+        });
+        describe('F (find char backward)', () => {
+            it('should find character backward on line', () => {
+                const buffer = createMockBuffer('hello world', [0, 9]);
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                act(() => result.current.handleInput(makeKey('F')));
+                act(() => result.current.handleInput(makeKey('o')));
+                // Should set cursor to 'o' in 'world' (position 7)
+                expect(buffer.cursor[1]).toBe(7);
+            });
+        });
+        describe('t (find char forward before)', () => {
+            it('should find character forward and stop before it', () => {
+                const buffer = createMockBuffer('hello world', [0, 0]);
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                act(() => result.current.handleInput(makeKey('t')));
+                act(() => result.current.handleInput(makeKey('o')));
+                // Should set cursor to position 3 (before 'o')
+                expect(buffer.cursor[1]).toBe(3);
+            });
+        });
+        describe('T (find char backward after)', () => {
+            it('should find character backward and stop after it', () => {
+                const buffer = createMockBuffer('hello world', [0, 9]);
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                act(() => result.current.handleInput(makeKey('T')));
+                act(() => result.current.handleInput(makeKey('o')));
+                // Should set cursor to position 8 (after 'o' in world)
+                expect(buffer.cursor[1]).toBe(8);
+            });
+        });
+        describe('; (repeat find)', () => {
+            it('should repeat last f command', () => {
+                const buffer = createMockBuffer('hello world', [0, 0]);
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                // First find 'o'
+                act(() => result.current.handleInput(makeKey('f')));
+                act(() => result.current.handleInput(makeKey('o')));
+                expect(buffer.cursor[1]).toBe(4);
+                // Repeat find
+                act(() => result.current.handleInput(makeKey(';')));
+                // Should find next 'o' in 'world' (position 7)
+                expect(buffer.cursor[1]).toBe(7);
+            });
+        });
+        describe(', (reverse repeat find)', () => {
+            it('should reverse repeat last f command', () => {
+                const buffer = createMockBuffer('hello world', [0, 0]);
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                // First find 'o' forward (finds at position 4)
+                act(() => result.current.handleInput(makeKey('f')));
+                act(() => result.current.handleInput(makeKey('o')));
+                expect(buffer.cursor[1]).toBe(4);
+                // Reverse repeat find - should go back to previous 'o' (none before position 0, stays at 4)
+                act(() => result.current.handleInput(makeKey(',')));
+                // No 'o' before position 0, so stays at 4
+                expect(buffer.cursor[1]).toBe(4);
+            });
+        });
+        describe('y (yank)', () => {
+            it('should yank line with yy for later paste', () => {
+                const buffer = createMockBuffer('hello world', [0, 5]);
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                act(() => result.current.handleInput(makeKey('y')));
+                act(() => result.current.handleInput(makeKey('y')));
+                // Paste on last line should append at line end
+                act(() => result.current.handleInput(makeKey('p')));
+                expect(buffer.replaceRange).toHaveBeenCalledWith(0, 11, 0, 11, '\nhello world');
+            });
+        });
+        describe('Y (yank line)', () => {
+            it('should yank entire line for later paste', () => {
+                const buffer = createMockBuffer('hello world', [0, 5]);
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                act(() => result.current.handleInput(makeKey('Y')));
+                // Paste should insert the yanked line above current line
+                act(() => result.current.handleInput(makeKey('P')));
+                expect(buffer.replaceRange).toHaveBeenCalledWith(0, 0, 0, 0, 'hello world\n');
+            });
+        });
+        describe('p (paste after)', () => {
+            it('should paste after cursor', () => {
+                const buffer = createMockBuffer('hello world', [0, 0]);
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                // yw from col 0 yanks 'hello ' (word + trailing space)
+                act(() => result.current.handleInput(makeKey('y')));
+                act(() => result.current.handleInput(makeKey('w')));
+                // Paste after cursor at col 1 (col + 1)
+                act(() => result.current.handleInput(makeKey('p')));
+                expect(buffer.replaceRange).toHaveBeenCalledWith(0, 1, 0, 1, 'hello ');
+                expect(buffer.vimMoveLeft).toHaveBeenCalledWith(1);
+            });
+        });
+        describe('P (paste before)', () => {
+            it('should paste before cursor', () => {
+                const buffer = createMockBuffer('hello world', [0, 0]);
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                // yw from col 0 yanks 'hello '
+                act(() => result.current.handleInput(makeKey('y')));
+                act(() => result.current.handleInput(makeKey('w')));
+                // Paste before cursor at col 0
+                act(() => result.current.handleInput(makeKey('P')));
+                expect(buffer.replaceRange).toHaveBeenCalledWith(0, 0, 0, 0, 'hello ');
+            });
+        });
+        describe('Enter (submit in NORMAL mode)', () => {
+            it('should submit text when Enter is pressed in NORMAL mode', () => {
+                const buffer = createMockBuffer('hello world');
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                act(() => result.current.handleInput(makeKey('\r', 'return')));
+                expect(mockHandleFinalSubmit).toHaveBeenCalledWith('hello world');
+                expect(buffer.setText).toHaveBeenCalledWith('');
+            });
+            it('should not submit empty text', () => {
+                const buffer = createMockBuffer('');
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                act(() => result.current.handleInput(makeKey('\r', 'return')));
+                expect(mockHandleFinalSubmit).not.toHaveBeenCalled();
+            });
+            it('should not submit whitespace-only text', () => {
+                const buffer = createMockBuffer('   ');
+                const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+                act(() => result.current.handleInput(makeKey('\r', 'return')));
+                expect(mockHandleFinalSubmit).not.toHaveBeenCalled();
+            });
+        });
+    });
+    describe('Pending operator clearing', () => {
+        it.each(['r', 'f', 'F', 't', 'T'])('should clear pending operator on Escape during char-read (%s)', (key) => {
+            const buffer = createMockBuffer('hello world', [0, 0]);
+            const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+            // Set pending operator d
+            act(() => result.current.handleInput(makeKey('d')));
+            // Enter char-read mode
+            act(() => result.current.handleInput(makeKey(key)));
+            // Press Escape to cancel
+            act(() => result.current.handleInput(makeKey('\u001b', 'escape')));
+            // Now w should just move cursor, not delete
+            act(() => result.current.handleInput(makeKey('w')));
+            expect(buffer.vimDeleteWordForward).not.toHaveBeenCalled();
+            expect(buffer.vimMoveWordForward).toHaveBeenCalledWith(1);
+        });
+        it('should clear pending operator on ~ (toggle case)', () => {
+            const buffer = createMockBuffer('Hello', [0, 0]);
+            const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+            // Set pending operator d
+            act(() => result.current.handleInput(makeKey('d')));
+            // Press ~ to toggle case
+            act(() => result.current.handleInput(makeKey('~')));
+            // Now w should just move cursor, not delete
+            act(() => result.current.handleInput(makeKey('w')));
+            expect(buffer.vimDeleteWordForward).not.toHaveBeenCalled();
+            expect(buffer.vimMoveWordForward).toHaveBeenCalledWith(1);
+        });
+        it('should clear pending operator on u (undo)', () => {
+            const buffer = createMockBuffer('Hello', [0, 0]);
+            const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+            // Set pending operator d
+            act(() => result.current.handleInput(makeKey('d')));
+            // Press u to undo
+            act(() => result.current.handleInput(makeKey('u')));
+            // Now w should just move cursor, not delete
+            act(() => result.current.handleInput(makeKey('w')));
+            expect(buffer.vimDeleteWordForward).not.toHaveBeenCalled();
+            expect(buffer.vimMoveWordForward).toHaveBeenCalledWith(1);
+        });
+        it('should clear pending operator on J (join lines)', () => {
+            const buffer = createMockBuffer('hello\nworld', [0, 0]);
+            const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+            // Set pending operator d
+            act(() => result.current.handleInput(makeKey('d')));
+            // Press J to join lines
+            act(() => result.current.handleInput(makeKey('J')));
+            // Now w should just move cursor, not delete
+            act(() => result.current.handleInput(makeKey('w')));
+            expect(buffer.vimDeleteWordForward).not.toHaveBeenCalled();
+            expect(buffer.vimMoveWordForward).toHaveBeenCalledWith(1);
+        });
+        it('should clear pending operator on x (delete char)', () => {
+            const buffer = createMockBuffer('hello world', [0, 0]);
+            const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+            // Set pending operator d
+            act(() => result.current.handleInput(makeKey('d')));
+            // Press x to delete char
+            act(() => result.current.handleInput(makeKey('x')));
+            // Now w should just move cursor, not delete
+            act(() => result.current.handleInput(makeKey('w')));
+            expect(buffer.vimDeleteWordForward).not.toHaveBeenCalled();
+            expect(buffer.vimMoveWordForward).toHaveBeenCalledWith(1);
+        });
+        it('should clear pending operator on D (delete to EOL)', () => {
+            const buffer = createMockBuffer('hello world', [0, 0]);
+            const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+            // Set pending operator d
+            act(() => result.current.handleInput(makeKey('d')));
+            // Press D to delete to EOL
+            act(() => result.current.handleInput(makeKey('D')));
+            // Now w should just move cursor, not delete
+            act(() => result.current.handleInput(makeKey('w')));
+            expect(buffer.vimDeleteWordForward).not.toHaveBeenCalled();
+            expect(buffer.vimMoveWordForward).toHaveBeenCalledWith(1);
+        });
+        it('should clear pending operator on C (change to EOL)', () => {
+            const buffer = createMockBuffer('hello world', [0, 0]);
+            const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+            // Set pending operator d
+            act(() => result.current.handleInput(makeKey('d')));
+            // Press C to change to EOL (enters INSERT mode)
+            act(() => result.current.handleInput(makeKey('C')));
+            // C enters INSERT mode, so pending operator should be cleared
+            // We can verify by checking that vimDeleteWordForward was not called
+            // (which would happen if pending d was still active)
+            expect(buffer.vimDeleteWordForward).not.toHaveBeenCalled();
+        });
+        it('should clear pending operator on Y (yank line)', () => {
+            const buffer = createMockBuffer('hello world', [0, 0]);
+            const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+            // Set pending operator d
+            act(() => result.current.handleInput(makeKey('d')));
+            // Press Y to yank line
+            act(() => result.current.handleInput(makeKey('Y')));
+            // Now w should just move cursor, not delete
+            act(() => result.current.handleInput(makeKey('w')));
+            expect(buffer.vimDeleteWordForward).not.toHaveBeenCalled();
+            expect(buffer.vimMoveWordForward).toHaveBeenCalledWith(1);
+        });
+        it('should clear pending operator on . (dot repeat)', () => {
+            const buffer = createMockBuffer('hello world', [0, 0]);
+            const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+            // Set pending operator d
+            act(() => result.current.handleInput(makeKey('d')));
+            // Press . to repeat
+            act(() => result.current.handleInput(makeKey('.')));
+            // Now w should just move cursor, not delete
+            act(() => result.current.handleInput(makeKey('w')));
+            expect(buffer.vimDeleteWordForward).not.toHaveBeenCalled();
+            expect(buffer.vimMoveWordForward).toHaveBeenCalledWith(1);
+        });
+    });
+    describe('Delete movement (dh, dl, dj, dk)', () => {
+        it('should delete character to the left with dh', () => {
+            const buffer = createMockBuffer('hello world', [0, 5]);
+            const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+            act(() => result.current.handleInput(makeKey('d')));
+            act(() => result.current.handleInput(makeKey('h')));
+            expect(buffer.vimDeleteMovement).toHaveBeenCalledWith('h', 1);
+        });
+        it('should delete character to the right with dl', () => {
+            const buffer = createMockBuffer('hello world', [0, 5]);
+            const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+            act(() => result.current.handleInput(makeKey('d')));
+            act(() => result.current.handleInput(makeKey('l')));
+            expect(buffer.vimDeleteMovement).toHaveBeenCalledWith('l', 1);
+        });
+        it('should delete current and next line with dj', () => {
+            const buffer = createMockBuffer('line1\nline2\nline3', [0, 0]);
+            const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+            act(() => result.current.handleInput(makeKey('d')));
+            act(() => result.current.handleInput(makeKey('j')));
+            expect(buffer.vimDeleteMovement).toHaveBeenCalledWith('j', 1);
+        });
+        it('should delete current and previous line with dk', () => {
+            const buffer = createMockBuffer('line1\nline2\nline3', [1, 0]);
+            const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+            act(() => result.current.handleInput(makeKey('d')));
+            act(() => result.current.handleInput(makeKey('k')));
+            expect(buffer.vimDeleteMovement).toHaveBeenCalledWith('k', 1);
+        });
+    });
+    describe('Yank movement (yh, yl, yj, yk)', () => {
+        it('should yank character to the left with yh', () => {
+            const buffer = createMockBuffer('hello world', [0, 5]);
+            const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+            act(() => result.current.handleInput(makeKey('y')));
+            act(() => result.current.handleInput(makeKey('h')));
+            // Yank movement doesn't call buffer methods, just updates register
+            expect(buffer.vimDeleteMovement).not.toHaveBeenCalled();
+        });
+        it('should yank character to the right with yl', () => {
+            const buffer = createMockBuffer('hello world', [0, 5]);
+            const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+            act(() => result.current.handleInput(makeKey('y')));
+            act(() => result.current.handleInput(makeKey('l')));
+            expect(buffer.vimDeleteMovement).not.toHaveBeenCalled();
+        });
+        it('should yank current and next line with yj', () => {
+            const buffer = createMockBuffer('line1\nline2\nline3', [0, 0]);
+            const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+            act(() => result.current.handleInput(makeKey('y')));
+            act(() => result.current.handleInput(makeKey('j')));
+            expect(buffer.vimDeleteMovement).not.toHaveBeenCalled();
+        });
+        it('should yank current and previous line with yk', () => {
+            const buffer = createMockBuffer('line1\nline2\nline3', [1, 0]);
+            const { result } = renderHook(() => useVim(buffer, mockHandleFinalSubmit));
+            act(() => result.current.handleInput(makeKey('y')));
+            act(() => result.current.handleInput(makeKey('k')));
+            expect(buffer.vimDeleteMovement).not.toHaveBeenCalled();
+        });
+    });
+});
+//# sourceMappingURL=vim.test.js.map