indusagi 0.12.32 → 0.12.33

package/dist/types/tracing/signal/segment.d.ts

@@ -0,0 +1,124 @@
+/**
+ * The unit of trace data: an immutable {@link Segment} value.
+ *
+ * A {@link Segment} is a plain, frozen value object — never a class instance and
+ * never mutated in place. The lifecycle (open → note → close) is expressed by
+ * *producing new* segment values rather than by toggling fields on a live
+ * object, which keeps the data model trivially serializable and free of the
+ * `BaseSpan`/`DefaultSpan`/`NoopSpan` inheritance shape. The behavioural side —
+ * the open/note/close operations a caller actually invokes — lives entirely in
+ * {@link SegmentHandle} (see `./handle`).
+ *
+ * The vocabulary here is deliberately distinct from the OpenTelemetry "span"
+ * lineage: an entity kind is a {@link SegmentKind} (`run`/`inference`/`action`/
+ * `recall`/`custom`), and the exported, closed form is a {@link TraceRecord}.
+ */
+/**
+ * The kind of work a segment records.
+ *
+ * - `run`       — a whole agent run / top-level invocation.
+ * - `inference` — a single model/LLM call.
+ * - `action`    — a tool or side-effecting action execution.
+ * - `recall`    — a memory / retrieval operation.
+ * - `custom`    — anything a caller wants to time that does not fit above.
+ */
+export type SegmentKind = "run" | "inference" | "action" | "recall" | "custom";
+/** The lifecycle status of a segment. `open` until closed; then `ok` or `error`. */
+export type SegmentStatus = "open" | "ok" | "error";
+/** A captured failure attached to a segment. Intentionally minimal and serializable. */
+export interface SegmentError {
+    readonly message: string;
+}
+/**
+ * An immutable trace segment.
+ *
+ * Every field is `readonly`; the value is frozen at construction (see
+ * {@link openSegment}). Transitions are modelled as *new* frozen values derived
+ * from a prior one ({@link withAttributes}, {@link closeSegment}) — there is no
+ * in-place mutation anywhere in this module.
+ */
+export interface Segment {
+    /** Stable identifier for this segment, unique within its trace. Hex. */
+    readonly id: string;
+    /** Identifier of the trace this segment belongs to. Shared by all kin. Hex. */
+    readonly traceId: string;
+    /** The enclosing segment's `id`, or `null` for a trace root. */
+    readonly parentId: string | null;
+    /** What kind of work this segment records. */
+    readonly kind: SegmentKind;
+    /** Human-readable label for the segment. */
+    readonly name: string;
+    /** Wall-clock start, in epoch milliseconds. */
+    readonly startedAt: number;
+    /** Wall-clock end, in epoch milliseconds; `null` while still open. */
+    readonly endedAt: number | null;
+    /** Lifecycle status. */
+    readonly status: SegmentStatus;
+    /** Arbitrary structured annotations; a frozen, read-only bag. */
+    readonly attributes: Readonly<Record<string, unknown>>;
+    /** Present only once a segment has failed. */
+    readonly error?: SegmentError;
+}
+/**
+ * The exported, serializable form of a *closed* segment.
+ *
+ * Structurally a {@link Segment} that is guaranteed terminal: `endedAt` is a
+ * number (not `null`) and `status` is no longer `open`. This is what a
+ * `close` signal carries and what sinks persist; it never appears for a segment
+ * still in flight.
+ */
+export interface TraceRecord extends Segment {
+    readonly endedAt: number;
+    readonly status: "ok" | "error";
+}
+/**
+ * Generate a fresh hex identifier of `byteLength` random bytes.
+ *
+ * Trace ids default to 16 bytes (128-bit) and segment ids to 8 bytes (64-bit),
+ * mirroring the W3C Trace Context sizing without depending on any OTel SDK.
+ */
+export declare function freshId(byteLength: number): string;
+/** A new 128-bit hex trace id. */
+export declare function freshTraceId(): string;
+/** A new 64-bit hex segment id. */
+export declare function freshSegmentId(): string;
+/** Inputs for opening a fresh segment. Missing ids/clock are generated/sampled. */
+export interface OpenSegmentInput {
+    readonly kind: SegmentKind;
+    readonly name: string;
+    /** Trace to join. Omit on a root to mint a fresh trace id. */
+    readonly traceId?: string;
+    /** Enclosing segment id, or `null`/omitted for a root. */
+    readonly parentId?: string | null;
+    /** Pre-assigned segment id; one is minted when omitted. */
+    readonly id?: string;
+    /** Initial annotations. */
+    readonly attributes?: Readonly<Record<string, unknown>>;
+    /** Start clock override (epoch ms); `Date.now()` when omitted. */
+    readonly startedAt?: number;
+}
+/**
+ * Construct a fresh, frozen, `open` {@link Segment}.
+ *
+ * Pure aside from id/clock defaulting: with all fields supplied it is
+ * deterministic. The returned value and its `attributes` bag are both frozen.
+ */
+export declare function openSegment(input: OpenSegmentInput): Segment;
+/**
+ * Derive a new frozen segment with `patch` merged over its attributes.
+ *
+ * Last-writer-wins on key collision. The original segment is untouched.
+ */
+export declare function withAttributes(segment: Segment, patch: Readonly<Record<string, unknown>>): Segment;
+/**
+ * Derive the terminal {@link TraceRecord} for an open segment.
+ *
+ * Stamps `endedAt` (defaulting to now), sets the final `status`, and — when the
+ * status is `error` — attaches `error` (a passed-in error wins over any already
+ * recorded one). Closing an already-closed segment is idempotent in spirit:
+ * the new end clock and status simply replace the prior terminal fields.
+ */
+export declare function closeSegment(segment: Segment, status: "ok" | "error", options?: {
+    readonly endedAt?: number;
+    readonly error?: SegmentError;
+}): TraceRecord;

