@peerbit/shared-log 13.2.33 → 13.2.35

package/dist/src/replication-info-v2-receive.js

@@ -10,6 +10,7 @@ const DEFAULT_MAX_REQUEST_RETRY_MS = 30_000;
 const DEFAULT_REQUEST_MAX_ATTEMPTS = 7;
 const DEFAULT_LEGACY_FALLBACK_DELAY_MS = 5_000;
 const MAX_U64 = (1n << 64n) - 1n;
+const MAX_BACKOFF_EXPONENT = 20;
 const bytesEqual = (left, right) => {
     if (left.byteLength !== right.byteLength) {
         return false;
@@ -41,6 +42,8 @@ export class ReplicationInfoV2ReceiveCoordinator {
     _receiveStates;
     _cutoverPeerSessions;
     _localCapabilityReadyBySession;
+    _localCapabilityContextBySession;
+    _localCapabilityAdvertisementsByPeer;
     _reservedAdmissionsByPeer;
     now;
     requestRetryMs;
@@ -57,6 +60,8 @@ export class ReplicationInfoV2ReceiveCoordinator {
         this._receiveStates = new Map();
         this._cutoverPeerSessions = new WeakSet();
         this._localCapabilityReadyBySession = new WeakMap();
+        this._localCapabilityContextBySession = new WeakMap();
+        this._localCapabilityAdvertisementsByPeer = new Map();
         this._reservedAdmissionsByPeer = new Map();
     }
     resetForOpen() {
@@ -64,25 +69,41 @@ export class ReplicationInfoV2ReceiveCoordinator {
         this._receiveStates = new Map();
         this._cutoverPeerSessions = new WeakSet();
         this._localCapabilityReadyBySession = new WeakMap();
+        this._localCapabilityContextBySession = new WeakMap();
+        this._localCapabilityAdvertisementsByPeer = new Map();
         this._reservedAdmissionsByPeer = new Map();
     }
     clearForClose() {
+        for (const advertisement of [
+            ...(this._localCapabilityAdvertisementsByPeer?.values() ?? []),
+        ]) {
+            this.clearLocalCapabilityAdvertisement(advertisement);
+        }
+        this._localCapabilityAdvertisementsByPeer?.clear();
         for (const state of this._receiveStates?.values() ?? []) {
             this.clearState(state);
         }
         this._receiveStates?.clear();
         this._cutoverPeerSessions = new WeakSet();
         this._localCapabilityReadyBySession = new WeakMap();
+        this._localCapabilityContextBySession = new WeakMap();
     }
     clearPeer(peerHash, expectedSession) {
+        const advertisement = this._localCapabilityAdvertisementsByPeer.get(peerHash);
+        if (advertisement &&
+            (!expectedSession || advertisement.peerSession === expectedSession)) {
+            this.clearLocalCapabilityAdvertisement(advertisement);
+        }
         const state = this._receiveStates.get(peerHash);
         if (state && (!expectedSession || state.peerSession === expectedSession)) {
             this.clearState(state);
             this._localCapabilityReadyBySession.delete(state.peerSession);
+            this._localCapabilityContextBySession.delete(state.peerSession);
             this._cutoverPeerSessions.delete(state.peerSession);
         }
         if (expectedSession) {
             this._localCapabilityReadyBySession.delete(expectedSession);
+            this._localCapabilityContextBySession.delete(expectedSession);
             this._cutoverPeerSessions.delete(expectedSession);
         }
     }
@@ -112,8 +133,345 @@ export class ReplicationInfoV2ReceiveCoordinator {
             this._receiveStates.delete(state.peerHash);
         }
     }
+    clearLocalCapabilityAdvertisement(state, options) {
+        if (state.timer) {
+            clearTimeout(state.timer);
+            state.timer = undefined;
+        }
+        state.lifecycleSignal.removeEventListener("abort", state.onLifecycleAbort);
+        state.controller.abort();
+        const wasMapped = this._localCapabilityAdvertisementsByPeer.get(state.peerHash) === state;
+        if (wasMapped) {
+            this._localCapabilityAdvertisementsByPeer.delete(state.peerHash);
+        }
+        const ready = this._localCapabilityReadyBySession.get(state.peerSession);
+        if (ready?.advertisement === state) {
+            this._localCapabilityReadyBySession.delete(state.peerSession);
+        }
+        if (wasMapped &&
+            !options?.preserveContext &&
+            this._localCapabilityContextBySession.get(state.peerSession) ===
+                state.context) {
+            this._localCapabilityContextBySession.delete(state.peerSession);
+        }
+    }
+    isLocalCapabilityAdvertisementOwnerCurrent(state) {
+        return (this._localCapabilityAdvertisementsByPeer.get(state.peerHash) === state &&
+            this._localCapabilityContextBySession.get(state.peerSession) ===
+                state.context &&
+            state.context.peerHash === state.peerHash &&
+            state.context.lifecycleSignal === state.lifecycleSignal &&
+            state.context.target.equals(state.target) &&
+            !state.controller.signal.aborted &&
+            !state.lifecycleSignal.aborted &&
+            !this.deps.isClosed() &&
+            this.deps.isPeerSessionCurrent(state.peerHash, state.peerSession) &&
+            (state.receiverTransportSession === undefined ||
+                this.deps.getReceiverTransportSession() ===
+                    state.receiverTransportSession));
+    }
+    isLocalCapabilityAdvertisementGenerationCurrent(state) {
+        return (this.isLocalCapabilityAdvertisementOwnerCurrent(state) &&
+            this.deps.isReceiveEpochCurrent(state.peerHash, state.receiveEpoch));
+    }
+    isLocalCapabilityAdvertisementReadyOpen(state) {
+        return (this.isLocalCapabilityAdvertisementGenerationCurrent(state) &&
+            this.deps.isPeerStateCurrent(state.peerHash, state.peerSession, state.receiveEpoch));
+    }
+    localCapabilityRetryDelay(state) {
+        const exponent = Math.max(0, state.attempts - 1);
+        return Math.min(this.maxRequestRetryMs, this.requestRetryMs * 2 ** Math.min(exponent, MAX_BACKOFF_EXPONENT));
+    }
+    armLocalCapabilityAdvertisement(state) {
+        if (state.timer || state.inFlight || state.ready) {
+            return;
+        }
+        if (state.acknowledgedReady && !state.context.legacyBarrierReleased) {
+            return;
+        }
+        if (!this.isLocalCapabilityAdvertisementOwnerCurrent(state)) {
+            this.clearLocalCapabilityAdvertisement(state);
+            return;
+        }
+        if (!this.isLocalCapabilityAdvertisementGenerationCurrent(state)) {
+            return;
+        }
+        state.timer = setTimeout(() => {
+            state.timer = undefined;
+            if (!this.isLocalCapabilityAdvertisementOwnerCurrent(state)) {
+                this.clearLocalCapabilityAdvertisement(state);
+                return;
+            }
+            if (!this.isLocalCapabilityAdvertisementGenerationCurrent(state)) {
+                return;
+            }
+            if (!this.isLocalCapabilityAdvertisementReadyOpen(state)) {
+                this.armLocalCapabilityAdvertisement(state);
+                return;
+            }
+            void this.runLocalCapabilityAdvertisement(state);
+        }, this.localCapabilityRetryDelay(state));
+        state.timer.unref?.();
+    }
+    async runLocalCapabilityAdvertisement(state) {
+        if (state.inFlight) {
+            await state.inFlight;
+            return;
+        }
+        if (state.ready) {
+            return;
+        }
+        if (!this.isLocalCapabilityAdvertisementOwnerCurrent(state)) {
+            this.clearLocalCapabilityAdvertisement(state);
+            return;
+        }
+        if (!this.isLocalCapabilityAdvertisementGenerationCurrent(state)) {
+            return;
+        }
+        if (state.acknowledgedReady) {
+            if (state.context.legacyBarrierReleased) {
+                this.promoteLocalCapabilityAdvertisement(state);
+            }
+            return;
+        }
+        if (!this.isLocalCapabilityAdvertisementReadyOpen(state)) {
+            this.armLocalCapabilityAdvertisement(state);
+            return;
+        }
+        state.attempts = Math.min(state.attempts + 1, MAX_BACKOFF_EXPONENT + 1);
+        let operation;
+        operation = (async () => {
+            const refreshed = await this.deps.refreshLocalCapability({
+                peerHash: state.peerHash,
+                target: state.target,
+                peerSession: state.peerSession,
+                receiveEpoch: state.receiveEpoch,
+                signal: AbortSignal.any([
+                    state.controller.signal,
+                    state.lifecycleSignal,
+                ]),
+            });
+            if (!refreshed ||
+                !this.isLocalCapabilityAdvertisementGenerationCurrent(state) ||
+                this.deps.getReceiverTransportSession() !==
+                    refreshed.receiverTransportSession) {
+                return;
+            }
+            state.receiverTransportSession = refreshed.receiverTransportSession;
+            state.acknowledgedReady = {
+                peerHash: state.peerHash,
+                receiveEpoch: state.receiveEpoch,
+                receiverTransportSession: refreshed.receiverTransportSession,
+                requestNotBeforeMs: refreshed.requestNotBeforeMs,
+                advertisement: state,
+            };
+            state.attempts = 0;
+            this.promoteLocalCapabilityAdvertisement(state);
+        })()
+            .catch((error) => {
+            if (!state.controller.signal.aborted &&
+                !state.lifecycleSignal.aborted &&
+                !this.deps.isClosed()) {
+                this.deps.onLocalCapabilityError?.(error);
+            }
+        })
+            .finally(() => {
+            if (state.inFlight === operation) {
+                state.inFlight = undefined;
+            }
+            if (!this.isLocalCapabilityAdvertisementOwnerCurrent(state)) {
+                this.clearLocalCapabilityAdvertisement(state);
+            }
+            else if (this.isLocalCapabilityAdvertisementGenerationCurrent(state) &&
+                !state.ready) {
+                if (!state.acknowledgedReady || state.context.legacyBarrierReleased) {
+                    this.armLocalCapabilityAdvertisement(state);
+                }
+            }
+        });
+        state.inFlight = operation;
+        await operation;
+    }
+    /**
+     * Start local authenticated-apply advertisement independently of the legacy
+     * join path. ACK and legacy publication are a two-phase barrier: the first
+     * attempt always settles independently, while readiness is promoted only
+     * after the host releases the legacy barrier. Failed attempts leave one
+     * exact-session worker retrying with capped exponential backoff.
+     */
+    advertiseLocalCapability(properties) {
+        const peerHash = properties.target.hashcode();
+        if (properties.signal.aborted ||
+            this.deps.isClosed() ||
+            !this.deps.isPeerSessionCurrent(peerHash, properties.peerSession) ||
+            !this.deps.isReceiveEpochCurrent(peerHash, properties.receiveEpoch)) {
+            return {
+                firstAttempt: Promise.resolve(),
+                releaseLegacyBarrier: () => { },
+            };
+        }
+        let context = this._localCapabilityContextBySession.get(properties.peerSession);
+        if (context &&
+            (context.peerHash !== peerHash ||
+                !context.target.equals(properties.target) ||
+                context.lifecycleSignal !== properties.signal)) {
+            return {
+                firstAttempt: Promise.resolve(),
+                releaseLegacyBarrier: () => { },
+            };
+        }
+        if (!context) {
+            context = {
+                peerHash,
+                target: properties.target,
+                lifecycleSignal: properties.signal,
+                legacyBarrierReleased: false,
+            };
+            this._localCapabilityContextBySession.set(properties.peerSession, context);
+        }
+        let state = this._localCapabilityAdvertisementsByPeer.get(peerHash);
+        if (state &&
+            (state.peerSession !== properties.peerSession ||
+                state.context !== context ||
+                state.lifecycleSignal !== properties.signal ||
+                !state.target.equals(properties.target))) {
+            this.clearLocalCapabilityAdvertisement(state);
+            state = undefined;
+        }
+        if (state && state.receiveEpoch !== properties.receiveEpoch) {
+            this.clearLocalCapabilityAdvertisement(state, { preserveContext: true });
+            state = undefined;
+        }
+        if (state && !this.isLocalCapabilityAdvertisementOwnerCurrent(state)) {
+            this.clearLocalCapabilityAdvertisement(state);
+            state = undefined;
+        }
+        if (this._localCapabilityContextBySession.get(properties.peerSession) !==
+            context) {
+            return {
+                firstAttempt: Promise.resolve(),
+                releaseLegacyBarrier: () => { },
+            };
+        }
+        if (!state) {
+            const controller = new AbortController();
+            const advertisement = {
+                peerHash,
+                target: properties.target,
+                peerSession: properties.peerSession,
+                receiveEpoch: properties.receiveEpoch,
+                lifecycleSignal: properties.signal,
+                onLifecycleAbort: () => { },
+                controller,
+                context,
+                attempts: 0,
+                ready: false,
+                receiverTransportSession: this.deps.getReceiverTransportSession(),
+            };
+            advertisement.onLifecycleAbort = () => this.clearLocalCapabilityAdvertisement(advertisement);
+            properties.signal.addEventListener("abort", advertisement.onLifecycleAbort, {
+                once: true,
+            });
+            this._localCapabilityAdvertisementsByPeer.set(peerHash, advertisement);
+            state = advertisement;
+        }
+        const firstAttempt = state.firstAttempt ??
+            (state.firstAttempt = this.runLocalCapabilityAdvertisement(state));
+        const advertisement = state;
+        return {
+            firstAttempt,
+            releaseLegacyBarrier: () => this.releaseLocalCapabilityLegacyBarrier(advertisement.peerSession, context),
+        };
+    }
+    releaseLocalCapabilityLegacyBarrier(peerSession, context) {
+        if (context.legacyBarrierReleased) {
+            return;
+        }
+        if (this._localCapabilityContextBySession.get(peerSession) !== context ||
+            context.lifecycleSignal.aborted ||
+            this.deps.isClosed() ||
+            !this.deps.isPeerSessionCurrent(context.peerHash, peerSession)) {
+            return;
+        }
+        context.legacyBarrierReleased = true;
+        const state = this._localCapabilityAdvertisementsByPeer.get(context.peerHash);
+        if (state?.peerSession === peerSession && state.context === context) {
+            if (!this.isLocalCapabilityAdvertisementOwnerCurrent(state)) {
+                this.clearLocalCapabilityAdvertisement(state);
+                return;
+            }
+            this.promoteLocalCapabilityAdvertisement(state);
+        }
+    }
+    promoteLocalCapabilityAdvertisement(state) {
+        const ready = state.acknowledgedReady;
+        if (state.ready ||
+            !state.context.legacyBarrierReleased ||
+            !ready ||
+            ready.receiveEpoch !== state.receiveEpoch ||
+            ready.advertisement !== state ||
+            !this.isLocalCapabilityAdvertisementOwnerCurrent(state) ||
+            !this.isLocalCapabilityAdvertisementGenerationCurrent(state) ||
+            this.deps.getReceiverTransportSession() !== ready.receiverTransportSession) {
+            return state.ready;
+        }
+        if (!this.isLocalCapabilityAdvertisementReadyOpen(state)) {
+            this.armLocalCapabilityAdvertisement(state);
+            return false;
+        }
+        if (!this.recordLocalCapabilityReady({
+            peerHash: state.peerHash,
+            peerSession: state.peerSession,
+            receiveEpoch: state.receiveEpoch,
+            receiverTransportSession: ready.receiverTransportSession,
+            requestNotBeforeMs: ready.requestNotBeforeMs,
+        }, state)) {
+            return false;
+        }
+        state.ready = true;
+        return true;
+    }
+    /**
+     * Re-advertise one exact current recovery epoch from the stable membership
+     * context captured during opening. The opening handle owns barrier release;
+     * recovery never bypasses a legacy snapshot or role publication still in
+     * progress.
+     */
+    reAdvertiseLocalCapabilityForRecovery(properties) {
+        const context = this._localCapabilityContextBySession.get(properties.peerSession);
+        if (!context ||
+            context.peerHash !== properties.peerHash ||
+            context.lifecycleSignal.aborted ||
+            this.deps.isClosed() ||
+            !this.deps.isPeerSessionCurrent(properties.peerHash, properties.peerSession) ||
+            !this.deps.isReceiveEpochCurrent(properties.peerHash, properties.receiveEpoch)) {
+            return false;
+        }
+        const state = this._receiveStates.get(properties.peerHash);
+        if (state?.peerSession === properties.peerSession &&
+            state.receiveEpoch === properties.receiveEpoch &&
+            state.receiverBinding !== undefined) {
+            return false;
+        }
+        const ready = this._localCapabilityReadyBySession.get(properties.peerSession);
+        if (ready?.peerHash === properties.peerHash &&
+            ready.receiveEpoch === properties.receiveEpoch &&
+            ready.receiverTransportSession === this.deps.getReceiverTransportSession()) {
+            return false;
+        }
+        this.advertiseLocalCapability({
+            target: context.target,
+            peerSession: properties.peerSession,
+            receiveEpoch: properties.receiveEpoch,
+            signal: context.lifecycleSignal,
+        });
+        return true;
+    }
     /** Record success of this session's ACKed local APPLY advertisement. */
     markLocalCapabilityReady(properties) {
+        return this.recordLocalCapabilityReady(properties);
+    }
+    recordLocalCapabilityReady(properties, advertisement) {
         const { peerHash, peerSession, receiverTransportSession } = properties;
         const state = this._receiveStates.get(peerHash);
         if (this.deps.isClosed() ||
@@ -123,8 +481,10 @@ export class ReplicationInfoV2ReceiveCoordinator {
         }
         const ready = {
             peerHash,
+            receiveEpoch: properties.receiveEpoch,
             receiverTransportSession,
             requestNotBeforeMs: properties.requestNotBeforeMs,
+            advertisement,
         };
         this._localCapabilityReadyBySession.set(peerSession, ready);
         if (state?.peerSession === peerSession &&
@@ -198,7 +558,9 @@ export class ReplicationInfoV2ReceiveCoordinator {
                 });
             }
             const ready = this._localCapabilityReadyBySession.get(peerSession);
-            if (ready?.peerHash === peerHash && state.receiverBinding === undefined) {
+            if (ready?.peerHash === peerHash &&
+                ready.receiveEpoch === receiveEpoch &&
+                state.receiverBinding === undefined) {
                 this.bindLocalCapability(state, ready);
             }
             if (state.phase !== "active") {
@@ -231,7 +593,7 @@ export class ReplicationInfoV2ReceiveCoordinator {
         };
         this._receiveStates.set(peerHash, state);
         const ready = this._localCapabilityReadyBySession.get(peerSession);
-        if (ready?.peerHash === peerHash) {
+        if (ready?.peerHash === peerHash && ready.receiveEpoch === receiveEpoch) {
             this.bindLocalCapability(state, ready);
             this.armRequest(state, 0);
         }
@@ -260,6 +622,33 @@ export class ReplicationInfoV2ReceiveCoordinator {
         });
         return true;
     }
+    /**
+     * Resume only a request generation that exhausted its bounded retries.
+     * Wait/liveness callers may nudge recovery without invalidating an active,
+     * timed or in-flight request and without advancing the receive epoch.
+     */
+    resumeParkedRequest(properties) {
+        const state = this._receiveStates.get(properties.peerHash);
+        if (!state ||
+            state.peerSession !== properties.peerSession ||
+            state.receiveEpoch !== properties.receiveEpoch ||
+            !this.deps.isPeerStateCurrent(properties.peerHash, properties.peerSession, properties.receiveEpoch) ||
+            state.phase === "active" ||
+            !state.requestParked ||
+            state.requestTimer !== undefined ||
+            state.requestInFlight !== undefined ||
+            this._reservedAdmissionsByPeer.has(properties.peerHash) ||
+            state.receiverBinding === undefined ||
+            state.lastSequence === MAX_U64) {
+            return false;
+        }
+        state.requestAttempts = 0;
+        state.requestsSinceCapabilityRefresh = 0;
+        state.capabilityRefreshRequired = true;
+        state.requestParked = false;
+        this.armRequest(state, 0);
+        return true;
+    }
     transitionToResync(state, options) {
         const shouldRestart = state.phase !== "resync" ||
             options?.force === true ||
@@ -385,6 +774,14 @@ export class ReplicationInfoV2ReceiveCoordinator {
         const { state } = admission;
         this._reservedAdmissionsByPeer.set(peerHash, admission);
         state.reservedAdmission = admission;
+        if (state.requestTimer) {
+            clearTimeout(state.requestTimer);
+            state.requestTimer = undefined;
+        }
+        if (state.legacyFallbackTimer) {
+            clearTimeout(state.legacyFallbackTimer);
+            state.legacyFallbackTimer = undefined;
+        }
         return admission;
     }
     release(admission) {
@@ -403,6 +800,27 @@ export class ReplicationInfoV2ReceiveCoordinator {
                 (currentState !== state && currentState.phase !== "active"))) {
             this.transitionToResync(currentState, { force: true });
         }
+        else if (currentState === state &&
+            !admission.committed &&
+            this.isStateCurrent(state) &&
+            state.phase !== "active" &&
+            state.requestTimer === undefined &&
+            state.requestInFlight === undefined &&
+            !state.requestParked) {
+            // Reserving a Full pauses this generation's retry timer. If its host
+            // apply lane releases without committing, restore the bounded request
+            // worker so the exact current generation cannot become stranded.
+            this.armRequest(state, 0);
+        }
+        if (currentState === state &&
+            this.isStateCurrent(state) &&
+            state.phase === "active" &&
+            state.legacyFallbackFingerprint !== undefined) {
+            // A reservation also pauses compat sidecar recovery. Matching commits
+            // clear the evidence; an uncommitted or non-matching frame restores its
+            // bounded fallback without invalidating work in the host apply lane.
+            this.armLegacyFallback(state);
+        }
     }
     /**
      * B9 can lose its sender grant while keeping the topic session open. Its
@@ -485,6 +903,16 @@ export class ReplicationInfoV2ReceiveCoordinator {
         if (state.legacyFallbackTimer) {
             return true;
         }
+        this.armLegacyFallback(state);
+        return true;
+    }
+    armLegacyFallback(state) {
+        if (state.legacyFallbackTimer ||
+            state.phase !== "active" ||
+            state.legacyFallbackFingerprint === undefined ||
+            this._reservedAdmissionsByPeer.has(state.peerHash)) {
+            return;
+        }
         state.legacyFallbackTimer = setTimeout(() => {
             state.legacyFallbackTimer = undefined;
             if (this.isStateCurrent(state) && state.phase === "active") {
@@ -495,7 +923,6 @@ export class ReplicationInfoV2ReceiveCoordinator {
             }
         }, this.legacyFallbackDelayMs);
         state.legacyFallbackTimer.unref?.();
-        return true;
     }
     clearLegacyFallback(state) {
         if (state.legacyFallbackTimer) {
@@ -594,8 +1021,7 @@ export class ReplicationInfoV2ReceiveCoordinator {
         if (this._receiveStates.get(state.peerHash) !== state ||
             state.controller.signal.aborted ||
             this.deps.isClosed() ||
-            (this._reservedAdmissionsByPeer.has(state.peerHash) &&
-                this._reservedAdmissionsByPeer.get(state.peerHash)?.state !== state) ||
+            this._reservedAdmissionsByPeer.has(state.peerHash) ||
             state.receiverBinding === undefined ||
             state.phase === "active" ||
             state.requestParked ||
@@ -614,6 +1040,7 @@ export class ReplicationInfoV2ReceiveCoordinator {
         return Math.min(this.maxRequestRetryMs, this.requestRetryMs * 2 ** Math.min(exponent, 20));
     }
     async refreshGrant(state) {
+        const version = state.version;
         const refreshed = await this.deps.refreshLocalCapability({
             peerHash: state.peerHash,
             target: state.target,
@@ -622,6 +1049,8 @@ export class ReplicationInfoV2ReceiveCoordinator {
             signal: state.controller.signal,
         });
         if (!refreshed ||
+            state.version !== version ||
+            this._reservedAdmissionsByPeer.has(state.peerHash) ||
             !this.isStateCurrent(state) ||
             this.deps.getReceiverTransportSession() !==
                 refreshed.receiverTransportSession) {
@@ -629,6 +1058,7 @@ export class ReplicationInfoV2ReceiveCoordinator {
         }
         const ready = {
             peerHash: state.peerHash,
+            receiveEpoch: state.receiveEpoch,
             receiverTransportSession: refreshed.receiverTransportSession,
             requestNotBeforeMs: refreshed.requestNotBeforeMs,
         };
@@ -647,7 +1077,8 @@ export class ReplicationInfoV2ReceiveCoordinator {
         if (state.requestInFlight) {
             return;
         }
-        if (!this.isStateCurrent(state)) {
+        if (!this.isStateCurrent(state) ||
+            this._reservedAdmissionsByPeer.has(state.peerHash)) {
             return;
         }
         if (state.phase === "active" ||
@@ -667,12 +1098,14 @@ export class ReplicationInfoV2ReceiveCoordinator {
                     return;
                 }
             }
-            if (!this.isStateCurrent(state)) {
+            if (!this.isStateCurrent(state) ||
+                this._reservedAdmissionsByPeer.has(state.peerHash)) {
                 return;
             }
             const ready = this._localCapabilityReadyBySession.get(state.peerSession);
             if (!ready ||
                 ready.peerHash !== state.peerHash ||
+                ready.receiveEpoch !== state.receiveEpoch ||
                 ready.receiverTransportSession !== state.receiverTransportSession) {
                 return;
             }
@@ -705,6 +1138,7 @@ export class ReplicationInfoV2ReceiveCoordinator {
             }
             if (this._receiveStates.get(state.peerHash) === state &&
                 !state.controller.signal.aborted &&
+                !this._reservedAdmissionsByPeer.has(state.peerHash) &&
                 !state.requestTimer &&
                 state.phase !== "active") {
                 if (state.requestsSinceCapabilityRefresh >= 3) {