@floegence/floeterm-terminal-web 0.14.0 → 0.15.0

package/dist/manager/TerminalInstanceController.js

@@ -1,1076 +0,0 @@
-import { TerminalCore } from '../core/TerminalCore.js';
-import { SequenceBuffer } from '../internal/SequenceBuffer.js';
-import { createTerminalError } from '../utils/errors.js';
-import { getDefaultTerminalConfig, getThemeColors } from '../utils/config.js';
-import { createConsoleLogger, noopLogger } from '../utils/logger.js';
-import { concatChunks } from '../utils/history.js';
-import { createGhosttyCheckpointActor } from '../checkpoint/GhosttyCheckpointActor.js';
-import { TerminalState, computeConnectionState, computeTerminalState, } from '../types.js';
-var ConnectionState;
-(function (ConnectionState) {
-    ConnectionState["IDLE"] = "idle";
-    ConnectionState["CONNECTING"] = "connecting";
-    ConnectionState["CONNECTED"] = "connected";
-    ConnectionState["DISCONNECTED"] = "disconnected";
-    ConnectionState["RETRYING"] = "retrying";
-    ConnectionState["FAILED"] = "failed";
-    ConnectionState["ABORTED"] = "aborted";
-})(ConnectionState || (ConnectionState = {}));
-const MAX_WRITE_BATCH_CHUNKS = 2048;
-const MAX_WRITE_BATCH_BYTES = 512 * 1024;
-const MAX_IMMEDIATE_LIVE_BATCH_BYTES = 256;
-const DEFAULT_CHECKPOINT_CAPTURE_BYTES = 4 * 1024 * 1024;
-const isAtomicTransport = (transport) => (typeof transport.attachWithHistoryBoundary === 'function'
-    && typeof transport.historyPage === 'function');
-const createDefaultScheduler = () => ({
-    requestFrame: callback => {
-        if (typeof requestAnimationFrame === 'function') {
-            return requestAnimationFrame(callback);
-        }
-        return setTimeout(() => callback(Date.now()), 0);
-    },
-    cancelFrame: id => {
-        if (typeof cancelAnimationFrame === 'function') {
-            cancelAnimationFrame(id);
-            return;
-        }
-        clearTimeout(id);
-    },
-    setTimer: (callback, delayMs) => setTimeout(callback, delayMs),
-    clearTimer: id => clearTimeout(id),
-});
-export class FrameworkNeutralTerminalInstanceController {
-    constructor(options) {
-        this.listeners = new Set();
-        this.container = null;
-        this.terminalCore = null;
-        this.isInitializing = false;
-        this.terminalDataUnsubscribe = null;
-        this.terminalGeometryUnsubscribe = null;
-        this.lastGeometryGeneration = 0;
-        this.pendingGeometryEvents = [];
-        this.checkpointActor = null;
-        this.checkpointActorTail = Promise.resolve();
-        this.checkpointBytesSinceCommit = 0;
-        this.checkpointActorGeneration = 0;
-        this.sequenceBuffer = new SequenceBuffer();
-        this.replayCompleteReceived = false;
-        this.isReplayActive = false;
-        this.lastAppliedSequence = 0;
-        this.loadingState = 'idle';
-        this.loadingMessage = '';
-        this.connectionState = ConnectionState.IDLE;
-        this.connectionError = null;
-        this.retryCount = 0;
-        this.connectGeneration = 0;
-        this.resizeGeneration = 0;
-        this.retryTimeout = null;
-        this.initializationAbortController = null;
-        this.queueRetryTimeout = null;
-        this.state = {
-            state: TerminalState.IDLE,
-            error: undefined,
-            dimensions: { cols: 80, rows: 24 }
-        };
-        this.dimensions = { cols: 80, rows: 24 };
-        this.dataQueue = [];
-        this.isProcessing = false;
-        this.queueGeneration = 0;
-        this.flushRaf = null;
-        this.flushMicrotaskScheduled = false;
-        this.flushMicrotaskGeneration = 0;
-        this.immediateFlushEligible = false;
-        this.disposed = false;
-        this.actions = {
-            write: data => {
-                const chunk = {
-                    data: new TextEncoder().encode(data),
-                    sequence: 0,
-                    timestampMs: Date.now()
-                };
-                this.addChunkToQueue(chunk);
-            },
-            clear: () => {
-                this.disposeCheckpointActor();
-                this.terminalCore?.clear();
-                this.dataQueue = [];
-                const sessionId = this.options.sessionId;
-                if (!sessionId) {
-                    return;
-                }
-                this.options.transport.clear(sessionId)
-                    .catch(error => this.logger.warn('[TerminalInstanceController] Clear history failed', { error }))
-                    .finally(() => {
-                    this.options.transport.sendInput(sessionId, '\r')
-                        .catch(error => this.logger.warn('[TerminalInstanceController] Clear redraw failed', { error }));
-                });
-            },
-            findNext: (term, options) => this.terminalCore?.findNext(term, options) ?? false,
-            findPrevious: (term, options) => this.terminalCore?.findPrevious(term, options) ?? false,
-            clearSearch: () => this.terminalCore?.clearSearch(),
-            serialize: () => this.terminalCore?.serialize() ?? '',
-            getSelectionText: () => this.terminalCore?.getSelectionText() ?? '',
-            hasSelection: () => this.terminalCore?.hasSelection() ?? false,
-            copySelection: source => this.terminalCore?.copySelection(source) ?? Promise.resolve({
-                copied: false,
-                reason: 'empty_selection',
-                source: source ?? 'command'
-            }),
-            setConnected: connected => this.terminalCore?.setConnected(connected),
-            forceResize: () => this.terminalCore?.forceResize(),
-            measureHostDimensions: () => this.terminalCore?.measureHostDimensions?.(),
-            setSearchResultsCallback: callback => this.terminalCore?.setSearchResultsCallback(callback),
-            focus: options => this.terminalCore?.focus(options),
-            getTerminalInfo: () => this.terminalCore?.getTerminalInfo() ?? null,
-            sendInput: data => this.handleUserInput(data),
-            setAppearance: appearance => this.applyCoreAppearance(appearance),
-            setTheme: theme => this.applyCoreAppearance({ themeName: theme }),
-            setFontSize: size => this.applyCoreAppearance({ fontSize: size }),
-            setPresentationScale: scale => this.applyCoreAppearance({ presentationScale: scale }),
-            reinitialize: () => this.reinitialize(),
-        };
-        this.handleStateChange = (newState) => {
-            this.updateState({ state: newState });
-        };
-        this.handleResize = async (size) => {
-            const resizeGeneration = this.resizeGeneration;
-            this.dimensions = size;
-            this.updateState({ dimensions: size });
-            this.options.onResize?.(size.cols, size.rows);
-            const sessionId = this.options.sessionId;
-            if (!sessionId) {
-                return;
-            }
-            if (isAtomicTransport(this.options.transport) && this.connectionState !== ConnectionState.CONNECTED) {
-                return;
-            }
-            try {
-                await this.options.transport.resize(sessionId, size.cols, size.rows);
-            }
-            catch (error) {
-                if (this.disposed || resizeGeneration !== this.resizeGeneration) {
-                    return;
-                }
-                this.logger.warn('[TerminalInstanceController] Resize request failed', { error });
-            }
-        };
-        this.handleError = (error) => {
-            this.updateState({ error, state: TerminalState.ERROR });
-            this.options.onError?.(error);
-        };
-        this.options = { ...options };
-        this.logger = options.logger ?? createConsoleLogger();
-        this.scheduler = options.scheduler ?? createDefaultScheduler();
-        this.subscribeToTerminalData();
-        this.subscribeToTerminalGeometry();
-    }
-    get connection() {
-        return computeConnectionState(this.createConnectionState());
-    }
-    async mount(container) {
-        if (this.disposed) {
-            throw new Error('Cannot mount a disposed TerminalInstanceController');
-        }
-        this.container = container;
-        this.scheduleInitialize();
-    }
-    unmount() {
-        this.initializationAbortController?.abort();
-        this.initializationAbortController = null;
-        this.cleanupTerminal();
-        this.container = null;
-    }
-    dispose() {
-        if (this.disposed) {
-            return;
-        }
-        this.disposed = true;
-        this.connectGeneration += 1;
-        this.initializationAbortController?.abort();
-        this.initializationAbortController = null;
-        this.clearRetryTimeout();
-        this.clearQueueRetryTimeout();
-        this.cancelDataQueueFlush();
-        this.terminalDataUnsubscribe?.();
-        this.terminalDataUnsubscribe = null;
-        this.terminalGeometryUnsubscribe?.();
-        this.terminalGeometryUnsubscribe = null;
-        this.cleanupTerminal();
-        this.updateState({ state: TerminalState.DISPOSED });
-        this.listeners.clear();
-    }
-    updateOptions(options) {
-        if (this.disposed) {
-            return;
-        }
-        const previousSessionId = this.options.sessionId;
-        const previousIsActive = this.options.isActive;
-        const previousTheme = this.options.themeName;
-        const previousFontSize = this.options.fontSize;
-        const previousFontFamily = this.options.config?.fontFamily;
-        const previousPresentationScale = this.options.presentationScale;
-        const previousSharedGeometry = Boolean(this.options.config?.responsive?.reportHostDimensionsWithFixedGrid);
-        this.options = {
-            ...this.options,
-            ...options,
-            config: options.config !== undefined ? options.config : this.options.config,
-        };
-        if (options.sessionId !== undefined && options.sessionId !== previousSessionId) {
-            this.resetSessionState();
-            this.subscribeToTerminalData();
-            this.subscribeToTerminalGeometry();
-            if (this.terminalCore) {
-                void this.reinitialize();
-            }
-            return;
-        }
-        const nextSharedGeometry = Boolean(this.options.config?.responsive?.reportHostDimensionsWithFixedGrid);
-        if (previousSharedGeometry !== nextSharedGeometry) {
-            this.lastGeometryGeneration = 0;
-            this.pendingGeometryEvents = [];
-            if (!nextSharedGeometry)
-                this.terminalCore?.setFixedDimensions(null);
-            this.subscribeToTerminalGeometry();
-        }
-        if (options.isActive !== undefined && options.isActive !== previousIsActive) {
-            if (this.options.isActive) {
-                this.scheduleInitialize();
-                if (this.terminalCore && this.options.sessionId) {
-                    void this.connectToSession();
-                }
-            }
-            else {
-                this.terminalCore?.setConnected(false);
-            }
-        }
-        const nextFontFamily = this.options.config?.fontFamily;
-        if (previousTheme !== this.options.themeName
-            || previousFontSize !== this.options.fontSize
-            || previousFontFamily !== nextFontFamily
-            || previousPresentationScale !== this.options.presentationScale) {
-            this.applyCoreAppearance({
-                themeName: this.options.themeName,
-                ...(typeof this.options.fontSize === 'number' ? { fontSize: this.options.fontSize } : {}),
-                ...(typeof nextFontFamily === 'string' ? { fontFamily: nextFontFamily } : {}),
-                presentationScale: this.options.presentationScale ?? 1
-            });
-        }
-    }
-    getSnapshot() {
-        return {
-            state: computeTerminalState(this.state),
-            connection: computeConnectionState(this.createConnectionState()),
-            loadingState: this.loadingState,
-            loadingMessage: this.loadingMessage,
-        };
-    }
-    subscribe(listener) {
-        this.listeners.add(listener);
-        listener(this.getSnapshot());
-        return () => {
-            this.listeners.delete(listener);
-        };
-    }
-    getCore() {
-        return this.terminalCore;
-    }
-    emit() {
-        if (this.disposed) {
-            return;
-        }
-        const snapshot = this.getSnapshot();
-        for (const listener of this.listeners) {
-            listener(snapshot);
-        }
-    }
-    updateState(updates) {
-        this.state = { ...this.state, ...updates };
-        this.emit();
-    }
-    setLoading(state, message) {
-        this.loadingState = state;
-        this.loadingMessage = message;
-        this.emit();
-    }
-    setConnectionState(state) {
-        this.connectionState = state;
-        this.terminalCore?.setConnected(state === ConnectionState.CONNECTED);
-        this.emit();
-    }
-    setConnectionError(error) {
-        this.connectionError = error;
-        this.emit();
-    }
-    createConnectionState() {
-        return {
-            state: this.connectionState,
-            error: this.connectionError,
-            retryCount: this.retryCount,
-            connect: () => void this.connectToSession(),
-            disconnect: () => {
-                this.clearRetryTimeout();
-                this.connectGeneration += 1;
-                this.setConnectionState(ConnectionState.ABORTED);
-            },
-            retry: () => {
-                this.clearRetryTimeout();
-                this.retryCount = 0;
-                this.setConnectionError(null);
-                this.setConnectionState(ConnectionState.IDLE);
-                void this.connectToSession();
-            },
-            clearError: () => this.setConnectionError(null),
-        };
-    }
-    resetSessionState() {
-        this.queueGeneration += 1;
-        this.connectGeneration += 1;
-        this.sequenceBuffer.reset(1);
-        this.replayCompleteReceived = false;
-        this.isReplayActive = false;
-        this.lastAppliedSequence = 0;
-        this.lastGeometryGeneration = 0;
-        this.pendingGeometryEvents = [];
-        this.terminalCore?.setFixedDimensions(null);
-        this.dataQueue = [];
-        this.isProcessing = false;
-        this.cancelDataQueueFlush();
-        this.clearQueueRetryTimeout();
-        this.setConnectionState(ConnectionState.IDLE);
-        this.setConnectionError(null);
-        this.retryCount = 0;
-        this.clearRetryTimeout();
-    }
-    handleUserInput(data) {
-        const sessionId = this.options.sessionId;
-        if (!sessionId) {
-            return;
-        }
-        this.options.transport.sendInput(sessionId, data).catch(error => {
-            this.logger.warn('[TerminalInstanceController] sendInput failed', { error });
-            this.handleError(error instanceof Error ? error : new Error(String(error)));
-        });
-    }
-    scheduleFocus() {
-        if (!this.options.autoFocus) {
-            return;
-        }
-        this.scheduler.requestFrame(() => {
-            this.scheduler.requestFrame(() => {
-                this.terminalCore?.focus();
-            });
-        });
-    }
-    cleanupTerminal() {
-        this.resizeGeneration += 1;
-        this.initializationAbortController?.abort();
-        this.initializationAbortController = null;
-        this.isInitializing = false;
-        this.disposeCheckpointActor();
-        if (this.terminalCore) {
-            this.terminalCore.dispose();
-            this.terminalCore = null;
-        }
-        this.dataQueue = [];
-        this.isProcessing = false;
-    }
-    finishReplayIfIdle() {
-        if (!this.replayCompleteReceived || this.dataQueue.length > 0 || this.isProcessing) {
-            return;
-        }
-        if (this.isReplayActive) {
-            this.terminalCore?.endHistoryReplay?.();
-            this.isReplayActive = false;
-        }
-        this.setLoading('ready', '');
-        this.scheduleFocus();
-    }
-    scheduleDataQueueFlush(allowImmediate = false) {
-        if (this.flushRaf !== null) {
-            this.immediateFlushEligible = false;
-            return;
-        }
-        this.immediateFlushEligible = allowImmediate;
-        const generation = this.queueGeneration;
-        this.flushRaf = this.scheduler.requestFrame(() => {
-            this.flushRaf = null;
-            if (this.queueGeneration !== generation) {
-                return;
-            }
-            void this.processDataQueue();
-        });
-        if (!allowImmediate || this.isReplayActive || this.flushMicrotaskScheduled) {
-            return;
-        }
-        this.flushMicrotaskScheduled = true;
-        const microtaskGeneration = ++this.flushMicrotaskGeneration;
-        queueMicrotask(() => {
-            if (microtaskGeneration !== this.flushMicrotaskGeneration) {
-                return;
-            }
-            this.flushMicrotaskScheduled = false;
-            if (this.disposed || this.queueGeneration !== generation || this.isReplayActive || this.isProcessing) {
-                return;
-            }
-            if (!this.immediateFlushEligible
-                || this.dataQueue.length !== 1
-                || this.dataQueue[0].data.byteLength > MAX_IMMEDIATE_LIVE_BATCH_BYTES) {
-                return;
-            }
-            this.cancelDataQueueFlush();
-            void this.processDataQueue();
-        });
-    }
-    cancelDataQueueFlush() {
-        this.immediateFlushEligible = false;
-        this.flushMicrotaskScheduled = false;
-        this.flushMicrotaskGeneration += 1;
-        if (this.flushRaf === null) {
-            return;
-        }
-        this.scheduler.cancelFrame(this.flushRaf);
-        this.flushRaf = null;
-    }
-    async processDataQueue() {
-        const generation = this.queueGeneration;
-        if (this.isProcessing || !this.terminalCore) {
-            return;
-        }
-        this.applyPendingGeometryEvents();
-        if (this.dataQueue.length === 0)
-            return;
-        const terminalState = this.terminalCore.getState();
-        if (terminalState !== TerminalState.READY && terminalState !== TerminalState.CONNECTED) {
-            this.clearQueueRetryTimeout();
-            this.queueRetryTimeout = this.scheduler.setTimer(() => {
-                this.queueRetryTimeout = null;
-                if (this.queueGeneration !== generation) {
-                    return;
-                }
-                void this.processDataQueue();
-            }, 100);
-            return;
-        }
-        this.isProcessing = true;
-        try {
-            let batchLength = 0;
-            let batchBytes = 0;
-            let batchGeometry;
-            const geometryBoundary = this.pendingGeometryEvents[0]?.outputSequenceBoundary;
-            for (const chunk of this.dataQueue) {
-                if (batchLength >= MAX_WRITE_BATCH_CHUNKS) {
-                    break;
-                }
-                if (geometryBoundary !== undefined
-                    && chunk.sequence > 0
-                    && chunk.sequence > geometryBoundary) {
-                    break;
-                }
-                const hasGeometry = chunk.geometryGeneration !== undefined
-                    || chunk.cols !== undefined
-                    || chunk.rows !== undefined;
-                if (batchLength > 0 && hasGeometry !== (batchGeometry !== undefined)) {
-                    break;
-                }
-                if (hasGeometry) {
-                    if (chunk.geometryGeneration === undefined
-                        || chunk.cols === undefined
-                        || chunk.rows === undefined
-                        || !Number.isSafeInteger(chunk.geometryGeneration)
-                        || chunk.geometryGeneration <= 0
-                        || !Number.isSafeInteger(chunk.cols)
-                        || chunk.cols <= 0
-                        || !Number.isSafeInteger(chunk.rows)
-                        || chunk.rows <= 0) {
-                        throw new Error('terminal history chunk geometry is invalid');
-                    }
-                    const geometry = {
-                        generation: chunk.geometryGeneration,
-                        cols: chunk.cols,
-                        rows: chunk.rows,
-                    };
-                    if (batchGeometry && (batchGeometry.generation !== geometry.generation
-                        || batchGeometry.cols !== geometry.cols
-                        || batchGeometry.rows !== geometry.rows)) {
-                        break;
-                    }
-                    batchGeometry = geometry;
-                }
-                if (batchLength > 0 && batchBytes + chunk.data.byteLength > MAX_WRITE_BATCH_BYTES) {
-                    break;
-                }
-                batchLength += 1;
-                batchBytes += chunk.data.byteLength;
-            }
-            if (batchLength === 0) {
-                return;
-            }
-            const batch = this.dataQueue.splice(0, batchLength);
-            if (this.queueGeneration !== generation) {
-                return;
-            }
-            const payload = batch.length === 1 ? batch[0].data : concatChunks(batch.map(chunk => chunk.data));
-            if (batchGeometry) {
-                this.terminalCore.setFixedDimensions({ cols: batchGeometry.cols, rows: batchGeometry.rows }, { notifyResize: false });
-            }
-            this.terminalCore.writeFrame(payload);
-            for (const chunk of batch) {
-                if (this.queueGeneration !== generation) {
-                    return;
-                }
-                if (chunk.sequence > this.lastAppliedSequence) {
-                    this.lastAppliedSequence = chunk.sequence;
-                }
-            }
-            this.scheduleCheckpointChunks(batch);
-            this.applyPendingGeometryEvents();
-        }
-        finally {
-            this.isProcessing = false;
-            if (this.dataQueue.length > 0) {
-                this.scheduleDataQueueFlush();
-            }
-            else {
-                this.finishReplayIfIdle();
-            }
-        }
-    }
-    addChunkToQueue(chunk, allowImmediate = false) {
-        if (chunk.sequence > 0 && chunk.sequence <= this.lastAppliedSequence) {
-            return;
-        }
-        const ready = this.sequenceBuffer.push(chunk);
-        if (ready.length === 0) {
-            return;
-        }
-        const queueWasEmpty = this.dataQueue.length === 0;
-        this.dataQueue.push(...ready);
-        if (!this.isProcessing) {
-            this.scheduleDataQueueFlush(queueWasEmpty && ready.length === 1 && allowImmediate);
-        }
-    }
-    applyCoreAppearance(appearance) {
-        const core = this.terminalCore;
-        if (!core) {
-            return;
-        }
-        const theme = appearance.themeName ? getThemeColors(appearance.themeName) : undefined;
-        if (core.setAppearance) {
-            core.setAppearance({
-                ...(theme ? { theme } : {}),
-                ...(typeof appearance.fontSize === 'number' ? { fontSize: appearance.fontSize } : {}),
-                ...(typeof appearance.fontFamily === 'string' ? { fontFamily: appearance.fontFamily } : {}),
-                ...(typeof appearance.presentationScale === 'number' ? { presentationScale: appearance.presentationScale } : {})
-            });
-            return;
-        }
-        if (theme) {
-            core.setTheme(theme);
-        }
-        if (typeof appearance.fontSize === 'number') {
-            core.setFontSize(appearance.fontSize);
-        }
-        if (typeof appearance.fontFamily === 'string') {
-            core.setFontFamily?.(appearance.fontFamily);
-        }
-        if (typeof appearance.presentationScale === 'number') {
-            core.setPresentationScale(appearance.presentationScale);
-        }
-    }
-    scheduleInitialize() {
-        if (!this.options.isActive || !this.container || this.terminalCore || this.isInitializing) {
-            return;
-        }
-        void this.initializeTerminal();
-    }
-    async initializeTerminal() {
-        if (!this.container || this.isInitializing || this.terminalCore || this.disposed) {
-            return;
-        }
-        this.isInitializing = true;
-        const abortController = new AbortController();
-        this.initializationAbortController = abortController;
-        this.setLoading('initializing_terminal', 'Initializing terminal...');
-        try {
-            const configOverrides = {
-                ...(this.options.config ?? {}),
-                sessionId: this.options.sessionId,
-                ...(this.options.fontSize ? { fontSize: this.options.fontSize } : {}),
-                ...(this.options.presentationScale ? { presentationScale: this.options.presentationScale } : {}),
-            };
-            const config = getDefaultTerminalConfig(this.options.themeName ?? 'dark', configOverrides);
-            const CoreCtor = this.options.coreConstructor ?? TerminalCore;
-            const terminalCore = new CoreCtor(this.container, config, {
-                onData: data => this.handleUserInput(data),
-                onResize: size => void this.handleResize(size),
-                onStateChange: this.handleStateChange,
-                onError: this.handleError,
-                onRender: durationMs => this.options.onRender?.(durationMs),
-            }, this.logger ?? noopLogger);
-            this.terminalCore = terminalCore;
-            await terminalCore.initialize({ priority: 'interactive', signal: abortController.signal });
-            if (abortController.signal.aborted
-                || this.disposed
-                || !this.container
-                || this.terminalCore !== terminalCore) {
-                return;
-            }
-            if (this.isReplayActive) {
-                terminalCore.startHistoryReplay(30000);
-            }
-            const sessionId = this.options.sessionId;
-            if (sessionId && !isAtomicTransport(this.options.transport)) {
-                const dimensions = terminalCore.getDimensions();
-                await this.options.transport.resize(sessionId, dimensions.cols, dimensions.rows);
-            }
-            void this.processDataQueue();
-            if (!this.isReplayActive || this.replayCompleteReceived) {
-                this.setLoading('ready', '');
-            }
-            else {
-                this.setLoading('processing_history', 'Restoring terminal...');
-            }
-            if (this.options.isActive && sessionId) {
-                await this.connectToSession();
-            }
-        }
-        catch (error) {
-            if (abortController.signal.aborted) {
-                return;
-            }
-            this.handleError(error instanceof Error ? error : new Error(String(error)));
-            this.setLoading('ready', '');
-        }
-        finally {
-            if (this.initializationAbortController === abortController) {
-                this.initializationAbortController = null;
-                this.isInitializing = false;
-            }
-        }
-    }
-    async connectToSession() {
-        const sessionId = this.options.sessionId;
-        if (!sessionId || this.disposed) {
-            return;
-        }
-        this.clearRetryTimeout();
-        this.setConnectionState(ConnectionState.CONNECTING);
-        this.setConnectionError(null);
-        this.setLoading('attaching', 'Attaching to session...');
-        const connectGeneration = ++this.connectGeneration;
-        try {
-            const dims = this.terminalCore?.getDimensions() ?? this.dimensions;
-            if (isAtomicTransport(this.options.transport)) {
-                const attached = await this.options.transport.attachWithHistoryBoundary(sessionId, dims.cols, dims.rows);
-                if (connectGeneration !== this.connectGeneration || this.disposed)
-                    return;
-                await this.recoverAtomicHistory(sessionId, attached);
-            }
-            else {
-                await this.options.transport.attach(sessionId, dims.cols, dims.rows);
-            }
-            if (connectGeneration !== this.connectGeneration || this.disposed)
-                return;
-            this.setConnectionState(ConnectionState.CONNECTED);
-            this.retryCount = 0;
-            this.emit();
-            if (!this.isReplayActive || this.replayCompleteReceived) {
-                this.setLoading('ready', '');
-            }
-            else {
-                this.setLoading('processing_history', 'Restoring terminal...');
-            }
-        }
-        catch (error) {
-            if (connectGeneration !== this.connectGeneration || this.disposed)
-                return;
-            const terminalError = createTerminalError('transport', error);
-            this.setConnectionState(ConnectionState.FAILED);
-            this.setConnectionError(terminalError);
-            this.setLoading('ready', '');
-            this.scheduleConnectionRetry();
-        }
-    }
-    async recoverAtomicHistory(sessionId, attachment) {
-        const boundary = attachment.historyBoundarySequence;
-        const historyGeneration = attachment.historyGeneration;
-        const historyStartSequence = attachment.historyStartSequence;
-        if (!Number.isSafeInteger(boundary) || boundary < 0) {
-            throw new Error('terminal live history boundary is invalid');
-        }
-        if (!Number.isSafeInteger(historyGeneration) || historyGeneration < 1) {
-            throw new Error('terminal live history generation is invalid');
-        }
-        if (!Number.isSafeInteger(historyStartSequence)
-            || historyStartSequence < 1
-            || historyStartSequence > boundary + 1) {
-            throw new Error('terminal live history start sequence is invalid');
-        }
-        if (!isAtomicTransport(this.options.transport)) {
-            throw new Error('terminal atomic history page transport is required');
-        }
-        this.lastAppliedSequence = Math.max(this.lastAppliedSequence, historyStartSequence - 1);
-        this.applyPendingGeometryEvents();
-        let queuedHistoryOutput = false;
-        let restoredCheckpoint = false;
-        let checkpointActorConfigured = false;
-        let startSequence = Math.max(this.lastAppliedSequence + 1, historyStartSequence);
-        if (boundary === 0 && historyStartSequence === 1) {
-            checkpointActorConfigured = this.configureCheckpointActor(attachment, undefined, 0);
-        }
-        while (startSequence <= boundary) {
-            const page = await this.options.transport.historyPage(sessionId, startSequence, boundary, historyGeneration);
-            if (page.historyGeneration !== historyGeneration || page.historyReset) {
-                throw new Error('terminal history generation changed during atomic replay');
-            }
-            if (page.snapshotEndSequence !== boundary) {
-                throw new Error('terminal history snapshot boundary does not match live attachment');
-            }
-            if (page.checkpoint) {
-                if (restoredCheckpoint) {
-                    throw new Error('terminal history page repeated its authoritative checkpoint');
-                }
-                const checkpoint = page.checkpoint;
-                if (checkpoint.parserEpoch !== historyGeneration) {
-                    throw new Error('terminal history checkpoint parser epoch does not match history generation');
-                }
-                if (checkpoint.formatVersion !== 1
-                    || checkpoint.engineId !== 'floegence-ghostty-web'
-                    || !Number.isSafeInteger(checkpoint.coveredThroughSequence)
-                    || checkpoint.coveredThroughSequence < 0
-                    || checkpoint.coveredThroughSequence > boundary
-                    || !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.checksumSha256)
-                    || !/^[0-9a-f]{64}$/.test(checkpoint.stateDigestSha256)) {
-                    throw new Error('terminal history authoritative checkpoint is invalid');
-                }
-                if (page.deltaStartSequence !== undefined && page.deltaStartSequence !== checkpoint.coveredThroughSequence + 1) {
-                    throw new Error('terminal history checkpoint delta boundary is invalid');
-                }
-                if (!this.terminalCore?.restoreAuthoritativeCheckpoint) {
-                    throw new Error('terminal history checkpoint restore is unavailable');
-                }
-                this.terminalCore.setFixedDimensions({ cols: checkpoint.cols, rows: checkpoint.rows }, { notifyResize: false });
-                await this.terminalCore.restoreAuthoritativeCheckpoint({
-                    ...checkpoint,
-                    bytes: checkpoint.bytes.slice(),
-                });
-                restoredCheckpoint = true;
-                checkpointActorConfigured = this.configureCheckpointActor(attachment, checkpoint, checkpoint.coveredThroughSequence);
-                this.lastAppliedSequence = Math.max(this.lastAppliedSequence, checkpoint.coveredThroughSequence);
-                startSequence = Math.max(startSequence, checkpoint.coveredThroughSequence + 1);
-            }
-            else if (page.historyTruncated) {
-                throw new Error('terminal history was truncated before the acknowledged live boundary');
-            }
-            if (!checkpointActorConfigured && startSequence === historyStartSequence) {
-                checkpointActorConfigured = this.configureCheckpointActor(attachment, undefined, historyStartSequence - 1);
-            }
-            if (!Number.isSafeInteger(page.coveredThroughSequence)
-                || page.coveredThroughSequence < startSequence - 1
-                || page.coveredThroughSequence > boundary) {
-                throw new Error('terminal history page coverage is invalid');
-            }
-            let expectedSequence = startSequence;
-            for (const chunk of page.chunks) {
-                if (!Number.isSafeInteger(chunk.sequence) || chunk.sequence !== expectedSequence) {
-                    throw new Error(`missing terminal output sequence ${expectedSequence} before replay boundary ${boundary}`);
-                }
-                if (chunk.sequence > page.coveredThroughSequence) {
-                    throw new Error('terminal history chunk exceeded its page coverage');
-                }
-                this.addChunkToQueue(chunk);
-                queuedHistoryOutput = true;
-                expectedSequence += 1;
-            }
-            const explicitlyCleared = page.chunks.length === 0 && page.totalBytes === 0;
-            if (page.coveredThroughSequence >= expectedSequence && !explicitlyCleared) {
-                throw new Error(`missing terminal output sequence ${expectedSequence} before replay boundary ${boundary}`);
-            }
-            if (!page.hasMore) {
-                if (page.coveredThroughSequence !== boundary) {
-                    throw new Error('terminal history did not cover the acknowledged live boundary');
-                }
-                startSequence = boundary + 1;
-                break;
-            }
-            if (!Number.isSafeInteger(page.nextStartSequence)
-                || page.nextStartSequence !== page.coveredThroughSequence + 1) {
-                throw new Error('terminal history page cursor is invalid');
-            }
-            startSequence = page.nextStartSequence;
-        }
-        const ready = this.sequenceBuffer.coverThrough(boundary);
-        if (ready.length > 0) {
-            this.dataQueue.push(...ready);
-            this.scheduleDataQueueFlush();
-        }
-        if (!queuedHistoryOutput) {
-            this.lastAppliedSequence = Math.max(this.lastAppliedSequence, boundary);
-            this.applyPendingGeometryEvents();
-        }
-        this.replayCompleteReceived = true;
-        this.finishReplayIfIdle();
-    }
-    configureCheckpointActor(attachment, checkpoint, initialSequence) {
-        if (this.checkpointActor || !isAtomicTransport(this.options.transport))
-            return this.checkpointActor !== null;
-        if (typeof this.options.transport.commitHistoryCheckpoint !== 'function')
-            return false;
-        const captureEveryBytes = this.options.checkpointCompaction?.captureEveryBytes
-            ?? DEFAULT_CHECKPOINT_CAPTURE_BYTES;
-        if (!Number.isSafeInteger(captureEveryBytes) || captureEveryBytes <= 0) {
-            this.logger.warn('[TerminalInstanceController] Checkpoint compaction budget is invalid');
-            return false;
-        }
-        const actor = this.options.checkpointCompaction?.createActor?.() ?? createGhosttyCheckpointActor();
-        const generation = ++this.checkpointActorGeneration;
-        this.checkpointActor = actor;
-        this.checkpointBytesSinceCommit = 0;
-        this.checkpointActorTail = actor.start({
-            cols: checkpoint?.cols ?? attachment.cols,
-            rows: checkpoint?.rows ?? attachment.rows,
-            parserEpoch: checkpoint?.parserEpoch ?? attachment.historyGeneration,
-            ...(!checkpoint && initialSequence > 0 ? { initialSequence } : {}),
-            ...(checkpoint ? { checkpoint } : {}),
-        }).catch(error => {
-            this.disableCheckpointActor(actor, generation, error);
-        });
-        return true;
-    }
-    scheduleCheckpointChunks(chunks) {
-        const actor = this.checkpointActor;
-        const sessionId = this.options.sessionId;
-        if (!actor || !sessionId || !isAtomicTransport(this.options.transport))
-            return;
-        const commit = this.options.transport.commitHistoryCheckpoint;
-        if (!commit)
-            return;
-        const generation = this.checkpointActorGeneration;
-        const captureEveryBytes = this.options.checkpointCompaction?.captureEveryBytes
-            ?? DEFAULT_CHECKPOINT_CAPTURE_BYTES;
-        let actorChunks;
-        try {
-            actorChunks = chunks.map(chunk => {
-                if (!Number.isSafeInteger(chunk.sequence) || chunk.sequence <= 0
-                    || !Number.isSafeInteger(chunk.geometryGeneration) || (chunk.geometryGeneration ?? 0) <= 0
-                    || !Number.isSafeInteger(chunk.cols) || (chunk.cols ?? 0) <= 0
-                    || !Number.isSafeInteger(chunk.rows) || (chunk.rows ?? 0) <= 0) {
-                    throw new Error('checkpoint compaction requires sequenced geometry-tagged output');
-                }
-                return {
-                    sequence: chunk.sequence,
-                    data: chunk.data.slice(),
-                    geometryGeneration: chunk.geometryGeneration,
-                    cols: chunk.cols,
-                    rows: chunk.rows,
-                };
-            });
-        }
-        catch (error) {
-            this.disableCheckpointActor(actor, generation, error);
-            return;
-        }
-        const addedBytes = actorChunks.reduce((total, chunk) => total + chunk.data.byteLength, 0);
-        this.checkpointActorTail = this.checkpointActorTail.then(async () => {
-            if (this.checkpointActor !== actor || this.checkpointActorGeneration !== generation)
-                return;
-            actor.append(actorChunks);
-            this.checkpointBytesSinceCommit += addedBytes;
-            if (this.checkpointBytesSinceCommit < captureEveryBytes)
-                return;
-            const targetSequence = actorChunks[actorChunks.length - 1].sequence;
-            const checkpoint = await actor.capture(targetSequence);
-            if (this.checkpointActor !== actor || this.checkpointActorGeneration !== generation)
-                return;
-            await commit.call(this.options.transport, sessionId, checkpoint);
-            if (this.checkpointActor === actor && this.checkpointActorGeneration === generation) {
-                this.checkpointBytesSinceCommit = 0;
-            }
-        }).catch(error => {
-            this.disableCheckpointActor(actor, generation, error);
-        });
-    }
-    disableCheckpointActor(actor, generation, error) {
-        if (this.checkpointActor !== actor || this.checkpointActorGeneration !== generation)
-            return;
-        this.logger.warn('[TerminalInstanceController] Checkpoint compaction stopped; durable raw history remains retained', {
-            error: error instanceof Error ? error.message : String(error),
-        });
-        this.checkpointActor = null;
-        this.checkpointBytesSinceCommit = 0;
-        actor.dispose();
-    }
-    disposeCheckpointActor() {
-        const actor = this.checkpointActor;
-        this.checkpointActor = null;
-        this.checkpointActorGeneration += 1;
-        this.checkpointBytesSinceCommit = 0;
-        actor?.dispose();
-        this.checkpointActorTail = Promise.resolve();
-    }
-    scheduleConnectionRetry() {
-        if (this.connectionState !== ConnectionState.FAILED || this.disposed) {
-            return;
-        }
-        const delay = Math.min(5000, 1000 * Math.pow(2, this.retryCount));
-        this.clearRetryTimeout();
-        this.retryTimeout = this.scheduler.setTimer(() => {
-            this.retryTimeout = null;
-            this.retryCount += 1;
-            this.setConnectionState(ConnectionState.RETRYING);
-            void this.connectToSession();
-        }, delay);
-    }
-    clearRetryTimeout() {
-        if (!this.retryTimeout) {
-            return;
-        }
-        this.scheduler.clearTimer(this.retryTimeout);
-        this.retryTimeout = null;
-    }
-    clearQueueRetryTimeout() {
-        if (!this.queueRetryTimeout) {
-            return;
-        }
-        this.scheduler.clearTimer(this.queueRetryTimeout);
-        this.queueRetryTimeout = null;
-    }
-    subscribeToTerminalData() {
-        this.terminalDataUnsubscribe?.();
-        this.terminalDataUnsubscribe = null;
-        const sessionId = this.options.sessionId;
-        if (!sessionId) {
-            return;
-        }
-        this.isReplayActive = true;
-        this.replayCompleteReceived = false;
-        this.terminalCore?.startHistoryReplay(30000);
-        this.setLoading('processing_history', 'Restoring terminal...');
-        const lastSeq = this.terminalCore ? this.lastAppliedSequence : 0;
-        const unsubscribe = this.options.eventSource.onTerminalData(sessionId, (payload) => {
-            try {
-                if (payload.type === 'error') {
-                    throw new Error(payload.error || 'Terminal stream failed');
-                }
-                if (payload.type === 'replay-complete') {
-                    const boundary = payload.sequence ?? this.lastAppliedSequence;
-                    this.sequenceBuffer.assertCoveredThrough(boundary);
-                    this.replayCompleteReceived = true;
-                    const ready = this.sequenceBuffer.flushPending();
-                    if (ready.length > 0) {
-                        this.dataQueue.push(...ready);
-                        this.scheduleDataQueueFlush();
-                    }
-                    this.finishReplayIfIdle();
-                    return;
-                }
-                const chunk = {
-                    data: payload.data,
-                    sequence: payload.sequence ?? 0,
-                    timestampMs: payload.timestampMs ?? Date.now(),
-                    ...(payload.geometryGeneration !== undefined ? { geometryGeneration: payload.geometryGeneration } : {}),
-                    ...(payload.cols !== undefined ? { cols: payload.cols } : {}),
-                    ...(payload.rows !== undefined ? { rows: payload.rows } : {})
-                };
-                this.addChunkToQueue(chunk, payload.liveBatchSize === 1);
-            }
-            catch (value) {
-                const error = value instanceof Error ? value : new Error(String(value));
-                const terminalError = createTerminalError('connection', error);
-                this.setConnectionState(ConnectionState.FAILED);
-                this.setConnectionError(terminalError);
-                this.setLoading('ready', '');
-                this.updateState({ error, state: TerminalState.ERROR });
-                this.options.onError?.(error);
-                this.scheduleConnectionRetry();
-            }
-        }, { lastSeq });
-        this.terminalDataUnsubscribe = unsubscribe;
-    }
-    subscribeToTerminalGeometry() {
-        this.terminalGeometryUnsubscribe?.();
-        this.terminalGeometryUnsubscribe = null;
-        if (!this.options.config?.responsive?.reportHostDimensionsWithFixedGrid) {
-            return;
-        }
-        const sessionId = this.options.sessionId;
-        const subscribe = this.options.eventSource.onTerminalGeometry;
-        if (!sessionId || !subscribe) {
-            return;
-        }
-        this.terminalGeometryUnsubscribe = subscribe(sessionId, (event) => {
-            if (!Number.isSafeInteger(event.generation) || event.generation <= 0 ||
-                !Number.isSafeInteger(event.outputSequenceBoundary) || event.outputSequenceBoundary < 0 ||
-                !Number.isSafeInteger(event.cols) || event.cols <= 0 ||
-                !Number.isSafeInteger(event.rows) || event.rows <= 0) {
-                this.handleError(new Error('terminal live geometry is invalid'));
-                return;
-            }
-            if (event.generation <= this.lastGeometryGeneration) {
-                return;
-            }
-            const duplicate = this.pendingGeometryEvents.find(pending => pending.generation === event.generation);
-            if (duplicate) {
-                if (duplicate.outputSequenceBoundary !== event.outputSequenceBoundary
-                    || duplicate.cols !== event.cols
-                    || duplicate.rows !== event.rows) {
-                    this.handleError(new Error('terminal live geometry generation is inconsistent'));
-                }
-                return;
-            }
-            this.pendingGeometryEvents.push(event);
-            this.pendingGeometryEvents.sort((left, right) => left.generation - right.generation);
-            this.applyPendingGeometryEvents();
-        });
-    }
-    applyPendingGeometryEvents() {
-        if (!this.terminalCore)
-            return;
-        while (this.pendingGeometryEvents.length > 0) {
-            const event = this.pendingGeometryEvents[0];
-            if (event.generation <= this.lastGeometryGeneration) {
-                this.pendingGeometryEvents.shift();
-                continue;
-            }
-            if (event.outputSequenceBoundary > this.lastAppliedSequence)
-                return;
-            this.pendingGeometryEvents.shift();
-            this.lastGeometryGeneration = event.generation;
-            this.terminalCore.setFixedDimensions({ cols: event.cols, rows: event.rows });
-        }
-    }
-    async reinitialize() {
-        this.terminalDataUnsubscribe?.();
-        this.terminalDataUnsubscribe = null;
-        this.queueGeneration += 1;
-        this.sequenceBuffer.reset(1);
-        this.replayCompleteReceived = false;
-        this.isReplayActive = true;
-        this.lastAppliedSequence = 0;
-        this.lastGeometryGeneration = 0;
-        this.pendingGeometryEvents = [];
-        this.dataQueue = [];
-        this.isProcessing = false;
-        this.cancelDataQueueFlush();
-        this.clearQueueRetryTimeout();
-        this.setLoading('processing_history', 'Restoring terminal...');
-        this.cleanupTerminal();
-        this.subscribeToTerminalData();
-        this.subscribeToTerminalGeometry();
-        await this.initializeTerminal();
-    }
-}
-export const createTerminalInstance = (options) => {
-    return new FrameworkNeutralTerminalInstanceController(options);
-};
-//# sourceMappingURL=TerminalInstanceController.js.map