@sayknow-cli/tui 0.3.15 → 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);
 		}
 
@@ -2182,16 +2334,25 @@ export class TUI extends Container {
 			this.#previousHeight = height;
 		};
 
-		const viewportRepaint = (reason: string): void => {
+		const viewportRepaint = (reason: string, absoluteClear = false): void => {
 			this.#fullRedrawCount += 1;
 			if (renderMetrics.enabled) renderMetrics.recordFullRedraw(reason);
 			const nextViewportTop = Math.max(0, newLines.length - height);
-			const currentScreenRow = Math.max(0, Math.min(height - 1, hardwareCursorRow - prevViewportTop));
 			let buffer = "\x1b[?2026h";
-			if (currentScreenRow > 0) {
-				buffer += `\x1b[${currentScreenRow}A`;
+			if (absoluteClear) {
+				// A width reflow under a terminal multiplexer re-wraps the on-screen rows to
+				// the new width before SIGWINCH fires, so cursor-relative row math (from the
+				// old width) lands on the wrong physical row and corrupts the repaint. Clear
+				// the visible screen and repaint from absolute home; skip 3J so scrollback
+				// history is preserved.
+				buffer += "\x1b[2J\x1b[H";
+			} else {
+				const currentScreenRow = Math.max(0, Math.min(height - 1, hardwareCursorRow - prevViewportTop));
+				if (currentScreenRow > 0) {
+					buffer += `\x1b[${currentScreenRow}A`;
+				}
+				buffer += "\r";
 			}
-			buffer += "\r";
 			for (let screenRow = 0; screenRow < height; screenRow++) {
 				if (screenRow > 0) buffer += "\r\n";
 				buffer += "\x1b[2K";
@@ -2253,13 +2414,22 @@ export class TUI extends Container {
 
 		// Width changes always need a full re-render because wrapping changes.
 		if (widthChanged) {
+			// A forced render (requestRender(true)) resets #previousWidth to -1: that is a
+			// *fake* width change (the terminal never reflowed), so it keeps the cheap
+			// cursor-relative repaint. A *real* width change (a valid prior width that
+			// differs) means the multiplexer already re-wrapped the on-screen rows,
+			// invalidating cursor-relative row math, so it needs the absolute clear.
+			const realWidthChange = this.#previousWidth > 0 && this.#previousWidth !== width;
 			logRedraw(`terminal width changed (${this.#previousWidth} -> ${width})`);
 			if (useViewportRepaintPath(this.terminal)) {
 				// In viewport-repaint sessions a full replay can either pile the transcript
 				// back onto scrollback (tmux/screen) or visibly jump to the transcript top
-				// (Windows Terminal). Repaint the viewport only, mirroring the height-change
-				// branch and neutralizing fake width changes from requestRender(true).
-				viewportRepaint(`terminal width changed (${this.#previousWidth} -> ${width})`);
+				// (Windows Terminal). For a real width change the reflow invalidates
+				// cursor-relative math, so clear the visible screen and repaint the viewport
+				// from absolute home (absoluteClear) — fixing the corruption without replaying
+				// the whole transcript (no scrollback storm). A fake (force) width change
+				// keeps the in-place relative repaint.
+				viewportRepaint(`terminal width changed (${this.#previousWidth} -> ${width})`, realWidthChange);
 			} else {
 				fullRender(true, "terminal width changed");
 			}
@@ -2274,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
@@ -2333,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)
@@ -2580,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;
-}