@peerbit/shared-log 13.2.32 → 13.2.33

package/dist/src/index.js

@@ -51,27 +51,28 @@ import PQueue from "p-queue";
 import { concat, fromString } from "uint8arrays";
 import { BlocksMessage } from "./blocks.js";
 import { CheckedPruneCoordinator, } from "./checked-prune.js";
+import { CoordinatePersistenceCoordinator, combineCoordinateDeleteHashes, isPromiseLike, mapMaybePromise, normalizedHashValues, } from "./coordinate-persistence.js";
 import { CPUUsageIntervalLag } from "./cpu.js";
 import { debouncedAccumulatorMap, } from "./debounce.js";
 import { NativeDurableCommitError, NoPeersError, isNotStartedError, } from "./errors.js";
 import { EXCHANGE_HEADS_REPAIR_HINT, EntryWithRefs, ExchangeHeadsMessage, MAX_RAW_EXCHANGE_MESSAGE_SIZE, RawEntryWithRefs, RawExchangeHeadsMessage, RequestIPrune, RequestIPruneV2, ResponseIPrune, ResponseIPruneV2, SYNC_CAPABILITY_RAW_EXCHANGE_HEADS, SYNC_CAPABILITY_REPLICATION_INFO_V2_APPLY, SYNC_CAPABILITY_REPLICATION_INFO_V2_DECODE, SYNC_CAPABILITY_REPLICATION_INFO_V2_SEND, StashBackedRawExchangeHeadsMessage, SyncCapabilitiesMessage, collectRawExchangeHeadSendPlan, createExchangeHeadsMessages, createRawExchangeHeadsMessages, getExchangeHeadHash, getPreparedRawExchangeGid, getPreparedRawExchangeHashNumber, getPreparedRawExchangeHeadAppendFacts, getPreparedRawExchangeHeadGid, getPreparedRawExchangeHeadRequestedReplicas, getPreparedRawExchangeHeadShallowEntry, getPreparedRawExchangeHeadSignatureVerified, getPreparedRawExchangeNext, getPreparedRawExchangeRequestedReplicas, getPreparedRawExchangeTimestamp, getRawExchangeHeadByteLength, getRawExchangeHeadStashIndexes, initExchangeHeadEntry, isPreparedRawEntryWithRefs, isStashBackedRawExchangeHeadsMessage, materializeVerifiedRawExchangeHeadsMessage, } from "./exchange-heads.js";
 import { FanoutEnvelope } from "./fanout-envelope.js";
-import { CoordinatePersistenceCoordinator, combineCoordinateDeleteHashes, isPromiseLike, mapMaybePromise, normalizedHashValues, } from "./coordinate-persistence.js";
 import { InstanceLifecycle } from "./instance-lifecycle.js";
 import { MAX_U32, MAX_U64, createNumbers, } from "./integers.js";
 import { JoinWarmupCoordinator } from "./join-warmup.js";
 import { LeaderPlanCache } from "./leader-plan-cache.js";
 import { TransportMessage } from "./message.js";
 import { NativeBackboneWriteThroughBlockStore } from "./native-write-through-block-store.js";
-import { PeerSessionRegistry, } from "./peer-session.js";
+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 { ReplicationInfoV2SendCoordinator } from "./replication-info-v2-send.js";
 import { createReplicationDomainHash, } from "./replication-domain-hash.js";
 import { createReplicationDomainTime, } from "./replication-domain-time.js";
 import {} from "./replication-domain.js";
