@sayknow-cli/coding-agent 0.4.1 → 0.4.3

package/dist/types/config/config-file.d.ts

@@ -0,0 +1,58 @@
+import type { ZodType } from "zod/v4";
+/** Minimal subset of the AJV ConfigSchemaError shape this module actually relies on. */
+interface ConfigSchemaError {
+    instancePath: string;
+    message: string | undefined;
+}
+export interface IConfigFile<T> {
+    readonly id: string;
+    readonly schema: ZodType<T>;
+    path?(): string;
+    load(): T | null;
+    invalidate?(): void;
+}
+export declare class ConfigError extends Error {
+    #private;
+    readonly id: string;
+    readonly schemaErrors: ConfigSchemaError[] | null | undefined;
+    readonly other?: {
+        err: unknown;
+        stage: string;
+    } | undefined;
+    constructor(id: string, schemaErrors: ConfigSchemaError[] | null | undefined, other?: {
+        err: unknown;
+        stage: string;
+    } | undefined);
+    get message(): string;
+    toString(): string;
+}
+export type LoadStatus = "ok" | "error" | "not-found";
+export type LoadResult<T> = {
+    value?: null;
+    error: ConfigError;
+    status: "error";
+} | {
+    value: T;
+    error?: undefined;
+    status: "ok";
+} | {
+    value?: null;
+    error?: unknown;
+    status: "not-found";
+};
+export declare class ConfigFile<T> implements IConfigFile<T> {
+    #private;
+    readonly id: string;
+    readonly schema: ZodType<T>;
+    constructor(id: string, schema: ZodType<T>, configPath?: string);
+    relocate(configPath?: string): ConfigFile<T>;
+    getMtimeMs(): number | null;
+    withValidation(name: string, validate: (value: T) => void): this;
+    createDefault(): T;
+    tryLoad(): LoadResult<T>;
+    load(): T | null;
+    loadOrDefault(): T;
+    path(): string;
+    invalidate(): void;
+}
+export {};

package/dist/types/config/file-lock-gc.d.ts

@@ -0,0 +1,5 @@
+/**
+ * GC adapter for config file-locks (`<file>.lock` dirs holding `{pid, timestamp}`).
+ */
+import type { GcStoreAdapter } from "../skc-runtime/gc-runtime";
+export declare const fileLocksGcAdapter: GcStoreAdapter;

package/dist/types/config/file-lock.d.ts

@@ -0,0 +1,46 @@
+export interface FileLockOptions {
+    staleMs?: number;
+    retries?: number;
+    retryDelayMs?: number;
+}
+/**
+ * Returns the OS-provided process start timestamp for PID-reuse detection.
+ * `ps` is available on the supported Unix hosts (macOS and Linux), unlike
+ * Linux's `/proc/<pid>/stat` pseudo-file.
+ */
+export declare function processStartTime(pid: number): string | null;
+/** @internal */
+export declare function readFileLockInfoForGc(lockDir: string): Promise<FileLockOwnerToken | null>;
+/** Owner identity stamped into a `<file>.lock/info` record. */
+export interface FileLockOwnerToken {
+    pid: number;
+    start_time?: string;
+    timestamp: number;
+}
+/** Outcome of a guarded lock-dir removal attempt (`removeFileLockDirForGc`). */
+export type FileLockGcRemoval = "removed" | "owner_changed" | "missing";
+/**
+ * @internal
+ * Fail-closed removal of a lock dir whose owner is expected to be dead or
+ * finished. Re-reads the on-disk owner token as close to the unlink as possible
+ * and only deletes the dir when it STILL holds the exact `{pid, timestamp}`
+ * identity the caller observed.
+ *
+ * Closes stale-cleanup TOCTOU windows (#606): between a dead/stale re-read and
+ * the unlink, a live process can reclaim a stale lock at the same path
+ * (`acquireLock` rms the stale dir, then re-`mkdir`s and rewrites `info` with a
+ * fresh pid+timestamp). Deleting by path alone would reap that LIVE lock. Any
+ * mismatch (`owner_changed`) or absent/unreadable info (`missing` — e.g. a
+ * fresh acquirer between `mkdir` and `writeLockInfo`) refuses the delete and
+ * leaves the dir intact. POSIX has no atomic compare-and-delete for a
+ * directory, so the residual read->unlink window cannot be fully eliminated,
+ * but the reclaim-after-stale scenario the issue describes is now guarded.
+ */
+export declare function removeFileLockDirForGc(lockDir: string, expected: FileLockOwnerToken): Promise<FileLockGcRemoval>;
+/**
+ * Serializes all contenders, including callers in the same process. Because this
+ * API exposes no ownership token, recursive acquisition is indistinguishable
+ * from independent async contention; code that already holds the lock must pass
+ * that fact through its own `lockHeld` path instead of acquiring it again.
+ */
+export declare function withFileLock<T>(filePath: string, fn: () => Promise<T>, options?: FileLockOptions): Promise<T>;

