@machina.ai/cell-cli 1.11.0-rc1 → 1.13.0-rc2

package/dist/src/ui/components/InputPrompt.test.js

@@ -5,7 +5,8 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * SPDX-License-Identifier: Apache-2.0
  */
 import { renderWithProviders } from '../../test-utils/render.js';
-import { waitFor, act } from '@testing-library/react';
+import { waitFor } from '../../test-utils/async.js';
+import { act } from 'react';
 import { InputPrompt } from './InputPrompt.js';
 import { ApprovalMode } from '@google/gemini-cli-core';
 import * as path from 'node:path';
@@ -112,6 +113,7 @@ describe('InputPrompt', () => {
             moveToOffset: vi.fn((offset) => {
                 mockBuffer.cursor = [0, offset];
             }),
+            moveToVisualPosition: vi.fn(),
             killLineRight: vi.fn(),
             killLineLeft: vi.fn(),
             openInExternalEditor: vi.fn(),
@@ -207,63 +209,68 @@ describe('InputPrompt', () => {
             streamingState: StreamingState.Idle,
         };
     });
-    const wait = (ms = 50) => new Promise((resolve) => setTimeout(resolve, ms));
     it('should call shellHistory.getPreviousCommand on up arrow in shell mode', async () => {
         props.shellModeActive = true;
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('\u001B[A');
-        await wait();
-        expect(mockShellHistory.getPreviousCommand).toHaveBeenCalled();
+        await act(async () => {
+            stdin.write('\u001B[A');
+        });
+        await waitFor(() => expect(mockShellHistory.getPreviousCommand).toHaveBeenCalled());
         unmount();
     });
     it('should call shellHistory.getNextCommand on down arrow in shell mode', async () => {
         props.shellModeActive = true;
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('\u001B[B');
-        await wait();
-        expect(mockShellHistory.getNextCommand).toHaveBeenCalled();
+        await act(async () => {
+            stdin.write('\u001B[B');
+            await waitFor(() => expect(mockShellHistory.getNextCommand).toHaveBeenCalled());
+        });
         unmount();
     });
     it('should set the buffer text when a shell history command is retrieved', async () => {
         props.shellModeActive = true;
         vi.mocked(mockShellHistory.getPreviousCommand).mockReturnValue('previous command');
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('\u001B[A');
-        await wait();
-        expect(mockShellHistory.getPreviousCommand).toHaveBeenCalled();
-        expect(props.buffer.setText).toHaveBeenCalledWith('previous command');
+        await act(async () => {
+            stdin.write('\u001B[A');
+        });
+        await waitFor(() => {
+            expect(mockShellHistory.getPreviousCommand).toHaveBeenCalled();
+            expect(props.buffer.setText).toHaveBeenCalledWith('previous command');
+        });
         unmount();
     });
     it('should call shellHistory.addCommandToHistory on submit in shell mode', async () => {
         props.shellModeActive = true;
         props.buffer.setText('ls -l');
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('\r');
-        await wait();
-        expect(mockShellHistory.addCommandToHistory).toHaveBeenCalledWith('ls -l');
-        expect(props.onSubmit).toHaveBeenCalledWith('ls -l');
+        await act(async () => {
+            stdin.write('\r');
+        });
+        await waitFor(() => {
+            expect(mockShellHistory.addCommandToHistory).toHaveBeenCalledWith('ls -l');
+            expect(props.onSubmit).toHaveBeenCalledWith('ls -l');
+        });
         unmount();
     });
     it('should NOT call shell history methods when not in shell mode', async () => {
         props.buffer.setText('some text');
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('\u001B[A'); // Up arrow
-        await wait();
-        stdin.write('\u001B[B'); // Down arrow
-        await wait();
-        stdin.write('\r'); // Enter
-        await wait();
+        await act(async () => {
+            stdin.write('\u001B[A'); // Up arrow
+        });
+        await waitFor(() => expect(mockInputHistory.navigateUp).toHaveBeenCalled());
+        await act(async () => {
+            stdin.write('\u001B[B'); // Down arrow
+        });
+        await waitFor(() => expect(mockInputHistory.navigateDown).toHaveBeenCalled());
+        await act(async () => {
+            stdin.write('\r'); // Enter
+        });
+        await waitFor(() => expect(props.onSubmit).toHaveBeenCalledWith('some text'));
         expect(mockShellHistory.getPreviousCommand).not.toHaveBeenCalled();
         expect(mockShellHistory.getNextCommand).not.toHaveBeenCalled();
         expect(mockShellHistory.addCommandToHistory).not.toHaveBeenCalled();
-        expect(mockInputHistory.navigateUp).toHaveBeenCalled();
-        expect(mockInputHistory.navigateDown).toHaveBeenCalled();
-        expect(props.onSubmit).toHaveBeenCalledWith('some text');
         unmount();
     });
     it('should call completion.navigateUp for both up arrow and Ctrl+P when suggestions are showing', async () => {
@@ -277,13 +284,15 @@ describe('InputPrompt', () => {
         });
         props.buffer.setText('/mem');
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
         // Test up arrow
-        stdin.write('\u001B[A'); // Up arrow
-        await wait();
-        stdin.write('\u0010'); // Ctrl+P
-        await wait();
-        expect(mockCommandCompletion.navigateUp).toHaveBeenCalledTimes(2);
+        await act(async () => {
+            stdin.write('\u001B[A'); // Up arrow
+        });
+        await waitFor(() => expect(mockCommandCompletion.navigateUp).toHaveBeenCalledTimes(1));
+        await act(async () => {
+            stdin.write('\u0010'); // Ctrl+P
+        });
+        await waitFor(() => expect(mockCommandCompletion.navigateUp).toHaveBeenCalledTimes(2));
         expect(mockCommandCompletion.navigateDown).not.toHaveBeenCalled();
         unmount();
     });
@@ -298,13 +307,15 @@ describe('InputPrompt', () => {
         });
         props.buffer.setText('/mem');
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
         // Test down arrow
-        stdin.write('\u001B[B'); // Down arrow
-        await wait();
-        stdin.write('\u000E'); // Ctrl+N
-        await wait();
-        expect(mockCommandCompletion.navigateDown).toHaveBeenCalledTimes(2);
+        await act(async () => {
+            stdin.write('\u001B[B'); // Down arrow
+        });
+        await waitFor(() => expect(mockCommandCompletion.navigateDown).toHaveBeenCalledTimes(1));
+        await act(async () => {
+            stdin.write('\u000E'); // Ctrl+N
+        });
+        await waitFor(() => expect(mockCommandCompletion.navigateDown).toHaveBeenCalledTimes(2));
         expect(mockCommandCompletion.navigateUp).not.toHaveBeenCalled();
         unmount();
     });
