@crouton-kit/crouter 0.3.70 → 0.3.79

package/dist/core/tui/__tests__/host-keybindings.test.d.ts

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

package/dist/core/tui/__tests__/host-keybindings.test.js

@@ -0,0 +1,112 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { resolveKeybindings } from '../../keybindings/index.js';
+import { matchViewBinding, matchesViewHostBinding, parseViewKeypress, resolveViewKeyHints } from '../host.js';
+function key(input = '', patch = {}) {
+    return {
+        upArrow: false,
+        downArrow: false,
+        leftArrow: false,
+        rightArrow: false,
+        return: false,
+        escape: false,
+        ctrl: false,
+        meta: false,
+        tab: false,
+        shiftTab: false,
+        backspace: false,
+        ...patch,
+    };
+}
+test('catalog view bindings use defaults, remaps, and effective hint labels', () => {
+    const keymap = [
+        { bindingId: 'crtr.view.canvas.down', intent: 'down', hint: { label: 'move' } },
+    ];
+    const defaults = resolveKeybindings();
+    assert.deepEqual(matchViewBinding(keymap, defaults, 'j', key('j'), { row: 0 }), { intent: 'down', payload: undefined });
+    assert.deepEqual(resolveViewKeyHints(keymap, defaults, { row: 0 }), [{ keys: 'J / Down', label: 'move' }]);
+    const remapped = resolveKeybindings({ 'crtr.view.canvas.down': ['x'] });
+    assert.equal(matchViewBinding(keymap, remapped, 'j', key('j'), { row: 0 }), null);
+    assert.deepEqual(matchViewBinding(keymap, remapped, 'x', key('x'), { row: 0 }), { intent: 'down', payload: undefined });
+    assert.deepEqual(resolveViewKeyHints(keymap, remapped, { row: 0 }), [{ keys: 'X', label: 'move' }]);
+});
+test('custom view literals retain their matching and presenter-authored hints', () => {
+    const keymap = [
+        { keys: ['z'], intent: 'custom', hint: { keys: 'z', label: 'custom' } },
+    ];
+    const bindings = resolveKeybindings();
+    assert.deepEqual(matchViewBinding(keymap, bindings, 'z', key('z'), undefined), { intent: 'custom', payload: undefined });
+    assert.equal(matchViewBinding(keymap, bindings, 'x', key('x'), undefined), null);
+    assert.deepEqual(resolveViewKeyHints(keymap, bindings, undefined), [{ keys: 'z', label: 'custom' }]);
+});
+test('Alt+<letter> does not falsely match a bare custom literal', () => {
+    const keymap = [{ keys: ['q'], intent: 'quit' }];
+    const bindings = resolveKeybindings();
+    const altQ = parseViewKeypress(Buffer.from('\x1bq'));
+    assert.equal(matchViewBinding(keymap, bindings, altQ.input, altQ.key, undefined, altQ.raw), null);
+    const q = parseViewKeypress(Buffer.from('q'));
+    assert.deepEqual(matchViewBinding(keymap, bindings, q.input, q.key, undefined, q.raw), { intent: 'quit', payload: undefined });
+});
+test('host force quit and capture deletion follow catalog IDs through raw terminal decoding', () => {
+    const defaults = resolveKeybindings();
+    const ctrlC = parseViewKeypress(Buffer.from('\x03'));
+    const del = parseViewKeypress(Buffer.from('\x7f'), defaults);
+    const bs = parseViewKeypress(Buffer.from('\b'), defaults);
+    assert.ok(matchesViewHostBinding(defaults, 'crtr.view.host.force-quit', ctrlC.raw));
+    assert.ok(matchesViewHostBinding(defaults, 'crtr.view.host.editor.backspace', del.raw));
+    // 0x08 stays Backspace under default config so ^H-erase terminals still delete.
+    assert.ok(matchesViewHostBinding(defaults, 'crtr.view.host.editor.backspace', bs.raw));
+    const remapped = resolveKeybindings({
+        'crtr.view.host.force-quit': ['alt+x'],
+        'crtr.view.host.editor.backspace': ['ctrl+h'],
+    });
+    const altX = parseViewKeypress(Buffer.from('\x1bx'), remapped);
+    const ctrlH = parseViewKeypress(Buffer.from('\b'), remapped);
+    const delRemap = parseViewKeypress(Buffer.from('\x7f'), remapped);
+    assert.equal(matchesViewHostBinding(remapped, 'crtr.view.host.force-quit', ctrlC.raw), false);
+    assert.ok(matchesViewHostBinding(remapped, 'crtr.view.host.force-quit', altX.raw));
+    // With deletion remapped to Ctrl-H, the 0x08 byte deletes and DEL no longer does.
+    assert.equal(matchesViewHostBinding(remapped, 'crtr.view.host.editor.backspace', delRemap.raw), false);
+    assert.ok(matchesViewHostBinding(remapped, 'crtr.view.host.editor.backspace', ctrlH.raw));
+});
+test('Alt+Backspace deletes like Backspace under default config', () => {
+    const defaults = resolveKeybindings();
+    const altDel = parseViewKeypress(Buffer.from('\x1b\x7f'), defaults);
+    const altBs = parseViewKeypress(Buffer.from('\x1b\b'), defaults);
+    assert.ok(matchesViewHostBinding(defaults, 'crtr.view.host.editor.backspace', altDel.raw));
+    assert.ok(matchesViewHostBinding(defaults, 'crtr.view.host.editor.backspace', altBs.raw));
+});
+test('raw terminal decoding covers modified arrows and enter/return equivalence', () => {
+    const keymap = [{ bindingId: 'crtr.view.settings.edit-or-submit', intent: 'submit' }];
+    const bindings = resolveKeybindings();
+    const cr = parseViewKeypress(Buffer.from('\r'));
+    const lf = parseViewKeypress(Buffer.from('\n'));
+    assert.deepEqual(matchViewBinding(keymap, bindings, cr.input, cr.key, undefined, cr.raw), { intent: 'submit', payload: undefined });
+    assert.deepEqual(matchViewBinding(keymap, bindings, lf.input, lf.key, undefined, lf.raw), { intent: 'submit', payload: undefined });
+    const ctrlUp = parseViewKeypress(Buffer.from('\x1b[1;5A'));
+    assert.equal(ctrlUp.raw.upArrow, true);
+    assert.equal(ctrlUp.raw.ctrl, true);
+    const up = parseViewKeypress(Buffer.from('\x1b[A'));
+    assert.equal(up.raw.upArrow, true);
+    assert.equal(up.raw.ctrl, false);
+});
+test('a disabled binding neither matches nor renders a hint', () => {
+    const keymap = [
+        { bindingId: 'crtr.view.canvas.refresh', intent: 'refresh', hint: { label: 'refresh' } },
+    ];
+    const bindings = resolveKeybindings({ 'crtr.view.canvas.refresh': [] });
+    const g = parseViewKeypress(Buffer.from('g'));
+    assert.equal(matchViewBinding(keymap, bindings, g.input, g.key, undefined, g.raw), null);
+    assert.deepEqual(resolveViewKeyHints(keymap, bindings, undefined), []);
+});
+test('capture hints are host-owned, mode-gated, and keep custom KeyHint keys verbatim', () => {
+    const gated = [
+        { capture: 'setDraft', when: (state) => state.compose, hint: { label: 'compose' } },
+    ];
+    assert.deepEqual(resolveViewKeyHints(gated, resolveKeybindings(), { compose: true }), [{ keys: 'type', label: 'compose' }]);
+    assert.deepEqual(resolveViewKeyHints(gated, resolveKeybindings(), { compose: false }), []);
+    const custom = [
+        { capture: 'setDraft', when: () => true, hint: { keys: 'edit', label: 'compose' } },
+    ];
+    assert.deepEqual(resolveViewKeyHints(custom, resolveKeybindings(), undefined), [{ keys: 'edit', label: 'compose' }]);
+});

