@peerbit/shared-log 15.0.0 → 16.0.1

package/src/index.ts

@@ -231,10 +231,7 @@ import {
 	shouldAssigneToRangeBoundary as shouldAssignToRangeBoundary,
 	toRebalance,
 } from "./ranges.js";
-import {
-	ReplicationAnnouncementCoordinator,
-	isTransientReplicationAnnouncementError,
-} from "./replication-announcement.js";
+import { ReplicationAnnouncementCoordinator } from "./replication-announcement.js";
 import {
 	type ReplicationDomainHash,
 	createReplicationDomainHash,
@@ -277,7 +274,6 @@ import {
 	maxReplicas,
 } from "./replication.js";
 import { ReplicatorLivenessMonitor } from "./replicator-liveness.js";
-import { Observer, Replicator } from "./role.js";
 import { createSyncronizer } from "./sync/factory.js";
 import type {
 	SharedLogNativeWireSync,
@@ -2021,7 +2017,6 @@ export class SharedLog<
 
 	uniqueReplicators!: Set<string>;
 	private _replicatorJoinEmitted!: Set<string>;
-	private _replicatorsReconciled!: boolean;
 
 	/* private _totalParticipation!: number; */
 
@@ -2078,34 +2073,26 @@ export class SharedLog<
 	// public key hash to range id to range
 	pendingMaturity!: Map<string, Map<string, PendingMaturityRecord<R>>>; // 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.
-	private latestReplicationInfoMessage!: Map<string, bigint>;
+	// 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).
 	private _replicationInfoRequestByPeer!: Map<
 		string,
 		{
-			// Legacy scheduler: sends issued (bounded by maxAttempts). V2 recovery
-			// scheduler: consecutive fruitless unparks — the escalation exponent
-			// for the next unpark delay, reset on any applied V2 progress.
+			// Consecutive fruitless unparks — the escalation exponent for the
+			// next unpark delay, reset on any applied V2 progress.
 			attempts: number;
 			timer?: ReturnType<typeof setTimeout>;
-			peerSession?: PeerSession;
-			// V2 recovery scheduler only: when the current park was first observed.
+			peerSession: PeerSession;
+			// When the current park was first observed.
 			parkedSinceMs?: number;
 		}
 	>;
@@ -2266,7 +2253,6 @@ export class 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);
@@ -3268,7 +3254,7 @@ export class SharedLog<
 	private rebalanceParticipationDebounced:
 		| ReturnType<typeof debounceFixedInterval>
 		| undefined;
-	private _announcements!: ReplicationAnnouncementCoordinator<R>;
+	private _announcements!: ReplicationAnnouncementCoordinator;
 	private _v2Receive!: ReplicationInfoV2ReceiveCoordinator;
 	private _v2Send!: ReplicationInfoV2SendCoordinator<R>;
 
@@ -3396,37 +3382,13 @@ export class SharedLog<
 		});
 	}
 
