@peerbit/shared-log 14.0.0 → 16.0.0

package/dist/src/index.js

@@ -66,7 +66,7 @@ import { NativeBackboneWriteThroughBlockStore } from "./native-write-through-blo
 import { PeerSessionRegistry } from "./peer-session.js";
 import { PIDReplicationController } from "./pid.js";
 import { EntryReplicatedU32, EntryReplicatedU64, ReplicationIntent, ReplicationRangeIndexableU32, ReplicationRangeIndexableU64, ReplicationRangeMessage, appromixateCoverage, calculateCoverage, countCoveringRangesSameOwner, createAssignedRangesQuery, debounceAggregationChanges, getAllMergeCandiates, getCoverSet, getSamples, isEntryReplicated, isMatured, isReplicationRangeMessage, mergeRanges, minimumWidthToCover, shouldAssigneToRangeBoundary as shouldAssignToRangeBoundary, toRebalance, } from "./ranges.js";
-import { ReplicationAnnouncementCoordinator, isTransientReplicationAnnouncementError, } from "./replication-announcement.js";
+import { ReplicationAnnouncementCoordinator } from "./replication-announcement.js";
 import { createReplicationDomainHash, } from "./replication-domain-hash.js";
 import { createReplicationDomainTime, } from "./replication-domain-time.js";
 import {} from "./replication-domain.js";
@@ -74,7 +74,6 @@ import { ReplicationInfoV2ReceiveCoordinator } from "./replication-info-v2-recei
 import { ReplicationInfoV2SendCoordinator } from "./replication-info-v2-send.js";
 import { AbsoluteReplicas, AddedReplicationInfoV2Message, AddedReplicationSegmentMessage, AllReplicatingSegmentsMessage, FullReplicationInfoV2Message, MinReplicas, ReplicationError, ReplicationPingMessage, RequestReplicationInfoMessage, RequestReplicationInfoV2Message, ResponseRoleMessage, StoppedReplicating, StoppedReplicationInfoV2Message, decodeReplicas, encodeReplicas, isReplicationInfoV2Message, maxReplicas, } from "./replication.js";
 import { ReplicatorLivenessMonitor } from "./replicator-liveness.js";
-import { Observer, Replicator } from "./role.js";
 import { createSyncronizer } from "./sync/factory.js";
 import { emitSyncProfileDuration, emitSyncProfileEvent, syncProfileStart, } from "./sync/profile.js";
 import { ConfirmEntriesMessage, SYNC_MESSAGE_PRIORITY, SimpleSyncronizer, } from "./sync/simple.js";
