@lingxi-ai-cn/dsh-tui-runtime 0.1.0-rc.8

package/lib/invariant.js

@@ -0,0 +1,9 @@
+//#region lib/types/invariant.js
+/** Package-owned invariant companion for `@lingxi-ai-cn/dsh-tui-runtime`. */
+const PACKAGE_NAME = "@lingxi-ai-cn/dsh-tui-runtime";
+const name = "tui-invariant";
+const inject = ["invariants"];
+const install = () => {};
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/agent-view.d.ts

@@ -0,0 +1,40 @@
+/** Process-local single-view Agent navigation state for the native TUI. */
+import type { SessionIdType as SessionId } from './host.ts';
+/** Exact Agent transcript and input target rendered by the native TUI. */
+export interface TuiAgentViewDescriptor {
+    /** Whether the view is the owned root or one borrowed local child. */
+    readonly kind: 'root' | 'child';
+    /** Session and Agent identity whose durable transcript is rendered. */
+    readonly id: SessionId;
+    /** Concise source-owned label shown in the header. */
+    readonly label: string;
+    /** Durable direct parent required to authorize child input. */
+    readonly parentSession?: SessionId | undefined;
+    /** Whether the current view accepts composer input. */
+    readonly acceptsInput: boolean;
+    /** Exact reason input is unavailable. */
+    readonly readOnlyReason?: string | undefined;
+}
+/**
+ * Process-local state slots keyed by Agent Session id.
+ * @typeParam T - complete disposable UI state owned by one transcript view.
+ */
+export declare class TuiAgentViewStateCache<T> {
+    private readonly states;
+    /**
+     * Save the complete local state of one view.
+     * @param id - view Session id.
+     * @param state - disposable state to restore on the next visit.
+     */
+    set(id: SessionId, state: T): void;
+    /**
+     * Restore one view or create its initial local state.
+     * @param id - view Session id.
+     * @param create - initializer used only on the first visit.
+     * @returns the cached or newly initialized state.
+     */
+    get(id: SessionId, create: () => T): T;
+    /** Drop every saved view after the owning TUI lifecycle ends. */
+    clear(): void;
+}
+//# sourceMappingURL=agent-view.d.ts.map

package/lib/types/app.d.ts

