@opentuah/core 0.1.77

package/renderables/composition/vnode.d.ts

@@ -0,0 +1,46 @@
+import { Renderable, type RenderableOptions } from "../../Renderable";
+import type { RenderContext } from "../../types";
+export type VChild = VNode | Renderable | VChild[] | null | undefined | false;
+export interface PendingCall {
+    method: string;
+    args: any[];
+    isProperty?: boolean;
+}
+declare const BrandedVNode: unique symbol;
+export interface VNode<P = any, C = VChild[]> {
+    [BrandedVNode]: true;
+    type: Construct<P>;
+    props?: P;
+    children?: C;
+    __delegateMap?: Record<string, string>;
+    __pendingCalls?: PendingCall[];
+}
+export type ProxiedVNode<TCtor extends RenderableConstructor<any>> = VNode<TCtor extends RenderableConstructor<infer P> ? P : any> & {
+    [K in keyof InstanceType<TCtor>]: InstanceType<TCtor>[K] extends (...args: infer Args) => any ? (...args: Args) => ProxiedVNode<TCtor> : InstanceType<TCtor>[K];
+};
+export interface RenderableConstructor<P extends RenderableOptions<any> = RenderableOptions<any>> {
+    new (ctx: RenderContext, options: P): Renderable;
+}
+export type FunctionalConstruct<P = any> = (props: P, children?: VChild[]) => VNode;
+export type Construct<P = any> = RenderableConstructor<P extends RenderableOptions<any> ? P : never> | FunctionalConstruct<P>;
+export declare function h<TCtor extends RenderableConstructor<any>>(type: TCtor, props?: TCtor extends RenderableConstructor<infer P> ? P : never, ...children: VChild[]): ProxiedVNode<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[]> | 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;
+};
+export declare function instantiate<NodeType extends VNode | Renderable>(ctx: RenderContext, node: NodeType): InstantiateFn<NodeType>;
+export type DelegateMap<T> = Partial<Record<keyof T, string>>;
+export type ValidateShape<Given, AllowedKeys> = {
+    [K in keyof Given]: K extends keyof AllowedKeys ? NonNullable<Given[K]> : never;
+};
+type InferNode<T> = T extends InstantiateFn<infer U> ? U : never;
+export declare function delegate<Factory extends InstantiateFn<any>, InnerNode extends InferNode<Factory>, TargetMap extends Record<keyof InnerNode, string>, const Mapping extends Partial<TargetMap>>(mapping: ValidateShape<Mapping, TargetMap>, vnode: Factory): Renderable;
+export declare function delegate<ConstructorType extends RenderableConstructor<any>, TargetMap extends Record<keyof InstanceType<ConstructorType>, string>, const Mapping extends Partial<TargetMap>>(mapping: ValidateShape<Mapping, TargetMap>, vnode: ProxiedVNode<ConstructorType>): ProxiedVNode<ConstructorType>;
+export declare function delegate<ConstructorType extends RenderableConstructor<any>, const Mapping extends DelegateMap<InstanceType<ConstructorType>>>(mapping: ValidateShape<Mapping, string>, vnode: VNode & {
+    type: ConstructorType;
+}): VNode;
+export {};

package/renderables/index.d.ts

@@ -0,0 +1,20 @@
+export * from "./ASCIIFont";
+export * from "./Box";
+export * from "./Code";
+export * from "./composition/constructs";
+export * from "./composition/VRenderable";
+export * from "./composition/vnode";
+export * from "./Diff";
+export * from "./FrameBuffer";
+export * from "./Input";
+export * from "./LineNumberRenderable";
+export * from "./Markdown";
+export * from "./ScrollBar";
+export * from "./ScrollBox";
+export * from "./Select";
+export * from "./Slider";
+export * from "./TabSelect";
+export * from "./Text";
+export * from "./TextBufferRenderable";
+export * from "./TextNode";
+export * from "./Textarea";

package/renderables/markdown-parser.d.ts