@@ -682,24 +681,17 @@ let SharedLog = (() => {
         _pendingIHave;
         // public key hash to range id to range
         pendingMaturity; // map of peerId to timeout
-        // Stage-4 KEEP-OLD verdict (fence B8, split by role). The watermark's
-        // FENCING role — rejecting late replication-info across unsubscribe and
-        // eviction races — is fully subsumed by the per-peer receive epoch plus
-        // the blocked set and session identity: every unsubscribe-path `now` write
-        // is preceded in the same synchronous block by a blocked-add, so an
-        // admitted handler can never observe one. Its intra-epoch ORDERING role is
-        // NOT subsumed: within one (lifecycle, session, epoch, unblocked) regime
-        // the epoch token is constant across every message from the peer, so only
-        // the two apply-lane timestamp comparisons can drop an older reset
-        // delivered after a newer add (unordered pubsub / retransmits) — an
-        // identity token carries no order. Deletion is blocked until
-        // replication-info messages carry sender-authoritative sequence numbers
-        // (stage-5 schema change); the `receive admission replication-info
-        // ordering watermark` pins fail if the read sites are removed before then.
-        latestReplicationInfoMessage;
+        // The legacy replication-info ordering watermark (fence B8) is deleted:
+        // its FENCING role was subsumed by the per-peer receive epoch, blocked set
+        // and session identity, and its intra-epoch ORDERING role existed only for
+        // the legacy apply lanes. The V2 lane orders by sender-authoritative
+        // sequence numbers, and legacy frames are dropped unconditionally at the
+        // B1 gate before any side effect.
         // The replication-info blocked set (fence B5) lives on the peer-session
         // registry: unsubscribed peers whose replication-info is ignored until a
         // reconnect barrier commits. See PeerSessionRegistry._replicationInfoBlockedPeers.
+        // V2 recovery scheduler state, one row per open peer session (B12: the
+        // legacy request scheduler that shared this map is deleted).
         _replicationInfoRequestByPeer;
         _replicationInfoApplyQueueByPeer;
         // One in-flight targeted subscriber-snapshot request per session-less peer.
@@ -841,7 +833,6 @@ let SharedLog = (() => {
             for (const hash of this._checkedPrune?.retries.keys() ?? []) {
                 this._checkedPrune.clearRetry(hash);
             }
-            this._announcements.cancelCurrentReplicationStateAnnouncementRetry();
             this.joinWarmup.cancelAllJoinWarmupTargets();
             for (const timer of this._repairRetryTimers) {
                 clearTimeout(timer);
@@ -1707,25 +1698,9 @@ let SharedLog = (() => {
         }
         createReplicationAnnouncementCoordinator() {
             return new ReplicationAnnouncementCoordinator({
-                // Route re-entrant queueing through the owner so coordinator spies keep
-                // observing it (the poison guard assertions in events.spec.ts depend on
-                // this).
-                queueCurrentReplicationStateAnnouncementRepair: () => this._announcements.queueCurrentReplicationStateAnnouncementRepair(),
-                queueCurrentReplicationStateAnnouncementRetry: (error) => this._announcements.queueCurrentReplicationStateAnnouncementRetry(error),
                 enqueueReplicationInfoV2: (message) => this._v2Send.enqueue(message),
-                isLegacyReplicationInfoEnabled: () => this.legacyReplicationInfoEnabled,
-                isClosed: () => this.closed,
-                getCloseSignal: () => this._closeController.signal,
-                getMyReplicationSegments: () => this.getMyReplicationSegments(),
-                validatePersistedReplicationRangeSnapshot: (ranges) => this.validatePersistedReplicationRangeSnapshot(ranges),
-                getSubscribers: () => this.node.services.pubsub.getSubscribers(this.topic),
-                getSelfHash: () => this.node.identity.publicKey.hashcode(),
-                isBlockedPeer: (hash) => this._peerSessions.isReplicationInfoBlocked(hash),
-                getRpc: () => this.rpc,
                 captureReplicationOwnershipLifecycle: () => this.captureReplicationOwnershipLifecycle(),
                 throwIfReplicationOwnershipLifecycleInactive: (controller) => this.throwIfReplicationOwnershipLifecycleInactive(controller),
-                isAdaptiveReplicating: () => this._isAdaptiveReplicating,
-                callRebalanceParticipationDebounced: () => this.rebalanceParticipationDebounced?.call(),
             });
         }
         createReplicationInfoV2SendCoordinator() {
@@ -1885,7 +1860,6 @@ let SharedLog = (() => {
             this._admittedPruneRemoves = new Set();
             this._pendingIHave = new Map();
             this._pendingIHaveCallbacks = new Set();
-            this.latestReplicationInfoMessage = new Map();
             this._replicationInfoRequestByPeer = new Map();
             this._subscriberSnapshotRequestsByPeer = new Map();
             this._replicationInfoApplyQueueByPeer = new Map();
@@ -1985,25 +1959,9 @@ let SharedLog = (() => {
             this._nativeStrictDurableDocumentRecoveryDeferred ??= false;
             this._nativeStrictDurableTransactionsClosing ??= false;
         }
-        get compatibility() {
-            // B12: the open option was removed and any defined value rejects at
-            // open(); this is permanently undefined and dies with the residual
-            // gates in a later cleanup stage.
-            return this._logProperties?.compatibility;
-        }
-        /**
-         * Legacy replication-info is an explicit compatibility fallback. Current
-         * logs never infer or re-enable it from a remote peer's capabilities.
-         */
-        get legacyReplicationInfoEnabled() {
-            return this.compatibility !== undefined && this.compatibility < 10;
-        }
         get isAdaptiveReplicating() {
             return this._isAdaptiveReplicating;
         }
-        get v8Behaviour() {
-            return (this.compatibility ?? Number.MAX_VALUE) < 9;
-        }
         getFanoutChannelOptions(options) {
             return {
                 ...DEFAULT_SHARED_LOG_FANOUT_CHANNEL_OPTIONS,
@@ -2692,8 +2650,7 @@ let SharedLog = (() => {
                 !delivery &&
                 !requireRecipients &&
                 (leaders.size === 0 || (leaders.size === 1 && leaders.has(selfHash)))) {
-                const allowSubscriberFallback = this.syncronizer instanceof SimpleSyncronizer ||
-                    (this.compatibility ?? Number.MAX_VALUE) < 10;
+                const allowSubscriberFallback = this.syncronizer instanceof SimpleSyncronizer;
                 if (!allowSubscriberFallback) {
                     return;
                 }
@@ -2816,8 +2773,7 @@ let SharedLog = (() => {
                 // sweeps can still backfill peers that missed the initial delivery.
                 const set = new Set(leaders.keys());
                 let hasRemotePeers = set.has(selfHash) ? set.size > 1 : set.size > 0;
-                const allowSubscriberFallback = this.syncronizer instanceof SimpleSyncronizer ||
-                    (this.compatibility ?? Number.MAX_VALUE) < 10;
+                const allowSubscriberFallback = this.syncronizer instanceof SimpleSyncronizer;
                 if (!hasRemotePeers && allowSubscriberFallback) {
                     try {
                         const subscribers = await this._getTopicSubscribers(this.topic);
@@ -3185,21 +3141,6 @@ let SharedLog = (() => {
                 context: this.cloneLeaderSelectionContext(context),
             };
         }
-        // @deprecated
-        getRoleFromReplicationSegments(segments) {
-            if (segments.length > 1) {
-                throw new Error("More than one replication segment found. Can only use one segment for compatbility with v8");
-            }
-            if (segments.length > 0) {
-                const segment = segments[0].toReplicationRange();
-                return new Replicator({
-                    factor: segment.factor / MAX_U32,
-                    offset: segment.offset / MAX_U32,
-                });
-            }
-            // TODO this is not accurate but might be good enough
-            return new Observer();
-        }
         isTerminating() {
             return (this.acceptsParentAttachments === false ||
                 this.closed ||
@@ -3398,10 +3339,7 @@ let SharedLog = (() => {
             this.rebalanceParticipationDebounced = rebalanceParticipationDebounced;
         }
         onRebalanceParticipationError(error) {
-            if (this.closed ||
-                isNotStartedError(error) ||
-                (isTransientReplicationAnnouncementError(error) &&
-                    this._announcements._replicationAnnouncementRetryPending)) {
+            if (this.closed || isNotStartedError(error)) {
                 return;
             }
             // Debounced invocations run from an un-awaited timer. Throwing here would
@@ -3630,9 +3568,11 @@ let SharedLog = (() => {
                 }, replicationOwnershipLifecycleController);
                 this.throwIfReplicationOwnershipLifecycleInactive(replicationOwnershipLifecycleController);
                 if (confirmedPreliminaryRemovals.length > 0) {
-                    await this._announcements.sendReplicationAnnouncement(new StoppedReplicating({
-                        segmentIds: confirmedPreliminaryRemovals.map((x) => x.id),
-                    }), replicationOwnershipLifecycleController);
+                    await this._announcements.sendReplicationAnnouncement({
+                        stopped: {
+                            segmentIds: confirmedPreliminaryRemovals.map((x) => x.id),
+                        },
+                    }, replicationOwnershipLifecycleController);
                     this.throwIfReplicationOwnershipLifecycleInactive(replicationOwnershipLifecycleController);
                 }
             }
@@ -3646,7 +3586,7 @@ let SharedLog = (() => {
                     const segments = (await this.getMyReplicationSegments()).map((range) => range.toReplicationRange());
                     this.throwIfReplicationOwnershipLifecycleInactive(replicationOwnershipLifecycleController);
                     this.validatePersistedReplicationRangeSnapshot(segments);
-                    await this._announcements.sendReplicationAnnouncement(new AllReplicatingSegmentsMessage({ segments }), replicationOwnershipLifecycleController);
+                    await this._announcements.sendReplicationAnnouncement({ full: { segments } }, replicationOwnershipLifecycleController);
                 }
                 catch (error) {
                     announcementError = error;
@@ -3856,7 +3796,7 @@ let SharedLog = (() => {
                 return;
             }
             try {
-                await this._announcements.sendReplicationAnnouncement(new StoppedReplicating({ segmentIds: removedSegmentIds }), replicationOwnershipLifecycleController);
+                await this._announcements.sendReplicationAnnouncement({ stopped: { segmentIds: removedSegmentIds } }, replicationOwnershipLifecycleController);
                 this.throwIfReplicationOwnershipLifecycleInactive(replicationOwnershipLifecycleController);
             }
             catch (announcementError) {
@@ -4070,7 +4010,7 @@ let SharedLog = (() => {
                     let announcementError;
                     if (isMe && !ownerHasRanges) {
                         try {
-                            await this._announcements.sendReplicationAnnouncement(new AllReplicatingSegmentsMessage({ segments: [] }), replicationOwnershipLifecycleController);
+                            await this._announcements.sendReplicationAnnouncement({ full: { segments: [] } }, replicationOwnershipLifecycleController);
                         }
                         catch (error) {
                             announcementError = error;
@@ -4743,7 +4683,7 @@ let SharedLog = (() => {
                     const segments = (await this.getMyReplicationSegments()).map((range) => range.toReplicationRange());
                     this.throwIfReplicationOwnershipLifecycleInactive(replicationOwnershipLifecycleController);
                     this.validatePersistedReplicationRangeSnapshot(segments);
-                    await this._announcements.sendReplicationAnnouncement(new AllReplicatingSegmentsMessage({ segments }), replicationOwnershipLifecycleController);
+                    await this._announcements.sendReplicationAnnouncement({ full: { segments } }, replicationOwnershipLifecycleController);
                 }
                 catch (error) {
                     announcementError = error;
@@ -4784,14 +4724,14 @@ let SharedLog = (() => {
                     }
                     let message = undefined;
                     if (options.reset) {
-                        message = new AllReplicatingSegmentsMessage({
-                            segments: added.map((x) => x.range.toReplicationRange()),
-                        });
+                        message = {
+                            full: { segments: added.map((x) => x.range.toReplicationRange()) },
+                        };
                     }
                     else {
-                        message = new AddedReplicationSegmentMessage({
-                            segments: added.map((x) => x.range.toReplicationRange()),
-                        });
+                        message = {
+                            added: { segments: added.map((x) => x.range.toReplicationRange()) },
+                        };
                     }
                     if (options.announce) {
                         return options.announce(message);
@@ -9173,10 +9113,7 @@ let SharedLog = (() => {
             this._logProperties = options;
             this.domain = options?.domain
                 ? options.domain(this)
-                : createReplicationDomainHash(options?.compatibility !== undefined &&
-                    options.compatibility < 10
-                    ? "u32"
-                    : "u64")(this);
+                : createReplicationDomainHash("u64")(this);
             this.indexableDomain = createIndexableDomainFromResolution(this.domain.resolution);
             this._respondToIHaveTimeout = options?.respondToIHaveTimeout ?? 2e4;
             this._checkedPrune = new CheckedPruneCoordinator();
@@ -9184,7 +9121,6 @@ let SharedLog = (() => {
             this._admittedPruneRemoves = new Set();
             this._pendingIHave = new Map();
             this._pendingIHaveCallbacks = new Set();
-            this.latestReplicationInfoMessage = new Map();
             this._replicationInfoRequestByPeer = new Map();
             this._subscriberSnapshotRequestsByPeer = new Map();
             // Terminal close/drop drains the previous lifecycle before another open can
@@ -9253,7 +9189,6 @@ let SharedLog = (() => {
             this._liveness.resetForOpen();
             this._lastLocalAppendAt = 0;
             this._announcements ??= this.createReplicationAnnouncementCoordinator();
-            this._announcements.resetForOpen();
             this._v2Receive ??= this.createReplicationInfoV2ReceiveCoordinator();
             this._v2Receive.resetForOpen();
             this._v2Send ??= this.createReplicationInfoV2SendCoordinator();
@@ -9295,13 +9230,6 @@ let SharedLog = (() => {
                 throw new Error("waitForReplicatorRequestMaxAttempts must be a positive number");
             }
             this._closeController = new AbortController();
-            if (this.legacyReplicationInfoEnabled) {
-                this._announcements.setupReplicationAnnouncementRetryFunction();
-                this._announcements.setupReplicationAnnouncementRepairFunction();
-            }
-            else {
-                this._announcements.cancelCurrentReplicationStateAnnouncementRetry();
-            }
             this._closeController.signal.addEventListener("abort", () => {
                 for (const [_peer, state] of this._replicationInfoRequestByPeer) {
                     if (state.timer)
@@ -9656,7 +9584,6 @@ let SharedLog = (() => {
                 peerSupportsRawExchangeHeads: (peer) => this.peerSupportsRawExchangeHeads(peer),
                 sendRawExchangeHeads: (hashes, to, sendOptions) => this.trySendFusedRawExchangeHeads(hashes, to, sendOptions),
                 warn,
-                compatibility: this._logProperties?.compatibility,
                 resolution: this.domain.resolution,
                 sync: options?.sync,
                 syncronizer: options?.syncronizer,
@@ -10397,7 +10324,7 @@ let SharedLog = (() => {
         cleanupPeerDisconnectTracking(peerHash, ownershipLifecycleController = this.captureReplicationOwnershipLifecycle()) {
             const peerSession = this._peerSessions.current(peerHash);
             const preserveV2Session = peerSession?.phase === "open" && peerSession.isActive();
-            if (this.legacyReplicationInfoEnabled || !preserveV2Session) {
+            if (!preserveV2Session) {
                 this.cancelReplicationInfoRequests(peerHash);
             }
             this._liveness._replicatorLivenessFailures.delete(peerHash);
@@ -10423,11 +10350,8 @@ let SharedLog = (() => {
         }
         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.
+            // when they eventually reach the apply lane.
             const receiveEpoch = this._peerSessions.advanceReceiveEpoch(peerHash);
-            this.latestReplicationInfoMessage.delete(peerHash);
             const peerSession = this._peerSessions.current(peerHash);
             if (peerSession?.phase === "open") {
                 this._v2Receive.advanceRecovery({
@@ -11136,13 +11060,6 @@ let SharedLog = (() => {
                     firstError ??= error;
                 }
             };
-            // A borsh-deserialized instance that is closed before ever being opened
-            // has no coordinators (they are created in open()); the old inline code
-            // only touched plain fields here and never threw.
-            captureSync(() => this._announcements?.cancelCurrentReplicationStateAnnouncementRetry());
-            if (this._announcements) {
-                this._announcements.replicationAnnouncementRetryDebounced = undefined;
-            }
             captureSync(() => {
                 if (this._wireSyncSession) {
                     this._wireSyncSession.unregisterTopic(this.topic);
@@ -11225,7 +11142,6 @@ let SharedLog = (() => {
             captureSync(() => {
                 this._pendingIHave?.clear();
                 this._pendingIHaveCallbacks?.clear();
-                this.latestReplicationInfoMessage?.clear();
                 this._peerSessions?.clearReceiveEpochsForClose();
                 this._peerSessions?.clearCleanupGatesForClose();
                 this._activeReceiveHandlersByPeer?.clear();
@@ -11315,7 +11231,6 @@ let SharedLog = (() => {
                 await pruneRemoveTerminalFence.drained;
                 await this.drainPendingIHaveCallbacks();
                 this.ensureNativeDurabilityRuntimeState();
-                this._announcements.cancelCurrentReplicationStateAnnouncementRetry();
             }
             catch (error) {
                 // The terminal preamble has already disabled parent attachments and the
@@ -11358,17 +11273,7 @@ let SharedLog = (() => {
                         }
                     }, 2_000);
                     try {
-                        const reset = new AllReplicatingSegmentsMessage({ segments: [] });
-                        const resets = [this._v2Send.sendTerminalReset(abort.signal)];
-                        if (this.legacyReplicationInfoEnabled) {
-                            resets.push(this.rpc
-                                .send(reset, {
-                                priority: CONVERGENCE_MESSAGE_PRIORITY,
-                                signal: abort.signal,
-                            })
-                                .catch(() => { }));
-                        }
-                        await Promise.all(resets);
+                        await this._v2Send.sendTerminalReset(abort.signal);
                     }
                     finally {
                         clearTimeout(abortTimer);
@@ -11460,7 +11365,6 @@ let SharedLog = (() => {
                 await replicationRangeTerminalFence.drained;
                 await pruneRemoveTerminalFence.drained;
                 await this.drainPendingIHaveCallbacks();
-                this._announcements.cancelCurrentReplicationStateAnnouncementRetry();
             }
             catch (error) {
                 // The terminal preamble is not safely reversible. Preserve the fence until
@@ -11487,17 +11391,7 @@ let SharedLog = (() => {
                         }
                     }, 2_000);
                     try {
-                        const reset = new AllReplicatingSegmentsMessage({ segments: [] });
-                        const resets = [this._v2Send.sendTerminalReset(abort.signal)];
-                        if (this.legacyReplicationInfoEnabled) {
-                            resets.push(this.rpc
-                                .send(reset, {
-                                priority: CONVERGENCE_MESSAGE_PRIORITY,
-                                signal: abort.signal,
-                            })
-                                .catch(() => { }));
-                        }
-                        await Promise.all(resets);
+                        await this._v2Send.sendTerminalReset(abort.signal);
                     }
                     finally {
                         clearTimeout(abortTimer);
@@ -11921,15 +11815,15 @@ let SharedLog = (() => {
                 if (!context.from) {
                     throw new Error("Missing from in update role message");
                 }
-                if (!this.legacyReplicationInfoEnabled &&
-                    (msg instanceof RequestReplicationInfoMessage ||
-                        msg instanceof ResponseRoleMessage ||
-                        msg instanceof AllReplicatingSegmentsMessage ||
-                        msg instanceof AddedReplicationSegmentMessage ||
-                        msg instanceof StoppedReplicating)) {
-                    // These variants remain registered decode tombstones, but current logs
-                    // fail closed before leases, synchronizer work, liveness, watermarks or
-                    // mutations. Only an explicit pre-v10 compatibility open admits them.
+                if (msg instanceof RequestReplicationInfoMessage ||
+                    msg instanceof ResponseRoleMessage ||
+                    msg instanceof AllReplicatingSegmentsMessage ||
+                    msg instanceof AddedReplicationSegmentMessage ||
+                    msg instanceof StoppedReplicating) {
+                    // These variants remain registered decode tombstones, but logs fail
+                    // closed unconditionally before leases, synchronizer work, liveness,
+                    // watermarks or mutations (B12: the compatibility opens that once
+                    // admitted them reject at open()).
                     return;
                 }
                 // Snapshot receive ownership before any async handler gets a chance to
@@ -11959,29 +11853,20 @@ let SharedLog = (() => {
                 const receiveOwnershipRevision = this._instanceLifecycle?._receiveOwnershipRevision ?? 0;
                 const receiveOwnershipLifecycleController = this.captureReplicationOwnershipLifecycle();
                 const receiveReplicationInfoReceiveEpoch = this._peerSessions.receiveEpoch(receiveFromHash);
-                if (msg instanceof ResponseRoleMessage) {
-                    msg = msg.toReplicationInfoMessage(); // migration
-                }
-                if (msg instanceof AllReplicatingSegmentsMessage ||
-                    msg instanceof AddedReplicationSegmentMessage ||
-                    msg instanceof FullReplicationInfoV2Message ||
+                if (msg instanceof FullReplicationInfoV2Message ||
                     msg instanceof AddedReplicationInfoV2Message) {
                     // Bound decoded untrusted vectors before per-peer/global mutation
                     // queues, trusted-replicator authorization, or liveness side effects.
                     this.validateReplicationRangeAnnouncement(msg.segments);
                 }
-                else if (msg instanceof StoppedReplicating ||
-                    msg instanceof StoppedReplicationInfoV2Message) {
+                else if (msg instanceof StoppedReplicationInfoV2Message) {
                     // Bound the raw decoded vector before deduplication can hide the
                     // allocation cost, and before liveness or apply-queue side effects.
                     this.validateStoppedReplicationAnnouncement(msg.segmentIds);
                 }
                 if (!context.from.equals(this.node.identity.publicKey) &&
                     !(msg instanceof RequestReplicationInfoV2Message) &&
-                    !isReplicationInfoV2Message(msg) &&
-                    !(msg instanceof AllReplicatingSegmentsMessage) &&
-                    !(msg instanceof AddedReplicationSegmentMessage) &&
-                    !(msg instanceof StoppedReplicating)) {
+                    !isReplicationInfoV2Message(msg)) {
                     this._liveness.markReplicatorActivity(receiveFromHash);
                 }
                 const syncProfile = this._logProperties?.sync?.profile;
@@ -13403,16 +13288,6 @@ let SharedLog = (() => {
                     else if (msg instanceof ReplicationPingMessage) {
                         // No-op: used as an ACKed unicast liveness probe.
                     }
-                    else if (msg instanceof RequestReplicationInfoMessage) {
-                        await this.handleRequestReplicationInfo(msg, laneRequestContext, lane);
-                    }
-                    else if (msg instanceof AllReplicatingSegmentsMessage ||
-                        msg instanceof AddedReplicationSegmentMessage) {
-                        await this.handleReplicationInfoAnnouncement(msg, laneRequestContext, lane);
-                    }
-                    else if (msg instanceof StoppedReplicating) {
-                        await this.handleStoppedReplicating(msg, laneRequestContext, lane);
-                    }
                     else {
                         throw new Error("Unexpected message");
                     }
@@ -13598,68 +13473,6 @@ let SharedLog = (() => {
                 }
             }
         }
-        async handleRequestReplicationInfo(_msg, context, lane) {
-            const receiveFromHash = lane.fromHash;
-            const receiveSession = lane.session;
-            const receiveReplicationLifecycleController = lane.lifecycleController;
-            if (context.from.equals(this.node.identity.publicKey)) {
-                return;
-            }
-            const replicationLifecycleController = receiveReplicationLifecycleController;
-            if (!replicationLifecycleController ||
-                !this._peerSessions.isReceiveAdmissionOpen(receiveFromHash, receiveSession, replicationLifecycleController)) {
-                return;
-            }
-            let replicationSegments;
-            try {
-                replicationSegments = await this.getMyReplicationSegments();
-            }
-            catch (error) {
-                if (!this._peerSessions.isReceiveAdmissionOpen(receiveFromHash, receiveSession, replicationLifecycleController) &&
-                    isNotStartedError(error)) {
-                    return;
-                }
-                throw error;
-            }
-            if (!this._peerSessions.isReceiveAdmissionOpen(receiveFromHash, receiveSession, replicationLifecycleController)) {
-                return;
-            }
-            const segments = replicationSegments.map((x) => x.toReplicationRange());
-            this.validatePersistedReplicationRangeSnapshot(segments);
-            this._v2Send.enqueueSnapshotForPeer(receiveFromHash);
-            await this.rpc
-                .send(new AllReplicatingSegmentsMessage({ segments }), {
-                mode: new AcknowledgeDelivery({
-                    to: [context.from],
-                    redundancy: 1,
-                }),
-                signal: replicationLifecycleController.signal,
-            })
-                .catch((error) => this.handleReplicationLifecycleSendError(error, replicationLifecycleController));
-            if (!this._peerSessions.isReceiveAdmissionOpen(receiveFromHash, receiveSession, replicationLifecycleController)) {
-                return;
-            }
-            // for backwards compatibility (v8) remove this when we are sure that all nodes are v9+
-            if (this.v8Behaviour) {
-                const role = this.getRoleFromReplicationSegments(replicationSegments);
-                if (role instanceof Replicator) {
-                    const fixedSettings = !this._isAdaptiveReplicating;
-                    if (fixedSettings) {
-                        await this.rpc
-                            .send(new ResponseRoleMessage({
-                            role,
-                        }), {
-                            mode: new SilentDelivery({
-                                to: [context.from],
-                                redundancy: 1,
-                            }),
-                            signal: replicationLifecycleController.signal,
-                        })
-                            .catch((error) => this.handleReplicationLifecycleSendError(error, replicationLifecycleController));
-                    }
-                }
-            }
-        }
         async handleReplicationInfoV2Announcement(msg, context, lane) {
             const from = context.from;
             const fromHash = lane.fromHash;
@@ -13795,187 +13608,12 @@ let SharedLog = (() => {
                     // A committed V2 announcement is applied progress: the peer answers,
                     // so recovery re-solicitation may restart from the base interval.
                     this.resetReplicationInfoV2RecoveryEscalation(fromHash);
-                    if (msg instanceof FullReplicationInfoV2Message &&
-                        this.legacyReplicationInfoEnabled) {
-                        this.cancelReplicationInfoRequests(fromHash);
-                    }
                 });
             }
             finally {
                 this._v2Receive.release(admission);
             }
         }
-        async handleReplicationInfoAnnouncement(msg, context, lane) {
-            const receiveFromHash = lane.fromHash;
-            const receiveSession = lane.session;
-            const receiveReplicationLifecycleController = lane.lifecycleController;
-            const receiveReplicationInfoReceiveEpoch = lane.receiveEpoch;
-            const peerReceiveLease = lane.lease;
-            if (context.from.equals(this.node.identity.publicKey)) {
-                return;
-            }
-            const replicationInfoMessage = msg;
-            // Process replication updates even if the sender isn't yet considered "ready" by
-            // `Program.waitFor()`. Dropping these messages can lead to missing replicator info
-            // (and downstream `waitForReplicator()` timeouts) under timing-sensitive joins.
-            const from = context.from;
-            const fromHash = from.hashcode();
-            if (this._v2Receive.isLegacyCutover(receiveSession)) {
-                if (receiveSession) {
-                    this._v2Receive.noteLegacyAnnouncement({
-                        peerHash: fromHash,
-                        peerSession: receiveSession,
-                        receiveEpoch: receiveReplicationInfoReceiveEpoch,
-                        senderTransportSession: context.message.header.session,
-                        transportTimestamp: context.message.header.timestamp,
-                        message: msg,
-                    });
-                }
-                return;
-            }
-            // Pre-lane gate: lifecycle -> receive-epoch -> blocked, exactly the
-            // legacy order. isMembershipActiveFor is the unit-pinned fold of
-            // isReplicationLifecycleActive; isReceiveEpochCurrent is the
-            // relocated `===`-with-`?? null`. The DELIBERATE absence of a
-            // subscription-epoch term is preserved: the lease already validated
-            // it, and the in-lane recheck owns post-await staleness.
-            if (!this._instanceLifecycle.isMembershipActiveFor(receiveReplicationLifecycleController) ||
-                !this._peerSessions.isReceiveEpochCurrent(receiveFromHash, receiveReplicationInfoReceiveEpoch) ||
-                this._peerSessions.isReplicationInfoBlocked(fromHash)) {
-                return;
-            }
-            const messageTimestamp = context.message.header.timestamp;
-            peerReceiveLease.release();
-            await this.withReplicationInfoApplyQueue(fromHash, async () => {
-                try {
-                    // The peer may have unsubscribed after this message was queued.
-                    // In-lane gate: lifecycle -> subscription-epoch -> receive-epoch
-                    // -> blocked, term for term as before the session migration.
-                    if (!this._instanceLifecycle.isMembershipActiveFor(receiveReplicationLifecycleController) ||
-                        !this._peerSessions.isCurrent(fromHash, receiveSession) ||
-                        !this._peerSessions.isReceiveEpochCurrent(fromHash, receiveReplicationInfoReceiveEpoch) ||
-                        this._peerSessions.isReplicationInfoBlocked(fromHash)) {
-                        return;
-                    }
-                    if (receiveSession && this._v2Receive.isLegacyCutover(receiveSession)) {
-                        this._v2Receive.noteLegacyAnnouncement({
-                            peerHash: fromHash,
-                            peerSession: receiveSession,
-                            receiveEpoch: receiveReplicationInfoReceiveEpoch,
-                            senderTransportSession: context.message.header.session,
-                            transportTimestamp: context.message.header.timestamp,
-                            message: msg,
-                        });
-                        return;
-                    }
-                    // Process in-order to avoid races where repeated reset messages arrive
-                    // concurrently and trigger spurious "added" diffs / rebalancing.
-                    const prev = this.latestReplicationInfoMessage.get(fromHash);
-                    if (prev && prev > messageTimestamp) {
-                        return;
-                    }
-                    this.latestReplicationInfoMessage.set(fromHash, messageTimestamp);
-                    if (this.closed) {
-                        return;
-                    }
-                    const reset = msg instanceof AllReplicatingSegmentsMessage;
-                    const result = await this.addReplicationRange(replicationInfoMessage.segments.map((x) => x.toReplicationRangeIndexable(from)), from, {
-                        reset,
-                        checkDuplicates: true,
-                        timestamp: Number(messageTimestamp),
-                        allowLegacyOrderedReplacementPairs: msg instanceof AddedReplicationSegmentMessage,
-                    });
-                    if (result === undefined) {
-                        return;
-                    }
-                    this._liveness.markReplicatorActivity(fromHash);
-                    // If the peer reports any replication segments, stop re-requesting.
-                    // (Empty reports can be transient during startup.)
-                    if (replicationInfoMessage.segments.length > 0) {
-                        this.cancelReplicationInfoRequests(fromHash);
-                    }
-                }
-                catch (e) {
-                    if (isNotStartedError(e)) {
-                        return;
-                    }
-                    logger.error(`Failed to apply replication settings from '${fromHash}': ${e?.message ?? e}`);
-                }
-            });
-        }
-        async handleStoppedReplicating(msg, context, lane) {
-            const receiveFromHash = lane.fromHash;
-            const receiveSession = lane.session;
-            const receiveReplicationLifecycleController = lane.lifecycleController;
-            const receiveReplicationInfoReceiveEpoch = lane.receiveEpoch;
-            const peerReceiveLease = lane.lease;
-            const from = context.from;
-            const segmentIds = msg.segmentIds;
-            if (from.equals(this.node.identity.publicKey)) {
-                return;
-            }
-            const fromHash = from.hashcode();
-            if (this._v2Receive.isLegacyCutover(receiveSession)) {
-                if (receiveSession) {
-                    this._v2Receive.noteLegacyAnnouncement({
-                        peerHash: fromHash,
-                        peerSession: receiveSession,
-                        receiveEpoch: receiveReplicationInfoReceiveEpoch,
-                        senderTransportSession: context.message.header.session,
-                        transportTimestamp: context.message.header.timestamp,
-                        message: msg,
-                    });
-                }
-                return;
-            }
-            // Same pre-lane gate shape as Added/All above (and the same
-            // intentional absence of a subscription-epoch term).
-            if (!this._instanceLifecycle.isMembershipActiveFor(receiveReplicationLifecycleController) ||
-                !this._peerSessions.isReceiveEpochCurrent(receiveFromHash, receiveReplicationInfoReceiveEpoch) ||
-                this._peerSessions.isReplicationInfoBlocked(fromHash)) {
-                return;
-            }
-            const messageTimestamp = context.message.header.timestamp;
-            peerReceiveLease.release();
-            await this.withReplicationInfoApplyQueue(fromHash, async () => {
-                if (!this._instanceLifecycle.isMembershipActiveFor(receiveReplicationLifecycleController) ||
-                    !this._peerSessions.isCurrent(fromHash, receiveSession) ||
-                    !this._peerSessions.isReceiveEpochCurrent(fromHash, receiveReplicationInfoReceiveEpoch) ||
-                    this._peerSessions.isReplicationInfoBlocked(fromHash)) {
-                    return;
-                }
-                if (receiveSession && this._v2Receive.isLegacyCutover(receiveSession)) {
-                    this._v2Receive.noteLegacyAnnouncement({
-                        peerHash: fromHash,
-                        peerSession: receiveSession,
-                        receiveEpoch: receiveReplicationInfoReceiveEpoch,
-                        senderTransportSession: context.message.header.session,
-                        transportTimestamp: context.message.header.timestamp,
-                        message: msg,
-                    });
-                    return;
-                }
-                const previousTimestamp = this.latestReplicationInfoMessage.get(fromHash);
-                if (previousTimestamp && previousTimestamp > messageTimestamp) {
-                    return;
-                }
-                this.latestReplicationInfoMessage.set(fromHash, messageTimestamp);
-                if (this.closed) {
-                    return;
-                }
-                const rangesToRemove = await this.resolveReplicationRangesFromIdsAndKey(segmentIds, from);
-                await this.removeReplicationRanges(rangesToRemove, from);
-                this._liveness.markReplicatorActivity(fromHash);
-                const timestamp = BigInt(+new Date());
-                for (const range of rangesToRemove) {
-                    this.replicationChangeDebounceFn.add({
-                        range,
-                        type: "removed",
-                        timestamp,
-                    });
-                }
-            });
-        }
         async calculateTotalParticipation(options) {
             if (options?.sum) {
                 const ranges = await this.replicationIndex.iterate().all();
@@ -14217,13 +13855,13 @@ let SharedLog = (() => {
                     // in one large message instead
                     announce: (msg) => {
                         throwIfInactive();
-                        if (msg instanceof AllReplicatingSegmentsMessage) {
+                        if (!("added" in msg)) {
                             throw new Error("Unexpected");
                         }
                         if (messageToSend) {
                             // merge segments to make it into one messages
-                            for (const segment of msg.segments) {
-                                messageToSend.segments.push(segment);
+                            for (const segment of msg.added.segments) {
+                                messageToSend.added.segments.push(segment);
                             }
                         }
                         else {
@@ -14332,36 +13970,21 @@ let SharedLog = (() => {
                     return;
                 }
                 requestAttempts++;
-                if (this.legacyReplicationInfoEnabled) {
-                    this.rpc
-                        .send(new RequestReplicationInfoMessage(), {
-                        mode: new AcknowledgeDelivery({ redundancy: 1, to: [key] }),
-                    })
-                        .catch((e) => {
-                        // Best-effort: missing peers / unopened RPC should not fail the wait logic.
-                        if (isNotStartedError(e)) {
-                            return;
-                        }
-                        logger.error(e?.toString?.() ?? String(e));
+                const peerHash = key.hashcode();
+                const peerSession = this._peerSessions.current(peerHash);
+                if (peerSession?.phase === "open") {
+                    this._v2Receive.resumeParkedRequest({
+                        peerHash,
+                        peerSession,
+                        receiveEpoch: this._peerSessions.receiveEpoch(peerHash),
                     });
                 }
-                else {
-                    const peerHash = key.hashcode();
-                    const peerSession = this._peerSessions.current(peerHash);
-                    if (peerSession?.phase === "open") {
-                        this._v2Receive.resumeParkedRequest({
-                            peerHash,
-                            peerSession,
-                            receiveEpoch: this._peerSessions.receiveEpoch(peerHash),
-                        });
-                    }
-                    else if (peerSession === null || peerSession.phase === "departing") {
-                        // A peer can be known to routing before its SharedLog topic
-                        // subscription has been observed. Legacy requests used to bootstrap
-                        // that case directly; V2 needs an authoritative Subscribe snapshot
-                        // before it can create a fenced PeerSession and request a Full.
-                        requestSubscriberSnapshot();
-                    }
+                else if (peerSession === null || peerSession.phase === "departing") {
+                    // A peer can be known to routing before its SharedLog topic
+                    // subscription has been observed. Legacy requests used to bootstrap
+                    // that case directly; V2 needs an authoritative Subscribe snapshot
+                    // before it can create a fenced PeerSession and request a Full.
+                    requestSubscriberSnapshot();
                 }
                 if (requestAttempts < maxRequestAttempts) {
                     requestTimer = setTimeout(requestReplicationInfo, requestIntervalMs);
@@ -16183,7 +15806,7 @@ let SharedLog = (() => {
          */
         resetReplicationInfoV2RecoveryEscalation(peerHash) {
             const state = this._replicationInfoRequestByPeer.get(peerHash);
-            if (!state || state.peerSession === undefined) {
+            if (!state) {
                 return;
             }
             state.attempts = 0;
@@ -16272,65 +15895,20 @@ let SharedLog = (() => {
             };
             tick();
         }
+        /**
+         * Collapsed B12 shell: the legacy request-polling body (bounded
+         * RequestReplicationInfoMessage ticks) is deleted; V2 recovery is the
+         * only scheduler. Retained as a named seam rather than inlined at the
+         * callers because the liveness monitor wiring and several suites
+         * stub/spy it by name.
+         */
         scheduleReplicationInfoRequests(peer, replicationLifecycleController = this._instanceLifecycle
             ?.membershipLifecycleController) {
             if (!replicationLifecycleController ||
                 !this.isReplicationLifecycleActive(replicationLifecycleController)) {
                 return;
             }
-            if (!this.legacyReplicationInfoEnabled) {
-                this.scheduleReplicationInfoV2Recovery(peer, replicationLifecycleController);
-                return;
-            }
-            const peerHash = peer.hashcode();
-            const requestStates = this._replicationInfoRequestByPeer;
-            if (requestStates.has(peerHash)) {
-                return;
-            }
-            const state = {
-                attempts: 0,
-            };
-            requestStates.set(peerHash, state);
-            const cancel = () => {
-                if (requestStates.get(peerHash) !== state) {
-                    return;
-                }
-                if (state.timer) {
-                    clearTimeout(state.timer);
-                }
-                requestStates.delete(peerHash);
-            };
-            const intervalMs = Math.max(50, this.waitForReplicatorRequestIntervalMs);
-            const maxAttempts = this.waitForReplicatorRequestMaxAttempts ??
-                Math.max(WAIT_FOR_REPLICATOR_REQUEST_MIN_ATTEMPTS, Math.ceil(this.waitForReplicatorTimeout / intervalMs));
-            const tick = () => {
-                if (!this.isReplicationLifecycleActive(replicationLifecycleController)) {
-                    cancel();
-                    return;
-                }
-                state.attempts++;
-                this.rpc
-                    .send(new RequestReplicationInfoMessage(), {
-                    mode: new AcknowledgeDelivery({ redundancy: 1, to: [peer] }),
-                    signal: replicationLifecycleController.signal,
-                })
-                    .catch((e) => {
-                    // Best-effort: missing peers / unopened RPC should not fail join flows.
-                    if (isNotStartedError(e) ||
-                        (replicationLifecycleController.signal.aborted &&
-                            e instanceof AbortError)) {
-                        return;
-                    }
-                    logger.error(e?.toString?.() ?? String(e));
-                });
-                if (state.attempts >= maxAttempts) {
-                    cancel();
-                    return;
-                }
-                state.timer = setTimeout(tick, intervalMs);
-                state.timer.unref?.();
-            };
-            tick();
+            this.scheduleReplicationInfoV2Recovery(peer, replicationLifecycleController);
         }
         async handleSubscriptionChange(publicKey, topics, subscribed, subscriptionEpoch, subscriptionTransportSession) {
             if (!topics.includes(this.topic)) {
@@ -16393,10 +15971,6 @@ let SharedLog = (() => {
                         !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) {
@@ -16439,11 +16013,6 @@ let SharedLog = (() => {
                 this._peerSessions.blockReplicationInfo(peerHash);
                 const disconnectedWarmupSession = this.joinWarmup._warmupSessionsByTarget.get(peerHash) ?? null;
                 this.joinWarmup.cancelJoinWarmupTarget(peerHash);
-                const now = BigInt(+new Date());
-                const previous = this.latestReplicationInfoMessage.get(peerHash);
-                if (!previous || previous < now) {
-                    this.latestReplicationInfoMessage.set(peerHash, now);
-                }
                 let removed = false;
                 try {
                     // Unsubscribe can race with the peer's final replication reset message.
@@ -16485,84 +16054,20 @@ let SharedLog = (() => {
             this.promoteReplicationInfoV2ReceiveCapability(publicKey, expectedSubscriptionEpoch);
             // Decode, sender and authenticated apply readiness are separate bits. An
             // ACKed capability advert is the local half of receiver-led negotiation;
-            // readiness is promoted only after the legacy startup path has completed.
-            // This preserves mixed-version discovery without putting capability ACK
-            // latency on the subscription callback's critical path.
+            // readiness is promoted through the coordinator once the ACK arrives.
+            // This keeps capability ACK latency off the subscription callback's
+            // critical path.
             const receiveEpoch = this._peerSessions.receiveEpoch(peerHash);
-            const localCapabilityAdvertisement = this._v2Receive.advertiseLocalCapability({
+            // B12: there is no legacy startup work to order ahead of RequestV2, so
+            // the two-phase legacy barrier is gone — an ACKed advert promotes
+            // readiness through the coordinator as soon as it lands.
+            this._v2Receive.advertiseLocalCapability({
                 target: publicKey,
                 peerSession: expectedSubscriptionEpoch,
                 receiveEpoch,
                 signal: replicationLifecycleController.signal,
             });
-            if (!this.legacyReplicationInfoEnabled) {
-                // Current logs have no legacy startup work to order ahead of RequestV2.
-                // Releasing is synchronous and exact-session fenced; the ACK may still
-                // arrive later and promote readiness through the coordinator.
-                localCapabilityAdvertisement.releaseLegacyBarrier();
-                this.scheduleReplicationInfoV2Recovery(publicKey, replicationLifecycleController);
-                return;
-            }
-            try {
-                let replicationSegments;
-                try {
-                    replicationSegments = await this.getMyReplicationSegments();
-                }
-                catch (error) {
-                    if (!this.isReplicationLifecycleActive(replicationLifecycleController) &&
-                        isNotStartedError(error)) {
-                        return;
-                    }
-                    throw error;
-                }
-                if (!this.isReplicationLifecycleActive(replicationLifecycleController) ||
-                    !ownsSubscriptionEpoch()) {
-                    return;
-                }
-                if (replicationSegments.length > 0) {
-                    const segments = replicationSegments.map((x) => x.toReplicationRange());
-                    this.validatePersistedReplicationRangeSnapshot(segments);
-                    await this.rpc
-                        .send(new AllReplicatingSegmentsMessage({
-                        segments,
-                    }), {
-                        mode: new AcknowledgeDelivery({
-                            redundancy: 1,
-                            to: [publicKey],
-                        }),
-                        signal: replicationLifecycleController.signal,
-                    })
-                        .catch((error) => this.handleReplicationLifecycleSendError(error, replicationLifecycleController));
-                    if (!this.isReplicationLifecycleActive(replicationLifecycleController) ||
-                        !ownsSubscriptionEpoch()) {
-                        return;
-                    }
-                    if (this.v8Behaviour) {
-                        // for backwards compatibility
-                        await this.rpc
-                            .send(new ResponseRoleMessage({
-                            role: this.getRoleFromReplicationSegments(replicationSegments),
-                        }), {
-                            mode: new AcknowledgeDelivery({
-                                redundancy: 1,
-                                to: [publicKey],
-                            }),
-                            signal: replicationLifecycleController.signal,
-                        })
-                            .catch((error) => this.handleReplicationLifecycleSendError(error, replicationLifecycleController));
-                    }
-                }
-                // Keep legacy request-based discovery independent of the capability ACK.
-                // This makes mixed-version joins resilient to timing-sensitive delivery/order
-                // issues where we may miss the remote peer's initial announcement.
-                if (this.isReplicationLifecycleActive(replicationLifecycleController) &&
-                    ownsSubscriptionEpoch()) {
-                    this.scheduleReplicationInfoRequests(publicKey, replicationLifecycleController);
-                }
-            }
-            finally {
-                localCapabilityAdvertisement.releaseLegacyBarrier();
-            }
+            this.scheduleReplicationInfoV2Recovery(publicKey, replicationLifecycleController);
         }
         getClampedReplicas(customValue) {
             if (!customValue) {
@@ -17538,14 +17043,6 @@ let SharedLog = (() => {
             const subscriptionEpoch = this._peerSessions.rotate(fromHash, "departing");
             this._peerSessions.blockReplicationInfo(fromHash);
             this._recentRepairDispatch.delete(fromHash);
-            // Keep a per-peer timestamp watermark when we observe an unsubscribe. This
-            // prevents late/out-of-order replication-info messages from re-introducing
-            // stale segments for a peer that has already left the topic.
-            const now = BigInt(+new Date());
-            const prev = this.latestReplicationInfoMessage.get(fromHash);
-            if (!prev || prev < now) {
-                this.latestReplicationInfoMessage.set(fromHash, now);
-            }
             this.invalidateSharedLogTopicSubscribersCache();
             return this.handleSubscriptionChange(evt.detail.from, evt.detail.topics, false, subscriptionEpoch);
         }
@@ -17661,22 +17158,13 @@ let SharedLog = (() => {
                         if (!canReplicate) {
                             return false;
                         }
-                        try {
-                            await this.startAnnounceReplicating([dynamicRange], {
-                                checkDuplicates: false,
-                                reset: false,
-                                shouldApply: isCurrent,
-                            }, ownershipLifecycleController);
-                            if (!isCurrent())
-                                return false;
-                        }
-                        catch (error) {
-                            if (isTransientReplicationAnnouncementError(error) &&
-                                this._announcements._replicationAnnouncementRetryPending) {
-                                return false;
-                            }
-                            throw error;
-                        }
+                        await this.startAnnounceReplicating([dynamicRange], {
+                            checkDuplicates: false,
+                            reset: false,
+                            shouldApply: isCurrent,
+                        }, ownershipLifecycleController);
+                        if (!isCurrent())
+                            return false;
                         /* await this._updateRole(newRole, onRoleChange); */
                         if (isCurrent()) {
                             void rebalanceParticipationDebounced?.call();