-	private createReplicationAnnouncementCoordinator(): ReplicationAnnouncementCoordinator<R> {
-		return new ReplicationAnnouncementCoordinator<R>({
-			// 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: unknown) =>
-				this._announcements.queueCurrentReplicationStateAnnouncementRetry(
-					error,
-				),
+	private createReplicationAnnouncementCoordinator(): ReplicationAnnouncementCoordinator {
+		return new ReplicationAnnouncementCoordinator({
 			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(),
 		});
 	}
 
@@ -3653,7 +3615,6 @@ export class 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();
@@ -3696,7 +3657,6 @@ export class SharedLog<
 		this.recentlyRebalanced = new Cache<string>({ max: 1e4, ttl: 1e5 });
 		this.uniqueReplicators = new Set();
 		this._replicatorJoinEmitted = new Set();
-		this._replicatorsReconciled = false;
 		this._liveness = this.createReplicatorLivenessMonitor();
 		this._v2Receive = this.createReplicationInfoV2ReceiveCoordinator();
 		this._v2Send = this.createReplicationInfoV2SendCoordinator();
@@ -3764,29 +3724,10 @@ export class SharedLog<
 		this._nativeStrictDurableTransactionsClosing ??= false;
 	}
 
-	get compatibility(): number | undefined {
-		// 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 as any)?.compatibility;
-	}
-
-	/**
-	 * Legacy replication-info is an explicit compatibility fallback. Current
-	 * logs never infer or re-enable it from a remote peer's capabilities.
-	 */
-	private get legacyReplicationInfoEnabled(): boolean {
-		return this.compatibility !== undefined && this.compatibility < 10;
-	}
-
 	get isAdaptiveReplicating() {
 		return this._isAdaptiveReplicating;
 	}
 
-	private get v8Behaviour() {
-		return (this.compatibility ?? Number.MAX_VALUE) < 9;
-	}
-
 	private getFanoutChannelOptions(
 		options?: SharedLogFanoutOptions,
 	): Omit<FanoutTreeChannelOptions, "role"> {
@@ -4691,8 +4632,7 @@ export class SharedLog<
 			(leaders.size === 0 || (leaders.size === 1 && leaders.has(selfHash)))
 		) {
 			const allowSubscriberFallback =
-				this.syncronizer instanceof SimpleSyncronizer ||
-				(this.compatibility ?? Number.MAX_VALUE) < 10;
+				this.syncronizer instanceof SimpleSyncronizer;
 			if (!allowSubscriberFallback) {
 				return;
 			}
@@ -4841,8 +4781,7 @@ export class SharedLog<
 			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;
+				this.syncronizer instanceof SimpleSyncronizer;
 			if (!hasRemotePeers && allowSubscriberFallback) {
 				try {
 					const subscribers = await this._getTopicSubscribers(this.topic);
@@ -5305,28 +5244,6 @@ export class SharedLog<
 		};
 	}
 
-	// @deprecated
-	private getRoleFromReplicationSegments(
-		segments: ReplicationRangeIndexable<R>[],
-	) {
-		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 as number) / MAX_U32,
-				offset: (segment.offset as number) / MAX_U32,
-			});
-		}
-
-		// TODO this is not accurate but might be good enough
-		return new Observer();
-	}
-
 	private isTerminating() {
 		return (
 			this.acceptsParentAttachments === false ||
@@ -5604,12 +5521,7 @@ export class SharedLog<
 	}
 
 	private onRebalanceParticipationError(error: Error): void {
-		if (
-			this.closed ||
-			isNotStartedError(error) ||
-			(isTransientReplicationAnnouncementError(error) &&
-				this._announcements._replicationAnnouncementRetryPending)
-		) {
+		if (this.closed || isNotStartedError(error)) {
 			return;
 		}
 
@@ -6865,7 +6777,7 @@ export class SharedLog<
 			rebalance?: boolean;
 			checkDuplicates?: boolean;
 			timestamp?: number;
-			allowLegacyOrderedReplacementPairs?: boolean;
+			allowOrderedReplacementPairs?: boolean;
 			onConfirmedDurableStateChanged?: () => void;
 			onDurableApplyCommitted?: () => boolean | void;
 			shouldApply?: () => boolean;
@@ -6907,7 +6819,7 @@ export class SharedLog<
 			checkDuplicates,
 			timestamp: ts,
 			rebalance,
-			allowLegacyOrderedReplacementPairs,
+			allowOrderedReplacementPairs,
 			onConfirmedDurableStateChanged,
 			onDurableApplyCommitted,
 			shouldApply,
@@ -6916,7 +6828,7 @@ export class SharedLog<
 			rebalance?: boolean;
 			checkDuplicates?: boolean;
 			timestamp?: number;
-			allowLegacyOrderedReplacementPairs?: boolean;
+			allowOrderedReplacementPairs?: boolean;
 			onConfirmedDurableStateChanged?: () => void;
 			onDurableApplyCommitted?: () => boolean | void;
 			shouldApply?: () => boolean;
@@ -6955,17 +6867,19 @@ export class SharedLog<
 			incomingRangeCountsById.set(range.idString, count);
 			if (
 				count > 1 &&
-				(!allowLegacyOrderedReplacementPairs || reset === true || count > 2)
+				(!allowOrderedReplacementPairs || reset === true || count > 2)
 			) {
 				throw new Error(
 					`Duplicate replication range id in announcement: ${range.idString}`,
 				);
 			}
-			// Released peers represented a non-reset replacement as the retired
-			// geometry followed by the current geometry under the same id. The
-			// sender is already authorized to replace that id with the final item,
-			// so collapsing an exact two-item incremental pair to its last item
-			// preserves rolling-upgrade compatibility without broadening authority.
+			// Rolling-upgrade relaxation on the live V2 Added path: a peer may
+			// still express a non-reset replacement as the retired geometry
+			// followed by the current geometry under one id. The sender is already
+			// authorized to replace that id with the final item, so collapsing an
+			// EXACT two-item incremental pair to its last item accepts the older
+			// wire shape without broadening authority. Deliberately narrow — reset
+			// announcements and any run longer than two still fail as duplicates.
 			incomingRangesById.set(range.idString, range);
 		}
 		const incomingRanges = [...incomingRangesById.values()];
@@ -14247,12 +14161,7 @@ export class SharedLog<
 
 		this.domain = options?.domain
 			? (options.domain(this) as unknown as D)
-			: (createReplicationDomainHash(
-					(options as any)?.compatibility !== undefined &&
-						(options as any).compatibility < 10
-						? "u32"
-						: "u64",
-				)(this) as unknown as D);
+			: (createReplicationDomainHash("u64")(this) as unknown as D);
 		this.indexableDomain = createIndexableDomainFromResolution(
 			this.domain.resolution,
 		);
@@ -14262,7 +14171,6 @@ export class 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
@@ -14327,7 +14235,6 @@ export class SharedLog<
 
 		this.uniqueReplicators = new Set();
 		this._replicatorJoinEmitted = new Set();
-		this._replicatorsReconciled = false;
 		// Deserialized instances never ran the constructor; create the monitor and
 		// coordinator lazily on first open. Reopens keep the SAME instances so
 		// stale async continuations observe resets via property lookup.
@@ -14335,7 +14242,6 @@ export class 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();
@@ -14398,12 +14304,6 @@ export class SharedLog<
 		}
 
 		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) clearTimeout(state.timer);