@@ -0,0 +1,10 @@
+import { type MarkedToken } from "marked";
+export interface ParseState {
+    content: string;
+    tokens: MarkedToken[];
+}
+/**
+ * Incrementally parse markdown, reusing unchanged tokens from previous parse.
+ * Compares token.raw at each offset - matching tokens keep same object reference.
+ */
+export declare function parseMarkdownIncremental(newContent: string, prevState: ParseState | null, trailingUnstable?: number): ParseState;

package/renderer.d.ts

@@ -0,0 +1,370 @@
+import { Renderable, RootRenderable } from "./Renderable";
+import { type CursorStyle, DebugOverlayCorner, type RenderContext, type WidthMethod } from "./types";
+import { RGBA, type ColorInput } from "./lib/RGBA";
+import type { Pointer } from "bun:ffi";
+import { OptimizedBuffer } from "./buffer";
+import { type RenderLib } from "./zig";
+import { TerminalConsole, type ConsoleOptions } from "./console";
+import { type MouseEventType, type RawMouseEvent, type ScrollInfo } from "./lib/parse.mouse";
+import { Selection } from "./lib/selection";
+import { type ClipboardTarget } from "./lib/clipboard";
+import { EventEmitter } from "events";
+import { KeyHandler, InternalKeyHandler } from "./lib/KeyHandler";
+import { type TerminalColors, type GetPaletteOptions } from "./lib/terminal-palette";
+export interface CliRendererConfig {
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+    remote?: boolean;
+    exitOnCtrlC?: boolean;
+    exitSignals?: NodeJS.Signals[];
+    debounceDelay?: number;
+    targetFps?: number;
+    maxFps?: number;
+    memorySnapshotInterval?: number;
+    useThread?: boolean;
+    gatherStats?: boolean;
+    maxStatSamples?: number;
+    consoleOptions?: ConsoleOptions;
+    postProcessFns?: ((buffer: OptimizedBuffer, deltaTime: number) => void)[];
+    enableMouseMovement?: boolean;
+    useMouse?: boolean;
+    autoFocus?: boolean;
+    useAlternateScreen?: boolean;
+    useConsole?: boolean;
+    experimental_splitHeight?: number;
+    useKittyKeyboard?: KittyKeyboardOptions | null;
+    backgroundColor?: ColorInput;
+    openConsoleOnError?: boolean;
+    prependInputHandlers?: ((sequence: string) => boolean)[];
+    onDestroy?: () => void;
+}
+export type PixelResolution = {
+    width: number;
+    height: number;
+};
+/**
+ * Kitty Keyboard Protocol configuration options
+ * See: https://sw.kovidgoyal.net/kitty/keyboard-protocol/#progressive-enhancement
+ */
+export interface KittyKeyboardOptions {
+    /** Disambiguate escape codes (fixes ESC timing, alt+key ambiguity, ctrl+c as event). Default: true */
+    disambiguate?: boolean;
+    /** Report alternate keys (numpad, shifted, base layout) for cross-keyboard shortcuts. Default: true */
+    alternateKeys?: boolean;
+    /** Report event types (press/repeat/release). Default: false */
+    events?: boolean;
+    /** Report all keys as escape codes. Default: false */
+    allKeysAsEscapes?: boolean;
+    /** Report text associated with key events. Default: false */
+    reportText?: boolean;
+}
+/**
+ * Build kitty keyboard protocol flags based on configuration
+ * @param config Kitty keyboard configuration object (null/undefined = disabled)
+ * @returns The combined flags value (0 = disabled, >0 = enabled)
+ * @internal Exported for testing
+ */
+export declare function buildKittyKeyboardFlags(config: KittyKeyboardOptions | null | undefined): number;
+export declare class MouseEvent {
+    readonly type: MouseEventType;
+    readonly button: number;
+    readonly x: number;
+    readonly y: number;
+    readonly source?: Renderable;
+    readonly modifiers: {
+        shift: boolean;
+        alt: boolean;
+        ctrl: boolean;
+    };
+    readonly scroll?: ScrollInfo;
+    readonly target: Renderable | null;
+    readonly isDragging?: boolean;
+    private _propagationStopped;
+    private _defaultPrevented;
+    get propagationStopped(): boolean;
+    get defaultPrevented(): boolean;
+    constructor(target: Renderable | null, attributes: RawMouseEvent & {
+        source?: Renderable;
+        isDragging?: boolean;
+    });
+    stopPropagation(): void;
+    preventDefault(): void;
+}
+export declare enum MouseButton {
+    LEFT = 0,
+    MIDDLE = 1,
+    RIGHT = 2,
+    WHEEL_UP = 4,
+    WHEEL_DOWN = 5
+}
+export declare function createCliRenderer(config?: CliRendererConfig): Promise<CliRenderer>;
+export declare enum CliRenderEvents {
+    DEBUG_OVERLAY_TOGGLE = "debugOverlay:toggle",
+    DESTROY = "destroy"
+}
+export declare enum RendererControlState {
+    IDLE = "idle",
+    AUTO_STARTED = "auto_started",
+    EXPLICIT_STARTED = "explicit_started",
+    EXPLICIT_PAUSED = "explicit_paused",
+    EXPLICIT_SUSPENDED = "explicit_suspended",
+    EXPLICIT_STOPPED = "explicit_stopped"
+}
+export declare class CliRenderer extends EventEmitter implements RenderContext {
+    private static animationFrameId;
+    private lib;
+    rendererPtr: Pointer;
+    stdin: NodeJS.ReadStream;
+    private stdout;
+    private exitOnCtrlC;
+    private exitSignals;
+    private _exitListenersAdded;
+    private _isDestroyed;
+    private _destroyPending;
+    private _destroyFinalized;
+    nextRenderBuffer: OptimizedBuffer;
+    currentRenderBuffer: OptimizedBuffer;
+    private _isRunning;
+    private targetFps;
+    private maxFps;
+    private automaticMemorySnapshot;
+    private memorySnapshotInterval;
+    private memorySnapshotTimer;
+    private lastMemorySnapshot;
+    readonly root: RootRenderable;
+    width: number;
+    height: number;
+    private _useThread;
+    private gatherStats;
+    private frameTimes;
+    private maxStatSamples;
+    private postProcessFns;
+    private backgroundColor;
+    private waitingForPixelResolution;
+    private rendering;
+    private renderingNative;
+    private renderTimeout;
+    private lastTime;
+    private frameCount;
+    private lastFpsTime;
+    private currentFps;
+    private targetFrameTime;
+    private minTargetFrameTime;
+    private immediateRerenderRequested;
+    private updateScheduled;
+    private liveRequestCounter;
+    private _controlState;
+    private frameCallbacks;
+    private renderStats;
+    debugOverlay: {
+        enabled: any;
+        corner: DebugOverlayCorner;
+    };
+    private _console;
+    private _resolution;
+    private _keyHandler;
+    private _stdinBuffer;
+    private animationRequest;
+    private resizeTimeoutId;
+    private capabilityTimeoutId;
+    private resizeDebounceDelay;
+    private enableMouseMovement;
+    private _useMouse;
+    private autoFocus;
+    private _useAlternateScreen;
+    private _suspendedMouseEnabled;
+    private _previousControlState;
+    private capturedRenderable?;
+    private lastOverRenderableNum;
+    private lastOverRenderable?;
+    private currentSelection;
+    private selectionContainers;
+    private clipboard;
+    private _splitHeight;
+    private renderOffset;
+    private _terminalWidth;
+    private _terminalHeight;
+    private _terminalIsSetup;
+    private realStdoutWrite;
+    private captureCallback;
+    private _useConsole;
+    private mouseParser;
+    private sigwinchHandler;
+    private _capabilities;
+    private _latestPointer;
+    private _hasPointer;
+    private _lastPointerModifiers;
+    private _currentFocusedRenderable;
+    private lifecyclePasses;
+    private _openConsoleOnError;
+    private _paletteDetector;
+    private _cachedPalette;
+    private _paletteDetectionPromise;
+    private _onDestroy?;
+    private inputHandlers;
+    private prependedInputHandlers;
+    private idleResolvers;
+    private _debugInputs;
+    private _debugModeEnabled;
+    private handleError;
+    private dumpOutputCache;
+    private exitHandler;
+    private warningHandler;
+    get controlState(): RendererControlState;
+    constructor(lib: RenderLib, rendererPtr: Pointer, stdin: NodeJS.ReadStream, stdout: NodeJS.WriteStream, width: number, height: number, config?: CliRendererConfig);
+    private addExitListeners;
+    private removeExitListeners;
+    get isDestroyed(): boolean;
+    registerLifecyclePass(renderable: Renderable): void;
+    unregisterLifecyclePass(renderable: Renderable): void;
+    getLifecyclePasses(): Set<Renderable>;
+    get currentFocusedRenderable(): Renderable | null;
+    focusRenderable(renderable: Renderable): void;
+    private setCapturedRenderable;
+    addToHitGrid(x: number, y: number, width: number, height: number, id: number): void;
+    pushHitGridScissorRect(x: number, y: number, width: number, height: number): void;
+    popHitGridScissorRect(): void;
+    clearHitGridScissorRects(): void;
+    get widthMethod(): WidthMethod;
+    private writeOut;
+    requestRender(): void;
+    private activateFrame;
+    get useConsole(): boolean;
+    set useConsole(value: boolean);
+    get isRunning(): boolean;
+    private isIdleNow;
+    private resolveIdleIfNeeded;
+    idle(): Promise<void>;
+    get resolution(): PixelResolution | null;
+    get console(): TerminalConsole;
+    get keyInput(): KeyHandler;
+    get _internalKeyInput(): InternalKeyHandler;
+    get terminalWidth(): number;
+    get terminalHeight(): number;
+    get useThread(): boolean;
+    get useMouse(): boolean;
+    set useMouse(useMouse: boolean);
+    get experimental_splitHeight(): number;
+    get liveRequestCount(): number;
+    get currentControlState(): string;
+    get capabilities(): any | null;
+    getDebugInputs(): Array<{
+        timestamp: string;
+        sequence: string;
+    }>;
+    get useKittyKeyboard(): boolean;
+    set useKittyKeyboard(use: boolean);
+    set experimental_splitHeight(splitHeight: number);
+    private interceptStdoutWrite;
+    disableStdoutInterception(): void;
+    private flushStdoutCache;
+    private enableMouse;
+    private disableMouse;
+    enableKittyKeyboard(flags?: number): void;
+    disableKittyKeyboard(): void;
+    set useThread(useThread: boolean);
+    setupTerminal(): Promise<void>;
+    private stdinListener;
+    addInputHandler(handler: (sequence: string) => boolean): void;
+    prependInputHandler(handler: (sequence: string) => boolean): void;
+    removeInputHandler(handler: (sequence: string) => boolean): void;
+    private capabilityHandler;
+    private focusHandler;
+    private setupInput;
+    private dispatchMouseEvent;
+    private handleMouseData;
+    /**
+     * Recheck hover state after hit grid changes.
+     * Called after render when native code detects the hit grid changed.
+     * Fires out/over events if the element under the cursor changed.
+     */
+    private recheckHoverState;
+    hitTest(x: number, y: number): number;
+    private takeMemorySnapshot;
+    private startMemorySnapshotTimer;
+    private stopMemorySnapshotTimer;
+    setMemorySnapshotInterval(interval: number): void;
+    private handleResize;
+    private queryPixelResolution;
+    private processResize;
+    setBackgroundColor(color: ColorInput): void;
+    toggleDebugOverlay(): void;
+    configureDebugOverlay(options: {
+        enabled?: boolean;
+        corner?: DebugOverlayCorner;
+    }): void;
+    setTerminalTitle(title: string): void;
+    copyToClipboardOSC52(text: string, target?: ClipboardTarget): boolean;
+    clearClipboardOSC52(target?: ClipboardTarget): boolean;
+    isOsc52Supported(): boolean;
+    dumpHitGrid(): void;
+    dumpBuffers(timestamp?: number): void;
+    dumpStdoutBuffer(timestamp?: number): void;
+    static setCursorPosition(renderer: CliRenderer, x: number, y: number, visible?: boolean): void;
+    static setCursorStyle(renderer: CliRenderer, style: CursorStyle, blinking?: boolean, color?: RGBA): void;
+    static setCursorColor(renderer: CliRenderer, color: RGBA): void;
+    setCursorPosition(x: number, y: number, visible?: boolean): void;
+    setCursorStyle(style: CursorStyle, blinking?: boolean, color?: RGBA): void;
+    setCursorColor(color: RGBA): void;
+    getCursorState(): import("./zig").CursorState;
+    addPostProcessFn(processFn: (buffer: OptimizedBuffer, deltaTime: number) => void): void;
+    removePostProcessFn(processFn: (buffer: OptimizedBuffer, deltaTime: number) => void): void;
+    clearPostProcessFns(): void;
+    setFrameCallback(callback: (deltaTime: number) => Promise<void>): void;
+    removeFrameCallback(callback: (deltaTime: number) => Promise<void>): void;
+    clearFrameCallbacks(): void;
+    requestLive(): void;
+    dropLive(): void;
+    start(): void;
+    auto(): void;
+    private internalStart;
+    pause(): void;
+    suspend(): void;
+    resume(): void;
+    private internalPause;
+    stop(): void;
+    private internalStop;
+    destroy(): void;
+    private finalizeDestroy;
+    private startRenderLoop;
+    private loop;
+    intermediateRender(): void;
+    private renderNative;
+    private collectStatSample;
+    getStats(): {
+        fps: number;
+        frameCount: number;
+        frameTimes: number[];
+        averageFrameTime: number;
+        minFrameTime: number;
+        maxFrameTime: number;
+    };
+    resetStats(): void;
+    setGatherStats(enabled: boolean): void;
+    getSelection(): Selection | null;
+    get hasSelection(): boolean;
+    getSelectionContainer(): Renderable | null;
+    clearSelection(): void;
+    /**
+     * Start a new selection at the given coordinates.
+     * Used by both mouse and keyboard selection.
+     */
+    startSelection(renderable: Renderable, x: number, y: number): void;
+    updateSelection(currentRenderable: Renderable | undefined, x: number, y: number, options?: {
+        finishDragging?: boolean;
+    }): void;
+    requestSelectionUpdate(): void;
+    private isWithinContainer;
+    private finishSelection;
+    private notifySelectablesOfSelectionChange;
+    private walkSelectableRenderables;
+    get paletteDetectionStatus(): "idle" | "detecting" | "cached";
+    clearPaletteCache(): void;
+    /**
+     * Detects the terminal's color palette
+     *
+     * @returns Promise resolving to TerminalColors object containing palette and special colors
+     * @throws Error if renderer is suspended
+     */
+    getPalette(options?: GetPaletteOptions): Promise<TerminalColors>;
+}