package/dist/types/tracing/sinks/base.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The {@link Sink} contract: a consumer that drains a {@link SignalChannel}.
+ *
+ * A sink is the *terminal* end of the trace transport. Where a producer pushes
+ * {@link TraceSignal}s into a {@link SignalChannel} (via `emit`), a sink pulls
+ * them back out with `for await … of channel` and does something with them —
+ * print a line, append NDJSON, forward to an injected stream. There is no
+ * subscriber registration and no push: the sink owns its own pull loop and runs
+ * until the channel is closed and drained.
+ *
+ * This mirrors the layer's deliberate divergence from the OTel exporter shape:
+ * a sink is not an `Exporter` with `export(batch)` / `shutdown()`; it is a plain
+ * object with a single mandatory {@link Sink.drain} coroutine plus optional
+ * {@link Sink.flush}/{@link Sink.close} lifecycle hooks. Concrete sinks
+ * (`ConsoleSink`, `FileSink`, `StreamSink`) implement this interface.
+ */
+import type { SignalChannel } from "../channel/signal";
+/**
+ * A terminal consumer of a {@link SignalChannel}.
+ *
+ * Implementations iterate the channel to completion inside {@link drain},
+ * handling each {@link TraceSignal} as it arrives. {@link flush} and
+ * {@link close} are optional: a buffered sink overrides `flush` to force pending
+ * writes to their destination, and a sink that owns a resource (a file handle,
+ * a socket) overrides `close` to release it. A sink with no buffering and no
+ * owned resource needs neither.
+ */
+export interface Sink {
+    /**
+     * Pull every signal from `channel` and handle it, returning once the channel
+     * is closed and fully drained.
+     *
+     * Implemented as a `for await … of channel` loop. A sink is expected to call
+     * this once per channel; concurrent drains of the same channel are undefined
+     * because the channel is single-consumer.
+     */
+    drain(channel: SignalChannel): Promise<void>;
+    /**
+     * Force any buffered output to its destination without ending the sink.
+     *
+     * Optional — only buffered sinks need it. Safe to call repeatedly.
+     */
+    flush?(): Promise<void>;
+    /**
+     * Release any resource the sink owns (file handle, socket, …).
+     *
+     * Optional — only resource-owning sinks need it. Should be idempotent and is
+     * typically preceded by an implicit or explicit {@link flush}.
+     */
+    close?(): Promise<void>;
+}

