@aragon-agent/cli 0.6.47 → 0.6.48

package/dist/input/cursor-report.js

@@ -1,97 +0,0 @@
-/**
- * Cursor Position Report parsing (tui-bottom-anchored-live-region §4.5).
- *
- * The bottom anchor needs one number the writer cannot compute: how many rows are
- * left below the cursor. `ESC[6n` is the only way to ask, and the terminal answers
- * with `ESC[<row>;<col>R` (DECXCPR adds a `?`: `ESC[?<row>;<col>R`) on STDIN —
- * the same stream the user types on. Two things follow, and both live here:
- *
- *  1. THE ANSWER MUST BE STRIPPED BEFORE INK SEES IT. A report that reaches Ink
- *     travels the keystroke path: `[` is 0x5B, so `PromptInput`'s control-sequence
- *     guard passes it through and the user's draft gets `[12;1R` typed into it (the
- *     same class of accident the mouse filter exists to prevent).
- *  2. THE ANSWER CAN ARRIVE IN TWO CHUNKS. ConPTY, tmux and a loaded SSH session
- *     all split reads at arbitrary points, and a half report (`ESC[12`) is worse
- *     than a whole one: `parse-keypress` has no branch for it.
- *
- * Pure functions only, mirroring `mouse-events.ts`: the filter owns the buffering
- * and the timers, this module owns the shapes.
- */
-/** The query for a Cursor Position Report (DSR 6). ASCII by construction. */
-export const CURSOR_REPORT_QUERY = '\x1b[6n';
-/**
- * `ESC[<row>;<col>R`, with the DECXCPR `?` accepted. Anchored on `ESC[` plus digits
- * and one `;`, which is what keeps it from matching a private-mode write such as
- * `ESC[?25l` (that one ends in a letter this pattern cannot accept).
- *
- * Built per call rather than shared: a module-level `/g` regex carries `lastIndex`
- * between calls, which turns a pure function into a stateful one.
- */
-const reportPattern = () => /\x1b\[\??(\d+);(\d+)R/g;
-/**
- * A PROPER prefix of a report: `ESC`, `ESC[`, then an optional `?`, then digits, at
- * most one `;`, then more digits. Nothing a keyboard produces matches past `ESC[`
- * (arrow keys end in a letter), so the filter's 12 ms hold stays a rare path.
- */
-const PREFIX = /^\x1b(\[(\?(\d*(;\d*)?)?|\d*(;\d*)?)?)?$/;
-/** True when `s` is a non-empty proper prefix of a possible report. */
-export function isCursorReportPrefix(s) {
-    return s.length > 0 && s.length < 24 && PREFIX.test(s);
-}
-/**
- * Split the reports out of one chunk.
- *
- * `pending` carries the tail that might still complete into a report. It is only
- * ever the LAST fragment: the scan is left to right, so anything before a complete
- * report is settled text.
- */
-export function splitCursorReports(text) {
-    const reports = [];
-    const pattern = reportPattern();
-    let out = '';
-    let index = 0;
-    for (let match = pattern.exec(text); match !== null; match = pattern.exec(text)) {
-        out += text.slice(index, match.index);
-        reports.push({ row: Number(match[1]), col: Number(match[2]) });
-        index = match.index + match[0].length;
-    }
-    out += text.slice(index);
-    const pendingLength = trailingCprPrefixLength(out);
-    if (pendingLength === 0)
-        return { text: out, reports, pending: '' };
-    return {
-        text: out.slice(0, out.length - pendingLength),
-        reports,
-        pending: out.slice(out.length - pendingLength),
-    };
-}
-/**
- * Length of the trailing run of `text` that is a proper prefix of a report, or 0.
- *
- * LONGEST MATCH WINS, unlike the mouse family's shortest-wins rule. The families are
- * combined with `max()`, so only the longest answer ever survives, and a longer hold
- * is never wrong here: `ESC[1` can still become `ESC[12;1R`, while the shorter
- * answer `ESC` could not describe it. The bound is the longest report the terminals
- * we target emit (DECXCPR with a `?` and three-digit coordinates).
- */
-export function trailingCprPrefixLength(text) {
-    const max = Math.min(text.length, 24);
-    for (let k = max; k >= 1; k -= 1) {
-        if (isCursorReportPrefix(text.slice(text.length - k)))
-            return k;
-    }
-    return 0;
-}
-/** The query bytes, as a function so call sites read as an action rather than a literal. */
-export function formatCursorReportQuery() {
-    return CURSOR_REPORT_QUERY;
-}
-/**
- * Rows left below a reported cursor row on a terminal of `rows` rows.
- * `0` means the cursor is already on the last row; `null` when the height is unknown.
- */
-export function spaceBelowFromReport(report, rows) {
-    if (rows === undefined || !Number.isFinite(rows) || rows < 1)
-        return null;
-    return Math.max(0, Math.floor(rows) - 1 - (report.row - 1));
-}

package/dist/input/enter-sequences.d.ts

@@ -1,64 +0,0 @@
-/**
- * Enter-family sequence recognition (tui-shift-enter-copy-queue §3.3) -- pure,
- * stream-free, no node/React imports, callable from any test environment.
- *
- * WHY THIS LIVES BELOW INK. Ink 5's `parse-keypress.js` calls `parseKeypress`
- * ONCE per stdin chunk and hard-codes `shift: false` for the exact string
- * `'\r'`, so a component can never see `key.return && key.shift` -- the
- * `PromptInput` branch for it is dead code. Worse, terminals that DO encode a
- * distinct Shift+Enter send CSI-u (`\x1b[13;2u`), which Ink's `fnKeyRe` does
- * not match: the ESC is stripped by `use-input.js` and `'[13;2u'` falls through
- * to the PRINTABLE branch, typing garbage into the draft. The only layer that
- * sees the bytes before Ink mangles them is the stdin filter, which is where
- * the mouse-report and paste-marker dialects are already translated.
- *
- * THE CONTRACT: rewrite every recognized sequence to ONE normalized token --
- * `ENTER_NEWLINE_FRAME` for "this was a modified Enter, the user wants a
- * newline" and `'\r'` for the unmodified CSI-u Enter some other program left
- * behind. No state, no partial-output: `rewriteEnterSequences` is idempotent
- * because its output contains none of its inputs.
- */
-/** What one recognized sequence means, for tests and `/terminal-setup` copy. */
-export interface EnterSequenceSpec {
-    /** The exact byte sequence a terminal sends for this key. */
-    readonly seq: string;
-    /** The chord it names, e.g. `'shift+enter'`, `'ctrl+alt+enter'`, `'enter'`. */
-    readonly meaning: string;
-    /** What `rewriteEnterSequences` replaces it with. */
-    readonly to: string;
-}
-/**
- * The recognition table (§3.3). CSI-u modifiers 2-8 cover Shift(2), Alt(3),
- * Shift+Alt(4), Ctrl(5), Ctrl+Shift(6), Ctrl+Alt(7), Ctrl+Alt+Shift(8) as
- * emitted by kitty/WezTerm keyboard-enhancement mode and by
- * `modifyOtherKeys=2`; every one of them means "Enter with a modifier", and a
- * modified Enter must NEVER submit the draft. `\x1b\r` / `\x1b\n` are the
- * classic Alt+Enter encodings. `\x1b[13u` (no modifier field) is what a
- * leftover kitty mode sends for a PLAIN Enter: it must submit, so it maps to
- * `'\r'` rather than to a newline.
- */
-export declare const ENTER_SEQUENCES: readonly EnterSequenceSpec[];
-export type EnterSequenceSegment = {
-    kind: 'text';
-    text: string;
-} | {
-    kind: 'newline';
-} | {
-    kind: 'submit';
-};
-/** Split explicit keys using the recognition table; bare CR/LF remain text. */
-export declare function splitEnterSequences(text: string): EnterSequenceSegment[];
-/** Normalize explicit Enter keys without changing unknown sequences. */
-export declare function rewriteEnterSequences(text: string): string;
-/**
- * Length of the trailing run of `text` that is a proper prefix of an
- * Enter-family sequence, or 0.
- *
- * LONGEST MATCH, not shortest: unlike the mouse and paste families, a torn
- * CSI-u sequence diverges from its siblings only at the LAST byte
- * (`\x1b[13;` + `2u`), so every byte before the divergence point must be held
- * back for the next chunk or the sequence is destroyed a byte early. Feeding
- * the result into the filter's `keep = max(...)` alongside the other two
- * families keeps every family's hold intact.
- */
-export declare function trailingEnterPrefixLength(text: string): number;

package/dist/input/enter-sequences.js

@@ -1,153 +0,0 @@
-/**
- * Enter-family sequence recognition (tui-shift-enter-copy-queue §3.3) -- pure,
- * stream-free, no node/React imports, callable from any test environment.
- *
- * WHY THIS LIVES BELOW INK. Ink 5's `parse-keypress.js` calls `parseKeypress`
- * ONCE per stdin chunk and hard-codes `shift: false` for the exact string
- * `'\r'`, so a component can never see `key.return && key.shift` -- the
- * `PromptInput` branch for it is dead code. Worse, terminals that DO encode a
- * distinct Shift+Enter send CSI-u (`\x1b[13;2u`), which Ink's `fnKeyRe` does
- * not match: the ESC is stripped by `use-input.js` and `'[13;2u'` falls through
- * to the PRINTABLE branch, typing garbage into the draft. The only layer that
- * sees the bytes before Ink mangles them is the stdin filter, which is where
- * the mouse-report and paste-marker dialects are already translated.
- *
- * THE CONTRACT: rewrite every recognized sequence to ONE normalized token --
- * `ENTER_NEWLINE_FRAME` for "this was a modified Enter, the user wants a
- * newline" and `'\r'` for the unmodified CSI-u Enter some other program left
- * behind. No state, no partial-output: `rewriteEnterSequences` is idempotent
- * because its output contains none of its inputs.
- */
-import { ENTER_NEWLINE_FRAME } from './limits.js';
-/**
- * The recognition table (§3.3). CSI-u modifiers 2-8 cover Shift(2), Alt(3),
- * Shift+Alt(4), Ctrl(5), Ctrl+Shift(6), Ctrl+Alt(7), Ctrl+Alt+Shift(8) as
- * emitted by kitty/WezTerm keyboard-enhancement mode and by
- * `modifyOtherKeys=2`; every one of them means "Enter with a modifier", and a
- * modified Enter must NEVER submit the draft. `\x1b\r` / `\x1b\n` are the
- * classic Alt+Enter encodings. `\x1b[13u` (no modifier field) is what a
- * leftover kitty mode sends for a PLAIN Enter: it must submit, so it maps to
- * `'\r'` rather than to a newline.
- */
-export const ENTER_SEQUENCES = [
-    { seq: '\x1b[13;1u', meaning: 'enter', to: '\r' },
-    {
-        seq: '\x1b[13;2u',
-        meaning: 'shift+enter',
-        to: ENTER_NEWLINE_FRAME,
-    },
-    {
-        seq: '\x1b[13;3u',
-        meaning: 'alt+enter',
-        to: ENTER_NEWLINE_FRAME,
-    },
-    {
-        seq: '\x1b[13;4u',
-        meaning: 'shift+alt+enter',
-        to: ENTER_NEWLINE_FRAME,
-    },
-    {
-        seq: '\x1b[13;5u',
-        meaning: 'ctrl+enter',
-        to: ENTER_NEWLINE_FRAME,
-    },
-    {
-        seq: '\x1b[13;6u',
-        meaning: 'ctrl+shift+enter',
-        to: ENTER_NEWLINE_FRAME,
-    },
-    {
-        seq: '\x1b[13;7u',
-        meaning: 'ctrl+alt+enter',
-        to: ENTER_NEWLINE_FRAME,
-    },
-    {
-        seq: '\x1b[13;8u',
-        meaning: 'ctrl+alt+shift+enter',
-        to: ENTER_NEWLINE_FRAME,
-    },
-    {
-        seq: '\x1b\r',
-        meaning: 'alt+enter',
-        to: ENTER_NEWLINE_FRAME,
-    },
-    {
-        seq: '\x1b\n',
-        meaning: 'alt+enter',
-        to: ENTER_NEWLINE_FRAME,
-    },
-    {
-        seq: '\x1b[13u',
-        meaning: 'enter',
-        to: '\r',
-    },
-];
-/**
- * Longest strict prefix any recognized sequence can have. Derived from the
- * table rather than hard-coded so adding a sequence can never leave the hold
- * ceiling behind: the longest sequence is 7 bytes, so a torn sequence can hold
- * up to 6 of them.
- */
-const MAX_ENTER_PREFIX = Math.max(...ENTER_SEQUENCES.map((s) => s.seq.length)) - 1;
-/** Split explicit keys using the recognition table; bare CR/LF remain text. */
-export function splitEnterSequences(text) {
-    const segments = [];
-    let start = 0;
-    let index = 0;
-    while (index < text.length) {
-        const match = text[index] === '\x1b'
-            ? ENTER_SEQUENCES.find((spec) => text.startsWith(spec.seq, index)) : undefined;
-        if (!match) {
-            index += 1;
-            continue;
-        }
-        if (index > start)
-            segments.push({ kind: 'text', text: text.slice(start, index) });
-        segments.push({ kind: match.to === '\r' ? 'submit' : 'newline' });
-        index += match.seq.length;
-        start = index;
-    }
-    if (start < text.length)
-        segments.push({ kind: 'text', text: text.slice(start) });
-    return segments;
-}
-/** Normalize explicit Enter keys without changing unknown sequences. */
-export function rewriteEnterSequences(text) {
-    return splitEnterSequences(text).map((segment) => {
-        if (segment.kind === 'text')
-            return segment.text;
-        return segment.kind === 'submit' ? '\r' : ENTER_NEWLINE_FRAME;
-    }).join('');
-}
-/** True when `s` is a PROPER prefix of some recognized sequence (never whole). */
-function isEnterPrefix(s) {
-    if (s.length === 0 || s.length > MAX_ENTER_PREFIX)
-        return false;
-    for (const spec of ENTER_SEQUENCES) {
-        // `length >`, not `startsWith` alone: `startsWith` accepts the WHOLE
-        // sequence too, and holding a complete sequence back would add 12 ms
-        // of latency to a key that is ready to be rewritten right now.
-        if (spec.seq.length > s.length && spec.seq.startsWith(s))
-            return true;
-    }
-    return false;
-}
-/**
- * Length of the trailing run of `text` that is a proper prefix of an
- * Enter-family sequence, or 0.
- *
- * LONGEST MATCH, not shortest: unlike the mouse and paste families, a torn
- * CSI-u sequence diverges from its siblings only at the LAST byte
- * (`\x1b[13;` + `2u`), so every byte before the divergence point must be held
- * back for the next chunk or the sequence is destroyed a byte early. Feeding
- * the result into the filter's `keep = max(...)` alongside the other two
- * families keeps every family's hold intact.
- */
-export function trailingEnterPrefixLength(text) {
-    const max = Math.min(text.length, MAX_ENTER_PREFIX);
-    for (let k = max; k >= 1; k -= 1) {
-        if (isEnterPrefix(text.slice(text.length - k)))
-            return k;
-    }
-    return 0;
-}

package/dist/input/interrupt-gesture.d.ts

@@ -1,18 +0,0 @@
-/** Confirmation window for two independent decoded Escape events. */
-export declare const INTERRUPT_CONFIRM_MS = 1500;
-export type InterruptGestureState = {
-    phase: 'ready';
-} | {
-    phase: 'armed';
-    armedAt: number;
-} | {
-    phase: 'stopping';
-};
-export interface InterruptGestureResult {
-    state: InterruptGestureState;
-    action: 'hint' | 'abort' | 'force-stop';
-}
-/** Advance using a monotonic clock; the caller owns the current run's lifetime. */
-export declare function advanceInterruptGesture(state: InterruptGestureState, now: number): InterruptGestureResult;
-/** Other input cancels confirmation, but cannot undo an already requested stop. */
-export declare function cancelInterruptConfirmation(state: InterruptGestureState): InterruptGestureState;

package/dist/input/interrupt-gesture.js

@@ -1,19 +0,0 @@
-/** Confirmation window for two independent decoded Escape events. */
-export const INTERRUPT_CONFIRM_MS = 1500;
-/** Advance using a monotonic clock; the caller owns the current run's lifetime. */
-export function advanceInterruptGesture(state, now) {
-    if (state.phase === 'stopping') {
-        return { state: { phase: 'ready' }, action: 'force-stop' };
-    }
-    if (state.phase === 'armed') {
-        const elapsed = now - state.armedAt;
-        if (elapsed >= 0 && elapsed <= INTERRUPT_CONFIRM_MS) {
-            return { state: { phase: 'stopping' }, action: 'abort' };
-        }
-    }
-    return { state: { phase: 'armed', armedAt: now }, action: 'hint' };
-}
-/** Other input cancels confirmation, but cannot undo an already requested stop. */
-export function cancelInterruptConfirmation(state) {
-    return state.phase === 'armed' ? { phase: 'ready' } : state;
-}

package/dist/input/keyboard-enhancement.d.ts

@@ -1,42 +0,0 @@
-/**
- * Keyboard-enhancement lifecycle (the Shift+Enter newline fix).
- *
- * WHY A LIFECYCLE MODULE AND NOT ANOTHER `screen.ts` MODE. The alternate
- * screen is bound to fullscreen rendering; keyboard enhancement must run in
- * every interactive session, inline included, because the composer is always
- * there. It still follows the screen module's discipline: bytes are written
- * ONLY for a TTY stdout, restore is idempotent, and the caller owns every
- * decision -- this module is told the resolved capability and never derives
- * one from config or environment.
- *
- * PLATFORM SPLIT, DECIDED BY BYTE-LEVEL PROBES (see
- * docs/diagnoses/shift-enter-newline-dead-by-default):
- *
- * - win32: `?9001h` (win32-input-mode). It works through ConPTY on both
- *   conhost and Windows Terminal; kitty `CSI > 1 u` is swallowed there (a
- *   `CSI ? u` query never answers) and modifyOtherKeys is a no-op. Gated on
- *   the SAME `vtInputSupported` measurement the mouse feature uses: on Node
- *   < 22.17 / < 24.2 libuv never turns on `ENABLE_VIRTUAL_TERMINAL_INPUT`,
- *   so the records cannot reach the process and the mode would be a lie.
- * - everything else: kitty disambiguate (`CSI > 1 u`) plus
- *   `modifyOtherKeys=2`. iTerm2 / kitty / ghostty / WezTerm / foot implement
- *   at least one; terminals that implement neither ignore both bytes.
- */
-export interface KeyboardEnhancementHandle {
-    /** Idempotent; writes the disable bytes exactly once. */
-    restore(): void;
-}
-/** The handle a gated-out session reads: nothing was pushed, nothing unwinds. */
-export declare const NOOP_KEYBOARD_ENHANCEMENT: KeyboardEnhancementHandle;
-/**
- * Ask the terminal to report modified keys distinctly. The returned handle's
- * `restore()` hands the keyboard back; wire it into the same convergence
- * point the screen restore uses so every exit path unwinds both.
- *
- * `vtInputSupported` is the measurement `cli.tsx` already resolves for the
- * mouse gate; on win32 it decides between `?9001h` and nothing at all.
- */
-export declare function enableKeyboardEnhancement(stdout: NodeJS.WriteStream | undefined, opts: {
-    readonly platform: string;
-    readonly vtInputSupported: boolean;
-}): KeyboardEnhancementHandle;

package/dist/input/keyboard-enhancement.js

@@ -1,65 +0,0 @@
-/**
- * Keyboard-enhancement lifecycle (the Shift+Enter newline fix).
- *
- * WHY A LIFECYCLE MODULE AND NOT ANOTHER `screen.ts` MODE. The alternate
- * screen is bound to fullscreen rendering; keyboard enhancement must run in
- * every interactive session, inline included, because the composer is always
- * there. It still follows the screen module's discipline: bytes are written
- * ONLY for a TTY stdout, restore is idempotent, and the caller owns every
- * decision -- this module is told the resolved capability and never derives
- * one from config or environment.
- *
- * PLATFORM SPLIT, DECIDED BY BYTE-LEVEL PROBES (see
- * docs/diagnoses/shift-enter-newline-dead-by-default):
- *
- * - win32: `?9001h` (win32-input-mode). It works through ConPTY on both
- *   conhost and Windows Terminal; kitty `CSI > 1 u` is swallowed there (a
- *   `CSI ? u` query never answers) and modifyOtherKeys is a no-op. Gated on
- *   the SAME `vtInputSupported` measurement the mouse feature uses: on Node
- *   < 22.17 / < 24.2 libuv never turns on `ENABLE_VIRTUAL_TERMINAL_INPUT`,
- *   so the records cannot reach the process and the mode would be a lie.
- * - everything else: kitty disambiguate (`CSI > 1 u`) plus
- *   `modifyOtherKeys=2`. iTerm2 / kitty / ghostty / WezTerm / foot implement
- *   at least one; terminals that implement neither ignore both bytes.
- */
-import { CSI_U_DISABLE, CSI_U_ENABLE, } from './csiu-keys.js';
-import { WIN32_INPUT_DISABLE, WIN32_INPUT_ENABLE } from './win32-input-mode.js';
-const NOOP_HANDLE = { restore() { } };
-/** The handle a gated-out session reads: nothing was pushed, nothing unwinds. */
-export const NOOP_KEYBOARD_ENHANCEMENT = NOOP_HANDLE;
-function safeWrite(stdout, data) {
-    try {
-        stdout.write(data);
-    }
-    catch {
-        // A closed/broken stdout must never crash the exit path.
-    }
-}
-/**
- * Ask the terminal to report modified keys distinctly. The returned handle's
- * `restore()` hands the keyboard back; wire it into the same convergence
- * point the screen restore uses so every exit path unwinds both.
- *
- * `vtInputSupported` is the measurement `cli.tsx` already resolves for the
- * mouse gate; on win32 it decides between `?9001h` and nothing at all.
- */
-export function enableKeyboardEnhancement(stdout, opts) {
-    if (!stdout || !stdout.isTTY || typeof stdout.write !== 'function')
-        return NOOP_HANDLE;
-    const enable = opts.platform === 'win32'
-        ? (opts.vtInputSupported ? WIN32_INPUT_ENABLE : '')
-        : CSI_U_ENABLE;
-    if (enable.length === 0)
-        return NOOP_HANDLE;
-    const disable = opts.platform === 'win32' ? WIN32_INPUT_DISABLE : CSI_U_DISABLE;
-    safeWrite(stdout, enable);
-    let restored = false;
-    return {
-        restore() {
-            if (restored)
-                return;
-            restored = true;
-            safeWrite(stdout, disable);
-        },
-    };
-}

package/dist/input/keymap.d.ts

@@ -1,20 +0,0 @@
-/**
- * Editing keymap (spec §3.10). Pure: maps a raw `useInput` `(input, key)` pair
- * to a line-editing intent. Ink does not surface Home/End/word keys on its
- * `key` object — those arrive as raw escape sequences in `input` — so this
- * recognizer inspects both the parsed `key` flags (for Ctrl/Alt combos) and the
- * raw sequence (for Home/End/word jumps), and returns `null` for anything it
- * does not own so the caller can drop unknown control bytes instead of
- * inserting them into the buffer.
- */
-export type EditIntent = 'home' | 'end' | 'wordLeft' | 'wordRight' | 'deleteWordBack' | 'killToStart' | 'killToEnd';
-/** Minimal shape of Ink's `Key` we consult (structurally compatible). */
-export interface KeyState {
-    ctrl?: boolean;
-    meta?: boolean;
-    shift?: boolean;
-    leftArrow?: boolean;
-    rightArrow?: boolean;
-}
-/** Recognize a line-editing intent, or `null` if this key is not an edit op. */
-export declare function recognize(input: string, key: KeyState): EditIntent | null;

package/dist/input/keymap.js

@@ -1,99 +0,0 @@
-/**
- * Editing keymap (spec §3.10). Pure: maps a raw `useInput` `(input, key)` pair
- * to a line-editing intent. Ink does not surface Home/End/word keys on its
- * `key` object — those arrive as raw escape sequences in `input` — so this
- * recognizer inspects both the parsed `key` flags (for Ctrl/Alt combos) and the
- * raw sequence (for Home/End/word jumps), and returns `null` for anything it
- * does not own so the caller can drop unknown control bytes instead of
- * inserting them into the buffer.
- */
-/**
- * Map a Ctrl-modified key to an intent, if any.
- *
- * `Ctrl+K` IS DELIBERATELY NOT HERE (agent-model-kits D-15). That byte belongs
- * to the Agent-kit picker on the main screen, and this recognizer runs BEFORE
- * `PromptInput`'s `if (key.ctrl) return` - so keeping the binding would delete
- * the user's draft in one listener while the other opened the overlay. The
- * capability moved to `Alt+K` (`fromMeta`) instead of being dropped.
- */
-function fromCtrl(input, key) {
-    if (key.leftArrow)
-        return 'wordLeft';
-    if (key.rightArrow)
-        return 'wordRight';
-    switch (input) {
-        case 'a':
-            return 'home';
-        case 'e':
-            return 'end';
-        case 'w':
-            return 'deleteWordBack';
-        case 'u':
-            return 'killToStart';
-        default:
-            return null;
-    }
-}
-/** Map an Alt/Meta-modified key to an intent, if any. */
-function fromMeta(input) {
-    if (input === 'b')
-        return 'wordLeft';
-    if (input === 'f')
-        return 'wordRight';
-    // `killToEnd` LIVES HERE NOW (agent-model-kits D-15). `Alt+K` keeps the
-    // capability, and it keeps the kill family together: `M-k` is kill-sentence in
-    // the Emacs tradition this keymap already borrows `Ctrl+W` and `Alt+B/F` from.
-    if (input === 'k')
-        return 'killToEnd';
-    if (input === '\x7f' || input === '\b')
-        return 'deleteWordBack';
-    return null;
-}
-/** Map a raw terminal escape / control sequence to an intent, if any. */
-function fromRaw(input) {
-    switch (input) {
-        case '\x1b[H':
-        case '\x1b[1~':
-        case '\x1bOH':
-        case '\x01': // Ctrl+A (raw)
-            return 'home';
-        case '\x1b[F':
-        case '\x1b[4~':
-        case '\x1bOF':
-        case '\x05': // Ctrl+E (raw)
-            return 'end';
-        case '\x1b[1;5D':
-        case '\x1bb':
-            return 'wordLeft';
-        case '\x1b[1;5C':
-        case '\x1bf':
-            return 'wordRight';
-        case '\x17': // Ctrl+W (raw)
-        case '\x1b\x7f':
-        case '\x1b\b':
-            return 'deleteWordBack';
-        case '\x15': // Ctrl+U (raw)
-            return 'killToStart';
-        case '\x1bk':
-            // Alt+K (raw ESC + k). `\x0b` (Ctrl+K) is deliberately ABSENT: it belongs
-            // to the Agent-kit picker, and a case for it here would be a dead binding
-            // that still looks alive to every future reader.
-            return 'killToEnd';
-        default:
-            return null;
-    }
-}
-/** Recognize a line-editing intent, or `null` if this key is not an edit op. */
-export function recognize(input, key) {
-    if (key.ctrl) {
-        const hit = fromCtrl(input, key);
-        if (hit)
-            return hit;
-    }
-    if (key.meta) {
-        const hit = fromMeta(input);
-        if (hit)
-            return hit;
-    }
-    return fromRaw(input);
-}