@sayknow-cli/tui 0.3.16 → 0.4.0

package/src/tui.ts

@@ -45,6 +45,44 @@ type InputListener = (data: string) => InputListenerResult;
 /**
  * Component interface - all components must implement this
  */
+export type MouseEvent = {
+	kind: "wheel" | "click";
+	direction?: -1 | 1;
+	button?: 0;
+	/** Terminal cell coordinates, one-based. */
+	x: number;
+	y: number;
+	/** Focused-overlay cell coordinates, one-based when dispatched to an overlay. */
+	localX?: number;
+	localY?: number;
+};
+
+type OverlayMouseBounds = {
+	row: number;
+	col: number;
+	width: number;
+	height: number;
+	termWidth: number;
+	termHeight: number;
+};
+
+/** Parse xterm SGR mouse reports. Drag and button-release reports are ignored. */
+export function parseSgrMouseEvent(data: string): MouseEvent | undefined {
+	const match = data.match(/^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/);
+	if (!match) return undefined;
+	const button = Number(match[1]);
+	const x = Number(match[2]);
+	const y = Number(match[3]);
+	const terminator = match[4];
+	if (![button, x, y].every(Number.isSafeInteger) || x < 1 || y < 1) return undefined;
+
+	if (button & 32 || terminator === "m") return undefined;
+	if (button === 64) return { kind: "wheel", direction: -1, x, y };
+	if (button === 65) return { kind: "wheel", direction: 1, x, y };
+	if (button === 0) return { kind: "click", button, x, y };
+	return undefined;
+}
+
 export interface Component {
 	/**
 	 * Render the component to lines for the given viewport width
@@ -58,6 +96,9 @@ export interface Component {
 	 */
 	handleInput?(data: string): void;
 
+	/** Optional handler for terminal mouse events when component has focus. */
+	handleMouse?(event: MouseEvent): void;
+
 	/**
 	 * If true, component receives key release events (Kitty protocol).
 	 * Default is false - release events are filtered out.
@@ -279,31 +320,41 @@ function isViewportSensitiveHost(
 	env: Record<string, string | undefined>,
 	platform: NodeJS.Platform,
 	includeNativeWindows: boolean,
+	includeProcessTerminal: boolean,
 ): boolean {
-	return isMultiplexerSession(env) || isWindowsTerminalSession(env) || (includeNativeWindows && platform === "win32");
+	return (
+		isMultiplexerSession(env) ||
+		isWindowsTerminalSession(env) ||
+		includeProcessTerminal ||
+		(includeNativeWindows && platform === "win32")
+	);
 }
 /**
  * True when repainting only the live viewport is safer than clearing/replaying
- * the full transcript. Native Windows console hosts are included even when
- * WT_SESSION is absent because PowerShell/ConPTY launch chains can drop terminal
- * identity variables while keeping the same scroll-jump behavior.
+ * the full transcript. Real process terminals are viewport-sensitive because
+ * their native scrollback position is not observable by the renderer. Native
+ * Windows console hosts are also recognized from platform identity when that
+ * process-terminal capability is unavailable.
  */
 export function shouldUseViewportRepaintForHost(
 	env: Record<string, string | undefined> = Bun.env,
 	platform: NodeJS.Platform = process.platform,
-	options: { includeNativeWindows?: boolean } = {},
+	options: { includeNativeWindows?: boolean; includeProcessTerminal?: boolean } = {},
 ): boolean {
 	const multiplexed = isMultiplexerSession(env);
 	const includeNativeWindows = options.includeNativeWindows ?? true;
+	const includeProcessTerminal = options.includeProcessTerminal ?? false;
 	return (
-		isViewportSensitiveHost(env, platform, includeNativeWindows) &&
+		isViewportSensitiveHost(env, platform, includeNativeWindows, includeProcessTerminal) &&
 		!(multiplexed && useLegacyMultiplexerFullRender(env))
 	);
 }
 
 function useViewportRepaintPath(terminal: Terminal): boolean {
+	if (terminal.isProcessTerminal !== true) return false;
 	return shouldUseViewportRepaintForHost(Bun.env, process.platform, {
-		includeNativeWindows: terminal.isProcessTerminal === true,
+		includeNativeWindows: true,
+		includeProcessTerminal: true,
 	});
 }
 
@@ -319,7 +370,8 @@ function allowsHostNeutralOverflowRepaint(
 }
 
 function shouldPreserveScrollbackOnFullClear(terminal: Terminal): boolean {
-	return isViewportSensitiveHost(Bun.env, process.platform, terminal.isProcessTerminal === true);
+	if (terminal.isProcessTerminal !== true) return false;
+	return isViewportSensitiveHost(Bun.env, process.platform, true, true);
 }
 
 /**
@@ -618,6 +670,7 @@ export class TUI extends Container {
 	#stopped = false;
 	#terminalUnavailable = false;
 	#bottomPinnedComponent: Component | null = null;
+	#pendingTerminalCleanup: Array<{ payload: string; onDelivered?: () => void }> = [];
 
 	#unsubscribeTabWidthChange?: () => void;
 	static #renderCounters: TuiRenderCounterSnapshot = {
@@ -661,9 +714,14 @@ export class TUI extends Container {
 		options?: OverlayOptions;
 		preFocus: Component | null;
 		hidden: boolean;
+		mouseBounds?: OverlayMouseBounds;
 	}[] = [];
 
-	constructor(terminal: Terminal, showHardwareCursor?: boolean) {
+	constructor(
+		terminal: Terminal,
+		showHardwareCursor?: boolean,
+		private readonly options: { enableMouse?: boolean } = {},
+	) {
 		super();
 		this.terminal = terminal;
 		if (showHardwareCursor !== undefined) {
@@ -758,6 +816,50 @@ export class TUI extends Container {
 		if (this.#manualViewportAnchor !== null) this.#reconcileMissingViewportAnchor = true;
 	}
 
+	/** Reveal a semantic viewport anchor without changing the rendered content width. */
+	revealViewportAnchor(id: ViewportAnchorId, alignment: "top" | "center" | "bottom"): boolean {
+		const height = this.terminal.rows;
+		const width = this.terminal.columns;
+		const frame = this.#viewportAnchorFrame;
+		if (height <= 0 || width <= 0 || this.#previousLines.length === 0 || frame === null) return false;
+
+		const selectedRow = frame.anchors.findIndex(anchor => anchor?.id === id);
+		const selected = selectedRow < 0 ? null : frame.anchors[selectedRow];
+		if (selected === null) return false;
+
+		const desiredScreenRow = alignment === "top" ? 0 : alignment === "center" ? Math.floor(height / 2) : height - 1;
+		const targetViewportTop = Math.max(0, frame.startRow + selectedRow - desiredScreenRow);
+		this.#manualViewportAnchor = {
+			id: selected.id,
+			graphemeIndex: selected.graphemeStart,
+			cellOffset: selected.cellStart,
+			desiredScreenRow,
+		};
+		const firstCandidateRow = Math.max(0, targetViewportTop - frame.startRow);
+		const lastCandidateRow = Math.min(frame.anchors.length, targetViewportTop + height - frame.startRow);
+		const fallbacks: ManualViewportAnchor[] = [];
+		for (let row = firstCandidateRow; row < lastCandidateRow; row++) {
+			const anchor = frame.anchors[row];
+			if (anchor === null || row === selectedRow) continue;
+			fallbacks.push({
+				id: anchor.id,
+				graphemeIndex: anchor.graphemeStart,
+				cellOffset: anchor.cellStart,
+				desiredScreenRow: row + frame.startRow - targetViewportTop,
+			});
+		}
+		fallbacks.sort(
+			(a, b) =>
+				Math.abs(a.desiredScreenRow - this.#manualViewportAnchor!.desiredScreenRow) -
+				Math.abs(b.desiredScreenRow - this.#manualViewportAnchor!.desiredScreenRow),
+		);
+		this.#manualViewportFallbackAnchors = fallbacks;
+		this.#manualViewportTop = this.#viewportTopRow;
+		this.#reconcileMissingViewportAnchor = false;
+		this.requestRender();
+		return true;
+	}
+
 	scrollViewportPages(direction: -1 | 1): boolean {
 		const height = this.terminal.rows;
 		const width = this.terminal.columns;
@@ -866,7 +968,8 @@ export class TUI extends Container {
 	 * Returns a handle to control the overlay's visibility.
 	 */
 	showOverlay(component: Component, options?: OverlayOptions): OverlayHandle {
-		const entry = { component, options, preFocus: this.#focusedComponent, hidden: false };
+		const entry = { component, options, preFocus: this.#focusedComponent, hidden: false, mouseBounds: undefined };
+
 		this.overlayStack.push(entry);
 		// Only focus if overlay is actually visible
 		if (this.#isOverlayVisible(entry)) {
@@ -880,6 +983,8 @@ export class TUI extends Container {
 			hide: () => {
 				const index = this.overlayStack.indexOf(entry);
 				if (index !== -1) {
+					entry.mouseBounds = undefined;
+
 					this.overlayStack.splice(index, 1);
 					// Restore focus if this overlay had focus
 					if (this.#focusedComponent === component) {
@@ -893,6 +998,8 @@ export class TUI extends Container {
 			setHidden: (hidden: boolean) => {
 				if (entry.hidden === hidden) return;
 				entry.hidden = hidden;
+				entry.mouseBounds = undefined;
+
 				// Update focus when hiding/showing
 				if (hidden) {
 					// If this overlay had focus, move focus to next visible or preFocus
@@ -916,6 +1023,7 @@ export class TUI extends Container {
 	hideOverlay(): void {
 		const overlay = this.overlayStack.pop();
 		if (!overlay) return;
+		overlay.mouseBounds = undefined;
 		// Find topmost visible overlay, or fall back to preFocus
 		const topVisible = this.#getTopmostVisibleOverlay();
 		this.setFocus(topVisible?.component ?? overlay.preFocus);
@@ -950,11 +1058,13 @@ export class TUI extends Container {
 	override invalidate(): void {
 		super.invalidate();
 		for (const overlay of this.overlayStack) overlay.component.invalidate?.();
+		for (const overlay of this.overlayStack) overlay.mouseBounds = undefined;
 	}
 
 	start(): void {
 		this.#stopped = false;
 		this.#terminalUnavailable = false;
+		this.terminal.setMouseEnabled?.(this.options.enableMouse === true);
 		this.terminal.start(
 			data => this.#handleInput(data),
 			() => {
@@ -962,6 +1072,7 @@ export class TUI extends Container {
 				this.requestResizeRender();
 			},
 		);
+		this.flushTerminalCleanup();
 		this.#hideCursor();
 		this.#querySixelSupport();
 		this.#queryCellSize();
@@ -1171,6 +1282,7 @@ export class TUI extends Container {
 	}
 
 	stop(): void {
+		this.flushTerminalCleanup();
 		this.#clearSixelProbeState();
 		this.#stopped = true;
 		if (this.#renderTimer) {
@@ -1229,7 +1341,7 @@ export class TUI extends Container {
 	 * `PI_TUI_LEGACY_MULTIPLEXER_FULL_RENDER=1` to restore the legacy tmux redraw.
 	 */
 	requestResizeRender(): void {
-		this.requestRender(!useViewportRepaintPath(this.terminal) && !isTermuxSession(), "resize");
+		this.requestRender(!useViewportRepaintPath(this.terminal), "resize");
 	}
 
 	requestRender(force = false, source = "unknown"): void {
@@ -1357,6 +1469,44 @@ export class TUI extends Container {
 			data = current;
 		}
 
+		const mouse = parseSgrMouseEvent(data);
+		if (mouse) {
+			// Coordinates outside the current terminal cannot name a visible cell.
+			if (mouse.x > this.terminal.columns || mouse.y > this.terminal.rows) return;
+			if (mouse.kind === "wheel") this.scrollViewportPages(mouse.direction!);
+			else {
+				const focusedOverlay = this.overlayStack.find(o => o.component === this.#focusedComponent);
+				if (focusedOverlay) {
+					if (!this.#isOverlayVisible(focusedOverlay)) {
+						focusedOverlay.mouseBounds = undefined;
+						return;
+					}
+					const bounds = focusedOverlay.mouseBounds;
+					if (bounds?.termWidth !== this.terminal.columns || bounds.termHeight !== this.terminal.rows) {
+						return;
+					}
+
+					if (
+						!bounds ||
+						mouse.x < bounds.col + 1 ||
+						mouse.x > bounds.col + bounds.width ||
+						mouse.y < bounds.row + 1 ||
+						mouse.y > bounds.row + bounds.height
+					)
+						return;
+					this.#focusedComponent?.handleMouse?.({
+						...mouse,
+						localX: mouse.x - bounds.col,
+						localY: mouse.y - bounds.row,
+					});
+				} else this.#focusedComponent?.handleMouse?.(mouse);
+			}
+			this.requestRender(false, "mouse");
+			return;
+		}
+		// SGR-looking reports, including malformed reports, are terminal controls.
+		if (data.startsWith("\x1b[<")) return;
+
 		// Consume terminal cell size responses without blocking unrelated input.
 		if (this.#consumeCellSizeResponse(data)) {
 			return;
@@ -1556,6 +1706,7 @@ export class TUI extends Container {
 	#compositeOverlays(lines: string[], termWidth: number, termHeight: number): string[] {
 		if (this.overlayStack.length === 0) return lines;
 		const result = [...lines];
+		for (const entry of this.overlayStack) entry.mouseBounds = undefined;
 
 		// Pre-render all visible overlays and calculate positions
 		const rendered: { overlayLines: string[]; row: number; col: number; w: number }[] = [];
@@ -1583,6 +1734,7 @@ export class TUI extends Container {
 			const { row, col } = this.#resolveOverlayLayout(options, overlayLines.length, termWidth, termHeight);
 
 			rendered.push({ overlayLines, row, col, w: width });
+			entry.mouseBounds = { row, col, width, height: overlayLines.length, termWidth, termHeight };
 			minLinesNeeded = Math.max(minLinesNeeded, row + overlayLines.length);
 		}
 
@@ -2292,11 +2444,9 @@ export class TUI extends Container {
 				viewportRepaint(`terminal height changed (${this.#previousHeight} -> ${height})`);
 				return;
 			}
-			if (!isTermuxSession() && !isMultiplexerSession()) {
-				logRedraw(`terminal height changed (${this.#previousHeight} -> ${height})`);
-				fullRender(true, "terminal height changed");
-				return;
-			}
+			logRedraw(`terminal height changed (${this.#previousHeight} -> ${height})`);
+			fullRender(true, "terminal height changed");
+			return;
 		}
 
 		// Content shrunk below the previous render and no overlays - re-render to clear empty rows
@@ -2351,8 +2501,8 @@ export class TUI extends Container {
 		}
 
 		const nextLiveViewportTop = Math.max(0, newLines.length - height);
-		if (firstChanged >= newLines.length && nextLiveViewportTop !== prevViewportTop) {
-			viewportRepaint(`tail shrink changed viewport top (${prevViewportTop} -> ${nextLiveViewportTop})`);
+		if (newLines.length < this.#previousLines.length && nextLiveViewportTop !== prevViewportTop) {
+			viewportRepaint(`content contraction changed viewport top (${prevViewportTop} -> ${nextLiveViewportTop})`);
 			return;
 		}
 		// All changes are in deleted lines (nothing to render, just clear)
@@ -2598,6 +2748,22 @@ export class TUI extends Container {
 		return { seq, toRow: targetRow };
 	}
 
+	/** Retain terminal cleanup until a write succeeds, even after its component is disposed. */
+	queueTerminalCleanup(payload: string, onDelivered?: () => void): void {
+		this.#pendingTerminalCleanup.push({ payload, onDelivered });
+		this.flushTerminalCleanup();
+	}
+
+	/** Retry queued terminal cleanup after terminal recovery or before shutdown. */
+	flushTerminalCleanup(): void {
+		while (this.#pendingTerminalCleanup.length > 0) {
+			const pending = this.#pendingTerminalCleanup[0];
+			if (!this.#writeTerminal(pending.payload)) return;
+			this.#pendingTerminalCleanup.shift();
+			pending.onDelivered?.();
+		}
+	}
+
 	/**
 	 * Register an emitter whose escape payload is appended to every render
 	 * write (inside its own synchronized-output block, cursor saved/restored).

package/dist/types/animation-scheduler.d.ts

@@ -1,13 +0,0 @@
-export type AnimationCadence = 16 | 80;
-type AnimationCallback = (now: number) => void;
-export interface AnimationRegistration {
-    unregister(): void;
-}
-export declare function registerAnimationCallback(callback: AnimationCallback, cadence?: AnimationCadence): AnimationRegistration;
-export declare const __animationSchedulerTestHooks: {
-    getActiveTimerCount(cadence?: AnimationCadence): number;
-    getRegistrantCount(cadence?: AnimationCadence): number;
-    getStartedTimerCount(cadence?: AnimationCadence): number;
-    reset(): void;
-};
-export {};

package/dist/types/autocomplete.d.ts

@@ -1,83 +0,0 @@
-export declare function getSlashCommandMatchRank(query: string, commandName: string): number;
-export declare function extractSlashCommandTokenPrefix(text: string): string | null;
-export interface AutocompleteItem {
-    value: string;
-    label: string;
-    description?: 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;
-    description?: string;
-    argumentHint?: string;
-    /**
-     * Higher values surface first in autocomplete, ahead of fuzzy-score ordering.
-     * Use this to pin first-class commands (e.g. bundled SKC skills) to the top.
-     */
-    priority?: number;
-    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 */
-    getSuggestions(lines: string[], cursorLine: number, cursorCol: number): 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;
-}
-export declare class CombinedAutocompleteProvider implements AutocompleteProvider {
-    #private;
-    constructor(commands?: (SlashCommand | AutocompleteItem)[], basePath?: string);
-    getSuggestions(lines: string[], cursorLine: number, cursorCol: number): 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): 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

@@ -1,26 +0,0 @@
-export type PasteResult = {
-    handled: false;
-} | {
-    handled: true;
-    pasteContent?: string;
-    remaining: string;
-};
-/**
- * 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;
-    /**
-     * 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; omitted when still buffering.
-     */
-    process(data: string): PasteResult;
-}

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

@@ -1,20 +0,0 @@
-import type { Component } from "../tui";
-/**
- * Box component - a container that applies padding and background to all children
- */
-export declare class Box implements Component {
-    #private;
-    children: Component[];
-    constructor(paddingX?: number, paddingY?: number, bgFn?: (text: string) => string);
-    addChild(component: Component): void;
-    removeChild(component: Component): void;
-    /** Remove a child without disposing it (for detach-then-readd reuse). */
-    detachChild(component: Component): void;
-    clear(): void;
-    /** Remove all children without disposing them (for detach-then-readd reuse). */
-    detachAll(): void;
-    dispose(): void;
-    setBgFn(bgFn?: (text: string) => string): void;
-    invalidate(): void;
-    render(width: number): string[];
-}

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

@@ -1,21 +0,0 @@
-import { Loader } from "./loader";
-/**
- * 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/editor.d.ts

@@ -1,126 +0,0 @@
-import { type AutocompleteProvider } from "../autocomplete";
-import type { SymbolTheme } from "../symbols";
-import { type Component, type Focusable } from "../tui";
-import { type SelectListTheme } from "./select-list";
-export interface EditorTheme {
-    borderColor: (str: string) => string;
-    selectList: SelectListTheme;
-    symbols: SymbolTheme;
-    editorPaddingX?: number;
-    /** Style function for inline hint/ghost text (dim text after cursor) */
-    hintStyle?: (text: string) => string;
-}
-export interface EditorTopBorder {
-    /** The status content (already styled) */
-    content: string;
-    /** Visible width of the content */
-    width: number;
-}
-export type EditorBorderStyle = "round" | "sharp";
-interface HistoryEntry {
-    prompt: string;
-}
-interface HistoryStorage {
-    add(prompt: string, cwd?: string): Promise<void>;
-    getRecent(limit: number, cwd?: string): HistoryEntry[];
-}
-/** Test-only performance counters for advisory baseline tests. */
-export declare const __editorPerfCounters: {
-    layoutTextInvocations: number;
-    layoutLogicalLinesProcessed: number;
-    visibleWidthMeasurements: number;
-    reset(): void;
-};
-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;
-    borderColor: (str: string) => string;
-    onAutocompleteUpdate?: () => void;
-    onSubmit?: (text: string) => void;
-    onAltEnter?: (text: string) => void;
-    onChange?: (text: string) => void;
-    onAutocompleteCancel?: () => void;
-    onTabDeclined?: (text: string) => void;
-    /**
-     * Called before Tab opens/applies autocomplete. Return true to consume Tab
-     * for app-level behavior (for example, queueing a draft while a turn runs).
-     */
-    onTab?: (text: string) => boolean | undefined;
-    disableSubmit: boolean;
-    constructor(theme: EditorTheme);
-    dispose(): void;
-    setAutocompleteProvider(provider: AutocompleteProvider): void;
-    getAutocompleteProvider(): AutocompleteProvider | undefined;
-    /** Whether the autocomplete dropdown is currently open. */
-    isAutocompleteOpen(): boolean;
-    /**
-     * Set custom content for the top border (e.g., status line).
-     * Pass undefined to use the default plain border.
-     */
-    setTopBorder(content: EditorTopBorder | undefined): void;
-    /**
-     * Show or hide the editor border chrome.
-     */
-    setBorderVisible(borderVisible: boolean): void;
-    setBorderStyle(borderStyle: EditorBorderStyle): void;
-    setClosedBorderBox(closedBorderBox: boolean): void;
-    setPromptGutter(promptGutter: string | undefined): void;
-    setInputPrefix(inputPrefix: string | undefined): void;
-    setPlaceholder(placeholder: string | undefined): void;
-    /**
-     * Get the available width for top border content given a total terminal width.
-     * Accounts for right gutter, 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;
-    getUseTerminalCursor(): boolean;
-    setMaxHeight(maxHeight: number | undefined): void;
-    setPaddingX(paddingX: number): void;
-    setRightGutterWidth(width: number): void;
-    getAutocompleteMaxVisible(): number;
-    setAutocompleteMaxVisible(maxVisible: number): void;
-    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): string[];
-    handleInput(data: string): void;
-    /** Test-only seam: current wrap-cache entry count (memory-bound assertions). */
-    get wrappedLineCacheSize(): number;
-    getText(): string;
-    /**
-     * 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;
-    /** Insert text at the current cursor position */
-    insertText(text: string): void;
-    isShowingAutocomplete(): boolean;
-}
-export {};

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

@@ -1,18 +0,0 @@
-import { type ImageDimensions } from "../terminal-capabilities";
-import type { Component } from "../tui";
-export interface ImageTheme {
-    fallbackColor: (str: string) => string;
-}
-export interface ImageOptions {
-    maxWidthCells?: number;
-    maxHeightCells?: number;
-    filename?: string;
-    refetch?: () => string;
-}
-export declare class Image implements Component {
-    #private;
-    constructor(base64Data: string, mimeType: string, theme: ImageTheme, options?: ImageOptions, dimensions?: ImageDimensions);
-    invalidate(): void;
-    get retainedBase64DataForTest(): string | undefined;
-    render(width: number): string[];
-}