@@ -14859,7 +14759,6 @@ export class SharedLog<
 				sendOptions?: { priority?: number; signal?: AbortSignal },
 			) => this.trySendFusedRawExchangeHeads(hashes, to, sendOptions),
 			warn,
-			compatibility: (this._logProperties as any)?.compatibility,
 			resolution: this.domain.resolution,
 			sync: options?.sync,
 			syncronizer: options?.syncronizer,
@@ -15613,16 +15512,8 @@ export class SharedLog<
 		const existingSubscribersPromise = this.node.services.pubsub.getSubscribers(
 			this.topic,
 		);
-		const replicationLifecycleController =
-			this._instanceLifecycle?.membershipLifecycleController;
-
 		// We do this here, because these calls requires this.closed == false
 		void this.pruneOfflineReplicators()
-			.then(() => {
-				if (this.isReplicationLifecycleActive(replicationLifecycleController)) {
-					this._replicatorsReconciled = true;
-				}
-			})
 			.catch((error) => {
 				if (isNotStartedError(error as Error)) {
 					return;
@@ -15863,7 +15754,7 @@ export class SharedLog<
 		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);
@@ -15895,11 +15786,8 @@ export class SharedLog<
 
 	private advanceReplicationInfoRecoveryEpoch(peerHash: string) {
 		// 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({
@@ -16788,15 +16676,6 @@ export class 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);
@@ -16890,7 +16769,6 @@ export class SharedLog<
 		captureSync(() => {
 			this._pendingIHave?.clear();
 			this._pendingIHaveCallbacks?.clear();
-			this.latestReplicationInfoMessage?.clear();
 			this._peerSessions?.clearReceiveEpochsForClose();
 			this._peerSessions?.clearCleanupGatesForClose();
 			this._activeReceiveHandlersByPeer?.clear();
@@ -16991,7 +16869,6 @@ export class SharedLog<
 			await pruneRemoveTerminalFence.drained;
 			await this.drainPendingIHaveCallbacks();
 			this.ensureNativeDurabilityRuntimeState();
-			this._announcements.cancelCurrentReplicationStateAnnouncementRetry();
 		} catch (error) {
 			// The terminal preamble has already disabled parent attachments and the
 			// network lifecycle. Keep mutation admission fenced for an exact retry.
@@ -17035,19 +16912,7 @@ export class 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);
 				}
@@ -17140,7 +17005,6 @@ export class 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
 			// a retry finishes cleanup.
@@ -17168,19 +17032,7 @@ export class 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);
 				}
@@ -17707,16 +17559,16 @@ export class SharedLog<
 				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)
+				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.
+				// 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
@@ -17757,22 +17609,14 @@ export class SharedLog<
 				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 ||
 				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);
@@ -17780,10 +17624,7 @@ export class SharedLog<
 			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);
 			}
@@ -19498,23 +19339,6 @@ export class 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");
 				}
@@ -19743,113 +19567,6 @@ export class SharedLog<
 		}
 	}
 
