@pugi/cli 0.1.0-beta.22 → 0.1.0-beta.23

package/dist/core/theme/presets.js

@@ -0,0 +1,228 @@
+/**
+ * Leak L30 (2026-05-27) — TUI color theme presets.
+ *
+ * Sibling to `core/output-style/presets.ts` but addressing a different
+ * layer of the operator surface:
+ *
+ *   - `output-style` steers the engine's PROSE register (terse /
+ *     explanatory / russian-formal / casual). It compiles into a rule
+ *     block appended to the system prompt; the model adjusts voice.
+ *
+ *   - `theme` steers the LOCAL TUI's color palette. It never reaches
+ *     the engine; only the Ink components in `tui/*.tsx` read it. The
+ *     operator can run any output-style under any theme — the two
+ *     surfaces are orthogonal.
+ *
+ * Design contract:
+ *
+ *   - The catalogue is a closed set of 4 entries — `default`, `dark`,
+ *     `light`, `colorblind`. The slug union is intentionally tight so
+ *     the operator can hold the full surface in working memory and so
+ *     Ink consumers can switch on every slug without a fall-through.
+ *
+ *   - Each preset defines 7 semantic color tokens (foreground, muted,
+ *     accent, success, warning, error, background). Ink components
+ *     reference these tokens via `useTheme()` instead of inlining
+ *     literal hex codes. The brand accent `#3da9fc` is preserved in
+ *     `default` so the existing header / splash chrome reads
+ *     identically when no override is active.
+ *
+ *   - `colorblind` is tuned for deuteranopia (red-green color
+ *     blindness, ~5% of male population). Status colors are mapped to
+ *     a blue-yellow axis (`success` cyan, `warning` yellow, `error`
+ *     bright-magenta) so the OK/WARN/ERROR triplet remains
+ *     distinguishable without red/green discrimination. The accent is
+ *     also shifted to bright-yellow `#ffd166` so it does not collide
+ *     with the success cue.
+ *
+ *   - `light` uses darker foreground + lighter accent values so the
+ *     palette reads on a white terminal background. Most operators
+ *     run dark terminals, so `dark` is closer to the default;
+ *     `light` exists specifically for screen-share / projector demos
+ *     where the room is bright.
+ *
+ *   - All color values are 6-digit hex strings prefixed with `#`. Ink's
+ *     `Text color` prop accepts hex strings directly; we deliberately
+ *     do NOT use named colors like `green` / `red` so the palette is
+ *     fully under operator control. The Ink-named fallback for OK/
+ *     WARN/ERROR exists separately in `doctor-table.tsx` legacy code
+ *     and gets superseded once the theme context is wired.
+ *
+ * Test surface: `test/commands/theme-presets.spec.ts` exercises
+ * catalogue invariants (4 entries, unique slugs, every preset has all
+ * 7 tokens, hex format, colorblind palette avoids red-green for
+ * status), the `isThemeSlug` predicate, and the `compileSampleRow`
+ * helper used by the preview table.
+ */
+/**
+ * The closed list of theme slugs in catalogue order. Mirror used by
+ * the CLI surface (`/theme` table, `pugi theme --list`) so the
+ * operator sees themes in a stable order regardless of iteration
+ * order of the keyed catalogue.
+ */
+export const THEME_SLUGS = Object.freeze([
+    'default',
+    'dark',
+    'light',
+    'colorblind',
+]);
+/**
+ * Default slug used when no workspace-/user-level preference is set.
+ * Exported so `state.ts` and the CLI handler share one constant.
+ */
+export const DEFAULT_THEME = 'default';
+/**
+ * Catalogue keyed by slug. Frozen so callers cannot mutate the
+ * shared rows; the CLI handler returns slugs, not preset references,
+ * to keep the boundary clean.
+ *
+ * Color choices:
+ *
+ *   - `default` accent `#3da9fc` is the existing Pugi blue baked into
+ *     `repl.tsx` header + `/help` palette. Preserved verbatim so the
+ *     default theme reads identically to pre-L30 chrome.
+ *
+ *   - `dark` saturates the brand palette for deep-black terminals
+ *     (true-black iTerm, kitty, alacritty). Accent cyan `#22d3ee`
+ *     pops against `#0a0a0a`; foreground is a near-white `#f5f5f5`
+ *     that does not glare.
+ *
+ *   - `light` inverts the contrast: foreground is `#1a1a1a` (near-
+ *     black), background `#fafafa` (off-white), accent `#1e40af`
+ *     (deep blue, readable on white). Status colors are darkened
+ *     equivalents — `#15803d` green, `#a16207` amber, `#b91c1c`
+ *     deep-red — so they retain saturation on bright backgrounds.
+ *
+ *   - `colorblind` shifts the status axis from red-green to
+ *     blue-yellow. `#0ea5e9` cyan replaces green, `#facc15` yellow
+ *     stays warning, `#d946ef` magenta replaces red. The
+ *     deuteranopia community can distinguish blue from yellow from
+ *     magenta even when red/green collapse. Accent moves to
+ *     `#ffd166` bright-yellow so it does not collide with success
+ *     cyan; we trade brand consistency for accessibility here, which
+ *     is the explicit purpose of the preset.
+ */
+export const THEMES = Object.freeze({
+    default: Object.freeze({
+        slug: 'default',
+        title: 'Default',
+        gloss: 'Current Pugi palette — blue accent on dark terminal.',
+        colors: Object.freeze({
+            foreground: '#e5e7eb',
+            background: '#0f172a',
+            muted: '#94a3b8',
+            accent: '#3da9fc',
+            success: '#22c55e',
+            warning: '#eab308',
+            error: '#ef4444',
+        }),
+    }),
+    dark: Object.freeze({
+        slug: 'dark',
+        title: 'Dark',
+        gloss: 'Saturated palette for deep-black terminals (iTerm, alacritty, kitty).',
+        colors: Object.freeze({
+            foreground: '#f5f5f5',
+            background: '#0a0a0a',
+            muted: '#737373',
+            accent: '#22d3ee',
+            success: '#4ade80',
+            warning: '#fbbf24',
+            error: '#f87171',
+        }),
+    }),
+    light: Object.freeze({
+        slug: 'light',
+        title: 'Light',
+        gloss: 'Inverted palette for projector demos + white-background terminals.',
+        colors: Object.freeze({
+            foreground: '#1a1a1a',
+            background: '#fafafa',
+            muted: '#525252',
+            accent: '#1e40af',
+            success: '#15803d',
+            warning: '#a16207',
+            error: '#b91c1c',
+        }),
+    }),
+    colorblind: Object.freeze({
+        slug: 'colorblind',
+        title: 'Colorblind',
+        gloss: 'High-contrast deuteranopia-safe — status on blue-yellow-magenta axis.',
+        colors: Object.freeze({
+            foreground: '#f5f5f5',
+            background: '#0f172a',
+            muted: '#9ca3af',
+            accent: '#ffd166',
+            success: '#0ea5e9',
+            warning: '#facc15',
+            error: '#d946ef',
+        }),
+    }),
+});
+/**
+ * Type-narrowing predicate. Used by the slash-command parser + state
+ * loader so an unknown string from operator input or a stale config
+ * file degrades to the default theme instead of crashing.
+ */
+export function isThemeSlug(value) {
+    return (typeof value === 'string' && THEME_SLUGS.includes(value));
+}
+/**
+ * Resolve the colors for a slug. Pure lookup; never throws. Callers
+ * pass the slug from `resolveTheme()` so unknown values cannot reach
+ * this helper, but defensive isThemeSlug + DEFAULT_THEME fallback is
+ * still applied so future refactors cannot regress to a runtime
+ * crash on a stale config.
+ */
+export function getThemeColors(slug) {
+    const preset = THEMES[slug] ?? THEMES[DEFAULT_THEME];
+    return preset.colors;
+}
+/**
+ * Render the theme catalogue as a plain-text table for the `/theme`
+ * + `pugi theme` surfaces. Marks the active slug with `*` so the
+ * operator can see at a glance which theme is in effect.
+ *
+ * Pure renderer (no fs, no env). Identical text is emitted from both
+ * the slash dispatcher and the top-level CLI command so operators
+ * trained on one surface read the same table on the other.
+ *
+ * The plain-text variant skips the color-sample preview row — Ink's
+ * `<ThemeTable>` in `tui/theme-table.tsx` renders the sample row
+ * inline using `Text color={preset.colors.accent}` so the operator
+ * can preview each palette before switching.
+ */
+export function renderThemeTable(active) {
+    const slugWidth = Math.max('NAME'.length, ...THEME_SLUGS.map((slug) => slug.length));
+    const header = `${'NAME'.padEnd(slugWidth)}  GLOSS`;
+    const rows = THEME_SLUGS.map((slug) => {
+        const preset = THEMES[slug];
+        const marker = slug === active ? '*' : ' ';
+        return `${marker} ${slug.padEnd(slugWidth)}  ${preset.gloss}`;
+    });
+    return [header, ...rows].join('\n');
+}
+/**
+ * Build the per-row sample text used by `<ThemeTable>`. Pure helper
+ * so the spec can assert the canonical sample copy ("Aa 123 OK WARN
+ * ERROR") without mounting Ink. The TUI component colors each
+ * fragment with the matching token (`foreground`, `accent`, `success`,
+ * `warning`, `error`) — this helper only returns the source strings
+ * the renderer splices in.
+ */
+export function compileSampleRow(slug) {
+    // The strings are slug-independent today; the helper exists so
+    // future presets can ship per-theme sample copy (e.g. localised
+    // OK/ERROR labels for a future `russian-tui` preset) without
+    // touching the consumer Ink component.
+    void slug;
+    return Object.freeze({
+        foreground: 'Aa',
+        accent: '123',
+        success: 'OK',
+        warning: 'WARN',
+        error: 'ERROR',
+    });
+}
+//# sourceMappingURL=presets.js.map

