@deepseek-harness-tui/dsh-tui 0.9.0 → 0.9.2

package/lib/types/utils/fileTarget.d.ts

@@ -0,0 +1,46 @@
+/** Our custom OSC 8 scheme carrying a raw display path (URI-encoded). */
+export declare const FILE_LINK_SCHEME = "dsh-file:";
+/** Encode a display path into a `dsh-file:` link URL. */
+export declare function fileLinkUrl(path: string): string;
+/**
+ * Decode a `dsh-file:` link URL back to the raw display path. Returns
+ * undefined for anything that is not a well-formed dsh-file URL.
+ */
+export declare function parseFileLinkUrl(url: string): string | undefined;
+/**
+ * Resolve a target (raw display path) against the session's base directory:
+ * absolute paths and `~` pass through (with ~ expanded), everything else is
+ * joined onto the base. Pure, so it is unit-testable without a workspace.
+ */
+export declare function resolveTargetPath(path: string, baseDir: string): string;
+/**
+ * Convert a `file://` URL to a local path. Wraps node:url.fileURLToPath —
+ * undefined when the URL is not a valid file URL.
+ */
+export declare function fileUrlToPath(url: string): string | undefined;
+/**
+ * Conservative heuristic: does this text look like a file path worth
+ * making clickable? Requires a slash separator, no whitespace, no URL/email
+ * shape, and either a path anchor (`./`, `../`, `/`, `~/`, drive letter)
+ * with a real path shape (another separator or an extension — a bare
+ * anchored word like `/a` or `x.com/a` is too ambiguous), or a plausible
+ * file extension. Length-capped so huge tokens (base64, logs) never get
+ * linked.
+ */
+export declare function looksLikeFilePath(text: string): boolean;
+/**
+ * Best-effort existence hint: does `path` exist on disk? Used to decide
+ * whether to render a path as clickable in contexts where the raw text is
+ * ambiguous; never throws.
+ */
+export declare function pathExistsOnDisk(path: string): boolean;
+/**
+ * Replace every path-looking span in `text` via `wrap(path, display)`.
+ * Trailing sentence punctuation stays OUTSIDE the wrapped display (so
+ * "src/foo.ts." links `src/foo.ts` and keeps the period). Spans that fail
+ * `looksLikeFilePath` are returned unchanged.
+ * @param text - plain text to scan (no ANSI).
+ * @param wrap - builds the clickable rendering for one path.
+ */
+export declare function linkifyFilePaths(text: string, wrap: (path: string, display: string) => string): string;
+//# sourceMappingURL=fileTarget.d.ts.map

package/lib/types/utils/fileTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileTarget.d.ts","sourceRoot":"","sources":["../../../src/utils/fileTarget.ts"],"names":[],"mappings":"AAuBA,yEAAyE;AACzE,eAAO,MAAM,gBAAgB,cAAc,CAAA;AAE3C,yDAAyD;AACzD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOhE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAWvE;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAM7D;AA0BD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAoBvD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAMtD;AAWD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,GAC9C,MAAM,CAcR"}

package/lib/types/utils/fileTarget.js

