@sigrun/tui 0.1.0 → 0.2.0

package/dist/keymaps/emacs.js

@@ -1,133 +0,0 @@
-/**
- * The emacs keymap (Task C5, UI refresh): modeless, chord-driven. `C-x`
- * ("\x18") arms a 1 000 ms chord: `C-x b` conversation picker, `C-x o`
- * focus cycle, `C-x C-c` quit, `C-x k` a consumed no-op (a mismatched
- * follow-up is the emacs undefined-key beep — consumed, never typed).
- * `M-x` opens the command picker; `C-s` / `C-r` search forward / backward
- * (the app's search overlay turns them into next / previous while open);
- * `C-g` cancels a live run, closes the search/picker (it passes through
- * to the open overlay), or focuses the composer. `M-p` / `M-n` jump
- * between prompts; `M-w` copy, `M-f` fork, `M-e` edit are outside-
- * composer actions (in the composer `M-f` is the editor's word-forward —
- * all three pass). `C-n` / `C-p` move outside the composer; `C-o`
- * answers an interaction, `C-l` redraws, `C-h` opens the key reference.
- * Every {@link RESERVED_KEYS} chord passes in every focus — ctrl+b is
- * NEVER bound (no `C-x C-b` either).
- */
-import { Key, matchesKey } from "@earendil-works/pi-tui";
-import { RESERVED_KEYS } from "./types.js";
-/** The C-x chord window. */
-const CHORD_MS = 1_000;
-const BINDINGS = [
-    { keys: "C-x b", action: "conversation picker" },
-    { keys: "C-x o", action: "cycle focus" },
-    { keys: "C-x C-c", action: "quit" },
-    { keys: "M-x", action: "command picker" },
-    { keys: "C-s / C-r", action: "search forward / backward" },
-    { keys: "C-g", action: "cancel run / close / focus composer" },
-    { keys: "M-p / M-n", action: "previous / next prompt" },
-    { keys: "M-w", action: "copy turn" },
-    { keys: "M-f", action: "fork here" },
-    { keys: "M-e", action: "edit here" },
-    { keys: "C-n / C-p", action: "move down / up" },
-    { keys: "enter", action: "open / fold" },
-    { keys: "C-o", action: "answer interaction" },
-    { keys: "C-l", action: "redraw" },
-    { keys: "C-h", action: "key reference" },
-];
-/** Match `data` against any reserved chord (they always pass). */
-function isReserved(data) {
-    return RESERVED_KEYS.some((id) => matchesKey(data, id));
-}
-export function createEmacsKeymap() {
-    /** The armed C-x prefix timestamp (undefined = no chord pending). */
-    let chordAt;
-    /**
-     * Resolve the C-x chord against `data`. Returns the chord's result,
-     * "consume" when `data` ARMS the prefix, or undefined to process
-     * `data` fresh (no prefix pending, or the window expired).
-     */
-    const chord = (data) => {
-        const now = Date.now();
-        if (chordAt !== undefined) {
-            const armed = chordAt;
-            chordAt = undefined;
-            if (now - armed <= CHORD_MS) {
-                if (data === "b")
-                    return { type: "picker", kind: "conversation" };
-                if (data === "o")
-                    return { type: "focus-cycle", direction: 1 };
-                if (data === "\x03")
-                    return { type: "quit" }; // C-x C-c
-                if (data === "k")
-                    return "consume"; // C-x k: a no-op, consumed
-                return "consume"; // undefined chord: the emacs beep
-            }
-            // Expired: `data` is processed fresh below.
-        }
-        if (data === "\x18") {
-            chordAt = now;
-            return "consume";
-        }
-        return undefined;
-    };
-    return {
-        name: "emacs",
-        modeLabel: () => undefined,
-        handle(data, ctx) {
-            // The composer's readline chords + the tmux prefix: NEVER bound.
-            // A reserved pass-through disarms a pending C-x — otherwise
-            // `C-x C-b b` would fire the picker with the user's "b".
-            if (isReserved(data)) {
-                chordAt = undefined;
-                return "pass";
-            }
-            // A modal overlay owns the keys; C-g passes too — the picker and
-            // the search overlay close themselves on it.
-            if (ctx.overlayOpen)
-                return "pass";
-            const chorded = chord(data);
-            if (chorded !== undefined)
-                return chorded;
-            if (data === "\x1bx")
-                return { type: "picker", kind: "command" };
-            if (data === "\x13")
-                return { type: "search", direction: "forward" };
-            if (data === "\x12")
-                return { type: "search", direction: "backward" };
-            if (data === "\x07") {
-                return ctx.busy
-                    ? { type: "cancel-run" }
-                    : { type: "focus", target: "composer" };
-            }
-            if (data === "\x1bp")
-                return { type: "prompt-jump", delta: -1 };
-            if (data === "\x1bn")
-                return { type: "prompt-jump", delta: 1 };
-            if (data === "\x0f")
-                return { type: "answer-interaction" };
-            if (data === "\x0c")
-                return { type: "redraw" };
-            if (data === "\x08")
-                return { type: "help" };
-            if (ctx.focus === "composer")
-                return "pass";
-            // Outside the composer: the transcript/list actions.
-            if (data === "\x1bw")
-                return { type: "copy" };
-            if (data === "\x1bf")
-                return { type: "fork-here" };
-            if (data === "\x1be")
-                return { type: "edit-here" };
-            if (data === "\x0e")
-                return { type: "move", delta: 1 };
-            if (data === "\x10")
-                return { type: "move", delta: -1 };
-            if (matchesKey(data, Key.enter) || data === "\r")
-                return { type: "open" };
-            return "pass";
-        },
-        hints: () => ["C-x b chats", "M-x commands", "C-h keys"],
-        describe: () => BINDINGS,
-    };
-}