package/dist/core/theme/state.js

@@ -0,0 +1,181 @@
+/**
+ * Leak L30 (2026-05-27) — Theme state persistence.
+ *
+ * Mirror of `core/output-style/state.ts` — same two-tier ladder
+ * (workspace > user > default), same `~/.pugi/config.json` envelope,
+ * same malformed-config tolerance. The two modules write to disjoint
+ * keys (`outputStyle` vs `theme`) of the same JSON file so neighbour
+ * settings (`permissionMode`, `privacy`, `model`, `outputStyle`)
+ * survive a theme flip.
+ *
+ * Two-tier storage:
+ *
+ *   1. **Workspace** — `<workspaceRoot>/.pugi/config.json`. Set by
+ *      `/theme <name>` or `pugi theme <name>` without `--persist`.
+ *      Overrides the user default for the current workspace only.
+ *
+ *   2. **User default** — `~/.pugi/config.json` (PUGI_HOME-aware).
+ *      Set by `pugi theme <name> --persist` or `/theme <name>
+ *      --persist`. Applies to every workspace that has no
+ *      workspace-level override.
+ *
+ * Precedence (highest → lowest):
+ *
+ *   workspace value > user value > DEFAULT_THEME ('default')
+ *
+ * The reader tolerates:
+ *   - missing file (returns the default slug),
+ *   - empty file (returns the default slug),
+ *   - malformed JSON (returns the default slug — DO NOT crash REPL
+ *     boot because of a hand-edited config),
+ *   - unknown slug (returns the default slug + emits no error; the
+ *     operator can `/theme` to see the table and re-set).
+ *
+ * The writer is a read-modify-write to preserve neighbouring keys
+ * (`outputStyle`, `permissionMode`, etc.) — overwriting the whole
+ * file would clobber the other tier's settings AND any sibling
+ * module's slot in the same envelope.
+ *
+ * Test surface: `test/commands/theme-state.spec.ts` exercises
+ * precedence, malformed-config tolerance, persistence across reads,
+ * the `--persist` (user-default) path, reset semantics, and the
+ * coexistence contract with `outputStyle` in the same file.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, resolve } from 'node:path';
+import { DEFAULT_THEME, isThemeSlug } from './presets.js';
+/**
+ * Env override for `~/.pugi` so the spec can sandbox both tiers
+ * without touching the developer's real config. Re-exported under a
+ * theme-specific alias so consumers in this module do not need to
+ * import the output-style constant; the underlying env key is shared
+ * (`PUGI_HOME`) because the two modules write to the same config
+ * envelope.
+ */
+export const PUGI_HOME_ENV = 'PUGI_HOME';
+/**
+ * Resolve the active theme for the workspace, applying the
+ * precedence ladder (workspace > user > default).
+ *
+ * Pure read. Never writes, never throws — every IO failure degrades
+ * to the default slug. The function returns the source label too so
+ * the CLI surface can show the operator where the value came from.
+ */
+export function resolveTheme(io) {
+    const workspaceSlug = readSlugFromFile(workspaceConfigPath(io.workspaceRoot));
+    if (workspaceSlug)
+        return { slug: workspaceSlug, source: 'workspace' };
+    const userSlug = readSlugFromFile(userConfigPath(io.env ?? process.env));
+    if (userSlug)
+        return { slug: userSlug, source: 'user' };
+    return { slug: DEFAULT_THEME, source: 'default' };
+}
+/**
+ * Write `slug` to the workspace tier. Creates `<workspaceRoot>/.pugi/`
+ * if missing. Preserves neighbouring config keys via read-modify-write.
+ */
+export function setWorkspaceTheme(slug, io) {
+    writeSlugToFile(workspaceConfigPath(io.workspaceRoot), slug);
+}
+/**
+ * Write `slug` to the user tier (`~/.pugi/config.json`).
+ *
+ * Mirrors the workspace writer's read-modify-write so the user's
+ * `outputStyle` / `permissionMode` / `privacy` / `model` keys survive
+ * a theme flip.
+ */
+export function setUserTheme(slug, io) {
+    writeSlugToFile(userConfigPath(io.env ?? process.env), slug);
+}
+/**
+ * Clear the workspace tier's `theme` key. The user tier (and
+ * therefore the eventual resolved theme) is left untouched.
+ *
+ * Used by `/theme --reset` so the operator can revert a workspace
+ * override without nuking the rest of their workspace config (or the
+ * user default).
+ */
+export function clearWorkspaceTheme(io) {
+    clearSlugInFile(workspaceConfigPath(io.workspaceRoot));
+}
+/**
+ * Clear the user tier's `theme` key. Lower-blast-radius reset for
+ * operators who want every workspace to fall back to `default` unless
+ * an explicit workspace value is set.
+ */
+export function clearUserTheme(io) {
+    clearSlugInFile(userConfigPath(io.env ?? process.env));
+}
+/**
+ * Workspace config path. Exported for the spec; production callers
+ * should use the `setWorkspace…` / `resolveTheme` helpers.
+ */
+export function workspaceConfigPath(workspaceRoot) {
+    return resolve(workspaceRoot, '.pugi', 'config.json');
+}
+/**
+ * User config path resolved against `PUGI_HOME` (or `~/.pugi`).
+ * Exported for the spec.
+ */
+export function userConfigPath(env = process.env) {
+    const home = env[PUGI_HOME_ENV] ?? resolve(homedir(), '.pugi');
+    return resolve(home, 'config.json');
+}
+/**
+ * Read + parse a config file. Returns an empty object on any IO or
+ * parse error. Caller-provided JSON must be a plain object; arrays /
+ * scalars / null are treated as "no config" so a hand-edited file
+ * never crashes the REPL.
+ */
+function readConfigFile(path) {
+    if (!existsSync(path))
+        return {};
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch {
+        return {};
+    }
+    if (raw.trim().length === 0)
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return {};
+    return parsed;
+}
+function writeConfigFile(path, config) {
+    mkdirSync(dirname(path), { recursive: true });
+    // 0o600 mirrors `core/output-style/state.ts` + `runtime/commands/config.ts` —
+    // the config file may hold preferredEndpoint URLs etc. that should
+    // not be world-readable.
+    writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`, {
+        encoding: 'utf8',
+        mode: 0o600,
+    });
+}
+function readSlugFromFile(path) {
+    const config = readConfigFile(path);
+    const candidate = config.theme;
+    return isThemeSlug(candidate) ? candidate : null;
+}
+function writeSlugToFile(path, slug) {
+    const config = readConfigFile(path);
+    config.theme = slug;
+    writeConfigFile(path, config);
+}
+function clearSlugInFile(path) {
+    const config = readConfigFile(path);
+    if (!('theme' in config))
+        return;
+    delete config.theme;
+    writeConfigFile(path, config);
+}
+//# sourceMappingURL=state.js.map

package/dist/core/vim/keymap.js

@@ -0,0 +1,288 @@
+/**
+ * Leak L26 (2026-05-27) — Vim-style modal editing keymap.
+ *
+ * Pure, data-only motion + edit primitives. The TUI layer
+ * (`tui/vim-input.tsx`) maps Ink key events onto these helpers so the
+ * keymap stays trivially testable and the React component stays free
+ * of motion arithmetic.
+ *
+ * Scope (matches the leak research surface for Claude Code `/vim`):
+ *
+ *   Normal-mode motions
+ *     h / j / k / l        → left / down / up / right (j/k are
+ *                            no-ops on a single-line buffer; we keep
+ *                            the kind in the discriminator so the
+ *                            multi-line buffer follow-up can extend
+ *                            without churning the call sites).
+ *     0 / $                → line start / line end
+ *     w / b                → word forward / word backward
+ *
+ *   Normal-mode edits
+ *     x                    → delete the char under the cursor
+ *     dd                   → delete the entire line (clears the buffer
+ *                            for the single-line REPL prompt)
+ *     i / a                → enter insert mode (`a` advances cursor by
+ *                            one column first, capped at line length)
+ *
+ *   Ex-line commands (typed after `:` in normal mode)
+ *     :w                   → submit current buffer (same as Enter in
+ *                            insert mode)
+ *     :q                   → clear buffer + return to prompt (no
+ *                            submission)
+ *
+ *   Mode transitions
+ *     Esc                  → return to normal mode
+ *     i / a in normal      → insert mode
+ *
+ * The motion helpers return both the new cursor position AND a
+ * structured discriminator so the TUI layer can react (e.g. animate
+ * the caret, log an undo entry, etc.) without re-parsing the key.
+ *
+ * The keymap is intentionally NOT a full vim implementation. We model
+ * just the subset that maps cleanly onto a single-line input buffer +
+ * the four REPL verbs (submit / cancel / accept-insert / leave-insert).
+ * Counts (`3dd`, `5j`), registers, marks, search (`/pattern`), visual
+ * mode, undo/redo, and macros are explicitly out of scope and left
+ * for a follow-up sprint once the single-line surface is shipped.
+ */
+export const PENDING_NONE = { kind: 'none' };
+/**
+ * Whitespace classifier used by `w` / `b`. Matches vim's default
+ * "word" classification loosely — treat any non-whitespace, non-
+ * punctuation byte as a word character; collapse runs.
+ *
+ * We DELIBERATELY do not split on punctuation the way vim's `w`/`b`
+ * do (`hello-world` is two words in vim but one here). The REPL
+ * brief is prose-heavy and operators expect `w` to skip whole tokens
+ * — splitting on punctuation surprised every internal tester.
+ */
+function isWordChar(ch) {
+    return /[^\s]/.test(ch);
+}
+/**
+ * Move cursor forward by one word: skip the current run of word
+ * chars, then skip the run of whitespace, land on the first char of
+ * the next word. Clamps at `line.length` so end-of-line is safe.
+ */
+export function wordForward(line, cursor) {
+    if (cursor >= line.length)
+        return line.length;
+    let i = cursor;
+    // Skip current word chars (if we're on one).
+    while (i < line.length && isWordChar(line[i] ?? ''))
+        i++;
+    // Skip whitespace gap.
+    while (i < line.length && !isWordChar(line[i] ?? ''))
+        i++;
+    return i;
+}
+/**
+ * Move cursor backward by one word: step back over whitespace, then
+ * step back over the previous word. Clamps at 0.
+ */
+export function wordBackward(line, cursor) {
+    if (cursor <= 0)
+        return 0;
+    let i = cursor - 1;
+    // Skip whitespace behind cursor.
+    while (i > 0 && !isWordChar(line[i] ?? ''))
+        i--;
+    // Skip the word until we hit whitespace or start.
+    while (i > 0 && isWordChar(line[i - 1] ?? ''))
+        i--;
+    return i;
+}
+/**
+ * Single-character delete under the cursor (`x`). When the cursor sits
+ * past end-of-line (legal in insert mode) we no-op.
+ *
+ * The cursor stays at the same offset after the splice unless the
+ * deleted char was the trailing one — in which case we step back so
+ * the caret does not sit past EOL.
+ */
+function deleteCharUnder(line, cursor) {
+    if (cursor < 0 || cursor >= line.length)
+        return { line, cursor };
+    const next = line.slice(0, cursor) + line.slice(cursor + 1);
+    const nextCursor = cursor >= next.length ? Math.max(0, next.length - (next.length === 0 ? 0 : 1)) : cursor;
+    // Subtle: when the deletion empties the buffer we want cursor=0,
+    // NOT length-1=−1. The Math.max above guards it but spell it out.
+    return { line: next, cursor: next.length === 0 ? 0 : nextCursor };
+}
+/**
+ * Apply a normal-mode keystroke and return the new buffer + cursor +
+ * mode + pending state. Pure — no side effects. The TUI is the only
+ * caller; tests exercise this directly.
+ */
+export function handleNormalKey(input) {
+    const { line, cursor, pending, ch } = input;
+    // Esc resets any in-flight multi-key sequence and re-asserts normal
+    // mode (we stay in normal — the caller invoked us BECAUSE we are in
+    // normal, but a stale `pending=d` should not survive an Esc).
+    if (input.escape) {
+        return {
+            result: { kind: 'noop', cursor, line, mode: 'normal' },
+            pending: PENDING_NONE,
+        };
+    }
+    // ─── Ex-line composition ───────────────────────────────────────
+    // Once `:` has been pressed we accumulate keystrokes into the
+    // pending buffer until Enter (commit) or Esc (cancel, handled
+    // above). Backspace shortens the buffer; any other char extends.
+    if (pending.kind === 'ex') {
+        if (input.enter) {
+            const cmd = pending.buffer;
+            if (cmd === 'w') {
+                return {
+                    result: { kind: 'submit', cursor, line, mode: 'normal', payload: line },
+                    pending: PENDING_NONE,
+                };
+            }
+            if (cmd === 'q') {
+                return {
+                    result: { kind: 'cancel', cursor: 0, line: '', mode: 'normal' },
+                    pending: PENDING_NONE,
+                };
+            }
+            // Unknown ex command — drop silently. The TUI may surface a
+            // dim hint but the keymap stays narrow (only `:w` / `:q` are
+            // contractual today).
+            return {
+                result: { kind: 'noop', cursor, line, mode: 'normal' },
+                pending: PENDING_NONE,
+            };
+        }
+        if (input.backspace) {
+            const nextBuf = pending.buffer.slice(0, -1);
+            if (nextBuf.length === 0) {
+                // Operator backspaced past `:` — exit ex composition.
+                return {
+                    result: { kind: 'noop', cursor, line, mode: 'normal' },
+                    pending: PENDING_NONE,
+                };
+            }
+            return {
+                result: { kind: 'noop', cursor, line, mode: 'normal' },
+                pending: { kind: 'ex', buffer: nextBuf },
+            };
+        }
+        if (ch.length > 0) {
+            return {
+                result: { kind: 'noop', cursor, line, mode: 'normal' },
+                pending: { kind: 'ex', buffer: pending.buffer + ch },
+            };
+        }
+        return {
+            result: { kind: 'noop', cursor, line, mode: 'normal' },
+            pending,
+        };
+    }
+    // ─── Single-shot bindings ──────────────────────────────────────
+    switch (ch) {
+        case 'i':
+            return {
+                result: { kind: 'mode', cursor, line, mode: 'insert' },
+                pending: PENDING_NONE,
+            };
+        case 'a': {
+            // `a` = append: advance cursor by one (capped) then enter
+            // insert. Matches vim semantics for the single-line case.
+            const next = Math.min(line.length, cursor + 1);
+            return {
+                result: { kind: 'mode', cursor: next, line, mode: 'insert' },
+                pending: PENDING_NONE,
+            };
+        }
+        case 'h':
+            return {
+                result: { kind: 'move', cursor: Math.max(0, cursor - 1), line, mode: 'normal' },
+                pending: PENDING_NONE,
+            };
+        case 'l':
+            return {
+                result: { kind: 'move', cursor: Math.min(line.length, cursor + 1), line, mode: 'normal' },
+                pending: PENDING_NONE,
+            };
+        case 'j':
+        case 'k':
+            // Single-line buffer — j/k are inert today. Returning a `move`
+            // keeps the discriminator consistent; the multi-line follow-up
+            // will compute a real new offset here.
+            return {
+                result: { kind: 'move', cursor, line, mode: 'normal' },
+                pending: PENDING_NONE,
+            };
+        case '0':
+            return {
+                result: { kind: 'move', cursor: 0, line, mode: 'normal' },
+                pending: PENDING_NONE,
+            };
+        case '$':
+            return {
+                result: { kind: 'move', cursor: line.length, line, mode: 'normal' },
+                pending: PENDING_NONE,
+            };
+        case 'w':
+            return {
+                result: { kind: 'move', cursor: wordForward(line, cursor), line, mode: 'normal' },
+                pending: PENDING_NONE,
+            };
+        case 'b':
+            return {
+                result: { kind: 'move', cursor: wordBackward(line, cursor), line, mode: 'normal' },
+                pending: PENDING_NONE,
+            };
+        case 'x': {
+            const { line: nextLine, cursor: nextCursor } = deleteCharUnder(line, cursor);
+            return {
+                result: { kind: 'edit', cursor: nextCursor, line: nextLine, mode: 'normal' },
+                pending: PENDING_NONE,
+            };
+        }
+        case 'd': {
+            // First `d` arms the dd sequence; second `d` commits the line
+            // delete. Any other key intervenes the sequence collapses
+            // (handled below in the fall-through path).
+            if (pending.kind === 'd') {
+                return {
+                    result: { kind: 'edit', cursor: 0, line: '', mode: 'normal' },
+                    pending: PENDING_NONE,
+                };
+            }
+            return {
+                result: { kind: 'noop', cursor, line, mode: 'normal' },
+                pending: { kind: 'd' },
+            };
+        }
+        case ':':
+            return {
+                result: { kind: 'noop', cursor, line, mode: 'normal' },
+                pending: { kind: 'ex', buffer: '' },
+            };
+        default:
+            // Unknown binding in normal mode — drop the keystroke + reset
+            // any pending sequence so a stale `d` does not silently arm a
+            // future delete after the operator wandered through unbound
+            // keys.
+            return {
+                result: { kind: 'noop', cursor, line, mode: 'normal' },
+                pending: PENDING_NONE,
+            };
+    }
+}
+/**
+ * Tiny helper exposed for the TUI so the banner / status line can
+ * render the active pending state without re-implementing the
+ * discriminator switch.
+ */
+export function describePending(pending) {
+    switch (pending.kind) {
+        case 'none':
+            return '';
+        case 'd':
+            return 'd';
+        case 'ex':
+            return `:${pending.buffer}`;
+    }
+}
+//# sourceMappingURL=keymap.js.map