@floegence/floeterm-terminal-web 0.14.0 → 0.15.0

package/dist/core/PagedTerminalOutputCoordinator.js

@@ -1,1197 +0,0 @@
-import { scheduleUiTurn } from '../internal/scheduleUiTurn.js';
-const DEFAULT_POLICY = {
-    maxRetainedLiveChunks: 2048,
-    maxRetainedLiveBytes: 8 * 1024 * 1024,
-    retryDelaysMs: [250, 1000, 4000],
-    maxWriteBatchBytes: 512 * 1024,
-};
-const DEFAULT_PREPARED_HISTORY_MAX_BYTES = 32 * 1024 * 1024;
-const normalizePositiveInteger = (value, fallback) => (typeof value === 'number' && Number.isSafeInteger(value) && value > 0
-    ? value
-    : fallback);
-const normalizeSequence = (value, field, optional = false) => {
-    if (value === undefined && optional)
-        return undefined;
-    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
-        throw new HistoryContractError('history_contract_invalid', `${field} must be a non-negative safe integer`);
-    }
-    return value;
-};
-const concatData = (chunks) => {
-    const total = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
-    const result = new Uint8Array(total);
-    let offset = 0;
-    for (const chunk of chunks) {
-        result.set(chunk, offset);
-        offset += chunk.byteLength;
-    }
-    return result;
-};
-class HistoryContractError extends Error {
-    constructor(code, message, firstRetainedSequence) {
-        super(message);
-        this.name = 'HistoryContractError';
-        this.code = code;
-        this.firstRetainedSequence = firstRetainedSequence;
-    }
-}
-const createAbortError = () => {
-    if (typeof DOMException !== 'undefined')
-        return new DOMException('Operation aborted', 'AbortError');
-    const error = new Error('Operation aborted');
-    error.name = 'AbortError';
-    return error;
-};
-const throwIfAborted = (signal) => {
-    if (signal?.aborted)
-        throw createAbortError();
-};
-const waitForPreparedPage = (promise, signal) => {
-    if (!signal)
-        return promise;
-    if (signal.aborted)
-        return Promise.reject(createAbortError());
-    return new Promise((resolve, reject) => {
-        const onAbort = () => reject(createAbortError());
-        signal.addEventListener('abort', onAbort, { once: true });
-        promise.then(value => {
-            signal.removeEventListener('abort', onAbort);
-            resolve(value);
-        }, error => {
-            signal.removeEventListener('abort', onAbort);
-            reject(error);
-        });
-    });
-};
-const yieldHistoryPreparation = async (signal, yieldControl) => {
-    throwIfAborted(signal);
-    if (yieldControl) {
-        await yieldControl();
-        throwIfAborted(signal);
-        return;
-    }
-    await new Promise((resolve, reject) => {
-        const cancelTurn = scheduleUiTurn(() => {
-            signal?.removeEventListener('abort', onAbort);
-            resolve();
-        });
-        const onAbort = () => {
-            cancelTurn();
-            reject(createAbortError());
-        };
-        signal?.addEventListener('abort', onAbort, { once: true });
-    });
-};
-const clonePreparedChunk = (chunk) => {
-    const immutableData = new Uint8Array(chunk.data);
-    return Object.freeze({
-        get data() {
-            return new Uint8Array(immutableData);
-        },
-        ...(chunk.sequence !== undefined ? { sequence: chunk.sequence } : {}),
-        ...(chunk.timestampMs !== undefined ? { timestampMs: chunk.timestampMs } : {}),
-        ...(chunk.geometryGeneration !== undefined ? { geometryGeneration: chunk.geometryGeneration } : {}),
-        ...(chunk.cols !== undefined ? { cols: chunk.cols } : {}),
-        ...(chunk.rows !== undefined ? { rows: chunk.rows } : {}),
-    });
-};
-const historyGeometryForChunk = (chunk) => {
-    if (chunk.geometryGeneration === undefined || chunk.cols === undefined || chunk.rows === undefined) {
-        throw new HistoryContractError('history_contract_missing', 'history chunk geometry is required');
-    }
-    if (!Number.isSafeInteger(chunk.geometryGeneration) || chunk.geometryGeneration <= 0
-        || !Number.isSafeInteger(chunk.cols) || chunk.cols <= 0
-        || !Number.isSafeInteger(chunk.rows) || chunk.rows <= 0) {
-        throw new HistoryContractError('history_contract_invalid', 'history chunk geometry is invalid');
-    }
-    return { generation: chunk.geometryGeneration, cols: chunk.cols, rows: chunk.rows };
-};
-const validateHistoryGeometryOrder = (previous, current) => {
-    if (previous && current.generation < previous.generation) {
-        throw new HistoryContractError('history_contract_invalid', 'history geometry generation regressed');
-    }
-    if (previous && current.generation === previous.generation
-        && (current.cols !== previous.cols || current.rows !== previous.rows)) {
-        throw new HistoryContractError('history_contract_invalid', 'history geometry dimensions conflict within a generation');
-    }
-    return current;
-};
-const sameHistoryGeometry = (left, right) => (left.generation === right.generation && left.cols === right.cols && left.rows === right.rows);
-const validateCheckpointForPage = (checkpoint, page, requestedStart, snapshotEnd, firstRetained) => {
-    if (checkpoint === undefined)
-        return undefined;
-    if (checkpoint.formatVersion !== 1
-        || checkpoint.engineId !== 'floegence-ghostty-web'
-        || !Number.isSafeInteger(checkpoint.coveredThroughSequence)
-        || checkpoint.coveredThroughSequence < Math.max(0, requestedStart - 1)
-        || (snapshotEnd !== undefined && checkpoint.coveredThroughSequence > snapshotEnd)
-        || !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 HistoryContractError('history_checkpoint_invalid', 'terminal history checkpoint metadata is invalid');
-    }
-    const expectedDeltaStart = checkpoint.coveredThroughSequence + 1;
-    if (page.deltaStartSequence !== expectedDeltaStart) {
-        throw new HistoryContractError('history_checkpoint_invalid', 'terminal history checkpoint delta boundary is invalid');
-    }
-    if (firstRetained !== undefined && firstRetained !== expectedDeltaStart) {
-        throw new HistoryContractError('history_checkpoint_invalid', 'terminal history checkpoint retention floor is invalid', firstRetained);
-    }
-    return { ...checkpoint, bytes: checkpoint.bytes.slice() };
-};
-export const preparePagedTerminalHistory = async (options) => {
-    const requestedStartSequence = normalizeSequence(options.startSequence ?? 1, 'startSequence');
-    const maxBytes = normalizePositiveInteger(options.maxBytes, DEFAULT_PREPARED_HISTORY_MAX_BYTES);
-    let startSequence = Math.max(1, requestedStartSequence);
-    let cursor;
-    let historyGeneration;
-    let snapshotEndSequence;
-    let firstRetainedSequence;
-    let coveredThroughSequence = Math.max(0, startSequence - 1);
-    let byteLength = 0;
-    let pageCount = 0;
-    let chunks = [];
-    let rebaseAttempts = 0;
-    let previousHistoryGeometry;
-    const requestSignal = options.signal ?? new AbortController().signal;
-    while (true) {
-        throwIfAborted(options.signal);
-        const page = await waitForPreparedPage(options.fetchPage({
-            startSequence,
-            endSequence: snapshotEndSequence,
-            historyGeneration,
-            cursor,
-            maxBytes: Math.max(1, maxBytes - byteLength),
-            signal: requestSignal,
-        }), options.signal);
-        throwIfAborted(options.signal);
-        pageCount += 1;
-        if (!Object.prototype.hasOwnProperty.call(page, 'coveredThroughSequence')) {
-            throw new HistoryContractError('history_contract_missing', 'coveredThroughSequence is required');
-        }
-        if (!Object.prototype.hasOwnProperty.call(page, 'snapshotEndSequence')) {
-            throw new HistoryContractError('history_contract_missing', 'snapshotEndSequence is required');
-        }
-        if (!Object.prototype.hasOwnProperty.call(page, 'historyGeneration')) {
-            throw new HistoryContractError('history_contract_missing', 'historyGeneration is required');
-        }
-        if (!Object.prototype.hasOwnProperty.call(page, 'firstRetainedSequence')
-            && !Object.prototype.hasOwnProperty.call(page, 'firstAvailableSequence')) {
-            throw new HistoryContractError('history_contract_missing', 'firstRetainedSequence is required');
-        }
-        const pageCoverage = normalizeSequence(page.coveredThroughSequence, 'coveredThroughSequence');
-        const pageSnapshotEnd = normalizeSequence(page.snapshotEndSequence, 'snapshotEndSequence');
-        const pageGeneration = normalizeSequence(page.historyGeneration, 'historyGeneration');
-        const pageFirstRetained = normalizeSequence(page.firstRetainedSequence ?? page.firstAvailableSequence, 'firstRetainedSequence');
-        const generationChanged = historyGeneration !== undefined && pageGeneration !== historyGeneration;
-        const snapshotChanged = snapshotEndSequence !== undefined && pageSnapshotEnd !== snapshotEndSequence;
-        const retentionAdvanced = firstRetainedSequence !== undefined
-            && pageFirstRetained > firstRetainedSequence;
-        if (historyGeneration !== undefined
-            && (page.historyReset || page.historyTruncated || generationChanged || snapshotChanged || retentionAdvanced)) {
-            if (rebaseAttempts >= 2) {
-                throw new HistoryContractError('history_contract_invalid', 'terminal history changed repeatedly while preparing a stable snapshot');
-            }
-            rebaseAttempts += 1;
-            startSequence = Math.max(1, pageFirstRetained);
-            cursor = undefined;
-            historyGeneration = undefined;
-            snapshotEndSequence = undefined;
-            firstRetainedSequence = undefined;
-            coveredThroughSequence = startSequence - 1;
-            byteLength = 0;
-            chunks = [];
-            previousHistoryGeometry = undefined;
-            await yieldHistoryPreparation(options.signal, options.yieldControl);
-            continue;
-        }
-        if (pageCoverage < coveredThroughSequence) {
-            throw new HistoryContractError('history_contract_invalid', 'coveredThroughSequence regressed');
-        }
-        if (pageCoverage > pageSnapshotEnd) {
-            throw new HistoryContractError('history_contract_invalid', 'coveredThroughSequence exceeded snapshotEndSequence');
-        }
-        let previousChunkSequence = coveredThroughSequence;
-        for (const chunk of page.chunks) {
-            const sequence = normalizeSequence(chunk.sequence, 'chunk.sequence');
-            if (sequence <= previousChunkSequence || sequence > pageCoverage) {
-                throw new HistoryContractError('history_contract_invalid', 'prepared history chunks must have strictly increasing sequences within page coverage');
-            }
-            previousChunkSequence = sequence;
-            previousHistoryGeometry = validateHistoryGeometryOrder(previousHistoryGeometry, historyGeometryForChunk(chunk));
-        }
-        if (pageCoverage > Math.max(0, pageFirstRetained - 1)
-            && previousChunkSequence !== pageCoverage) {
-            throw new HistoryContractError('history_contract_invalid', 'prepared history page did not include its covered terminal sequence');
-        }
-        historyGeneration = pageGeneration;
-        snapshotEndSequence = pageSnapshotEnd;
-        firstRetainedSequence = pageFirstRetained;
-        if (pageFirstRetained > startSequence) {
-            coveredThroughSequence = Math.max(coveredThroughSequence, pageFirstRetained - 1);
-        }
-        const pageBytes = page.chunks.reduce((sum, chunk) => sum + chunk.data.byteLength, 0);
-        const remainingBytes = maxBytes - byteLength;
-        if (pageBytes <= remainingBytes) {
-            chunks.push(...page.chunks.map(clonePreparedChunk));
-            byteLength += pageBytes;
-            coveredThroughSequence = Math.max(coveredThroughSequence, pageCoverage);
-        }
-        else {
-            for (const chunk of page.chunks) {
-                const sequence = normalizeSequence(chunk.sequence, 'chunk.sequence');
-                if (byteLength + chunk.data.byteLength > maxBytes)
-                    break;
-                chunks.push(clonePreparedChunk(chunk));
-                byteLength += chunk.data.byteLength;
-                coveredThroughSequence = Math.max(coveredThroughSequence, sequence);
-            }
-            return Object.freeze({
-                chunks: Object.freeze(chunks),
-                requestedStartSequence,
-                firstRetainedSequence,
-                coveredThroughSequence,
-                snapshotEndSequence,
-                historyGeneration,
-                byteLength,
-                pageCount,
-                complete: false,
-            });
-        }
-        if (!page.hasMore) {
-            return Object.freeze({
-                chunks: Object.freeze(chunks),
-                requestedStartSequence,
-                firstRetainedSequence,
-                coveredThroughSequence,
-                snapshotEndSequence,
-                historyGeneration,
-                byteLength,
-                pageCount,
-                complete: coveredThroughSequence >= snapshotEndSequence,
-            });
-        }
-        if (byteLength >= maxBytes) {
-            return Object.freeze({
-                chunks: Object.freeze(chunks),
-                requestedStartSequence,
-                firstRetainedSequence,
-                coveredThroughSequence,
-                snapshotEndSequence,
-                historyGeneration,
-                byteLength,
-                pageCount,
-                complete: false,
-            });
-        }
-        if (page.nextCursor === undefined) {
-            throw new HistoryContractError('history_contract_invalid', 'nextCursor is required when hasMore is true');
-        }
-        cursor = page.nextCursor;
-        startSequence = pageCoverage + 1;
-        await yieldHistoryPreparation(options.signal, options.yieldControl);
-    }
-};
-class PagedTerminalOutputCoordinator {
-    constructor(options) {
-        this.active = true;
-        this.state = 'idle';
-        this.baselineReady = false;
-        this.coveredThroughSequence = 0;
-        this.scheduledThroughSequence = 0;
-        this.retainedLive = [];
-        this.retainedLiveBytes = 0;
-        this.retryAttempt = 0;
-        this.retryTimer = null;
-        this.abortController = null;
-        this.generation = 0;
-        this.recoverySerial = 0;
-        this.disposed = false;
-        this.lastError = null;
-        this.failure = null;
-        this.recoveryStartSequence = 1;
-        this.explicitAttachFence = false;
-        this.recoveryKind = 'initial';
-        this.recoveryRunning = false;
-        this.needsRebase = false;
-        this.historyRebasePrepared = false;
-        this.writeChain = Promise.resolve();
-        this.pendingLiveWrites = [];
-        this.liveWriteScheduled = false;
-        this.baselineWaiters = [];
-        this.activeWriters = 0;
-        this.writerQuiescenceWaiters = [];
-        this.pausedRecoveryPending = false;
-        this.droppedLiveThroughSequence = 0;
-        this.preparedHistory = null;
-        this.preparedHistoryOutcome = {
-            status: 'not-provided',
-            rebased: false,
-        };
-        this.options = options;
-        this.policy = {
-            maxRetainedLiveChunks: normalizePositiveInteger(options.policy?.maxRetainedLiveChunks, DEFAULT_POLICY.maxRetainedLiveChunks),
-            maxRetainedLiveBytes: normalizePositiveInteger(options.policy?.maxRetainedLiveBytes, DEFAULT_POLICY.maxRetainedLiveBytes),
-            retryDelaysMs: options.policy?.retryDelaysMs !== undefined
-                ? options.policy.retryDelaysMs.map(delay => Math.max(0, Math.floor(delay)))
-                : DEFAULT_POLICY.retryDelaysMs,
-            maxWriteBatchBytes: normalizePositiveInteger(options.policy?.maxWriteBatchBytes, DEFAULT_POLICY.maxWriteBatchBytes),
-        };
-    }
-    async attach(startSequence = 1, snapshotEndSequence, options) {
-        const attachGeneration = this.beginAttach(startSequence);
-        await this.completeAttach(attachGeneration, snapshotEndSequence, options);
-    }
-    beginAttach(startSequence = 1) {
-        if (this.disposed)
-            return this.generation;
-        this.cancelRecovery();
-        this.resolveBaselineWaiters();
-        this.retainedLive = [];
-        this.retainedLiveBytes = 0;
-        this.pendingLiveWrites = [];
-        this.liveWriteScheduled = false;
-        this.pausedRecoveryPending = false;
-        this.writeChain = Promise.resolve();
-        this.baselineReady = false;
-        this.coveredThroughSequence = Math.max(0, Math.floor(startSequence) - 1);
-        this.scheduledThroughSequence = this.coveredThroughSequence;
-        this.recoveryKind = 'initial';
-        this.recoveryStartSequence = Math.max(0, Math.floor(startSequence));
-        this.recoveryEndSequence = undefined;
-        this.explicitAttachFence = false;
-        this.droppedLiveThroughSequence = 0;
-        this.needsRebase = false;
-        this.retryAttempt = 0;
-        this.failure = null;
-        this.lastError = null;
-        this.historyRebasePrepared = false;
-        this.preparedHistory = null;
-        this.preparedHistoryOutcome = { status: 'not-provided', rebased: false };
-        this.setState('idle');
-        return this.generation;
-    }
-    async completeAttach(attachGeneration, snapshotEndSequence, options = {}) {
-        if (this.disposed || !this.isCurrent(attachGeneration))
-            return;
-        this.explicitAttachFence = snapshotEndSequence !== undefined;
-        this.recoveryEndSequence = normalizeSequence(snapshotEndSequence, 'snapshotEndSequence', true);
-        this.preparedHistoryOutcome = options.preparedHistory
-            ? { status: 'rejected', rebased: false }
-            : { status: 'not-provided', rebased: false };
-        this.preparedHistory = this.acceptPreparedHistory(options.preparedHistory);
-        if (this.preparedHistory) {
-            this.preparedHistoryOutcome = {
-                ...this.preparedHistoryOutcome,
-                status: 'accepted',
-            };
-        }
-        if (this.explicitAttachFence && this.recoveryEndSequence === 0) {
-            if (this.needsRebase) {
-                this.prepareRetainedLiveRebase();
-                await this.runRecovery();
-                return;
-            }
-            this.baselineReady = true;
-            this.resolveBaselineWaiters();
-            this.emitState();
-            this.setState('live');
-            this.drainRetainedLive();
-            await this.writeChain;
-            return;
-        }
-        await this.runRecovery();
-    }
-    waitForBaseline() {
-        const snapshot = this.getSnapshot();
-        if (snapshot.baselineReady || snapshot.state === 'failed' || snapshot.disposed) {
-            return Promise.resolve(snapshot);
-        }
-        return new Promise(resolve => this.baselineWaiters.push(resolve));
-    }
-    async pause() {
-        if (this.disposed)
-            return this.getSnapshot();
-        this.active = false;
-        const recoveryPending = this.recoveryRunning
-            || this.state === 'initial-replay'
-            || this.state === 'catching-up'
-            || this.state === 'retry-wait';
-        if (recoveryPending) {
-            this.pausedRecoveryPending = true;
-            this.cancelRecovery(false);
-        }
-        this.emitState();
-        await this.writeChain;
-        await this.waitForWriterQuiescence();
-        return this.getSnapshot();
-    }
-    pushLive(chunk) {
-        if (this.disposed)
-            return;
-        const tagged = { ...chunk, source: 'live' };
-        if (this.state !== 'live' || !this.canRenderLive()) {
-            this.retainLive(tagged);
-            return;
-        }
-        this.acceptLive(tagged);
-    }
-    setActive(active) {
-        if (this.disposed)
-            return;
-        this.active = active;
-        if (active) {
-            if (this.pausedRecoveryPending) {
-                this.pausedRecoveryPending = false;
-                void this.runRecovery();
-            }
-            else if (this.needsRebase) {
-                if (!this.recoveryRunning) {
-                    this.prepareRetainedLiveRebase();
-                    void this.runRecovery();
-                }
-            }
-            else if (this.state === 'live') {
-                this.drainRetainedLive();
-            }
-        }
-        this.emitState();
-    }
-    clear(startSequence = 1) {
-        if (this.disposed)
-            return;
-        this.cancelRecovery();
-        this.options.clear?.();
-        this.retainedLive = [];
-        this.retainedLiveBytes = 0;
-        this.pendingLiveWrites = [];
-        this.liveWriteScheduled = false;
-        this.pausedRecoveryPending = false;
-        this.writeChain = Promise.resolve();
-        this.baselineReady = false;
-        this.coveredThroughSequence = Math.max(0, Math.floor(startSequence) - 1);
-        this.scheduledThroughSequence = this.coveredThroughSequence;
-        this.recoveryEndSequence = undefined;
-        this.explicitAttachFence = false;
-        this.droppedLiveThroughSequence = 0;
-        this.retryAttempt = 0;
-        this.failure = null;
-        this.lastError = null;
-        this.historyRebasePrepared = false;
-        this.preparedHistory = null;
-        this.preparedHistoryOutcome = { status: 'not-provided', rebased: false };
-        this.setState('idle');
-        this.resolveBaselineWaiters();
-    }
-    retry() {
-        if (this.disposed || this.state !== 'failed')
-            return;
-        this.retryAttempt = 0;
-        this.failure = null;
-        void this.runRecovery();
-    }
-    getSnapshot() {
-        return {
-            state: this.state,
-            active: this.active,
-            baselineReady: this.baselineReady,
-            coveredThroughSequence: this.coveredThroughSequence,
-            retainedLiveChunks: this.retainedLive.length,
-            retainedLiveBytes: this.retainedLiveBytes,
-            retryAttempt: this.retryAttempt,
-            retryScheduled: this.retryTimer !== null,
-            failure: this.failure,
-            lastError: this.lastError,
-            attachGeneration: this.generation,
-            disposed: this.disposed,
-            preparedHistoryOutcome: { ...this.preparedHistoryOutcome },
-        };
-    }
-    dispose() {
-        if (this.disposed)
-            return;
-        this.disposed = true;
-        this.cancelRecovery();
-        this.retainedLive = [];
-        this.retainedLiveBytes = 0;
-        this.pendingLiveWrites = [];
-        this.liveWriteScheduled = false;
-        this.pausedRecoveryPending = false;
-        this.preparedHistory = null;
-        this.setState('disposed');
-        this.resolveBaselineWaiters();
-    }
-    beginCatchUp(startSequence) {
-        if (this.disposed || this.recoveryRunning || this.state === 'initial-replay')
-            return;
-        this.recoveryKind = 'catch-up';
-        this.recoveryStartSequence = Math.max(0, Math.floor(startSequence));
-        const firstRetainedSequence = this.firstRetainedLiveSequence();
-        this.recoveryEndSequence = firstRetainedSequence === undefined
-            ? undefined
-            : Math.max(0, firstRetainedSequence - 1);
-        this.retryAttempt = 0;
-        void this.runRecovery();
-    }
-    acceptPreparedHistory(preparedHistory) {
-        if (!preparedHistory || this.recoveryEndSequence === undefined)
-            return null;
-        try {
-            const requestedStart = normalizeSequence(preparedHistory.requestedStartSequence, 'preparedHistory.requestedStartSequence');
-            const firstRetained = normalizeSequence(preparedHistory.firstRetainedSequence, 'preparedHistory.firstRetainedSequence');
-            const coveredThrough = normalizeSequence(preparedHistory.coveredThroughSequence, 'preparedHistory.coveredThroughSequence');
-            const snapshotEnd = normalizeSequence(preparedHistory.snapshotEndSequence, 'preparedHistory.snapshotEndSequence');
-            normalizeSequence(preparedHistory.historyGeneration, 'preparedHistory.historyGeneration');
-            normalizeSequence(preparedHistory.byteLength, 'preparedHistory.byteLength');
-            normalizeSequence(preparedHistory.pageCount, 'preparedHistory.pageCount');
-            const expectedStart = Math.max(1, this.recoveryStartSequence);
-            if (requestedStart > expectedStart)
-                return null;
-            if (firstRetained > coveredThrough + 1)
-                return null;
-            if (coveredThrough < expectedStart - 1 || coveredThrough > snapshotEnd)
-                return null;
-            if (snapshotEnd > this.recoveryEndSequence || coveredThrough > this.recoveryEndSequence)
-                return null;
-            if (!Array.isArray(preparedHistory.chunks))
-                return null;
-            let previousChunkSequence = Math.max(0, firstRetained - 1);
-            let previousGeometry;
-            let preparedBytes = 0;
-            for (const chunk of preparedHistory.chunks) {
-                if (!(chunk.data instanceof Uint8Array))
-                    return null;
-                const sequence = normalizeSequence(chunk.sequence, 'preparedHistory.chunk.sequence');
-                if (sequence <= previousChunkSequence || sequence > coveredThrough)
-                    return null;
-                previousChunkSequence = sequence;
-                try {
-                    previousGeometry = validateHistoryGeometryOrder(previousGeometry, historyGeometryForChunk(chunk));
-                }
-                catch {
-                    return null;
-                }
-                preparedBytes += chunk.data.byteLength;
-            }
-            if (preparedBytes !== preparedHistory.byteLength)
-                return null;
-            if (coveredThrough >= Math.max(1, firstRetained)
-                && previousChunkSequence !== coveredThrough)
-                return null;
-            if (preparedHistory.complete !== (coveredThrough >= snapshotEnd))
-                return null;
-            if (firstRetained > expectedStart) {
-                this.markPreparedHistoryRebased(false);
-                this.options.clear?.();
-                this.options.onHistoryTruncated?.('history-evicted');
-            }
-            return preparedHistory;
-        }
-        catch {
-            return null;
-        }
-    }
-    discardPreparedHistoryForFullRecovery() {
-        this.markPreparedHistoryRebased(true);
-        this.preparedHistory = null;
-        this.coveredThroughSequence = Math.max(0, this.recoveryStartSequence - 1);
-        this.scheduledThroughSequence = this.coveredThroughSequence;
-        this.historyRebasePrepared = false;
-    }
-    async runRecovery() {
-        if (this.disposed || this.recoveryRunning)
-            return;
-        this.cancelRecovery(false);
-        const generation = this.generation;
-        const recoverySerial = ++this.recoverySerial;
-        const controller = new AbortController();
-        this.abortController = controller;
-        this.lastError = null;
-        this.failure = null;
-        this.recoveryRunning = true;
-        this.setState(this.recoveryKind === 'initial' ? 'initial-replay' : 'catching-up');
-        try {
-            await this.writeChain;
-            if (!this.isRecoveryCurrent(generation, recoverySerial, controller))
-                return;
-            const preparedHistory = this.preparedHistory;
-            const historyChunks = preparedHistory
-                ? preparedHistory.chunks.map(item => ({ ...item, data: new Uint8Array(item.data), source: 'history' }))
-                : [];
-            let cursor;
-            let startSequence = preparedHistory
-                ? Math.max(1, preparedHistory.coveredThroughSequence
-                    + (preparedHistory.coveredThroughSequence < (this.recoveryEndSequence ?? 0) ? 1 : 0))
-                : this.recoveryStartSequence;
-            let snapshotEnd = this.recoveryEndSequence;
-            let historyGeneration = preparedHistory?.historyGeneration;
-            let coveredEnd = preparedHistory?.coveredThroughSequence ?? this.coveredThroughSequence;
-            let firstPage = preparedHistory === null;
-            let restoredCheckpointSequence;
-            const preparedBaseline = preparedHistory === null
-                ? undefined
-                : Math.max(Math.max(1, this.recoveryStartSequence) - 1, preparedHistory.firstRetainedSequence - 1);
-            if (preparedBaseline !== undefined) {
-                this.coveredThroughSequence = preparedBaseline;
-                this.scheduledThroughSequence = preparedBaseline;
-            }
-            do {
-                const page = await this.options.fetchPage({
-                    startSequence,
-                    endSequence: snapshotEnd,
-                    historyGeneration,
-                    cursor,
-                    signal: controller.signal,
-                });
-                if (!this.isRecoveryCurrent(generation, recoverySerial, controller))
-                    return;
-                const pageSnapshotEnd = normalizeSequence(page.snapshotEndSequence, 'snapshotEndSequence', true);
-                const pageGeneration = normalizeSequence(page.historyGeneration, 'historyGeneration', true);
-                const firstRetained = normalizeSequence(page.firstRetainedSequence ?? page.firstAvailableSequence, 'firstRetainedSequence', true);
-                const pageCheckpoint = validateCheckpointForPage(page.checkpoint, page, Math.max(1, startSequence), pageSnapshotEnd, firstRetained);
-                let restoredCheckpointThisPage = false;
-                if (pageCheckpoint) {
-                    if (restoredCheckpointSequence !== undefined) {
-                        throw new HistoryContractError('history_checkpoint_invalid', 'terminal history checkpoint was repeated during pagination');
-                    }
-                    if (!this.options.restoreCheckpoint) {
-                        throw new HistoryContractError('history_checkpoint_missing', 'terminal history checkpoint restore is not configured');
-                    }
-                    try {
-                        await this.options.restoreCheckpoint(pageCheckpoint);
-                    }
-                    catch (error) {
-                        throw new HistoryContractError('history_checkpoint_restore_failed', 'terminal history checkpoint restore failed', pageCheckpoint.coveredThroughSequence);
-                    }
-                    restoredCheckpointSequence = pageCheckpoint.coveredThroughSequence;
-                    restoredCheckpointThisPage = true;
-                    this.coveredThroughSequence = pageCheckpoint.coveredThroughSequence;
-                    this.scheduledThroughSequence = pageCheckpoint.coveredThroughSequence;
-                    coveredEnd = Math.max(coveredEnd, pageCheckpoint.coveredThroughSequence);
-                    if (preparedHistory !== null)
-                        historyChunks.length = 0;
-                }
-                if (preparedHistory !== null
-                    && (pageSnapshotEnd === undefined || pageGeneration === undefined || firstRetained === undefined)) {
-                    this.discardPreparedHistoryForFullRecovery();
-                    this.recoveryRunning = false;
-                    await this.runRecovery();
-                    return;
-                }
-                const generationChanged = historyGeneration !== undefined
-                    && pageGeneration !== undefined
-                    && pageGeneration !== historyGeneration;
-                const effectivePageStart = Math.max(1, startSequence);
-                const retentionAdvanced = firstRetained !== undefined
-                    && (firstRetained > effectivePageStart
-                        || (preparedHistory !== null && firstRetained > preparedHistory.firstRetainedSequence));
-                const generationNeedsRebase = !restoredCheckpointThisPage && (page.historyReset || generationChanged);
-                const retentionNeedsRebase = !restoredCheckpointThisPage && (page.historyTruncated || retentionAdvanced);
-                if (retentionNeedsRebase && !pageCheckpoint && !this.historyRebasePrepared) {
-                    throw new HistoryContractError('history_checkpoint_missing', 'truncated terminal history requires a validated checkpoint', firstRetained);
-                }
-                const fencedRangeFullyEvicted = this.recoveryEndSequence !== undefined
-                    && firstRetained !== undefined
-                    && firstRetained > this.recoveryEndSequence;
-                if (!this.historyRebasePrepared && (generationNeedsRebase || retentionNeedsRebase)) {
-                    this.markPreparedHistoryRebased(preparedHistory !== null);
-                    this.preparedHistory = null;
-                    if (fencedRangeFullyEvicted) {
-                        this.options.clear?.();
-                        this.options.onHistoryTruncated?.('history-evicted');
-                        if (preparedHistory !== null)
-                            historyChunks.length = 0;
-                        if (generationNeedsRebase) {
-                            this.historyRebasePrepared = true;
-                            this.recoveryRunning = false;
-                            await this.runRecovery();
-                            return;
-                        }
-                    }
-                    else {
-                        this.prepareHistoryGenerationRebase(firstRetained);
-                        this.recoveryRunning = false;
-                        await this.runRecovery();
-                        return;
-                    }
-                }
-                if (this.historyRebasePrepared && generationNeedsRebase) {
-                    throw new HistoryContractError('history_contract_invalid', 'history generation reset persisted after rebase');
-                }
-                let coverage;
-                try {
-                    coverage = this.validatePage(page, coveredEnd);
-                }
-                catch (error) {
-                    if (preparedHistory === null)
-                        throw error;
-                    this.markPreparedHistoryRebased(true);
-                    this.preparedHistory = null;
-                    this.prepareHistoryGenerationRebase(firstRetained);
-                    this.recoveryRunning = false;
-                    await this.runRecovery();
-                    return;
-                }
-                if (snapshotEnd !== undefined && coverage > snapshotEnd) {
-                    throw new HistoryContractError('history_contract_invalid', 'coveredThroughSequence exceeded the recovery fence');
-                }
-                if (firstPage) {
-                    if (this.recoveryEndSequence !== undefined) {
-                        if (pageSnapshotEnd !== undefined && pageSnapshotEnd !== this.recoveryEndSequence) {
-                            throw new HistoryContractError('history_contract_invalid', 'snapshotEndSequence does not match the requested recovery fence');
-                        }
-                        snapshotEnd = this.recoveryEndSequence;
-                    }
-                    else {
-                        snapshotEnd = pageSnapshotEnd;
-                    }
-                    historyGeneration = pageGeneration;
-                    const effectiveStart = Math.max(1, startSequence);
-                    if (!restoredCheckpointThisPage && !fencedRangeFullyEvicted && firstRetained !== undefined && firstRetained > effectiveStart) {
-                        if (!this.historyRebasePrepared) {
-                            this.options.clear?.();
-                            this.options.onHistoryTruncated?.('history-evicted');
-                        }
-                        this.coveredThroughSequence = Math.max(0, (firstRetained ?? effectiveStart) - 1);
-                        this.scheduledThroughSequence = this.coveredThroughSequence;
-                    }
-                    this.historyRebasePrepared = false;
-                }
-                else {
-                    if (snapshotEnd !== undefined && pageSnapshotEnd !== undefined && pageSnapshotEnd !== snapshotEnd) {
-                        if (preparedHistory !== null) {
-                            this.markPreparedHistoryRebased(true);
-                            this.preparedHistory = null;
-                            this.prepareHistoryGenerationRebase(firstRetained);
-                            this.recoveryRunning = false;
-                            await this.runRecovery();
-                            return;
-                        }
-                        throw new HistoryContractError('history_contract_invalid', 'snapshotEndSequence changed during pagination');
-                    }
-                }
-                firstPage = false;
-                historyChunks.push(...page.chunks.map(item => ({ ...item, source: 'history' })));
-                coveredEnd = Math.max(coveredEnd, coverage);
-                cursor = page.nextCursor;
-                if (!page.hasMore)
-                    break;
-                if (cursor === undefined) {
-                    throw new HistoryContractError('history_contract_invalid', 'nextCursor is required when hasMore is true');
-                }
-                startSequence = coverage + 1;
-            } while (!controller.signal.aborted);
-            if (!this.isRecoveryCurrent(generation, recoverySerial, controller))
-                return;
-            if (this.recoveryEndSequence !== undefined && coveredEnd < this.recoveryEndSequence) {
-                throw new HistoryContractError('history_coverage_incomplete', 'terminal history coverage did not reach the recovery fence');
-            }
-            if (this.needsRebase) {
-                this.prepareRetainedLiveRebase();
-                this.recoveryRunning = false;
-                await this.runRecovery();
-                return;
-            }
-            const replayChunks = this.mergeRecoveryChunks(historyChunks, coveredEnd);
-            await this.writeOrdered(replayChunks, generation, () => this.isRecoveryCurrent(generation, recoverySerial, controller));
-            if (!this.isRecoveryCurrent(generation, recoverySerial, controller))
-                return;
-            if (this.needsRebase) {
-                this.prepareRetainedLiveRebase();
-                this.recoveryRunning = false;
-                await this.runRecovery();
-                return;
-            }
-            this.coveredThroughSequence = Math.max(this.coveredThroughSequence, coveredEnd);
-            this.scheduledThroughSequence = Math.max(this.scheduledThroughSequence, coveredEnd);
-            const firstRetainedSequence = this.firstRetainedLiveSequence();
-            if (this.recoveryKind === 'catch-up'
-                && firstRetainedSequence !== undefined
-                && firstRetainedSequence > coveredEnd + 1) {
-                throw new HistoryContractError('history_coverage_incomplete', 'terminal history coverage has not reached retained live output', firstRetainedSequence);
-            }
-            if (this.recoveryKind === 'initial' && !this.baselineReady) {
-                this.baselineReady = true;
-                this.resolveBaselineWaiters();
-                this.emitState();
-            }
-            this.retryAttempt = 0;
-            this.lastError = null;
-            this.failure = null;
-            this.preparedHistory = null;
-            this.setState('live');
-            this.recoveryRunning = false;
-            this.drainRetainedLive();
-            await this.writeChain;
-        }
-        catch (error) {
-            if (!this.isRecoveryCurrent(generation, recoverySerial, controller))
-                return;
-            this.lastError = error;
-            const contract = error instanceof HistoryContractError ? error : null;
-            this.failure = {
-                code: contract?.code ?? 'history_fetch_failed',
-                phase: this.recoveryKind === 'initial' ? 'initial' : 'catch_up',
-                retryable: contract?.code !== 'history_contract_missing'
-                    && contract?.code !== 'history_contract_invalid'
-                    && contract?.code !== 'history_checkpoint_missing'
-                    && contract?.code !== 'history_checkpoint_invalid'
-                    && contract?.code !== 'history_checkpoint_restore_failed',
-                attempt: this.retryAttempt,
-                coveredSequence: this.coveredThroughSequence,
-                firstRetainedSequence: contract?.firstRetainedSequence,
-                attachGeneration: generation,
-                cause: error,
-            };
-            this.recoveryRunning = false;
-            this.scheduleRetry();
-        }
-    }
-    validatePage(page, previousCoverage) {
-        if (!Object.prototype.hasOwnProperty.call(page, 'coveredThroughSequence')) {
-            throw new HistoryContractError('history_contract_missing', 'coveredThroughSequence is required');
-        }
-        const coverage = normalizeSequence(page.coveredThroughSequence, 'coveredThroughSequence');
-        if (coverage < previousCoverage) {
-            throw new HistoryContractError('history_contract_invalid', 'coveredThroughSequence regressed');
-        }
-        return coverage;
-    }
-    mergeRecoveryChunks(history, coveredEnd) {
-        const selected = new Map();
-        const unsequenced = [];
-        for (const item of history) {
-            const sequence = this.chunkSequence(item);
-            if (sequence === undefined)
-                unsequenced.push(item);
-            else if (sequence > this.coveredThroughSequence && sequence <= coveredEnd)
-                selected.set(sequence, item);
-        }
-        const remaining = [];
-        let remainingBytes = 0;
-        for (const item of this.retainedLive) {
-            const sequence = this.chunkSequence(item);
-            if (sequence !== undefined && sequence <= coveredEnd) {
-                // A live copy preserves terminal query/response semantics that history replay suppresses.
-                selected.set(sequence, item);
-            }
-            else {
-                remaining.push(item);
-                remainingBytes += item.data.byteLength;
-            }
-        }
-        this.retainedLive = remaining;
-        this.retainedLiveBytes = remainingBytes;
-        return [
-            ...[...selected.entries()].sort(([left], [right]) => left - right).map(([, item]) => item),
-            ...unsequenced,
-        ];
-    }
-    async writeOrdered(chunks, generation, canStartBatch = () => this.isCurrent(generation)) {
-        let batch = [];
-        let batchBytes = 0;
-        let batchSource;
-        let batchGeometry;
-        let previousHistoryGeometry;
-        const flush = async () => {
-            if (batch.length === 0 || !this.isCurrent(generation) || !canStartBatch())
-                return;
-            const current = batch;
-            const source = batchSource;
-            const geometry = batchGeometry;
-            batch = [];
-            batchBytes = 0;
-            batchSource = undefined;
-            batchGeometry = undefined;
-            const accepted = [];
-            const data = [];
-            for (const item of current) {
-                const transformed = this.options.transformChunk ? this.options.transformChunk(item) : item.data;
-                if (transformed === null)
-                    continue;
-                accepted.push({ ...item, data: transformed });
-                data.push(transformed);
-            }
-            if (accepted.length === 0 || !this.isCurrent(generation))
-                return;
-            const writer = source === 'history' ? (this.options.writeHistory ?? this.options.write) : this.options.write;
-            if (source === 'history') {
-                if (!geometry) {
-                    throw new HistoryContractError('history_contract_missing', 'history batch geometry is required');
-                }
-                await this.options.applyHistoryGeometry?.(geometry);
-            }
-            await this.invokeWriter(writer, concatData(data), accepted, generation);
-        };
-        for (const item of chunks) {
-            const source = item.source ?? 'live';
-            let itemGeometry;
-            if (source === 'history') {
-                itemGeometry = historyGeometryForChunk(item);
-                previousHistoryGeometry = validateHistoryGeometryOrder(previousHistoryGeometry, itemGeometry);
-            }
-            else if (item.geometryGeneration !== undefined
-                && item.cols !== undefined
-                && item.rows !== undefined) {
-                // Live batches carry the PTY geometry that produced their bytes. Keep
-                // geometry transitions as writer boundaries so relative cursor output
-                // is never concatenated across grids.
-                itemGeometry = historyGeometryForChunk(item);
-            }
-            if (batch.length > 0 && (source !== batchSource || batchBytes + item.data.byteLength > this.policy.maxWriteBatchBytes
-                || (batchGeometry && itemGeometry && !sameHistoryGeometry(batchGeometry, itemGeometry)))) {
-                await flush();
-            }
-            batchSource = source;
-            batchGeometry = itemGeometry;
-            batch.push(item);
-            batchBytes += item.data.byteLength;
-        }
-        await flush();
-    }
-    scheduleRetry() {
-        if (this.failure && !this.failure.retryable) {
-            this.setState('failed');
-            if (!this.baselineReady)
-                this.resolveBaselineWaiters();
-            return;
-        }
-        const delay = this.policy.retryDelaysMs[this.retryAttempt];
-        if (delay === undefined) {
-            this.setState('failed');
-            if (!this.baselineReady)
-                this.resolveBaselineWaiters();
-            return;
-        }
-        this.retryAttempt += 1;
-        this.setState('retry-wait');
-        const generation = this.generation;
-        const setTimer = this.options.scheduler?.setTimer ?? setTimeout;
-        this.retryTimer = setTimer(() => {
-            this.retryTimer = null;
-            if (!this.isCurrent(generation))
-                return;
-            void this.runRecovery();
-        }, delay);
-        this.emitState();
-    }
-    retainLive(chunk) {
-        this.retainedLive.push(chunk);
-        this.retainedLiveBytes += chunk.data.byteLength;
-        while (this.retainedLive.length > this.policy.maxRetainedLiveChunks
-            || this.retainedLiveBytes > this.policy.maxRetainedLiveBytes) {
-            const removed = this.retainedLive.shift();
-            if (!removed)
-                break;
-            this.retainedLiveBytes -= removed.data.byteLength;
-            const removedSequence = this.chunkSequence(removed);
-            if (removedSequence !== undefined) {
-                this.droppedLiveThroughSequence = Math.max(this.droppedLiveThroughSequence, removedSequence);
-            }
-            this.needsRebase = true;
-        }
-        this.emitState();
-    }
-    prepareRetainedLiveRebase() {
-        this.markPreparedHistoryRebased(false);
-        this.needsRebase = false;
-        this.historyRebasePrepared = false;
-        this.recoveryKind = this.baselineReady ? 'catch-up' : 'initial';
-        this.recoveryStartSequence = 0;
-        const firstRetainedSequence = this.firstRetainedLiveSequence();
-        this.recoveryEndSequence = Math.max(this.droppedLiveThroughSequence, firstRetainedSequence === undefined ? 0 : firstRetainedSequence - 1) || undefined;
-        this.droppedLiveThroughSequence = 0;
-        this.coveredThroughSequence = 0;
-        this.scheduledThroughSequence = 0;
-        this.options.clear?.();
-        this.options.onHistoryTruncated?.('retained-live-overflow');
-    }
-    prepareHistoryGenerationRebase(firstRetainedSequence) {
-        this.recoveryKind = this.baselineReady ? 'catch-up' : 'initial';
-        this.recoveryStartSequence = 0;
-        this.coveredThroughSequence = 0;
-        this.scheduledThroughSequence = 0;
-        this.options.clear?.();
-        this.options.onHistoryTruncated?.('history-evicted');
-        this.historyRebasePrepared = true;
-        if (firstRetainedSequence !== undefined && firstRetainedSequence > 1) {
-            this.recoveryStartSequence = firstRetainedSequence;
-            this.coveredThroughSequence = firstRetainedSequence - 1;
-            this.scheduledThroughSequence = this.coveredThroughSequence;
-        }
-    }
-    markPreparedHistoryRebased(discard) {
-        if (this.preparedHistoryOutcome.status === 'not-provided')
-            return;
-        this.preparedHistoryOutcome = {
-            status: discard ? 'rejected' : this.preparedHistoryOutcome.status,
-            rebased: true,
-        };
-    }
-    canRenderLive() {
-        return this.active && (this.options.isInteractive?.() ?? true);
-    }
-    acceptLive(chunk) {
-        const sequence = this.chunkSequence(chunk);
-        if (sequence !== undefined && sequence <= this.scheduledThroughSequence)
-            return;
-        if (sequence !== undefined
-            && this.explicitAttachFence
-            && this.scheduledThroughSequence === 0
-            && sequence > 1) {
-            this.retainLive(chunk);
-            this.beginCatchUp(1);
-            return;
-        }
-        if (sequence !== undefined
-            && this.scheduledThroughSequence > 0
-            && sequence > this.scheduledThroughSequence + 1) {
-            this.retainLive(chunk);
-            this.beginCatchUp(this.scheduledThroughSequence + 1);
-            return;
-        }
-        if (sequence !== undefined && this.scheduledThroughSequence === 0) {
-            this.coveredThroughSequence = sequence - 1;
-            this.scheduledThroughSequence = sequence - 1;
-        }
-        this.enqueueLiveWrite(chunk);
-    }
-    enqueueLiveWrite(chunk) {
-        const generation = this.generation;
-        const sequence = this.chunkSequence(chunk);
-        if (sequence !== undefined)
-            this.scheduledThroughSequence = Math.max(this.scheduledThroughSequence, sequence);
-        this.pendingLiveWrites.push(chunk);
-        if (this.liveWriteScheduled)
-            return;
-        this.liveWriteScheduled = true;
-        this.writeChain = this.writeChain.then(async () => {
-            if (!this.isCurrent(generation))
-                return;
-            const pending = this.pendingLiveWrites.splice(0);
-            this.liveWriteScheduled = false;
-            await this.writeOrdered(pending, generation);
-        }).catch(error => {
-            this.liveWriteScheduled = false;
-            if (!this.isCurrent(generation))
-                return;
-            this.lastError = error;
-            this.failure = {
-                code: 'history_fetch_failed',
-                phase: 'catch_up',
-                retryable: true,
-                attempt: this.retryAttempt,
-                coveredSequence: this.coveredThroughSequence,
-                attachGeneration: generation,
-                cause: error,
-            };
-            this.setState('failed');
-        });
-    }
-    drainRetainedLive() {
-        if (!this.canRenderLive() || this.retainedLive.length === 0 || this.state !== 'live')
-            return;
-        const retained = [...this.retainedLive].sort((left, right) => ((this.chunkSequence(left) ?? Number.MAX_SAFE_INTEGER)
-            - (this.chunkSequence(right) ?? Number.MAX_SAFE_INTEGER)));
-        this.retainedLive = [];
-        this.retainedLiveBytes = 0;
-        for (let index = 0; index < retained.length; index += 1) {
-            this.acceptLive(retained[index]);
-            if (this.state !== 'live') {
-                for (const pending of retained.slice(index + 1))
-                    this.retainLive(pending);
-                break;
-            }
-        }
-    }
-    async invokeWriter(writer, data, chunks, generation) {
-        this.activeWriters += 1;
-        try {
-            await writer(data, chunks);
-            if (!this.isCurrent(generation))
-                return;
-            for (const item of chunks) {
-                const sequence = this.chunkSequence(item);
-                if (sequence !== undefined) {
-                    this.coveredThroughSequence = Math.max(this.coveredThroughSequence, sequence);
-                    this.scheduledThroughSequence = Math.max(this.scheduledThroughSequence, sequence);
-                }
-            }
-        }
-        finally {
-            this.activeWriters -= 1;
-            if (this.activeWriters === 0) {
-                const waiters = this.writerQuiescenceWaiters.splice(0);
-                for (const resolve of waiters)
-                    resolve();
-            }
-        }
-    }
-    waitForWriterQuiescence() {
-        if (this.activeWriters === 0)
-            return Promise.resolve();
-        return new Promise(resolve => this.writerQuiescenceWaiters.push(resolve));
-    }
-    chunkSequence(chunk) {
-        const sequence = chunk.sequence;
-        return typeof sequence === 'number' && Number.isSafeInteger(sequence) && sequence > 0
-            ? sequence
-            : undefined;
-    }
-    firstRetainedLiveSequence() {
-        let first;
-        for (const item of this.retainedLive) {
-            const sequence = this.chunkSequence(item);
-            if (sequence !== undefined && (first === undefined || sequence < first))
-                first = sequence;
-        }
-        return first;
-    }
-    isCurrent(generation) {
-        return !this.disposed && generation === this.generation;
-    }
-    isRecoveryCurrent(generation, recoverySerial, controller) {
-        return this.isCurrent(generation)
-            && recoverySerial === this.recoverySerial
-            && !controller.signal.aborted;
-    }
-    cancelRecovery(incrementGeneration = true) {
-        this.abortController?.abort();
-        this.abortController = null;
-        this.recoveryRunning = false;
-        this.recoverySerial += 1;
-        if (this.retryTimer !== null) {
-            const clearTimer = this.options.scheduler?.clearTimer ?? clearTimeout;
-            clearTimer(this.retryTimer);
-            this.retryTimer = null;
-        }
-        if (incrementGeneration)
-            this.generation += 1;
-    }
-    resolveBaselineWaiters() {
-        if (this.baselineWaiters.length === 0)
-            return;
-        const snapshot = this.getSnapshot();
-        const waiters = this.baselineWaiters.splice(0);
-        for (const resolve of waiters)
-            resolve(snapshot);
-    }
-    setState(state) {
-        this.state = state;
-        this.emitState();
-    }
-    emitState() {
-        this.options.onStateChange?.(this.getSnapshot());
-    }
-}
-export const createPagedTerminalOutputCoordinator = (options) => new PagedTerminalOutputCoordinator(options);
-//# sourceMappingURL=PagedTerminalOutputCoordinator.js.map