@peerbit/shared-log 13.2.34 → 13.2.36

package/dist/src/index.js

@@ -370,6 +370,13 @@ export const WAIT_FOR_REPLICATOR_TIMEOUT = 20000;
 export const WAIT_FOR_ROLE_MATURITY = 5000;
 export const WAIT_FOR_REPLICATOR_REQUEST_INTERVAL = 1000;
 export const WAIT_FOR_REPLICATOR_REQUEST_MIN_ATTEMPTS = 3;
+// The V2 recovery scheduler is deliberately persistent (a subscribed peer is
+// re-solicited for as long as its topic session stays open), but consecutive
+// fruitless park/unpark cycles double the wait before the next unpark so a
+// silent-but-subscribed peer converges to one bounded request cycle per cap
+// window instead of one per base interval. Any applied V2 progress resets it.
+export const REPLICATION_INFO_V2_RECOVERY_MAX_UNPARK_DELAY = 300_000;
+const REPLICATION_INFO_V2_RECOVERY_MAX_UNPARK_EXPONENT = 20;
 // TODO(prune): Investigate if/when a non-zero prune delay is required for correctness
 // (e.g. responsibility/replication-info message reordering in multi-peer scenarios).
 // Prefer making pruning robust without timing-based heuristics.
@@ -695,6 +702,11 @@ let SharedLog = (() => {
         // reconnect barrier commits. See PeerSessionRegistry._replicationInfoBlockedPeers.
         _replicationInfoRequestByPeer;
         _replicationInfoApplyQueueByPeer;
+        // One in-flight targeted subscriber-snapshot request per session-less peer.
+        // A capability burst from a peer whose Subscribe has not been observed must
+        // coalesce into a single pubsub.requestSubscribers call (mirrors the
+        // waitForReplicator in-flight coalescing); a later burst may request again.
+        _subscriberSnapshotRequestsByPeer;
         // Range ids are global primary keys while receive lanes are per peer. Keep
         // reads and writes that decide one mutation in a single global lane.
         _replicationRangeMutationTail = Promise.resolve();
@@ -1701,6 +1713,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(),
@@ -1874,6 +1887,7 @@ let SharedLog = (() => {
             this._pendingIHaveCallbacks = new Set();
             this.latestReplicationInfoMessage = new Map();
             this._replicationInfoRequestByPeer = new Map();
+            this._subscriberSnapshotRequestsByPeer = new Map();
             this._replicationInfoApplyQueueByPeer = new Map();
             // The registry constructor runs resetForOpen(), which creates the
             // replication-info blocked set (fence B5) alongside the session maps —
@@ -1974,6 +1988,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;
         }
@@ -2379,6 +2400,9 @@ let SharedLog = (() => {
                 : previousTimestamp);
             if (generationAdvanced) {
                 this._v2Send.advancePeerCapability(peerHash);
+                // A fresh signed capability generation is V2 progress from the peer:
+                // recovery re-solicitation may restart from the base interval.
+                this.resetReplicationInfoV2RecoveryEscalation(peerHash);
             }
             return true;
         }
@@ -2400,6 +2424,33 @@ let SharedLog = (() => {
                 capabilityTimestamp,
             });
         }
+        /**
+         * Coalesced targeted subscriber-snapshot request for the
+         * capability-before-Subscribe recovery path. The observed-capability gate
+         * is sender-paced (any advancing timestamp passes), so a burst of frames
+         * from one session-less peer must not fan out into one GetSubscribers
+         * unicast per frame. One request per peer is in flight at a time; once it
+         * settles, a genuinely new session-less capability may request again.
+         */
+        requestSubscriberSnapshotForCapability(target) {
+            const peerHash = target.hashcode();
+            if (this._subscriberSnapshotRequestsByPeer.has(peerHash)) {
+                return;
+            }
+            const request = Promise.resolve()
+                .then(() => this.node.services.pubsub.requestSubscribers(this.topic, target))
+                .catch((error) => {
+                if (!isNotStartedError(error)) {
+                    logger.error(error?.toString?.() ?? String(error));
+                }
+            })
+                .finally(() => {
+                if (this._subscriberSnapshotRequestsByPeer.get(peerHash) === request) {
+                    this._subscriberSnapshotRequestsByPeer.delete(peerHash);
+                }
+            });
+            this._subscriberSnapshotRequestsByPeer.set(peerHash, request);
+        }
         /**
          * Live append gossip may use the raw exchange-heads path only when we
          * opted into raw sync and every remote recipient advertised raw capability
@@ -9108,7 +9159,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();
@@ -9118,6 +9171,7 @@ let SharedLog = (() => {
             this._pendingIHaveCallbacks = new Set();
             this.latestReplicationInfoMessage = new Map();
             this._replicationInfoRequestByPeer = new Map();
+            this._subscriberSnapshotRequestsByPeer = new Map();
             // Terminal close/drop drains the previous lifecycle before another open can
             // install fresh lanes and opaque per-subscription ownership tokens.
             this._replicationInfoApplyQueueByPeer = new Map();
@@ -9226,8 +9280,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)
@@ -10146,7 +10205,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()
@@ -10163,6 +10227,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)) {
@@ -10171,6 +10236,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));
             });
         }
@@ -10309,7 +10382,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) {
@@ -11269,15 +11344,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);
@@ -11397,15 +11473,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);
@@ -11829,6 +11906,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.
@@ -13243,14 +13331,24 @@ 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.
+                                    this.requestSubscriberSnapshotForCapability(context.from);
+                                }
                             }
                         }
                         return;
@@ -13679,7 +13777,11 @@ let SharedLog = (() => {
                         return;
                     }
                     this._liveness.markReplicatorActivity(fromHash);
-                    if (msg instanceof FullReplicationInfoV2Message) {
+                    // A committed V2 announcement is applied progress: the peer answers,
+                    // so recovery re-solicitation may restart from the base interval.
+                    this.resetReplicationInfoV2RecoveryEscalation(fromHash);
+                    if (msg instanceof FullReplicationInfoV2Message &&
+                        this.legacyReplicationInfoEnabled) {
                         this.cancelReplicationInfoRequests(fromHash);
                     }
                 });
@@ -14183,9 +14285,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;
@@ -14194,17 +14317,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);
                 }
@@ -16016,12 +16159,114 @@ let SharedLog = (() => {
             }
             this._replicationInfoRequestByPeer.delete(peerHash);
         }
+        /**
+         * Applied V2 progress from a peer (a committed Full/Added/Stopped, or a
+         * rotated capability generation) proves the peer answers. Reset the
+         * recovery scheduler's unpark escalation so a later stall restarts from
+         * the base interval. Peer-session rotation resets implicitly: the recovery
+         * scheduler creates a fresh per-session state.
+         */
+        resetReplicationInfoV2RecoveryEscalation(peerHash) {
+            const state = this._replicationInfoRequestByPeer.get(peerHash);
+            if (!state || state.peerSession === undefined) {
+                return;
+            }
+            state.attempts = 0;
+            state.parkedSinceMs = undefined;
+        }
+        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 maxUnparkDelayMs = Math.max(intervalMs, REPLICATION_INFO_V2_RECOVERY_MAX_UNPARK_DELAY);
+            const unparkDelayMs = () => Math.min(maxUnparkDelayMs, intervalMs *
+                2 **
+                    Math.min(state.attempts, REPLICATION_INFO_V2_RECOVERY_MAX_UNPARK_EXPONENT));
+            const arm = (delayMs) => {
+                state.timer = setTimeout(tick, delayMs);
+                state.timer.unref?.();
+            };
+            const tick = () => {
+                if (!this.isReplicationLifecycleActive(replicationLifecycleController) ||
+                    peerSession.phase !== "open" ||
+                    !this._peerSessions.isCurrent(peerHash, peerSession)) {
+                    cancel();
+                    return;
+                }
+                const receiveEpoch = this._peerSessions.receiveEpoch(peerHash);
+                if (!this._v2Receive.isRequestParked({ peerHash, peerSession, receiveEpoch })) {
+                    // Active, or a bounded request cycle is still running its own
+                    // exponential retries. Keep polling for the next park.
+                    state.parkedSinceMs = undefined;
+                    arm(intervalMs);
+                    return;
+                }
+                const now = Date.now();
+                if (state.parkedSinceMs === undefined) {
+                    state.parkedSinceMs = now;
+                }
+                const resumeAtMs = state.parkedSinceMs + unparkDelayMs();
+                if (now < resumeAtMs) {
+                    arm(Math.max(50, resumeAtMs - now));
+                    return;
+                }
+                if (this._v2Receive.resumeParkedRequest({
+                    peerHash,
+                    peerSession,
+                    receiveEpoch,
+                })) {
+                    // Fruitless until proven otherwise: escalate the next unpark wait.
+                    // Applied progress resets via resetReplicationInfoV2RecoveryEscalation.
+                    state.attempts++;
+                    state.parkedSinceMs = undefined;
+                }
+                arm(intervalMs);
+            };
+            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)) {
@@ -16072,7 +16317,7 @@ let SharedLog = (() => {
             };
             tick();
         }
-        async handleSubscriptionChange(publicKey, topics, subscribed, subscriptionEpoch) {
+        async handleSubscriptionChange(publicKey, topics, subscribed, subscriptionEpoch, subscriptionTransportSession) {
             if (!topics.includes(this.topic)) {
                 return;
             }
@@ -16088,13 +16333,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 &&
@@ -16219,6 +16480,14 @@ let SharedLog = (() => {
                 receiveEpoch,
                 signal: replicationLifecycleController.signal,
             });
+            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;
+            }
             try {
                 let replicationSegments;
                 try {
@@ -17275,7 +17544,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