@crunchloop/ghostty-web 0.4.1

package/dist/headless.d.ts

@@ -0,0 +1,1271 @@
+/**
+ * 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;
+}
+
+/**
+ * Dirty state from RenderState. Mirrors GhosttyRenderStateDirty.
+ */
+declare enum DirtyState {
+    NONE = 0,
+    PARTIAL = 1,
+    FULL = 2
+}
+
+declare class EventEmitter<T> {
+    private listeners;
+    fire(arg: T): void;
+    event: IEvent<T>;
+    dispose(): void;
+}
+
+/* Excluded from this release type: getGhostty */
+
+/**
+ * Main Ghostty WASM wrapper class
+ */
+export declare class Ghostty {
+    private exports;
+    private memory;
+    constructor(wasmInstance: WebAssembly.Instance);
+    createKeyEncoder(): KeyEncoder;
+    createTerminal(cols?: number, rows?: number, config?: GhosttyTerminalConfig): GhosttyTerminal;
+    static load(wasmPath?: string): Promise<Ghostty>;
+    private static loadFromPath;
+}
+
+/**
+ * Cell structure matching ghostty_cell_t in C (16 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;
+    fgIsDefault: boolean;
+    bgIsDefault: boolean;
+    flags: number;
+    width: number;
+    hyperlink_id: number;
+    grapheme_len: number;
+}
+
+/**
+ * GhosttyTerminal - High-performance terminal emulator
+ *
+ * Uses Ghostty's native RenderState for optimal performance:
+ * - ONE call to update all state (renderStateUpdate)
+ * - ONE call to get all cells (getViewport)
+ * - No per-row WASM boundary crossings!
+ */
+declare class GhosttyTerminal {
+    private exports;
+    private memory;
+    private handle;
+    private renderHandle;
+    private rowIter;
+    private rowCells;
+    private _cols;
+    private _rows;
+    /** Cell pool for zero-allocation rendering */
+    private cellPool;
+    /**
+     * Cell pixel dimensions last pushed to the WASM terminal via
+     * ghostty_terminal_resize. Zero means "unknown / disabled" — kitty
+     * graphics image sizing and CSI 14/16/18 t in-band size reports will
+     * return zero/no-op until setCellPixelSize() is called with real values.
+     */
+    private cellWidthPx;
+    private cellHeightPx;
+    /**
+     * Per-row dirty state for the current render-state snapshot. Cleared on
+     * update() and populated lazily by isRowDirty() (or as a side effect of
+     * getViewport, which iterates rows anyway).
+     */
+    private rowDirtyCache;
+    /**
+     * Per-row soft-wrap state for the current render-state snapshot. Same
+     * lifecycle as rowDirtyCache; the two caches are filled in lockstep.
+     */
+    private rowWrapCache;
+    /**
+     * Whether cellPool currently holds a valid built viewport.
+     *
+     * The visible-screen content is a pure function of the WASM terminal state,
+     * which only changes via write() (all VT sequences — text, scroll, clear,
+     * alt-screen switch) or resize(). So once getViewport() has walked the grid
+     * and populated cellPool, the result stays valid until the next write/resize
+     * — letting repeated getViewport()/getLine() calls within (and across, when
+     * idle) a render pass reuse the pool instead of re-walking it (~3-4 WASM
+     * crossings per cell). Cursor blink, selection overlays and scrollback
+     * paging don't read cellPool, so they don't invalidate it.
+     */
+    private viewportValid;
+    /**
+     * Bytes the terminal would have written back to a real PTY in response
+     * to query sequences (DSR, XTVERSION, in-band size reports, ...).
+     * Captured by the WRITE_PTY callback installed in the constructor and
+     * drained by readResponse(). Each slot is one callback invocation, so
+     * a single response sequence may span multiple slots.
+     */
+    private pendingResponses;
+    /**
+     * Per-table registry for callback trampolines. Keyed on the WASM
+     * module's __indirect_function_table so that multiple Ghostty.load()
+     * instances each get their own trampoline slots and routing map —
+     * terminal handles are only unique within a single WASM instance, and
+     * indices into one module's table are meaningless in another.
+     *
+     * One trampoline pair (write_pty + size) is installed per table; their
+     * slot indices live here alongside the routing map. The dispatchers
+     * close over the same instancesByHandle so any GhosttyTerminal coming
+     * from this WASM module routes correctly.
+     */
+    private static callbackRegistries;
+    /**
+     * Cached pointer to this terminal's registry. We only need it to
+     * deregister cleanly in free() / cleanupOnConstructorFailure().
+     */
+    private callbackRegistry?;
+    constructor(exports: GhosttyWasmExports, memory: WebAssembly.Memory, cols?: number, rows?: number, config?: GhosttyTerminalConfig);
+    /**
+     * Allocate an opaque handle through one of the new(allocator, *outHandle)
+     * factory functions. Wraps the boilerplate of: alloc out-pointer, call
+     * factory, check Result, read the handle, free out-pointer.
+     *
+     * If the factory call fails, frees any already-acquired terminal/render
+     * resources so the caller-throwing flow doesn't leak across the partially
+     * constructed object.
+     */
+    private allocOpaqueOrFail;
+    /**
+     * Apply user-supplied colors + palette overrides to the freshly-created
+     * terminal via ghostty_terminal_set(COLOR_*).
+     *
+     * For the palette: the new C ABI takes a full 256-entry array, but coder's
+     * config carries only the legacy 16 ANSI entries (each as a 0xRRGGBB int,
+     * 0 meaning "use default"). To preserve indices ≥16 we read the existing
+     * default palette first, overlay the non-zero entries from config, and
+     * write the merged 768-byte buffer back.
+     */
+    private applyConfig;
+    private setColorOption;
+    /**
+     * Release any resources that have been allocated by the constructor up to
+     * this point. Called when a subsequent step fails so we don't leak handles
+     * before the throw propagates.
+     */
+    private cleanupOnConstructorFailure;
+    private rsGetU8;
+    private rsGetU16;
+    private rsGetU32;
+    private rsGetRgb;
+    private tGetU8;
+    private tGetU32;
+    get cols(): number;
+    get rows(): number;
+    write(data: string | Uint8Array): void;
+    resize(cols: number, rows: number): void;
+    /**
+     * Set the maximum bytes of image data the terminal will retain across
+     * all kitty graphics images. Zero disables kitty graphics entirely
+     * (transmissions will be parsed and dropped). Set this BEFORE any
+     * image-bearing data is written to the terminal — there's no
+     * retroactive recovery of dropped images.
+     *
+     * Input is uint64_t* on the C side, so we use a u32-pair little-endian
+     * write to keep the byte count exact even past 4GB (probably overkill
+     * but free).
+     */
+    setKittyImageStorageLimit(bytes: number): void;
+    /**
+     * Get the kitty graphics storage handle for the active screen, or null
+     * if storage is disabled or no images are stored. Cheap to call; returns
+     * a borrowed pointer.
+     */
+    getKittyGraphics(): number | null;
+    /**
+     * Iterate placements in the active screen, yielding render-ready info
+     * for each. The optional `onlyVisible` flag (default true) drops
+     * placements that don't intersect the viewport — most renderers want
+     * this. Use `false` if you need to track invalidated regions for
+     * partial damage.
+     *
+     * Internally this uses the upstream placement iterator + the one-shot
+     * placement_render_info call (fills 12 fields in one WASM crossing
+     * instead of 5 separate getters).
+     */
+    iterPlacements(graphics: number, onlyVisible?: boolean): Generator<KittyPlacementInfo>;
+    /**
+     * Get the pixel data + metadata for an image by id. Returns null if the
+     * image isn't stored or isn't in a format we can hand the renderer
+     * directly (RGB / RGBA / GRAY / GRAY_ALPHA).
+     *
+     * The returned `data` is a borrowed view into WASM memory — copy before
+     * the next vt_write if you need to retain. Most callers will turn this
+     * into an ImageData / canvas immediately and discard the view.
+     */
+    getKittyImagePixels(graphics: number, imageId: number): KittyImagePixels | null;
+    /**
+     * Push the renderer's per-cell pixel size into the WASM terminal.
+     *
+     * The new C ABI doesn't expose a separate "set pixel size" call —
+     * dimensions only flow through ghostty_terminal_resize, which takes
+     * (cols, rows, cell_width_px, cell_height_px). We cache the cell pixel
+     * dims on the instance so subsequent resize() calls keep the values
+     * stable, and short-circuit when nothing has changed.
+     *
+     * The width/height arguments are PER-CELL CSS pixels — matches what
+     * the renderer reports via getMetrics(). Coder's old setPixelSize
+     * took TOTAL screen pixels (cell_width * cols, cell_height * rows);
+     * we renamed to avoid silent value mis-passing.
+     *
+     * Affects in-band size reports (CSI 14/16/18 t) and kitty graphics
+     * placement sizing. Until called, those query paths return zero.
+     */
+    setCellPixelSize(cellWidthPx: number, cellHeightPx: number): void;
+    free(): void;
+    /**
+     * Update terminal colors at runtime. All color values are applied directly
+     * (no sentinel — 0x000000 is valid black). Forces a full redraw on next render.
+     *
+     * Uses the same ghostty_terminal_set(COLOR_*) path as applyConfig; this
+     * is the runtime variant called by Terminal.setTheme().
+     */
+    setColors(config: GhosttyTerminalConfig): void;
+    /**
+     * Update render state from terminal.
+     *
+     * This syncs the RenderState with the current Terminal state.
+     * The dirty state (full/partial/none) is stored in the WASM RenderState
+     * and can be queried via isRowDirty(). When dirty==full, isRowDirty()
+     * returns true for ALL rows.
+     *
+     * The WASM layer automatically detects screen switches (normal <-> alternate)
+     * and returns FULL dirty state when switching screens (e.g., vim exit).
+     *
+     * Safe to call multiple times - dirty state persists until markClean().
+     */
+    update(): DirtyState;
+    /**
+     * Get cursor state from render state.
+     * Calls update() first; safe to call repeatedly within a frame.
+     */
+    getCursor(): RenderStateCursor;
+    /**
+     * Get default fg/bg/cursor colors from render state.
+     */
+    getColors(): RenderStateColors;
+    /**
+     * Check if a specific row is dirty.
+     *
+     * Backed by a per-row cache populated lazily — first call after update()
+     * walks the iterator once and reads the dirty flag for each row, then
+     * subsequent calls are O(1). getViewport() also populates the cache as a
+     * side effect so a typical "update → for-each-row isRowDirty → getViewport"
+     * render loop only iterates rows once.
+     */
+    isRowDirty(y: number): boolean;
+    /**
+     * Check if a row is soft-wrapped (continues onto the next row).
+     *
+     * Same cache discipline as isRowDirty: lazy-populated on first call after
+     * update(), or as a side effect of getViewport.
+     */
+    isRowWrapped(y: number): boolean;
+    /**
+     * Walk the row iterator once and capture per-row dirty + wrap flags.
+     *
+     * Calls update() first since callers (isRowDirty / isRowWrapped) typically
+     * query right after a terminal write, before any explicit render-state
+     * refresh has happened. Same idempotency guarantee as getCursor/getColors:
+     * if no terminal change occurred since the last update, this is cheap.
+     *
+     * Reads ROW_DATA_DIRTY directly from the iterator, then ROW_DATA_RAW to
+     * obtain the GhosttyRow (u64) needed to call ghostty_row_get(WRAP_*). The
+     * row value is only valid for the current iterator position; we read it
+     * inline before advancing.
+     */
+    private refreshRowMetaCache;
+    /**
+     * Mark render state as clean — clears both global and per-row dirty.
+     *
+     * Per the upstream contract, "setting one dirty state doesn't unset the
+     * other." Global dirty is cleared via _set(OPTION_DIRTY, FALSE); per-row
+     * dirty is cleared by walking the row iterator and calling _row_set on
+     * each. Without the per-row pass, the next update() would still report
+     * the old per-row flags as dirty even though the terminal hasn't changed.
+     */
+    markClean(): void;
+    /**
+     * Populate the cellPool from the current render state and return it.
+     *
+     * The new C ABI replaces coder's single ghostty_render_state_get_viewport()
+     * buffer-fill with a row iterator + per-row cells iterator. We allocate
+     * both iterators once at construction time and re-populate them per call:
+     *
+     *   _get(state, ROW_ITERATOR, &rowIter)
+     *   while (row_iterator_next(rowIter)) {
+     *     _row_get(rowIter, ROW_DATA_CELLS, &rowCells)
+     *     while (row_cells_next(rowCells)) {
+     *       _row_cells_get(rowCells, GRAPHEMES_LEN, &len)
+     *       _row_cells_get(rowCells, GRAPHEMES_BUF, &codepoint)  // if len > 0
+     *       _row_cells_get(rowCells, FG_COLOR/BG_COLOR, &rgb)    // INVALID_VALUE if unset
+     *     }
+     *   }
+     *
+     * This is intentionally minimal: we capture codepoint + fg/bg only.
+     * Style flags, cell width (double-width), and hyperlink IDs are deferred
+     * — they require parsing the GhosttyStyle sized struct and the per-cell
+     * ghostty_cell_get(WIDE)/HAS_HYPERLINK paths. The cellPool fields keep
+     * placeholder defaults (flags=0, width=1, hyperlink_id=0).
+     *
+     * Performance: ~3-4 WASM crossings per visible cell. For an 80x24 viewport
+     * that's ~6k crossings per frame. Profile before optimizing — likely
+     * candidates are _row_cells_get_multi for batched reads, or RAW + a
+     * cached layout map for direct memory access.
+     */
+    getViewport(): GhosttyCell[];
+    /**
+     * Helper for the in/out pointer pattern used by ROW_ITERATOR / ROW_DATA_CELLS:
+     * write a handle into a 4-byte slot, hand the slot to a populator, then
+     * free the slot. The handle value itself is unchanged; the populator uses
+     * it to find and rebind the iterator's internal data.
+     */
+    private populateHandle;
+    /**
+     * Reset every cell in the pool to "empty" so cells we don't visit during
+     * iteration (e.g. iterator stopped early, or grid resized down) don't
+     * carry stale values from a previous frame.
+     */
+    private zeroCellPool;
+    /**
+     * Get line - for compatibility, extracts from viewport.
+     * Ensures render state is fresh by calling update().
+     * Returns a COPY of the cells to avoid pool reference issues.
+     */
+    getLine(y: number): GhosttyCell[] | null;
+    /** For compatibility with old API */
+    isDirty(): boolean;
+    /**
+     * Check if a full redraw is needed (screen change, resize, etc.)
+     * Note: This calls update() to ensure fresh state. Safe to call multiple times.
+     */
+    needsFullRedraw(): boolean;
+    /** Mark render state as clean after rendering */
+    clearDirty(): void;
+    isAlternateScreen(): boolean;
+    hasBracketedPaste(): boolean;
+    hasFocusEvents(): boolean;
+    hasMouseTracking(): boolean;
+    /** Get dimensions - for compatibility */
+    getDimensions(): {
+        cols: number;
+        rows: number;
+    };
+    /** Get number of scrollback lines (history, not including active screen) */
+    getScrollbackLength(): number;
+    /**
+     * Get a line from the scrollback buffer.
+     * @param offset 0 = oldest scrollback line, (scrollbackLength-1) = most
+     *   recent scrollback line.
+     *
+     * Uses ghostty_terminal_grid_ref with POINT_TAG_HISTORY to address rows
+     * outside the active viewport. The render-state row iterator only walks
+     * the viewport, so scrollback access has to go through grid_ref.
+     *
+     * Cell content is currently codepoint-only; fg/bg colors, style flags,
+     * and hyperlinks are deferred (defaults: 0 colors, flags=0, width=1).
+     * The text-extraction tests that drove this commit only check codepoints.
+     */
+    getScrollbackLine(offset: number): GhosttyCell[] | null;
+    /**
+     * Get the hyperlink URI for a cell at the given position in the active
+     * viewport. Returns null when no hyperlink is attached.
+     */
+    getHyperlinkUri(row: number, col: number): string | null;
+    /**
+     * Get the hyperlink URI for a cell in the scrollback buffer.
+     */
+    getScrollbackHyperlinkUri(offset: number, col: number): string | null;
+    private readGridLine;
+    /**
+     * Decode a GhosttyStyleColor (16 bytes at colorPtr — tag@0:u32,
+     * value@8:union) and write the resolved RGB into the cell's fg_*
+     * or bg_* triple. Tag values: NONE=0 (leaves zeros so the renderer's
+     * theme fallback kicks in), PALETTE=1 (looks up the terminal's
+     * effective palette), RGB=2 (direct read).
+     */
+    private resolveStyleColor;
+    private readHyperlinkUri;
+    private allocPoint;
+    private makeEmptyCell;
+    /**
+     * Whether any terminal response bytes are queued for readResponse().
+     *
+     * Responses are delivered synchronously during vt_write() by the
+     * WRITE_PTY callback (e.g. DSR replies, XTVERSION, in-band size reports).
+     * They sit in pendingResponses until drained.
+     */
+    hasResponse(): boolean;
+    /**
+     * Drain queued response bytes, decode as UTF-8, return as a single
+     * string. Multiple callback invocations are concatenated. Returns null
+     * when nothing's pending so the demo's echo loop can short-circuit.
+     */
+    readResponse(): string | null;
+    /**
+     * Install the WRITE_PTY and SIZE trampoline callbacks.
+     *
+     * Trampolines are shared across all terminals that come from the
+     * same WASM instance, but NOT across instances — terminal handles are
+     * only unique within their parent module, and table indices in module
+     * A are meaningless in module B's table. So we keep a per-table
+     * registry (WeakMap keyed on the indirect function table) that owns
+     * the slot indices plus the handle→instance routing map for that
+     * table.
+     *
+     * On first use for a given table we instantiate the trampolines,
+     * `table.grow(2)`, and write both into the new slots. Subsequent
+     * terminals from the same module reuse the registry and just
+     * register their handle in instancesByHandle.
+     */
+    private installCallbacks;
+    /**
+     * Query arbitrary terminal mode by number.
+     * @param mode Mode number (e.g., 25 for cursor visibility, 2004 for bracketed paste)
+     * @param isAnsi True for ANSI modes, false for DEC modes (default: false)
+     */
+    getMode(mode: number, isAnsi?: boolean): boolean;
+    private initCellPool;
+    /**
+     * Get all codepoints for a grapheme cluster at the given position.
+     * For most cells this returns a single codepoint, but for complex scripts
+     * (Hindi, emoji with ZWJ, etc.) it returns multiple codepoints.
+     * @returns Array of codepoints, or null on error
+     */
+    getGrapheme(row: number, col: number): number[] | null;
+    /**
+     * Get a string representation of the grapheme at the given position.
+     * This properly handles complex scripts like Hindi, emoji with ZWJ, etc.
+     */
+    getGraphemeString(row: number, col: number): string;
+    /**
+     * Get all codepoints for a grapheme cluster in the scrollback buffer.
+     * @param offset Scrollback line offset (0 = oldest)
+     * @param col Column index
+     * @returns Array of codepoints, or null on error
+     */
+    getScrollbackGrapheme(offset: number, col: number): number[] | null;
+    /**
+     * Get a string representation of a grapheme in the scrollback buffer.
+     */
+    getScrollbackGraphemeString(offset: number, col: number): string;
+}
+
+/**
+ * Terminal configuration (passed to ghostty_terminal_new_with_config)
+ * All color values use 0xRRGGBB format. A value of 0 means "use default".
+ */
+export declare interface GhosttyTerminalConfig {
+    /** Scrollback buffer size in bytes. Passed to Terminal.max_scrollback. */
+    scrollbackLimit?: number;
+    fgColor?: number;
+    bgColor?: number;
+    cursorColor?: number;
+    palette?: number[];
+}
+
+/**
+ * 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(allocatorPtr: number, terminalPtrPtr: number, optionsPtr: number): number;
+    ghostty_terminal_free(terminal: TerminalHandle): void;
+    ghostty_terminal_resize(terminal: TerminalHandle, cols: number, rows: number, cellWidthPx: number, cellHeightPx: number): number;
+    ghostty_terminal_vt_write(terminal: TerminalHandle, dataPtr: number, dataLen: number): void;
+    ghostty_render_state_new(allocatorPtr: number, statePtrPtr: number): number;
+    ghostty_render_state_free(state: number): void;
+    ghostty_render_state_update(state: number, terminal: TerminalHandle): number;
+    ghostty_render_state_get(state: number, key: number, outPtr: number): number;
+    ghostty_render_state_get_multi(state: number, count: number, keysPtr: number, valuesPtr: number, outWrittenPtr: number): number;
+    ghostty_render_state_set(state: number, option: number, valuePtr: number): number;
+    ghostty_render_state_colors_get(state: number, outColorsPtr: number): number;
+    ghostty_render_state_row_iterator_new(allocatorPtr: number, outIterPtrPtr: number): number;
+    ghostty_render_state_row_iterator_free(iter: number): void;
+    ghostty_render_state_row_iterator_next(iter: number): boolean;
+    ghostty_render_state_row_get(iter: number, key: number, outPtr: number): number;
+    ghostty_render_state_row_set(iter: number, option: number, valuePtr: number): number;
+    ghostty_render_state_row_cells_new(allocatorPtr: number, outCellsPtrPtr: number): number;
+    ghostty_render_state_row_cells_free(cells: number): void;
+    ghostty_render_state_row_cells_next(cells: number): boolean;
+    ghostty_render_state_row_cells_select(cells: number, col: number): number;
+    ghostty_render_state_row_cells_get(cells: number, key: number, outPtr: number): number;
+    ghostty_render_state_row_cells_get_multi(cells: number, count: number, keysPtr: number, valuesPtr: number, outWrittenPtr: number): number;
+    ghostty_cell_get(cell: bigint, key: number, outPtr: number): number;
+    ghostty_row_get(row: bigint, key: number, outPtr: number): number;
+    ghostty_terminal_grid_ref(terminal: TerminalHandle, pointPtr: number, outRefPtr: number): number;
+    ghostty_grid_ref_cell(refPtr: number, outCellPtr: number): number;
+    ghostty_grid_ref_row(refPtr: number, outRowPtr: number): number;
+    ghostty_grid_ref_graphemes(refPtr: number, bufPtr: number, bufLen: number, outLenPtr: number): number;
+    ghostty_grid_ref_hyperlink_uri(refPtr: number, bufPtr: number, bufLen: number, outLenPtr: number): number;
+    ghostty_grid_ref_style(refPtr: number, outStylePtr: number): number;
+    ghostty_kitty_graphics_get(graphics: number, key: number, outPtr: number): number;
+    ghostty_kitty_graphics_image(graphics: number, imageId: number): number;
+    ghostty_kitty_graphics_image_get(image: number, key: number, outPtr: number): number;
+    ghostty_kitty_graphics_image_get_multi(image: number, count: number, keysPtr: number, valuesPtr: number, outWrittenPtr: number): number;
+    ghostty_kitty_graphics_placement_iterator_new(allocatorPtr: number, outIterPtrPtr: number): number;
+    ghostty_kitty_graphics_placement_iterator_free(iter: number): void;
+    ghostty_kitty_graphics_placement_iterator_set(iter: number, option: number, valuePtr: number): number;
+    ghostty_kitty_graphics_placement_next(iter: number): boolean;
+    ghostty_kitty_graphics_placement_get(iter: number, key: number, outPtr: number): number;
+    ghostty_kitty_graphics_placement_get_multi(iter: number, count: number, keysPtr: number, valuesPtr: number, outWrittenPtr: number): number;
+    ghostty_kitty_graphics_placement_rect(iter: number, image: number, terminal: TerminalHandle, outSelectionPtr: number): number;
+    ghostty_kitty_graphics_placement_pixel_size(iter: number, image: number, terminal: TerminalHandle, outWidthPtr: number, outHeightPtr: number): number;
+    ghostty_kitty_graphics_placement_grid_size(iter: number, image: number, terminal: TerminalHandle, outColsPtr: number, outRowsPtr: number): number;
+    ghostty_kitty_graphics_placement_viewport_pos(iter: number, image: number, terminal: TerminalHandle, outColPtr: number, outRowPtr: number): number;
+    ghostty_kitty_graphics_placement_source_rect(iter: number, image: number, outX: number, outY: number, outW: number, outH: number): number;
+    ghostty_kitty_graphics_placement_render_info(iter: number, image: number, terminal: TerminalHandle, outInfoPtr: number): number;
+    ghostty_terminal_get(terminal: TerminalHandle, key: number, outPtr: number): number;
+    ghostty_terminal_get_multi(terminal: TerminalHandle, count: number, keysPtr: number, valuesPtr: number, outWrittenPtr: number): number;
+    ghostty_terminal_set(terminal: TerminalHandle, option: number, valuePtr: number): number;
+    ghostty_sys_set(option: number, valuePtr: number): number;
+    ghostty_alloc(allocatorPtr: number, len: number): number;
+    ghostty_free(allocatorPtr: number, ptr: number, len: number): void;
+    ghostty_terminal_mode_get(terminal: TerminalHandle, mode: number, outBoolPtr: number): number;
+    ghostty_terminal_mode_set(terminal: TerminalHandle, mode: number, value: boolean): number;
+}
+
+/**
+ * A terminal buffer (normal or alternate screen)
+ */
+export declare interface IBuffer {
+    /** Buffer type: 'normal' or 'alternate' */
+    readonly type: 'normal' | 'alternate';
+    /** Cursor X position (0-indexed) */
+    readonly cursorX: number;
+    /** Cursor Y position (0-indexed, relative to viewport) */
+    readonly cursorY: number;
+    /** Viewport Y position (scroll offset, 0 = bottom of scrollback) */
+    readonly viewportY: number;
+    /** Base Y position (always 0 for normal buffer, may vary for alternate) */
+    readonly baseY: number;
+    /** Total buffer length (rows + scrollback for normal, just rows for alternate) */
+    readonly length: number;
+    /**
+     * Get a line from the buffer
+     * @param y Line index (0 = top of scrollback for normal buffer)
+     * @returns Line object or undefined if out of bounds
+     */
+    getLine(y: number): IBufferLine | undefined;
+    /**
+     * Get the null cell (used for empty/uninitialized cells)
+     */
+    getNullCell(): IBufferCell;
+}
+
+/**
+ * A single cell in the buffer
+ */
+export declare interface IBufferCell {
+    /** Character(s) in this cell (may be empty, single char, or emoji) */
+    getChars(): string;
+    /** Unicode codepoint (0 for null cell) */
+    getCode(): number;
+    /** Character width (1 = normal, 2 = wide/emoji, 0 = combining) */
+    getWidth(): number;
+    /** Foreground color index (for palette colors) or -1 for RGB */
+    getFgColorMode(): number;
+    /** Background color index (for palette colors) or -1 for RGB */
+    getBgColorMode(): number;
+    /** Foreground RGB color (or 0 for default) */
+    getFgColor(): number;
+    /** Background RGB color (or 0 for default) */
+    getBgColor(): number;
+    /** Whether cell has bold style */
+    isBold(): number;
+    /** Whether cell has italic style */
+    isItalic(): number;
+    /** Whether cell has underline style */
+    isUnderline(): number;
+    /** Whether cell has strikethrough style */
+    isStrikethrough(): number;
+    /** Whether cell has blink style */
+    isBlink(): number;
+    /** Whether cell has inverse video style */
+    isInverse(): number;
+    /** Whether cell has invisible style */
+    isInvisible(): number;
+    /** Whether cell has faint/dim style */
+    isFaint(): number;
+    /** Get hyperlink ID for this cell (0 = no link) */
+    getHyperlinkId(): number;
+    /** Get the Unicode codepoint for this cell */
+    getCodepoint(): number;
+    /** Whether cell has dim/faint attribute (boolean version) */
+    isDim(): boolean;
+}
+
+/**
+ * A single line in the buffer
+ */
+export declare interface IBufferLine {
+    /** Length of the line (in columns) */
+    readonly length: number;
+    /** Whether this line wraps to the next line */
+    readonly isWrapped: boolean;
+    /**
+     * Get a cell from this line
+     * @param x Column index (0-indexed)
+     * @returns Cell object or undefined if out of bounds
+     */
+    getCell(x: number): IBufferCell | undefined;
+    /**
+     * Translate the line to a string
+     * @param trimRight Whether to trim trailing whitespace (default: false)
+     * @param startColumn Start column (default: 0)
+     * @param endColumn End column (default: length)
+     * @returns String representation of the line
+     */
+    translateToString(trimRight?: boolean, startColumn?: number, endColumn?: number): string;
+}
+
+/**
+ * Top-level buffer API namespace
+ * Provides access to active, normal, and alternate screen buffers
+ */
+export declare interface IBufferNamespace {
+    /** The currently active buffer (normal or alternate) */
+    readonly active: IBuffer;
+    /** The normal buffer (primary screen) */
+    readonly normal: IBuffer;
+    /** The alternate buffer (used by full-screen apps like vim) */
+    readonly alternate: IBuffer;
+    /** Event fired when buffer changes (normal ↔ alternate) */
+    readonly onBufferChange: IEvent<IBuffer>;
+}
+
+/**
+ * Buffer range for selection coordinates
+ */
+export declare interface IBufferRange {
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+}
+
+export declare interface IDisposable {
+    dispose(): void;
+}
+
+export declare type IEvent<T> = (listener: (arg: T) => void) => IDisposable;
+
+/**
+ * Initialize ghostty-web headless. Must be called before creating Terminal instances.
+ */
+export declare function init(wasmPath?: string): Promise<void>;
+
+/**
+ * Check if ghostty-web headless has been initialized.
+ */
+export declare function isInitialized(): boolean;
+
+export declare interface ITerminalAddon {
+    activate(terminal: ITerminalCore): void;
+    dispose(): void;
+}
+
+declare interface ITerminalCore {
+    cols: number;
+    rows: number;
+    element?: HTMLElement;
+    textarea?: HTMLTextAreaElement;
+}
+
+export declare interface ITerminalOptions {
+    cols?: number;
+    rows?: number;
+    cursorBlink?: boolean;
+    cursorStyle?: 'block' | 'underline' | 'bar';
+    theme?: ITheme;
+    scrollback?: number;
+    fontSize?: number;
+    fontFamily?: string;
+    allowTransparency?: boolean;
+    convertEol?: boolean;
+    disableStdin?: boolean;
+    focusOnOpen?: boolean;
+    smoothScrollDuration?: number;
+    /**
+     * When true, the viewport stays locked on the same scrollback content as
+     * new output arrives — instead of auto-scrolling to the bottom. Mirrors
+     * the behaviour of modern terminals (kitty, alacritty). Default: false
+     * (preserves the xterm.js-style auto-scroll behaviour for back-compat).
+     */
+    preserveScrollOnWrite?: boolean;
+    emitTerminalResponses?: boolean;
+    ghostty?: Ghostty;
+}
+
+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 matching Ghostty's internal Key enum.
+ * These values are used by Ghostty's key encoder to produce correct escape sequences.
+ * Reference: ghostty/src/input/key.zig
+ */
+declare enum Key {
+    UNIDENTIFIED = 0,
+    GRAVE = 1,// ` and ~
+    BACKSLASH = 2,// \ and |
+    BRACKET_LEFT = 3,// [ and {
+    BRACKET_RIGHT = 4,// ] and }
+    COMMA = 5,// , and <
+    ZERO = 6,
+    ONE = 7,
+    TWO = 8,
+    THREE = 9,
+    FOUR = 10,
+    FIVE = 11,
+    SIX = 12,
+    SEVEN = 13,
+    EIGHT = 14,
+    NINE = 15,
+    EQUAL = 16,// = and +
+    INTL_BACKSLASH = 17,
+    INTL_RO = 18,
+    INTL_YEN = 19,
+    A = 20,
+    B = 21,
+    C = 22,
+    D = 23,
+    E = 24,
+    F = 25,
+    G = 26,
+    H = 27,
+    I = 28,
+    J = 29,
+    K = 30,
+    L = 31,
+    M = 32,
+    N = 33,
+    O = 34,
+    P = 35,
+    Q = 36,
+    R = 37,
+    S = 38,
+    T = 39,
+    U = 40,
+    V = 41,
+    W = 42,
+    X = 43,
+    Y = 44,
+    Z = 45,
+    MINUS = 46,// - and _
+    PERIOD = 47,// . and >
+    QUOTE = 48,// ' and "
+    SEMICOLON = 49,// ; and :
+    SLASH = 50,// / and ?
+    ALT_LEFT = 51,
+    ALT_RIGHT = 52,
+    BACKSPACE = 53,
+    CAPS_LOCK = 54,
+    CONTEXT_MENU = 55,
+    CONTROL_LEFT = 56,
+    CONTROL_RIGHT = 57,
+    ENTER = 58,
+    META_LEFT = 59,
+    META_RIGHT = 60,
+    SHIFT_LEFT = 61,
+    SHIFT_RIGHT = 62,
+    SPACE = 63,
+    TAB = 64,
+    CONVERT = 65,
+    KANA_MODE = 66,
+    NON_CONVERT = 67,
+    DELETE = 68,
+    END = 69,
+    HELP = 70,
+    HOME = 71,
+    INSERT = 72,
+    PAGE_DOWN = 73,
+    PAGE_UP = 74,
+    DOWN = 75,
+    LEFT = 76,
+    RIGHT = 77,
+    UP = 78,
+    NUM_LOCK = 79,
+    KP_0 = 80,
+    KP_1 = 81,
+    KP_2 = 82,
+    KP_3 = 83,
+    KP_4 = 84,
+    KP_5 = 85,
+    KP_6 = 86,
+    KP_7 = 87,
+    KP_8 = 88,
+    KP_9 = 89,
+    KP_PLUS = 90,// Keypad +
+    KP_BACKSPACE = 91,
+    KP_CLEAR = 92,
+    KP_CLEAR_ENTRY = 93,
+    KP_COMMA = 94,
+    KP_PERIOD = 95,// Keypad .
+    KP_DIVIDE = 96,// Keypad /
+    KP_ENTER = 97,// Keypad Enter
+    KP_EQUAL = 98,
+    KP_MEMORY_ADD = 99,
+    KP_MEMORY_CLEAR = 100,
+    KP_MEMORY_RECALL = 101,
+    KP_MEMORY_STORE = 102,
+    KP_MEMORY_SUBTRACT = 103,
+    KP_MULTIPLY = 104,// Keypad *
+    KP_PAREN_LEFT = 105,
+    KP_PAREN_RIGHT = 106,
+    KP_MINUS = 107,// Keypad -
+    KP_SEPARATOR = 108,
+    NUMPAD_UP = 109,
+    NUMPAD_DOWN = 110,
+    NUMPAD_RIGHT = 111,
+    NUMPAD_LEFT = 112,
+    NUMPAD_BEGIN = 113,
+    NUMPAD_HOME = 114,
+    NUMPAD_END = 115,
+    NUMPAD_INSERT = 116,
+    NUMPAD_DELETE = 117,
+    NUMPAD_PAGE_UP = 118,
+    NUMPAD_PAGE_DOWN = 119,
+    ESCAPE = 120,
+    F1 = 121,
+    F2 = 122,
+    F3 = 123,
+    F4 = 124,
+    F5 = 125,
+    F6 = 126,
+    F7 = 127,
+    F8 = 128,
+    F9 = 129,
+    F10 = 130,
+    F11 = 131,
+    F12 = 132,
+    F13 = 133,
+    F14 = 134,
+    F15 = 135,
+    F16 = 136,
+    F17 = 137,
+    F18 = 138,
+    F19 = 139,
+    F20 = 140,
+    F21 = 141,
+    F22 = 142,
+    F23 = 143,
+    F24 = 144,
+    F25 = 145,
+    FN_LOCK = 146,
+    PRINT_SCREEN = 147,
+    SCROLL_LOCK = 148,
+    PAUSE = 149,
+    BROWSER_BACK = 150,
+    BROWSER_FAVORITES = 151,
+    BROWSER_FORWARD = 152,
+    BROWSER_HOME = 153,
+    BROWSER_REFRESH = 154,
+    BROWSER_SEARCH = 155,
+    BROWSER_STOP = 156,
+    EJECT = 157,
+    LAUNCH_APP_1 = 158,
+    LAUNCH_APP_2 = 159,
+    LAUNCH_MAIL = 160,
+    MEDIA_PLAY_PAUSE = 161,
+    MEDIA_SELECT = 162,
+    MEDIA_STOP = 163,
+    MEDIA_TRACK_NEXT = 164,
+    MEDIA_TRACK_PREVIOUS = 165,
+    POWER = 166,
+    SLEEP = 167,
+    AUDIO_VOLUME_DOWN = 168,
+    AUDIO_VOLUME_MUTE = 169,
+    AUDIO_VOLUME_UP = 170,
+    WAKE_UP = 171,
+    COPY = 172,
+    CUT = 173,
+    PASTE = 174
+}
+
+/**
+ * Key action
+ */
+declare enum KeyAction {
+    RELEASE = 0,
+    PRESS = 1,
+    REPEAT = 2
+}
+
+/**
+ * Key Encoder - converts keyboard events into terminal escape sequences
+ */
+declare class KeyEncoder {
+    private exports;
+    private encoder;
+    constructor(exports: GhosttyWasmExports);
+    setOption(option: KeyEncoderOption, value: boolean | number): void;
+    setKittyFlags(flags: KittyKeyFlags): void;
+    encode(event: KeyEvent): Uint8Array;
+    dispose(): void;
+}
+
+/**
+ * Key encoder options
+ */
+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
+ */
+declare interface KeyEvent {
+    action: KeyAction;
+    key: Key;
+    mods: Mods;
+    consumedMods?: Mods;
+    composing?: boolean;
+    utf8?: string;
+    unshiftedCodepoint?: number;
+}
+
+/**
+ * Pixel format of a Kitty graphics image. Mirrors GhosttyKittyImageFormat.
+ *   RGB:        24-bit, 3 bytes/px
+ *   RGBA:       32-bit, 4 bytes/px (the canvas-friendly path)
+ *   PNG:        compressed; needs a JS-side decoder hooked up via
+ *               ghostty_sys_set(DECODE_PNG, fn)
+ *   GRAY_ALPHA: 16-bit, 2 bytes/px
+ *   GRAY:       8-bit, 1 byte/px
+ */
+declare enum KittyImageFormat {
+    RGB = 0,
+    RGBA = 1,
+    PNG = 2,
+    GRAY_ALPHA = 3,
+    GRAY = 4
+}
+
+/**
+ * Image bytes + metadata returned by GhosttyTerminal.getKittyImageRgba.
+ * `data` is a *view* into WASM memory and is invalidated by the next
+ * mutating terminal call — copy out before vt_write if you need to retain.
+ */
+declare interface KittyImagePixels {
+    width: number;
+    height: number;
+    format: KittyImageFormat;
+    /** Borrowed view into WASM memory; copy before vt_write to retain. */
+    data: Uint8Array;
+}
+
+/**
+ * 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
+}
+
+/**
+ * Parsed GhosttyKittyGraphicsPlacementRenderInfo — everything the renderer
+ * needs about a single placement to composite it on the canvas.
+ *
+ * Wire layout on wasm32 (48 bytes, extern struct, 4-byte aligned):
+ *   size:               u32 @ 0   (sized-struct discriminator; we just write 48)
+ *   pixel_width:        u32 @ 4
+ *   pixel_height:       u32 @ 8
+ *   grid_cols:          u32 @ 12
+ *   grid_rows:          u32 @ 16
+ *   viewport_col:       i32 @ 20
+ *   viewport_row:       i32 @ 24
+ *   viewport_visible:   bool @ 28 (1 byte + 3 bytes padding to next u32)
+ *   source_x:           u32 @ 32
+ *   source_y:           u32 @ 36
+ *   source_width:       u32 @ 40
+ *   source_height:      u32 @ 44
+ */
+declare interface KittyPlacementInfo {
+    imageId: number;
+    /** Destination size on the canvas, in pixels. */
+    pixelWidth: number;
+    pixelHeight: number;
+    /** Destination size on the grid, in cells. */
+    gridCols: number;
+    gridRows: number;
+    /** Top-left in viewport-relative cells. Negative when scrolled partway off the top. */
+    viewportCol: number;
+    viewportRow: number;
+    /** Whether any part of the placement intersects the visible viewport. */
+    viewportVisible: boolean;
+    /** Source rect within the image, in pixels (already clamped to image bounds). */
+    sourceX: number;
+    sourceY: number;
+    sourceWidth: number;
+    sourceHeight: number;
+    /**
+     * Virtual placements have no fixed viewport position; their image is
+     * drawn into U+10EEEE placeholder cells written to the grid by the
+     * application. The renderer picks them up by image_id rather than
+     * iterating through them for direct compositing.
+     */
+    isVirtual: boolean;
+}
+
+/**
+ * Modifier keys
+ */
+declare enum Mods {
+    NONE = 0,
+    SHIFT = 1,
+    CTRL = 2,
+    ALT = 4,
+    SUPER = 8,// Windows/Command key
+    CAPSLOCK = 16,
+    NUMLOCK = 32
+}
+
+/**
+ * Colors from RenderState (12 bytes packed)
+ */
+declare interface RenderStateColors {
+    background: RGB;
+    foreground: RGB;
+    cursor: RGB | null;
+}
+
+/**
+ * Cursor state from RenderState (8 bytes packed)
+ * Layout: x(u16) + y(u16) + viewport_x(i16) + viewport_y(i16) + visible(bool) + blinking(bool) + style(u8) + _pad(u8)
+ */
+declare interface RenderStateCursor {
+    x: number;
+    y: number;
+    viewportX: number;
+    viewportY: number;
+    visible: boolean;
+    blinking: boolean;
+    style: 'block' | 'underline' | 'bar';
+}
+
+/**
+ * RGB color
+ */
+export declare interface RGB {
+    r: number;
+    g: number;
+    b: number;
+}
+
+/**
+ * Headless Terminal — same API as @xterm/headless.
+ *
+ * @example
+ * ```typescript
+ * import { init, Terminal } from 'ghostty-web/headless';
+ *
+ * await init();
+ * const term = new Terminal({ cols: 80, rows: 24, scrollback: 1000 });
+ * term.write('\x1b[31mRed text\x1b[0m\r\n');
+ *
+ * const line = term.buffer.active.getLine(0);
+ * console.log(line?.translateToString());
+ * ```
+ */
+export declare class Terminal extends TerminalCore {
+    constructor(options?: ITerminalOptions);
+}
+
+declare class TerminalCore implements IDisposable {
+    cols: number;
+    rows: number;
+    readonly buffer: IBufferNamespace;
+    readonly options: Required<ITerminalOptions>;
+    protected ghostty: Ghostty;
+    wasmTerm?: GhosttyTerminal;
+    protected dataEmitter: EventEmitter<string>;
+    protected resizeEmitter: EventEmitter<{
+        cols: number;
+        rows: number;
+    }>;
+    protected bellEmitter: EventEmitter<void>;
+    protected titleChangeEmitter: EventEmitter<string>;
+    protected scrollEmitter: EventEmitter<number>;
+    protected cursorMoveEmitter: EventEmitter<void>;
+    protected lineFeedEmitter: EventEmitter<void>;
+    protected writeParsedEmitter: EventEmitter<void>;
+    protected binaryEmitter: EventEmitter<string>;
+    protected promptStartEmitter: EventEmitter<void>;
+    protected commandStartEmitter: EventEmitter<void>;
+    protected commandEndEmitter: EventEmitter<{
+        exitCode: number | undefined;
+    }>;
+    readonly onData: IEvent<string>;
+    readonly onResize: IEvent<{
+        cols: number;
+        rows: number;
+    }>;
+    readonly onBell: IEvent<void>;
+    readonly onTitleChange: IEvent<string>;
+    readonly onScroll: IEvent<number>;
+    readonly onCursorMove: IEvent<void>;
+    readonly onLineFeed: IEvent<void>;
+    readonly onWriteParsed: IEvent<void>;
+    readonly onBinary: IEvent<string>;
+    /** Fires when OSC 133 A is received (shell prompt is about to be drawn). */
+    readonly onPromptStart: IEvent<void>;
+    /** Fires when OSC 133 C is received (user hit Enter — command is running). */
+    readonly onCommandStart: IEvent<void>;
+    /** Fires when OSC 133 D is received (command finished). exitCode is undefined if not reported. */
+    readonly onCommandEnd: IEvent<{
+        exitCode: number | undefined;
+    }>;
+    protected isDisposed: boolean;
+    protected addons: ITerminalAddon[];
+    protected currentTitle: string;
+    protected lastCursorY: number;
+    protected lastCursorX: number;
+    protected _viewportY: number;
+    protected _markers: any[];
+    constructor(ghostty: Ghostty, options?: ITerminalOptions);
+    get markers(): ReadonlyArray<any>;
+    protected handleOptionChange(key: string, _newValue: any, _oldValue: any): void;
+    write(data: string | Uint8Array, callback?: () => void): void;
+    writeln(data: string | Uint8Array, callback?: () => void): void;
+    input(data: string, wasUserInput?: boolean): void;
+    resize(cols: number, rows: number): void;
+    reset(): void;
+    clear(): void;
+    dispose(): void;
+    scrollLines(amount: number): void;
+    scrollPages(pageCount: number): void;
+    scrollToTop(): void;
+    scrollToBottom(): void;
+    scrollToLine(line: number): void;
+    registerMarker(_cursorYOffset?: number): any | undefined;
+    loadAddon(addon: ITerminalAddon): void;
+    getViewportY(): number;
+    getScrollbackLength(): number;
+    getScrollbackLine(offset: number): GhosttyCell[] | null;
+    getMode(mode: number, isAnsi?: boolean): boolean;
+    hasBracketedPaste(): boolean;
+    hasFocusEvents(): boolean;
+    hasMouseTracking(): boolean;
+    protected parseColorToHex(color?: string): number;
+    protected buildWasmConfig(): GhosttyTerminalConfig | undefined;
+    protected processTerminalResponses(): void;
+    /**
+     * Intercept OSC 133 shell-integration markers in outgoing PTY data.
+     *
+     * A = prompt start   B = input start (ignored here, fires with A)
+     * C = command start  D = command end (optionally with exit code)
+     *
+     * Sequences span a single write in practice; partial-write edge cases
+     * are not handled — the common case is one atomic write per marker.
+     */
+    protected checkForShellIntegration(data: string): void;
+    protected checkForTitleChange(data: string): void;
+    protected checkCursorMove(): void;
+}
+
+/**
+ * Opaque terminal pointer (WASM memory address)
+ */
+declare type TerminalHandle = number;
+
+export { }