@@ -315,17 +326,24 @@ describe('InputPrompt', () => {
         });
         props.buffer.setText('some text');
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('\u001B[A'); // Up arrow
-        await wait();
-        stdin.write('\u001B[B'); // Down arrow
-        await wait();
-        stdin.write('\u0010'); // Ctrl+P
-        await wait();
-        stdin.write('\u000E'); // Ctrl+N
-        await wait();
-        expect(mockCommandCompletion.navigateUp).not.toHaveBeenCalled();
-        expect(mockCommandCompletion.navigateDown).not.toHaveBeenCalled();
+        await act(async () => {
+            stdin.write('\u001B[A'); // Up arrow
+        });
+        await waitFor(() => expect(mockInputHistory.navigateUp).toHaveBeenCalled());
+        await act(async () => {
+            stdin.write('\u001B[B'); // Down arrow
+        });
+        await waitFor(() => expect(mockInputHistory.navigateDown).toHaveBeenCalled());
+        await act(async () => {
+            stdin.write('\u0010'); // Ctrl+P
+        });
+        await act(async () => {
+            stdin.write('\u000E'); // Ctrl+N
+        });
+        await waitFor(() => {
+            expect(mockCommandCompletion.navigateUp).not.toHaveBeenCalled();
+            expect(mockCommandCompletion.navigateDown).not.toHaveBeenCalled();
+        });
         unmount();
     });
     describe('clipboard image paste', () => {
@@ -338,23 +356,27 @@ describe('InputPrompt', () => {
             vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(true);
             vi.mocked(clipboardUtils.saveClipboardImage).mockResolvedValue('/test/.cell-cli-clipboard/clipboard-123.png');
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
             // Send Ctrl+V
-            stdin.write('\x16'); // Ctrl+V
-            await wait();
-            expect(clipboardUtils.clipboardHasImage).toHaveBeenCalled();
-            expect(clipboardUtils.saveClipboardImage).toHaveBeenCalledWith(props.config.getTargetDir());
-            expect(clipboardUtils.cleanupOldClipboardImages).toHaveBeenCalledWith(props.config.getTargetDir());
-            expect(mockBuffer.replaceRangeByOffset).toHaveBeenCalled();
+            await act(async () => {
+                stdin.write('\x16'); // Ctrl+V
+            });
+            await waitFor(() => {
+                expect(clipboardUtils.clipboardHasImage).toHaveBeenCalled();
+                expect(clipboardUtils.saveClipboardImage).toHaveBeenCalledWith(props.config.getTargetDir());
+                expect(clipboardUtils.cleanupOldClipboardImages).toHaveBeenCalledWith(props.config.getTargetDir());
+                expect(mockBuffer.replaceRangeByOffset).toHaveBeenCalled();
+            });
             unmount();
         });
         it('should not insert anything when clipboard has no image', async () => {
             vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false);
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('\x16'); // Ctrl+V
-            await wait();
-            expect(clipboardUtils.clipboardHasImage).toHaveBeenCalled();
+            await act(async () => {
+                stdin.write('\x16'); // Ctrl+V
+            });
+            await waitFor(() => {
+                expect(clipboardUtils.clipboardHasImage).toHaveBeenCalled();
+            });
             expect(clipboardUtils.saveClipboardImage).not.toHaveBeenCalled();
             expect(mockBuffer.setText).not.toHaveBeenCalled();
             unmount();
@@ -363,10 +385,12 @@ describe('InputPrompt', () => {
             vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(true);
             vi.mocked(clipboardUtils.saveClipboardImage).mockResolvedValue(null);
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('\x16'); // Ctrl+V
-            await wait();
-            expect(clipboardUtils.saveClipboardImage).toHaveBeenCalled();
+            await act(async () => {
+                stdin.write('\x16'); // Ctrl+V
+            });
+            await waitFor(() => {
+                expect(clipboardUtils.saveClipboardImage).toHaveBeenCalled();
+            });
             expect(mockBuffer.setText).not.toHaveBeenCalled();
             unmount();
         });
@@ -380,11 +404,13 @@ describe('InputPrompt', () => {
             mockBuffer.lines = ['Hello world'];
             mockBuffer.replaceRangeByOffset = vi.fn();
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('\x16'); // Ctrl+V
-            await wait();
-            // Should insert at cursor position with spaces
-            expect(mockBuffer.replaceRangeByOffset).toHaveBeenCalled();
+            await act(async () => {
+                stdin.write('\x16'); // Ctrl+V
+            });
+            await waitFor(() => {
+                // Should insert at cursor position with spaces
+                expect(mockBuffer.replaceRangeByOffset).toHaveBeenCalled();
+            });
             // Get the actual call to see what path was used
             const actualCall = vi.mocked(mockBuffer.replaceRangeByOffset).mock
                 .calls[0];
@@ -399,10 +425,12 @@ describe('InputPrompt', () => {
                 .mockImplementation(() => { });
             vi.mocked(clipboardUtils.clipboardHasImage).mockRejectedValue(new Error('Clipboard error'));
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('\x16'); // Ctrl+V
-            await wait();
-            expect(consoleErrorSpy).toHaveBeenCalledWith('Error handling clipboard image:', expect.any(Error));
+            await act(async () => {
+                stdin.write('\x16'); // Ctrl+V
+            });
+            await waitFor(() => {
+                expect(consoleErrorSpy).toHaveBeenCalledWith('Error handling clipboard image:', expect.any(Error));
+            });
             expect(mockBuffer.setText).not.toHaveBeenCalled();
             consoleErrorSpy.mockRestore();
             unmount();
@@ -418,10 +446,10 @@ describe('InputPrompt', () => {
         });
         props.buffer.setText('/mem');
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('\t'); // Press Tab
-        await wait();
-        expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
+        await act(async () => {
+            stdin.write('\t'); // Press Tab
+        });
+        await waitFor(() => expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0));
         unmount();
     });
     it('should append a sub-command when the parent command is already complete', async () => {
@@ -437,10 +465,10 @@ describe('InputPrompt', () => {
         });
         props.buffer.setText('/memory ');
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('\t'); // Press Tab
-        await wait();
-        expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(1);
+        await act(async () => {
+            stdin.write('\t'); // Press Tab
+        });
+        await waitFor(() => expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(1));
         unmount();
     });
     it('should handle the "backspace" edge case correctly', async () => {
@@ -457,11 +485,12 @@ describe('InputPrompt', () => {
         // The user has backspaced, so the query is now just '/memory'
         props.buffer.setText('/memory');
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('\t'); // Press Tab
-        await wait();
+        await act(async () => {
+            stdin.write('\t'); // Press Tab
+        });
+        await waitFor(() => 
         // It should NOT become '/show'. It should correctly become '/memory show'.
-        expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
+        expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0));
         unmount();
     });
     it('should complete a partial argument for a command', async () => {
@@ -474,10 +503,10 @@ describe('InputPrompt', () => {
         });
         props.buffer.setText('/chat resume fi-');
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('\t'); // Press Tab
-        await wait();
-        expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
+        await act(async () => {
+            stdin.write('\t'); // Press Tab
+        });
+        await waitFor(() => expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0));
         unmount();
     });
     it('should autocomplete on Enter when suggestions are active, without submitting', async () => {
@@ -489,11 +518,13 @@ describe('InputPrompt', () => {
         });
         props.buffer.setText('/mem');
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('\r');
-        await wait();
-        // The app should autocomplete the text, NOT submit.
-        expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
+        await act(async () => {
+            stdin.write('\r');
+        });
+        await waitFor(() => {
+            // The app should autocomplete the text, NOT submit.
+            expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
+        });
         expect(props.onSubmit).not.toHaveBeenCalled();
         unmount();
     });
@@ -514,19 +545,21 @@ describe('InputPrompt', () => {
         });
         props.buffer.setText('/?');
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('\t'); // Press Tab for autocomplete
-        await wait();
-        expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
+        await act(async () => {
+            stdin.write('\t'); // Press Tab for autocomplete
+        });
+        await waitFor(() => expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0));
         unmount();
     });
     it('should not submit on Enter when the buffer is empty or only contains whitespace', async () => {
         props.buffer.setText('   '); // Set buffer to whitespace
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('\r'); // Press Enter
-        await wait();
-        expect(props.onSubmit).not.toHaveBeenCalled();
+        await act(async () => {
+            stdin.write('\r'); // Press Enter
+        });
+        await waitFor(() => {
+            expect(props.onSubmit).not.toHaveBeenCalled();
+        });
         unmount();
     });
     it('should submit directly on Enter when isPerfectMatch is true', async () => {
@@ -537,10 +570,10 @@ describe('InputPrompt', () => {
         });
         props.buffer.setText('/clear');
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('\r');
-        await wait();
-        expect(props.onSubmit).toHaveBeenCalledWith('/clear');
+        await act(async () => {
+            stdin.write('\r');
+        });
+        await waitFor(() => expect(props.onSubmit).toHaveBeenCalledWith('/clear'));
         unmount();
     });
     it('should submit directly on Enter when a complete leaf command is typed', async () => {
@@ -551,10 +584,10 @@ describe('InputPrompt', () => {
         });
         props.buffer.setText('/clear');
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('\r');
-        await wait();
-        expect(props.onSubmit).toHaveBeenCalledWith('/clear');
+        await act(async () => {
+            stdin.write('\r');
+        });
+        await waitFor(() => expect(props.onSubmit).toHaveBeenCalledWith('/clear'));
         unmount();
     });
     it('should autocomplete an @-path on Enter without submitting', async () => {
@@ -566,10 +599,10 @@ describe('InputPrompt', () => {
         });
         props.buffer.setText('@src/components/');
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('\r');
-        await wait();
-        expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
+        await act(async () => {
+            stdin.write('\r');
+        });
+        await waitFor(() => expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0));
         expect(props.onSubmit).not.toHaveBeenCalled();
         unmount();
     });
