cvc-tui 0.1.0 → 0.4.0

package/dist/components/textInput.js

@@ -1,264 +1,794 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-// CVC power-input composer — Hermes ui-tui parity.
-//
-// Features:
-//  • Multi-line buffer (Alt+Enter / Shift+Enter newline; Enter submit)
-//  • Word-wrap to terminal columns
-//  • Visible inverse-block cursor
-//  • Dim live char/line counter footer
-//  • Up/Down history cycle (when on first/last logical line)
-//  • Ctrl+R reverse-incremental search overlay
-//  • Tab completion: slash commands + file paths
-//  • Ctrl+L clears
-//  • Queued submission indicator `[queued: N]`
-//  • Hidden when promptStore has an active confirm/secret prompt
-//
-// Pure buffer math lives in ../app/inputBuffer.ts; this file is the React
-// glue + key dispatch.
-import { useCallback, useEffect, useState } from 'react';
-import { Box, Text, useInput } from 'ink';
-import { useStore } from '@nanostores/react';
-import { $buffer, $completion, resetCompletion, setBuffer, setBufferRaw, } from '../app/inputStore.js';
-import { emptyBuffer, insert, backspace, del as bufDel, moveLeft, moveRight, moveHome, moveEnd, moveUp, moveDown, onFirstLine, onLastLine, bufferStats, cursorRowCol, } from '../app/inputBuffer.js';
-import { $history, loadHistory, pushHistory, historyPrev, historyNext, resetHistoryBrowse, } from '../app/historyStore.js';
-import { $queue } from '../app/queueStore.js';
-import { $prompt } from '../app/promptStore.js';
-import { $ui } from '../app/uiStore.js';
-import { tokenAtCursor, candidatesFor, applyCandidate, } from '../app/completion.js';
-import { HistorySearch } from './overlays/historySearch.js';
-import { ConfirmPrompt } from './overlays/confirmPrompt.js';
-import { SecretPrompt } from './overlays/secretPrompt.js';
-const PROMPT_COLOR = '#e63946';
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as Ink from '@cvc/ink';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { setInputSelection } from '../app/inputSelectionStore.js';
+import { readClipboardText, writeClipboardText } from '../lib/clipboard.js';
+import { cursorLayout, offsetFromPosition } from '../lib/inputMetrics.js';
+import { DEFAULT_VOICE_RECORD_KEY, isActionMod, isMac, isMacActionFallback, isVoiceToggleKey } from '../lib/platform.js';
+const ink = Ink;
+const { Box, Text, useStdin, useInput, useStdout, stringWidth, useDeclaredCursor, useTerminalFocus } = ink;
+const ESC = '\x1b';
+const INV = `${ESC}[7m`;
+const INV_OFF = `${ESC}[27m`;
+const DIM = `${ESC}[2m`;
+const DIM_OFF = `${ESC}[22m`;
+const FWD_DEL_RE = new RegExp(`${ESC}\\[3(?:[~$^]|;)`);
+const PRINTABLE = /^[ -~\u00a0-\uffff]+$/;
+const BRACKET_PASTE = new RegExp(`${ESC}?\\[20[01]~`, 'g');
+const MULTI_CLICK_MS = 500;
+const invert = (s) => INV + s + INV_OFF;
+const dim = (s) => DIM + s + DIM_OFF;
+let _seg = null;
+const seg = () => (_seg ??= new Intl.Segmenter(undefined, { granularity: 'grapheme' }));
+const STOP_CACHE_MAX = 32;
+const stopCache = new Map();
+function graphemeStops(s) {
+    const hit = stopCache.get(s);
+    if (hit) {
+        return hit;
+    }
+    const stops = [0];
+    for (const { index } of seg().segment(s)) {
+        if (index > 0) {
+            stops.push(index);
+        }
+    }
+    if (stops.at(-1) !== s.length) {
+        stops.push(s.length);
+    }
+    stopCache.set(s, stops);
+    if (stopCache.size > STOP_CACHE_MAX) {
+        const oldest = stopCache.keys().next().value;
+        if (oldest !== undefined) {
+            stopCache.delete(oldest);
+        }
+    }
+    return stops;
+}
+function snapPos(s, p) {
+    const pos = Math.max(0, Math.min(p, s.length));
+    let last = 0;
+    for (const stop of graphemeStops(s)) {
+        if (stop > pos) {
+            break;
+        }
+        last = stop;
+    }
+    return last;
+}
+function prevPos(s, p) {
+    const pos = snapPos(s, p);
+    let prev = 0;
+    for (const stop of graphemeStops(s)) {
+        if (stop >= pos) {
+            return prev;
+        }
+        prev = stop;
+    }
+    return prev;
+}
+function nextPos(s, p) {
+    const pos = snapPos(s, p);
+    for (const stop of graphemeStops(s)) {
+        if (stop > pos) {
+            return stop;
+        }
+    }
+    return s.length;
+}
+function wordLeft(s, p) {
+    let i = snapPos(s, p) - 1;
+    while (i > 0 && /\s/.test(s[i])) {
+        i--;
+    }
+    while (i > 0 && !/\s/.test(s[i - 1])) {
+        i--;
+    }
+    return Math.max(0, i);
+}
+function wordRight(s, p) {
+    let i = snapPos(s, p);
+    while (i < s.length && !/\s/.test(s[i])) {
+        i++;
+    }
+    while (i < s.length && /\s/.test(s[i])) {
+        i++;
+    }
+    return i;
+}
 /**
- * Render the buffer with an inverse-block cursor at `cursor`. Wraps to `cols`
- * columns. Returns an array of visual lines (already containing ANSI invert
- * codes for the cursor cell).
+ * Move cursor one logical line up or down inside `s` while preserving the
+ * column offset from the current line's start. Returns `null` when the cursor
+ * is already on the first line (up) or last line (down) — callers use that
+ * signal to fall through to history cycling instead of eating the arrow key.
  */
