@linxiraos/pi-tui 1.1.0 → 1.1.2

package/dist/types/autocomplete.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Locate the slash that opens a slash command on the line, allowing leading
+ * whitespace. Returns the index of the `/` or `null` when the line is not a
+ * slash command. Aligns with `trimStart` semantics so the editor and provider
+ * agree on which prefixes count.
+ */
+export declare function findLeadingSlashCommandStart(text: string): number | null;
+export declare function findTrailingSlashCommandStart(text: string): number | null;
+export interface AutocompleteItem {
+    value: string;
+    label: string;
+    description?: string;
+    /** Optional type-indicator glyph rendered in an aligned column before the label */
+    icon?: string;
+    /** Dim hint text shown inline after cursor when this item is selected */
+    hint?: string;
+}
+type Awaitable<T> = T | Promise<T>;
+export interface SlashCommand {
+    name: string;
+    aliases?: string[];
+    description?: string;
+    /** Optional type-indicator glyph shown before the command name in autocomplete */
+    icon?: string;
+    argumentHint?: string;
+    /** Whether the command consumes argument text after the command name. False means the full input stays normal prompt text once args are present. */
+    allowArgs?: boolean;
+    /** Dynamic display-only description for slash-command autocomplete. Must be synchronous and side-effect free. */
+    getAutocompleteDescription?: () => string | undefined;
+    getArgumentCompletions?(argumentPrefix: string): Awaitable<AutocompleteItem[] | null>;
+    /** Return inline hint text for the current argument state (shown as dim ghost text after cursor) */
+    getInlineHint?(argumentText: string): string | null;
+}
+export interface AutocompleteProvider {
+    /** Get autocomplete suggestions for current text/cursor position. Expensive providers SHOULD stop when `signal` aborts. */
+    getSuggestions(lines: string[], cursorLine: number, cursorCol: number, signal?: AbortSignal): Promise<{
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null>;
+    /** Apply the selected item and return new text + cursor position */
+    applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
+        lines: string[];
+        cursorLine: number;
+        cursorCol: number;
+        onApplied?: () => void;
+    };
+    /** Get inline hint text to show as dim ghost text after the cursor */
+    getInlineHint?(lines: string[], cursorLine: number, cursorCol: number): string | null;
+    /** Synchronously try to complete a slash command at the start of a line (no async I/O). */
+    /** Returns matched items and the full prefix, or null if not applicable. */
+    trySyncSlashCompletion?(textBeforeCursor: string): {
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null;
+    /**
+     * Synchronously try to expand text immediately before the cursor (no async I/O).
+     * Called after every single-character insert. Implementations MUST cheaply
+     * early-return when the trailing context cannot trigger them.
+     * Returns the number of characters to delete immediately before the cursor
+     * and the literal string to insert in their place, or null to leave the
+     * buffer untouched.
+     */
+    trySyncInlineReplace?(textBeforeCursor: string): {
+        replaceLen: number;
+        insert: string;
+    } | null;
+    /**
+     * Force file-path completion (called on Tab). Returns matched items plus the
+     * full prefix, or null when no path token sits before the cursor. Present on
+     * file-aware providers; absent on slash-only ones.
+     * Expensive providers SHOULD stop when `signal` aborts.
+     */
+    getForceFileSuggestions?(lines: string[], cursorLine: number, cursorCol: number, signal?: AbortSignal): Promise<{
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null>;
+    /** Whether a Tab press should attempt file completion at the cursor. */
+    shouldTriggerFileCompletion?(lines: string[], cursorLine: number, cursorCol: number): boolean;
+}
+type CommandEntry = SlashCommand | AutocompleteItem;
+/** Optional behaviors for {@link CombinedAutocompleteProvider}. */
+export interface CombinedAutocompleteOptions {
+    /** Usage count per command name; higher counts rank earlier among equal text-match scores. */
+    commandUsage?: (name: string) => number;
+}
+export declare function scoreCommandTextMatch(lowerPrefix: string, lowerTarget: string): number;
+export declare const SKILL_NAMESPACE = "skill:";
+/**
+ * Whether a mid-prompt slash token (`prose … /tok`) is skill-shaped enough to
+ * surface `name` in the skill popup. Deliberately stricter than submitted
+ * slash-command matching: a stray `/word` in running prose must not keep the
+ * popup alive through fuzzy name/description hits, so a token only matches as
+ * - a prefix of the `skill:` namespace (incl. the bare `/` entry point),
+ * - an explicit `skill:…` query (full fuzzy name/description search), or
+ * - a prefix of the skill's bare name (`/hum` → `skill:humanizer`).
+ * Anything else yields no items, letting the caller fall through to path
+ * completion or close the popup. Shared with the editor's accept-time
+ * staleness guard so Tab/Enter never accepts a skill the refreshed popup
+ * would no longer show.
+ */
+export declare function midPromptSkillTokenMatches(lowerToken: string, name: string, description?: string): boolean;
+export declare class CombinedAutocompleteProvider implements AutocompleteProvider {
+    #private;
+    constructor(commands?: CommandEntry[], basePath?: string, options?: CombinedAutocompleteOptions);
+    getSuggestions(lines: string[], cursorLine: number, cursorCol: number, signal?: AbortSignal): Promise<{
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null>;
+    applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
+        lines: string[];
+        cursorLine: number;
+        cursorCol: number;
+    };
+    invalidateDirCache(dir?: string): void;
+    getForceFileSuggestions(lines: string[], cursorLine: number, cursorCol: number, signal?: AbortSignal): Promise<{
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null>;
+    shouldTriggerFileCompletion(lines: string[], cursorLine: number, cursorCol: number): boolean;
+    /** Get inline hint text for slash commands with subcommand hints */
+    getInlineHint(lines: string[], cursorLine: number, cursorCol: number): string | null;
+    trySyncSlashCompletion(textBeforeCursor: string): {
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null;
+}
+export {};

package/dist/types/bracketed-paste.d.ts

@@ -0,0 +1,51 @@
+export type PasteResult = {
+    handled: false;
+} | {
+    handled: true;
+    pasteContent?: string;
+    remaining: string;
+};
+/**
+ * Decode tmux's re-encoded control bytes (both `extended-keys-format` variants) inside a
+ * bracketed-paste payload back to their literal byte (e.g. Ctrl+J → "\n"). Leaves the rest of
+ * the text untouched. Call before any control-character stripping so newlines/tabs survive
+ * instead of leaking the printable escape tail into the buffer.
+ */
+export declare function decodeReencodedPasteControls(text: string): string;
+/**
+ * Options for {@link BracketedPasteHandler}.
+ */
+export type BracketedPasteHandlerOptions = {
+    /**
+     * Byte cap for buffered paste content (default: 64 MiB). When exceeded,
+     * paste mode is aborted and the accumulated content is delivered as
+     * `pasteContent` on the same `process()` call so a lost/corrupted end
+     * marker cannot consume unbounded memory. Mirrors `StdinBuffer#abortPaste`
+     * — defense in depth for callers that bypass `StdinBuffer` (issue #4073
+     * case B). The normal `ProcessTerminal` path re-wraps `StdinBuffer`'s
+     * bounded paste with both markers, so this cap only fires on alternate
+     * callers.
+     */
+    byteLimit?: number;
+};
+/**
+ * Handles bracketed paste mode buffering for terminal input components.
+ *
+ * Bracketed paste mode wraps pasted content between start (\x1b[200~) and
+ * end (\x1b[201~) markers, which may arrive split across multiple chunks.
+ * This class buffers incoming data and assembles complete paste payloads.
+ */
+export declare class BracketedPasteHandler {
+    #private;
+    constructor(options?: BracketedPasteHandlerOptions);
+    /**
+     * Process incoming terminal data for bracketed paste sequences.
+     *
+     * @returns `{ handled: false }` if the data contains no paste sequence and
+     *          should be processed normally. `{ handled: true }` if the data was
+     *          consumed by paste buffering — `pasteContent` is set when a complete
+     *          paste has been assembled (or the byte cap has aborted a runaway
+     *          buffer); omitted when still buffering.
+     */
+    process(data: string): PasteResult;
+}

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

@@ -0,0 +1,31 @@
+import type { Component } from "../tui.js";
+/** Box-drawing glyphs plus an optional colorizer for an outline drawn around a {@link Box}. */
+export interface BoxBorder {
+    chars: {
+        topLeft: string;
+        topRight: string;
+        bottomLeft: string;
+        bottomRight: string;
+        horizontal: string;
+        vertical: string;
+    };
+    color?: (text: string) => string;
+}
+/**
+ * Box component - a container that applies padding and background to all children
+ */
+export declare class Box implements Component {
+    #private;
+    children: Component[];
+    setIgnoreTight(ignore: boolean): this;
+    constructor(paddingX?: number, paddingY?: number, bgFn?: (text: string) => string, border?: BoxBorder);
+    addChild(component: Component): void;
+    removeChild(component: Component): void;
+    clear(): void;
+    setPaddingX(paddingX: number): void;
+    setPaddingY(paddingY: number): void;
+    setBgFn(bgFn?: (text: string) => string): void;
+    setBorder(border?: BoxBorder): void;
+    invalidate(): void;
+    render(width: number): readonly string[];
+}

package/dist/types/components/cancellable-loader.d.ts

@@ -0,0 +1,21 @@
+import { Loader } from "./loader.js";
+/**
+ * Loader that can be cancelled with Escape.
+ * Extends Loader with an AbortSignal for cancelling async operations.
+ *
+ * @example
+ * const loader = new CancellableLoader(tui, cyan, dim, "Working...");
+ * loader.onAbort = () => done(null);
+ * doWork(loader.signal).then(done);
+ */
+export declare class CancellableLoader extends Loader {
+    #private;
+    /** Called when user presses Escape */
+    onAbort?: () => void;
+    /** AbortSignal that is aborted when user presses Escape */
+    get signal(): AbortSignal;
+    /** Whether the loader was aborted */
+    get aborted(): boolean;
+    handleInput(data: string): void;
+    dispose(): void;
+}

package/dist/types/components/composer/borderless.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Chrome-free composer: a bare `❯ ` prompt with no rules or borders. Also the
+ * effective style whenever a host calls `setBorderVisible(false)` (hook
+ * editors, agents hub). The status bar renders as a plain standalone bottom
+ * bar with both segment groups.
+ */
+import type { ComposerStyle } from "./types.js";
+export declare const borderlessComposerStyle: ComposerStyle;

package/dist/types/components/composer/box.d.ts

@@ -0,0 +1,2 @@
+import type { ComposerStyle } from "./types.js";
+export declare const boxComposerStyle: ComposerStyle;

package/dist/types/components/composer/claude.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Claude Code-like composer: full-width horizontal rules above and below a
+ * borderless `❯ ` prompt. The right status group rides the top rule as a
+ * bg chip near the right edge (`─────── hi ─`); the left group renders as a
+ * plain standalone bottom bar that yields its row to the autocomplete menu.
+ */
+import type { ComposerStyle } from "./types.js";
+export declare const claudeComposerStyle: ComposerStyle;

package/dist/types/components/composer/field.d.ts

@@ -0,0 +1,3 @@
+import type { ComposerStyle } from "./types.js";
+/** One-row filled field with accent caps. */
+export declare const fieldComposerStyle: ComposerStyle;

package/dist/types/components/composer/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./borderless.js";
+export * from "./box.js";
+export * from "./claude.js";
+export * from "./field.js";
+export * from "./pi.js";
+export * from "./rail.js";
+export * from "./registry.js";
+export * from "./rule.js";
+export * from "./types.js";

package/dist/types/components/composer/pi.d.ts

@@ -0,0 +1,2 @@
+import type { ComposerStyle } from "./types.js";
+export declare const piComposerStyle: ComposerStyle;

package/dist/types/components/composer/rail.d.ts

@@ -0,0 +1,3 @@
+import type { ComposerStyle } from "./types.js";
+/** Filled composer surface anchored by a single left accent rail. */
+export declare const railComposerStyle: ComposerStyle;

package/dist/types/components/composer/registry.d.ts

@@ -0,0 +1,12 @@
+import type { ComposerStyle, EditorBorderStyle } from "./types.js";
+/** Whether an id names a composer style shipped by pi-tui. */
+export declare function isBuiltinComposerStyle(id: string): boolean;
+/**
+ * Register one extension-owned composer style for this process.
+ *
+ * Built-in ids and duplicate extension ids are rejected. The returned disposer
+ * removes only this registration.
+ */
+export declare function registerComposerStyle(style: ComposerStyle): () => void;
+/** Style object for a composer shape; unknown ids fall back to `box`. */
+export declare function getComposerStyle(id: EditorBorderStyle): ComposerStyle;

package/dist/types/components/composer/rule.d.ts

@@ -0,0 +1,7 @@
+import type { ComposerChromeContext, ComposerStyle } from "./types.js";
+/** Draw a full-width rule with status content docked at its right edge.
+ * Over-wide content is truncated (keeping one rule cell on each side) rather
+ * than dropped, so the chip survives narrow terminals and previews. */
+export declare function renderTopRule(ctx: ComposerChromeContext): string;
+/** Composer style with one status-bearing top rule and no bottom chrome. */
+export declare const ruleComposerStyle: ComposerStyle;

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

@@ -0,0 +1,90 @@
+/**
+ * Composer chrome contract. A {@link ComposerStyle} owns everything about how
+ * the input editor's frame looks — top/bottom chrome, per-row side chrome,
+ * default padding and prompt gutter — plus metadata telling the host where the
+ * status bar attaches. The editor, the /settings preview, and the setup-wizard
+ * preview all render through the same style object, so the three surfaces can
+ * never drift apart.
+ */
+import type { SymbolTheme } from "../../symbols.js";
+/** Box-drawing glyph set used for composer chrome (the theme's `boxRound`). */
+export type ComposerBox = SymbolTheme["boxRound"];
+/** Built-in composer shape identifiers shipped by pi-tui. */
+export declare const BUILTIN_EDITOR_BORDER_STYLES: readonly ["box", "claude", "pi", "borderless", "rule", "field", "rail"];
+/** Identifier for a built-in composer shape. */
+export type BuiltinEditorBorderStyle = (typeof BUILTIN_EDITOR_BORDER_STYLES)[number];
+/** Composer shape identifier; extensions may register additional strings. */
+export type EditorBorderStyle = string;
+/** Pre-rendered status content injected into the top chrome. */
+export interface EditorTopBorder {
+    /** The status content (already styled) */
+    content: string;
+    /** Visible width of the content */
+    width: number;
+    /** Optional logical revision that changes independently of available width. */
+    revision?: number;
+}
+/** Inputs shared by every chrome row. */
+export interface ComposerChromeContext {
+    /** Full terminal width available to the composer. */
+    width: number;
+    /** Horizontal padding inside the side chrome. */
+    paddingX: number;
+    borderColor: (str: string) => string;
+    /** Stable accent used by shape-defining chrome such as field caps and rails. */
+    accentColor: (str: string) => string;
+    /** Background fill for composer surfaces; preserves the fill across nested SGR resets. */
+    surfaceColor: (str: string) => string;
+    /** Box-drawing glyph set (theme's `boxRound`). */
+    box: ComposerBox;
+    /** Status content for the top chrome; box embeds it after the corner while
+     * rule-based styles dock it against the right edge. */
+    topBorder?: EditorTopBorder;
+}
+/** Inputs for one content row. */
+export interface ComposerRowContext extends ComposerChromeContext {
+    /** Fully decorated row text (cursor glyph / IME marker included). */
+    text: string;
+    /** Spaces padding the text out to the content width. */
+    pad: string;
+    /** Prompt gutter cells for this row ("" when the style has none). */
+    gutter: string;
+    isLastRow: boolean;
+    /** Cells the end-of-line cursor overflowed into the right chrome (box). */
+    cursorOverflow: number;
+    /** Emit an empty right chrome after the cursor so terminal-local IME
+     *  preedit cannot shift the frame (box last row). */
+    imeSafeCursorTail: boolean;
+    /** Row lies inside the right-border scrollbar thumb (box). */
+    scrollbarThumb: boolean;
+}
+export interface ComposerStyle {
+    readonly id: EditorBorderStyle;
+    /** Content rows carry left/right border glyphs; drives the cursor-reserve
+     *  column, IME-safe layout, and the right-border scrollbar. */
+    readonly sideBorders: boolean;
+    /** Rows consumed by top+bottom chrome (drives maxHeight budgeting). */
+    readonly verticalChrome: 0 | 1 | 2;
+    /** Where the host should attach the status bar: embedded in the top border,
+     * docked onto a top rule, or detached into a standalone bottom bar. */
+    readonly statusAttachment: "top-border" | "top-rule-chip" | "none";
+    /** Which segment groups the standalone bottom status bar shows. */
+    readonly bottomBar: "none" | "left" | "full";
+    /** Insert a blank spacer row between the editor and the standalone bottom
+     * bar. Styles without bottom chrome need it so the bar doesn't sit flush
+     * against the last input row. */
+    readonly bottomBarGap: boolean;
+    /** Default prompt gutter when the host sets none. */
+    readonly defaultPromptGutter: string | undefined;
+    /** Default horizontal padding; `themePaddingX` is the theme's request. */
+    defaultPaddingX(themePaddingX: number | undefined): number;
+    /** Cells consumed per side on content rows (border glyph + padding). */
+    sideChromeWidth(paddingX: number): number;
+    /** Top chrome row; `undefined` renders none. */
+    renderTop(ctx: ComposerChromeContext): string | undefined;
+    /** Chrome-wrapped content row; box's IME-safe last row emits two rows. */
+    renderRow(ctx: ComposerRowContext): string[];
+    /** Bottom chrome row; `undefined` renders none (box merges the bottom
+     *  border into its last content row). */
+    renderBottom(ctx: ComposerChromeContext): string | undefined;
+}

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

@@ -0,0 +1,213 @@
+import { type AutocompleteProvider } from "../autocomplete.js";
+import type { SymbolTheme } from "../symbols.js";
+import { type Component, type Focusable } from "../tui.js";
+import { type EditorBorderStyle, type EditorTopBorder } from "./composer/index.js";
+export type { EditorBorderStyle, EditorTopBorder };
+import { type SelectListTheme } from "./select-list.js";
+export interface EditorTheme {
+    borderColor: (str: string) => string;
+    /** Stable accent for composer chrome that should not follow the mutable border state. */
+    accentColor?: (str: string) => string;
+    /** Background fill used by filled composer styles. */
+    surfaceColor?: (str: string) => string;
+    selectList: SelectListTheme;
+    symbols: SymbolTheme;
+    editorPaddingX?: number;
+    /** Style function for inline hint/ghost text (dim text after cursor) */
+    hintStyle?: (text: string) => string;
+}
+interface HistoryEntry {
+    prompt: string;
+}
+interface HistoryStorage {
+    add(prompt: string, cwd?: string): Promise<void>;
+    getRecent(limit: number): HistoryEntry[];
+}
+/** A synchronous replacement immediately before the editor cursor. */
+export interface EditorInlineReplacement {
+    /** UTF-16 code units to remove immediately before the cursor. */
+    replaceLen: number;
+    /** Literal text inserted where the removed suffix started. */
+    insert: string;
+}
+/** Replacement candidates and the current-line span they replace. */
+export interface EditorWordReplacements {
+    line: number;
+    startCol: number;
+    endCol: number;
+    items: readonly string[];
+}
+/** Source location for one visual text segment passed to `decorateText`. */
+export interface EditorTextDecorationContext {
+    line: number;
+    startCol: number;
+    endCol: number;
+}
+/**
+ * Optional prose assistance kept separate from command/file autocomplete.
+ * Hosts independently decide whether word completion and autocorrection are enabled.
+ */
+export interface EditorTextAssistProvider {
+    /** Return ghost-text suffix for the partial word at the cursor, or `null`. */
+    getWordCompletion?(lines: string[], cursorLine: number, cursorCol: number): string | null;
+    /** Return a correction after one single-character insertion, or `null`. */
+    tryAutocorrect?(lines: string[], cursorLine: number, cursorCol: number): EditorInlineReplacement | null | Promise<EditorInlineReplacement | null>;
+    /** Return replacement candidates for the misspelled word at the cursor. */
+    getWordReplacements?(lines: string[], cursorLine: number, cursorCol: number): EditorWordReplacements | null | Promise<EditorWordReplacements | null>;
+}
+export declare class Editor implements Component, Focusable {
+    #private;
+    /** Focusable interface - set by TUI when focus changes */
+    focused: boolean;
+    /** When set, replaces the normal cursor glyph at end-of-text with this ANSI-styled string. */
+    cursorOverride: string | undefined;
+    /** Display width of the cursorOverride glyph (needed because override may contain ANSI escapes). */
+    cursorOverrideWidth: number | undefined;
+    /** Optional hook that decorates displayed user text after source-text layout.
+     *  Width-changing output is allowed on lines without the cursor; it is truncated
+     *  to the content width rather than reflowed. Cursor glyphs and inline hints are excluded. */
+    decorateText: ((text: string, context: EditorTextDecorationContext) => string) | undefined;
+    borderColor: (str: string) => string;
+    onAutocompleteUpdate?: () => void;
+    /** Called after an async text-assist result mutates the document outside an input event, so hosts can schedule a repaint. */
+    onTextAssistApplied?: () => void;
+    /** Terminal height source for clamping the autocomplete dropdown. Hosts wire this to their Terminal's rows. */
+    viewportRowsProvider?: () => number;
+    /** Optional pattern matching atomic placeholder tokens (e.g. `[Image #1, 800x600]` or
+     *  `[Paste #2, +30 lines]`) that the editor treats as indivisible: a backspace or forward-delete
+     *  landing on any character of a token removes the whole token instead of corrupting it into
+     *  stray text. MUST be a global regex; the editor recompiles a private copy so its `lastIndex`
+     *  is never shared with the caller. */
+    atomicTokenPattern: RegExp | undefined;
+    onSubmit?: (text: string) => void | Promise<void>;
+    onAltEnter?: (text: string) => void;
+    onChange?: (text: string) => void;
+    /** Called for a "marker-sized" paste — the point where the editor would otherwise collapse it
+     *  into a `[Paste #N]` token (> 10 lines or > 1000 characters). Return `true` to intercept:
+     *  the editor inserts nothing and records no undo state, leaving insertion to the host (e.g. a
+     *  "wrap in a code block / XML / attach as file" menu for very large pastes), which re-inserts
+     *  via {@link insertPaste} or {@link insertText}. Return `false` (or leave unset) for the
+     *  default collapse-to-marker behavior. `lineCount` is the sanitized paste's line count. */
+    onLargePaste?: (text: string, lineCount: number) => boolean;
+    onAutocompleteCancel?: () => void;
+    disableSubmit: boolean;
+    constructor(theme: EditorTheme);
+    setTheme(theme: EditorTheme): void;
+    setAutocompleteProvider(provider: AutocompleteProvider): void;
+    /** Install prose assistance without changing command/file autocomplete. */
+    setTextAssistProvider(provider: EditorTextAssistProvider | undefined): void;
+    /**
+     * Set custom content for the top border (e.g., status line).
+     * Pass undefined to use the default plain border.
+     *
+     * Eager: the passed value is cached and reused every frame. Callers that
+     * mutate status upstream must recompute and call this again. Prefer
+     * {@link setTopBorderProvider} for high-frequency updates — it collapses
+     * per-event rebuilds to one per painted frame.
+     */
+    setTopBorder(content: EditorTopBorder | undefined): void;
+    /**
+     * Install a lazy provider invoked once per editor render with the current
+     * `availableWidth`. Overrides any eager content set via {@link setTopBorder}
+     * — pass `undefined` to detach and fall back to the eager slot.
+     *
+     * Use this when the top border derives from state that mutates far faster
+     * than the render cadence (session events, streaming, subagent updates).
+     * The TUI already throttles renders, so a provider is invoked exactly once
+     * per frame and does no work between paints. 	 */
+    setTopBorderProvider(provider: ((availableWidth: number) => EditorTopBorder | undefined) | undefined): void;
+    /**
+     * Show or hide the editor border chrome.
+     */
+    setBorderVisible(borderVisible: boolean): void;
+    setPromptGutter(promptGutter: string | undefined): void;
+    getBorderStyle(): EditorBorderStyle;
+    setBorderStyle(style: EditorBorderStyle): void;
+    /** True while the autocomplete/slash-command menu is open below the editor. */
+    isAutocompleteActive(): boolean;
+    /**
+     * Get the available width for top border content given a total terminal width.
+     * Accounts for the border characters and horizontal padding when visible.
+     */
+    getTopBorderAvailableWidth(terminalWidth: number): number;
+    /**
+     * Use the real terminal cursor instead of rendering a cursor glyph.
+     */
+    setUseTerminalCursor(useTerminalCursor: boolean): void;
+    /** Render a dedicated bottom border so terminal-local IME preedit cannot shift editor chrome. */
+    setImeSafeCursorLayout(enabled: boolean): void;
+    getUseTerminalCursor(): boolean;
+    setMaxHeight(maxHeight: number | undefined): void;
+    /** Enable/disable the right-border scrollbar. Only shown when content overflows. */
+    setScrollbarVisible(visible: boolean): void;
+    setPaddingX(paddingX: number): void;
+    getAutocompleteMaxVisible(): number;
+    setAutocompleteMaxVisible(maxVisible: number): void;
+    /** Loads persistent prompts for navigation and enables future persistence. */
+    setHistoryStorage(storage: HistoryStorage): void;
+    /**
+     * Add a prompt to history for up/down arrow navigation.
+     * Called after successful submission.
+     */
+    addToHistory(text: string): void;
+    invalidate(): void;
+    render(width: number): readonly string[];
+    handleInput(data: string): void;
+    getText(): string;
+    /** Whether the buffer text equals `value`, without `getText()`'s full join —
+     *  O(1) for the hot per-keystroke probes against short single-line values. */
+    textEquals(value: string): boolean;
+    /** Register `label` as a collapsed atom expanding to `expansion` on submit, without inserting
+     *  it — for hosts that re-collapse restored draft text via {@link setText}. */
+    registerAtom(label: string, expansion: string): void;
+    /** Insert `label` (plus a trailing space) at the cursor and register it as an atom expanding
+     *  to `expansion` on submit. Pair with {@link atomicTokenPattern} so the label deletes as a
+     *  unit. */
+    insertAtom(label: string, expansion: string): void;
+    /** Drop every registered atom expansion (draft cleared or replaced by the host). */
+    clearAtoms(): void;
+    /**
+     * Get text with paste markers expanded to their actual content.
+     * Use this when you need the full content (e.g., for external editor).
+     */
+    getExpandedText(): string;
+    getLines(): string[];
+    getCursor(): {
+        line: number;
+        col: number;
+    };
+    moveToLineStart(): void;
+    moveToLineEnd(): void;
+    moveToMessageStart(): void;
+    moveToMessageEnd(): void;
+    /**
+     * Undo the last meaningful edit while ignoring transient text that is still present at the cursor.
+     * Used for command-like autocomplete actions whose typed trigger should not count as the edit being undone.
+     */
+    undoPastTransientText(transientText: string): void;
+    setText(text: string): void;
+    submit(): void;
+    /** Insert text at the current cursor position */
+    insertText(text: string): void;
+    /** Delete up to `count` characters immediately before the cursor on the current line.
+     *  Used to "track back" the auto-repeat spaces that the space-hold push-to-talk gesture
+     *  optimistically inserts before it recognizes the hold. Capped at the cursor column so it
+     *  never crosses a line boundary or under-runs the line. */
+    deleteBeforeCursor(count: number): void;
+    /** Show or replace a volatile speech-to-text preview at the cursor. The text is
+     *  inserted with undo suspended so a long live dictation never floods the undo
+     *  stack; finalize it with {@link commitVolatileText} or drop it with
+     *  {@link clearVolatileText}. Newlines are allowed. */
+    setVolatileText(text: string): void;
+    /** Remove the current volatile preview without committing it. */
+    clearVolatileText(): void;
+    /** Drop any volatile preview, then insert `text` as a single undoable edit. */
+    commitVolatileText(text: string): void;
+    /** Apply terminal paste semantics to text from non-bracketed paste transports. */
+    pasteText(text: string): void;
+    /** Insert `content` as a collapsed `[Paste #N]` marker (stored for expansion on submit via
+     *  {@link getExpandedText}). Hosts that intercept large pastes through {@link onLargePaste} use
+     *  this to re-insert a (possibly transformed) paste without re-triggering the interception hook. */
+    insertPaste(content: string): void;
+    isShowingAutocomplete(): boolean;
+}