@@ -579,243 +612,137 @@ describe('InputPrompt', () => {
         mockBuffer.cursor = [0, 11];
         mockBuffer.lines = ['first line\\'];
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('\r');
-        await wait();
+        await act(async () => {
+            stdin.write('\r');
+        });
+        await waitFor(() => {
+            expect(props.buffer.backspace).toHaveBeenCalled();
+            expect(props.buffer.newline).toHaveBeenCalled();
+        });
         expect(props.onSubmit).not.toHaveBeenCalled();
-        expect(props.buffer.backspace).toHaveBeenCalled();
-        expect(props.buffer.newline).toHaveBeenCalled();
         unmount();
     });
     it('should clear the buffer on Ctrl+C if it has text', async () => {
-        props.buffer.setText('some text to clear');
+        await act(async () => {
+            props.buffer.setText('some text to clear');
+        });
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('\x03'); // Ctrl+C character
-        await wait();
-        expect(props.buffer.setText).toHaveBeenCalledWith('');
-        expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
+        await act(async () => {
+            stdin.write('\x03'); // Ctrl+C character
+        });
+        await waitFor(() => {
+            expect(props.buffer.setText).toHaveBeenCalledWith('');
+            expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
+        });
         expect(props.onSubmit).not.toHaveBeenCalled();
         unmount();
     });
     it('should NOT clear the buffer on Ctrl+C if it is empty', async () => {
         props.buffer.text = '';
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('\x03'); // Ctrl+C character
-        await wait();
-        expect(props.buffer.setText).not.toHaveBeenCalled();
+        await act(async () => {
+            stdin.write('\x03'); // Ctrl+C character
+        });
+        await waitFor(() => {
+            expect(props.buffer.setText).not.toHaveBeenCalled();
+        });
         unmount();
     });
     describe('cursor-based completion trigger', () => {
-        it('should trigger completion when cursor is after @ without spaces', async () => {
-            // Set up buffer state
-            mockBuffer.text = '@src/components';
-            mockBuffer.lines = ['@src/components'];
-            mockBuffer.cursor = [0, 15];
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
+        it.each([
+            {
+                name: 'should trigger completion when cursor is after @ without spaces',
+                text: '@src/components',
+                cursor: [0, 15],
                 showSuggestions: true,
-                suggestions: [{ label: 'Button.tsx', value: 'Button.tsx' }],
-            });
-            const { unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            // Verify useCompletion was called with correct signature
-            expect(mockedUseCommandCompletion).toHaveBeenCalledWith(mockBuffer, ['/test/project/src'], path.join('test', 'project', 'src'), mockSlashCommands, mockCommandContext, false, false, expect.any(Object));
-            unmount();
-        });
-        it('should trigger completion when cursor is after / without spaces', async () => {
-            mockBuffer.text = '/memory';
-            mockBuffer.lines = ['/memory'];
-            mockBuffer.cursor = [0, 7];
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
+            },
+            {
+                name: 'should trigger completion when cursor is after / without spaces',
+                text: '/memory',
+                cursor: [0, 7],
                 showSuggestions: true,
-                suggestions: [{ label: 'show', value: 'show' }],
-            });
-            const { unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            expect(mockedUseCommandCompletion).toHaveBeenCalledWith(mockBuffer, ['/test/project/src'], path.join('test', 'project', 'src'), mockSlashCommands, mockCommandContext, false, false, expect.any(Object));
-            unmount();
-        });
-        it('should NOT trigger completion when cursor is after space following @', async () => {
-            mockBuffer.text = '@src/file.ts hello';
-            mockBuffer.lines = ['@src/file.ts hello'];
-            mockBuffer.cursor = [0, 18];
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
+            },
+            {
+                name: 'should NOT trigger completion when cursor is after space following @',
+                text: '@src/file.ts hello',
+                cursor: [0, 18],
                 showSuggestions: false,
-                suggestions: [],
-            });
-            const { unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            expect(mockedUseCommandCompletion).toHaveBeenCalledWith(mockBuffer, ['/test/project/src'], path.join('test', 'project', 'src'), mockSlashCommands, mockCommandContext, false, false, expect.any(Object));
-            unmount();
-        });
-        it('should NOT trigger completion when cursor is after space following /', async () => {
-            mockBuffer.text = '/memory add';
-            mockBuffer.lines = ['/memory add'];
-            mockBuffer.cursor = [0, 11];
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
+            },
+            {
+                name: 'should NOT trigger completion when cursor is after space following /',
+                text: '/memory add',
+                cursor: [0, 11],
                 showSuggestions: false,
-                suggestions: [],
-            });
-            const { unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            expect(mockedUseCommandCompletion).toHaveBeenCalledWith(mockBuffer, ['/test/project/src'], path.join('test', 'project', 'src'), mockSlashCommands, mockCommandContext, false, false, expect.any(Object));
-            unmount();
-        });
-        it('should NOT trigger completion when cursor is not after @ or /', async () => {
-            mockBuffer.text = 'hello world';
-            mockBuffer.lines = ['hello world'];
-            mockBuffer.cursor = [0, 5];
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
+            },
+            {
+                name: 'should NOT trigger completion when cursor is not after @ or /',
+                text: 'hello world',
+                cursor: [0, 5],
                 showSuggestions: false,
-                suggestions: [],
-            });
-            const { unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            expect(mockedUseCommandCompletion).toHaveBeenCalledWith(mockBuffer, ['/test/project/src'], path.join('test', 'project', 'src'), mockSlashCommands, mockCommandContext, false, false, expect.any(Object));
-            unmount();
-        });
-        it('should handle multiline text correctly', async () => {
-            mockBuffer.text = 'first line\n/memory';
-            mockBuffer.lines = ['first line', '/memory'];
-            mockBuffer.cursor = [1, 7];
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
+            },
+            {
+                name: 'should handle multiline text correctly',
+                text: 'first line\n/memory',
+                cursor: [1, 7],
                 showSuggestions: false,
-                suggestions: [],
-            });
-            const { unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            // Verify useCompletion was called with the buffer
-            expect(mockedUseCommandCompletion).toHaveBeenCalledWith(mockBuffer, ['/test/project/src'], path.join('test', 'project', 'src'), mockSlashCommands, mockCommandContext, false, false, expect.any(Object));
-            unmount();
-        });
-        it('should handle single line slash command correctly', async () => {
-            mockBuffer.text = '/memory';
-            mockBuffer.lines = ['/memory'];
-            mockBuffer.cursor = [0, 7];
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
-                showSuggestions: true,
-                suggestions: [{ label: 'show', value: 'show' }],
-            });
-            const { unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            expect(mockedUseCommandCompletion).toHaveBeenCalledWith(mockBuffer, ['/test/project/src'], path.join('test', 'project', 'src'), mockSlashCommands, mockCommandContext, false, false, expect.any(Object));
-            unmount();
-        });
-        it('should handle Unicode characters (emojis) correctly in paths', async () => {
-            // Test with emoji in path after @
-            mockBuffer.text = '@src/file👍.txt';
-            mockBuffer.lines = ['@src/file👍.txt'];
-            mockBuffer.cursor = [0, 14]; // After the emoji character
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
+            },
+            {
+                name: 'should handle Unicode characters (emojis) correctly in paths',
+                text: '@src/file👍.txt',
+                cursor: [0, 14],
                 showSuggestions: true,
-                suggestions: [{ label: 'file👍.txt', value: 'file👍.txt' }],
-            });
-            const { unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            expect(mockedUseCommandCompletion).toHaveBeenCalledWith(mockBuffer, ['/test/project/src'], path.join('test', 'project', 'src'), mockSlashCommands, mockCommandContext, false, false, expect.any(Object));
-            unmount();
-        });
-        it('should handle Unicode characters with spaces after them', async () => {
-            // Test with emoji followed by space - should NOT trigger completion
-            mockBuffer.text = '@src/file👍.txt hello';
-            mockBuffer.lines = ['@src/file👍.txt hello'];
-            mockBuffer.cursor = [0, 20]; // After the space
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
+            },
+            {
+                name: 'should handle Unicode characters with spaces after them',
+                text: '@src/file👍.txt hello',
+                cursor: [0, 20],
                 showSuggestions: false,
-                suggestions: [],
-            });
-            const { unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            expect(mockedUseCommandCompletion).toHaveBeenCalledWith(mockBuffer, ['/test/project/src'], path.join('test', 'project', 'src'), mockSlashCommands, mockCommandContext, false, false, expect.any(Object));
-            unmount();
-        });
-        it('should handle escaped spaces in paths correctly', async () => {
-            // Test with escaped space in path - should trigger completion
-            mockBuffer.text = '@src/my\\ file.txt';
-            mockBuffer.lines = ['@src/my\\ file.txt'];
-            mockBuffer.cursor = [0, 16]; // After the escaped space and filename
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
+            },
+            {
+                name: 'should handle escaped spaces in paths correctly',
+                text: '@src/my\\ file.txt',
+                cursor: [0, 16],
                 showSuggestions: true,
-                suggestions: [{ label: 'my file.txt', value: 'my file.txt' }],
-            });
-            const { unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            expect(mockedUseCommandCompletion).toHaveBeenCalledWith(mockBuffer, ['/test/project/src'], path.join('test', 'project', 'src'), mockSlashCommands, mockCommandContext, false, false, expect.any(Object));
-            unmount();
-        });
-        it('should NOT trigger completion after unescaped space following escaped space', async () => {
-            // Test: @path/my\ file.txt hello (unescaped space after escaped space)
-            mockBuffer.text = '@path/my\\ file.txt hello';
-            mockBuffer.lines = ['@path/my\\ file.txt hello'];
-            mockBuffer.cursor = [0, 24]; // After "hello"
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
+            },
+            {
+                name: 'should NOT trigger completion after unescaped space following escaped space',
+                text: '@path/my\\ file.txt hello',
+                cursor: [0, 24],
                 showSuggestions: false,
-                suggestions: [],
-            });
-            const { unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            expect(mockedUseCommandCompletion).toHaveBeenCalledWith(mockBuffer, ['/test/project/src'], path.join('test', 'project', 'src'), mockSlashCommands, mockCommandContext, false, false, expect.any(Object));
-            unmount();
-        });
-        it('should handle multiple escaped spaces in paths', async () => {
-            // Test with multiple escaped spaces
-            mockBuffer.text = '@docs/my\\ long\\ file\\ name.md';
-            mockBuffer.lines = ['@docs/my\\ long\\ file\\ name.md'];
-            mockBuffer.cursor = [0, 29]; // At the end
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
+            },
+            {
+                name: 'should handle multiple escaped spaces in paths',
+                text: '@docs/my\\ long\\ file\\ name.md',
+                cursor: [0, 29],
                 showSuggestions: true,
-                suggestions: [
-                    { label: 'my long file name.md', value: 'my long file name.md' },
-                ],
-            });
-            const { unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            expect(mockedUseCommandCompletion).toHaveBeenCalledWith(mockBuffer, ['/test/project/src'], path.join('test', 'project', 'src'), mockSlashCommands, mockCommandContext, false, false, expect.any(Object));
-            unmount();
-        });
-        it('should handle escaped spaces in slash commands', async () => {
-            // Test escaped spaces with slash commands (though less common)
-            mockBuffer.text = '/memory\\ test';
-            mockBuffer.lines = ['/memory\\ test'];
-            mockBuffer.cursor = [0, 13]; // At the end
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
+            },
+            {
+                name: 'should handle escaped spaces in slash commands',
+                text: '/memory\\ test',
+                cursor: [0, 13],
                 showSuggestions: true,
-                suggestions: [{ label: 'test-command', value: 'test-command' }],
-            });
-            const { unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            expect(mockedUseCommandCompletion).toHaveBeenCalledWith(mockBuffer, ['/test/project/src'], path.join('test', 'project', 'src'), mockSlashCommands, mockCommandContext, false, false, expect.any(Object));
-            unmount();
-        });
-        it('should handle Unicode characters with escaped spaces', async () => {
-            // Test combining Unicode and escaped spaces
-            mockBuffer.text = '@' + path.join('files', 'emoji\\ 👍\\ test.txt');
-            mockBuffer.lines = ['@' + path.join('files', 'emoji\\ 👍\\ test.txt')];
-            mockBuffer.cursor = [0, 25]; // After the escaped space and emoji
+            },
+            {
+                name: 'should handle Unicode characters with escaped spaces',
+                text: `@${path.join('files', 'emoji\\ 👍\\ test.txt')}`,
+                cursor: [0, 25],
+                showSuggestions: true,
+            },
+        ])('$name', async ({ text, cursor, showSuggestions }) => {
+            mockBuffer.text = text;
+            mockBuffer.lines = text.split('\n');
+            mockBuffer.cursor = cursor;
             mockedUseCommandCompletion.mockReturnValue({
                 ...mockCommandCompletion,
-                showSuggestions: true,
-                suggestions: [
-                    { label: 'emoji 👍 test.txt', value: 'emoji 👍 test.txt' },
-                ],
+                showSuggestions,
+                suggestions: showSuggestions
+                    ? [{ label: 'suggestion', value: 'suggestion' }]
+                    : [],
             });
             const { unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            expect(mockedUseCommandCompletion).toHaveBeenCalledWith(mockBuffer, ['/test/project/src'], path.join('test', 'project', 'src'), mockSlashCommands, mockCommandContext, false, false, expect.any(Object));
+            await waitFor(() => {
+                expect(mockedUseCommandCompletion).toHaveBeenCalledWith(mockBuffer, ['/test/project/src'], path.join('test', 'project', 'src'), mockSlashCommands, mockCommandContext, false, false, expect.any(Object));
+            });
             unmount();
         });
     });
