@peerbit/shared-log 13.2.33 → 13.2.35

package/dist/src/index.js

@@ -1701,6 +1701,7 @@ let SharedLog = (() => {
                 queueCurrentReplicationStateAnnouncementRepair: () => this._announcements.queueCurrentReplicationStateAnnouncementRepair(),
                 queueCurrentReplicationStateAnnouncementRetry: (error) => this._announcements.queueCurrentReplicationStateAnnouncementRetry(error),
                 enqueueReplicationInfoV2: (message) => this._v2Send.enqueue(message),
+                isLegacyReplicationInfoEnabled: () => this.legacyReplicationInfoEnabled,
                 isClosed: () => this.closed,
                 getCloseSignal: () => this._closeController.signal,
                 getMyReplicationSegments: () => this.getMyReplicationSegments(),
@@ -1723,6 +1724,7 @@ let SharedLog = (() => {
                 getMyReplicationSegments: () => this.getMyReplicationSegments(),
                 validatePersistedReplicationRangeSnapshot: (ranges) => this.validatePersistedReplicationRangeSnapshot(ranges),
                 isClosed: () => this.closed,
+                isPeerSessionCurrent: (peerHash, peerSession) => this._peerSessions.isCurrent(peerHash, peerSession),
                 isPeerSessionOpen: (peerHash, peerSession) => this._peerSessions.isCurrent(peerHash, peerSession) &&
                     peerSession.phase === "open" &&
                     !this._peerSessions.isReplicationInfoBlocked(peerHash) &&
@@ -1773,6 +1775,10 @@ let SharedLog = (() => {
                 getSelfKey: () => this.node.identity.publicKey,
                 getReceiverTransportSession: () => BigInt(this.node.services.pubsub.session),
                 isClosed: () => this.closed,
+                isPeerSessionCurrent: (peerHash, peerSession) => this._peerSessions.isCurrent(peerHash, peerSession) &&
+                    peerSession.phase === "open" &&
+                    peerSession.isActive(),
+                isReceiveEpochCurrent: (peerHash, receiveEpoch) => this._peerSessions.isReceiveEpochCurrent(peerHash, receiveEpoch),
                 isPeerStateCurrent: (peerHash, peerSession, receiveEpoch) => this._peerSessions.isCurrent(peerHash, peerSession) &&
                     peerSession.phase === "open" &&
                     peerSession.isActive() &&
@@ -1801,6 +1807,7 @@ let SharedLog = (() => {
                     }
                     logger.trace(`Replication-info V2 recovery request failed: ${error?.message ?? String(error)}`);
                 },
+                onLocalCapabilityError: (error) => this.handleReplicationLifecycleSendError(error),
             });
         }
         createReplicatorLivenessMonitor() {
@@ -1968,6 +1975,13 @@ let SharedLog = (() => {
         get compatibility() {
             return this._logProperties?.compatibility;
         }
+        /**
+         * Legacy replication-info is an explicit compatibility fallback. Current
+         * logs never infer or re-enable it from a remote peer's capabilities.
+         */
+        get legacyReplicationInfoEnabled() {
+            return this.compatibility !== undefined && this.compatibility < 10;
+        }
         get isAdaptiveReplicating() {
             return this._isAdaptiveReplicating;
         }
@@ -4039,10 +4053,16 @@ let SharedLog = (() => {
                     // deliver the authoritative Full that completes recovery.
                     const peerSession = this._peerSessions.current(keyHash);
                     if (peerSession?.phase === "open") {
+                        const receiveEpoch = this._peerSessions.receiveEpoch(keyHash);
                         this._v2Receive.advanceRecovery({
                             peerHash: keyHash,
                             peerSession,
-                            receiveEpoch: this._peerSessions.receiveEpoch(keyHash),
+                            receiveEpoch,
+                        });
+                        this._v2Receive.reAdvertiseLocalCapabilityForRecovery({
+                            peerHash: keyHash,
+                            peerSession,
+                            receiveEpoch,
                         });
                     }
                 }
@@ -9096,7 +9116,9 @@ let SharedLog = (() => {
             this._logProperties = options;
             this.domain = options?.domain
                 ? options.domain(this)
-                : createReplicationDomainHash(options?.compatibility && options?.compatibility < 10 ? "u32" : "u64")(this);
+                : createReplicationDomainHash(options?.compatibility !== undefined && options.compatibility < 10
+                    ? "u32"
+                    : "u64")(this);
             this.indexableDomain = createIndexableDomainFromResolution(this.domain.resolution);
             this._respondToIHaveTimeout = options?.respondToIHaveTimeout ?? 2e4;
             this._checkedPrune = new CheckedPruneCoordinator();
@@ -9214,8 +9236,13 @@ let SharedLog = (() => {
                 throw new Error("waitForReplicatorRequestMaxAttempts must be a positive number");
             }
             this._closeController = new AbortController();
-            this._announcements.setupReplicationAnnouncementRetryFunction();
-            this._announcements.setupReplicationAnnouncementRepairFunction();
+            if (this.legacyReplicationInfoEnabled) {
+                this._announcements.setupReplicationAnnouncementRetryFunction();
+                this._announcements.setupReplicationAnnouncementRepairFunction();
+            }
+            else {
+                this._announcements.cancelCurrentReplicationStateAnnouncementRetry();
+            }
             this._closeController.signal.addEventListener("abort", () => {
                 for (const [_peer, state] of this._replicationInfoRequestByPeer) {
                     if (state.timer)
@@ -10134,7 +10161,12 @@ let SharedLog = (() => {
         }
         async afterOpen() {
             await super.afterOpen();
-            const existingSubscribersPromise = this._getTopicSubscribers(this.topic);
+            // Start the broader discovery eagerly, in parallel with rebalance, for its
+            // routing/cache side effects. It also contains connected/provider/fanout
+            // candidates that have not subscribed to this log, so only the authoritative
+            // pubsub snapshot below may create subscription fallback sessions.
+            const subscriberDiscoveryPromise = this._getTopicSubscribers(this.topic);
+            const existingSubscribersPromise = this.node.services.pubsub.getSubscribers(this.topic);
             const replicationLifecycleController = this._instanceLifecycle?.membershipLifecycleController;
             // We do this here, because these calls requires this.closed == false
             void this.pruneOfflineReplicators()
@@ -10151,6 +10183,7 @@ let SharedLog = (() => {
             });
             this._liveness.startReplicatorLivenessSweep();
             await this.rebalanceParticipation();
+            await subscriberDiscoveryPromise;
             // Take into account existing subscription
             (await existingSubscribersPromise)?.forEach((v) => {
                 if (v.equals(this.node.identity.publicKey)) {
@@ -10159,6 +10192,14 @@ let SharedLog = (() => {
                 if (this.closed) {
                     return;
                 }
+                // The live subscribe event and this after-open snapshot can report the
+                // same initial transport generation. The live callback rotates its
+                // PeerSession synchronously, so any current session here proves the
+                // fallback is stale/duplicate. Rotating again would erase the signed
+                // capability binding that the first callback just established.
+                if (this._peerSessions.current(v.hashcode()) !== null) {
+                    return;
+                }
                 void this.runSubscriptionChangeCallback(() => this.handleSubscriptionChange(v, [this.topic], true));
             });
         }
@@ -10297,7 +10338,9 @@ let SharedLog = (() => {
         cleanupPeerDisconnectTracking(peerHash, ownershipLifecycleController = this.captureReplicationOwnershipLifecycle()) {
             const peerSession = this._peerSessions.current(peerHash);
             const preserveV2Session = peerSession?.phase === "open" && peerSession.isActive();
-            this.cancelReplicationInfoRequests(peerHash);
+            if (this.legacyReplicationInfoEnabled || !preserveV2Session) {
+                this.cancelReplicationInfoRequests(peerHash);
+            }
             this._liveness._replicatorLivenessFailures.delete(peerHash);
             this._liveness._replicatorLastActivityAt.delete(peerHash);
             if (!preserveV2Session) {
@@ -11257,15 +11300,16 @@ let SharedLog = (() => {
                     }, 2_000);
                     try {
                         const reset = new AllReplicatingSegmentsMessage({ segments: [] });
-                        await Promise.all([
-                            this.rpc
+                        const resets = [this._v2Send.sendTerminalReset(abort.signal)];
+                        if (this.legacyReplicationInfoEnabled) {
+                            resets.push(this.rpc
                                 .send(reset, {
                                 priority: CONVERGENCE_MESSAGE_PRIORITY,
                                 signal: abort.signal,
                             })
-                                .catch(() => { }),
-                            this._v2Send.sendTerminalReset(abort.signal),
-                        ]);
+                                .catch(() => { }));
+                        }
+                        await Promise.all(resets);
                     }
                     finally {
                         clearTimeout(abortTimer);
@@ -11385,15 +11429,16 @@ let SharedLog = (() => {
                     }, 2_000);
                     try {
                         const reset = new AllReplicatingSegmentsMessage({ segments: [] });
-                        await Promise.all([
-                            this.rpc
+                        const resets = [this._v2Send.sendTerminalReset(abort.signal)];
+                        if (this.legacyReplicationInfoEnabled) {
+                            resets.push(this.rpc
                                 .send(reset, {
                                 priority: CONVERGENCE_MESSAGE_PRIORITY,
                                 signal: abort.signal,
                             })
-                                .catch(() => { }),
-                            this._v2Send.sendTerminalReset(abort.signal),
-                        ]);
+                                .catch(() => { }));
+                        }
+                        await Promise.all(resets);
                     }
                     finally {
                         clearTimeout(abortTimer);
@@ -11817,6 +11862,17 @@ let SharedLog = (() => {
                 if (!context.from) {
                     throw new Error("Missing from in update role message");
                 }
+                if (!this.legacyReplicationInfoEnabled &&
+                    (msg instanceof RequestReplicationInfoMessage ||
+                        msg instanceof ResponseRoleMessage ||
+                        msg instanceof AllReplicatingSegmentsMessage ||
+                        msg instanceof AddedReplicationSegmentMessage ||
+                        msg instanceof StoppedReplicating)) {
+                    // These variants remain registered decode tombstones, but current logs
+                    // fail closed before leases, synchronizer work, liveness, watermarks or
+                    // mutations. Only an explicit pre-v10 compatibility open admits them.
+                    return;
+                }
                 // Snapshot receive ownership before any async handler gets a chance to
                 // yield. Replication-info messages reach their branch only after the
                 // synchronizer declines them, and a U/S transition can happen meanwhile.
@@ -13231,14 +13287,30 @@ let SharedLog = (() => {
                                     openingSession: receiveSession,
                                 });
                             }
-                            else if (this.observePeerSyncCapabilities({
-                                peerHash: receiveFromHash,
-                                capabilities: msg.capabilities,
-                                transportSession: capabilityTransportSession,
-                                timestamp: capabilityTimestamp,
-                            }) &&
-                                receiveSession?.phase === "open") {
-                                this.promoteReplicationInfoV2ReceiveCapability(context.from, receiveSession);
+                            else {
+                                const observed = this.observePeerSyncCapabilities({
+                                    peerHash: receiveFromHash,
+                                    capabilities: msg.capabilities,
+                                    transportSession: capabilityTransportSession,
+                                    timestamp: capabilityTimestamp,
+                                });
+                                if (observed && receiveSession?.phase === "open") {
+                                    this.promoteReplicationInfoV2ReceiveCapability(context.from, receiveSession);
+                                }
+                                else if (observed && receiveSession === null) {
+                                    // A capability can arrive before the sender's topic Subscribe after
+                                    // reconnect. Ask that authenticated peer for its authoritative
+                                    // subscriber snapshot; the resulting Subscribe creates the real
+                                    // PeerSession and completes the symmetric capability handshake.
+                                    // Never synthesize membership from capability traffic alone.
+                                    void Promise.resolve()
+                                        .then(() => this.node.services.pubsub.requestSubscribers(this.topic, context.from))
+                                        .catch((error) => {
+                                        if (!isNotStartedError(error)) {
+                                            logger.error(error?.toString?.() ?? String(error));
+                                        }
+                                    });
+                                }
                             }
                         }
                         return;
@@ -13667,7 +13739,8 @@ let SharedLog = (() => {
                         return;
                     }
                     this._liveness.markReplicatorActivity(fromHash);
-                    if (msg instanceof FullReplicationInfoV2Message) {
+                    if (msg instanceof FullReplicationInfoV2Message &&
+                        this.legacyReplicationInfoEnabled) {
                         this.cancelReplicationInfoRequests(fromHash);
                     }
                 });
@@ -14171,9 +14244,30 @@ let SharedLog = (() => {
                 reject(new TimeoutError(`Timeout waiting for replicator ${key.hashcode()}`));
             }, timeoutMs);
             let requestAttempts = 0;
+            let subscriberSnapshotInFlight;
             const requestIntervalMs = this.waitForReplicatorRequestIntervalMs;
             const maxRequestAttempts = this.waitForReplicatorRequestMaxAttempts ??
                 Math.max(WAIT_FOR_REPLICATOR_REQUEST_MIN_ATTEMPTS, Math.ceil(timeoutMs / requestIntervalMs));
+            const requestSubscriberSnapshot = () => {
+                if (subscriberSnapshotInFlight) {
+                    return;
+                }
+                subscriberSnapshotInFlight = Promise.resolve()
+                    .then(async () => {
+                    if (settled || this.closed) {
+                        return;
+                    }
+                    await this.node.services.pubsub.requestSubscribers(this.topic, key);
+                })
+                    .catch((error) => {
+                    if (!isNotStartedError(error)) {
+                        logger.error(error?.toString?.() ?? String(error));
+                    }
+                })
+                    .finally(() => {
+                    subscriberSnapshotInFlight = undefined;
+                });
+            };
             const requestReplicationInfo = () => {
                 if (settled || this.closed) {
                     return;
@@ -14182,17 +14276,37 @@ let SharedLog = (() => {
                     return;
                 }
                 requestAttempts++;
-                this.rpc
-                    .send(new RequestReplicationInfoMessage(), {
-                    mode: new AcknowledgeDelivery({ redundancy: 1, to: [key] }),
-                })
-                    .catch((e) => {
-                    // Best-effort: missing peers / unopened RPC should not fail the wait logic.
-                    if (isNotStartedError(e)) {
-                        return;
+                if (this.legacyReplicationInfoEnabled) {
+                    this.rpc
+                        .send(new RequestReplicationInfoMessage(), {
+                        mode: new AcknowledgeDelivery({ redundancy: 1, to: [key] }),
+                    })
+                        .catch((e) => {
+                        // Best-effort: missing peers / unopened RPC should not fail the wait logic.
+                        if (isNotStartedError(e)) {
+                            return;
+                        }
+                        logger.error(e?.toString?.() ?? String(e));
+                    });
+                }
+                else {
+                    const peerHash = key.hashcode();
+                    const peerSession = this._peerSessions.current(peerHash);
+                    if (peerSession?.phase === "open") {
+                        this._v2Receive.resumeParkedRequest({
+                            peerHash,
+                            peerSession,
+                            receiveEpoch: this._peerSessions.receiveEpoch(peerHash),
+                        });
                     }
-                    logger.error(e?.toString?.() ?? String(e));
-                });
+                    else if (peerSession === null || peerSession.phase === "departing") {
+                        // A peer can be known to routing before its SharedLog topic
+                        // subscription has been observed. Legacy requests used to bootstrap
+                        // that case directly; V2 needs an authoritative Subscribe snapshot
+                        // before it can create a fenced PeerSession and request a Full.
+                        requestSubscriberSnapshot();
+                    }
+                }
                 if (requestAttempts < maxRequestAttempts) {
                     requestTimer = setTimeout(requestReplicationInfo, requestIntervalMs);
                 }
@@ -16004,12 +16118,71 @@ let SharedLog = (() => {
             }
             this._replicationInfoRequestByPeer.delete(peerHash);
         }
+        scheduleReplicationInfoV2Recovery(peer, replicationLifecycleController = this._instanceLifecycle
+            ?.membershipLifecycleController) {
+            if (!replicationLifecycleController ||
+                !this.isReplicationLifecycleActive(replicationLifecycleController)) {
+                return;
+            }
+            const peerHash = peer.hashcode();
+            const peerSession = this._peerSessions.current(peerHash);
+            if (!peerSession || peerSession.phase !== "open") {
+                return;
+            }
+            const requestStates = this._replicationInfoRequestByPeer;
+            const existing = requestStates.get(peerHash);
+            if (existing?.peerSession === peerSession) {
+                return;
+            }
+            if (existing) {
+                if (existing.timer) {
+                    clearTimeout(existing.timer);
+                }
+                requestStates.delete(peerHash);
+            }
+            const state = {
+                attempts: 0,
+                peerSession,
+            };
+            requestStates.set(peerHash, state);
+            const cancel = () => {
+                if (requestStates.get(peerHash) !== state) {
+                    return;
+                }
+                if (state.timer) {
+                    clearTimeout(state.timer);
+                }
+                requestStates.delete(peerHash);
+            };
+            const intervalMs = Math.max(50, this.waitForReplicatorRequestIntervalMs);
+            const tick = () => {
+                if (!this.isReplicationLifecycleActive(replicationLifecycleController) ||
+                    peerSession.phase !== "open" ||
+                    !this._peerSessions.isCurrent(peerHash, peerSession)) {
+                    cancel();
+                    return;
+                }
+                this._v2Receive.resumeParkedRequest({
+                    peerHash,
+                    peerSession,
+                    receiveEpoch: this._peerSessions.receiveEpoch(peerHash),
+                });
+                state.attempts++;
+                state.timer = setTimeout(tick, intervalMs);
+                state.timer.unref?.();
+            };
+            tick();
+        }
         scheduleReplicationInfoRequests(peer, replicationLifecycleController = this._instanceLifecycle
             ?.membershipLifecycleController) {
             if (!replicationLifecycleController ||
                 !this.isReplicationLifecycleActive(replicationLifecycleController)) {
                 return;
             }
+            if (!this.legacyReplicationInfoEnabled) {
+                this.scheduleReplicationInfoV2Recovery(peer, replicationLifecycleController);
+                return;
+            }
             const peerHash = peer.hashcode();
             const requestStates = this._replicationInfoRequestByPeer;
             if (requestStates.has(peerHash)) {
@@ -16060,7 +16233,7 @@ let SharedLog = (() => {
             };
             tick();
         }
-        async handleSubscriptionChange(publicKey, topics, subscribed, subscriptionEpoch) {
+        async handleSubscriptionChange(publicKey, topics, subscribed, subscriptionEpoch, subscriptionTransportSession) {
             if (!topics.includes(this.topic)) {
                 return;
             }
@@ -16076,13 +16249,29 @@ let SharedLog = (() => {
             if (!ownsSubscriptionEpoch()) {
                 return;
             }
+            // A reconnect can arrive before the previous exact-session recovery tick
+            // observes its stale session. Retire that job synchronously so it cannot
+            // suppress the replacement session's scheduler in the shared peer slot.
+            this.cancelReplicationInfoRequests(peerHash);
             // A destination stream is scoped to exactly one topic-subscription
             // session. Abort the predecessor synchronously before either barrier can
             // yield; a late queue completion must never enter the new session.
             this._v2Receive.clearPeer(peerHash);
             this._v2Send.clearPeer(peerHash);
-            this._peerSyncCapabilitySessions.delete(peerHash);
-            this._peerSyncCapabilityTimestamps.delete(peerHash);
+            const capabilityTransportSession = this._peerSyncCapabilitySessions.get(peerHash);
+            const canInheritCapability = subscribed &&
+                (subscriptionTransportSession !== undefined
+                    ? capabilityTransportSession === subscriptionTransportSession
+                    : !expectedSubscriptionEpoch.hasPredecessor);
+            if (!canInheritCapability) {
+                // Departures and successor openings revoke the signed transport binding.
+                // A live successor may inherit a capability that arrived just before its
+                // Subscribe only when both signed frames belong to the same transport
+                // generation. Snapshot fallbacks lack that proof, so only their first
+                // opening may inherit pre-opening capability state.
+                this._peerSyncCapabilitySessions.delete(peerHash);
+                this._peerSyncCapabilityTimestamps.delete(peerHash);
+            }
             if (subscribed) {
                 const pendingOpeningCapabilities = this._openingSyncCapabilitiesByPeer.get(peerHash);
                 if (pendingOpeningCapabilities &&
@@ -16195,56 +16384,48 @@ let SharedLog = (() => {
             this._liveness.markReplicatorActivity(peerHash);
             this._peerSessions.markOpen(peerHash, expectedSubscriptionEpoch);
             this.promoteReplicationInfoV2ReceiveCapability(publicKey, expectedSubscriptionEpoch);
-            // Decode, sender and authenticated apply readiness are separate bits. Start
-            // the ACKed receiver-led negotiation before the legacy snapshot, but do not
-            // hold mixed-version replication discovery behind that round trip. Attach
-            // the rejection handler now because a lifecycle fence below may return before
-            // awaiting the advert. RequestV2 is armed only after both sends settle.
+            // Decode, sender and authenticated apply readiness are separate bits. An
+            // ACKed capability advert is the local half of receiver-led negotiation;
+            // readiness is promoted only after the legacy startup path has completed.
+            // This preserves mixed-version discovery without putting capability ACK
+            // latency on the subscription callback's critical path.
             const receiveEpoch = this._peerSessions.receiveEpoch(peerHash);
-            const localCapabilityAdvertisement = this.advertiseReplicationInfoV2ReceiveCapability({
+            const localCapabilityAdvertisement = this._v2Receive.advertiseLocalCapability({
                 target: publicKey,
                 peerSession: expectedSubscriptionEpoch,
                 receiveEpoch,
                 signal: replicationLifecycleController.signal,
-            }).catch((error) => {
-                this.handleReplicationLifecycleSendError(error, replicationLifecycleController);
-                return undefined;
             });
-            let replicationSegments;
-            try {
-                replicationSegments = await this.getMyReplicationSegments();
-            }
-            catch (error) {
-                if (!this.isReplicationLifecycleActive(replicationLifecycleController) &&
-                    isNotStartedError(error)) {
-                    return;
-                }
-                throw error;
-            }
-            if (!this.isReplicationLifecycleActive(replicationLifecycleController) ||
-                !ownsSubscriptionEpoch()) {
+            if (!this.legacyReplicationInfoEnabled) {
+                // Current logs have no legacy startup work to order ahead of RequestV2.
+                // Releasing is synchronous and exact-session fenced; the ACK may still
+                // arrive later and promote readiness through the coordinator.
+                localCapabilityAdvertisement.releaseLegacyBarrier();
+                this.scheduleReplicationInfoV2Recovery(publicKey, replicationLifecycleController);
                 return;
             }
-            if (replicationSegments.length > 0) {
-                const segments = replicationSegments.map((x) => x.toReplicationRange());
-                this.validatePersistedReplicationRangeSnapshot(segments);
-                await this.rpc
-                    .send(new AllReplicatingSegmentsMessage({
-                    segments,
-                }), {
-                    mode: new AcknowledgeDelivery({ redundancy: 1, to: [publicKey] }),
-                    signal: replicationLifecycleController.signal,
-                })
-                    .catch((error) => this.handleReplicationLifecycleSendError(error, replicationLifecycleController));
+            try {
+                let replicationSegments;
+                try {
+                    replicationSegments = await this.getMyReplicationSegments();
+                }
+                catch (error) {
+                    if (!this.isReplicationLifecycleActive(replicationLifecycleController) &&
+                        isNotStartedError(error)) {
+                        return;
+                    }
+                    throw error;
+                }
                 if (!this.isReplicationLifecycleActive(replicationLifecycleController) ||
                     !ownsSubscriptionEpoch()) {
                     return;
                 }
-                if (this.v8Behaviour) {
-                    // for backwards compatibility
+                if (replicationSegments.length > 0) {
+                    const segments = replicationSegments.map((x) => x.toReplicationRange());
+                    this.validatePersistedReplicationRangeSnapshot(segments);
                     await this.rpc
-                        .send(new ResponseRoleMessage({
-                        role: this.getRoleFromReplicationSegments(replicationSegments),
+                        .send(new AllReplicatingSegmentsMessage({
+                        segments,
                     }), {
                         mode: new AcknowledgeDelivery({
                             redundancy: 1,
@@ -16253,23 +16434,35 @@ let SharedLog = (() => {
                         signal: replicationLifecycleController.signal,
                     })
                         .catch((error) => this.handleReplicationLifecycleSendError(error, replicationLifecycleController));
+                    if (!this.isReplicationLifecycleActive(replicationLifecycleController) ||
+                        !ownsSubscriptionEpoch()) {
+                        return;
+                    }
+                    if (this.v8Behaviour) {
+                        // for backwards compatibility
+                        await this.rpc
+                            .send(new ResponseRoleMessage({
+                            role: this.getRoleFromReplicationSegments(replicationSegments),
+                        }), {
+                            mode: new AcknowledgeDelivery({
+                                redundancy: 1,
+                                to: [publicKey],
+                            }),
+                            signal: replicationLifecycleController.signal,
+                        })
+                            .catch((error) => this.handleReplicationLifecycleSendError(error, replicationLifecycleController));
+                    }
+                }
+                // Keep legacy request-based discovery independent of the capability ACK.
+                // This makes mixed-version joins resilient to timing-sensitive delivery/order
+                // issues where we may miss the remote peer's initial announcement.
+                if (this.isReplicationLifecycleActive(replicationLifecycleController) &&
+                    ownsSubscriptionEpoch()) {
+                    this.scheduleReplicationInfoRequests(publicKey, replicationLifecycleController);
                 }
             }
-            // Keep legacy request-based discovery independent of the capability ACK too.
-            // This makes mixed-version joins resilient to timing-sensitive delivery/order
-            // issues where we may miss the remote peer's initial announcement.
-            if (this.isReplicationLifecycleActive(replicationLifecycleController) &&
-                ownsSubscriptionEpoch()) {
-                this.scheduleReplicationInfoRequests(publicKey, replicationLifecycleController);
-            }
-            const localCapabilityReady = await localCapabilityAdvertisement;
-            if (localCapabilityReady) {
-                this._v2Receive.markLocalCapabilityReady({
-                    peerHash,
-                    peerSession: expectedSubscriptionEpoch,
-                    receiveEpoch,
-                    ...localCapabilityReady,
-                });
+            finally {
+                localCapabilityAdvertisement.releaseLegacyBarrier();
             }
         }
         getClampedReplicas(customValue) {
@@ -17267,7 +17460,7 @@ let SharedLog = (() => {
             this.remoteBlocks.onReachable(evt.detail.from);
             this._peerSessions.blockReplicationInfo(fromHash);
             this.invalidateSharedLogTopicSubscribersCache();
-            await this.handleSubscriptionChange(evt.detail.from, evt.detail.topics, true, subscriptionEpoch);
+            await this.handleSubscriptionChange(evt.detail.from, evt.detail.topics, true, subscriptionEpoch, evt.detail.session);
         }
         async rebalanceParticipation(ownershipLifecycleController = this.captureReplicationOwnershipLifecycle(), rebalanceParticipationDebounced = this.rebalanceParticipationDebounced) {
             // Stage 3: the lifecycle owns all three identity terms. `lifecycle` may