@peerbit/shared-log 13.2.10 → 13.2.11

package/dist/src/index.js

@@ -33,7 +33,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     return useValue ? value : void 0;
 };
 import { BorshError, deserialize, field, serialize, variant, } from "@dao-xyz/borsh";
-import { AnyBlockStore, RemoteBlocks } from "@peerbit/blocks";
+import { AnyBlockStore, RemoteBlocks, } from "@peerbit/blocks";
 import { cidifyString } from "@peerbit/blocks-interface";
 import { Cache } from "@peerbit/cache";
 import { AccessError, Ed25519Keypair, Ed25519PublicKey, PublicSignKey, Secp256k1PublicKey, getPublicKeyFromPeerId, sha256Base64Sync, sha256Sync, toHexString, } from "@peerbit/crypto";
@@ -44,7 +44,7 @@ import { ClosedError, Program, TerminalOperationNotStartedError, } from "@peerbi
 import { FanoutChannel, waitForSubscribers, } from "@peerbit/pubsub";
 import { SubscriptionEvent, UnsubcriptionEvent, } from "@peerbit/pubsub-interface";
 import { RPC } from "@peerbit/rpc";
-import { ACK_CONTROL_PRIORITY, AcknowledgeDelivery, AnyWhere, BACKGROUND_MESSAGE_PRIORITY, CONVERGENCE_MESSAGE_PRIORITY, DataMessage, MessageHeader, NotStartedError, SilentDelivery, createRequestTransportContext, } from "@peerbit/stream-interface";
+import { ACK_CONTROL_PRIORITY, AcknowledgeDelivery, AnyWhere, BACKGROUND_MESSAGE_PRIORITY, CONVERGENCE_MESSAGE_PRIORITY, DataMessage, DeliveryError, MessageHeader, NotStartedError, SilentDelivery, createRequestTransportContext, } from "@peerbit/stream-interface";
 import { AbortError, TimeoutError, debounceAccumulator, debounceFixedInterval, waitFor, } from "@peerbit/time";
 import pDefer, {} from "p-defer";
 import PQueue from "p-queue";
@@ -1381,6 +1381,46 @@ const isTransientReplicationAnnouncementError = (error, seen = new Set()) => {
         : "";
     return constructorName === "TimeoutError" || name === "TimeoutError";
 };
