@oh-my-pi/pi-tui 18.2.4 → 18.2.6

package/dist/types/components/scroll-view.d.ts

@@ -1,6 +1,8 @@
 import type { Component } from "../tui.js";
 import { Ellipsis } from "../utils.js";
+import { type ViewportAlignment } from "./scroll-viewport.js";
 type ScrollbarMode = "auto" | "always" | "never";
+export type ScrollAnchor = "start" | "end";
 export interface ScrollViewTheme {
     track?: (text: string) => string;
     thumb?: (text: string) => string;
@@ -9,7 +11,7 @@ export interface ScrollViewOptions {
     height: number;
     /** Defaults to "auto". "auto" reserves a scrollbar column only when content overflows. */
     scrollbar?: ScrollbarMode | boolean;
-    /** Logical row count for pre-windowed line slices. Defaults to lines.length. */
+    /** Logical row count for pre-windowed line slices. Defaults to the rendered content row count. */
     totalRows?: number;
     theme?: ScrollViewTheme;
     trackChar?: string;
@@ -17,48 +19,80 @@ export interface ScrollViewOptions {
     /**
      * Indicator appended when a row overflows `contentWidth`. Defaults to
      * {@link Ellipsis.Unicode}. Pass {@link Ellipsis.Omit} when callers wrap
-     * lines to width themselves and only trailing padding can overflow (e.g.
-     * the plan-review overlay), so no stray `…` lands on every padded row.
+     * lines to width themselves and only trailing padding can overflow.
      */
     ellipsis?: Ellipsis;
-    /**
-     * Rows moved per keystroke when {@link ScrollView.handleScrollKey} sees a
-     * Shift+Arrow (the "scroll faster" affordance). Defaults to 5.
-     */
+    /** Rows moved by Shift+Arrow in {@link ScrollView.handleScrollKey}. Defaults to 5. */
     fastScrollLines?: number;
+    /** Follow newly appended rows while the viewport was already at its tail. */
+    followTail?: boolean;
+    /** Preserve either the leading row or the distance from the tail across content/height changes. */
+    anchor?: ScrollAnchor;
+}
+/** A selected logical range revealed once or whenever its geometry changes. */
+export interface ScrollRangeAnchor {
+    id: string;
+    start: number;
+    end: number;
+    margin?: number;
+    alignment?: ViewportAlignment;
+    mode?: "selection" | "once";
+    /** Prefer the leading edge when the selected range fills more than the viewport. */
+    oversized?: "nearest" | "start";
 }
 /**
- * Fixed-height viewport over pre-rendered lines, with optional right-edge scrollbar.
+ * Fixed-height viewport over supplied rows or a lazily rendered child.
  *
- * ScrollView owns only the row offset. Callers remain responsible for producing
- * already-wrapped logical lines appropriate for the current render width.
+ * Without `totalRows`, content is a complete row buffer and ScrollView slices
+ * it at its own offset. With `totalRows`, content is an already-windowed slice:
+ * the offset remains logical (for thumb and hit mapping), while local row zero
+ * is rendered from content row zero.
  */
 export declare class ScrollView implements Component {
     #private;
-    constructor(lines: readonly string[], options: ScrollViewOptions);
+    constructor(content: readonly string[] | Component, options: ScrollViewOptions);
+    /** Child exposed for debug-tree traversal when the viewport wraps a component. */
+    get debugChildren(): readonly Component[];
     /** Return viewport, content, and scroll position state for debug inspection. */
     debugState(): Record<string, unknown>;
     setLines(lines: readonly string[]): void;
+    /** Replace the supplied rows with a lazily rendered child component. */
+    setChild(child: Component): void;
     setTotalRows(totalRows: number | undefined): void;
     setHeight(height: number): void;
     setScrollbar(scrollbar: ScrollViewOptions["scrollbar"]): void;
+    setFollowTail(followTail: boolean): void;
+    setAnchor(anchor: ScrollAnchor): void;
     getScrollOffset(): number;
     getMaxScrollOffset(): number;
+    /** Current half-open logical row range. */
+    getVisibleRange(): {
+        start: number;
+        end: number;
+    };
+    /** Map a local viewport row to its logical content row. */
+    logicalRowAt(localRow: number): number | undefined;
+    /** Map a visible logical content row to its local viewport row. */
+    localRowFor(logicalRow: number): number | undefined;
     setScrollOffset(offset: number): void;
+    /** Keep a logical row visible now and through subsequent resize/content changes. */
+    setActiveRow(row: number | undefined, alignment?: ViewportAlignment): void;
+    /** Whether a keyed range has already been revealed successfully. */
+    hasRevealedRange(id: string): boolean;
+    /**
+     * Reveal a changed selection without snapping manual scrolling back on
+     * unchanged renders. Passing undefined forgets the previous range.
+     */
+    revealRange(anchor: ScrollRangeAnchor | undefined, width: number): boolean;
     scroll(delta: number): void;
     page(delta: number): void;
     scrollToTop(): void;
     scrollToBottom(): void;
-    /**
-     * Apply a standard navigation key to the viewport. Shift+Arrow scrolls by
-     * {@link ScrollViewOptions.fastScrollLines} (the "scroll faster" affordance);
-     * plain Arrow by one line; PageUp/PageDown by a page; Home/End to the ends.
-     * Returns true when the key was consumed, so callers can fall through to
-     * their own (e.g. vim-style) bindings. Generic on purpose: every ScrollView
-     * consumer gets the same scroll keys, including Shift-to-go-faster.
-     */
+    /** Apply Arrow, Shift+Arrow, Page, Home, and End navigation keys. */
     handleScrollKey(data: string): boolean;
     invalidate(): void;
+    /** Permanently release a wrapped child's timers, subscriptions, and other resources. */
+    dispose(): void;
     render(width: number): readonly string[];
 }
 export {};

package/dist/types/components/scroll-viewport.d.ts

@@ -0,0 +1,46 @@
+export type ViewportAlignment = "nearest" | "start" | "center" | "end";
+export interface ViewportRange {
+    /** First visible logical row. */
+    start: number;
+    /** Exclusive end of the visible logical rows. */
+    end: number;
+}
+export interface ScrollbarThumbRange {
+    /** First local viewport row occupied by the thumb. */
+    start: number;
+    /** Exclusive end of the thumb. */
+    end: number;
+}
+export interface CursorColumnWindow {
+    /** Visible source slice. */
+    text: string;
+    /** First visible terminal column in the source. */
+    startColumn: number;
+    /** UTF-16 index of the cursor within {@link text}. */
+    cursorIndex: number;
+}
+/** Maximum legal row offset for a bounded viewport. */
+export declare function maxScrollOffset(totalRows: number, viewportRows: number): number;
+/** Clamp a row offset to the bounds of a viewport. */
+export declare function clampScrollOffset(offset: number, totalRows: number, viewportRows: number): number;
+/** Logical half-open row range visible at an offset. */
+export declare function viewportRange(totalRows: number, viewportRows: number, offset: number): ViewportRange;
+/** Whether the logical row set is taller than its viewport. */
+export declare function viewportOverflows(totalRows: number, viewportRows: number): boolean;
+/**
+ * Offset that keeps `row` visible, optionally aligning it to a viewport edge
+ * or center. `nearest` preserves the current offset while the row is visible.
+ */
+export declare function scrollOffsetForRow(currentOffset: number, row: number, totalRows: number, viewportRows: number, alignment?: ViewportAlignment): number;
+/** Selection-centered logical row window. */
+export declare function centeredViewportRange(selectedRow: number, totalRows: number, viewportRows: number): ViewportRange;
+/**
+ * Scrollbar thumb geometry shared by standalone viewports and embedded border
+ * renderers. The returned rows are local to the viewport.
+ */
+export declare function scrollbarThumbRange(viewportRows: number, totalRows: number, scrollOffset: number): ScrollbarThumbRange;
+/**
+ * Horizontally window a single rendered line around its cursor. Grapheme width
+ * is respected, including a wide cursor cell at the right edge.
+ */
+export declare function cursorColumnWindow(text: string, cursorIndex: number, width: number): CursorColumnWindow;

package/dist/types/components/section.d.ts

@@ -0,0 +1,19 @@
+import type { Component } from "../tui.js";
+/** Explicit heading/rule/spacing policy for a data section. */
+export interface SectionOptions {
+    readonly title: string;
+    readonly body: Component | readonly string[];
+    readonly titleStyle?: (text: string) => string;
+    readonly ruleStyle?: (text: string) => string;
+    readonly ruleGlyph: string;
+    readonly ruleWidth: number | "fill";
+    readonly blankAfter?: boolean;
+}
+/** Compose a width-bounded heading, rule, child rows, and optional trailing blank line. */
+export declare class Section implements Component {
+    #private;
+    constructor(options: SectionOptions);
+    invalidate(): void;
+    dispose(): void;
+    render(width: number): readonly string[];
+}

package/dist/types/components/select-list.d.ts

@@ -9,6 +9,12 @@ export interface SelectItem {
     icon?: string;
     /** Dim hint text shown inline after cursor when this item is selected */
     hint?: string;
+    /** Disabled rows stay visible but are skipped by navigation and cannot activate. */
+    disabled?: boolean;
+    /** When set, activation requires a second Enter/click and this text becomes the status line. */
+    confirmation?: string;
+    /** Additional text included by the default fuzzy filter without being rendered. */
+    searchText?: string;
 }
 export interface SelectListTheme {
     selectedPrefix: (text: string) => string;
@@ -29,12 +35,46 @@ export interface SelectListTruncatePrimaryContext {
     item: SelectItem;
     isSelected: boolean;
 }
+/** State supplied to a rich SelectList row renderer or measurer. */
+export interface SelectListRenderItemContext {
+    item: SelectItem;
+    index: number;
+    width: number;
+    selected: boolean;
+    hovered: boolean;
+    pendingConfirmation: boolean;
+    theme: SelectListTheme;
+}
+/** Current controlled menu state supplied to a custom status renderer. */
+export interface SelectListStatusContext {
+    query: string;
+    selectedIndex: number;
+    visibleCount: number;
+    totalCount: number;
+    pendingItem: SelectItem | undefined;
+}
 export interface SelectListLayoutOptions {
     minPrimaryColumnWidth?: number;
     maxPrimaryColumnWidth?: number;
     truncatePrimary?: (context: SelectListTruncatePrimaryContext) => string;
     /** Enable type-to-filter search when the item count exceeds maxVisible. Defaults to true. */
     overflowSearch?: boolean;
+    /** Search activation policy. `overflowSearch` remains authoritative when this is omitted. */
+    search?: "overflow" | "always" | "never";
+    /** Domain-specific filtering/ranking. Selection is retained by item value when possible. */
+    filterItems?: (items: readonly SelectItem[], query: string) => readonly SelectItem[];
+    /** Custom rich-row renderer. Every returned line is mouse-hit-tested as the same item. */
+    renderItem?: (context: SelectListRenderItemContext) => readonly string[];
+    /** Cheap row measurement for custom renderers; defaults to calling renderItem and reading its length. */
+    measureItem?: (context: SelectListRenderItemContext) => number;
+    /** Empty-list message (before a query is entered). */
+    emptyText?: string;
+    /** No-match message (after filtering). */
+    noMatchText?: string;
+    /** Optional status renderer. Return undefined to omit the status row. */
+    statusText?: (context: SelectListStatusContext) => string | undefined;
+    /** Whether single-step keyboard navigation wraps at the edges. Defaults to true. */
+    wrapNavigation?: boolean;
     /**
      * Wrap long descriptions onto continuation rows indented under the
      * description column instead of truncating. Defaults to false so existing
@@ -51,7 +91,6 @@ export interface SelectListLayoutOptions {
 }
 export declare class SelectList implements Component, MouseRoutable {
     #private;
-    private readonly items;
     private readonly theme;
     private readonly layout;
     onSelect?: (item: SelectItem) => void;
@@ -63,14 +102,19 @@ export declare class SelectList implements Component, MouseRoutable {
     /** Refit the visible row budget (hosts clamp the list to available height). */
     setMaxVisible(rows: number): void;
     setFilter(filter: string): void;
+    /** Replace controlled items while retaining the selected value when possible. */
+    setItems(items: readonly SelectItem[]): void;
     setSelectedIndex(index: number): void;
+    /** Select a visible item by its stable value. */
+    setSelectedValue(value: string): void;
+    getFilter(): string;
     /** Resolve a 0-based rendered-line index to a filtered-item index. */
     hitTest(line: number): number | undefined;
     /** Highlight the item under the pointer (null clears). */
     setHoverIndex(index: number | null): void;
     /** Move the selection one step for a wheel notch. */
     handleWheel(delta: -1 | 1): void;
-    /** Mouse click: select the item under the pointer and confirm it. */
+    /** Mouse click: select the item under the pointer and request activation. */
     clickItem(index: number): void;
     routeMouse(event: SgrMouseEvent, line: number, _col: number): void;
     invalidate(): void;

package/dist/types/components/settings-list.d.ts

@@ -1,5 +1,6 @@
 import type { SgrMouseEvent } from "../mouse.js";
 import type { Component } from "../tui.js";
+import { FormField, type FormFieldOptions, type FormFieldTheme } from "./form.js";
 export interface SettingItem {
     /** Unique identifier for this setting */
     id: string;
@@ -131,3 +132,22 @@ export declare class SettingsList implements Component {
     render(width: number): readonly string[];
     handleInput(data: string): void;
 }
+/** Construction options for a SettingsList composed as a form field. */
+export interface SettingsFormFieldOptions extends Omit<FormFieldOptions, "theme"> {
+    items: SettingItem[];
+    maxVisible: number;
+    settingsTheme: SettingsListTheme;
+    fieldTheme: FormFieldTheme;
+    onChange(id: string, newValue: string): void;
+    onCancel(): void;
+    listOptions?: SettingsListOptions;
+}
+/**
+ * SettingsList adapter for detail forms. It retains the canonical list
+ * implementation while sharing FormField label, description, hint, focus, and
+ * input dispatch with text and selection fields.
+ */
+export declare class SettingsFormField extends FormField {
+    readonly settingsList: SettingsList;
+    constructor(options: SettingsFormFieldOptions);
+}

package/dist/types/components/table.d.ts

@@ -0,0 +1,32 @@
+import type { Component } from "../tui.js";
+/** One table cell. Styling is applied after alignment so padding shares the cell style. */
+export interface TableCell {
+    readonly text: string;
+    readonly style?: (text: string) => string;
+}
+/** Explicit sizing and overflow policy for a table column. */
+export interface TableColumn {
+    readonly width: number;
+    readonly minWidth?: number;
+    readonly align: "left" | "right";
+    readonly overflow: "allow" | "truncate";
+    /** Lower-priority columns shrink before higher-priority columns. */
+    readonly priority?: number;
+    readonly style?: (text: string) => string;
+}
+/** Row-layout options shared by table functions and the component. */
+export interface TableOptions {
+    readonly gap?: string;
+    readonly indent?: string;
+    readonly fit?: boolean;
+}
+/** Render one ANSI-aware fixed-column row. */
+export declare function renderTableRow(cells: readonly TableCell[], columns: readonly TableColumn[], maxWidth?: number, options?: TableOptions): string;
+/** Bounded table component for structured rows with replaceable data and stable unchanged-render arrays. */
+export declare class Table implements Component {
+    #private;
+    constructor(rows: readonly (readonly TableCell[])[], columns: readonly TableColumn[], options?: TableOptions);
+    setRows(rows: readonly (readonly TableCell[])[]): boolean;
+    invalidate(): void;
+    render(width: number): readonly string[];
+}

package/dist/types/components/tree-view.d.ts

@@ -0,0 +1,130 @@
+import type { Theme } from "../theme/theme.js";
+import type { Component } from "../tui.js";
+import { type ScrollViewTheme } from "./scroll-view.js";
+/** Stable identity accepted by {@link TreeView}. Keys must be unique within one hierarchy. */
+export type TreeKey = string | number;
+/** One ancestor retained on a flattened hierarchy row. */
+export interface TreeAncestor<K extends TreeKey> {
+    key: K;
+    depth: number;
+    isLast: boolean;
+    siblingCount: number;
+}
+/** Structural metadata for one item in depth-first display order. */
+export interface TreeRow<T, K extends TreeKey> {
+    item: T;
+    key: K;
+    parentKey: K | undefined;
+    depth: number;
+    index: number;
+    siblingIndex: number;
+    siblingCount: number;
+    isLast: boolean;
+    ancestors: readonly TreeAncestor<K>[];
+}
+/** Controls the iterative hierarchy projection shared by display and interactive trees. */
+export interface FlattenTreeOptions<T, K extends TreeKey> {
+    roots: readonly T[];
+    getKey: (item: T) => K;
+    getChildren: (item: T, row: TreeRow<T, K>) => readonly T[];
+    /** False omits descendants while retaining the item itself. Defaults to true. */
+    isExpanded?: (item: T, row: TreeRow<T, K>) => boolean;
+    /** Display depth assigned to roots. Defaults to zero. */
+    rootDepth?: number;
+    /** Override the display depth inherited by direct children. */
+    getChildDepth?: (item: T, row: TreeRow<T, K>, children: readonly T[]) => number;
+    /** Stop projection after this many structural items. Omit for no traversal cap. */
+    maxItems?: number;
+}
+/** First-line and continuation prefixes for a rendered tree item. */
+export interface TreePrefix {
+    first: string;
+    continuation: string;
+}
+/** Optional symbol styling for {@link treeRowPrefix}. */
+export interface TreePrefixStyle {
+    connector?: (symbol: string) => string;
+    vertical?: (symbol: string) => string;
+}
+/** Render the conventional three-cell tree gutter for a flattened row. */
+export declare function treeRowPrefix<T, K extends TreeKey>(row: TreeRow<T, K>, theme: Theme, style?: TreePrefixStyle): TreePrefix;
+/** Context supplied while laying out one visible tree row. */
+export interface TreeViewRowContext<T, K extends TreeKey> {
+    row: TreeRow<T, K>;
+    selected: boolean;
+    rowIndex: number;
+    windowStart: number;
+    windowEnd: number;
+    windowRows: readonly TreeRow<T, K>[];
+    width: number;
+    contentWidth: number;
+    prefix: TreePrefix;
+}
+/** Row bodies may be plain lines or an existing component rendered at the remaining width. */
+export type TreeViewRowContent = string | readonly string[] | Component;
+/** Rendering, filtering, selection, expansion, and budget policy for {@link TreeView}. */
+export interface TreeViewOptions<T, K extends TreeKey> extends FlattenTreeOptions<T, K> {
+    theme: Theme;
+    renderRow: (item: T, context: TreeViewRowContext<T, K>) => TreeViewRowContent;
+    filter?: (item: T, row: TreeRow<T, K>) => boolean;
+    selectedKey?: K;
+    /** Logical rows shown around the selection. Omit to render every filtered row. */
+    maxRows?: number;
+    /** Strict physical-line budget after multiline row expansion. */
+    maxLines?: number;
+    /** Defaults to true when `selectedKey` is provided. */
+    centerSelection?: boolean;
+    /** Custom indentation/gutter geometry. */
+    renderPrefix?: (row: TreeRow<T, K>, context: Omit<TreeViewRowContext<T, K>, "prefix" | "contentWidth" | "selected">) => TreePrefix;
+    /** Content before the tree gutter, such as an interactive selection cursor. */
+    renderLeading?: (item: T, context: TreeViewRowContext<T, K>) => string;
+    /** Applied to every physical line belonging to the selected logical row. */
+    styleSelected?: (line: string) => string;
+    /** Bound physical rows to `render(width)`. Defaults to true; disable only for formatting adapters. */
+    truncateRows?: boolean;
+    /** Add a viewport scrollbar when `maxRows` hides logical rows. */
+    scrollbar?: boolean;
+    scrollbarTheme?: ScrollViewTheme;
+}
+/** Result of a tree render, including whether a row or line budget omitted content. */
+export interface TreeViewRenderResult {
+    lines: readonly string[];
+    truncated: boolean;
+    windowStart: number;
+    windowEnd: number;
+    totalRows: number;
+}
+/**
+ * Reusable keyed hierarchy component. It keeps flattened and rendered arrays
+ * stable by reference until its inputs, selection, filter, or width change.
+ */
+export declare class TreeView<T, K extends TreeKey = string> implements Component {
+    #private;
+    constructor(options: TreeViewOptions<T, K>);
+    /** Rebuild hierarchy state on the next access and discard rendered lines. */
+    invalidate(): void;
+    dispose(): void;
+    /** Replace the visible-row predicate while retaining the nearest possible selection. */
+    setFilter(filter: ((item: T, row: TreeRow<T, K>) => boolean) | undefined): void;
+    /** Every structural row before filtering. The returned array is immutable and stable until invalidated. */
+    get allRows(): readonly TreeRow<T, K>[];
+    /** Filtered rows in navigation order. The returned array is immutable and stable until invalidated. */
+    get rows(): readonly TreeRow<T, K>[];
+    /** Currently selected key, or undefined for an empty tree. */
+    get selectedKey(): K | undefined;
+    /** Currently selected item, or undefined for an empty tree. */
+    get selectedItem(): T | undefined;
+    /** Index in filtered navigation order, or -1 when empty. */
+    get selectionIndex(): number;
+    /** Select a key, walking to its nearest visible ancestor when filtered. */
+    setSelectedKey(key: K | undefined): void;
+    /** Select a filtered-row index, clamped to the current range. */
+    setSelectionIndex(index: number): void;
+    /** Move by logical rows. Wrapping is opt-in for menu-style interaction. */
+    moveSelection(delta: number, wrap?: boolean): void;
+    /** Move to the next row in `direction` satisfying a domain predicate. */
+    moveSelectionWhere(predicate: (item: T, row: TreeRow<T, K>) => boolean, direction: -1 | 1): void;
+    render(width: number): readonly string[];
+    /** Render lines plus budget/window metadata for adapters that append an ellipsis. */
+    renderWithState(width: number): TreeViewRenderResult;
+}

package/dist/types/components/wizard-step.d.ts

@@ -0,0 +1,60 @@
+import type { MouseRoutable, SgrMouseEvent } from "../mouse.js";
+import type { Component } from "../tui.js";
+/** Semantic role of a wizard step's primary interactive content. */
+export type WizardStepKind = "input" | "choice" | "confirm" | "async" | "custom";
+/** A component slot rendered by {@link WizardStep}. */
+export interface WizardStepSlot {
+    readonly component: Component;
+    /** Omit this slot when retaining it would squeeze content below `minContentLines`. */
+    readonly optional?: boolean;
+}
+/** Composition and height policy for a single wizard step. */
+export interface WizardStepOptions {
+    readonly kind: WizardStepKind;
+    readonly content: Component;
+    readonly heading?: Component;
+    readonly intro?: Component;
+    readonly preview?: WizardStepSlot;
+    readonly status?: Component;
+    readonly footer?: Component;
+    /** Blank rows inserted between non-empty slots. Defaults to one. */
+    readonly gap?: number;
+    /** Minimum useful content height used when deciding whether to show an optional preview. */
+    readonly minContentLines?: number;
+    /** Resize content-owned viewports before their next render. */
+    readonly fitContent?: (maxLines: number | undefined) => void;
+}
+/**
+ * Reusable presentation for input, choice, confirmation, and asynchronous
+ * wizard steps. Controllers retain state transitions; this component owns the
+ * ordered slots, bounded content budget, optional-preview collapse, and mouse
+ * coordinate translation into the interactive content child.
+ */
+export declare class WizardStep implements Component, MouseRoutable {
+    #private;
+    readonly debugKind = "WizardStep";
+    constructor(options: WizardStepOptions);
+    get debugChildren(): readonly Component[];
+    debugState(): Record<string, unknown>;
+    /** Update the semantic role exposed through debug state. */
+    setKind(kind: WizardStepKind): void;
+    /** Replace or remove the heading slot without rebuilding the step. */
+    setHeading(heading: Component | undefined): void;
+    /** Replace or remove the introductory slot without rebuilding the step. */
+    setIntro(intro: Component | undefined): void;
+    /** Replace or remove the preview slot without rebuilding the step. */
+    setPreview(preview: WizardStepSlot | undefined): void;
+    /** Replace the interactive content while retaining layout and height state. */
+    setContent(content: Component): void;
+    /** Replace or remove the status slot without rebuilding the step. */
+    setStatus(status: Component | undefined): void;
+    /** Replace or remove the footer slot without rebuilding the step. */
+    setFooter(footer: Component | undefined): void;
+    /** Bound the complete step, including heading, preview, status, and footer. */
+    setMaxHeight(maxHeight: number | undefined): void;
+    invalidate(): void;
+    dispose(): void;
+    handleInput(data: string): void;
+    routeMouse(event: SgrMouseEvent, line: number, col: number): void;
+    render(width: number): readonly string[];
+}

package/dist/types/hotkeys-markdown.d.ts

@@ -0,0 +1,7 @@
+import { type KeybindingsManager } from "./app-keybindings.js";
+/** Effective keybinding operations used to render the hotkey reference. */
+export interface HotkeysMarkdownBindings {
+    keybindings: Pick<KeybindingsManager, "getDisplayString" | "getKeys" | "matchesCanonical">;
+}
+/** Build the platform-aware Markdown reference for effective application hotkeys. */
+export declare function buildHotkeysMarkdown(bindings: HotkeysMarkdownBindings): string;

package/dist/types/index.d.ts

@@ -1,19 +1,35 @@
 export * from "./autocomplete.js";
+export * from "./chat/transcript-browser.js";
 export * from "./components/box.js";
 export * from "./components/cancellable-loader.js";
 export * from "./components/composer/index.js";
+export * from "./components/disclosure.js";
 export * from "./components/editor.js";
+export * from "./components/form.js";
 export * from "./components/image.js";
 export * from "./components/input.js";
+export * from "./components/key-value-list.js";
+export * from "./components/layout/geometry.js";
+export * from "./components/layout/row.js";
+export * from "./components/layout/split-pane.js";
+export * from "./components/layout/stack.js";
 export * from "./components/loader.js";
 export * from "./components/markdown.js";
+export * from "./components/menu-selection.js";
+export * from "./components/metric.js";
+export * from "./components/progress-bar.js";
 export * from "./components/scroll-view.js";
+export * from "./components/scroll-viewport.js";
+export * from "./components/section.js";
 export * from "./components/select-list.js";
 export * from "./components/settings-list.js";
 export * from "./components/spacer.js";
 export * from "./components/tab-bar.js";
+export * from "./components/table.js";
 export * from "./components/text.js";
+export * from "./components/tree-view.js";
 export * from "./components/truncated-text.js";
+export * from "./components/wizard-step.js";
 export * from "./debug-server.js";
 export * from "./deccara.js";
 export * from "./desktop-notify.js";
@@ -29,6 +45,7 @@ export * from "./stdin-buffer.js";
 export type * from "./symbols.js";
 export * from "./terminal.js";
 export * from "./terminal-capabilities.js";
+export * from "./theme/index.js";
 export * from "./ttyid.js";
 export * from "./tui.js";
 export * from "./utils.js";

package/dist/types/keybinding-matchers.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Match the coding-agent interrupt key.
+ *
+ * Interactive mode installs a keybinding manager that exposes `app.interrupt`
+ * globally, but some isolated component tests still run with only TUI
+ * keybindings registered. In that case, fall back to raw Escape matching.
+ */
+export declare function matchesAppInterrupt(data: string): boolean;
+/** Match `app.tools.expand`, falling back to Ctrl+O when the action is unbound. */
+export declare function matchesAppToolsExpand(data: string): boolean;
+/** Match the generic selector cancel keybinding. */
+export declare function matchesSelectCancel(data: string): boolean;
+/** Match the generic selector up-navigation keybinding. */
+export declare function matchesSelectUp(data: string): boolean;
+/** Match the generic selector down-navigation keybinding. */
+export declare function matchesSelectDown(data: string): boolean;
+/** Match the generic selector page-up keybinding. */
+export declare function matchesSelectPageUp(data: string): boolean;
+/** Match the generic selector page-down keybinding. */
+export declare function matchesSelectPageDown(data: string): boolean;
+/** Match the external-editor keybinding, falling back to Ctrl+G when unbound. */
+export declare function matchesAppExternalEditor(data: string): boolean;
+/**
+ * Match the "submit multi-line text input" keybinding (`app.message.followUp`).
+ *
+ * Used by forms where plain Enter inserts a newline and a modified-Enter chord
+ * submits — the main editor's follow-up handler, the agent dashboard's new-agent
+ * description, and the hook editor's hook-style mode. The keybinding defaults to
+ * `["ctrl+q", "ctrl+enter"]` so Windows Terminal (which can't deliver a distinct
+ * Ctrl+Enter event; #1903) still has a working chord without user remapping.
+ *
+ * Also recognizes modifier-tagged LF as Ctrl+Enter only when Ctrl+Enter is an
+ * effective follow-up binding.
+ */
+export declare function matchesAppFollowUp(data: string): boolean;

package/dist/types/keys.d.ts

@@ -42,9 +42,9 @@ export declare function setKittyProtocolActive(active: boolean): void;
 export declare function isKittyProtocolActive(): boolean;
 type Letter = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z";
 type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
-type SymbolKey = "`" | "-" | "=" | "[" | "]" | "\\" | ";" | "'" | "," | "." | "/" | "!" | "@" | "#" | "$" | "%" | "^" | "&" | "*" | "(" | ")" | "_" | "+" | "|" | "~" | "{" | "}" | ":" | "<" | ">" | "?";
+type KeySymbol = "`" | "-" | "=" | "[" | "]" | "\\" | ";" | "'" | "," | "." | "/" | "!" | "@" | "#" | "$" | "%" | "^" | "&" | "*" | "(" | ")" | "_" | "+" | "|" | "~" | "{" | "}" | ":" | "<" | ">" | "?";
 type SpecialKey = "escape" | "esc" | "enter" | "return" | "tab" | "space" | "backspace" | "delete" | "insert" | "clear" | "home" | "end" | "pageUp" | "pageDown" | "up" | "down" | "left" | "right" | "f1" | "f2" | "f3" | "f4" | "f5" | "f6" | "f7" | "f8" | "f9" | "f10" | "f11" | "f12";
-type BaseKey = Letter | Digit | SymbolKey | SpecialKey;
+type BaseKey = Letter | Digit | KeySymbol | SpecialKey;
 type ModifierName = "ctrl" | "shift" | "alt" | "super";
 type ModifiedKeyId<Key extends string, RemainingModifiers extends ModifierName = ModifierName> = {
     [M in RemainingModifiers]: `${M}+${Key}` | `${M}+${ModifiedKeyId<Key, Exclude<RemainingModifiers, M>>}`;

package/dist/types/lang-from-path.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Language id for syntax highlighting and UI (icons, read tool), or undefined if unknown.
+ */
+export declare function getLanguageFromPath(filePath: string): string | undefined;
+export declare function isMarkdownPath(filePath: string): boolean;
+/**
+ * LSP language identifier; falls back to `plaintext`.
+ */
+export declare function detectLanguageId(filePath: string): string;