@@ -0,0 +1,121 @@
+/** Ink component tree for transcript, interactions, composer, and status. */
+import React from 'react';
+import type { Agent, CommandDescriptor, ContextPressureProjection, FsPathCompletionResult, ModelSelection, PermissionSelect } from './host.ts';
+import { AgentStatusStore, InteractionStore, SessionEventStore, ValueStore } from './store.ts';
+import type { InputCursorTarget } from './terminal-session.ts';
+import { type ComposerLayout } from './composer.ts';
+import { type TuiInteractionDescriptor } from './keybindings.ts';
+import { type TuiFooterItemId } from './footer.ts';
+import { type TuiResumeCandidate, type TuiResumeDialogSnapshot } from './resume.ts';
+import type { TuiFreshSessionDialogSnapshot } from './session-lifecycle.ts';
+import type { TuiSessionExportDialogSnapshot } from './session-export.ts';
+import type { TuiRewindCandidate, TuiRewindDialogSnapshot } from './rewind.ts';
+import type { TuiWorkItemView, TuiWorkSnapshot } from './work.ts';
+import { type TuiPluginHubDetailLine, type TuiPluginHubDialogSnapshot } from './plugin-hub.ts';
+import type { PluginId } from '@lingxi-ai-cn/dsh-plugin-hub';
+import { type TuiAgentViewDescriptor } from './agent-view.ts';
+import { type TuiTerminalInputEvent } from './terminal-input.ts';
+import { type TuiTheme } from './theme.tsx';
+import { type TuiStartupLogoVariant } from './startup-logo.tsx';
+export interface TuiAppProps {
+    agent: Agent;
+    view: TuiAgentViewDescriptor;
+    events: SessionEventStore;
+    status: AgentStatusStore;
+    interactions: InteractionStore;
+    externalNotice: ValueStore<string>;
+    modelSelection: ValueStore<ModelSelection | undefined>;
+    helpOpen: ValueStore<boolean>;
+    permissions: ValueStore<PermissionSelect | undefined>;
+    contextPressure: ValueStore<ContextPressureProjection | undefined>;
+    resumeDialog: ValueStore<TuiResumeDialogSnapshot | undefined>;
+    freshSessionDialog: ValueStore<TuiFreshSessionDialogSnapshot | undefined>;
+    rewindDialog: ValueStore<TuiRewindDialogSnapshot | undefined>;
+    sessionExportDialog: ValueStore<TuiSessionExportDialogSnapshot | undefined>;
+    pluginHubDialog: ValueStore<TuiPluginHubDialogSnapshot | undefined>;
+    work: ValueStore<TuiWorkSnapshot>;
+    maxResumeOptions: number;
+    commands: readonly CommandDescriptor[];
+    interactionRegistry: readonly TuiInteractionDescriptor[];
+    completePaths(query: string, signal: AbortSignal): Promise<FsPathCompletionResult>;
+    onInputCursor(target: InputCursorTarget | undefined): void;
+    onSubmit(text: string): Promise<void>;
+    /** Copy non-secret UI text through the negotiated terminal clipboard path. */
+    onCopy(text: string): {
+        readonly ok: boolean;
+        readonly message?: string;
+    };
+    onActivateFooter(itemId: TuiFooterItemId): Promise<void>;
+    onResume(candidate: TuiResumeCandidate): Promise<void>;
+    onCloseResume(): void;
+    onConfirmFreshSession(): Promise<void>;
+    onCloseFreshSession(): void;
+    onRewind(candidate: TuiRewindCandidate): Promise<void>;
+    onCloseRewind(): void;
+    onExportSession(directory: string, includeDescendants: boolean): Promise<void>;
+    onCloseSessionExport(): void;
+    onClosePluginHub(): void;
+    onPluginHubToggleView(): Promise<void>;
+    onPluginHubSearch(query: string): Promise<void>;
+    onPluginHubDetail(pluginId: PluginId): Promise<void>;
+    onPluginHubInstall(): Promise<void>;
+    onPluginHubRemove(packageName: string): Promise<void>;
+    onPluginHubConfirm(): Promise<void>;
+    onPluginHubRefresh(): Promise<void>;
+    onPluginHubLoadMore(): Promise<void>;
+    onPluginHubSort(): Promise<void>;
+    onPluginHubCategory(): Promise<void>;
+    onMounted: () => void;
+    onOpenHelp(): void;
+    onCloseHelp(): void;
+    onCancelWork(item: TuiWorkItemView): Promise<void>;
+    onOpenWork(item: TuiWorkItemView): Promise<void>;
+    onReturnRoot(): void;
+    onCancel(): void;
+    onExit(): void;
+    /** Input events buffered while terminal capabilities were negotiated. */
+    initialTerminalInput?: readonly TuiTerminalInputEvent[] | undefined;
+}
+/**
+ * Resolve readable semantic color for one Plugin Hub detail or confirmation line.
+ * @param theme - active terminal theme.
+ * @param line - projected Plugin Hub line.
+ * @returns text style without ANSI dim, which would compound muted palette colors.
+ */
+export declare function tuiPluginHubDetailTextStyle(theme: TuiTheme, line: TuiPluginHubDetailLine): Readonly<{
+    color?: string;
+}>;
+/**
+ * Resolve the real terminal cursor cell used by CJK IME preedit rendering.
+ * @param stdout - terminal dimensions used by the active Ink frame.
+ * @param prefix - first-line composer label rendered before the editable text.
+ * @param layout - visible Unicode-aware composer layout.
+ * @param placement - optional centered-composer origin; omission selects the bottom workspace.
+ * @returns one-based terminal row and column for the insertion point.
+ */
+export declare function inputCursorTarget(stdout: Pick<NodeJS.WriteStream, 'rows' | 'columns'>, prefix: string, layout: ComposerLayout, placement?: {
+    readonly firstInputRow: number;
+    readonly leftColumn: number;
+}): InputCursorTarget;
+/**
+ * Resolve the bounded startup composer frame and its first editable terminal row.
+ * @param stdout - terminal dimensions used by the active Ink frame.
+ * @param composerRows - mounted editor rows inside the bordered composer.
+ * @param supplementalRows - suggestion rows mounted between the brand and composer.
+ * @returns centered width, zero-based horizontal origin, one-based first input row, and selected mark.
+ */
+export declare function tuiStartupComposerFrame(stdout: Pick<NodeJS.WriteStream, 'rows' | 'columns'>, composerRows: number, supplementalRows?: number): {
+    readonly width: number;
+    readonly leftColumn: number;
+    readonly firstInputRow: number;
+    readonly logo: TuiStartupLogoVariant;
+};
+/**
+ * Select one stable-width frame for the running-Agent activity indicator.
+ * @param tick - monotonically increasing process-local animation tick.
+ * @returns a three-cell ASCII frame.
+ */
+export declare function tuiWorkingFrame(tick: number): string;
+/** Render the native single-view Agent TUI. */
+export declare function TuiApp(props: TuiAppProps): React.ReactElement;
+//# sourceMappingURL=app.d.ts.map

