@peerbit/shared-log 16.0.29 → 16.0.31

package/src/index.ts

@@ -564,7 +564,7 @@ const emitAdvisorySyncProfileDuration = (
 	try {
 		emitSyncProfileDuration(profile, startedAt, event);
 	} catch {
-		// Diagnostics must not change open or provider-resolution correctness.
+		// Advisory diagnostics must not change replication or lifecycle behavior.
 	}
 };
 
@@ -4033,7 +4033,13 @@ export class SharedLog<
 				this._repairMetrics["join-warmup"].simpleFallbackPasses += 1;
 			},
 			sendEntriesSimple: (target, entries, options) =>
-				this.sendRepairEntriesWithTransport(target, entries, "simple", options),
+				this.sendRepairEntriesWithTransport(
+					target,
+					entries,
+					"simple",
+					options,
+					"join-warmup",
+				),
 			logError: (error) => logger.error(error),
 		});
 	}
@@ -6346,6 +6352,95 @@ export class SharedLog<
 				records.size,
 			);
 		const signal = deadline.signal;
+		const recoveryController = new AbortController();
+		const recoverySignal = AbortSignal.any([signal, recoveryController.signal]);
+		const recoveryByPeer = new Map<
+			string,
+			{
+				controller: AbortController;
+				timer: ReturnType<typeof setTimeout>;
+			}
+		>();
+		let recoveryCursor = 0;
+		const recoverSelectedPeers = (selected: Set<string>) => {
+			// Recovery is advisory work, not a receipt or a replacement leader plan.
+			// Never occupy transfer/request slots while waiting for it. The separate
+			// bounded pool rotates through fresh candidates so quiet/incomplete peers
+			// cannot indefinitely hide a later recoverable peer.
+			for (const [peer, state] of recoveryByPeer) {
+				if (!selected.has(peer)) {
+					clearTimeout(state.timer);
+					state.controller.abort();
+				}
+			}
+			const peers = [...selected];
+			for (
+				let visited = 0;
+				visited < peers.length &&
+				recoveryByPeer.size < MAX_PERSISTED_RECEIPT_REQUESTS_GLOBAL &&
+				!recoverySignal.aborted;
+				visited++
+			) {
+				const peer = peers[recoveryCursor++ % peers.length]!;
+				if (recoveryByPeer.has(peer)) continue;
+				const current = this.persistedReceiptPeerSession(peer);
+				if (
+					current &&
+					this._v2Send.isLatestConfirmedForPeer({
+						peerHash: peer,
+						peerSession: current.peerSession,
+						receiverTransportSession: current.capabilitySession,
+					})
+				) {
+					continue;
+				}
+				const expiresAt = Math.min(
+					deadline.deadline,
+					Date.now() + MAX_PERSISTED_RECEIPT_ATTEMPT_MS,
+				);
+				const controller = new AbortController();
+				const attemptSignal = AbortSignal.any([
+					recoverySignal,
+					controller.signal,
+				]);
+				const timer = setTimeout(
+					() => controller.abort(),
+					Math.max(1, expiresAt - Date.now()),
+				);
+				timer.unref?.();
+				const state = { controller, timer };
+				recoveryByPeer.set(peer, state);
+				void (async () => {
+					// Resolve only an authenticated transport-cache key. Keep this slot
+					// reserved until the lookup actually settles, even if a custom
+					// resolver ignores cancellation, rather than launching duplicates.
+					const key = await this._resolvePublicKeyFromHash(peer);
+					if (
+						attemptSignal.aborted ||
+						!key ||
+						key.hashcode() !== peer ||
+						Date.now() >= expiresAt
+					) {
+						return;
+					}
+					// Reuse the exact-session watchdog, capability/subscriber recovery,
+					// and replacement-session handling from the public preflight. Its
+					// result is ignored: settlement still checks the exact entry leaders
+					// and accepts only the subsequent durable, session-bound receipts.
+					await this.waitForPersistedReceiptPeerReadiness(key, {
+						timeout: Math.max(1, expiresAt - Date.now()),
+						signal: attemptSignal,
+					});
+				})()
+					.catch(() => undefined)
+					.finally(() => {
+						clearTimeout(timer);
+						if (recoveryByPeer.get(peer) === state) {
+							recoveryByPeer.delete(peer);
+						}
+					});
+			}
+		};
 		let maxAttemptMs = MAX_PERSISTED_RECEIPT_ATTEMPT_MS;
 		let initialTransferPending = transferOnFirstRound;
 		let needsInitialLeaderCheck = true;
