@timurproko/a1 0.1.8-dev.3b54f21 → 0.1.8-dev.407

package/dist/{src/foundation/pi-tui-runtime-adapter → integrations/pi/tui-runtime}/adapter.js

@@ -1,4 +1,9 @@
 import { HStack, ProcessTerminal, ScrollView, TuiAltScreen, TuiMainScreen, VStack, visibleWidth, } from "#pi-tui";
+import { MouseReportInput } from "./mouse-report-input.js";
+import { GeometryObservedAltScreen, OverlayGeometryTracker } from "./overlay-geometry.js";
+import { boundedCleanup, EMERGENCY_TERMINAL_RESET } from "../../../foundation/terminal-cleanup/index.js";
+import { InputPresentationCoordinator, } from "./input-presentation-coordinator.js";
+/** Identifies the Pi TUI lifecycle stage that failed while preserving the original cause. */
 export class PiTuiRuntimeError extends Error {
     stage;
     constructor(stage, cause) {
@@ -9,9 +14,11 @@ export class PiTuiRuntimeError extends Error {
 }
 class ComponentBridge {
     port;
+    traceComposition;
     #focused = false;
-    constructor(port) {
+    constructor(port, traceComposition) {
         this.port = port;
+        this.traceComposition = traceComposition;
     }
     get focused() {
         return this.#focused;
@@ -24,12 +31,20 @@ class ComponentBridge {
         return this.port.wantsKeyRelease ?? false;
     }
     render(width) {
-        const lines = [...this.port.render(width)];
-        const overflow = lines.findIndex(line => visibleWidth(line) > width);
-        if (overflow >= 0) {
-            throw new RangeError(`Pi TUI component row ${overflow} exceeds available width ${width}`);
+        this.traceComposition?.("composition-start");
+        try {
+            const lines = [...this.port.render(width)];
+            // Protocol: Kitty APC carries pixels, not columns. Still validate every ordinary cell
+            // around the payload instead of exempting the entire image-bearing row from width checks.
+            const overflow = lines.findIndex(line => visibleWidth(line.replace(/\u001b_G[^\u001b]*\u001b\\/g, "")) > width);
+            if (overflow >= 0) {
+                throw new RangeError(`Pi TUI component row ${overflow} exceeds available width ${width}`);
+            }
+            return lines;
+        }
+        finally {
+            this.traceComposition?.("composition-end");
         }
-        return lines;
     }
     handleInput(data) {
         this.port.handleInput?.(data);
@@ -79,8 +94,10 @@ class OverlayHandleBridge {
         return !this.#disposed && this.handle.isFocused();
     }
 }
+/** Bridges neutral presentation ports to one Pi TUI instance and owns terminal restoration on stop. */
 export class PiTuiRuntimeAdapter {
     #terminal;
+    #tuiTerminal;
     #tui;
     #root;
     #layoutRoot;
@@ -90,17 +107,56 @@ export class PiTuiRuntimeAdapter {
     #bridges = new WeakMap();
     #mountedComponents = new Set();
     #scrollViews = new Map();
+    #overlayGeometry;
     #overlayDisposers = new Set();
+    #overlayInputCoordination = new Map();
     #inputListeners = new Map();
+    #preInputListeners = new Set();
+    #inputCoordinator;
+    #inputDiagnostics;
+    #diagnosticNow;
+    #inputSink;
     #state = "idle";
     #stopPromise;
     #rootDisposed = false;
+    #terminalProgress = false;
     constructor(options) {
         this.#root = options.root;
+        this.#overlayGeometry = options.onOverlayGeometry === undefined ? undefined : new OverlayGeometryTracker(options.onOverlayGeometry);
         this.#terminal = options.terminal ?? new ProcessTerminal();
+        this.#inputDiagnostics = options.inputDiagnostics;
+        this.#diagnosticNow = options.inputDiagnostics?.now ?? (() => performance.now());
+        const tracedTerminal = options.inputDiagnostics === undefined
+            ? this.#terminal
+            : diagnosticTerminal(this.#terminal, phase => this.#traceRuntimePhase(phase));
+        const decoratedTerminal = options.decorateTerminal?.(tracedTerminal) ?? tracedTerminal;
+        const coordination = options.inputCoordination ?? (options.inputDiagnostics === undefined
+            ? undefined
+            : { classify: () => "barrier" });
+        this.#inputCoordinator = coordination === undefined
+            ? undefined
+            : new InputPresentationCoordinator({
+                classify: data => coordination.classify(data, this.#focusedOverlayInputCoordination()),
+                deliver: data => {
+                    const routed = this.#routePreInput(data);
+                    if (routed.length > 0)
+                        this.#inputSink?.(routed);
+                },
+                ...(coordination.onReceipt === undefined ? {} : { onReceipt: coordination.onReceipt }),
+                ...(coordination.scheduler === undefined ? {} : { scheduler: coordination.scheduler }),
+                now: this.#diagnosticNow,
+                ...(options.inputDiagnostics === undefined ? {} : {
+                    onTrace: event => this.#traceInputCoordination(event),
+                }),
+            });
+        this.#tuiTerminal = this.#inputCoordinator === undefined
+            ? preInputTerminal(decoratedTerminal, data => this.#routePreInput(data), this.#overlayGeometry !== undefined)
+            : coordinatedInputTerminal(decoratedTerminal, this.#inputCoordinator, sink => { this.#inputSink = sink; }, this.#overlayGeometry !== undefined);
         this.#layoutRoot = options.layoutRoot;
         this.#logDirectory = options.logDirectory;
-        this.#rootBridge = new ComponentBridge(options.root);
+        this.#rootBridge = new ComponentBridge(options.root, options.inputDiagnostics === undefined
+            ? undefined
+            : phase => this.#traceRuntimePhase(phase));
         this.#bridges.set(options.root, this.#rootBridge);
         this.#mountedComponents.add(options.root);
         try {
@@ -206,6 +262,8 @@ export class PiTuiRuntimeAdapter {
     }
     setFocus(component) {
         this.#assertRunning("focus");
+        if (this.#overlayInputCoordination.size > 0)
+            this.#overlayGeometry?.invalidate();
         this.#tui.setFocus(this.#bridgeFor(component));
     }
     showOverlay(component, options) {
@@ -214,22 +272,29 @@ export class PiTuiRuntimeAdapter {
             throw new TypeError("Pi TUI component is already mounted");
         const bridge = new ComponentBridge(component);
         this.#bridges.set(component, bridge);
+        this.#overlayGeometry?.ports.set(bridge, component);
         let hidden = false;
         const dispose = () => {
             if (hidden)
                 return;
             hidden = true;
             this.#overlayDisposers.delete(dispose);
+            this.#overlayInputCoordination.delete(bridge);
             this.#bridges.delete(component);
             component.dispose?.();
         };
         this.#overlayDisposers.add(dispose);
+        this.#overlayInputCoordination.set(bridge, options?.inputCoordination ?? "opaque");
         const handle = this.#tui.showOverlay(bridge, toOverlayOptions(options));
         return new OverlayHandleBridge(handle, target => this.#bridgeFor(target), dispose);
     }
     hasOverlay() {
         return this.#tui.hasOverlay();
     }
+    /** Keyboard capture is independent of a passive overlay's visible pointer region. */
+    hasFocusedOverlay() {
+        return this.#tui instanceof GeometryObservedAltScreen ? this.#tui.overlayFocused : this.#focusedOverlayInputCoordination() !== undefined;
+    }
     /**
      * Writes a terminal control sequence. Used to enable and disable mouse
      * reporting while an A1-owned application is presented, and for nothing else:
@@ -239,6 +304,12 @@ export class PiTuiRuntimeAdapter {
         this.#assertRunning("control sequence");
         this.#terminal.write(data);
     }
+    addPreInputListener(listener) {
+        if (this.#preInputListeners.has(listener))
+            throw new TypeError("Pi TUI pre-input listener is already registered");
+        this.#preInputListeners.add(listener);
+        return () => this.#preInputListeners.delete(listener);
+    }
     addInputListener(listener) {
         this.#assertRunning("input listener");
         if (this.#inputListeners.has(listener))
@@ -292,9 +363,26 @@ export class PiTuiRuntimeAdapter {
     getHardwareCursor() {
         return this.#tui.getShowHardwareCursor();
     }
+    setClearOnShrink(enabled) {
+        this.#tui.setClearOnShrink(enabled);
+    }
+    getClearOnShrink() {
+        return this.#tui.getClearOnShrink();
+    }
+    setTerminalProgress(active) {
+        if (this.#terminalProgress === active)
+            return;
+        this.#terminal.setProgress(active);
+        this.#terminalProgress = active;
+    }
     setTitle(title) {
         this.#terminal.setTitle(title);
     }
+    writeAfterStop(text) {
+        if (this.#state !== "stopped")
+            throw new Error("terminal output requires a stopped Pi TUI runtime");
+        this.#terminal.write(text);
+    }
     invalidate() {
         this.#tui.invalidate();
         if (this.active)
@@ -313,6 +401,8 @@ export class PiTuiRuntimeAdapter {
             return this.#stopPromise;
         if (this.#state === "idle") {
             this.#state = "stopped";
+            this.#clearTerminalProgress();
+            this.#preInputListeners.clear();
             this.#disposeRoot();
             return Promise.resolve();
         }
@@ -327,9 +417,15 @@ export class PiTuiRuntimeAdapter {
     async #stop(options) {
         this.#state = "stopping";
         let failure;
+        try {
+            this.#inputCoordinator?.dispose(false);
+        }
+        catch (error) {
+            failure = new PiTuiRuntimeError("restoration", error);
+        }
         if (options.drainInput !== false) {
             try {
-                await this.#terminal.drainInput(options.drainMaxMs, options.drainIdleMs);
+                await boundedCleanup(() => this.#terminal.drainInput(options.drainMaxMs, options.drainIdleMs));
             }
             catch (error) {
                 failure = new PiTuiRuntimeError("input-drain", error);
@@ -344,6 +440,7 @@ export class PiTuiRuntimeAdapter {
             this.#bestEffortTerminalRestore();
         }
         finally {
+            this.#clearTerminalProgress();
             this.#disposeComponents();
         }
         this.#state = failure === undefined ? "stopped" : "failed";
@@ -351,9 +448,49 @@ export class PiTuiRuntimeAdapter {
             throw failure;
     }
     #createTui(mode, hardwareCursor) {
-        return mode === "fullscreen"
-            ? new TuiAltScreen(this.#terminal, hardwareCursor, this.#logDirectory, this.#tuiOptions)
-            : new TuiMainScreen(this.#terminal, hardwareCursor, this.#logDirectory);
+        if (mode !== "fullscreen")
+            return new TuiMainScreen(this.#tuiTerminal, hardwareCursor, this.#logDirectory);
+        if (this.#overlayGeometry === undefined)
+            return new TuiAltScreen(this.#tuiTerminal, hardwareCursor, this.#logDirectory, this.#tuiOptions);
+        const screen = new GeometryObservedAltScreen(this.#tuiTerminal, hardwareCursor, this.#logDirectory, this.#tuiOptions);
+        screen.geometry = this.#overlayGeometry;
+        return screen;
+    }
+    #routePreInput(data) {
+        let current = data;
+        for (const listener of this.#preInputListeners) {
+            if (current.length === 0)
+                break;
+            const result = listener(current);
+            if (result?.data !== undefined)
+                current = result.data;
+            else if (result?.consume === true)
+                current = "";
+        }
+        return current;
+    }
+    #focusedOverlayInputCoordination() {
+        for (const [bridge, coordination] of this.#overlayInputCoordination) {
+            if (bridge.focused)
+                return coordination;
+        }
+        return undefined;
+    }
+    #traceInputCoordination(event) {
+        this.#inputDiagnostics?.onEvent(event);
+    }
+    #traceRuntimePhase(phase) {
+        if (this.#inputDiagnostics === undefined)
+            return;
+        const coordinator = this.#inputCoordinator;
+        this.#inputDiagnostics.onEvent({
+            phase,
+            revision: coordinator?.appliedRevision ?? 0,
+            atMs: this.#diagnosticNow(),
+            pendingDepth: coordinator?.pendingDepth ?? 0,
+            pendingPresentationDepth: coordinator?.pendingPresentation === true ? 1 : 0,
+            appliedRevision: coordinator?.appliedRevision ?? 0,
+        });
     }
     #mountTui(tui) {
         tui.addChild(this.#rootBridge);
@@ -436,7 +573,20 @@ export class PiTuiRuntimeAdapter {
             this.#bestEffortTerminalRestore();
         }
     }
+    #clearTerminalProgress() {
+        try {
+            this.#terminal.setProgress(false);
+        }
+        catch { }
+        this.#terminalProgress = false;
+    }
     #bestEffortTerminalRestore() {
+        this.#clearTerminalProgress();
+        try {
+            if (this.mode === "fullscreen")
+                this.#terminal.write(EMERGENCY_TERMINAL_RESET);
+        }
+        catch { }
         try {
             this.#terminal.showCursor();
         }
@@ -455,14 +605,108 @@ export class PiTuiRuntimeAdapter {
         this.#mountedComponents.clear();
     }
     #disposeComponents() {
+        this.#inputCoordinator?.dispose(false);
+        this.#inputSink = undefined;
         for (const remove of this.#inputListeners.values())
             remove();
         this.#inputListeners.clear();
+        this.#preInputListeners.clear();
         for (const dispose of [...this.#overlayDisposers])
             dispose();
+        this.#overlayInputCoordination.clear();
         this.#disposeRoot();
     }
 }
+function coordinatedInputTerminal(terminal, coordinator, setSink, frameMouse) {
+    const mouse = frameMouse ? new MouseReportInput(data => coordinator.accept(data)) : undefined;
+    return {
+        get columns() { return terminal.columns; },
+        get rows() { return terminal.rows; },
+        get kittyProtocolActive() { return terminal.kittyProtocolActive; },
+        start(onInput, onResize) {
+            setSink(onInput);
+            terminal.start(data => mouse === undefined ? coordinator.accept(data) : mouse.accept(data), () => {
+                coordinator.flush();
+                mouse?.reset();
+                onResize();
+            });
+        },
+        stop() {
+            coordinator.flush();
+            mouse?.reset();
+            setSink(undefined);
+            terminal.stop();
+        },
+        drainInput: (maxMs, idleMs) => terminal.drainInput(maxMs, idleMs),
+        write: data => terminal.write(data),
+        moveBy: lines => terminal.moveBy(lines),
+        hideCursor: () => terminal.hideCursor(),
+        showCursor: () => terminal.showCursor(),
+        clearLine: () => terminal.clearLine(),
+        clearFromCursor: () => terminal.clearFromCursor(),
+        clearScreen: () => terminal.clearScreen(),
+        setTitle: title => terminal.setTitle(title),
+        setProgress: active => terminal.setProgress(active),
+    };
+}
+function diagnosticTerminal(terminal, trace) {
+    return {
+        get columns() { return terminal.columns; },
+        get rows() { return terminal.rows; },
+        get kittyProtocolActive() { return terminal.kittyProtocolActive; },
+        start: (onInput, onResize) => terminal.start(onInput, onResize),
+        stop: () => terminal.stop(),
+        drainInput: (maxMs, idleMs) => terminal.drainInput(maxMs, idleMs),
+        write(data) {
+            trace("write-start");
+            try {
+                terminal.write(data);
+            }
+            finally {
+                trace("write-end");
+            }
+        },
+        moveBy: lines => terminal.moveBy(lines),
+        hideCursor: () => terminal.hideCursor(),
+        showCursor: () => terminal.showCursor(),
+        clearLine: () => terminal.clearLine(),
+        clearFromCursor: () => terminal.clearFromCursor(),
+        clearScreen: () => terminal.clearScreen(),
+        setTitle: title => terminal.setTitle(title),
+        setProgress: active => terminal.setProgress(active),
+    };
+}
+function preInputTerminal(terminal, route, frameMouse) {
+    let mouse;
+    return {
+        get columns() { return terminal.columns; },
+        get rows() { return terminal.rows; },
+        get kittyProtocolActive() { return terminal.kittyProtocolActive; },
+        start(onInput, onResize) {
+            const deliver = (data) => {
+                const routed = route(data);
+                if (routed.length > 0)
+                    onInput(routed);
+            };
+            mouse = frameMouse ? new MouseReportInput(deliver) : undefined;
+            terminal.start(data => mouse === undefined ? deliver(data) : mouse.accept(data), () => {
+                mouse?.reset();
+                onResize();
+            });
+        },
+        stop: () => { mouse?.reset(); terminal.stop(); },
+        drainInput: (maxMs, idleMs) => terminal.drainInput(maxMs, idleMs),
+        write: data => terminal.write(data),
+        moveBy: lines => terminal.moveBy(lines),
+        hideCursor: () => terminal.hideCursor(),
+        showCursor: () => terminal.showCursor(),
+        clearLine: () => terminal.clearLine(),
+        clearFromCursor: () => terminal.clearFromCursor(),
+        clearScreen: () => terminal.clearScreen(),
+        setTitle: title => terminal.setTitle(title),
+        setProgress: active => terminal.setProgress(active),
+    };
+}
 function toOverlayOptions(options) {
     if (options === undefined)
         return undefined;

package/dist/{src/foundation/pi-tui-runtime-adapter → integrations/pi/tui-runtime}/contracts.d.ts

@@ -1,3 +1,5 @@
+import type { PresentationComponentPort, PresentationPointerSurface } from "../../../contracts/presentation/index.js";
+import type { PiTuiInputCoordinationDecision, PiTuiInputCoordinationScheduler, PiTuiInputSurfaceKind } from "./input-presentation-coordinator.js";
 export type PiTuiRuntimeState = "idle" | "running" | "stopping" | "stopped" | "failed";
 export interface PiTuiViewport {
     readonly columns: number;
@@ -9,13 +11,9 @@ export interface PiTuiScrollState {
     readonly followingEnd: boolean;
     readonly scrollbarVisible: boolean;
 }
-export interface PiTuiComponentPort {
-    render(width: number): readonly string[];
-    invalidate(): void;
-    handleInput?(data: string): void;
+export type PiTuiPointerSurface = PresentationPointerSurface;
+export interface PiTuiComponentPort extends PresentationComponentPort {
     readonly wantsKeyRelease?: boolean;
-    setFocused?(focused: boolean): void;
-    dispose?(): void;
 }
 export interface PiTuiTerminalPort {
     start(onInput: (data: string) => void, onResize: () => void): void;
@@ -54,6 +52,8 @@ export interface PiTuiOverlayOptions {
     readonly margin?: PiTuiOverlayMargin | number;
     readonly visible?: (columns: number, rows: number) => boolean;
     readonly nonCapturing?: boolean;
+    /** A1-owned input scheduling declaration; omitted extension overlays fail closed. */
+    readonly inputCoordination?: Exclude<PiTuiInputSurfaceKind, "editor">;
 }
 export interface PiTuiOverlayUnfocusOptions {
     readonly target: PiTuiComponentPort | null;
@@ -71,6 +71,8 @@ export interface PiTuiInputListenerResult {
     readonly data?: string;
 }
 export type PiTuiInputListener = (data: string) => PiTuiInputListenerResult | undefined;
+/** Runs at the terminal bridge before Pi TUI receives physical input. */
+export type PiTuiPreInputListener = PiTuiInputListener;
 export interface PiTuiLayoutEntry {
     readonly node: PiTuiLayoutNode;
     readonly basis?: number | "auto";
@@ -100,11 +102,35 @@ export type PiTuiLayoutNode = {
     readonly scrollbarStyle?: (text: string) => string;
     readonly scrollbarHideDelayMs?: number;
 };
+export type PiTuiInputDiagnosticsPhase = "receipt" | "semantic-start" | "semantic-end" | "composition-start" | "composition-end" | "write-start" | "write-end";
+export interface PiTuiInputDiagnosticsEvent {
+    readonly phase: PiTuiInputDiagnosticsPhase;
+    readonly revision: number;
+    readonly atMs: number;
+    readonly pendingDepth: number;
+    readonly pendingPresentationDepth: 0 | 1;
+    readonly appliedRevision: number;
+}
 export interface PiTuiRuntimeAdapterOptions {
     readonly root: PiTuiComponentPort;
+    /** Bare viewport only: painted overlays in back-to-front order; null while geometry is stale. */
+    readonly onOverlayGeometry?: (surfaces: readonly PiTuiPointerSurface[] | null) => void;
     readonly mode?: "regular" | "fullscreen";
     readonly layoutRoot?: PiTuiLayoutNode;
     readonly terminal?: PiTuiTerminalPort;
+    /** A1-owned public-boundary decorator; comparison paths omit it. */
+    readonly decorateTerminal?: (terminal: PiTuiTerminalPort) => PiTuiTerminalPort;
+    /** Bare-custom-viewport scheduling policy; comparison paths omit it. */
+    readonly inputCoordination?: {
+        readonly classify: (data: string, focusedOverlay?: Exclude<PiTuiInputSurfaceKind, "editor">) => PiTuiInputCoordinationDecision;
+        readonly onReceipt?: () => void;
+        readonly scheduler?: PiTuiInputCoordinationScheduler;
+    };
+    /** Optional bounded evidence hook. Production composition omits it. */
+    readonly inputDiagnostics?: {
+        readonly onEvent: (event: PiTuiInputDiagnosticsEvent) => void;
+        readonly now?: () => number;
+    };
     readonly hardwareCursor?: boolean;
     readonly mouse?: boolean;
     readonly wheelScrollLines?: number;

package/dist/integrations/pi/tui-runtime/contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/integrations/pi/tui-runtime/damage-aware-terminal.d.ts

@@ -0,0 +1,81 @@
+import type { PiTuiTerminalPort } from "./contracts.js";
+export declare const PINNED_PI_TUI_DAMAGE_GRAMMAR = "@earendil-works/pi-tui@0.84.2:tui-alt-screen-one-write-v1";
+export interface PiTuiDamageFrameDescriptor {
+    readonly frameId: number;
+    readonly width: number;
+    readonly height: number;
+    readonly transcript: {
+        readonly rowStart: number;
+        readonly rowEnd: number;
+    } | null;
+    readonly dock: {
+        readonly rowStart: number;
+        readonly rowEnd: number;
+    } | null;
+    /**
+     * Visible rows owned by the block that is currently streaming. A live block repaints
+     * every row it owns when it reflows, so the allowed damage follows the declared tail
+     * instead of assuming a one-row tail.
+     */
+    readonly liveTailRows?: number;
+    readonly verticalShiftRows: number;
+    readonly safeVerticalShift: boolean;
+    readonly cause: string;
+}
+export interface PiTuiDamageFrameSafety {
+    readonly overlayActive: boolean;
+    readonly selectionActive: boolean;
+    readonly replacementSurfaceActive: boolean;
+}
+export type PiTuiDamageDecisionReason = "transformed" | "suppressed-redundant-clear" | "hyperlink-cleanup" | "pending-hyperlink-cleanup" | "not-armed" | "unsafe-frame" | "stale-frame" | "unsupported-region-scroll" | "geometry-mismatch" | "grammar-mismatch" | "unsafe-terminal-content" | "incomplete-prior-frame" | "excessive-real-damage";
+export interface PiTuiDamageDecision {
+    readonly frameId: number | null;
+    readonly transformed: boolean;
+    readonly reason: PiTuiDamageDecisionReason;
+    readonly shiftRows: number;
+    readonly paintedRows: readonly number[];
+}
+export interface DamageAwareTerminalOptions {
+    readonly regionalScroll: boolean;
+    /** The shell supplies visible-row analysis; the terminal layer owns no UI parser. */
+    readonly inspectHyperlinks: (content: string) => {
+        readonly ranges: readonly unknown[];
+        readonly hasExplicitLink: boolean;
+        readonly signature: string;
+        readonly replaySafe: boolean;
+        readonly width: number;
+    };
+    readonly onResize?: () => void;
+    readonly onHyperlinkCleanupRequired?: () => void;
+}
+/**
+ * A fail-closed adapter for one pinned Pi fullscreen write grammar. Semantic
+ * viewport metadata authorizes a shift; bytes are inspected only to validate
+ * and preserve Pi's complete row paint and cursor syntax.
+ */
+export declare class DamageAwareTerminalAdapter implements PiTuiTerminalPort {
+    #private;
+    readonly inner: PiTuiTerminalPort;
+    readonly options: DamageAwareTerminalOptions;
+    constructor(inner: PiTuiTerminalPort, options: DamageAwareTerminalOptions);
+    get columns(): number;
+    get rows(): number;
+    get kittyProtocolActive(): boolean;
+    get lastDecision(): PiTuiDamageDecision;
+    get hyperlinkCleanupPending(): boolean;
+    /** Latches the former link rows, including rows whose replacement contains no link. */
+    requestHyperlinkCleanup(rows?: readonly number[]): void;
+    arm(descriptor: PiTuiDamageFrameDescriptor, safety: PiTuiDamageFrameSafety): void;
+    start(onInput: (data: string) => void, onResize: () => void): void;
+    stop(): void;
+    drainInput(maxMs?: number, idleMs?: number): Promise<void>;
+    write(data: string): void;
+    moveBy(lines: number): void;
+    hideCursor(): void;
+    showCursor(): void;
+    clearLine(): void;
+    clearFromCursor(): void;
+    clearScreen(): void;
+    setTitle(title: string): void;
+    setProgress(active: boolean): void;
+}