@machina.ai/cell-cli 1.33.0-rc1 → 1.38.1-rc1

package/dist/src/ui/components/shared/vim-buffer-actions.test.js

@@ -28,6 +28,7 @@ const createTestState = (lines = ['hello world'], cursorRow = 0, cursorCol = 0)
     visualLayout: defaultVisualLayout,
     pastedContent: {},
     expandedPaste: null,
+    yankRegister: null,
 });
 describe('vim-buffer-actions', () => {
     describe('Movement commands', () => {
@@ -393,6 +394,20 @@ describe('vim-buffer-actions', () => {
                 expect(result).toHaveOnlyValidCharacters();
                 expect(result.cursorCol).toBe(3); // Position of 'h'
             });
+            it('vim_move_to_first_nonwhitespace should go to column 0 on whitespace-only line', () => {
+                const state = createTestState(['     '], 0, 3);
+                const action = { type: 'vim_move_to_first_nonwhitespace' };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.cursorCol).toBe(0);
+            });
+            it('vim_move_to_first_nonwhitespace should go to column 0 on empty line', () => {
+                const state = createTestState([''], 0, 0);
+                const action = { type: 'vim_move_to_first_nonwhitespace' };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.cursorCol).toBe(0);
+            });
             it('vim_move_to_first_line should move to row 0', () => {
                 const state = createTestState(['line1', 'line2', 'line3'], 2, 5);
                 const action = { type: 'vim_move_to_first_line' };
@@ -465,6 +480,19 @@ describe('vim-buffer-actions', () => {
                 const result = handleVimAction(state, action);
                 expect(result).toHaveOnlyValidCharacters();
                 expect(result.lines[0]).toBe('hel');
+                // Cursor clamps to last char of the shortened line (vim NORMAL mode
+                // cursor cannot rest past the final character).
+                expect(result.cursorCol).toBe(2);
+            });
+            it('should clamp cursor when deleting the last character on a line', () => {
+                const state = createTestState(['hello'], 0, 4);
+                const action = {
+                    type: 'vim_delete_char',
+                    payload: { count: 1 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines[0]).toBe('hell');
                 expect(result.cursorCol).toBe(3);
             });
             it('should do nothing at end of line', () => {
@@ -511,7 +539,7 @@ describe('vim-buffer-actions', () => {
                 const result = handleVimAction(state, action);
                 expect(result).toHaveOnlyValidCharacters();
                 expect(result.lines[0]).toBe('hello ');
-                expect(result.cursorCol).toBe(6);
+                expect(result.cursorCol).toBe(5);
             });
             it('should delete only the word characters if it is the last word followed by whitespace', () => {
                 const state = createTestState(['foo bar   '], 0, 4); // on 'b'
@@ -545,6 +573,51 @@ describe('vim-buffer-actions', () => {
                 expect(result).toHaveOnlyValidCharacters();
                 expect(result.lines[0]).toBe('foo    ');
             });
+            it('should clamp cursor when dW removes the last word leaving only a trailing space', () => {
+                // cursor on 'w' in 'hello world'; dW deletes 'world' → 'hello '
+                const state = createTestState(['hello world'], 0, 6);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_big_word_forward',
+                    payload: { count: 1 },
+                });
+                expect(result.lines[0]).toBe('hello ');
+                // col 6 is past the new line end (len 6, max valid = 5)
+                expect(result.cursorCol).toBe(5);
+            });
+        });
+        describe('vim_delete_word_end', () => {
+            it('should clamp cursor when de removes the last word on a line', () => {
+                // cursor on 'w' in 'hello world'; de deletes through 'd' → 'hello '
+                const state = createTestState(['hello world'], 0, 6);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_word_end',
+                    payload: { count: 1 },
+                });
+                expect(result.lines[0]).toBe('hello ');
+                expect(result.cursorCol).toBe(5);
+            });
+        });
+        describe('vim_delete_big_word_end', () => {
+            it('should delete from cursor to end of WORD (skipping punctuation)', () => {
+                // cursor on 'b' in 'foo bar.baz qux'; dE treats 'bar.baz' as one WORD
+                const state = createTestState(['foo bar.baz qux'], 0, 4);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_big_word_end',
+                    payload: { count: 1 },
+                });
+                expect(result.lines[0]).toBe('foo  qux');
+                expect(result.cursorCol).toBe(4);
+            });
+            it('should clamp cursor when dE removes the last WORD on a line', () => {
+                // cursor on 'w' in 'hello world'; dE deletes through 'd' → 'hello '
+                const state = createTestState(['hello world'], 0, 6);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_big_word_end',
+                    payload: { count: 1 },
+                });
+                expect(result.lines[0]).toBe('hello ');
+                expect(result.cursorCol).toBe(5);
+            });
         });
         describe('vim_delete_word_backward', () => {
             it('should delete from cursor to previous word start', () => {
@@ -611,20 +684,322 @@ describe('vim-buffer-actions', () => {
         describe('vim_delete_to_end_of_line', () => {
             it('should delete from cursor to end of line', () => {
                 const state = createTestState(['hello world'], 0, 5);
-                const action = { type: 'vim_delete_to_end_of_line' };
+                const action = {
+                    type: 'vim_delete_to_end_of_line',
+                    payload: { count: 1 },
+                };
                 const result = handleVimAction(state, action);
                 expect(result).toHaveOnlyValidCharacters();
                 expect(result.lines[0]).toBe('hello');
-                expect(result.cursorCol).toBe(5);
+                expect(result.cursorCol).toBe(4);
             });
             it('should do nothing at end of line', () => {
                 const state = createTestState(['hello'], 0, 5);
-                const action = { type: 'vim_delete_to_end_of_line' };
+                const action = {
+                    type: 'vim_delete_to_end_of_line',
+                    payload: { count: 1 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines[0]).toBe('hello');
+            });
+            it('should delete to end of line plus additional lines with count > 1', () => {
+                const state = createTestState(['line one', 'line two', 'line three'], 0, 5);
+                const action = {
+                    type: 'vim_delete_to_end_of_line',
+                    payload: { count: 2 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                // 2D at position 5 on "line one" should delete "one" + entire "line two"
+                expect(result.lines).toEqual(['line ', 'line three']);
+                expect(result.cursorCol).toBe(4);
+            });
+            it('should handle count exceeding available lines', () => {
+                const state = createTestState(['line one', 'line two'], 0, 5);
+                const action = {
+                    type: 'vim_delete_to_end_of_line',
+                    payload: { count: 5 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                // Should delete to end of available lines
+                expect(result.lines).toEqual(['line ']);
+            });
+        });
+        describe('vim_delete_to_first_nonwhitespace', () => {
+            it('should delete from cursor backwards to first non-whitespace', () => {
+                const state = createTestState(['    hello world'], 0, 10);
+                const action = { type: 'vim_delete_to_first_nonwhitespace' };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                // Delete from 'h' (col 4) to cursor (col 10), leaving "    world"
+                expect(result.lines[0]).toBe('    world');
+                expect(result.cursorCol).toBe(4);
+            });
+            it('should delete from cursor forwards when cursor is in whitespace', () => {
+                const state = createTestState(['    hello'], 0, 2);
+                const action = { type: 'vim_delete_to_first_nonwhitespace' };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                // Delete from cursor (col 2) to first non-ws (col 4), leaving "  hello"
+                expect(result.lines[0]).toBe('  hello');
+                expect(result.cursorCol).toBe(2);
+            });
+            it('should do nothing when cursor is at first non-whitespace', () => {
+                const state = createTestState(['    hello'], 0, 4);
+                const action = { type: 'vim_delete_to_first_nonwhitespace' };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines[0]).toBe('    hello');
+            });
+            it('should delete to column 0 on whitespace-only line', () => {
+                const state = createTestState(['    '], 0, 2);
+                const action = { type: 'vim_delete_to_first_nonwhitespace' };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                // On whitespace-only line, ^ goes to col 0, so d^ deletes cols 0-2
+                expect(result.lines[0]).toBe('  ');
+                expect(result.cursorCol).toBe(0);
+            });
+        });
+        describe('vim_delete_to_first_line', () => {
+            it('should delete from current line to first line (dgg)', () => {
+                const state = createTestState(['line1', 'line2', 'line3', 'line4'], 2, 0);
+                const action = {
+                    type: 'vim_delete_to_first_line',
+                    payload: { count: 0 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                // Delete lines 0, 1, 2 (current), leaving line4
+                expect(result.lines).toEqual(['line4']);
+                expect(result.cursorRow).toBe(0);
+            });
+            it('should delete from current line to specified line (d5gg)', () => {
+                const state = createTestState(['line1', 'line2', 'line3', 'line4', 'line5'], 4, 0);
+                const action = {
+                    type: 'vim_delete_to_first_line',
+                    payload: { count: 2 }, // Delete to line 2 (1-based)
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                // Delete lines 1-4 (line2 to line5), leaving line1
+                expect(result.lines).toEqual(['line1']);
+                expect(result.cursorRow).toBe(0);
+            });
+            it('should keep one empty line when deleting all lines', () => {
+                const state = createTestState(['line1', 'line2'], 1, 0);
+                const action = {
+                    type: 'vim_delete_to_first_line',
+                    payload: { count: 0 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines).toEqual(['']);
+            });
+        });
+        describe('vim_delete_to_last_line', () => {
+            it('should delete from current line to last line (dG)', () => {
+                const state = createTestState(['line1', 'line2', 'line3', 'line4'], 1, 0);
+                const action = {
+                    type: 'vim_delete_to_last_line',
+                    payload: { count: 0 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                // Delete lines 1, 2, 3 (from current to last), leaving line1
+                expect(result.lines).toEqual(['line1']);
+                expect(result.cursorRow).toBe(0);
+            });
+            it('should delete from current line to specified line (d3G)', () => {
+                const state = createTestState(['line1', 'line2', 'line3', 'line4', 'line5'], 0, 0);
+                const action = {
+                    type: 'vim_delete_to_last_line',
+                    payload: { count: 3 }, // Delete to line 3 (1-based)
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                // Delete lines 0-2 (line1 to line3), leaving line4 and line5
+                expect(result.lines).toEqual(['line4', 'line5']);
+                expect(result.cursorRow).toBe(0);
+            });
+            it('should keep one empty line when deleting all lines', () => {
+                const state = createTestState(['line1', 'line2'], 0, 0);
+                const action = {
+                    type: 'vim_delete_to_last_line',
+                    payload: { count: 0 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines).toEqual(['']);
+            });
+        });
+        describe('vim_change_to_start_of_line', () => {
+            it('should delete from start of line to cursor (c0)', () => {
+                const state = createTestState(['hello world'], 0, 6);
+                const action = { type: 'vim_change_to_start_of_line' };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines[0]).toBe('world');
+                expect(result.cursorCol).toBe(0);
+            });
+            it('should do nothing at start of line', () => {
+                const state = createTestState(['hello'], 0, 0);
+                const action = { type: 'vim_change_to_start_of_line' };
                 const result = handleVimAction(state, action);
                 expect(result).toHaveOnlyValidCharacters();
                 expect(result.lines[0]).toBe('hello');
             });
         });
+        describe('vim_change_to_first_nonwhitespace', () => {
+            it('should delete from first non-whitespace to cursor (c^)', () => {
+                const state = createTestState(['    hello world'], 0, 10);
+                const action = { type: 'vim_change_to_first_nonwhitespace' };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines[0]).toBe('    world');
+                expect(result.cursorCol).toBe(4);
+            });
+            it('should delete backwards when cursor before first non-whitespace', () => {
+                const state = createTestState(['    hello'], 0, 2);
+                const action = { type: 'vim_change_to_first_nonwhitespace' };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines[0]).toBe('  hello');
+                expect(result.cursorCol).toBe(2);
+            });
+            it('should handle whitespace-only line', () => {
+                const state = createTestState(['     '], 0, 3);
+                const action = { type: 'vim_change_to_first_nonwhitespace' };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines[0]).toBe('  ');
+                expect(result.cursorCol).toBe(0);
+            });
+        });
+        describe('vim_change_to_end_of_line', () => {
+            it('should delete from cursor to end of line (C)', () => {
+                const state = createTestState(['hello world'], 0, 6);
+                const action = {
+                    type: 'vim_change_to_end_of_line',
+                    payload: { count: 1 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines[0]).toBe('hello ');
+                expect(result.cursorCol).toBe(6);
+            });
+            it('should delete multiple lines with count (2C)', () => {
+                const state = createTestState(['line1 hello', 'line2', 'line3'], 0, 6);
+                const action = {
+                    type: 'vim_change_to_end_of_line',
+                    payload: { count: 2 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines).toEqual(['line1 ', 'line3']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(6);
+            });
+            it('should delete remaining lines when count exceeds available (3C on 2 lines)', () => {
+                const state = createTestState(['hello world', 'end'], 0, 6);
+                const action = {
+                    type: 'vim_change_to_end_of_line',
+                    payload: { count: 3 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines).toEqual(['hello ']);
+                expect(result.cursorCol).toBe(6);
+            });
+            it('should handle count at last line', () => {
+                const state = createTestState(['first', 'last line'], 1, 5);
+                const action = {
+                    type: 'vim_change_to_end_of_line',
+                    payload: { count: 2 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines).toEqual(['first', 'last ']);
+                expect(result.cursorRow).toBe(1);
+                expect(result.cursorCol).toBe(5);
+            });
+        });
+        describe('vim_change_to_first_line', () => {
+            it('should delete from first line to current line (cgg)', () => {
+                const state = createTestState(['line1', 'line2', 'line3'], 2, 3);
+                const action = {
+                    type: 'vim_delete_to_first_line',
+                    payload: { count: 0 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines).toEqual(['']);
+                expect(result.cursorRow).toBe(0);
+            });
+            it('should delete from line 1 to target line (c3gg)', () => {
+                const state = createTestState(['line1', 'line2', 'line3', 'line4', 'line5'], 0, 0);
+                const action = {
+                    type: 'vim_delete_to_first_line',
+                    payload: { count: 3 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines).toEqual(['line4', 'line5']);
+                expect(result.cursorRow).toBe(0);
+            });
+            it('should handle cursor below target line', () => {
+                // Cursor on line 4 (index 3), target line 2 (index 1)
+                // Should delete lines 2-4 (indices 1-3), leaving line1 and line5
+                const state = createTestState(['line1', 'line2', 'line3', 'line4', 'line5'], 3, 0);
+                const action = {
+                    type: 'vim_delete_to_first_line',
+                    payload: { count: 2 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines).toEqual(['line1', 'line5']);
+                expect(result.cursorRow).toBe(1);
+            });
+        });
+        describe('vim_change_to_last_line', () => {
+            it('should delete from current line to last line (cG)', () => {
+                const state = createTestState(['line1', 'line2', 'line3'], 0, 3);
+                const action = {
+                    type: 'vim_delete_to_last_line',
+                    payload: { count: 0 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines).toEqual(['']);
+                expect(result.cursorRow).toBe(0);
+            });
+            it('should delete from cursor to target line (c2G)', () => {
+                const state = createTestState(['line1', 'line2', 'line3', 'line4'], 0, 0);
+                const action = {
+                    type: 'vim_delete_to_last_line',
+                    payload: { count: 2 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines).toEqual(['line3', 'line4']);
+                expect(result.cursorRow).toBe(0);
+            });
+            it('should handle cursor above target', () => {
+                // Cursor on line 2 (index 1), target line 3 (index 2)
+                // Should delete lines 2-3 (indices 1-2), leaving line1 and line4
+                const state = createTestState(['line1', 'line2', 'line3', 'line4'], 1, 0);
+                const action = {
+                    type: 'vim_delete_to_last_line',
+                    payload: { count: 3 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines).toEqual(['line1', 'line4']);
+                expect(result.cursorRow).toBe(1);
+            });
+        });
     });
     describe('Insert mode commands', () => {
         describe('vim_insert_at_cursor', () => {
@@ -775,46 +1150,132 @@ describe('vim-buffer-actions', () => {
                 };
                 const result = handleVimAction(state, action);
                 expect(result).toHaveOnlyValidCharacters();
-                // The movement 'j' with count 2 changes 2 lines starting from cursor row
-                // Since we're at cursor position 2, it changes lines starting from current row
-                expect(result.lines).toEqual(['line1', 'line2', 'line3']); // No change because count > available lines
+                // In VIM, 2cj deletes current line + 2 lines below = 3 lines total
+                // Since there are exactly 3 lines, all are deleted
+                expect(result.lines).toEqual(['']);
                 expect(result.cursorRow).toBe(0);
-                expect(result.cursorCol).toBe(2);
+                expect(result.cursorCol).toBe(0);
             });
-        });
-    });
-    describe('Edge cases', () => {
-        it('should handle empty text', () => {
-            const state = createTestState([''], 0, 0);
-            const action = {
-                type: 'vim_move_word_forward',
-                payload: { count: 1 },
-            };
-            const result = handleVimAction(state, action);
-            expect(result).toHaveOnlyValidCharacters();
-            expect(result.cursorRow).toBe(0);
-            expect(result.cursorCol).toBe(0);
-        });
-        it('should handle single character line', () => {
-            const state = createTestState(['a'], 0, 0);
-            const action = { type: 'vim_move_to_line_end' };
-            const result = handleVimAction(state, action);
-            expect(result).toHaveOnlyValidCharacters();
-            expect(result.cursorCol).toBe(0); // Should be last character position
-        });
-        it('should handle empty lines in multi-line text', () => {
-            const state = createTestState(['line1', '', 'line3'], 1, 0);
-            const action = {
-                type: 'vim_move_word_forward',
-                payload: { count: 1 },
-            };
-            const result = handleVimAction(state, action);
-            expect(result).toHaveOnlyValidCharacters();
-            // Should move to next line with content
-            expect(result.cursorRow).toBe(2);
-            expect(result.cursorCol).toBe(0);
-        });
-        it('should preserve undo stack in operations', () => {
+            it('should handle Unicode characters in cj (down)', () => {
+                const state = createTestState(['hello 🎉 world', 'line2 émoji', 'line3'], 0, 0);
+                const action = {
+                    type: 'vim_change_movement',
+                    payload: { movement: 'j', count: 1 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines).toEqual(['line3']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(0);
+            });
+            it('should handle Unicode characters in ck (up)', () => {
+                const state = createTestState(['line1', 'hello 🎉 world', 'line3 émoji'], 2, 0);
+                const action = {
+                    type: 'vim_change_movement',
+                    payload: { movement: 'k', count: 1 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines).toEqual(['line1']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(0);
+            });
+            it('should handle cj on first line of 2 lines (delete all)', () => {
+                const state = createTestState(['line1', 'line2'], 0, 0);
+                const action = {
+                    type: 'vim_change_movement',
+                    payload: { movement: 'j', count: 1 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines).toEqual(['']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(0);
+            });
+            it('should handle cj on last line (delete only current line)', () => {
+                const state = createTestState(['line1', 'line2', 'line3'], 2, 0);
+                const action = {
+                    type: 'vim_change_movement',
+                    payload: { movement: 'j', count: 1 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines).toEqual(['line1', 'line2']);
+                expect(result.cursorRow).toBe(1);
+                expect(result.cursorCol).toBe(0);
+            });
+            it('should handle ck on first line (delete only current line)', () => {
+                const state = createTestState(['line1', 'line2', 'line3'], 0, 0);
+                const action = {
+                    type: 'vim_change_movement',
+                    payload: { movement: 'k', count: 1 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines).toEqual(['line2', 'line3']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(0);
+            });
+            it('should handle 2cj from middle line', () => {
+                const state = createTestState(['line1', 'line2', 'line3', 'line4', 'line5'], 1, 0);
+                const action = {
+                    type: 'vim_change_movement',
+                    payload: { movement: 'j', count: 2 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                // 2cj from line 1: delete lines 1, 2, 3 (current + 2 below)
+                expect(result.lines).toEqual(['line1', 'line5']);
+                expect(result.cursorRow).toBe(1);
+                expect(result.cursorCol).toBe(0);
+            });
+            it('should handle 2ck from middle line', () => {
+                const state = createTestState(['line1', 'line2', 'line3', 'line4', 'line5'], 3, 0);
+                const action = {
+                    type: 'vim_change_movement',
+                    payload: { movement: 'k', count: 2 },
+                };
+                const result = handleVimAction(state, action);
+                expect(result).toHaveOnlyValidCharacters();
+                // 2ck from line 3: delete lines 1, 2, 3 (current + 2 above)
+                expect(result.lines).toEqual(['line1', 'line5']);
+                expect(result.cursorRow).toBe(1);
+                expect(result.cursorCol).toBe(0);
+            });
+        });
+    });
+    describe('Edge cases', () => {
+        it('should handle empty text', () => {
+            const state = createTestState([''], 0, 0);
+            const action = {
+                type: 'vim_move_word_forward',
+                payload: { count: 1 },
+            };
+            const result = handleVimAction(state, action);
+            expect(result).toHaveOnlyValidCharacters();
+            expect(result.cursorRow).toBe(0);
+            expect(result.cursorCol).toBe(0);
+        });
+        it('should handle single character line', () => {
+            const state = createTestState(['a'], 0, 0);
+            const action = { type: 'vim_move_to_line_end' };
+            const result = handleVimAction(state, action);
+            expect(result).toHaveOnlyValidCharacters();
+            expect(result.cursorCol).toBe(0); // Should be last character position
+        });
+        it('should handle empty lines in multi-line text', () => {
+            const state = createTestState(['line1', '', 'line3'], 1, 0);
+            const action = {
+                type: 'vim_move_word_forward',
+                payload: { count: 1 },
+            };
+            const result = handleVimAction(state, action);
+            expect(result).toHaveOnlyValidCharacters();
+            // Should move to next line with content
+            expect(result.cursorRow).toBe(2);
+            expect(result.cursorCol).toBe(0);
+        });
+        it('should preserve undo stack in operations', () => {
             const state = createTestState(['hello'], 0, 0);
             state.undoStack = [
                 {
@@ -1014,5 +1475,798 @@ describe('vim-buffer-actions', () => {
             });
         });
     });
+    describe('Character manipulation commands (X, ~, r, f/F/t/T)', () => {
+        describe('vim_delete_char_before (X)', () => {
+            it('should delete the character before the cursor', () => {
+                const state = createTestState(['hello'], 0, 3);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_char_before',
+                    payload: { count: 1 },
+                });
+                expect(result.lines[0]).toBe('helo');
+                expect(result.cursorCol).toBe(2);
+            });
+            it('should delete N characters before the cursor', () => {
+                const state = createTestState(['hello world'], 0, 5);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_char_before',
+                    payload: { count: 3 },
+                });
+                expect(result.lines[0]).toBe('he world');
+                expect(result.cursorCol).toBe(2);
+            });
+            it('should clamp to start of line when count exceeds position', () => {
+                const state = createTestState(['hello'], 0, 2);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_char_before',
+                    payload: { count: 10 },
+                });
+                expect(result.lines[0]).toBe('llo');
+                expect(result.cursorCol).toBe(0);
+            });
+            it('should do nothing when cursor is at column 0', () => {
+                const state = createTestState(['hello'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_char_before',
+                    payload: { count: 1 },
+                });
+                expect(result.lines[0]).toBe('hello');
+                expect(result.cursorCol).toBe(0);
+            });
+            it('should push undo state', () => {
+                const state = createTestState(['hello'], 0, 3);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_char_before',
+                    payload: { count: 1 },
+                });
+                expect(result.undoStack.length).toBeGreaterThan(0);
+            });
+        });
+        describe('vim_toggle_case (~)', () => {
+            it('should toggle lowercase to uppercase', () => {
+                const state = createTestState(['hello'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_toggle_case',
+                    payload: { count: 1 },
+                });
+                expect(result.lines[0]).toBe('Hello');
+                expect(result.cursorCol).toBe(1);
+            });
+            it('should toggle uppercase to lowercase', () => {
+                const state = createTestState(['HELLO'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_toggle_case',
+                    payload: { count: 1 },
+                });
+                expect(result.lines[0]).toBe('hELLO');
+                expect(result.cursorCol).toBe(1);
+            });
+            it('should toggle N characters', () => {
+                const state = createTestState(['hello world'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_toggle_case',
+                    payload: { count: 5 },
+                });
+                expect(result.lines[0]).toBe('HELLO world');
+                expect(result.cursorCol).toBe(5); // cursor advances past the toggled range
+            });
+            it('should clamp count to end of line', () => {
+                const state = createTestState(['hi'], 0, 1);
+                const result = handleVimAction(state, {
+                    type: 'vim_toggle_case',
+                    payload: { count: 100 },
+                });
+                expect(result.lines[0]).toBe('hI');
+                expect(result.cursorCol).toBe(1);
+            });
+            it('should do nothing when cursor is past end of line', () => {
+                const state = createTestState(['hi'], 0, 5);
+                const result = handleVimAction(state, {
+                    type: 'vim_toggle_case',
+                    payload: { count: 1 },
+                });
+                expect(result.lines[0]).toBe('hi');
+            });
+            it('should push undo state', () => {
+                const state = createTestState(['hello'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_toggle_case',
+                    payload: { count: 1 },
+                });
+                expect(result.undoStack.length).toBeGreaterThan(0);
+            });
+        });
+        describe('vim_replace_char (r)', () => {
+            it('should replace the character under the cursor', () => {
+                const state = createTestState(['hello'], 0, 1);
+                const result = handleVimAction(state, {
+                    type: 'vim_replace_char',
+                    payload: { char: 'a', count: 1 },
+                });
+                expect(result.lines[0]).toBe('hallo');
+                expect(result.cursorCol).toBe(1);
+            });
+            it('should replace N characters with the given char', () => {
+                const state = createTestState(['hello'], 0, 1);
+                const result = handleVimAction(state, {
+                    type: 'vim_replace_char',
+                    payload: { char: 'x', count: 3 },
+                });
+                expect(result.lines[0]).toBe('hxxxo');
+                expect(result.cursorCol).toBe(3); // cursor at last replaced char
+            });
+            it('should clamp replace count to end of line', () => {
+                const state = createTestState(['hi'], 0, 1);
+                const result = handleVimAction(state, {
+                    type: 'vim_replace_char',
+                    payload: { char: 'z', count: 100 },
+                });
+                expect(result.lines[0]).toBe('hz');
+                expect(result.cursorCol).toBe(1);
+            });
+            it('should do nothing when cursor is past end of line', () => {
+                const state = createTestState(['hi'], 0, 5);
+                const result = handleVimAction(state, {
+                    type: 'vim_replace_char',
+                    payload: { char: 'z', count: 1 },
+                });
+                expect(result.lines[0]).toBe('hi');
+            });
+            it('should push undo state', () => {
+                const state = createTestState(['hello'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_replace_char',
+                    payload: { char: 'x', count: 1 },
+                });
+                expect(result.undoStack.length).toBeGreaterThan(0);
+            });
+        });
+        it.each([
+            {
+                label: 'f: move to char',
+                type: 'vim_find_char_forward',
+                cursorStart: 0,
+                char: 'o',
+                count: 1,
+                till: false,
+                expectedCol: 4,
+            },
+            {
+                label: 'f: Nth occurrence',
+                type: 'vim_find_char_forward',
+                cursorStart: 0,
+                char: 'o',
+                count: 2,
+                till: false,
+                expectedCol: 7,
+            },
+            {
+                label: 't: move before char',
+                type: 'vim_find_char_forward',
+                cursorStart: 0,
+                char: 'o',
+                count: 1,
+                till: true,
+                expectedCol: 3,
+            },
+            {
+                label: 'f: not found',
+                type: 'vim_find_char_forward',
+                cursorStart: 0,
+                char: 'z',
+                count: 1,
+                till: false,
+                expectedCol: 0,
+            },
+            {
+                label: 'f: skip char at cursor',
+                type: 'vim_find_char_forward',
+                cursorStart: 1,
+                char: 'h',
+                count: 1,
+                till: false,
+                expectedCol: 1,
+            },
+            {
+                label: 'F: move to char',
+                type: 'vim_find_char_backward',
+                cursorStart: 10,
+                char: 'o',
+                count: 1,
+                till: false,
+                expectedCol: 7,
+            },
+            {
+                label: 'F: Nth occurrence',
+                type: 'vim_find_char_backward',
+                cursorStart: 10,
+                char: 'o',
+                count: 2,
+                till: false,
+                expectedCol: 4,
+            },
+            {
+                label: 'T: move after char',
+                type: 'vim_find_char_backward',
+                cursorStart: 10,
+                char: 'o',
+                count: 1,
+                till: true,
+                expectedCol: 8,
+            },
+            {
+                label: 'F: not found',
+                type: 'vim_find_char_backward',
+                cursorStart: 4,
+                char: 'z',
+                count: 1,
+                till: false,
+                expectedCol: 4,
+            },
+            {
+                label: 'F: skip char at cursor',
+                type: 'vim_find_char_backward',
+                cursorStart: 3,
+                char: 'o',
+                count: 1,
+                till: false,
+                expectedCol: 3,
+            },
+        ])('$label', ({ type, cursorStart, char, count, till, expectedCol }) => {
+            const line = type === 'vim_find_char_forward' ? ['hello world'] : ['hello world'];
+            const state = createTestState(line, 0, cursorStart);
+            const result = handleVimAction(state, {
+                type,
+                payload: { char, count, till },
+            });
+            expect(result.cursorCol).toBe(expectedCol);
+        });
+    });
+    describe('Unicode character support in find operations', () => {
+        it('vim_find_char_forward: finds multi-byte char (é) correctly', () => {
+            const state = createTestState(['café world'], 0, 0);
+            const result = handleVimAction(state, {
+                type: 'vim_find_char_forward',
+                payload: { char: 'é', count: 1, till: false },
+            });
+            expect(result.cursorCol).toBe(3); // 'c','a','f','é' — é is at index 3
+            expect(result.lines[0]).toBe('café world');
+        });
+        it('vim_find_char_backward: finds multi-byte char (é) correctly', () => {
+            const state = createTestState(['café world'], 0, 9);
+            const result = handleVimAction(state, {
+                type: 'vim_find_char_backward',
+                payload: { char: 'é', count: 1, till: false },
+            });
+            expect(result.cursorCol).toBe(3);
+        });
+        it('vim_delete_to_char_forward: handles multi-byte target char', () => {
+            const state = createTestState(['café world'], 0, 0);
+            const result = handleVimAction(state, {
+                type: 'vim_delete_to_char_forward',
+                payload: { char: 'é', count: 1, till: false },
+            });
+            // Deletes 'caf' + 'é' → ' world' remains
+            expect(result.lines[0]).toBe(' world');
+            expect(result.cursorCol).toBe(0);
+        });
+        it('vim_delete_to_char_forward (till): stops before multi-byte char', () => {
+            const state = createTestState(['café world'], 0, 0);
+            const result = handleVimAction(state, {
+                type: 'vim_delete_to_char_forward',
+                payload: { char: 'é', count: 1, till: true },
+            });
+            // Deletes 'caf', keeps 'é world'
+            expect(result.lines[0]).toBe('é world');
+            expect(result.cursorCol).toBe(0);
+        });
+    });
+    describe('vim_delete_to_char_forward (df/dt)', () => {
+        it('df: deletes from cursor through found char (inclusive)', () => {
+            const state = createTestState(['hello world'], 0, 0);
+            const result = handleVimAction(state, {
+                type: 'vim_delete_to_char_forward',
+                payload: { char: 'o', count: 1, till: false },
+            });
+            expect(result.lines[0]).toBe(' world');
+            expect(result.cursorCol).toBe(0);
+        });
+        it('dt: deletes from cursor up to (not including) found char', () => {
+            const state = createTestState(['hello world'], 0, 0);
+            const result = handleVimAction(state, {
+                type: 'vim_delete_to_char_forward',
+                payload: { char: 'o', count: 1, till: true },
+            });
+            expect(result.lines[0]).toBe('o world');
+            expect(result.cursorCol).toBe(0);
+        });
+        it('df with count: deletes to Nth occurrence', () => {
+            const state = createTestState(['hello world'], 0, 0);
+            const result = handleVimAction(state, {
+                type: 'vim_delete_to_char_forward',
+                payload: { char: 'o', count: 2, till: false },
+            });
+            expect(result.lines[0]).toBe('rld');
+            expect(result.cursorCol).toBe(0);
+        });
+        it('does nothing if char not found', () => {
+            const state = createTestState(['hello'], 0, 0);
+            const result = handleVimAction(state, {
+                type: 'vim_delete_to_char_forward',
+                payload: { char: 'z', count: 1, till: false },
+            });
+            expect(result.lines[0]).toBe('hello');
+            expect(result.cursorCol).toBe(0);
+        });
+        it('pushes undo state', () => {
+            const state = createTestState(['hello world'], 0, 0);
+            const result = handleVimAction(state, {
+                type: 'vim_delete_to_char_forward',
+                payload: { char: 'o', count: 1, till: false },
+            });
+            expect(result.undoStack.length).toBeGreaterThan(0);
+        });
+        it('df: clamps cursor when deleting through the last char on the line', () => {
+            // cursor at 1 in 'hello'; dfo finds 'o' at col 4 and deletes [1,4] → 'h'
+            const state = createTestState(['hello'], 0, 1);
+            const result = handleVimAction(state, {
+                type: 'vim_delete_to_char_forward',
+                payload: { char: 'o', count: 1, till: false },
+            });
+            expect(result.lines[0]).toBe('h');
+            // cursor was at col 1, new line has only col 0 valid
+            expect(result.cursorCol).toBe(0);
+        });
+    });
+    describe('vim_delete_to_char_backward (dF/dT)', () => {
+        it('dF: deletes from found char through cursor (inclusive)', () => {
+            const state = createTestState(['hello world'], 0, 7);
+            const result = handleVimAction(state, {
+                type: 'vim_delete_to_char_backward',
+                payload: { char: 'o', count: 1, till: false },
+            });
+            // cursor at 7 ('o' in world), dFo finds 'o' at col 4
+            // delete [4, 8) — both ends inclusive → 'hell' + 'rld'
+            expect(result.lines[0]).toBe('hellrld');
+            expect(result.cursorCol).toBe(4);
+        });
+        it('dT: deletes from found+1 through cursor (inclusive)', () => {
+            const state = createTestState(['hello world'], 0, 7);
+            const result = handleVimAction(state, {
+                type: 'vim_delete_to_char_backward',
+                payload: { char: 'o', count: 1, till: true },
+            });
+            // dTo finds 'o' at col 4, deletes [5, 8) → 'hello' + 'rld'
+            expect(result.lines[0]).toBe('hellorld');
+            expect(result.cursorCol).toBe(5);
+        });
+        it('does nothing if char not found', () => {
+            const state = createTestState(['hello'], 0, 4);
+            const result = handleVimAction(state, {
+                type: 'vim_delete_to_char_backward',
+                payload: { char: 'z', count: 1, till: false },
+            });
+            expect(result.lines[0]).toBe('hello');
+            expect(result.cursorCol).toBe(4);
+        });
+        it('pushes undo state', () => {
+            const state = createTestState(['hello world'], 0, 7);
+            const result = handleVimAction(state, {
+                type: 'vim_delete_to_char_backward',
+                payload: { char: 'o', count: 1, till: false },
+            });
+            expect(result.undoStack.length).toBeGreaterThan(0);
+        });
+        it('dF: clamps cursor when deletion removes chars up to end of line', () => {
+            // 'hello', cursor on last char 'o' (col 4), dFe finds 'e' at col 1
+            // deletes [1, 5) → 'h'; without clamp cursor would be at col 1 (past end)
+            const state = createTestState(['hello'], 0, 4);
+            const result = handleVimAction(state, {
+                type: 'vim_delete_to_char_backward',
+                payload: { char: 'e', count: 1, till: false },
+            });
+            expect(result.lines[0]).toBe('h');
+            expect(result.cursorCol).toBe(0);
+        });
+    });
+    describe('vim yank and paste', () => {
+        describe('vim_yank_line (yy)', () => {
+            it('should yank current line into register as linewise', () => {
+                const state = createTestState(['hello world'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_yank_line',
+                    payload: { count: 1 },
+                });
+                expect(result.yankRegister).toEqual({
+                    text: 'hello world',
+                    linewise: true,
+                });
+            });
+            it('should not modify the buffer or cursor position', () => {
+                const state = createTestState(['hello world'], 0, 3);
+                const result = handleVimAction(state, {
+                    type: 'vim_yank_line',
+                    payload: { count: 1 },
+                });
+                expect(result.lines).toEqual(['hello world']);
+                expect(result.cursorRow).toBe(0);
+                expect(result.cursorCol).toBe(3);
+            });
+            it('should yank multiple lines with count', () => {
+                const state = createTestState(['line1', 'line2', 'line3'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_yank_line',
+                    payload: { count: 2 },
+                });
+                expect(result.yankRegister).toEqual({
+                    text: 'line1\nline2',
+                    linewise: true,
+                });
+                expect(result.lines).toEqual(['line1', 'line2', 'line3']);
+            });
+            it('should clamp count to available lines', () => {
+                const state = createTestState(['only'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_yank_line',
+                    payload: { count: 99 },
+                });
+                expect(result.yankRegister).toEqual({ text: 'only', linewise: true });
+            });
+        });
+        describe('vim_yank_word_forward (yw)', () => {
+            it('should yank from cursor to start of next word', () => {
+                const state = createTestState(['hello world'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_yank_word_forward',
+                    payload: { count: 1 },
+                });
+                expect(result.yankRegister).toEqual({
+                    text: 'hello ',
+                    linewise: false,
+                });
+                expect(result.lines).toEqual(['hello world']);
+            });
+        });
+        describe('vim_yank_big_word_forward (yW)', () => {
+            it('should yank from cursor to start of next big word', () => {
+                const state = createTestState(['hello world'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_yank_big_word_forward',
+                    payload: { count: 1 },
+                });
+                expect(result.yankRegister).toEqual({
+                    text: 'hello ',
+                    linewise: false,
+                });
+                expect(result.lines).toEqual(['hello world']);
+            });
+        });
+        describe('vim_yank_word_end (ye)', () => {
+            it('should yank from cursor to end of current word', () => {
+                const state = createTestState(['hello world'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_yank_word_end',
+                    payload: { count: 1 },
+                });
+                expect(result.yankRegister).toEqual({ text: 'hello', linewise: false });
+                expect(result.lines).toEqual(['hello world']);
+            });
+        });
+        describe('vim_yank_big_word_end (yE)', () => {
+            it('should yank from cursor to end of current big word', () => {
+                const state = createTestState(['hello world'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_yank_big_word_end',
+                    payload: { count: 1 },
+                });
+                expect(result.yankRegister).toEqual({ text: 'hello', linewise: false });
+                expect(result.lines).toEqual(['hello world']);
+            });
+        });
+        describe('vim_yank_to_end_of_line (y$)', () => {
+            it('should yank from cursor to end of line', () => {
+                const state = createTestState(['hello world'], 0, 6);
+                const result = handleVimAction(state, {
+                    type: 'vim_yank_to_end_of_line',
+                    payload: { count: 1 },
+                });
+                expect(result.yankRegister).toEqual({ text: 'world', linewise: false });
+                expect(result.lines).toEqual(['hello world']);
+            });
+            it('should do nothing when cursor is at end of line', () => {
+                const state = createTestState(['hello'], 0, 5);
+                const result = handleVimAction(state, {
+                    type: 'vim_yank_to_end_of_line',
+                    payload: { count: 1 },
+                });
+                expect(result.yankRegister).toBeNull();
+            });
+        });
+        describe('delete operations populate yankRegister', () => {
+            it('should populate register on x (vim_delete_char)', () => {
+                const state = createTestState(['hello'], 0, 1);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_char',
+                    payload: { count: 1 },
+                });
+                expect(result.yankRegister).toEqual({ text: 'e', linewise: false });
+                expect(result.lines[0]).toBe('hllo');
+            });
+            it('should populate register on X (vim_delete_char_before)', () => {
+                // cursor at col 2 ('l'); X deletes the char before = col 1 ('e')
+                const state = createTestState(['hello'], 0, 2);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_char_before',
+                    payload: { count: 1 },
+                });
+                expect(result.yankRegister).toEqual({ text: 'e', linewise: false });
+                expect(result.lines[0]).toBe('hllo');
+            });
+            it('should populate register on dd (vim_delete_line) as linewise', () => {
+                const state = createTestState(['hello', 'world'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_line',
+                    payload: { count: 1 },
+                });
+                expect(result.yankRegister).toEqual({ text: 'hello', linewise: true });
+                expect(result.lines).toEqual(['world']);
+            });
+            it('should populate register on 2dd with multiple lines', () => {
+                const state = createTestState(['one', 'two', 'three'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_line',
+                    payload: { count: 2 },
+                });
+                expect(result.yankRegister).toEqual({
+                    text: 'one\ntwo',
+                    linewise: true,
+                });
+                expect(result.lines).toEqual(['three']);
+            });
+            it('should populate register on dw (vim_delete_word_forward)', () => {
+                const state = createTestState(['hello world'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_word_forward',
+                    payload: { count: 1 },
+                });
+                expect(result.yankRegister).toEqual({
+                    text: 'hello ',
+                    linewise: false,
+                });
+                expect(result.lines[0]).toBe('world');
+            });
+            it('should populate register on dW (vim_delete_big_word_forward)', () => {
+                const state = createTestState(['hello world'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_big_word_forward',
+                    payload: { count: 1 },
+                });
+                expect(result.yankRegister).toEqual({
+                    text: 'hello ',
+                    linewise: false,
+                });
+            });
+            it('should populate register on de (vim_delete_word_end)', () => {
+                const state = createTestState(['hello world'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_word_end',
+                    payload: { count: 1 },
+                });
+                expect(result.yankRegister).toEqual({ text: 'hello', linewise: false });
+            });
+            it('should populate register on dE (vim_delete_big_word_end)', () => {
+                const state = createTestState(['hello world'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_big_word_end',
+                    payload: { count: 1 },
+                });
+                expect(result.yankRegister).toEqual({ text: 'hello', linewise: false });
+            });
+            it('should populate register on D (vim_delete_to_end_of_line)', () => {
+                const state = createTestState(['hello world'], 0, 6);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_to_end_of_line',
+                    payload: { count: 1 },
+                });
+                expect(result.yankRegister).toEqual({ text: 'world', linewise: false });
+                expect(result.lines[0]).toBe('hello ');
+            });
+            it('should populate register on df (vim_delete_to_char_forward, inclusive)', () => {
+                const state = createTestState(['hello world'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_to_char_forward',
+                    payload: { char: 'o', count: 1, till: false },
+                });
+                expect(result.yankRegister).toEqual({ text: 'hello', linewise: false });
+            });
+            it('should populate register on dt (vim_delete_to_char_forward, till)', () => {
+                const state = createTestState(['hello world'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_to_char_forward',
+                    payload: { char: 'o', count: 1, till: true },
+                });
+                // dt stops before 'o', so deletes 'hell'
+                expect(result.yankRegister).toEqual({ text: 'hell', linewise: false });
+            });
+            it('should populate register on dF (vim_delete_to_char_backward, inclusive)', () => {
+                // cursor at 7 ('o' in world), dFo finds 'o' at col 4, deletes [4, 8)
+                const state = createTestState(['hello world'], 0, 7);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_to_char_backward',
+                    payload: { char: 'o', count: 1, till: false },
+                });
+                expect(result.yankRegister).toEqual({ text: 'o wo', linewise: false });
+            });
+            it('should populate register on dT (vim_delete_to_char_backward, till)', () => {
+                // cursor at 7 ('o' in world), dTo finds 'o' at col 4, deletes [5, 8) = ' wo'
+                const state = createTestState(['hello world'], 0, 7);
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_to_char_backward',
+                    payload: { char: 'o', count: 1, till: true },
+                });
+                expect(result.yankRegister).toEqual({ text: ' wo', linewise: false });
+            });
+            it('should preserve existing register when delete finds nothing to delete', () => {
+                const state = {
+                    ...createTestState(['hello'], 0, 5),
+                    yankRegister: { text: 'preserved', linewise: false },
+                };
+                // x at end-of-line does nothing
+                const result = handleVimAction(state, {
+                    type: 'vim_delete_char',
+                    payload: { count: 1 },
+                });
+                expect(result.yankRegister).toEqual({
+                    text: 'preserved',
+                    linewise: false,
+                });
+            });
+        });
+        describe('vim_paste_after (p)', () => {
+            it('should paste charwise text after cursor and land on last pasted char', () => {
+                const state = {
+                    ...createTestState(['abc'], 0, 1),
+                    yankRegister: { text: 'XY', linewise: false },
+                };
+                const result = handleVimAction(state, {
+                    type: 'vim_paste_after',
+                    payload: { count: 1 },
+                });
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines[0]).toBe('abXYc');
+                expect(result.cursorCol).toBe(3);
+            });
+            it('should paste charwise at end of line when cursor is on last char', () => {
+                const state = {
+                    ...createTestState(['ab'], 0, 1),
+                    yankRegister: { text: 'Z', linewise: false },
+                };
+                const result = handleVimAction(state, {
+                    type: 'vim_paste_after',
+                    payload: { count: 1 },
+                });
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines[0]).toBe('abZ');
+                expect(result.cursorCol).toBe(2);
+            });
+            it('should paste linewise below current row', () => {
+                const state = {
+                    ...createTestState(['hello', 'world'], 0, 0),
+                    yankRegister: { text: 'inserted', linewise: true },
+                };
+                const result = handleVimAction(state, {
+                    type: 'vim_paste_after',
+                    payload: { count: 1 },
+                });
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines).toEqual(['hello', 'inserted', 'world']);
+                expect(result.cursorRow).toBe(1);
+                expect(result.cursorCol).toBe(0);
+            });
+            it('should do nothing when register is empty', () => {
+                const state = createTestState(['hello'], 0, 0);
+                const result = handleVimAction(state, {
+                    type: 'vim_paste_after',
+                    payload: { count: 1 },
+                });
+                expect(result.lines).toEqual(['hello']);
+                expect(result.cursorCol).toBe(0);
+            });
+            it('should paste charwise text count times', () => {
+                const state = {
+                    ...createTestState(['abc'], 0, 1),
+                    yankRegister: { text: 'X', linewise: false },
+                };
+                const result = handleVimAction(state, {
+                    type: 'vim_paste_after',
+                    payload: { count: 2 },
+                });
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines[0]).toBe('abXXc');
+            });
+            it('should paste linewise count times', () => {
+                const state = {
+                    ...createTestState(['hello', 'world'], 0, 0),
+                    yankRegister: { text: 'foo', linewise: true },
+                };
+                const result = handleVimAction(state, {
+                    type: 'vim_paste_after',
+                    payload: { count: 2 },
+                });
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines).toEqual(['hello', 'foo', 'foo', 'world']);
+                expect(result.cursorRow).toBe(1);
+            });
+            it('should land cursor on last char when pasting multiline charwise text', () => {
+                // Simulates yanking across a line boundary and pasting charwise.
+                // Cursor must land on the last pasted char, not a large out-of-bounds column.
+                const state = {
+                    ...createTestState(['ab', 'cd'], 0, 1),
+                    yankRegister: { text: 'b\nc', linewise: false },
+                };
+                const result = handleVimAction(state, {
+                    type: 'vim_paste_after',
+                    payload: { count: 1 },
+                });
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.cursorRow).toBe(1);
+                expect(result.cursorCol).toBe(0);
+            });
+            it('should land cursor correctly for count > 1 multiline charwise paste', () => {
+                const state = {
+                    ...createTestState(['ab', 'cd'], 0, 0),
+                    yankRegister: { text: 'x\ny', linewise: false },
+                };
+                const result = handleVimAction(state, {
+                    type: 'vim_paste_after',
+                    payload: { count: 2 },
+                });
+                expect(result).toHaveOnlyValidCharacters();
+                // cursor should be on the last char of the last pasted copy, not off-screen
+                expect(result.cursorCol).toBeLessThanOrEqual(result.lines[result.cursorRow].length - 1);
+            });
+        });
+        describe('vim_paste_before (P)', () => {
+            it('should paste charwise text before cursor and land on last pasted char', () => {
+                const state = {
+                    ...createTestState(['abc'], 0, 2),
+                    yankRegister: { text: 'XY', linewise: false },
+                };
+                const result = handleVimAction(state, {
+                    type: 'vim_paste_before',
+                    payload: { count: 1 },
+                });
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines[0]).toBe('abXYc');
+                expect(result.cursorCol).toBe(3);
+            });
+            it('should land cursor on last char when pasting multiline charwise text', () => {
+                const state = {
+                    ...createTestState(['ab', 'cd'], 0, 1),
+                    yankRegister: { text: 'b\nc', linewise: false },
+                };
+                const result = handleVimAction(state, {
+                    type: 'vim_paste_before',
+                    payload: { count: 1 },
+                });
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.cursorCol).toBeLessThanOrEqual(result.lines[result.cursorRow].length - 1);
+            });
+            it('should paste linewise above current row', () => {
+                const state = {
+                    ...createTestState(['hello', 'world'], 1, 0),
+                    yankRegister: { text: 'inserted', linewise: true },
+                };
+                const result = handleVimAction(state, {
+                    type: 'vim_paste_before',
+                    payload: { count: 1 },
+                });
+                expect(result).toHaveOnlyValidCharacters();
+                expect(result.lines).toEqual(['hello', 'inserted', 'world']);
+                expect(result.cursorRow).toBe(1);
+                expect(result.cursorCol).toBe(0);
+            });
+        });
+    });
 });
 //# sourceMappingURL=vim-buffer-actions.test.js.map