package/dist/types/tracing/sinks/console.d.ts

@@ -0,0 +1,44 @@
+/**
+ * {@link ConsoleSink}: a human-facing sink that prints one tidy line per closed
+ * segment.
+ *
+ * It drains a {@link SignalChannel} and ignores `open`/`update` chatter,
+ * emitting a single formatted line only when a segment *closes* — i.e. on each
+ * {@link CloseSignal} / {@link TraceRecord}. The line carries the status, the
+ * segment kind and name, the wall-clock duration, and a short trace/segment id
+ * tag, e.g.:
+ *
+ * ```text
+ * ✓ inference  chat.completion        842ms  [a1b2c3d4/9f8e7d6c]
+ * ✗ action     write_file              12ms  [a1b2c3d4/0011aabb] — EACCES: permission denied
+ * ```
+ *
+ * Output goes through an injected `log` function (default `console.log`) so the
+ * sink stays testable and never reaches for a global directly beyond that
+ * default.
+ */
+import type { SignalChannel } from "../channel/signal";
+import type { Sink } from "./base";
+/** Tuning for a {@link ConsoleSink}. */
+export interface ConsoleSinkOptions {
+    /**
+     * Where formatted lines go. Defaults to `console.log`. Injected for tests and
+     * for routing to alternative loggers.
+     */
+    readonly log?: (line: string) => void;
+}
+/**
+ * A {@link Sink} that prints one line per closed segment to a `log` function.
+ *
+ * Stateless and resource-free: it owns no buffer and no handle, so it needs
+ * neither `flush` nor `close`. Constructing it does nothing until {@link drain}
+ * is awaited on a channel.
+ */
+export declare class ConsoleSink implements Sink {
+    private readonly log;
+    constructor(options?: ConsoleSinkOptions);
+    /** Render the one-line summary for a closed segment. */
+    private format;
+    /** Drain `channel`, printing a line for every `close` signal. */
+    drain(channel: SignalChannel): Promise<void>;
+}

package/dist/types/tracing/sinks/file.d.ts

@@ -0,0 +1,47 @@
+/**
+ * {@link FileSink}: persists closed segments as newline-delimited JSON.
+ *
+ * It drains a {@link SignalChannel} and, for every `close` signal, appends the
+ * carried {@link TraceRecord} as a single JSON line to a file. The result is an
+ * NDJSON log — one self-contained record per line — that downstream tools can
+ * stream-parse without loading the whole file.
+ *
+ * Writes go through `node:fs/promises` `appendFile`, which creates the file if
+ * absent and atomically appends otherwise. Records are buffered in memory and
+ * flushed in a single append either when the in-memory batch reaches
+ * `flushEvery` lines or when {@link flush}/{@link close} is called — so a busy
+ * trace is not one syscall per segment. Only `open`/`update` are ignored;
+ * everything persisted is a terminal record.
+ */
+import type { SignalChannel } from "../channel/signal";
+import type { Sink } from "./base";
+/** Tuning for a {@link FileSink}. */
+export interface FileSinkOptions {
+    /**
+     * How many records to accumulate before an automatic append. Defaults to 1
+     * (append each record as it closes). Larger values trade latency for fewer
+     * syscalls; any remainder is flushed on {@link flush}/{@link close}.
+     */
+    readonly flushEvery?: number;
+}
+/**
+ * A {@link Sink} that appends each closed segment to a path as NDJSON.
+ *
+ * Owns an in-memory pending batch (hence a meaningful {@link flush}) but no live
+ * OS handle — each write opens, appends, and closes via `fs/promises`. {@link drain}
+ * flushes whatever remains when the channel ends, and {@link close} is a final
+ * flush.
+ */
+export declare class FileSink implements Sink {
+    private readonly path;
+    private readonly flushEvery;
+    /** Serialized records awaiting their append, oldest first. */
+    private pending;
+    constructor(path: string, options?: FileSinkOptions);
+    /** Drain `channel`, buffering each closed record and flushing on threshold/end. */
+    drain(channel: SignalChannel): Promise<void>;
+    /** Append all pending records to the file as NDJSON lines, then clear them. */
+    flush(): Promise<void>;
+    /** Flush any remaining records. Idempotent; the sink holds no OS handle. */
+    close(): Promise<void>;
+}

