ink-prompt 0.1.5 → 0.1.7

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

@@ -2,6 +2,7 @@ import { type Key, type Buffer, type Cursor } from './types.js';
 import { type UseTextInputResult } from './useTextInput.js';
 export interface KeyHandlerActions extends Omit<UseTextInputResult, 'value' | 'cursor' | 'cursorOffset' | 'setCursorOffset'> {
     submit: () => void;
+    onBoundaryArrow?: (direction: 'up' | 'down' | 'left' | 'right') => void;
 }
 /**
  * Handles keyboard input and maps it to text input actions.
@@ -12,5 +13,6 @@ export interface KeyHandlerActions extends Omit<UseTextInputResult, 'value' | 'c
  * @param actions - The actions available to modify the state
  * @param cursor - The current cursor position (optional, but required for some logic like backslash check)
  * @param rawInput - The raw input sequence (optional, used for detecting Home/End keys)
+ * @param width - Terminal width for visual-aware boundary detection (optional)
  */
-export declare function handleKey(key: Partial<Key>, input: string, buffer: Buffer, actions: KeyHandlerActions, cursor?: Cursor, rawInput?: string): void;
+export declare function handleKey(key: Partial<Key>, input: string, buffer: Buffer, actions: KeyHandlerActions, cursor?: Cursor, rawInput?: string, width?: number): void;

package/dist/components/MultilineInput/KeyHandler.js

@@ -1,4 +1,105 @@
+import { getVisualRows } from './TextBuffer.js';
 import { log } from '../../utils/logger.js';
+/**
+ * Check if cursor is at the left boundary (start of text).
+ */
+function isAtLeftBoundary(cursor) {
+    return cursor.line === 0 && cursor.column === 0;
+}
+/**
+ * Check if cursor is at the right boundary (end of text).
+ */
+function isAtRightBoundary(buffer, cursor) {
+    const lastLineIndex = buffer.lines.length - 1;
+    const lastLine = buffer.lines[lastLineIndex];
+    return cursor.line === lastLineIndex && cursor.column >= lastLine.length;
+}
+/**
+ * Check if cursor is at the top boundary (cannot move up).
+ * When width is provided, this considers visual line wrapping.
+ */
+function isAtTopBoundary(buffer, cursor, width) {
+    if (cursor.line > 0) {
+        // Not on first buffer line, check visual wrapping
+        if (width !== undefined) {
+            const currentLine = buffer.lines[cursor.line];
+            const rows = getVisualRows(currentLine, width);
+            // Find which visual row the cursor is on
+            let visualRow = 0;
+            for (let i = 0; i < rows.length; i++) {
+                const row = rows[i];
+                const rowEnd = row.start + row.length;
+                if (cursor.column >= row.start && cursor.column <= rowEnd) {
+                    visualRow = i;
+                    break;
+                }
+            }
+            // If cursor is not on the first visual row of this line, it can move up
+            return false;
+        }
+        return false;
+    }
+    // Cursor is on first buffer line
+    if (width !== undefined) {
+        const currentLine = buffer.lines[0];
+        const rows = getVisualRows(currentLine, width);
+        // Find which visual row the cursor is on
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            const rowEnd = row.start + row.length;
+            if (cursor.column >= row.start && cursor.column <= rowEnd) {
+                // At top boundary only if on first visual row
+                return i === 0;
+            }
+        }
+    }
+    // No width - buffer line-based: first line means at top
+    return true;
+}
+/**
+ * Check if cursor is at the bottom boundary (cannot move down).
+ * When width is provided, this considers visual line wrapping.
+ */
+function isAtBottomBoundary(buffer, cursor, width) {
+    const lastLineIndex = buffer.lines.length - 1;
+    if (cursor.line < lastLineIndex) {
+        // Not on last buffer line, check visual wrapping
+        if (width !== undefined) {
+            const currentLine = buffer.lines[cursor.line];
+            const rows = getVisualRows(currentLine, width);
+            // Find which visual row the cursor is on
+            let visualRow = 0;
+            for (let i = 0; i < rows.length; i++) {
+                const row = rows[i];
+                const rowEnd = row.start + row.length;
+                if (cursor.column >= row.start && cursor.column <= rowEnd) {
+                    visualRow = i;
+                    break;
+                }
+            }
+            // If cursor is not on the last visual row of this line, it can move down
+            return false;
+        }
+        return false;
+    }
+    // Cursor is on last buffer line
+    if (width !== undefined) {
+        const currentLine = buffer.lines[lastLineIndex];
+        const rows = getVisualRows(currentLine, width);
+        const lastVisualRow = rows.length - 1;
+        // Find which visual row the cursor is on
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            const rowEnd = row.start + row.length;
+            if (cursor.column >= row.start && cursor.column <= rowEnd) {
+                // At bottom boundary only if on last visual row
+                return i === lastVisualRow;
+            }
+        }
+    }
+    // No width - buffer line-based: last line means at bottom
+    return true;
+}
 /**
  * Escape sequences for Home key (various terminal emulators)
  */
