@opentui/core 0.0.0-20250908-4906ddad → 0.0.0-20250912-12c969f4

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/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-20250912-12c969f4",
   "description": "OpenTUI is a TypeScript library for building terminal user interfaces (TUIs)",
   "license": "MIT",
   "repository": {
@@ -38,11 +38,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-20250912-12c969f4",
+    "@opentui/core-darwin-arm64": "0.0.0-20250912-12c969f4",
+    "@opentui/core-linux-x64": "0.0.0-20250912-12c969f4",
+    "@opentui/core-linux-arm64": "0.0.0-20250912-12c969f4",
+    "@opentui/core-win32-x64": "0.0.0-20250912-12c969f4",
+    "@opentui/core-win32-arm64": "0.0.0-20250912-12c969f4"
   }
 }

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,64 @@
+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;
+    set fg(fg: RGBA);
+    set bg(bg: RGBA);
+    set attributes(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

@@ -70,7 +70,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;
@@ -134,7 +134,14 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     private sigwinchHandler;
     private _capabilities;
     private _latestPointer;
+    private _currentFocusedRenderable;
+    private lifecyclePasses;
     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;
@@ -155,7 +162,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 +170,7 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     disableKittyKeyboard(): void;
     set useThread(useThread: boolean);
     setupTerminal(): Promise<void>;
+    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,15 @@
+import { CliRenderer, type CliRendererConfig } from "../renderer";
+import { createMockKeys } from "./mock-keys";
+import { createMockMouse } from "./mock-mouse";
+export interface TestRendererOptions extends CliRendererConfig {
+}
+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>;
+}>;

package/text-buffer.d.ts

@@ -5,8 +5,7 @@ import { type Pointer } from "bun:ffi";
 import { type WidthMethod } from "./types";
 export interface TextChunk {
     __isChunk: true;
-    text: Uint8Array;
-    plainText: string;
+    text: string;
     fg?: RGBA;
     bg?: RGBA;
     attributes?: number;
@@ -17,8 +16,10 @@ export declare class TextBuffer {
     private _length;
     private _capacity;
     private _lineInfo?;
+    private _destroyed;
     constructor(lib: RenderLib, ptr: Pointer, capacity: number);
     static create(capacity: number | undefined, widthMethod: WidthMethod): TextBuffer;
+    private guard;
     setStyledText(text: StyledText): void;
     setDefaultFg(fg: RGBA | null): void;
     setDefaultBg(bg: RGBA | null): void;

package/types.d.ts

@@ -1,6 +1,7 @@
 import type { RGBA } from "./lib/RGBA";
 import type { EventEmitter } from "events";
 import type { Selection } from "./lib/selection";
+import type { Renderable } from "./Renderable";
 export declare const TextAttributes: {
     NONE: number;
     BOLD: number;
@@ -46,6 +47,11 @@ export interface RenderContext extends EventEmitter {
     hasSelection: boolean;
     getSelection: () => Selection | null;
     requestSelectionUpdate: () => void;
+    currentFocusedRenderable: Renderable | null;
+    focusRenderable: (renderable: Renderable) => void;
+    registerLifecyclePass: (renderable: Renderable) => void;
+    unregisterLifecyclePass: (renderable: Renderable) => void;
+    getLifecyclePasses: () => Set<Renderable>;
 }
 export type Timeout = ReturnType<typeof setTimeout> | undefined;
 export interface ViewportBounds {

package/utils.d.ts

@@ -1,3 +1,4 @@
+import { Renderable } from "./Renderable";
 export declare function createTextAttributes({ bold, italic, underline, dim, blink, inverse, hidden, strikethrough, }?: {
     bold?: boolean;
     italic?: boolean;
@@ -8,3 +9,4 @@ export declare function createTextAttributes({ bold, italic, underline, dim, bli
     hidden?: boolean;
     strikethrough?: boolean;
 }): number;
+export declare function visualizeRenderableTree(renderable: Renderable, maxDepth?: number): void;

package/zig.d.ts

@@ -10,7 +10,9 @@ export declare enum LogLevel {
     Debug = 3
 }
 export interface RenderLib {
-    createRenderer: (width: number, height: number) => Pointer | null;
+    createRenderer: (width: number, height: number, options?: {
+        testing: boolean;
+    }) => Pointer | null;
     destroyRenderer: (renderer: Pointer, useAlternateScreen: boolean, splitHeight: number) => void;
     setUseThread: (renderer: Pointer, useThread: boolean) => void;
     setBackgroundColor: (renderer: Pointer, color: RGBA) => void;