@@ -6412,6 +6507,7 @@ export class SharedLog<
 				// transport epoch. A revision/session change purges them before they can
 				// survive an away-and-back leader transition or combine with a later peer.
 				const hashesByPeer = new Map<string, string[]>();
+				const recoveryCandidates = new Set<string>();
 				const entryArray = [...records.values()];
 				const leadersByEntry = await this.planPersistedDeliveryLeaders(
 					entryArray,
@@ -6456,6 +6552,7 @@ export class SharedLog<
 					if (acknowledgements.size >= minAcks) continue;
 					for (const peer of leaders.keys()) {
 						if (peer === selfHash) continue;
+						recoveryCandidates.add(peer);
 						const current = this.persistedReceiptPeerSession(peer);
 						if (!current) continue;
 						if (acknowledgements.has(peer)) continue;
@@ -6465,6 +6562,7 @@ export class SharedLog<
 					}
 				}
 				if (!isRoundOwnershipCurrent()) continue;
+				recoverSelectedPeers(recoveryCandidates);
 
 				const operationQueue = new PQueue({
 					concurrency: MAX_PERSISTED_RECEIPT_REQUESTS_GLOBAL,
@@ -6825,6 +6923,11 @@ export class SharedLog<
 			}
 			throw new PersistedDeliveryError(error, committedHashes);
 		} finally {
+			recoveryController.abort();
+			for (const state of recoveryByPeer.values()) {
+				clearTimeout(state.timer);
+				state.controller.abort();
+			}
 			if (ownedDeadline) deadline.dispose();
 		}
 	}
@@ -10639,6 +10742,7 @@ export class SharedLog<
 			isStillCurrent?: () => boolean;
 			signal?: AbortSignal;
 		},
