@timurproko/a1 0.1.8-dev.49ff83a → 0.1.8-dev.508

package/dist/integrations/pi/components/tool-image-presentation.js

@@ -0,0 +1,83 @@
+import { convertToPng } from "../startup-public.js";
+import { getCapabilities, Image, Text } from "@earendil-works/pi-tui";
+import { piTheme } from "./theme.js";
+const MAX_BYTES = 20 * 1024 * 1024;
+const MAX_IMAGES = 16;
+const bytes = (data) => Math.floor(data.length * 3 / 4) - (data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0);
+/**
+ * Own only current attachment presentation; tool renderers still receive original result content.
+ * Unlike pinned 0.84.2's index cache, entries follow immutable source bytes and stale completions
+ * cannot republish. At most one conversion runs per mount; queued work is only the current set.
+ */
+export class ToolImagePresentation {
+    #entries = [];
+    #visible = false;
+    #disposed = false;
+    #active = false;
+    changed;
+    convert;
+    constructor(changed, convert = convertToPng) { this.changed = changed; this.convert = convert; }
+    update(content, show) {
+        if (this.#disposed)
+            return;
+        const previous = this.#entries;
+        const next = [];
+        for (const part of content) {
+            if (part.type !== "image" || !part.data || !part.mimeType)
+                continue;
+            const source = { data: part.data, mimeType: part.mimeType };
+            const same = (entry) => entry.source.data === source.data && entry.source.mimeType === source.mimeType;
+            next.push(next.find(same) ?? previous.find(same) ?? { source, state: "waiting" });
+            if (next.length === MAX_IMAGES)
+                break;
+        }
+        this.#entries = next;
+        this.#visible = show && getCapabilities().images !== null;
+        this.#pump();
+    }
+    /** Public Image remains responsible for Kitty/iTerm protocol and dimension-aware fallback. */
+    components(width) {
+        if (this.#disposed || !this.#visible)
+            return [];
+        return this.#entries.map(entry => {
+            const source = entry.source;
+            if (getCapabilities().images === "kitty" && source.mimeType !== "image/png") {
+                if (entry.converted === undefined)
+                    return new Text(piTheme().fg("muted", entry.state === "unavailable" ? `[Image unavailable: ${source.mimeType}]` : `[Image converting: ${source.mimeType}]`), 1, 0);
+            }
+            const image = getCapabilities().images === "kitty" ? entry.converted ?? source : source;
+            return new Image(image.data, image.mimeType, { fallbackColor: text => piTheme().fg("toolOutput", text) }, { maxWidthCells: width });
+        });
+    }
+    dispose() {
+        this.#disposed = true;
+        this.#entries = [];
+    }
+    #pump() {
+        if (this.#disposed || this.#active || !this.#visible || getCapabilities().images !== "kitty")
+            return;
+        const entry = this.#entries.find(value => value.source.mimeType !== "image/png" && value.state === "waiting");
+        if (entry === undefined)
+            return;
+        entry.state = "converting";
+        this.#active = true;
+        // Concurrency: defer codec entry until the caller's synchronous component mutation finishes.
+        void Promise.resolve().then(() => this.#disposed || !this.#entries.includes(entry)
+            ? null : this.convert(entry.source.data, entry.source.mimeType)).catch(() => null).then(converted => {
+            this.#active = false;
+            if (this.#disposed)
+                return;
+            if (this.#entries.includes(entry)) {
+                // Invariant: limits match the existing 16 references / 20 MiB per image, not a new aggregate cap.
+                if (converted !== null && converted.mimeType === "image/png" && bytes(converted.data) <= MAX_BYTES) {
+                    entry.converted = converted;
+                    entry.state = "ready";
+                }
+                else
+                    entry.state = "unavailable";
+                this.changed();
+            }
+            this.#pump();
+        });
+    }
+}

package/dist/integrations/pi/components/tool-result-adapter.d.ts

@@ -0,0 +1,6 @@
+import type { ToolExecutionComponent } from "./upstream/components/tool-execution.js";
+import type { OwnedUiTranscriptBlock } from "../../../contracts/owned-ui/index.js";
+import { type PiShellImageAssetResolver } from "./shell-shared-facade.js";
+/** Reconstruct public Pi inputs once at the component boundary, never from diagnostic summaries. */
+export declare function updatePiToolResult(component: Pick<ToolExecutionComponent, "updateResult">, block: OwnedUiTranscriptBlock, assets?: PiShellImageAssetResolver): void;
+export declare function piToolArguments(block: OwnedUiTranscriptBlock): unknown;

package/dist/integrations/pi/components/tool-result-adapter.js

@@ -0,0 +1,27 @@
+import { isRecord } from "./shell-shared-facade.js";
+/** Reconstruct public Pi inputs once at the component boundary, never from diagnostic summaries. */
+export function updatePiToolResult(component, block, assets) {
+    const payload = isRecord(block.payload) ? block.payload : {};
+    if (block.kind !== "tool-result" && payload.partialResult !== true)
+        return;
+    const image = (index) => {
+        const reference = block.imageReferences?.[index];
+        const asset = reference === undefined ? null : assets?.resolve(reference.assetId);
+        return asset == null
+            ? { type: "text", text: `[Image unavailable: ${reference?.mimeType ?? "unknown"}]` }
+            : { type: "image", data: asset.data, mimeType: asset.mimeType };
+    };
+    const result = block.toolRendering?.result;
+    const content = result === undefined
+        ? [{ type: "text", text: block.text }, ...(block.imageReferences ?? []).map((_, index) => image(index))]
+        : result.content.map(part => part.type === "text"
+            ? { type: "text", text: block.text.slice(part.start, part.end) } : image(part.imageIndex));
+    component.updateResult({ content, details: result?.details, isError: payload.isError === true }, block.status === "live");
+}
+export function piToolArguments(block) {
+    if (block.toolRendering !== undefined)
+        return block.toolRendering.arguments;
+    // Compatibility: existing owned blocks and component consumers may lack rendering metadata.
+    const payload = isRecord(block.payload) ? block.payload : {};
+    return isRecord(payload.arguments) && "json" in payload.arguments ? payload.arguments.json : payload.arguments ?? {};
+}

package/dist/integrations/pi/components/transcript-image-resolver.d.ts

@@ -0,0 +1,7 @@
+import type { OwnedUiImageAttachment, OwnedUiTranscriptBlock } from "../../../contracts/owned-ui/index.js";
+import type { PiShellImageAssetResolver } from "./shell-shared-facade.js";
+export declare function createTranscriptImageResolver(source: PiShellImageAssetResolver | undefined, initial: OwnedUiTranscriptBlock): {
+    resolve: (id: string) => OwnedUiImageAttachment | null;
+    update: (block: OwnedUiTranscriptBlock) => void;
+    dispose: () => void;
+};

package/dist/integrations/pi/components/transcript-image-resolver.js

@@ -0,0 +1,19 @@
+// Concurrency: a mounted block can outlive its engine revision while delivery is pending; retain its immutable assets through rebuilds.
+export function createTranscriptImageResolver(source, initial) {
+    let images = new Map();
+    const update = (block) => {
+        const next = new Map();
+        for (const reference of block.imageReferences ?? []) {
+            const asset = source?.resolve(reference.assetId) ?? images.get(reference.assetId);
+            if (asset != null)
+                next.set(reference.assetId, asset);
+        }
+        images = next;
+    };
+    update(initial);
+    return {
+        resolve: (id) => images.get(id) ?? null,
+        update,
+        dispose: () => images.clear(),
+    };
+}

package/dist/integrations/pi/components/upstream/adjacent/core/keybindings.d.ts

@@ -0,0 +1,445 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.85.1 (MIT), commit d981de1229ef899957bbe968bc8dcda02a21f477,
+ * packages/coding-agent/src/core/keybindings.ts.
+ * Modifications: Mechanical source port with Node import prefixes, public package-root agent-directory
+ * resolution, and an opt-in bare-A1 input profile including Ctrl+L level cycling and unbound model
+ * selection.
+ * Deviations: keybindings-public-config-boundary, owned-level-cycle-shortcut,
+ * owned-input-keybinding-aliases.
+ */
+import { type Keybinding, type KeybindingDefinitions, type KeybindingsConfig, type KeyId, KeybindingsManager as TuiKeybindingsManager } from "@earendil-works/pi-tui";
+export interface AppKeybindings {
+    "app.interrupt": true;
+    "app.clear": true;
+    "app.exit": true;
+    "app.suspend": true;
+    "app.thinking.cycle": true;
+    "app.thinking.save": true;
+    "app.model.cycleForward": true;
+    "app.model.cycleBackward": true;
+    "app.model.select": true;
+    "app.tools.expand": true;
+    "app.thinking.toggle": true;
+    "app.session.toggleNamedFilter": true;
+    "app.editor.external": true;
+    "app.message.copy": true;
+    "app.message.followUp": true;
+    "app.message.dequeue": true;
+    "app.clipboard.pasteImage": true;
+    "app.session.new": true;
+    "app.session.tree": true;
+    "app.session.fork": true;
+    "app.session.resume": true;
+    "app.tree.foldOrUp": true;
+    "app.tree.unfoldOrDown": true;
+    "app.tree.editLabel": true;
+    "app.tree.toggleLabelTimestamp": true;
+    "app.session.togglePath": true;
+    "app.session.toggleSort": true;
+    "app.session.rename": true;
+    "app.session.delete": true;
+    "app.session.deleteNoninvasive": true;
+    "app.models.save": true;
+    "app.models.enableAll": true;
+    "app.models.clearAll": true;
+    "app.models.toggleProvider": true;
+    "app.models.reorderUp": true;
+    "app.models.reorderDown": true;
+    "app.tree.filter.default": true;
+    "app.tree.filter.noTools": true;
+    "app.tree.filter.userOnly": true;
+    "app.tree.filter.labeledOnly": true;
+    "app.tree.filter.all": true;
+    "app.tree.filter.cycleForward": true;
+    "app.tree.filter.cycleBackward": true;
+    "owned.editor.selectAll": true;
+    "owned.editor.cut": true;
+    "owned.editor.paste": true;
+    "owned.editor.redo": true;
+    "owned.editor.extendLeft": true;
+    "owned.editor.extendRight": true;
+}
+export type AppKeybinding = keyof AppKeybindings;
+export declare function useWindowsKeybindings(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): boolean;
+declare module "@earendil-works/pi-tui" {
+    interface Keybindings extends AppKeybindings {
+    }
+}
+export declare const KEYBINDINGS: {
+    readonly "tui.editor.undo": {
+        readonly defaultKeys: "ctrl+z" | "alt+z" | "ctrl+-";
+        readonly description: "Undo";
+    };
+    readonly "tui.altScreen.previousPrompt": {
+        readonly defaultKeys: "ctrl+up" | ("ctrl+up" | "ctrl+shift+up")[];
+        readonly description: "Jump to previous semantic prompt";
+    };
+    readonly "tui.altScreen.nextPrompt": {
+        readonly defaultKeys: "ctrl+down" | ("ctrl+down" | "ctrl+shift+down")[];
+        readonly description: "Jump to next semantic prompt";
+    };
+    readonly "tui.altScreen.search": {
+        readonly defaultKeys: "ctrl+f" | "ctrl+shift+f";
+        readonly description: "Search the primary scroll view";
+    };
+    readonly "app.interrupt": {
+        readonly defaultKeys: "escape";
+        readonly description: "Cancel or abort";
+    };
+    readonly "app.clear": {
+        readonly defaultKeys: "ctrl+c";
+        readonly description: "Clear editor";
+    };
+    readonly "app.exit": {
+        readonly defaultKeys: "ctrl+d";
+        readonly description: "Exit when editor is empty";
+    };
+    readonly "app.suspend": {
+        readonly defaultKeys: never[] | "ctrl+z";
+        readonly description: "Suspend to background";
+    };
+    readonly "app.thinking.cycle": {
+        readonly defaultKeys: "shift+tab";
+        readonly description: "Cycle thinking level";
+    };
+    readonly "app.thinking.save": {
+        readonly defaultKeys: "ctrl+s";
+        readonly description: "Save thinking level";
+    };
+    readonly "app.model.cycleForward": {
+        readonly defaultKeys: "ctrl+p";
+        readonly description: "Cycle to next model";
+    };
+    readonly "app.model.cycleBackward": {
+        readonly defaultKeys: "alt+p" | "shift+ctrl+p";
+        readonly description: "Cycle to previous model";
+    };
+    readonly "app.model.select": {
+        readonly defaultKeys: "ctrl+l";
+        readonly description: "Open model selector";
+    };
+    readonly "app.tools.expand": {
+        readonly defaultKeys: "ctrl+o";
+        readonly description: "Toggle tool output";
+    };
+    readonly "app.thinking.toggle": {
+        readonly defaultKeys: "ctrl+t";
+        readonly description: "Toggle thinking blocks";
+    };
+    readonly "app.session.toggleNamedFilter": {
+        readonly defaultKeys: "ctrl+n";
+        readonly description: "Toggle named session filter";
+    };
+    readonly "app.editor.external": {
+        readonly defaultKeys: "ctrl+g";
+        readonly description: "Open external editor";
+    };
+    readonly "app.message.copy": {
+        readonly defaultKeys: "ctrl+x";
+        readonly description: "Copy message to clipboard";
+    };
+    readonly "app.message.followUp": {
+        readonly defaultKeys: "ctrl+q" | "alt+enter";
+        readonly description: "Queue follow-up message";
+    };
+    readonly "app.message.dequeue": {
+        readonly defaultKeys: "alt+q" | "alt+up";
+        readonly description: "Restore queued messages";
+    };
+    readonly "app.clipboard.pasteImage": {
+        readonly defaultKeys: "ctrl+v" | "alt+v";
+        readonly description: "Paste image from clipboard (text fallback)";
+    };
+    readonly "app.session.new": {
+        readonly defaultKeys: [];
+        readonly description: "Start a new session";
+    };
+    readonly "app.session.tree": {
+        readonly defaultKeys: [];
+        readonly description: "Open session tree";
+    };
+    readonly "app.session.fork": {
+        readonly defaultKeys: [];
+        readonly description: "Fork current session";
+    };
+    readonly "app.session.resume": {
+        readonly defaultKeys: [];
+        readonly description: "Resume a session";
+    };
+    readonly "app.tree.foldOrUp": {
+        readonly defaultKeys: ("ctrl+left" | "alt+left")[];
+        readonly description: "Fold tree branch or move up";
+    };
+    readonly "app.tree.unfoldOrDown": {
+        readonly defaultKeys: ("ctrl+right" | "alt+right")[];
+        readonly description: "Unfold tree branch or move down";
+    };
+    readonly "app.tree.editLabel": {
+        readonly defaultKeys: "shift+l";
+        readonly description: "Edit tree label";
+    };
+    readonly "app.tree.toggleLabelTimestamp": {
+        readonly defaultKeys: "shift+t";
+        readonly description: "Toggle tree label timestamps";
+    };
+    readonly "app.session.togglePath": {
+        readonly defaultKeys: "ctrl+p";
+        readonly description: "Toggle session path display";
+    };
+    readonly "app.session.toggleSort": {
+        readonly defaultKeys: "ctrl+s";
+        readonly description: "Toggle session sort mode";
+    };
+    readonly "app.session.rename": {
+        readonly defaultKeys: "ctrl+r";
+        readonly description: "Rename session";
+    };
+    readonly "app.session.delete": {
+        readonly defaultKeys: "ctrl+d";
+        readonly description: "Delete session";
+    };
+    readonly "app.session.deleteNoninvasive": {
+        readonly defaultKeys: "ctrl+backspace";
+        readonly description: "Delete session when query is empty";
+    };
+    readonly "app.models.save": {
+        readonly defaultKeys: "ctrl+s";
+        readonly description: "Save model selection";
+    };
+    readonly "app.models.enableAll": {
+        readonly defaultKeys: "ctrl+a";
+        readonly description: "Enable all models";
+    };
+    readonly "app.models.clearAll": {
+        readonly defaultKeys: "ctrl+x";
+        readonly description: "Clear all models";
+    };
+    readonly "app.models.toggleProvider": {
+        readonly defaultKeys: "ctrl+p";
+        readonly description: "Toggle all models for provider";
+    };
+    readonly "app.models.reorderUp": {
+        readonly defaultKeys: "alt+up";
+        readonly description: "Move model up in order";
+    };
+    readonly "app.models.reorderDown": {
+        readonly defaultKeys: "alt+down";
+        readonly description: "Move model down in order";
+    };
+    readonly "app.tree.filter.default": {
+        readonly defaultKeys: "ctrl+d";
+        readonly description: "Tree filter: default view";
+    };
+    readonly "app.tree.filter.noTools": {
+        readonly defaultKeys: "ctrl+t";
+        readonly description: "Tree filter: hide tool results";
+    };
+    readonly "app.tree.filter.userOnly": {
+        readonly defaultKeys: "ctrl+u";
+        readonly description: "Tree filter: user messages only";
+    };
+    readonly "app.tree.filter.labeledOnly": {
+        readonly defaultKeys: "ctrl+l";
+        readonly description: "Tree filter: labeled entries only";
+    };
+    readonly "app.tree.filter.all": {
+        readonly defaultKeys: "ctrl+a";
+        readonly description: "Tree filter: show all entries";
+    };
+    readonly "app.tree.filter.cycleForward": {
+        readonly defaultKeys: "ctrl+o";
+        readonly description: "Tree filter: cycle forward";
+    };
+    readonly "app.tree.filter.cycleBackward": {
+        readonly defaultKeys: "shift+ctrl+o";
+        readonly description: "Tree filter: cycle backward";
+    };
+    readonly "tui.editor.cursorUp": {
+        readonly defaultKeys: "up";
+        readonly description: "Move cursor up";
+    };
+    readonly "tui.editor.cursorDown": {
+        readonly defaultKeys: "down";
+        readonly description: "Move cursor down";
+    };
+    readonly "tui.editor.historyPrevious": {
+        readonly defaultKeys: [];
+        readonly description: "Select previous prompt history entry";
+    };
+    readonly "tui.editor.historyNext": {
+        readonly defaultKeys: [];
+        readonly description: "Select next prompt history entry";
+    };
+    readonly "tui.editor.cursorLeft": {
+        readonly defaultKeys: ["left", "ctrl+b"];
+        readonly description: "Move cursor left";
+    };
+    readonly "tui.editor.cursorRight": {
+        readonly defaultKeys: ["right", "ctrl+f"];
+        readonly description: "Move cursor right";
+    };
+    readonly "tui.editor.cursorWordLeft": {
+        readonly defaultKeys: ["alt+left", "ctrl+left", "alt+b"];
+        readonly description: "Move cursor word left";
+    };
+    readonly "tui.editor.cursorWordRight": {
+        readonly defaultKeys: ["alt+right", "ctrl+right", "alt+f"];
+        readonly description: "Move cursor word right";
+    };
+    readonly "tui.editor.cursorLineStart": {
+        readonly defaultKeys: ["home", "ctrl+home", "ctrl+a"];
+        readonly description: "Move to line start";
+    };
+    readonly "tui.editor.cursorLineEnd": {
+        readonly defaultKeys: ["end", "ctrl+end", "ctrl+e"];
+        readonly description: "Move to line end";
+    };
+    readonly "tui.editor.jumpForward": {
+        readonly defaultKeys: "ctrl+]";
+        readonly description: "Jump forward to character";
+    };
+    readonly "tui.editor.jumpBackward": {
+        readonly defaultKeys: "ctrl+alt+]";
+        readonly description: "Jump backward to character";
+    };
+    readonly "tui.editor.pageUp": {
+        readonly defaultKeys: ["pageUp", "ctrl+pageUp"];
+        readonly description: "Page up";
+    };
+    readonly "tui.editor.pageDown": {
+        readonly defaultKeys: ["pageDown", "ctrl+pageDown"];
+        readonly description: "Page down";
+    };
+    readonly "tui.editor.deleteCharBackward": {
+        readonly defaultKeys: "backspace";
+        readonly description: "Delete character backward";
+    };
+    readonly "tui.editor.deleteCharForward": {
+        readonly defaultKeys: ["delete", "ctrl+d"];
+        readonly description: "Delete character forward";
+    };
+    readonly "tui.editor.deleteWordBackward": {
+        readonly defaultKeys: ["ctrl+w", "alt+backspace"];
+        readonly description: "Delete word backward";
+    };
+    readonly "tui.editor.deleteWordForward": {
+        readonly defaultKeys: ["alt+d", "alt+delete"];
+        readonly description: "Delete word forward";
+    };
+    readonly "tui.editor.deleteToLineStart": {
+        readonly defaultKeys: "ctrl+u";
+        readonly description: "Delete to line start";
+    };
+    readonly "tui.editor.deleteToLineEnd": {
+        readonly defaultKeys: "ctrl+k";
+        readonly description: "Delete to line end";
+    };
+    readonly "tui.editor.yank": {
+        readonly defaultKeys: "ctrl+y";
+        readonly description: "Yank";
+    };
+    readonly "tui.editor.yankPop": {
+        readonly defaultKeys: "alt+y";
+        readonly description: "Yank pop";
+    };
+    readonly "tui.input.newLine": {
+        readonly defaultKeys: ["shift+enter", "ctrl+j"];
+        readonly description: "Insert newline";
+    };
+    readonly "tui.input.submit": {
+        readonly defaultKeys: "enter";
+        readonly description: "Submit input";
+    };
+    readonly "tui.input.tab": {
+        readonly defaultKeys: "tab";
+        readonly description: "Tab / autocomplete";
+    };
+    readonly "tui.input.copy": {
+        readonly defaultKeys: "ctrl+c";
+        readonly description: "Copy selection";
+    };
+    readonly "tui.select.up": {
+        readonly defaultKeys: "up";
+        readonly description: "Move selection up";
+    };
+    readonly "tui.select.down": {
+        readonly defaultKeys: "down";
+        readonly description: "Move selection down";
+    };
+    readonly "tui.select.pageUp": {
+        readonly defaultKeys: "pageUp";
+        readonly description: "Selection page up";
+    };
+    readonly "tui.select.pageDown": {
+        readonly defaultKeys: "pageDown";
+        readonly description: "Selection page down";
+    };
+    readonly "tui.select.confirm": {
+        readonly defaultKeys: "enter";
+        readonly description: "Confirm selection";
+    };
+    readonly "tui.select.cancel": {
+        readonly defaultKeys: ["escape", "ctrl+c"];
+        readonly description: "Cancel selection";
+    };
+    readonly "tui.altScreen.pageUp": {
+        readonly defaultKeys: "pageUp";
+        readonly description: "Scroll viewport up one page";
+    };
+    readonly "tui.altScreen.pageDown": {
+        readonly defaultKeys: "pageDown";
+        readonly description: "Scroll viewport down one page";
+    };
+    readonly "tui.altScreen.halfPageUp": {
+        readonly defaultKeys: [];
+        readonly description: "Scroll viewport up half a page";
+    };
+    readonly "tui.altScreen.halfPageDown": {
+        readonly defaultKeys: [];
+        readonly description: "Scroll viewport down half a page";
+    };
+    readonly "tui.altScreen.lineUp": {
+        readonly defaultKeys: [];
+        readonly description: "Scroll viewport up one line";
+    };
+    readonly "tui.altScreen.lineDown": {
+        readonly defaultKeys: [];
+        readonly description: "Scroll viewport down one line";
+    };
+    readonly "tui.altScreen.searchNext": {
+        readonly defaultKeys: ["enter", "ctrl+g"];
+        readonly description: "Select the next search match";
+    };
+    readonly "tui.altScreen.searchPrevious": {
+        readonly defaultKeys: ["shift+enter", "ctrl+shift+g"];
+        readonly description: "Select the previous search match";
+    };
+    readonly "tui.altScreen.searchClose": {
+        readonly defaultKeys: "escape";
+        readonly description: "Close transcript search";
+    };
+    readonly "tui.altScreen.top": {
+        readonly defaultKeys: "home";
+        readonly description: "Scroll viewport to top";
+    };
+    readonly "tui.altScreen.bottom": {
+        readonly defaultKeys: "end";
+        readonly description: "Scroll viewport to bottom";
+    };
+};
+export declare function migrateKeybindingsConfig(rawConfig: Record<string, unknown>): {
+    config: Record<string, unknown>;
+    migrated: boolean;
+};
+export declare class KeybindingsManager extends TuiKeybindingsManager {
+    private configPath;
+    constructor(userBindings?: KeybindingsConfig, configPath?: string, definitions?: KeybindingDefinitions);
+    static create(agentDir?: string): KeybindingsManager;
+    static fromOwnedBindings(bindings?: KeybindingsConfig): KeybindingsManager;
+    static createForOwnedInput(agentDir?: string): KeybindingsManager;
+    private static createWithDefinitions;
+    reload(): void;
+    getEffectiveConfig(): KeybindingsConfig;
+    private static loadFromFile;
+}
+export type { Keybinding, KeyId, KeybindingsConfig };