package/dist/keymaps/standard.d.ts

@@ -1,17 +0,0 @@
-/**
- * The standard keymap (Task C3, UI refresh): readline-friendly globals
- * plus vi-flavoured navigation OUTSIDE the composer. The composer owns
- * every printable key and every {@link RESERVED_KEYS} chord — nothing
- * here shadows a line-editing key (ctrl+d/ctrl+u included), and ctrl+b
- * is never bound anywhere.
- *
- * Global (every focus): ctrl+p conversation picker, ctrl+n new
- * conversation, ctrl+t cycle thinking, ctrl+o answer interaction,
- * ctrl+l redraw, ctrl+c quit, tab/shift+tab focus cycle, Esc (abort a
- * live run, else focus the composer; passes through while the
- * composer's autocomplete is open). Outside the composer: arrows move,
- * PgUp/PgDn page, Home/End jump, Enter open, y copy, f fork, e edit,
- * / search, n/N next match, ? help.
- */
-import { type Keymap } from "./types.js";
-export declare function createStandardKeymap(): Keymap;

package/dist/keymaps/standard.js

@@ -1,131 +0,0 @@
-/**
- * The standard keymap (Task C3, UI refresh): readline-friendly globals
- * plus vi-flavoured navigation OUTSIDE the composer. The composer owns
- * every printable key and every {@link RESERVED_KEYS} chord — nothing
- * here shadows a line-editing key (ctrl+d/ctrl+u included), and ctrl+b
- * is never bound anywhere.
- *
- * Global (every focus): ctrl+p conversation picker, ctrl+n new
- * conversation, ctrl+t cycle thinking, ctrl+o answer interaction,
- * ctrl+l redraw, ctrl+c quit, tab/shift+tab focus cycle, Esc (abort a
- * live run, else focus the composer; passes through while the
- * composer's autocomplete is open). Outside the composer: arrows move,
- * PgUp/PgDn page, Home/End jump, Enter open, y copy, f fork, e edit,
- * / search, n/N next match, ? help.
- */
-import { Key, matchesKey } from "@earendil-works/pi-tui";
-import { RESERVED_KEYS } from "./types.js";
-/** The help table (also the source of the status-bar hints). */
-const BINDINGS = [
-    { keys: "ctrl+p", action: "conversation picker" },
-    { keys: "ctrl+n", action: "new conversation" },
-    { keys: "ctrl+t", action: "cycle thinking" },
-    { keys: "ctrl+o", action: "answer interaction" },
-    { keys: "ctrl+l", action: "redraw" },
-    { keys: "ctrl+c", action: "quit" },
-    { keys: "tab / shift+tab", action: "cycle focus" },
-    { keys: "esc", action: "abort run / focus composer" },
-    { keys: "↑ ↓", action: "move (list/transcript)" },
-    { keys: "pgup pgdn", action: "page (list/transcript)" },
-    { keys: "home end", action: "top / bottom" },
-    { keys: "enter", action: "open / select" },
-    { keys: "y", action: "copy turn" },
-    { keys: "f", action: "fork here" },
-    { keys: "e", action: "edit here" },
-    { keys: "/", action: "search transcript" },
-    { keys: "n / N", action: "next / previous match" },
-    { keys: "?", action: "help" },
-];
-/** Match `data` against any reserved chord (they always pass). */
-function isReserved(data) {
-    return RESERVED_KEYS.some((id) => matchesKey(data, id));
-}
-export function createStandardKeymap() {
-    const global = (data, ctx) => {
-        if (matchesKey(data, Key.ctrl("p")))
-            return { type: "picker", kind: "conversation" };
-        if (matchesKey(data, Key.ctrl("n")))
-            return { type: "new-conversation" };
-        if (matchesKey(data, Key.ctrl("t")))
-            return { type: "cycle-thinking" };
-        if (matchesKey(data, Key.ctrl("o")))
-            return { type: "answer-interaction" };
-        if (matchesKey(data, Key.ctrl("l")))
-            return { type: "redraw" };
-        if (matchesKey(data, Key.ctrl("c")))
-            return { type: "quit" };
-        if (matchesKey(data, Key.tab) || matchesKey(data, "tab")) {
-            return ctx.autocompleteOpen ? "pass" : { type: "focus-cycle", direction: 1 };
-        }
-        if (matchesKey(data, "shift+tab"))
-            return { type: "focus-cycle", direction: -1 };
-        if (matchesKey(data, Key.escape)) {
-            if (ctx.autocompleteOpen)
-                return "pass";
-            if (ctx.busy)
-                return { type: "cancel-run" };
-            return { type: "focus", target: "composer" };
-        }
-        return undefined;
-    };
-    const outsideComposer = (data) => {
-        if (matchesKey(data, Key.up) || matchesKey(data, "up"))
-            return { type: "move", delta: -1 };
-        if (matchesKey(data, Key.down) || matchesKey(data, "down"))
-            return { type: "move", delta: 1 };
-        if (matchesKey(data, Key.pageUp) || matchesKey(data, "pageUp"))
-            return { type: "page", direction: -1, half: false };
-        if (matchesKey(data, Key.pageDown) || matchesKey(data, "pageDown"))
-            return { type: "page", direction: 1, half: false };
-        if (matchesKey(data, Key.home) || matchesKey(data, "home"))
-            return { type: "edge", to: "top" };
-        if (matchesKey(data, Key.end) || matchesKey(data, "end"))
-            return { type: "edge", to: "bottom" };
-        if (matchesKey(data, Key.enter))
-            return { type: "open" };
-        if (data === "y")
-            return { type: "copy" };
-        if (data === "f")
-            return { type: "fork-here" };
-        if (data === "e")
-            return { type: "edit-here" };
-        if (data === "/")
-            return { type: "search", direction: "forward" };
-        if (data === "n")
-            return { type: "search-next", reverse: false };
-        if (data === "N")
-            return { type: "search-next", reverse: true };
-        if (data === "?")
-            return { type: "help" };
-        return undefined;
-    };
-    return {
-        name: "standard",
-        modeLabel: () => undefined,
-        handle(data, ctx) {
-            // The composer's readline chords + the tmux prefix: NEVER bound.
-            if (isReserved(data))
-                return "pass";
-            // A modal overlay owns the keys; only quit still works.
-            if (ctx.overlayOpen) {
-                return matchesKey(data, Key.ctrl("c")) ? { type: "quit" } : "pass";
-            }
-            const globalResult = global(data, ctx);
-            if (globalResult !== undefined)
-                return globalResult;
-            if (ctx.focus !== "composer") {
-                const navResult = outsideComposer(data);
-                if (navResult !== undefined)
-                    return navResult;
-            }
-            return "pass";
-        },
-        hints(ctx) {
-            if (ctx.focus === "composer") {
-                return ["Tab focus", "^P chats", "? keys"];
-            }
-            return ["enter open", "y copy", "f fork", "e edit", "/ search", "? help"];
-        },
-        describe: () => BINDINGS,
-    };
-}