-import { AbsoluteReplicas, AddedReplicationSegmentMessage, AllReplicatingSegmentsMessage, MinReplicas, ReplicationError, ReplicationPingMessage, RequestReplicationInfoMessage, RequestReplicationInfoV2Message, ResponseRoleMessage, StoppedReplicating, decodeReplicas, encodeReplicas, isReplicationInfoV2Message, maxReplicas, } from "./replication.js";
+import { ReplicationInfoV2ReceiveCoordinator } from "./replication-info-v2-receive.js";
+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";
@@ -625,7 +626,8 @@ let SharedLog = (() => {
                 value;
         }
         get _nativeBackboneCoordinateJournalLastFlushMs() {
-            return this._coordinates?._nativeBackboneCoordinateJournalLastFlushMs;
+            return this._coordinates
+                ?._nativeBackboneCoordinateJournalLastFlushMs;
         }
         set _nativeBackboneCoordinateJournalLastFlushMs(value) {
             (this._coordinates ??=
@@ -1498,7 +1500,8 @@ let SharedLog = (() => {
             }
             if (!lowerMarkerCommitted) {
                 if (intent.coordinates.length > 0) {
-                    const mutationGenerations = (this._coordinates._nativeCoordinateMutationGenerations ??= new Map());
+                    const mutationGenerations = (this._coordinates._nativeCoordinateMutationGenerations ??=
+                        new Map());
                     const rollback = {
                         hashes: new Set(),
                         entries: new Map(),
@@ -1609,6 +1612,7 @@ let SharedLog = (() => {
         // A fn that we can call many times that recalculates the participation role
         rebalanceParticipationDebounced;
         _announcements;
+        _v2Receive;
         _v2Send;
         // A fn for debouncing the calls for pruning
         pruneDebouncedFn;
@@ -1727,6 +1731,78 @@ let SharedLog = (() => {
                 isReplicationOwnershipLifecycleActive: (controller) => this.isRepairLifecycleActive(controller),
             });
         }
+        replicationInfoV2ReceiveCapabilities() {
+            return (SYNC_CAPABILITY_REPLICATION_INFO_V2_DECODE |
+                SYNC_CAPABILITY_REPLICATION_INFO_V2_SEND |
+                SYNC_CAPABILITY_REPLICATION_INFO_V2_APPLY |
+                (this._logProperties?.sync?.rawExchangeHeads === true
+                    ? SYNC_CAPABILITY_RAW_EXCHANGE_HEADS
+                    : 0));
+        }
+        async advertiseReplicationInfoV2ReceiveCapability(properties) {
+            const peerHash = properties.target.hashcode();
+            const receiverTransportSession = BigInt(this.node.services.pubsub.session);
+            await this.rpc.send(new SyncCapabilitiesMessage({
+                capabilities: this.replicationInfoV2ReceiveCapabilities(),
+            }), {
+                mode: new AcknowledgeDelivery({
+                    redundancy: 1,
+                    to: [properties.target],
+                }),
+                priority: CONVERGENCE_MESSAGE_PRIORITY,
+                signal: properties.signal,
+            });
+            if (properties.signal.aborted ||
+                this.closed ||
+                !this._peerSessions.isCurrent(peerHash, properties.peerSession) ||
+                properties.peerSession.phase !== "open" ||
+                !properties.peerSession.isActive() ||
+                !this._peerSessions.isReceiveEpochCurrent(peerHash, properties.receiveEpoch) ||
+                this._peerSessions.isReplicationInfoBlocked(peerHash) ||
+                !this._peerSessions.isReceiveCleanupGateOpen(peerHash) ||
+                BigInt(this.node.services.pubsub.session) !== receiverTransportSession) {
+                return undefined;
+            }
+            return {
+                receiverTransportSession,
+                requestNotBeforeMs: Date.now(),
+            };
+        }
+        createReplicationInfoV2ReceiveCoordinator() {
+            return new ReplicationInfoV2ReceiveCoordinator({
+                getSelfKey: () => this.node.identity.publicKey,
+                getReceiverTransportSession: () => BigInt(this.node.services.pubsub.session),
+                isClosed: () => this.closed,
+                isPeerStateCurrent: (peerHash, peerSession, receiveEpoch) => this._peerSessions.isCurrent(peerHash, peerSession) &&
+                    peerSession.phase === "open" &&
+                    peerSession.isActive() &&
+                    this._peerSessions.isReceiveEpochCurrent(peerHash, receiveEpoch) &&
+                    !this._peerSessions.isReplicationInfoBlocked(peerHash) &&
+                    this._peerSessions.isReceiveCleanupGateOpen(peerHash),
+                isSenderTransportSessionCurrent: (peerHash, senderTransportSession) => this._peerSyncCapabilitySessions.get(peerHash) ===
+                    senderTransportSession,
+                sendRequest: async (request, target, signal) => {
+                    await this.rpc.send(request, {
+                        mode: new AcknowledgeDelivery({ redundancy: 1, to: [target] }),
+                        priority: CONVERGENCE_MESSAGE_PRIORITY,
+                        signal,
+                    });
+                },
+                refreshLocalCapability: (properties) => this.advertiseReplicationInfoV2ReceiveCapability({
+                    target: properties.target,
+                    peerSession: properties.peerSession,
+                    receiveEpoch: properties.receiveEpoch,
+                    signal: properties.signal,
+                }),
+                onRequestError: (error) => {
+                    if (isNotStartedError(error) ||
+                        (this.closed && error instanceof AbortError)) {
+                        return;
+                    }
+                    logger.trace(`Replication-info V2 recovery request failed: ${error?.message ?? String(error)}`);
+                },
+            });
+        }
         createReplicatorLivenessMonitor() {
             return new ReplicatorLivenessMonitor({
                 // Sweep-driven probes and activity marks dispatch through the owner so
@@ -1831,6 +1907,7 @@ let SharedLog = (() => {
             this._replicatorJoinEmitted = new Set();
             this._replicatorsReconciled = false;
             this._liveness = this.createReplicatorLivenessMonitor();
+            this._v2Receive = this.createReplicationInfoV2ReceiveCoordinator();
             this._v2Send = this.createReplicationInfoV2SendCoordinator();
             this._announcements = this.createReplicationAnnouncementCoordinator();
             this.pendingMaturity = new Map();
@@ -2226,11 +2303,20 @@ let SharedLog = (() => {
             const { peerHash, capabilities, transportSession, timestamp, openingSession, } = properties;
             if (openingSession) {
                 const previous = this._openingSyncCapabilitiesByPeer.get(peerHash);
+                if (transportSession !== undefined &&
+                    timestamp !== undefined &&
+                    previous?.epoch === openingSession &&
+                    previous.timestamp !== undefined &&
+                    previous.transportSession !== transportSession &&
+                    timestamp <= previous.timestamp) {
+                    return false;
+                }
                 if (transportSession !== undefined &&
                     timestamp !== undefined &&
                     previous?.epoch === openingSession &&
                     previous.transportSession === transportSession) {
-                    if (previous.timestamp !== undefined && timestamp < previous.timestamp) {
+                    if (previous.timestamp !== undefined &&
+                        timestamp < previous.timestamp) {
                         return false;
                     }
                     this._openingSyncCapabilitiesByPeer.set(peerHash, {
@@ -2258,24 +2344,26 @@ let SharedLog = (() => {
                 this._peerSyncCapabilitySessions.delete(peerHash);
                 this._peerSyncCapabilityTimestamps.delete(peerHash);
                 this._v2Send.advancePeerCapability(peerHash);
+                this._v2Receive.revokePeerCapability(peerHash);
                 return true;
             }
             const previousSession = this._peerSyncCapabilitySessions.get(peerHash);
             const previousTimestamp = this._peerSyncCapabilityTimestamps.get(peerHash);
             const sameTransportSession = previousSession === transportSession;
-            if (sameTransportSession &&
-                previousTimestamp !== undefined &&
-                timestamp < previousTimestamp) {
+            if (previousTimestamp !== undefined &&
+                ((sameTransportSession && timestamp < previousTimestamp) ||
+                    (!sameTransportSession && timestamp <= previousTimestamp))) {
                 return false;
             }
             const previousCapabilities = this._peerSyncCapabilities.get(peerHash) ?? 0;
             const nextCapabilities = sameTransportSession
                 ? previousCapabilities | capabilities
                 : capabilities;
+            const senderGrantCapabilityMask = SYNC_CAPABILITY_REPLICATION_INFO_V2_DECODE |
+                SYNC_CAPABILITY_REPLICATION_INFO_V2_APPLY;
             const generationAdvanced = !sameTransportSession ||
-                previousTimestamp === undefined ||
-                timestamp > previousTimestamp ||
-                nextCapabilities !== previousCapabilities;
+                (previousCapabilities & senderGrantCapabilityMask) !==
+                    (nextCapabilities & senderGrantCapabilityMask);
             this._peerSyncCapabilities.set(peerHash, nextCapabilities);
             this._peerSyncCapabilitySessions.set(peerHash, transportSession);
             this._peerSyncCapabilityTimestamps.set(peerHash, previousTimestamp === undefined ||
@@ -2288,6 +2376,24 @@ let SharedLog = (() => {
             }
             return true;
         }
+        promoteReplicationInfoV2ReceiveCapability(target, peerSession) {
+            const peerHash = target.hashcode();
+            const senderTransportSession = this._peerSyncCapabilitySessions.get(peerHash);
+            const capabilityTimestamp = this._peerSyncCapabilityTimestamps.get(peerHash);
+            if (senderTransportSession === undefined ||
+                capabilityTimestamp === undefined) {
+                return false;
+            }
+            return this._v2Receive.observeCapability({
+                peerHash,
+                target,
+                peerSession,
+                receiveEpoch: this._peerSessions.receiveEpoch(peerHash),
+                capabilities: this._peerSyncCapabilities.get(peerHash) ?? 0,
+                senderTransportSession,
+                capabilityTimestamp,
+            });
+        }
         /**
          * Live append gossip may use the raw exchange-heads path only when we
          * opted into raw sync and every remote recipient advertised raw capability
@@ -2984,7 +3090,8 @@ let SharedLog = (() => {
             return undefined;
         }
         isReceiveOwnershipSnapshotStable(revision) {
-            return ((this._instanceLifecycle?._receiveOwnershipMutationAdmissions ?? 0) === 0 &&
+            return ((this._instanceLifecycle?._receiveOwnershipMutationAdmissions ?? 0) ===
+                0 &&
                 (this._instanceLifecycle?._receiveOwnershipRevision ?? 0) === revision);
         }
         canCacheLeaderSelectionContext(options) {
@@ -3771,6 +3878,7 @@ let SharedLog = (() => {
             };
             let removed = false;
             let removalCallCompleted = false;
+            let replicationInfoRecoveryEpochAdvanced = false;
             // Replication-info updates already serialize per peer. Put the hash-wide
             // removal on the same queue so a newer reset cannot be deleted underneath
             // itself by an older unsubscribe callback.
@@ -3840,6 +3948,13 @@ let SharedLog = (() => {
                             // before mutating ownership.
                             this.cleanupCheckedPrunePeer(keyHash, replicationOwnershipLifecycleController, checkedPruneCoordinator);
                         }
+                        if (!isMe) {
+                            // This is the last synchronous current-generation boundary
+                            // before destructive work. Fence parked receives now because
+                            // the coherent delete can durably mutate and then fail or poison.
+                            this.advanceReplicationInfoRecoveryEpoch(keyHash);
+                            replicationInfoRecoveryEpochAdvanced = true;
+                        }
                         const deletion = await this.deleteReplicationRangesCoherently(deleted, keyHash);
                         deleted = deletion.removed;
                         ownerHasRanges = deletion.ownerHasRanges;
@@ -3885,11 +4000,6 @@ let SharedLog = (() => {
                     // through replication-info updates without a topic unsubscribe event.
                     await cleanupDisconnectedPeer();
                     if (!isMe) {
-                        // Replication-info handlers release their receive lease before joining
-                        // this lane. Fence every handler queued behind this successful removal,
-                        // regardless of whether it came from liveness, startup pruning, or an
-                        // unsubscribe transition.
-                        this.advanceReplicationInfoRecoveryEpoch(keyHash);
                         this.rebalanceParticipationDebounced?.call();
                     }
                     removed = true;
@@ -3920,6 +4030,22 @@ let SharedLog = (() => {
             }
             finally {
                 releaseReceiveCleanupGate?.();
+                if (replicationInfoRecoveryEpochAdvanced &&
+                    ownsReplicationOwnershipLifecycle() &&
+                    ownsReplicationLifecycle() &&
+                    ownsSubscriptionEpoch()) {
+                    // The first recovery arm ran while receive admission was fenced.
+                    // Re-arm after releasing the cleanup gate so a still-open peer can
+                    // deliver the authoritative Full that completes recovery.
+                    const peerSession = this._peerSessions.current(keyHash);
+                    if (peerSession?.phase === "open") {
+                        this._v2Receive.advanceRecovery({
+                            peerHash: keyHash,
+                            peerSession,
+                            receiveEpoch: this._peerSessions.receiveEpoch(keyHash),
+                        });
+                    }
+                }
                 if (isSpeculativePeerRemoval) {
                     const cancelledByFreshActivity = removalCallCompleted &&
                         !removed &&
@@ -4012,6 +4138,11 @@ let SharedLog = (() => {
             }
             const deletion = await this.deleteReplicationRangesCoherently(ranges, ownerHash);
             ranges = deletion.removed;
+            if ((options?.shouldRemove && !options.shouldRemove()) ||
+                options?.onDurableRemoveCommitted?.() === false) {
+                await deletion.rollback();
+                return false;
+            }
             options?.onRemoved?.(ranges);
             if (ranges.length > 0) {
                 this.events.dispatchEvent(new CustomEvent("replication:change", {
@@ -4075,7 +4206,7 @@ let SharedLog = (() => {
             this.throwIfReplicationOwnershipLifecycleInactive(replicationOwnershipLifecycleController);
             return this.withReceiveOwnershipMutationQueue(() => this.addReplicationRangeUnlocked(ranges, from, options, replicationOwnershipLifecycleController), replicationOwnershipLifecycleController);
         }
-        async addReplicationRangeUnlocked(ranges, from, { reset, checkDuplicates, timestamp: ts, rebalance, allowLegacyOrderedReplacementPairs, onConfirmedDurableStateChanged, shouldApply, } = {}, replicationOwnershipLifecycleController = this.captureReplicationOwnershipLifecycle()) {
+        async addReplicationRangeUnlocked(ranges, from, { reset, checkDuplicates, timestamp: ts, rebalance, allowLegacyOrderedReplacementPairs, onConfirmedDurableStateChanged, onDurableApplyCommitted, shouldApply, } = {}, replicationOwnershipLifecycleController = this.captureReplicationOwnershipLifecycle()) {
             this.validateReplicationRangeAnnouncement(ranges);
             this.throwIfReplicationOwnershipLifecycleInactive(replicationOwnershipLifecycleController);
             // This predicate is intentionally checked inside the global ownership lane.
@@ -4084,6 +4215,12 @@ let SharedLog = (() => {
             if (shouldApply && !shouldApply()) {
                 return [];
             }
+            const applySuperseded = Symbol("replication-range-apply-superseded");
+            const throwIfApplySuperseded = () => {
+                if (shouldApply && !shouldApply()) {
+                    throw applySuperseded;
+                }
+            };
             const fromHash = from.hashcode();
             const incomingRangesById = new Map();
             const incomingRangeCountsById = new Map();
@@ -4142,6 +4279,7 @@ let SharedLog = (() => {
             let isStoppedReplicating = false;
             let wasReplicatorBeforeDestructiveReset = false;
             let resetFailureLeaveEmitted = false;
+            let resetDeletionRollback;
             const publishConfirmedResetStop = (ownerHasRanges) => {
                 if (ownerHasRanges || resetFailureLeaveEmitted) {
                     return;
@@ -4182,8 +4320,14 @@ let SharedLog = (() => {
                 else {
                     wasReplicatorBeforeDestructiveReset =
                         this.uniqueReplicators.has(fromHash);
+                    throwIfApplySuperseded();
                     const deletion = await this.deleteReplicationRangesCoherently(deleted, fromHash, { preserveOwnerMembership: ranges.length > 0 });
                     deleted = deletion.removed;
+                    resetDeletionRollback = deletion.rollback;
+                    if (shouldApply && !shouldApply()) {
+                        await deletion.rollback();
+                        return [];
+                    }
                     diffs = [
                         ...deleted.map((x) => {
                             return { range: x, type: "removed", timestamp };
@@ -4339,19 +4483,27 @@ let SharedLog = (() => {
                 return failure;
             };
             try {
+                throwIfApplySuperseded();
                 for (const diff of diffs) {
                     if (diff.type !== "added") {
                         continue;
                     }
+                    throwIfApplySuperseded();
                     appliedPositiveRanges.push(diff);
                     await this.replicationIndex.put(diff.range);
                     this.putNativeReplicationRange(diff.range);
+                    throwIfApplySuperseded();
                 }
                 if (reset && diffs.length > 0) {
                     await this.updateOldestTimestampFromIndex();
+                    throwIfApplySuperseded();
+                }
+                if (onDurableApplyCommitted?.() === false) {
+                    throw applySuperseded;
                 }
             }
             catch (error) {
+                const superseded = error === applySuperseded;
                 let outcomeError = error;
                 if (appliedPositiveRanges.length > 0) {
                     try {
@@ -4361,6 +4513,20 @@ let SharedLog = (() => {
                         outcomeError = poisonFromPositiveRollback(rollbackError, error);
                     }
                 }
+                if (superseded) {
+                    if (resetDeletionRollback) {
+                        try {
+                            await resetDeletionRollback();
+                        }
+                        catch (rollbackError) {
+                            outcomeError = rollbackError;
+                        }
+                    }
+                    if (outcomeError === applySuperseded) {
+                        return [];
+                    }
+                    throw outcomeError;
+                }
                 if (reset) {
                     const negativeDiffs = diffs.filter((diff) => diff.type !== "added");
                     if (negativeDiffs.length > 0) {
@@ -6967,7 +7133,8 @@ let SharedLog = (() => {
         appendLocallyPreparedPayloadNativeBackboneStorageTransaction(payloadData, appendOptions, properties, minReplicasValue, runtimeOnlyCoordinates, ownershipLifecycleController) {
             this.throwIfReplicationOwnershipLifecycleInactive(ownershipLifecycleController);
             const backbone = this._nativeBackbone;
-            if (!backbone || !this._coordinates.canUseNativeBackboneResidentCoordinateState()) {
+            if (!backbone ||
+                !this._coordinates.canUseNativeBackboneResidentCoordinateState()) {
                 return undefined;
             }
             if (properties?.nativeBackboneDocumentDeleteKey &&
@@ -7098,11 +7265,12 @@ let SharedLog = (() => {
                         backboneAppend.trimmed.map((entry) => entry.hash);
                     const committedHash = backboneAppend.entry.cid ?? backboneAppend.entry.hash;
                     const committedNext = backboneAppend.entry.next ?? next;
-                    nativeCoordinateRollback = this._coordinates.snapshotResidentCoordinateEntries([
-                        ...(committedHash ? [committedHash] : []),
-                        ...committedNext,
-                        ...nativeTrimmedHashes,
-                    ]);
+                    nativeCoordinateRollback =
+                        this._coordinates.snapshotResidentCoordinateEntries([
+                            ...(committedHash ? [committedHash] : []),
+                            ...committedNext,
+                            ...nativeTrimmedHashes,
+                        ]);
                     await this.setNativeStrictDurableTransactionOperation(nativeStrictTransaction, committedHash ? [committedHash] : [], nativeTrimmedHashes, nativeCoordinateRollback, combineCoordinateDeleteHashes(committedNext, nativeTrimmedHashes));
                     const rollbackCommitted = async (cause, committedCids) => {
                         durableWrapper?.cancelNativeDeleteCleanup?.(nativeDeleteCleanupToken);
@@ -7770,14 +7938,15 @@ let SharedLog = (() => {
                     const nativeTrimmedHashSet = new Set(committedAppends.flatMap((append) => append.trimmedHashes ??
                         append.trimmed.map((entry) => entry.hash)));
                     const nativeTrimmedHashes = [...nativeTrimmedHashSet];
-                    batchCoordinateRollback = this._coordinates.snapshotResidentCoordinateEntries(committedAppends.flatMap((append) => [
-                        ...((append.entry.cid ?? append.entry.hash)
-                            ? [append.entry.cid ?? append.entry.hash]
-                            : []),
-                        ...append.entry.next,
-                        ...(append.trimmedHashes ??
-                            append.trimmed.map((entry) => entry.hash)),
-                    ]));
+                    batchCoordinateRollback =
+                        this._coordinates.snapshotResidentCoordinateEntries(committedAppends.flatMap((append) => [
+                            ...((append.entry.cid ?? append.entry.hash)
+                                ? [append.entry.cid ?? append.entry.hash]
+                                : []),
+                            ...append.entry.next,
+                            ...(append.trimmedHashes ??
+                                append.trimmed.map((entry) => entry.hash)),
+                        ]));
                     await this.setNativeStrictDurableTransactionOperation(nativeStrictTransaction, committedCids, nativeTrimmedHashes, batchCoordinateRollback, committedAppends.flatMap((append) => [
                         ...append.entry.next,
                         ...(append.trimmedHashes ??
@@ -9004,6 +9173,8 @@ let SharedLog = (() => {
             this._lastLocalAppendAt = 0;
             this._announcements ??= this.createReplicationAnnouncementCoordinator();
             this._announcements.resetForOpen();
+            this._v2Receive ??= this.createReplicationInfoV2ReceiveCoordinator();
+            this._v2Receive.resetForOpen();
             this._v2Send ??= this.createReplicationInfoV2SendCoordinator();
             this._v2Send.resetForOpen();
             const adaptiveReplicateOptions = options?.replicate && isAdaptiveReplicatorOption(options.replicate)
@@ -9575,7 +9746,8 @@ let SharedLog = (() => {
                 // any stale coordinate or document state to this backbone.
                 await this._coordinates._nativeBackboneCoordinatePersistence.resumeDrop?.();
                 await this._coordinates._nativeBackboneCoordinatePersistence.hydrate(backbone);
-                this._coordinates._nativeBackboneCoordinateJournalLastFlushMs = Date.now();
+                this._coordinates._nativeBackboneCoordinateJournalLastFlushMs =
+                    Date.now();
                 this.hydrateNativeCoordinateStateFromBackbone(backbone);
                 return;
             }
@@ -9787,18 +9959,20 @@ let SharedLog = (() => {
                 }
                 if (this.node.directory != null &&
                     this._coordinates._nativeBackboneCoordinatePersistence) {
-                    if (this._coordinates._nativeBackboneCoordinatePersistence.durableBarrier !== true ||
+                    if (this._coordinates._nativeBackboneCoordinatePersistence
+                        .durableBarrier !== true ||
                         typeof this._nativeBackboneCoordinatePersistenceStore
                             ?.durableBarrier !== "function") {
                         throw new Error("Durable nativeBackbone coordinate persistence requires an explicit physical durability barrier");
                     }
                 }
                 if (this._coordinates._nativeBackboneCoordinatePersistence &&
-                    (this._coordinates._nativeBackboneCoordinatePersistence.compactMaxJournalBytes !=
-                        null ||
-                        this._coordinates._nativeBackboneCoordinatePersistence.compactMaxJournalRecords !=
-                            null) &&
-                    this._coordinates._nativeBackboneCoordinatePersistence.crashSafeCompaction !== true) {
+                    (this._coordinates._nativeBackboneCoordinatePersistence
+                        .compactMaxJournalBytes != null ||
+                        this._coordinates._nativeBackboneCoordinatePersistence
+                            .compactMaxJournalRecords != null) &&
+                    this._coordinates._nativeBackboneCoordinatePersistence
+                        .crashSafeCompaction !== true) {
                     // Durable custom adapters must explicitly advertise an atomic generation
                     // protocol before SharedLog permits automatic WAL compaction.
                     throw new Error("Durable native coordinate persistence compaction thresholds require crashSafeCompaction");
@@ -10121,13 +10295,18 @@ let SharedLog = (() => {
             }
         }
         cleanupPeerDisconnectTracking(peerHash, ownershipLifecycleController = this.captureReplicationOwnershipLifecycle()) {
+            const peerSession = this._peerSessions.current(peerHash);
+            const preserveV2Session = peerSession?.phase === "open" && peerSession.isActive();
             this.cancelReplicationInfoRequests(peerHash);
             this._liveness._replicatorLivenessFailures.delete(peerHash);
             this._liveness._replicatorLastActivityAt.delete(peerHash);
-            this._peerSyncCapabilities.delete(peerHash);
-            this._peerSyncCapabilitySessions.delete(peerHash);
-            this._peerSyncCapabilityTimestamps.delete(peerHash);
-            this._v2Send.clearPeer(peerHash);
+            if (!preserveV2Session) {
+                this._peerSyncCapabilities.delete(peerHash);
+                this._peerSyncCapabilitySessions.delete(peerHash);
+                this._peerSyncCapabilityTimestamps.delete(peerHash);
+                this._v2Receive.clearPeer(peerHash);
+                this._v2Send.clearPeer(peerHash);
+            }
             this.cleanupPendingIHavePeer(peerHash);
             this.cleanupCheckedPrunePeer(peerHash, ownershipLifecycleController, this._checkedPrune);
         }
@@ -10145,8 +10324,16 @@ let SharedLog = (() => {
             // when they eventually reach the apply lane. Reset the sender's
             // ordering watermark with the local epoch so a later arrival can be
             // accepted without comparing its clock to this receiver's clock.
-            this._peerSessions.advanceReceiveEpoch(peerHash);
+            const receiveEpoch = this._peerSessions.advanceReceiveEpoch(peerHash);
             this.latestReplicationInfoMessage.delete(peerHash);
+            const peerSession = this._peerSessions.current(peerHash);
+            if (peerSession?.phase === "open") {
+                this._v2Receive.advanceRecovery({
+                    peerHash,
+                    peerSession,
+                    receiveEpoch,
+                });
+            }
         }
         async resolveCandidatePeersForHash(hash, options) {
             if (options?.signal?.aborted)
@@ -10946,6 +11133,7 @@ let SharedLog = (() => {
                 this._peerSyncCapabilities?.clear();
                 this._peerSyncCapabilitySessions?.clear();
                 this._peerSyncCapabilityTimestamps?.clear();
+                this._v2Receive?.clearForClose();
                 this._v2Send?.clearForClose();
                 this._liveRawGossipBatches?.clear();
                 this._nativeSharedLogState?.clearGidPeers();
@@ -11009,6 +11197,7 @@ let SharedLog = (() => {
             this.preventParentAttachments();
             this.stopRepairLifecycle();
             this._instanceLifecycle?.beginTerminal("close");
+            this._v2Receive?.clearForClose();
             const replicationRangeTerminalFence = this.acquireReplicationRangeMutationTerminalFence();
             const pruneRemoveTerminalFence = this.acquirePruneRemoveTerminalFence();
             try {
@@ -11069,10 +11258,12 @@ let SharedLog = (() => {
                     try {
                         const reset = new AllReplicatingSegmentsMessage({ segments: [] });
                         await Promise.all([
-                            this.rpc.send(reset, {
+                            this.rpc
+                                .send(reset, {
                                 priority: CONVERGENCE_MESSAGE_PRIORITY,
                                 signal: abort.signal,
-                            }).catch(() => { }),
+                            })
+                                .catch(() => { }),
                             this._v2Send.sendTerminalReset(abort.signal),
                         ]);
                     }
@@ -11151,6 +11342,7 @@ let SharedLog = (() => {
             this.preventParentAttachments();
             this.stopRepairLifecycle();
             this._instanceLifecycle?.beginTerminal("drop");
+            this._v2Receive?.clearForClose();
             const replicationRangeTerminalFence = this.acquireReplicationRangeMutationTerminalFence();
             const pruneRemoveTerminalFence = this.acquirePruneRemoveTerminalFence();
             try {
@@ -11194,10 +11386,12 @@ let SharedLog = (() => {
                     try {
                         const reset = new AllReplicatingSegmentsMessage({ segments: [] });
                         await Promise.all([
-                            this.rpc.send(reset, {
+                            this.rpc
+                                .send(reset, {
                                 priority: CONVERGENCE_MESSAGE_PRIORITY,
                                 signal: abort.signal,
-                            }).catch(() => { }),
+                            })
+                                .catch(() => { }),
                             this._v2Send.sendTerminalReset(abort.signal),
                         ]);
                     }
@@ -11614,13 +11808,6 @@ let SharedLog = (() => {
         }
         // Callback for receiving a message from the network
         async onMessage(msg, context) {
-            // Decode-first only: capability advertisement is not permission to use
-            // V2. Drop every unsolicited V2 envelope before even entering the shared
-            // receive envelope, so durable poison checks, leases, liveness, ordering
-            // watermarks, replication ranges and cleanup side effects cannot observe it.
-            if (isReplicationInfoV2Message(msg)) {
-                return;
-            }
             const stashBackedRawMessage = isStashBackedRawExchangeHeadsMessage(msg)
                 ? msg
                 : undefined;
@@ -11661,18 +11848,25 @@ let SharedLog = (() => {
                     msg = msg.toReplicationInfoMessage(); // migration
                 }
                 if (msg instanceof AllReplicatingSegmentsMessage ||
-                    msg instanceof AddedReplicationSegmentMessage) {
+                    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) {
+                else if (msg instanceof StoppedReplicating ||
+                    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)) {
+                    !(msg instanceof RequestReplicationInfoV2Message) &&
+                    !isReplicationInfoV2Message(msg) &&
+                    !(msg instanceof AllReplicatingSegmentsMessage) &&
+                    !(msg instanceof AddedReplicationSegmentMessage) &&
+                    !(msg instanceof StoppedReplicating)) {
                     this._liveness.markReplicatorActivity(receiveFromHash);
                 }
                 const syncProfile = this._logProperties?.sync?.profile;
@@ -12988,6 +13182,7 @@ let SharedLog = (() => {
                         fromHash: receiveFromHash,
                         session: receiveSession,
                         lifecycleController: receiveReplicationLifecycleController,
+                        ownershipLifecycleController: receiveOwnershipLifecycleController,
                         receiveEpoch: receiveReplicationInfoReceiveEpoch,
                         syncProfile,
                         lease: peerReceiveLease,
@@ -13013,6 +13208,9 @@ let SharedLog = (() => {
                         this.clearRepairFrontierHashes(context.from.hashcode(), msg.hashes);
                         return;
                     }
+                    else if (isReplicationInfoV2Message(msg)) {
+                        await this.handleReplicationInfoV2Announcement(msg, laneRequestContext, lane);
+                    }
                     else if (msg instanceof SyncCapabilitiesMessage) {
                         if (!context.from.equals(this.node.identity.publicKey)) {
                             const capabilityTransportSession = context.message?.header?.session;
@@ -13033,13 +13231,14 @@ let SharedLog = (() => {
                                     openingSession: receiveSession,
                                 });
                             }
-                            else {
-                                this.observePeerSyncCapabilities({
-                                    peerHash: receiveFromHash,
-                                    capabilities: msg.capabilities,
-                                    transportSession: capabilityTransportSession,
-                                    timestamp: capabilityTimestamp,
-                                });
+                            else if (this.observePeerSyncCapabilities({
+                                peerHash: receiveFromHash,
+                                capabilities: msg.capabilities,
+                                transportSession: capabilityTransportSession,
+                                timestamp: capabilityTimestamp,
+                            }) &&
+                                receiveSession?.phase === "open") {
+                                this.promoteReplicationInfoV2ReceiveCapability(context.from, receiveSession);
                             }
                         }
                         return;
@@ -13060,6 +13259,7 @@ let SharedLog = (() => {
                                 from: context.from,
                                 peerSession: receiveSession,
                                 receiverTransportSession: context.message.header.session,
+                                capabilityTimestamp: this._peerSyncCapabilityTimestamps.get(receiveFromHash),
                                 requestTimestamp: context.message.header.timestamp,
                             })) {
                             this._liveness.markReplicatorActivity(receiveFromHash);
@@ -13335,6 +13535,147 @@ let SharedLog = (() => {
                 }
             }
         }
+        async handleReplicationInfoV2Announcement(msg, context, lane) {
+            const from = context.from;
+            const fromHash = lane.fromHash;
+            const receiveSession = lane.session;
+            if (from.equals(this.node.identity.publicKey) ||
+                receiveSession === null ||
+                receiveSession.phase !== "open") {
+                return;
+            }
+            // Authenticate and reserve before the per-peer lane. One reservation per
+            // peer bounds decoded-frame retention while another mutation is parked.
+            const receiveState = this._v2Receive._receiveStates.get(fromHash);
+            if (!receiveState ||
+                receiveState.peerSession !== receiveSession ||
+                receiveState.senderTransportSession !== context.message.header.session) {
+                return;
+            }
+            const admission = this._v2Receive.reserve(msg, {
+                from,
+                peerSession: receiveSession,
+                receiveEpoch: lane.receiveEpoch,
+                senderTransportSession: context.message.header.session,
+                transportTimestamp: context.message.header.timestamp,
+            });
+            if (!admission) {
+                return;
+            }
+            lane.lease.release();
+            try {
+                await this.withReplicationInfoApplyQueue(fromHash, async () => {
+                    const hostGate = () => this._instanceLifecycle.isMembershipActiveFor(lane.lifecycleController) &&
+                        this.isRepairLifecycleActive(lane.ownershipLifecycleController) &&
+                        this._peerSessions.isCurrent(fromHash, receiveSession) &&
+                        receiveSession.phase === "open" &&
+                        this._peerSessions.isReceiveEpochCurrent(fromHash, lane.receiveEpoch) &&
+                        !this._peerSessions.isReplicationInfoBlocked(fromHash) &&
+                        this._peerSessions.isReceiveCleanupGateOpen(fromHash);
+                    if (!hostGate()) {
+                        return;
+                    }
+                    const exactGate = () => hostGate() && this._v2Receive.isAdmissionCurrent(admission);
+                    let durableCommitted = false;
+                    try {
+                        if (msg instanceof FullReplicationInfoV2Message ||
+                            msg instanceof AddedReplicationInfoV2Message) {
+                            let mutationGateChecked = false;
+                            let mutationGateAdmitted = false;
+                            const result = await this.addReplicationRange(msg.segments.map((segment) => segment.toReplicationRangeIndexable(from)), from, {
+                                reset: msg instanceof FullReplicationInfoV2Message,
+                                checkDuplicates: true,
+                                timestamp: Number(context.message.header.timestamp),
+                                allowLegacyOrderedReplacementPairs: msg instanceof AddedReplicationInfoV2Message,
+                                shouldApply: () => {
+                                    mutationGateChecked = true;
+                                    mutationGateAdmitted = exactGate();
+                                    return mutationGateAdmitted;
+                                },
+                                onDurableApplyCommitted: () => {
+                                    if (!exactGate() || !this._v2Receive.commit(admission)) {
+                                        return false;
+                                    }
+                                    durableCommitted = true;
+                                    return true;
+                                },
+                            }, lane.ownershipLifecycleController);
+                            if (result === undefined ||
+                                !mutationGateChecked ||
+                                !mutationGateAdmitted ||
+                                !durableCommitted ||
+                                !exactGate()) {
+                                return;
+                            }
+                        }
+                        else {
+                            if (!exactGate()) {
+                                return;
+                            }
+                            const rangesToRemove = await this.resolveReplicationRangesFromIdsAndKey(msg.segmentIds, from);
+                            if (!exactGate()) {
+                                return;
+                            }
+                            let mutationGateAdmitted = true;
+                            const removedRanges = [];
+                            const removed = await this.removeReplicationRanges(rangesToRemove, from, {
+                                shouldRemove: () => {
+                                    mutationGateAdmitted = exactGate();
+                                    return mutationGateAdmitted;
+                                },
+                                onDurableRemoveCommitted: () => {
+                                    if (!exactGate() || !this._v2Receive.commit(admission)) {
+                                        return false;
+                                    }
+                                    durableCommitted = true;
+                                    return true;
+                                },
+                                onRemoved: (ranges) => removedRanges.push(...ranges),
+                            }, lane.ownershipLifecycleController);
+                            if (!durableCommitted) {
+                                if (!mutationGateAdmitted ||
+                                    !exactGate() ||
+                                    removed ||
+                                    !this._v2Receive.commit(admission)) {
+                                    return;
+                                }
+                                durableCommitted = true;
+                            }
+                            if (this._instanceLifecycle.isMembershipActiveFor(lane.lifecycleController) &&
+                                this.isRepairLifecycleActive(lane.ownershipLifecycleController)) {
+                                const timestamp = BigInt(Date.now());
+                                for (const range of removedRanges) {
+                                    this.replicationChangeDebounceFn.add({
+                                        range,
+                                        type: "removed",
+                                        timestamp,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    catch (error) {
+                        this._v2Receive.requireFullAfterFailure(admission);
+                        throw error;
+                    }
+                    if (!durableCommitted) {
+                        if (!exactGate() || !this._v2Receive.commit(admission)) {
+                            return;
+                        }
+                    }
+                    if (!hostGate()) {
+                        return;
+                    }
+                    this._liveness.markReplicatorActivity(fromHash);
+                    if (msg instanceof FullReplicationInfoV2Message) {
+                        this.cancelReplicationInfoRequests(fromHash);
+                    }
+                });
+            }
+            finally {
+                this._v2Receive.release(admission);
+            }
+        }
         async handleReplicationInfoAnnouncement(msg, context, lane) {
             const receiveFromHash = lane.fromHash;
             const receiveSession = lane.session;
@@ -13350,6 +13691,19 @@ let SharedLog = (() => {
             // (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
@@ -13374,6 +13728,17 @@ let SharedLog = (() => {
                         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);
@@ -13381,17 +13746,20 @@ let SharedLog = (() => {
                         return;
                     }
                     this.latestReplicationInfoMessage.set(fromHash, messageTimestamp);
-                    this._liveness._replicatorLivenessFailures.delete(fromHash);
                     if (this.closed) {
                         return;
                     }
                     const reset = msg instanceof AllReplicatingSegmentsMessage;
-                    await this.addReplicationRange(replicationInfoMessage.segments.map((x) => x.toReplicationRangeIndexable(from)), from, {
+                    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) {
@@ -13418,6 +13786,19 @@ let SharedLog = (() => {
                 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) ||
@@ -13434,17 +13815,28 @@ let SharedLog = (() => {
                     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);
-                this._liveness._replicatorLivenessFailures.delete(fromHash);
                 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({
@@ -15313,6 +15705,8 @@ let SharedLog = (() => {
          * This method must run inside the global replication-range mutation lane.
          */
         async deleteReplicationRangesCoherently(ranges, ownerHash, options) {
+            const wasReplicator = this.uniqueReplicators.has(ownerHash);
+            const joinWasEmitted = this._replicatorJoinEmitted.has(ownerHash);
             if (ranges.length === 0) {
                 const ownerHasRanges = (await this.replicationIndex.count({ query: { hash: ownerHash } })) > 0;
                 if (!ownerHasRanges) {
@@ -15323,13 +15717,25 @@ let SharedLog = (() => {
                     removed: [],
                     retained: [],
                     ownerHasRanges,
+                    rollback: async () => {
+                        if (wasReplicator) {
+                            this.uniqueReplicators.add(ownerHash);
+                        }
+                        else {
+                            this.uniqueReplicators.delete(ownerHash);
+                        }
+                        if (joinWasEmitted) {
+                            this._replicatorJoinEmitted.add(ownerHash);
+                        }
+                        else {
+                            this._replicatorJoinEmitted.delete(ownerHash);
+                        }
+                    },
                 };
             }
             const uniqueRanges = [
                 ...new Map(ranges.map((range) => [range.idString, range])).values(),
             ];
-            const wasReplicator = this.uniqueReplicators.has(ownerHash);
-            const joinWasEmitted = this._replicatorJoinEmitted.has(ownerHash);
             const snapshots = uniqueRanges.map((range) => {
                 const pending = this.pendingMaturity.get(ownerHash)?.get(range.idString);
                 return {
@@ -15516,10 +15922,76 @@ let SharedLog = (() => {
                 outcomeError = new AggregateError(errors, "Replication-range deletion and post-state reconciliation failed");
                 this.poisonReplicationOwnership(outcomeError);
             }
+            let rollbackStarted = false;
+            const rollback = async () => {
+                if (rollbackStarted) {
+                    return;
+                }
+                rollbackStarted = true;
+                const rollbackErrors = [];
+                const removedIds = new Set(removed.map((range) => range.idString));
+                for (const snapshot of snapshots) {
+                    if (!removedIds.has(snapshot.range.idString)) {
+                        continue;
+                    }
+                    try {
+                        await this.replicationIndex.put(snapshot.range);
+                        this.putNativeReplicationRange(snapshot.range);
+                    }
+                    catch (error) {
+                        rollbackErrors.push(error);
+                    }
+                }
+                for (const snapshot of snapshots) {
+                    if (!removedIds.has(snapshot.range.idString) ||
+                        !snapshot.pending ||
+                        this.pendingMaturity.get(ownerHash)?.has(snapshot.range.idString)) {
+                        continue;
+                    }
+                    try {
+                        this.schedulePendingMaturity(snapshot.pending.range, snapshot.pending.from, {
+                            rebalance: snapshot.pending.rebalance,
+                            waitMs: Math.max(0, snapshot.pending.expiresAt - Date.now()),
+                        }, snapshot.pending.ownershipLifecycleController);
+                    }
+                    catch (error) {
+                        rollbackErrors.push(error);
+                    }
+                }
+                try {
+                    if (wasReplicator) {
+                        this.uniqueReplicators.add(ownerHash);
+                    }
+                    else {
+                        this.uniqueReplicators.delete(ownerHash);
+                    }
+                    if (joinWasEmitted) {
+                        this._replicatorJoinEmitted.add(ownerHash);
+                    }
+                    else {
+                        this._replicatorJoinEmitted.delete(ownerHash);
+                    }
+                }
+                catch (error) {
+                    rollbackErrors.push(error);
+                }
+                try {
+                    await this.updateOldestTimestampFromIndex();
+                }
+                catch (error) {
+                    rollbackErrors.push(error);
+                }
+                if (rollbackErrors.length > 0) {
+                    const failure = new AggregateError(rollbackErrors, "Replication-range deletion rollback failed");
+                    this.poisonReplicationOwnership(failure);
+                    throw failure;
+                }
+            };
             return {
                 removed,
                 retained,
                 ownerHasRanges,
+                rollback,
                 error: outcomeError,
             };
         }
@@ -15532,7 +16004,8 @@ let SharedLog = (() => {
             }
             this._replicationInfoRequestByPeer.delete(peerHash);
         }
-        scheduleReplicationInfoRequests(peer, replicationLifecycleController = this._instanceLifecycle?.membershipLifecycleController) {
+        scheduleReplicationInfoRequests(peer, replicationLifecycleController = this._instanceLifecycle
+            ?.membershipLifecycleController) {
             if (!replicationLifecycleController ||
                 !this.isReplicationLifecycleActive(replicationLifecycleController)) {
                 return;
@@ -15606,6 +16079,7 @@ let SharedLog = (() => {
             // A destination stream is scoped to exactly one topic-subscription
             // session. Abort the predecessor synchronously before either barrier can
             // yield; a late queue completion must never enter the new session.
+            this._v2Receive.clearPeer(peerHash);
             this._v2Send.clearPeer(peerHash);
             this._peerSyncCapabilitySessions.delete(peerHash);
             this._peerSyncCapabilityTimestamps.delete(peerHash);
@@ -15720,23 +16194,22 @@ let SharedLog = (() => {
             this._liveness._replicatorLivenessFailures.delete(peerHash);
             this._liveness.markReplicatorActivity(peerHash);
             this._peerSessions.markOpen(peerHash, expectedSubscriptionEpoch);
-            // Decode support and receiver-led negotiation readiness are separate bits.
-            // This node never initiates a request in this rollout; normal replication
-            // announcements remain legacy unless a peer explicitly grants one signed,
-            // session-bound V2 destination stream.
-            const receiveCapabilities = SYNC_CAPABILITY_REPLICATION_INFO_V2_DECODE |
-                SYNC_CAPABILITY_REPLICATION_INFO_V2_SEND |
-                (this._logProperties?.sync?.rawExchangeHeads === true
-                    ? SYNC_CAPABILITY_RAW_EXCHANGE_HEADS
-                    : 0);
-            this.rpc
-                .send(new SyncCapabilitiesMessage({
-                capabilities: receiveCapabilities,
-            }), {
-                mode: new SilentDelivery({ redundancy: 1, to: [publicKey] }),
+            this.promoteReplicationInfoV2ReceiveCapability(publicKey, expectedSubscriptionEpoch);
+            // Decode, sender and authenticated apply readiness are separate bits. Start
+            // the ACKed receiver-led negotiation before the legacy snapshot, but do not
+            // hold mixed-version replication discovery behind that round trip. Attach
+            // the rejection handler now because a lifecycle fence below may return before
+            // awaiting the advert. RequestV2 is armed only after both sends settle.
+            const receiveEpoch = this._peerSessions.receiveEpoch(peerHash);
+            const localCapabilityAdvertisement = this.advertiseReplicationInfoV2ReceiveCapability({
+                target: publicKey,
+                peerSession: expectedSubscriptionEpoch,
+                receiveEpoch,
                 signal: replicationLifecycleController.signal,
-            })
-                .catch((error) => this.handleReplicationLifecycleSendError(error, replicationLifecycleController));
+            }).catch((error) => {
+                this.handleReplicationLifecycleSendError(error, replicationLifecycleController);
+                return undefined;
+            });
             let replicationSegments;
             try {
                 replicationSegments = await this.getMyReplicationSegments();
@@ -15782,13 +16255,22 @@ let SharedLog = (() => {
                         .catch((error) => this.handleReplicationLifecycleSendError(error, replicationLifecycleController));
                 }
             }
-            // Request the remote peer's replication info. This makes joins resilient to
-            // timing-sensitive delivery/order issues where we may miss their initial
-            // replication announcement.
+            // Keep legacy request-based discovery independent of the capability ACK too.
+            // This makes mixed-version joins resilient to timing-sensitive delivery/order
+            // issues where we may miss the remote peer's initial announcement.
             if (this.isReplicationLifecycleActive(replicationLifecycleController) &&
                 ownsSubscriptionEpoch()) {
                 this.scheduleReplicationInfoRequests(publicKey, replicationLifecycleController);
             }
+            const localCapabilityReady = await localCapabilityAdvertisement;
+            if (localCapabilityReady) {
+                this._v2Receive.markLocalCapabilityReady({
+                    peerHash,
+                    peerSession: expectedSubscriptionEpoch,
+                    receiveEpoch,
+                    ...localCapabilityReady,
+                });
+            }
         }
         getClampedReplicas(customValue) {
             if (!customValue) {