package/dist/types/tracing/sinks/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The sinks layer — public surface.
+ *
+ * The {@link Sink} contract (`drain`/`flush?`/`close?`) and its concrete
+ * implementations: {@link ConsoleSink} (one pretty line per closed segment),
+ * {@link FileSink} (NDJSON of {@link TraceRecord}s appended to a path), and
+ * {@link StreamSink} (JSON lines to an injected `Writable`). Each consumes a
+ * {@link import('../channel/signal').SignalChannel} and writes somewhere.
+ */
+export type { Sink } from "./base";
+export { ConsoleSink } from "./console";
+export type { ConsoleSinkOptions } from "./console";
+export { FileSink } from "./file";
+export type { FileSinkOptions } from "./file";
+export { StreamSink } from "./stream";
+export type { StreamSinkOptions } from "./stream";

package/dist/types/tracing/sinks/stream.d.ts

@@ -0,0 +1,46 @@
+/**
+ * {@link StreamSink}: writes closed segments to an injected {@link Writable}.
+ *
+ * It drains a {@link SignalChannel} and, for every `close` signal, serializes the
+ * {@link TraceRecord} to a JSON line and writes it to a caller-provided
+ * `node:stream` {@link Writable} — `process.stdout`, a file write stream, a
+ * network socket, a `PassThrough` in tests. This is the most general sink: the
+ * destination is whatever Writable you hand it.
+ *
+ * Backpressure is honoured. When `write` returns `false` (the stream's internal
+ * buffer is full) the sink awaits the next `drain` event before continuing, so a
+ * slow consumer throttles the trace rather than ballooning memory. {@link close}
+ * optionally ends the underlying stream when the sink was told it owns it.
+ */
+import type { Writable } from "node:stream";
+import type { SignalChannel } from "../channel/signal";
+import type { Sink } from "./base";
+/** Tuning for a {@link StreamSink}. */
+export interface StreamSinkOptions {
+    /**
+     * Whether {@link close} should `end()` the underlying stream. Defaults to
+     * `false` — by default the sink writes but never closes a stream it did not
+     * create (e.g. you would not want it ending `process.stdout`).
+     */
+    readonly endOnClose?: boolean;
+}
+/**
+ * A {@link Sink} that writes each closed segment as a JSON line to a {@link Writable}.
+ *
+ * Owns no buffer of its own — bytes go straight to the stream — so {@link flush}
+ * is a no-op resolution. {@link close} ends the stream only when constructed with
+ * `endOnClose: true`.
+ */
+export declare class StreamSink implements Sink {
+    private readonly stream;
+    private readonly endOnClose;
+    constructor(stream: Writable, options?: StreamSinkOptions);
+    /** Write `line`, resolving once it is accepted or once backpressure clears. */
+    private writeLine;
+    /** Drain `channel`, writing a JSON line per closed record (with backpressure). */
+    drain(channel: SignalChannel): Promise<void>;
+    /** No-op: bytes are not buffered by this sink. Present for interface symmetry. */
+    flush(): Promise<void>;
+    /** End the underlying stream when this sink owns it (`endOnClose`); else no-op. */
+    close(): Promise<void>;
+}

package/dist/types/tracing/tracing.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Behavioural tests for the homegrown tracer: the {@link Recorder} → channel →
+ * sink flow, sampling, secret redaction, and the runtime {@link traceAgentRun}
+ * adapter. No network and no real timers; the {@link FileSink} writes under
+ * {@link os.tmpdir}.
+ */
+export {};

package/dist/types/ui/autocomplete.d.ts

