@opentui/core 0.0.0-20250908-4906ddad → 0.0.0-20250915-f5db043a

package/lib/KeyHandler.d.ts

@@ -1,11 +1,15 @@
 import { EventEmitter } from "events";
 import { type ParsedKey } from "./parse.keypress";
+export type { ParsedKey };
 type KeyHandlerEventMap = {
     keypress: [ParsedKey];
+    keyrepeat: [ParsedKey];
+    keyrelease: [ParsedKey];
 };
 export declare class KeyHandler extends EventEmitter<KeyHandlerEventMap> {
-    constructor();
+    private stdin;
+    private useKittyKeyboard;
+    constructor(stdin?: NodeJS.ReadStream, useKittyKeyboard?: boolean);
     destroy(): void;
 }
-export declare function getKeyHandler(): KeyHandler;
-export {};
+export declare function getKeyHandler(useKittyKeyboard?: boolean): KeyHandler;

package/lib/objects-in-viewport.d.ts

@@ -0,0 +1,10 @@
+import type { ViewportBounds } from "../types";
+interface ViewportObject {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    zIndex: number;
+}
+export declare function getObjectsInViewport<T extends ViewportObject>(viewport: ViewportBounds, objects: T[], direction?: "row" | "column", padding?: number, minTriggerSize?: number): T[];
+export {};

package/lib/parse.keypress-kitty.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedKey } from "./parse.keypress";
+export declare function parseKittyKeyboard(sequence: string): ParsedKey | null;

package/lib/parse.keypress.d.ts

@@ -1,5 +1,6 @@
 import { Buffer } from "node:buffer";
 export declare const nonAlphanumericKeys: string[];