@@ -823,32 +750,38 @@ describe('InputPrompt', () => {
         it('should not call buffer.handleInput when vim mode is enabled and vim handles the input', async () => {
             props.vimHandleInput = vi.fn().mockReturnValue(true); // Mock that vim handled it.
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('i');
-            await wait();
-            expect(props.vimHandleInput).toHaveBeenCalled();
+            await act(async () => {
+                stdin.write('i');
+            });
+            await waitFor(() => {
+                expect(props.vimHandleInput).toHaveBeenCalled();
+            });
             expect(mockBuffer.handleInput).not.toHaveBeenCalled();
             unmount();
         });
         it('should call buffer.handleInput when vim mode is enabled but vim does not handle the input', async () => {
             props.vimHandleInput = vi.fn().mockReturnValue(false); // Mock that vim did NOT handle it.
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('i');
-            await wait();
-            expect(props.vimHandleInput).toHaveBeenCalled();
-            expect(mockBuffer.handleInput).toHaveBeenCalled();
+            await act(async () => {
+                stdin.write('i');
+            });
+            await waitFor(() => {
+                expect(props.vimHandleInput).toHaveBeenCalled();
+                expect(mockBuffer.handleInput).toHaveBeenCalled();
+            });
             unmount();
         });
         it('should call handleInput when vim mode is disabled', async () => {
             // Mock vimHandleInput to return false (vim didn't handle the input)
             props.vimHandleInput = vi.fn().mockReturnValue(false);
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('i');
-            await wait();
-            expect(props.vimHandleInput).toHaveBeenCalled();
-            expect(mockBuffer.handleInput).toHaveBeenCalled();
+            await act(async () => {
+                stdin.write('i');
+            });
+            await waitFor(() => {
+                expect(props.vimHandleInput).toHaveBeenCalled();
+                expect(mockBuffer.handleInput).toHaveBeenCalled();
+            });
             unmount();
         });
     });
