@floegence/floeterm-terminal-web 0.5.14 → 0.5.16

package/dist/core/PagedTerminalOutputCoordinator.js

@@ -1,12 +1,20 @@
-import { createTerminalOutputPipeline, } from './TerminalOutputPipeline';
 const DEFAULT_POLICY = {
     maxRetainedLiveChunks: 2048,
     maxRetainedLiveBytes: 8 * 1024 * 1024,
     retryDelaysMs: [250, 1000, 4000],
+    maxWriteBatchBytes: 256 * 1024,
 };
-const normalizePositiveInteger = (value, fallback) => (typeof value === 'number' && Number.isFinite(value) && value > 0
-    ? Math.floor(value)
+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);
@@ -17,22 +25,40 @@ const concatData = (chunks) => {
     }
     return result;
 };
+class HistoryContractError extends Error {
+    constructor(code, message, firstRetainedSequence) {
+        super(message);
+        this.name = 'HistoryContractError';
+        this.code = code;
+        this.firstRetainedSequence = firstRetainedSequence;
+    }
+}
 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.recoveryKind = 'initial';
+        this.recoveryRunning = false;
         this.needsRebase = false;
+        this.historyRebasePrepared = false;
+        this.writeChain = Promise.resolve();
+        this.pendingLiveWrites = [];
+        this.liveWriteScheduled = false;
+        this.baselineWaiters = [];
         this.options = options;
         this.policy = {
             maxRetainedLiveChunks: normalizePositiveInteger(options.policy?.maxRetainedLiveChunks, DEFAULT_POLICY.maxRetainedLiveChunks),
@@ -40,39 +66,46 @@ class PagedTerminalOutputCoordinator {
             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),
         };
-        const pipelinePolicy = {
-            maxInactiveChunks: this.policy.maxRetainedLiveChunks,
-            maxInactiveBytes: this.policy.maxRetainedLiveBytes,
-        };
-        this.pipeline = createTerminalOutputPipeline({
-            write: (_data, chunks) => this.writeAcceptedChunks(chunks),
-            isInteractive: () => true,
-            policy: pipelinePolicy,
-            scheduler: options.scheduler,
-        });
     }
     async attach(startSequence = 1) {
         if (this.disposed)
             return;
         this.cancelRecovery();
+        this.resolveBaselineWaiters();
         this.retainedLive = [];
         this.retainedLiveBytes = 0;
+        this.pendingLiveWrites = [];
+        this.liveWriteScheduled = false;
+        this.writeChain = Promise.resolve();
+        this.baselineReady = false;
         this.coveredThroughSequence = Math.max(0, Math.floor(startSequence) - 1);
-        this.pipeline.reset({ startSequence: this.coveredThroughSequence + 1 });
+        this.scheduledThroughSequence = this.coveredThroughSequence;
         this.recoveryKind = 'initial';
         this.recoveryStartSequence = Math.max(0, Math.floor(startSequence));
         this.retryAttempt = 0;
+        this.failure = null;
+        this.lastError = null;
+        this.historyRebasePrepared = false;
         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));