+export type KeyEventType = "press" | "repeat" | "release";
 export type ParsedKey = {
     name: string;
     ctrl: boolean;
@@ -9,6 +10,15 @@ export type ParsedKey = {
     sequence: string;
     number: boolean;
     raw: string;
+    eventType: KeyEventType;
     code?: string;
+    super?: boolean;
+    hyper?: boolean;
+    capsLock?: boolean;
+    numLock?: boolean;
+    baseCode?: number;
 };
-export declare const parseKeypress: (s?: Buffer | string) => ParsedKey;
+export type ParseKeypressOptions = {
+    useKittyKeyboard?: boolean;
+};
+export declare const parseKeypress: (s?: Buffer | string, options?: ParseKeypressOptions) => ParsedKey;

package/lib/styled-text.d.ts

@@ -1,6 +1,7 @@
 import type { TextRenderable } from "../renderables/Text";
 import type { TextChunk } from "../text-buffer";
 import { type ColorInput } from "./RGBA";
+declare const BrandedStyledText: unique symbol;
 export type Color = ColorInput;
 export interface StyleAttrs {
     fg?: Color;
@@ -13,7 +14,9 @@ export interface StyleAttrs {
     reverse?: boolean;
     blink?: boolean;
 }
+export declare function isStyledText(obj: any): obj is StyledText;
 export declare class StyledText {
+    [BrandedStyledText]: boolean;
     chunks: TextChunk[];
     textRenderable?: TextRenderable;
     constructor(chunks: TextChunk[]);
@@ -71,3 +74,4 @@ export declare const bg: (color: Color) => (input: StylableInput) => TextChunk;
  * Returns a StyledText object containing chunks of text with optional styles.
  */
 export declare function t(strings: TemplateStringsArray, ...values: StylableInput[]): StyledText;
+export {};

package/package.json

@@ -4,7 +4,7 @@
   "main": "index.js",
   "types": "index.d.ts",
   "type": "module",
-  "version": "0.0.0-20250908-4906ddad",
+  "version": "0.0.0-20250915-f5db043a",
   "description": "OpenTUI is a TypeScript library for building terminal user interfaces (TUIs)",
   "license": "MIT",
   "repository": {
@@ -22,6 +22,11 @@
       "import": "./3d.js",
       "require": "./3d.js",
       "types": "./3d.d.ts"
+    },
+    "./testing": {
+      "import": "./testing.js",
+      "require": "./testing.js",
+      "types": "./testing.d.ts"
     }
   },
   "dependencies": {
@@ -38,11 +43,11 @@
     "bun-webgpu": "0.1.3",
     "planck": "^1.4.2",
     "three": "0.177.0",
-    "@opentui/core-darwin-x64": "0.0.0-20250908-4906ddad",
-    "@opentui/core-darwin-arm64": "0.0.0-20250908-4906ddad",
-    "@opentui/core-linux-x64": "0.0.0-20250908-4906ddad",
-    "@opentui/core-linux-arm64": "0.0.0-20250908-4906ddad",
-    "@opentui/core-win32-x64": "0.0.0-20250908-4906ddad",
-    "@opentui/core-win32-arm64": "0.0.0-20250908-4906ddad"
+    "@opentui/core-darwin-x64": "0.0.0-20250915-f5db043a",
+    "@opentui/core-darwin-arm64": "0.0.0-20250915-f5db043a",
+    "@opentui/core-linux-x64": "0.0.0-20250915-f5db043a",
+    "@opentui/core-linux-arm64": "0.0.0-20250915-f5db043a",
+    "@opentui/core-win32-x64": "0.0.0-20250915-f5db043a",
+    "@opentui/core-win32-arm64": "0.0.0-20250915-f5db043a"
   }
 }

package/renderables/Input.d.ts

@@ -20,7 +20,7 @@ export declare enum InputRenderableEvents {
     ENTER = "enter"
 }
 export declare class InputRenderable extends Renderable {
-    protected focusable: boolean;
+    protected _focusable: boolean;
     private _value;
     private _cursorPosition;
     private _placeholder;

package/renderables/ScrollBar.d.ts

@@ -17,7 +17,7 @@ export declare class ScrollBarRenderable extends Renderable {
     readonly startArrow: ArrowRenderable;
     readonly endArrow: ArrowRenderable;
     readonly orientation: "vertical" | "horizontal";
-    protected focusable: boolean;
+    protected _focusable: boolean;
     private _scrollSize;
     private _scrollPosition;
     private _viewportSize;

package/renderables/ScrollBox.d.ts

@@ -18,6 +18,8 @@ export interface ScrollBoxOptions extends BoxOptions<ScrollBoxRenderable> {
     scrollbarOptions?: Omit<ScrollBarOptions, "orientation">;
     verticalScrollbarOptions?: Omit<ScrollBarOptions, "orientation">;
     horizontalScrollbarOptions?: Omit<ScrollBarOptions, "orientation">;
+    stickyScroll?: boolean;
+    stickyStart?: "bottom" | "top" | "left" | "right";
 }
 export declare class ScrollBoxRenderable extends BoxRenderable {
     static idCounter: number;
@@ -27,7 +29,7 @@ export declare class ScrollBoxRenderable extends BoxRenderable {
     readonly content: ContentRenderable;
     readonly horizontalScrollBar: ScrollBarRenderable;
     readonly verticalScrollBar: ScrollBarRenderable;
-    protected focusable: boolean;
+    protected _focusable: boolean;
     private selectionListener?;
     private autoScrollMouseX;
     private autoScrollMouseY;
@@ -40,13 +42,26 @@ export declare class ScrollBoxRenderable extends BoxRenderable {
     private cachedAutoScrollSpeed;
     private autoScrollAccumulatorX;
     private autoScrollAccumulatorY;
+    private _stickyScroll;
+    private _stickyScrollTop;
+    private _stickyScrollBottom;
+    private _stickyScrollLeft;
+    private _stickyScrollRight;
+    private _stickyStart?;
+    private _hasManualScroll;
+    get stickyScroll(): boolean;
+    set stickyScroll(value: boolean);
+    get stickyStart(): "bottom" | "top" | "left" | "right" | undefined;
+    set stickyStart(value: "bottom" | "top" | "left" | "right" | undefined);
     get scrollTop(): number;
     set scrollTop(value: number);
     get scrollLeft(): number;
     set scrollLeft(value: number);
     get scrollWidth(): number;
     get scrollHeight(): number;
-    constructor(ctx: RenderContext, { wrapperOptions, viewportOptions, contentOptions, rootOptions, scrollbarOptions, verticalScrollbarOptions, horizontalScrollbarOptions, ...options }: ScrollBoxOptions);
+    private updateStickyState;
+    private applyStickyStart;
+    constructor(ctx: RenderContext, { wrapperOptions, viewportOptions, contentOptions, rootOptions, scrollbarOptions, verticalScrollbarOptions, horizontalScrollbarOptions, stickyScroll, stickyStart, ...options }: ScrollBoxOptions);
     protected onUpdate(deltaTime: number): void;
     scrollBy(delta: number | {
         x: number;

package/renderables/Select.d.ts

@@ -31,7 +31,7 @@ export declare enum SelectRenderableEvents {
     ITEM_SELECTED = "itemSelected"
 }
 export declare class SelectRenderable extends Renderable {
-    protected focusable: boolean;
+    protected _focusable: boolean;
     private _options;
     private selectedIndex;
     private scrollOffset;

package/renderables/Slider.d.ts

@@ -1,31 +1,44 @@
 import { type ColorInput, OptimizedBuffer, Renderable, type RenderableOptions, type RenderContext, RGBA } from "../index";
 export interface SliderOptions extends RenderableOptions<SliderRenderable> {
     orientation: "vertical" | "horizontal";
-    thumbSize?: number;
-    thumbPosition?: number;
+    value?: number;
+    min?: number;
+    max?: number;
+    viewPortSize?: number;
     backgroundColor?: ColorInput;
     foregroundColor?: ColorInput;
-    onChange?: (position: number) => void;
+    onChange?: (value: number) => void;
 }
 export declare class SliderRenderable extends Renderable {
     readonly orientation: "vertical" | "horizontal";
-    private _thumbSize;
-    private _thumbPosition;
+    private _value;
+    private _min;
+    private _max;
+    private _viewPortSize;
     private _backgroundColor;
     private _foregroundColor;
     private _onChange?;
     constructor(ctx: RenderContext, options: SliderOptions);
-    get thumbSize(): number;
-    set thumbSize(value: number);
-    get thumbPosition(): number;
-    set thumbPosition(value: number);
+    get value(): number;
+    set value(newValue: number);
+    get min(): number;
+    set min(newMin: number);
+    get max(): number;
+    set max(newMax: number);
+    set viewPortSize(size: number);
+    get viewPortSize(): number;
     get backgroundColor(): RGBA;
     set backgroundColor(value: ColorInput);
     get foregroundColor(): RGBA;
     set foregroundColor(value: ColorInput);
+    private calculateDragOffsetVirtual;
     private setupMouseHandling;
-    private updatePositionFromMouse;
-    private getThumbPosition;
+    private updateValueFromMouseDirect;
+    private updateValueFromMouseWithOffset;
     private getThumbRect;
     protected renderSelf(buffer: OptimizedBuffer): void;
+    private renderHorizontal;
+    private renderVertical;
+    private getVirtualThumbSize;
+    private getVirtualThumbStart;
 }

package/renderables/TabSelect.d.ts

@@ -29,7 +29,7 @@ export declare enum TabSelectRenderableEvents {
     ITEM_SELECTED = "itemSelected"
 }
 export declare class TabSelectRenderable extends Renderable {
-    protected focusable: boolean;
+    protected _focusable: boolean;
     private _options;
     private selectedIndex;
     private scrollOffset;

package/renderables/Text.d.ts

@@ -1,10 +1,11 @@
-import { Renderable, type RenderableOptions } from "../Renderable";
+import { BaseRenderable, Renderable, type RenderableOptions } from "../Renderable";
 import { Selection } from "../lib/selection";
 import { StyledText } from "../lib/styled-text";
 import { type TextChunk } from "../text-buffer";
 import { RGBA } from "../lib/RGBA";
 import { type RenderContext } from "../types";
 import type { OptimizedBuffer } from "../buffer";
+import { RootTextNodeRenderable, TextNodeRenderable } from "./TextNode";
 export interface TextOptions extends RenderableOptions<TextRenderable> {
     content?: StyledText | string;
     fg?: string | RGBA;
@@ -25,6 +26,7 @@ export declare class TextRenderable extends Renderable {
     private lastLocalSelection;
     private textBuffer;
     private _lineInfo;
+    protected rootTextNode: RootTextNodeRenderable;
     protected _defaultOptions: {
         content: string;
         fg: RGBA;
@@ -41,6 +43,7 @@ export declare class TextRenderable extends Renderable {
     get plainText(): string;
     get textLength(): number;
     get chunks(): TextChunk[];
+    get textNode(): RootTextNodeRenderable;
     set content(value: StyledText | string);
     get fg(): RGBA;
     set fg(value: RGBA | string | undefined);
@@ -59,6 +62,12 @@ export declare class TextRenderable extends Renderable {
     insertChunk(chunk: TextChunk, index?: number): void;
     removeChunk(chunk: TextChunk): void;
     replaceChunk(chunk: TextChunk, oldChunk: TextChunk): void;
+    private updateTextFromNodes;
+    add(obj: TextNodeRenderable | StyledText | string, index?: number): number;
+    remove(id: string): void;
+    insertBefore(obj: BaseRenderable | any, anchor?: TextNodeRenderable): number;
+    getTextChildren(): BaseRenderable[];
+    clear(): void;
     shouldStartSelection(x: number, y: number): boolean;
     onSelectionChanged(selection: Selection | null): boolean;
     getSelectedText(): string;
@@ -67,6 +76,8 @@ export declare class TextRenderable extends Renderable {
         start: number;
         end: number;
     } | null;
+    onLifecyclePass: () => void;
+    render(buffer: OptimizedBuffer, deltaTime: number): void;
     protected renderSelf(buffer: OptimizedBuffer): void;
     destroy(): void;
 }

package/renderables/TextNode.d.ts

@@ -0,0 +1,67 @@
+import type { TextRenderable } from ".";
+import { BaseRenderable, type BaseRenderableOptions } from "../Renderable";
+import { RGBA } from "../lib/RGBA";
+import { StyledText } from "../lib/styled-text";
+import { type TextChunk } from "../text-buffer";
+import type { RenderContext } from "../types";
+export interface TextNodeOptions extends BaseRenderableOptions {
+    fg?: string | RGBA;
+    bg?: string | RGBA;
+    attributes?: number;
+}
+declare const BrandedTextNodeRenderable: unique symbol;
+export declare function isTextNodeRenderable(obj: any): obj is TextNodeRenderable;
+export declare class TextNodeRenderable extends BaseRenderable {
+    [BrandedTextNodeRenderable]: boolean;
+    private _fg?;
+    private _bg?;
+    private _attributes;
+    private _children;
+    parent: TextNodeRenderable | null;
+    constructor(options: TextNodeOptions);
+    get children(): (string | TextNodeRenderable)[];
+    set children(children: (string | TextNodeRenderable)[]);
+    requestRender(): void;
+    add(obj: TextNodeRenderable | StyledText | string, index?: number): number;
+    replace(obj: TextNodeRenderable | string, index: number): void;
+    insertBefore(child: string | TextNodeRenderable | StyledText, anchorNode: TextNodeRenderable | string | unknown): this;
+    remove(child: string | TextNodeRenderable): this;
+    clear(): void;
+    mergeStyles(parentStyle: {
+        fg?: RGBA;
+        bg?: RGBA;
+        attributes: number;
+    }): {
+        fg?: RGBA;
+        bg?: RGBA;
+        attributes: number;
+    };
+    gatherWithInheritedStyle(parentStyle?: {
+        fg?: RGBA;
+        bg?: RGBA;
+        attributes: number;
+    }): TextChunk[];
+    static fromString(text: string, options?: Partial<TextNodeOptions>): TextNodeRenderable;
+    static fromNodes(nodes: TextNodeRenderable[], options?: Partial<TextNodeOptions>): TextNodeRenderable;
+    toChunks(parentStyle?: {
+        fg?: RGBA;
+        bg?: RGBA;
+        attributes: number;
+    }): TextChunk[];
+    getChildren(): BaseRenderable[];
+    getChildrenCount(): number;
+    getRenderable(id: string): BaseRenderable | undefined;
+    get fg(): RGBA | undefined;
+    set fg(fg: RGBA | string | undefined);
+    set bg(bg: RGBA | string | undefined);
+    get bg(): RGBA | undefined;
+    set attributes(attributes: number);
+    get attributes(): number;
+}
+export declare class RootTextNodeRenderable extends TextNodeRenderable {
+    private readonly ctx;
+    textParent: TextRenderable;
+    constructor(ctx: RenderContext, options: TextNodeOptions, textParent: TextRenderable);
+    requestRender(): void;
+}
+export {};

package/renderables/composition/constructs.d.ts

@@ -1,12 +1,33 @@
 import { ASCIIFontRenderable, BoxRenderable, InputRenderable, SelectRenderable, TabSelectRenderable, TextRenderable, VRenderable, type ASCIIFontOptions, type BoxOptions, type TextOptions, type VRenderableOptions, type InputRenderableOptions, type SelectRenderableOptions, type TabSelectRenderableOptions, FrameBufferRenderable, type FrameBufferOptions } from "../";
-import { type VChild, type ProxiedVNode } from "./vnode";
-export declare function Generic(props?: VRenderableOptions, ...children: VChild[]): ProxiedVNode<typeof VRenderable>;
-export declare function Box(props?: BoxOptions, ...children: VChild[]): ProxiedVNode<typeof BoxRenderable>;
+import { TextNodeRenderable } from "../TextNode";
+import { type VChild } from "./vnode";
+import type { RGBA } from "../../lib/RGBA";
+export declare function Generic(props?: VRenderableOptions, ...children: VChild[]): import("./vnode").ProxiedVNode<typeof VRenderable>;
+export declare function Box(props?: BoxOptions, ...children: VChild[]): import("./vnode").ProxiedVNode<typeof BoxRenderable>;
 export declare function Text(props?: TextOptions & {
     content?: any;
-}, ...children: VChild[]): ProxiedVNode<typeof TextRenderable>;
-export declare function ASCIIFont(props?: ASCIIFontOptions, ...children: VChild[]): ProxiedVNode<typeof ASCIIFontRenderable>;
-export declare function Input(props?: InputRenderableOptions, ...children: VChild[]): ProxiedVNode<typeof InputRenderable>;
-export declare function Select(props?: SelectRenderableOptions, ...children: VChild[]): ProxiedVNode<typeof SelectRenderable>;
-export declare function TabSelect(props?: TabSelectRenderableOptions, ...children: VChild[]): ProxiedVNode<typeof TabSelectRenderable>;
-export declare function FrameBuffer(props: FrameBufferOptions, ...children: VChild[]): ProxiedVNode<typeof FrameBufferRenderable>;
+}, ...children: VChild[] | TextNodeRenderable[]): import("./vnode").ProxiedVNode<typeof TextRenderable>;
+export declare function ASCIIFont(props?: ASCIIFontOptions, ...children: VChild[]): import("./vnode").ProxiedVNode<typeof ASCIIFontRenderable>;
+export declare function Input(props?: InputRenderableOptions, ...children: VChild[]): import("./vnode").ProxiedVNode<typeof InputRenderable>;
+export declare function Select(props?: SelectRenderableOptions, ...children: VChild[]): import("./vnode").ProxiedVNode<typeof SelectRenderable>;
+export declare function TabSelect(props?: TabSelectRenderableOptions, ...children: VChild[]): import("./vnode").ProxiedVNode<typeof TabSelectRenderable>;
+export declare function FrameBuffer(props: FrameBufferOptions, ...children: VChild[]): import("./vnode").ProxiedVNode<typeof FrameBufferRenderable>;
+export declare const vstyles: {
+    bold: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    italic: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    underline: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    dim: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    blink: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    inverse: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    hidden: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    strikethrough: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    boldItalic: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    boldUnderline: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    italicUnderline: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    boldItalicUnderline: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    color: (color: string | RGBA, ...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    bgColor: (bgColor: string | RGBA, ...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    fg: (color: string | RGBA, ...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    bg: (bgColor: string | RGBA, ...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    styled: (attributes?: number, ...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+};

package/renderables/composition/vnode.d.ts

@@ -27,7 +27,7 @@ export declare function h<TCtor extends RenderableConstructor<any>>(type: TCtor,
 export declare function h<P>(type: FunctionalConstruct<P>, props?: P, ...children: VChild[]): VNode<P>;
 export declare function h<P>(type: Construct<P>, props?: P, ...children: VChild[]): VNode<P> | ProxiedVNode<any>;
 export declare function isVNode(node: any): node is VNode;
-export declare function maybeMakeRenderable(ctx: RenderContext, node: Renderable | VNode<any, any[]>): Renderable | null;
+export declare function maybeMakeRenderable(ctx: RenderContext, node: Renderable | VNode<any, any[]> | unknown): Renderable | null;
 export declare function wrapWithDelegates<T extends InstanceType<RenderableConstructor>>(instance: T, delegateMap: Record<string, string> | undefined): T;
 export type InstantiateFn<NodeType extends VNode | Renderable> = Renderable & {
     __node?: NodeType;

package/renderables/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./Box";
 export * from "./FrameBuffer";
 export * from "./Text";
+export * from "./TextNode";
 export * from "./ASCIIFont";
 export * from "./Input";
 export * from "./Select";

package/renderer.d.ts

@@ -8,6 +8,7 @@ import { TerminalConsole, type ConsoleOptions } from "./console";
 import { type MouseEventType, type RawMouseEvent, type ScrollInfo } from "./lib/parse.mouse";
 import { Selection } from "./lib/selection";
 import { EventEmitter } from "events";
+import { KeyHandler } from "./lib/KeyHandler";
 export interface CliRendererConfig {
     stdin?: NodeJS.ReadStream;
     stdout?: NodeJS.WriteStream;
@@ -25,6 +26,7 @@ export interface CliRendererConfig {
     useAlternateScreen?: boolean;
     useConsole?: boolean;
     experimental_splitHeight?: number;
+    useKittyKeyboard?: boolean;
 }
 export type PixelResolution = {
     width: number;
@@ -70,7 +72,7 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     private static animationFrameId;
     private lib;
     rendererPtr: Pointer;
-    private stdin;
+    stdin: NodeJS.ReadStream;
     private stdout;
     private exitOnCtrlC;
     private isDestroyed;
@@ -111,6 +113,7 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     };
     private _console;
     private _resolution;
+    private _keyHandler;
     private animationRequest;
     private resizeTimeoutId;
     private resizeDebounceDelay;
@@ -134,7 +137,17 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     private sigwinchHandler;
     private _capabilities;
     private _latestPointer;
+    private _currentFocusedRenderable;
+    private lifecyclePasses;
+    private handleError;
+    private exitHandler;
+    private warningHandler;
     constructor(lib: RenderLib, rendererPtr: Pointer, stdin: NodeJS.ReadStream, stdout: NodeJS.WriteStream, width: number, height: number, config?: CliRendererConfig);
+    registerLifecyclePass(renderable: Renderable): void;
+    unregisterLifecyclePass(renderable: Renderable): void;
+    getLifecyclePasses(): Set<Renderable>;
+    get currentFocusedRenderable(): Renderable | null;
+    focusRenderable(renderable: Renderable): void;
     addToHitGrid(x: number, y: number, width: number, height: number, id: number): void;
     get widthMethod(): WidthMethod;
     private writeOut;
@@ -144,6 +157,7 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     get isRunning(): boolean;
     get resolution(): PixelResolution | null;
     get console(): TerminalConsole;
+    get keyInput(): KeyHandler;
     get terminalWidth(): number;
     get terminalHeight(): number;
     get useThread(): boolean;
@@ -155,7 +169,7 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     get capabilities(): any | null;
     set experimental_splitHeight(splitHeight: number);
     private interceptStdoutWrite;
-    private disableStdoutInterception;
+    disableStdoutInterception(): void;
     private flushStdoutCache;
     private enableMouse;
     private disableMouse;
@@ -163,6 +177,8 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     disableKittyKeyboard(): void;
     set useThread(useThread: boolean);
     setupTerminal(): Promise<void>;
+    private stdinListener;
+    private setupInput;
     private handleMouseData;
     private takeMemorySnapshot;
     private startMemorySnapshotTimer;

package/testing/mock-keys.d.ts

@@ -0,0 +1,67 @@
+import type { CliRenderer } from "../renderer";
+export declare const KeyCodes: {
+    readonly ENTER: "\r";
+    readonly TAB: "\t";
+    readonly BACKSPACE: "\b";
+    readonly DELETE: "\u001B[3~";
+    readonly HOME: "\u001B[H";
+    readonly END: "\u001B[F";
+    readonly ESCAPE: "\u001B";
+    readonly ARROW_UP: "\u001B[A";
+    readonly ARROW_DOWN: "\u001B[B";
+    readonly ARROW_RIGHT: "\u001B[C";
+    readonly ARROW_LEFT: "\u001B[D";
+    readonly F1: "\u001BOP";
+    readonly F2: "\u001BOQ";
+    readonly F3: "\u001BOR";
+    readonly F4: "\u001BOS";
+    readonly F5: "\u001B[15~";
+    readonly F6: "\u001B[17~";
+    readonly F7: "\u001B[18~";
+    readonly F8: "\u001B[19~";
+    readonly F9: "\u001B[20~";
+    readonly F10: "\u001B[21~";
+    readonly F11: "\u001B[23~";
+    readonly F12: "\u001B[24~";
+    readonly CTRL_A: "\u0001";
+    readonly CTRL_B: "\u0002";
+    readonly CTRL_C: "\u0003";
+    readonly CTRL_D: "\u0004";
+    readonly CTRL_E: "\u0005";
+    readonly CTRL_F: "\u0006";
+    readonly CTRL_G: "\u0007";
+    readonly CTRL_H: "\b";
+    readonly CTRL_I: "\t";
+    readonly CTRL_J: "\n";
+    readonly CTRL_K: "\v";
+    readonly CTRL_L: "\f";
+    readonly CTRL_M: "\r";
+    readonly CTRL_N: "\u000E";
+    readonly CTRL_O: "\u000F";
+    readonly CTRL_P: "\u0010";
+    readonly CTRL_Q: "\u0011";
+    readonly CTRL_R: "\u0012";
+    readonly CTRL_S: "\u0013";
+    readonly CTRL_T: "\u0014";
+    readonly CTRL_U: "\u0015";
+    readonly CTRL_V: "\u0016";
+    readonly CTRL_W: "\u0017";
+    readonly CTRL_X: "\u0018";
+    readonly CTRL_Y: "\u0019";
+    readonly CTRL_Z: "\u001A";
+    readonly ALT_A: "\u001Ba";
+    readonly ALT_B: "\u001Bb";
+    readonly ALT_C: "\u001Bc";
+};
+export type KeyInput = string | keyof typeof KeyCodes;
+export declare function createMockKeys(renderer: CliRenderer): {
+    pressKeys: (keys: KeyInput[], delayMs?: number) => Promise<void>;
+    pressKey: (key: KeyInput) => void;
+    typeText: (text: string, delayMs?: number) => Promise<void>;
+    pressEnter: () => void;
+    pressEscape: () => void;
+    pressTab: () => void;
+    pressBackspace: () => void;
+    pressArrow: (direction: "up" | "down" | "left" | "right") => void;
+    pressCtrlC: () => void;
+};

package/testing/mock-mouse.d.ts

@@ -0,0 +1,38 @@
+import type { CliRenderer } from "../renderer";
+export declare const MouseButtons: {
+    readonly LEFT: 0;
+    readonly MIDDLE: 1;
+    readonly RIGHT: 2;
+    readonly WHEEL_UP: 64;
+    readonly WHEEL_DOWN: 65;
+    readonly WHEEL_LEFT: 66;
+    readonly WHEEL_RIGHT: 67;
+};
+export type MouseButton = (typeof MouseButtons)[keyof typeof MouseButtons];
+export interface MousePosition {
+    x: number;
+    y: number;
+}
+export interface MouseModifiers {
+    shift?: boolean;
+    alt?: boolean;
+    ctrl?: boolean;
+}
+export type MouseEventType = "down" | "up" | "move" | "drag" | "scroll";
+export interface MouseEventOptions {
+    button?: MouseButton;
+    modifiers?: MouseModifiers;
+    delayMs?: number;
+}
+export declare function createMockMouse(renderer: CliRenderer): {
+    moveTo: (x: number, y: number, options?: MouseEventOptions) => Promise<void>;
+    click: (x: number, y: number, button?: MouseButton, options?: MouseEventOptions) => Promise<void>;
+    doubleClick: (x: number, y: number, button?: MouseButton, options?: MouseEventOptions) => Promise<void>;
+    pressDown: (x: number, y: number, button?: MouseButton, options?: MouseEventOptions) => Promise<void>;
+    release: (x: number, y: number, button?: MouseButton, options?: MouseEventOptions) => Promise<void>;
+    drag: (startX: number, startY: number, endX: number, endY: number, button?: MouseButton, options?: MouseEventOptions) => Promise<void>;
+    scroll: (x: number, y: number, direction: "up" | "down" | "left" | "right", options?: MouseEventOptions) => Promise<void>;
+    getCurrentPosition: () => MousePosition;
+    getPressedButtons: () => MouseButton[];
+    emitMouseEvent: (type: MouseEventType, x: number, y: number, button?: MouseButton, options?: Omit<MouseEventOptions, "button">) => Promise<void>;
+};

package/testing/test-renderer.d.ts

@@ -0,0 +1,18 @@
+import { CliRenderer, type CliRendererConfig } from "../renderer";
+import { createMockKeys } from "./mock-keys";
+import { createMockMouse } from "./mock-mouse";
+export interface TestRendererOptions extends CliRendererConfig {
+    width?: number;
+    height?: number;
+}
+export interface TestRenderer extends CliRenderer {
+}
+export type MockInput = ReturnType<typeof createMockKeys>;
+export type MockMouse = ReturnType<typeof createMockMouse>;
+export declare function createTestRenderer(options: TestRendererOptions): Promise<{
+    renderer: TestRenderer;
+    mockInput: MockInput;
+    mockMouse: MockMouse;
+    renderOnce: () => Promise<void>;
+    captureCharFrame: () => string;
+}>;

package/testing.d.ts

@@ -0,0 +1,3 @@
+export * from "./testing/test-renderer";
+export * from "./testing/mock-keys";
+export * from "./testing/mock-mouse";