@peerbit/shared-log 16.0.23 → 16.0.25

package/dist/src/index.js

@@ -55,7 +55,7 @@ import { CoordinatePersistenceCoordinator, combineCoordinateDeleteHashes, isProm
 import { CPUUsageIntervalLag } from "./cpu.js";
 import { debouncedAccumulatorMap, } from "./debounce.js";
 import { CompatibilityModeRetiredError, NativeDurableCommitError, NoPeersError, PersistedDeliveryError, isNotStartedError, } from "./errors.js";
-import { EXCHANGE_HEADS_REPAIR_HINT, EntryWithRefs, ExchangeHeadsMessage, MAX_RAW_EXCHANGE_MESSAGE_SIZE, RawEntryWithRefs, RawExchangeHeadsMessage, RequestIPrune, RequestIPruneV2, ResponseIPrune, ResponseIPruneV2, SYNC_CAPABILITY_PERSISTED_ENTRY_RECEIPTS, SYNC_CAPABILITY_RAW_EXCHANGE_HEADS, SYNC_CAPABILITY_REPLICATION_INFO_V2_APPLY, SYNC_CAPABILITY_REPLICATION_INFO_V2_CONFIRM, 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 { EXCHANGE_HEADS_REPAIR_HINT, EntryWithRefs, ExchangeHeadsMessage, MAX_RAW_EXCHANGE_MESSAGE_SIZE, RawEntryWithRefs, RawExchangeHeadsMessage, RequestIPrune, RequestIPruneV2, ResponseIPrune, ResponseIPruneV2, SYNC_CAPABILITY_PERSISTED_ENTRY_RECEIPTS, SYNC_CAPABILITY_RAW_EXCHANGE_HEADS, SYNC_CAPABILITY_REPLICATION_INFO_V2_APPLY, SYNC_CAPABILITY_REPLICATION_INFO_V2_CONFIRM, SYNC_CAPABILITY_REPLICATION_INFO_V2_DECODE, SYNC_CAPABILITY_REPLICATION_INFO_V2_REARM, 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 { InstanceLifecycle } from "./instance-lifecycle.js";
 import { MAX_U32, MAX_U64, createNumbers, } from "./integers.js";
@@ -81,6 +81,54 @@ import { emitSyncProfileDuration, emitSyncProfileEvent, syncProfileStart, } from
 import { ConfirmEntriesMessage, RECENT_KNOWN_EXCHANGE_HEAD_SUPPRESSION_MS, RequestPersistedEntriesV1, SYNC_MESSAGE_PRIORITY, SimpleSyncronizer, } from "./sync/simple.js";
 import { groupByGid, tryGroupByGidSync } from "./utils.js";
 const getSharedLogFanoutService = (services) => services.fanout;
+const FANOUT_OPEN_METRICS = [
+    ["joinReqSent", "joinReqSent"],
+    ["joinAcceptReceived", "joinAcceptReceived"],
+    ["joinRejectReceived", "joinRejectReceived"],
+    ["bootstrapDialAttempts", "joinBootstrapDialAttempts"],
+    ["bootstrapDialFailures", "joinBootstrapDialFailures"],
+    ["candidateDialAttempts", "joinCandidateDialAttempts"],
+    ["candidateDialFailures", "joinCandidateDialFailures"],
+    ["connectedCandidateAttempts", "joinConnectedCandidateAttempts"],
+    ["unconnectedCandidateAttempts", "joinUnconnectedCandidateAttempts"],
+    ["joinReqTimeouts", "joinReqTimeouts"],
+    ["deadlineExpirations", "joinDeadlineExpirations"],
+];
+const snapshotFanoutOpenMetrics = (service, topic, root) => {
+    try {
+        const metrics = service.getChannelMetrics(topic, root);
+        return Object.fromEntries(FANOUT_OPEN_METRICS.map(([name, source]) => [name, metrics[source] ?? 0]));
+    }
+    catch {
+        return;
+    }
+};
+const emitFanoutOpenProfile = (properties) => {
+    if (!properties.profile)
+        return;
+    try {
+        const after = snapshotFanoutOpenMetrics(properties.service, properties.topic, properties.root);
+        const deltas = Object.fromEntries(FANOUT_OPEN_METRICS.map(([name]) => [
+            name,
+            (after?.[name] ?? 0) - (properties.before?.[name] ?? 0),
+        ]));
+        emitSyncProfileDuration(properties.profile, properties.startedAt, {
+            name: "sharedLog.open.fanout",
+            component: "shared-log",
+            messages: deltas.joinReqSent,
+            details: {
+                configured: true,
+                mode: properties.mode,
+                outcome: properties.outcome,
+                configuredTimeoutMs: properties.timeoutMs,
+                ...deltas,
+            },
+        });
+    }
+    catch {
+        // Diagnostics must not affect open correctness.
+    }
+};
 const createOneShotPeerReceiveLease = (releaseFn) => {
     let released = false;
     return {
@@ -133,6 +181,14 @@ export { ExchangeHeadsMessage, RawExchangeHeadsMessage, StashBackedRawExchangeHe
 export const logger = loggerFn("peerbit:shared-log");
 const warn = logger.newScope("warn");
 const traceLogger = logger.trace;
+const emitAdvisorySyncProfileDuration = (profile, startedAt, event) => {
+    try {
+        emitSyncProfileDuration(profile, startedAt, event);
+    }
+    catch {
+        // Diagnostics must not change open or provider-resolution correctness.
+    }
+};
 const canUseOptionalNativeModuleImports = () => {
     const scope = globalThis;
     const serviceWorkerGlobalScope = scope.ServiceWorkerGlobalScope;
@@ -1968,7 +2024,10 @@ let SharedLog = (() => {
             const peerHash = properties.target.hashcode();
             const receiverTransportSession = this.ownTransportSession();
             await this.rpc.send(new SyncCapabilitiesMessage({
-                capabilities: this.replicationInfoV2ReceiveCapabilities(),
+                capabilities: this.replicationInfoV2ReceiveCapabilities() |
+                    (properties.requestRemoteFullRearm
+                        ? SYNC_CAPABILITY_REPLICATION_INFO_V2_REARM
+                        : 0),
             }), {
                 mode: new AcknowledgeDelivery({
                     redundancy: 1,
@@ -2022,6 +2081,7 @@ let SharedLog = (() => {
                     peerSession: properties.peerSession,
                     receiveEpoch: properties.receiveEpoch,
                     signal: properties.signal,
+                    requestRemoteFullRearm: properties.requestRemoteFullRearm,
                 }),
                 onRequestError: (error) => {
                     if (isNotStartedError(error) ||
@@ -2252,18 +2312,40 @@ let SharedLog = (() => {
                         void this._onFanoutUnicast(detail).catch((error) => logger.error(error));
                     });
             channel.addEventListener("unicast", this._onFanoutUnicastFn);
+            const profile = this._logProperties?.sync?.profile;
+            const startedAt = syncProfileStart(profile);
+            const mode = resolvedRoot === fanoutService.publicKeyHash ? "root" : "node";
+            const before = profile
+                ? snapshotFanoutOpenMetrics(fanoutService, this.topic, resolvedRoot)
+                : undefined;
+            let outcome = "error";
             try {
                 const channelOptions = this.getFanoutChannelOptions(options);
-                if (resolvedRoot === fanoutService.publicKeyHash) {
+                if (mode === "root") {
                     await channel.openAsRoot(channelOptions);
+                    outcome = "opened";
                     return;
                 }
                 await channel.join(channelOptions, options.join);
+                outcome = "joined";
             }
             catch (error) {
                 this._closeFanoutChannel();
                 throw error;
             }
+            finally {
+                emitFanoutOpenProfile({
+                    profile,
+                    startedAt,
+                    service: fanoutService,
+                    topic: this.topic,
+                    root: resolvedRoot,
+                    mode,
+                    outcome,
+                    timeoutMs: options.join?.timeoutMs,
+                    before,
+                });
+            }
         }
         _closeFanoutChannel() {
             if (this._fanoutChannel) {
@@ -3369,7 +3451,7 @@ let SharedLog = (() => {
                 })) {
                 return undefined;
             }
-            return { capabilitySession, peerSession };
+            return { capabilitySession, peerSession, receiveEpoch };
         }
         async waitPersistedReceiptRetry(signal, ms) {
             try {
@@ -11083,6 +11165,8 @@ let SharedLog = (() => {
             const recoveringNativeDurableFailure = this._nativeDurableCommitFailure !== undefined;
             options = applySharedLogNativeDefaults(options, this.node
                 .sharedLogNativeDefaults);
+            const openProfile = options?.sync?.profile;
+            const openStartedAt = syncProfileStart(openProfile);
             this.replicas = {
                 min: options?.replicas?.min != null
                     ? typeof options?.replicas?.min === "number"
@@ -11249,6 +11333,7 @@ let SharedLog = (() => {
             this._isTrustedReplicator = options?.canReplicate;
             this.keep = options?.keep;
             this.pendingMaturity = new Map();
+            const localStateStartedAt = syncProfileStart(openProfile);
             const id = sha256Base64Sync(this.log.id);
             const [storage, logScope] = await Promise.all([
                 this.node.storage.sublevel(id),
@@ -11303,6 +11388,11 @@ let SharedLog = (() => {
             this._entryCoordinatesIndex = await replicationIndex.init({
                 schema: this.indexableDomain.constructorEntry,
             });
+            emitAdvisorySyncProfileDuration(openProfile, localStateStartedAt, {
+                name: "sharedLog.open.localState",
+                component: "shared-log",
+            });
+            const blockStoreStartedAt = syncProfileStart(openProfile);
             const deferStandaloneNativeRangePlanner = !!options?.nativeBackbone && options.nativeRangePlanner == null;
             await this.openNativeRangePlanner(deferStandaloneNativeRangePlanner ? false : options?.nativeRangePlanner);
             this._nativeBackbone = await this.openNativeBackbone(options?.nativeBackbone);
@@ -11343,6 +11433,14 @@ let SharedLog = (() => {
             else {
                 localBlocks = await createDefaultDurableBlockStore(storage);
             }
+            emitAdvisorySyncProfileDuration(openProfile, blockStoreStartedAt, {
+                name: "sharedLog.open.blockStore",
+                component: "shared-log",
+                details: {
+                    nativeBackbone: this._nativeBackbone != null,
+                    directoryConfigured: this.node.directory != null,
+                },
+            });
             this.remoteBlocks = new RemoteBlocks({
                 local: localBlocks,
                 publish: (message, options) => this.rpc.send(new BlocksMessage(message), options),
@@ -11352,30 +11450,61 @@ let SharedLog = (() => {
                 // compatible eager path with bounded validation and storage budgets.
                 eagerBlocks: options?.eagerBlocks ?? false,
                 resolveProviders: async (cid, opts) => {
+                    const profile = this._logProperties?.sync?.profile;
                     const maxPeers = 8;
+                    const excluded = new Set((opts?.exclude ?? []).slice(0, maxPeers));
+                    const lookupPeers = opts?.refresh
+                        ? Math.min(maxPeers * 2, maxPeers + excluded.size)
+                        : maxPeers;
+                    const resolutionStartedAt = syncProfileStart(profile);
                     const localCandidates = (await this.resolveCandidatePeersForHash(cid, {
                         signal: opts?.signal,
-                        maxPeers,
+                        maxPeers: lookupPeers,
                     })) ?? [];
-                    if (opts?.signal?.aborted)
+                    const emitResolution = profile
+                        ? (status, targets, directoryCandidates = 0, reachableCandidates = 0) => emitAdvisorySyncProfileDuration(profile, resolutionStartedAt, {
+                            name: "sharedLog.blocks.resolveProviders",
+                            component: "shared-log",
+                            count: targets,
+                            targets,
+                            details: {
+                                status,
+                                refresh: opts?.refresh === true,
+                                excluded: excluded.size,
+                                lookupPeers,
+                                localCandidates: localCandidates.length,
+                                directoryCandidates,
+                                reachableCandidates,
+                            },
+                        })
+                        : undefined;
+                    if (opts?.signal?.aborted) {
+                        emitResolution?.("aborted", 0);
                         return [];
+                    }
                     const locallyReachable = new Set(await this._getLocalReachablePeerHashes(this.topic));
+                    if (opts?.signal?.aborted) {
+                        emitResolution?.("aborted", 0, 0, locallyReachable.size);
+                        return [];
+                    }
                     const confirmed = this._checkedPrune.getConfirmedReplicators(cid);
                     const contacted = this._checkedPrune.getContactedReplicators(cid);
-                    const hasLiveCandidate = localCandidates.some((peer) => locallyReachable.has(peer) &&
-                        (confirmed?.has(peer) ||
-                            contacted?.has(peer) ||
-                            this.uniqueReplicators.has(peer)));
+                    const hasProviderEvidence = (peer) => confirmed?.has(peer) === true ||
+                        contacted?.has(peer) ||
+                        this.uniqueReplicators.has(peer);
+                    const hasLiveCandidate = localCandidates.some((peer) => locallyReachable.has(peer) && hasProviderEvidence(peer));
                     // Only reachability corroborated by provider/replicator evidence may
                     // bypass the initial CID lookup. Arbitrary bootstrap connections are
                     // useful fallbacks, but are not evidence that they hold this block.
                     if (hasLiveCandidate && !opts?.refresh) {
-                        return localCandidates;
+                        const selected = localCandidates.slice(0, maxPeers);
+                        emitResolution?.("local", selected.length, 0, locallyReachable.size);
+                        return selected;
                     }
                     let directoryProviders = [];
                     try {
                         const query = (namespace) => fanoutService?.queryProviders(namespace, {
-                            want: maxPeers,
+                            want: lookupPeers,
                             timeoutMs: 2_000,
                             queryTimeoutMs: 500,
                             bootstrapMaxPeers: 2,
@@ -11387,13 +11516,17 @@ let SharedLog = (() => {
                         ]);
                         for (const result of results) {
                             if (result.status === "fulfilled") {
-                                directoryProviders.push(...result.value);
+                                directoryProviders.push(...result.value.slice(0, lookupPeers));
                             }
                         }
                     }
                     catch {
                         // Ignore discovery failures; local evidence remains usable.
                     }
+                    if (opts?.signal?.aborted) {
+                        emitResolution?.("aborted", 0, directoryProviders.length, locallyReachable.size);
+                        return [];
+                    }
                     const selected = [];
                     const selectedSet = new Set();
                     const add = (peer) => {
@@ -11403,11 +11536,44 @@ let SharedLog = (() => {
                         selectedSet.add(peer);
                         selected.push(peer);
                     };
-                    for (let index = 0; selected.length < maxPeers &&
-                        (index < localCandidates.length || index < directoryProviders.length); index++) {
-                        add(localCandidates[index]);
-                        add(directoryProviders[index]);
+                    const append = (providers, includeExcluded, predicate) => {
+                        for (const provider of providers) {
+                            if (selected.length >= maxPeers)
+                                return;
+                            if (excluded.has(provider) === includeExcluded &&
+                                (!predicate || predicate(provider))) {
+                                add(provider);
+                            }
+                        }
+                    };
+                    const appendInterleaved = (includeExcluded) => {
+                        for (let index = 0; selected.length < maxPeers &&
+                            (index < localCandidates.length ||
+                                index < directoryProviders.length); index++) {
+                            const local = localCandidates[index];
+                            if (local && excluded.has(local) === includeExcluded)
+                                add(local);
+                            const directory = directoryProviders[index];
+                            if (directory && excluded.has(directory) === includeExcluded) {
+                                add(directory);
+                            }
+                        }
+                    };
+                    if (opts?.refresh) {
+                        // Retry results are wider than the regular eight-peer window. Prefer
+                        // untried reachable holders, then the remaining fresh directory
+                        // evidence, without discarding attempted peers as bounded transient-
+                        // failure fallbacks.
+                        append(directoryProviders, false, (peer) => locallyReachable.has(peer));
+                        append(localCandidates, false, (peer) => locallyReachable.has(peer) && hasProviderEvidence(peer));
+                        append(directoryProviders, false);
+                        append(localCandidates, false);
+                    }
+                    else {
+                        appendInterleaved(false);
                     }
+                    appendInterleaved(true);
+                    emitResolution?.("directory", selected.length, directoryProviders.length, locallyReachable.size);
                     return selected;
                 },
                 watchProviders: fanoutService
@@ -11454,7 +11620,13 @@ let SharedLog = (() => {
                     }
                     : undefined,
             });
-            const remoteBlocksStartPromise = this.remoteBlocks.start();
+            const remoteBlocksStartedAt = syncProfileStart(openProfile);
+            const remoteBlocksStartPromise = this.remoteBlocks.start().then(() => {
+                emitAdvisorySyncProfileDuration(openProfile, remoteBlocksStartedAt, {
+                    name: "sharedLog.open.remoteBlocks",
+                    component: "shared-log",
+                });
+            });
             const hasIndexedReplicationInfo = (await this.replicationIndex.count({
                 query: [
                     new StringMatch({
@@ -11613,6 +11785,7 @@ let SharedLog = (() => {
             // joins rely on: a replicate:false observer syncing a head whose parents
             // are not local would fail block resolution, and Log.join treats that as
             // recoverable and skips the entry without persisting anything.
+            const lowerLogStartedAt = syncProfileStart(openProfile);
             await this.log.open(this.remoteBlocks, this.node.identity, {
                 keychain: this.node.services.keychain,
                 resolveRemotePeers: (hash, options) => this.resolveCandidatePeersForHash(hash, {
@@ -11643,6 +11816,10 @@ let SharedLog = (() => {
                 },
                 indexer: logIndex,
             });
+            emitAdvisorySyncProfileDuration(openProfile, lowerLogStartedAt, {
+                name: "sharedLog.open.lowerLog",
+                component: "shared-log",
+            });
             this._persistedReceiptStorage = this.resolvePersistedReceiptStorage();
             try {
                 const recovered = await this.recoverNativeStrictDurableTransactionIntent();
@@ -11694,6 +11871,7 @@ let SharedLog = (() => {
                     ((event) => {
                         void this.runSubscriptionChangeCallback(() => this._onUnsubscription(event));
                     });
+            const communicationStartedAt = syncProfileStart(openProfile);
             await Promise.all([
                 this.rpc.open({
                     queryType: TransportMessage,
@@ -11705,6 +11883,11 @@ let SharedLog = (() => {
                 this.node.services.pubsub.addEventListener("subscribe", this._onSubscriptionFn),
                 this.node.services.pubsub.addEventListener("unsubscribe", this._onUnsubscriptionFn),
             ]);
+            emitAdvisorySyncProfileDuration(openProfile, communicationStartedAt, {
+                name: "sharedLog.open.rpcSubscriptions",
+                component: "shared-log",
+            });
+            const providerChannelStartedAt = syncProfileStart(openProfile);
             const fanoutOpenPromise = this._openFanoutChannel(options?.fanout);
             // Mark previously-owned replication ranges as "new" only when they already exist.
             // Fresh opens have nothing to touch here, so skip the extra scan/write entirely.
@@ -11712,30 +11895,57 @@ let SharedLog = (() => {
                 ? this.updateTimestampOfOwnedReplicationRanges()
                 : Promise.resolve();
             await Promise.all([fanoutOpenPromise, updateOwnedReplicationPromise]);
+            emitAdvisorySyncProfileDuration(openProfile, providerChannelStartedAt, {
+                name: "sharedLog.open.providerAndOwnership",
+                component: "shared-log",
+                details: { indexedReplicationInfo: hasIndexedReplicationInfo },
+            });
             // if we had a previous session with replication info, and new replication info dictates that we unreplicate
             // we should do that. Otherwise if options is a unreplication we dont need to do anything because
             // we are already unreplicated (as we are just opening)
             const isUnreplicationOptionsDefined = isUnreplicationOptions(options?.replicate);
             const canResumeReplication = hasIndexedReplicationInfo &&
                 (await isReplicationOptionsDependentOnPreviousState(options?.replicate, this.replicationIndex, this.node.identity.publicKey));
+            const replicationStartedAt = syncProfileStart(openProfile);
+            let replicationAction;
             if (hasIndexedReplicationInfo && isUnreplicationOptionsDefined) {
+                replicationAction = "replace";
                 await this.replicate(options?.replicate, { checkDuplicates: true });
             }
             else if (canResumeReplication) {
+                replicationAction = "resume";
                 // dont do anthing since we are alread replicating stuff
             }
             else {
+                replicationAction = "reset";
                 await this.replicate(options?.replicate, {
                     checkDuplicates: true,
                     reset: true,
                 });
             }
+            emitAdvisorySyncProfileDuration(openProfile, replicationStartedAt, {
+                name: "sharedLog.open.replication",
+                component: "shared-log",
+                details: {
+                    hadIndexedState: hasIndexedReplicationInfo,
+                    action: replicationAction,
+                },
+            });
+            const synchronizerStartedAt = syncProfileStart(openProfile);
             await this.syncronizer.open();
+            emitAdvisorySyncProfileDuration(openProfile, synchronizerStartedAt, {
+                name: "sharedLog.open.synchronizer",
+                component: "shared-log",
+            });
             this.interval = setInterval(() => {
                 void this.rebalanceParticipationDebounced?.call();
             }, RECALCULATE_PARTICIPATION_DEBOUNCE_INTERVAL);
             this._instanceLifecycle.markOpenComplete();
             this.scheduleReplicationStatusRefresh();
+            emitAdvisorySyncProfileDuration(openProfile, openStartedAt, {
+                name: "sharedLog.open.total",
+                component: "shared-log",
+            });
         }
         toNativeReplicationRange(range) {
             return {
@@ -15760,6 +15970,13 @@ let SharedLog = (() => {
                         if (!context.from.equals(this.node.identity.publicKey)) {
                             const capabilityTransportSession = context.message?.header?.session;
                             const capabilityTimestamp = context.message?.header?.timestamp;
+                            const previousCapabilitySession = this._peerSyncCapabilitySessions.get(receiveFromHash);
+                            const previousCapabilityTimestamp = this._peerSyncCapabilityTimestamps.get(receiveFromHash);
+                            const requestsRemoteFullRearm = (msg.capabilities & SYNC_CAPABILITY_REPLICATION_INFO_V2_REARM) !==
+                                0;
+                            // The rearm bit is a one-shot authenticated command, not a sticky
+                            // negotiated capability. Store and promote only the steady bits.
+                            const steadyCapabilities = msg.capabilities & ~SYNC_CAPABILITY_REPLICATION_INFO_V2_REARM;
                             // 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.
@@ -15770,7 +15987,7 @@ let SharedLog = (() => {
                                 // cleanup cannot erase it before the opening transition commits.
                                 this.observePeerSyncCapabilities({
                                     peerHash: receiveFromHash,
-                                    capabilities: msg.capabilities,
+                                    capabilities: steadyCapabilities,
                                     transportSession: capabilityTransportSession,
                                     timestamp: capabilityTimestamp,
                                     openingSession: receiveSession,
@@ -15779,12 +15996,34 @@ let SharedLog = (() => {
                             else {
                                 const observed = this.observePeerSyncCapabilities({
                                     peerHash: receiveFromHash,
-                                    capabilities: msg.capabilities,
+                                    capabilities: steadyCapabilities,
                                     transportSession: capabilityTransportSession,
                                     timestamp: capabilityTimestamp,
                                 });
                                 if (observed && receiveSession?.phase === "open") {
                                     this.promoteReplicationInfoV2ReceiveCapability(context.from, receiveSession);
+                                    const freshExactRearm = requestsRemoteFullRearm &&
+                                        capabilityTransportSession !== undefined &&
+                                        capabilityTimestamp !== undefined &&
+                                        previousCapabilitySession === capabilityTransportSession &&
+                                        previousCapabilityTimestamp !== undefined &&
+                                        capabilityTimestamp > previousCapabilityTimestamp;
+                                    if (freshExactRearm &&
+                                        this._v2Receive.isCurrentActive({
+                                            peerHash: receiveFromHash,
+                                            peerSession: receiveSession,
+                                            receiveEpoch: this._peerSessions.receiveEpoch(receiveFromHash),
+                                            senderTransportSession: capabilityTransportSession,
+                                        })) {
+                                        // Rotate the receiver grant/challenge before requesting Full. A
+                                        // sender rebuilt from no state starts at sequence one, which an
+                                        // active receiver's old sequence fence must otherwise reject.
+                                        this._v2Receive.advanceRecovery({
+                                            peerHash: receiveFromHash,
+                                            peerSession: receiveSession,
+                                            receiveEpoch: this._peerSessions.receiveEpoch(receiveFromHash),
+                                        });
+                                    }
                                 }
                                 else if (observed && receiveSession === null) {
                                     // A capability can arrive before the sender's topic Subscribe after
@@ -16649,8 +16888,8 @@ let SharedLog = (() => {
             }
             throwIfInactive();
         }
-        nudgePersistedReceiptPeerReadiness(publicKey) {
-            if (this.closed)
+        nudgePersistedReceiptPeerReadiness(publicKey, signal) {
+            if (this.closed || signal.aborted)
                 return;
             const peerHash = publicKey.hashcode();
             const peerSession = this._peerSessions.current(peerHash);
@@ -16680,6 +16919,20 @@ let SharedLog = (() => {
                 peerSession,
                 receiveEpoch,
             });
+            const receiptTarget = this.persistedReceiptPeerSession(peerHash);
+            if (receiptTarget &&
+                !this._v2Send.hasCurrentStateForPeer({
+                    peerHash,
+                    peerSession: receiptTarget.peerSession,
+                    receiverTransportSession: receiptTarget.capabilitySession,
+                })) {
+                this._v2Receive.reAdvertiseLocalCapabilityForRemoteFull({
+                    peerHash,
+                    peerSession: receiptTarget.peerSession,
+                    receiveEpoch: receiptTarget.receiveEpoch,
+                    signal,
+                });
+            }
             this.scheduleReplicationInfoV2Recovery(publicKey);
         }
         /**
@@ -16873,17 +17126,25 @@ let SharedLog = (() => {
                     throw new AbortError("Persisted-receipt readiness wait settled");
                 }
             };
+            const recoveryDelayMs = Math.max(50, Math.min(1_000, this.waitForReplicatorRequestIntervalMs));
             const armRecoveryTick = () => {
                 if (settled || recoveryTimer)
                     return;
-                const delayMs = Math.max(50, Math.min(1_000, this.waitForReplicatorRequestIntervalMs));
                 recoveryTimer = setTimeout(() => {
                     recoveryTimer = undefined;
                     if (!continueWait())
                         return;
-                    this.nudgePersistedReceiptPeerReadiness(key);
+                    this.nudgePersistedReceiptPeerReadiness(key, operationSignal);
+                    if (checkInFlight) {
+                        // Confirmation can legitimately span several recovery intervals.
+                        // Keep repairing the exact current generation without aborting its
+                        // one application-confirmation waiter on every tick.
+                        rerun = true;
+                        armRecoveryTick();
+                        return;
+                    }
                     scheduleCheck();
-                }, delayMs);
+                }, recoveryDelayMs);
                 recoveryTimer.unref?.();
             };
             const runCheck = async () => {
@@ -16913,6 +17174,11 @@ let SharedLog = (() => {
                         snapshot.reason === "replication-confirmation-pending") {
                         const target = this.persistedReceiptPeerSession(peerHash);
                         if (target) {
+                            // A confirmation waiter cannot create an outbound V2 stream when
+                            // that exact session state is missing. Nudge first, then keep the
+                            // recovery tick alive while the single confirmation wait remains.
+                            this.nudgePersistedReceiptPeerReadiness(key, operationSignal);
+                            armRecoveryTick();
                             const currentConfirmationController = new AbortController();
                             confirmationController = currentConfirmationController;
                             try {
@@ -16957,7 +17223,7 @@ let SharedLog = (() => {
                     }
                     if (!continueWait())
                         return;
-                    this.nudgePersistedReceiptPeerReadiness(key);
+                    this.nudgePersistedReceiptPeerReadiness(key, operationSignal);
                 }
                 catch (error) {
                     if (!settled)