package/dist/types/config/keybindings.d.ts

@@ -0,0 +1,405 @@
+import { type Keybinding, type KeybindingsConfig, type KeyId, KeybindingsManager as TuiKeybindingsManager } from "@sayknow-cli/tui";
+/**
+ * Application-level keybindings (coding agent specific).
+ * Values are always `true` — used for declaration merging.
+ */
+interface AppKeybindings {
+    "app.interrupt": true;
+    "app.clear": true;
+    "app.exit": true;
+    "app.suspend": true;
+    "app.thinking.cycle": true;
+    "app.thinking.toggle": true;
+    "app.commandPalette.open": true;
+    "app.model.cycleForward": true;
+    "app.model.cycleBackward": true;
+    "app.model.select": true;
+    "app.model.selectTemporary": true;
+    "app.tools.expand": true;
+    "app.tool.backgroundFold": true;
+    "app.editor.external": true;
+    "app.message.followUp": true;
+    "app.message.queue": true;
+    "app.message.dequeue": true;
+    "app.clipboard.pasteImage": true;
+    "app.clipboard.copyLine": true;
+    "app.clipboard.copyPrompt": true;
+    "app.session.new": true;
+    "app.session.tree": true;
+    "app.session.fork": true;
+    "app.session.resume": true;
+    "app.session.observe": true;
+    "app.session.dashboard": true;
+    "app.jobs.open": true;
+    "app.session.togglePath": true;
+    "app.session.toggleSort": true;
+    "app.session.rename": true;
+    "app.session.delete": true;
+    "app.session.deleteNoninvasive": true;
+    "app.tree.foldOrUp": true;
+    "app.tree.unfoldOrDown": true;
+    "app.plan.toggle": true;
+    "app.history.search": true;
+    "app.stt.toggle": true;
+    "app.irc.sidebar.toggle": true;
+    "app.transcript.browse": true;
+    "app.transcript.prevTurn": true;
+    "app.transcript.nextTurn": true;
+    "app.mode.cycle": true;
+    "app.tasks.toggle": true;
+    "app.queue.togglePane": true;
+    "app.message.sendNow": true;
+}
+export type AppKeybinding = keyof AppKeybindings;
+declare module "@sayknow-cli/tui" {
+    interface Keybindings extends AppKeybindings {
+    }
+}
+export declare function defaultMessageQueueKeysForPlatform(platform?: NodeJS.Platform): KeyId;
+export declare function defaultClipboardPasteImageKeysForPlatform(platform?: NodeJS.Platform): KeyId;
+/**
+ * All keybindings definitions: TUI + app-specific.
+ */
+export declare const KEYBINDINGS: {
+    readonly "app.interrupt": {
+        readonly defaultKeys: "escape";
+        readonly description: "Interrupt current operation";
+    };
+    readonly "app.clear": {
+        readonly defaultKeys: "ctrl+c";
+        readonly description: "Clear screen or cancel";
+    };
+    readonly "app.exit": {
+        readonly defaultKeys: "ctrl+d";
+        readonly description: "Exit application";
+    };
+    readonly "app.suspend": {
+        readonly defaultKeys: "ctrl+z";
+        readonly description: "Suspend application";
+    };
+    readonly "app.thinking.cycle": {
+        readonly defaultKeys: "shift+tab";
+        readonly description: "Cycle thinking level";
+    };
+    readonly "app.thinking.toggle": {
+        readonly defaultKeys: "ctrl+t";
+        readonly description: "Toggle thinking mode";
+    };
+    readonly "app.commandPalette.open": {
+        readonly defaultKeys: "ctrl+p";
+        readonly description: "Open command palette";
+    };
+    readonly "app.model.cycleForward": {
+        readonly defaultKeys: "alt+n";
+        readonly description: "Cycle to next model";
+    };
+    readonly "app.model.cycleBackward": {
+        readonly defaultKeys: "alt+shift+n";
+        readonly description: "Cycle to previous model";
+    };
+    readonly "app.model.select": {
+        readonly defaultKeys: "ctrl+l";
+        readonly description: "Select model";
+    };
+    readonly "app.model.selectTemporary": {
+        readonly defaultKeys: "alt+p";
+        readonly description: "Select temporary model for current session";
+    };
+    readonly "app.tools.expand": {
+        readonly defaultKeys: "ctrl+o";
+        readonly description: "Expand tools";
+    };
+    readonly "app.tool.backgroundFold": {
+        readonly defaultKeys: "ctrl+b";
+        readonly description: "Fold/background supported foreground tool";
+    };
+    readonly "app.editor.external": {
+        readonly defaultKeys: "ctrl+g";
+        readonly description: "Open external editor";
+    };
+    readonly "app.message.followUp": {
+        readonly defaultKeys: [];
+        readonly description: "Send follow-up message (no default; Ctrl+Enter submits)";
+    };
+    readonly "app.message.queue": {
+        readonly defaultKeys: KeyId;
+        readonly description: "Queue message for next turn";
+    };
+    readonly "app.message.dequeue": {
+        readonly defaultKeys: ["alt+up", "alt+down"];
+        readonly description: "Select queued message to edit";
+    };
+    readonly "app.clipboard.pasteImage": {
+        readonly defaultKeys: KeyId;
+        readonly description: "Paste image from clipboard";
+    };
+    readonly "app.clipboard.copyLine": {
+        readonly defaultKeys: "alt+shift+l";
+        readonly description: "Copy current line";
+    };
+    readonly "app.clipboard.copyPrompt": {
+        readonly defaultKeys: "alt+shift+c";
+        readonly description: "Copy prompt";
+    };
+    readonly "app.session.new": {
+        readonly defaultKeys: "ctrl+n";
+        readonly description: "Start a new session";
+    };
+    readonly "app.session.tree": {
+        readonly defaultKeys: [];
+        readonly description: "Show session tree";
+    };
+    readonly "app.session.fork": {
+        readonly defaultKeys: [];
+        readonly description: "Fork session";
+    };
+    readonly "app.session.resume": {
+        readonly defaultKeys: [];
+        readonly description: "Resume session";
+    };
+    readonly "app.session.observe": {
+        readonly defaultKeys: "ctrl+s";
+        readonly description: "Observe subagent sessions";
+    };
+    readonly "app.session.dashboard": {
+        readonly defaultKeys: [];
+        readonly description: "Show all persisted sessions dashboard";
+    };
+    readonly "app.jobs.open": {
+        readonly defaultKeys: "alt+j";
+        readonly description: "Open monitor/cron jobs overlay";
+    };
+    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 order";
+    };
+    readonly "app.session.rename": {
+        readonly defaultKeys: "ctrl+r";
+        readonly description: "Rename session";
+    };
+    readonly "app.session.delete": {
+        readonly defaultKeys: "ctrl+d";
+        readonly description: "Delete current session transcript/artifacts";
+    };
+    readonly "app.session.deleteNoninvasive": {
+        readonly defaultKeys: "ctrl+backspace";
+        readonly description: "Delete selected session transcript/artifacts (non-invasive)";
+    };
+    readonly "app.tree.foldOrUp": {
+        readonly defaultKeys: ["ctrl+left", "alt+left"];
+        readonly description: "Fold or move up";
+    };
+    readonly "app.tree.unfoldOrDown": {
+        readonly defaultKeys: ["ctrl+right", "alt+right"];
+        readonly description: "Unfold or move down";
+    };
+    readonly "app.plan.toggle": {
+        readonly defaultKeys: "alt+shift+p";
+        readonly description: "Toggle plan mode";
+    };
+    readonly "app.history.search": {
+        readonly defaultKeys: "ctrl+r";
+        readonly description: "Search history";
+    };
+    readonly "app.stt.toggle": {
+        readonly defaultKeys: "alt+h";
+        readonly description: "Toggle speech-to-text";
+    };
+    readonly "app.irc.sidebar.toggle": {
+        readonly defaultKeys: "alt+i";
+        readonly description: "Toggle IRC sidebar";
+    };
+    readonly "app.transcript.browse": {
+        readonly defaultKeys: [];
+        readonly description: "Browse the transcript";
+    };
+    readonly "app.transcript.prevTurn": {
+        readonly defaultKeys: [];
+        readonly description: "Jump to previous user turn";
+    };
+    readonly "app.transcript.nextTurn": {
+        readonly defaultKeys: [];
+        readonly description: "Jump to next user turn";
+    };
+    readonly "app.mode.cycle": {
+        readonly defaultKeys: [];
+        readonly description: "Cycle interaction mode";
+    };
+    readonly "app.tasks.toggle": {
+        readonly defaultKeys: "alt+t";
+        readonly description: "Toggle tasks pane";
+    };
+    readonly "app.queue.togglePane": {
+        readonly defaultKeys: [];
+        readonly description: "Toggle message queue pane";
+    };
+    readonly "app.message.sendNow": {
+        readonly defaultKeys: [];
+        readonly description: "Send message immediately";
+    };
+    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.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+a"];
+        readonly description: "Move to line start";
+    };
+    readonly "tui.editor.cursorLineEnd": {
+        readonly defaultKeys: ["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";
+        readonly description: "Page up";
+    };
+    readonly "tui.editor.pageDown": {
+        readonly defaultKeys: "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", "ctrl+backspace"];
+        readonly description: "Delete word backward";
+    };
+    readonly "tui.editor.deleteWordForward": {
+        readonly defaultKeys: ["alt+delete", "alt+d"];
+        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.editor.undo": {
+        readonly defaultKeys: ["ctrl+-", "ctrl+_"];
+        readonly description: "Undo";
+    };
+    readonly "tui.input.newLine": {
+        readonly defaultKeys: "shift+enter";
+        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.global.debug": {
+        readonly defaultKeys: "shift+ctrl+d";
+        readonly description: "Toggle debug overlay";
+    };
+};
+declare function migrateKeybindingsConfigFile(agentDir: string): void;
+/**
+ * Manages all keybindings (app + TUI).
+ * Extends the TUI KeybindingsManager with app-specific functionality.
+ */
+export declare class KeybindingsManager extends TuiKeybindingsManager {
+    #private;
+    constructor(userBindings?: KeybindingsConfig, configPath?: string);
+    /**
+     * Create from config file at agentDir/keybindings.json.
+     */
+    static create(agentDir?: string): KeybindingsManager;
+    /**
+     * Create an in-memory keybindings manager without file persistence.
+     */
+    static inMemory(userBindings?: KeybindingsConfig): KeybindingsManager;
+    /**
+     * Reload keybindings from the config file.
+     */
+    reload(): void;
+    /**
+     * Get the effective resolved bindings (defaults + user overrides).
+     */
+    getEffectiveConfig(): KeybindingsConfig;
+    /**
+     * Get display string for a keybinding (e.g., "ctrl+c/escape").
+     */
+    getDisplayString(keybinding: Keybinding): string;
+}
+export declare function formatKeyHint(key: KeyId): string;
+export declare function formatKeyHints(keys: KeyId | KeyId[]): string;
+export type { Keybinding, KeybindingsConfig, KeyId };
+export { migrateKeybindingsConfigFile };