-function renderWrapped(buf, _cols) {
-    const text = buf.text;
-    const cursor = Math.max(0, Math.min(buf.cursor, text.length));
-    // Insert cursor sentinel as inverted character.
-    const ESC = '\x1b';
-    const INV = `${ESC}[7m`;
-    const OFF = `${ESC}[27m`;
-    const ch = cursor < text.length && text[cursor] !== '\n' ? text[cursor] : ' ';
-    const withCursor = text.slice(0, cursor) + INV + ch + OFF + text.slice(cursor + (cursor < text.length && text[cursor] !== '\n' ? 1 : 0));
-    // Wrap each logical line. We can't naively wrapText because of escape codes;
-    // however the codes are zero-width so length-based wrap with the *raw* text
-    // still produces visually correct output if we map back. For simplicity and
-    // since terminal widths in our tests are generous, we wrap on raw text with
-    // injected codes treated as part of the line — the codes themselves don't
-    // consume cells, but wrapText sees them as chars. To stay correct, wrap the
-    // raw line and re-inject the cursor cell.
-    // Simpler: split on '\n' from withCursor and let Ink soft-wrap visually.
-    return withCursor.split('\n');
+export function lineNav(s, p, dir) {
+    const pos = snapPos(s, p);
+    const curStart = s.lastIndexOf('\n', pos - 1) + 1;
+    const col = pos - curStart;
+    if (dir < 0) {
+        if (curStart === 0) {
+            return null;
+        }
+        const prevStart = s.lastIndexOf('\n', curStart - 2) + 1;
+        return snapPos(s, Math.min(prevStart + col, curStart - 1));
+    }
+    const nextBreak = s.indexOf('\n', pos);
+    if (nextBreak < 0) {
+        return null;
+    }
+    const nextEnd = s.indexOf('\n', nextBreak + 1);
+    const lineEnd = nextEnd < 0 ? s.length : nextEnd;
+    return snapPos(s, Math.min(nextBreak + 1 + col, lineEnd));
 }
-/** Slim hint footer: `chars · lines · [queued: N]`. */
-const Hints = ({ chars, lineCount, queued, mode, }) => {
-    const parts = [`${chars} chars`, `${lineCount} line${lineCount === 1 ? '' : 's'}`];
-    if (queued > 0)
-        parts.push(`queued: ${queued}`);
-    if (mode)
-        parts.push(mode);
-    return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: parts.join(' · ') }) }));
-};
-export const Composer = ({ onSubmit, placeholder, prompt = '❯' }) => {
-    const buf = useStore($buffer);
-    const completion = useStore($completion);
-    const ui = useStore($ui);
-    const queue = useStore($queue);
-    const prompts = useStore($prompt);
-    const history = useStore($history);
-    const [searchOpen, setSearchOpen] = useState(false);
-    // One-time history load.
-    useEffect(() => {
-        if (history.length === 0)
-            loadHistory();
-    }, [history.length]);
-    // If a prompt is active, show the appropriate overlay instead of the composer.
-    // (Composer hides — Hermes parity.)
-    if (prompts) {
-        if (prompts.kind === 'confirm')
-            return _jsx(ConfirmPrompt, {});
-        if (prompts.kind === 'secret')
-            return _jsx(SecretPrompt, {});
+export { offsetFromPosition };
+function renderWithCursor(value, cursor) {
+    const pos = Math.max(0, Math.min(cursor, value.length));
+    let out = '', done = false;
+    for (const { segment, index } of seg().segment(value)) {
+        if (!done && index >= pos) {
+            out += invert(index === pos && segment !== '\n' ? segment : ' ');
+            done = true;
+            if (index === pos && segment !== '\n') {
+                continue;
+            }
+        }
+        out += segment;
     }
-    if (searchOpen) {
-        return (_jsx(HistorySearch, { onAccept: (entry) => {
-                setBuffer({ text: entry, cursor: entry.length });
-                setSearchOpen(false);
-            }, onCancel: () => setSearchOpen(false) }));
+    return done ? out : out + invert(' ');
+}
+function renderWithSelection(value, start, end) {
+    if (start >= end) {
+        return value;
     }
-    const cols = Math.max(20, ui.cols ?? 80);
-    const submit = useCallback(() => {
-        const text = buf.text;
-        if (!text.trim()) {
-            // Empty submit: just clear.
-            setBuffer(emptyBuffer());
+    return value.slice(0, start) + invert(value.slice(start, end) || ' ') + value.slice(end);
+}
+function useFwdDelete(active) {
+    const ref = useRef(false);
+    const { inputEmitter: ee } = useStdin();
+    useEffect(() => {
+        if (!active) {
             return;
         }
-        pushHistory(text);
-        resetHistoryBrowse();
-        setBuffer(emptyBuffer());
-        if (onSubmit)
-            onSubmit(text);
-    }, [buf.text, onSubmit]);
-    const cycleCompletion = useCallback((dir) => {
-        // Tab pressed: either start a new cycle or rotate the existing one.
-        if (completion.active && completion.candidates.length > 0) {
-            const n = completion.candidates.length;
-            const nextIdx = (completion.index + dir + n) % n;
-            const cand = completion.candidates[nextIdx];
-            const replaced = applyCandidate(buf.text, completion.start, completion.prefix.length, cand);
-            // Use raw setter so we don't reset the cycle.
-            setBufferRaw({ text: replaced.text, cursor: replaced.cursor });
-            $completion.set({
-                ...completion,
-                index: nextIdx,
-                prefix: cand,
-            });
+        const h = (d) => {
+            ref.current = FWD_DEL_RE.test(d);
+        };
+        ee.prependListener('input', h);
+        return () => {
+            ee.removeListener('input', h);
+        };
+    }, [active, ee]);
+    return ref;
+}
+const isPasteResultPromise = (value) => !!value && typeof value.then === 'function';
+export function TextInput({ columns = 80, value, onChange, onPaste, onSubmit, mask, mouseApiRef, voiceRecordKey = DEFAULT_VOICE_RECORD_KEY, placeholder = '', focus = true }) {
+    const [cur, setCur] = useState(value.length);
+    const [sel, setSel] = useState(null);
+    const fwdDel = useFwdDelete(focus);
+    const termFocus = useTerminalFocus();
+    const { stdout } = useStdout();
+    const curRef = useRef(cur);
+    const selRef = useRef(null);
+    const vRef = useRef(value);
+    const self = useRef(false);
+    const pasteBuf = useRef('');
+    const pasteEnd = useRef(null);
+    const pasteTimer = useRef(null);
+    const pastePos = useRef(0);
+    const editVersionRef = useRef(0);
+    const parentChangeTimer = useRef(null);
+    const pendingParentValue = useRef(null);
+    const localRenderTimer = useRef(null);
+    const lineWidthRef = useRef(stringWidth(value.includes('\n') ? value.slice(value.lastIndexOf('\n') + 1) : value));
+    const mouseAnchorRef = useRef(null);
+    const lastClickRef = useRef({ at: 0, offset: -1 });
+    const undo = useRef([]);
+    const redo = useRef([]);
+    const cbChange = useRef(onChange);
+    const cbSubmit = useRef(onSubmit);
+    const cbPaste = useRef(onPaste);
+    cbChange.current = onChange;
+    cbSubmit.current = onSubmit;
+    cbPaste.current = onPaste;
+    const raw = self.current ? vRef.current : value;
+    const display = mask ? raw.replace(/[^\n]/g, mask[0] ?? '*') : raw;
+    const selected = useMemo(() => sel && sel.start !== sel.end ? { end: Math.max(sel.start, sel.end), start: Math.min(sel.start, sel.end) } : null, [sel]);
+    const layout = useMemo(() => cursorLayout(display, cur, columns), [columns, cur, display]);
+    const boxRef = useDeclaredCursor({
+        line: layout.line,
+        column: layout.column,
+        active: focus && termFocus && !selected
+    });
+    // Hide the hardware cursor while a selection is active (prevents
+    // auto-wrap onto the next row when inverted text fills the column
+    // exactly) or when the terminal loses focus (suppresses the hollow-rect
+    // ghost most terminals draw at the parked position).
+    const hideHardwareCursor = focus && !!stdout?.isTTY && (!!selected || !termFocus);
+    useEffect(() => {
+        if (!hideHardwareCursor || !stdout) {
             return;
         }
-        const ctx = tokenAtCursor(buf.text, buf.cursor);
-        if (!ctx)
-            return;
-        const cands = candidatesFor(ctx);
-        if (cands.length === 0)
+        stdout.write('\x1b[?25l');
+        return () => {
+            stdout.write('\x1b[?25h');
+        };
+    }, [hideHardwareCursor, stdout]);
+    const nativeCursor = focus && termFocus && !selected && !!stdout?.isTTY;
+    // Placeholder text is just a hint, not a selection — render it dim
+    // without inverse styling. In a TTY the hardware cursor parks at column
+    // 0 and visually marks the input start. Non-TTY surfaces still need the
+    // synthetic inverse first-char to draw a cursor at all.
+    const rendered = useMemo(() => {
+        if (!focus) {
+            return display || dim(placeholder);
+        }
+        if (!display && placeholder) {
+            return nativeCursor ? dim(placeholder) : invert(placeholder[0] ?? ' ') + dim(placeholder.slice(1));
+        }
+        if (selected) {
+            return renderWithSelection(display, selected.start, selected.end);
+        }
+        return nativeCursor ? display || ' ' : renderWithCursor(display, cur);
+    }, [cur, display, focus, nativeCursor, placeholder, selected]);
+    useEffect(() => {
+        if (self.current) {
+            self.current = false;
+        }
+        else {
+            setCur(value.length);
+            setSel(null);
+            curRef.current = value.length;
+            selRef.current = null;
+            vRef.current = value;
+            lineWidthRef.current = stringWidth(value.includes('\n') ? value.slice(value.lastIndexOf('\n') + 1) : value);
+            undo.current = [];
+            redo.current = [];
+        }
+    }, [value]);
+    useEffect(() => {
+        if (!focus) {
             return;
-        const first = cands[0];
-        const replaced = applyCandidate(buf.text, ctx.start, ctx.token.length, first);
-        setBufferRaw({ text: replaced.text, cursor: replaced.cursor });
-        $completion.set({
-            active: true,
-            prefix: first,
-            candidates: cands,
-            index: 0,
-            start: ctx.start,
+        }
+        const dropSel = () => {
+            if (!selRef.current) {
+                return;
+            }
+            selRef.current = null;
+            setSel(null);
+        };
+        setInputSelection({
+            clear: dropSel,
+            collapseToEnd: () => {
+                dropSel();
+                setCur(vRef.current.length);
+                curRef.current = vRef.current.length;
+            },
+            end: selected?.end ?? curRef.current,
+            start: selected?.start ?? curRef.current,
+            value: vRef.current
         });
-    }, [buf.text, buf.cursor, completion]);
-    useInput((input, key) => {
-        // Ctrl+L: clear buffer.
-        if (key.ctrl && input === 'l') {
-            setBuffer(emptyBuffer());
+        return () => setInputSelection(null);
+    }, [cur, focus, selected]);
+    useEffect(() => () => {
+        if (pasteTimer.current) {
+            clearTimeout(pasteTimer.current);
+        }
+        if (parentChangeTimer.current) {
+            clearTimeout(parentChangeTimer.current);
+        }
+        if (localRenderTimer.current) {
+            clearTimeout(localRenderTimer.current);
+        }
+    }, []);
+    const flushParentChange = () => {
+        if (parentChangeTimer.current) {
+            clearTimeout(parentChangeTimer.current);
+            parentChangeTimer.current = null;
+        }
+        const next = pendingParentValue.current;
+        pendingParentValue.current = null;
+        if (next !== null) {
+            self.current = true;
+            cbChange.current(next);
+        }
+    };
+    const scheduleParentChange = (next) => {
+        pendingParentValue.current = next;
+        if (parentChangeTimer.current) {
             return;
         }
-        // Ctrl+R: open reverse-search overlay.
-        if (key.ctrl && input === 'r') {
-            setSearchOpen(true);
+        parentChangeTimer.current = setTimeout(flushParentChange, 16);
+    };
+    const cancelLocalRender = () => {
+        if (localRenderTimer.current) {
+            clearTimeout(localRenderTimer.current);
+            localRenderTimer.current = null;
+        }
+    };
+    const scheduleLocalRender = () => {
+        if (localRenderTimer.current) {
             return;
         }
-        // Ctrl+C: clear current input (don't crash; parent handles outer SIGINT).
-        if (key.ctrl && input === 'c') {
-            if (buf.text.length === 0) {
-                process.exit(0);
+        localRenderTimer.current = setTimeout(() => {
+            localRenderTimer.current = null;
+            setCur(curRef.current);
+        }, 16);
+    };
+    const canFastEchoBase = () => focus && termFocus && !selected && !mask && !!stdout?.isTTY;
+    const canFastAppend = (current, cursor, text) => {
+        const sw = stringWidth(text);
+        return (canFastEchoBase() &&
+            cursor === current.length &&
+            current.length > 0 &&
+            !current.includes('\n') &&
+            sw === text.length &&
+            lineWidthRef.current + sw < Math.max(1, columns));
+    };
+    const canFastBackspace = (current, cursor) => {
+        if (!canFastEchoBase() || cursor !== current.length || cursor <= 0 || current.includes('\n')) {
+            return false;
+        }
+        return stringWidth(current.slice(prevPos(current, cursor), cursor)) === 1;
+    };
+    const commit = (next, nextCur, track = true, syncParent = true, syncLocal = true, nextLineWidth) => {
+        const prev = vRef.current;
+        const c = snapPos(next, nextCur);
+        editVersionRef.current += 1;
+        if (selRef.current) {
+            selRef.current = null;
+            setSel(null);
+        }
+        if (track && next !== prev) {
+            undo.current.push({ cursor: curRef.current, value: prev });
+            if (undo.current.length > 200) {
+                undo.current.shift();
+            }
+            redo.current = [];
+        }
+        if (syncLocal) {
+            cancelLocalRender();
+            setCur(c);
+        }
+        else {
+            scheduleLocalRender();
+        }
+        curRef.current = c;
+        vRef.current = next;
+        lineWidthRef.current =
+            nextLineWidth ?? stringWidth(next.includes('\n') ? next.slice(next.lastIndexOf('\n') + 1) : next);
+        if (next !== prev) {
+            if (syncParent) {
+                flushParentChange();
+                self.current = true;
+                cbChange.current(next);
+            }
+            else {
+                self.current = true;
+                scheduleParentChange(next);
             }
-            setBuffer(emptyBuffer());
+        }
+    };
+    const swap = (from, to) => {
+        const entry = from.current.pop();
+        if (!entry) {
+            return;
+        }
+        to.current.push({ cursor: curRef.current, value: vRef.current });
+        commit(entry.value, entry.cursor, false);
+    };
+    const emitPaste = (e) => {
+        const startVersion = editVersionRef.current;
+        const h = cbPaste.current?.(e);
+        if (isPasteResultPromise(h)) {
+            const fallbackText = e.text;
+            void h
+                .then(result => {
+                if (result && editVersionRef.current === startVersion) {
+                    commit(result.value, result.cursor);
+                }
+                else if (result && fallbackText && PRINTABLE.test(fallbackText)) {
+                    // User typed while async paste was in-flight — fall back to raw text insert
+                    // so the pasted content is not silently lost.
+                    const cur = curRef.current;
+                    const v = vRef.current;
+                    commit(v.slice(0, cur) + fallbackText + v.slice(cur), cur + fallbackText.length);
+                }
+            })
+                .catch(() => { });
+            return true;
+        }
+        if (h) {
+            commit(h.value, h.cursor);
+        }
+        return !!h;
+    };
+    const flushPaste = () => {
+        const text = pasteBuf.current;
+        const at = pastePos.current;
+        const end = pasteEnd.current ?? at;
+        pasteBuf.current = '';
+        pasteEnd.current = null;
+        pasteTimer.current = null;
+        if (!text) {
+            return;
+        }
+        if (!emitPaste({ cursor: at, text, value: vRef.current }) && PRINTABLE.test(text)) {
+            commit(vRef.current.slice(0, at) + text + vRef.current.slice(end), at + text.length);
+        }
+    };
+    const clearSel = () => {
+        if (!selRef.current) {
             return;
         }
-        // Tab / Shift+Tab.
-        if (key.tab) {
-            cycleCompletion(key.shift ? -1 : 1);
+        selRef.current = null;
+        setSel(null);
+    };
+    const selectAll = () => {
+        const end = vRef.current.length;
+        if (!end) {
             return;
         }
-        // Enter / newline. Ink reports Alt+Enter via key.meta, Shift+Enter via key.shift.
-        if (key.return) {
-            if (key.meta || key.shift) {
-                setBuffer(insert(buf, '\n'));
+        const next = { end, start: 0 };
+        selRef.current = next;
+        setSel(next);
+        setCur(end);
+        curRef.current = end;
+    };
+    const moveCursor = (next, extend = false) => {
+        const c = snapPos(vRef.current, next);
+        const anchor = selRef.current?.start ?? curRef.current;
+        if (!extend || anchor === c) {
+            clearSel();
+        }
+        else {
+            const nextSel = { end: c, start: anchor };
+            selRef.current = nextSel;
+            setSel(nextSel);
+        }
+        setCur(c);
+        curRef.current = c;
+    };
+    const selRange = () => {
+        const range = selRef.current;
+        return range && range.start !== range.end
+            ? { end: Math.max(range.start, range.end), start: Math.min(range.start, range.end) }
+            : null;
+    };
+    const ins = (v, c, s) => v.slice(0, c) + s + v.slice(c);
+    const pastePlainText = (text) => {
+        const cleaned = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        if (!cleaned) {
+            return;
+        }
+        const range = selRange();
+        const nextValue = range
+            ? vRef.current.slice(0, range.start) + cleaned + vRef.current.slice(range.end)
+            : vRef.current.slice(0, curRef.current) + cleaned + vRef.current.slice(curRef.current);
+        const nextCursor = range ? range.start + cleaned.length : curRef.current + cleaned.length;
+        commit(nextValue, nextCursor);
+    };
+    const startMouseSelection = (next) => {
+        const c = snapPos(vRef.current, next);
+        mouseAnchorRef.current = c;
+        selRef.current = { end: c, start: c };
+        setSel(null);
+        setCur(c);
+        curRef.current = c;
+    };
+    const dragMouseSelection = (next) => {
+        if (mouseAnchorRef.current === null) {
+            return;
+        }
+        const c = snapPos(vRef.current, next);
+        const range = { end: c, start: mouseAnchorRef.current };
+        selRef.current = range;
+        setSel(range.start === range.end ? null : range);
+        setCur(c);
+        curRef.current = c;
+    };
+    const endMouseSelection = () => {
+        mouseAnchorRef.current = null;
+        const range = selRef.current;
+        if (range && range.start === range.end) {
+            selRef.current = null;
+            setSel(null);
+            return;
+        }
+        const normalized = selRange();
+        if (isMac && normalized) {
+            void writeClipboardText(vRef.current.slice(normalized.start, normalized.end));
+        }
+    };
+    const offsetAt = (e) => offsetFromPosition(display, e.localRow ?? 0, e.localCol ?? 0, columns);
+    const isMultiClickAt = (offset) => {
+        const now = Date.now();
+        const last = lastClickRef.current;
+        lastClickRef.current = { at: now, offset };
+        return now - last.at < MULTI_CLICK_MS && offset === last.offset;
+    };
+    if (mouseApiRef) {
+        mouseApiRef.current = {
+            dragAt: (row, col) => dragMouseSelection(offsetFromPosition(display, row, col, columns)),
+            end: endMouseSelection,
+            startAtBeginning: () => startMouseSelection(0)
+        };
+    }
+    useInput((inp, k, event) => {
+        const eventRaw = event.keypress.raw;
+        // Configured voice shortcut wins over composer-level defaults like
+        // paste/copy so users who bind voice to ctrl+v / alt+v / cmd+v
+        // actually get voice toggled instead of a paste (Copilot round-7
+        // follow-up on #19835). The pass-through predicate is a no-op for
+        // ordinary typing and plain paste when voice is unbound to 'v'.
+        if (shouldPassThroughToGlobalHandler(inp, k, voiceRecordKey)) {
+            return;
+        }
+        if (eventRaw === '\x1bv' ||
+            eventRaw === '\x1bV' ||
+            eventRaw === '\x16' ||
+            (isMac && isActionMod(k) && inp.toLowerCase() === 'v')) {
+            if (cbPaste.current) {
+                return void emitPaste({ cursor: curRef.current, hotkey: true, text: '', value: vRef.current });
+            }
+            if (isMac) {
+                void readClipboardText().then(text => {
+                    if (text) {
+                        pastePlainText(text);
+                    }
+                });
+            }
+            return;
+        }
+        if (isMac && isActionMod(k) && inp.toLowerCase() === 'c') {
+            const range = selRange();
+            if (range) {
+                const text = vRef.current.slice(range.start, range.end);
+                void writeClipboardText(text);
+            }
+            return;
+        }
+        if (k.upArrow || k.downArrow) {
+            const next = lineNav(vRef.current, curRef.current, k.upArrow ? -1 : 1);
+            if (next !== null) {
+                moveCursor(next, k.shift);
                 return;
             }
-            submit();
             return;
         }
-        if (key.backspace || key.delete) {
-            // Ink convention: `key.delete` is forward-delete on some terms; `key.backspace` for backspace.
-            if (key.delete && !key.backspace) {
-                setBuffer(bufDel(buf));
+        if (k.return) {
+            if (k.shift || k.ctrl || (isMac ? isActionMod(k) : k.meta)) {
+                flushParentChange();
+                commit(ins(vRef.current, curRef.current, '\n'), curRef.current + 1);
             }
             else {
-                setBuffer(backspace(buf));
+                flushParentChange();
+                cbSubmit.current?.(vRef.current);
             }
             return;
         }
-        if (key.leftArrow) {
-            setBuffer(moveLeft(buf));
+        let c = curRef.current;
+        let v = vRef.current;
+        const mod = isActionMod(k);
+        const wordMod = mod || k.meta;
+        const actionHome = k.home || (!isMac && mod && inp === 'a') || isMacActionFallback(k, inp, 'a');
+        const actionEnd = k.end || (mod && inp === 'e') || isMacActionFallback(k, inp, 'e');
+        const actionDeleteToStart = (mod && inp === 'u') || isMacActionFallback(k, inp, 'u');
+        const actionKillToEnd = (mod && inp === 'k') || isMacActionFallback(k, inp, 'k');
+        const actionDeleteWord = (mod && inp === 'w') || isMacActionFallback(k, inp, 'w');
+        const range = selRange();
+        const delFwd = k.delete || fwdDel.current;
+        if (mod && inp === 'z') {
+            return swap(undo, redo);
+        }
+        if ((mod && inp === 'y') || (mod && k.shift && inp === 'z')) {
+            return swap(redo, undo);
+        }
+        if (isMac && mod && inp === 'a') {
+            return selectAll();
+        }
+        if (actionHome) {
+            c = 0;
+            moveCursor(c, k.shift);
             return;
         }
-        if (key.rightArrow) {
-            setBuffer(moveRight(buf));
+        else if (actionEnd) {
+            c = v.length;
+            moveCursor(c, k.shift);
             return;
         }
-        if (key.upArrow) {
-            // History cycle when on the first logical line.
-            if (onFirstLine(buf)) {
-                const entry = historyPrev(buf.text);
-                if (entry !== null) {
-                    setBuffer({ text: entry, cursor: entry.length });
-                }
-                return;
+        else if (k.leftArrow) {
+            if (range && !wordMod && !k.shift) {
+                clearSel();
+                c = range.start;
+            }
+            else {
+                c = wordMod ? wordLeft(v, c) : prevPos(v, c);
             }
-            setBuffer(moveUp(buf));
+            moveCursor(c, k.shift);
             return;
         }
-        if (key.downArrow) {
-            if (onLastLine(buf)) {
-                const entry = historyNext();
-                if (entry !== null) {
-                    setBuffer({ text: entry, cursor: entry.length });
-                }
-                return;
+        else if (k.rightArrow) {
+            if (range && !wordMod && !k.shift) {
+                clearSel();
+                c = range.end;
+            }
+            else {
+                c = wordMod ? wordRight(v, c) : nextPos(v, c);
             }
-            setBuffer(moveDown(buf));
+            moveCursor(c, k.shift);
             return;
         }
-        // Home / End — Ink doesn't expose these directly; they often arrive as raw escapes.
-        if (key.ctrl && input === 'a') {
-            setBuffer(moveHome(buf));
-            return;
+        else if (wordMod && inp === 'b') {
+            clearSel();
+            c = wordLeft(v, c);
         }
-        if (key.ctrl && input === 'e') {
-            setBuffer(moveEnd(buf));
-            return;
+        else if (wordMod && inp === 'f') {
+            clearSel();
+            c = wordRight(v, c);
+        }
+        else if (range && (k.backspace || delFwd)) {
+            v = v.slice(0, range.start) + v.slice(range.end);
+            c = range.start;
         }
-        if (key.escape) {
-            // Esc: cancel completion, otherwise clear buffer.
-            if (completion.active) {
-                resetCompletion();
+        else if (k.backspace && c > 0) {
+            if (wordMod) {
+                const t = wordLeft(v, c);
+                v = v.slice(0, t) + v.slice(c);
+                c = t;
+            }
+            else if (canFastBackspace(v, c)) {
+                const t = prevPos(v, c);
+                v = v.slice(0, t) + v.slice(c);
+                c = t;
+                stdout.write('\b \b');
+                commit(v, c, true, false, false, Math.max(0, lineWidthRef.current - 1));
                 return;
             }
-            setBuffer(emptyBuffer());
-            return;
+            else {
+                const t = prevPos(v, c);
+                v = v.slice(0, t) + v.slice(c);
+                c = t;
+            }
         }
-        // Printable input.
-        if (input && !key.ctrl && !key.meta) {
-            setBuffer(insert(buf, input));
-            return;
+        else if (delFwd && c < v.length) {
+            if (wordMod) {
+                const t = wordRight(v, c);
+                v = v.slice(0, c) + v.slice(t);
+            }
+            else {
+                v = v.slice(0, c) + v.slice(nextPos(v, c));
+            }
         }
-    });
-    const stats = bufferStats(buf.text);
-    const wrapped = renderWrapped(buf, cols);
-    const showPlaceholder = buf.text.length === 0 && placeholder;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { color: PROMPT_COLOR, children: [prompt, " "] }), showPlaceholder ? (_jsx(Text, { dimColor: true, children: placeholder })) : (_jsx(Box, { flexDirection: "column", children: wrapped.map((line, i) => (_jsx(Text, { children: line || ' ' }, i))) }))] }), _jsx(Hints, { chars: stats.chars, lineCount: stats.lineCount, queued: queue.length, mode: completion.active ? `tab ${completion.index + 1}/${completion.candidates.length}` : undefined })] }));
-};
-export const TextInput = ({ value, onChange, onSubmit, placeholder, prompt }) => {
-    const buf = useStore($buffer);
-    // Sync controlled value into the store on mount / external change.
-    useEffect(() => {
-        if (buf.text !== value) {
-            setBuffer({ text: value, cursor: value.length });
+        else if (actionDeleteWord) {
+            if (range) {
+                v = v.slice(0, range.start) + v.slice(range.end);
+                c = range.start;
+            }
+            else if (c > 0) {
+                clearSel();
+                const t = wordLeft(v, c);
+                v = v.slice(0, t) + v.slice(c);
+                c = t;
+            }
+            else {
+                return;
+            }
         }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [value]);
-    // Push buffer changes back to parent on every text change.
-    useEffect(() => {
-        if (buf.text !== value)
-            onChange(buf.text);
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [buf.text]);
-    return (_jsx(Composer, { placeholder: placeholder, prompt: prompt, onSubmit: (t) => {
-            onChange('');
-            if (onSubmit)
-                onSubmit(t);
-        } }));
-};
-// Re-exports for tests / consumers.
-export { cursorRowCol };
+        else if (actionDeleteToStart) {
+            if (range) {
+                v = v.slice(0, range.start) + v.slice(range.end);
+                c = range.start;
+            }
+            else {
+                v = v.slice(c);
+                c = 0;
+            }
+        }
+        else if (actionKillToEnd) {
+            if (range) {
+                v = v.slice(0, range.start) + v.slice(range.end);
+                c = range.start;
+            }
+            else {
+                v = v.slice(0, c);
+            }
+        }
+        else if (event.keypress.isPasted || inp.length > 0) {
+            const bracketed = event.keypress.isPasted || inp.includes('[200~');
+            const text = inp.replace(BRACKET_PASTE, '').replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+            if (bracketed && emitPaste({ bracketed: true, cursor: c, text, value: v })) {
+                return;
+            }
+            if (!text) {
+                return;
+            }
+            if (text === '\n') {
+                return commit(ins(v, c, '\n'), c + 1);
+            }
+            if (text.length > 1 || text.includes('\n')) {
+                if (!pasteBuf.current) {
+                    pastePos.current = range ? range.start : c;
+                    pasteEnd.current = range ? range.end : pastePos.current;
+                }
+                pasteBuf.current += text;
+                if (pasteTimer.current) {
+                    clearTimeout(pasteTimer.current);
+                }
+                pasteTimer.current = setTimeout(flushPaste, 50);
+                return;
+            }
+            if (PRINTABLE.test(text)) {
+                if (range) {
+                    v = v.slice(0, range.start) + text + v.slice(range.end);
+                    c = range.start + text.length;
+                }
+                else {
+                    const simpleAppend = canFastAppend(v, c, text);
+                    v = v.slice(0, c) + text + v.slice(c);
+                    c += text.length;
+                    if (simpleAppend) {
+                        stdout.write(text);
+                        commit(v, c, true, false, false, lineWidthRef.current + stringWidth(text));
+                        return;
+                    }
+                }
+            }
+            else {
+                return;
+            }
+        }
+        else {
+            return;
+        }
+        commit(v, c);
+    }, { isActive: focus });
+    return (_jsx(Box, { onClick: (e) => {
+            if (!focus) {
+                return;
+            }
+            e.stopImmediatePropagation?.();
+            clearSel();
+            const next = offsetAt(e);
+            setCur(next);
+            curRef.current = next;
+        }, onMouseDown: (e) => {
+            if (!focus) {
+                return;
+            }
+            // Right-click → route through the same path as Alt+V so the composer
+            // clipboard RPC (text or image) handles it.
+            if (e.button === 2) {
+                e.stopImmediatePropagation?.();
+                emitPaste({ cursor: curRef.current, hotkey: true, text: '', value: vRef.current });
+                return;
+            }
+            if (e.button !== 0) {
+                return;
+            }
+            e.stopImmediatePropagation?.();
+            const offset = offsetAt(e);
+            if (isMultiClickAt(offset)) {
+                mouseAnchorRef.current = null;
+                selectAll();
+                return;
+            }
+            startMouseSelection(offset);
+        }, onMouseDrag: (e) => {
+            if (!focus || e.button !== 0 || mouseAnchorRef.current === null) {
+                return;
+            }
+            e.stopImmediatePropagation?.();
+            dragMouseSelection(offsetAt(e));
+        }, onMouseUp: (e) => {
+            e.stopImmediatePropagation?.();
+            endMouseSelection();
+        }, ref: boxRef, width: columns, children: _jsx(Text, { wrap: "wrap", children: rendered }) }));
+}
+export const shouldPassThroughToGlobalHandler = (input, key, voiceRecordKey = DEFAULT_VOICE_RECORD_KEY) => (key.ctrl && input === 'c') ||
+    (key.ctrl && input === 'x') ||
+    key.tab ||
+    (key.shift && key.tab) ||
+    key.pageUp ||
+    key.pageDown ||
+    key.escape ||
+    isVoiceToggleKey(key, input, voiceRecordKey);