+/**
+ * Directed transport-delivery repair is allowed to retry explicit delivery
+ * failures in addition to timeouts. A DirectStream ACK confirms receipt of the
+ * signed envelope, not successful application by the receiver. Keep this
+ * separate from the primary fanout classifier above so replicate() rejection
+ * semantics remain unchanged for programming, serialization, and lifecycle
+ * errors.
+ */
+const isTransientReplicationAnnouncementRepairError = (error, seen = new Set()) => {
+    if (error != null &&
+        (typeof error === "object" || typeof error === "function")) {
+        if (seen.has(error)) {
+            return false;
+        }
+        seen.add(error);
+    }
+    if (error instanceof DeliveryError || error instanceof TimeoutError) {
+        return true;
+    }
+    const nested = error?.errors;
+    if (Array.isArray(nested) && nested.length > 0) {
+        return nested.every((item) => isTransientReplicationAnnouncementRepairError(item, new Set(seen)));
+    }
+    const cause = error?.cause;
+    if (cause != null &&
+        isTransientReplicationAnnouncementRepairError(cause, seen)) {
+        return true;
+    }
+    const constructorName = typeof error?.constructor
+        ?.name === "string"
+        ? error.constructor.name
+        : "";
+    const name = typeof error?.name === "string"
+        ? error.name
+        : "";
+    return (constructorName === "DeliveryError" ||
+        name === "DeliveryError" ||
+        constructorName === "TimeoutError" ||
+        name === "TimeoutError");
+};
 const EMPTY_HASHES = [];
 const normalizedHashValues = (hashes) => {
     if (Array.isArray(hashes)) {
@@ -1442,6 +1482,22 @@ const createIndexableDomainFromResolution = (resolution) => {
     }
     throw new Error("Unsupported resolution");
 };
+const mergeDefinedFanoutChannelOptions = (...sources) => {
+    let merged;
+    for (const source of sources) {
+        if (!source) {
+            continue;
+        }
+        for (const [key, value] of Object.entries(source)) {
+            if (value === undefined) {
+                continue;
+            }
+            merged ??= {};
+            merged[key] = value;
+        }
+    }
+    return merged;
+};
 const applySharedLogNativeDefaults = (options, defaults) => {
     if (!defaults) {
         return options;
@@ -1453,11 +1509,18 @@ const applySharedLogNativeDefaults = (options, defaults) => {
             nativeWireSync: options?.sync?.nativeWireSync ?? defaults.sync?.nativeWireSync,
         }
         : undefined;
+    const fanout = options?.fanout
+        ? {
+            ...options.fanout,
+            channel: mergeDefinedFanoutChannelOptions(defaults.fanout?.channel, options.fanout.channel),
+        }
+        : undefined;
     return {
         ...options,
         nativeBackbone: options?.nativeBackbone ?? defaults.nativeBackbone,
         nativeGraph: options?.nativeGraph ?? defaults.nativeGraph,
         sync,
+        fanout,
     };
 };
 export const DEFAULT_MIN_REPLICAS = 2;
@@ -1478,6 +1541,14 @@ const CHECKED_PRUNE_RETRY_MAX_DELAY_MS = 30_000;
 // DONT SET THIS ANY LOWER, because it will make the pid controller unstable as the system responses are not fast enough to updates from the pid controller
 const RECALCULATE_PARTICIPATION_DEBOUNCE_INTERVAL = 1000;
 const REPLICATION_ANNOUNCEMENT_RETRY_INTERVAL = 1000;
+const REPLICATION_ANNOUNCEMENT_REPAIR_INTERVAL = 1000;
+const REPLICATION_ANNOUNCEMENT_REPAIR_MAX_ATTEMPTS = 3;
+// Repair one bounded cohort per mutation generation. The subscriber snapshot
+// is a best-effort cache and can contain thousands of entries, so attempting
+// the whole cache after every role mutation would turn convergence repair into
+// an unbounded burst of separately signed, acknowledged messages. A cursor
+// retained across generations rotates best-effort coverage over later changes.
+const REPLICATION_ANNOUNCEMENT_REPAIR_TARGETS_PER_GENERATION = 8;
 const RECALCULATE_PARTICIPATION_MIN_RELATIVE_CHANGE = 0.01;
 const RECALCULATE_PARTICIPATION_MIN_RELATIVE_CHANGE_WITH_CPU_LIMIT = 0.005;
 const RECALCULATE_PARTICIPATION_MIN_RELATIVE_CHANGE_WITH_MEMORY_LIMIT = 0.001;
@@ -1517,9 +1588,13 @@ const REPLICATOR_LIVENESS_PROBE_FAILURES_TO_EVICT = 2;
 const CHURN_REPAIR_RETRY_SCHEDULE_MS = [
     0, 1_000, 3_000, 7_000, 15_000, 30_000, 45_000,
 ];
+// Preserve the bounded retry window for transient local misses, but serialize
+// delayed warmup sends per target so fixed snapshots cannot overlap and amplify
+// large transfers. Every queued pass re-checks current peer knowledge on entry.
 const JOIN_WARMUP_RETRY_SCHEDULE_MS = [
     0, 1_000, 3_000, 7_000, 15_000, 30_000, 60_000,
 ];
+const JOIN_WARMUP_SEND_SPACING_MS = 250;
 const JOIN_AUTHORITATIVE_RETRY_SCHEDULE_MS = [
     0, 1_000, 3_000, 7_000, 15_000, 30_000, 60_000,
 ];
@@ -1686,6 +1761,11 @@ let SharedLog = (() => {
         _subscriptionChangeCallbacks;
         _acceptSubscriptionChangeCallbacks = false;
         _replicationLifecycleController;
+        _activeReceiveHandlersByPeer;
+        _receiveHandlerDrainByPeer;
+        _receiveCleanupGateByPeer;
+        _subscriptionOpeningEpochByPeer;
+        _openingSyncCapabilitiesByPeer;
         _onFanoutDataFn;
         _onFanoutUnicastFn;
         _fanoutChannel;
@@ -1695,6 +1775,7 @@ let SharedLog = (() => {
         _closeController;
         _respondToIHaveTimeout;
         _checkedPrune;
+        _pendingIHaveCallbacks;
         _pendingIHaveExpiryTimer;
         _pendingIHaveExpiryDeadline = Number.POSITIVE_INFINITY;
         get _pendingDeletes() {
@@ -1710,6 +1791,18 @@ let SharedLog = (() => {
         _replicationInfoBlockedPeers;
         _replicationInfoRequestByPeer;
         _replicationInfoApplyQueueByPeer;
+        // Local receive generations fence replication-info handlers that were admitted
+        // before a liveness eviction but reach the per-peer apply lane after it. Unlike
+        // message timestamps, these tokens never compare clocks from different peers.
+        _replicationInfoReceiveEpochByPeer;
+        // Subscription callbacks can overlap because removing a replicator mutates the
+        // replication index asynchronously. Keep that lifecycle separate from message
+        // timestamps so a reconnect can synchronously revoke an older unsubscribe.
+        _subscriptionEpochByPeer;
+        // A superseded removal may be the queue item that actually observed an active
+        // replicator. Carry that leave obligation to the transition that ultimately
+        // wins, while a winning reconnect clears it without emitting a stale leave.
+        _pendingReplicatorLeaveByPeer;
         _replicatorLivenessSweepRunning;
         _replicatorLivenessTimer;
         _replicatorLivenessTargets;
@@ -2461,6 +2554,15 @@ let SharedLog = (() => {
         _replicationAnnouncementRetryPending;
         _replicationAnnouncementRetryGeneration;
         _replicationAnnouncementRetryController;
+        replicationAnnouncementRepairDebounced;
+        _replicationAnnouncementRepairPending;
+        _replicationAnnouncementRepairGeneration;
+        _replicationAnnouncementRepairGenerationController;
+        _replicationAnnouncementRepairTargets;
+        _replicationAnnouncementRepairCohortSelected;
+        _replicationAnnouncementRepairFairCursorHash;
+        _replicationAnnouncementRepairMaxAttempts;
+        _replicationAnnouncementRepairController;
         // A fn for debouncing the calls for pruning
         pruneDebouncedFn;
         responseToPruneDebouncedFn;
@@ -2479,10 +2581,16 @@ let SharedLog = (() => {
         _repairSweepRunning;
         _repairSweepPendingModes;
         _repairSweepPendingPeersByMode;
+        _repairSweepJoinWarmupGenerationByTarget;
         _repairFrontierByMode;
         _repairFrontierActiveTargetsByMode;
         _repairFrontierBypassKnownPeersByMode;
+        _joinWarmupGenerationByTarget;
+        _joinWarmupSendStateByTarget;
+        _joinWarmupRetryTimersByTarget;
+        _joinWarmupScheduledRetriesByTarget;
         _repairSweepOptimisticGidPeersPending;
+        _repairSweepOptimisticGidsByPeer;
         _entryKnownPeers;
         _entryKnownPeerObservedAt;
         _joinAuthoritativeRepairTimersByDelay;
@@ -2527,19 +2635,36 @@ let SharedLog = (() => {
             this.rpc = new RPC();
             this._checkedPrune = new CheckedPruneCoordinator();
             this._pendingIHave = new Map();
+            this._pendingIHaveCallbacks = new Set();
             this.latestReplicationInfoMessage = new Map();
             this._replicationInfoBlockedPeers = new Set();
             this._replicationInfoRequestByPeer = new Map();
             this._replicationInfoApplyQueueByPeer = new Map();
+            this._replicationInfoReceiveEpochByPeer = new Map();
+            this._subscriptionEpochByPeer = new Map();
+            this._pendingReplicatorLeaveByPeer = new Set();
+            this._activeReceiveHandlersByPeer = new Map();
+            this._receiveHandlerDrainByPeer = new Map();
+            this._receiveCleanupGateByPeer = new Map();
+            this._subscriptionOpeningEpochByPeer = new Map();
+            this._openingSyncCapabilitiesByPeer = new Map();
             this._gidPeersHistory = new Map();
             this._repairRetryTimers = new Set();
             this._recentRepairDispatch = new Map();
             this._repairSweepRunning = false;
             this._repairSweepPendingModes = new Set();
             this._repairSweepPendingPeersByMode = createRepairPendingPeersByMode();
+            this._repairSweepJoinWarmupGenerationByTarget = new Map();
             this._repairFrontierByMode = createRepairFrontierByMode();
             this._repairFrontierActiveTargetsByMode = createRepairActiveTargetsByMode();
+            this._repairFrontierBypassKnownPeersByMode =
+                createRepairFrontierBypassKnownPeersByMode();
+            this._joinWarmupGenerationByTarget = new Map();
+            this._joinWarmupSendStateByTarget = new Map();
+            this._joinWarmupRetryTimersByTarget = new Map();
+            this._joinWarmupScheduledRetriesByTarget = new Map();
             this._repairSweepOptimisticGidPeersPending = new Map();
+            this._repairSweepOptimisticGidsByPeer = new Map();
             this._entryKnownPeers = new Map();
             this._joinAuthoritativeRepairTimersByDelay = new Map();
             this._joinAuthoritativeRepairPeersByDelay = new Map();
@@ -2562,6 +2687,16 @@ let SharedLog = (() => {
             this._replicationAnnouncementRetryPending = false;
             this._replicationAnnouncementRetryGeneration = 0;
             this._replicationAnnouncementRetryController = new AbortController();
+            this._replicationAnnouncementRepairPending = false;
+            this._replicationAnnouncementRepairGeneration = 0;
+            this._replicationAnnouncementRepairGenerationController =
+                new AbortController();
+            this._replicationAnnouncementRepairTargets = new Map();
+            this._replicationAnnouncementRepairCohortSelected = false;
+            this._replicationAnnouncementRepairFairCursorHash = undefined;
+            this._replicationAnnouncementRepairMaxAttempts =
+                REPLICATION_ANNOUNCEMENT_REPAIR_MAX_ATTEMPTS;
+            this._replicationAnnouncementRepairController = new AbortController();
             this.pendingMaturity = new Map();
             this._closeController = new AbortController();
         }
@@ -2848,7 +2983,7 @@ let SharedLog = (() => {
             });
         }
         async _sendAckWithUnifiedHints(properties) {
-            const { peer, message, payload, fanoutUnicastOptions } = properties;
+            const { peer, message, payload, priority, fanoutUnicastOptions } = properties;
             const hints = await this._getSortedRouteHints(peer);
             const hasDirectHint = hints.some((hint) => hint.kind === "directstream-ack");
             const fanoutHint = hints.find((hint) => hint.kind === "fanout-token");
@@ -2859,6 +2994,7 @@ let SharedLog = (() => {
                             redundancy: 1,
                             to: [peer],
                         }),
+                        priority,
                     });
                     return;
                 }
@@ -2889,6 +3025,7 @@ let SharedLog = (() => {
                     redundancy: 1,
                     to: [peer],
                 }),
+                priority,
             });
         }
         /** Live append gossip that stayed on the plain TS path (countable in tests). */
@@ -3202,6 +3339,7 @@ let SharedLog = (() => {
                                     peer,
                                     message,
                                     payload,
+                                    priority: delivery.priority,
                                     fanoutUnicastOptions,
                                 });
                             })());
@@ -3214,6 +3352,7 @@ let SharedLog = (() => {
                                 redundancy: 1,
                                 to: nativeDeliveryPlan.silentTo,
                             }),
+                            priority: delivery.priority,
                         })
                             .catch((error) => logger.error(error));
                     }
@@ -3337,6 +3476,7 @@ let SharedLog = (() => {
                                 peer,
                                 message,
                                 payload,
+                                priority: delivery.priority,
                                 fanoutUnicastOptions,
                             });
                         })());
@@ -3346,6 +3486,7 @@ let SharedLog = (() => {
                     this.rpc
                         .send(message, {
                         mode: new SilentDelivery({ redundancy: 1, to: silentTo }),
+                        priority: delivery.priority,
                     })
                         .catch((error) => logger.error(error));
                 }
@@ -3611,6 +3752,134 @@ let SharedLog = (() => {
                 await Promise.all([...callbacks]);
             }
         }
+        isPeerReceiveAdmissionOpen(peerHash, replicationLifecycleController, subscriptionEpoch, options) {
+            return (this.isReplicationLifecycleActive(replicationLifecycleController) &&
+                this.isCurrentSubscriptionEpoch(peerHash, subscriptionEpoch) &&
+                (options?.allowReplicationInfoBlocked === true ||
+                    !this._replicationInfoBlockedPeers.has(peerHash)) &&
+                (options?.allowCleanupGate === true ||
+                    (this._receiveCleanupGateByPeer.get(peerHash) ?? 0) === 0));
+        }
+        acquirePeerReceiveLease(peerHash, replicationLifecycleController, subscriptionEpoch, options) {
+            if (!this.isPeerReceiveAdmissionOpen(peerHash, replicationLifecycleController, subscriptionEpoch, options)) {
+                return;
+            }
+            let state = this._activeReceiveHandlersByPeer.get(peerHash);
+            if (!state) {
+                const current = { active: 0 };
+                state = { current, activeBuckets: new Set() };
+                this._activeReceiveHandlersByPeer.set(peerHash, state);
+            }
+            const bucket = state.current;
+            bucket.active += 1;
+            state.activeBuckets.add(bucket);
+            let released = false;
+            return () => {
+                if (released) {
+                    return;
+                }
+                released = true;
+                bucket.active -= 1;
+                if (bucket.active > 0) {
+                    return;
+                }
+                state.activeBuckets.delete(bucket);
+                bucket.drain?.resolve();
+                if (state.activeBuckets.size === 0 &&
+                    state.current.active === 0 &&
+                    this._activeReceiveHandlersByPeer.get(peerHash) === state) {
+                    this._activeReceiveHandlersByPeer.delete(peerHash);
+                }
+            };
+        }
+        async drainPeerReceiveHandlers(peerHash) {
+            const state = this._activeReceiveHandlersByPeer.get(peerHash);
+            if (!state || state.activeBuckets.size === 0) {
+                return;
+            }
+            // Rotate before awaiting so a reconnect/opening generation can keep receiving
+            // sync traffic without joining the drain for the previous subscription. Cleanup
+            // callers gate admission first; terminal callers also repeat until empty.
+            const buckets = [...state.activeBuckets];
+            state.current = { active: 0 };
+            const drain = Promise.all(buckets.map((bucket) => {
+                bucket.drain ??= pDefer();
+                return bucket.drain.promise;
+            })).then(() => undefined);
+            let drains = this._receiveHandlerDrainByPeer.get(peerHash);
+            if (!drains) {
+                drains = new Set();
+                this._receiveHandlerDrainByPeer.set(peerHash, drains);
+            }
+            drains.add(drain);
+            try {
+                await drain;
+            }
+            finally {
+                drains.delete(drain);
+                if (drains.size === 0) {
+                    this._receiveHandlerDrainByPeer.delete(peerHash);
+                }
+            }
+        }
+        async drainReceiveHandlers() {
+            for (;;) {
+                const peers = [...this._activeReceiveHandlersByPeer.keys()];
+                if (peers.length === 0) {
+                    return;
+                }
+                await Promise.all(peers.map((peerHash) => this.drainPeerReceiveHandlers(peerHash)));
+            }
+        }
+        runPendingIHaveCallback(pending, entry) {
+            const replicationLifecycleController = this._replicationLifecycleController;
+            if (!this.isReplicationLifecycleActive(replicationLifecycleController)) {
+                if (this._pendingIHave.get(entry.hash) === pending) {
+                    pending.clear();
+                    this._pendingIHave.delete(entry.hash);
+                }
+                return;
+            }
+            // Register before invoking the callback so a synchronous terminal reentry
+            // cannot make close/drop miss work that has already been admitted.
+            const completion = pDefer();
+            const observed = completion.promise.catch((error) => {
+                if (!(this.isTerminating() && isNotStartedError(error))) {
+                    logger.error(error?.toString?.() ?? String(error));
+                }
+            });
+            this._pendingIHaveCallbacks.add(observed);
+            void observed.finally(() => {
+                this._pendingIHaveCallbacks.delete(observed);
+                if (this._pendingIHave.get(entry.hash) === pending) {
+                    pending.clear();
+                    this._pendingIHave.delete(entry.hash);
+                }
+            });
+            try {
+                Promise.resolve(pending.callback(entry)).then(() => completion.resolve(), (error) => completion.reject(error));
+            }
+            catch (error) {
+                completion.reject(error);
+            }
+        }
+        async drainPendingIHaveCallbacks() {
+            while (this._pendingIHaveCallbacks.size > 0) {
+                await Promise.all([...this._pendingIHaveCallbacks]);
+            }
+        }
+        blockPeerReceiveAdmission(peerHash) {
+            this._receiveCleanupGateByPeer.set(peerHash, (this._receiveCleanupGateByPeer.get(peerHash) ?? 0) + 1);
+        }
+        unblockPeerReceiveAdmission(peerHash) {
+            const remaining = (this._receiveCleanupGateByPeer.get(peerHash) ?? 1) - 1;
+            if (remaining > 0) {
+                this._receiveCleanupGateByPeer.set(peerHash, remaining);
+            }
+            else {
+                this._receiveCleanupGateByPeer.delete(peerHash);
+            }
+        }
         handleReplicationLifecycleSendError(error, controller = this._replicationLifecycleController) {
             if ((controller?.signal.aborted ||
                 !this.isReplicationLifecycleActive(controller)) &&
@@ -3689,11 +3958,232 @@ let SharedLog = (() => {
                 },
             });
         }
+        setupReplicationAnnouncementRepairFunction(interval = REPLICATION_ANNOUNCEMENT_REPAIR_INTERVAL, maxAttempts = REPLICATION_ANNOUNCEMENT_REPAIR_MAX_ATTEMPTS) {
+            if (!Number.isSafeInteger(maxAttempts) || maxAttempts <= 0) {
+                throw new RangeError("Replication announcement repair attempts must be positive");
+            }
+            this.replicationAnnouncementRepairDebounced?.close();
+            this._replicationAnnouncementRepairController?.abort();
+            this._replicationAnnouncementRepairGenerationController?.abort();
+            this._replicationAnnouncementRepairController = new AbortController();
+            this._replicationAnnouncementRepairGenerationController =
+                new AbortController();
+            this._replicationAnnouncementRepairPending = false;
+            this._replicationAnnouncementRepairGeneration =
+                this._replicationAnnouncementRetryGeneration;
+            this._replicationAnnouncementRepairTargets = new Map();
+            this._replicationAnnouncementRepairCohortSelected = false;
+            this._replicationAnnouncementRepairFairCursorHash = undefined;
+            this._replicationAnnouncementRepairMaxAttempts = maxAttempts;
+            this.replicationAnnouncementRepairDebounced = debounceFixedInterval(() => this.runCurrentReplicationStateAnnouncementRepair(), interval, {
+                leading: false,
+                // The wrapper catches worker failures while it still owns the generation
+                // context. Keep this boundary visibility-only: it must never mutate a
+                // possibly newer generation's pending state.
+                onError: (error) => logger.error(error),
+            });
+        }
+        cancelCurrentReplicationStateAnnouncementRepair() {
+            this._replicationAnnouncementRepairPending = false;
+            this._replicationAnnouncementRepairController?.abort();
+            this._replicationAnnouncementRepairGenerationController?.abort();
+            this.replicationAnnouncementRepairDebounced?.close();
+            this._replicationAnnouncementRepairTargets?.clear();
+        }
+        advanceCurrentReplicationStateAnnouncementRepairGeneration() {
+            const generation = this._replicationAnnouncementRetryGeneration;
+            if (generation === this._replicationAnnouncementRepairGeneration) {
+                return;
+            }
+            // Abort acknowledged sends carrying the old full-state snapshot before the
+            // primary announcement for the new mutation waits on transport. Otherwise a
+            // stale batch can hold the current state behind DirectStream's seek timeout.
+            this._replicationAnnouncementRepairGenerationController?.abort();
+            this._replicationAnnouncementRepairGenerationController =
+                new AbortController();
+            this._replicationAnnouncementRepairGeneration = generation;
+            this._replicationAnnouncementRepairPending = false;
+            this._replicationAnnouncementRepairTargets.clear();
+            this._replicationAnnouncementRepairCohortSelected = false;
+        }
+        queueCurrentReplicationStateAnnouncementRepair() {
+            if (this.closed ||
+                this._closeController.signal.aborted ||
+                this._replicationAnnouncementRepairController.signal.aborted ||
+                !this.replicationAnnouncementRepairDebounced) {
+                return;
+            }
+            this.advanceCurrentReplicationStateAnnouncementRepairGeneration();
+            this._replicationAnnouncementRepairPending = true;
+            void this.replicationAnnouncementRepairDebounced.call();
+        }
+        async runCurrentReplicationStateAnnouncementRepair() {
+            const generation = this._replicationAnnouncementRetryGeneration;
+            const lifecycleController = this._replicationAnnouncementRepairController;
+            const generationController = this._replicationAnnouncementRepairGenerationController;
+            try {
+                await this.repairCurrentReplicationStateAnnouncement({
+                    generation,
+                    lifecycleController,
+                    generationController,
+                });
+            }
+            catch (error) {
+                if (this.closed ||
+                    this._closeController.signal.aborted ||
+                    lifecycleController.signal.aborted ||
+                    generationController.signal.aborted ||
+                    generation !== this._replicationAnnouncementRetryGeneration ||
+                    generationController !==
+                        this._replicationAnnouncementRepairGenerationController) {
+                    return;
+                }
+                if (isNotStartedError(error)) {
+                    return;
+                }
+                // Only the worker that still owns the current generation may conclude
+                // that its repair failed. A stale worker must not clear a newer call's
+                // pending flag or attribute its error to the new generation.
+                this._replicationAnnouncementRepairPending = false;
+                logger.error(error);
+            }
+        }
+        async repairCurrentReplicationStateAnnouncement(context) {
+            if (!this._replicationAnnouncementRepairPending) {
+                return;
+            }
+            const generation = context?.generation ?? this._replicationAnnouncementRetryGeneration;
+            const lifecycleController = context?.lifecycleController ??
+                this._replicationAnnouncementRepairController;
+            const generationController = context?.generationController ??
+                this._replicationAnnouncementRepairGenerationController;
+            const segments = (await this.getMyReplicationSegments()).map((range) => range.toReplicationRange());
+            if (this.closed ||
+                this._closeController.signal.aborted ||
+                lifecycleController.signal.aborted ||
+                generationController.signal.aborted) {
+                return;
+            }
+            if (generation !== this._replicationAnnouncementRetryGeneration) {
+                this.queueCurrentReplicationStateAnnouncementRepair();
+                return;
+            }
+            const subscribers = (await this.node.services.pubsub.getSubscribers(this.topic)) ?? [];
+            if (this.closed ||
+                this._closeController.signal.aborted ||
+                lifecycleController.signal.aborted ||
+                generationController.signal.aborted) {
+                return;
+            }
+            if (generation !== this._replicationAnnouncementRetryGeneration) {
+                this.queueCurrentReplicationStateAnnouncementRepair();
+                return;
+            }
+            const selfHash = this.node.identity.publicKey.hashcode();
+            const currentTargets = new Map();
+            for (const key of subscribers) {
+                const hash = key.hashcode();
+                if (hash !== selfHash &&
+                    !this._replicationInfoBlockedPeers.has(hash) &&
+                    !currentTargets.has(hash)) {
+                    currentTargets.set(hash, key);
+                }
+            }
+            for (const [hash, target] of this._replicationAnnouncementRepairTargets) {
+                if (target.generation !== generation || !currentTargets.has(hash)) {
+                    this._replicationAnnouncementRepairTargets.delete(hash);
+                }
+                else {
+                    target.key = currentTargets.get(hash);
+                }
+            }
+            if (!this._replicationAnnouncementRepairCohortSelected) {
+                const candidates = [...currentTargets.entries()].sort(([left], [right]) => left.localeCompare(right));
+                const cursorIndex = this._replicationAnnouncementRepairFairCursorHash
+                    ? candidates.findIndex(([hash]) => hash.localeCompare(this._replicationAnnouncementRepairFairCursorHash) > 0)
+                    : 0;
+                const fairStart = cursorIndex < 0 ? 0 : cursorIndex;
+                const fairOrder = [
+                    ...candidates.slice(fairStart),
+                    ...candidates.slice(0, fairStart),
+                ];
+                const cohort = fairOrder.slice(0, REPLICATION_ANNOUNCEMENT_REPAIR_TARGETS_PER_GENERATION);
+                for (const [hash, key] of cohort) {
+                    this._replicationAnnouncementRepairTargets.set(hash, {
+                        key,
+                        generation,
+                        attempts: 0,
+                        done: false,
+                    });
+                }
+                if (cohort.length > 0) {
+                    this._replicationAnnouncementRepairFairCursorHash =
+                        cohort[cohort.length - 1][0];
+                }
+                this._replicationAnnouncementRepairCohortSelected = true;
+            }
+            const batch = [
+                ...this._replicationAnnouncementRepairTargets.entries(),
+            ].filter(([, target]) => !target.done);
+            const snapshot = new AllReplicatingSegmentsMessage({ segments });
+            const results = await Promise.allSettled(batch.map(([, target]) => this.rpc.send(snapshot, {
+                mode: new AcknowledgeDelivery({
+                    to: [target.key],
+                    redundancy: 1,
+                }),
+                priority: CONVERGENCE_MESSAGE_PRIORITY,
+                signal: generationController.signal,
+            })));
+            if (this.closed ||
+                this._closeController.signal.aborted ||
+                lifecycleController.signal.aborted ||
+                generationController.signal.aborted) {
+                return;
+            }
+            if (generation !== this._replicationAnnouncementRetryGeneration) {
+                this.queueCurrentReplicationStateAnnouncementRepair();
+                return;
+            }
+            for (const [index, result] of results.entries()) {
+                const [hash, attemptedTarget] = batch[index];
+                const target = this._replicationAnnouncementRepairTargets.get(hash);
+                if (target !== attemptedTarget || target.generation !== generation) {
+                    continue;
+                }
+                if (result.status === "fulfilled") {
+                    // DirectStream ACKs confirm that the signed transport envelope reached
+                    // the target. Applying the contained replication state remains a
+                    // receiver-local, best-effort operation.
+                    target.done = true;
+                    continue;
+                }
+                target.attempts += 1;
+                if (!isTransientReplicationAnnouncementRepairError(result.reason)) {
+                    target.done = true;
+                    logger.error(result.reason);
+                }
+                else if (target.attempts >= this._replicationAnnouncementRepairMaxAttempts) {
+                    target.done = true;
+                    logger.trace("Acknowledged replication announcement repair exhausted for %s", hash);
+                }
+            }
+            if (generation !== this._replicationAnnouncementRetryGeneration) {
+                this.queueCurrentReplicationStateAnnouncementRepair();
+                return;
+            }
+            if ([...this._replicationAnnouncementRepairTargets.values()].some((target) => !target.done)) {
+                void this.replicationAnnouncementRepairDebounced?.call();
+                return;
+            }
+            this._replicationAnnouncementRepairPending = false;
+            this._replicationAnnouncementRepairTargets.clear();
+        }
         cancelCurrentReplicationStateAnnouncementRetry() {
             this._replicationAnnouncementRetryGeneration += 1;
             this._replicationAnnouncementRetryPending = false;
             this._replicationAnnouncementRetryController?.abort();
             this.replicationAnnouncementRetryDebounced?.close();
+            this.cancelCurrentReplicationStateAnnouncementRepair();
         }
         async sendReplicationAnnouncement(message) {
             // Advance before every post-mutation send, including successful ones. An
@@ -3701,10 +4191,12 @@ let SharedLog = (() => {
             // local state; the generation mismatch forces one more current snapshot
             // after that stale send settles.
             this._replicationAnnouncementRetryGeneration += 1;
+            this.advanceCurrentReplicationStateAnnouncementRepairGeneration();
             try {
                 await this.rpc.send(message, {
                     priority: CONVERGENCE_MESSAGE_PRIORITY,
                 });
+                this.queueCurrentReplicationStateAnnouncementRepair();
             }
             catch (error) {
                 // The local replication-index mutation precedes all calls to this
@@ -3733,6 +4225,7 @@ let SharedLog = (() => {
                     priority: CONVERGENCE_MESSAGE_PRIORITY,
                     signal: controller.signal,
                 });
+                this.queueCurrentReplicationStateAnnouncementRepair();
             }
             catch (error) {
                 if (this.closed ||
@@ -4139,61 +4632,135 @@ let SharedLog = (() => {
         }
         async removeReplicator(key, options) {
             const keyHash = typeof key === "string" ? key : key.hashcode();
-            const deleted = await this.replicationIndex
-                .iterate({
-                query: { hash: keyHash },
-            })
-                .all();
-            this.uniqueReplicators.delete(keyHash);
-            this._replicatorJoinEmitted.delete(keyHash);
-            await this.replicationIndex.del({ query: { hash: keyHash } });
-            for (const result of deleted) {
-                this.deleteNativeReplicationRange(result.value);
-            }
-            await this.updateOldestTimestampFromIndex();
-            const isMe = this.node.identity.publicKey.hashcode() === keyHash;
-            if (isMe) {
-                // announce that we are no longer replicating
-                await this.sendReplicationAnnouncement(new AllReplicatingSegmentsMessage({ segments: [] }));
-            }
-            if (options?.noEvent !== true) {
-                const publicKey = toLocalPublicSignKey(key);
-                if (publicKey) {
-                    this.events.dispatchEvent(new CustomEvent("replication:change", {
-                        detail: { publicKey },
-                    }));
+            const expectedJoinWarmupGeneration = options?.expectedJoinWarmupGeneration !== undefined
+                ? options.expectedJoinWarmupGeneration
+                : (this._joinWarmupGenerationByTarget.get(keyHash) ?? null);
+            const ownsSubscriptionEpoch = () => options?.subscriptionEpoch === undefined ||
+                this.isCurrentSubscriptionEpoch(keyHash, options.subscriptionEpoch);
+            const ownsReplicationLifecycle = () => options?.replicationLifecycleController === undefined ||
+                this.isReplicationLifecycleActive(options.replicationLifecycleController);
+            const cancelExpectedJoinWarmupTarget = () => {
+                if (expectedJoinWarmupGeneration !== null &&
+                    this._joinWarmupGenerationByTarget.get(keyHash) ===
+                        expectedJoinWarmupGeneration) {
+                    this.cancelJoinWarmupTarget(keyHash);
                 }
-                else {
-                    throw new Error("Key was not a PublicSignKey");
+            };
+            const isMe = this.node.identity.publicKey.hashcode() === keyHash;
+            let receiveAdmissionBlocked = false;
+            const blockAndDrainPeerReceives = async () => {
+                if (!receiveAdmissionBlocked) {
+                    this.blockPeerReceiveAdmission(keyHash);
+                    receiveAdmissionBlocked = true;
                 }
-            }
-            const timestamp = BigInt(+new Date());
-            for (const x of deleted) {
-                this.replicationChangeDebounceFn.add({
-                    range: x.value,
-                    type: "removed",
-                    timestamp,
+                await this.drainPeerReceiveHandlers(keyHash);
+            };
+            const cleanupDisconnectedPeer = async () => {
+                await blockAndDrainPeerReceives();
+                this.removePeerFromGidPeerHistory(keyHash);
+                this.cleanupPeerDisconnectTracking(keyHash);
+                this.removeRepairFrontierTarget(keyHash, {
+                    expectedJoinWarmupGeneration,
                 });
-            }
-            const pendingMaturity = this.pendingMaturity.get(keyHash);
-            if (pendingMaturity) {
-                for (const [_k, v] of pendingMaturity) {
-                    clearTimeout(v.timeout);
+                this._recentRepairDispatch.delete(keyHash);
+                if (!isMe) {
+                    await this.syncronizer.onPeerDisconnected(keyHash);
                 }
-                this.pendingMaturity.delete(keyHash);
-            }
-            // Keep local sync/prune state consistent even when a peer disappears
-            // through replication-info updates without a topic unsubscribe event.
-            this.removePeerFromGidPeerHistory(keyHash);
-            this._checkedPrune.cleanupPeer(keyHash);
-            this.removeRepairFrontierTarget(keyHash);
-            this._recentRepairDispatch.delete(keyHash);
-            if (!isMe) {
-                this.syncronizer.onPeerDisconnected(keyHash);
-            }
-            if (!isMe) {
-                this.rebalanceParticipationDebounced?.call();
-            }
+            };
+            let removed = false;
+            // Replication-info updates already serialize per peer. Put the hash-wide
+            // removal on the same queue so a newer reset cannot be deleted underneath
+            // itself by an older unsubscribe callback.
+            await this.withReplicationInfoApplyQueue(keyHash, async () => {
+                if (!ownsReplicationLifecycle()) {
+                    return;
+                }
+                if (!ownsSubscriptionEpoch()) {
+                    // A reconnect may supersede an unsubscribe before its destructive
+                    // removal starts. Still retire the old connection's sync/request state
+                    // in lane order so the reconnect barrier cannot inherit stale caches.
+                    if (options?.cleanupIfSubscriptionSuperseded) {
+                        await cleanupDisconnectedPeer();
+                    }
+                    return;
+                }
+                if (options?.shouldRemove && !options.shouldRemove()) {
+                    return;
+                }
+                const wasReplicator = this.uniqueReplicators.has(keyHash);
+                const deleted = await this.replicationIndex
+                    .iterate({
+                    query: { hash: keyHash },
+                })
+                    .all();
+                // Liveness evidence can arrive without a subscription transition while
+                // this scan is pending. Stop new receives, drain those already admitted,
+                // then revalidate immediately before the first destructive mutation.
+                await blockAndDrainPeerReceives();
+                if (options?.shouldRemove && !options.shouldRemove()) {
+                    return;
+                }
+                // Liveness removal must not cancel a still-current warmup until fresh
+                // activity has been rechecked at the destructive boundary.
+                cancelExpectedJoinWarmupTarget();
+                await this.replicationIndex.del({ query: { hash: keyHash } });
+                for (const result of deleted) {
+                    this.deleteNativeReplicationRange(result.value);
+                }
+                // Once the range indexes have removed the peer, make membership agree
+                // before any later awaited bookkeeping can fail.
+                this.uniqueReplicators.delete(keyHash);
+                this._replicatorJoinEmitted.delete(keyHash);
+                await this.updateOldestTimestampFromIndex();
+                if (isMe) {
+                    // announce that we are no longer replicating
+                    await this.sendReplicationAnnouncement(new AllReplicatingSegmentsMessage({ segments: [] }));
+                }
+                if (options?.noEvent !== true) {
+                    const publicKey = toLocalPublicSignKey(key);
+                    if (publicKey) {
+                        this.events.dispatchEvent(new CustomEvent("replication:change", {
+                            detail: { publicKey },
+                        }));
+                    }
+                    else {
+                        throw new Error("Key was not a PublicSignKey");
+                    }
+                }
+                const timestamp = BigInt(+new Date());
+                for (const x of deleted) {
+                    this.replicationChangeDebounceFn.add({
+                        range: x.value,
+                        type: "removed",
+                        timestamp,
+                    });
+                }
+                const pendingMaturity = this.pendingMaturity.get(keyHash);
+                if (pendingMaturity) {
+                    for (const [_k, v] of pendingMaturity) {
+                        clearTimeout(v.timeout);
+                    }
+                    this.pendingMaturity.delete(keyHash);
+                }
+                // Keep local sync/prune state consistent even when a peer disappears
+                // through replication-info updates without a topic unsubscribe event.
+                await cleanupDisconnectedPeer();
+                if (!isMe) {
+                    // Replication-info handlers release their receive lease before joining
+                    // this lane. Fence every handler queued behind this successful removal,
+                    // regardless of whether it came from liveness, startup pruning, or an
+                    // unsubscribe transition.
+                    this.advanceReplicationInfoRecoveryEpoch(keyHash);
+                    this.rebalanceParticipationDebounced?.call();
+                }
+                removed = true;
+                options?.onRemoved?.({ wasReplicator });
+            }).finally(() => {
+                if (receiveAdmissionBlocked) {
+                    this.unblockPeerReceiveAdmission(keyHash);
+                }
+            });
+            return removed;
         }
         async updateOldestTimestampFromIndex() {
             const iterator = await this.replicationIndex.iterate({
@@ -4257,6 +4824,10 @@ let SharedLog = (() => {
             if (this._isTrustedReplicator && !(await this._isTrustedReplicator(from))) {
                 return undefined;
             }
+            // Preserve what the peer announced before duplicate filtering can empty the
+            // working array. A repeated authoritative/non-empty announcement is still
+            // proof of live membership after this process reopens.
+            const announcedReplication = ranges.length > 0;
             let isNewReplicator = false;
             let timestamp = BigInt(ts ?? +new Date());
             rebalance = rebalance == null ? true : rebalance;
@@ -4376,14 +4947,14 @@ let SharedLog = (() => {
             // means "nothing new", not "stopped". Removing the peer here would let
             // uniqueReplicators diverge from replicationIndex while the peer's
             // ranges stay indexed.
-            const announcedStopped = reset === true && ranges.length === 0;
+            const announcedStopped = reset === true && !announcedReplication;
             const stoppedTransition = announcedStopped
                 ? this.uniqueReplicators.delete(fromHash)
                 : false;
             if (announcedStopped) {
                 this._replicatorJoinEmitted.delete(fromHash);
             }
-            else if (ranges.length > 0) {
+            else if (announcedReplication) {
                 this.uniqueReplicators.add(fromHash);
             }
             let now = +new Date();
@@ -4488,6 +5059,14 @@ let SharedLog = (() => {
                     this.rebalanceParticipationDebounced?.call();
                 }
             }
+            if (announcedReplication &&
+                !from.equals(this.node.identity.publicKey) &&
+                !this._replicatorJoinEmitted.has(fromHash)) {
+                this._replicatorJoinEmitted.add(fromHash);
+                this.events.dispatchEvent(new CustomEvent("replicator:join", {
+                    detail: { publicKey: from },
+                }));
+            }
             return diffs;
         }
         async startAnnounceReplicating(range, options = {}) {
@@ -4679,16 +5258,40 @@ let SharedLog = (() => {
             const observedAt = this._entryKnownPeerObservedAt.get(hash)?.get(peer);
             return observedAt != null && Date.now() - observedAt <= maxAgeMs;
         }
-        markRepairSweepOptimisticPeer(gid, peer) {
+        markRepairSweepOptimisticPeer(gid, peer, generation) {
             let peers = this._repairSweepOptimisticGidPeersPending.get(gid);
             if (!peers) {
                 peers = new Map();
                 this._repairSweepOptimisticGidPeersPending.set(gid, peers);
             }
-            peers.set(peer, (peers.get(peer) || 0) + 1);
+            const current = peers.get(peer);
+            peers.set(peer, {
+                count: current?.generation === generation ? current.count + 1 : 1,
+                generation,
+            });
+            let gids = this._repairSweepOptimisticGidsByPeer.get(peer);
+            if (!gids) {
+                gids = new Set();
+                this._repairSweepOptimisticGidsByPeer.set(peer, gids);
+            }
+            gids.add(gid);
         }
         hasPendingRepairSweepOptimisticPeer(gid, peer) {
-            return ((this._repairSweepOptimisticGidPeersPending.get(gid)?.get(peer) || 0) > 0);
+            return ((this._repairSweepOptimisticGidPeersPending.get(gid)?.get(peer)?.count ||
+                0) > 0);
+        }
+        clearRepairSweepOptimisticPeer(peer) {
+            for (const gid of this._repairSweepOptimisticGidsByPeer.get(peer) ?? []) {
+                const peers = this._repairSweepOptimisticGidPeersPending.get(gid);
+                if (!peers) {
+                    continue;
+                }
+                peers.delete(peer);
+                if (peers.size === 0) {
+                    this._repairSweepOptimisticGidPeersPending.delete(gid);
+                }
+            }
+            this._repairSweepOptimisticGidsByPeer.delete(peer);
         }
         createEntryReplicatedForRepair(properties) {
             const assignedToRangeBoundary = shouldAssignToRangeBoundary(properties.leaders, properties.replicas);
@@ -4757,14 +5360,221 @@ let SharedLog = (() => {
                 if (!pending) {
                     continue;
                 }
-                for (const hash of hashList) {
-                    pending.delete(hash);
+                for (const hash of hashList) {
+                    pending.delete(hash);
+                }
+                if (pending.size === 0) {
+                    this._repairFrontierByMode.get(mode)?.delete(target);
+                    this._repairFrontierBypassKnownPeersByMode.get(mode)?.delete(target);
+                }
+            }
+        }
+        getJoinWarmupGeneration(target) {
+            let generation = this._joinWarmupGenerationByTarget.get(target);
+            if (!generation) {
+                generation = {};
+                this._joinWarmupGenerationByTarget.set(target, generation);
+            }
+            return generation;
+        }
+        trackJoinWarmupTimer(target, timer) {
+            let timers = this._joinWarmupRetryTimersByTarget.get(target);
+            if (!timers) {
+                timers = new Set();
+                this._joinWarmupRetryTimersByTarget.set(target, timers);
+            }
+            timers.add(timer);
+            this._repairRetryTimers.add(timer.handle);
+        }
+        untrackJoinWarmupTimer(target, timer) {
+            this._repairRetryTimers.delete(timer.handle);
+            const timers = this._joinWarmupRetryTimersByTarget.get(target);
+            if (!timers) {
+                return;
+            }
+            timers.delete(timer);
+            if (timers.size === 0) {
+                this._joinWarmupRetryTimersByTarget.delete(target);
+            }
+        }
+        cancelJoinWarmupTimers(target) {
+            const timers = this._joinWarmupRetryTimersByTarget.get(target);
+            if (!timers) {
+                return;
+            }
+            for (const timer of [...timers]) {
+                clearTimeout(timer.handle);
+                timer.resolve?.();
+                this.untrackJoinWarmupTimer(target, timer);
+            }
+        }
+        cancelJoinWarmupTarget(target) {
+            this._joinWarmupGenerationByTarget.delete(target);
+            const pendingWarmupPeers = this._repairSweepPendingPeersByMode.get("join-warmup");
+            pendingWarmupPeers?.delete(target);
+            if (pendingWarmupPeers?.size === 0) {
+                this._repairSweepPendingModes.delete("join-warmup");
+            }
+            this._repairSweepJoinWarmupGenerationByTarget.delete(target);
+            this.clearRepairSweepOptimisticPeer(target);
+            this.cancelJoinWarmupTimers(target);
+            this._joinWarmupScheduledRetriesByTarget.delete(target);
+            const state = this._joinWarmupSendStateByTarget.get(target);
+            if (!state) {
+                return;
+            }
+            state.bypassKnownPeerHints = false;
+            state.entries.clear();
+            state.pending = false;
+            if (!state.running) {
+                this._joinWarmupSendStateByTarget.delete(target);
+            }
+        }
+        cancelAllJoinWarmupTargets() {
+            const targets = new Set([
+                ...this._joinWarmupGenerationByTarget.keys(),
+                ...this._joinWarmupRetryTimersByTarget.keys(),
+                ...this._joinWarmupScheduledRetriesByTarget.keys(),
+                ...this._joinWarmupSendStateByTarget.keys(),
+            ]);
+            for (const target of targets) {
+                this.cancelJoinWarmupTarget(target);
+            }
+        }
+        async sleepJoinWarmupTracked(target, delayMs) {
+            if (delayMs <= 0) {
+                return;
+            }
+            await new Promise((resolve) => {
+                let settled = false;
+                let trackedTimer;
+                const settle = () => {
+                    if (settled) {
+                        return;
+                    }
+                    settled = true;
+                    this.untrackJoinWarmupTimer(target, trackedTimer);
+                    resolve();
+                };
+                const handle = setTimeout(settle, delayMs);
+                handle.unref?.();
+                trackedTimer = { handle, resolve: settle };
+                this.trackJoinWarmupTimer(target, trackedTimer);
+            });
+        }
+        scheduleJoinWarmupRetries(target, generation, delaysMs, entries, bypassKnownPeerHints) {
+            if (this.closed ||
+                this._joinWarmupGenerationByTarget.get(target) !== generation) {
+                return;
+            }
+            let scheduled = this._joinWarmupScheduledRetriesByTarget.get(target);
+            if (scheduled?.generation !== generation) {
+                this.cancelJoinWarmupTimers(target);
+                this._joinWarmupScheduledRetriesByTarget.delete(target);
+                scheduled = undefined;
+            }
+            if (!scheduled) {
+                scheduled = {
+                    generation,
+                    slotsByDelay: new Map(),
+                };
+                this._joinWarmupScheduledRetriesByTarget.set(target, scheduled);
+            }
+            const delays = [...new Set(delaysMs)];
+            const batch = {
+                bypassKnownPeerHints,
+                entries: new Map(entries),
+                remainingAttempts: delays.length,
+            };
+            const now = Date.now();
+            for (const delayMs of delays) {
+                let slot = scheduled.slotsByDelay.get(delayMs);
+                if (!slot) {
+                    slot = { cohorts: [], head: 0 };
+                    scheduled.slotsByDelay.set(delayMs, slot);
+                }
+                const tail = slot.cohorts.at(-1);
+                const dueAt = Math.max(tail?.dueAt ?? 0, now + delayMs);
+                if (tail?.dueAt === dueAt) {
+                    tail.batches.push(batch);
+                }
+                else {
+                    slot.cohorts.push({
+                        batches: [batch],
+                        dueAt,
+                    });
+                }
+                this.armJoinWarmupRetrySlot(target, scheduled, delayMs, slot);
+            }
+        }
+        armJoinWarmupRetrySlot(target, scheduled, delayMs, slot) {
+            const nextDueAt = slot.cohorts[slot.head]?.dueAt;
+            if (nextDueAt == null) {
+                return;
+            }
+            if (slot.timer && slot.timerDueAt === nextDueAt) {
+                return;
+            }
+            if (slot.timer) {
+                clearTimeout(slot.timer.handle);
+                this.untrackJoinWarmupTimer(target, slot.timer);
+            }
+            let trackedTimer;
+            const handle = setTimeout(() => {
+                this.untrackJoinWarmupTimer(target, trackedTimer);
+                if (slot.timer !== trackedTimer) {
+                    return;
+                }
+                slot.timer = undefined;
+                slot.timerDueAt = undefined;
+                const current = this._joinWarmupScheduledRetriesByTarget.get(target);
+                if (current !== scheduled ||
+                    current.slotsByDelay.get(delayMs) !== slot) {
+                    return;
+                }
+                const dueEntries = new Map();
+                let bypassKnownPeerHints = false;
+                const now = Date.now();
+                while (slot.head < slot.cohorts.length &&
+                    slot.cohorts[slot.head].dueAt <= now) {
+                    const cohort = slot.cohorts[slot.head++];
+                    for (const batch of cohort.batches) {
+                        for (const [hash, entry] of batch.entries) {
+                            dueEntries.set(hash, entry);
+                        }
+                        bypassKnownPeerHints ||=
+                            batch.bypassKnownPeerHints;
+                        batch.remainingAttempts -= 1;
+                        if (batch.remainingAttempts === 0) {
+                            batch.entries.clear();
+                        }
+                    }
+                    cohort.batches.length = 0;
+                }
+                if (dueEntries.size > 0 &&
+                    !this.closed &&
+                    this._joinWarmupGenerationByTarget.get(target) ===
+                        scheduled.generation) {
+                    this.queueJoinWarmupSend(target, scheduled.generation, dueEntries, bypassKnownPeerHints);
                 }
-                if (pending.size === 0) {
-                    this._repairFrontierByMode.get(mode)?.delete(target);
-                    this._repairFrontierBypassKnownPeersByMode.get(mode)?.delete(target);
+                if (slot.head === slot.cohorts.length) {
+                    current.slotsByDelay.delete(delayMs);
+                    if (current.slotsByDelay.size === 0) {
+                        this._joinWarmupScheduledRetriesByTarget.delete(target);
+                    }
+                    return;
                 }
-            }
+                if (slot.head >= 1_024 && slot.head * 2 >= slot.cohorts.length) {
+                    slot.cohorts = slot.cohorts.slice(slot.head);
+                    slot.head = 0;
+                }
+                this.armJoinWarmupRetrySlot(target, current, delayMs, slot);
+            }, Math.max(0, nextDueAt - Date.now()));
+            handle.unref?.();
+            trackedTimer = { handle };
+            slot.timer = trackedTimer;
+            slot.timerDueAt = nextDueAt;
+            this.trackJoinWarmupTimer(target, trackedTimer);
         }
         async getFullReplicaRepairCandidates(extraPeers, options) {
             const candidates = new Set([
@@ -4795,7 +5605,13 @@ let SharedLog = (() => {
             }
             return candidates;
         }
-        removeRepairFrontierTarget(target) {
+        removeRepairFrontierTarget(target, options) {
+            if (options?.expectedJoinWarmupGeneration === undefined ||
+                (options.expectedJoinWarmupGeneration !== null &&
+                    this._joinWarmupGenerationByTarget.get(target) ===
+                        options.expectedJoinWarmupGeneration)) {
+                this.cancelJoinWarmupTarget(target);
+            }
             for (const mode of REPAIR_DISPATCH_MODES) {
                 this._repairFrontierByMode.get(mode)?.delete(target);
                 this._repairFrontierActiveTargetsByMode.get(mode)?.delete(target);
@@ -4870,6 +5686,89 @@ let SharedLog = (() => {
                 targets: [target],
             });
         }
+        queueJoinWarmupSend(target, generation, entries, bypassKnownPeerHints) {
+            if (this.closed ||
+                this._joinWarmupGenerationByTarget.get(target) !== generation) {
+                return;
+            }
+            let state = this._joinWarmupSendStateByTarget.get(target);
+            if (!state) {
+                state = {
+                    bypassKnownPeerHints: false,
+                    entries: new Map(),
+                    generation,
+                    lastCompletedAt: Number.NEGATIVE_INFINITY,
+                    pending: false,
+                    running: false,
+                };
+                this._joinWarmupSendStateByTarget.set(target, state);
+            }
+            else if (state.generation !== generation) {
+                state.bypassKnownPeerHints = false;
+                state.entries.clear();
+                state.pending = false;
+            }
+            for (const [hash, entry] of entries) {
+                state.entries.set(hash, entry);
+            }
+            state.bypassKnownPeerHints ||= bypassKnownPeerHints;
+            state.generation = generation;
+            state.pending = true;
+            if (state.running) {
+                return;
+            }
+            void this.drainJoinWarmupSends(target, state).catch((error) => logger.error(error));
+        }
+        async drainJoinWarmupSends(target, state) {
+            if (state.running) {
+                return;
+            }
+            state.running = true;
+            try {
+                while (state.pending) {
+                    state.pending = false;
+                    const generation = state.generation;
+                    const entries = new Map(state.entries);
+                    state.entries.clear();
+                    const bypassKnownPeerHints = state.bypassKnownPeerHints;
+                    state.bypassKnownPeerHints = false;
+                    const spacingMs = Math.max(0, state.lastCompletedAt + JOIN_WARMUP_SEND_SPACING_MS - Date.now());
+                    await this.sleepJoinWarmupTracked(target, spacingMs);
+                    if (this.closed ||
+                        state.generation !== generation ||
+                        this._joinWarmupGenerationByTarget.get(target) !== generation) {
+                        continue;
+                    }
+                    if (entries.size === 0) {
+                        continue;
+                    }
+                    this._repairMetrics["join-warmup"].simpleFallbackPasses += 1;
+                    try {
+                        await this.sendRepairEntriesWithTransport(target, entries, "simple", {
+                            bypassKnownPeers: bypassKnownPeerHints,
+                            bypassRecentKnownPeers: bypassKnownPeerHints,
+                        });
+                    }
+                    catch (error) {
+                        logger.error(error);
+                    }
+                    finally {
+                        state.lastCompletedAt = Date.now();
+                    }
+                }
+            }
+            finally {
+                state.running = false;
+                if (this._joinWarmupSendStateByTarget.get(target) === state) {
+                    if (state.pending) {
+                        void this.drainJoinWarmupSends(target, state).catch((error) => logger.error(error));
+                    }
+                    else if (!this._joinWarmupGenerationByTarget.has(target)) {
+                        this._joinWarmupSendStateByTarget.delete(target);
+                    }
+                }
+            }
+        }
         async sendMaybeMissingEntriesNow(target, entries, options) {
             if (entries.size === 0) {
                 return;
@@ -5074,25 +5973,41 @@ let SharedLog = (() => {
             const bucket = this._repairMetrics[options.mode];
             bucket.dispatches += 1;
             bucket.entries += filteredEntries.size;
+            const joinWarmupGeneration = options.mode === "join-warmup"
+                ? this.getJoinWarmupGeneration(target)
+                : undefined;
+            const bypassKnownPeerHints = this.shouldBypassKnownPeerHints(options.mode, options.bypassKnownPeerHints);
             const run = (transport) => {
-                if (transport === "simple") {
-                    bucket.simpleFallbackPasses += 1;
+                if (transport === "simple" &&
+                    options.mode === "join-warmup" &&
+                    joinWarmupGeneration) {
+                    this.queueJoinWarmupSend(target, joinWarmupGeneration, filteredEntries, bypassKnownPeerHints);
+                    return;
                 }
-                else {
+                if (transport === "rateless") {
                     bucket.ratelessFirstPasses += 1;
                 }
-                const bypassKnownPeerHints = this.shouldBypassKnownPeerHints(options.mode, options.bypassKnownPeerHints);
+                else {
+                    bucket.simpleFallbackPasses += 1;
+                }
                 return Promise.resolve(this.sendRepairEntriesWithTransport(target, filteredEntries, transport, {
                     bypassKnownPeers: bypassKnownPeerHints,
                     bypassRecentKnownPeers: bypassKnownPeerHints,
                 })).catch((error) => logger.error(error));
             };
+            const delayedJoinWarmupRetries = [];
             retrySchedule.forEach((delayMs, index) => {
                 const transport = getRepairTransportForAttempt(options.mode, index);
                 if (delayMs === 0) {
                     void run(transport);
                     return;
                 }
+                if (options.mode === "join-warmup" &&
+                    joinWarmupGeneration &&
+                    transport === "simple") {
+                    delayedJoinWarmupRetries.push(delayMs);
+                    return;
+                }
                 const timer = setTimeout(() => {
                     this._repairRetryTimers.delete(timer);
                     if (this.closed) {
@@ -5103,15 +6018,29 @@ let SharedLog = (() => {
                 timer.unref?.();
                 this._repairRetryTimers.add(timer);
             });
+            if (joinWarmupGeneration && delayedJoinWarmupRetries.length > 0) {
+                this.scheduleJoinWarmupRetries(target, joinWarmupGeneration, delayedJoinWarmupRetries, filteredEntries, bypassKnownPeerHints);
+            }
         }
         scheduleRepairSweep(options) {
-            this._repairSweepPendingModes.add(options.mode);
             const pendingPeers = this._repairSweepPendingPeersByMode.get(options.mode);
             if (pendingPeers) {
                 for (const peer of options.peers ?? []) {
+                    if (options.mode === "join-warmup") {
+                        const generation = options.joinWarmupGenerations?.get(peer) ??
+                            this.getJoinWarmupGeneration(peer);
+                        if (this._joinWarmupGenerationByTarget.get(peer) !== generation) {
+                            continue;
+                        }
+                        this._repairSweepJoinWarmupGenerationByTarget.set(peer, generation);
+                    }
                     pendingPeers.add(peer);
                 }
             }
+            if (!pendingPeers || pendingPeers.size === 0) {
+                return;
+            }
+            this._repairSweepPendingModes.add(options.mode);
             if (!this._repairSweepRunning && !this.closed) {
                 this._repairSweepRunning = true;
                 void this.runRepairSweep();
@@ -5162,10 +6091,26 @@ let SharedLog = (() => {
                 while (!this.closed) {
                     const pendingModes = new Set(this._repairSweepPendingModes);
                     const pendingPeersByMode = cloneRepairPendingPeersByMode(this._repairSweepPendingPeersByMode);
+                    const pendingJoinWarmupGenerations = new Map(this._repairSweepJoinWarmupGenerationByTarget);
                     this._repairSweepPendingModes.clear();
                     for (const peers of this._repairSweepPendingPeersByMode.values()) {
                         peers.clear();
                     }
+                    this._repairSweepJoinWarmupGenerationByTarget.clear();
+                    const pendingJoinWarmupPeers = pendingPeersByMode.get("join-warmup");
+                    const pruneStaleJoinWarmupPeers = () => {
+                        for (const peer of [...(pendingJoinWarmupPeers ?? [])]) {
+                            if (this._joinWarmupGenerationByTarget.get(peer) !==
+                                pendingJoinWarmupGenerations.get(peer)) {
+                                pendingJoinWarmupPeers?.delete(peer);
+                            }
+                        }
+                        if (pendingJoinWarmupPeers?.size === 0) {
+                            pendingModes.delete("join-warmup");
+                        }
+                        return pendingModes.size > 0;
+                    };
+                    pruneStaleJoinWarmupPeers();
                     if (pendingModes.size === 0) {
                         return;
                     }
@@ -5182,14 +6127,14 @@ let SharedLog = (() => {
                             ._repairSweepOptimisticGidPeersPending) {
                             let matchedPeers;
                             let matchedCounts;
-                            for (const [peer, count] of peerCounts) {
+                            for (const [peer, state] of peerCounts) {
                                 if (!modePeers.has(peer)) {
                                     continue;
                                 }
                                 matchedPeers ||= new Set();
                                 matchedCounts ||= new Map();
                                 matchedPeers.add(peer);
-                                matchedCounts.set(peer, count);
+                                matchedCounts.set(peer, { ...state });
                             }
                             if (matchedPeers && matchedCounts) {
                                 optimisticGidPeers.set(gid, matchedPeers);
@@ -5211,6 +6156,7 @@ let SharedLog = (() => {
                     const fullReplicaRepairCandidates = await this.getFullReplicaRepairCandidates(pendingRepairPeers, {
                         includeSubscribers: false,
                     });
+                    pruneStaleJoinWarmupPeers();
                     const fullReplicaRepairCandidateCount = Math.max(1, fullReplicaRepairCandidates.size);
                     const nextFrontierByMode = new Map([
                         ["join-authoritative", new Map()],
@@ -5222,6 +6168,16 @@ let SharedLog = (() => {
                         if (!entries || entries.size === 0) {
                             return;
                         }
+                        if (mode === "join-warmup" &&
+                            this._joinWarmupGenerationByTarget.get(target) !==
+                                pendingJoinWarmupGenerations.get(target)) {
+                            targets?.delete(target);
+                            pendingJoinWarmupPeers?.delete(target);
+                            if (pendingJoinWarmupPeers?.size === 0) {
+                                pendingModes.delete("join-warmup");
+                            }
+                            return;
+                        }
                         this.dispatchMaybeMissingEntries(target, entries, {
                             bypassRecentDedupe: true,
                             bypassKnownPeerHints: mode === "churn" ||
@@ -5233,6 +6189,15 @@ let SharedLog = (() => {
                         targets?.delete(target);
                     };
                     const queueEntryForTarget = (mode, target, entry) => {
+                        if (mode === "join-warmup" &&
+                            this._joinWarmupGenerationByTarget.get(target) !==
+                                pendingJoinWarmupGenerations.get(target)) {
+                            pendingJoinWarmupPeers?.delete(target);
+                            if (pendingJoinWarmupPeers?.size === 0) {
+                                pendingModes.delete("join-warmup");
+                            }
+                            return;
+                        }
                         const sweepTargets = nextFrontierByMode.get(mode);
                         if (sweepTargets) {
                             let sweepSet = sweepTargets.get(target);
@@ -5260,14 +6225,17 @@ let SharedLog = (() => {
                     if ((this._nativeBackbone ?? this._nativeSharedLogState) &&
                         residentEntriesByHash &&
                         !this.hasCustomFindLeaders()) {
-                        const repairDispatchPlan = await this.planResidentRepairDispatchBatch({
-                            pendingModes,
-                            pendingPeersByMode,
-                            optimisticGidPeersByMode,
-                            fullReplicaRepairCandidates,
-                            fullReplicaRepairCandidateCount,
-                            selfHash: this.node.identity.publicKey.hashcode(),
-                        });
+                        const repairDispatchPlan = pruneStaleJoinWarmupPeers()
+                            ? await this.planResidentRepairDispatchBatch({
+                                pendingModes,
+                                pendingPeersByMode,
+                                optimisticGidPeersByMode,
+                                fullReplicaRepairCandidates,
+                                fullReplicaRepairCandidateCount,
+                                selfHash: this.node.identity.publicKey.hashcode(),
+                            })
+                            : new Map();
+                        pruneStaleJoinWarmupPeers();
                         for (const [mode, targets] of repairDispatchPlan) {
                             for (const [target, hashes] of targets) {
                                 for (const hash of hashes) {
@@ -5279,11 +6247,16 @@ let SharedLog = (() => {
                             }
                         }
                     }
-                    else {
+                    else if (pruneStaleJoinWarmupPeers()) {
                         const iterator = this.entryCoordinatesIndex.iterate({});
                         try {
-                            while (!this.closed && !iterator.done()) {
+                            while (!this.closed &&
+                                !iterator.done() &&
+                                pruneStaleJoinWarmupPeers()) {
                                 const entries = await iterator.next(REPAIR_SWEEP_ENTRY_BATCH_SIZE);
+                                if (!pruneStaleJoinWarmupPeers()) {
+                                    break;
+                                }
                                 const entryReplicatedBatch = entries.map((entry) => entry.value);
                                 const requestedReplicasBatch = entryReplicatedBatch.map((entry) => decodeReplicas(entry).getValue(this));
                                 const repairDispatchPlan = await this.planRepairDispatchBatch({
@@ -5296,6 +6269,9 @@ let SharedLog = (() => {
                                     fullReplicaRepairCandidateCount,
                                     selfHash: this.node.identity.publicKey.hashcode(),
                                 });
+                                if (!pruneStaleJoinWarmupPeers()) {
+                                    break;
+                                }
                                 const entriesByHash = new Map(entryReplicatedBatch.map((entry) => [entry.hash, entry]));
                                 for (const [mode, targets] of repairDispatchPlan) {
                                     for (const [target, hashes] of targets) {
@@ -5319,14 +6295,26 @@ let SharedLog = (() => {
                             if (!pendingPeerCounts) {
                                 continue;
                             }
-                            for (const [peer, count] of peerCounts) {
-                                const current = pendingPeerCounts.get(peer) || 0;
-                                const next = current - count;
+                            for (const [peer, consumed] of peerCounts) {
+                                const current = pendingPeerCounts.get(peer);
+                                if (!current ||
+                                    current.generation !== consumed.generation) {
+                                    continue;
+                                }
+                                const next = current.count - consumed.count;
                                 if (next > 0) {
-                                    pendingPeerCounts.set(peer, next);
+                                    pendingPeerCounts.set(peer, {
+                                        count: next,
+                                        generation: current.generation,
+                                    });
                                 }
                                 else {
                                     pendingPeerCounts.delete(peer);
+                                    const gids = this._repairSweepOptimisticGidsByPeer.get(peer);
+                                    gids?.delete(gid);
+                                    if (gids?.size === 0) {
+                                        this._repairSweepOptimisticGidsByPeer.delete(peer);
+                                    }
                                 }
                             }
                             if (pendingPeerCounts.size === 0) {
@@ -5772,10 +6760,20 @@ let SharedLog = (() => {
             if (toPrune.size === 0) {
                 return;
             }
-            void Promise.allSettled(this.prune(toPrune));
+            const pruneTasks = this.prune(toPrune);
+            const confirmationTasks = [];
             for (const hash of responseStillApplies) {
-                void this._checkedPrune.getPendingDelete(hash)?.resolve(publicKeyHash);
+                const pendingDelete = this._checkedPrune.getPendingDelete(hash);
+                if (pendingDelete) {
+                    confirmationTasks.push(Promise.resolve(pendingDelete.resolve(publicKeyHash)));
+                }
             }
+            // The restarted prune session owns its own bounded timeout and revalidates
+            // before deletion. Only the peer-derived confirmations must remain inside
+            // this receive lease; waiting for the whole prune session could stall close
+            // or disconnect until its background timeout.
+            void Promise.allSettled(pruneTasks);
+            await Promise.allSettled(confirmationTasks);
         }
         async append(data, options) {
             this.throwIfNativeDurableCommitFailed();
@@ -8193,20 +9191,37 @@ let SharedLog = (() => {
             this._respondToIHaveTimeout = options?.respondToIHaveTimeout ?? 2e4;
             this._checkedPrune = new CheckedPruneCoordinator();
             this._pendingIHave = new Map();
+            this._pendingIHaveCallbacks = new Set();
             this.latestReplicationInfoMessage = new Map();
             this._replicationInfoBlockedPeers = new Set();
             this._replicationInfoRequestByPeer = 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();
+            this._replicationInfoReceiveEpochByPeer = new Map();
+            this._subscriptionEpochByPeer = new Map();
+            this._pendingReplicatorLeaveByPeer = new Set();
+            this._activeReceiveHandlersByPeer = new Map();
+            this._receiveHandlerDrainByPeer = new Map();
+            this._receiveCleanupGateByPeer = new Map();
+            this._subscriptionOpeningEpochByPeer = new Map();
+            this._openingSyncCapabilitiesByPeer = new Map();
             this._repairRetryTimers = new Set();
             this._recentRepairDispatch = new Map();
             this._repairSweepRunning = false;
             this._repairSweepPendingModes = new Set();
             this._repairSweepPendingPeersByMode = createRepairPendingPeersByMode();
+            this._repairSweepJoinWarmupGenerationByTarget = new Map();
             this._repairFrontierByMode = createRepairFrontierByMode();
             this._repairFrontierActiveTargetsByMode = createRepairActiveTargetsByMode();
             this._repairFrontierBypassKnownPeersByMode =
                 createRepairFrontierBypassKnownPeersByMode();
+            this._joinWarmupGenerationByTarget = new Map();
+            this._joinWarmupSendStateByTarget ??= new Map();
+            this._joinWarmupRetryTimersByTarget = new Map();
+            this._joinWarmupScheduledRetriesByTarget = new Map();
             this._repairSweepOptimisticGidPeersPending = new Map();
+            this._repairSweepOptimisticGidsByPeer = new Map();
             this._entryKnownPeers = new Map();
             this._entryKnownPeerObservedAt = new Map();
             this._joinAuthoritativeRepairTimersByDelay = new Map();
@@ -8273,6 +9288,7 @@ let SharedLog = (() => {
             }
             this._closeController = new AbortController();
             this.setupReplicationAnnouncementRetryFunction();
+            this.setupReplicationAnnouncementRepairFunction();
             this._closeController.signal.addEventListener("abort", () => {
                 for (const [_peer, state] of this._replicationInfoRequestByPeer) {
                     if (state.timer)
@@ -8353,7 +9369,9 @@ let SharedLog = (() => {
                 publish: (message, options) => this.rpc.send(new BlocksMessage(message), options),
                 waitFor: this.rpc.waitFor.bind(this.rpc),
                 publicKey: this.node.identity.publicKey,
-                eagerBlocks: options?.eagerBlocks ?? true,
+                // Unsolicited block retention is opt-in. Explicit `true` retains the
+                // compatible eager path with bounded validation and storage budgets.
+                eagerBlocks: options?.eagerBlocks ?? false,
                 resolveProviders: async (cid, opts) => {
                     // 1) tracker-backed provider directory (best-effort, bounded)
                     try {
@@ -9096,10 +10114,13 @@ let SharedLog = (() => {
         async afterOpen() {
             await super.afterOpen();
             const existingSubscribersPromise = this._getTopicSubscribers(this.topic);
+            const replicationLifecycleController = this._replicationLifecycleController;
             // We do this here, because these calls requires this.closed == false
             void this.pruneOfflineReplicators()
                 .then(() => {
-                this._replicatorsReconciled = true;
+                if (this.isReplicationLifecycleActive(replicationLifecycleController)) {
+                    this._replicatorsReconciled = true;
+                }
             })
                 .catch((error) => {
                 if (isNotStartedError(error)) {
@@ -9126,46 +10147,81 @@ let SharedLog = (() => {
         async pruneOfflineReplicators() {
             // Go through all segments and wait for replicators to become reachable;
             // otherwise prune them away from the local membership view.
+            const replicationLifecycleController = this._replicationLifecycleController;
             try {
+                if (!replicationLifecycleController ||
+                    !this.isReplicationLifecycleActive(replicationLifecycleController)) {
+                    return;
+                }
                 const promises = [];
                 const iterator = this.replicationIndex.iterate();
                 const checkedIsAlive = new Set();
                 while (!iterator.done()) {
-                    for (const segment of await iterator.next(1000)) {
+                    const segments = await iterator.next(1000);
+                    if (!this.isReplicationLifecycleActive(replicationLifecycleController)) {
+                        return;
+                    }
+                    for (const segment of segments) {
                         if (checkedIsAlive.has(segment.value.hash) ||
                             this.node.identity.publicKey.hashcode() === segment.value.hash) {
                             this.uniqueReplicators.add(this.node.identity.publicKey.hashcode());
                             continue;
                         }
                         checkedIsAlive.add(segment.value.hash);
-                        promises.push(waitForSubscribers(this.node, segment.value.hash, this.rpc.topic, {
+                        const peerHash = segment.value.hash;
+                        const subscriptionEpoch = this.getSubscriptionEpoch(peerHash);
+                        promises.push(waitForSubscribers(this.node, peerHash, this.rpc.topic, {
                             timeout: this.waitForReplicatorTimeout,
                             signal: this._closeController.signal,
                         })
                             .then(async () => {
-                            const key = await this._resolvePublicKeyFromHash(segment.value.hash);
+                            if (!this.isReplicationLifecycleActive(replicationLifecycleController)) {
+                                return;
+                            }
+                            const key = await this._resolvePublicKeyFromHash(peerHash);
                             if (!key) {
                                 throw new Error("Failed to resolve public key from hash: " +
-                                    segment.value.hash);
+                                    peerHash);
                             }
                             const keyHash = key.hashcode();
-                            this.uniqueReplicators.add(keyHash);
-                            if (!this._replicatorJoinEmitted.has(keyHash)) {
-                                this._replicatorJoinEmitted.add(keyHash);
-                                this.events.dispatchEvent(new CustomEvent("replicator:join", {
-                                    detail: { publicKey: key },
-                                }));
-                                this.events.dispatchEvent(new CustomEvent("replication:change", {
-                                    detail: { publicKey: key },
-                                }));
+                            if (keyHash !== peerHash) {
+                                return;
                             }
+                            return this.withReplicationInfoApplyQueue(keyHash, async () => {
+                                // A successful reachability check may legitimately span a
+                                // subscribe event during startup. The current lane's blocked
+                                // state plus an extant index row are the authoritative guard;
+                                // only the destructive catch path remains tied to the old token.
+                                if (!this.isReplicationLifecycleActive(replicationLifecycleController) ||
+                                    this.closed ||
+                                    this._replicationInfoBlockedPeers.has(keyHash)) {
+                                    return;
+                                }
+                                const hasReplicationRange = (await this.replicationIndex.count({
+                                    query: { hash: keyHash },
+                                })) > 0;
+                                if (!hasReplicationRange ||
+                                    !this.isReplicationLifecycleActive(replicationLifecycleController) ||
+                                    this._replicationInfoBlockedPeers.has(keyHash)) {
+                                    return;
+                                }
+                                this.uniqueReplicators.add(keyHash);
+                                if (!this._replicatorJoinEmitted.has(keyHash)) {
+                                    this._replicatorJoinEmitted.add(keyHash);
+                                    this.events.dispatchEvent(new CustomEvent("replicator:join", { detail: { publicKey: key } }));
+                                    this.events.dispatchEvent(new CustomEvent("replication:change", { detail: { publicKey: key } }));
+                                }
+                            });
                         })
                             .catch(async (error) => {
-                            if (isNotStartedError(error)) {
+                            if (isNotStartedError(error) ||
+                                !this.isReplicationLifecycleActive(replicationLifecycleController)) {
                                 return;
                             }
-                            return this.removeReplicator(segment.value.hash, {
+                            return this.removeReplicator(peerHash, {
                                 noEvent: true,
+                                replicationLifecycleController,
+                                subscriptionEpoch,
                             });
                         }));
                     }
@@ -9173,7 +10229,8 @@ let SharedLog = (() => {
                 return Promise.all(promises);
             }
             catch (error) {
-                if (isNotStartedError(error)) {
+                if (isNotStartedError(error) ||
+                    !this.isReplicationLifecycleActive(replicationLifecycleController)) {
                     return;
                 }
                 throw error;
@@ -9228,10 +10285,26 @@ let SharedLog = (() => {
             this._replicatorLivenessFailures.delete(peerHash);
             this._replicatorLastActivityAt.delete(peerHash);
             this._peerSyncCapabilities.delete(peerHash);
+            this.cleanupPendingIHavePeer(peerHash);
             this._checkedPrune.cleanupPeer(peerHash);
         }
+        cleanupPendingIHavePeer(peerHash) {
+            for (const [hash, pending] of this._pendingIHave) {
+                pending.requesting.delete(peerHash);
+                if (pending.requesting.size === 0) {
+                    pending.clear();
+                    this._pendingIHave.delete(hash);
+                }
+            }
+        }
         markReplicatorActivity(peerHash, now = Date.now()) {
             this._replicatorLastActivityAt.set(peerHash, now);
+            // Any recent authenticated activity is positive liveness evidence. Reset the
+            // consecutive miss streak immediately, including while an eviction is
+            // waiting in the per-peer mutation lane.
+            if (Date.now() - now < REPLICATOR_LIVENESS_IDLE_THRESHOLD_MS) {
+                this._replicatorLivenessFailures.delete(peerHash);
+            }
         }
         hasRecentReplicatorActivity(peerHash, now = Date.now()) {
             const lastActivityAt = this._replicatorLastActivityAt.get(peerHash);
@@ -9242,31 +10315,48 @@ let SharedLog = (() => {
             }
             return false;
         }
-        async evictReplicatorFromLiveness(peerHash, publicKey) {
-            const wasReplicator = this.uniqueReplicators.has(peerHash);
-            const watermark = BigInt(+new Date());
-            const previousWatermark = this.latestReplicationInfoMessage.get(peerHash);
-            if (!previousWatermark || previousWatermark < watermark) {
-                this.latestReplicationInfoMessage.set(peerHash, watermark);
-            }
+        advanceReplicationInfoRecoveryEpoch(peerHash) {
+            // Handlers admitted before a successful peer removal must not restore state
+            // when they eventually reach the apply lane. Reset the sender's
+            // ordering watermark with the local epoch so a later arrival can be
+            // accepted without comparing its clock to this receiver's clock.
+            this.advanceReplicationInfoReceiveEpoch(peerHash);
+            this.latestReplicationInfoMessage.delete(peerHash);
+        }
+        async evictReplicatorFromLiveness(peerHash, publicKey, replicationLifecycleController, subscriptionEpoch, observedActivityAt) {
             try {
-                await this.removeReplicator(publicKey, { noEvent: true });
+                await this.removeReplicator(publicKey, {
+                    noEvent: true,
+                    replicationLifecycleController,
+                    shouldRemove: () => this._replicatorLastActivityAt.get(peerHash) === observedActivityAt,
+                    subscriptionEpoch,
+                    onRemoved: ({ wasReplicator }) => {
+                        if (wasReplicator) {
+                            this._pendingReplicatorLeaveByPeer.add(peerHash);
+                        }
+                        // A newer subscription/lifecycle may have started while the admitted
+                        // removal was completing. Its reconnect barrier owns all later effects.
+                        if (!this.isReplicationLifecycleActive(replicationLifecycleController) ||
+                            !this.isCurrentSubscriptionEpoch(peerHash, subscriptionEpoch)) {
+                            return;
+                        }
+                        if (this._pendingReplicatorLeaveByPeer.delete(peerHash)) {
+                            this.events.dispatchEvent(new CustomEvent("replicator:leave", {
+                                detail: { publicKey },
+                            }));
+                        }
+                        if (!this._replicationInfoBlockedPeers.has(peerHash)) {
+                            this.scheduleReplicationInfoRequests(publicKey, replicationLifecycleController);
+                        }
+                        this._replicatorLivenessTargetsSize = -1;
+                    },
+                });
             }
             catch (error) {
                 if (!isNotStartedError(error)) {
                     throw error;
                 }
             }
-            this.cleanupPeerDisconnectTracking(peerHash);
-            if (wasReplicator) {
-                this.events.dispatchEvent(new CustomEvent("replicator:leave", {
-                    detail: { publicKey },
-                }));
-            }
-            if (!this._replicationInfoBlockedPeers.has(peerHash)) {
-                this.scheduleReplicationInfoRequests(publicKey);
-            }
-            this._replicatorLivenessTargetsSize = -1;
         }
         async resolveCandidatePeersForHash(hash, options) {
             if (options?.signal?.aborted)
@@ -9338,7 +10428,10 @@ let SharedLog = (() => {
             return pickDeterministicSubset(peers, seed, maxPeers);
         }
         async runReplicatorLivenessSweep() {
-            if (this.closed || this._closeController.signal.aborted) {
+            const replicationLifecycleController = this._replicationLifecycleController;
+            if (this.closed ||
+                this._closeController.signal.aborted ||
+                !this.isReplicationLifecycleActive(replicationLifecycleController)) {
                 return;
             }
             if (this._replicatorLivenessSweepRunning) {
@@ -9364,13 +10457,23 @@ let SharedLog = (() => {
                 }
             }
             finally {
-                this._replicatorLivenessSweepRunning = false;
+                if (this._replicationLifecycleController ===
+                    replicationLifecycleController) {
+                    this._replicatorLivenessSweepRunning = false;
+                }
             }
         }
         async probeReplicatorLiveness(peerHash) {
-            if (this.closed || this._closeController.signal.aborted) {
+            const replicationLifecycleController = this._replicationLifecycleController;
+            if (this.closed ||
+                this._closeController.signal.aborted ||
+                !replicationLifecycleController ||
+                !this.isReplicationLifecycleActive(replicationLifecycleController)) {
                 return;
             }
+            const subscriptionEpoch = this.getSubscriptionEpoch(peerHash);
+            const ownsProbe = () => this.isReplicationLifecycleActive(replicationLifecycleController) &&
+                this.isCurrentSubscriptionEpoch(peerHash, subscriptionEpoch);
             if (!this.uniqueReplicators.has(peerHash)) {
                 this._replicatorLivenessFailures.delete(peerHash);
                 return;
@@ -9378,18 +10481,35 @@ let SharedLog = (() => {
             if (this.hasRecentReplicatorActivity(peerHash)) {
                 return;
             }
+            const observedActivityAt = this._replicatorLastActivityAt.get(peerHash);
             const publicKey = await this._resolvePublicKeyFromHash(peerHash);
+            if (!ownsProbe()) {
+                return;
+            }
+            if (this.hasRecentReplicatorActivity(peerHash)) {
+                return;
+            }
             if (!publicKey) {
                 try {
-                    await this.removeReplicator(peerHash, { noEvent: true });
+                    await this.removeReplicator(peerHash, {
+                        noEvent: true,
+                        replicationLifecycleController,
+                        shouldRemove: () => this._replicatorLastActivityAt.get(peerHash) ===
+                            observedActivityAt,
+                        subscriptionEpoch,
+                        onRemoved: () => {
+                            if (!ownsProbe()) {
+                                return;
+                            }
+                            this._replicatorLivenessTargetsSize = -1;
+                        },
+                    });
                 }
                 catch (error) {
                     if (!isNotStartedError(error)) {
                         throw error;
                     }
                 }
-                this.cleanupPeerDisconnectTracking(peerHash);
-                this._replicatorLivenessTargetsSize = -1;
                 return;
             }
             try {
@@ -9400,6 +10520,9 @@ let SharedLog = (() => {
                     priority: ACK_CONTROL_PRIORITY,
                     responsePriority: ACK_CONTROL_PRIORITY,
                 });
+                if (!ownsProbe()) {
+                    return;
+                }
                 this.markReplicatorActivity(peerHash);
                 this._replicatorLivenessFailures.delete(peerHash);
                 return;
@@ -9409,25 +10532,40 @@ let SharedLog = (() => {
                     return;
                 }
             }
+            if (!ownsProbe()) {
+                return;
+            }
+            if (this.hasRecentReplicatorActivity(peerHash)) {
+                return;
+            }
             // Relay-backed prod paths can keep a peer subscribed/reachable even if an
             // ACKed liveness ping gets delayed or dropped under load. Treat observed
             // topic presence as a positive liveness signal before evicting the peer.
             if (await this.confirmReplicatorSubscriberPresence(peerHash)) {
+                if (!ownsProbe()) {
+                    return;
+                }
                 this.markReplicatorActivity(peerHash);
                 this._replicatorLivenessFailures.delete(peerHash);
                 return;
             }
+            if (!ownsProbe()) {
+                return;
+            }
+            if (this.hasRecentReplicatorActivity(peerHash)) {
+                return;
+            }
             const failures = (this._replicatorLivenessFailures.get(peerHash) ?? 0) + 1;
             this._replicatorLivenessFailures.set(peerHash, failures);
-            this.scheduleReplicationInfoRequests(publicKey);
+            this.scheduleReplicationInfoRequests(publicKey, replicationLifecycleController);
             if (failures < REPLICATOR_LIVENESS_PROBE_FAILURES_TO_EVICT) {
                 return;
             }
-            if (!this.uniqueReplicators.has(peerHash)) {
+            if (!ownsProbe() || !this.uniqueReplicators.has(peerHash)) {
                 this._replicatorLivenessFailures.delete(peerHash);
                 return;
             }
-            await this.evictReplicatorFromLiveness(peerHash, publicKey);
+            await this.evictReplicatorFromLiveness(peerHash, publicKey, replicationLifecycleController, subscriptionEpoch, observedActivityAt);
         }
         async confirmReplicatorSubscriberPresence(peerHash) {
             try {
@@ -9459,6 +10597,24 @@ let SharedLog = (() => {
             return this.log.blocks.size();
             /* ((await this.log.entryIndex?.getMemoryUsage()) || 0) */ // + (await this.log.blocks.size())
         }
+        /** Return a detached snapshot of effective shared-log runtime settings. */
+        getRuntimeSnapshot() {
+            const nativeGraph = this.log.entryIndex.properties.nativeGraph;
+            const active = nativeGraph?.graph != null;
+            return Object.freeze({
+                nativeGraph: Object.freeze({
+                    active,
+                    useHeads: active && nativeGraph?.useHeads === true,
+                }),
+            });
+        }
+        /**
+         * Return a detached snapshot of the optional eager-response cache.
+         * Undefined means eager response retention is disabled for this log.
+         */
+        getEagerBlockCacheTelemetry() {
+            return this.remoteBlocks?.getEagerBlockCacheTelemetry();
+        }
         clampReplicas(value) {
             const lower = this.replicas.min?.getValue(this) || 1;
             const higher = this.replicas.max?.getValue(this) ?? Number.MAX_SAFE_INTEGER;
@@ -10073,6 +11229,7 @@ let SharedLog = (() => {
             captureSync(() => this.node.services.pubsub.removeEventListener("subscribe", this._onSubscriptionFn));
             captureSync(() => this.node.services.pubsub.removeEventListener("unsubscribe", this._onUnsubscriptionFn));
             captureSync(() => {
+                this.cancelAllJoinWarmupTargets();
                 for (const timer of this._repairRetryTimers ?? [])
                     clearTimeout(timer);
                 this._repairRetryTimers?.clear();
@@ -10081,7 +11238,9 @@ let SharedLog = (() => {
                 this._repairSweepPendingModes?.clear();
                 for (const peers of this._repairSweepPendingPeersByMode?.values() ?? [])
                     peers.clear();
+                this._repairSweepJoinWarmupGenerationByTarget?.clear();
                 this._repairSweepOptimisticGidPeersPending?.clear();
+                this._repairSweepOptimisticGidsByPeer?.clear();
                 this._entryKnownPeers?.clear();
                 this._entryKnownPeerObservedAt?.clear();
                 this._nativeSharedLogState?.clearEntryKnownPeers();
@@ -10118,7 +11277,14 @@ let SharedLog = (() => {
             }
             captureSync(() => {
                 this._pendingIHave?.clear();
+                this._pendingIHaveCallbacks?.clear();
                 this.latestReplicationInfoMessage?.clear();
+                this._replicationInfoReceiveEpochByPeer?.clear();
+                this._activeReceiveHandlersByPeer?.clear();
+                this._receiveHandlerDrainByPeer?.clear();
+                this._receiveCleanupGateByPeer?.clear();
+                this._subscriptionOpeningEpochByPeer?.clear();
+                this._openingSyncCapabilitiesByPeer?.clear();
                 this._gidPeersHistory?.clear();
                 this._peerSyncCapabilities?.clear();
                 this._liveRawGossipBatches?.clear();
@@ -10181,7 +11347,14 @@ let SharedLog = (() => {
             // SharedLog-specific await or observable teardown can admit a new owner.
             this.preventParentAttachments();
             this.stopSubscriptionChangeCallbackAdmission();
+            this.cancelAllJoinWarmupTargets();
             await this.drainSubscriptionChangeCallbacks();
+            // An already-admitted subscription callback can create a fresh warmup
+            // generation while the first cancellation is draining.
+            this.cancelAllJoinWarmupTargets();
+            await this.drainReceiveHandlers();
+            await this.drainReplicationInfoApplyQueues();
+            await this.drainPendingIHaveCallbacks();
             this.ensureNativeDurabilityRuntimeState();
             this.cancelCurrentReplicationStateAnnouncementRetry();
             // Best-effort: announce that we are going offline before tearing down
@@ -10301,7 +11474,14 @@ let SharedLog = (() => {
             // the terminal fence only after that precondition succeeds.
             this.preventParentAttachments();
             this.stopSubscriptionChangeCallbackAdmission();
+            this.cancelAllJoinWarmupTargets();
             await this.drainSubscriptionChangeCallbacks();
+            // An already-admitted subscription callback can create a fresh warmup
+            // generation while the first cancellation is draining.
+            this.cancelAllJoinWarmupTargets();
+            await this.drainReceiveHandlers();
+            await this.drainReplicationInfoApplyQueues();
+            await this.drainPendingIHaveCallbacks();
             this.cancelCurrentReplicationStateAnnouncementRetry();
             // Best-effort: announce that we are going offline before tearing down
             // RPC/subscription state (same reasoning as in `close()`).
@@ -10512,13 +11692,35 @@ let SharedLog = (() => {
             const stashBackedRawMessage = isStashBackedRawExchangeHeadsMessage(msg)
                 ? msg
                 : undefined;
+            let releasePeerReceiveLease;
             try {
                 this.throwIfNativeDurableCommitFailed();
                 if (!context.from) {
                     throw new Error("Missing from in update role message");
                 }
+                // 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.
+                const receiveFromHash = context.from.hashcode();
+                const receiveReplicationLifecycleController = this._replicationLifecycleController;
+                const receiveSubscriptionEpoch = this.getSubscriptionEpoch(receiveFromHash);
+                const isOpeningSubscriptionReceive = this._subscriptionOpeningEpochByPeer.get(receiveFromHash) ===
+                    receiveSubscriptionEpoch;
+                const isOpeningCapabilityAdvertisement = msg instanceof SyncCapabilitiesMessage && isOpeningSubscriptionReceive;
+                releasePeerReceiveLease = this.acquirePeerReceiveLease(receiveFromHash, receiveReplicationLifecycleController, receiveSubscriptionEpoch, {
+                    // The replication-info fence existed before receive leases and is
+                    // intentionally narrower than the subscription itself. Keep admitting
+                    // sync negotiation/data while the new subscription drains the previous
+                    // apply generation; replication-info branches recheck the fence below.
+                    allowReplicationInfoBlocked: isOpeningSubscriptionReceive,
+                    allowCleanupGate: isOpeningCapabilityAdvertisement,
+                });
+                if (!releasePeerReceiveLease) {
+                    return;
+                }
+                const receiveReplicationInfoReceiveEpoch = this.getReplicationInfoReceiveEpoch(receiveFromHash);
                 if (!context.from.equals(this.node.identity.publicKey)) {
-                    this.markReplicatorActivity(context.from.hashcode());
+                    this.markReplicatorActivity(receiveFromHash);
                 }
                 if (msg instanceof ResponseRoleMessage) {
                     msg = msg.toReplicationInfoMessage(); // migration
@@ -11601,6 +12803,7 @@ let SharedLog = (() => {
                             allToMergeMaterializedEntries ??= allToMerge.map((entry) => entry.entry);
                             return allToMergeMaterializedEntries;
                         };
+                        let admittedMergeHashes = new Set();
                         let nativePreparedCommittedHashes;
                         if (allToMerge.length > 0) {
                             const validateStartedAt = syncProfileStart(syncProfile);
@@ -11696,8 +12899,8 @@ let SharedLog = (() => {
                             const entriesToPersist = usedNativeAllKeptJoinPlan
                                 ? allToMergeShallowEntries
                                 : joinPlans.flatMap((plan) => plan.toPersist);
-                            const coordinatePersistFallbackEntries = [];
-                            const reusableCoordinatePersistItems = [];
+                            let coordinatePersistFallbackEntries = [];
+                            let reusableCoordinatePersistItems = [];
                             for (const entry of entriesToPersist) {
                                 const reusablePlan = reusableCoordinatePlans.get(entry.hash);
                                 if (!reusablePlan) {
@@ -11713,7 +12916,6 @@ let SharedLog = (() => {
                                     prepared: reusablePlan.prepared,
                                 });
                             }
-                            const reusableCoordinatePersistItemCount = reusableCoordinatePersistItems.length;
                             let nativePreparedCoordinateBatch;
                             let nativePreparedCoordinatesFinished = false;
                             let nativeBackboneOnlyPersistedHashes;
@@ -11789,6 +12991,26 @@ let SharedLog = (() => {
                                     __peerbitProfile: syncProfile,
                                 });
                             }
+                            // A recursive lower-log join can resolve successfully while declining
+                            // an individual top-level entry (for example, when one of its parents
+                            // is temporarily unavailable). The public Log.join() API intentionally
+                            // does not expose that per-entry result, so make local index presence the
+                            // authority before publishing any SharedLog-side effects. A successful
+                            // prepared-facts batch is atomic and already proves every input hash.
+                            const admittedHashes = joinedPreparedFacts
+                                ? new Set(allToMergeHashes)
+                                : await this.log.hasMany(allToMergeHashes);
+                            admittedMergeHashes = admittedHashes;
+                            const admittedShallowEntries = admittedHashes.size === allToMergeShallowEntries.length
+                                ? allToMergeShallowEntries
+                                : allToMergeShallowEntries.filter((entry) => admittedHashes.has(entry.hash));
+                            if (!joinedPreparedFacts) {
+                                reusableCoordinatePersistItems =
+                                    reusableCoordinatePersistItems.filter((item) => admittedHashes.has(item.entry.hash));
+                                coordinatePersistFallbackEntries =
+                                    coordinatePersistFallbackEntries.filter((entry) => admittedHashes.has(entry.hash));
+                            }
+                            const reusableCoordinatePersistItemCount = reusableCoordinatePersistItems.length;
                             if (syncProfile) {
                                 emitSyncProfileDuration(syncProfile, lowerLogJoinStartedAt, {
                                     name: "sharedLog.receive.lowerLogJoin",
@@ -11800,6 +13022,7 @@ let SharedLog = (() => {
                                         batchHashOnlyEntryAdded,
                                         programOnChange,
                                         joinedPreparedFacts,
+                                        admittedEntries: admittedHashes.size,
                                         nativePreparedCoordinatesFinished,
                                     },
                                 });
@@ -11854,11 +13077,11 @@ let SharedLog = (() => {
                                     },
                                 });
                             }
-                            for (const hash of allToMergeHashes) {
+                            for (const hash of admittedHashes) {
                                 confirmedHashes.add(hash);
                             }
                             const checkedPruneStartedAt = syncProfileStart(syncProfile);
-                            await this.pruneJoinedEntriesNoLongerLed(allToMergeShallowEntries, {
+                            await this.pruneJoinedEntriesNoLongerLed(admittedShallowEntries, {
                                 decodedReplicaCounts: receiveReplicaCounts,
                                 reusableLeaderPlans: reusableCoordinatePlans,
                                 profile: syncProfile,
@@ -11872,10 +13095,12 @@ let SharedLog = (() => {
                                 });
                             }
                             for (const plan of joinPlans) {
-                                plan.toDelete?.map((x) => this.pruneDebouncedFnAddIfNotKeeping({
-                                    key: x.hash,
+                                plan.toDelete
+                                    ?.filter((entry) => admittedMergeHashes.has(entry.hash))
+                                    .map((entry) => this.pruneDebouncedFnAddIfNotKeeping({
+                                    key: entry.hash,
                                     value: {
-                                        entry: x,
+                                        entry,
                                         leaders: plan.leaders,
                                     },
                                 }));
@@ -11887,14 +13112,18 @@ let SharedLog = (() => {
                                 continue;
                             }
                             for (const entries of plan.maybeDelete) {
-                                const minReplicas = await this.getMaxReplicasFromHeads(this.getEntryGid(entries[0].entry));
+                                const admittedEntries = entries.filter((entry) => admittedMergeHashes.has(getExchangeHeadHash(entry)));
+                                if (admittedEntries.length === 0) {
+                                    continue;
+                                }
+                                const minReplicas = await this.getMaxReplicasFromHeads(this.getEntryGid(admittedEntries[0].entry));
                                 if (minReplicas != null) {
                                     const isLeader = await this.isLeader({
-                                        entry: entries[0].entry,
+                                        entry: admittedEntries[0].entry,
                                         replicas: minReplicas,
                                     });
                                     if (!isLeader) {
-                                        for (const x of entries) {
+                                        for (const x of admittedEntries) {
                                             this.pruneDebouncedFnAddIfNotKeeping({
                                                 key: x.entry.hash,
                                                 value: {
@@ -12101,6 +13330,9 @@ let SharedLog = (() => {
                     let pendingIHaveExtended = 0;
                     const leaderResponseHashes = [];
                     for (let i = 0; i < msg.hashes.length; i++) {
+                        if (!this.isReplicationLifecycleActive(receiveReplicationLifecycleController)) {
+                            return;
+                        }
                         const hash = msg.hashes[i];
                         const nativeEntryGid = nativeLeaderHints.nativeEntryGids?.[i];
                         const nativeEntryData = nativeLeaderHints.nativeEntryDataByIndex?.[i];
@@ -12213,8 +13445,14 @@ let SharedLog = (() => {
                                     resetTimeout: () => this.resetPendingIHaveTimeout(pendingIHave),
                                     clear: () => this.clearPendingIHaveTimeout(pendingIHave),
                                     callback: async (entry) => {
-                                        this.removePeerFromGidPeerHistory(from, entry.meta.gid);
-                                        this.removePruneRequestSent(entry.hash, from);
+                                        if (!this.isReplicationLifecycleActive(receiveReplicationLifecycleController) ||
+                                            requesting.size === 0) {
+                                            return;
+                                        }
+                                        for (const requester of requesting) {
+                                            this.removePeerFromGidPeerHistory(requester, entry.meta.gid);
+                                            this.removePruneRequestSent(entry.hash, requester);
+                                        }
                                         let isLeader = false;
                                         await this._waitForEntryReplicators(entry, decodeReplicas(entry).getValue(this), [
                                             {
@@ -12228,12 +13466,15 @@ let SharedLog = (() => {
                                                         key === this.node.identity.publicKey.hashcode();
                                             },
                                         });
+                                        if (!this.isReplicationLifecycleActive(receiveReplicationLifecycleController) ||
+                                            requesting.size === 0) {
+                                            return;
+                                        }
                                         if (isLeader) {
                                             this.responseToPruneDebouncedFn.add({
                                                 hashes: [entry.hash],
-                                                peers: requesting,
+                                                peers: new Set(requesting),
                                             });
-                                            this._pendingIHave.delete(hash);
                                         }
                                     },
                                 };
@@ -12276,17 +13517,24 @@ let SharedLog = (() => {
                 }
                 else if (msg instanceof ResponseIPrune) {
                     const lateResponses = [];
+                    const responseTasks = [];
                     for (const hash of msg.hashes) {
                         const pendingDelete = this._checkedPrune.getPendingDelete(hash);
                         if (pendingDelete) {
-                            void pendingDelete.resolve(context.from.hashcode());
+                            responseTasks.push(Promise.resolve(pendingDelete.resolve(context.from.hashcode())));
                         }
                         else {
                             lateResponses.push(hash);
                         }
                     }
                     if (lateResponses.length > 0) {
-                        void this.recoverCheckedPruneFromLateResponses(lateResponses, context.from.hashcode()).catch((error) => logger.error(error.toString()));
+                        responseTasks.push(this.recoverCheckedPruneFromLateResponses(lateResponses, context.from.hashcode()));
+                    }
+                    const results = await Promise.allSettled(responseTasks);
+                    for (const result of results) {
+                        if (result.status === "rejected") {
+                            logger.error(result.reason?.toString?.() ?? String(result.reason));
+                        }
                     }
                 }
                 else if (msg instanceof ConfirmEntriesMessage) {
@@ -12296,7 +13544,20 @@ let SharedLog = (() => {
                 }
                 else if (msg instanceof SyncCapabilitiesMessage) {
                     if (!context.from.equals(this.node.identity.publicKey)) {
-                        this._peerSyncCapabilities.set(context.from.hashcode(), msg.capabilities);
+                        const openingEpoch = this._subscriptionOpeningEpochByPeer.get(receiveFromHash);
+                        if (this._replicationInfoBlockedPeers.has(receiveFromHash) &&
+                            openingEpoch === receiveSubscriptionEpoch) {
+                            // A prior unsubscribe cleanup may still be ahead of this reconnect
+                            // barrier. Stage the new generation's one-shot advertisement so that
+                            // cleanup cannot erase it before the opening transition commits.
+                            this._openingSyncCapabilitiesByPeer.set(receiveFromHash, {
+                                epoch: openingEpoch,
+                                capabilities: msg.capabilities,
+                            });
+                        }
+                        else {
+                            this._peerSyncCapabilities.set(receiveFromHash, msg.capabilities);
+                        }
                     }
                     return;
                 }
@@ -12316,9 +13577,9 @@ let SharedLog = (() => {
                     if (context.from.equals(this.node.identity.publicKey)) {
                         return;
                     }
-                    const replicationLifecycleController = this._replicationLifecycleController;
+                    const replicationLifecycleController = receiveReplicationLifecycleController;
                     if (!replicationLifecycleController ||
-                        !this.isReplicationLifecycleActive(replicationLifecycleController)) {
+                        !this.isPeerReceiveAdmissionOpen(receiveFromHash, replicationLifecycleController, receiveSubscriptionEpoch)) {
                         return;
                     }
                     let replicationSegments;
@@ -12326,13 +13587,13 @@ let SharedLog = (() => {
                         replicationSegments = await this.getMyReplicationSegments();
                     }
                     catch (error) {
-                        if (!this.isReplicationLifecycleActive(replicationLifecycleController) &&
+                        if (!this.isPeerReceiveAdmissionOpen(receiveFromHash, replicationLifecycleController, receiveSubscriptionEpoch) &&
                             isNotStartedError(error)) {
                             return;
                         }
                         throw error;
                     }
-                    if (!this.isReplicationLifecycleActive(replicationLifecycleController)) {
+                    if (!this.isPeerReceiveAdmissionOpen(receiveFromHash, replicationLifecycleController, receiveSubscriptionEpoch)) {
                         return;
                     }
                     const segments = replicationSegments.map((x) => x.toReplicationRange());
@@ -12345,7 +13606,7 @@ let SharedLog = (() => {
                         signal: replicationLifecycleController.signal,
                     })
                         .catch((error) => this.handleReplicationLifecycleSendError(error, replicationLifecycleController));
-                    if (!this.isReplicationLifecycleActive(replicationLifecycleController)) {
+                    if (!this.isPeerReceiveAdmissionOpen(receiveFromHash, replicationLifecycleController, receiveSubscriptionEpoch)) {
                         return;
                     }
                     // for backwards compatibility (v8) remove this when we are sure that all nodes are v9+
@@ -12380,14 +13641,21 @@ let SharedLog = (() => {
                     // (and downstream `waitForReplicator()` timeouts) under timing-sensitive joins.
                     const from = context.from;
                     const fromHash = from.hashcode();
-                    if (this._replicationInfoBlockedPeers.has(fromHash)) {
+                    if (!this.isReplicationLifecycleActive(receiveReplicationLifecycleController) ||
+                        !this.isCurrentReplicationInfoReceiveEpoch(receiveFromHash, receiveReplicationInfoReceiveEpoch) ||
+                        this._replicationInfoBlockedPeers.has(fromHash)) {
                         return;
                     }
                     const messageTimestamp = context.message.header.timestamp;
+                    releasePeerReceiveLease?.();
+                    releasePeerReceiveLease = undefined;
                     await this.withReplicationInfoApplyQueue(fromHash, async () => {
                         try {
                             // The peer may have unsubscribed after this message was queued.
-                            if (this._replicationInfoBlockedPeers.has(fromHash)) {
+                            if (!this.isReplicationLifecycleActive(receiveReplicationLifecycleController) ||
+                                !this.isCurrentSubscriptionEpoch(fromHash, receiveSubscriptionEpoch) ||
+                                !this.isCurrentReplicationInfoReceiveEpoch(fromHash, receiveReplicationInfoReceiveEpoch) ||
+                                this._replicationInfoBlockedPeers.has(fromHash)) {
                                 return;
                             }
                             // Process in-order to avoid races where repeated reset messages arrive
@@ -12422,24 +13690,47 @@ let SharedLog = (() => {
                     });
                 }
                 else if (msg instanceof StoppedReplicating) {
-                    if (context.from.equals(this.node.identity.publicKey)) {
+                    const from = context.from;
+                    const segmentIds = msg.segmentIds;
+                    if (from.equals(this.node.identity.publicKey)) {
                         return;
                     }
-                    const fromHash = context.from.hashcode();
-                    if (this._replicationInfoBlockedPeers.has(fromHash)) {
+                    const fromHash = from.hashcode();
+                    if (!this.isReplicationLifecycleActive(receiveReplicationLifecycleController) ||
+                        !this.isCurrentReplicationInfoReceiveEpoch(receiveFromHash, receiveReplicationInfoReceiveEpoch) ||
+                        this._replicationInfoBlockedPeers.has(fromHash)) {
                         return;
                     }
-                    this._replicatorLivenessFailures.delete(fromHash);
-                    const rangesToRemove = await this.resolveReplicationRangesFromIdsAndKey(msg.segmentIds, context.from);
-                    await this.removeReplicationRanges(rangesToRemove, context.from);
-                    const timestamp = BigInt(+new Date());
-                    for (const range of rangesToRemove) {
-                        this.replicationChangeDebounceFn.add({
-                            range,
-                            type: "removed",
-                            timestamp,
-                        });
-                    }
+                    const messageTimestamp = context.message.header.timestamp;
+                    releasePeerReceiveLease?.();
+                    releasePeerReceiveLease = undefined;
+                    await this.withReplicationInfoApplyQueue(fromHash, async () => {
+                        if (!this.isReplicationLifecycleActive(receiveReplicationLifecycleController) ||
+                            !this.isCurrentSubscriptionEpoch(fromHash, receiveSubscriptionEpoch) ||
+                            !this.isCurrentReplicationInfoReceiveEpoch(fromHash, receiveReplicationInfoReceiveEpoch) ||
+                            this._replicationInfoBlockedPeers.has(fromHash)) {
+                            return;
+                        }
+                        const previousTimestamp = this.latestReplicationInfoMessage.get(fromHash);
+                        if (previousTimestamp && previousTimestamp > messageTimestamp) {
+                            return;
+                        }
+                        this.latestReplicationInfoMessage.set(fromHash, messageTimestamp);
+                        this._replicatorLivenessFailures.delete(fromHash);
+                        if (this.closed) {
+                            return;
+                        }
+                        const rangesToRemove = await this.resolveReplicationRangesFromIdsAndKey(segmentIds, from);
+                        await this.removeReplicationRanges(rangesToRemove, from);
+                        const timestamp = BigInt(+new Date());
+                        for (const range of rangesToRemove) {
+                            this.replicationChangeDebounceFn.add({
+                                range,
+                                type: "removed",
+                                timestamp,
+                            });
+                        }
+                    });
                 }
                 else {
                     throw new Error("Unexpected message");
@@ -12485,6 +13776,8 @@ let SharedLog = (() => {
                     // Every return and every locally swallowed receive error passes this
                     // boundary. Release a native wire stash exactly once first, then surface
                     // any durable mutation poison that arose while handling the message.
+                    releasePeerReceiveLease?.();
+                    releasePeerReceiveLease = undefined;
                     this.throwIfNativeDurableCommitFailed();
                 }
             }
@@ -12960,12 +14253,16 @@ let SharedLog = (() => {
         }
         async waitForLeaderSelection(waitFor, options, checkLeaders) {
             const timeout = options.timeout ?? this.waitForReplicatorTimeout;
+            const closeSignal = this._closeController.signal;
+            const replicationLifecycleSignal = this._replicationLifecycleController?.signal;
             return new Promise((resolve, reject) => {
                 let settled = false;
+                const checks = new Set();
                 const removeListeners = () => {
                     this.events.removeEventListener("replication:change", roleListener);
                     this.events.removeEventListener("replicator:mature", roleListener);
-                    this._closeController.signal.removeEventListener("abort", abortListener);
+                    closeSignal.removeEventListener("abort", abortListener);
+                    replicationLifecycleSignal?.removeEventListener("abort", abortListener);
                 };
                 const settleResolve = (value) => {
                     if (settled)
@@ -12973,7 +14270,10 @@ let SharedLog = (() => {
                     settled = true;
                     removeListeners();
                     clearTimeout(timer);
-                    resolve(value);
+                    // Leader planning may persist coordinates. Keep the caller (and any
+                    // receive lease it owns) alive until checks admitted before this
+                    // timeout/abort have finished their local side effects.
+                    void Promise.allSettled([...checks]).then(() => resolve(value));
                 };
                 const settleReject = (error) => {
                     if (settled)
@@ -12981,7 +14281,7 @@ let SharedLog = (() => {
                     settled = true;
                     removeListeners();
                     clearTimeout(timer);
-                    reject(error);
+                    void Promise.allSettled([...checks]).then(() => reject(error));
                 };
                 const abortListener = () => {
                     settleResolve(false);
@@ -13010,16 +14310,30 @@ let SharedLog = (() => {
                     settleResolve(leaders);
                 };
                 const runCheck = () => {
-                    void check().catch((error) => {
+                    if (settled)
+                        return;
+                    let running;
+                    running = check()
+                        .catch((error) => {
                         settleReject(error);
-                    });
+                    })
+                        .finally(() => checks.delete(running));
+                    checks.add(running);
                 };
                 const roleListener = () => {
                     runCheck();
                 };
                 this.events.addEventListener("replication:change", roleListener);
                 this.events.addEventListener("replicator:mature", roleListener);
-                this._closeController.signal.addEventListener("abort", abortListener);
+                closeSignal.addEventListener("abort", abortListener);
+                replicationLifecycleSignal?.addEventListener("abort", abortListener);
+                // AbortSignal does not replay an abort event to listeners added after it
+                // fired. Recheck after registration so work started concurrently with the
+                // terminal fence cannot wait for the full leader-selection timeout.
+                if (closeSignal.aborted || replicationLifecycleSignal?.aborted) {
+                    abortListener();
+                    return;
+                }
                 runCheck();
             });
         }
@@ -15054,6 +16368,40 @@ let SharedLog = (() => {
                 }
             });
         }
+        async drainReplicationInfoApplyQueues() {
+            for (;;) {
+                const tails = [...(this._replicationInfoApplyQueueByPeer?.values() ?? [])];
+                if (tails.length === 0) {
+                    return;
+                }
+                await Promise.allSettled(tails);
+                // Queue cleanup runs in `finally`; give it a microtask before checking for
+                // tails admitted while the previous snapshot was settling.
+                await Promise.resolve();
+            }
+        }
+        advanceReplicationInfoReceiveEpoch(peerHash) {
+            const next = {};
+            this._replicationInfoReceiveEpochByPeer.set(peerHash, next);
+            return next;
+        }
+        getReplicationInfoReceiveEpoch(peerHash) {
+            return this._replicationInfoReceiveEpochByPeer.get(peerHash) ?? null;
+        }
+        isCurrentReplicationInfoReceiveEpoch(peerHash, epoch) {
+            return this.getReplicationInfoReceiveEpoch(peerHash) === epoch;
+        }
+        advanceSubscriptionEpoch(peerHash) {
+            const next = {};
+            this._subscriptionEpochByPeer.set(peerHash, next);
+            return next;
+        }
+        getSubscriptionEpoch(peerHash) {
+            return this._subscriptionEpochByPeer.get(peerHash) ?? null;
+        }
+        isCurrentSubscriptionEpoch(peerHash, epoch) {
+            return this.getSubscriptionEpoch(peerHash) === epoch;
+        }
         cancelReplicationInfoRequests(peerHash) {
             const state = this._replicationInfoRequestByPeer.get(peerHash);
             if (!state)
@@ -15118,7 +16466,7 @@ let SharedLog = (() => {
             };
             tick();
         }
-        async handleSubscriptionChange(publicKey, topics, subscribed) {
+        async handleSubscriptionChange(publicKey, topics, subscribed, subscriptionEpoch) {
             if (!topics.includes(this.topic)) {
                 return;
             }
@@ -15128,30 +16476,91 @@ let SharedLog = (() => {
                 return;
             }
             const peerHash = publicKey.hashcode();
+            const expectedSubscriptionEpoch = subscriptionEpoch ?? this.advanceSubscriptionEpoch(peerHash);
+            const ownsSubscriptionEpoch = () => this.isCurrentSubscriptionEpoch(peerHash, expectedSubscriptionEpoch);
+            if (!ownsSubscriptionEpoch()) {
+                return;
+            }
+            if (subscribed) {
+                const pendingOpeningCapabilities = this._openingSyncCapabilitiesByPeer.get(peerHash);
+                if (pendingOpeningCapabilities &&
+                    pendingOpeningCapabilities.epoch !== expectedSubscriptionEpoch) {
+                    this._openingSyncCapabilitiesByPeer.delete(peerHash);
+                }
+                this._subscriptionOpeningEpochByPeer.set(peerHash, expectedSubscriptionEpoch);
+                // Fence new messages immediately, drain handlers admitted by the previous
+                // subscription, then wait behind every queued replication mutation. A
+                // reconnect must not inherit metadata or ranges from the old connection.
+                try {
+                    this._replicationInfoBlockedPeers.add(peerHash);
+                    await this.drainPeerReceiveHandlers(peerHash);
+                    await this.withReplicationInfoApplyQueue(peerHash, async () => { });
+                    if (!this.isReplicationLifecycleActive(replicationLifecycleController) ||
+                        !ownsSubscriptionEpoch()) {
+                        return;
+                    }
+                    // The timestamp watermark belongs to the previous subscription epoch.
+                    // Sender clocks are not synchronized, so carrying a local unsubscribe
+                    // timestamp forward could reject every valid announcement after reconnect.
+                    this.latestReplicationInfoMessage.delete(peerHash);
+                    this._pendingReplicatorLeaveByPeer.delete(peerHash);
+                    const openingCapabilities = this._openingSyncCapabilitiesByPeer.get(peerHash);
+                    if (openingCapabilities?.epoch === expectedSubscriptionEpoch) {
+                        this._peerSyncCapabilities.set(peerHash, openingCapabilities.capabilities);
+                        this._openingSyncCapabilitiesByPeer.delete(peerHash);
+                    }
+                    this._replicationInfoBlockedPeers.delete(peerHash);
+                }
+                finally {
+                    if (this._openingSyncCapabilitiesByPeer.get(peerHash)?.epoch ===
+                        expectedSubscriptionEpoch) {
+                        this._openingSyncCapabilitiesByPeer.delete(peerHash);
+                    }
+                    if (this._subscriptionOpeningEpochByPeer.get(peerHash) ===
+                        expectedSubscriptionEpoch) {
+                        this._subscriptionOpeningEpochByPeer.delete(peerHash);
+                    }
+                }
+            }
             if (!subscribed) {
+                this._subscriptionOpeningEpochByPeer.delete(peerHash);
+                this._openingSyncCapabilitiesByPeer.delete(peerHash);
                 this._replicationInfoBlockedPeers.add(peerHash);
+                const disconnectedJoinWarmupGeneration = this._joinWarmupGenerationByTarget.get(peerHash) ?? null;
+                this.cancelJoinWarmupTarget(peerHash);
                 const now = BigInt(+new Date());
                 const previous = this.latestReplicationInfoMessage.get(peerHash);
                 if (!previous || previous < now) {
                     this.latestReplicationInfoMessage.set(peerHash, now);
                 }
-                const wasReplicator = this.uniqueReplicators.has(peerHash);
+                let removed = false;
                 try {
                     // Unsubscribe can race with the peer's final replication reset message.
                     // Proactively evict its ranges so leader selection doesn't keep stale owners.
-                    await this.removeReplicator(publicKey, { noEvent: true });
+                    removed = await this.removeReplicator(publicKey, {
+                        cleanupIfSubscriptionSuperseded: true,
+                        expectedJoinWarmupGeneration: disconnectedJoinWarmupGeneration,
+                        noEvent: true,
+                        onRemoved: ({ wasReplicator }) => {
+                            if (wasReplicator) {
+                                this._pendingReplicatorLeaveByPeer.add(peerHash);
+                            }
+                        },
+                        replicationLifecycleController,
+                        subscriptionEpoch: expectedSubscriptionEpoch,
+                    });
                 }
                 catch (error) {
                     if (!isNotStartedError(error)) {
                         throw error;
                     }
                 }
-                if (!this.isReplicationLifecycleActive(replicationLifecycleController)) {
+                if (!this.isReplicationLifecycleActive(replicationLifecycleController) ||
+                    !ownsSubscriptionEpoch() ||
+                    !removed) {
                     return;
                 }
-                this._replicatorJoinEmitted.delete(peerHash);
-                this.cleanupPeerDisconnectTracking(peerHash);
-                if (wasReplicator) {
+                if (this._pendingReplicatorLeaveByPeer.delete(peerHash)) {
                     this.events.dispatchEvent(new CustomEvent("replicator:leave", {
                         detail: { publicKey },
                     }));
@@ -15185,7 +16594,8 @@ let SharedLog = (() => {
                 }
                 throw error;
             }
-            if (!this.isReplicationLifecycleActive(replicationLifecycleController)) {
+            if (!this.isReplicationLifecycleActive(replicationLifecycleController) ||
+                !ownsSubscriptionEpoch()) {
                 return;
             }
             if (replicationSegments.length > 0) {
@@ -15197,7 +16607,8 @@ let SharedLog = (() => {
                     signal: replicationLifecycleController.signal,
                 })
                     .catch((error) => this.handleReplicationLifecycleSendError(error, replicationLifecycleController));
-                if (!this.isReplicationLifecycleActive(replicationLifecycleController)) {
+                if (!this.isReplicationLifecycleActive(replicationLifecycleController) ||
+                    !ownsSubscriptionEpoch()) {
                     return;
                 }
                 if (this.v8Behaviour) {
@@ -15218,7 +16629,8 @@ let SharedLog = (() => {
             // Request the remote peer's replication info. This makes joins resilient to
             // timing-sensitive delivery/order issues where we may miss their initial
             // replication announcement.
-            if (this.isReplicationLifecycleActive(replicationLifecycleController)) {
+            if (this.isReplicationLifecycleActive(replicationLifecycleController) &&
+                ownsSubscriptionEpoch()) {
                 this.scheduleReplicationInfoRequests(publicKey, replicationLifecycleController);
             }
         }
@@ -15532,12 +16944,18 @@ let SharedLog = (() => {
             if (this.closed) {
                 return;
             }
-            await this.log.trim();
             const batchedChanges = Array.isArray(changeOrChanges[0])
                 ? changeOrChanges
                 : [changeOrChanges];
             const changes = batchedChanges.flat();
             const selfHash = this.node.identity.publicKey.hashcode();
+            const joinWarmupGenerations = new Map();
+            for (const change of changes) {
+                if (change.type === "added" && change.range.hash !== selfHash) {
+                    joinWarmupGenerations.set(change.range.hash, this.getJoinWarmupGeneration(change.range.hash));
+                }
+            }
+            await this.log.trim();
             // On removed ranges (peer leaves / shrink), gid-level history can hide
             // per-entry gaps. Force a fresh delivery pass for reassigned entries.
             const forceFreshDelivery = changes.some((change) => change.type === "removed");
@@ -15597,6 +17015,10 @@ let SharedLog = (() => {
                 ? changes.filter((change) => !(change.range.hash === selfHash &&
                     (change.type === "added" || change.type === "replaced")))
                 : changes;
+            const isCurrentJoinWarmupTarget = (target) => warmupPeers.has(target) &&
+                this._joinWarmupGenerationByTarget.get(target) ===
+                    joinWarmupGenerations.get(target);
+            const areJoinWarmupGenerationsCurrent = () => [...warmupPeers].every(isCurrentJoinWarmupTarget);
             try {
                 const uncheckedDeliver = new Map();
                 const flushUncheckedDeliverTarget = (target) => {
@@ -15605,6 +17027,10 @@ let SharedLog = (() => {
                         return;
                     }
                     const isWarmupTarget = warmupPeers.has(target);
+                    if (isWarmupTarget && !isCurrentJoinWarmupTarget(target)) {
+                        uncheckedDeliver.delete(target);
+                        return;
+                    }
                     const mode = forceFreshDelivery
                         ? "churn"
                         : isWarmupTarget
@@ -15624,6 +17050,9 @@ let SharedLog = (() => {
                     uncheckedDeliver.delete(target);
                 };
                 const queueUncheckedDeliver = (target, entry) => {
+                    if (warmupPeers.has(target) && !isCurrentJoinWarmupTarget(target)) {
+                        return;
+                    }
                     churnRepairPeers.add(target);
                     let set = uncheckedDeliver.get(target);
                     if (!set) {
@@ -15642,7 +17071,9 @@ let SharedLog = (() => {
                     for await (const entryReplicated of toRebalance(immediateRebalanceChanges, this.entryCoordinatesIndex, this.recentlyRebalanced, {
                         forceFresh: forceFreshDelivery || useJoinWarmupFastPath,
                     })) {
-                        if (this.closed) {
+                        if (this.closed ||
+                            (useJoinWarmupFastPath &&
+                                !areJoinWarmupGenerationsCurrent())) {
                             break;
                         }
                         if (useJoinWarmupFastPath) {
@@ -15659,7 +17090,9 @@ let SharedLog = (() => {
                             }
                             const candidatePeers = new Set([selfHash]);
                             for (const target of warmupPeers) {
-                                candidatePeers.add(target);
+                                if (isCurrentJoinWarmupTarget(target)) {
+                                    candidatePeers.add(target);
+                                }
                             }
                             if (oldPeersSet) {
                                 for (const oldPeer of oldPeersSet) {
@@ -15671,6 +17104,9 @@ let SharedLog = (() => {
                                 candidates: candidatePeers,
                                 persist: false,
                             });
+                            if (!areJoinWarmupGenerationsCurrent()) {
+                                continue;
+                            }
                             if (oldPeersSet) {
                                 for (const oldPeer of oldPeersSet) {
                                     if (!currentPeers.has(oldPeer)) {
@@ -15679,11 +17115,11 @@ let SharedLog = (() => {
                                 }
                             }
                             for (const [peer] of currentPeers) {
-                                if (warmupPeers.has(peer)) {
-                                    this.markRepairSweepOptimisticPeer(entryReplicated.gid, peer);
+                                if (isCurrentJoinWarmupTarget(peer)) {
+                                    this.markRepairSweepOptimisticPeer(entryReplicated.gid, peer, joinWarmupGenerations.get(peer));
                                 }
                             }
-                            const authoritativePeers = [...currentPeers.keys()].filter((peer) => !warmupPeers.has(peer) &&
+                            const authoritativePeers = [...currentPeers.keys()].filter((peer) => !isCurrentJoinWarmupTarget(peer) &&
                                 !this.hasPendingRepairSweepOptimisticPeer(entryReplicated.gid, peer));
                             this.addPeersToGidPeerHistory(entryReplicated.gid, authoritativePeers, true);
                             if (!currentPeers.has(selfHash)) {
@@ -15730,8 +17166,8 @@ let SharedLog = (() => {
                             }
                         }
                         for (const [peer] of currentPeers) {
-                            if (addedPeers.has(peer)) {
-                                this.markRepairSweepOptimisticPeer(entryReplicated.gid, peer);
+                            if (isCurrentJoinWarmupTarget(peer)) {
+                                this.markRepairSweepOptimisticPeer(entryReplicated.gid, peer, joinWarmupGenerations.get(peer));
                             }
                         }
                         const authoritativePeers = [...currentPeers.keys()].filter((peer) => !addedPeers.has(peer) &&
@@ -15771,6 +17207,7 @@ let SharedLog = (() => {
                         this.scheduleRepairSweep({
                             mode: "join-warmup",
                             peers,
+                            joinWarmupGenerations,
                         });
                     }, 250);
                     timer.unref?.();
@@ -15827,6 +17264,7 @@ let SharedLog = (() => {
                 return;
             }
             const fromHash = evt.detail.from.hashcode();
+            const subscriptionEpoch = this.advanceSubscriptionEpoch(fromHash);
             this._replicationInfoBlockedPeers.add(fromHash);
             this._recentRepairDispatch.delete(fromHash);
             // Keep a per-peer timestamp watermark when we observe an unsubscribe. This
@@ -15838,17 +17276,19 @@ let SharedLog = (() => {
                 this.latestReplicationInfoMessage.set(fromHash, now);
             }
             this.invalidateSharedLogTopicSubscribersCache();
-            return this.handleSubscriptionChange(evt.detail.from, evt.detail.topics, false);
+            return this.handleSubscriptionChange(evt.detail.from, evt.detail.topics, false, subscriptionEpoch);
         }
         async _onSubscription(evt) {
             logger.trace(`New peer '${evt.detail.from.hashcode()}' connected to '${JSON.stringify(evt.detail.topics.map((x) => x))}'`);
             if (!evt.detail.topics.includes(this.topic)) {
                 return;
             }
+            const fromHash = evt.detail.from.hashcode();
+            const subscriptionEpoch = this.advanceSubscriptionEpoch(fromHash);
             this.remoteBlocks.onReachable(evt.detail.from);
-            this._replicationInfoBlockedPeers.delete(evt.detail.from.hashcode());
+            this._replicationInfoBlockedPeers.add(fromHash);
             this.invalidateSharedLogTopicSubscribersCache();
-            await this.handleSubscriptionChange(evt.detail.from, evt.detail.topics, true);
+            await this.handleSubscriptionChange(evt.detail.from, evt.detail.topics, true, subscriptionEpoch);
         }
         async rebalanceParticipation() {
             // update more participation rate to converge to the average expected rate or bounded by
@@ -15998,7 +17438,7 @@ let SharedLog = (() => {
             const ih = this._pendingIHave.get(entry.hash);
             if (ih) {
                 ih.clear();
-                ih.callback(entry);
+                this.runPendingIHaveCallback(ih, entry);
             }
             this.syncronizer.onEntryAdded(entry);
         }
@@ -16010,7 +17450,7 @@ let SharedLog = (() => {
                 }
                 const entry = materializeEntry();
                 ih.clear();
-                ih.callback(entry);
+                this.runPendingIHaveCallback(ih, entry);
                 this.syncronizer.onEntryAdded(entry);
                 return;
             }