ink-prompt 0.1.2

package/dist/components/MultilineInput/TextRenderer.js

@@ -0,0 +1,80 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+/**
+ * Wrap buffer lines to fit within a given width.
+ * Returns visual lines and maps cursor position to visual coordinates.
+ */
+export function wrapLines(buffer, cursor, width) {
+    const visualLines = [];
+    let cursorVisualRow = 0;
+    let cursorVisualCol = 0;
+    let visualRowIndex = 0;
+    for (let lineIndex = 0; lineIndex < buffer.lines.length; lineIndex++) {
+        const line = buffer.lines[lineIndex];
+        const isCursorLine = lineIndex === cursor.line;
+        if (line.length <= width) {
+            // Line fits, no wrapping needed
+            visualLines.push(line);
+            if (isCursorLine) {
+                cursorVisualRow = visualRowIndex;
+                cursorVisualCol = cursor.column;
+            }
+            visualRowIndex++;
+        }
+        else {
+            // Line needs to be wrapped
+            let offset = 0;
+            while (offset < line.length) {
+                const chunk = line.slice(offset, offset + width);
+                visualLines.push(chunk);
+                if (isCursorLine) {
+                    // Check if cursor falls within this chunk
+                    if (cursor.column >= offset && cursor.column < offset + width) {
+                        cursorVisualRow = visualRowIndex;
+                        cursorVisualCol = cursor.column - offset;
+                    }
+                    else if (cursor.column === line.length && offset + chunk.length === line.length) {
+                        // Cursor at end of line
+                        cursorVisualRow = visualRowIndex;
+                        cursorVisualCol = chunk.length;
+                    }
+                }
+                offset += width;
+                visualRowIndex++;
+            }
+        }
+    }
+    return { visualLines, cursorVisualRow, cursorVisualCol };
+}
+/**
+ * Render a line with cursor inserted at the specified position
+ */
+function renderLineWithCursor(line, cursorCol, showCursor) {
+    if (!showCursor) {
+        // Empty lines need a space to be rendered by Ink
+        return _jsx(Text, { children: line || ' ' });
+    }
+    // For empty lines with cursor, we need special handling
+    if (line.length === 0) {
+        return _jsx(Text, { inverse: true, children: " " });
+    }
+    const before = line.slice(0, cursorCol);
+    const charUnderCursor = cursorCol < line.length ? line[cursorCol] : ' ';
+    const after = line.slice(cursorCol + 1);
+    // Render the cursor using Ink's Text with inverse colors for high visibility.
+    // We show the actual character under the cursor (or a space at line end)
+    // with inverted colors to make it stand out in any terminal color scheme.
+    return (_jsxs(_Fragment, { children: [_jsx(Text, { children: before }), _jsx(Text, { inverse: true, children: charUnderCursor }), _jsx(Text, { children: after })] }));
+}
+/**
+ * TextRenderer component for displaying buffer content with cursor
+ */
+export function TextRenderer({ buffer, cursor, width = 80, showCursor = true, }) {
+    const { visualLines, cursorVisualRow, cursorVisualCol } = wrapLines(buffer, cursor, width);
+    return (_jsx(Box, { flexDirection: "column", children: visualLines.map((line, index) => {
+            const isCursorRow = index === cursorVisualRow;
+            return (_jsx(Box, { children: isCursorRow ? (
+                // renderLineWithCursor returns a ReactNode composed of Text
+                renderLineWithCursor(line, cursorVisualCol, showCursor)) : (_jsx(Text, { children: line || ' ' })) }, index));
+        }) }));
+}

package/dist/components/MultilineInput/__tests__/KeyHandler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/MultilineInput/__tests__/KeyHandler.test.js