package/lib/types/composer.d.ts

@@ -0,0 +1,188 @@
+/** Pure Unicode-aware editor state and layout for the native TUI composer. */
+/** Process-local large-paste payload represented by one bounded editor placeholder. */
+export interface TuiComposerPasteReference {
+    /** Stable placeholder embedded in this draft's visible text. */
+    readonly placeholder: string;
+    /** Terminal-safe original text expanded only when the prompt is submitted. */
+    readonly text: string;
+    /** UTF-8 payload size used in the bounded placeholder. */
+    readonly bytes: number;
+    /** Physical source-line count used in the bounded placeholder. */
+    readonly lines: number;
+}
+/** Text and insertion point restored by one composer undo or redo action. */
+export interface TuiComposerSnapshot {
+    /** Complete editor text. */
+    text: string;
+    /** UTF-16 insertion offset at a grapheme boundary. */
+    cursor: number;
+    /** Large-paste payloads still referenced by the visible text. */
+    references?: readonly TuiComposerPasteReference[] | undefined;
+}
+/** Edit category used to define composer undo units. */
+export type TuiComposerEditKind = 'typing' | 'delete-backward' | 'delete-forward' | 'delete-word-backward' | 'delete-word-forward' | 'paste' | 'multiline' | 'suggestion' | 'history';
+/** Bounded process-local undo and redo stacks for one active draft. */
+export interface TuiComposerEditHistory {
+    /** Oldest-first snapshots available to undo. */
+    past: readonly TuiComposerSnapshot[];
+    /** Oldest-first snapshots available to redo, with the next value last. */
+    future: readonly TuiComposerSnapshot[];
+    /** Most recent mergeable edit and its timestamp. */
+    coalescing?: {
+        kind: TuiComposerEditKind;
+        at: number;
+    } | undefined;
+}
+/** Process-local editor value, insertion point, and history traversal state. */
+export interface ComposerState {
+    /** Complete draft text. */
+    text: string;
+    /** UTF-16 insertion offset at a grapheme boundary. */
+    cursor: number;
+    /** Newest-first submitted-history offset, or `-1` outside history traversal. */
+    historyIndex: number;
+    /** Draft retained while submitted history is being inspected. */
+    historyScratch?: TuiComposerDraft | undefined;
+    /** Large-paste payloads referenced by bounded placeholders in {@link text}. */
+    references?: readonly TuiComposerPasteReference[] | undefined;
+    /** Process-local bounded edit history, created after the first text change. */
+    editHistory?: TuiComposerEditHistory | undefined;
+}
+/** Process-local draft value retained outside the active editor. */
+export interface TuiComposerDraft {
+    /** Complete retained text. */
+    text: string;
+    /** UTF-16 insertion offset at a grapheme boundary. */
+    cursor: number;
+    /** Edit history retained with this draft while it is stashed or searched. */
+    editHistory?: TuiComposerEditHistory | undefined;
+    /** Large-paste payloads retained with this process-local draft. */
+    references?: readonly TuiComposerPasteReference[] | undefined;
+}
+/** Result of one stash, restore, or swap action. */
+export interface TuiComposerStashTransition {
+    /** Active editor after the action. */
+    composer: ComposerState;
+    /** Draft retained outside the editor, absent after restoration. */
+    stash?: TuiComposerDraft | undefined;
+    /** Observable action taken for status rendering. */
+    action: 'unchanged' | 'stashed' | 'restored' | 'swapped';
+}
+/** Visible composer rows and insertion cell relative to the editor content. */
+export interface ComposerLayout {
+    /** Bounded physical rows mounted by Ink. */
+    lines: readonly string[];
+    /** Zero-based visible row containing the insertion point. */
+    cursorRow: number;
+    /** Zero-based display cell within `cursorRow`. */
+    cursorColumn: number;
+}
+/**
+ * Create a composer editor at the end of an optional initial value.
+ * @param text - initial editor text.
+ * @returns initialized editor state.
+ */
+export declare function createComposerState(text?: string): ComposerState;
+/**
+ * Stash a non-empty draft, restore into an empty editor, or swap two non-empty drafts.
+ * @param composer - active editor value and cursor.
+ * @param stash - currently retained process-local draft.
+ * @returns the new editor, retained draft, and action name.
+ */
+export declare function toggleTuiComposerStash(composer: ComposerState, stash: TuiComposerDraft | undefined): TuiComposerStashTransition;
+/**
+ * Replace the complete editor value as one explicit undo unit.
+ * @param state - current editor state.
+ * @param text - complete replacement text.
+ * @param cursor - insertion point in the replacement text.
+ * @param kind - edit category controlling coalescing.
+ * @param now - edit timestamp used for bounded typing and deletion coalescing.
+ * @param references - paste references retained by placeholders in the replacement text.
+ * @returns updated editor with redo cleared.
+ */
+export declare function replaceComposerText(state: ComposerState, text: string, cursor: number, kind: TuiComposerEditKind, now?: number, references?: readonly TuiComposerPasteReference[] | undefined): ComposerState;
+/**
+ * Restore the preceding composer snapshot.
+ * @param state - current editor state.
+ * @returns preceding value, or the unchanged state when no undo is available.
+ */
+export declare function undoComposerEdit(state: ComposerState): ComposerState;
+/**
+ * Restore the next composer snapshot after an undo.
+ * @param state - current editor state.
+ * @returns next value, or the unchanged state when no redo is available.
+ */
+export declare function redoComposerEdit(state: ComposerState): ComposerState;
+/**
+ * Insert terminal-safe text at the active insertion point.
+ * @param state - current editor state.
+ * @param input - typed or pasted text.
+ * @param now - edit timestamp used for coalescing.
+ * @returns updated editor state.
+ */
+export declare function insertComposerText(state: ComposerState, input: string, now?: number): ComposerState;
+/**
+ * Decide whether one bracketed paste should be represented by a bounded placeholder.
+ * @param input - committed terminal paste text.
+ * @returns true when its byte or line count exceeds the direct-editor threshold.
+ */
+export declare function isLargeComposerPaste(input: string): boolean;
+/**
+ * Insert one large terminal paste as an undoable process-local reference.
+ * @param state - current editor state.
+ * @param input - committed bracketed-paste payload.
+ * @param now - edit timestamp retained with the independent paste unit.
+ * @returns editor state containing one bounded visible placeholder.
+ */
+export declare function insertComposerPasteReference(state: ComposerState, input: string, now?: number): ComposerState;
+/**
+ * Expand process-local paste references into the model-visible prompt.
+ * @param state - complete editor state at submission.
+ * @returns terminal-safe prompt text with every intact placeholder expanded.
+ */
+export declare function materializeComposerText(state: ComposerState): string;
+/**
+ * Detach one draft for stash, submitted history, or view-local retention.
+ * @param state - active editor state.
+ * @returns process-local draft preserving cursor, edits, and paste references.
+ */
+export declare function tuiComposerDraft(state: ComposerState): TuiComposerDraft;
+/**
+ * Restore a detached process-local draft as an active editor.
+ * @param draft - retained draft value.
+ * @returns editor state preserving paste references and edit history.
+ */
+export declare function restoreTuiComposerDraft(draft: TuiComposerDraft): ComposerState;
+/**
+ * Move the insertion point without changing text.
+ * @param state - current editor state.
+ * @param movement - grapheme, word, line, or buffer movement.
+ * @returns state with the updated insertion point.
+ */
+export declare function moveComposerCursor(state: ComposerState, movement: 'left' | 'right' | 'home' | 'end' | 'buffer-home' | 'buffer-end' | 'word-left' | 'word-right'): ComposerState;
+/**
+ * Delete one grapheme or one adjacent word around the insertion point.
+ * @param state - current editor state.
+ * @param deletion - deletion direction and unit.
+ * @param now - edit timestamp used for coalescing.
+ * @returns updated editor state.
+ */
+export declare function deleteComposerText(state: ComposerState, deletion: 'backward' | 'forward' | 'word-backward' | 'word-forward', now?: number): ComposerState;
+/**
+ * Traverse submitted history while preserving the unsent draft.
+ * @param state - current editor state.
+ * @param history - oldest-first submitted values.
+ * @param direction - history traversal direction.
+ * @param now - edit timestamp retained with the independent history unit.
+ * @returns recalled value or restored scratch draft.
+ */
+export declare function traverseComposerHistory(state: ComposerState, history: readonly (string | TuiComposerDraft)[], direction: 'older' | 'newer', now?: number): ComposerState;
+/**
+ * Wrap and vertically window the draft while retaining the insertion row.
+ * @param state - current editor state.
+ * @param width - available terminal display cells.
+ * @param maxRows - maximum visible physical rows.
+ * @returns bounded visible lines and insertion geometry.
+ */
+export declare function layoutComposer(state: ComposerState, width: number, maxRows?: number): ComposerLayout;
+//# sourceMappingURL=composer.d.ts.map