package/syntax-style.d.ts

@@ -0,0 +1,54 @@
+import { RGBA, type ColorInput } from "./lib/RGBA";
+import { type RenderLib } from "./zig";
+import { type Pointer } from "bun:ffi";
+export interface StyleDefinition {
+    fg?: RGBA;
+    bg?: RGBA;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    dim?: boolean;
+}
+export interface MergedStyle {
+    fg?: RGBA;
+    bg?: RGBA;
+    attributes: number;
+}
+export interface ThemeTokenStyle {
+    scope: string[];
+    style: {
+        foreground?: ColorInput;
+        background?: ColorInput;
+        bold?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        dim?: boolean;
+    };
+}
+export declare function convertThemeToStyles(theme: ThemeTokenStyle[]): Record<string, StyleDefinition>;
+export declare class SyntaxStyle {
+    private lib;
+    private stylePtr;
+    private _destroyed;
+    private nameCache;
+    private styleDefs;
+    private mergedCache;
+    constructor(lib: RenderLib, ptr: Pointer);
+    static create(): SyntaxStyle;
+    static fromTheme(theme: ThemeTokenStyle[]): SyntaxStyle;
+    static fromStyles(styles: Record<string, StyleDefinition>): SyntaxStyle;
+    private guard;
+    registerStyle(name: string, style: StyleDefinition): number;
+    resolveStyleId(name: string): number | null;
+    getStyleId(name: string): number | null;
+    get ptr(): Pointer;
+    getStyleCount(): number;
+    clearNameCache(): void;
+    getStyle(name: string): StyleDefinition | undefined;
+    mergeStyles(...styleNames: string[]): MergedStyle;
+    clearCache(): void;
+    getCacheSize(): number;
+    getAllStyles(): Map<string, StyleDefinition>;
+    getRegisteredNames(): string[];
+    destroy(): void;
+}