+		mode?: RepairDispatchMode,
 	) {
 		const isStillCurrent = options?.isStillCurrent ?? (() => true);
 		if (!isStillCurrent()) {
@@ -10646,53 +10750,87 @@ export class SharedLog<
 		}
 		const unknownEntries = new Map<string, RepairDispatchEntry<R>>();
 		const knownHashes: string[] = [];
-		for (const [hash, entry] of entries) {
-			if (
-				(options?.bypassRecentKnownPeers ||
-					!this.isEntryRecentlyKnownByPeer(
-						hash,
-						target,
-						RECENT_KNOWN_REPAIR_SUPPRESSION_MS,
-					)) &&
-				(options?.bypassKnownPeers || !this.isEntryKnownByPeer(hash, target))
-			) {
-				unknownEntries.set(hash, entry);
-			} else {
-				knownHashes.push(hash);
+		const profile = this._logProperties?.sync?.profile;
+		const startedAt = syncProfileStart(profile);
+		const inputEntries = profile ? entries.size : 0;
+		let selectedEntries = 0;
+		let lastObservedCurrent = true;
+		let outcome = "stale";
+		try {
+			for (const [hash, entry] of entries) {
+				if (
+					(options?.bypassRecentKnownPeers ||
+						!this.isEntryRecentlyKnownByPeer(
+							hash,
+							target,
+							RECENT_KNOWN_REPAIR_SUPPRESSION_MS,
+						)) &&
+					(options?.bypassKnownPeers || !this.isEntryKnownByPeer(hash, target))
+				) {
+					unknownEntries.set(hash, entry);
+				} else {
+					knownHashes.push(hash);
+				}
 			}
-		}
-		if (!isStillCurrent()) {
-			return;
-		}
-		this.clearRepairFrontierHashes(target, knownHashes);
-		if (unknownEntries.size === 0) {
-			return;
-		}
-		if (transport === "simple") {
-			// Fallback repair should not depend on the target completing the
-			// RequestMaybeSync -> ResponseMaybeSync round trip.
-			await this.pushRepairEntries(
-				target,
-				unknownEntries,
-				isStillCurrent,
-				options?.signal,
-			);
-			return;
-		}
-
-		const syncEntries = this._logProperties?.sync?.priority
-			? (this._coordinates.materializeRepairDispatchEntries(
+			// A custom synchronizer may mutate the Map once it receives it.
+			if (profile) selectedEntries = unknownEntries.size;
+			if (!isStillCurrent()) return;
+			this.clearRepairFrontierHashes(target, knownHashes);
+			if (unknownEntries.size === 0) {
+				outcome = "known-suppressed";
+				return;
+			}
+			if (transport === "simple") {
+				// Observe only checks the lower path already makes, without adding
+				// lifecycle decisions or wrapping the disabled-profiling path.
+				const dispatchIsStillCurrent = profile
+					? () => (lastObservedCurrent = isStillCurrent())
+					: isStillCurrent;
+				// Fallback repair does not wait for the maybe-sync round trip.
+				await this.pushRepairEntries(
+					target,
 					unknownEntries,
-				) as unknown as Map<string, SyncEntryCoordinates<R>>)
-			: (unknownEntries as Map<string, SyncEntryCoordinates<R>>);
-		if (!isStillCurrent()) {
-			return;
+					dispatchIsStillCurrent,
+					options?.signal,
+				);
+			} else {
+				const syncEntries = this._logProperties?.sync?.priority
+					? (this._coordinates.materializeRepairDispatchEntries(
+							unknownEntries,
+						) as unknown as Map<string, SyncEntryCoordinates<R>>)
+					: (unknownEntries as Map<string, SyncEntryCoordinates<R>>);
+				if (!isStillCurrent()) return;
+				await this.syncronizer.onMaybeMissingEntries({
+					entries: syncEntries,
+					targets: [target],
+					signal: options?.signal,
+				});
+			}
+			outcome = !lastObservedCurrent
+				? "stale"
+				: options?.signal?.aborted
+					? "cancelled"
+					: "dispatched";
+		} catch (error) {
+			outcome = "error";
+			throw error;
+		} finally {
+			if (profile) {
+				emitAdvisorySyncProfileDuration(profile, startedAt, {
+					name: "sharedLog.repair.dispatch",
+					component: "shared-log",
+					entries: inputEntries,
+					count: selectedEntries,
+					targets: 1,
+					details: {
+						mode,
+						transport,
+						outcome,
+						knownSuppressedEntries: knownHashes.length,
+					},
+				});
+			}
 		}
-		await this.syncronizer.onMaybeMissingEntries({
-			entries: syncEntries,
-			targets: [target],
-			signal: options?.signal,
-		});
 	}
 
 	private async sendMaybeMissingEntriesNow(
@@ -10776,6 +10914,7 @@ export class SharedLog<
 						this.isRepairLifecycleActive(repairLifecycleController),
 					signal: repairLifecycleController.signal,
 				},
+				options.mode,
 			),
 		).catch((error: any) => logger.error(error));
 	}
@@ -11166,6 +11305,7 @@ export class SharedLog<
 							this.isRepairLifecycleActive(repairLifecycleController),
 						signal: repairLifecycleController.signal,
 					},
+					options.mode,
 				),
 			).catch((error: any) => logger.error(error));
 		};