package/lib/types/detail.d.ts

@@ -0,0 +1,24 @@
+/** Cached logical and physical rows for one focused transcript detail. */
+import type { TranscriptNode, TranscriptToolNode } from './transcript.ts';
+/**
+ * Project complete unwrapped transcript detail for clipboard transfer.
+ * @param node - current semantic parent block.
+ * @param child - focused retained tool child, when applicable.
+ * @returns terminal-safe logical rows joined without viewport-introduced wrapping.
+ */
+export declare function tuiTranscriptDetailText(node: TranscriptNode, child?: TranscriptToolNode): string;
+/** Process-local detail projection keyed by stable block identity and current node reference. */
+export declare class TuiTranscriptDetailCache {
+    private readonly entries;
+    /** Drop all cached logical and width-dependent physical rows. */
+    reset(): void;
+    /**
+     * Resolve wrapped physical rows for one transcript block or retained child.
+     * @param node - current semantic parent block.
+     * @param width - available terminal cells.
+     * @param child - focused retained tool child, when applicable.
+     * @returns immutable physical detail rows.
+     */
+    lines(node: TranscriptNode, width: number, child?: TranscriptToolNode): readonly string[];
+}
+//# sourceMappingURL=detail.d.ts.map

package/lib/types/footer.d.ts