package/testing/mock-keys.d.ts

@@ -0,0 +1,80 @@
+import type { CliRenderer } from "../renderer";
+export declare const KeyCodes: {
+    readonly RETURN: "\r";
+    readonly LINEFEED: "\n";
+    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~";
+};
+export type KeyInput = string | keyof typeof KeyCodes;
+export interface MockKeysOptions {
+    kittyKeyboard?: boolean;
+    otherModifiersMode?: boolean;
+}
+export declare function createMockKeys(renderer: CliRenderer, options?: MockKeysOptions): {
+    pressKeys: (keys: KeyInput[], delayMs?: number) => Promise<void>;
+    pressKey: (key: KeyInput, modifiers?: {
+        shift?: boolean;
+        ctrl?: boolean;
+        meta?: boolean;
+        super?: boolean;
+        hyper?: boolean;
+    }) => void;
+    typeText: (text: string, delayMs?: number) => Promise<void>;
+    pressEnter: (modifiers?: {
+        shift?: boolean;
+        ctrl?: boolean;
+        meta?: boolean;
+        super?: boolean;
+        hyper?: boolean;
+    }) => void;
+    pressEscape: (modifiers?: {
+        shift?: boolean;
+        ctrl?: boolean;
+        meta?: boolean;
+        super?: boolean;
+        hyper?: boolean;
+    }) => void;
+    pressTab: (modifiers?: {
+        shift?: boolean;
+        ctrl?: boolean;
+        meta?: boolean;
+        super?: boolean;
+        hyper?: boolean;
+    }) => void;
+    pressBackspace: (modifiers?: {
+        shift?: boolean;
+        ctrl?: boolean;
+        meta?: boolean;
+        super?: boolean;
+        hyper?: boolean;
+    }) => void;
+    pressArrow: (direction: "up" | "down" | "left" | "right", modifiers?: {
+        shift?: boolean;
+        ctrl?: boolean;
+        meta?: boolean;
+        super?: boolean;
+        hyper?: boolean;
+    }) => void;
+    pressCtrlC: () => void;
+    pasteBracketedText: (text: string) => Promise<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/mock-tree-sitter-client.d.ts

@@ -0,0 +1,23 @@
+import { TreeSitterClient } from "../lib/tree-sitter";
+import type { SimpleHighlight } from "../lib/tree-sitter/types";
+export declare class MockTreeSitterClient extends TreeSitterClient {
+    private _highlightPromises;
+    private _mockResult;
+    private _autoResolveTimeout?;
+    constructor(options?: {
+        autoResolveTimeout?: number;
+    });
+    highlightOnce(content: string, filetype: string): Promise<{
+        highlights?: SimpleHighlight[];
+        warning?: string;
+        error?: string;
+    }>;
+    setMockResult(result: {
+        highlights?: SimpleHighlight[];
+        warning?: string;
+        error?: string;
+    }): void;
+    resolveHighlightOnce(index?: number): void;
+    resolveAllHighlightOnce(): void;
+    isHighlighting(): boolean;
+}

package/testing/spy.d.ts

@@ -0,0 +1,7 @@
+export declare function createSpy(): {
+    (...args: any[]): void;
+    calls: any[][];
+    callCount(): number;
+    calledWith(...expected: any[]): boolean;
+    reset(): number;
+};