@peerbit/shared-log 13.2.31 → 13.2.33

package/dist/src/index.js

@@ -51,26 +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_DECODE, 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 { 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 { 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, 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";
@@ -624,7 +626,8 @@ let SharedLog = (() => {
                 value;
         }
         get _nativeBackboneCoordinateJournalLastFlushMs() {
-            return this._coordinates?._nativeBackboneCoordinateJournalLastFlushMs;
+            return this._coordinates
+                ?._nativeBackboneCoordinateJournalLastFlushMs;
         }
         set _nativeBackboneCoordinateJournalLastFlushMs(value) {
             (this._coordinates ??=
@@ -1497,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(),
@@ -1608,6 +1612,8 @@ 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;
         _checkedPruneAuditTimer;
@@ -1637,6 +1643,10 @@ let SharedLog = (() => {
         // Sync capability bits advertised by peers (SyncCapabilitiesMessage), keyed
         // by public key hash. Entries are dropped on unsubscribe/disconnect.
         _peerSyncCapabilities;
+        // Signed transport session carried by the capability envelope. Kept in a
+        // parallel map so existing capability-number consumers remain unchanged.
+        _peerSyncCapabilitySessions;
+        _peerSyncCapabilityTimestamps;
         // Pending live raw exchange-head gossip, coalesced per recipient set and
         // flushed at the end of the current event-loop turn (or when a batch cap
         // is hit). Only used when every recipient advertised raw capability.
@@ -1690,6 +1700,7 @@ let SharedLog = (() => {
                 // this).
                 queueCurrentReplicationStateAnnouncementRepair: () => this._announcements.queueCurrentReplicationStateAnnouncementRepair(),
                 queueCurrentReplicationStateAnnouncementRetry: (error) => this._announcements.queueCurrentReplicationStateAnnouncementRetry(error),
+                enqueueReplicationInfoV2: (message) => this._v2Send.enqueue(message),
                 isClosed: () => this.closed,
                 getCloseSignal: () => this._closeController.signal,
                 getMyReplicationSegments: () => this.getMyReplicationSegments(),
@@ -1704,6 +1715,94 @@ let SharedLog = (() => {
                 callRebalanceParticipationDebounced: () => this.rebalanceParticipationDebounced?.call(),
             });
         }
+        createReplicationInfoV2SendCoordinator() {
+            return new ReplicationInfoV2SendCoordinator({
+                getRpc: () => this.rpc,
+                getSelfKey: () => this.node.identity.publicKey,
+                getSenderTransportSession: () => BigInt(this.node.services.pubsub.session),
+                getMyReplicationSegments: () => this.getMyReplicationSegments(),
+                validatePersistedReplicationRangeSnapshot: (ranges) => this.validatePersistedReplicationRangeSnapshot(ranges),
+                isClosed: () => this.closed,
+                isPeerSessionOpen: (peerHash, peerSession) => this._peerSessions.isCurrent(peerHash, peerSession) &&
+                    peerSession.phase === "open" &&
+                    !this._peerSessions.isReplicationInfoBlocked(peerHash) &&
+                    this._peerSessions.isReceiveCleanupGateOpen(peerHash),
+                captureReplicationOwnershipLifecycle: () => this.captureReplicationOwnershipLifecycle(),
+                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
@@ -1798,6 +1897,8 @@ let SharedLog = (() => {
             this._appendBackfillPendingByTarget = new Map();
             this._topicSubscribersCache = new Map();
             this._peerSyncCapabilities = new Map();
+            this._peerSyncCapabilitySessions = new Map();
+            this._peerSyncCapabilityTimestamps = new Map();
             this._liveRawGossipBatches = new Map();
             this._liveRawGossipFlushScheduled = false;
             this.coordinateToHash = new Cache({ max: 1e6, ttl: 1e4 });
@@ -1806,6 +1907,8 @@ 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();
             this._closeController = new AbortController();
@@ -2196,6 +2299,101 @@ let SharedLog = (() => {
                 SYNC_CAPABILITY_RAW_EXCHANGE_HEADS) !==
                 0);
         }
+        observePeerSyncCapabilities(properties) {
+            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) {
+                        return false;
+                    }
+                    this._openingSyncCapabilitiesByPeer.set(peerHash, {
+                        epoch: openingSession,
+                        capabilities: previous.capabilities | capabilities,
+                        transportSession,
+                        timestamp: previous.timestamp === undefined || timestamp > previous.timestamp
+                            ? timestamp
+                            : previous.timestamp,
+                    });
+                    return true;
+                }
+                this._openingSyncCapabilitiesByPeer.set(peerHash, {
+                    epoch: openingSession,
+                    capabilities,
+                    transportSession,
+                    timestamp,
+                });
+                return true;
+            }
+            if (transportSession === undefined || timestamp === undefined) {
+                // Test/in-process synthetic contexts predate signed envelope captures.
+                // They may exercise capability-number behavior, but can never authorize V2.
+                this._peerSyncCapabilities.set(peerHash, capabilities);
+                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 (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 ||
+                (previousCapabilities & senderGrantCapabilityMask) !==
+                    (nextCapabilities & senderGrantCapabilityMask);
+            this._peerSyncCapabilities.set(peerHash, nextCapabilities);
+            this._peerSyncCapabilitySessions.set(peerHash, transportSession);
+            this._peerSyncCapabilityTimestamps.set(peerHash, previousTimestamp === undefined ||
+                !sameTransportSession ||
+                timestamp > previousTimestamp
+                ? timestamp
+                : previousTimestamp);
+            if (generationAdvanced) {
+                this._v2Send.advancePeerCapability(peerHash);
+            }
+            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
@@ -2892,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) {
@@ -3679,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.
@@ -3748,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;
@@ -3793,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;
@@ -3828,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 &&
@@ -3920,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", {
@@ -3983,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.
@@ -3992,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();
@@ -4050,6 +4279,7 @@ let SharedLog = (() => {
             let isStoppedReplicating = false;
             let wasReplicatorBeforeDestructiveReset = false;
             let resetFailureLeaveEmitted = false;
+            let resetDeletionRollback;
             const publishConfirmedResetStop = (ownerHasRanges) => {
                 if (ownerHasRanges || resetFailureLeaveEmitted) {
                     return;
@@ -4090,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 };
@@ -4247,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 {
@@ -4269,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) {
@@ -6875,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 &&
@@ -7006,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);
@@ -7678,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 ??
@@ -8895,6 +9156,8 @@ let SharedLog = (() => {
                 ttl: LEADER_PLAN_CACHE_TTL_MS,
             });
             this._peerSyncCapabilities = new Map();
+            this._peerSyncCapabilitySessions = new Map();
+            this._peerSyncCapabilityTimestamps = new Map();
             this._liveRawGossipBatches = new Map();
             this._liveRawGossipFlushScheduled = false;
             this.coordinateToHash = new Cache({ max: 1e6, ttl: 1e4 });
@@ -8910,6 +9173,10 @@ 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)
                 ? options.replicate
                 : undefined;
@@ -9479,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;
             }
@@ -9691,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");
@@ -10025,10 +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);
+            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);
         }
@@ -10046,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)
@@ -10845,6 +11131,10 @@ let SharedLog = (() => {
                 this._openingSyncCapabilitiesByPeer?.clear();
                 this._gidPeersHistory?.clear();
                 this._peerSyncCapabilities?.clear();
+                this._peerSyncCapabilitySessions?.clear();
+                this._peerSyncCapabilityTimestamps?.clear();
+                this._v2Receive?.clearForClose();
+                this._v2Send?.clearForClose();
                 this._liveRawGossipBatches?.clear();
                 this._nativeSharedLogState?.clearGidPeers();
                 this._nativeBackbone?.clearGidPeers();
@@ -10907,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 {
@@ -10965,12 +11256,16 @@ let SharedLog = (() => {
                         }
                     }, 2_000);
                     try {
-                        await this.rpc
-                            .send(new AllReplicatingSegmentsMessage({ segments: [] }), {
-                            priority: CONVERGENCE_MESSAGE_PRIORITY,
-                            signal: abort.signal,
-                        })
-                            .catch(() => { });
+                        const reset = new AllReplicatingSegmentsMessage({ segments: [] });
+                        await Promise.all([
+                            this.rpc
+                                .send(reset, {
+                                priority: CONVERGENCE_MESSAGE_PRIORITY,
+                                signal: abort.signal,
+                            })
+                                .catch(() => { }),
+                            this._v2Send.sendTerminalReset(abort.signal),
+                        ]);
                     }
                     finally {
                         clearTimeout(abortTimer);
@@ -11047,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 {
@@ -11088,12 +11384,16 @@ let SharedLog = (() => {
                         }
                     }, 2_000);
                     try {
-                        await this.rpc
-                            .send(new AllReplicatingSegmentsMessage({ segments: [] }), {
-                            priority: CONVERGENCE_MESSAGE_PRIORITY,
-                            signal: abort.signal,
-                        })
-                            .catch(() => { });
+                        const reset = new AllReplicatingSegmentsMessage({ segments: [] });
+                        await Promise.all([
+                            this.rpc
+                                .send(reset, {
+                                priority: CONVERGENCE_MESSAGE_PRIORITY,
+                                signal: abort.signal,
+                            })
+                                .catch(() => { }),
+                            this._v2Send.sendTerminalReset(abort.signal),
+                        ]);
                     }
                     finally {
                         clearTimeout(abortTimer);
@@ -11508,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;
@@ -11555,17 +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)) {
+                if (!context.from.equals(this.node.identity.publicKey) &&
+                    !(msg instanceof RequestReplicationInfoV2Message) &&
+                    !isReplicationInfoV2Message(msg) &&
+                    !(msg instanceof AllReplicatingSegmentsMessage) &&
+                    !(msg instanceof AddedReplicationSegmentMessage) &&
+                    !(msg instanceof StoppedReplicating)) {
                     this._liveness.markReplicatorActivity(receiveFromHash);
                 }
                 const syncProfile = this._logProperties?.sync?.profile;
@@ -12881,6 +13182,7 @@ let SharedLog = (() => {
                         fromHash: receiveFromHash,
                         session: receiveSession,
                         lifecycleController: receiveReplicationLifecycleController,
+                        ownershipLifecycleController: receiveOwnershipLifecycleController,
                         receiveEpoch: receiveReplicationInfoReceiveEpoch,
                         syncProfile,
                         lease: peerReceiveLease,
@@ -12906,8 +13208,13 @@ 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;
+                            const capabilityTimestamp = context.message?.header?.timestamp;
                             // No await separates this from the capture above, so the captured
                             // window state is exact: the legacy re-read of the opening map here
                             // could never observe a different value.
@@ -12916,17 +13223,49 @@ let SharedLog = (() => {
                                 // A prior unsubscribe cleanup may still be ahead of this reconnect
                                 // barrier. Stage the new generation's one-shot advertisement so that
                                 // cleanup cannot erase it before the opening transition commits.
-                                this._openingSyncCapabilitiesByPeer.set(receiveFromHash, {
-                                    epoch: receiveSession,
+                                this.observePeerSyncCapabilities({
+                                    peerHash: receiveFromHash,
                                     capabilities: msg.capabilities,
+                                    transportSession: capabilityTransportSession,
+                                    timestamp: capabilityTimestamp,
+                                    openingSession: receiveSession,
                                 });
                             }
-                            else {
-                                this._peerSyncCapabilities.set(receiveFromHash, msg.capabilities);
+                            else if (this.observePeerSyncCapabilities({
+                                peerHash: receiveFromHash,
+                                capabilities: msg.capabilities,
+                                transportSession: capabilityTransportSession,
+                                timestamp: capabilityTimestamp,
+                            }) &&
+                                receiveSession?.phase === "open") {
+                                this.promoteReplicationInfoV2ReceiveCapability(context.from, receiveSession);
                             }
                         }
                         return;
                     }
+                    else if (msg instanceof RequestReplicationInfoV2Message) {
+                        const requiredCapabilities = SYNC_CAPABILITY_REPLICATION_INFO_V2_DECODE |
+                            SYNC_CAPABILITY_REPLICATION_INFO_V2_APPLY;
+                        if (receiveSession &&
+                            ((this._peerSyncCapabilities.get(receiveFromHash) ?? 0) &
+                                requiredCapabilities) ===
+                                requiredCapabilities &&
+                            this._peerSyncCapabilitySessions.get(receiveFromHash) ===
+                                context.message.header.session &&
+                            this._peerSyncCapabilityTimestamps.has(receiveFromHash) &&
+                            context.message.header.timestamp >
+                                this._peerSyncCapabilityTimestamps.get(receiveFromHash) &&
+                            this._v2Send.acceptRequest(msg, {
+                                from: context.from,
+                                peerSession: receiveSession,
+                                receiverTransportSession: context.message.header.session,
+                                capabilityTimestamp: this._peerSyncCapabilityTimestamps.get(receiveFromHash),
+                                requestTimestamp: context.message.header.timestamp,
+                            })) {
+                            this._liveness.markReplicatorActivity(receiveFromHash);
+                        }
+                        return;
+                    }
                     else if (await this.syncronizer.onMessage(msg, context)) {
                         return; // the syncronizer has handled the message
                     }
@@ -13162,6 +13501,7 @@ let SharedLog = (() => {
             }
             const segments = replicationSegments.map((x) => x.toReplicationRange());
             this.validatePersistedReplicationRangeSnapshot(segments);
+            this._v2Send.enqueueSnapshotForPeer(receiveFromHash);
             await this.rpc
                 .send(new AllReplicatingSegmentsMessage({ segments }), {
                 mode: new AcknowledgeDelivery({
@@ -13195,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;
@@ -13210,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
@@ -13234,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);
@@ -13241,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) {
@@ -13278,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) ||
@@ -13294,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({
@@ -15173,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) {
@@ -15183,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 {
@@ -15376,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,
             };
         }
@@ -15392,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;
@@ -15463,6 +16076,13 @@ let SharedLog = (() => {
             if (!ownsSubscriptionEpoch()) {
                 return;
             }
+            // 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);
             if (subscribed) {
                 const pendingOpeningCapabilities = this._openingSyncCapabilitiesByPeer.get(peerHash);
                 if (pendingOpeningCapabilities &&
@@ -15493,6 +16113,18 @@ let SharedLog = (() => {
                     const openingCapabilities = this._openingSyncCapabilitiesByPeer.get(peerHash);
                     if (openingCapabilities?.epoch === expectedSubscriptionEpoch) {
                         this._peerSyncCapabilities.set(peerHash, openingCapabilities.capabilities);
+                        if (openingCapabilities.transportSession === undefined) {
+                            this._peerSyncCapabilitySessions.delete(peerHash);
+                        }
+                        else {
+                            this._peerSyncCapabilitySessions.set(peerHash, openingCapabilities.transportSession);
+                        }
+                        if (openingCapabilities.timestamp === undefined) {
+                            this._peerSyncCapabilityTimestamps.delete(peerHash);
+                        }
+                        else {
+                            this._peerSyncCapabilityTimestamps.set(peerHash, openingCapabilities.timestamp);
+                        }
                         this._openingSyncCapabilitiesByPeer.delete(peerHash);
                     }
                     this._peerSessions.unblockReplicationInfo(peerHash);
@@ -15562,21 +16194,22 @@ let SharedLog = (() => {
             this._liveness._replicatorLivenessFailures.delete(peerHash);
             this._liveness.markReplicatorActivity(peerHash);
             this._peerSessions.markOpen(peerHash, expectedSubscriptionEpoch);
-            // Decode support is advertised independently from use permission. Every
-            // replication-info send below and in the announcement coordinator remains
-            // on the legacy wire format until a later receiver-led negotiation exists.
-            const receiveCapabilities = SYNC_CAPABILITY_REPLICATION_INFO_V2_DECODE |
-                (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();
@@ -15622,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) {