@@ -856,185 +789,158 @@ describe('InputPrompt', () => {
         it('should handle bracketed paste when not focused', async () => {
             props.focus = false;
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('\x1B[200~pasted text\x1B[201~');
-            await wait();
-            expect(mockBuffer.handleInput).toHaveBeenCalledWith(expect.objectContaining({
-                paste: true,
-                sequence: 'pasted text',
-            }));
+            await act(async () => {
+                stdin.write('\x1B[200~pasted text\x1B[201~');
+            });
+            await waitFor(() => {
+                expect(mockBuffer.handleInput).toHaveBeenCalledWith(expect.objectContaining({
+                    paste: true,
+                    sequence: 'pasted text',
+                }));
+            });
             unmount();
         });
         it('should ignore regular keypresses when not focused', async () => {
             props.focus = false;
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('a');
-            await wait();
+            await act(async () => {
+                stdin.write('a');
+            });
+            await waitFor(() => { });
             expect(mockBuffer.handleInput).not.toHaveBeenCalled();
             unmount();
         });
     });
     describe('Highlighting and Cursor Display', () => {
-        it('should display cursor mid-word by highlighting the character', async () => {
-            mockBuffer.text = 'hello world';
-            mockBuffer.lines = ['hello world'];
-            mockBuffer.viewportVisualLines = ['hello world'];
-            mockBuffer.visualCursor = [0, 3]; // cursor on the second 'l'
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            const frame = stdout.lastFrame();
-            // The component will render the text with the character at the cursor inverted.
-            expect(frame).toContain(`hel${chalk.inverse('l')}o world`);
-            unmount();
-        });
-        it('should display cursor at the beginning of the line', async () => {
-            mockBuffer.text = 'hello';
-            mockBuffer.lines = ['hello'];
-            mockBuffer.viewportVisualLines = ['hello'];
-            mockBuffer.visualCursor = [0, 0]; // cursor on 'h'
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            const frame = stdout.lastFrame();
-            expect(frame).toContain(`${chalk.inverse('h')}ello`);
-            unmount();
-        });
-        it('should display cursor at the end of the line as an inverted space', async () => {
-            mockBuffer.text = 'hello';
-            mockBuffer.lines = ['hello'];
-            mockBuffer.viewportVisualLines = ['hello'];
-            mockBuffer.visualCursor = [0, 5]; // cursor after 'o'
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            const frame = stdout.lastFrame();
-            expect(frame).toContain(`hello${chalk.inverse(' ')}`);
-            unmount();
-        });
-        it('should display cursor correctly on a highlighted token', async () => {
-            mockBuffer.text = 'run @path/to/file';
-            mockBuffer.lines = ['run @path/to/file'];
-            mockBuffer.viewportVisualLines = ['run @path/to/file'];
-            mockBuffer.visualCursor = [0, 9]; // cursor on 't' in 'to'
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            const frame = stdout.lastFrame();
-            // The token '@path/to/file' is colored, and the cursor highlights one char inside it.
-            expect(frame).toContain(`@path/${chalk.inverse('t')}o/file`);
-            unmount();
-        });
-        it('should display cursor correctly for multi-byte unicode characters', async () => {
-            const text = 'hello 👍 world';
-            mockBuffer.text = text;
-            mockBuffer.lines = [text];
-            mockBuffer.viewportVisualLines = [text];
-            mockBuffer.visualCursor = [0, 6]; // cursor on '👍'
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            const frame = stdout.lastFrame();
-            expect(frame).toContain(`hello ${chalk.inverse('👍')} world`);
-            unmount();
-        });
-        it('should display cursor at the end of a line with unicode characters', async () => {
-            const text = 'hello 👍';
-            mockBuffer.text = text;
-            mockBuffer.lines = [text];
-            mockBuffer.viewportVisualLines = [text];
-            mockBuffer.visualCursor = [0, 8]; // cursor after '👍' (length is 6 + 2 for emoji)
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            const frame = stdout.lastFrame();
-            expect(frame).toContain(`hello 👍${chalk.inverse(' ')}`);
-            unmount();
-        });
-        it('should display cursor on an empty line', async () => {
-            mockBuffer.text = '';
-            mockBuffer.lines = [''];
-            mockBuffer.viewportVisualLines = [''];
-            mockBuffer.visualCursor = [0, 0];
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            const frame = stdout.lastFrame();
-            expect(frame).toContain(chalk.inverse(' '));
-            unmount();
-        });
-        it('should display cursor on a space between words', async () => {
-            mockBuffer.text = 'hello world';
-            mockBuffer.lines = ['hello world'];
-            mockBuffer.viewportVisualLines = ['hello world'];
-            mockBuffer.visualCursor = [0, 5]; // cursor on the space
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            const frame = stdout.lastFrame();
-            expect(frame).toContain(`hello${chalk.inverse(' ')}world`);
-            unmount();
-        });
-        it('should display cursor in the middle of a line in a multiline block', async () => {
-            const text = 'first line\nsecond line\nthird line';
-            mockBuffer.text = text;
-            mockBuffer.lines = text.split('\n');
-            mockBuffer.viewportVisualLines = text.split('\n');
-            mockBuffer.visualCursor = [1, 3]; // cursor on 'o' in 'second'
-            mockBuffer.visualToLogicalMap = [
-                [0, 0],
-                [1, 0],
-                [2, 0],
-            ];
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            const frame = stdout.lastFrame();
-            expect(frame).toContain(`sec${chalk.inverse('o')}nd line`);
-            unmount();
-        });
-        it('should display cursor at the beginning of a line in a multiline block', async () => {
-            const text = 'first line\nsecond line';
-            mockBuffer.text = text;
-            mockBuffer.lines = text.split('\n');
-            mockBuffer.viewportVisualLines = text.split('\n');
-            mockBuffer.visualCursor = [1, 0]; // cursor on 's' in 'second'
-            mockBuffer.visualToLogicalMap = [
-                [0, 0],
-                [1, 0],
-            ];
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            const frame = stdout.lastFrame();
-            expect(frame).toContain(`${chalk.inverse('s')}econd line`);
-            unmount();
-        });
-        it('should display cursor at the end of a line in a multiline block', async () => {
-            const text = 'first line\nsecond line';
-            mockBuffer.text = text;
-            mockBuffer.lines = text.split('\n');
-            mockBuffer.viewportVisualLines = text.split('\n');
-            mockBuffer.visualCursor = [0, 10]; // cursor after 'first line'
-            mockBuffer.visualToLogicalMap = [
-                [0, 0],
-                [1, 0],
-            ];
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            const frame = stdout.lastFrame();
-            expect(frame).toContain(`first line${chalk.inverse(' ')}`);
-            unmount();
+        describe('single-line scenarios', () => {
+            it.each([
+                {
+                    name: 'mid-word',
+                    text: 'hello world',
+                    visualCursor: [0, 3],
+                    expected: `hel${chalk.inverse('l')}o world`,
+                },
+                {
+                    name: 'at the beginning of the line',
+                    text: 'hello',
+                    visualCursor: [0, 0],
+                    expected: `${chalk.inverse('h')}ello`,
+                },
+                {
+                    name: 'at the end of the line',
+                    text: 'hello',
+                    visualCursor: [0, 5],
+                    expected: `hello${chalk.inverse(' ')}`,
+                },
+                {
+                    name: 'on a highlighted token',
+                    text: 'run @path/to/file',
+                    visualCursor: [0, 9],
+                    expected: `@path/${chalk.inverse('t')}o/file`,
+                },
+                {
+                    name: 'for multi-byte unicode characters',
+                    text: 'hello 👍 world',
+                    visualCursor: [0, 6],
+                    expected: `hello ${chalk.inverse('👍')} world`,
+                },
+                {
+                    name: 'at the end of a line with unicode characters',
+                    text: 'hello 👍',
+                    visualCursor: [0, 8],
+                    expected: `hello 👍${chalk.inverse(' ')}`,
+                },
+                {
+                    name: 'on an empty line',
+                    text: '',
+                    visualCursor: [0, 0],
+                    expected: chalk.inverse(' '),
+                },
+                {
+                    name: 'on a space between words',
+                    text: 'hello world',
+                    visualCursor: [0, 5],
+                    expected: `hello${chalk.inverse(' ')}world`,
+                },
+            ])('should display cursor correctly $name', async ({ text, visualCursor, expected }) => {
+                mockBuffer.text = text;
+                mockBuffer.lines = [text];
+                mockBuffer.viewportVisualLines = [text];
+                mockBuffer.visualCursor = visualCursor;
+                const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
+                await waitFor(() => {
+                    const frame = stdout.lastFrame();
+                    expect(frame).toContain(expected);
+                });
+                unmount();
+            });
         });
-        it('should display cursor on a blank line in a multiline block', async () => {
-            const text = 'first line\n\nthird line';
-            mockBuffer.text = text;
-            mockBuffer.lines = text.split('\n');
-            mockBuffer.viewportVisualLines = text.split('\n');
-            mockBuffer.visualCursor = [1, 0]; // cursor on the blank line
-            mockBuffer.visualToLogicalMap = [
-                [0, 0],
-                [1, 0],
-                [2, 0],
-            ];
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            const frame = stdout.lastFrame();
-            const lines = frame.split('\n');
-            // The line with the cursor should just be an inverted space inside the box border
-            expect(lines.find((l) => l.includes(chalk.inverse(' ')))).not.toBeUndefined();
-            unmount();
+        describe('multi-line scenarios', () => {
+            it.each([
+                {
+                    name: 'in the middle of a line',
+                    text: 'first line\nsecond line\nthird line',
+                    visualCursor: [1, 3],
+                    visualToLogicalMap: [
+                        [0, 0],
+                        [1, 0],
+                        [2, 0],
+                    ],
+                    expected: `sec${chalk.inverse('o')}nd line`,
+                },
+                {
+                    name: 'at the beginning of a line',
+                    text: 'first line\nsecond line',
+                    visualCursor: [1, 0],
+                    visualToLogicalMap: [
+                        [0, 0],
+                        [1, 0],
+                    ],
+                    expected: `${chalk.inverse('s')}econd line`,
+                },
+                {
+                    name: 'at the end of a line',
+                    text: 'first line\nsecond line',
+                    visualCursor: [0, 10],
+                    visualToLogicalMap: [
+                        [0, 0],
+                        [1, 0],
+                    ],
+                    expected: `first line${chalk.inverse(' ')}`,
+                },
+            ])('should display cursor correctly $name in a multiline block', async ({ text, visualCursor, expected, visualToLogicalMap }) => {
+                mockBuffer.text = text;
+                mockBuffer.lines = text.split('\n');
+                mockBuffer.viewportVisualLines = text.split('\n');
+                mockBuffer.visualCursor = visualCursor;
+                mockBuffer.visualToLogicalMap = visualToLogicalMap;
+                const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
+                await waitFor(() => {
+                    const frame = stdout.lastFrame();
+                    expect(frame).toContain(expected);
+                });
+                unmount();
+            });
+            it('should display cursor on a blank line in a multiline block', async () => {
+                const text = 'first line\n\nthird line';
+                mockBuffer.text = text;
+                mockBuffer.lines = text.split('\n');
+                mockBuffer.viewportVisualLines = text.split('\n');
+                mockBuffer.visualCursor = [1, 0]; // cursor on the blank line
+                mockBuffer.visualToLogicalMap = [
+                    [0, 0],
+                    [1, 0],
+                    [2, 0],
+                ];
+                const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
+                await waitFor(() => {
+                    const frame = stdout.lastFrame();
+                    const lines = frame.split('\n');
+                    // The line with the cursor should just be an inverted space inside the box border
+                    expect(lines.find((l) => l.includes(chalk.inverse(' ')))).not.toBeUndefined();
+                });
+                unmount();
+            });
         });
     });
     describe('multiline rendering', () => {
@@ -1052,15 +958,16 @@ describe('InputPrompt', () => {
                 [2, 0], // 'world' is logical line 2, col 0
             ];
             const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            const frame = stdout.lastFrame();
-            // Check that all lines, including the empty one, are rendered.
-            // This implicitly tests that the Box wrapper provides height for the empty line.
-            expect(frame).toContain('hello');
-            expect(frame).toContain(`world${chalk.inverse(' ')}`);
-            const outputLines = frame.split('\n');
-            // The number of lines should be 2 for the border plus 3 for the content.
-            expect(outputLines.length).toBe(5);
+            await waitFor(() => {
+                const frame = stdout.lastFrame();
+                // Check that all lines, including the empty one, are rendered.
+                // This implicitly tests that the Box wrapper provides height for the empty line.
+                expect(frame).toContain('hello');
+                expect(frame).toContain(`world${chalk.inverse(' ')}`);
+                const outputLines = frame.split('\n');
+                // The number of lines should be 2 for the border plus 3 for the content.
+                expect(outputLines.length).toBe(5);
+            });
             unmount();
         });
     });
@@ -1080,16 +987,18 @@ describe('InputPrompt', () => {
             },
         ])('should handle multiline paste $description', async ({ pastedText }) => {
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
             // Simulate a bracketed paste event from the terminal
-            stdin.write(`\x1b[200~${pastedText}\x1b[201~`);
-            await wait();
-            // Verify that the buffer's handleInput was called once with the full text
-            expect(props.buffer.handleInput).toHaveBeenCalledTimes(1);
-            expect(props.buffer.handleInput).toHaveBeenCalledWith(expect.objectContaining({
-                paste: true,
-                sequence: pastedText,
-            }));
+            await act(async () => {
+                stdin.write(`\x1b[200~${pastedText}\x1b[201~`);
+            });
+            await waitFor(() => {
+                // Verify that the buffer's handleInput was called once with the full text
+                expect(props.buffer.handleInput).toHaveBeenCalledTimes(1);
+                expect(props.buffer.handleInput).toHaveBeenCalledWith(expect.objectContaining({
+                    paste: true,
+                    sequence: pastedText,
+                }));
+            });
             unmount();
         });
     });
