ghostty-web 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,953 @@
+export declare class CanvasRenderer {
+    private canvas;
+    private ctx;
+    private fontSize;
+    private fontFamily;
+    private cursorStyle;
+    private cursorBlink;
+    private theme;
+    private devicePixelRatio;
+    private metrics;
+    private palette;
+    private cursorVisible;
+    private cursorBlinkInterval?;
+    private lastCursorPosition;
+    private selectionManager?;
+    constructor(canvas: HTMLCanvasElement, options?: RendererOptions);
+    private measureFont;
+    /**
+     * Remeasure font metrics (call after font loads or changes)
+     */
+    remeasureFont(): void;
+    private rgbToCSS;
+    /**
+     * Resize canvas to fit terminal dimensions
+     */
+    resize(cols: number, rows: number): void;
+    /**
+     * Render the terminal buffer to canvas
+     */
+    render(buffer: IRenderable, forceAll?: boolean): void;
+    /**
+     * Render a single line
+     */
+    private renderLine;
+    /**
+     * Render a single cell
+     */
+    private renderCell;
+    /**
+     * Render cursor
+     */
+    private renderCursor;
+    private startCursorBlink;
+    private stopCursorBlink;
+    /**
+     * Update theme colors
+     */
+    setTheme(theme: ITheme): void;
+    /**
+     * Update font size
+     */
+    setFontSize(size: number): void;
+    /**
+     * Update font family
+     */
+    setFontFamily(family: string): void;
+    /**
+     * Update cursor style
+     */
+    setCursorStyle(style: 'block' | 'underline' | 'bar'): void;
+    /**
+     * Enable/disable cursor blinking
+     */
+    setCursorBlink(enabled: boolean): void;
+    /**
+     * Get current font metrics
+     */
+    getMetrics(): FontMetrics;
+    /**
+     * Get canvas element (needed by SelectionManager)
+     */
+    getCanvas(): HTMLCanvasElement;
+    /**
+     * Set selection manager (for rendering selection overlay)
+     */
+    setSelectionManager(manager: SelectionManager): void;
+    /**
+     * Clear entire canvas
+     */
+    clear(): void;
+    /**
+     * Render selection overlay
+     */
+    private renderSelection;
+    /**
+     * Cleanup resources
+     */
+    dispose(): void;
+}
+
+/**
+ * Cell style flags (bitfield)
+ */
+export declare enum CellFlags {
+    BOLD = 1,
+    ITALIC = 2,
+    UNDERLINE = 4,
+    STRIKETHROUGH = 8,
+    INVERSE = 16,
+    INVISIBLE = 32,
+    BLINK = 64,
+    FAINT = 128
+}
+
+/**
+ * Cursor position and visibility
+ */
+export declare interface Cursor {
+    x: number;
+    y: number;
+    visible: boolean;
+}
+
+export declare class EventEmitter<T> {
+    private listeners;
+    fire(arg: T): void;
+    event: IEvent<T>;
+    dispose(): void;
+}
+
+export declare class FitAddon implements ITerminalAddon {
+    private _terminal?;
+    private _resizeObserver?;
+    private _resizeDebounceTimer?;
+    private _lastCols?;
+    private _lastRows?;
+    private _isResizing;
+    /**
+     * Activate the addon (called by Terminal.loadAddon)
+     */
+    activate(terminal: ITerminalCore): void;
+    /**
+     * Dispose the addon and clean up resources
+     */
+    dispose(): void;
+    /**
+     * Fit the terminal to its container
+     *
+     * Calculates optimal dimensions and resizes the terminal.
+     * Does nothing if dimensions cannot be calculated or haven't changed.
+     */
+    fit(): void;
+    /**
+     * Propose dimensions to fit the terminal to its container
+     *
+     * Calculates cols and rows based on:
+     * - Terminal container element dimensions (clientWidth/Height)
+     * - Terminal element padding
+     * - Font metrics (character cell size)
+     * - Scrollbar width reservation
+     *
+     * @returns Proposed dimensions or undefined if cannot calculate
+     */
+    proposeDimensions(): ITerminalDimensions | undefined;
+    /**
+     * Observe the terminal's container for resize events
+     *
+     * Sets up a ResizeObserver to automatically call fit() when the
+     * container size changes. Resize events are debounced to avoid
+     * excessive calls during window drag operations.
+     *
+     * Call dispose() to stop observing.
+     */
+    observeResize(): void;
+}
+
+export declare interface FontMetrics {
+    width: number;
+    height: number;
+    baseline: number;
+}
+
+/**
+ * Main Ghostty WASM wrapper class
+ */
+export declare class Ghostty {
+    private exports;
+    private memory;
+    constructor(wasmInstance: WebAssembly.Instance);
+    /**
+     * Get current memory buffer (may change when memory grows)
+     */
+    private getBuffer;
+    /**
+     * Create a key encoder instance
+     */
+    createKeyEncoder(): KeyEncoder;
+    /**
+     * Create a terminal emulator instance
+     */
+    createTerminal(cols?: number, rows?: number): GhosttyTerminal;
+    /**
+     * Load Ghostty WASM from URL or file path
+     * If no path is provided, attempts to load from common default locations
+     */
+    static load(wasmPath?: string): Promise<Ghostty>;
+}
+
+/**
+ * Cell structure matching ghostty_cell_t in C (12 bytes)
+ */
+export declare interface GhosttyCell {
+    codepoint: number;
+    fg_r: number;
+    fg_g: number;
+    fg_b: number;
+    bg_r: number;
+    bg_g: number;
+    bg_b: number;
+    flags: number;
+    width: number;
+}
+
+/**
+ * GhosttyTerminal - Wraps the WASM terminal emulator
+ *
+ * Provides a TypeScript-friendly interface to Ghostty's complete
+ * terminal implementation via WASM.
+ *
+ * @example
+ * ```typescript
+ * const ghostty = await Ghostty.load('./ghostty-vt.wasm');
+ * const term = ghostty.createTerminal(80, 24);
+ *
+ * term.write('Hello\x1b[31m Red\x1b[0m\n');
+ * const cursor = term.getCursor();
+ * const cells = term.getLine(0);
+ *
+ * term.free();
+ * ```
+ */
+export declare class GhosttyTerminal {
+    private exports;
+    private memory;
+    private handle;
+    private _cols;
+    private _rows;
+    /**
+     * Size of ghostty_cell_t in bytes (12 bytes in WASM)
+     * Structure: codepoint(u32) + fg_rgb(3xu8) + bg_rgb(3xu8) + flags(u8) + width(u8)
+     */
+    private static readonly CELL_SIZE;
+    /**
+     * Create a new terminal.
+     *
+     * @param exports WASM exports
+     * @param memory WASM memory
+     * @param cols Number of columns (default: 80)
+     * @param rows Number of rows (default: 24)
+     * @throws Error if allocation fails
+     */
+    constructor(exports: GhosttyWasmExports, memory: WebAssembly.Memory, cols?: number, rows?: number);
+    /**
+     * Free the terminal. Must be called to prevent memory leaks.
+     */
+    free(): void;
+    /**
+     * Write data to terminal (parses VT sequences and updates screen).
+     *
+     * @param data UTF-8 string or Uint8Array
+     *
+     * @example
+     * ```typescript
+     * term.write('Hello, World!\n');
+     * term.write('\x1b[1;31mBold Red\x1b[0m\n');
+     * term.write(new Uint8Array([0x1b, 0x5b, 0x41])); // Up arrow
+     * ```
+     */
+    write(data: string | Uint8Array): void;
+    /**
+     * Resize the terminal.
+     *
+     * @param cols New column count
+     * @param rows New row count
+     */
+    resize(cols: number, rows: number): void;
+    /**
+     * Get terminal dimensions.
+     */
+    get cols(): number;
+    get rows(): number;
+    /**
+     * Get terminal dimensions (for IRenderable compatibility)
+     */
+    getDimensions(): {
+        cols: number;
+        rows: number;
+    };
+    /**
+     * Get cursor position and visibility.
+     */
+    getCursor(): Cursor;
+    /**
+     * Get scrollback length (number of lines in history).
+     */
+    getScrollbackLength(): number;
+    /**
+     * Get a line of cells from the visible screen.
+     *
+     * @param y Line number (0 = top visible line)
+     * @returns Array of cells, or null if y is out of bounds
+     *
+     * @example
+     * ```typescript
+     * const cells = term.getLine(0);
+     * if (cells) {
+     *   for (const cell of cells) {
+     *     const char = String.fromCodePoint(cell.codepoint);
+     *     const isBold = (cell.flags & CellFlags.BOLD) !== 0;
+     *     console.log(`"${char}" ${isBold ? 'bold' : 'normal'}`);
+     *   }
+     * }
+     * ```
+     */
+    getLine(y: number): GhosttyCell[] | null;
+    /**
+     * Get a line from scrollback history.
+     *
+     * @param offset Line offset from top of scrollback (0 = oldest line)
+     * @returns Array of cells, or null if not available
+     */
+    getScrollbackLine(offset: number): GhosttyCell[] | null;
+    /**
+     * Check if any part of the screen is dirty.
+     */
+    isDirty(): boolean;
+    /**
+     * Check if a specific row is dirty.
+     */
+    isRowDirty(y: number): boolean;
+    /**
+     * Clear all dirty flags (call after rendering).
+     */
+    clearDirty(): void;
+    /**
+     * Get all visible lines at once (convenience method).
+     *
+     * @returns Array of line arrays, or empty array on error
+     */
+    getAllLines(): GhosttyCell[][];
+    /**
+     * Get only the dirty lines (for optimized rendering).
+     *
+     * @returns Map of row number to cell array
+     */
+    getDirtyLines(): Map<number, GhosttyCell[]>;
+}
+
+/**
+ * Interface for libghostty-vt WASM exports
+ */
+declare interface GhosttyWasmExports extends WebAssembly.Exports {
+    memory: WebAssembly.Memory;
+    ghostty_wasm_alloc_opaque(): number;
+    ghostty_wasm_free_opaque(ptr: number): void;
+    ghostty_wasm_alloc_u8_array(len: number): number;
+    ghostty_wasm_free_u8_array(ptr: number, len: number): void;
+    ghostty_wasm_alloc_u16_array(len: number): number;
+    ghostty_wasm_free_u16_array(ptr: number, len: number): void;
+    ghostty_wasm_alloc_u8(): number;
+    ghostty_wasm_free_u8(ptr: number): void;
+    ghostty_wasm_alloc_usize(): number;
+    ghostty_wasm_free_usize(ptr: number): void;
+    ghostty_sgr_new(allocator: number, parserPtrPtr: number): number;
+    ghostty_sgr_free(parser: number): void;
+    ghostty_sgr_reset(parser: number): void;
+    ghostty_sgr_set_params(parser: number, paramsPtr: number, subsPtr: number, paramsLen: number): number;
+    ghostty_sgr_next(parser: number, attrPtr: number): boolean;
+    ghostty_sgr_attribute_tag(attrPtr: number): number;
+    ghostty_sgr_attribute_value(attrPtr: number, tagPtr: number): number;
+    ghostty_wasm_alloc_sgr_attribute(): number;
+    ghostty_wasm_free_sgr_attribute(ptr: number): void;
+    ghostty_key_encoder_new(allocator: number, encoderPtrPtr: number): number;
+    ghostty_key_encoder_free(encoder: number): void;
+    ghostty_key_encoder_setopt(encoder: number, option: number, valuePtr: number): number;
+    ghostty_key_encoder_encode(encoder: number, eventPtr: number, bufPtr: number, bufLen: number, writtenPtr: number): number;
+    ghostty_key_event_new(allocator: number, eventPtrPtr: number): number;
+    ghostty_key_event_free(event: number): void;
+    ghostty_key_event_set_action(event: number, action: number): void;
+    ghostty_key_event_set_key(event: number, key: number): void;
+    ghostty_key_event_set_mods(event: number, mods: number): void;
+    ghostty_key_event_set_utf8(event: number, ptr: number, len: number): void;
+    ghostty_terminal_new(cols: number, rows: number): TerminalHandle;
+    ghostty_terminal_new_with_config(cols: number, rows: number, configPtr: number): TerminalHandle;
+    ghostty_terminal_free(terminal: TerminalHandle): void;
+    ghostty_terminal_write(terminal: TerminalHandle, dataPtr: number, dataLen: number): void;
+    ghostty_terminal_resize(terminal: TerminalHandle, cols: number, rows: number): void;
+    ghostty_terminal_get_cols(terminal: TerminalHandle): number;
+    ghostty_terminal_get_rows(terminal: TerminalHandle): number;
+    ghostty_terminal_get_cursor_x(terminal: TerminalHandle): number;
+    ghostty_terminal_get_cursor_y(terminal: TerminalHandle): number;
+    ghostty_terminal_get_cursor_visible(terminal: TerminalHandle): boolean;
+    ghostty_terminal_is_dirty(terminal: TerminalHandle): boolean;
+    ghostty_terminal_is_row_dirty(terminal: TerminalHandle, row: number): boolean;
+    ghostty_terminal_clear_dirty(terminal: TerminalHandle): void;
+    ghostty_terminal_get_line(terminal: TerminalHandle, row: number, bufPtr: number, bufLen: number): number;
+    ghostty_terminal_get_scrollback_line(terminal: TerminalHandle, offset: number, bufPtr: number, bufLen: number): number;
+    ghostty_terminal_get_scrollback_length(terminal: TerminalHandle): number;
+}
+
+export declare interface IDisposable {
+    dispose(): void;
+}
+
+export declare type IEvent<T> = (listener: (arg: T) => void) => IDisposable;
+
+/**
+ * InputHandler class
+ * Attaches keyboard event listeners to a container and converts
+ * keyboard events to terminal input data
+ */
+export declare class InputHandler {
+    private encoder;
+    private container;
+    private onDataCallback;
+    private onBellCallback;
+    private keydownListener;
+    private keypressListener;
+    private pasteListener;
+    private isDisposed;
+    /**
+     * Create a new InputHandler
+     * @param ghostty - Ghostty instance (for creating KeyEncoder)
+     * @param container - DOM element to attach listeners to
+     * @param onData - Callback for terminal data (escape sequences to send to PTY)
+     * @param onBell - Callback for bell/beep event
+     */
+    constructor(ghostty: Ghostty, container: HTMLElement, onData: (data: string) => void, onBell: () => void);
+    /**
+     * Attach keyboard event listeners to container
+     */
+    private attach;
+    /**
+     * Map KeyboardEvent.code to USB HID Key enum value
+     * @param code - KeyboardEvent.code value
+     * @returns Key enum value or null if unmapped
+     */
+    private mapKeyCode;
+    /**
+     * Extract modifier flags from KeyboardEvent
+     * @param event - KeyboardEvent
+     * @returns Mods flags
+     */
+    private extractModifiers;
+    /**
+     * Check if this is a printable character with no special modifiers
+     * @param event - KeyboardEvent
+     * @returns true if printable character
+     */
+    private isPrintableCharacter;
+    /**
+     * Handle keydown event
+     * @param event - KeyboardEvent
+     */
+    private handleKeyDown;
+    /**
+     * Handle paste event from clipboard
+     * @param event - ClipboardEvent
+     */
+    private handlePaste;
+    /**
+     * Dispose the InputHandler and remove event listeners
+     */
+    dispose(): void;
+    /**
+     * Check if handler is disposed
+     */
+    isActive(): boolean;
+}
+
+export declare interface IRenderable {
+    getLine(y: number): GhosttyCell[] | null;
+    getCursor(): {
+        x: number;
+        y: number;
+        visible: boolean;
+    };
+    getDimensions(): {
+        cols: number;
+        rows: number;
+    };
+    isRowDirty(y: number): boolean;
+    clearDirty(): void;
+}
+
+export declare interface ITerminalAddon {
+    activate(terminal: ITerminalCore): void;
+    dispose(): void;
+}
+
+export declare interface ITerminalCore {
+    cols: number;
+    rows: number;
+    element?: HTMLElement;
+    textarea?: HTMLTextAreaElement;
+}
+
+export declare interface ITerminalDimensions {
+    cols: number;
+    rows: number;
+}
+
+/**
+ * xterm.js-compatible interfaces
+ */
+export declare interface ITerminalOptions {
+    cols?: number;
+    rows?: number;
+    cursorBlink?: boolean;
+    cursorStyle?: 'block' | 'underline' | 'bar';
+    theme?: ITheme;
+    scrollback?: number;
+    fontSize?: number;
+    fontFamily?: string;
+    allowTransparency?: boolean;
+    wasmPath?: string;
+}
+
+export declare interface ITheme {
+    foreground?: string;
+    background?: string;
+    cursor?: string;
+    cursorAccent?: string;
+    selectionBackground?: string;
+    selectionForeground?: string;
+    black?: string;
+    red?: string;
+    green?: string;
+    yellow?: string;
+    blue?: string;
+    magenta?: string;
+    cyan?: string;
+    white?: string;
+    brightBlack?: string;
+    brightRed?: string;
+    brightGreen?: string;
+    brightYellow?: string;
+    brightBlue?: string;
+    brightMagenta?: string;
+    brightCyan?: string;
+    brightWhite?: string;
+}
+
+/**
+ * Physical key codes (based on USB HID Usage Tables - Keyboard/Keypad Page 0x07)
+ * Reference: https://www.usb.org/sites/default/files/hut1_21.pdf
+ */
+export declare enum Key {
+    A = 4,
+    B = 5,
+    C = 6,
+    D = 7,
+    E = 8,
+    F = 9,
+    G = 10,
+    H = 11,
+    I = 12,
+    J = 13,
+    K = 14,
+    L = 15,
+    M = 16,
+    N = 17,
+    O = 18,
+    P = 19,
+    Q = 20,
+    R = 21,
+    S = 22,
+    T = 23,
+    U = 24,
+    V = 25,
+    W = 26,
+    X = 27,
+    Y = 28,
+    Z = 29,
+    ONE = 30,
+    TWO = 31,
+    THREE = 32,
+    FOUR = 33,
+    FIVE = 34,
+    SIX = 35,
+    SEVEN = 36,
+    EIGHT = 37,
+    NINE = 38,
+    ZERO = 39,
+    ENTER = 40,
+    ESCAPE = 41,
+    BACKSPACE = 42,
+    TAB = 43,
+    SPACE = 44,
+    MINUS = 45,// - and _
+    EQUAL = 46,// = and +
+    BRACKET_LEFT = 47,// [ and {
+    BRACKET_RIGHT = 48,// ] and }
+    BACKSLASH = 49,// \ and |
+    SEMICOLON = 51,// ; and :
+    QUOTE = 52,// ' and "
+    GRAVE = 53,// ` and ~
+    COMMA = 54,// , and <
+    PERIOD = 55,// . and >
+    SLASH = 56,// / and ?
+    CAPS_LOCK = 57,
+    F1 = 58,
+    F2 = 59,
+    F3 = 60,
+    F4 = 61,
+    F5 = 62,
+    F6 = 63,
+    F7 = 64,
+    F8 = 65,
+    F9 = 66,
+    F10 = 67,
+    F11 = 68,
+    F12 = 69,
+    PRINT_SCREEN = 70,
+    SCROLL_LOCK = 71,
+    PAUSE = 72,
+    INSERT = 73,
+    HOME = 74,
+    PAGE_UP = 75,
+    DELETE = 76,
+    END = 77,
+    PAGE_DOWN = 78,
+    RIGHT = 79,
+    LEFT = 80,
+    DOWN = 81,
+    UP = 82,
+    NUM_LOCK = 83,
+    KP_DIVIDE = 84,// Keypad /
+    KP_MULTIPLY = 85,// Keypad *
+    KP_MINUS = 86,// Keypad -
+    KP_PLUS = 87,// Keypad +
+    KP_ENTER = 88,// Keypad Enter
+    KP_1 = 89,
+    KP_2 = 90,
+    KP_3 = 91,
+    KP_4 = 92,
+    KP_5 = 93,
+    KP_6 = 94,
+    KP_7 = 95,
+    KP_8 = 96,
+    KP_9 = 97,
+    KP_0 = 98,
+    KP_PERIOD = 99,// Keypad .
+    NON_US_BACKSLASH = 100,// \ and | on non-US keyboards
+    APPLICATION = 101,// Context menu key
+    F13 = 104,
+    F14 = 105,
+    F15 = 106,
+    F16 = 107,
+    F17 = 108,
+    F18 = 109,
+    F19 = 110,
+    F20 = 111,
+    F21 = 112,
+    F22 = 113,
+    F23 = 114,
+    F24 = 115
+}
+
+/**
+ * Key action
+ */
+export declare enum KeyAction {
+    RELEASE = 0,
+    PRESS = 1,
+    REPEAT = 2
+}
+
+/**
+ * Key Encoder
+ * Converts keyboard events into terminal escape sequences
+ */
+export declare class KeyEncoder {
+    private exports;
+    private encoder;
+    constructor(exports: GhosttyWasmExports);
+    /**
+     * Set an encoder option
+     */
+    setOption(option: KeyEncoderOption, value: boolean | number): void;
+    /**
+     * Enable Kitty keyboard protocol with specified flags
+     */
+    setKittyFlags(flags: KittyKeyFlags): void;
+    /**
+     * Encode a key event to escape sequence
+     */
+    encode(event: KeyEvent): Uint8Array;
+    /**
+     * Free encoder resources
+     */
+    dispose(): void;
+}
+
+/**
+ * Key encoder options
+ */
+export declare enum KeyEncoderOption {
+    CURSOR_KEY_APPLICATION = 0,// DEC mode 1
+    KEYPAD_KEY_APPLICATION = 1,// DEC mode 66
+    IGNORE_KEYPAD_WITH_NUMLOCK = 2,// DEC mode 1035
+    ALT_ESC_PREFIX = 3,// DEC mode 1036
+    MODIFY_OTHER_KEYS_STATE_2 = 4,// xterm modifyOtherKeys
+    KITTY_KEYBOARD_FLAGS = 5
+}
+
+/**
+ * Key event structure
+ */
+export declare interface KeyEvent {
+    action: KeyAction;
+    key: Key;
+    mods: Mods;
+    consumedMods?: Mods;
+    composing?: boolean;
+    utf8?: string;
+    unshiftedCodepoint?: number;
+}
+
+/**
+ * Kitty keyboard protocol flags
+ * From include/ghostty/vt/key/encoder.h
+ */
+declare enum KittyKeyFlags {
+    DISABLED = 0,
+    DISAMBIGUATE = 1,// Disambiguate escape codes
+    REPORT_EVENTS = 2,// Report press and release
+    REPORT_ALTERNATES = 4,// Report alternate key codes
+    REPORT_ALL = 8,// Report all events
+    REPORT_ASSOCIATED = 16,// Report associated text
+    ALL = 31
+}
+
+/**
+ * Modifier keys
+ */
+export declare enum Mods {
+    NONE = 0,
+    SHIFT = 1,
+    CTRL = 2,
+    ALT = 4,
+    SUPER = 8,// Windows/Command key
+    CAPSLOCK = 16,
+    NUMLOCK = 32
+}
+
+export declare interface RendererOptions {
+    fontSize?: number;
+    fontFamily?: string;
+    cursorStyle?: 'block' | 'underline' | 'bar';
+    cursorBlink?: boolean;
+    theme?: ITheme;
+    devicePixelRatio?: number;
+}
+
+/**
+ * RGB color
+ */
+export declare interface RGB {
+    r: number;
+    g: number;
+    b: number;
+}
+
+export declare interface SelectionCoordinates {
+    startCol: number;
+    startRow: number;
+    endCol: number;
+    endRow: number;
+}
+
+export declare class SelectionManager {
+    private terminal;
+    private renderer;
+    private wasmTerm;
+    private selectionStart;
+    private selectionEnd;
+    private isSelecting;
+    private previousSelection;
+    private selectionChangedEmitter;
+    private boundMouseUpHandler;
+    constructor(terminal: Terminal, renderer: CanvasRenderer, wasmTerm: GhosttyTerminal);
+    /**
+     * Get the selected text as a string
+     */
+    getSelection(): string;
+    /**
+     * Check if there's an active selection
+     */
+    hasSelection(): boolean;
+    /**
+     * Check if currently in the process of selecting (mouse is down)
+     */
+    isActivelySelecting(): boolean;
+    /**
+     * Clear the selection
+     */
+    clearSelection(): void;
+    /**
+     * Select all text in the terminal
+     */
+    selectAll(): void;
+    /**
+     * Get normalized selection coordinates (for rendering)
+     */
+    getSelectionCoords(): SelectionCoordinates | null;
+    /**
+     * Get previous selection coordinates (for clearing old highlight)
+     */
+    getPreviousSelectionCoords(): SelectionCoordinates | null;
+    /**
+     * Clear the previous selection tracking (after redraw)
+     */
+    clearPreviousSelection(): void;
+    /**
+     * Get selection change event accessor
+     */
+    get onSelectionChange(): IEvent<void>;
+    /**
+     * Cleanup resources
+     */
+    dispose(): void;
+    /**
+     * Attach mouse event listeners to canvas
+     */
+    private attachEventListeners;
+    /**
+     * Convert pixel coordinates to terminal cell coordinates
+     */
+    private pixelToCell;
+    /**
+     * Normalize selection coordinates (handle backward selection)
+     */
+    private normalizeSelection;
+    /**
+     * Get word boundaries at a cell position
+     */
+    private getWordAtCell;
+    /**
+     * Copy text to clipboard
+     */
+    private copyToClipboard;
+    /**
+     * Fallback clipboard copy using execCommand (works in more contexts)
+     */
+    private copyToClipboardFallback;
+    /**
+     * Request a render update (triggers selection overlay redraw)
+     */
+    private requestRender;
+}
+
+export declare class Terminal implements ITerminalCore {
+    cols: number;
+    rows: number;
+    element?: HTMLElement;
+    textarea?: HTMLTextAreaElement;
+    private options;
+    private ghostty?;
+    private wasmTerm?;
+    private renderer?;
+    private inputHandler?;
+    private selectionManager?;
+    private canvas?;
+    private dataEmitter;
+    private resizeEmitter;
+    private bellEmitter;
+    private selectionChangeEmitter;
+    readonly onData: IEvent<string>;
+    readonly onResize: IEvent<{
+        cols: number;
+        rows: number;
+    }>;
+    readonly onBell: IEvent<void>;
+    readonly onSelectionChange: IEvent<void>;
+    private isOpen;
+    private isDisposed;
+    private animationFrameId?;
+    private addons;
+    constructor(options?: ITerminalOptions);
+    /**
+     * Open terminal in a parent element
+     * This initializes all components and starts rendering
+     */
+    open(parent: HTMLElement): Promise<void>;
+    /**
+     * Write data to terminal
+     */
+    write(data: string | Uint8Array): void;
+    /**
+     * Write data with newline
+     */
+    writeln(data: string): void;
+    /**
+     * Resize terminal
+     */
+    resize(cols: number, rows: number): void;
+    /**
+     * Clear terminal screen
+     */
+    clear(): void;
+    /**
+     * Reset terminal state
+     */
+    reset(): void;
+    /**
+     * Focus terminal input
+     */
+    focus(): void;
+    /**
+     * Load an addon
+     */
+    loadAddon(addon: ITerminalAddon): void;
+    /**
+     * Get the selected text as a string
+     */
+    getSelection(): string;
+    /**
+     * Check if there's an active selection
+     */
+    hasSelection(): boolean;
+    /**
+     * Clear the current selection
+     */
+    clearSelection(): void;
+    /**
+     * Select all text in the terminal
+     */
+    selectAll(): void;
+    /**
+     * Dispose terminal and clean up resources
+     */
+    dispose(): void;
+    /**
+     * Start the render loop
+     */
+    private startRenderLoop;
+    /**
+     * Clean up components (called on dispose or error)
+     */
+    private cleanupComponents;
+    /**
+     * Assert terminal is open (throw if not)
+     */
+    private assertOpen;
+}
+
+/**
+ * Opaque terminal pointer (WASM memory address)
+ */
+export declare type TerminalHandle = number;
+
+export { }