package/dist/types/config/model-auth.d.ts

@@ -0,0 +1,3 @@
+export declare const kNoAuth = "N/A";
+export declare function isAuthenticated(apiKey: string | undefined | null): apiKey is string;
+export declare function isAuthenticatedOrKeyless(apiKey: string | undefined | null): boolean;

package/dist/types/config/model-bindings-applier.d.ts

@@ -0,0 +1,13 @@
+import { type ModelSelectorValue } from "./model-selector-value";
+import type { Settings } from "./settings";
+export interface ConfiguredModelBindings {
+    modelRoles?: Record<string, ModelSelectorValue>;
+    agentModelOverrides?: Record<string, ModelSelectorValue>;
+}
+/** Synchronizes config-owned model bindings while preserving user edits. */
+export declare class ModelBindingsApplier {
+    #private;
+    setBindings(bindings: ConfiguredModelBindings | undefined): void;
+    applyTo(targetSettings: Settings): void;
+    apply(): void;
+}

package/dist/types/config/model-discovery-manager.d.ts

@@ -0,0 +1,49 @@
+import { type Api, type Model, type ModelRefreshStrategy } from "@sayknow-cli/ai";
+export interface DiscoveryProvider {
+    provider: string;
+    optional?: boolean;
+}
+export type ProviderDiscoveryStatus = "idle" | "ok" | "empty" | "cached" | "unavailable" | "unauthenticated";
+export interface ProviderDiscoveryState {
+    provider: string;
+    status: ProviderDiscoveryStatus;
+    optional: boolean;
+    stale: boolean;
+    fetchedAt?: number;
+    models: string[];
+    error?: string;
+}
+export interface DiscoveryRefreshToken {
+    provider: string;
+    generation: number;
+}
+/** A generation-guarded, immutable result for the registry to merge into its catalog. */
+export interface DiscoveryMergeInput {
+    provider: string;
+    token: DiscoveryRefreshToken;
+    current: boolean;
+    models: readonly Model<Api>[];
+    state: ProviderDiscoveryState;
+    warning?: string;
+}
+export interface ProviderDiscoveryCallbacks<TProvider extends DiscoveryProvider> {
+    cacheDbPath?: string;
+    requiresAuth: (provider: TProvider) => boolean;
+    peekApiKey: (provider: TProvider) => Promise<string | undefined>;
+    isAuthenticated: (apiKey: string | undefined) => boolean;
+    fetchModels: (provider: TProvider) => Promise<Model<Api>[]>;
+}
+/** Owns configured discovery inputs, status, cache lifecycle, and refresh generations. */
+export declare class ModelDiscoveryManager<TProvider extends DiscoveryProvider> {
+    #private;
+    reset(): void;
+    setProviders(providers: readonly TProvider[]): void;
+    addProvider(provider: TProvider): void;
+    get providers(): readonly TProvider[];
+    providerIds(): Set<string>;
+    getState(provider: string): ProviderDiscoveryState | undefined;
+    loadCached(provider: TProvider, cacheDbPath?: string): readonly Model<Api>[];
+    beginRefresh(provider: string): DiscoveryRefreshToken;
+    isCurrent(token: DiscoveryRefreshToken): boolean;
+    discover(provider: TProvider, strategy: ModelRefreshStrategy, callbacks: ProviderDiscoveryCallbacks<TProvider>): Promise<DiscoveryMergeInput>;
+}