package/dist/keymaps/types.d.ts

@@ -1,43 +0,0 @@
-/**
- * The keymap contract (Task C3, UI refresh): a keymap maps raw terminal
- * input to an {@link Action}, `"pass"` (the focused component — usually
- * the composer — gets the key), or `"consume"` (swallow silently). The
- * launcher's single input listener asks the keymap first, then dispatches
- * / consumes / passes.
- *
- * RESERVED_KEYS are the composer's line-editing chords (readline-style)
- * and the tmux prefix: a keymap must NEVER bind them — it returns "pass"
- * for every one in every focus so the editor (or tmux) always sees them.
- * Ctrl+B in particular is the user's hard rule.
- */
-import type { Action, Focus } from "../actions.js";
-/** The state a keymap decision depends on. */
-export interface KeyContext {
-    readonly focus: Focus;
-    /** A live run is in flight (Esc aborts it). */
-    readonly busy: boolean;
-    /** The composer's autocomplete dropdown is open (Esc/Tab pass to it). */
-    readonly autocompleteOpen: boolean;
-    /** A modal overlay (picker/search/answer) owns the keys. */
-    readonly overlayOpen: boolean;
-}
-/** What the launcher does with the key: run the action, swallow, or pass. */
-export type KeyResult = Action | "pass" | "consume";
-export interface Keymap {
-    readonly name: "standard" | "vim" | "emacs";
-    /** The status-bar mode chip text; undefined = no chip (standard). */
-    modeLabel(): string | undefined;
-    handle(data: string, ctx: KeyContext): KeyResult;
-    /** The one-line hint cluster for the status bar. */
-    hints(ctx: KeyContext): readonly string[];
-    /** The help listing: every binding with a human description. */
-    describe(): readonly {
-        keys: string;
-        action: string;
-    }[];
-}
-/**
- * Keys no keymap may bind: the composer's readline chords plus the tmux
- * prefix (ctrl+b). Keymaps return "pass" for all of them in every focus.
- */
-export declare const RESERVED_KEYS: readonly string[];