@@ -33,22 +134,39 @@ function isBackspaceSequence(seq) {
  * @param actions - The actions available to modify the state
  * @param cursor - The current cursor position (optional, but required for some logic like backslash check)
  * @param rawInput - The raw input sequence (optional, used for detecting Home/End keys)
+ * @param width - Terminal width for visual-aware boundary detection (optional)
  */
-export function handleKey(key, input, buffer, actions, cursor, rawInput) {
-    // Navigation
+export function handleKey(key, input, buffer, actions, cursor, rawInput, width) {
+    // Navigation with boundary detection
     if (key.upArrow) {
+        if (cursor && actions.onBoundaryArrow && isAtTopBoundary(buffer, cursor, width)) {
+            actions.onBoundaryArrow('up');
+            return;
+        }
         actions.moveCursor('up');
         return;
     }
     if (key.downArrow) {
+        if (cursor && actions.onBoundaryArrow && isAtBottomBoundary(buffer, cursor, width)) {
+            actions.onBoundaryArrow('down');
+            return;
+        }
         actions.moveCursor('down');
         return;
     }
     if (key.leftArrow) {
+        if (cursor && actions.onBoundaryArrow && isAtLeftBoundary(cursor)) {
+            actions.onBoundaryArrow('left');
+            return;
+        }
         actions.moveCursor('left');
         return;
     }
     if (key.rightArrow) {
+        if (cursor && actions.onBoundaryArrow && isAtRightBoundary(buffer, cursor)) {
+            actions.onBoundaryArrow('right');
+            return;
+        }
         actions.moveCursor('right');
         return;
     }

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

@@ -62,6 +62,179 @@ describe('KeyHandler', () => {
             expect(actions.moveCursor).toHaveBeenCalledWith('lineEnd');
         });
     });
+    describe('Boundary Arrow', () => {
+        describe('Left boundary', () => {
+            it('calls onBoundaryArrow("left") when cursor is at position 0', () => {
+                buffer = { lines: ['hello'] };
+                const cursor = { line: 0, column: 0 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ leftArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).toHaveBeenCalledWith('left');
+                expect(actions.moveCursor).not.toHaveBeenCalled();
+            });
+            it('does not call onBoundaryArrow when cursor can move left', () => {
+                buffer = { lines: ['hello'] };
+                const cursor = { line: 0, column: 3 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ leftArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).not.toHaveBeenCalled();
+                expect(actions.moveCursor).toHaveBeenCalledWith('left');
+            });
+            it('does not call onBoundaryArrow when at start of line but previous line exists', () => {
+                buffer = { lines: ['first', 'second'] };
+                const cursor = { line: 1, column: 0 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ leftArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).not.toHaveBeenCalled();
+                expect(actions.moveCursor).toHaveBeenCalledWith('left');
+            });
+        });
+        describe('Right boundary', () => {
+            it('calls onBoundaryArrow("right") when cursor is at end of text', () => {
+                buffer = { lines: ['hello'] };
+                const cursor = { line: 0, column: 5 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ rightArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).toHaveBeenCalledWith('right');
+                expect(actions.moveCursor).not.toHaveBeenCalled();
+            });
+            it('does not call onBoundaryArrow when cursor can move right', () => {
+                buffer = { lines: ['hello'] };
+                const cursor = { line: 0, column: 2 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ rightArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).not.toHaveBeenCalled();
+                expect(actions.moveCursor).toHaveBeenCalledWith('right');
+            });
+            it('does not call onBoundaryArrow when at end of line but next line exists', () => {
+                buffer = { lines: ['first', 'second'] };
+                const cursor = { line: 0, column: 5 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ rightArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).not.toHaveBeenCalled();
+                expect(actions.moveCursor).toHaveBeenCalledWith('right');
+            });
+        });
+        describe('Up boundary', () => {
+            it('calls onBoundaryArrow("up") when cursor is on first line', () => {
+                buffer = { lines: ['hello'] };
+                const cursor = { line: 0, column: 2 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ upArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).toHaveBeenCalledWith('up');
+                expect(actions.moveCursor).not.toHaveBeenCalled();
+            });
+            it('does not call onBoundaryArrow when previous line exists', () => {
+                buffer = { lines: ['first', 'second'] };
+                const cursor = { line: 1, column: 2 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ upArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).not.toHaveBeenCalled();
+                expect(actions.moveCursor).toHaveBeenCalledWith('up');
+            });
+            it('considers visual rows when width is provided - cursor on first visual row', () => {
+                // "hello world" with width 5 wraps to:
+                // "hello" (visual row 0)
+                // " worl" (visual row 1)
+                // "d" (visual row 2)
+                buffer = { lines: ['hello world'] };
+                const cursor = { line: 0, column: 2 }; // On first visual row
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ upArrow: true }, '', buffer, actions, cursor, undefined, 5);
+                expect(onBoundaryArrow).toHaveBeenCalledWith('up');
+                expect(actions.moveCursor).not.toHaveBeenCalled();
+            });
+            it('considers visual rows when width is provided - cursor on second visual row', () => {
+                // "hello world" with width 5 wraps to visual rows
+                buffer = { lines: ['hello world'] };
+                const cursor = { line: 0, column: 7 }; // On second visual row (after first wrap)
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ upArrow: true }, '', buffer, actions, cursor, undefined, 5);
+                // Can move up within the same buffer line (to previous visual row)
+                expect(onBoundaryArrow).not.toHaveBeenCalled();
+                expect(actions.moveCursor).toHaveBeenCalledWith('up');
+            });
+        });
+        describe('Down boundary', () => {
+            it('calls onBoundaryArrow("down") when cursor is on last line', () => {
+                buffer = { lines: ['hello'] };
+                const cursor = { line: 0, column: 2 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ downArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).toHaveBeenCalledWith('down');
+                expect(actions.moveCursor).not.toHaveBeenCalled();
+            });
+            it('does not call onBoundaryArrow when next line exists', () => {
+                buffer = { lines: ['first', 'second'] };
+                const cursor = { line: 0, column: 2 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ downArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).not.toHaveBeenCalled();
+                expect(actions.moveCursor).toHaveBeenCalledWith('down');
+            });
+            it('considers visual rows when width is provided - cursor on last visual row', () => {
+                // "hello world" with width 5 wraps to visual rows
+                buffer = { lines: ['hello world'] };
+                const cursor = { line: 0, column: 10 }; // On last visual row (at 'd')
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ downArrow: true }, '', buffer, actions, cursor, undefined, 5);
+                expect(onBoundaryArrow).toHaveBeenCalledWith('down');
+                expect(actions.moveCursor).not.toHaveBeenCalled();
+            });
+            it('considers visual rows when width is provided - cursor on first visual row', () => {
+                // "hello world" with width 5 wraps to visual rows
+                buffer = { lines: ['hello world'] };
+                const cursor = { line: 0, column: 2 }; // On first visual row
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ downArrow: true }, '', buffer, actions, cursor, undefined, 5);
+                // Can move down within the same buffer line (to next visual row)
+                expect(onBoundaryArrow).not.toHaveBeenCalled();
+                expect(actions.moveCursor).toHaveBeenCalledWith('down');
+            });
+        });
+        describe('No callback provided', () => {
+            it('moves cursor normally when onBoundaryArrow is not set', () => {
+                buffer = { lines: ['hello'] };
+                const cursor = { line: 0, column: 0 };
+                // actions.onBoundaryArrow is not set
+                handleKey({ leftArrow: true }, '', buffer, actions, cursor);
+                expect(actions.moveCursor).toHaveBeenCalledWith('left');
+            });
+        });
+        describe('Empty buffer', () => {
+            it('calls onBoundaryArrow for all directions in empty buffer', () => {
+                buffer = { lines: [''] };
+                const cursor = { line: 0, column: 0 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ upArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).toHaveBeenCalledWith('up');
+                onBoundaryArrow.mockClear();
+                handleKey({ downArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).toHaveBeenCalledWith('down');
+                onBoundaryArrow.mockClear();
+                handleKey({ leftArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).toHaveBeenCalledWith('left');
+                onBoundaryArrow.mockClear();
+                handleKey({ rightArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).toHaveBeenCalledWith('right');
+            });
+        });
+    });
     describe('Editing', () => {
         it('handles Backspace', () => {
             handleKey({ backspace: true }, 'backspace', buffer, actions);

package/dist/components/MultilineInput/index.d.ts

@@ -1,37 +1,110 @@
 import React from 'react';
 export interface MultilineInputProps {
-    /** Controlled text value */
+    /**
+     * Controlled text value. When provided, the component becomes controlled
+     * and the value is managed externally.
+     */
     value?: string;
-    /** Called when text changes */
+    /**
+     * Called when the text content changes due to user input. Receives the
+     * new text value as a parameter.
+     */
     onChange?: (value: string) => void;
-    /** Called when user submits (Enter without backslash) */
+    /**
+     * Called when the user submits the input (typically by pressing Enter
+     * without a backslash at the end). Receives the final text value.
+     */
     onSubmit?: (value: string) => void;
-    /** Placeholder text when empty */
+    /**
+     * Placeholder text displayed when the input is empty and the cursor
+     * is not shown.
+     */
     placeholder?: string;
-    /** Whether to show the cursor (defaults to true) */
+    /**
+     * Whether to display the cursor. Defaults to true.
+     */
     showCursor?: boolean;
-    /** Terminal width for word wrapping */
+    /**
+     * Terminal width for word wrapping. If not provided, uses the terminal's
+     * current width with resize support.
+     */
     width?: number;
-    /** Whether input is active/focused (defaults to true) */
+    /**
+     * Whether the input is active and focused, allowing keyboard input.
+     * Defaults to true.
+     */
     isActive?: boolean;
-    /** Called whenever the cursor offset changes (flat index) */
+    /**
+     * Called whenever the cursor position changes. Receives the flat
+     * character offset as a parameter.
+     */
     onCursorChange?: (offset: number) => void;
-    /** Optional external cursor override (flat index) */
+    /**
+     * Optional external cursor position override. When set, forces the
+     * cursor to the specified flat character offset.
+     */
     cursorOverride?: number;
+    /**
+     * Called when an arrow key is pressed but cursor is at a boundary.
+     * - 'up': cursor is on the first/topmost line
+     * - 'down': cursor is on the last/bottommost line
+     * - 'left': cursor is at position 0 (start of text)
+     * - 'right': cursor is at end of text (after last character)
+     */
+    onBoundaryArrow?: (direction: 'up' | 'down' | 'left' | 'right') => void;
 }
 /**
  * Props for the core component (without Ink-specific hooks)
  * This allows testing the rendering logic separately.
  */
 export interface MultilineInputCoreProps {
+    /**
+     * Controlled text value. When provided, the component becomes controlled
+     * and the text is managed externally.
+     */
     value?: string;
+    /**
+     * Called when the text content changes. Receives the new text value
+     * as a parameter.
+     */
     onChange?: (value: string) => void;
+    /**
+     * Called when the user submits the input (typically by pressing Enter
+     * without a backslash at the end).
+     */
     onSubmit?: (value: string) => void;
+    /**
+     * Placeholder text displayed when the input is empty and the cursor
+     * is not shown.
+     */
     placeholder?: string;
+    /**
+     * Whether to display the cursor. Defaults to true.
+     */
     showCursor?: boolean;
+    /**
+     * Terminal width for word wrapping. If not provided, uses the terminal's
+     * current width.
+     */
     width?: number;
+    /**
+     * Called whenever the cursor position changes. Receives the flat
+     * character offset as a parameter.
+     */
     onCursorChange?: (offset: number) => void;
+    /**
+     * Optional external cursor position override. When set, forces the
+     * cursor to the specified flat character offset.
+     */
     cursorOverride?: number;
+    /**
+     * Called when an arrow key is pressed but cursor is at a boundary.
+     * - 'up': cursor is on the first/topmost line
+     * - 'down': cursor is on the last/bottommost line
+     * - 'left': cursor is at position 0 (start of text)
+     * - 'right': cursor is at end of text (after last character)
+     */
+    onBoundaryArrow?: (direction: 'up' | 'down' | 'left' | 'right') => void;
 }
 /**
  * Core rendering component that can be tested without Ink runtime.

package/dist/components/MultilineInput/index.js

@@ -66,7 +66,7 @@ export const MultilineInputCore = ({ value, onChange, placeholder, showCursor =
  * Full MultilineInput with Ink keyboard handling.
  * This component uses Ink-specific hooks and must be rendered in an Ink context.
  */
-export const MultilineInput = ({ value, onChange, onSubmit, placeholder, showCursor = true, width, isActive = true, onCursorChange, cursorOverride, }) => {
+export const MultilineInput = ({ value, onChange, onSubmit, placeholder, showCursor = true, width, isActive = true, onCursorChange, cursorOverride, onBoundaryArrow, }) => {
     // Get terminal width from Ink (with resize support) if not provided
     const terminalWidth = useTerminalWidth(width);
     // Track raw input for detecting Home/End keys
@@ -140,11 +140,12 @@ export const MultilineInput = ({ value, onChange, onSubmit, placeholder, showCur
         redo: textInput.redo,
         setText: textInput.setText,
         submit: handleSubmit,
+        onBoundaryArrow,
     };
     // Handle keyboard input
     useInput((input, key) => {
         log(`[USEINPUT] input="${input.replace(/[\x00-\x1F\x7F-\uFFFF]/g, c => `\\x${c.charCodeAt(0).toString(16)}`)}" key=${JSON.stringify(key)} rawLen=${lastRawInput.current?.length || 0}`);
-        handleKey(key, input, buffer, actions, textInput.cursor, lastRawInput.current);
+        handleKey(key, input, buffer, actions, textInput.cursor, lastRawInput.current, terminalWidth);
     }, { isActive });
     // Show placeholder if empty and no cursor shown
     const isEmpty = textInput.value === '';

package/dist/components/MultilineInput/types.d.ts

@@ -18,6 +18,10 @@ export interface Buffer {
  * Cursor movement directions
  */
 export type Direction = 'up' | 'down' | 'left' | 'right' | 'lineStart' | 'lineEnd';
+/**
+ * Boundary arrow directions (subset of Direction used for boundary detection)
+ */
+export type BoundaryDirection = 'up' | 'down' | 'left' | 'right';
 /**
  * Result of wrapping buffer lines for visual display
  */

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export { MultilineInput } from './components/MultilineInput/index.js';
 export type { MultilineInputProps } from './components/MultilineInput/index.js';
+export type { BoundaryDirection } from './components/MultilineInput/types.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ink-prompt",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "A React Ink component for prompts",
   "type": "module",
   "main": "./dist/index.js",

package/dist/examples/examples/basic.d.ts

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

package/dist/examples/examples/basic.js

@@ -1,9 +0,0 @@
-import React from 'react';
-import { render } from 'ink';
-import { MultilineInput } from '../src/index.js';
-const App = () => {
-    return (React.createElement(MultilineInput
-    // Add props here
-    , null));
-};
-render(React.createElement(App, null));

package/dist/examples/src/components/MultilineInput/KeyHandler.d.ts

@@ -1,15 +0,0 @@
-import { type Key, type Buffer, type Cursor } from './types';
-import { type UseTextInputResult } from './useTextInput';
-export interface KeyHandlerActions extends Omit<UseTextInputResult, 'value' | 'cursor'> {
-    submit: () => void;
-}
-/**
- * Handles keyboard input and maps it to text input actions.
- *
- * @param key - The Ink key object
- * @param input - The input string (if any)
- * @param buffer - The current text buffer
- * @param actions - The actions available to modify the state
- * @param cursor - The current cursor position (optional, but required for some logic like backslash check)
- */
-export declare function handleKey(key: Partial<Key>, input: string, buffer: Buffer, actions: KeyHandlerActions, cursor?: Cursor): void;

package/dist/examples/src/components/MultilineInput/KeyHandler.js

@@ -1,97 +0,0 @@
-/**
- * Handles keyboard input and maps it to text input actions.
- *
- * @param key - The Ink key object
- * @param input - The input string (if any)
- * @param buffer - The current text buffer
- * @param actions - The actions available to modify the state
- * @param cursor - The current cursor position (optional, but required for some logic like backslash check)
- */
-export function handleKey(key, input, buffer, actions, cursor) {
-    // Navigation
-    if (key.upArrow) {
-        actions.moveCursor('up');
-        return;
-    }
-    if (key.downArrow) {
-        actions.moveCursor('down');
-        return;
-    }
-    if (key.leftArrow) {
-        actions.moveCursor('left');
-        return;
-    }
-    if (key.rightArrow) {
-        actions.moveCursor('right');
-        return;
-    }
-    // Home/End (Ink might not provide these directly in all environments, but if it does)
-    // We check for 'home' and 'end' properties if they exist on the key object,
-    // or specific sequences if we were parsing raw input, but here we assume Ink's Key object.
-    // Note: Ink's Key interface might not have home/end in all versions, but we'll assume it does or we extend it.
-    // If not, we might need to check specific input sequences, but for now let's trust the test/types.
-    if (key.home) {
-        actions.moveCursor('lineStart');
-        return;
-    }
-    if (key.end) {
-        actions.moveCursor('lineEnd');
-        return;
-    }
-    // History
-    if (key.ctrl) {
-        if (input === 'z') {
-            actions.undo();
-            return;
-        }
-        if (input === 'y') {
-            actions.redo();
-            return;
-        }
-        if (input === 'j') {
-            actions.newLine();
-            return;
-        }
-    }
-    // Editing
-    if (key.backspace) {
-        actions.delete();
-        return;
-    }
-    if (key.delete) {
-        // Currently mapped to delete (backspace behavior) as per requirements/tests,
-        // but usually delete is forward.
-        // The plan said "Delete (delete at cursor)", which usually means forward.
-        // But our useTextInput only has `delete` (which is backspace).
-        // For now, we map it to `delete` as per the test "handles Delete".
-        actions.delete();
-        return;
-    }
-    // Submission / New Line
-    if (key.return) {
-        if (cursor) {
-            const currentLine = buffer.lines[cursor.line];
-            // Check if line ends with backslash AND cursor is at the end (or we just check the line content?)
-            // Requirement: "Line ending with \ + Enter continues to next line"
-            // Usually this implies the user typed '\' then Enter.
-            // We should probably check if the character *before* the cursor is '\' if we want to be precise,
-            // or just if the line ends with '\'.
-            // Let's assume "line ends with \" means the last char of the line is '\'.
-            if (currentLine.endsWith('\\')) {
-                actions.delete(); // Remove the backslash
-                actions.newLine(); // Insert newline
-                return;
-            }
-        }
-        actions.submit();
-        return;
-    }
-    // Text Insertion
-    // Ignore control keys if they don't have a specific handler above
-    if (key.ctrl || key.meta) {
-        return;
-    }
-    if (input) {
-        actions.insert(input);
-    }
-}