duckdb-terminal 0.1.0

package/dist/lib.d.ts

@@ -0,0 +1,2194 @@
+export declare const BOLD = "\u001B[1m";
+
+/**
+ * Apply bold style
+ */
+export declare function bold(text: string): string;
+
+/**
+ * Apply color to text.
+ * Accepts either a VT100 escape code constant (e.g., FG_RED) or a named color string (e.g., 'red').
+ *
+ * @param text - The text to colorize
+ * @param color - Either a VT100 escape code or a named color ('red', 'green', 'yellow', 'blue', 'cyan', 'magenta', 'white', 'black', or 'bright' variants)
+ * @returns The text wrapped with the color escape codes
+ *
+ * @example
+ * // Using VT100 constants
+ * colorize('Error', FG_RED)
+ *
+ * @example
+ * // Using named colors
+ * colorize('Success', 'green')
+ */
+export declare function colorize(text: string, color: string): string;
+
+/**
+ * Definition of a dot command
+ */
+export declare interface Command {
+    /** Command name including the dot prefix */
+    name: string;
+    /** Short description of what the command does */
+    description: string;
+    /** Usage example */
+    usage?: string;
+    /** The function that handles the command */
+    handler: CommandHandler;
+}
+
+/**
+ * Interface for the terminal context needed by command handlers
+ */
+export declare interface CommandContext {
+    /** Write text to terminal (no newline) */
+    write: (text: string) => void;
+    /** Write text to terminal with newline */
+    writeln: (text: string) => void;
+    /** Clear the terminal */
+    clear: () => void;
+    /** Get the database instance */
+    getDatabase: () => Database;
+    /** Get loaded files map */
+    getLoadedFiles: () => Map<string, FileInfo>;
+    /** Get last query result */
+    getLastQueryResult: () => QueryResult | null;
+    /** Get current output mode */
+    getOutputMode: () => 'table' | 'csv' | 'tsv' | 'json';
+    /** Set output mode */
+    setOutputMode: (mode: 'table' | 'csv' | 'tsv' | 'json') => void;
+    /** Get timer status */
+    getShowTimer: () => boolean;
+    /** Set timer status */
+    setShowTimer: (enabled: boolean) => void;
+    /** Get syntax highlighting status */
+    getSyntaxHighlighting: () => boolean;
+    /** Set syntax highlighting status */
+    setSyntaxHighlighting: (enabled: boolean) => void;
+    /** Get link provider */
+    getLinkProvider: () => LinkProvider;
+    /** Get page size */
+    getPageSize: () => number;
+    /** Set page size */
+    setPageSize: (size: number) => void;
+    /** Get current prompt */
+    getPrompt: () => string;
+    /** Get current continuation prompt */
+    getContinuationPrompt: () => string;
+    /** Set prompts */
+    setPrompts: (primary: string, continuation?: string) => void;
+    /** Get highlighted SQL */
+    getHighlightedSQL: (sql: string) => string;
+    /** Set theme */
+    setTheme: (theme: 'dark' | 'light') => void;
+    /** Get current theme name */
+    getThemeName: () => string;
+    /** Load a file */
+    loadFile: (file: File) => Promise<void>;
+    /** Remove a loaded file */
+    removeFile: (filename: string) => Promise<void>;
+    /** Reset the terminal state */
+    resetState: () => Promise<void>;
+}
+
+/**
+ * Handler function for a command
+ */
+export declare type CommandHandler = (args: string[]) => Promise<void> | void;
+
+/**
+ * An auto-completion suggestion.
+ */
+declare interface CompletionSuggestion {
+    /** The suggested completion value */
+    value: string;
+    /** The type of suggestion (for display styling) */
+    type: 'keyword' | 'table' | 'column' | 'function';
+}
+
+/**
+ * URL link detection and handling for terminal output.
+ *
+ * This module provides utilities for detecting URLs in text and wrapping them
+ * in OSC 8 escape sequences to create clickable hyperlinks in supported terminals.
+ *
+ * OSC 8 (Operating System Command 8) is a standard escape sequence for hyperlinks:
+ * `\x1b]8;;URL\x07LINK_TEXT\x1b]8;;\x07`
+ *
+ * @module utils/link-provider
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { linkifyText, containsURL } from './link-provider';
+ *
+ * const text = 'Visit https://example.com for more info';
+ * if (containsURL(text)) {
+ *   const linkedText = linkifyText(text);
+ *   // linkedText contains OSC 8 escape sequences
+ * }
+ * ```
+ */
+/**
+ * Checks if text contains any URLs.
+ *
+ * @param text - The text to search for URLs
+ * @returns True if text contains at least one URL
+ */
+export declare function containsURL(text: string): boolean;
+
+/**
+ * Clipboard utilities for copy/paste support
+ */
+/**
+ * Copy text to clipboard
+ */
+export declare function copyToClipboard(text: string): Promise<boolean>;
+
+/**
+ * Creates all command definitions for the terminal
+ */
+export declare function createCommands(ctx: CommandContext): Map<string, Command>;
+
+/**
+ * Creates and initializes a DuckDB terminal instance.
+ *
+ * This is the primary factory function for creating a terminal. It instantiates
+ * a new {@link DuckDBTerminal}, initializes all components (terminal adapter,
+ * database, history), and returns the ready-to-use terminal.
+ *
+ * @param config - Configuration options for the terminal
+ * @returns A promise that resolves to the initialized terminal instance
+ *
+ * @throws Error if the container element is not found
+ * @throws Error if DuckDB WASM initialization fails
+ *
+ * @example Create with a CSS selector
+ * ```typescript
+ * const terminal = await createTerminal({
+ *   container: '#my-terminal',
+ *   theme: 'dark',
+ * });
+ * ```
+ *
+ * @example Create with an HTML element
+ * ```typescript
+ * const container = document.getElementById('terminal');
+ * const terminal = await createTerminal({
+ *   container,
+ *   fontSize: 16,
+ *   fontFamily: 'JetBrains Mono',
+ *   theme: 'light',
+ * });
+ * ```
+ *
+ * @example Create with custom theme
+ * ```typescript
+ * const terminal = await createTerminal({
+ *   container: '#terminal',
+ *   theme: {
+ *     name: 'my-theme',
+ *     colors: {
+ *       background: '#1a1b26',
+ *       foreground: '#a9b1d6',
+ *       // ... other colors
+ *     },
+ *   },
+ * });
+ * ```
+ *
+ * @example Create with custom prompts
+ * ```typescript
+ * const terminal = await createTerminal({
+ *   container: '#terminal',
+ *   prompt: 'SQL> ',
+ *   continuationPrompt: '... ',
+ * });
+ * ```
+ */
+export declare function createTerminal(config: TerminalConfig): Promise<DuckDBTerminal>;
+
+/**
+ * Dark theme
+ */
+export declare const darkTheme: Theme;
+
+/**
+ * A wrapper around DuckDB WASM that provides a simplified interface for
+ * executing SQL queries and managing the database lifecycle.
+ *
+ * This class handles:
+ * - DuckDB WASM initialization and worker setup
+ * - Query execution and result formatting
+ * - Auto-completion suggestions for SQL keywords, tables, and functions
+ * - Virtual filesystem for loading external files (CSV, Parquet, JSON)
+ *
+ * @example Basic usage
+ * ```typescript
+ * const db = new Database({ storage: 'memory' });
+ * await db.init();
+ *
+ * const result = await db.executeQuery('SELECT 1 + 1 as answer;');
+ * console.log(result.rows); // [[2]]
+ *
+ * await db.close();
+ * ```
+ *
+ * @example With OPFS persistent storage
+ * ```typescript
+ * const db = new Database({
+ *   storage: 'opfs',
+ *   databasePath: '/mydata.duckdb',
+ * });
+ * await db.init();
+ * // Data persists across page refreshes
+ * ```
+ *
+ * @example Loading external files
+ * ```typescript
+ * const db = new Database();
+ * await db.init();
+ *
+ * // Register a file in DuckDB's virtual filesystem
+ * const csvData = new Uint8Array([...]); // CSV file contents
+ * await db.registerFile('data.csv', csvData);
+ *
+ * // Query the file
+ * const result = await db.executeQuery("SELECT * FROM read_csv('data.csv');");
+ * ```
+ */
+export declare class Database {
+    private db;
+    private conn;
+    private worker;
+    private initialized;
+    private options;
+    constructor(options?: DatabaseOptions);
+    /**
+     * Initializes the DuckDB database.
+     *
+     * This method performs the following setup:
+     * 1. Downloads the appropriate DuckDB WASM bundle
+     * 2. Creates a Web Worker for database operations
+     * 3. Instantiates the DuckDB instance
+     * 4. Opens the database (in-memory or OPFS-backed)
+     * 5. Creates a connection for query execution
+     *
+     * @returns A promise that resolves when initialization is complete
+     *
+     * @throws Error if initialization fails (network issues, WASM loading, etc.)
+     *
+     * @example
+     * ```typescript
+     * const db = new Database();
+     * await db.init();
+     * console.log('Database ready:', db.isReady());
+     * ```
+     */
+    init(): Promise<void>;
+    /**
+     * Executes a SQL query and returns the results.
+     *
+     * @param sql - The SQL statement to execute
+     * @returns A promise that resolves to the query result containing columns, rows, row count, and duration
+     *
+     * @throws Error if the database is not initialized
+     * @throws Error if the SQL query is invalid or fails
+     *
+     * @example SELECT query
+     * ```typescript
+     * const result = await db.executeQuery('SELECT * FROM users WHERE age > 18;');
+     * console.log('Columns:', result.columns); // ['id', 'name', 'age']
+     * console.log('Rows:', result.rows);       // [[1, 'Alice', 25], [2, 'Bob', 30]]
+     * console.log('Duration:', result.duration); // 5.23 (milliseconds)
+     * ```
+     *
+     * @example DDL statement
+     * ```typescript
+     * await db.executeQuery('CREATE TABLE products (id INTEGER, name VARCHAR);');
+     * ```
+     */
+    executeQuery(sql: string): Promise<QueryResult>;
+    /**
+     * Gets auto-completion suggestions for the current input.
+     *
+     * Provides suggestions for:
+     * - SQL keywords (SELECT, FROM, WHERE, etc.)
+     * - Table names from the current database
+     * - Common SQL functions
+     *
+     * @param text - The current input text
+     * @param cursorPosition - The cursor position within the text
+     * @returns A promise that resolves to an array of completion suggestions
+     *
+     * @example
+     * ```typescript
+     * const suggestions = await db.getCompletions('SEL', 3);
+     * console.log(suggestions);
+     * // [{ value: 'SELECT', type: 'keyword' }]
+     * ```
+     */
+    getCompletions(text: string, cursorPosition: number): Promise<CompletionSuggestion[]>;
+    /**
+     * Gets a list of all tables in the database.
+     *
+     * Queries the information_schema to retrieve table names from the 'main' schema.
+     *
+     * @returns A promise that resolves to an array of table names
+     *
+     * @example
+     * ```typescript
+     * const tables = await db.getTables();
+     * console.log('Tables:', tables); // ['users', 'products', 'orders']
+     * ```
+     */
+    getTables(): Promise<string[]>;
+    /**
+     * Gets the schema (column definitions) for a specific table.
+     *
+     * @param tableName - The name of the table to get the schema for
+     * @returns A promise that resolves to an array of column definitions
+     *
+     * @example
+     * ```typescript
+     * const schema = await db.getTableSchema('users');
+     * console.log(schema);
+     * // [
+     * //   { name: 'id', type: 'INTEGER' },
+     * //   { name: 'name', type: 'VARCHAR' },
+     * //   { name: 'email', type: 'VARCHAR' }
+     * // ]
+     * ```
+     */
+    getTableSchema(tableName: string): Promise<{
+        name: string;
+        type: string;
+    }[]>;
+    /**
+     * Registers a file in DuckDB's virtual filesystem.
+     *
+     * This allows you to load external files (CSV, Parquet, JSON) into DuckDB
+     * and query them using functions like `read_csv()`, `read_parquet()`, etc.
+     *
+     * @param filename - The virtual filename to register (e.g., 'data.csv')
+     * @param data - The file contents as a Uint8Array
+     *
+     * @throws Error if the database is not initialized
+     *
+     * @example
+     * ```typescript
+     * // Load a CSV file
+     * const response = await fetch('https://example.com/data.csv');
+     * const data = new Uint8Array(await response.arrayBuffer());
+     * await db.registerFile('data.csv', data);
+     *
+     * // Query the file
+     * const result = await db.executeQuery("SELECT * FROM read_csv('data.csv');");
+     * ```
+     */
+    registerFile(filename: string, data: Uint8Array): Promise<void>;
+    /**
+     * Removes a file from DuckDB's virtual filesystem.
+     *
+     * @param filename - The filename to remove
+     *
+     * @throws Error if the database is not initialized
+     *
+     * @example
+     * ```typescript
+     * await db.dropFile('data.csv');
+     * ```
+     */
+    dropFile(filename: string): Promise<void>;
+    /**
+     * Checks if the database is initialized and ready for queries.
+     *
+     * @returns True if the database is ready, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (db.isReady()) {
+     *   const result = await db.executeQuery('SELECT 1;');
+     * }
+     * ```
+     */
+    isReady(): boolean;
+    /**
+     * Closes the database connection and releases resources.
+     *
+     * This method:
+     * 1. Closes the database connection
+     * 2. Terminates the DuckDB instance
+     * 3. Terminates the Web Worker
+     *
+     * After calling this method, {@link init} must be called again before
+     * executing any queries.
+     *
+     * @returns A promise that resolves when cleanup is complete
+     *
+     * @example
+     * ```typescript
+     * await db.close();
+     * console.log('Database closed:', !db.isReady());
+     * ```
+     */
+    close(): Promise<void>;
+}
+
+/**
+ * Configuration options for the Database class.
+ */
+declare interface DatabaseOptions {
+    /**
+     * The storage backend to use.
+     * - 'memory': In-memory database (default, data lost on page refresh)
+     * - 'opfs': Origin Private File System (persistent storage)
+     */
+    storage?: 'memory' | 'opfs';
+    /**
+     * The database file path when using OPFS storage.
+     * Defaults to ':memory:' for in-memory storage.
+     */
+    databasePath?: string;
+}
+
+export declare const DIM = "\u001B[2m";
+
+/**
+ * Apply dim style
+ */
+export declare function dim(text: string): string;
+
+/**
+ * A browser-based SQL terminal for DuckDB, powered by Ghostty terminal emulator.
+ *
+ * DuckDBTerminal provides a full-featured SQL REPL (Read-Eval-Print Loop) that runs
+ * entirely in the browser using DuckDB WASM. It supports:
+ *
+ * - Multi-line SQL statements with syntax highlighting
+ * - Command history with arrow key navigation
+ * - Tab completion for SQL keywords, table names, and functions
+ * - Dot commands (`.help`, `.tables`, `.schema`, etc.)
+ * - Multiple output formats (table, CSV, JSON)
+ * - File loading via drag-and-drop or file picker
+ * - Result pagination for large datasets
+ * - Custom theming
+ * - Customizable prompts (via config or `.prompt` command)
+ * - Event system for integration with host applications
+ *
+ * @implements {TerminalInterface}
+ *
+ * @example Basic usage
+ * ```typescript
+ * const terminal = new DuckDBTerminal({
+ *   container: '#terminal',
+ *   theme: 'dark',
+ * });
+ * await terminal.start();
+ * ```
+ *
+ * @example With custom prompts
+ * ```typescript
+ * const terminal = new DuckDBTerminal({
+ *   container: '#terminal',
+ *   prompt: 'SQL> ',
+ *   continuationPrompt: '... ',
+ * });
+ * await terminal.start();
+ * ```
+ *
+ * @example With event listeners
+ * ```typescript
+ * const terminal = new DuckDBTerminal({ container: '#terminal' });
+ *
+ * terminal.on('queryEnd', ({ sql, result, duration }) => {
+ *   console.log(`Query "${sql}" completed in ${duration}ms`);
+ * });
+ *
+ * terminal.on('error', ({ message, source }) => {
+ *   console.error(`Error from ${source}: ${message}`);
+ * });
+ *
+ * await terminal.start();
+ * ```
+ *
+ * @example Programmatic SQL execution
+ * ```typescript
+ * const terminal = new DuckDBTerminal({ container: '#terminal' });
+ * await terminal.start();
+ *
+ * const result = await terminal.executeSQL('SELECT * FROM users LIMIT 10;');
+ * console.log(result.columns); // ['id', 'name', 'email']
+ * console.log(result.rows);    // [[1, 'Alice', 'alice@example.com'], ...]
+ * ```
+ */
+export declare class DuckDBTerminal implements TerminalInterface {
+    private terminalAdapter;
+    private database;
+    private inputBuffer;
+    private history;
+    private state;
+    private collectedSQL;
+    private commands;
+    private showTimer;
+    private outputMode;
+    private currentThemeName;
+    private customTheme;
+    private config;
+    private loadedFiles;
+    private syntaxHighlighting;
+    private lastQueryResult;
+    private linkProvider;
+    private eventListeners;
+    private pageSize;
+    private paginationQuery;
+    private currentPage;
+    private totalRows;
+    private prompt;
+    private continuationPrompt;
+    private debouncedHighlight;
+    private queryQueue;
+    private dragDropCleanup;
+    constructor(config: TerminalConfig);
+    /**
+     * Subscribes to a terminal event.
+     *
+     * The terminal emits various events during its lifecycle that you can
+     * subscribe to for monitoring, logging, or integrating with your application.
+     *
+     * @typeParam K - The event type key from {@link TerminalEvents}
+     * @param event - The event name to subscribe to
+     * @param listener - The callback function to invoke when the event occurs
+     * @returns An unsubscribe function that removes the listener when called
+     *
+     * @example Subscribe to query events
+     * ```typescript
+     * const unsubscribe = terminal.on('queryEnd', ({ sql, result, duration }) => {
+     *   console.log(`Query completed in ${duration}ms`);
+     * });
+     *
+     * // Later, to stop listening:
+     * unsubscribe();
+     * ```
+     *
+     * @example Monitor state changes
+     * ```typescript
+     * terminal.on('stateChange', ({ state, previous }) => {
+     *   console.log(`Terminal state: ${previous} -> ${state}`);
+     * });
+     * ```
+     */
+    on<K extends keyof TerminalEvents>(event: K, listener: TerminalEventListener<K>): () => void;
+    /**
+     * Unsubscribes a listener from a terminal event.
+     *
+     * This is an alternative to using the unsubscribe function returned by {@link on}.
+     *
+     * @typeParam K - The event type key from {@link TerminalEvents}
+     * @param event - The event name to unsubscribe from
+     * @param listener - The callback function to remove
+     *
+     * @example
+     * ```typescript
+     * const handler = ({ sql }) => console.log(sql);
+     * terminal.on('queryStart', handler);
+     *
+     * // Later:
+     * terminal.off('queryStart', handler);
+     * ```
+     */
+    off<K extends keyof TerminalEvents>(event: K, listener: TerminalEventListener<K>): void;
+    /* Excluded from this release type: emit */
+    /* Excluded from this release type: setState */
+    /**
+     * Returns SQL with syntax highlighting applied.
+     *
+     * @param sql - The SQL string to highlight
+     * @returns The SQL with VT100 color codes applied, or the original SQL if highlighting is disabled
+     */
+    private getHighlightedSQL;
+    /**
+     * Redraws the current input line with syntax highlighting applied.
+     *
+     * This method clears the current line content and rewrites it with
+     * color codes for SQL keywords, strings, numbers, etc. Called on
+     * delimiter characters (space, semicolon, parentheses, comma) via debouncing.
+     */
+    private redrawLineHighlighted;
+    /**
+     * Returns the current theme object for terminal styling.
+     *
+     * @returns The custom theme if set, otherwise the built-in theme ('dark' or 'light')
+     */
+    private getCurrentThemeObject;
+    /**
+     * Initializes and starts the terminal.
+     *
+     * This method performs the following initialization steps:
+     * 1. Resolves the container element
+     * 2. Initializes the terminal adapter (Ghostty), database (DuckDB), and history store in parallel
+     * 3. Sets up input handling and drag-and-drop file loading
+     * 4. Displays the welcome message (if enabled)
+     * 5. Shows the command prompt
+     * 6. Emits the 'ready' event
+     *
+     * @returns A promise that resolves when the terminal is fully initialized
+     *
+     * @throws Error if the container element cannot be found
+     * @throws Error if DuckDB WASM initialization fails
+     *
+     * @example
+     * ```typescript
+     * const terminal = new DuckDBTerminal({ container: '#terminal' });
+     * await terminal.start();
+     * console.log('Terminal is ready!');
+     * ```
+     *
+     * @fires ready - Emitted when initialization is complete
+     */
+    start(): Promise<void>;
+    /**
+     * Cleans up resources and event listeners.
+     *
+     * Call this method when disposing of the terminal to prevent memory leaks.
+     * This removes drag-and-drop handlers and clears internal state.
+     */
+    destroy(): void;
+    /**
+     * Processes files dropped onto the terminal via drag-and-drop.
+     *
+     * Uses Promise.allSettled to ensure all files are attempted even if some fail.
+     *
+     * @param files - Array of File objects to load into DuckDB
+     */
+    private handleDroppedFiles;
+    /**
+     * Loads a file into DuckDB's virtual filesystem.
+     *
+     * Registers the file and displays usage hints for supported file types
+     * (CSV, Parquet, JSON). Emits a 'fileLoaded' event on success.
+     *
+     * @param file - The file to load
+     * @returns True if the file was loaded successfully, false otherwise
+     */
+    private loadFile;
+    /**
+     * Resolves the container element from the configuration.
+     *
+     * @returns The resolved HTML element to attach the terminal to
+     * @throws Error if the container selector doesn't match any element
+     */
+    private resolveContainer;
+    /**
+     * Registers all built-in dot commands (.help, .tables, .schema, etc.).
+     *
+     * Called during construction to populate the commands map with handlers
+     * for terminal commands.
+     */
+    private registerCommands;
+    /**
+     * Displays the command prompt (primary or continuation based on state).
+     *
+     * Sets terminal state to 'idle' if not currently collecting multi-line SQL.
+     */
+    private showPrompt;
+    /**
+     * Handles raw terminal input data.
+     *
+     * Routes input to the appropriate handler based on terminal state
+     * (executing, paginating, or normal input mode). Processes escape
+     * sequences separately from regular character input.
+     *
+     * @param data - The raw input data from the terminal
+     */
+    private handleInput;
+    /**
+     * Handles input during pagination mode.
+     *
+     * Supports: [n]ext page, [p]revious page, [q]uit, page number entry,
+     * and arrow keys for navigation.
+     *
+     * @param data - The input character or escape sequence
+     */
+    private handlePaginationInput;
+    /**
+     * Processes a single character of user input.
+     *
+     * Handles special characters (Enter, Backspace, Tab, Ctrl sequences)
+     * and regular printable characters including Unicode.
+     *
+     * @param char - The single character to process
+     */
+    private handleChar;
+    /**
+     * Checks if a character should trigger syntax highlighting redraw.
+     *
+     * @param char - The character to check
+     * @returns True if the character is a highlighting trigger (space, semicolon, parentheses, comma)
+     */
+    private isHighlightTrigger;
+    /**
+     * Processes VT100 escape sequences for special keys.
+     *
+     * Handles arrow keys (up/down for history, left/right for cursor),
+     * Home, End, and Delete keys.
+     *
+     * @param seq - The escape sequence string (e.g., '\x1b[A' for Arrow Up)
+     */
+    private handleEscapeSequence;
+    /**
+     * Handles the Enter key press.
+     *
+     * For dot commands, executes immediately. For SQL, collects lines until
+     * a semicolon terminates the statement, then executes.
+     */
+    private handleEnter;
+    /**
+     * Navigates to the previous command in history (Arrow Up).
+     */
+    private handleArrowUp;
+    /**
+     * Navigates to the next command in history (Arrow Down).
+     */
+    private handleArrowDown;
+    /**
+     * Handles Tab key for auto-completion.
+     *
+     * Provides suggestions for SQL keywords, table names, and functions.
+     * Single match is applied directly; multiple matches are displayed.
+     */
+    private handleTab;
+    /**
+     * Finds the longest common prefix among an array of strings.
+     *
+     * Used for auto-completion to expand to the longest unambiguous prefix.
+     *
+     * @param strings - Array of strings to find common prefix for
+     * @returns The longest common prefix (case-insensitive comparison)
+     */
+    private findCommonPrefix;
+    /**
+     * Handles Ctrl+C to cancel current input or multi-line collection.
+     */
+    private handleCtrlC;
+    /**
+     * Handles Ctrl+V to paste content from clipboard.
+     *
+     * Inserts text character-by-character, skipping newlines.
+     */
+    private handlePaste;
+    /**
+     * Copy last query result to clipboard
+     */
+    copyLastResult(): Promise<boolean>;
+    /**
+     * Executes a dot command (e.g., .help, .tables, .schema).
+     *
+     * Parses the command and arguments, looks up the handler, and executes it.
+     * Emits 'commandExecute' event on execution and 'error' on failure.
+     *
+     * @param input - The full command string including arguments
+     */
+    private executeCommand;
+    /**
+     * Executes a SQL query and displays the results.
+     *
+     * This method executes the provided SQL statement against the DuckDB database,
+     * displays the results in the configured output format (table, CSV, or JSON),
+     * and adds the query to the command history.
+     *
+     * For large result sets (when pagination is enabled via `.pagesize`), the method
+     * will automatically paginate the results and enter pagination mode.
+     *
+     * @param sql - The SQL statement to execute (should end with a semicolon)
+     * @returns A promise that resolves to the query result, or null if an error occurred
+     *
+     * @fires queryStart - Emitted before query execution begins
+     * @fires queryEnd - Emitted after query execution completes (success or failure)
+     * @fires error - Emitted if the query fails
+     *
+     * @example Execute a SELECT query
+     * ```typescript
+     * const result = await terminal.executeSQL('SELECT * FROM users;');
+     * if (result) {
+     *   console.log(`Retrieved ${result.rowCount} rows in ${result.duration}ms`);
+     *   console.log('Columns:', result.columns);
+     *   console.log('First row:', result.rows[0]);
+     * }
+     * ```
+     *
+     * @example Execute DDL statements
+     * ```typescript
+     * await terminal.executeSQL('CREATE TABLE products (id INTEGER, name VARCHAR);');
+     * await terminal.executeSQL("INSERT INTO products VALUES (1, 'Widget');");
+     * ```
+     */
+    executeSQL(sql: string): Promise<QueryResult | null>;
+    /* Excluded from this release type: executeSQLInternal */
+    /**
+     * Executes the current paginated query for the current page.
+     *
+     * Adds LIMIT/OFFSET to the stored query and displays results with
+     * pagination controls.
+     *
+     * @returns The query result for the current page, or null on error
+     */
+    private executePaginatedQuery;
+    /**
+     * Exits pagination mode and resets pagination state.
+     */
+    private exitPagination;
+    /**
+     * Displays a query result in the current output mode.
+     *
+     * Formats and writes the result as table, CSV, TSV, or JSON based on
+     * the current outputMode setting.
+     *
+     * @param result - The query result to display
+     */
+    private displayResult;
+    private cmdHelp;
+    private cmdTables;
+    private cmdSchema;
+    private cmdTimer;
+    private cmdMode;
+    private cmdTheme;
+    private cmdExamples;
+    private cmdFiles;
+    private cmdOpen;
+    private cmdHighlight;
+    private cmdLinks;
+    private cmdPageSize;
+    private cmdReset;
+    private cmdPrompt;
+    /**
+     * Writes text to the terminal without a trailing newline.
+     *
+     * Use this method for inline output where you don't want to start a new line.
+     * The text is written directly to the terminal without any processing.
+     *
+     * @param text - The text to write to the terminal
+     *
+     * @example
+     * ```typescript
+     * terminal.write('Loading');
+     * terminal.write('...');
+     * terminal.write(' Done!\n');
+     * ```
+     */
+    write(text: string): void;
+    /**
+     * Writes text to the terminal followed by a newline.
+     *
+     * The text is processed for clickable URLs (if link detection is enabled)
+     * and newlines are normalized to CRLF for proper terminal display.
+     *
+     * @param text - The text to write to the terminal
+     *
+     * @example
+     * ```typescript
+     * terminal.writeln('Query completed successfully!');
+     * terminal.writeln('Visit https://duckdb.org for documentation');
+     * ```
+     */
+    writeln(text: string): void;
+    /**
+     * Clears the terminal screen.
+     *
+     * This removes all content from the terminal display and moves the cursor
+     * to the top-left corner.
+     *
+     * @example
+     * ```typescript
+     * terminal.clear();
+     * terminal.writeln('Screen cleared!');
+     * ```
+     */
+    clear(): void;
+    /**
+     * Sets the terminal color theme.
+     *
+     * You can set a built-in theme ('dark' or 'light') or provide a custom
+     * theme object with your own colors. Built-in theme preferences are
+     * persisted to localStorage.
+     *
+     * @param theme - The theme to apply: 'dark', 'light', or a custom Theme object
+     *
+     * @fires themeChange - Emitted after the theme is changed
+     *
+     * @example Set a built-in theme
+     * ```typescript
+     * terminal.setTheme('light');
+     * ```
+     *
+     * @example Set a custom theme
+     * ```typescript
+     * terminal.setTheme({
+     *   name: 'my-theme',
+     *   colors: {
+     *     background: '#1a1b26',
+     *     foreground: '#a9b1d6',
+     *     cursor: '#c0caf5',
+     *     // ... other color properties
+     *   },
+     * });
+     * ```
+     */
+    setTheme(theme: 'dark' | 'light' | Theme): void;
+    /**
+     * Gets the current theme mode.
+     *
+     * Returns 'dark' or 'light' based on the current theme. For custom themes,
+     * this returns 'light' if the theme name is 'light', otherwise 'dark'.
+     *
+     * @returns The current theme mode: 'dark' or 'light'
+     *
+     * @example
+     * ```typescript
+     * const mode = terminal.getTheme();
+     * console.log(`Current theme mode: ${mode}`);
+     * ```
+     */
+    getTheme(): 'dark' | 'light';
+}
+
+/**
+ * Embeds a DuckDB terminal into a container element.
+ *
+ * This is an alias for {@link createTerminal} provided for semantic clarity
+ * when embedding the terminal into an existing page.
+ *
+ * @param config - Configuration options for the terminal
+ * @returns A promise that resolves to the initialized terminal instance
+ *
+ * @example
+ * ```typescript
+ * const terminal = await embed({
+ *   container: '#sql-editor',
+ *   theme: 'dark',
+ *   welcomeMessage: false,
+ * });
+ * ```
+ */
+export declare function embed(config: TerminalConfig): Promise<DuckDBTerminal>;
+
+/**
+ * Extracts all URLs from text.
+ *
+ * @param text - The text to extract URLs from
+ * @returns Array of URLs found in the text
+ */
+export declare function extractURLs(text: string): string[];
+
+export declare const FG_BLUE = "\u001B[34m";
+
+export declare const FG_CYAN = "\u001B[36m";
+
+export declare const FG_GREEN = "\u001B[32m";
+
+export declare const FG_RED = "\u001B[31m";
+
+export declare const FG_WHITE = "\u001B[37m";
+
+export declare const FG_YELLOW = "\u001B[33m";
+
+declare interface FileInfo {
+    name: string;
+    size: number;
+    type: string;
+    lastModified: Date;
+}
+
+/**
+ * Format query results as CSV
+ */
+export declare function formatCSV(columns: string[], rows: unknown[][]): string;
+
+/**
+ * Format query results as JSON.
+ * Uses jsonSafeReplacer to handle BigInt values that JSON.stringify
+ * cannot serialize natively.
+ */
+export declare function formatJSON(columns: string[], rows: unknown[][]): string;
+
+/**
+ * Format query results as ASCII table
+ */
+export declare function formatTable(columns: string[], rows: unknown[][], options?: TableOptions): string;
+
+/**
+ * Format query results as TSV (Tab-Separated Values)
+ */
+export declare function formatTSV(columns: string[], rows: unknown[][]): string;
+
+/**
+ * Get saved theme preference
+ */
+export declare function getSavedTheme(): 'dark' | 'light';
+
+/**
+ * Get theme by name
+ */
+export declare function getTheme(name: 'dark' | 'light'): Theme;
+
+/**
+ * Highlight SQL string with ANSI colors
+ */
+export declare function highlightSQL(sql: string): string;
+
+/**
+ * Command history store using IndexedDB for persistence.
+ *
+ * This module provides a persistent command history that survives browser
+ * refreshes. History is stored in IndexedDB and falls back to in-memory
+ * storage if IndexedDB is unavailable.
+ *
+ * @module utils/history
+ */
+/**
+ * A persistent command history store backed by IndexedDB.
+ *
+ * Features:
+ * - Persists command history to IndexedDB
+ * - Falls back to in-memory storage if IndexedDB is unavailable
+ * - Supports navigation through history with previous/next
+ * - Automatically limits history size to prevent unbounded growth
+ * - Deduplicates consecutive identical commands
+ *
+ * @example Basic usage
+ * ```typescript
+ * const history = new HistoryStore();
+ * await history.init();
+ *
+ * // Add commands to history
+ * await history.add('SELECT * FROM users;');
+ * await history.add('SELECT count(*) FROM orders;');
+ *
+ * // Navigate history
+ * const prev = history.previous('');  // Returns 'SELECT count(*) FROM orders;'
+ * const prev2 = history.previous(''); // Returns 'SELECT * FROM users;'
+ * const next = history.next();        // Returns 'SELECT count(*) FROM orders;'
+ * ```
+ *
+ * @example With input preservation
+ * ```typescript
+ * const history = new HistoryStore();
+ * await history.init();
+ *
+ * // Current input is preserved when navigating
+ * const prev = history.previous('SELECT '); // Saves 'SELECT ' as current input
+ * // ... user navigates through history ...
+ * const current = history.next(); // Eventually returns 'SELECT '
+ * ```
+ */
+export declare class HistoryStore {
+    private db;
+    private history;
+    private cursor;
+    private currentInput;
+    private initialized;
+    /**
+     * Initializes the history store by opening IndexedDB and loading existing history.
+     *
+     * This method must be called before using other methods. It loads any
+     * previously stored commands from IndexedDB. If IndexedDB is unavailable
+     * (e.g., in private browsing), the store falls back to in-memory storage.
+     *
+     * @returns A promise that resolves when initialization is complete
+     *
+     * @example
+     * ```typescript
+     * const history = new HistoryStore();
+     * await history.init();
+     * // Now ready to use
+     * ```
+     */
+    init(): Promise<void>;
+    /**
+     * Open IndexedDB database
+     */
+    private openDatabase;
+    /**
+     * Load history from IndexedDB
+     */
+    private loadHistory;
+    /**
+     * Adds a command to the history.
+     *
+     * The command is stored both in memory and persisted to IndexedDB.
+     * Empty commands and consecutive duplicates are ignored.
+     *
+     * @param command - The command to add to history
+     * @returns A promise that resolves when the command has been persisted
+     *
+     * @example
+     * ```typescript
+     * await history.add('SELECT * FROM users;');
+     * await history.add('SELECT * FROM users;'); // Ignored (duplicate)
+     * await history.add(''); // Ignored (empty)
+     * ```
+     */
+    add(command: string): Promise<void>;
+    /**
+     * Save command to IndexedDB
+     */
+    private saveCommand;
+    /**
+     * Trim history in IndexedDB to max size.
+     *
+     * Uses a single transaction for all deletions for better performance.
+     */
+    private trimHistory;
+    /**
+     * Navigates to the previous command in history.
+     *
+     * When called from the end of history (most recent position), this method
+     * saves the current input so it can be restored when navigating forward.
+     *
+     * @param currentInput - The current input buffer content to preserve
+     * @returns The previous command, or null if at the beginning of history
+     *
+     * @example
+     * ```typescript
+     * // Assuming history has ['SELECT 1;', 'SELECT 2;']
+     * const cmd1 = history.previous('SELECT 3'); // Returns 'SELECT 2;'
+     * const cmd2 = history.previous('');         // Returns 'SELECT 1;'
+     * const cmd3 = history.previous('');         // Returns null (at beginning)
+     * ```
+     */
+    previous(currentInput: string): string | null;
+    /**
+     * Navigates to the next command in history.
+     *
+     * When reaching the end of history, returns the previously saved current input.
+     *
+     * @returns The next command, the saved current input if at the end, or null if beyond
+     *
+     * @example
+     * ```typescript
+     * // After navigating backward with previous()
+     * const cmd1 = history.next(); // Returns next newer command
+     * const cmd2 = history.next(); // Returns original input when at end
+     * ```
+     */
+    next(): string | null;
+    /**
+     * Resets the history cursor to the end and clears the saved current input.
+     *
+     * This should be called after a command is executed to prepare for new navigation.
+     */
+    reset(): void;
+    /**
+     * Returns a copy of all commands in history.
+     *
+     * @returns An array of all stored commands, oldest first
+     */
+    getAll(): string[];
+    /**
+     * Clears all history from both memory and IndexedDB.
+     *
+     * @returns A promise that resolves when the history has been cleared
+     */
+    clear(): Promise<void>;
+}
+
+/**
+ * A text buffer with cursor management for terminal line editing.
+ *
+ * The InputBuffer maintains both the current text content and cursor position,
+ * providing methods for common editing operations. Each editing method returns
+ * the VT100 escape sequences needed to update the terminal display.
+ *
+ * Features:
+ * - Character insertion at cursor position
+ * - Backspace and delete key handling
+ * - Cursor movement (left, right, home, end)
+ * - Line clearing operations
+ * - Word-based operations for auto-completion
+ *
+ * @example Basic usage
+ * ```typescript
+ * const buffer = new InputBuffer();
+ *
+ * // Type "hello"
+ * terminal.write(buffer.insert('h'));
+ * terminal.write(buffer.insert('e'));
+ * terminal.write(buffer.insert('l'));
+ * terminal.write(buffer.insert('l'));
+ * terminal.write(buffer.insert('o'));
+ *
+ * console.log(buffer.getContent()); // 'hello'
+ * console.log(buffer.getCursorPos()); // 5
+ *
+ * // Delete last character
+ * terminal.write(buffer.backspace()); // Buffer is now 'hell'
+ * ```
+ *
+ * @example Cursor movement
+ * ```typescript
+ * const buffer = new InputBuffer();
+ * buffer.setContent('hello world');
+ *
+ * terminal.write(buffer.moveToStart()); // Cursor at position 0
+ * terminal.write(buffer.moveRight());   // Cursor at position 1
+ * terminal.write(buffer.moveToEnd());   // Cursor at position 11
+ * ```
+ *
+ * @example Auto-completion
+ * ```typescript
+ * const buffer = new InputBuffer();
+ * buffer.setContent('SELECT * FROM us');
+ *
+ * const word = buffer.getWordBeforeCursor(); // 'us'
+ * terminal.write(buffer.replaceWordBeforeCursor('users'));
+ * console.log(buffer.getContent()); // 'SELECT * FROM users'
+ * ```
+ */
+export declare class InputBuffer {
+    private buffer;
+    private cursorPos;
+    private maxSize;
+    /**
+     * Set the prompt length for cursor calculations (reserved for future use)
+     */
+    setPromptLength(_length: number): void;
+    /**
+     * Sets the maximum buffer size.
+     *
+     * @param size - Maximum size in bytes (defaults to MAX_BUFFER_SIZE)
+     */
+    setMaxSize(size: number): void;
+    /**
+     * Returns the maximum buffer size.
+     *
+     * @returns The maximum size in bytes
+     */
+    getMaxSize(): number;
+    /**
+     * Returns the current buffer content.
+     *
+     * @returns The full text content of the buffer
+     */
+    getContent(): string;
+    /**
+     * Returns the current cursor position within the buffer.
+     *
+     * @returns The zero-based cursor position
+     */
+    getCursorPos(): number;
+    /**
+     * Clears the buffer and resets cursor to position 0.
+     */
+    clear(): void;
+    /**
+     * Sets the buffer content and moves cursor to end.
+     *
+     * Used for history navigation when replacing the current line with a previous command.
+     *
+     * @param content - The new buffer content
+     */
+    setContent(content: string): void;
+    /**
+     * Inserts text at the cursor position.
+     *
+     * @param char - The character(s) to insert
+     * @returns VT100 escape sequences to update the terminal display
+     */
+    insert(char: string): string;
+    /**
+     * Deletes the character before the cursor (backspace operation).
+     *
+     * @returns VT100 escape sequences to update the terminal display, or empty string if at start
+     */
+    backspace(): string;
+    /**
+     * Deletes the character at the cursor position (delete key operation).
+     *
+     * @returns VT100 escape sequences to update the terminal display, or empty string if at end
+     */
+    delete(): string;
+    /**
+     * Moves the cursor one position to the left.
+     *
+     * @returns VT100 escape sequence, or empty string if already at start
+     */
+    moveLeft(): string;
+    /**
+     * Moves the cursor one position to the right.
+     *
+     * @returns VT100 escape sequence, or empty string if already at end
+     */
+    moveRight(): string;
+    /**
+     * Moves the cursor to the start of the line (Home key / Ctrl+A).
+     *
+     * @returns VT100 escape sequence, or empty string if already at start
+     */
+    moveToStart(): string;
+    /**
+     * Moves the cursor to the end of the line (End key / Ctrl+E).
+     *
+     * @returns VT100 escape sequence, or empty string if already at end
+     */
+    moveToEnd(): string;
+    /**
+     * Clears from cursor position to end of line (Ctrl+K).
+     *
+     * @returns VT100 escape sequence to clear the terminal
+     */
+    clearToEnd(): string;
+    /**
+     * Clears the entire line and resets buffer (Ctrl+U).
+     *
+     * @returns VT100 escape sequences to clear the terminal line
+     */
+    clearLine(): string;
+    /**
+     * Returns the word immediately before the cursor for auto-completion.
+     *
+     * A word is defined as a sequence of word characters (`\w`) and dots.
+     *
+     * @returns The word before cursor, or empty string if none
+     */
+    getWordBeforeCursor(): string;
+    /**
+     * Replaces the word before the cursor with a completion string.
+     *
+     * @param completion - The completion string to insert
+     * @returns VT100 escape sequences to update the terminal display
+     */
+    replaceWordBeforeCursor(completion: string): string;
+    /**
+     * Checks if the buffer is empty.
+     *
+     * @returns True if buffer has no content
+     */
+    isEmpty(): boolean;
+    /**
+     * Checks if the buffer contains only whitespace.
+     *
+     * @returns True if buffer is empty or contains only whitespace
+     */
+    isBlank(): boolean;
+}
+
+/**
+ * Check if clipboard API is available
+ */
+export declare function isClipboardAvailable(): boolean;
+
+/**
+ * Check if SQL appears complete (ends with semicolon outside of string/comment)
+ */
+export declare function isSQLComplete(sql: string): boolean;
+
+/**
+ * Validates if a string is a valid URL.
+ *
+ * @param str - The string to validate
+ * @returns True if the string is a valid URL
+ */
+export declare function isValidURL(str: string): boolean;
+
+/**
+ * Light theme
+ */
+export declare const lightTheme: Theme;
+
+/**
+ * Processes text and makes all URLs clickable using OSC 8 escape sequences.
+ *
+ * @param text - The text to process
+ * @returns The text with URLs wrapped in hyperlink escape sequences
+ */
+export declare function linkifyText(text: string): string;
+
+/**
+ * A class for processing text output and adding clickable hyperlinks.
+ *
+ * The LinkProvider wraps the utility functions in a stateful class that
+ * can be enabled/disabled and configured with a maximum URL display length.
+ *
+ * @example
+ * ```typescript
+ * const provider = new LinkProvider();
+ *
+ * // Process text with links
+ * const output = provider.process('See https://example.com');
+ *
+ * // Disable link processing
+ * provider.setEnabled(false);
+ * ```
+ */
+export declare class LinkProvider {
+    private enabled;
+    private maxURLLength;
+    /**
+     * Enable or disable URL linking
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Check if URL linking is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Set maximum URL display length
+     */
+    setMaxURLLength(length: number): void;
+    /**
+     * Process text and add hyperlinks to URLs
+     */
+    process(text: string): string;
+    /**
+     * Process text with truncated URL display
+     */
+    processWithTruncation(text: string): string;
+}
+
+/**
+ * Interface for the terminal context needed by pagination
+ */
+export declare interface PaginationContext {
+    /** Write text to terminal (no newline) */
+    write: (text: string) => void;
+    /** Write text to terminal with newline */
+    writeln: (text: string) => void;
+    /** Get the database instance */
+    getDatabase: () => Database;
+    /** Display query result */
+    displayResult: (result: QueryResult, showTiming: boolean) => void;
+    /** Get input buffer content */
+    getInputContent: () => string;
+    /** Clear input buffer */
+    clearInput: () => void;
+    /** Insert character into input buffer */
+    insertChar: (char: string) => string;
+    /** Backspace in input buffer */
+    backspace: () => string;
+}
+
+/**
+ * PaginationHandler manages the pagination of large query results
+ */
+export declare class PaginationHandler {
+    private state;
+    private ctx;
+    constructor(ctx: PaginationContext);
+    /**
+     * Initialize pagination for a query
+     */
+    start(query: string, totalRows: number, pageSize: number): void;
+    /**
+     * Exit pagination mode
+     */
+    exit(): void;
+    /**
+     * Check if pagination is currently active
+     */
+    isActive(): boolean;
+    /**
+     * Get current state
+     */
+    getState(): Readonly<PaginationState>;
+    /**
+     * Get the total number of pages
+     */
+    getTotalPages(): number;
+    /**
+     * Get current page (1-indexed for display)
+     */
+    getCurrentPageDisplay(): number;
+    /**
+     * Execute the paginated query for the current page
+     */
+    executeCurrentPage(): Promise<void>;
+    /**
+     * Show navigation hint
+     */
+    showNavigationHint(): void;
+    /**
+     * Handle user input during pagination
+     * @returns true if the input was handled, false otherwise
+     */
+    handleInput(data: string): Promise<boolean>;
+    /**
+     * Check if a query should use pagination
+     * @param sql The SQL query
+     * @param rowCount The total row count
+     * @param pageSize The configured page size (0 = disabled)
+     * @returns Whether pagination should be enabled
+     */
+    static shouldPaginate(sql: string, rowCount: number, pageSize: number): boolean;
+    /**
+     * Strip trailing semicolon from SQL for pagination
+     */
+    static prepareQuery(sql: string): string;
+}
+
+/**
+ * State for pagination
+ */
+export declare interface PaginationState {
+    /** The original query being paginated */
+    query: string | null;
+    /** Current page index (0-based) */
+    currentPage: number;
+    /** Total number of rows in result */
+    totalRows: number;
+    /** Number of rows per page */
+    pageSize: number;
+    /** Whether pagination is active */
+    isActive: boolean;
+}
+
+/**
+ * The result of executing a SQL query.
+ *
+ * @example
+ * ```typescript
+ * const result: QueryResult = {
+ *   columns: ['id', 'name', 'email'],
+ *   rows: [
+ *     [1, 'Alice', 'alice@example.com'],
+ *     [2, 'Bob', 'bob@example.com'],
+ *   ],
+ *   rowCount: 2,
+ *   duration: 5.23,
+ * };
+ * ```
+ */
+declare interface QueryResult {
+    /** Column names from the query result */
+    columns: string[];
+    /** Row data as a 2D array */
+    rows: unknown[][];
+    /** Total number of rows returned */
+    rowCount: number;
+    /** Query execution time in milliseconds */
+    duration: number;
+}
+
+/**
+ * Read text from clipboard
+ */
+export declare function readFromClipboard(): Promise<string | null>;
+
+/**
+ * VT100/ANSI escape code utilities
+ */
+export declare const RESET = "\u001B[0m";
+
+/**
+ * Save theme preference
+ */
+export declare function saveTheme(theme: 'dark' | 'light'): void;
+
+declare interface TableOptions {
+    maxWidth?: number;
+    maxColumnWidth?: number;
+    nullValue?: string;
+}
+
+/**
+ * An adapter that wraps the Ghostty terminal emulator for web use.
+ *
+ * This class provides a simplified interface for:
+ * - Initializing the Ghostty WASM terminal
+ * - Writing text and handling input
+ * - Managing themes and dimensions
+ * - Auto-fitting to container size
+ *
+ * The adapter handles all the low-level details of working with the Ghostty
+ * terminal emulator, including WASM initialization, addon loading, and
+ * event handling.
+ *
+ * @example Basic usage
+ * ```typescript
+ * const adapter = new TerminalAdapter();
+ * await adapter.init(document.getElementById('container'), {
+ *   fontSize: 16,
+ *   theme: darkTheme,
+ * });
+ *
+ * adapter.write('Hello, World!');
+ * adapter.onData((input) => {
+ *   console.log('User typed:', input);
+ * });
+ * ```
+ *
+ * @example Theme switching
+ * ```typescript
+ * const adapter = new TerminalAdapter();
+ * await adapter.init(container);
+ *
+ * adapter.setTheme(darkTheme);
+ * // Later...
+ * adapter.setTheme(lightTheme);
+ * ```
+ */
+export declare class TerminalAdapter {
+    private terminal;
+    private fitAddon;
+    private ghostty;
+    private dataHandler?;
+    private resizeHandler?;
+    private currentTheme;
+    private initialized;
+    private container;
+    private options;
+    private resizeObserver;
+    private mobileInput;
+    /**
+     * Initializes the Ghostty terminal and mounts it to the container.
+     *
+     * This method:
+     * 1. Initializes the Ghostty WASM module
+     * 2. Creates the terminal with the specified options
+     * 3. Loads the FitAddon for auto-resizing
+     * 4. Mounts the terminal to the container
+     * 5. Sets up resize observers
+     *
+     * @param container - The HTML element to mount the terminal into
+     * @param options - Configuration options for the terminal
+     * @returns A promise that resolves when initialization is complete
+     *
+     * @example
+     * ```typescript
+     * const adapter = new TerminalAdapter();
+     * await adapter.init(document.getElementById('terminal'), {
+     *   fontSize: 14,
+     *   fontFamily: 'JetBrains Mono',
+     *   theme: darkTheme,
+     * });
+     * ```
+     */
+    init(container: HTMLElement, options?: TerminalOptions): Promise<void>;
+    /* Excluded from this release type: createTerminal */
+    /* Excluded from this release type: setupMobileInput */
+    /* Excluded from this release type: setupMobileKeyboard */
+    /* Excluded from this release type: setupTouchScrolling */
+    /* Excluded from this release type: themeToGhostty */
+    /* Excluded from this release type: handleResize */
+    /**
+     * Fits the terminal to its container dimensions.
+     *
+     * This method should be called when the container size changes.
+     * It's automatically called on window resize, but you may need
+     * to call it manually after dynamic layout changes.
+     *
+     * @example
+     * ```typescript
+     * // After changing container size
+     * container.style.height = '500px';
+     * adapter.fit();
+     * ```
+     */
+    fit(): void;
+    /**
+     * Writes text to the terminal without a trailing newline.
+     *
+     * @param text - The text to write
+     *
+     * @example
+     * ```typescript
+     * adapter.write('Hello');
+     * adapter.write(' World');
+     * ```
+     */
+    write(text: string): void;
+    /**
+     * Writes text to the terminal followed by a newline.
+     *
+     * @param text - The text to write
+     *
+     * @example
+     * ```typescript
+     * adapter.writeln('First line');
+     * adapter.writeln('Second line');
+     * ```
+     */
+    writeln(text: string): void;
+    /**
+     * Clears the terminal screen and moves cursor to top-left.
+     *
+     * @example
+     * ```typescript
+     * adapter.clear();
+     * adapter.writeln('Fresh start!');
+     * ```
+     */
+    clear(): void;
+    /**
+     * Gives keyboard focus to the terminal.
+     * On mobile devices, focuses the hidden input to trigger the virtual keyboard.
+     *
+     * @example
+     * ```typescript
+     * adapter.focus();
+     * ```
+     */
+    focus(): void;
+    /* Excluded from this release type: isTouchDevice */
+    /**
+     * Registers a callback to receive user input data.
+     *
+     * The callback is invoked whenever the user types in the terminal.
+     * This includes regular characters, control sequences, and escape codes.
+     *
+     * @param handler - The callback function to handle input data
+     *
+     * @example
+     * ```typescript
+     * adapter.onData((data) => {
+     *   if (data === '\r') {
+     *     console.log('User pressed Enter');
+     *   } else {
+     *     console.log('User typed:', data);
+     *   }
+     * });
+     * ```
+     */
+    onData(handler: (data: string) => void): void;
+    /**
+     * Registers a callback to receive terminal resize events.
+     *
+     * @param handler - The callback function receiving new dimensions
+     *
+     * @example
+     * ```typescript
+     * adapter.onResize((cols, rows) => {
+     *   console.log(`Terminal resized to ${cols}x${rows}`);
+     * });
+     * ```
+     */
+    onResize(handler: (cols: number, rows: number) => void): void;
+    /**
+     * The number of columns (characters per line) in the terminal.
+     *
+     * @returns The current column count, or 80 if not initialized
+     */
+    get cols(): number;
+    /**
+     * The number of rows (lines) in the terminal.
+     *
+     * @returns The current row count, or 24 if not initialized
+     */
+    get rows(): number;
+    /**
+     * Sets the terminal color theme.
+     *
+     * Since Ghostty-web doesn't fully support runtime theme changes,
+     * this method recreates the terminal with the new theme.
+     *
+     * @param theme - The theme to apply
+     *
+     * @example
+     * ```typescript
+     * adapter.setTheme({
+     *   name: 'dark',
+     *   colors: {
+     *     background: '#1e1e1e',
+     *     foreground: '#d4d4d4',
+     *     // ... other colors
+     *   },
+     * });
+     * ```
+     */
+    setTheme(theme: Theme): void;
+    /**
+     * Gets the current terminal theme.
+     *
+     * @returns The current theme, or null if no theme is set
+     */
+    getTheme(): Theme | null;
+    /**
+     * Disposes of the terminal and cleans up resources.
+     *
+     * After calling this method, the adapter cannot be used again.
+     * Create a new instance if you need another terminal.
+     *
+     * @example
+     * ```typescript
+     * adapter.dispose();
+     * // adapter is no longer usable
+     * ```
+     */
+    dispose(): void;
+}
+
+/**
+ * Configuration options for creating a DuckDB terminal.
+ *
+ * @example Minimal configuration
+ * ```typescript
+ * const config: TerminalConfig = {
+ *   container: '#terminal',
+ * };
+ * ```
+ *
+ * @example Full configuration
+ * ```typescript
+ * const config: TerminalConfig = {
+ *   container: document.getElementById('terminal'),
+ *   fontFamily: 'JetBrains Mono',
+ *   fontSize: 16,
+ *   theme: 'dark',
+ *   storage: 'opfs',
+ *   databasePath: '/mydata.duckdb',
+ *   welcomeMessage: true,
+ *   prompt: 'SQL> ',
+ *   continuationPrompt: '... ',
+ *   linkDetection: true,
+ * };
+ * ```
+ */
+export declare interface TerminalConfig {
+    /**
+     * The container element or CSS selector where the terminal will be mounted.
+     * Can be an HTMLElement or a CSS selector string (e.g., '#terminal', '.container').
+     */
+    container: HTMLElement | string;
+    /**
+     * Font family for the terminal text.
+     * @defaultValue '"Fira Code", "Cascadia Code", "JetBrains Mono", Consolas, monospace'
+     */
+    fontFamily?: string;
+    /**
+     * Font size in pixels.
+     * @defaultValue 14
+     */
+    fontSize?: number;
+    /**
+     * The color theme for the terminal.
+     * Can be 'dark', 'light', or a custom Theme object.
+     * @defaultValue 'dark'
+     */
+    theme?: 'dark' | 'light' | Theme;
+    /**
+     * The storage backend for the database.
+     * - 'memory': In-memory storage (data lost on page refresh)
+     * - 'opfs': Origin Private File System (persistent storage)
+     * @defaultValue 'memory'
+     */
+    storage?: 'memory' | 'opfs';
+    /**
+     * The database file path when using OPFS storage.
+     * Only used when storage is 'opfs'.
+     */
+    databasePath?: string;
+    /**
+     * Whether to display the welcome message on startup.
+     * @defaultValue true
+     */
+    welcomeMessage?: boolean;
+    /**
+     * The primary prompt string displayed before each command.
+     * @defaultValue '🦆 '
+     */
+    prompt?: string;
+    /**
+     * The continuation prompt displayed for multi-line SQL statements.
+     * @defaultValue '  > '
+     */
+    continuationPrompt?: string;
+    /**
+     * Whether to automatically detect and make URLs clickable in output.
+     * @defaultValue true
+     */
+    linkDetection?: boolean;
+    /**
+     * Scrollback buffer size in bytes. Larger values allow more history but use more memory.
+     * @defaultValue 10485760 (10MB)
+     */
+    scrollback?: number;
+}
+
+/**
+ * Type for event listener callbacks.
+ *
+ * @typeParam K - The event name from {@link TerminalEvents}
+ *
+ * @example
+ * ```typescript
+ * const listener: TerminalEventListener<'queryEnd'> = (event) => {
+ *   console.log(event.duration);
+ * };
+ * ```
+ */
+export declare type TerminalEventListener<K extends keyof TerminalEvents> = (event: TerminalEvents[K]) => void;
+
+/**
+ * Event payload types for all terminal events.
+ *
+ * Use with {@link DuckDBTerminal.on} to subscribe to events.
+ *
+ * @example
+ * ```typescript
+ * terminal.on('queryEnd', (event: TerminalEvents['queryEnd']) => {
+ *   console.log(`Query took ${event.duration}ms`);
+ * });
+ * ```
+ */
+export declare interface TerminalEvents {
+    /**
+     * Emitted when the terminal is fully initialized and ready for input.
+     * The payload is an empty object.
+     */
+    ready: Record<string, never>;
+    /**
+     * Emitted when a SQL query starts executing.
+     */
+    queryStart: {
+        /** The SQL statement being executed */
+        sql: string;
+    };
+    /**
+     * Emitted when a SQL query completes (success or failure).
+     */
+    queryEnd: {
+        /** The SQL statement that was executed */
+        sql: string;
+        /** The query result, or null if the query failed */
+        result: QueryResult | null;
+        /** Error message if the query failed */
+        error?: string;
+        /** Execution time in milliseconds */
+        duration: number;
+    };
+    /**
+     * Emitted when a dot command is executed.
+     */
+    commandExecute: {
+        /** The command name (e.g., '.help') */
+        command: string;
+        /** Command arguments */
+        args: string[];
+    };
+    /**
+     * Emitted when a file is loaded via drag-and-drop or file picker.
+     */
+    fileLoaded: {
+        /** The filename */
+        filename: string;
+        /** File size in bytes */
+        size: number;
+        /** File extension/type */
+        type: string;
+    };
+    /**
+     * Emitted when the terminal theme changes.
+     */
+    themeChange: {
+        /** The new theme */
+        theme: Theme;
+        /** The previous theme (null if this is the initial theme) */
+        previous: Theme | null;
+    };
+    /**
+     * Emitted when an error occurs.
+     */
+    error: {
+        /** The error message */
+        message: string;
+        /** Where the error originated (e.g., 'query', 'command') */
+        source: string;
+    };
+    /**
+     * Emitted when the terminal state changes.
+     */
+    stateChange: {
+        /** The new state */
+        state: TerminalState;
+        /** The previous state */
+        previous: TerminalState;
+    };
+}
+
+/**
+ * Interface for interacting with the terminal from commands.
+ *
+ * This interface is passed to command handlers and provides methods
+ * for writing output and executing SQL.
+ */
+export declare interface TerminalInterface {
+    /**
+     * Writes text to the terminal without a newline.
+     * @param text - The text to write
+     */
+    write(text: string): void;
+    /**
+     * Writes text to the terminal followed by a newline.
+     * @param text - The text to write
+     */
+    writeln(text: string): void;
+    /**
+     * Clears the terminal screen.
+     */
+    clear(): void;
+    /**
+     * Executes a SQL query and returns the result.
+     * @param sql - The SQL statement to execute
+     * @returns The query result, or null if an error occurred
+     */
+    executeSQL(sql: string): Promise<QueryResult | null>;
+    /**
+     * Sets the terminal theme.
+     * @param theme - The theme to apply ('dark' or 'light')
+     */
+    setTheme(theme: 'dark' | 'light'): void;
+    /**
+     * Gets the current theme mode.
+     * @returns The current theme mode
+     */
+    getTheme(): 'dark' | 'light';
+}
+
+/**
+ * Configuration options for the terminal adapter.
+ */
+declare interface TerminalOptions {
+    /**
+     * Font family for the terminal text.
+     * Defaults to a stack of monospace fonts.
+     */
+    fontFamily?: string;
+    /**
+     * Font size in pixels.
+     * @defaultValue 14
+     */
+    fontSize?: number;
+    /**
+     * The color theme to apply to the terminal.
+     */
+    theme?: Theme;
+    /**
+     * Scrollback buffer size in bytes.
+     * @defaultValue 10485760 (10MB)
+     */
+    scrollback?: number;
+}
+
+/**
+ * The current state of the terminal.
+ *
+ * - `idle`: Waiting for user input
+ * - `collecting`: Collecting multi-line SQL input
+ * - `executing`: Running a query
+ * - `paginating`: Displaying paginated results
+ */
+declare type TerminalState = 'idle' | 'collecting' | 'executing' | 'paginating';
+
+/**
+ * A complete terminal theme definition.
+ *
+ * @example
+ * ```typescript
+ * const myTheme: Theme = {
+ *   name: 'my-dark-theme',
+ *   colors: {
+ *     background: '#1a1b26',
+ *     foreground: '#a9b1d6',
+ *     // ... other colors
+ *   },
+ * };
+ * ```
+ */
+export declare interface Theme {
+    /** Unique name for the theme */
+    name: string;
+    /** Color definitions for the theme */
+    colors: ThemeColors;
+}
+
+/**
+ * Color definitions for a terminal theme.
+ *
+ * Includes the standard 16 ANSI colors plus special terminal colors
+ * (background, foreground, cursor, selection).
+ *
+ * @example
+ * ```typescript
+ * const colors: ThemeColors = {
+ *   background: '#1e1e1e',
+ *   foreground: '#d4d4d4',
+ *   cursor: '#aeafad',
+ *   selection: '#264f78',
+ *   black: '#000000',
+ *   red: '#cd3131',
+ *   green: '#0dbc79',
+ *   yellow: '#e5e510',
+ *   blue: '#2472c8',
+ *   magenta: '#bc3fbc',
+ *   cyan: '#11a8cd',
+ *   white: '#e5e5e5',
+ *   brightBlack: '#666666',
+ *   brightRed: '#f14c4c',
+ *   brightGreen: '#23d18b',
+ *   brightYellow: '#f5f543',
+ *   brightBlue: '#3b8eea',
+ *   brightMagenta: '#d670d6',
+ *   brightCyan: '#29b8db',
+ *   brightWhite: '#e5e5e5',
+ * };
+ * ```
+ */
+export declare interface ThemeColors {
+    /** Terminal background color */
+    background: string;
+    /** Default text (foreground) color */
+    foreground: string;
+    /** Cursor color */
+    cursor: string;
+    /** Text selection highlight color */
+    selection: string;
+    /** ANSI black (color 0) */
+    black: string;
+    /** ANSI red (color 1) */
+    red: string;
+    /** ANSI green (color 2) */
+    green: string;
+    /** ANSI yellow (color 3) */
+    yellow: string;
+    /** ANSI blue (color 4) */
+    blue: string;
+    /** ANSI magenta (color 5) */
+    magenta: string;
+    /** ANSI cyan (color 6) */
+    cyan: string;
+    /** ANSI white (color 7) */
+    white: string;
+    /** ANSI bright black (color 8) */
+    brightBlack: string;
+    /** ANSI bright red (color 9) */
+    brightRed: string;
+    /** ANSI bright green (color 10) */
+    brightGreen: string;
+    /** ANSI bright yellow (color 11) */
+    brightYellow: string;
+    /** ANSI bright blue (color 12) */
+    brightBlue: string;
+    /** ANSI bright magenta (color 13) */
+    brightMagenta: string;
+    /** ANSI bright cyan (color 14) */
+    brightCyan: string;
+    /** ANSI bright white (color 15) */
+    brightWhite: string;
+}
+
+declare interface Token {
+    type: TokenType;
+    value: string;
+    start: number;
+    end: number;
+}
+
+/**
+ * Tokenize SQL string
+ */
+export declare function tokenize(sql: string): Token[];
+
+/**
+ * SQL Syntax Highlighting
+ */
+declare type TokenType = 'keyword' | 'type' | 'function' | 'string' | 'number' | 'comment' | 'operator' | 'identifier' | 'whitespace';
+
+export { }