+    }
     pushLive(chunk) {
         if (this.disposed)
             return;
+        const tagged = { ...chunk, source: 'live' };
         if (this.state !== 'live' || !this.canRenderLive()) {
-            this.retainLive(chunk);
+            this.retainLive(tagged);
             return;
         }
-        this.acceptLive(chunk);
+        this.acceptLive(tagged);
     }
     setActive(active) {
         if (this.disposed)
@@ -80,16 +113,13 @@ class PagedTerminalOutputCoordinator {
         this.active = active;
         if (active) {
             if (this.needsRebase) {
-                this.needsRebase = false;
-                this.recoveryKind = 'catch-up';
-                this.recoveryStartSequence = 0;
-                this.options.clear?.();
-                this.options.onHistoryTruncated?.('retained-live-overflow');
-                void this.runRecovery();
+                if (!this.recoveryRunning) {
+                    this.prepareRetainedLiveRebase();
+                    void this.runRecovery();
+                }
             }
-            else {
-                this.drainRetainedLive(new Set());
-                this.pipeline.flush();
+            else if (this.state === 'live') {
+                this.drainRetainedLive();
             }
         }
         this.emitState();
@@ -101,28 +131,39 @@ class PagedTerminalOutputCoordinator {
         this.options.clear?.();
         this.retainedLive = [];
         this.retainedLiveBytes = 0;
+        this.pendingLiveWrites = [];
+        this.liveWriteScheduled = false;
+        this.writeChain = Promise.resolve();
+        this.baselineReady = false;
         this.coveredThroughSequence = Math.max(0, Math.floor(startSequence) - 1);
-        this.pipeline.reset({ startSequence: this.coveredThroughSequence + 1 });
+        this.scheduledThroughSequence = this.coveredThroughSequence;
         this.retryAttempt = 0;
+        this.failure = null;
         this.lastError = null;
+        this.historyRebasePrepared = 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 + this.pipeline.getStats().catchUpChunks,
-            retainedLiveBytes: this.retainedLiveBytes + this.pipeline.getStats().catchUpBytes,
+            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,
         };
     }
@@ -133,11 +174,13 @@ class PagedTerminalOutputCoordinator {
         this.cancelRecovery();
         this.retainedLive = [];
         this.retainedLiveBytes = 0;
-        this.pipeline.dispose();
+        this.pendingLiveWrites = [];
+        this.liveWriteScheduled = false;
         this.setState('disposed');
+        this.resolveBaselineWaiters();
     }
     beginCatchUp(startSequence) {
-        if (this.disposed || this.state === 'initial-replay')
+        if (this.disposed || this.recoveryRunning || this.state === 'initial-replay')
             return;
         this.recoveryKind = 'catch-up';
         this.recoveryStartSequence = Math.max(0, Math.floor(startSequence));
@@ -145,99 +188,254 @@ class PagedTerminalOutputCoordinator {
         void this.runRecovery();
     }
     async runRecovery() {
-        if (this.disposed)
+        if (this.disposed || this.recoveryRunning)
             return;
         this.cancelRecovery(false);
-        const generation = ++this.generation;
+        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 {
-            const replayedSequences = new Set();
+            await this.writeChain;
+            if (!this.isRecoveryCurrent(generation, recoverySerial, controller))
+                return;
+            const historyChunks = [];
             let cursor;
             let startSequence = this.recoveryStartSequence;
+            let snapshotEnd;
+            let historyGeneration;
+            let coveredEnd = this.coveredThroughSequence;
             let firstPage = true;
             do {
                 const page = await this.options.fetchPage({
                     startSequence,
+                    endSequence: snapshotEnd,
+                    historyGeneration,
                     cursor,
                     signal: controller.signal,
                 });
-                if (this.disposed || generation !== this.generation)
+                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 generationChanged = historyGeneration !== undefined
+                    && pageGeneration !== undefined
+                    && pageGeneration !== historyGeneration;
+                const effectivePageStart = Math.max(1, startSequence);
+                const retentionAdvanced = firstRetained !== undefined
+                    && firstRetained > effectivePageStart;
+                const generationNeedsRebase = page.historyReset || generationChanged;
+                const retentionNeedsRebase = page.historyTruncated || retentionAdvanced;
+                if (!this.historyRebasePrepared && (generationNeedsRebase || retentionNeedsRebase)) {
+                    this.prepareHistoryGenerationRebase(firstRetained);
+                    this.recoveryRunning = false;
+                    await this.runRecovery();
                     return;
-                const firstAvailable = page.firstAvailableSequence;
-                if (firstPage && firstAvailable && startSequence > 0 && firstAvailable > startSequence) {
-                    this.options.clear?.();
-                    this.options.onHistoryTruncated?.('history-evicted');
-                    this.coveredThroughSequence = firstAvailable - 1;
-                    this.pipeline.reset({ startSequence: firstAvailable });
                 }
-                firstPage = false;
-                const replayChunks = page.chunks.filter(chunk => (!chunk.sequence || chunk.sequence > this.coveredThroughSequence));
-                for (const chunk of replayChunks) {
-                    if (chunk.sequence)
-                        replayedSequences.add(chunk.sequence);
+                if (this.historyRebasePrepared && generationNeedsRebase) {
+                    throw new HistoryContractError('history_contract_invalid', 'history generation reset persisted after rebase');
+                }
+                const coverage = this.validatePage(page, coveredEnd);
+                if (firstPage) {
+                    snapshotEnd = pageSnapshotEnd;
+                    historyGeneration = pageGeneration;
+                    const effectiveStart = Math.max(1, startSequence);
+                    if (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;
                 }
-                this.writeAcceptedChunks(replayChunks);
-                this.coveredThroughSequence = Math.max(this.coveredThroughSequence, Math.floor(page.coveredThroughSequence || 0));
+                else {
+                    if (snapshotEnd !== undefined && pageSnapshotEnd !== undefined && pageSnapshotEnd !== snapshotEnd) {
+                        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;
-                startSequence = this.coveredThroughSequence + 1;
                 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.disposed || generation !== this.generation)
+            if (!this.isRecoveryCurrent(generation, recoverySerial, controller))
                 return;
             if (this.needsRebase) {
-                this.needsRebase = false;
-                this.options.clear?.();
-                this.pipeline.reset({ startSequence: 1 });
-                this.coveredThroughSequence = 0;
-                this.recoveryStartSequence = 0;
-                this.options.onHistoryTruncated?.('retained-live-overflow');
+                this.prepareRetainedLiveRebase();
+                this.recoveryRunning = false;
                 await this.runRecovery();
                 return;
             }
-            let firstRetainedSequence;
-            for (const chunk of this.retainedLive) {
-                const sequence = chunk.sequence;
-                if (typeof sequence === 'number'
-                    && Number.isFinite(sequence)
-                    && sequence > 0
-                    && (firstRetainedSequence === undefined || sequence < firstRetainedSequence)) {
-                    firstRetainedSequence = Math.floor(sequence);
-                }
+            const replayChunks = this.mergeRecoveryChunks(historyChunks, coveredEnd);
+            await this.writeOrdered(replayChunks, generation);
+            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
-                && firstRetainedSequence > this.coveredThroughSequence + 1) {
-                throw new Error('terminal history coverage has not reached retained live output');
+                && 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.pipeline.reset();
             this.retryAttempt = 0;
             this.lastError = null;
+            this.failure = null;
             this.setState('live');
-            this.drainRetainedLive(replayedSequences);
-            this.pipeline.flushNow();
+            this.recoveryRunning = false;
+            this.drainRetainedLive();
         }
         catch (error) {
-            if (controller.signal.aborted || this.disposed || generation !== this.generation)
+            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',
+                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) {
+                if (!selected.has(sequence))
+                    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) {
+        let batch = [];
+        let batchBytes = 0;
+        let batchSource;
+        const flush = async () => {
+            if (batch.length === 0 || !this.isCurrent(generation))
+                return;
+            const current = batch;
+            const source = batchSource;
+            batch = [];
+            batchBytes = 0;
+            batchSource = 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;
+            await writer(concatData(data), accepted);
+            if (!this.isCurrent(generation))
+                return;
+            for (const item of accepted) {
+                const sequence = this.chunkSequence(item);
+                if (sequence !== undefined) {
+                    this.coveredThroughSequence = Math.max(this.coveredThroughSequence, sequence);
+                    this.scheduledThroughSequence = Math.max(this.scheduledThroughSequence, sequence);
+                }
+            }
+        };
+        for (const item of chunks) {
+            const source = item.source ?? 'live';
+            if (batch.length > 0 && (source !== batchSource || batchBytes + item.data.byteLength > this.policy.maxWriteBatchBytes)) {
+                await flush();
+            }
+            batchSource = source;
+            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();
@@ -255,93 +453,129 @@ class PagedTerminalOutputCoordinator {
         }
         this.emitState();
     }
+    prepareRetainedLiveRebase() {
+        this.needsRebase = false;
+        this.historyRebasePrepared = false;
+        this.recoveryKind = this.baselineReady ? 'catch-up' : 'initial';
+        this.recoveryStartSequence = 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;
+        }
+    }
     canRenderLive() {
         return this.active && (this.options.isInteractive?.() ?? true);
     }
     acceptLive(chunk) {
-        const sequence = typeof chunk.sequence === 'number' && Number.isFinite(chunk.sequence) && chunk.sequence > 0
-            ? Math.floor(chunk.sequence)
-            : undefined;
-        if (sequence && sequence <= this.coveredThroughSequence) {
+        const sequence = this.chunkSequence(chunk);
+        if (sequence !== undefined && sequence <= this.scheduledThroughSequence)
             return;
-        }
-        if (sequence && this.coveredThroughSequence > 0 && sequence > this.coveredThroughSequence + 1) {
-            this.pipeline.flushNow();
-            this.retainLive({ ...chunk, sequence });
-            this.beginCatchUp(this.coveredThroughSequence + 1);
+        if (sequence !== undefined
+            && this.scheduledThroughSequence > 0
+            && sequence > this.scheduledThroughSequence + 1) {
+            this.retainLive(chunk);
+            this.beginCatchUp(this.scheduledThroughSequence + 1);
             return;
         }
-        this.enqueueForRender(sequence ? { ...chunk, sequence } : chunk);
-    }
-    enqueueForRender(chunk) {
-        const sequence = chunk.sequence;
-        const pipelineChunk = {
-            ...chunk,
-            sequence: undefined,
-            coordinatorSequence: sequence,
-        };
-        this.pipeline.enqueue(pipelineChunk);
-        if (sequence) {
-            this.coveredThroughSequence = Math.max(this.coveredThroughSequence, sequence);
+        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;
+            await Promise.resolve();
+            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(replayedSequences) {
-        if (!this.canRenderLive() || this.retainedLive.length === 0)
+    drainRetainedLive() {
+        if (!this.canRenderLive() || this.retainedLive.length === 0 || this.state !== 'live')
             return;
-        const retained = [...this.retainedLive].sort((left, right) => ((left.sequence ?? 0) - (right.sequence ?? 0)));
+        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;
-        const firstSequence = retained.find(chunk => chunk.sequence)?.sequence;
-        if (this.coveredThroughSequence === 0 && firstSequence && replayedSequences.size === 0) {
-            this.coveredThroughSequence = firstSequence - 1;
-        }
         for (let index = 0; index < retained.length; index += 1) {
-            const chunk = retained[index];
-            if (chunk.sequence && replayedSequences.has(chunk.sequence))
-                continue;
-            if (chunk.sequence && chunk.sequence <= this.coveredThroughSequence) {
-                this.enqueueForRender(chunk);
-                continue;
-            }
-            this.acceptLive(chunk);
+            this.acceptLive(retained[index]);
             if (this.state !== 'live') {
-                for (const pending of retained.slice(index + 1)) {
+                for (const pending of retained.slice(index + 1))
                     this.retainLive(pending);
-                }
                 break;
             }
         }
     }
-    writeAcceptedChunks(chunks) {
-        if (chunks.length === 0)
-            return;
-        const acceptedChunks = [];
-        const data = [];
-        for (const queuedChunk of chunks) {
-            const coordinatorSequence = queuedChunk.coordinatorSequence;
-            const chunk = coordinatorSequence
-                ? { ...queuedChunk, sequence: coordinatorSequence }
-                : queuedChunk;
-            const transformed = this.options.transformChunk
-                ? this.options.transformChunk(chunk)
-                : chunk.data;
-            if (transformed === null)
-                continue;
-            acceptedChunks.push({ ...chunk, data: transformed });
-            data.push(transformed);
-        }
-        if (acceptedChunks.length > 0) {
-            this.options.write(concatData(data), acceptedChunks);
-            for (const chunk of acceptedChunks) {
-                if (chunk.sequence) {
-                    this.coveredThroughSequence = Math.max(this.coveredThroughSequence, chunk.sequence);
-                }
-            }
+    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);
@@ -350,6 +584,14 @@ class PagedTerminalOutputCoordinator {
         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();