@@ -0,0 +1,124 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { handleKey } from '../KeyHandler.js';
+describe('KeyHandler', () => {
+    let actions;
+    let buffer;
+    beforeEach(() => {
+        actions = {
+            insert: vi.fn(),
+            delete: vi.fn(),
+            deleteForward: vi.fn(),
+            newLine: vi.fn(),
+            deleteAndNewLine: vi.fn(),
+            moveCursor: vi.fn(),
+            undo: vi.fn(),
+            redo: vi.fn(),
+            setText: vi.fn(),
+            submit: vi.fn(),
+        };
+        buffer = { lines: [''] };
+    });
+    describe('Navigation', () => {
+        it('handles ArrowUp', () => {
+            handleKey({ upArrow: true }, 'up', buffer, actions);
+            expect(actions.moveCursor).toHaveBeenCalledWith('up');
+        });
+        it('handles ArrowDown', () => {
+            handleKey({ downArrow: true }, 'down', buffer, actions);
+            expect(actions.moveCursor).toHaveBeenCalledWith('down');
+        });
+        it('handles ArrowLeft', () => {
+            handleKey({ leftArrow: true }, 'left', buffer, actions);
+            expect(actions.moveCursor).toHaveBeenCalledWith('left');
+        });
+        it('handles ArrowRight', () => {
+            handleKey({ rightArrow: true }, 'right', buffer, actions);
+            expect(actions.moveCursor).toHaveBeenCalledWith('right');
+        });
+        it('handles Home key via escape sequence', () => {
+            // Home key comes as escape sequence, not key.home
+            handleKey({}, '', buffer, actions, undefined, '\x1b[H');
+            expect(actions.moveCursor).toHaveBeenCalledWith('lineStart');
+        });
+        it('handles Home key via alternative escape sequence', () => {
+            handleKey({}, '', buffer, actions, undefined, '\x1bOH');
+            expect(actions.moveCursor).toHaveBeenCalledWith('lineStart');
+        });
+        it('handles Ctrl+A as Home alternative', () => {
+            handleKey({ ctrl: true }, 'a', buffer, actions);
+            expect(actions.moveCursor).toHaveBeenCalledWith('lineStart');
+        });
+        it('handles End key via escape sequence', () => {
+            // End key comes as escape sequence, not key.end
+            handleKey({}, '', buffer, actions, undefined, '\x1b[F');
+            expect(actions.moveCursor).toHaveBeenCalledWith('lineEnd');
+        });
+        it('handles End key via alternative escape sequence', () => {
+            handleKey({}, '', buffer, actions, undefined, '\x1bOF');
+            expect(actions.moveCursor).toHaveBeenCalledWith('lineEnd');
+        });
+        it('handles Ctrl+E as End alternative', () => {
+            handleKey({ ctrl: true }, 'e', buffer, actions);
+            expect(actions.moveCursor).toHaveBeenCalledWith('lineEnd');
+        });
+    });
+    describe('Editing', () => {
+        it('handles Backspace', () => {
+            handleKey({ backspace: true }, 'backspace', buffer, actions);
+            expect(actions.delete).toHaveBeenCalled();
+        });
+        it('handles Delete (forward delete)', () => {
+            handleKey({ delete: true }, '', buffer, actions);
+            expect(actions.deleteForward).toHaveBeenCalled();
+        });
+        it('handles Ctrl+J (NewLine)', () => {
+            handleKey({ ctrl: true }, 'j', buffer, actions);
+            expect(actions.newLine).toHaveBeenCalled();
+        });
+        it('handles regular text insertion', () => {
+            handleKey({}, 'a', buffer, actions);
+            expect(actions.insert).toHaveBeenCalledWith('a');
+        });
+        it('ignores control keys without text', () => {
+            handleKey({ ctrl: true }, '', buffer, actions);
+            expect(actions.insert).not.toHaveBeenCalled();
+        });
+    });
+    describe('History', () => {
+        it('handles Ctrl+Z (Undo)', () => {
+            handleKey({ ctrl: true }, 'z', buffer, actions);
+            expect(actions.undo).toHaveBeenCalled();
+        });
+        it('handles Ctrl+Y (Redo)', () => {
+            handleKey({ ctrl: true }, 'y', buffer, actions);
+            expect(actions.redo).toHaveBeenCalled();
+        });
+    });
+    describe('Submission', () => {
+        it('handles Enter as submit by default', () => {
+            buffer = { lines: ['hello'] };
+            handleKey({ return: true }, 'return', buffer, actions);
+            expect(actions.submit).toHaveBeenCalled();
+            expect(actions.newLine).not.toHaveBeenCalled();
+        });
+        it('handles Enter as newline if line ends with backslash', () => {
+            buffer = { lines: ['hello\\'] };
+            const cursor = { line: 0, column: 6 };
+            handleKey({ return: true }, 'return', buffer, actions, cursor);
+            // It should use the combined deleteAndNewLine action
+            expect(actions.deleteAndNewLine).toHaveBeenCalledTimes(1);
+            expect(actions.delete).not.toHaveBeenCalled();
+            expect(actions.newLine).not.toHaveBeenCalled();
+            expect(actions.submit).not.toHaveBeenCalled();
+        });
+        it('handles Enter as newline if line ends with backslash (multiple lines)', () => {
+            const cursor = { line: 1, column: 7 };
+            buffer = { lines: ['first', 'second\\'] };
+            handleKey({ return: true }, 'return', buffer, actions, cursor);
+            expect(actions.deleteAndNewLine).toHaveBeenCalledTimes(1);
+            expect(actions.delete).not.toHaveBeenCalled();
+            expect(actions.newLine).not.toHaveBeenCalled();
+            expect(actions.submit).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/components/MultilineInput/__tests__/TextBuffer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/MultilineInput/__tests__/TextBuffer.test.js

@@ -0,0 +1,450 @@
+import { describe, it, expect } from 'vitest';
+import { createBuffer, insertText, deleteChar, deleteCharForward, insertNewLine, moveCursor, getTextContent, } from '../TextBuffer.js';
+describe('TextBuffer', () => {
+    describe('createBuffer', () => {
+        it('creates empty buffer with single empty line', () => {
+            const buffer = createBuffer();
+            expect(buffer).toEqual({ lines: [''] });
+        });
+        it('creates buffer from single line text', () => {
+            const buffer = createBuffer('hello');
+            expect(buffer).toEqual({ lines: ['hello'] });
+        });
+        it('creates buffer from multi-line text', () => {
+            const buffer = createBuffer('line1\nline2\nline3');
+            expect(buffer).toEqual({ lines: ['line1', 'line2', 'line3'] });
+        });
+        it('handles text ending with newline', () => {
+            const buffer = createBuffer('hello\n');
+            expect(buffer).toEqual({ lines: ['hello', ''] });
+        });
+    });
+    describe('insertText', () => {
+        it('inserts character into empty buffer', () => {
+            const buffer = createBuffer();
+            const cursor = { line: 0, column: 0 };
+            const result = insertText(buffer, cursor, 'a');
+            expect(result.buffer).toEqual({ lines: ['a'] });
+            expect(result.cursor).toEqual({ line: 0, column: 1 });
+        });
+        it('inserts character at end of line', () => {
+            const buffer = createBuffer('hello');
+            const cursor = { line: 0, column: 5 };
+            const result = insertText(buffer, cursor, '!');
+            expect(result.buffer).toEqual({ lines: ['hello!'] });
+            expect(result.cursor).toEqual({ line: 0, column: 6 });
+        });
+        it('inserts character in middle of line', () => {
+            const buffer = createBuffer('hllo');
+            const cursor = { line: 0, column: 1 };
+            const result = insertText(buffer, cursor, 'e');
+            expect(result.buffer).toEqual({ lines: ['hello'] });
+            expect(result.cursor).toEqual({ line: 0, column: 2 });
+        });
+        it('inserts character at line start', () => {
+            const buffer = createBuffer('ello');
+            const cursor = { line: 0, column: 0 };
+            const result = insertText(buffer, cursor, 'h');
+            expect(result.buffer).toEqual({ lines: ['hello'] });
+            expect(result.cursor).toEqual({ line: 0, column: 1 });
+        });
+        it('inserts into specific line of multi-line buffer', () => {
+            const buffer = createBuffer('line1\nline2\nline3');
+            const cursor = { line: 1, column: 4 };
+            const result = insertText(buffer, cursor, 'X');
+            expect(result.buffer).toEqual({ lines: ['line1', 'lineX2', 'line3'] });
+            expect(result.cursor).toEqual({ line: 1, column: 5 });
+        });
+        describe('multi-character insertion', () => {
+            it('inserts multiple characters at once', () => {
+                const buffer = createBuffer('world');
+                const cursor = { line: 0, column: 0 };
+                const result = insertText(buffer, cursor, 'hello ');
+                expect(result.buffer).toEqual({ lines: ['hello world'] });
+                expect(result.cursor).toEqual({ line: 0, column: 6 });
+            });
+            it('inserts multi-char string in middle of line', () => {
+                const buffer = createBuffer('helloworld');
+                const cursor = { line: 0, column: 5 };
+                const result = insertText(buffer, cursor, ', beautiful ');
+                expect(result.buffer).toEqual({ lines: ['hello, beautiful world'] });
+                expect(result.cursor).toEqual({ line: 0, column: 17 });
+            });
+        });
+        describe('multi-line insertion', () => {
+            it('handles text with single newline', () => {
+                const buffer = createBuffer('');
+                const cursor = { line: 0, column: 0 };
+                const result = insertText(buffer, cursor, 'hello\nworld');
+                expect(result.buffer).toEqual({ lines: ['hello', 'world'] });
+                expect(result.cursor).toEqual({ line: 1, column: 5 });
+            });
+            it('handles text with multiple newlines', () => {
+                const buffer = createBuffer('');
+                const cursor = { line: 0, column: 0 };
+                const result = insertText(buffer, cursor, 'line1\nline2\nline3');
+                expect(result.buffer).toEqual({ lines: ['line1', 'line2', 'line3'] });
+                expect(result.cursor).toEqual({ line: 2, column: 5 });
+            });
+            it('inserts multi-line text in middle of line', () => {
+                const buffer = createBuffer('helloworld');
+                const cursor = { line: 0, column: 5 };
+                const result = insertText(buffer, cursor, '\nthere\n');
+                expect(result.buffer).toEqual({ lines: ['hello', 'there', 'world'] });
+                expect(result.cursor).toEqual({ line: 2, column: 0 });
+            });
+            it('handles paste with trailing content', () => {
+                const buffer = createBuffer('start end');
+                const cursor = { line: 0, column: 6 };
+                const result = insertText(buffer, cursor, 'mid1\nmid2');
+                expect(result.buffer).toEqual({ lines: ['start mid1', 'mid2end'] });
+                expect(result.cursor).toEqual({ line: 1, column: 4 });
+            });
+            it('handles empty lines from consecutive newlines', () => {
+                const buffer = createBuffer('hello');
+                const cursor = { line: 0, column: 5 };
+                const result = insertText(buffer, cursor, '\n\nworld');
+                expect(result.buffer).toEqual({ lines: ['hello', '', 'world'] });
+                expect(result.cursor).toEqual({ line: 2, column: 5 });
+            });
+        });
+    });
+    describe('deleteChar (backspace)', () => {
+        it('does nothing when cursor at buffer start', () => {
+            const buffer = createBuffer('hello');
+            const cursor = { line: 0, column: 0 };
+            const result = deleteChar(buffer, cursor);
+            expect(result.buffer).toEqual({ lines: ['hello'] });
+            expect(result.cursor).toEqual({ line: 0, column: 0 });
+        });
+        it('deletes character before cursor', () => {
+            const buffer = createBuffer('hello');
+            const cursor = { line: 0, column: 5 };
+            const result = deleteChar(buffer, cursor);
+            expect(result.buffer).toEqual({ lines: ['hell'] });
+            expect(result.cursor).toEqual({ line: 0, column: 4 });
+        });
+        it('deletes character in middle of line', () => {
+            const buffer = createBuffer('heello');
+            const cursor = { line: 0, column: 3 };
+            const result = deleteChar(buffer, cursor);
+            expect(result.buffer).toEqual({ lines: ['hello'] });
+            expect(result.cursor).toEqual({ line: 0, column: 2 });
+        });
+        it('merges with previous line when at line start', () => {
+            const buffer = createBuffer('hello\nworld');
+            const cursor = { line: 1, column: 0 };
+            const result = deleteChar(buffer, cursor);
+            expect(result.buffer).toEqual({ lines: ['helloworld'] });
+            expect(result.cursor).toEqual({ line: 0, column: 5 });
+        });
+        it('merges empty line with previous', () => {
+            const buffer = createBuffer('hello\n');
+            const cursor = { line: 1, column: 0 };
+            const result = deleteChar(buffer, cursor);
+            expect(result.buffer).toEqual({ lines: ['hello'] });
+            expect(result.cursor).toEqual({ line: 0, column: 5 });
+        });
+    });
+    describe('deleteCharForward (delete key)', () => {
+        it('does nothing when cursor at buffer end', () => {
+            const buffer = createBuffer('hello');
+            const cursor = { line: 0, column: 5 };
+            const result = deleteCharForward(buffer, cursor);
+            expect(result.buffer).toEqual({ lines: ['hello'] });
+            expect(result.cursor).toEqual({ line: 0, column: 5 });
+        });
+        it('deletes character after cursor', () => {
+            const buffer = createBuffer('hello');
+            const cursor = { line: 0, column: 0 };
+            const result = deleteCharForward(buffer, cursor);
+            expect(result.buffer).toEqual({ lines: ['ello'] });
+            expect(result.cursor).toEqual({ line: 0, column: 0 });
+        });
+        it('deletes character in middle of line', () => {
+            const buffer = createBuffer('heello');
+            const cursor = { line: 0, column: 2 };
+            const result = deleteCharForward(buffer, cursor);
+            expect(result.buffer).toEqual({ lines: ['hello'] });
+            expect(result.cursor).toEqual({ line: 0, column: 2 });
+        });
+        it('merges with next line when at line end', () => {
+            const buffer = createBuffer('hello\nworld');
+            const cursor = { line: 0, column: 5 };
+            const result = deleteCharForward(buffer, cursor);
+            expect(result.buffer).toEqual({ lines: ['helloworld'] });
+            expect(result.cursor).toEqual({ line: 0, column: 5 });
+        });
+        it('merges next empty line with current', () => {
+            const buffer = createBuffer('hello\n');
+            const cursor = { line: 0, column: 5 };
+            const result = deleteCharForward(buffer, cursor);
+            expect(result.buffer).toEqual({ lines: ['hello'] });
+            expect(result.cursor).toEqual({ line: 0, column: 5 });
+        });
+        it('does nothing on last line at end', () => {
+            const buffer = createBuffer('hello\nworld');
+            const cursor = { line: 1, column: 5 };
+            const result = deleteCharForward(buffer, cursor);
+            expect(result.buffer).toEqual({ lines: ['hello', 'world'] });
+            expect(result.cursor).toEqual({ line: 1, column: 5 });
+        });
+    });
+    describe('insertNewLine', () => {
+        it('splits line at cursor position', () => {
+            const buffer = createBuffer('helloworld');
+            const cursor = { line: 0, column: 5 };
+            const result = insertNewLine(buffer, cursor);
+            expect(result.buffer).toEqual({ lines: ['hello', 'world'] });
+            expect(result.cursor).toEqual({ line: 1, column: 0 });
+        });
+        it('creates new line at line start', () => {
+            const buffer = createBuffer('hello');
+            const cursor = { line: 0, column: 0 };
+            const result = insertNewLine(buffer, cursor);
+            expect(result.buffer).toEqual({ lines: ['', 'hello'] });
+            expect(result.cursor).toEqual({ line: 1, column: 0 });
+        });
+        it('creates new line at line end', () => {
+            const buffer = createBuffer('hello');
+            const cursor = { line: 0, column: 5 };
+            const result = insertNewLine(buffer, cursor);
+            expect(result.buffer).toEqual({ lines: ['hello', ''] });
+            expect(result.cursor).toEqual({ line: 1, column: 0 });
+        });
+        it('inserts new line in middle of multi-line buffer', () => {
+            const buffer = createBuffer('line1\nline2\nline3');
+            const cursor = { line: 1, column: 2 };
+            const result = insertNewLine(buffer, cursor);
+            expect(result.buffer).toEqual({ lines: ['line1', 'li', 'ne2', 'line3'] });
+            expect(result.cursor).toEqual({ line: 2, column: 0 });
+        });
+    });
+    describe('moveCursor', () => {
+        describe('left', () => {
+            it('moves left within line', () => {
+                const buffer = createBuffer('hello');
+                const cursor = { line: 0, column: 3 };
+                const result = moveCursor(buffer, cursor, 'left');
+                expect(result).toEqual({ line: 0, column: 2 });
+            });
+            it('wraps to end of previous line', () => {
+                const buffer = createBuffer('hello\nworld');
+                const cursor = { line: 1, column: 0 };
+                const result = moveCursor(buffer, cursor, 'left');
+                expect(result).toEqual({ line: 0, column: 5 });
+            });
+            it('stays at buffer start', () => {
+                const buffer = createBuffer('hello');
+                const cursor = { line: 0, column: 0 };
+                const result = moveCursor(buffer, cursor, 'left');
+                expect(result).toEqual({ line: 0, column: 0 });
+            });
+        });
+        describe('right', () => {
+            it('moves right within line', () => {
+                const buffer = createBuffer('hello');
+                const cursor = { line: 0, column: 2 };
+                const result = moveCursor(buffer, cursor, 'right');
+                expect(result).toEqual({ line: 0, column: 3 });
+            });
+            it('wraps to start of next line', () => {
+                const buffer = createBuffer('hello\nworld');
+                const cursor = { line: 0, column: 5 };
+                const result = moveCursor(buffer, cursor, 'right');
+                expect(result).toEqual({ line: 1, column: 0 });
+            });
+            it('stays at buffer end', () => {
+                const buffer = createBuffer('hello');
+                const cursor = { line: 0, column: 5 };
+                const result = moveCursor(buffer, cursor, 'right');
+                expect(result).toEqual({ line: 0, column: 5 });
+            });
+        });
+        describe('up', () => {
+            it('moves up maintaining column', () => {
+                const buffer = createBuffer('hello\nworld');
+                const cursor = { line: 1, column: 3 };
+                const result = moveCursor(buffer, cursor, 'up');
+                expect(result).toEqual({ line: 0, column: 3 });
+            });
+            it('clamps column to shorter line', () => {
+                const buffer = createBuffer('hi\nhello');
+                const cursor = { line: 1, column: 4 };
+                const result = moveCursor(buffer, cursor, 'up');
+                expect(result).toEqual({ line: 0, column: 2 });
+            });
+            it('stays on first line', () => {
+                const buffer = createBuffer('hello');
+                const cursor = { line: 0, column: 2 };
+                const result = moveCursor(buffer, cursor, 'up');
+                expect(result).toEqual({ line: 0, column: 2 });
+            });
+        });
+        describe('down', () => {
+            it('moves down maintaining column', () => {
+                const buffer = createBuffer('hello\nworld');
+                const cursor = { line: 0, column: 3 };
+                const result = moveCursor(buffer, cursor, 'down');
+                expect(result).toEqual({ line: 1, column: 3 });
+            });
+            it('clamps column to shorter line', () => {
+                const buffer = createBuffer('hello\nhi');
+                const cursor = { line: 0, column: 4 };
+                const result = moveCursor(buffer, cursor, 'down');
+                expect(result).toEqual({ line: 1, column: 2 });
+            });
+            it('stays on last line', () => {
+                const buffer = createBuffer('hello');
+                const cursor = { line: 0, column: 2 };
+                const result = moveCursor(buffer, cursor, 'down');
+                expect(result).toEqual({ line: 0, column: 2 });
+            });
+        });
+        describe('visual navigation with wrapping', () => {
+            // A 25-char line wraps into 3 visual lines with width=10:
+            // Visual 0: "0123456789" (chars 0-9)
+            // Visual 1: "0123456789" (chars 10-19)
+            // Visual 2: "01234"      (chars 20-24)
+            const longLine = '0123456789012345678901234'; // 25 chars
+            describe('down with width (visual)', () => {
+                it('moves down within wrapped line', () => {
+                    const buffer = createBuffer(longLine);
+                    const cursor = { line: 0, column: 5 }; // visual row 0, col 5
+                    const result = moveCursor(buffer, cursor, 'down', 10);
+                    // Should move to visual row 1, col 5 → buffer column 15
+                    expect(result).toEqual({ line: 0, column: 15 });
+                });
+                it('moves from second visual row to third', () => {
+                    const buffer = createBuffer(longLine);
+                    const cursor = { line: 0, column: 12 }; // visual row 1, col 2
+                    const result = moveCursor(buffer, cursor, 'down', 10);
+                    // Should move to visual row 2, col 2 → buffer column 22
+                    expect(result).toEqual({ line: 0, column: 22 });
+                });
+                it('clamps column when moving to shorter visual row', () => {
+                    const buffer = createBuffer(longLine);
+                    const cursor = { line: 0, column: 17 }; // visual row 1, col 7
+                    const result = moveCursor(buffer, cursor, 'down', 10);
+                    // Visual row 2 only has 5 chars (0-4), so clamp to end of line position (25)
+                    // The cursor can be positioned at the end of the line (after the last char)
+                    expect(result).toEqual({ line: 0, column: 25 });
+                });
+                it('moves from last visual row of one line to first visual row of next line', () => {
+                    const buffer = createBuffer(longLine + '\nhello');
+                    const cursor = { line: 0, column: 22 }; // visual row 2, col 2
+                    const result = moveCursor(buffer, cursor, 'down', 10);
+                    // Should move to line 1, visual row 0, col 2 → line 1, column 2
+                    expect(result).toEqual({ line: 1, column: 2 });
+                });
+                it('stays at last visual row of last line', () => {
+                    const buffer = createBuffer(longLine);
+                    const cursor = { line: 0, column: 22 }; // visual row 2, col 2
+                    const result = moveCursor(buffer, cursor, 'down', 10);
+                    // No more visual rows, stay where we are
+                    expect(result).toEqual({ line: 0, column: 22 });
+                });
+            });
+            describe('up with width (visual)', () => {
+                it('moves up within wrapped line', () => {
+                    const buffer = createBuffer(longLine);
+                    const cursor = { line: 0, column: 15 }; // visual row 1, col 5
+                    const result = moveCursor(buffer, cursor, 'up', 10);
+                    // Should move to visual row 0, col 5 → buffer column 5
+                    expect(result).toEqual({ line: 0, column: 5 });
+                });
+                it('moves from third visual row to second', () => {
+                    const buffer = createBuffer(longLine);
+                    const cursor = { line: 0, column: 22 }; // visual row 2, col 2
+                    const result = moveCursor(buffer, cursor, 'up', 10);
+                    // Should move to visual row 1, col 2 → buffer column 12
+                    expect(result).toEqual({ line: 0, column: 12 });
+                });
+                it('moves from first visual row of line to last visual row of previous line', () => {
+                    const buffer = createBuffer(longLine + '\nhello');
+                    const cursor = { line: 1, column: 2 }; // line 1, visual row 0, col 2
+                    const result = moveCursor(buffer, cursor, 'up', 10);
+                    // Should move to line 0, visual row 2, col 2 → line 0, column 22
+                    expect(result).toEqual({ line: 0, column: 22 });
+                });
+                it('clamps column when moving to shorter visual row above', () => {
+                    const buffer = createBuffer(longLine + '\nhello');
+                    const cursor = { line: 1, column: 4 }; // line 1, col 4
+                    const result = moveCursor(buffer, cursor, 'up', 10);
+                    // Move to line 0, visual row 2 (only 5 chars: 0-4)
+                    // col 4 is valid, so buffer column = 20 + 4 = 24
+                    expect(result).toEqual({ line: 0, column: 24 });
+                });
+                it('stays at first visual row of first line', () => {
+                    const buffer = createBuffer(longLine);
+                    const cursor = { line: 0, column: 5 }; // visual row 0, col 5
+                    const result = moveCursor(buffer, cursor, 'up', 10);
+                    // No more visual rows above, stay where we are
+                    expect(result).toEqual({ line: 0, column: 5 });
+                });
+            });
+            describe('backward compatibility without width', () => {
+                it('up still works with buffer lines when width not provided', () => {
+                    const buffer = createBuffer(longLine + '\nhello');
+                    const cursor = { line: 1, column: 3 };
+                    const result = moveCursor(buffer, cursor, 'up');
+                    // Without width, should move to previous buffer line
+                    expect(result).toEqual({ line: 0, column: 3 });
+                });
+                it('down still works with buffer lines when width not provided', () => {
+                    const buffer = createBuffer('hello\n' + longLine);
+                    const cursor = { line: 0, column: 3 };
+                    const result = moveCursor(buffer, cursor, 'down');
+                    // Without width, should move to next buffer line
+                    expect(result).toEqual({ line: 1, column: 3 });
+                });
+            });
+        });
+        describe('lineStart', () => {
+            it('moves to start of line', () => {
+                const buffer = createBuffer('hello');
+                const cursor = { line: 0, column: 3 };
+                const result = moveCursor(buffer, cursor, 'lineStart');
+                expect(result).toEqual({ line: 0, column: 0 });
+            });
+            it('stays at start if already there', () => {
+                const buffer = createBuffer('hello');
+                const cursor = { line: 0, column: 0 };
+                const result = moveCursor(buffer, cursor, 'lineStart');
+                expect(result).toEqual({ line: 0, column: 0 });
+            });
+        });
+        describe('lineEnd', () => {
+            it('moves to end of line', () => {
+                const buffer = createBuffer('hello');
+                const cursor = { line: 0, column: 2 };
+                const result = moveCursor(buffer, cursor, 'lineEnd');
+                expect(result).toEqual({ line: 0, column: 5 });
+            });
+            it('stays at end if already there', () => {
+                const buffer = createBuffer('hello');
+                const cursor = { line: 0, column: 5 };
+                const result = moveCursor(buffer, cursor, 'lineEnd');
+                expect(result).toEqual({ line: 0, column: 5 });
+            });
+        });
+    });
+    describe('getTextContent', () => {
+        it('returns empty string for empty buffer', () => {
+            const buffer = createBuffer();
+            expect(getTextContent(buffer)).toBe('');
+        });
+        it('returns single line content', () => {
+            const buffer = createBuffer('hello');
+            expect(getTextContent(buffer)).toBe('hello');
+        });
+        it('joins multiple lines with newlines', () => {
+            const buffer = createBuffer('line1\nline2\nline3');
+            expect(getTextContent(buffer)).toBe('line1\nline2\nline3');
+        });
+        it('preserves empty lines', () => {
+            const buffer = createBuffer('hello\n\nworld');
+            expect(getTextContent(buffer)).toBe('hello\n\nworld');
+        });
+    });
+});

package/dist/components/MultilineInput/__tests__/TextRenderer.test.d.ts

@@ -0,0 +1 @@
+export {};