@@ -11309,6 +11449,18 @@ export class SharedLog<
 		repairLifecycleController: AbortController = this._instanceLifecycle
 			?.ownershipLifecycleController as AbortController,
 	) {
+		const profile = this._logProperties?.sync?.profile;
+		const startedAt = syncProfileStart(profile);
+		const profileCounts = profile
+			? {
+					passes: 0,
+					inputEntries: 0,
+					nativePasses: 0,
+					repairCandidates: 0,
+					repairBatches: 0,
+					outcome: "stale",
+				}
+			: undefined;
 		try {
 			while (this.isRepairLifecycleActive(repairLifecycleController)) {
 				if (!this.isRepairLifecycleActive(repairLifecycleController)) {
@@ -11347,8 +11499,10 @@ export class SharedLog<
 				pruneStaleJoinWarmupPeers();
 
 				if (pendingModes.size === 0) {
+					if (profileCounts) profileCounts.outcome = "completed";
 					return;
 				}
+				if (profileCounts) profileCounts.passes += 1;
 
 				const optimisticGidPeersByMode = new Map<
 					RepairDispatchMode,
@@ -11447,6 +11601,10 @@ export class SharedLog<
 						}
 						return;
 					}
+					if (profileCounts) {
+						profileCounts.repairCandidates += entries.size;
+						profileCounts.repairBatches += 1;
+					}
 					this.dispatchMaybeMissingEntries(
 						target,
 						entries,
@@ -11513,6 +11671,10 @@ export class SharedLog<
 					residentEntriesByHash &&
 					!this.hasCustomFindLeaders()
 				) {
+					if (profileCounts) {
+						profileCounts.nativePasses += 1;
+						profileCounts.inputEntries += residentEntriesByHash.size;
+					}
 					const repairDispatchPlan = pruneStaleJoinWarmupPeers()
 						? await this.planResidentRepairDispatchBatch(
 								{
@@ -11551,6 +11713,7 @@ export class SharedLog<
 							const entries = await iterator.next(
 								REPAIR_SWEEP_ENTRY_BATCH_SIZE,
 							);
+							if (profileCounts) profileCounts.inputEntries += entries.length;
 							if (!this.isRepairLifecycleActive(repairLifecycleController)) {
 								return;
 							}
@@ -11675,6 +11838,7 @@ export class SharedLog<
 				}
 			}
 		} catch (error: any) {
+			if (profileCounts) profileCounts.outcome = "error";
 			if (
 				this.isRepairLifecycleActive(repairLifecycleController) &&
 				!isNotStartedError(error)
@@ -11696,6 +11860,21 @@ export class SharedLog<
 					void this.runRepairSweep(repairLifecycleController);
 				}
 			}
+			if (profileCounts) {
+				emitAdvisorySyncProfileDuration(profile, startedAt, {
+					name: "sharedLog.placement.pass",
+					component: "shared-log",
+					entries: profileCounts.inputEntries,
+					count: profileCounts.repairCandidates,
+					details: {
+						phase: "repair-sweep",
+						outcome: profileCounts.outcome,
+						passes: profileCounts.passes,
+						nativePasses: profileCounts.nativePasses,
+						repairBatches: profileCounts.repairBatches,
+					},
+				});
+			}
 		}
 	}
 