package/dist/core/tui/host.d.ts

@@ -1,5 +1,7 @@
+import { type Key } from './terminal.js';
 import { type Draw, type Rect, type Size } from './draw.js';
-import type { ViewCore, TuiPresenter, TextPresenter, KeyHint, BannerLevel } from '../view/contract.js';
+import type { ViewCore, TuiPresenter, TextPresenter, KeyBinding, KeyHint, BannerLevel } from '../view/contract.js';
+import { type BindingId, type BindingResolution, type RawTerminalInput } from '../keybindings/index.js';
 export interface RunViewOptions {
     /** CLI flags forwarded verbatim to the view via host.options. */
     options?: Record<string, string>;
@@ -32,6 +34,33 @@ export interface ChromeManifest {
  *  on the row above it when set. */
 declare function drawChrome(draw: Draw, size: Size, manifest: ChromeManifest, c: Chrome, now?: number): Rect;
 export { drawChrome };
+/** Tokens a keystroke can match a keymap binding's `keys` against. Arrows →
+ *  up/down/left/right, return → return|enter, escape → escape|esc, a printable
+ *  char → the char itself (+ 'space' for ' '), ctrl+x → ctrl+x|c-x. */
+export interface ViewKeypress {
+    readonly input: string;
+    readonly key: Key;
+    readonly raw: RawTerminalInput;
+}
+/** Extend the shared legacy parser with the terminal gestures the catalog can
+ * express. The raw shape goes only to the catalog matcher; custom literals keep
+ * their established Key-based matching. When `bindings` is supplied the ambiguous
+ * 0x08 byte resolves to Ctrl-H only if an effective binding claims it. */
+export declare function parseViewKeypress(data: Buffer, bindings?: BindingResolution<BindingId>): ViewKeypress;
+/** Resolve footer hints for the CURRENT state: only bindings whose `when(state)`
+ * passes contribute, so mode-gated affordances (compose/react send/cancel/pick)
+ * appear exactly while active. Catalog bindings render the effective key label
+ * (omitted entirely when disabled); custom-view literal hints stay verbatim. */
+export declare function resolveViewKeyHints<S>(keymap: KeyBinding<S>[], bindings: BindingResolution<BindingId>, state: S): KeyHint[];
+/** The first non-capture binding whose key matches and whose `when` (if any)
+ * passes — catalog IDs use the terminal matcher; custom literals retain their
+ * presenter-authored matching. */
+export declare function matchViewBinding<S>(keymap: KeyBinding<S>[], bindings: BindingResolution<BindingId>, input: string, key: Key, state: S, raw?: RawTerminalInput): {
+    intent: string;
+    payload: unknown;
+} | null;
+/** Match a host-owned generic-view action through the same catalog snapshot. */
+export declare function matchesViewHostBinding(bindings: BindingResolution<BindingId>, id: 'crtr.view.host.force-quit' | 'crtr.view.host.editor.backspace', raw: RawTerminalInput): boolean;
 /** Host a dual-target ViewCore + TuiPresenter in the alt screen until it quits
  *  (or Ctrl-C). `text` is the optional text presenter for the piped path. */
 export declare function runCoreView<S>(core: ViewCore<S>, tui: TuiPresenter<S>, text: TextPresenter<S> | null, opts?: RunViewOptions): Promise<void>;

package/dist/core/tui/host.js

@@ -22,6 +22,7 @@ import { setupTerminal, restoreTerminal, getTerminalSize, parseKeypress, } from
 import { createDraw, detectColorCaps } from './draw.js';
 import { initialChrome, deriveState } from '../view/chrome.js';
 import { createLocalTransport } from '../view/transport-local.js';
+import { formatBinding, matchesTerminalInput, resolveUserKeybindings, } from '../keybindings/index.js';
 // Numeric SGR codes only (a color NAME emits a broken CSI — see draw.ts guard).
 const FG = { cyan: '36', green: '32', yellow: '33', red: '31', grey: '90' };
 /** The persistent state signal: word + glyph + hue, derived from host signals so
@@ -179,15 +180,94 @@ function drawChrome(draw, size, manifest, c, now = Date.now()) {
     return { row: top, col: 0, width: cols, height };
 }
 export { drawChrome };
-// ── Dual-target core host (runCoreView) ─────────────────────────────────────
-//
-// Hosts a ViewCore + TuiPresenter under the dual-target contract
-// (src/core/view/contract.ts). The model is the immutable-state + intents thunk
-// runtime: the core owns all state + behavior, presenters are pure reads, and a
-// keystroke maps through the keymap to a named intent the host dispatches.
-/** Tokens a keystroke can match a keymap binding's `keys` against. Arrows →
- *  up/down/left/right, return → return|enter, escape → escape|esc, a printable
- *  char → the char itself (+ 'space' for ' '), ctrl+x → ctrl+x|c-x. */
+/** True when some effective binding claims the `ctrl+h` gesture — used to decide
+ * whether the ambiguous 0x08 byte is a Ctrl-H remap or a plain Backspace. */
+function bindingSetClaimsCtrlH(bindings) {
+    for (const eff of bindings.bindings.values()) {
+        if (eff.gestures.includes('ctrl+h'))
+            return true;
+    }
+    return false;
+}
+/** One-line summary of rejected hand-edited overrides, surfaced once per surface. */
+function summarizeKeybindingDiagnostics(diags) {
+    if (diags.length === 0)
+        return null;
+    const extra = diags.length > 1 ? ` (+${diags.length - 1} more)` : '';
+    return `keybindings: ${diags[0].message}${extra}`;
+}
+/** Extend the shared legacy parser with the terminal gestures the catalog can
+ * express. The raw shape goes only to the catalog matcher; custom literals keep
+ * their established Key-based matching. When `bindings` is supplied the ambiguous
+ * 0x08 byte resolves to Ctrl-H only if an effective binding claims it. */
+export function parseViewKeypress(data, bindings) {
+    const parsed = parseKeypress(data);
+    const raw = { ...parsed.key, input: parsed.input };
+    const sequence = data.toString('utf8');
+    const named = {
+        '\x1b[3~': 'delete', '\x1b[5~': 'pageUp', '\x1b[6~': 'pageDown',
+        '\x1b[H': 'home', '\x1b[F': 'end', '\x1b[1~': 'home', '\x1b[4~': 'end',
+        '\x1bOH': 'home', '\x1bOF': 'end',
+    };
+    const setModifiers = (code) => {
+        const value = Number(code);
+        raw.shift = value === 2 || value === 4 || value === 6 || value === 8;
+        raw.meta = value === 3 || value === 4 || value === 7 || value === 8;
+        raw.ctrl = value === 5 || value === 6 || value === 7 || value === 8;
+    };
+    const namedKey = named[sequence];
+    if (namedKey)
+        raw[namedKey] = true;
+    const arrow = /^\x1b\[(?:1;)?([2-8])?([ABCD])$/.exec(sequence);
+    if (arrow) {
+        setModifiers(arrow[1]);
+        raw[{ A: 'upArrow', B: 'downArrow', C: 'rightArrow', D: 'leftArrow' }[arrow[2]]] = true;
+    }
+    const modifiedNamed = /^\x1b\[(3|5|6|1|4);([2-8])~$/.exec(sequence);
+    if (modifiedNamed) {
+        raw[{ 3: 'delete', 5: 'pageUp', 6: 'pageDown', 1: 'home', 4: 'end' }[modifiedNamed[1]]] = true;
+        setModifiers(modifiedNamed[2]);
+    }
+    const modifiedHomeEnd = /^\x1b\[1;([2-8])([HF])$/.exec(sequence);
+    if (modifiedHomeEnd) {
+        raw[modifiedHomeEnd[2] === 'H' ? 'home' : 'end'] = true;
+        setModifiers(modifiedHomeEnd[1]);
+    }
+    // Alt+<char> gestures (ESC-prefixed printables/control letters) that the
+    // legacy parser leaves as a raw two-byte `input`. Only the raw catalog shape
+    // gains the alt modifier; `parsed` keeps its Key-based shape so custom literals
+    // still match exactly as before (Alt+<letter> must NOT match a bare literal).
+    // Special keys the legacy parser already decoded (Alt+Backspace, arrows, …)
+    // return `input: ''`, so `parsed.input === sequence` skips them here.
+    if (sequence.length === 2 && sequence.startsWith('\x1b') && parsed.input === sequence) {
+        const code = sequence.charCodeAt(1);
+        raw.input = code < 32 ? String.fromCharCode(code + 64).toLowerCase() : sequence[1];
+        raw.meta = true;
+        raw.ctrl = code < 32;
+    }
+    // Backspace family. \x7f, \b, and their Alt-prefixed forms all mean "delete one
+    // char" and canonicalize to plain backspace (there is no alt+backspace catalog
+    // action, so Alt+Backspace deletes exactly like Backspace, as before). The 0x08
+    // byte is ALSO Ctrl-H: honor a Ctrl-H remap only when an effective binding
+    // actually claims `ctrl+h`, otherwise it stays backspace so default deletion
+    // keeps working on ^H-erase terminals.
+    if (raw.backspace) {
+        const ctrlHByte = sequence === '\b' || sequence === '\x1b\b';
+        if (ctrlHByte && bindings && bindingSetClaimsCtrlH(bindings)) {
+            raw.input = 'h';
+            raw.ctrl = true;
+            raw.meta = false;
+            raw.backspace = false;
+        }
+        else {
+            raw.input = '';
+            raw.ctrl = false;
+            raw.meta = false;
+            raw.backspace = true;
+        }
+    }
+    return { ...parsed, raw };
+}
 function keyTokens(input, key) {
     const t = [];
     if (key.upArrow)
@@ -228,21 +308,53 @@ function isPrintable(input, key) {
 function sanitizePrintable(s) {
     return Array.from(s).filter((ch) => ch.charCodeAt(0) >= 32).join('');
 }
+/** Resolve footer hints for the CURRENT state: only bindings whose `when(state)`
+ * passes contribute, so mode-gated affordances (compose/react send/cancel/pick)
+ * appear exactly while active. Catalog bindings render the effective key label
+ * (omitted entirely when disabled); custom-view literal hints stay verbatim. */
+export function resolveViewKeyHints(keymap, bindings, state) {
+    const hints = [];
+    for (const binding of keymap) {
+        if (!binding.hint)
+            continue;
+        if (binding.when && !binding.when(state))
+            continue;
+        if ('bindingId' in binding) {
+            if (bindings.gestures(binding.bindingId).length === 0)
+                continue; // disabled: no hint
+            hints.push({ keys: formatBinding(bindings, binding.bindingId), label: binding.hint.label });
+        }
+        else if ('capture' in binding) {
+            hints.push('keys' in binding.hint ? binding.hint : { keys: 'type', label: binding.hint.label });
+        }
+        else {
+            hints.push(binding.hint);
+        }
+    }
+    return hints;
+}
 /** The first non-capture binding whose key matches and whose `when` (if any)
- *  passes — returns the intent name + resolved payload. */
-function matchBinding(keymap, input, key, state) {
+ * passes — catalog IDs use the terminal matcher; custom literals retain their
+ * presenter-authored matching. */
+export function matchViewBinding(keymap, bindings, input, key, state, raw = { ...key, input }) {
     const tokens = keyTokens(input, key);
-    for (const b of keymap) {
-        if ('capture' in b)
+    for (const binding of keymap) {
+        if ('capture' in binding)
             continue;
-        if (b.when && !b.when(state))
+        if (binding.when && !binding.when(state))
             continue;
-        if (b.keys.some((k) => tokens.includes(k))) {
-            return { intent: b.intent, payload: b.payload ? b.payload(state) : undefined };
-        }
+        const matches = 'bindingId' in binding
+            ? matchesTerminalInput(bindings, binding.bindingId, raw)
+            : binding.keys.some((literal) => tokens.includes(literal));
+        if (matches)
+            return { intent: binding.intent, payload: binding.payload ? binding.payload(state) : undefined };
     }
     return null;
 }
+/** Match a host-owned generic-view action through the same catalog snapshot. */
+export function matchesViewHostBinding(bindings, id, raw) {
+    return matchesTerminalInput(bindings, id, raw);
+}
 /** The active text-capture binding for this state, if any (compose-mode entry). */
 function activeCapture(keymap, state) {
     for (const b of keymap) {
@@ -271,9 +383,13 @@ async function runRequest(transport, src, args) {
  *  (or Ctrl-C). `text` is the optional text presenter for the piped path. */
 export async function runCoreView(core, tui, text, opts = {}) {
     const options = Object.freeze({ ...(opts.options ?? {}) });
+    const bindings = resolveUserKeybindings();
+    const keybindingNotice = summarizeKeybindingDiagnostics(bindings.diagnostics);
     const transport = createLocalTransport({ cwd: process.cwd() });
     // ── Non-TTY / piped path: init, best-effort refresh, dump, exit 0. ──
     if (!process.stdin.isTTY) {
+        if (keybindingNotice)
+            process.stderr.write(`${keybindingNotice}\n`);
         let dstate = core.init(options);
         const dchrome = initialChrome();
         const dsignal = {
@@ -307,13 +423,9 @@ export async function runCoreView(core, tui, text, opts = {}) {
     let state = core.init(options);
     const chrome = initialChrome();
     let tick = 0;
-    // Footer hints come from the keymap bindings' `hint` field (single source of
-    // truth) — projected into the (ChromeManifest, Chrome) shape drawChrome reads.
-    const hints = [];
-    for (const b of tui.keymap) {
-        if (b.hint)
-            hints.push(b.hint);
-    }
+    // Report rejected hand-edited overrides once, as a chrome notice.
+    if (keybindingNotice)
+        chrome.banner = { msg: keybindingNotice, level: 'action' };
     // Restore the terminal exactly once, however we leave.
     let restored = false;
     const cleanup = () => {
@@ -329,7 +441,9 @@ export async function runCoreView(core, tui, text, opts = {}) {
     const render = () => {
         const size = getTerminalSize();
         const { draw, frame } = createDraw(size, caps);
-        const chromeManifest = { ...core.manifest, keymap: hints };
+        // Footer hints are re-derived per draw so they track the active mode
+        // (compose/react affordances appear only while their `when(state)` holds).
+        const chromeManifest = { ...core.manifest, keymap: resolveViewKeyHints(tui.keymap, bindings, state) };
         const tickChrome = { ...chrome, tick };
         const content = drawChrome(draw, size, chromeManifest, tickChrome);
         try {
@@ -525,14 +639,14 @@ export async function runCoreView(core, tui, text, opts = {}) {
             return;
         let parsed;
         try {
-            parsed = parseKeypress(data);
+            parsed = parseViewKeypress(data, bindings);
         }
         catch {
             return;
         }
-        const { input, key } = parsed;
-        // Ctrl-C is the universal escape hatch — works even mid-flight.
-        if (key.ctrl && input === 'c') {
+        const { input, key, raw } = parsed;
+        // The catalog-backed escape hatch works even mid-flight.
+        if (matchesViewHostBinding(bindings, 'crtr.view.host.force-quit', raw)) {
             finish();
             return;
         }
@@ -544,13 +658,13 @@ export async function runCoreView(core, tui, text, opts = {}) {
         // fall through to the keymap so submit/cancel can be bound.
         const cap = activeCapture(tui.keymap, state);
         if (cap) {
-            if (isPrintable(input, key)) {
-                captureBuf += sanitizePrintable(input);
+            if (matchesViewHostBinding(bindings, 'crtr.view.host.editor.backspace', raw)) {
+                captureBuf = captureBuf.slice(0, -1);
                 await enqueueDispatch(cap.capture, captureBuf);
                 return;
             }
-            if (key.backspace) {
-                captureBuf = captureBuf.slice(0, -1);
+            if (isPrintable(input, key)) {
+                captureBuf += sanitizePrintable(input);
                 await enqueueDispatch(cap.capture, captureBuf);
                 return;
             }
@@ -558,7 +672,7 @@ export async function runCoreView(core, tui, text, opts = {}) {
         else {
             captureBuf = '';
         }
-        const m = matchBinding(tui.keymap, input, key, state);
+        const m = matchViewBinding(tui.keymap, bindings, input, key, state, raw);
         if (m)
             await enqueueDispatch(m.intent, m.payload);
     };

package/dist/core/view/contract.d.ts

@@ -154,7 +154,20 @@ export interface KeyHint {
     keys: string;
     label: string;
 }
+/** A catalog binding supplies only its semantic hint label: the host derives
+ * the rendered key label from the effective user binding snapshot. */
+export interface CatalogKeyHint {
+    label: string;
+}
 export type KeyBinding<S> = {
+    /** Closed crouter catalog action. Shipped presenters use this form. */
+    bindingId: import('../keybindings/index.js').BindingId;
+    intent: string;
+    payload?: (state: S) => unknown;
+    when?: (state: S) => boolean;
+    hint?: CatalogKeyHint;
+} | {
+    /** Literal keys remain owned by custom/plugin views, outside crouter's catalog. */
     keys: string[];
     intent: string;
     payload?: (state: S) => unknown;
@@ -162,11 +175,12 @@ export type KeyBinding<S> = {
     hint?: KeyHint;
 } | {
     /** Text-capture binding: while `when(state)` is true the host runs a
-     *  built-in line-edit buffer over raw printable/backspace keys and
-     *  dispatches `capture` with the next draft value on each edit. */
+     *  built-in line-edit buffer over raw printable keys and dispatches
+     *  `capture` with the next draft value on each edit. Deletion is the
+     *  host catalog action `crtr.view.host.editor.backspace`. */
     capture: string;
     when: (state: S) => boolean;
-    hint?: KeyHint;
+    hint?: KeyHint | CatalogKeyHint;
 };
 export interface TuiPresenter<S = unknown> {
     /** Pure read of state, paints via draw.*; never ANSI. */