@@ -0,0 +1,85 @@
+/** Pure actionable-footer descriptors and width-bounded projections. */
+import type { ContextPressureProjection, ModelSelection, PermissionSelect } from './host.ts';
+import type { TuiWorkSummary } from './work.ts';
+/** Stable action targets exposed by the native TUI footer. */
+export type TuiFooterItemId = 'model' | 'permission' | 'work' | 'context' | 'workspace' | 'transcript';
+/** One actionable status item derived from authoritative runtime state. */
+export interface TuiFooterItemDescriptor {
+    /** Stable package-owned item identity. */
+    readonly id: TuiFooterItemId;
+    /** Short label retained when the footer is narrow. */
+    readonly label: string;
+    /** Compact current value shown in the status row. */
+    readonly value: string;
+    /** Enter behavior for this item. */
+    readonly action: 'models' | 'permissions' | 'work' | 'detail';
+    /** Complete read-only detail shown for local status items. */
+    readonly detailLines: readonly string[];
+}
+/** Current viewport position needed by the transcript footer item. */
+export interface TuiFooterTranscriptPosition {
+    /** Zero-based first mounted transcript node, or -1 when empty. */
+    readonly startIndex: number;
+    /** Zero-based last mounted transcript node, or -1 when empty. */
+    readonly endIndex: number;
+    /** Complete projected transcript node count. */
+    readonly total: number;
+    /** Whether content exists above the mounted page. */
+    readonly hasOlder: boolean;
+    /** Whether content exists below the mounted page. */
+    readonly hasNewer: boolean;
+}
+/** Authoritative values from which the current footer is projected. */
+export interface TuiFooterSources {
+    /** Selection used by the active request or the next request. */
+    readonly modelSelection?: ModelSelection | undefined;
+    /** Whether the selection describes a captured running request. */
+    readonly modelSelectionKind: 'running request' | 'next request';
+    /** Effective permission select, absent when the capability is not composed. */
+    readonly permissions?: PermissionSelect | undefined;
+    /** Provider-anchored approximate context occupancy. */
+    readonly context?: ContextPressureProjection | undefined;
+    /** Authoritative background-work counters. */
+    readonly work?: TuiWorkSummary | undefined;
+    /** Full Session workspace path. */
+    readonly workspace?: string | undefined;
+    /** Current mounted transcript page. */
+    readonly transcript: TuiFooterTranscriptPosition;
+}
+/**
+ * Project current authoritative state into stable actionable footer items.
+ * @param sources - model, permission, context, workspace, and viewport facts.
+ * @returns immutable items in navigation order; unavailable context is omitted.
+ */
+export declare function tuiFooterItems(sources: TuiFooterSources): readonly TuiFooterItemDescriptor[];
+/**
+ * Hide lower-priority items at narrow widths while preserving model and permission.
+ * @param items - complete current footer item list.
+ * @param columns - physical cells available to the footer row.
+ * @returns the navigable items mounted at this width.
+ */
+export declare function visibleTuiFooterItems(items: readonly TuiFooterItemDescriptor[], columns: number): readonly TuiFooterItemDescriptor[];
+/**
+ * Move a footer selection without depending on React state.
+ * @param items - current visible footer items.
+ * @param selected - current item id, possibly stale after capability changes.
+ * @param direction - previous or next navigation.
+ * @returns the selected id after cyclic movement, or undefined for no items.
+ */
+export declare function moveTuiFooterSelection(items: readonly TuiFooterItemDescriptor[], selected: TuiFooterItemId | undefined, direction: 'previous' | 'next'): TuiFooterItemId | undefined;
+/**
+ * Format every mounted item into one physical row.
+ * @param items - visible footer items.
+ * @param columns - complete row budget in terminal cells.
+ * @returns one row no wider than the supplied budget.
+ */
+export declare function tuiFooterStatusLine(items: readonly TuiFooterItemDescriptor[], columns: number): string;
+/**
+ * Format one selected item with its navigation position.
+ * @param items - visible footer items.
+ * @param selected - current item id, possibly stale after a width change.
+ * @param columns - complete row budget in terminal cells.
+ * @returns one selected-item row no wider than the supplied budget.
+ */
+export declare function tuiSelectedFooterLine(items: readonly TuiFooterItemDescriptor[], selected: TuiFooterItemId | undefined, columns: number): string;
+//# sourceMappingURL=footer.d.ts.map