package/dist/types/config/model-equivalence.d.ts

@@ -0,0 +1,44 @@
+import { type Api, type Model } from "@sayknow-cli/ai";
+export type CanonicalModelSource = "override" | "bundled" | "heuristic" | "fallback";
+export interface ModelEquivalenceConfig {
+    overrides?: Record<string, string>;
+    exclude?: string[];
+}
+export interface CanonicalModelVariant {
+    canonicalId: string;
+    selector: string;
+    model: Model<Api>;
+    source: CanonicalModelSource;
+}
+export interface CanonicalModelRecord {
+    id: string;
+    name: string;
+    variants: CanonicalModelVariant[];
+}
+export interface CanonicalModelIndex {
+    records: CanonicalModelRecord[];
+    byId: Map<string, CanonicalModelRecord>;
+    bySelector: Map<string, string>;
+}
+export declare function formatCanonicalVariantSelector(model: Model<Api>): string;
+/**
+ * Compare equivalent provider variants using the caller's ranking policy.
+ *
+ * The ordered criteria intentionally mirror the historical canonical resolver:
+ * vision support, configured provider rank, canonical exactness, canonical
+ * source, input plus cache-read cost, and original catalog order. Callers that
+ * do not have a canonical index can omit those axes while retaining a stable,
+ * total comparison.
+ */
+export declare function compareEquivalentModelVariants(left: Model<Api>, right: Model<Api>, options?: {
+    providerRank?: ReadonlyMap<string, number>;
+    canonicalId?: string;
+    leftSourceRank?: number;
+    rightSourceRank?: number;
+    modelOrder?: ReadonlyMap<string, number>;
+    includeCost?: boolean;
+    finalize?: boolean;
+}): number;
+/** @deprecated Use compareEquivalentModelVariants for total variant ranking. */
+export declare function compareModelVariantRank(left: Model<Api>, right: Model<Api>): number;
+export declare function buildCanonicalModelIndex(models: readonly Model<Api>[], equivalence?: ModelEquivalenceConfig): CanonicalModelIndex;