-	private async handleRequestReplicationInfo(
-		_msg: RequestReplicationInfoMessage,
-		context: ReceiveRequestContext,
-		lane: ReceiveLaneContext,
-	): Promise<void> {
-		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: ReplicationRangeIndexable<R>[];
-		try {
-			replicationSegments = await this.getMyReplicationSegments();
-		} catch (error) {
-			if (
-				!this._peerSessions.isReceiveAdmissionOpen(
-					receiveFromHash,
-					receiveSession,
-					replicationLifecycleController,
-				) &&
-				isNotStartedError(error as 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,
-							),
-						);
-				}
-			}
-		}
-	}
-
 	private async handleReplicationInfoV2Announcement(
 		msg: ReplicationInfoV2Message,
 		context: ReceiveRequestContext,
@@ -19926,7 +19643,7 @@ export class SharedLog<
 								reset: msg instanceof FullReplicationInfoV2Message,
 								checkDuplicates: true,
 								timestamp: Number(context.message.header.timestamp),
-								allowLegacyOrderedReplacementPairs:
+								allowOrderedReplacementPairs:
 									msg instanceof AddedReplicationInfoV2Message,
 								shouldApply: () => {
 									mutationGateChecked = true;
@@ -20029,252 +19746,12 @@ export class 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);
 		}
 	}
 
-	private async handleReplicationInfoAnnouncement(
-		msg: AllReplicatingSegmentsMessage | AddedReplicationSegmentMessage,
-		context: ReceiveRequestContext,
-		lane: ReceiveLaneContext,
-	): Promise<void> {
-		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 as
-			| AllReplicatingSegmentsMessage
-			| AddedReplicationSegmentMessage;
-
-		// 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 as Error)) {
-					return;
-				}
-				logger.error(
-					`Failed to apply replication settings from '${fromHash}': ${
-						(e as any)?.message ?? e
-					}`,
-				);
-			}
-		});
-	}
-
-	private async handleStoppedReplicating(
-		msg: StoppedReplicating,
-		context: ReceiveRequestContext,
-		lane: ReceiveLaneContext,
-	): Promise<void> {
-		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?: { sum?: boolean }) {
 		if (options?.sum) {
 			const ranges = await this.replicationIndex.iterate().all();
@@ -20736,34 +20213,20 @@ export class SharedLog<
 
 			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 as Error)) {
-							return;
-						}
-						logger.error(e?.toString?.() ?? String(e));
-					});
-			} else {
-				const peerHash = key.hashcode();
-				const peerSession = this._peerSessions.current(peerHash);
-				if (peerSession?.phase === "open") {
-					this._v2Receive.resumeParkedRequest({
-						peerHash,
-						peerSession,
-						receiveEpoch: this._peerSessions.receiveEpoch(peerHash),
-					});
-				} 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();
-				}
+			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();
 			}
 
 			if (requestAttempts < maxRequestAttempts) {
@@ -23507,7 +22970,7 @@ export class SharedLog<
 	 */
 	private resetReplicationInfoV2RecoveryEscalation(peerHash: string) {
 		const state = this._replicationInfoRequestByPeer.get(peerHash);
-		if (!state || state.peerSession === undefined) {
+		if (!state) {
 			return;
 		}
 		state.attempts = 0;
@@ -23590,7 +23053,11 @@ export class SharedLog<
 			}
 			const receiveEpoch = this._peerSessions.receiveEpoch(peerHash);
 			if (
-				!this._v2Receive.isRequestParked({ peerHash, peerSession, receiveEpoch })
+				!this._v2Receive.isRequestParked({
+					peerHash,
+					peerSession,
+					receiveEpoch,
+				})
 			) {
 				// Active, or a bounded request cycle is still running its own
 				// exponential retries. Keep polling for the next park.
@@ -23624,6 +23091,13 @@ export class 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.
+	 */
 	private scheduleReplicationInfoRequests(
 		peer: PublicSignKey,
 		replicationLifecycleController = this._instanceLifecycle
@@ -23635,75 +23109,10 @@ export class SharedLog<
 		) {
 			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: number; timer?: ReturnType<typeof setTimeout> } = {
-			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 as Error) ||
-						(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(
@@ -23786,10 +23195,6 @@ export class SharedLog<
 				) {
 					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);
@@ -23843,12 +23248,6 @@ export class SharedLog<
 				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.
@@ -23899,116 +23298,23 @@ export class SharedLog<
 
 		// 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({
-				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: ReplicationRangeIndexable<R>[];
-			try {
-				replicationSegments = await this.getMyReplicationSegments();
-			} catch (error) {
-				if (
-					!this.isReplicationLifecycleActive(replicationLifecycleController) &&
-					isNotStartedError(error as 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();
-		}
+		// 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,
+		});
+		this.scheduleReplicationInfoV2Recovery(
+			publicKey,
+			replicationLifecycleController,
+		);
 	}
 
 	private getClampedReplicas(customValue?: MinReplicas) {
@@ -25409,15 +24715,6 @@ export class 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(
@@ -25581,26 +24878,16 @@ export class SharedLog<
 						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()) {