package/dist/keymaps/types.js

@@ -1,28 +0,0 @@
-/**
- * The keymap contract (Task C3, UI refresh): a keymap maps raw terminal
- * input to an {@link Action}, `"pass"` (the focused component — usually
- * the composer — gets the key), or `"consume"` (swallow silently). The
- * launcher's single input listener asks the keymap first, then dispatches
- * / consumes / passes.
- *
- * RESERVED_KEYS are the composer's line-editing chords (readline-style)
- * and the tmux prefix: a keymap must NEVER bind them — it returns "pass"
- * for every one in every focus so the editor (or tmux) always sees them.
- * Ctrl+B in particular is the user's hard rule.
- */
-/**
- * Keys no keymap may bind: the composer's readline chords plus the tmux
- * prefix (ctrl+b). Keymaps return "pass" for all of them in every focus.
- */
-export const RESERVED_KEYS = [
-    "ctrl+b",
-    "ctrl+a",
-    "ctrl+e",
-    "ctrl+f",
-    "ctrl+k",
-    "ctrl+u",
-    "ctrl+w",
-    "ctrl+y",
-    "ctrl+d",
-    "ctrl+j",
-];

package/dist/keymaps/vim.d.ts

@@ -1,48 +0,0 @@
-/**
- * The vim keymap (Task C4, UI refresh): real insert/normal/command modes
- * over the C3 action layer. Starts in INSERT with the composer focused —
- * every key types through except Esc (→ NORMAL, focus transcript),
- * Ctrl+C (abort a live run; otherwise consumed — quitting is ZZ or :q),
- * and Ctrl+O (answer an interaction). Every {@link RESERVED_KEYS} chord
- * passes in INSERT (the composer's readline chords and the tmux prefix
- * are never shadowed; ctrl+b is NEVER bound anywhere).
- *
- * NORMAL owns the transcript/list: j/k move, h/l focus list/transcript,
- * ctrl+d/ctrl+u half-page (bound here — RESERVED exists to protect the
- * composer's editing, and in NORMAL the composer is not focused),
- * gg/G edges, {/} prompt jumps, Enter/za fold, o open, y/yy copy,
- * f fork, e edit, v edit-in-vim, //?/n/N search, i/a back to INSERT,
- * `:` the command line, ctrl+p picker, ctrl+l redraw, ZZ quit. UNBOUND
- * PRINTABLE KEYS ARE CONSUMED — they must never leak into the composer.
- *
- * COMMAND accumulates a line after `:` (the app renders ":"+buffer in
- * the status bar via {@link VimKeymap.getCommandLine}); Enter dispatches
- * run-command, Esc cancels, Tab completes the command name.
- *
- * The two-key chords (gg, yy, za, ZZ) share one pending-key window of
- * 500 ms; a timed-out or mismatched prefix is consumed silently.
- */
-import { type Keymap } from "./types.js";
-export type VimMode = "insert" | "normal" | "command";
-/** The keymap plus the mode/command-line seam the app polls after each key. */
-export interface VimKeymap extends Keymap {
-    readonly mode: VimMode;
-    /** The ":" line while in command mode; undefined otherwise. */
-    getCommandLine(): string | undefined;
-    /**
-     * Drop to INSERT (the app calls this after an external edit-in-vim so
-     * the mode agrees with the restored composer focus).
-     */
-    enterInsertMode(): void;
-}
-/** Options for {@link createVimKeymap}. */
-export interface VimKeymapOptions {
-    /**
-     * The slash-command catalog's names (C3's picker source); they join
-     * COMMAND_NAMES in the Tab completion table as `"/"`-prefixed
-     * entries. Defaults to none (the launcher fills a shared array once
-     * the catalog fetch lands).
-     */
-    readonly catalogNames?: readonly string[];
-}
-export declare function createVimKeymap(options?: VimKeymapOptions): VimKeymap;