@@ -0,0 +1,59 @@
+export interface AutocompleteItem {
+    value: string;
+    label: string;
+    description?: string;
+}
+export interface SlashCommand {
+    name: string;
+    description?: string;
+    getArgumentCompletions?(argumentPrefix: string): AutocompleteItem[] | null;
+}
+export interface AutocompleteProvider {
+    getSuggestions(lines: string[], cursorLine: number, cursorCol: number): {
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null;
+    applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
+        lines: string[];
+        cursorLine: number;
+        cursorCol: number;
+    };
+}
+type SuggestionResult = {
+    items: AutocompleteItem[];
+    prefix: string;
+};
+export declare class CombinedAutocompleteProvider implements AutocompleteProvider {
+    private readonly basePath;
+    private readonly fdPath;
+    private readonly cache;
+    private readonly commandEngine;
+    private readonly attachmentEngine;
+    private readonly pathEngine;
+    private readonly applyStrategy;
+    constructor(commands?: (SlashCommand | AutocompleteItem)[], basePath?: string, fdPath?: string | null);
+    getSuggestions(lines: string[], cursorLine: number, cursorCol: number): SuggestionResult | null;
+    applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
+        lines: string[];
+        cursorLine: number;
+        cursorCol: number;
+    };
+    clearCache(): void;
+    getForceFileSuggestions(lines: string[], cursorLine: number, cursorCol: number): SuggestionResult | null;
+    shouldTriggerFileCompletion(lines: string[], cursorLine: number, cursorCol: number): boolean;
+}
+export interface AsyncAutocompleteProvider {
+    getSuggestionsAsync(lines: string[], cursorLine: number, cursorCol: number): Promise<{
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null>;
+}
+export declare class AsyncAutocompleteChain implements AsyncAutocompleteProvider {
+    private readonly providers;
+    constructor(providers: AsyncAutocompleteProvider[]);
+    getSuggestionsAsync(lines: string[], cursorLine: number, cursorCol: number): Promise<{
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null>;
+}
+export {};

package/dist/types/ui/contracts.d.ts

@@ -0,0 +1,38 @@
+export interface Component {
+    onMount?(): void;
+    onUnmount?(): void;
+    onFocus?(): void;
+    onBlur?(): void;
+    handleInput?(data: string): void;
+    render(width: number): string[];
+    invalidate(): void;
+}
+export interface TUI {
+    requestRender?(): void;
+    focus?(component: Component | null): void;
+}
+export type OverlayAnchor = "center" | "top-center" | "bottom-center" | "left-center" | "right-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
+export interface OverlayMargin {
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+}
+export type SizeValue = number | `${number}%`;
+export interface OverlayOptions {
+    anchor?: OverlayAnchor;
+    row?: SizeValue;
+    col?: SizeValue;
+    offsetX?: number;
+    offsetY?: number;
+    margin?: OverlayMargin | number;
+    width?: SizeValue;
+    minWidth?: number;
+    maxHeight?: SizeValue;
+    visible?: (termWidth: number, termHeight: number) => boolean;
+}
+export interface OverlayHandle {
+    isHidden(): boolean;
+    setHidden(hidden: boolean): void;
+    hide(): void;
+}

package/dist/types/ui/editor-component.d.ts

@@ -0,0 +1,100 @@
+import type { AutocompleteProvider } from "./autocomplete.js";
+import type { Component } from "./contracts.js";
+/**
+ * Read-only capabilities of an editor component.
+ * Consumers that only need to observe state should depend on this type.
+ */
+export interface EditorReadAccess {
+    /**
+     * Returns the raw text currently held in the editor buffer.
+     * Does not include any virtual or expanded markers.
+     */
+    getText(): string;
+    /**
+     * Returns the text with any inline markers expanded (e.g., paste-mode
+     * sentinels replaced by their visible representation).
+     * Falls back to `getText()` when not implemented.
+     */
+    getExpandedText?(): string;
+}
+/**
+ * Mutation capabilities of an editor component.
+ * Consumers that drive the editor (set content, trigger history, etc.)
+ * depend on this type.
+ */
+export interface EditorWriteAccess {
+    /**
+     * Replaces the entire editor buffer with the given text.
+     * The cursor is repositioned to the end of the new content.
+     */
+    setText(text: string): void;
+    /**
+     * Inserts the given text at the current cursor position,
+     * pushing existing content to the right.
+     */
+    insertTextAtCursor?(text: string): void;
+    /**
+     * Pushes the given text string into the editor's history ring
+     * so it can be recalled with Up / Down arrow navigation.
+     */
+    addToHistory?(text: string): void;
+}
+/**
+ * Optional visual and autocomplete configuration for an editor component.
+ */
+export interface EditorDisplayConfig {
+    /**
+     * ANSI colour-wrap function applied to the editor's border.
+     * Receives the border characters and must return a styled string.
+     */
+    borderColor?: (str: string) => string;
+    /**
+     * Sets the number of blank columns added on the left and right
+     * of the editor's content area.
+     */
+    setPaddingX?(padding: number): void;
+    /**
+     * Attaches an autocomplete provider that supplies completion candidates
+     * as the user types.
+     */
+    setAutocompleteProvider?(provider: AutocompleteProvider): void;
+    /**
+     * Returns an opaque string identifier for this component's keybinding
+     * scope, used to resolve per-component keybinding overrides.
+     */
+    getKeybindingScopeId?(): string;
+}
+/**
+ * Event callbacks wired into the editor lifecycle.
+ */
+export interface EditorEventCallbacks {
+    /**
+     * Fired when the user commits the current input (e.g., presses Enter).
+     * Receives the final text value at the moment of submission.
+     */
+    onSubmit?: (text: string) => void;
+    /**
+     * Fired on every keystroke or programmatic change to the buffer content.
+     * Receives the updated text after the change has been applied.
+     */
+    onChange?: (text: string) => void;
+}
+/**
+ * Full interface for a pluggable editor component.
+ *
+ * Compose the read, write, display and callback sub-interfaces so that
+ * extensions (vim mode, emacs mode, custom keybindings, etc.) remain
+ * compatible with the core application while each concern is independently
+ * testable.
+ *
+ * @example
+ * ```ts
+ * class VimEditor implements EditorComponent {
+ *   getText() { return this.buffer; }
+ *   setText(t: string) { this.buffer = t; }
+ *   // ... Component lifecycle methods
+ * }
+ * ```
+ */
+export interface EditorComponent extends Component, EditorReadAccess, EditorWriteAccess, EditorDisplayConfig, EditorEventCallbacks {
+}

package/dist/types/ui/fuzzy.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Helpers for approximate ("fuzzy") string matching.
+ *
+ * A query is considered a match when every one of its characters can be found
+ * in the target string while preserving their relative order, even if other
+ * characters sit between them. Each match is also given a numeric score where
+ * smaller numbers indicate a tighter, more relevant match.
+ */
+export interface FuzzyMatch {
+    matches: boolean;
+    score: number;
+}
+export interface FuzzyScoringConfig {
+    gapPenalty: number;
+    consecutiveReward: number;
+    wordBoundaryReward: number;
+    lateMatchPenalty: number;
+    swappedTokenPenalty: number;
+}
+export interface FuzzyMatcherStrategy {
+    match(query: string, text: string, config: FuzzyScoringConfig): FuzzyMatch;
+}
+export declare function fuzzyMatch(query: string, text: string): FuzzyMatch;
+/**
+ * Keep only the items whose text fuzzy-matches the query, ordered so the
+ * strongest matches come first. The query may contain several whitespace-
+ * separated tokens; an item is only retained when it matches all of them.
+ */
+export declare function fuzzyFilter<T>(items: T[], query: string, getText: (item: T) => string): T[];

package/dist/types/ui/index.d.ts

@@ -0,0 +1,8 @@
+export { type AutocompleteItem, type AutocompleteProvider, CombinedAutocompleteProvider, type SlashCommand, } from "./autocomplete.js";
+export type { EditorComponent } from "./editor-component.js";
+export type { Component, OverlayAnchor, OverlayHandle, OverlayMargin, OverlayOptions, SizeValue, TUI } from "./contracts.js";
+export type { EditorTheme, MarkdownTheme, SelectListTheme, SettingsListTheme } from "./theme-types.js";
+export { type FuzzyMatch, fuzzyFilter, fuzzyMatch } from "./fuzzy.js";
+export { DEFAULT_EDITOR_KEYBINDINGS, type EditorAction, type EditorKeybindingsConfig, EditorKeybindingsManager, getEditorKeybindings, setEditorKeybindings, } from "./keybindings.js";
+export { isKeyRelease, isKeyRepeat, isKittyProtocolActive, Key, type KeyEventType, type KeyId, matchesKey, parseKey, setKittyProtocolActive, } from "./keys.js";
+export { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "./utils.js";

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

@@ -0,0 +1,62 @@
+import { type KeyId } from "./keys.js";
+/**
+ * Names of the bindable behaviors the line editor understands. Each value
+ * here is a logical action that one or more physical keys may trigger.
+ */
+export type EditorAction = "cursorUp" | "cursorDown" | "cursorLeft" | "cursorRight" | "cursorWordLeft" | "cursorWordRight" | "cursorLineStart" | "cursorLineEnd" | "pageUp" | "pageDown" | "deleteCharBackward" | "deleteCharForward" | "deleteWordBackward" | "deleteWordForward" | "deleteToLineStart" | "deleteToLineEnd" | "newLine" | "submit" | "tab" | "selectUp" | "selectDown" | "selectPageUp" | "selectPageDown" | "selectConfirm" | "selectCancel" | "copy" | "yank" | "yankPop" | "undo" | "expandTools" | "toggleSessionPath" | "toggleSessionSort" | "renameSession" | "deleteSession" | "deleteSessionNoninvasive";
+export type { KeyId };
+/**
+ * A mapping from editor actions to the key (or keys) that should fire them.
+ */
+export type EditorKeybindingsConfig = {
+    [K in EditorAction]?: KeyId | KeyId[];
+};
+export type KeybindingPreset = "default" | "vim";
+export interface KeybindingConflict {
+    key: string;
+    actions: EditorAction[];
+}
+/**
+ * The keybinding layer applied to every editor before any user overrides.
+ *
+ * The table below is organized into category blocks (caret motion, deletion,
+ * text entry, completion popup, clipboard/kill-ring, history, tool expansion,
+ * session management). Each block is flattened, in declaration order, into one
+ * ordered map. The flat order is preserved exactly.
+ *
+ * Provenance: bindings derived from GNU readline are marked "[readline]" and
+ * use readline's chord exactly. Bindings unique to the indus editor are marked
+ * "[indus-original]" and were picked by this project.
+ */
+export declare const DEFAULT_EDITOR_KEYBINDINGS: Required<EditorKeybindingsConfig>;
+export declare const VIM_EDITOR_KEYBINDINGS: Partial<Required<EditorKeybindingsConfig>>;
+/**
+ * Resolves which keys are wired to which editor action, layering presets,
+ * user config, and per-component overrides on top of one another.
+ */
+export declare class EditorKeybindingsManager {
+    private readonly registry;
+    private componentOverrides;
+    constructor(config?: EditorKeybindingsConfig, preset?: KeybindingPreset);
+    private rebuildRegistry;
+    private resolveKeys;
+    /**
+     * Report whether the given raw key data triggers the named action.
+     */
+    matches(data: string, action: EditorAction, componentId?: string): boolean;
+    /**
+     * List every key currently wired to the given action.
+     */
+    getKeys(action: EditorAction): KeyId[];
+    registerAction(action: EditorAction, keys: KeyId | KeyId[]): void;
+    getRegisteredActions(): EditorAction[];
+    /**
+     * Swap in a fresh config (and optional preset), rebuilding the bindings.
+     */
+    setConfig(config: EditorKeybindingsConfig, preset?: KeybindingPreset): void;
+    setComponentOverride(componentId: string, config: EditorKeybindingsConfig): void;
+    clearComponentOverride(componentId: string): void;
+    detectConflicts(): KeybindingConflict[];
+}
+export declare function getEditorKeybindings(): EditorKeybindingsManager;
+export declare function setEditorKeybindings(manager: EditorKeybindingsManager): void;