@@ -1109,13 +1018,20 @@ describe('InputPrompt', () => {
             // isTerminalPasteTrusted will be false due to beforeEach setup.
             props.buffer.text = 'some command';
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await vi.runAllTimersAsync();
+            await act(async () => {
+                await vi.runAllTimersAsync();
+            });
             // Simulate a paste operation (this should set the paste protection)
-            stdin.write(`\x1b[200~pasted content\x1b[201~`);
-            await vi.runAllTimersAsync();
+            await act(async () => {
+                stdin.write(`\x1b[200~pasted content\x1b[201~`);
+            });
             // Simulate an Enter key press immediately after paste
-            stdin.write('\r');
-            await vi.runAllTimersAsync();
+            await act(async () => {
+                stdin.write('\r');
+            });
+            await act(async () => {
+                await vi.runAllTimersAsync();
+            });
             // Verify that onSubmit was NOT called due to recent paste protection
             expect(props.onSubmit).not.toHaveBeenCalled();
             // It should call newline() instead
@@ -1126,19 +1042,27 @@ describe('InputPrompt', () => {
             // isTerminalPasteTrusted will be false due to beforeEach setup.
             props.buffer.text = 'pasted text';
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await vi.runAllTimersAsync();
+            await act(async () => {
+                await vi.runAllTimersAsync();
+            });
             // Simulate a paste operation (this sets the protection)
-            act(() => {
+            await act(async () => {
                 stdin.write('\x1b[200~pasted text\x1b[201~');
             });
-            await vi.runAllTimersAsync();
+            await act(async () => {
+                await vi.runAllTimersAsync();
+            });
             // Advance timers past the protection timeout
             await act(async () => {
                 await vi.advanceTimersByTimeAsync(50);
             });
             // Now Enter should work normally
-            stdin.write('\r');
-            await vi.runAllTimersAsync();
+            await act(async () => {
+                stdin.write('\r');
+            });
+            await act(async () => {
+                await vi.runAllTimersAsync();
+            });
             expect(props.onSubmit).toHaveBeenCalledWith('pasted text');
             expect(props.buffer.newline).not.toHaveBeenCalled();
             unmount();
@@ -1156,13 +1080,23 @@ describe('InputPrompt', () => {
             setup();
             props.buffer.text = 'pasted command';
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { kittyProtocolEnabled: true });
-            await vi.runAllTimersAsync();
+            await act(async () => {
+                await vi.runAllTimersAsync();
+            });
             // Simulate a paste operation
-            stdin.write('\x1b[200~some pasted stuff\x1b[201~');
-            await vi.runAllTimersAsync();
+            await act(async () => {
+                stdin.write('\x1b[200~some pasted stuff\x1b[201~');
+            });
+            await act(async () => {
+                await vi.runAllTimersAsync();
+            });
             // Simulate an Enter key press immediately after paste
-            stdin.write('\r');
-            await vi.runAllTimersAsync();
+            await act(async () => {
+                stdin.write('\r');
+            });
+            await act(async () => {
+                await vi.runAllTimersAsync();
+            });
             // Verify that onSubmit was called
             expect(props.onSubmit).toHaveBeenCalledWith('pasted command');
             unmount();
@@ -1171,10 +1105,16 @@ describe('InputPrompt', () => {
             // Set up buffer with text before rendering to ensure submission works
             props.buffer.text = 'normal command';
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await vi.runAllTimersAsync();
+            await act(async () => {
+                await vi.runAllTimersAsync();
+            });
             // Press Enter without any recent paste
-            stdin.write('\r');
-            await vi.runAllTimersAsync();
+            await act(async () => {
+                stdin.write('\r');
+            });
+            await act(async () => {
+                await vi.runAllTimersAsync();
+            });
             // Verify that onSubmit was called normally
             expect(props.onSubmit).toHaveBeenCalledWith('normal command');
             unmount();
@@ -1186,13 +1126,19 @@ describe('InputPrompt', () => {
             props.onEscapePromptChange = onEscapePromptChange;
             props.buffer.setText('text to clear');
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { kittyProtocolEnabled: false });
-            await wait();
-            stdin.write('\x1B');
-            await wait();
-            stdin.write('\x1B');
-            await wait();
-            expect(props.buffer.setText).toHaveBeenCalledWith('');
-            expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
+            await act(async () => {
+                stdin.write('\x1B');
+                await waitFor(() => {
+                    expect(onEscapePromptChange).toHaveBeenCalledWith(false);
+                });
+            });
+            await act(async () => {
+                stdin.write('\x1B');
+                await waitFor(() => {
+                    expect(props.buffer.setText).toHaveBeenCalledWith('');
+                    expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
+                });
+            });
             unmount();
         });
         it('should reset escape state on any non-ESC key', async () => {
@@ -1200,23 +1146,27 @@ describe('InputPrompt', () => {
             props.onEscapePromptChange = onEscapePromptChange;
             props.buffer.setText('some text');
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { kittyProtocolEnabled: false });
-            stdin.write('\x1B');
-            await waitFor(() => {
-                expect(onEscapePromptChange).toHaveBeenCalledWith(true);
+            await act(async () => {
+                stdin.write('\x1B');
+                await waitFor(() => {
+                    expect(onEscapePromptChange).toHaveBeenCalledWith(false);
+                });
             });
-            stdin.write('a');
-            await waitFor(() => {
-                expect(onEscapePromptChange).toHaveBeenCalledWith(false);
+            await act(async () => {
+                stdin.write('a');
+                await waitFor(() => {
+                    expect(onEscapePromptChange).toHaveBeenCalledWith(false);
+                });
             });
             unmount();
         });
         it('should handle ESC in shell mode by disabling shell mode', async () => {
             props.shellModeActive = true;
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { kittyProtocolEnabled: false });
-            await wait();
-            stdin.write('\x1B');
-            await wait();
-            expect(props.setShellModeActive).toHaveBeenCalledWith(false);
+            await act(async () => {
+                stdin.write('\x1B');
+                await waitFor(() => expect(props.setShellModeActive).toHaveBeenCalledWith(false));
+            });
             unmount();
         });
         it('should handle ESC when completion suggestions are showing', async () => {
@@ -1226,10 +1176,10 @@ describe('InputPrompt', () => {
                 suggestions: [{ label: 'suggestion', value: 'suggestion' }],
             });
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { kittyProtocolEnabled: false });
-            await wait();
-            stdin.write('\x1B');
-            await wait();
-            expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
+            await act(async () => {
+                stdin.write('\x1B');
+            });
+            await waitFor(() => expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled());
             unmount();
         });
         it('should not call onEscapePromptChange when not provided', async () => {
@@ -1237,21 +1187,28 @@ describe('InputPrompt', () => {
             props.onEscapePromptChange = undefined;
             props.buffer.setText('some text');
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { kittyProtocolEnabled: false });
-            await vi.runAllTimersAsync();
-            stdin.write('\x1B');
-            await vi.runAllTimersAsync();
+            await act(async () => {
+                await vi.runAllTimersAsync();
+            });
+            await act(async () => {
+                stdin.write('\x1B');
+            });
+            await act(async () => {
+                await vi.runAllTimersAsync();
+            });
             vi.useRealTimers();
             unmount();
         });
         it('should not interfere with existing keyboard shortcuts', async () => {
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { kittyProtocolEnabled: false });
-            await wait();
-            stdin.write('\x0C');
-            await wait();
-            expect(props.onClearScreen).toHaveBeenCalled();
-            stdin.write('\x01');
-            await wait();
-            expect(props.buffer.move).toHaveBeenCalledWith('home');
+            await act(async () => {
+                stdin.write('\x0C');
+            });
+            await waitFor(() => expect(props.onClearScreen).toHaveBeenCalled());
+            await act(async () => {
+                stdin.write('\x01');
+            });
+            await waitFor(() => expect(props.buffer.move).toHaveBeenCalledWith('home'));
             unmount();
         });
     });
@@ -1279,9 +1236,8 @@ describe('InputPrompt', () => {
                 activeSuggestionIndex: 0,
             });
             const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
             // Trigger reverse search with Ctrl+R
-            act(() => {
+            await act(async () => {
                 stdin.write('\x12');
             });
             await waitFor(() => {
@@ -1293,17 +1249,29 @@ describe('InputPrompt', () => {
             });
             unmount();
         });
-        it('resets reverse search state on Escape', async () => {
-            const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('\x12');
-            await wait();
-            stdin.write('\x1B');
-            stdin.write('\u001b[27u'); // Press kitty escape key
+        it.each([
+            { name: 'standard', kittyProtocolEnabled: false, escapeSequence: '\x1B' },
+            {
+                name: 'kitty',
+                kittyProtocolEnabled: true,
+                escapeSequence: '\u001b[27u',
+            },
+        ])('resets reverse search state on Escape ($name)', async ({ kittyProtocolEnabled, escapeSequence }) => {
+            const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { kittyProtocolEnabled });
+            await act(async () => {
+                stdin.write('\x12');
+            });
+            // Wait for reverse search to be active
+            await waitFor(() => {
+                expect(stdout.lastFrame()).toContain('(r:)');
+            });
+            await act(async () => {
+                stdin.write(escapeSequence);
+            });
             await waitFor(() => {
                 expect(stdout.lastFrame()).not.toContain('(r:)');
+                expect(stdout.lastFrame()).not.toContain('echo hello');
             });
-            expect(stdout.lastFrame()).not.toContain('echo hello');
             unmount();
         });
         it('completes the highlighted entry on Tab and exits reverse-search', async () => {
@@ -1326,7 +1294,7 @@ describe('InputPrompt', () => {
             }));
             const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
             // Enter reverse search mode with Ctrl+R
-            act(() => {
+            await act(async () => {
                 stdin.write('\x12');
             });
             // Verify reverse search is active
@@ -1334,12 +1302,13 @@ describe('InputPrompt', () => {
                 expect(stdout.lastFrame()).toContain('(r:)');
             });
             // Press Tab to complete the highlighted entry
-            act(() => {
+            await act(async () => {
                 stdin.write('\t');
             });
-            await wait();
-            expect(mockHandleAutocomplete).toHaveBeenCalledWith(0);
-            expect(props.buffer.setText).toHaveBeenCalledWith('echo hello');
+            await waitFor(() => {
+                expect(mockHandleAutocomplete).toHaveBeenCalledWith(0);
+                expect(props.buffer.setText).toHaveBeenCalledWith('echo hello');
+            });
             unmount();
         }, 15000);
         it('submits the highlighted entry on Enter and exits reverse-search', async () => {
@@ -1355,13 +1324,13 @@ describe('InputPrompt', () => {
                 activeSuggestionIndex: 0,
             });
             const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            act(() => {
+            await act(async () => {
                 stdin.write('\x12');
             });
             await waitFor(() => {
                 expect(stdout.lastFrame()).toContain('(r:)');
             });
-            act(() => {
+            await act(async () => {
                 stdin.write('\r');
             });
             await waitFor(() => {
@@ -1384,16 +1353,15 @@ describe('InputPrompt', () => {
                 showSuggestions: reverseSearchActiveFromInputPrompt,
             }));
             const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
             // reverse search with Ctrl+R
-            act(() => {
+            await act(async () => {
                 stdin.write('\x12');
             });
             await waitFor(() => {
                 expect(stdout.lastFrame()).toContain('(r:)');
             });
             // Press kitty escape key
-            act(() => {
+            await act(async () => {
                 stdin.write('\u001b[27u');
             });
             await waitFor(() => {
@@ -1410,10 +1378,12 @@ describe('InputPrompt', () => {
             props.buffer.cursor = [1, 2];
             props.buffer.lines = ['line 1', 'line 2', 'line 3'];
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('\x05'); // Ctrl+E
-            await wait();
-            expect(props.buffer.move).toHaveBeenCalledWith('end');
+            await act(async () => {
+                stdin.write('\x05'); // Ctrl+E
+            });
+            await waitFor(() => {
+                expect(props.buffer.move).toHaveBeenCalledWith('end');
+            });
             expect(props.buffer.moveToOffset).not.toHaveBeenCalled();
             unmount();
         });
@@ -1422,10 +1392,12 @@ describe('InputPrompt', () => {
             props.buffer.cursor = [0, 5];
             props.buffer.lines = ['single line text'];
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('\x05'); // Ctrl+E
-            await wait();
-            expect(props.buffer.move).toHaveBeenCalledWith('end');
+            await act(async () => {
+                stdin.write('\x05'); // Ctrl+E
+            });
+            await waitFor(() => {
+                expect(props.buffer.move).toHaveBeenCalledWith('end');
+            });
             expect(props.buffer.moveToOffset).not.toHaveBeenCalled();
             unmount();
         });
@@ -1445,18 +1417,18 @@ describe('InputPrompt', () => {
                 activeSuggestionIndex: isActive ? 0 : -1,
             }));
             const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            act(() => {
+            await act(async () => {
                 stdin.write('\x12'); // Ctrl+R
             });
-            await wait();
-            const frame = stdout.lastFrame() ?? '';
-            expect(frame).toContain('(r:)');
-            expect(frame).toContain('git commit');
-            expect(frame).toContain('git push');
+            await waitFor(() => {
+                const frame = stdout.lastFrame() ?? '';
+                expect(frame).toContain('(r:)');
+                expect(frame).toContain('git commit');
+                expect(frame).toContain('git push');
+            });
             unmount();
         });
-        it.skip('expands and collapses long suggestion via Right/Left arrows', async () => {
+        it('expands and collapses long suggestion via Right/Left arrows', async () => {
             props.shellModeActive = false;
             const longValue = 'l'.repeat(200);
             vi.mocked(useReverseSearchCompletion).mockReturnValue({
@@ -1468,18 +1440,26 @@ describe('InputPrompt', () => {
                 isLoadingSuggestions: false,
             });
             const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('\x12');
-            await wait();
-            expect(clean(stdout.lastFrame())).toContain('→');
-            stdin.write('\u001B[C');
-            await wait(200);
-            expect(clean(stdout.lastFrame())).toContain('←');
-            expect(stdout.lastFrame()).toMatchSnapshot('command-search-expanded-match');
-            stdin.write('\u001B[D');
-            await wait();
-            expect(clean(stdout.lastFrame())).toContain('→');
-            expect(stdout.lastFrame()).toMatchSnapshot('command-search-collapsed-match');
+            await act(async () => {
+                stdin.write('\x12');
+            });
+            await waitFor(() => {
+                expect(clean(stdout.lastFrame())).toContain('→');
+            });
+            await act(async () => {
+                stdin.write('\u001B[C');
+            });
+            await waitFor(() => {
+                expect(clean(stdout.lastFrame())).toContain('←');
+            });
+            expect(stdout.lastFrame()).toMatchSnapshot('command-search-render-expanded-match');
+            await act(async () => {
+                stdin.write('\u001B[D');
+            });
+            await waitFor(() => {
+                expect(clean(stdout.lastFrame())).toContain('→');
+            });
+            expect(stdout.lastFrame()).toMatchSnapshot('command-search-render-collapsed-match');
             unmount();
         });
         it('renders match window and expanded view (snapshots)', async () => {
@@ -1496,13 +1476,18 @@ describe('InputPrompt', () => {
                 isLoadingSuggestions: false,
             });
             const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('\x12');
-            await wait();
-            expect(stdout.lastFrame()).toMatchSnapshot('command-search-collapsed-match');
-            stdin.write('\u001B[C');
-            await wait();
-            expect(stdout.lastFrame()).toMatchSnapshot('command-search-expanded-match');
+            await act(async () => {
+                stdin.write('\x12');
+            });
+            await waitFor(() => {
+                expect(stdout.lastFrame()).toMatchSnapshot('command-search-render-collapsed-match');
+            });
+            await act(async () => {
+                stdin.write('\u001B[C');
+            });
+            await waitFor(() => {
+                expect(stdout.lastFrame()).toMatchSnapshot('command-search-render-expanded-match');
+            });
             unmount();
         });
         it('does not show expand/collapse indicator for short suggestions', async () => {
@@ -1517,12 +1502,72 @@ describe('InputPrompt', () => {
                 isLoadingSuggestions: false,
             });
             const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('\x12');
-            await wait();
-            const frame = clean(stdout.lastFrame());
-            expect(frame).not.toContain('→');
-            expect(frame).not.toContain('←');
+            await act(async () => {
+                stdin.write('\x12');
+            });
+            await waitFor(() => {
+                const frame = clean(stdout.lastFrame());
+                // Ensure it rendered the search mode
+                expect(frame).toContain('(r:)');
+                expect(frame).not.toContain('→');
+                expect(frame).not.toContain('←');
+            });
+            unmount();
+        });
+    });
+    describe('mouse interaction', () => {
+        it.each([
+            {
+                name: 'first line, first char',
+                relX: 0,
+                relY: 0,
+                mouseCol: 5,
+                mouseRow: 2,
+            },
+            {
+                name: 'first line, middle char',
+                relX: 6,
+                relY: 0,
+                mouseCol: 11,
+                mouseRow: 2,
+            },
+            {
+                name: 'second line, first char',
+                relX: 0,
+                relY: 1,
+                mouseCol: 5,
+                mouseRow: 3,
+            },
+            {
+                name: 'second line, end char',
+                relX: 5,
+                relY: 1,
+                mouseCol: 10,
+                mouseRow: 3,
+            },
+        ])('should move cursor on mouse click - $name', async ({ relX, relY, mouseCol, mouseRow }) => {
+            props.buffer.text = 'hello world\nsecond line';
+            props.buffer.lines = ['hello world', 'second line'];
+            props.buffer.viewportVisualLines = ['hello world', 'second line'];
+            props.buffer.visualToLogicalMap = [
+                [0, 0],
+                [1, 0],
+            ];
+            props.buffer.visualCursor = [0, 11];
+            props.buffer.visualScrollRow = 0;
+            const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { mouseEventsEnabled: true });
+            // Wait for initial render
+            await waitFor(() => {
+                expect(stdout.lastFrame()).toContain('hello world');
+            });
+            // Simulate left mouse press at calculated coordinates.
+            // Assumes inner box is at x=4, y=1 based on border(1)+padding(1)+prompt(2) and border-top(1).
+            await act(async () => {
+                stdin.write(`\x1b[<0;${mouseCol};${mouseRow}M`);
+            });
+            await waitFor(() => {
+                expect(props.buffer.moveToVisualPosition).toHaveBeenCalledWith(relY, relX);
+            });
             unmount();
         });
     });
@@ -1532,12 +1577,12 @@ describe('InputPrompt', () => {
             props.popAllMessages = mockPopAllMessages;
             props.buffer.text = '';
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('\u001B[A');
-            await wait();
-            expect(mockPopAllMessages).toHaveBeenCalled();
+            await act(async () => {
+                stdin.write('\u001B[A');
+            });
+            await waitFor(() => expect(mockPopAllMessages).toHaveBeenCalled());
             const callback = mockPopAllMessages.mock.calls[0][0];
-            act(() => {
+            await act(async () => {
                 callback('Message 1\n\nMessage 2\n\nMessage 3');
             });
             expect(props.buffer.setText).toHaveBeenCalledWith('Message 1\n\nMessage 2\n\nMessage 3');
@@ -1548,11 +1593,11 @@ describe('InputPrompt', () => {
             props.popAllMessages = mockPopAllMessages;
             props.buffer.text = 'some text';
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('\u001B[A');
-            await wait();
+            await act(async () => {
+                stdin.write('\u001B[A');
+            });
+            await waitFor(() => expect(mockInputHistory.navigateUp).toHaveBeenCalled());
             expect(mockPopAllMessages).not.toHaveBeenCalled();
-            expect(mockInputHistory.navigateUp).toHaveBeenCalled();
             unmount();
         });
         it('should handle undefined messages from popAllMessages', async () => {
@@ -1560,12 +1605,12 @@ describe('InputPrompt', () => {
             props.popAllMessages = mockPopAllMessages;
             props.buffer.text = '';
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('\u001B[A');
-            await wait();
-            expect(mockPopAllMessages).toHaveBeenCalled();
+            await act(async () => {
+                stdin.write('\u001B[A');
+            });
+            await waitFor(() => expect(mockPopAllMessages).toHaveBeenCalled());
             const callback = mockPopAllMessages.mock.calls[0][0];
-            act(() => {
+            await act(async () => {
                 callback(undefined);
             });
             expect(props.buffer.setText).not.toHaveBeenCalled();
@@ -1580,10 +1625,10 @@ describe('InputPrompt', () => {
             props.buffer.visualCursor = [0, 0];
             props.buffer.visualScrollRow = 0;
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('\u001B[A');
-            await wait();
-            expect(mockPopAllMessages).toHaveBeenCalled();
+            await act(async () => {
+                stdin.write('\u001B[A');
+            });
+            await waitFor(() => expect(mockPopAllMessages).toHaveBeenCalled());
             unmount();
         });
         it('should handle single queued message', async () => {
@@ -1591,11 +1636,12 @@ describe('InputPrompt', () => {
             props.popAllMessages = mockPopAllMessages;
             props.buffer.text = '';
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('\u001B[A');
-            await wait();
+            await act(async () => {
+                stdin.write('\u001B[A');
+            });
+            await waitFor(() => expect(mockPopAllMessages).toHaveBeenCalled());
             const callback = mockPopAllMessages.mock.calls[0][0];
-            act(() => {
+            await act(async () => {
                 callback('Single message');
             });
             expect(props.buffer.setText).toHaveBeenCalledWith('Single message');
@@ -1606,20 +1652,20 @@ describe('InputPrompt', () => {
             props.popAllMessages = mockPopAllMessages;
             props.buffer.text = '   '; // Whitespace only
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('\u001B[A');
-            await wait();
-            expect(mockPopAllMessages).toHaveBeenCalled();
+            await act(async () => {
+                stdin.write('\u001B[A');
+            });
+            await waitFor(() => expect(mockPopAllMessages).toHaveBeenCalled());
             unmount();
         });
         it('should not call popAllMessages if it is not provided', async () => {
             props.popAllMessages = undefined;
             props.buffer.text = '';
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('\u001B[A');
-            await wait();
-            expect(mockInputHistory.navigateUp).toHaveBeenCalled();
+            await act(async () => {
+                stdin.write('\u001B[A');
+            });
+            await waitFor(() => expect(mockInputHistory.navigateUp).toHaveBeenCalled());
             unmount();
         });
         it('should navigate input history on fresh start when no queued messages exist', async () => {
@@ -1627,12 +1673,12 @@ describe('InputPrompt', () => {
             props.popAllMessages = mockPopAllMessages;
             props.buffer.text = '';
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            stdin.write('\u001B[A');
-            await wait();
-            expect(mockPopAllMessages).toHaveBeenCalled();
+            await act(async () => {
+                stdin.write('\u001B[A');
+            });
+            await waitFor(() => expect(mockPopAllMessages).toHaveBeenCalled());
             const callback = mockPopAllMessages.mock.calls[0][0];
-            act(() => {
+            await act(async () => {
                 callback(undefined);
             });
             expect(mockInputHistory.navigateUp).toHaveBeenCalled();
@@ -1644,33 +1690,31 @@ describe('InputPrompt', () => {
         it('should render correctly in shell mode', async () => {
             props.shellModeActive = true;
             const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            expect(stdout.lastFrame()).toMatchSnapshot();
+            await waitFor(() => expect(stdout.lastFrame()).toMatchSnapshot());
             unmount();
         });
         it('should render correctly when accepting edits', async () => {
             props.approvalMode = ApprovalMode.AUTO_EDIT;
             const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            expect(stdout.lastFrame()).toMatchSnapshot();
+            await waitFor(() => expect(stdout.lastFrame()).toMatchSnapshot());
             unmount();
         });
         it('should render correctly in yolo mode', async () => {
             props.approvalMode = ApprovalMode.YOLO;
             const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            expect(stdout.lastFrame()).toMatchSnapshot();
+            await waitFor(() => expect(stdout.lastFrame()).toMatchSnapshot());
             unmount();
         });
         it('should not show inverted cursor when shell is focused', async () => {
             props.isEmbeddedShellFocused = true;
             props.focus = false;
             const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await wait();
-            expect(stdout.lastFrame()).not.toContain(`{chalk.inverse(' ')}`);
-            // This snapshot is good to make sure there was an input prompt but does
-            // not show the inverted cursor because snapshots do not show colors.
-            expect(stdout.lastFrame()).toMatchSnapshot();
+            await waitFor(() => {
+                expect(stdout.lastFrame()).not.toContain(`{chalk.inverse(' ')}`);
+                // This snapshot is good to make sure there was an input prompt but does
+                // not show the inverted cursor because snapshots do not show colors.
+                expect(stdout.lastFrame()).toMatchSnapshot();
+            });
             unmount();
         });
     });
@@ -1678,54 +1722,59 @@ describe('InputPrompt', () => {
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
             shellFocus: false,
         });
-        await wait();
-        stdin.write('a');
-        await wait();
-        expect(mockBuffer.handleInput).toHaveBeenCalled();
-        unmount();
-    });
-    it('should prevent slash commands from being queued while streaming', async () => {
-        props.onSubmit = vi.fn();
-        props.buffer.text = '/help';
-        props.setQueueErrorMessage = vi.fn();
-        props.streamingState = StreamingState.Responding;
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('/help');
-        stdin.write('\r');
-        await wait();
-        expect(props.onSubmit).not.toHaveBeenCalled();
-        expect(props.setQueueErrorMessage).toHaveBeenCalledWith('Slash commands cannot be queued');
-        unmount();
-    });
-    it('should prevent shell commands from being queued while streaming', async () => {
-        props.onSubmit = vi.fn();
-        props.buffer.text = 'ls';
-        props.setQueueErrorMessage = vi.fn();
-        props.streamingState = StreamingState.Responding;
-        props.shellModeActive = true;
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('ls');
-        stdin.write('\r');
-        await wait();
-        expect(props.onSubmit).not.toHaveBeenCalled();
-        expect(props.setQueueErrorMessage).toHaveBeenCalledWith('Shell commands cannot be queued');
+        await act(async () => {
+            stdin.write('a');
+        });
+        await waitFor(() => expect(mockBuffer.handleInput).toHaveBeenCalled());
         unmount();
     });
-    it('should allow regular messages to be queued while streaming', async () => {
-        props.onSubmit = vi.fn();
-        props.buffer.text = 'regular message';
-        props.setQueueErrorMessage = vi.fn();
-        props.streamingState = StreamingState.Responding;
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await wait();
-        stdin.write('regular message');
-        stdin.write('\r');
-        await wait();
-        expect(props.onSubmit).toHaveBeenCalledWith('regular message');
-        expect(props.setQueueErrorMessage).not.toHaveBeenCalled();
-        unmount();
+    describe('command queuing while streaming', () => {
+        beforeEach(() => {
+            props.streamingState = StreamingState.Responding;
+            props.setQueueErrorMessage = vi.fn();
+            props.onSubmit = vi.fn();
+        });
+        it.each([
+            {
+                name: 'should prevent slash commands',
+                bufferText: '/help',
+                shellMode: false,
+                shouldSubmit: false,
+                errorMessage: 'Slash commands cannot be queued',
+            },
+            {
+                name: 'should prevent shell commands',
+                bufferText: 'ls',
+                shellMode: true,
+                shouldSubmit: false,
+                errorMessage: 'Shell commands cannot be queued',
+            },
+            {
+                name: 'should allow regular messages',
+                bufferText: 'regular message',
+                shellMode: false,
+                shouldSubmit: true,
+                errorMessage: null,
+            },
+        ])('$name', async ({ bufferText, shellMode, shouldSubmit, errorMessage }) => {
+            props.buffer.text = bufferText;
+            props.shellModeActive = shellMode;
+            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
+            await act(async () => {
+                stdin.write('\r');
+            });
+            await waitFor(() => {
+                if (shouldSubmit) {
+                    expect(props.onSubmit).toHaveBeenCalledWith(bufferText);
+                    expect(props.setQueueErrorMessage).not.toHaveBeenCalled();
+                }
+                else {
+                    expect(props.onSubmit).not.toHaveBeenCalled();
+                    expect(props.setQueueErrorMessage).toHaveBeenCalledWith(errorMessage);
+                }
+            });
+            unmount();
+        });
     });
 });
 function clean(str) {