package/lib/types/history-search.d.ts

@@ -0,0 +1,58 @@
+/** Pure process-local search state over submitted TUI prompt history. */
+import { type ComposerState, type TuiComposerDraft } from './composer.ts';
+/** Active reverse-history query and the draft restored when search is cancelled. */
+export interface TuiHistorySearchState {
+    /** Text matched case-insensitively against submitted prompts. */
+    query: string;
+    /** Zero-based position in newest-first matching prompts, or `-1` with no match. */
+    matchIndex: number;
+    /** Exact editor value retained while search owns keyboard input. */
+    originalDraft: TuiComposerDraft;
+}
+/** Current match and count derived from one history-search state. */
+export interface TuiHistorySearchResult {
+    /** Selected submitted prompt, absent when the query has no match. */
+    match?: string | undefined;
+    /** Exact submitted draft, including process-local paste references. */
+    draft?: TuiComposerDraft | undefined;
+    /** One-based selected position, or zero when no prompt matches. */
+    position: number;
+    /** Number of unique matching submitted prompts. */
+    count: number;
+}
+/**
+ * Start reverse search using the current draft as both the query and cancel target.
+ * @param composer - editor state before search takes keyboard ownership.
+ * @param history - oldest-first submitted prompts.
+ * @returns initialized search state selecting the newest match when one exists.
+ */
+export declare function startTuiHistorySearch(composer: ComposerState, history: readonly (string | TuiComposerDraft)[]): TuiHistorySearchState;
+/**
+ * Restore the exact editor value retained when reverse search started.
+ * @param state - active history-search state.
+ * @returns editor state with the original text and insertion point.
+ */
+export declare function cancelTuiHistorySearch(state: TuiHistorySearchState): ComposerState;
+/**
+ * Replace the active query and restart matching from the newest prompt.
+ * @param state - active history-search state.
+ * @param query - complete replacement query.
+ * @param history - oldest-first submitted prompts.
+ * @returns search state positioned at the newest match.
+ */
+export declare function updateTuiHistorySearchQuery(state: TuiHistorySearchState, query: string, history: readonly (string | TuiComposerDraft)[]): TuiHistorySearchState;
+/**
+ * Select the next older match without wrapping to the newest prompt.
+ * @param state - active history-search state.
+ * @param history - oldest-first submitted prompts.
+ * @returns search state with a bounded selected index.
+ */
+export declare function nextTuiHistorySearchMatch(state: TuiHistorySearchState, history: readonly (string | TuiComposerDraft)[]): TuiHistorySearchState;
+/**
+ * Resolve the selected prompt and display position from current submitted history.
+ * @param state - active history-search state.
+ * @param history - oldest-first submitted prompts.
+ * @returns selected match and newest-first position metadata.
+ */
+export declare function tuiHistorySearchResult(state: TuiHistorySearchState, history: readonly (string | TuiComposerDraft)[]): TuiHistorySearchResult;
+//# sourceMappingURL=history-search.d.ts.map