@floegence/floeterm-terminal-web 0.14.1 → 0.15.0

package/dist/core/TerminalCore.js

@@ -1,3566 +0,0 @@
-import { filterXtermAutoResponses } from '../utils/xtermAutoResponseFilter.js';
-import { createConsoleLogger, noopLogger } from '../utils/logger.js';
-import { cursorToFabricCursor, renderReasonFromForce, terminalLiveFabric, themeToFabricTheme, } from '../fabric/TerminalLiveFabric.js';
-import { terminalFabricCoordinator } from '../fabric/TerminalFabricCoordinator.js';
-import { TerminalState, } from '../types.js';
-import { terminalInitializationScheduler, } from '../internal/TerminalInitializationScheduler.js';
-import { acquireGhosttyRuntime, getGhosttyFitAddonConstructor, getGhosttyLinkConstructors, getGhosttyTerminalConstructor, inspectGhosttyRuntimeMemory, loadGhosttyModules, waitWithAbort, } from '../internal/TerminalResourceLoader.js';
-import { capAutoFitTerminalColumns, mapGhosttyScrollbackRowsForPinnedVersion, validateTerminalColumns, validateTerminalScrollbackRows, } from '../internal/GhosttyScrollbackCompat.js';
-import { installPinnedGhosttyAlternateScreenProjection, installPinnedGhosttyOutputViewportPolicy, isPinnedGhosttyOutputWriteActive, suppressPinnedGhosttyScrollbarBeforeOpen, suppressPinnedGhosttyScrollbarRenderer, } from '../internal/GhosttyScrollbarCompat.js';
-import { createUnicodeSafeUrlProviderTerminal, } from '../internal/UnicodeSafeUrlProvider.js';
-import { resolveTerminalInputElement, TerminalInputBridge } from './TerminalInputBridge.js';
-import { terminalRenderScheduler } from './TerminalRenderScheduler.js';
-import { scheduleUiTurn } from '../internal/scheduleUiTurn.js';
-import { parseThemeColor } from '../utils/themeColor.js';
-import { normalizeTerminalScrollbarOptions, TerminalScrollbarOverlay, } from './TerminalScrollbarOverlay.js';
-const TERMINAL_SNAPSHOT_VERSION = 1;
-const DEFAULT_TERMINAL_SNAPSHOT_MAX_BYTES = 2 * 1024 * 1024;
-const ESTIMATED_RENDERER_BYTES = 4 * 1024 * 1024;
-const SNAPSHOT_RESET_PREFIX = '\x1bc\x1b[2J\x1b[H';
-const encodedByteLength = (value) => new TextEncoder().encode(value).byteLength;
-const sha256Hex = async (bytes) => {
-    if (typeof crypto === 'undefined' || !crypto.subtle) {
-        throw new Error('Web Crypto SHA-256 is unavailable for checkpoint validation');
-    }
-    const digest = await crypto.subtle.digest('SHA-256', bytes.slice());
-    return Array.from(new Uint8Array(digest), byte => byte.toString(16).padStart(2, '0')).join('');
-};
-const TERMINAL_SEARCH_MAX_RESULTS = 5000;
-const PRESENTATION_SCALE_EPSILON = 0.0001;
-const GHOSTTY_DEFAULT_SCROLLBAR_RESERVE_PX = 15;
-const MIN_TERMINAL_COLS = 2;
-const MIN_TERMINAL_ROWS = 1;
-// Search highlighting: all matches use yellow background; active match uses yellow + red text.
-const TERMINAL_SEARCH_MATCH_BACKGROUND = 'rgba(255, 234, 0, 0.38)';
-const TERMINAL_SEARCH_ACTIVE_BACKGROUND = 'rgba(255, 234, 0, 0.72)';
-const TERMINAL_SEARCH_ACTIVE_FOREGROUND = '#dc2626';
-const TERMINAL_SELECTION_BACKGROUND = '#f5e6b3';
-const TERMINAL_SELECTION_FOREGROUND = '#1f2328';
-const TERMINAL_THEME_PALETTE_KEYS = [
-    'black',
-    'red',
-    'green',
-    'yellow',
-    'blue',
-    'magenta',
-    'cyan',
-    'white',
-    'brightBlack',
-    'brightRed',
-    'brightGreen',
-    'brightYellow',
-    'brightBlue',
-    'brightMagenta',
-    'brightCyan',
-    'brightWhite',
-];
-function parsePositiveCSSPixelValue(value) {
-    if (!value) {
-        return null;
-    }
-    const parsed = Number.parseFloat(value);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
-}
-function resolveCanvasLocalDisplaySize(canvas, coordinateRoot) {
-    const canvasRect = canvas.getBoundingClientRect();
-    const rootRect = coordinateRoot.getBoundingClientRect();
-    const rootWidth = coordinateRoot.clientWidth;
-    const rootHeight = coordinateRoot.clientHeight;
-    const ratioWidth = rootRect.width > 0 && rootWidth > 0 && canvasRect.width > 0
-        ? rootWidth * (canvasRect.width / rootRect.width)
-        : null;
-    const ratioHeight = rootRect.height > 0 && rootHeight > 0 && canvasRect.height > 0
-        ? rootHeight * (canvasRect.height / rootRect.height)
-        : null;
-    const computed = (() => {
-        try {
-            return getComputedStyle(canvas);
-        }
-        catch {
-            return null;
-        }
-    })();
-    const cssWidth = ratioWidth
-        ?? parsePositiveCSSPixelValue(canvas.style.width)
-        ?? parsePositiveCSSPixelValue(computed?.width)
-        ?? (canvas.offsetWidth > 0 ? canvas.offsetWidth : null)
-        ?? (canvas.clientWidth > 0 ? canvas.clientWidth : null)
-        ?? canvas.width;
-    const cssHeight = ratioHeight
-        ?? parsePositiveCSSPixelValue(canvas.style.height)
-        ?? parsePositiveCSSPixelValue(computed?.height)
-        ?? (canvas.offsetHeight > 0 ? canvas.offsetHeight : null)
-        ?? (canvas.clientHeight > 0 ? canvas.clientHeight : null)
-        ?? canvas.height;
-    const dpr = cssWidth > 0 ? canvas.width / cssWidth : window.devicePixelRatio ?? 1;
-    return {
-        cssWidth,
-        cssHeight,
-        dpr: Number.isFinite(dpr) && dpr > 0 ? dpr : 1,
-    };
-}
-function syncCanvasOverlaySize(overlay, termCanvas, coordinateRoot) {
-    const { cssWidth, cssHeight, dpr } = resolveCanvasLocalDisplaySize(termCanvas, coordinateRoot);
-    if (overlay.canvas.width === termCanvas.width
-        && overlay.canvas.height === termCanvas.height
-        && overlay.cssWidth === cssWidth
-        && overlay.cssHeight === cssHeight
-        && overlay.dpr === dpr) {
-        return;
-    }
-    overlay.dpr = dpr;
-    overlay.cssWidth = cssWidth;
-    overlay.cssHeight = cssHeight;
-    overlay.canvas.style.width = `${cssWidth}px`;
-    overlay.canvas.style.height = `${cssHeight}px`;
-    overlay.canvas.width = termCanvas.width;
-    overlay.canvas.height = termCanvas.height;
-    overlay.ctx.setTransform(1, 0, 0, 1, 0, 0);
-    overlay.ctx.scale(dpr, dpr);
-}
-const getPerfProbe = () => {
-    if (typeof window === 'undefined') {
-        return undefined;
-    }
-    return window.__floetermPerfProbe;
-};
-export { preloadTerminalResources } from '../internal/TerminalResourceLoader.js';
-const mapThemeToGhostty = (theme) => {
-    if (!theme) {
-        return {};
-    }
-    const mapped = {};
-    for (const [key, value] of Object.entries(theme)) {
-        if (typeof value === 'string') {
-            mapped[key] = value;
-        }
-    }
-    if (mapped.selection && !mapped.selectionBackground) {
-        mapped.selectionBackground = mapped.selection;
-        delete mapped.selection;
-    }
-    return mapped;
-};
-function colorKey(color) {
-    return `${color.r},${color.g},${color.b}`;
-}
-function cellColorKey(cell, prefix) {
-    const r = Number(cell[`${prefix}_r`]);
-    const g = Number(cell[`${prefix}_g`]);
-    const b = Number(cell[`${prefix}_b`]);
-    if (![r, g, b].every(channel => Number.isInteger(channel) && channel >= 0 && channel <= 255)) {
-        return null;
-    }
-    return `${r},${g},${b}`;
-}
-function colorsEqual(left, right) {
-    return left.r === right.r && left.g === right.g && left.b === right.b;
-}
-function setColorTranslation(map, source, target, key) {
-    const sourceColor = parseThemeColor(source[key]);
-    const targetColor = parseThemeColor(target[key]);
-    if (!sourceColor || !targetColor || colorsEqual(sourceColor, targetColor)) {
-        return;
-    }
-    map.set(colorKey(sourceColor), targetColor);
-}
-function buildThemeColorTranslator(source, target) {
-    const fg = new Map();
-    const bg = new Map();
-    for (const key of TERMINAL_THEME_PALETTE_KEYS) {
-        setColorTranslation(fg, source, target, key);
-        setColorTranslation(bg, source, target, key);
-    }
-    setColorTranslation(fg, source, target, 'foreground');
-    setColorTranslation(bg, source, target, 'background');
-    if (fg.size === 0 && bg.size === 0) {
-        return null;
-    }
-    return { fg, bg };
-}
-function buildCellSignature(renderer, cell, row, col) {
-    const grapheme = (cell.grapheme_len ?? 0) > 0
-        ? String(renderer.currentBuffer?.getGraphemeString?.(row, col) ?? '')
-        : '';
-    return [
-        cell.codepoint ?? 0,
-        cell.fg_r ?? 0,
-        cell.fg_g ?? 0,
-        cell.fg_b ?? 0,
-        cell.bg_r ?? 0,
-        cell.bg_g ?? 0,
-        cell.bg_b ?? 0,
-        cell.flags ?? 0,
-        cell.width ?? 0,
-        cell.hyperlink_id ?? 0,
-        cell.grapheme_len ?? 0,
-        grapheme,
-    ].join(',');
-}
-function buildRowSignature(renderer, cells, row, cols) {
-    const parts = [`cols:${cols}`, `len:${cells.length}`];
-    for (let col = 0; col < cells.length; col += 1) {
-        parts.push(buildCellSignature(renderer, cells[col] ?? {}, row, col));
-    }
-    return parts.join(';');
-}
-function canSkipCachedRowRender(renderer, row) {
-    if (renderer.__floetermRowRenderCacheForceAll) {
-        return false;
-    }
-    if (hasTransientRendererState(renderer)) {
-        renderer.__floetermRowRenderCache?.clear();
-        return false;
-    }
-    const cursorY = renderer.currentBuffer?.getCursor?.()?.y;
-    if (typeof cursorY === 'number' && cursorY === row) {
-        return false;
-    }
-    const previousCursorY = renderer.lastCursorPosition?.y;
-    if (typeof previousCursorY === 'number' && previousCursorY === row) {
-        return false;
-    }
-    return true;
-}
-function canSkipNativeCanvasRowRender(renderer, row, fabricActive) {
-    void renderer;
-    void row;
-    return fabricActive;
-}
-function samePresentationScale(left, right) {
-    return Math.abs(left - right) <= PRESENTATION_SCALE_EPSILON;
-}
-function normalizeTerminalDimensions(value, columnsLabel = 'fixedDimensions.cols') {
-    const raw = (typeof value === 'object' && value) ? value : null;
-    if (!raw) {
-        return null;
-    }
-    const cols = validateTerminalColumns(raw.cols, columnsLabel);
-    const rows = Math.floor(Number(raw.rows));
-    if (!Number.isFinite(rows) || rows <= 0) {
-        return null;
-    }
-    return { cols, rows };
-}
-function sameTerminalDimensions(left, right) {
-    return Boolean(left && right && left.cols === right.cols && left.rows === right.rows);
-}
-function normalizeNonNegativePixels(value, fallback) {
-    const parsed = Number(value);
-    if (!Number.isFinite(parsed) || parsed < 0) {
-        return fallback;
-    }
-    return parsed;
-}
-function hasUsableClientSize(element) {
-    return Boolean(element && element.clientWidth > 0 && element.clientHeight > 0);
-}
-function formatCssPixelValue(value) {
-    const normalized = Number.isFinite(value) ? Math.max(1, value) : 1;
-    return `${Math.round(normalized * 1000) / 1000}px`;
-}
-function hasTransientRendererState(renderer) {
-    return Boolean(renderer.currentSelectionCoords
-        || (renderer.hoveredHyperlinkId ?? 0) > 0
-        || renderer.hoveredLinkRange);
-}
-function forceTransientRowsOnExit(renderer) {
-    const active = hasTransientRendererState(renderer);
-    const previous = Boolean(renderer.__floetermRowRenderCacheHadTransientState);
-    renderer.__floetermRowRenderCacheHadTransientState = active;
-    return previous && !active;
-}
-function normalizeNumberField(record, key) {
-    if (!record || typeof record !== 'object') {
-        return null;
-    }
-    const value = Number(record[key]);
-    return Number.isFinite(value) ? value : null;
-}
-function normalizeSelectionRange(value) {
-    const startCol = normalizeNumberField(value, 'startCol');
-    const startRow = normalizeNumberField(value, 'startRow');
-    const endCol = normalizeNumberField(value, 'endCol');
-    const endRow = normalizeNumberField(value, 'endRow');
-    if (startCol === null || startRow === null || endCol === null || endRow === null) {
-        return null;
-    }
-    return {
-        startCol: Math.max(0, Math.floor(startCol)),
-        startRow: Math.max(0, Math.floor(startRow)),
-        endCol: Math.max(0, Math.floor(endCol)),
-        endRow: Math.max(0, Math.floor(endRow)),
-    };
-}
-function normalizeHoverRange(value) {
-    const startX = normalizeNumberField(value, 'startX');
-    const startY = normalizeNumberField(value, 'startY');
-    const endX = normalizeNumberField(value, 'endX');
-    const endY = normalizeNumberField(value, 'endY');
-    if (startX === null || startY === null || endX === null || endY === null) {
-        return null;
-    }
-    return {
-        startX: Math.max(0, Math.floor(startX)),
-        startY: Math.max(0, Math.floor(startY)),
-        endX: Math.max(0, Math.floor(endX)),
-        endY: Math.max(0, Math.floor(endY)),
-    };
-}
-function normalizeFabricIdentifier(value) {
-    return value.trim().replace(/[^a-zA-Z0-9_-]+/g, '-').replace(/^-+|-+$/g, '') || 'terminal';
-}
-// TerminalCore provides a focused wrapper around @floegence/ghostty-web (xterm.js API-compatible) and its fit addon.
-export class TerminalCore {
-    constructor(container, config = {}, eventHandlers = {}, logger = createConsoleLogger()) {
-        this.container = container;
-        this.config = config;
-        this.terminal = null;
-        this.ownedRuntime = null;
-        this.ownedRuntimeMemory = null;
-        this.fitAddon = null;
-        this.needsFullRenderOnNextWrite = false;
-        this.demandRenderForceAll = false;
-        this.fabricView = null;
-        this.fabricAttachSeq = 0;
-        this.fabricAttachPromise = null;
-        this.fabricAttachWaiters = [];
-        this.committedFabricFrameGeneration = 0;
-        this.submittedFabricFrameGeneration = 0;
-        this.lastCommittedFabricFrame = null;
-        this.pendingPresentationRequest = null;
-        this.presentationRequests = new Set();
-        this.committedFrameRequests = new Set();
-        this.cancelFabricAttachSchedule = null;
-        this.cancelInputRefocusSchedule = null;
-        this.inputElement = null;
-        this.viewportHost = null;
-        this.renderHost = null;
-        this.scrollbarOverlay = null;
-        this.resizeObserver = null;
-        this.resizeDebounceTimer = null;
-        this.resizeRaf = null;
-        this.focusResizeRaf = null;
-        this.presentationScaleRaf = null;
-        this.state = TerminalState.IDLE;
-        this.isDisposed = false;
-        this.initializationOperation = null;
-        this.isReplayingHistory = false;
-        this.historyWriteDepth = 0;
-        this.replayingHistoryTimer = null;
-        this.logicalFontSize = 12;
-        this.presentationScale = 1;
-        this.fixedDimensions = null;
-        this.terminalThemeSource = {};
-        this.themeColorTranslator = null;
-        this.fontMetricSeq = 0;
-        this.fontMetricRefreshPromise = null;
-        this.pendingPresentationScale = null;
-        this.suppressResizeNotifications = false;
-        this.clearResizeSuppressionRaf = null;
-        this.hasFocus = false;
-        this.resizeNotifySeq = 0;
-        this.lastNotifiedSize = null;
-        this.unbindResponsiveListeners = null;
-        this.searchQuery = '';
-        this.searchOptionsKey = '';
-        this.searchMatches = [];
-        this.searchMatchIndex = -1;
-        this.searchRowIndex = new Map();
-        this.searchResultsCallback = null;
-        this.searchOverlay = null;
-        this.searchOverlayRaf = null;
-        this.searchOverlayUnsubs = [];
-        // Temporary theme override while search is active.
-        this.searchThemeRestore = null;
-        this.inputBridge = null;
-        this.terminalEventDisposables = [];
-        this.registeredLinkProviders = new Set();
-        this.appliedLinkProviders = new Set();
-        this.visualRenderState = {
-            suspendDepth: 0,
-            nextSuspendId: 1,
-            activeReasons: new Map(),
-            pendingDemandRender: false,
-            pendingForceFullRender: false,
-            pendingResizeReason: null,
-            pendingSearchOverlayRender: false,
-        };
-        const explicitCols = config?.cols;
-        if (explicitCols !== undefined) {
-            validateTerminalColumns(explicitCols);
-        }
-        this.scrollbackRows = validateTerminalScrollbackRows(config?.scrollback === undefined ? 1000 : config.scrollback);
-        this.eventHandlers = eventHandlers;
-        this.clipboard = TerminalCore.normalizeClipboardConfig(config?.clipboard);
-        this.fit = TerminalCore.normalizeFitConfig(config?.fit);
-        this.scrollbarOptions = normalizeTerminalScrollbarOptions(config?.scrollbar);
-        this.logger = logger ?? noopLogger;
-        this.responsive = TerminalCore.normalizeResponsiveConfig(config?.responsive);
-        this.logicalFontSize = TerminalCore.normalizeFontSize(config?.fontSize);
-        this.presentationScale = TerminalCore.normalizePresentationScale(config?.presentationScale);
-        this.fixedDimensions = normalizeTerminalDimensions(config?.fixedDimensions);
-        this.config = {
-            ...config,
-            ...(explicitCols === undefined ? {} : { cols: explicitCols }),
-            fixedDimensions: this.fixedDimensions,
-            scrollback: this.scrollbackRows,
-            scrollbar: this.scrollbarOptions,
-        };
-        this.renderTask = {
-            id: TerminalCore.nextRenderTaskId,
-            run: forceAll => {
-                this.demandRenderForceAll = false;
-                this.renderDemandFrame(forceAll);
-            },
-        };
-        this.fabricViewId = `floeterm-view-${this.renderTask.id}`;
-        TerminalCore.nextRenderTaskId += 1;
-    }
-    // initialize creates the @floegence/ghostty-web terminal instance and binds addons.
-    async initialize(options = {}) {
-        if (this.isDisposed) {
-            throw new Error('Cannot initialize a disposed TerminalCore');
-        }
-        if (this.terminal && this.isReady()) {
-            return Promise.resolve();
-        }
-        const priority = options.priority ?? 'interactive';
-        let operation = this.initializationOperation;
-        if (operation) {
-            if (priority === 'interactive')
-                operation.request.promote();
-            return this.waitForInitialization(operation, options.signal);
-        }
-        try {
-            this.setState(TerminalState.INITIALIZING);
-        }
-        catch (error) {
-            this.state = TerminalState.IDLE;
-            throw error;
-        }
-        const request = terminalInitializationScheduler.request(priority);
-        const lifecycleAbortController = new AbortController();
-        operation = {
-            request,
-            lifecycleAbortController,
-            started: false,
-            cancelled: false,
-            waiters: 0,
-            promise: Promise.resolve(),
-        };
-        operation.promise = (async () => {
-            const assertInitializationActive = () => {
-                if (this.isDisposed)
-                    throw new Error('Cannot initialize a disposed TerminalCore');
-                lifecycleAbortController.signal.throwIfAborted();
-            };
-            const permit = await request.permit;
-            if (!permit) {
-                if (this.isDisposed)
-                    throw new Error('Cannot initialize a disposed TerminalCore');
-                if (this.initializationOperation === operation)
-                    this.setState(TerminalState.IDLE);
-                return;
-            }
-            operation.started = true;
-            try {
-                assertInitializationActive();
-                await loadGhosttyModules(this.logger, lifecycleAbortController.signal);
-                assertInitializationActive();
-                const ownedRuntime = await acquireGhosttyRuntime(this.logger);
-                assertInitializationActive();
-                const ownedRuntimeMemory = inspectGhosttyRuntimeMemory(ownedRuntime);
-                assertInitializationActive();
-                this.ownedRuntime = ownedRuntime;
-                this.ownedRuntimeMemory = ownedRuntimeMemory;
-                await this.createTerminalInstance(lifecycleAbortController.signal);
-                assertInitializationActive();
-                await this.loadAddons();
-                assertInitializationActive();
-                await this.openTerminal(lifecycleAbortController.signal);
-                assertInitializationActive();
-                this.setupEventListeners();
-                this.setupResponsiveListeners();
-                this.startSizeWatching();
-                this.setState(TerminalState.READY);
-                this.performResize('post_init');
-                this.forceFullRender();
-                setTimeout(() => {
-                    if (!this.isReady())
-                        return;
-                    this.performResize('post_init');
-                }, 100);
-            }
-            catch (error) {
-                this.cleanupFailedInitialization();
-                if (!this.isDisposed)
-                    this.setState(TerminalState.IDLE);
-                throw error;
-            }
-            finally {
-                permit.release();
-            }
-        })().finally(() => {
-            if (this.initializationOperation === operation)
-                this.initializationOperation = null;
-        });
-        this.initializationOperation = operation;
-        return this.waitForInitialization(operation, options.signal);
-    }
-    waitForInitialization(operation, signal) {
-        operation.waiters += 1;
-        let settled = false;
-        const releaseWaiter = () => {
-            if (settled)
-                return;
-            settled = true;
-            operation.waiters = Math.max(0, operation.waiters - 1);
-            if (operation.waiters !== 0 || operation.cancelled)
-                return;
-            if (operation.started) {
-                if (this.initializationOperation === operation
-                    && !this.isDisposed
-                    && this.state === TerminalState.INITIALIZING) {
-                    operation.cancelled = true;
-                    // Ghostty.load() cannot be cancelled. Abort the Core lifecycle so the
-                    // owned runtime is discarded when that load settles, while the
-                    // initialization permit remains held by the operation's finally path.
-                    operation.lifecycleAbortController.abort();
-                }
-                return;
-            }
-            operation.cancelled = true;
-            operation.request.cancel();
-            if (this.initializationOperation === operation) {
-                this.initializationOperation = null;
-                if (!this.isDisposed)
-                    this.setState(TerminalState.IDLE);
-            }
-        };
-        return waitWithAbort(operation.promise, signal).finally(releaseWaiter);
-    }
-    cleanupFailedInitialization() {
-        this.unbindResponsiveListeners?.();
-        this.unbindResponsiveListeners = null;
-        this.resizeObserver?.disconnect();
-        this.resizeObserver = null;
-        this.disposeInputBridge();
-        this.disposeTerminalEventListeners();
-        this.scrollbarOverlay?.dispose();
-        this.scrollbarOverlay = null;
-        this.fabricView?.dispose();
-        this.fabricView = null;
-        this.terminal?.dispose();
-        this.terminal = null;
-        this.ownedRuntimeMemory = null;
-        this.ownedRuntime = null;
-        this.inputElement?.remove();
-        this.inputElement = null;
-        this.fitAddon = null;
-        this.viewportHost?.remove();
-        this.viewportHost = null;
-        this.renderHost = null;
-    }
-    async createTerminalInstance(signal) {
-        const TerminalCtor = getGhosttyTerminalConstructor();
-        if (!TerminalCtor) {
-            throw new Error('@floegence/ghostty-web module not loaded');
-        }
-        if (!this.ownedRuntime) {
-            throw new Error('@floegence/ghostty-web runtime not acquired');
-        }
-        const defaultConfig = {
-            cols: 80,
-            rows: 24,
-            theme: {
-                background: '#1a1a1a',
-                foreground: '#ffffff',
-                cursor: '#ffffff',
-                selectionBackground: TERMINAL_SELECTION_BACKGROUND,
-                selectionForeground: TERMINAL_SELECTION_FOREGROUND
-            },
-            fontSize: 12,
-            fontFamily: '\"SF Mono\", Monaco, \"Cascadia Code\", \"Roboto Mono\", Consolas, \"Courier New\", monospace',
-            cursorBlink: false,
-            scrollback: 1000,
-            allowTransparency: false,
-            convertEol: true,
-            cursorStyle: 'block',
-            disableStdin: false,
-            smoothScrollDuration: 80
-        };
-        const finalConfig = { ...defaultConfig, ...this.config };
-        const initialTheme = mapThemeToGhostty(finalConfig.theme);
-        this.terminalThemeSource = initialTheme;
-        this.themeColorTranslator = null;
-        this.logicalFontSize = TerminalCore.normalizeFontSize(finalConfig.fontSize);
-        this.presentationScale = TerminalCore.normalizePresentationScale(finalConfig.presentationScale);
-        await waitWithAbort(this.waitForTerminalFontReady(typeof finalConfig.fontFamily === 'string' ? finalConfig.fontFamily : undefined, this.resolveEffectiveFontSize(), 'initial'), signal);
-        const initialDimensions = this.fixedDimensions;
-        this.terminal = new TerminalCtor({
-            cols: initialDimensions?.cols ?? (typeof finalConfig.cols === 'number' ? finalConfig.cols : undefined),
-            rows: initialDimensions?.rows ?? (typeof finalConfig.rows === 'number' ? finalConfig.rows : undefined),
-            cursorBlink: typeof finalConfig.cursorBlink === 'boolean' ? finalConfig.cursorBlink : undefined,
-            cursorStyle: typeof finalConfig.cursorStyle === 'string' ? finalConfig.cursorStyle : undefined,
-            theme: initialTheme,
-            scrollback: mapGhosttyScrollbackRowsForPinnedVersion(this.scrollbackRows),
-            fontSize: this.resolveEffectiveFontSize(),
-            fontFamily: typeof finalConfig.fontFamily === 'string' ? finalConfig.fontFamily : undefined,
-            allowTransparency: typeof finalConfig.allowTransparency === 'boolean' ? finalConfig.allowTransparency : undefined,
-            convertEol: typeof finalConfig.convertEol === 'boolean' ? finalConfig.convertEol : undefined,
-            disableStdin: typeof finalConfig.disableStdin === 'boolean' ? finalConfig.disableStdin : undefined,
-            smoothScrollDuration: typeof finalConfig.smoothScrollDuration === 'number' ? finalConfig.smoothScrollDuration : undefined,
-            ghostty: this.ownedRuntime,
-        });
-    }
-    async loadAddons() {
-        if (!this.terminal) {
-            throw new Error('Terminal instance not created');
-        }
-        const FitAddonCtor = getGhosttyFitAddonConstructor();
-        if (!FitAddonCtor) {
-            throw new Error('Required @floegence/ghostty-web addons not loaded');
-        }
-        this.fitAddon = new FitAddonCtor();
-        this.terminal.loadAddon(this.fitAddon);
-        this.installFitAddonGeometryPatch();
-    }
-    async openTerminal(signal) {
-        if (!this.terminal) {
-            throw new Error('Terminal instance not created');
-        }
-        await waitWithAbort(this.waitForDOMAndFonts(), signal);
-        await waitWithAbort(this.ensureContainerReady(), signal);
-        const renderHost = this.ensurePresentationHosts();
-        this.applyPresentationScaleStyles();
-        this.installDemandRenderPatchBeforeOpen();
-        suppressPinnedGhosttyScrollbarBeforeOpen(this.terminal);
-        this.terminal.open(renderHost);
-        installPinnedGhosttyAlternateScreenProjection(this.terminal);
-        installPinnedGhosttyOutputViewportPolicy(this.terminal);
-        const renderer = this.terminal.renderer;
-        suppressPinnedGhosttyScrollbarRenderer(renderer ?? {});
-        this.installLinkDetector();
-        if (this.config.rendererType === 'webgl') {
-            const canvas = this.terminal
-                .renderer?.getCanvas?.();
-            if (canvas)
-                canvas.style.opacity = '0';
-        }
-        this.mountInputElement(renderHost);
-        this.stopGhosttyRenderLoop();
-        this.patchDemandRenderTriggersAfterOpen();
-        this.patchSelectionManagerClipboardBehavior();
-        this.patchSelectionManagerRenderingBehavior();
-        this.setupInputBridge(renderHost);
-        this.mountScrollbarOverlay();
-        this.applyRegisteredLinkProviders();
-        void this.refreshFontMetricsAfterLoad('open');
-    }
-    mountInputElement(renderHost) {
-        const input = resolveTerminalInputElement(renderHost);
-        if (!input) {
-            throw new Error('@floegence/ghostty-web terminal input element was not created');
-        }
-        const body = this.container.ownerDocument.body;
-        if (!body) {
-            throw new Error('Terminal input requires a document body');
-        }
-        body.appendChild(input);
-        this.inputElement = input;
-    }
-    mountScrollbarOverlay() {
-        if (!this.terminal || !this.viewportHost || !this.renderHost) {
-            throw new Error('Terminal scrollbar requires an initialized presentation host');
-        }
-        this.scrollbarOverlay?.dispose();
-        const terminal = this.terminal;
-        const surfaceId = `${this.fabricViewId}-surface`;
-        this.renderHost.id = surfaceId;
-        this.scrollbarOverlay = new TerminalScrollbarOverlay(this.viewportHost, {
-            get rows() {
-                return terminal.rows;
-            },
-            getScrollbackLength: () => terminal.getScrollbackLength(),
-            getViewportY: () => terminal.getViewportY(),
-            isAlternateScreen: () => terminal.isAlternateScreen(),
-            scrollToLine: line => terminal.scrollToLine(line),
-            scrollToTop: () => terminal.scrollToTop(),
-            scrollToBottom: () => terminal.scrollToBottom(),
-            scrollLines: amount => terminal.scrollLines(amount),
-            scrollPages: amount => terminal.scrollPages(amount),
-            focusTerminal: () => this.scheduleInputSurfaceRefocus({ preventScroll: true }),
-        }, this.scrollbarOptions, surfaceId);
-        this.scrollbarOverlay.setBackgroundColor(this.terminalThemeSource.background);
-    }
-    installLinkDetector() {
-        if (!this.terminal) {
-            throw new Error('Terminal instance not created');
-        }
-        const { LinkDetector, OSC8LinkProvider, UrlRegexProvider, } = getGhosttyLinkConstructors();
-        const detector = new LinkDetector(this.terminal);
-        detector.registerProvider(new OSC8LinkProvider(this.terminal));
-        detector.registerProvider(new UrlRegexProvider(createUnicodeSafeUrlProviderTerminal(this.terminal)));
-        this.terminal.linkDetector = detector;
-    }
-    installFitAddonGeometryPatch() {
-        const fitAddon = this.fitAddon;
-        if (!fitAddon || fitAddon.__floetermGeometryPatchApplied) {
-            return;
-        }
-        fitAddon.__floetermGeometryPatchApplied = true;
-        fitAddon.proposeDimensions = () => this.proposeFitDimensions();
-    }
-    proposeFitDimensions() {
-        const fabricDimensions = this.proposeFabricFitDimensions();
-        if (fabricDimensions) {
-            return fabricDimensions;
-        }
-        const terminalAny = this.terminal;
-        const renderer = terminalAny?.renderer;
-        const metrics = typeof renderer?.getMetrics === 'function' ? renderer.getMetrics() : null;
-        const cellWidth = Number(metrics?.width);
-        const cellHeight = Number(metrics?.height);
-        if (!Number.isFinite(cellWidth) || !Number.isFinite(cellHeight) || cellWidth <= 0 || cellHeight <= 0) {
-            return undefined;
-        }
-        const element = this.resolveFitElement(terminalAny?.element);
-        if (!element || typeof element.clientWidth === 'undefined') {
-            return undefined;
-        }
-        const width = element.clientWidth;
-        const height = element.clientHeight;
-        if (width === 0 || height === 0) {
-            return undefined;
-        }
-        const style = getComputedStyle(element);
-        const paddingTop = Number.parseInt(style.getPropertyValue('padding-top')) || 0;
-        const paddingBottom = Number.parseInt(style.getPropertyValue('padding-bottom')) || 0;
-        const paddingLeft = Number.parseInt(style.getPropertyValue('padding-left')) || 0;
-        const paddingRight = Number.parseInt(style.getPropertyValue('padding-right')) || 0;
-        const availableWidth = Math.max(0, width - paddingLeft - paddingRight - this.fit.scrollbarReservePx);
-        const availableHeight = Math.max(0, height - paddingTop - paddingBottom);
-        return {
-            cols: capAutoFitTerminalColumns(Math.max(MIN_TERMINAL_COLS, Math.floor(availableWidth / cellWidth))),
-            rows: Math.max(MIN_TERMINAL_ROWS, Math.floor(availableHeight / cellHeight)),
-        };
-    }
-    proposeFabricFitDimensions() {
-        if (this.config.rendererType !== 'webgl') {
-            return null;
-        }
-        const geometry = this.fabricView?.renderer.getGeometry();
-        if (!geometry) {
-            return null;
-        }
-        const cellWidth = Number(geometry.cellWidth);
-        const hostWidth = Number(this.viewportHost?.clientWidth ?? this.container.clientWidth);
-        const visibleCellWidth = cellWidth / this.presentationScale;
-        const cols = Number.isFinite(hostWidth) && hostWidth > 0
-            && Number.isFinite(visibleCellWidth) && visibleCellWidth > 0
-            ? Math.floor(Math.max(0, hostWidth - this.fit.scrollbarReservePx) / visibleCellWidth)
-            : Math.floor(Number(geometry.cols));
-        const rows = Math.floor(Number(geometry.rows));
-        if (!Number.isFinite(cols) || !Number.isFinite(rows) || cols <= 0 || rows <= 0) {
-            return null;
-        }
-        return {
-            cols: capAutoFitTerminalColumns(Math.max(MIN_TERMINAL_COLS, cols)),
-            rows: Math.max(MIN_TERMINAL_ROWS, rows),
-        };
-    }
-    syncGhosttyInputGeometryToFabric() {
-        if (!this.terminal || !this.isFabricRendererActive()) {
-            return;
-        }
-        const geometry = this.fabricView?.renderer.getGeometry();
-        if (!geometry) {
-            return;
-        }
-        const terminalAny = this.terminal;
-        const renderer = terminalAny.renderer;
-        const canvas = renderer?.getCanvas?.();
-        const cols = Math.floor(Number(terminalAny.cols ?? geometry.cols));
-        const rows = Math.floor(Number(terminalAny.rows ?? geometry.rows));
-        const cellWidth = Number(geometry.cellWidth);
-        const cellHeight = Number(geometry.cellHeight);
-        if (!renderer
-            || !canvas
-            || !Number.isFinite(cols)
-            || !Number.isFinite(rows)
-            || !Number.isFinite(cellWidth)
-            || !Number.isFinite(cellHeight)
-            || cols <= 0
-            || rows <= 0
-            || cellWidth <= 0
-            || cellHeight <= 0) {
-            return;
-        }
-        const currentMetrics = renderer.getMetrics?.() ?? renderer.metrics ?? {};
-        const baselineRatio = Number(currentMetrics.height) > 0
-            ? Number(currentMetrics.baseline ?? cellHeight * 0.8) / Number(currentMetrics.height)
-            : 0.8;
-        const nextMetrics = {
-            ...currentMetrics,
-            width: cellWidth,
-            height: cellHeight,
-            baseline: Math.max(1, Math.round(cellHeight * baselineRatio)),
-        };
-        renderer.metrics = nextMetrics;
-        const gridWidth = cols * cellWidth;
-        const gridHeight = rows * cellHeight;
-        canvas.style.width = formatCssPixelValue(gridWidth);
-        canvas.style.height = formatCssPixelValue(gridHeight);
-        canvas.style.maxWidth = 'none';
-        canvas.style.maxHeight = 'none';
-        const canvasDpr = canvas.width > 0 && gridWidth > 0
-            ? canvas.width / gridWidth
-            : window.devicePixelRatio ?? 1;
-        const dpr = Number.isFinite(canvasDpr) && canvasDpr > 0 ? canvasDpr : 1;
-        const expectedWidth = Math.max(1, Math.round(gridWidth * dpr));
-        const expectedHeight = Math.max(1, Math.round(gridHeight * dpr));
-        if (canvas.width !== expectedWidth || canvas.height !== expectedHeight) {
-            canvas.width = expectedWidth;
-            canvas.height = expectedHeight;
-        }
-        canvas.style.position = 'absolute';
-        canvas.style.left = '0';
-        canvas.style.top = '0';
-        canvas.style.inset = '0 auto auto 0';
-        canvas.style.zIndex = '1';
-        this.syncImeInputAnchor();
-    }
-    syncImeInputAnchor() {
-        const input = this.inputElement;
-        if (!input || this.shouldPreserveTransientInputPlacement(input)) {
-            return;
-        }
-        const geometry = this.resolveImeInputAnchorGeometry();
-        const cursor = this.resolveImeCursorPosition();
-        if (!geometry || !cursor) {
-            return;
-        }
-        const canvasRect = geometry.canvas.getBoundingClientRect();
-        const canvasClientWidth = Number(geometry.canvas.clientWidth);
-        const canvasClientHeight = Number(geometry.canvas.clientHeight);
-        if (!Number.isFinite(canvasClientWidth)
-            || !Number.isFinite(canvasClientHeight)
-            || canvasClientWidth <= 0
-            || canvasClientHeight <= 0) {
-            return;
-        }
-        const visibleScaleX = Number(canvasRect.width) / canvasClientWidth;
-        const visibleScaleY = Number(canvasRect.height) / canvasClientHeight;
-        const cellWidth = geometry.cellWidth * visibleScaleX;
-        const cellHeight = geometry.cellHeight * visibleScaleY;
-        const left = Number(canvasRect.left) + cursor.x * cellWidth;
-        const top = Number(canvasRect.top) + cursor.y * cellHeight;
-        if (!Number.isFinite(left)
-            || !Number.isFinite(top)
-            || !Number.isFinite(cellWidth)
-            || !Number.isFinite(cellHeight)
-            || cellWidth <= 0
-            || cellHeight <= 0) {
-            return;
-        }
-        input.style.position = 'fixed';
-        input.style.left = formatCssPixelValue(left);
-        input.style.top = formatCssPixelValue(top);
-        input.style.width = formatCssPixelValue(cellWidth);
-        input.style.height = formatCssPixelValue(cellHeight);
-        input.style.lineHeight = formatCssPixelValue(cellHeight);
-        input.style.padding = '0';
-        input.style.border = 'none';
-        input.style.margin = '0';
-        input.style.opacity = '0';
-        input.style.overflow = 'hidden';
-        input.style.whiteSpace = 'nowrap';
-        input.style.resize = 'none';
-        input.style.clipPath = 'none';
-        input.style.pointerEvents = 'none';
-        input.style.zIndex = '0';
-    }
-    shouldPreserveTransientInputPlacement(input) {
-        return input.style.pointerEvents === 'auto' || input.style.zIndex === '1000';
-    }
-    resolveImeInputAnchorGeometry() {
-        const terminalAny = this.terminal;
-        const renderer = terminalAny?.renderer ?? null;
-        const canvas = renderer?.getCanvas?.() ?? this.container.querySelector('canvas');
-        if (!(canvas instanceof HTMLCanvasElement)) {
-            return null;
-        }
-        const fabricGeometry = this.isFabricRendererActive()
-            ? this.fabricView?.renderer.getGeometry()
-            : null;
-        if (fabricGeometry) {
-            const cellWidth = Number(fabricGeometry.cellWidth);
-            const cellHeight = Number(fabricGeometry.cellHeight);
-            const cols = Math.floor(Number(terminalAny?.cols ?? fabricGeometry.cols));
-            const rows = Math.floor(Number(terminalAny?.rows ?? fabricGeometry.rows));
-            if (this.isUsableAnchorGeometry(cellWidth, cellHeight, cols, rows)) {
-                return { canvas, cellWidth, cellHeight, cols, rows };
-            }
-        }
-        const metrics = renderer?.getMetrics?.() ?? renderer?.metrics ?? {};
-        const cols = Math.floor(Number(terminalAny?.cols));
-        const rows = Math.floor(Number(terminalAny?.rows));
-        const fallbackCellWidth = cols > 0 ? Number(canvas.clientWidth) / cols : Number.NaN;
-        const fallbackCellHeight = rows > 0 ? Number(canvas.clientHeight) / rows : Number.NaN;
-        const cellWidth = Number(metrics.width ?? renderer?.charWidth ?? fallbackCellWidth);
-        const cellHeight = Number(metrics.height ?? renderer?.charHeight ?? fallbackCellHeight);
-        if (!this.isUsableAnchorGeometry(cellWidth, cellHeight, cols, rows)) {
-            return null;
-        }
-        return { canvas, cellWidth, cellHeight, cols, rows };
-    }
-    isUsableAnchorGeometry(cellWidth, cellHeight, cols, rows) {
-        return Number.isFinite(cellWidth)
-            && Number.isFinite(cellHeight)
-            && Number.isFinite(cols)
-            && Number.isFinite(rows)
-            && cellWidth > 0
-            && cellHeight > 0
-            && cols > 0
-            && rows > 0;
-    }
-    resolveImeCursorPosition() {
-        const terminalAny = this.terminal;
-        const cursor = terminalAny?.wasmTerm?.getCursor?.();
-        if (!cursor) {
-            return null;
-        }
-        const cols = Math.max(1, Math.floor(Number(terminalAny?.cols ?? 1)));
-        const rows = Math.max(1, Math.floor(Number(terminalAny?.rows ?? 1)));
-        const rawX = Number(cursor.viewportX ?? cursor.x);
-        const rawY = Number(cursor.viewportY ?? cursor.y);
-        if (!Number.isFinite(rawX) || !Number.isFinite(rawY)) {
-            return null;
-        }
-        return {
-            x: Math.max(0, Math.min(cols - 1, Math.floor(rawX))),
-            y: Math.max(0, Math.min(rows - 1, Math.floor(rawY))),
-        };
-    }
-    focusInputSurface(options) {
-        this.inputBridge?.focus(options);
-    }
-    scheduleInputSurfaceRefocus(options) {
-        this.cancelInputRefocusSchedule?.();
-        this.cancelInputRefocusSchedule = scheduleUiTurn(() => {
-            this.cancelInputRefocusSchedule = null;
-            if (this.isDisposed) {
-                return;
-            }
-            this.focusInputSurface(options);
-        });
-    }
-    resolveFitElement(terminalElement) {
-        const candidates = [
-            this.renderHost,
-            this.viewportHost,
-            this.container,
-            terminalElement,
-        ];
-        return candidates.find(hasUsableClientSize) ?? terminalElement ?? this.renderHost ?? this.container;
-    }
-    installDemandRenderPatchBeforeOpen() {
-        const terminalAny = this.terminal;
-        if (!terminalAny || terminalAny.__floetermDemandRenderLoopPatched) {
-            return;
-        }
-        terminalAny.__floetermDemandRenderLoopPatched = true;
-        // @floegence/ghostty-web currently starts a perpetual RAF loop from open(). TerminalCore
-        // already knows every meaningful invalidation point, so keep rendering
-        // demand-driven while preserving the upstream terminal surface.
-        terminalAny.startRenderLoop = () => {
-            this.requestDemandRender(false);
-        };
-    }
-    patchDemandRenderTriggersAfterOpen() {
-        const terminalAny = this.terminal;
-        if (!terminalAny || terminalAny.__floetermDemandRenderTriggersPatched) {
-            return;
-        }
-        terminalAny.__floetermDemandRenderTriggersPatched = true;
-        if (typeof terminalAny.animateScroll === 'function') {
-            const originalAnimateScroll = terminalAny.animateScroll.bind(terminalAny);
-            terminalAny.animateScroll = (...args) => {
-                const result = originalAnimateScroll(...args);
-                this.requestDemandRender(false);
-                return result;
-            };
-        }
-        const renderer = terminalAny.renderer;
-        this.installRendererRowCachePatch(renderer);
-        if (!renderer || renderer.__floetermDemandRenderPatched) {
-            return;
-        }
-        renderer.__floetermDemandRenderPatched = true;
-        const wrapRendererInvalidation = (method) => {
-            const original = renderer[method];
-            if (typeof original !== 'function') {
-                return;
-            }
-            renderer[method] = ((...args) => {
-                const result = original.apply(renderer, args);
-                this.requestDemandRender(false);
-                return result;
-            });
-        };
-        wrapRendererInvalidation('setHoveredHyperlinkId');
-        wrapRendererInvalidation('setHoveredLinkRange');
-        wrapRendererInvalidation('setCursorStyle');
-        wrapRendererInvalidation('setCursorBlink');
-        wrapRendererInvalidation('setTheme');
-        wrapRendererInvalidation('setFontSize');
-        wrapRendererInvalidation('setFontFamily');
-        wrapRendererInvalidation('clear');
-        this.patchRendererCursorBlinkForDemandRendering(renderer);
-    }
-    patchRendererCursorBlinkForDemandRendering(renderer) {
-        if (!renderer || renderer.__floetermDemandCursorPatched) {
-            return;
-        }
-        renderer.__floetermDemandCursorPatched = true;
-        renderer.cursorVisible = true;
-        try {
-            renderer.setCursorBlink?.(false);
-        }
-        catch (error) {
-            this.logger.debug('[TerminalCore] Failed to disable cursor blink for demand rendering', { error });
-        }
-        if (this.terminal) {
-            this.terminal.options.cursorBlink = false;
-        }
-    }
-    keepDemandCursorVisible(renderer) {
-        if (!renderer) {
-            return;
-        }
-        renderer.cursorVisible = true;
-    }
-    installRendererRowCachePatch(renderer) {
-        if (!renderer || renderer.__floetermRowRenderCachePatched) {
-            return;
-        }
-        if (typeof renderer.render !== 'function' || typeof renderer.renderLine !== 'function') {
-            return;
-        }
-        const originalRender = renderer.render.bind(renderer);
-        const originalRenderLine = renderer.renderLine.bind(renderer);
-        const cache = new Map();
-        renderer.__floetermRowRenderCachePatched = true;
-        renderer.__floetermRowRenderCache = cache;
-        renderer.render = (...args) => {
-            const incomingViewportY = Number(args[2] ?? 0);
-            const currentViewportY = Number(renderer.lastViewportY ?? 0);
-            const viewportChanged = Number.isFinite(incomingViewportY)
-                && Number.isFinite(currentViewportY)
-                && incomingViewportY !== currentViewportY;
-            const forceTransientExit = forceTransientRowsOnExit(renderer);
-            const forceAll = Boolean(args[1]) || viewportChanged || forceTransientExit;
-            renderer.__floetermRowRenderCacheForceAll = forceAll;
-            const fabricFrame = this.beginFabricFrame(forceAll, args[0]);
-            try {
-                const renderArgs = [...args];
-                renderArgs[1] = forceAll;
-                return originalRender(...renderArgs);
-            }
-            finally {
-                this.finishFabricFrame(fabricFrame);
-                renderer.__floetermRowRenderCacheForceAll = false;
-            }
-        };
-        renderer.renderLine = (cells, row, cols) => {
-            const themedCells = this.translateCellsForTheme(cells);
-            const fabricActive = this.writeFabricRow(renderer, row, themedCells, cols);
-            if (canSkipNativeCanvasRowRender(renderer, row, fabricActive)) {
-                return undefined;
-            }
-            const signature = buildRowSignature(renderer, themedCells, row, cols);
-            if (canSkipCachedRowRender(renderer, row) && cache.get(row) === signature) {
-                return undefined;
-            }
-            const result = originalRenderLine(themedCells, row, cols);
-            if (hasTransientRendererState(renderer)) {
-                cache.delete(row);
-                return result;
-            }
-            cache.set(row, signature);
-            return result;
-        };
-    }
-    beginFabricFrame(forceAll, buffer) {
-        const renderer = this.fabricView?.renderer;
-        if (!renderer?.isActive()) {
-            return null;
-        }
-        const dimensions = this.resolveFabricDimensions(buffer);
-        if (!dimensions) {
-            return null;
-        }
-        const frame = terminalFabricCoordinator.beginFrame(renderReasonFromForce(forceAll), forceAll);
-        const theme = this.resolveFabricTheme();
-        renderer.startFrame(frame, {
-            cols: dimensions.cols,
-            rows: dimensions.rows,
-            theme: themeToFabricTheme(theme),
-        });
-        return frame;
-    }
-    resolveFabricDimensions(buffer) {
-        const raw = buffer;
-        const dimensions = raw?.getDimensions?.();
-        const cols = Math.floor(Number(dimensions?.cols ?? this.terminal?.cols ?? 0));
-        const rows = Math.floor(Number(dimensions?.rows ?? this.terminal?.rows ?? 0));
-        if (!Number.isFinite(cols) || !Number.isFinite(rows) || cols <= 0 || rows <= 0) {
-            return null;
-        }
-        return { cols, rows };
-    }
-    writeFabricRow(renderer, row, cells, cols) {
-        const fabricRenderer = this.fabricView?.renderer;
-        if (!fabricRenderer?.isActive()) {
-            return false;
-        }
-        fabricRenderer.writeRow(renderer, row, cells, cols, this.resolveFabricRowRenderHints(renderer));
-        return true;
-    }
-    resolveFabricRowRenderHints(renderer) {
-        return {
-            selection: this.resolveFabricSelectionHint(renderer),
-            hover: {
-                hyperlinkId: Number(renderer.hoveredHyperlinkId ?? 0),
-                range: normalizeHoverRange(renderer.hoveredLinkRange),
-            },
-        };
-    }
-    resolveFabricSelectionHint(renderer) {
-        const range = normalizeSelectionRange(renderer.currentSelectionCoords);
-        if (!range) {
-            return null;
-        }
-        const theme = this.resolveFabricTheme();
-        return {
-            ...range,
-            background: parseThemeColor(theme.selectionBackground ?? TERMINAL_SELECTION_BACKGROUND)
-                ?? parseThemeColor(TERMINAL_SELECTION_BACKGROUND),
-            foreground: parseThemeColor(theme.selectionForeground ?? TERMINAL_SELECTION_FOREGROUND)
-                ?? parseThemeColor(TERMINAL_SELECTION_FOREGROUND),
-        };
-    }
-    syncFabricSelectionState() {
-        const renderer = this.terminal?.renderer;
-        const selectionManager = this.terminal?.selectionManager;
-        if (!renderer || !selectionManager) {
-            return;
-        }
-        renderer.currentSelectionCoords = selectionManager.hasSelection?.()
-            ? selectionManager.getSelectionCoords?.() ?? null
-            : null;
-        renderer.__floetermRowRenderCache?.clear();
-        this.demandRenderForceAll = true;
-    }
-    finishFabricFrame(frame) {
-        const fabricRenderer = this.fabricView?.renderer;
-        if (!frame || !fabricRenderer?.isActive()) {
-            return;
-        }
-        const terminalAny = this.terminal;
-        const result = fabricRenderer.finishFrame(cursorToFabricCursor(terminalAny?.wasmTerm?.getCursor?.()));
-        if (result.rendered) {
-            terminalFabricCoordinator.completeFrame(frame, result.renderedRows, result.dirtyCells);
-            this.committedFabricFrameGeneration += 1;
-            this.lastCommittedFabricFrame = {
-                generation: this.committedFabricFrameGeneration,
-                result,
-            };
-        }
-    }
-    resolveFabricTheme() {
-        if (this.searchQuery.trim().length > 0 && this.searchThemeRestore) {
-            return this.applySearchThemeOverride(this.searchThemeRestore);
-        }
-        const configured = mapThemeToGhostty(this.config.theme);
-        return Object.keys(configured).length > 0 ? configured : this.terminalThemeSource;
-    }
-    translateCellsForTheme(cells) {
-        const translator = this.themeColorTranslator;
-        if (!translator) {
-            return cells;
-        }
-        let translatedCells = null;
-        for (let index = 0; index < cells.length; index += 1) {
-            const cell = translatedCells?.[index] ?? cells[index] ?? {};
-            const translated = this.translateCellForTheme(cell, translator);
-            if (translated !== cell && !translatedCells) {
-                translatedCells = cells.slice(0, index);
-            }
-            translatedCells?.push(translated);
-        }
-        return translatedCells ?? cells;
-    }
-    translateCellForTheme(cell, translator) {
-        const fgKey = cellColorKey(cell, 'fg');
-        const bgKey = cellColorKey(cell, 'bg');
-        const fg = fgKey ? translator.fg.get(fgKey) : undefined;
-        const bg = bgKey ? translator.bg.get(bgKey) : undefined;
-        if (!fg && !bg) {
-            return cell;
-        }
-        return {
-            ...cell,
-            ...(fg ? { fg_r: fg.r, fg_g: fg.g, fg_b: fg.b } : {}),
-            ...(bg ? { bg_r: bg.r, bg_g: bg.g, bg_b: bg.b } : {}),
-        };
-    }
-    ensurePresentationHosts() {
-        if (this.viewportHost && this.renderHost) {
-            return this.renderHost;
-        }
-        if (this.viewportHost || this.renderHost) {
-            throw new Error('Terminal presentation host state is inconsistent');
-        }
-        const viewportHost = document.createElement('div');
-        viewportHost.style.position = 'relative';
-        viewportHost.style.width = '100%';
-        viewportHost.style.height = '100%';
-        viewportHost.style.overflow = 'hidden';
-        const renderHost = document.createElement('div');
-        renderHost.style.position = 'absolute';
-        renderHost.style.inset = '0';
-        renderHost.style.overflow = 'hidden';
-        renderHost.style.transformOrigin = 'top left';
-        renderHost.style.willChange = 'transform';
-        viewportHost.appendChild(renderHost);
-        this.container.replaceChildren(viewportHost);
-        this.viewportHost = viewportHost;
-        this.renderHost = renderHost;
-        return renderHost;
-    }
-    applyPresentationScaleStyles() {
-        const renderHost = this.renderHost;
-        if (!renderHost) {
-            return;
-        }
-        const scale = this.pendingPresentationScale ?? this.presentationScale;
-        if (scale <= 1.001) {
-            renderHost.style.width = '100%';
-            renderHost.style.height = '100%';
-            renderHost.style.transform = 'none';
-            return;
-        }
-        renderHost.style.width = `${scale * 100}%`;
-        renderHost.style.height = `${scale * 100}%`;
-        renderHost.style.transform = `scale(${1 / scale})`;
-    }
-    patchSelectionManagerClipboardBehavior() {
-        if (this.clipboard.copyOnSelect) {
-            return;
-        }
-        const selectionManager = (this.terminal
-            ?.selectionManager) ?? null;
-        if (!selectionManager || typeof selectionManager.copyToClipboard !== 'function') {
-            return;
-        }
-        selectionManager.copyToClipboard = async () => {
-            // Disable the upstream copy-on-select side effect while keeping
-            // the selection lifecycle intact for explicit copy commands.
-        };
-    }
-    patchSelectionManagerRenderingBehavior() {
-        const selectionManager = (this.terminal
-            ?.selectionManager) ?? null;
-        if (!selectionManager || selectionManager.__floetermDemandRenderPatched) {
-            return;
-        }
-        selectionManager.__floetermDemandRenderPatched = true;
-        const originalRequestRender = typeof selectionManager.requestRender === 'function'
-            ? selectionManager.requestRender.bind(selectionManager)
-            : null;
-        selectionManager.requestRender = () => {
-            originalRequestRender?.();
-            this.syncFabricSelectionState();
-            this.requestDemandRender(false);
-        };
-    }
-    async attachFabricRenderer(seq) {
-        if (this.fabricView || this.config.rendererType !== 'webgl' || !this.terminal) {
-            return;
-        }
-        const terminalAny = this.terminal;
-        const theme = Object.keys(this.terminalThemeSource).length > 0
-            ? this.terminalThemeSource
-            : mapThemeToGhostty(this.config.theme);
-        const fontFamily = typeof terminalAny.options?.fontFamily === 'string'
-            ? terminalAny.options.fontFamily
-            : typeof this.config.fontFamily === 'string'
-                ? this.config.fontFamily
-                : '"JetBrains Mono", monospace';
-        const fontSize = Number(terminalAny.options?.fontSize ?? this.resolveEffectiveFontSize());
-        const sessionId = normalizeFabricIdentifier(typeof this.config.sessionId === 'string' ? this.config.sessionId : this.fabricViewId);
-        const fabricView = await terminalLiveFabric.attachView({
-            sessionId,
-            viewId: this.fabricViewId,
-            container: this.renderHost ?? this.container,
-            logger: this.logger,
-            fontFamily,
-            fontSize: Number.isFinite(fontSize) && fontSize > 0 ? fontSize : this.resolveEffectiveFontSize(),
-            theme,
-            getGhosttyCanvas: () => terminalAny.renderer?.getCanvas?.() ?? null,
-            focusInputSurface: () => this.inputBridge?.focus(),
-            forwardWheel: event => {
-                this.container.dispatchEvent(new WheelEvent(event.type, event));
-            },
-            onRendererError: error => this.handleRendererFailure(error),
-        });
-        if (this.isDisposed || seq !== this.fabricAttachSeq || this.fabricView) {
-            fabricView.dispose();
-            if (this.isDisposed) {
-                throw new Error('TerminalCore was disposed before the Beamterm renderer attached');
-            }
-            return;
-        }
-        this.fabricView = fabricView;
-        this.fabricView.renderer.setAppearance({ theme, fontFamily, fontSize });
-        this.performResize('force');
-        this.syncGhosttyInputGeometryToFabric();
-        this.forceFullRender();
-        this.resolveFabricAttachWaiters();
-    }
-    waitForFabricRendererAttach() {
-        if (this.isFabricRendererActive())
-            return Promise.resolve();
-        if (this.isDisposed)
-            return Promise.reject(new Error('Cannot attach a disposed TerminalCore'));
-        const waiter = new Promise((resolve, reject) => {
-            this.fabricAttachWaiters.push({ resolve, reject });
-        });
-        if (!this.fabricAttachPromise) {
-            this.cancelFabricAttachSchedule?.();
-            this.cancelFabricAttachSchedule = null;
-            const seq = ++this.fabricAttachSeq;
-            void this.startFabricRendererAttach(seq).catch(() => undefined);
-        }
-        return waiter;
-    }
-    resolveFabricAttachWaiters() {
-        const waiters = this.fabricAttachWaiters;
-        this.fabricAttachWaiters = [];
-        for (const waiter of waiters)
-            waiter.resolve();
-    }
-    rejectFabricAttachWaiters(error) {
-        const waiters = this.fabricAttachWaiters;
-        this.fabricAttachWaiters = [];
-        for (const waiter of waiters)
-            waiter.reject(error);
-    }
-    startFabricRendererAttach(seq) {
-        if (this.fabricView)
-            return Promise.resolve();
-        if (this.fabricAttachPromise)
-            return this.fabricAttachPromise;
-        const operation = this.attachFabricRenderer(seq)
-            .catch(error => {
-            if (!this.isDisposed && seq === this.fabricAttachSeq) {
-                this.handleRendererFailure(error);
-            }
-            throw error;
-        })
-            .finally(() => {
-            if (this.fabricAttachPromise === operation) {
-                this.fabricAttachPromise = null;
-            }
-        });
-        this.fabricAttachPromise = operation;
-        return operation;
-    }
-    scheduleFabricRendererAttach() {
-        if (this.config.rendererType !== 'webgl' || this.fabricView || this.fabricAttachPromise || !this.terminal) {
-            return;
-        }
-        if (this.cancelFabricAttachSchedule !== null) {
-            return;
-        }
-        const seq = ++this.fabricAttachSeq;
-        const attach = () => {
-            this.cancelFabricAttachSchedule = null;
-            if (this.isDisposed || seq !== this.fabricAttachSeq || this.fabricView) {
-                return;
-            }
-            void this.startFabricRendererAttach(seq).catch(() => undefined);
-        };
-        this.cancelFabricAttachSchedule = scheduleUiTurn(() => {
-            if (this.isDisposed || seq !== this.fabricAttachSeq || this.fabricView) {
-                this.cancelFabricAttachSchedule = null;
-                return;
-            }
-            this.cancelFabricAttachSchedule = scheduleUiTurn(attach);
-        });
-    }
-    handleRendererFailure(value) {
-        if (this.isDisposed)
-            return;
-        const error = value instanceof Error ? value : new Error(String(value));
-        this.cancelDemandRender();
-        this.rejectFabricAttachWaiters(error);
-        this.rejectAllPresentationRequests(error);
-        this.logger.error('[TerminalCore] Beamterm WebGL2 renderer failed', { error });
-        this.setState(TerminalState.ERROR);
-        this.eventHandlers.onError?.(error);
-    }
-    setupInputBridge(inputHost) {
-        this.disposeInputBridge();
-        const input = this.inputElement;
-        if (!input) {
-            throw new Error('Terminal input element was not mounted');
-        }
-        this.inputBridge = new TerminalInputBridge({
-            inputHost,
-            inputElement: input,
-            onData: (data) => {
-                this.restoreTerminalViewportForUserInput();
-                getPerfProbe()?.onTerminalInput?.(data.length);
-                this.eventHandlers.onData?.(data);
-            },
-            logger: this.logger,
-            hasSelection: () => this.hasSelection(),
-            copySelection: (source, clipboardData) => this.performSelectionCopy(source, clipboardData),
-            syncInputGeometry: () => this.syncImeInputAnchor(),
-        });
-        this.syncImeInputAnchor();
-        if (this.isContainerFocused()) {
-            this.scheduleInputSurfaceRefocus();
-        }
-    }
-    async waitForDOMAndFonts() {
-        if (document.readyState !== 'complete') {
-            await new Promise((resolve) => {
-                const handler = () => {
-                    if (document.readyState === 'complete') {
-                        document.removeEventListener('readystatechange', handler);
-                        resolve();
-                    }
-                };
-                document.addEventListener('readystatechange', handler);
-            });
-        }
-        if (typeof document.fonts !== 'undefined' && document.fonts.ready) {
-            try {
-                await document.fonts.ready;
-            }
-            catch (error) {
-                this.logger.warn('[TerminalCore] Font loading failed, continuing', { error });
-                await new Promise(resolve => setTimeout(resolve, 200));
-            }
-        }
-        else {
-            await new Promise(resolve => setTimeout(resolve, 200));
-        }
-    }
-    async waitForTerminalFontReady(fontFamily, fontSize, reason) {
-        if (typeof document === 'undefined') {
-            return;
-        }
-        await this.waitForDOMAndFonts();
-        const fonts = document.fonts;
-        if (!fontFamily || typeof fonts === 'undefined' || typeof fonts.load !== 'function') {
-            return;
-        }
-        const cssFont = `${Math.max(1, fontSize)}px ${fontFamily}`;
-        try {
-            await fonts.load(cssFont, 'MMMMMMMMMM');
-            if (fonts.ready) {
-                await fonts.ready;
-            }
-        }
-        catch (error) {
-            this.logger.warn('[TerminalCore] Terminal font loading failed, continuing', { error, reason, fontFamily });
-        }
-    }
-    refreshFontMetricsAfterLoad(reason) {
-        if (!this.terminal) {
-            return Promise.resolve();
-        }
-        const terminalAny = this.terminal;
-        const fontFamily = terminalAny.options?.fontFamily ?? this.config.fontFamily;
-        const fontSize = Number(terminalAny.options?.fontSize ?? this.resolveEffectiveFontSize());
-        const seq = ++this.fontMetricSeq;
-        const refresh = this.applyFontMetricsAfterLoad(terminalAny, typeof fontFamily === 'string' ? fontFamily : undefined, fontSize, reason, seq);
-        this.fontMetricRefreshPromise = refresh;
-        return refresh;
-    }
-    async applyFontMetricsAfterLoad(terminal, fontFamily, fontSize, reason, seq) {
-        await this.waitForTerminalFontReady(fontFamily, fontSize, reason);
-        if (this.isDisposed || seq !== this.fontMetricSeq || !this.terminal) {
-            return;
-        }
-        try {
-            terminal.renderer?.remeasureFont?.();
-        }
-        catch (error) {
-            this.logger.debug('[TerminalCore] Terminal font remeasure failed', { error, reason });
-        }
-        this.performResize('font');
-        this.forceFullRender();
-        this.scheduleRenderSearchOverlay();
-    }
-    async waitForStableFontMetrics() {
-        while (true) {
-            if (this.isDisposed) {
-                throw new Error('TerminalCore was disposed before font metrics stabilized');
-            }
-            const seq = this.fontMetricSeq;
-            const refresh = this.fontMetricRefreshPromise;
-            if (refresh) {
-                await refresh;
-            }
-            if (seq === this.fontMetricSeq && refresh === this.fontMetricRefreshPromise) {
-                return seq;
-            }
-        }
-    }
-    async ensureContainerReady() {
-        const maxRetries = 15;
-        const retryDelay = 50;
-        if (!document.contains(this.container)) {
-            throw new Error('Container element is no longer in the DOM');
-        }
-        for (let i = 0; i < maxRetries; i += 1) {
-            if (!document.contains(this.container)) {
-                throw new Error('Container element removed from DOM during initialization');
-            }
-            const width = this.container.clientWidth;
-            const height = this.container.clientHeight;
-            const style = getComputedStyle(this.container);
-            if (width > 0 && height > 0 && style.display !== 'none' && style.visibility !== 'hidden') {
-                return;
-            }
-            await new Promise(resolve => requestAnimationFrame(resolve));
-            if (i < maxRetries - 1) {
-                await new Promise(resolve => setTimeout(resolve, retryDelay));
-            }
-        }
-    }
-    setupEventListeners() {
-        if (!this.terminal) {
-            return;
-        }
-        this.disposeTerminalEventListeners();
-        let pendingTerminalKeyInput = false;
-        let pendingTerminalKeyInputEpoch = 0;
-        if (this.eventHandlers.onData && typeof this.terminal.onKey === 'function') {
-            const disposable = this.terminal.onKey(() => {
-                pendingTerminalKeyInput = true;
-                const epoch = ++pendingTerminalKeyInputEpoch;
-                queueMicrotask(() => {
-                    if (pendingTerminalKeyInputEpoch !== epoch)
-                        return;
-                    pendingTerminalKeyInput = false;
-                });
-            });
-            this.trackTerminalEventDisposable(disposable);
-        }
-        if (this.eventHandlers.onData) {
-            const disposable = this.terminal.onData((data) => {
-                let filtered = data;
-                if (this.isReplayingHistory || this.historyWriteDepth > 0) {
-                    filtered = filterXtermAutoResponses(data);
-                    if (filtered.length === 0) {
-                        return;
-                    }
-                }
-                if (pendingTerminalKeyInput
-                    && !isPinnedGhosttyOutputWriteActive(this.terminal)) {
-                    pendingTerminalKeyInput = false;
-                    pendingTerminalKeyInputEpoch += 1;
-                    this.restoreTerminalViewportForUserInput();
-                }
-                getPerfProbe()?.onTerminalInput?.(filtered.length);
-                this.eventHandlers.onData?.(filtered);
-            });
-            this.trackTerminalEventDisposable(disposable);
-        }
-        if (this.eventHandlers.onResize) {
-            const disposable = this.terminal.onResize((size) => {
-                this.emitResize(size, { source: 'terminal' });
-            });
-            this.trackTerminalEventDisposable(disposable);
-        }
-        if (this.eventHandlers.onBell && typeof this.terminal.onBell === 'function') {
-            const disposable = this.terminal.onBell(() => {
-                this.eventHandlers.onBell?.();
-            });
-            this.trackTerminalEventDisposable(disposable);
-        }
-        if (this.eventHandlers.onTitleChange && typeof this.terminal.onTitleChange === 'function') {
-            const disposable = this.terminal.onTitleChange((title) => {
-                this.eventHandlers.onTitleChange?.(title);
-            });
-            this.trackTerminalEventDisposable(disposable);
-        }
-        if (typeof this.terminal.onScroll === 'function') {
-            const disposable = this.terminal.onScroll(() => {
-                this.syncImeInputAnchor();
-                this.scrollbarOverlay?.reveal();
-                this.scrollbarOverlay?.sync();
-                this.requestDemandRender(false);
-            });
-            this.trackTerminalEventDisposable(disposable);
-        }
-        if (typeof this.terminal.onSelectionChange === 'function') {
-            const disposable = this.terminal.onSelectionChange(() => {
-                this.syncFabricSelectionState();
-                this.requestDemandRender(false);
-            });
-            this.trackTerminalEventDisposable(disposable);
-        }
-    }
-    restoreTerminalViewportForUserInput() {
-        const terminal = this.terminal;
-        if (!terminal)
-            return;
-        if (isPinnedGhosttyOutputWriteActive(terminal))
-            return;
-        terminal.scrollToBottom?.();
-    }
-    setupResponsiveListeners() {
-        const enabled = this.responsive.fitOnFocus || this.responsive.emitResizeOnFocus || this.responsive.notifyResizeOnlyWhenFocused;
-        if (!enabled) {
-            return;
-        }
-        const onFocusIn = () => {
-            this.hasFocus = true;
-            this.scheduleFocusResize();
-        };
-        const onDocumentFocusIn = () => {
-            this.hasFocus = this.isContainerFocused();
-            if (this.hasFocus) {
-                this.scheduleFocusResize();
-            }
-        };
-        const onFocusOut = () => {
-            // focusout fires even when moving focus within the subtree; re-check on next frame.
-            requestAnimationFrame(() => {
-                if (this.isDisposed) {
-                    return;
-                }
-                this.hasFocus = this.isContainerFocused();
-            });
-        };
-        const onPointerDown = () => {
-            // pointerdown can happen before focus moves; treat it as "intent to interact".
-            this.hasFocus = true;
-            this.scheduleFocusResize();
-        };
-        this.container.addEventListener('focusin', onFocusIn);
-        this.container.addEventListener('focusout', onFocusOut);
-        this.container.addEventListener('pointerdown', onPointerDown);
-        this.container.ownerDocument.addEventListener('focusin', onDocumentFocusIn);
-        this.container.ownerDocument.addEventListener('focusout', onFocusOut);
-        this.hasFocus = this.isContainerFocused();
-        this.unbindResponsiveListeners = () => {
-            this.container.removeEventListener('focusin', onFocusIn);
-            this.container.removeEventListener('focusout', onFocusOut);
-            this.container.removeEventListener('pointerdown', onPointerDown);
-            this.container.ownerDocument.removeEventListener('focusin', onDocumentFocusIn);
-            this.container.ownerDocument.removeEventListener('focusout', onFocusOut);
-        };
-    }
-    startSizeWatching() {
-        if (!this.container || !this.fitAddon) {
-            return;
-        }
-        if (typeof ResizeObserver === 'undefined') {
-            return;
-        }
-        this.resizeObserver = new ResizeObserver(() => {
-            this.scheduleObservedResize();
-        });
-        const observed = new Set();
-        const observe = (target) => {
-            if (!target || observed.has(target)) {
-                return;
-            }
-            observed.add(target);
-            this.resizeObserver?.observe(target);
-        };
-        observe(this.container);
-        observe(this.container.parentElement);
-        observe(this.viewportHost);
-        observe(this.renderHost);
-    }
-    scheduleObservedResize() {
-        if (this.resizeRaf === null) {
-            this.resizeRaf = requestAnimationFrame(() => {
-                this.resizeRaf = null;
-                this.performResize('observer');
-            });
-        }
-        if (this.resizeDebounceTimer) {
-            clearTimeout(this.resizeDebounceTimer);
-        }
-        this.resizeDebounceTimer = setTimeout(() => {
-            this.resizeDebounceTimer = null;
-            this.performResize('observer');
-        }, 80);
-    }
-    performResize(reason) {
-        if (this.isVisualRenderSuspended()) {
-            this.markPendingResize(reason);
-            return;
-        }
-        this.performResizeNow(reason);
-    }
-    performResizeNow(reason) {
-        if (!this.isReady() || !this.fitAddon || !this.terminal) {
-            return;
-        }
-        if (this.fixedDimensions) {
-            this.applyFixedDimensions(reason);
-            return;
-        }
-        if (this.container.clientWidth === 0 || this.container.clientHeight === 0) {
-            return;
-        }
-        const startSeq = this.resizeNotifySeq;
-        const before = this.lastNotifiedSize;
-        try {
-            if (this.isFabricRendererActive()) {
-                this.resizeFabricToHost();
-            }
-            this.fitAddon.fit();
-            if (this.isFabricRendererActive()) {
-                this.syncGhosttyInputGeometryToFabric();
-            }
-            if (!this.isFabricRendererActive()) {
-                this.resizeFabricToHost();
-            }
-            this.syncImeInputAnchor();
-        }
-        catch (error) {
-            this.logger.debug('[TerminalCore] Resize failed', { error });
-        }
-        // Some @floegence/ghostty-web builds may not always emit onResize for programmatic fit().
-        // Emit a deduped notification based on the actual terminal dimensions.
-        if (this.resizeNotifySeq !== startSeq) {
-            return;
-        }
-        const dims = this.getDimensions();
-        if (reason === 'focus' && this.responsive.emitResizeOnFocus) {
-            const force = Boolean(before) && before.cols === dims.cols && before.rows === dims.rows;
-            this.emitResize(dims, { source: 'core', force });
-            return;
-        }
-        this.emitResize(dims, { source: 'core' });
-    }
-    applyFixedDimensions(reason) {
-        if (!this.terminal || !this.fixedDimensions) {
-            return;
-        }
-        const dims = this.fixedDimensions;
-        const startSeq = this.resizeNotifySeq;
-        const before = this.lastNotifiedSize;
-        const changed = this.terminal.cols !== dims.cols || this.terminal.rows !== dims.rows;
-        const reportHostDimensions = this.responsive.reportHostDimensionsWithFixedGrid;
-        const previousSuppression = this.suppressResizeNotifications;
-        if (reportHostDimensions && changed) {
-            this.suppressResizeNotifications = true;
-        }
-        try {
-            if (changed) {
-                this.terminal.resize(dims.cols, dims.rows);
-            }
-            this.resizeFabricToHost();
-            this.syncImeInputAnchor();
-        }
-        catch (error) {
-            this.logger.debug('[TerminalCore] Fixed-dimension resize failed', { error });
-        }
-        finally {
-            this.suppressResizeNotifications = previousSuppression;
-        }
-        if (reportHostDimensions) {
-            const hostDimensions = this.proposeFitDimensions();
-            if (!hostDimensions) {
-                return;
-            }
-            const force = reason === 'focus' && this.responsive.emitResizeOnFocus
-                && Boolean(before) && before.cols === hostDimensions.cols && before.rows === hostDimensions.rows;
-            this.emitResize(hostDimensions, { source: 'core', force });
-            return;
-        }
-        // Some @floegence/ghostty-web builds may not emit onResize for programmatic resize().
-        if (this.resizeNotifySeq !== startSeq) {
-            return;
-        }
-        if (reason === 'focus' && this.responsive.emitResizeOnFocus) {
-            const force = Boolean(before) && before.cols === dims.cols && before.rows === dims.rows;
-            this.emitResize(dims, { source: 'core', force });
-            return;
-        }
-        if (changed) {
-            this.emitResize(dims, { source: 'core' });
-        }
-    }
-    scheduleFocusResize() {
-        if (!this.responsive.fitOnFocus && !this.responsive.emitResizeOnFocus) {
-            return;
-        }
-        if (this.focusResizeRaf !== null) {
-            return;
-        }
-        this.focusResizeRaf = requestAnimationFrame(() => {
-            this.focusResizeRaf = null;
-            this.performResize('focus');
-        });
-    }
-    emitResize(size, opts) {
-        if (!this.eventHandlers.onResize) {
-            return;
-        }
-        if (this.suppressResizeNotifications) {
-            return;
-        }
-        if (this.responsive.notifyResizeOnlyWhenFocused && !this.hasFocus) {
-            return;
-        }
-        const cols = typeof size?.cols === 'number' ? size.cols : 0;
-        const rows = typeof size?.rows === 'number' ? size.rows : 0;
-        if (!opts.force && this.lastNotifiedSize && this.lastNotifiedSize.cols === cols && this.lastNotifiedSize.rows === rows) {
-            return;
-        }
-        this.lastNotifiedSize = { cols, rows };
-        this.resizeNotifySeq += 1;
-        try {
-            this.eventHandlers.onResize({ cols, rows });
-        }
-        catch (error) {
-            this.logger.warn('[TerminalCore] onResize handler threw', { error });
-        }
-    }
-    isContainerFocused() {
-        if (typeof document === 'undefined') {
-            return false;
-        }
-        const el = document.activeElement;
-        if (!el) {
-            return false;
-        }
-        return this.container.contains(el) || this.inputBridge?.containsTarget(el) === true;
-    }
-    setState(newState) {
-        if (this.state !== newState) {
-            this.state = newState;
-            this.eventHandlers.onStateChange?.(newState);
-        }
-    }
-    isReady() {
-        return this.state === TerminalState.READY || this.state === TerminalState.CONNECTED;
-    }
-    // startHistoryReplay enables auto-response filtering for a limited duration.
-    startHistoryReplay(duration = 2000) {
-        if (this.replayingHistoryTimer) {
-            clearTimeout(this.replayingHistoryTimer);
-        }
-        this.isReplayingHistory = true;
-        this.replayingHistoryTimer = setTimeout(() => this.endHistoryReplay(), duration);
-    }
-    // endHistoryReplay disables auto-response filtering.
-    endHistoryReplay() {
-        if (this.replayingHistoryTimer) {
-            clearTimeout(this.replayingHistoryTimer);
-            this.replayingHistoryTimer = null;
-        }
-        this.isReplayingHistory = false;
-    }
-    write(data, callback) {
-        this.writeWithRenderMode(data, callback, false);
-    }
-    writeFrame(data, callback) {
-        this.writeWithRenderMode(data, callback, true);
-    }
-    writeWithRenderMode(data, callback, renderInCurrentFrame) {
-        if (!this.terminal || !this.isReady()) {
-            callback?.();
-            return;
-        }
-        try {
-            const probe = getPerfProbe();
-            probe?.onTerminalWrite?.(typeof data === 'string' ? data.length : data.byteLength);
-            const profileStartedAt = performance.now();
-            let snapshotMs = 0;
-            let parseMs = 0;
-            const beforeSnapshotStartedAt = performance.now();
-            const beforeWrite = this.captureRenderSnapshot();
-            snapshotMs += performance.now() - beforeSnapshotStartedAt;
-            const shouldForce = this.needsFullRenderOnNextWrite;
-            const render = () => {
-                const afterSnapshotStartedAt = performance.now();
-                const shouldForceAfterWrite = shouldForce || this.shouldForceFullRenderAfterWrite(beforeWrite);
-                snapshotMs += performance.now() - afterSnapshotStartedAt;
-                if (shouldForceAfterWrite) {
-                    this.needsFullRenderOnNextWrite = false;
-                }
-                if (renderInCurrentFrame) {
-                    const forceCurrentFrame = shouldForceAfterWrite || this.demandRenderForceAll;
-                    this.cancelDemandRender();
-                    this.renderDemandFrame(forceCurrentFrame);
-                }
-                else {
-                    this.requestDemandRender(shouldForceAfterWrite);
-                }
-                this.scrollbarOverlay?.sync();
-                callback?.();
-                probe?.onTerminalWriteProfile?.({
-                    totalMs: performance.now() - profileStartedAt,
-                    parseMs,
-                    snapshotMs,
-                });
-            };
-            const parseStartedAt = performance.now();
-            if (callback || shouldForce) {
-                this.terminal.write(data, render);
-                parseMs += performance.now() - parseStartedAt;
-                return;
-            }
-            this.terminal.write(data);
-            parseMs += performance.now() - parseStartedAt;
-            render();
-        }
-        catch (error) {
-            this.logger.error('[TerminalCore] Write failed', { error });
-            callback?.();
-        }
-    }
-    writeHistory(data, callback) {
-        this.historyWriteDepth += 1;
-        this.write(data, () => {
-            this.historyWriteDepth = Math.max(0, this.historyWriteDepth - 1);
-            callback?.();
-        });
-    }
-    clear() {
-        if (!this.terminal || !this.isReady()) {
-            return;
-        }
-        this.terminal.clear();
-        this.needsFullRenderOnNextWrite = true;
-        this.forceFullRender();
-    }
-    serialize() {
-        return this.captureRestorableSnapshot()?.data ?? '';
-    }
-    captureRestorableSnapshot(options = {}) {
-        if (!this.terminal || !this.isReady()) {
-            return null;
-        }
-        const maxBytes = Number.isFinite(options.maxBytes) && Number(options.maxBytes) > 0
-            ? Math.floor(Number(options.maxBytes))
-            : DEFAULT_TERMINAL_SNAPSHOT_MAX_BYTES;
-        const info = this.getTerminalInfo();
-        if (!info) {
-            return null;
-        }
-        const lines = [];
-        for (let row = 0; row < info.bufferLength; row += 1) {
-            lines.push(this.readBufferLine(row, { trimRight: true }));
-        }
-        const suffix = '\x1b[0m';
-        let selected = lines;
-        let data = SNAPSHOT_RESET_PREFIX + selected.join('\r\n') + suffix;
-        let partial = false;
-        while (selected.length > Math.max(1, info.rows) && encodedByteLength(data) > maxBytes) {
-            partial = true;
-            selected = selected.slice(Math.max(1, Math.floor(selected.length / 4)));
-            data = SNAPSHOT_RESET_PREFIX + selected.join('\r\n') + suffix;
-        }
-        if (encodedByteLength(data) > maxBytes) {
-            partial = true;
-            const availableBytes = Math.max(0, maxBytes - encodedByteLength(SNAPSHOT_RESET_PREFIX + suffix));
-            const encoded = new TextEncoder().encode(selected.join('\r\n'));
-            const tail = encoded.slice(Math.max(0, encoded.byteLength - availableBytes));
-            data = SNAPSHOT_RESET_PREFIX + new TextDecoder().decode(tail) + suffix;
-        }
-        return {
-            version: TERMINAL_SNAPSHOT_VERSION,
-            data,
-            byteLength: encodedByteLength(data),
-            partial,
-            coveredThroughSequence: Math.max(0, Math.floor(options.coveredThroughSequence ?? 0)),
-            cols: info.cols,
-            rows: info.rows,
-            createdAtMs: options.now?.() ?? Date.now(),
-        };
-    }
-    async restoreSnapshot(snapshot) {
-        if (!this.terminal || !this.isReady() || snapshot.version !== TERMINAL_SNAPSHOT_VERSION) {
-            return false;
-        }
-        if (!Number.isFinite(snapshot.coveredThroughSequence) || snapshot.coveredThroughSequence < 0) {
-            return false;
-        }
-        this.startHistoryReplay();
-        this.needsFullRenderOnNextWrite = true;
-        return new Promise(resolve => {
-            this.write(snapshot.data, () => {
-                this.endHistoryReplay();
-                resolve(true);
-            });
-        });
-    }
-    /**
-     * Restores a validated checkpoint produced by the published Ghostty engine.
-     * The terminal must already be at the checkpoint geometry; geometry changes
-     * remain owned by the history boundary before restore is attempted.
-     */
-    async restoreAuthoritativeCheckpoint(checkpoint) {
-        if (!this.terminal || !this.isReady()) {
-            throw new Error('Cannot restore a checkpoint before initialization completes');
-        }
-        if (checkpoint.formatVersion !== 1
-            || checkpoint.engineId !== 'floegence-ghostty-web'
-            || !Number.isSafeInteger(checkpoint.coveredThroughSequence)
-            || checkpoint.coveredThroughSequence <= 0
-            || !Number.isSafeInteger(checkpoint.geometryGeneration)
-            || checkpoint.geometryGeneration <= 0
-            || !Number.isSafeInteger(checkpoint.parserEpoch)
-            || checkpoint.parserEpoch <= 0
-            || !Number.isSafeInteger(checkpoint.cols)
-            || checkpoint.cols <= 0
-            || !Number.isSafeInteger(checkpoint.rows)
-            || checkpoint.rows <= 0
-            || !(checkpoint.bytes instanceof Uint8Array)
-            || checkpoint.bytes.byteLength === 0
-            || !/^[0-9a-f]{64}$/.test(checkpoint.stateDigestSha256)) {
-            throw new Error('Invalid authoritative terminal checkpoint metadata');
-        }
-        const terminalAny = this.terminal;
-        const wasmTerm = terminalAny.wasmTerm;
-        if (!wasmTerm
-            || typeof wasmTerm.validateCheckpoint !== 'function'
-            || typeof wasmTerm.restoreCheckpoint !== 'function'
-            || typeof wasmTerm.getStateDigest !== 'function') {
-            throw new Error('Published Ghostty terminal checkpoint API is unavailable');
-        }
-        if (terminalAny.cols !== checkpoint.cols || terminalAny.rows !== checkpoint.rows) {
-            throw new Error('Terminal geometry does not match authoritative checkpoint');
-        }
-        const bytes = checkpoint.bytes.slice();
-        if (await sha256Hex(bytes) !== checkpoint.checksumSha256) {
-            throw new Error('Authoritative terminal checkpoint checksum mismatch');
-        }
-        const coordinates = {
-            historySequence: BigInt(checkpoint.coveredThroughSequence),
-            geometryGeneration: BigInt(checkpoint.geometryGeneration),
-            parserEpoch: BigInt(checkpoint.parserEpoch),
-        };
-        const metadata = wasmTerm.validateCheckpoint(bytes);
-        if (metadata.formatVersion !== checkpoint.formatVersion
-            || metadata.cols !== checkpoint.cols
-            || metadata.rows !== checkpoint.rows
-            || metadata.historySequence !== coordinates.historySequence
-            || metadata.geometryGeneration !== coordinates.geometryGeneration
-            || metadata.parserEpoch !== coordinates.parserEpoch) {
-            throw new Error('Authoritative terminal checkpoint coordinates do not match');
-        }
-        wasmTerm.restoreCheckpoint(bytes, coordinates);
-        if (wasmTerm.getStateDigest() !== checkpoint.stateDigestSha256) {
-            throw new Error('Authoritative terminal checkpoint state digest mismatch');
-        }
-        this.needsFullRenderOnNextWrite = true;
-        this.forceFullRender();
-        await this.forceResizeAndWaitForCommittedFrame();
-    }
-    getResourceEstimate() {
-        const wasmMemoryBytes = this.ownedRuntimeMemory?.buffer.byteLength ?? 0;
-        if (wasmMemoryBytes <= 0) {
-            return {
-                bufferBytes: 0,
-                cellCount: 0,
-                wasmMemoryBytes: 0,
-                estimatedBytes: 0,
-                rendererType: this.config.rendererType ?? 'canvas',
-            };
-        }
-        const info = this.getTerminalInfo();
-        const cellCount = info ? Math.max(0, info.cols * info.bufferLength) : 0;
-        let bufferBytes = 0;
-        if (info) {
-            for (let row = 0; row < info.bufferLength; row += 1) {
-                bufferBytes += encodedByteLength(this.readBufferLine(row));
-            }
-        }
-        return {
-            bufferBytes,
-            cellCount,
-            wasmMemoryBytes,
-            estimatedBytes: ESTIMATED_RENDERER_BYTES + wasmMemoryBytes,
-            rendererType: this.config.rendererType ?? 'canvas',
-        };
-    }
-    getSelectionText() {
-        if (!this.terminal) {
-            return '';
-        }
-        return this.terminal.getSelection();
-    }
-    hasSelection() {
-        return this.getSelectionSnapshot().hasSelection;
-    }
-    async copySelection(source = 'command') {
-        return this.performSelectionCopy(source);
-    }
-    getState() {
-        return this.state;
-    }
-    getSelectionSnapshot() {
-        const text = this.getSelectionText();
-        return {
-            text,
-            hasSelection: text.length > 0,
-        };
-    }
-    async performSelectionCopy(source, clipboardData = null) {
-        const selection = this.getSelectionSnapshot();
-        if (!selection.hasSelection) {
-            return {
-                copied: false,
-                reason: 'empty_selection',
-                source,
-            };
-        }
-        if (clipboardData && typeof clipboardData.setData === 'function') {
-            clipboardData.setData('text/plain', selection.text);
-            return {
-                copied: true,
-                textLength: selection.text.length,
-                source,
-            };
-        }
-        if (await this.copyTextWithNavigatorClipboard(selection.text, source)) {
-            return {
-                copied: true,
-                textLength: selection.text.length,
-                source,
-            };
-        }
-        if (this.copyTextWithExecCommand(selection.text)) {
-            return {
-                copied: true,
-                textLength: selection.text.length,
-                source,
-            };
-        }
-        this.logger.warn('[TerminalCore] Clipboard copy unavailable', {
-            source,
-            textLength: selection.text.length,
-        });
-        return {
-            copied: false,
-            reason: 'clipboard_unavailable',
-            source,
-        };
-    }
-    async copyTextWithNavigatorClipboard(text, source) {
-        const clipboard = typeof navigator !== 'undefined' ? navigator.clipboard : undefined;
-        if (!clipboard || typeof clipboard.writeText !== 'function') {
-            return false;
-        }
-        try {
-            await clipboard.writeText(text);
-            return true;
-        }
-        catch (error) {
-            this.logger.debug('[TerminalCore] navigator.clipboard.writeText failed', {
-                error,
-                source,
-            });
-            return false;
-        }
-    }
-    copyTextWithExecCommand(text) {
-        if (typeof document === 'undefined' || typeof document.execCommand !== 'function') {
-            return false;
-        }
-        const previousActiveElement = document.activeElement instanceof HTMLElement ? document.activeElement : null;
-        const restorableSelection = (previousActiveElement instanceof HTMLInputElement ||
-            previousActiveElement instanceof HTMLTextAreaElement)
-            ? {
-                element: previousActiveElement,
-                start: previousActiveElement.selectionStart ?? 0,
-                end: previousActiveElement.selectionEnd ?? 0,
-                direction: previousActiveElement.selectionDirection ?? 'none',
-            }
-            : null;
-        const textarea = document.createElement('textarea');
-        textarea.value = text;
-        textarea.setAttribute('readonly', 'true');
-        textarea.setAttribute('aria-hidden', 'true');
-        textarea.style.position = 'fixed';
-        textarea.style.top = '0';
-        textarea.style.left = '-9999px';
-        textarea.style.opacity = '0';
-        textarea.style.pointerEvents = 'none';
-        document.body.appendChild(textarea);
-        textarea.focus({ preventScroll: true });
-        textarea.select();
-        try {
-            textarea.setSelectionRange(0, text.length);
-        }
-        catch {
-            this.logger.debug('[TerminalCore] Failed to prepare textarea selection for clipboard fallback');
-        }
-        let copied = false;
-        try {
-            copied = document.execCommand('copy');
-        }
-        catch (error) {
-            this.logger.debug('[TerminalCore] document.execCommand("copy") failed', { error });
-        }
-        textarea.remove();
-        previousActiveElement?.focus({ preventScroll: true });
-        if (restorableSelection) {
-            try {
-                restorableSelection.element.setSelectionRange(restorableSelection.start, restorableSelection.end, restorableSelection.direction);
-            }
-            catch {
-                this.logger.debug('[TerminalCore] Failed to restore previous selection after clipboard fallback');
-            }
-        }
-        return copied;
-    }
-    getDimensions() {
-        if (!this.terminal) {
-            return { cols: 0, rows: 0 };
-        }
-        return { cols: this.terminal.cols, rows: this.terminal.rows };
-    }
-    getTerminalInfo() {
-        if (!this.terminal) {
-            return null;
-        }
-        return {
-            rows: this.terminal.rows,
-            cols: this.terminal.cols,
-            bufferLength: this.terminal.buffer.active.length
-        };
-    }
-    readBufferLine(row, options = {}) {
-        if (!this.terminal) {
-            return '';
-        }
-        const normalizedRow = Math.floor(Number(row));
-        if (!Number.isFinite(normalizedRow) || normalizedRow < 0) {
-            return '';
-        }
-        try {
-            const line = this.terminal.buffer?.active?.getLine?.(normalizedRow);
-            const text = line?.translateToString?.(options.trimRight ?? false);
-            return typeof text === 'string' ? text : '';
-        }
-        catch {
-            return '';
-        }
-    }
-    readBufferLines(startRow, endRowInclusive, options = {}) {
-        const start = Math.floor(Number(startRow));
-        const end = Math.floor(Number(endRowInclusive));
-        if (!Number.isFinite(start) || !Number.isFinite(end) || end < start) {
-            return [];
-        }
-        const lines = [];
-        for (let row = Math.max(0, start); row <= end; row += 1) {
-            const text = this.readBufferLine(row, options);
-            if (text.length > 0) {
-                lines.push({ row, text });
-            }
-        }
-        return lines;
-    }
-    getTouchScrollRuntime() {
-        const terminal = this.terminal;
-        if (!terminal) {
-            return null;
-        }
-        return {
-            scrollLines: amount => {
-                const normalizedAmount = Math.trunc(Number(amount));
-                if (!Number.isFinite(normalizedAmount) || normalizedAmount === 0) {
-                    return false;
-                }
-                if (typeof terminal.scrollLines !== 'function') {
-                    return false;
-                }
-                terminal.scrollLines(normalizedAmount);
-                this.requestDemandRender(false);
-                return true;
-            },
-            getScrollbackLength: () => {
-                if (typeof terminal.getScrollbackLength !== 'function') {
-                    return 0;
-                }
-                const length = Number(terminal.getScrollbackLength());
-                return Number.isFinite(length) && length > 0 ? length : 0;
-            },
-            isAlternateScreen: () => {
-                if (typeof terminal.isAlternateScreen !== 'function') {
-                    return false;
-                }
-                return Boolean(terminal.isAlternateScreen());
-            },
-            sendAlternateScreenInput: data => {
-                const text = String(data ?? '');
-                if (!text) {
-                    return;
-                }
-                if (typeof terminal.input === 'function') {
-                    terminal.input(text, true);
-                    return;
-                }
-                getPerfProbe()?.onTerminalInput?.(text.length);
-                this.eventHandlers.onData?.(text);
-            },
-        };
-    }
-    findNext(term, options) {
-        return this.findInternal(term, options, 1);
-    }
-    findPrevious(term, options) {
-        return this.findInternal(term, options, -1);
-    }
-    clearSearch() {
-        this.searchQuery = '';
-        this.searchOptionsKey = '';
-        this.searchMatches = [];
-        this.searchRowIndex = new Map();
-        this.searchMatchIndex = -1;
-        this.clearActiveSearchSelection();
-        this.disposeSearchOverlay();
-        this.restoreSearchTheme();
-        this.notifySearchResults();
-    }
-    setSearchResultsCallback(callback) {
-        this.searchResultsCallback = callback;
-        this.notifySearchResults();
-    }
-    notifySearchResults() {
-        if (!this.searchResultsCallback)
-            return;
-        const count = this.searchMatches.length;
-        const index = this.searchMatchIndex;
-        try {
-            this.searchResultsCallback({ resultIndex: index, resultCount: count });
-        }
-        catch (error) {
-            this.logger.debug('[TerminalCore] Search results callback failed', { error });
-        }
-    }
-    findInternal(rawTerm, options, dir) {
-        if (!this.terminal || !this.isReady())
-            return false;
-        const term = (rawTerm ?? '').trim();
-        const key = JSON.stringify({
-            term,
-            caseSensitive: Boolean(options?.caseSensitive),
-            wholeWord: Boolean(options?.wholeWord),
-            regex: Boolean(options?.regex)
-        });
-        if (!term) {
-            this.clearSearch();
-            return false;
-        }
-        const shouldRescan = term !== this.searchQuery || key !== this.searchOptionsKey;
-        this.searchQuery = term;
-        this.searchOptionsKey = key;
-        if (shouldRescan) {
-            this.searchMatches = this.scanTerminalMatches(term, options);
-            this.searchRowIndex = this.buildSearchRowIndex(this.searchMatches);
-            this.searchMatchIndex = this.searchMatches.length > 0 ? (dir === 1 ? 0 : this.searchMatches.length - 1) : -1;
-            this.ensureSearchTheme();
-            this.ensureSearchOverlaySubscriptions();
-            this.scheduleRenderSearchOverlay();
-        }
-        else if (this.searchMatches.length > 0) {
-            this.searchMatchIndex = dir === 1
-                ? (this.searchMatchIndex + 1) % this.searchMatches.length
-                : (this.searchMatchIndex - 1 + this.searchMatches.length) % this.searchMatches.length;
-        }
-        const match = this.searchMatchIndex >= 0 ? this.searchMatches[this.searchMatchIndex] : null;
-        if (!match) {
-            this.clearActiveSearchSelection();
-            this.scheduleRenderSearchOverlay();
-            this.notifySearchResults();
-            return false;
-        }
-        this.applySearchMatch(match);
-        this.scheduleRenderSearchOverlay();
-        this.notifySearchResults();
-        return true;
-    }
-    scanTerminalMatches(term, options) {
-        const t = this.terminal;
-        if (!t)
-            return [];
-        const buffer = t.buffer?.active;
-        if (!buffer || typeof buffer.length !== 'number')
-            return [];
-        const caseSensitive = Boolean(options?.caseSensitive);
-        const query = caseSensitive ? term : term.toLowerCase();
-        // 模糊搜索：按空白切分为多个 token（例如 "git status" -> ["git", "status"]）
-        const tokens = query.split(/\s+/).filter(Boolean);
-        let regex = null;
-        if (options?.regex) {
-            try {
-                regex = new RegExp(term, caseSensitive ? 'g' : 'gi');
-            }
-            catch {
-                regex = null;
-            }
-        }
-        const results = [];
-        for (let row = 0; row < buffer.length; row += 1) {
-            const line = buffer.getLine(row);
-            if (!line)
-                continue;
-            const raw = line.translateToString(false);
-            if (!raw)
-                continue;
-            const text = caseSensitive ? raw : raw.toLowerCase();
-            if (regex) {
-                regex.lastIndex = 0;
-                for (;;) {
-                    const m = regex.exec(raw);
-                    if (!m || typeof m.index !== 'number')
-                        break;
-                    const len = Math.max(1, String(m[0] ?? '').length);
-                    results.push({ row, col: m.index, len });
-                    if (results.length >= TERMINAL_SEARCH_MAX_RESULTS)
-                        break;
-                    if (len <= 0)
-                        break;
-                    if (regex.lastIndex === m.index)
-                        regex.lastIndex += 1;
-                }
-            }
-            else if (tokens.length <= 1) {
-                const needle = query;
-                let idx = 0;
-                while (idx <= text.length - needle.length) {
-                    const at = text.indexOf(needle, idx);
-                    if (at < 0)
-                        break;
-                    if (options?.wholeWord && !this.isWholeWordMatch(text, at, needle.length)) {
-                        idx = at + Math.max(1, needle.length);
-                        continue;
-                    }
-                    results.push({ row, col: at, len: Math.max(1, needle.length) });
-                    if (results.length >= TERMINAL_SEARCH_MAX_RESULTS)
-                        break;
-                    idx = at + Math.max(1, needle.length);
-                }
-            }
-            else {
-                // Multi-token fuzzy: tokens must appear in order; highlight the full span.
-                let from = 0;
-                let start = -1;
-                let end = -1;
-                let ok = true;
-                for (const token of tokens) {
-                    const at = text.indexOf(token, from);
-                    if (at < 0) {
-                        ok = false;
-                        break;
-                    }
-                    if (start < 0)
-                        start = at;
-                    end = at + token.length;
-                    from = end;
-                }
-                if (ok && start >= 0 && end > start) {
-                    const len = end - start;
-                    if (!options?.wholeWord || this.isWholeWordMatch(text, start, len)) {
-                        results.push({ row, col: start, len });
-                    }
-                }
-            }
-            if (results.length >= TERMINAL_SEARCH_MAX_RESULTS)
-                break;
-        }
-        // Prefer recent output: sort from bottom to top.
-        results.sort((a, b) => {
-            const dr = b.row - a.row;
-            if (dr !== 0)
-                return dr;
-            return a.col - b.col;
-        });
-        return results;
-    }
-    buildSearchRowIndex(matches) {
-        const byRow = new Map();
-        for (const m of matches) {
-            const list = byRow.get(m.row);
-            if (list)
-                list.push(m);
-            else
-                byRow.set(m.row, [m]);
-        }
-        return byRow;
-    }
-    isWholeWordMatch(haystack, start, len) {
-        const before = start > 0 ? haystack[start - 1] : '';
-        const after = start + len < haystack.length ? haystack[start + len] : '';
-        const isWordChar = (ch) => /[0-9A-Za-z_]/.test(ch);
-        if (before && isWordChar(before))
-            return false;
-        if (after && isWordChar(after))
-            return false;
-        return true;
-    }
-    applySearchMatch(match) {
-        const t = this.terminal;
-        if (!t)
-            return;
-        const scrollbackLen = typeof t.getScrollbackLength === 'function' ? t.getScrollbackLength() : 0;
-        const rows = typeof t.rows === 'number' ? t.rows : 24;
-        // Center the match line in viewport when possible.
-        const desiredTop = match.row >= scrollbackLen ? scrollbackLen : Math.max(0, Math.min(scrollbackLen, match.row - Math.floor(rows / 2)));
-        const viewportY = Math.max(0, Math.min(scrollbackLen, scrollbackLen - desiredTop));
-        if (typeof t.scrollToLine === 'function')
-            t.scrollToLine(viewportY);
-        const sm = t?.selectionManager;
-        const startCol = Math.max(0, match.col);
-        const endCol = Math.max(startCol, startCol + Math.max(1, match.len) - 1);
-        if (sm) {
-            this.patchSearchSelectionManager(sm);
-            sm.__floeterm_searchAllowSingleCellSelection = true;
-            sm.markCurrentSelectionDirty?.();
-            sm.selectionStart = { col: startCol, absoluteRow: match.row };
-            sm.selectionEnd = { col: endCol, absoluteRow: match.row };
-            sm.markCurrentSelectionDirty?.();
-            sm.selectionChangedEmitter?.fire?.();
-            // @floegence/ghostty-web 不会因为 selection change 自动触发 render；主动刷新以保证 UI（按钮/快捷键）操作立即可见。
-            this.forceFullRender();
-            return;
-        }
-        // Fallback: select within viewport row (may fail for scrollback).
-        const viewportRow = Math.max(0, Math.min(rows - 1, Math.floor(rows / 2)));
-        if (typeof t.select === 'function') {
-            t.select(startCol, viewportRow, Math.max(1, match.len));
-            // 同上：确保当前匹配的 selection 颜色立即显示。
-            this.forceFullRender();
-        }
-    }
-    clearActiveSearchSelection() {
-        const t = this.terminal;
-        const sm = t?.selectionManager;
-        if (sm) {
-            sm.__floeterm_searchAllowSingleCellSelection = false;
-        }
-        if (t?.clearSelection) {
-            try {
-                t.clearSelection();
-            }
-            catch {
-            }
-        }
-        // @floegence/ghostty-web 不会因为 clearSelection 自动触发 render；主动刷新以清除残留高亮。
-        this.forceFullRender();
-    }
-    patchSearchSelectionManager(sm) {
-        if (!sm || sm.__floeterm_searchPatched)
-            return;
-        const original = typeof sm.hasSelection === 'function' ? sm.hasSelection.bind(sm) : null;
-        if (!original)
-            return;
-        sm.__floeterm_searchPatched = true;
-        sm.__floeterm_searchAllowSingleCellSelection = false;
-        sm.hasSelection = () => {
-            // Keep original mouse selection semantics, but allow a single-cell selection for search.
-            if (sm.__floeterm_searchAllowSingleCellSelection && sm.selectionStart && sm.selectionEnd)
-                return true;
-            return original();
-        };
-    }
-    ensureSearchTheme() {
-        if (!this.terminal)
-            return;
-        if (this.searchThemeRestore)
-            return;
-        const terminalAny = this.terminal;
-        const rendererTheme = terminalAny?.renderer?.theme;
-        const base = rendererTheme && typeof rendererTheme === 'object' ? { ...rendererTheme } : mapThemeToGhostty(this.config.theme);
-        this.searchThemeRestore = { ...base };
-        const themed = this.applySearchThemeOverride(base);
-        this.applyRendererTheme(terminalAny, themed);
-    }
-    restoreSearchTheme() {
-        if (!this.terminal)
-            return;
-        if (!this.searchThemeRestore)
-            return;
-        const terminalAny = this.terminal;
-        const restore = this.searchThemeRestore;
-        this.searchThemeRestore = null;
-        this.applyRendererTheme(terminalAny, restore);
-        this.forceFullRender();
-    }
-    applySearchThemeOverride(theme) {
-        return {
-            ...theme,
-            selectionBackground: TERMINAL_SEARCH_ACTIVE_BACKGROUND,
-            selectionForeground: TERMINAL_SEARCH_ACTIVE_FOREGROUND,
-            selection: TERMINAL_SEARCH_ACTIVE_BACKGROUND
-        };
-    }
-    applyRendererTheme(terminalAny, theme) {
-        // @floegence/ghostty-web emits a warning when mutating options.theme after open().
-        // Apply theme directly to the renderer to avoid noisy console output.
-        if (!terminalAny.isOpen && this.terminal) {
-            this.terminal.options.theme = theme;
-        }
-        terminalAny.renderer?.setTheme?.(theme);
-        this.fabricView?.renderer.setAppearance({ theme });
-        if (this.isVisualRenderSuspended()) {
-            this.markPendingDemandRender(true);
-            return;
-        }
-        if (terminalAny.renderer?.render && terminalAny.wasmTerm) {
-            try {
-                terminalAny.renderer.render(terminalAny.wasmTerm, true, terminalAny.viewportY ?? 0, terminalAny, terminalAny.scrollbarOpacity);
-            }
-            catch (error) {
-                this.logger.debug('[TerminalCore] Theme render failed', { error });
-            }
-        }
-    }
-    captureRenderSnapshot() {
-        const terminalAny = this.terminal;
-        if (!terminalAny) {
-            return null;
-        }
-        const cursor = terminalAny.wasmTerm?.getCursor?.();
-        const cursorY = Number(cursor?.y);
-        const rows = Number(terminalAny.rows);
-        const scrollbackLength = (() => {
-            if (typeof terminalAny.getScrollbackLength === 'function') {
-                return Number(terminalAny.getScrollbackLength.call(terminalAny));
-            }
-            if (typeof terminalAny.wasmTerm?.getScrollbackLength === 'function') {
-                return Number(terminalAny.wasmTerm.getScrollbackLength.call(terminalAny.wasmTerm));
-            }
-            return Number.NaN;
-        })();
-        const viewportY = Number(terminalAny.viewportY ?? 0);
-        return {
-            cursorY: Number.isFinite(cursorY) ? cursorY : null,
-            rows: Number.isFinite(rows) ? rows : null,
-            scrollbackLength: Number.isFinite(scrollbackLength) ? scrollbackLength : null,
-            viewportY: Number.isFinite(viewportY) ? viewportY : null,
-        };
-    }
-    shouldForceFullRenderAfterWrite(before) {
-        if (!before) {
-            return false;
-        }
-        const after = this.captureRenderSnapshot();
-        if (!after) {
-            return false;
-        }
-        if (before.viewportY !== null
-            && after.viewportY !== null
-            && before.viewportY !== after.viewportY) {
-            return true;
-        }
-        if (before.scrollbackLength !== null
-            && after.scrollbackLength !== null
-            && before.scrollbackLength !== after.scrollbackLength) {
-            return true;
-        }
-        return Boolean(before.cursorY !== null
-            && after.cursorY !== null
-            && before.rows !== null
-            && before.cursorY >= before.rows - 1
-            && after.cursorY < before.cursorY);
-    }
-    ensureSearchOverlaySubscriptions() {
-        const t = this.terminal;
-        if (!t)
-            return;
-        if (this.searchOverlayUnsubs.length > 0)
-            return;
-        // Keep overlay synced with scroll/resize.
-        const onScroll = typeof t.onScroll === 'function' ? t.onScroll(() => this.scheduleRenderSearchOverlay()) : null;
-        if (onScroll?.dispose)
-            this.searchOverlayUnsubs.push(() => onScroll.dispose());
-        const onResize = typeof t.onResize === 'function' ? t.onResize(() => this.scheduleRenderSearchOverlay()) : null;
-        if (onResize?.dispose)
-            this.searchOverlayUnsubs.push(() => onResize.dispose());
-    }
-    disposeSearchOverlaySubscriptions() {
-        for (const unsub of this.searchOverlayUnsubs)
-            unsub();
-        this.searchOverlayUnsubs = [];
-    }
-    disposeSearchOverlay() {
-        if (this.searchOverlayRaf !== null) {
-            cancelAnimationFrame(this.searchOverlayRaf);
-            this.searchOverlayRaf = null;
-        }
-        this.disposeSearchOverlaySubscriptions();
-        if (this.searchOverlay?.canvas?.parentElement) {
-            this.searchOverlay.canvas.parentElement.removeChild(this.searchOverlay.canvas);
-        }
-        this.searchOverlay = null;
-    }
-    createCanvasOverlay(zIndex) {
-        const t = this.terminal;
-        if (!t)
-            return null;
-        const renderer = t?.renderer;
-        const termCanvas = renderer?.getCanvas?.();
-        if (!termCanvas)
-            return null;
-        try {
-            const style = getComputedStyle(this.container);
-            if (style.position === 'static')
-                this.container.style.position = 'relative';
-        }
-        catch {
-        }
-        const overlay = document.createElement('canvas');
-        overlay.style.position = 'absolute';
-        overlay.style.top = '0';
-        overlay.style.left = '0';
-        overlay.style.pointerEvents = 'none';
-        overlay.style.zIndex = zIndex;
-        overlay.style.mixBlendMode = 'normal';
-        const ctx = overlay.getContext('2d');
-        if (!ctx)
-            return null;
-        this.container.appendChild(overlay);
-        const state = {
-            canvas: overlay,
-            ctx,
-            dpr: 1,
-            cssWidth: 0,
-            cssHeight: 0,
-            termCanvas,
-        };
-        syncCanvasOverlaySize(state, termCanvas, this.container);
-        return state;
-    }
-    ensureSearchOverlay() {
-        const t = this.terminal;
-        if (!t)
-            return null;
-        const renderer = t?.renderer;
-        const termCanvas = renderer?.getCanvas?.();
-        if (!termCanvas)
-            return null;
-        // Ensure we have a positioning context.
-        try {
-            const style = getComputedStyle(this.container);
-            if (style.position === 'static')
-                this.container.style.position = 'relative';
-        }
-        catch {
-        }
-        if (this.searchOverlay && this.searchOverlay.termCanvas !== termCanvas) {
-            this.disposeSearchOverlay();
-        }
-        if (!this.searchOverlay) {
-            this.searchOverlay = this.createCanvasOverlay('5');
-        }
-        if (this.searchOverlay) {
-            syncCanvasOverlaySize(this.searchOverlay, termCanvas, this.container);
-        }
-        return this.searchOverlay;
-    }
-    scheduleRenderSearchOverlay() {
-        if (this.isVisualRenderSuspended()) {
-            this.visualRenderState.pendingSearchOverlayRender = true;
-            return;
-        }
-        if (this.searchOverlayRaf !== null)
-            return;
-        this.searchOverlayRaf = requestAnimationFrame(() => {
-            this.searchOverlayRaf = null;
-            this.renderSearchOverlay();
-        });
-    }
-    renderSearchOverlay() {
-        const t = this.terminal;
-        const queryActive = this.searchQuery.trim().length > 0;
-        const rowIndex = this.searchRowIndex;
-        if (!queryActive || rowIndex.size === 0 || !t) {
-            this.searchOverlay?.ctx.clearRect(0, 0, this.searchOverlay.cssWidth, this.searchOverlay.cssHeight);
-            return;
-        }
-        const overlay = this.ensureSearchOverlay();
-        if (!overlay)
-            return;
-        const renderer = t?.renderer;
-        const charW = typeof renderer?.charWidth === 'number' ? renderer.charWidth : 0;
-        const charH = typeof renderer?.charHeight === 'number' ? renderer.charHeight : 0;
-        const cols = typeof t.cols === 'number' ? t.cols : 0;
-        const rows = typeof t.rows === 'number' ? t.rows : 0;
-        const scrollbackLen = typeof t.getScrollbackLength === 'function' ? t.getScrollbackLength() : 0;
-        const viewportY = Math.max(0, Math.floor(typeof t.getViewportY === 'function' ? t.getViewportY() : t.viewportY ?? 0));
-        const viewportTop = Math.max(0, scrollbackLen - viewportY);
-        if (charW <= 0 || charH <= 0 || cols <= 0 || rows <= 0) {
-            overlay.ctx.clearRect(0, 0, overlay.cssWidth, overlay.cssHeight);
-            return;
-        }
-        overlay.ctx.clearRect(0, 0, overlay.cssWidth, overlay.cssHeight);
-        overlay.ctx.fillStyle = TERMINAL_SEARCH_MATCH_BACKGROUND;
-        for (let y = 0; y < rows; y += 1) {
-            const absRow = viewportTop + y;
-            const list = rowIndex.get(absRow);
-            if (!list || list.length === 0)
-                continue;
-            for (const m of list) {
-                const col = Math.max(0, Math.min(cols - 1, m.col));
-                const maxLen = Math.max(0, cols - col);
-                const len = Math.max(0, Math.min(maxLen, m.len));
-                if (len <= 0)
-                    continue;
-                overlay.ctx.fillRect(col * charW, y * charH, len * charW, charH);
-            }
-        }
-    }
-    focus(options) {
-        this.terminal?.focus();
-        this.focusInputSurface(options);
-        this.scheduleInputSurfaceRefocus(options);
-    }
-    setConnected(isConnected) {
-        this.setState(isConnected ? TerminalState.CONNECTED : TerminalState.READY);
-        if (isConnected) {
-            this.scheduleFabricRendererAttach();
-        }
-    }
-    forceResize() {
-        this.flushPendingPresentationScale();
-        this.performResize('force');
-        this.requestDemandRender(true);
-    }
-    /**
-     * Measures the host capacity without changing the currently rendered PTY grid.
-     * This is used by active shared-geometry views before an explicit transport resize.
-     */
-    measureHostDimensions() {
-        if (!this.isReady() || !this.terminal) {
-            return undefined;
-        }
-        return this.proposeFitDimensions();
-    }
-    async forceResizeAndWaitForPresentation() {
-        while (true) {
-            const fontMetricSeq = await this.waitForStableFontMetrics();
-            await this.requestPresentationFrame();
-            await this.waitForStableFontMetrics();
-            if (fontMetricSeq === this.fontMetricSeq) {
-                return;
-            }
-        }
-    }
-    /**
-     * Forces a resize and waits until the terminal renderer has committed a full frame.
-     * Unlike {@link forceResizeAndWaitForPresentation}, this does not wait for the
-     * following browser paint frame.
-     */
-    async forceResizeAndWaitForCommittedFrame() {
-        if (this.isDisposed) {
-            throw new Error('Cannot present a disposed TerminalCore');
-        }
-        if (!this.terminal || !this.isReady()) {
-            throw new Error('Cannot present a TerminalCore before initialization completes');
-        }
-        await new Promise((resolve, reject) => {
-            const request = {
-                baselineGeneration: this.committedFabricFrameGeneration,
-                frameHandle: null,
-                resolve: () => {
-                    this.committedFrameRequests.delete(request);
-                    resolve();
-                },
-                reject: error => {
-                    this.committedFrameRequests.delete(request);
-                    reject(error);
-                },
-            };
-            this.committedFrameRequests.add(request);
-            const start = () => {
-                if (this.isDisposed) {
-                    this.rejectCommittedFrameRequest(request, new Error('TerminalCore was disposed before the committed frame completed'));
-                    return;
-                }
-                if (this.config.rendererType === 'webgl' && !this.isFabricRendererActive()) {
-                    void this.waitForFabricRendererAttach().then(() => {
-                        if (this.isDisposed) {
-                            this.rejectCommittedFrameRequest(request, new Error('TerminalCore was disposed before the committed frame completed'));
-                        }
-                        else {
-                            this.forceCommittedFrame(request);
-                            this.scheduleCommittedFrameCheck(request);
-                        }
-                    }).catch(error => this.rejectCommittedFrameRequest(request, error instanceof Error ? error : new Error(String(error))));
-                    return;
-                }
-                this.forceCommittedFrame(request);
-                this.scheduleCommittedFrameCheck(request);
-            };
-            start();
-        });
-    }
-    forceCommittedFrame(request) {
-        this.forceResize();
-        if (!this.committedFrameRequests.has(request)
-            || this.config.rendererType !== 'webgl'
-            || !this.isFabricRendererActive()
-            || this.isVisualRenderSuspended()) {
-            return;
-        }
-        // A committed-frame fence is an explicit interactive presentation request.
-        // Render it in this task so shared background RAF work cannot add a frame of
-        // queueing latency; the full frame subsumes this core's pending demand render.
-        terminalRenderScheduler.cancel(this.renderTask);
-        this.demandRenderForceAll = false;
-        this.renderDemandFrame(true);
-    }
-    requestPresentationFrame() {
-        if (this.isDisposed) {
-            return Promise.reject(new Error('Cannot present a disposed TerminalCore'));
-        }
-        if (!this.terminal || !this.isReady()) {
-            return Promise.reject(new Error('Cannot present a TerminalCore before initialization completes'));
-        }
-        if (this.config.rendererType === 'webgl' && !this.isFabricRendererActive()) {
-            return this.waitForFabricRendererAttach().then(() => {
-                if (this.isDisposed)
-                    throw new Error('TerminalCore was disposed before presentation started');
-                this.forceResize();
-                return this.createPresentationRequest();
-            });
-        }
-        return this.createPresentationRequest();
-    }
-    createPresentationRequest() {
-        if (this.pendingPresentationRequest) {
-            this.forceResize();
-            return this.pendingPresentationRequest.promise;
-        }
-        let resolve;
-        let reject;
-        const promise = new Promise((resolvePromise, rejectPromise) => {
-            resolve = resolvePromise;
-            reject = rejectPromise;
-        });
-        const request = { promise, resolve, reject, frameHandle: null };
-        this.pendingPresentationRequest = request;
-        this.presentationRequests.add(request);
-        this.forceResize();
-        return promise;
-    }
-    setFixedDimensions(dimensions, options) {
-        const next = normalizeTerminalDimensions(dimensions);
-        if (sameTerminalDimensions(this.fixedDimensions, next) || (!this.fixedDimensions && !next)) {
-            return;
-        }
-        this.fixedDimensions = next;
-        this.config = { ...this.config, fixedDimensions: next };
-        if (!this.terminal) {
-            return;
-        }
-        const previousSuppression = this.suppressResizeNotifications;
-        if (options?.notifyResize === false) {
-            this.suppressResizeNotifications = true;
-        }
-        try {
-            this.forceResize();
-        }
-        finally {
-            this.suppressResizeNotifications = previousSuppression;
-        }
-    }
-    setAppearance(appearance) {
-        if (!appearance || typeof appearance !== 'object') {
-            return;
-        }
-        if (appearance.theme) {
-            this.setTheme(appearance.theme);
-        }
-        if (typeof appearance.fontSize === 'number') {
-            this.setFontSize(appearance.fontSize);
-        }
-        if (typeof appearance.fontFamily === 'string') {
-            this.setFontFamily(appearance.fontFamily);
-        }
-        if (typeof appearance.presentationScale === 'number') {
-            this.setPresentationScale(appearance.presentationScale);
-        }
-    }
-    setScrollbarOptions(options) {
-        normalizeTerminalScrollbarOptions(options);
-        const next = normalizeTerminalScrollbarOptions({ ...this.scrollbarOptions, ...options });
-        this.scrollbarOptions = next;
-        this.config = { ...this.config, scrollbar: next };
-        this.scrollbarOverlay?.setOptions(next);
-    }
-    setTheme(theme) {
-        const mapped = mapThemeToGhostty(theme);
-        // Persist latest theme so a future re-initialization can reuse it.
-        this.config = { ...this.config, theme: mapped };
-        this.themeColorTranslator = buildThemeColorTranslator(this.terminalThemeSource, mapped);
-        this.scrollbarOverlay?.setBackgroundColor(mapped.background);
-        if (!this.terminal) {
-            return;
-        }
-        const terminalAny = this.terminal;
-        // If search is active, apply the theme but keep the search selection colors.
-        if (this.searchQuery.trim().length > 0) {
-            this.searchThemeRestore = { ...mapped };
-            this.applyRendererTheme(terminalAny, this.applySearchThemeOverride(mapped));
-            this.scheduleRenderSearchOverlay();
-            return;
-        }
-        this.applyRendererTheme(terminalAny, mapped);
-    }
-    setFontSize(size) {
-        this.logicalFontSize = TerminalCore.normalizeFontSize(size);
-        this.config = { ...this.config, fontSize: this.logicalFontSize };
-        if (!this.terminal) {
-            return;
-        }
-        this.terminal.options.fontSize = this.resolveEffectiveFontSize();
-        this.fabricView?.renderer.setAppearance({ fontSize: this.resolveEffectiveFontSize() });
-        this.performResize('font');
-        void this.refreshFontMetricsAfterLoad('font_size');
-    }
-    setPresentationScale(scale) {
-        const nextScale = TerminalCore.normalizePresentationScale(scale);
-        const currentTargetScale = this.pendingPresentationScale ?? this.presentationScale;
-        if (samePresentationScale(nextScale, currentTargetScale)) {
-            return;
-        }
-        this.pendingPresentationScale = nextScale;
-        this.config = { ...this.config, presentationScale: nextScale };
-        this.applyPresentationScaleStyles();
-        if (typeof window === 'undefined') {
-            this.commitPresentationScale(nextScale);
-            return;
-        }
-        if (this.presentationScaleRaf !== null) {
-            return;
-        }
-        this.presentationScaleRaf = window.requestAnimationFrame(() => {
-            this.presentationScaleRaf = null;
-            const targetScale = this.pendingPresentationScale ?? this.presentationScale;
-            this.pendingPresentationScale = null;
-            this.commitPresentationScale(targetScale);
-        });
-    }
-    setFontFamily(family) {
-        const nextFamily = String(family ?? '').trim();
-        if (!nextFamily) {
-            return;
-        }
-        this.config = { ...this.config, fontFamily: nextFamily };
-        if (!this.terminal) {
-            return;
-        }
-        this.terminal.options.fontFamily = nextFamily;
-        this.fabricView?.renderer.setAppearance({
-            fontFamily: nextFamily,
-            fontSize: this.resolveEffectiveFontSize(),
-        });
-        this.performResize('font');
-        this.forceFullRender();
-        void this.refreshFontMetricsAfterLoad('font_family');
-    }
-    beginVisualSuspend(options = {}) {
-        const id = this.visualRenderState.nextSuspendId;
-        this.visualRenderState.nextSuspendId += 1;
-        const reason = options.reason ?? 'external';
-        let disposed = false;
-        this.visualRenderState.suspendDepth += 1;
-        this.visualRenderState.activeReasons.set(id, reason);
-        // Legacy compatibility: keep the handle lifecycle observable, but never
-        // freeze visible terminal rendering in the live fabric path.
-        this.visualRenderState.suspendDepth = Math.max(0, this.visualRenderState.suspendDepth - 1);
-        return {
-            id,
-            reason,
-            dispose: () => {
-                if (disposed) {
-                    return;
-                }
-                disposed = true;
-                this.endVisualSuspend(id);
-            },
-        };
-    }
-    registerLinkProvider(provider) {
-        if (!provider || this.registeredLinkProviders.has(provider)) {
-            return;
-        }
-        this.registeredLinkProviders.add(provider);
-        this.applyRegisteredLinkProviders();
-    }
-    dispose() {
-        this.isDisposed = true;
-        const disposalError = new Error('TerminalCore was disposed before presentation completed');
-        this.rejectFabricAttachWaiters(disposalError);
-        this.rejectAllPresentationRequests(disposalError);
-        this.initializationOperation?.lifecycleAbortController.abort();
-        this.initializationOperation?.request.cancel();
-        if (this.focusResizeRaf !== null) {
-            cancelAnimationFrame(this.focusResizeRaf);
-            this.focusResizeRaf = null;
-        }
-        if (this.presentationScaleRaf !== null) {
-            cancelAnimationFrame(this.presentationScaleRaf);
-            this.presentationScaleRaf = null;
-        }
-        if (this.clearResizeSuppressionRaf !== null) {
-            cancelAnimationFrame(this.clearResizeSuppressionRaf);
-            this.clearResizeSuppressionRaf = null;
-        }
-        if (this.resizeRaf !== null) {
-            cancelAnimationFrame(this.resizeRaf);
-            this.resizeRaf = null;
-        }
-        this.cancelDemandRender();
-        this.unbindResponsiveListeners?.();
-        this.unbindResponsiveListeners = null;
-        this.resizeObserver?.disconnect();
-        this.resizeObserver = null;
-        if (this.resizeDebounceTimer) {
-            clearTimeout(this.resizeDebounceTimer);
-            this.resizeDebounceTimer = null;
-        }
-        this.visualRenderState.suspendDepth = 0;
-        this.visualRenderState.activeReasons.clear();
-        this.visualRenderState.pendingDemandRender = false;
-        this.visualRenderState.pendingForceFullRender = false;
-        this.visualRenderState.pendingResizeReason = null;
-        this.visualRenderState.pendingSearchOverlayRender = false;
-        if (this.replayingHistoryTimer) {
-            clearTimeout(this.replayingHistoryTimer);
-            this.replayingHistoryTimer = null;
-        }
-        this.disposeInputBridge();
-        this.disposeTerminalEventListeners();
-        this.disposeSearchOverlay();
-        this.scrollbarOverlay?.dispose();
-        this.scrollbarOverlay = null;
-        this.fabricAttachSeq += 1;
-        this.cancelFabricAttachSchedule?.();
-        this.cancelFabricAttachSchedule = null;
-        this.cancelInputRefocusSchedule?.();
-        this.cancelInputRefocusSchedule = null;
-        this.fabricView?.dispose();
-        this.fabricView = null;
-        this.terminal?.dispose();
-        this.terminal = null;
-        this.ownedRuntimeMemory = null;
-        this.ownedRuntime = null;
-        this.inputElement?.remove();
-        this.inputElement = null;
-        this.viewportHost?.remove();
-        this.viewportHost = null;
-        this.renderHost = null;
-        this.fitAddon = null;
-        this.registeredLinkProviders.clear();
-        this.appliedLinkProviders.clear();
-        this.setState(TerminalState.DISPOSED);
-    }
-    disposeInputBridge() {
-        this.inputBridge?.dispose();
-        this.inputBridge = null;
-    }
-    disposeTerminalEventListeners() {
-        for (const dispose of this.terminalEventDisposables) {
-            dispose();
-        }
-        this.terminalEventDisposables = [];
-    }
-    trackTerminalEventDisposable(disposable) {
-        if (!disposable?.dispose) {
-            return;
-        }
-        this.terminalEventDisposables.push(() => disposable.dispose?.());
-    }
-    applyRegisteredLinkProviders() {
-        if (!this.terminal || typeof this.terminal.registerLinkProvider !== 'function') {
-            return;
-        }
-        for (const provider of this.registeredLinkProviders) {
-            if (this.appliedLinkProviders.has(provider)) {
-                continue;
-            }
-            try {
-                this.terminal.registerLinkProvider(provider);
-                this.appliedLinkProviders.add(provider);
-            }
-            catch (error) {
-                this.logger.warn('[TerminalCore] Failed to register link provider', { error });
-            }
-        }
-    }
-    static normalizeResponsiveConfig(value) {
-        const raw = (typeof value === 'object' && value) ? value : {};
-        return {
-            fitOnFocus: Boolean(raw.fitOnFocus),
-            emitResizeOnFocus: Boolean(raw.emitResizeOnFocus),
-            notifyResizeOnlyWhenFocused: Boolean(raw.notifyResizeOnlyWhenFocused),
-            reportHostDimensionsWithFixedGrid: Boolean(raw.reportHostDimensionsWithFixedGrid),
-        };
-    }
-    static normalizeClipboardConfig(value) {
-        const raw = (typeof value === 'object' && value) ? value : {};
-        return {
-            copyOnSelect: raw.copyOnSelect !== false,
-        };
-    }
-    static normalizeFitConfig(value) {
-        const raw = (typeof value === 'object' && value) ? value : {};
-        return {
-            scrollbarReservePx: normalizeNonNegativePixels(raw.scrollbarReservePx, GHOSTTY_DEFAULT_SCROLLBAR_RESERVE_PX),
-        };
-    }
-    static normalizeFontSize(value) {
-        const size = Number(value);
-        if (!Number.isFinite(size) || size <= 0) {
-            return 12;
-        }
-        return size;
-    }
-    static normalizePresentationScale(value) {
-        const scale = Number(value);
-        if (!Number.isFinite(scale) || scale <= 1.001) {
-            return 1;
-        }
-        return Math.min(scale, 4);
-    }
-    resolveEffectiveFontSize(scale = this.pendingPresentationScale ?? this.presentationScale) {
-        return Math.max(1, this.logicalFontSize * scale);
-    }
-    isVisualRenderSuspended() {
-        return this.visualRenderState.suspendDepth > 0;
-    }
-    markPendingDemandRender(forceAll) {
-        this.visualRenderState.pendingDemandRender = true;
-        this.visualRenderState.pendingForceFullRender = this.visualRenderState.pendingForceFullRender || forceAll;
-        this.demandRenderForceAll = this.demandRenderForceAll || forceAll;
-    }
-    markPendingResize(reason) {
-        this.visualRenderState.pendingResizeReason = this.mergePendingResizeReason(this.visualRenderState.pendingResizeReason, reason);
-    }
-    mergePendingResizeReason(current, next) {
-        if (!current) {
-            return next;
-        }
-        if (current === 'force' || next === 'force') {
-            return 'force';
-        }
-        if (current === 'font' || next === 'font') {
-            return 'font';
-        }
-        if (current === 'focus' || next === 'focus') {
-            return 'focus';
-        }
-        if (current === 'post_init' || next === 'post_init') {
-            return 'post_init';
-        }
-        return 'observer';
-    }
-    endVisualSuspend(id) {
-        if (!this.visualRenderState.activeReasons.has(id)) {
-            return;
-        }
-        this.visualRenderState.activeReasons.delete(id);
-        this.visualRenderState.suspendDepth = Math.max(0, this.visualRenderState.suspendDepth - 1);
-        if (this.visualRenderState.suspendDepth > 0) {
-            return;
-        }
-        this.flushDeferredVisualWork();
-    }
-    flushDeferredVisualWork() {
-        if (this.isDisposed || !this.terminal) {
-            return;
-        }
-        const resizeReason = this.visualRenderState.pendingResizeReason;
-        const shouldRender = this.visualRenderState.pendingDemandRender || this.demandRenderForceAll;
-        const shouldForceRender = this.visualRenderState.pendingForceFullRender || this.demandRenderForceAll;
-        const shouldRenderSearchOverlay = this.visualRenderState.pendingSearchOverlayRender;
-        this.visualRenderState.pendingResizeReason = null;
-        this.visualRenderState.pendingDemandRender = false;
-        this.visualRenderState.pendingForceFullRender = false;
-        this.visualRenderState.pendingSearchOverlayRender = false;
-        this.demandRenderForceAll = false;
-        if (resizeReason) {
-            this.performResizeNow(resizeReason);
-        }
-        if (shouldRender) {
-            this.requestDemandRender(shouldForceRender);
-        }
-        if (shouldRenderSearchOverlay) {
-            this.scheduleRenderSearchOverlay();
-        }
-    }
-    flushPendingPresentationScale() {
-        if (this.pendingPresentationScale === null) {
-            return;
-        }
-        const targetScale = this.pendingPresentationScale;
-        this.pendingPresentationScale = null;
-        if (this.presentationScaleRaf !== null) {
-            cancelAnimationFrame(this.presentationScaleRaf);
-            this.presentationScaleRaf = null;
-        }
-        this.commitPresentationScale(targetScale);
-    }
-    commitPresentationScale(scale) {
-        const nextScale = TerminalCore.normalizePresentationScale(scale);
-        if (samePresentationScale(nextScale, this.presentationScale)) {
-            this.applyPresentationScaleStyles();
-            return;
-        }
-        this.presentationScale = nextScale;
-        this.applyPresentationScaleStyles();
-        if (!this.terminal) {
-            return;
-        }
-        this.suppressResizeNotifications = true;
-        if (this.clearResizeSuppressionRaf !== null) {
-            cancelAnimationFrame(this.clearResizeSuppressionRaf);
-        }
-        this.clearResizeSuppressionRaf = requestAnimationFrame(() => {
-            this.clearResizeSuppressionRaf = null;
-            this.suppressResizeNotifications = false;
-        });
-        this.terminal.options.fontSize = this.resolveEffectiveFontSize(nextScale);
-        this.fabricView?.renderer.setAppearance({ fontSize: this.resolveEffectiveFontSize(nextScale) });
-        if (this.isVisualRenderSuspended()) {
-            this.markPendingResize('force');
-            this.markPendingDemandRender(true);
-            this.scheduleRenderSearchOverlay();
-            return;
-        }
-        this.performResize('force');
-        this.forceFullRender();
-        this.scheduleRenderSearchOverlay();
-    }
-    resizeFabricToHost() {
-        const host = this.renderHost ?? this.container;
-        if (!host) {
-            return;
-        }
-        const width = host.clientWidth;
-        const height = host.clientHeight;
-        if (width <= 0 || height <= 0) {
-            return;
-        }
-        this.fabricView?.renderer.resize(width, height);
-        this.syncGhosttyInputGeometryToFabric();
-    }
-    isFabricRendererActive() {
-        return Boolean(this.fabricView?.renderer.isActive());
-    }
-    forceFullRender() {
-        if (!this.terminal || !this.isReady()) {
-            return;
-        }
-        if (this.isVisualRenderSuspended()) {
-            this.markPendingDemandRender(true);
-            return;
-        }
-        this.renderDemandFrame(true);
-    }
-    requestDemandRender(forceAll) {
-        if (!this.terminal || this.isDisposed) {
-            return;
-        }
-        if (this.isVisualRenderSuspended()) {
-            this.markPendingDemandRender(forceAll);
-            return;
-        }
-        this.demandRenderForceAll = this.demandRenderForceAll || forceAll;
-        terminalRenderScheduler.schedule(this.renderTask, this.demandRenderForceAll);
-    }
-    cancelDemandRender() {
-        terminalRenderScheduler.cancel(this.renderTask);
-        this.demandRenderForceAll = false;
-        this.stopGhosttyRenderLoop();
-    }
-    stopGhosttyRenderLoop() {
-        const terminalAny = this.terminal;
-        if (!terminalAny || typeof terminalAny.animationFrameId !== 'number') {
-            return;
-        }
-        cancelAnimationFrame(terminalAny.animationFrameId);
-        terminalAny.animationFrameId = undefined;
-    }
-    renderDemandFrame(forceAll) {
-        if (!this.terminal || this.isDisposed) {
-            return;
-        }
-        const terminalAny = this.terminal;
-        if (terminalAny.isDisposed || terminalAny.isOpen === false || !terminalAny.renderer?.render || !terminalAny.wasmTerm) {
-            return;
-        }
-        const presentationRequest = forceAll ? this.pendingPresentationRequest : null;
-        const expectedRows = Math.max(0, Math.floor(Number(terminalAny.wasmTerm.getDimensions?.().rows ?? 0)));
-        const fabricFrameGeneration = this.committedFabricFrameGeneration;
-        try {
-            const startedAt = performance.now();
-            this.keepDemandCursorVisible(terminalAny.renderer);
-            terminalAny.renderer.render(terminalAny.wasmTerm, forceAll, terminalAny.viewportY ?? 0, terminalAny, terminalAny.scrollbarOpacity);
-            this.settleCommittedFrameRequests();
-            const cursor = terminalAny.wasmTerm.getCursor?.();
-            if (cursor && typeof cursor.y === 'number' && cursor.y !== terminalAny.lastCursorY) {
-                terminalAny.lastCursorY = cursor.y;
-                terminalAny.cursorMoveEmitter?.fire?.();
-            }
-            this.syncImeInputAnchor();
-            this.scrollbarOverlay?.sync();
-            const durationMs = performance.now() - startedAt;
-            getPerfProbe()?.onTerminalRender?.(durationMs);
-            if (this.config.rendererType !== 'webgl'
-                || this.committedFabricFrameGeneration > fabricFrameGeneration) {
-                try {
-                    this.eventHandlers.onRender?.(durationMs);
-                }
-                catch (error) {
-                    this.logger.debug('[TerminalCore] onRender observer failed', { error });
-                }
-            }
-            if (presentationRequest && this.pendingPresentationRequest === presentationRequest) {
-                if (this.config.rendererType === 'webgl') {
-                    const committed = this.lastCommittedFabricFrame;
-                    if (!committed
-                        || committed.generation <= fabricFrameGeneration
-                        || expectedRows <= 0
-                        || committed.result.renderedRows !== expectedRows) {
-                        this.rejectPresentationRequest(presentationRequest, new Error('The forced Beamterm frame was incomplete '
-                            + `(expected_rows=${expectedRows} rendered_rows=${committed?.result.renderedRows ?? 0})`));
-                        return;
-                    }
-                    const fabricRenderer = this.fabricView?.renderer;
-                    if (!fabricRenderer) {
-                        throw new Error('The Beamterm renderer detached before its frame completed');
-                    }
-                    fabricRenderer.finishSubmittedFrame();
-                    this.submittedFabricFrameGeneration = committed.generation;
-                }
-                this.pendingPresentationRequest = null;
-                presentationRequest.frameHandle = requestAnimationFrame(() => {
-                    if (!this.presentationRequests.has(presentationRequest))
-                        return;
-                    if (!this.presentationRequests.delete(presentationRequest))
-                        return;
-                    presentationRequest.frameHandle = null;
-                    presentationRequest.resolve();
-                });
-            }
-        }
-        catch (error) {
-            if (presentationRequest && this.presentationRequests.has(presentationRequest)) {
-                this.rejectPresentationRequest(presentationRequest, error instanceof Error ? error : new Error(String(error)));
-            }
-            this.logger.debug('[TerminalCore] Force render failed', { error });
-        }
-    }
-    rejectPresentationRequest(request, error) {
-        if (!this.presentationRequests.delete(request))
-            return;
-        if (this.pendingPresentationRequest === request) {
-            this.pendingPresentationRequest = null;
-        }
-        if (request.frameHandle !== null) {
-            cancelAnimationFrame(request.frameHandle);
-            request.frameHandle = null;
-        }
-        request.reject(error);
-    }
-    scheduleCommittedFrameCheck(request) {
-        if (!this.committedFrameRequests.has(request) || request.frameHandle !== null)
-            return;
-        queueMicrotask(() => {
-            if (!this.committedFrameRequests.has(request) || request.frameHandle !== null)
-                return;
-            request.frameHandle = requestAnimationFrame(() => {
-                request.frameHandle = null;
-                this.checkCommittedFrameRequest(request);
-            });
-        });
-    }
-    checkCommittedFrameRequest(request) {
-        if (!this.committedFrameRequests.has(request))
-            return;
-        if (this.isDisposed) {
-            this.rejectCommittedFrameRequest(request, new Error('TerminalCore was disposed before the committed frame completed'));
-            return;
-        }
-        if (this.config.rendererType !== 'webgl') {
-            this.resolveCommittedFrameRequest(request);
-            return;
-        }
-        if (this.committedFabricFrameGeneration > request.baselineGeneration) {
-            this.settleCommittedFrameRequests();
-            return;
-        }
-        this.scheduleCommittedFrameCheck(request);
-    }
-    settleCommittedFrameRequests() {
-        const ready = [...this.committedFrameRequests].filter(request => this.committedFabricFrameGeneration > request.baselineGeneration);
-        if (ready.length === 0)
-            return;
-        try {
-            if (this.submittedFabricFrameGeneration < this.committedFabricFrameGeneration) {
-                this.fabricView?.renderer.finishSubmittedFrame();
-                this.submittedFabricFrameGeneration = this.committedFabricFrameGeneration;
-            }
-            for (const request of ready)
-                this.resolveCommittedFrameRequest(request);
-        }
-        catch (error) {
-            const failure = error instanceof Error ? error : new Error(String(error));
-            for (const request of ready)
-                this.rejectCommittedFrameRequest(request, failure);
-        }
-    }
-    resolveCommittedFrameRequest(request) {
-        if (!this.committedFrameRequests.has(request))
-            return;
-        if (request.frameHandle !== null) {
-            cancelAnimationFrame(request.frameHandle);
-            request.frameHandle = null;
-        }
-        request.resolve();
-    }
-    rejectCommittedFrameRequest(request, error) {
-        if (!this.committedFrameRequests.delete(request))
-            return;
-        if (request.frameHandle !== null) {
-            cancelAnimationFrame(request.frameHandle);
-            request.frameHandle = null;
-        }
-        request.reject(error);
-    }
-    rejectAllPresentationRequests(error) {
-        for (const request of [...this.presentationRequests]) {
-            this.rejectPresentationRequest(request, error);
-        }
-        for (const request of [...this.committedFrameRequests]) {
-            this.rejectCommittedFrameRequest(request, error);
-        }
-    }
-}
-TerminalCore.nextRenderTaskId = 1;
-//# sourceMappingURL=TerminalCore.js.map