package/dist/keymaps/vim.js

@@ -1,254 +0,0 @@
-/**
- * The vim keymap (Task C4, UI refresh): real insert/normal/command modes
- * over the C3 action layer. Starts in INSERT with the composer focused —
- * every key types through except Esc (→ NORMAL, focus transcript),
- * Ctrl+C (abort a live run; otherwise consumed — quitting is ZZ or :q),
- * and Ctrl+O (answer an interaction). Every {@link RESERVED_KEYS} chord
- * passes in INSERT (the composer's readline chords and the tmux prefix
- * are never shadowed; ctrl+b is NEVER bound anywhere).
- *
- * NORMAL owns the transcript/list: j/k move, h/l focus list/transcript,
- * ctrl+d/ctrl+u half-page (bound here — RESERVED exists to protect the
- * composer's editing, and in NORMAL the composer is not focused),
- * gg/G edges, {/} prompt jumps, Enter/za fold, o open, y/yy copy,
- * f fork, e edit, v edit-in-vim, //?/n/N search, i/a back to INSERT,
- * `:` the command line, ctrl+p picker, ctrl+l redraw, ZZ quit. UNBOUND
- * PRINTABLE KEYS ARE CONSUMED — they must never leak into the composer.
- *
- * COMMAND accumulates a line after `:` (the app renders ":"+buffer in
- * the status bar via {@link VimKeymap.getCommandLine}); Enter dispatches
- * run-command, Esc cancels, Tab completes the command name.
- *
- * The two-key chords (gg, yy, za, ZZ) share one pending-key window of
- * 500 ms; a timed-out or mismatched prefix is consumed silently.
- */
-import { Key, matchesKey } from "@earendil-works/pi-tui";
-import { RESERVED_KEYS } from "./types.js";
-/** The two-key chord window (gg, yy, za, ZZ). */
-const CHORD_MS = 500;
-/** The command-mode completion table (Tab completes the command name). */
-const COMMAND_NAMES = ["new", "fork", "model", "set", "b", "ls", "q", "quit"];
-const BINDINGS = [
-    { keys: "esc (insert)", action: "normal mode" },
-    { keys: "i / a", action: "insert mode" },
-    { keys: "j / k", action: "move down / up" },
-    { keys: "h / l", action: "focus list / transcript" },
-    { keys: "ctrl+d / ctrl+u", action: "half page down / up" },
-    { keys: "gg / G", action: "top / bottom" },
-    { keys: "{ / }", action: "previous / next prompt" },
-    { keys: "enter / za", action: "toggle fold" },
-    { keys: "o", action: "open" },
-    { keys: "y / yy", action: "copy turn" },
-    { keys: "f", action: "fork here" },
-    { keys: "e", action: "edit here" },
-    { keys: "v", action: "edit in vim" },
-    { keys: "/ / ?", action: "search forward / backward" },
-    { keys: "n / N", action: "next / previous match" },
-    { keys: ":", action: "command line" },
-    { keys: "ctrl+p", action: "conversation picker" },
-    { keys: "ctrl+o", action: "answer interaction" },
-    { keys: "ctrl+l", action: "redraw" },
-    { keys: "ctrl+c", action: "abort run (busy)" },
-    { keys: "g?", action: "key reference" },
-    { keys: "ZZ / :q", action: "quit" },
-];
-function isReserved(data) {
-    return RESERVED_KEYS.some((id) => matchesKey(data, id));
-}
-/** A printable single character (space through ~, plus unicode text). */
-function isPrintable(data) {
-    return data.length === 1 && data >= " ";
-}
-export function createVimKeymap(options) {
-    const catalogNames = options?.catalogNames ?? [];
-    /** Tab completion table: the vim-native commands plus `/`-catalog names. */
-    const completionNames = () => [
-        ...COMMAND_NAMES,
-        ...catalogNames.map((name) => `/${name}`),
-    ];
-    let mode = "insert";
-    let commandLine = "";
-    /** The pending chord prefix ("g" | "y" | "z" | "Z") and its timestamp. */
-    let pending;
-    /**
-     * Resolve the pending two-key chord (gg → top, ZZ → quit, za → fold)
-     * against `data`. Returns the chord's action, "consume" when `data`
-     * STARTS a chord, or undefined to process `data` fresh (a mismatched
-     * or timed-out follow-up).
-     */
-    const chord = (data) => {
-        const now = Date.now();
-        if (pending !== undefined) {
-            const prefix = pending;
-            pending = undefined;
-            if (now - prefix.at <= CHORD_MS) {
-                if (prefix.key === "g" && data === "g")
-                    return { type: "edge", to: "top" };
-                // g? is vim normal's help key — "?" stays search-backward.
-                if (prefix.key === "g" && data === "?")
-                    return { type: "help" };
-                if (prefix.key === "Z" && data === "Z")
-                    return { type: "quit" };
-                if (prefix.key === "z" && data === "a")
-                    return { type: "toggle-fold" };
-            }
-            // Mismatch/timeout: `data` is processed fresh below.
-        }
-        if (data === "g" || data === "Z" || data === "z") {
-            pending = { key: data, at: now };
-            return "consume";
-        }
-        return undefined;
-    };
-    const insert = (data, ctx) => {
-        // The composer's readline chords + the tmux prefix: NEVER bound.
-        if (isReserved(data))
-            return "pass";
-        if (matchesKey(data, Key.escape)) {
-            if (ctx.autocompleteOpen)
-                return "pass";
-            mode = "normal";
-            return { type: "focus", target: "transcript" };
-        }
-        if (matchesKey(data, Key.ctrl("c"))) {
-            return ctx.busy ? { type: "cancel-run" } : "consume";
-        }
-        if (matchesKey(data, Key.ctrl("o")))
-            return { type: "answer-interaction" };
-        return "pass";
-    };
-    const normal = (data, ctx) => {
-        // ctrl+b / ctrl+f are NOT bound in vim normal — reserved chords pass.
-        const chorded = chord(data);
-        if (chorded !== undefined)
-            return chorded;
-        if (data === "y")
-            return { type: "copy" }; // yy is two copies — same action
-        if (data === "j")
-            return { type: "move", delta: 1 };
-        if (data === "k")
-            return { type: "move", delta: -1 };
-        if (data === "h")
-            return { type: "focus", target: "list" };
-        if (data === "l")
-            return { type: "focus", target: "transcript" };
-        if (matchesKey(data, Key.ctrl("d")))
-            return { type: "page", direction: 1, half: true };
-        if (matchesKey(data, Key.ctrl("u")))
-            return { type: "page", direction: -1, half: true };
-        if (data === "G")
-            return { type: "edge", to: "bottom" };
-        if (data === "{")
-            return { type: "prompt-jump", delta: -1 };
-        if (data === "}")
-            return { type: "prompt-jump", delta: 1 };
-        if (matchesKey(data, Key.enter))
-            return { type: "toggle-fold" };
-        if (data === "o")
-            return { type: "open" };
-        if (data === "f")
-            return { type: "fork-here" };
-        if (data === "e")
-            return { type: "edit-here" };
-        if (data === "v")
-            return { type: "edit-in-vim" };
-        if (data === "/")
-            return { type: "search", direction: "forward" };
-        if (data === "?")
-            return { type: "search", direction: "backward" };
-        if (data === "n")
-            return { type: "search-next", reverse: false };
-        if (data === "N")
-            return { type: "search-next", reverse: true };
-        if (data === "i" || data === "a") {
-            mode = "insert";
-            return { type: "focus", target: "composer" };
-        }
-        if (data === ":") {
-            mode = "command";
-            commandLine = "";
-            return "consume";
-        }
-        if (matchesKey(data, Key.ctrl("p")))
-            return { type: "picker", kind: "conversation" };
-        if (matchesKey(data, Key.ctrl("l")))
-            return { type: "redraw" };
-        if (matchesKey(data, Key.ctrl("c"))) {
-            return ctx.busy ? { type: "cancel-run" } : "consume";
-        }
-        // Reserved chords the composer owns pass even here (they are no-ops
-        // in a non-composer focus, but the invariant is one rule).
-        if (isReserved(data))
-            return "pass";
-        // UNBOUND PRINTABLE KEYS ARE CONSUMED: never typed into the composer.
-        if (isPrintable(data))
-            return "consume";
-        return "consume";
-    };
-    const command = (data) => {
-        if (matchesKey(data, Key.escape)) {
-            mode = "normal";
-            commandLine = "";
-            return "consume";
-        }
-        if (matchesKey(data, Key.enter) || data === "\r") {
-            const line = commandLine;
-            mode = "normal";
-            commandLine = "";
-            if (line.trim() === "")
-                return "consume";
-            return { type: "run-command", line };
-        }
-        if (matchesKey(data, Key.backspace) || data === "\x7f" || data === "\b") {
-            commandLine = commandLine.slice(0, -1);
-            return "consume";
-        }
-        if (matchesKey(data, Key.tab) || data === "\t") {
-            const match = completionNames().find((name) => name.startsWith(commandLine) && name !== commandLine);
-            if (match !== undefined)
-                commandLine = match;
-            return "consume";
-        }
-        if (isPrintable(data)) {
-            commandLine += data;
-            return "consume";
-        }
-        return "consume";
-    };
-    return {
-        name: "vim",
-        get mode() {
-            return mode;
-        },
-        getCommandLine: () => (mode === "command" ? `:${commandLine}` : undefined),
-        enterInsertMode: () => {
-            mode = "insert";
-        },
-        modeLabel: () => {
-            if (mode === "insert")
-                return "-- INSERT --";
-            if (mode === "normal")
-                return "-- NORMAL --";
-            return undefined; // the status bar shows the ":" line instead
-        },
-        handle(data, ctx) {
-            // A modal overlay owns the keys; only its cancel key is held back.
-            if (ctx.overlayOpen) {
-                return matchesKey(data, Key.escape) ? "consume" : "pass";
-            }
-            if (mode === "insert")
-                return insert(data, ctx);
-            if (mode === "normal")
-                return normal(data, ctx);
-            return command(data);
-        },
-        hints(ctx) {
-            if (mode === "command")
-                return ["enter run", "esc cancel", "tab complete"];
-            if (mode === "insert" || ctx.focus === "composer")
-                return ["Esc normal"];
-            return ["i insert", ": command", "g? keys"];
-        },
-        describe: () => BINDINGS,
-    };
-}