@@ -20871,6 +21050,10 @@ export class SharedLog<
 		const pruneRemoveTerminalFence = this.acquirePruneRemoveTerminalFence();
 		try {
 			this.stopSubscriptionChangeCallbackAdmission();
+			// A receive may be awaiting a synchronizer response shipment. Cancel
+			// its dispatch generation before draining that receive, rather than
+			// waiting for _close() to reach the synchronizer's final teardown.
+			this.syncronizer?.beginClose?.();
 			this.joinWarmup.cancelAllJoinWarmupTargets();
 			await this.drainSubscriptionChangeCallbacks();
 			// An already-admitted subscription callback can create a fresh warmup
@@ -21009,6 +21192,7 @@ export class SharedLog<
 		const pruneRemoveTerminalFence = this.acquirePruneRemoveTerminalFence();
 		try {
 			this.stopSubscriptionChangeCallbackAdmission();
+			this.syncronizer?.beginClose?.();
 			this.joinWarmup.cancelAllJoinWarmupTargets();
 			await this.drainSubscriptionChangeCallbacks();
 			// An already-admitted subscription callback can create a fresh warmup
@@ -21274,10 +21458,11 @@ export class SharedLog<
 			msg.heads.map((head) => head.hash),
 		);
 		if (syncProfile) {
-			emitSyncProfileDuration(syncProfile, rawExistingStartedAt, {
+			emitAdvisorySyncProfileDuration(syncProfile, rawExistingStartedAt, {
 				name: "sharedLog.rawReceive.existingHeads",
 				component: "shared-log",
 				entries: msg.heads.length,
+				count: rawExistingHashes.size,
 				messages: 1,
 			});
 		}
@@ -21711,10 +21896,11 @@ export class SharedLog<
 						? undefined
 						: await this.log.hasMany(headHashes);
 					if (syncProfile) {
-						emitSyncProfileDuration(syncProfile, existingStartedAt, {
+						emitAdvisorySyncProfileDuration(syncProfile, existingStartedAt, {
 							name: "sharedLog.receive.existingHeads",
 							component: "shared-log",
 							entries: heads.length,
+							count: existingHashes?.size,
 							messages: 1,
 							details: { rawMaterializedKnownMissing },
 						});
@@ -29478,6 +29664,17 @@ export class SharedLog<
 			isOwnershipLifecycleCurrent() &&
 			[...warmupPeers].every(isCurrentJoinWarmupTarget);
 
+		const profile = this._logProperties?.sync?.profile;
+		const profileStartedAt = syncProfileStart(profile);
+		const profileCounts = profile
+			? {
+					examinedEntries: 0,
+					repairCandidates: 0,
+					repairBatches: 0,
+					pruneScan: false,
+					outcome: "stale",
+				}
+			: undefined;
 		try {
 			const uncheckedDeliver: Map<
 				string,
@@ -29501,6 +29698,10 @@ export class SharedLog<
 					: isWarmupTarget
 						? "join-warmup"
 						: "join-authoritative";
+				if (profileCounts) {
+					profileCounts.repairCandidates += entries.size;
+					profileCounts.repairBatches += 1;
+				}
 				this.dispatchMaybeMissingEntries(
 					target,
 					entries,
@@ -29555,6 +29756,7 @@ export class SharedLog<
 						forceFresh: forceFreshDelivery || useJoinWarmupFastPath,
 					},
 				)) {
+					if (profileCounts) profileCounts.examinedEntries += 1;
 					if (
 						!isOwnershipLifecycleCurrent() ||
 						(useJoinWarmupFastPath && !areJoinWarmupGenerationsCurrent())
@@ -29838,6 +30040,7 @@ export class SharedLog<
 					));
 
 			if (shouldRunLocalPruneScan) {
+				if (profileCounts) profileCounts.pruneScan = true;
 				throwIfOwnershipLifecycleInactive();
 				// Adaptive range changes and fixed zero-width updates can make already-indexed
 				// local heads prunable even when the incremental rebalance scan misses them
@@ -29857,6 +30060,7 @@ export class SharedLog<
 				}
 			}
 
+			if (profileCounts) profileCounts.outcome = "completed";
 			return changed;
 		} catch (error: any) {
 			if (!isOwnershipLifecycleCurrent()) {
@@ -29866,8 +30070,27 @@ export class SharedLog<
 				return false; // we are not started yet, so no changes
 			}
 
+			if (profileCounts) profileCounts.outcome = "error";
 			logger.error(error.toString());
 			throw error;
+		} finally {
+			if (profileCounts) {
+				emitAdvisorySyncProfileDuration(profile, profileStartedAt, {
+					name: "sharedLog.placement.pass",
+					component: "shared-log",
+					entries: profileCounts.examinedEntries,
+					count: profileCounts.repairCandidates,
+					details: {
+						phase: "range-change",
+						outcome: profileCounts.outcome,
+						changes: changes.length,
+						repairBatches: profileCounts.repairBatches,
+						pruneScan: profileCounts.pruneScan,
+						forceFreshDelivery,
+						joinWarmupFastPath: useJoinWarmupFastPath,
+					},
+				});
+			}
 		}
 	}
 
@@ -29926,6 +30149,15 @@ export class SharedLog<
 		ownershipLifecycleController = this.captureReplicationOwnershipLifecycle(),
 		rebalanceParticipationDebounced = this.rebalanceParticipationDebounced,
 	) {
+		const profile = this._isAdaptiveReplicating
+			? this._logProperties?.sync?.profile
+			: undefined;
+		const profileStartedAt = syncProfileStart(profile);
+		const profileDetails:
+			| Record<string, string | number | boolean | undefined>
+			| undefined = profile
+			? { outcome: "stale", idleRemainingMs: 0 }
+			: undefined;
 		// Stage 3: the lifecycle owns all three identity terms. `lifecycle` may
 		// go stale later; its deps late-bind to the host, so the debouncer term
 		// still reads the current host field, and the role term can disagree
@@ -29965,6 +30197,14 @@ export class SharedLog<
 
 			if (this._isAdaptiveReplicating) {
 				if (this.shouldDelayAdaptiveRebalance()) {
+					if (profileDetails) {
+						profileDetails.outcome = "idle-deferred";
+						profileDetails.idleRemainingMs = Math.max(
+							0,
+							this.adaptiveRebalanceIdleMs -
+								(Date.now() - this._lastLocalAppendAt),
+						);
+					}
 					if (isCurrent()) {
 						void rebalanceParticipationDebounced?.call();
 					}
@@ -29974,11 +30214,17 @@ export class SharedLog<
 				const peers = this.replicationIndex;
 				const usedMemory = await this.getMemoryUsage();
 				if (!isCurrent()) return false;
+				if (profileDetails) {
+					profileDetails.storageUsedBytes = usedMemory;
+					profileDetails.storageObjectiveBytes =
+						this.replicationController.maxMemoryLimit;
+				}
 				this.scheduleReplicationStatusRefreshForStorage(usedMemory);
 				let dynamicRange = await this.getDynamicRange();
 				if (!isCurrent()) return false;
 
 				if (!dynamicRange) {
+					if (profileDetails) profileDetails.outcome = "not-permitted";
 					return; // not allowed to replicate
 				}
 
@@ -30005,13 +30251,24 @@ export class SharedLog<
 				const totalParticipation = await this.calculateTotalParticipation();
 				if (!isCurrent()) return false;
 
+				const cpuUsage = this.cpuUsage?.value();
+				const stepStartedAt = syncProfileStart(profile);
 				const newFactor = this.replicationController.step({
 					memoryUsage: usedMemory,
 					currentFactor: dynamicRange.widthNormalized,
 					totalFactor: totalParticipation, // TODO use this._totalParticipation when flakiness is fixed
 					peerCount: peersSize,
-					cpuUsage: this.cpuUsage?.value(),
+					cpuUsage,
 				});
+				if (profileDetails) {
+					profileDetails.preStepMs = stepStartedAt - profileStartedAt;
+					profileDetails.stepMs = syncProfileStart(profile) - stepStartedAt;
+					profileDetails.currentFactor = dynamicRange.widthNormalized;
+					profileDetails.proposedFactor = newFactor;
+					profileDetails.totalFactor = totalParticipation;
+					profileDetails.controllerPeerCount = peersSize;
+					profileDetails.cpuUsage = cpuUsage;
+				}
 
 				const absoluteDifference = Math.abs(
 					dynamicRange.widthNormalized - newFactor,
@@ -30048,9 +30305,11 @@ export class SharedLog<
 						(await this._isTrustedReplicator(this.node.identity.publicKey));
 					if (!isCurrent()) return false;
 					if (!canReplicate) {
+						if (profileDetails) profileDetails.outcome = "not-permitted";
 						return false;
 					}
 
+					const applyStartedAt = syncProfileStart(profile);
 					await this.startAnnounceReplicating(
 						[dynamicRange],
 						{
@@ -30061,6 +30320,10 @@ export class SharedLog<
 						ownershipLifecycleController,
 					);
 					if (!isCurrent()) return false;
+					if (profileDetails) {
+						profileDetails.outcome = "apply-settled";
+						profileDetails.applyMs = syncProfileStart(profile) - applyStartedAt;
+					}
 
 					/* await this._updateRole(newRole, onRoleChange); */
 					if (isCurrent()) {
@@ -30069,6 +30332,7 @@ export class SharedLog<
 
 					return true;
 				} else {
+					if (profileDetails) profileDetails.outcome = "unchanged";
 					if (isCurrent()) {
 						void rebalanceParticipationDebounced?.call();
 					}
@@ -30078,14 +30342,24 @@ export class SharedLog<
 			return false;
 		};
 
-		const resp = await fn().catch((error: any) => {
-			if (isNotStartedError(error) || isClosedStoreRace(error)) {
-				return false;
+		try {
+			return await fn().catch((error: any) => {
+				if (isNotStartedError(error) || isClosedStoreRace(error)) {
+					if (profileDetails) profileDetails.outcome = "stale";
+					return false;
+				}
+				if (profileDetails) profileDetails.outcome = "error";
+				throw error;
+			});
+		} finally {
+			if (profileDetails) {
+				emitAdvisorySyncProfileDuration(profile, profileStartedAt, {
+					name: "sharedLog.adaptive.rebalance",
+					component: "shared-log",
+					details: profileDetails,
+				});
 			}
-			throw error;
-		});
-
-		return resp;
+		}
 	}
 
 	private getDynamicRangeOffset(): NumberFromType<R> {

package/src/sync/index.ts

@@ -251,6 +251,13 @@ export interface Syncronizer<R extends "u32" | "u64"> {
 	onPeerDisconnected(key: PublicSignKey | string): void;
 
 	open(): Promise<void> | void;
+	/**
+	 * Synchronously fence dispatch admission and cancel the current generation's
+	 * network waits before SharedLog drains admitted receives. Do not stop shared
+	 * indexes or discard physical-work accounting here: close() still runs after
+	 * those receives settle. Optional for existing custom synchronizers.
+	 */
+	beginClose?(): void;
 	close(): Promise<void> | void;
 
 	get pending(): number;

package/src/sync/rateless-iblt.ts

@@ -1127,6 +1127,9 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 		timeoutMs?: number;
 		retryIntervalsMs?: number[];
 	}): RepairSession {
+		if (this.ratelessClosed) {
+			return this.simple.startRepairSession(properties);
+		}
 		const mode = properties.mode ?? "best-effort";
 		const targets = [...new Set(properties.targets)];
 		const timeoutMs = Math.max(
@@ -3303,13 +3306,16 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 		return this.simple.open();
 	}
 
-	close(): Promise<void> | void {
+	beginClose(): void {
 		this.ratelessClosed = true;
-		// Abort ownership first. Process abort listeners then cancel any in-flight
-		// StartSync/MoreSymbols send before they detach or free native state.
 		const reason = new Error("rateless synchronizer closed");
 		this.cancelRatelessRepairSessions(reason);
 		this.ratelessDispatchLifecycleController.abort(reason);
+		this.simple.beginClose();
+	}
+
+	close(): Promise<void> | void {
+		this.beginClose();
 		for (const obj of [...this.ingoingSyncProcesses.values()]) {
 			obj.free();
 		}