@peerbit/shared-log 16.0.23 → 16.0.25

package/src/index.ts

@@ -169,6 +169,7 @@ import {
 	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,
@@ -322,6 +323,86 @@ type SharedLogServicesWithFanout = {
 const getSharedLogFanoutService = (services: unknown): FanoutTree | undefined =>
 	(services as SharedLogServicesWithFanout).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"],
+] as const;
+
+type FanoutOpenMetric = (typeof FANOUT_OPEN_METRICS)[number][0];
+type FanoutOpenMetricSnapshot = Record<FanoutOpenMetric, number>;
+
+const snapshotFanoutOpenMetrics = (
+	service: FanoutTree,
+	topic: string,
+	root: string,
+): FanoutOpenMetricSnapshot | undefined => {
+	try {
+		const metrics = (
+			service as FanoutTree & {
+				getChannelMetrics: (
+					topic: string,
+					root: string,
+				) => Record<string, number>;
+			}
+		).getChannelMetrics(topic, root);
+		return Object.fromEntries(
+			FANOUT_OPEN_METRICS.map(([name, source]) => [name, metrics[source] ?? 0]),
+		) as FanoutOpenMetricSnapshot;
+	} catch {
+		return;
+	}
+};
+
+const emitFanoutOpenProfile = (properties: {
+	profile?: SyncProfileFn;
+	startedAt: number;
+	service: FanoutTree;
+	topic: string;
+	root: string;
+	mode: "root" | "node";
+	outcome: "error" | "opened" | "joined";
+	timeoutMs?: number;
+	before?: FanoutOpenMetricSnapshot;
+}) => {
+	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),
+			]),
+		) as FanoutOpenMetricSnapshot;
+		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.
+	}
+};
+
 type PendingIHave<T> = {
 	resetTimeout: () => void;
 	requesting: Map<string, Uint8Array>;
@@ -471,6 +552,18 @@ export const logger = loggerFn("peerbit:shared-log");
 const warn = logger.newScope("warn");
 const traceLogger = logger.trace as typeof logger.trace & { enabled?: boolean };
 
+const emitAdvisorySyncProfileDuration = (
+	profile: SyncProfileFn | undefined,
+	startedAt: number,
+	event: Parameters<typeof emitSyncProfileDuration>[2],
+): void => {
+	try {
+		emitSyncProfileDuration(profile, startedAt, event);
+	} catch {
+		// Diagnostics must not change open or provider-resolution correctness.
+	}
+};
+
 const canUseOptionalNativeModuleImports = (): boolean => {
 	const scope = globalThis as {
 		ServiceWorkerGlobalScope?: unknown;
@@ -3979,6 +4072,7 @@ export class SharedLog<
 		peerSession: PeerSession;
 		receiveEpoch: object | null;
 		signal: AbortSignal;
+		requestRemoteFullRearm?: boolean;
 	}): Promise<
 		{ receiverTransportSession: bigint; requestNotBeforeMs: number } | undefined
 	> {
@@ -3986,7 +4080,11 @@ export class SharedLog<
 		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({
@@ -4053,6 +4151,7 @@ export class SharedLog<
 					peerSession: properties.peerSession as PeerSession,
 					receiveEpoch: properties.receiveEpoch,
 					signal: properties.signal,
+					requestRemoteFullRearm: properties.requestRemoteFullRearm,
 				}),
 			onRequestError: (error) => {
 				if (
@@ -4341,16 +4440,38 @@ export class SharedLog<
 			});
 		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" | "opened" | "joined" = "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,
+			});
 		}
 	}
 
@@ -5737,7 +5858,13 @@ export class SharedLog<
 
 	private persistedReceiptPeerSession(
 		peerHash: string,
-	): { capabilitySession: bigint; peerSession: PeerSession } | undefined {
+	):
+		| {
+				capabilitySession: bigint;
+				peerSession: PeerSession;
+				receiveEpoch: object | null;
+		  }
+		| undefined {
 		// This is a hot receipt/transfer-loop predicate. Keep it allocation-light,
 		// while mirroring every exact-session gate in
 		// persistedReceiptReadinessCandidate (which additionally creates public
@@ -5770,7 +5897,7 @@ export class SharedLog<
 		) {
 			return undefined;
 		}
-		return { capabilitySession, peerSession };
+		return { capabilitySession, peerSession, receiveEpoch };
 	}
 
 	private async waitPersistedReceiptRetry(
@@ -17088,6 +17215,8 @@ export class SharedLog<
 			(this.node as unknown as NodeWithSharedLogNativeDefaults)
 				.sharedLogNativeDefaults,
 		);
+		const openProfile = options?.sync?.profile;
+		const openStartedAt = syncProfileStart(openProfile);
 		this.replicas = {
 			min:
 				options?.replicas?.min != null
@@ -17318,6 +17447,7 @@ export class SharedLog<
 		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),
@@ -17373,6 +17503,11 @@ export class 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(
@@ -17423,6 +17558,14 @@ export class SharedLog<
 				storage as unknown as DurableBlockSublevelStore,
 			);
 		}