@@ -0,0 +1,178 @@
+/**
+ * Clickable file targets: turning path-like text in AI output into
+ * clickable targets, and resolving those targets back to absolute paths at
+ * click time.
+ *
+ * Two URL shapes are produced / accepted:
+ * - `dsh-file:<encodeURIComponent(path)>` — our own scheme. The payload is
+ *   the RAW displayed path (possibly relative, possibly Windows-style), so
+ *   nothing is lost in transit and it resolves against the CURRENT
+ *   workspace at click time (paths in a long-lived session may outlive the
+ *   cwd they were written under).
+ * - `file://…` — real file URLs the model may emit in markdown; decoded
+ *   with node:url and treated the same way.
+ *
+ * `looksLikeFilePath` is deliberately conservative: it must be obviously a
+ * path (slash + no whitespace + anchor or extension), otherwise prose like
+ * "and/or" or "2024/01/15" would light up as clickable everywhere.
+ */
+import { resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { existsSync } from 'node:fs';
+/** Our custom OSC 8 scheme carrying a raw display path (URI-encoded). */
+export const FILE_LINK_SCHEME = 'dsh-file:';
+/** Encode a display path into a `dsh-file:` link URL. */
+export function fileLinkUrl(path) {
+    return FILE_LINK_SCHEME + encodeURIComponent(path);
+}
+/**
+ * Decode a `dsh-file:` link URL back to the raw display path. Returns
+ * undefined for anything that is not a well-formed dsh-file URL.
+ */
+export function parseFileLinkUrl(url) {
+    if (!url.startsWith(FILE_LINK_SCHEME))
+        return undefined;
+    try {
+        return decodeURIComponent(url.slice(FILE_LINK_SCHEME.length));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Resolve a target (raw display path) against the session's base directory:
+ * absolute paths and `~` pass through (with ~ expanded), everything else is
+ * joined onto the base. Pure, so it is unit-testable without a workspace.
+ */
+export function resolveTargetPath(path, baseDir) {
+    if (path === '')
+        return path;
+    if (path.startsWith('~/'))
+        return resolve(homedir(), path.slice(2));
+    if (path === '~')
+        return homedir();
+    // Windows drive-absolute (`C:\…`, `C:/…`) is absolute regardless of
+    // platform; node:path.isAbsolute handles the current platform only, so
+    // probe both separators explicitly.
+    if (/^[A-Za-z]:[\\/]/.test(path) || path.startsWith('/') || path.startsWith('\\')) {
+        return path;
+    }
+    return resolve(baseDir, path);
+}
+/**
+ * Convert a `file://` URL to a local path. Wraps node:url.fileURLToPath —
+ * undefined when the URL is not a valid file URL.
+ */
+export function fileUrlToPath(url) {
+    try {
+        return fileURLToPath(url);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Known source/config/data file extensions — the conservative allowlist. */
+const FILE_EXTENSION_RE = /\.([A-Za-z0-9]{1,6})$/u;
+/** A path is worth linking when it carries one of these anchors, or has a
+ *  known-extension tail. */
+const PATH_ANCHOR_RE = /^(\.{1,2}[\\/]|[\\/]|~[\\/]|[A-Za-z]:[\\/])/u;
+/** Stoplist for extension-like tails that are TLDs / prose words, not
+ *  file extensions (`github.com/foo` must not link as a file). */
+const NON_EXTENSION_TAILS = new Set([
+    'com', 'org', 'net', 'io', 'dev', 'app', 'edu', 'gov', 'mil', 'co', 'uk', 'cn',
+]);
+/** A dot-suffix of up to 6 alphanumerics is a plausible extension when at
+ *  least 4 chars precede it (`a/b.x`-style prose fragments and short
+ *  `x/y.ts` guesses must not false-positive). */
+function hasPlausibleExtension(stripped) {
+    const extMatch = FILE_EXTENSION_RE.exec(stripped);
+    if (extMatch === null)
+        return false;
+    const ext = extMatch[1].toLowerCase();
+    if (NON_EXTENSION_TAILS.has(ext))
+        return false;
+    return stripped.slice(0, extMatch.index).length >= 4;
+}
+/**
+ * Conservative heuristic: does this text look like a file path worth
+ * making clickable? Requires a slash separator, no whitespace, no URL/email
+ * shape, and either a path anchor (`./`, `../`, `/`, `~/`, drive letter)
+ * with a real path shape (another separator or an extension — a bare
+ * anchored word like `/a` or `x.com/a` is too ambiguous), or a plausible
+ * file extension. Length-capped so huge tokens (base64, logs) never get
+ * linked.
+ */
+export function looksLikeFilePath(text) {
+    const t = text.trim();
+    if (t.length < 2 || t.length > 200)
+        return false;
+    if (!t.includes('/') && !t.includes('\\'))
+        return false;
+    if (/\s/u.test(t))
+        return false;
+    if (/[<>"'`|?*]/.test(t))
+        return false;
+    // URLs (any scheme://, incl. file://) and emails are handled by their
+    // own linkifiers.
+    if (/^[a-z][a-z0-9+.-]*:\/\//iu.test(t) || /^www\./iu.test(t))
+        return false;
+    if (t.includes('@'))
+        return false;
+    if (/[#\u0000-\u001f]/u.test(t))
+        return false;
+    // Strip one layer of trailing punctuation so "foo/bar.ts." still links.
+    const stripped = t.replace(/[.,;:!?]+$/u, '');
+    if (stripped === '')
+        return false;
+    const separators = (stripped.match(/[\\/]/gu) ?? []).length;
+    if (PATH_ANCHOR_RE.test(stripped)) {
+        return separators >= 2 || hasPlausibleExtension(stripped);
+    }
+    return hasPlausibleExtension(stripped);
+}
+/**
+ * Best-effort existence hint: does `path` exist on disk? Used to decide
+ * whether to render a path as clickable in contexts where the raw text is
+ * ambiguous; never throws.
+ */
+export function pathExistsOnDisk(path) {
+    try {
+        return existsSync(path);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Candidate-span scanner: anchored paths (`./`, `../`, `/`, `~/`, drive)
+ * run to the end of the word; everything else must contain a slash AND a
+ * dot-extension tail. This is only a pre-filter — every span is then
+ * verified by `looksLikeFilePath` before it becomes clickable.
+ */
+const PATH_SPAN_RE = /(?:\.{1,2}[\\/]|[\\/]|~[\\/]|[A-Za-z]:[\\/])[^\s<>"'`|?#]*|(?:[^\s<>"'`|?#]*[\\/][^\s<>"'`|?#]*\.[A-Za-z0-9]{1,6})/gu;
+/**
+ * Replace every path-looking span in `text` via `wrap(path, display)`.
+ * Trailing sentence punctuation stays OUTSIDE the wrapped display (so
+ * "src/foo.ts." links `src/foo.ts` and keeps the period). Spans that fail
+ * `looksLikeFilePath` are returned unchanged.
+ * @param text - plain text to scan (no ANSI).
+ * @param wrap - builds the clickable rendering for one path.
+ */
+export function linkifyFilePaths(text, wrap) {
+    return text.replace(PATH_SPAN_RE, (match, offset, full) => {
+        // The slash-anchor branch would otherwise match inside URLs
+        // (`https:/…` matches `/…`): a span glued to a scheme colon or a `//`
+        // run is part of a URL, never a path. offset is available because the
+        // regex has no capture groups.
+        if (offset > 0) {
+            const prev = full[offset - 1];
+            if (prev === ':' || prev === '/')
+                return match;
+        }
+        const display = match.replace(/[.,;:!?]+$/u, '');
+        if (display === '' || !looksLikeFilePath(display))
+            return match;
+        return wrap(display, display) + match.slice(display.length);
+    });
+}

package/lib/types/utils/keymap.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Built-in keyboard-shortcut keymap: the shared combo grammar, the action
+ * registry, and the live override cache behind `/settings` customization.
+ *
+ * Split of concerns across the input stack:
+ * - `dsh-adapter/shortcuts.ts` owns the PLUGIN registry (`ctx.tuiShortcuts`)
+ *   and re-exports the grammar from here so both sides parse identically.
+ * - This module owns what the TUI itself binds: a fixed set of named actions
+ *   (paste, history, editor, …) whose combos resolve as
+ *   settings.yaml user layer > cordis.yml `shortcuts` > the registry default.
+ * `Chat.tsx` / `PromptInput.tsx` match keypresses against the EFFECTIVE
+ * combos via {@link actionMatches} — never against a hardcoded string.
+ *
+ * The macOS modifier alias mirrors `isMod`: a combo spelled with `ctrl`
+ * matches Cmd (`super`) on the mac too, so `ctrl+v` keeps meaning "paste
+ * with the platform primary modifier" everywhere. `alt` always means the
+ * ink `meta` flag. Shift must match exactly (ctrl+shift+v is the terminal's
+ * native paste, never the app's clipboard read).
+ */
+/** Minimal structural shape of the ink Key flags the matchers read. */
+export interface ComboKeyFlags {
+    ctrl?: boolean;
+    meta?: boolean;
+    super?: boolean;
+    shift?: boolean;
+    return?: boolean;
+    escape?: boolean;
+    tab?: boolean;
+    backspace?: boolean;
+    delete?: boolean;
+    upArrow?: boolean;
+    downArrow?: boolean;
+    leftArrow?: boolean;
+    rightArrow?: boolean;
+    home?: boolean;
+    end?: boolean;
+    pageUp?: boolean;
+    pageDown?: boolean;
+}
+/** A parsed `ctrl+shift+p` style combo. */
+export interface ParsedCombo {
+    readonly raw: string;
+    readonly ctrl: boolean;
+    readonly meta: boolean;
+    readonly shift: boolean;
+    /** Named key flag on the Key object, or undefined for a character key. */
+    readonly named?: keyof ComboKeyFlags;
+    /** Character to match against the ink `input` string (lowercased). */
+    readonly char?: string;
+}
+/**
+ * Parse `ctrl+shift+p` style combos. Returns undefined on anything
+ * malformed or disallowed (no ctrl/alt modifier, unknown key name, escape
+ * combos — the same grammar the plugin shortcut registry enforces).
+ */
+export declare function parseCombo(raw: string): ParsedCombo | undefined;
+/** Canonical form for dedupe/reserved checks: modifiers sorted, key last. */
+export declare function canonicalCombo(combo: ParsedCombo): string;
+/** Canonicalize a user-spelled combo string (`ctrl+c`); unparseable input
+ *  comes back lowercased as-is so reserved sets can still carry entries the
+ *  grammar itself refuses (bare escape, tab…). */
+export declare function canonicalComboString(raw: string): string;
+/**
+ * Strict matcher (plugin registry semantics): every modifier flag must equal
+ * the combo's. `ctrl` means the ctrl flag only — no platform alias.
+ */
+export declare function comboMatchesStrict(combo: ParsedCombo, input: string, key: ComboKeyFlags): boolean;
+/** Identifiers of every customizable built-in action. */
+export type ShortcutActionId = 'paste' | 'history' | 'editor' | 'transcript' | 'trajectory' | 'dashboard' | 'contextPanel' | 'showAll' | 'redraw' | 'todoFold';
+export interface ShortcutActionSpec {
+    readonly id: ShortcutActionId;
+    /** Default combos; the FIRST entry is the canonical display form. */
+    readonly defaults: readonly string[];
+}
+/**
+ * The registry. Defaults encode today's hard-wired bindings — `paste` also
+ * carries the `alt+v` alias for terminals that intercept Ctrl+V before the
+ * app ever sees the byte (some terminals/IMEs reserve Ctrl+V for their own
+ * paste and never forward it in raw mode).
+ */
+export declare const SHORTCUT_ACTIONS: readonly ShortcutActionSpec[];
+/**
+ * Replace the whole override map. Invalid or blank entries are DROPPED
+ * (the action keeps its default) — a typo in cordis.yml must never disable
+ * a built-in, and the settings field's parse already refuses invalid
+ * drafts before anything is written.
+ */
+export declare function setKeymapOverrides(overrides: Partial<Record<ShortcutActionId, string | readonly string[] | undefined>>): void;
+/** Test seam: drop every override. */
+export declare function resetKeymapOverrides(): void;
+/** Effective combos for one action (overrides win over defaults). */
+export declare function effectiveCombos(action: ShortcutActionId): readonly ParsedCombo[];
+/** Effective combos as display strings (`ctrl+v, alt+v`). */
+export declare function effectiveComboString(action: ShortcutActionId): string;
+/** Match a keypress against an action's EFFECTIVE combos (platform alias
+ *  included). This is the one call site Chat/PromptInput should need. */
+export declare function actionMatches(action: ShortcutActionId, input: string, key: ComboKeyFlags): boolean;
+/**
+ * Parse user draft text for a settings field: one or more combos separated
+ * by commas/semicolons (spaces around separators tolerated). Empty/blank
+ * text means "restore the default" ({ combos: [] }); a malformed token makes
+ * the whole draft undefined (invalid — the settings screen blocks the save).
+ */
+export declare function parseComboDraft(text: string): {
+    combos: string[];
+} | undefined;
+/**
+ * Canonical combos the TUI binds but users canNOT remap — interrupt/exit,
+ * the readline-style editor keys, the newline variants, and the navigation
+ * keys plugins must never shadow. The customizable action combos (see
+ * {@link SHORTCUT_ACTIONS}) join this set dynamically wherever both are
+ * consulted. Entries the combo grammar itself refuses (bare escape, tab,
+ * shift+tab) stay listed verbatim for the lowercase fallback canonical.
+ */
+export declare const FIXED_RESERVED_COMBOS: readonly string[];
+/** The fixed reserved set in canonical form (shared with the adapter registry). */
+export declare function fixedReservedCombos(): ReadonlySet<string>;
+/** Whether a user-spelled combo hits a binding that no remap can free. */
+export declare function isFixedReserved(raw: string): boolean;
+/**
+ * Draft-time conflict check for the settings fields: a combo is unusable
+ * when it is fixed-reserved, or when some OTHER action currently binds it
+ * (its own action's defaults are fine to restate). Without this a remap
+ * like history → ctrl+v would silently shadow paste at match time.
+ */
+export declare function draftComboConflicts(action: ShortcutActionId, combos: readonly string[]): boolean;
+/**
+ * Canonical combos every customizable action currently binds (defaults ∪
+ * overrides) — the `dsh-adapter` plugin registry folds these into its
+ * reserved set so a plugin can never shadow a built-in, however the user
+ * remapped it.
+ */
+export declare function reservedActionCombos(): ReadonlySet<string>;
+//# sourceMappingURL=keymap.d.ts.map

package/lib/types/utils/keymap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keymap.d.ts","sourceRoot":"","sources":["../../../src/utils/keymap.ts"],"names":[],"mappings":"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"}

package/lib/types/utils/keymap.js

@@ -0,0 +1,311 @@
+/**
+ * Built-in keyboard-shortcut keymap: the shared combo grammar, the action
+ * registry, and the live override cache behind `/settings` customization.
+ *
+ * Split of concerns across the input stack:
+ * - `dsh-adapter/shortcuts.ts` owns the PLUGIN registry (`ctx.tuiShortcuts`)
+ *   and re-exports the grammar from here so both sides parse identically.
+ * - This module owns what the TUI itself binds: a fixed set of named actions
+ *   (paste, history, editor, …) whose combos resolve as
+ *   settings.yaml user layer > cordis.yml `shortcuts` > the registry default.
+ * `Chat.tsx` / `PromptInput.tsx` match keypresses against the EFFECTIVE
+ * combos via {@link actionMatches} — never against a hardcoded string.
+ *
+ * The macOS modifier alias mirrors `isMod`: a combo spelled with `ctrl`
+ * matches Cmd (`super`) on the mac too, so `ctrl+v` keeps meaning "paste
+ * with the platform primary modifier" everywhere. `alt` always means the
+ * ink `meta` flag. Shift must match exactly (ctrl+shift+v is the terminal's
+ * native paste, never the app's clipboard read).
+ */
+import { isMac } from './modifiers.js';
+const NAMED_KEYS = {
+    enter: 'return',
+    return: 'return',
+    esc: 'escape',
+    escape: 'escape',
+    tab: 'tab',
+    backspace: 'backspace',
+    delete: 'delete',
+    up: 'upArrow',
+    down: 'downArrow',
+    left: 'leftArrow',
+    right: 'rightArrow',
+    home: 'home',
+    end: 'end',
+    pageup: 'pageUp',
+    pagedown: 'pageDown',
+};
+/**
+ * Parse `ctrl+shift+p` style combos. Returns undefined on anything
+ * malformed or disallowed (no ctrl/alt modifier, unknown key name, escape
+ * combos — the same grammar the plugin shortcut registry enforces).
+ */
+export function parseCombo(raw) {
+    const parts = String(raw ?? '')
+        .toLowerCase()
+        .split('+')
+        .map(part => part.trim())
+        .filter(part => part !== '');
+    if (parts.length === 0)
+        return undefined;
+    let ctrl = false;
+    let meta = false;
+    let shift = false;
+    let named;
+    let char;
+    for (const part of parts) {
+        if (part === 'ctrl' || part === 'control') {
+            if (ctrl)
+                return undefined;
+            ctrl = true;
+        }
+        else if (part === 'alt' || part === 'meta' || part === 'option') {
+            if (meta)
+                return undefined;
+            meta = true;
+        }
+        else if (part === 'shift') {
+            if (shift)
+                return undefined;
+            shift = true;
+        }
+        else if (part === 'space') {
+            if (char !== undefined || named !== undefined)
+                return undefined;
+            char = ' ';
+        }
+        else if (part in NAMED_KEYS) {
+            if (char !== undefined || named !== undefined)
+                return undefined;
+            named = NAMED_KEYS[part];
+        }
+        else if ([...part].length === 1) {
+            if (char !== undefined || named !== undefined)
+                return undefined;
+            char = part;
+        }
+        else {
+            return undefined;
+        }
+    }
+    if (char === undefined && named === undefined)
+        return undefined;
+    // Bare keys are typing/navigation; a modifier is what makes a shortcut.
+    if (!ctrl && !meta)
+        return undefined;
+    // Escape is fully owned by the TUI (every Escape arrives with meta set on
+    // the input layer), so escape combos can never be unambiguous.
+    if (named === 'escape')
+        return undefined;
+    return { raw: parts.join('+'), ctrl, meta, shift, ...(named === undefined ? {} : { named }), ...(char === undefined ? {} : { char }) };
+}
+/** Canonical form for dedupe/reserved checks: modifiers sorted, key last. */
+export function canonicalCombo(combo) {
+    const mods = [combo.ctrl ? 'ctrl' : '', combo.meta ? 'alt' : '', combo.shift ? 'shift' : '']
+        .filter(part => part !== '')
+        .sort();
+    return [...mods, combo.named === undefined ? (combo.char ?? '') : String(combo.named)].join('+');
+}
+/** Canonicalize a user-spelled combo string (`ctrl+c`); unparseable input
+ *  comes back lowercased as-is so reserved sets can still carry entries the
+ *  grammar itself refuses (bare escape, tab…). */
+export function canonicalComboString(raw) {
+    const combo = parseCombo(raw);
+    return combo === undefined ? String(raw ?? '').toLowerCase() : canonicalCombo(combo);
+}
+/**
+ * Strict matcher (plugin registry semantics): every modifier flag must equal
+ * the combo's. `ctrl` means the ctrl flag only — no platform alias.
+ */
+export function comboMatchesStrict(combo, input, key) {
+    if (Boolean(key.ctrl) !== combo.ctrl)
+        return false;
+    if (Boolean(key.meta) !== combo.meta)
+        return false;
+    if (key.super)
+        return false;
+    if (Boolean(key.shift) !== combo.shift)
+        return false;
+    if (combo.named !== undefined) {
+        return key[combo.named] === true;
+    }
+    if (combo.char === undefined)
+        return false;
+    return input.toLowerCase() === combo.char;
+}
+/**
+ * Built-in matcher with the platform primary-modifier alias: `ctrl` combos
+ * also accept Cmd (`super`) on macOS (isMod semantics), `alt` maps to the
+ * ink `meta` flag. Shift stays exact — ctrl+shift+v must keep meaning the
+ * terminal's native paste, never the app's clipboard read.
+ */
+function comboMatchesBuiltin(combo, input, key) {
+    const primary = key.ctrl === true || (isMac && key.super === true);
+    if (combo.ctrl !== primary)
+        return false;
+    if (Boolean(key.meta) !== combo.meta)
+        return false;
+    if (Boolean(key.shift) !== combo.shift)
+        return false;
+    if (combo.named !== undefined) {
+        return key[combo.named] === true;
+    }
+    if (combo.char === undefined)
+        return false;
+    return input.toLowerCase() === combo.char;
+}
+/**
+ * The registry. Defaults encode today's hard-wired bindings — `paste` also
+ * carries the `alt+v` alias for terminals that intercept Ctrl+V before the
+ * app ever sees the byte (some terminals/IMEs reserve Ctrl+V for their own
+ * paste and never forward it in raw mode).
+ */
+export const SHORTCUT_ACTIONS = [
+    { id: 'paste', defaults: ['ctrl+v', 'alt+v'] },
+    { id: 'history', defaults: ['ctrl+r'] },
+    { id: 'editor', defaults: ['ctrl+g'] },
+    { id: 'transcript', defaults: ['ctrl+o'] },
+    { id: 'trajectory', defaults: ['ctrl+t'] },
+    { id: 'dashboard', defaults: ['ctrl+a'] },
+    { id: 'contextPanel', defaults: ['ctrl+p'] },
+    { id: 'showAll', defaults: ['ctrl+e'] },
+    { id: 'redraw', defaults: ['ctrl+l'] },
+    { id: 'todoFold', defaults: ['ctrl+q'] },
+];
+const DEFAULT_COMBO_MAP = new Map(SHORTCUT_ACTIONS.map(action => [action.id, action.defaults.map(parseCombo).filter((combo) => combo !== undefined)]));
+/** Live overrides (settings user layer + cordis.yml merged by plugin.ts). */
+let overrideMap = new Map();
+/**
+ * Replace the whole override map. Invalid or blank entries are DROPPED
+ * (the action keeps its default) — a typo in cordis.yml must never disable
+ * a built-in, and the settings field's parse already refuses invalid
+ * drafts before anything is written.
+ */
+export function setKeymapOverrides(overrides) {
+    const next = new Map();
+    for (const action of SHORTCUT_ACTIONS) {
+        const raw = overrides[action.id];
+        if (raw === undefined)
+            continue;
+        const list = (Array.isArray(raw) ? raw : [raw])
+            .flatMap(entry => String(entry).split(/[,;]/))
+            .map(entry => entry.trim())
+            .filter(entry => entry !== '');
+        const parsed = list.map(parseCombo).filter((combo) => combo !== undefined);
+        if (parsed.length === 0)
+            continue;
+        next.set(action.id, parsed);
+    }
+    overrideMap = next;
+}
+/** Test seam: drop every override. */
+export function resetKeymapOverrides() {
+    overrideMap = new Map();
+}
+/** Effective combos for one action (overrides win over defaults). */
+export function effectiveCombos(action) {
+    return overrideMap.get(action) ?? DEFAULT_COMBO_MAP.get(action) ?? [];
+}
+/** Effective combos as display strings (`ctrl+v, alt+v`). */
+export function effectiveComboString(action) {
+    return effectiveCombos(action).map(combo => combo.raw).join(', ');
+}
+/** Match a keypress against an action's EFFECTIVE combos (platform alias
+ *  included). This is the one call site Chat/PromptInput should need. */
+export function actionMatches(action, input, key) {
+    const combos = effectiveCombos(action);
+    for (let index = 0; index < combos.length; index += 1) {
+        if (comboMatchesBuiltin(combos[index], input, key))
+            return true;
+    }
+    return false;
+}
+/**
+ * Parse user draft text for a settings field: one or more combos separated
+ * by commas/semicolons (spaces around separators tolerated). Empty/blank
+ * text means "restore the default" ({ combos: [] }); a malformed token makes
+ * the whole draft undefined (invalid — the settings screen blocks the save).
+ */
+export function parseComboDraft(text) {
+    const trimmed = String(text ?? '').trim();
+    if (trimmed === '')
+        return { combos: [] };
+    const tokens = trimmed
+        .split(/[,;]/)
+        .map(token => token.trim())
+        .filter(token => token !== '');
+    if (tokens.length === 0)
+        return { combos: [] };
+    const combos = [];
+    for (const token of tokens) {
+        if (parseCombo(token) === undefined)
+            return undefined;
+        combos.push(token.toLowerCase());
+    }
+    return { combos };
+}
+/**
+ * Canonical combos the TUI binds but users canNOT remap — interrupt/exit,
+ * the readline-style editor keys, the newline variants, and the navigation
+ * keys plugins must never shadow. The customizable action combos (see
+ * {@link SHORTCUT_ACTIONS}) join this set dynamically wherever both are
+ * consulted. Entries the combo grammar itself refuses (bare escape, tab,
+ * shift+tab) stay listed verbatim for the lowercase fallback canonical.
+ */
+export const FIXED_RESERVED_COMBOS = [
+    'ctrl+c', // interrupt / clear
+    'ctrl+d', // exit on empty input
+    'ctrl+e', // editor line end (also the showAll action's default)
+    'ctrl+a', // editor line start (also the dashboard action's default)
+    'ctrl+u', // kill line
+    'ctrl+k', // kill to end
+    'ctrl+w', // kill word
+    'ctrl+left', // word jump
+    'ctrl+right', // word jump
+    'ctrl+return', // newline (multi-line input)
+    'ctrl+shift+return', // shift+Enter newline (CSI 13;6u) — same editor binding
+    'alt+return', // newline fallback on terminals without shift reporting
+    'alt+up', // pull the last pending message back for editing
+    'escape', // pickers / interrupt / rewind double-tap
+    'tab', // command completion
+    'shift+tab', // session-mode cycle
+];
+const FIXED_RESERVED_CANONICAL = new Set(FIXED_RESERVED_COMBOS.map(canonicalComboString));
+/** The fixed reserved set in canonical form (shared with the adapter registry). */
+export function fixedReservedCombos() {
+    return FIXED_RESERVED_CANONICAL;
+}
+/** Whether a user-spelled combo hits a binding that no remap can free. */
+export function isFixedReserved(raw) {
+    return FIXED_RESERVED_CANONICAL.has(canonicalComboString(raw));
+}
+/**
+ * Draft-time conflict check for the settings fields: a combo is unusable
+ * when it is fixed-reserved, or when some OTHER action currently binds it
+ * (its own action's defaults are fine to restate). Without this a remap
+ * like history → ctrl+v would silently shadow paste at match time.
+ */
+export function draftComboConflicts(action, combos) {
+    const others = new Set();
+    for (const spec of SHORTCUT_ACTIONS) {
+        if (spec.id === action)
+            continue;
+        for (const combo of effectiveCombos(spec.id))
+            others.add(canonicalCombo(combo));
+    }
+    return combos.some(combo => isFixedReserved(combo) || others.has(canonicalComboString(combo)));
+}
+/**
+ * Canonical combos every customizable action currently binds (defaults ∪
+ * overrides) — the `dsh-adapter` plugin registry folds these into its
+ * reserved set so a plugin can never shadow a built-in, however the user
+ * remapped it.
+ */
+export function reservedActionCombos() {
+    const reserved = new Set();
+    for (const action of SHORTCUT_ACTIONS) {
+        for (const combo of effectiveCombos(action.id))
+            reserved.add(canonicalCombo(combo));
+    }
+    return reserved;
+}