+		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) =>
@@ -17433,38 +17576,76 @@ export class 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) return [];
+				const emitResolution = profile
+					? (
+							status: "aborted" | "local" | "directory",
+							targets: number,
+							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 hasProviderEvidence = (peer: string) =>
+					confirmed?.has(peer) === true ||
+					contacted?.has(peer) ||
+					this.uniqueReplicators.has(peer);
 				const hasLiveCandidate = localCandidates.some(
-					(peer) =>
-						locallyReachable.has(peer) &&
-						(confirmed?.has(peer) ||
-							contacted?.has(peer) ||
-							this.uniqueReplicators.has(peer)),
+					(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: string[] = [];
 				try {
 					const query = (namespace: string) =>
 						fanoutService?.queryProviders(namespace, {
-							want: maxPeers,
+							want: lookupPeers,
 							timeoutMs: 2_000,
 							queryTimeoutMs: 500,
 							bootstrapMaxPeers: 2,
@@ -17476,12 +17657,21 @@ export class 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: string[] = [];
 				const selectedSet = new Set<string>();
@@ -17492,15 +17682,62 @@ export class 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: readonly string[],
+					includeExcluded: boolean,
+					predicate?: (provider: string) => boolean,
+				) => {
+					for (const provider of providers) {
+						if (selected.length >= maxPeers) return;
+						if (
+							excluded.has(provider) === includeExcluded &&
+							(!predicate || predicate(provider))
+						) {
+							add(provider);
+						}
+					}
+				};
+				const appendInterleaved = (includeExcluded: boolean) => {
+					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
@@ -17548,7 +17785,13 @@ export class 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: [
@@ -17764,6 +18007,7 @@ export class 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) =>
@@ -17795,6 +18039,10 @@ export class SharedLog<
 			},
 			indexer: logIndex,
 		});
+		emitAdvisorySyncProfileDuration(openProfile, lowerLogStartedAt, {
+			name: "sharedLog.open.lowerLog",
+			component: "shared-log",
+		});
 		this._persistedReceiptStorage = this.resolvePersistedReceiptStorage();
 		try {
 			const recovered =
@@ -17859,6 +18107,7 @@ export class SharedLog<
 					this._onUnsubscription(event),
 				);
 			});
+		const communicationStartedAt = syncProfileStart(openProfile);
 		await Promise.all([
 			this.rpc.open({
 				queryType: TransportMessage,
@@ -17877,7 +18126,12 @@ export class SharedLog<
 				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.
@@ -17885,6 +18139,11 @@ export class 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
@@ -17902,17 +18161,35 @@ export class SharedLog<
 				this.node.identity.publicKey,
 			));
 
+		const replicationStartedAt = syncProfileStart(openProfile);
+		let replicationAction: "replace" | "resume" | "reset";
 		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();
@@ -17920,6 +18197,10 @@ export class SharedLog<
 
 		this._instanceLifecycle!.markOpenComplete();
 		this.scheduleReplicationStatusRefresh();
+		emitAdvisorySyncProfileDuration(openProfile, openStartedAt, {
+			name: "sharedLog.open.total",
+			component: "shared-log",
+		});
 	}
 
 	private toNativeReplicationRange(
@@ -22900,6 +23181,17 @@ export class 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.
@@ -22912,7 +23204,7 @@ export class 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!,
@@ -22920,7 +23212,7 @@ export class SharedLog<
 						} else {
 							const observed = this.observePeerSyncCapabilities({
 								peerHash: receiveFromHash,
-								capabilities: msg.capabilities,
+								capabilities: steadyCapabilities,
 								transportSession: capabilityTransportSession,
 								timestamp: capabilityTimestamp,
 							});
@@ -22929,6 +23221,33 @@ export class SharedLog<
 									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
 								// reconnect. Ask that authenticated peer for its authoritative
@@ -24059,8 +24378,11 @@ export class SharedLog<
 		throwIfInactive();
 	}
 
-	private nudgePersistedReceiptPeerReadiness(publicKey: PublicSignKey): void {
-		if (this.closed) return;
+	private nudgePersistedReceiptPeerReadiness(
+		publicKey: PublicSignKey,
+		signal: AbortSignal,
+	): void {
+		if (this.closed || signal.aborted) return;
 		const peerHash = publicKey.hashcode();
 		const peerSession = this._peerSessions.current(peerHash);
 		if (
@@ -24091,6 +24413,22 @@ export class 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);
 	}
 
@@ -24359,18 +24697,26 @@ export class 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 () => {
@@ -24403,6 +24749,11 @@ export class SharedLog<
 				) {
 					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 {
@@ -24447,7 +24798,7 @@ export class SharedLog<
 					}
 				}
 				if (!continueWait()) return;
-				this.nudgePersistedReceiptPeerReadiness(key);
+				this.nudgePersistedReceiptPeerReadiness(key, operationSignal);
 			} catch (error) {
 				if (!settled) reject(error);
 			} finally {