@peerbit/shared-log 16.0.30 → 16.0.32

package/src/index.ts

@@ -297,6 +297,7 @@ import {
 	maxReplicas,
 } from "./replication.js";
 import { ReplicatorLivenessMonitor } from "./replicator-liveness.js";
+import { SyncReceiveAbortError } from "./sync/dispatch-lifecycle.js";
 import { createSyncronizer } from "./sync/factory.js";
 import type {
 	SharedLogNativeWireSync,
@@ -417,6 +418,7 @@ type PendingIHave<T> = {
 
 type PeerReceiveLeaseBucket = {
 	active: number;
+	controller: AbortController;
 	drain?: DeferredPromise<void>;
 };
 
@@ -433,13 +435,15 @@ type PeerReceiveLeaseState = {
  */
 type PeerReceiveLease = {
 	release: () => void;
+	signal: AbortSignal;
 };
 
 const createOneShotPeerReceiveLease = (
-	releaseFn: () => void,
+	releaseFn: (() => void) & { signal: AbortSignal },
 ): PeerReceiveLease => {
 	let released = false;
 	return {
+		signal: releaseFn.signal,
 		release: () => {
 			if (released) {
 				return;
@@ -6352,6 +6356,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;
@@ -6418,6 +6511,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,
@@ -6462,6 +6556,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;
@@ -6471,6 +6566,7 @@ export class SharedLog<
 					}
 				}
 				if (!isRoundOwnershipCurrent()) continue;
+				recoverSelectedPeers(recoveryCandidates);
 
 				const operationQueue = new PQueue({
 					concurrency: MAX_PERSISTED_RECEIPT_REQUESTS_GLOBAL,
@@ -6831,6 +6927,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();
 		}
 	}
@@ -7740,7 +7841,7 @@ export class SharedLog<
 			allowReplicationInfoBlocked?: boolean;
 			allowCleanupGate?: boolean;
 		},
-	): (() => void) | undefined {
+	): ((() => void) & { signal: AbortSignal }) | undefined {
 		if (
 			!this._peerSessions.isReceiveAdmissionOpen(
 				peerHash,
@@ -7754,7 +7855,10 @@ export class SharedLog<
 
 		let state = this._activeReceiveHandlersByPeer.get(peerHash);
 		if (!state) {
-			const current: PeerReceiveLeaseBucket = { active: 0 };
+			const current: PeerReceiveLeaseBucket = {
+				active: 0,
+				controller: new AbortController(),
+			};
 			state = { current, activeBuckets: new Set() };
 			this._activeReceiveHandlersByPeer.set(peerHash, state);
 		}
@@ -7762,7 +7866,7 @@ export class SharedLog<
 		bucket.active += 1;
 		state.activeBuckets.add(bucket);
 		let released = false;
-		return () => {
+		const release = () => {
 			if (released) {
 				return;
 			}
@@ -7781,6 +7885,7 @@ export class SharedLog<
 				this._activeReceiveHandlersByPeer.delete(peerHash);
 			}
 		};
+		return Object.assign(release, { signal: bucket.controller.signal });
 	}
 
 	private async drainPeerReceiveHandlers(peerHash: string): Promise<void> {
@@ -7793,7 +7898,7 @@ export class SharedLog<
 		// sync traffic without joining the drain for the previous subscription. Cleanup
 		// callers gate admission first; terminal callers also repeat until empty.
 		const buckets = [...state.activeBuckets];
-		state.current = { active: 0 };
+		state.current = { active: 0, controller: new AbortController() };
 		const drain = Promise.all(
 			buckets.map((bucket) => {
 				bucket.drain ??= pDefer<void>();
@@ -7806,6 +7911,14 @@ export class SharedLog<
 			this._receiveHandlerDrainByPeer.set(peerHash, drains);
 		}
 		drains.add(drain);
+		// Cancel only work admitted into this snapshot, never a replacement's
+		// current bucket. Aborting requests cooperation; the physical receive
+		// leases below still own all cleanup until their actual finally settles.
+		for (const bucket of buckets) {
+			bucket.controller.abort(
+				new SyncReceiveAbortError("peer receive generation draining"),
+			);
+		}
 		try {
 			await drain;
 		} finally {
@@ -20953,6 +21066,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
@@ -21091,6 +21208,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
@@ -23550,7 +23668,11 @@ export class SharedLog<
 						this._liveness.markReplicatorActivity(receiveFromHash);
 					}
 					return;
-				} else if (await this.syncronizer.onMessage(msg, context)) {
+				} else if (
+					await this.syncronizer.onMessage(msg, context, {
+						signal: peerReceiveLease.signal,
+					})
+				) {
 					return; // the syncronizer has handled the message
 				} else if (msg instanceof BlocksMessage) {
 					await this.remoteBlocks.onMessage(msg.message, {

package/src/sync/dispatch-lifecycle.ts

@@ -16,6 +16,26 @@
 // caller-specific fields such as epochs, batches and retained-work
 // counters); the registry owns the per-target active sets, the listener
 // add/remove pairing and the dispose gating.
+import { AbortError } from "@peerbit/time";
+
+/** Local receive drain cancellation; never a transport or persistence failure. */
+export class SyncReceiveAbortError extends AbortError {}
+
+export const isSyncDispatchCancellation = (
+	error: unknown,
+	signal: AbortSignal | undefined,
+	inactive = signal?.aborted === true,
+): boolean => {
+	if (!inactive) return false;
+	// Keep the existing owner/disconnect error policy. Only the new receive
+	// cancellation must distinguish unrelated failures that race its abort.
+	if (!(signal?.reason instanceof SyncReceiveAbortError)) return true;
+	return (
+		error === signal.reason ||
+		error instanceof AbortError ||
+		(error instanceof Error && error.name === "AbortError")
+	);
+};
 
 export interface DispatchTargetLifecycleBase<LC> {
 	lifecycle: LC;

package/src/sync/index.ts

@@ -231,6 +231,9 @@ export interface Syncronizer<R extends "u32" | "u64"> {
 	onMessage(
 		message: TransportMessage,
 		context: RequestContext,
+		// Exact admitted receive lifetime, not a peer-hash-wide disconnect.
+		// Implementations must still settle physical work before returning.
+		options?: { signal?: AbortSignal },
 	): Promise<boolean> | boolean;
 
 	onReceivedEntries(properties: {
@@ -251,6 +254,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

@@ -27,7 +27,9 @@ import { TransportMessage } from "../message.js";
 import { type EntryReplicated } from "../ranges.js";
 import {
 	DispatchLifecycleRegistry,
+	SyncReceiveAbortError,
 	isOwnershipGenerationActive,
+	isSyncDispatchCancellation,
 	isTrackedSessionActive,
 } from "./dispatch-lifecycle.js";
 import type {
@@ -827,6 +829,7 @@ type OutgoingRatelessSyncProcess = {
 		lastSeqNo: bigint;
 	}) => { symbols: CodedSymbolBatch; exhaustedAfterSend: boolean } | undefined;
 	startSimpleFallback: () => Promise<void>;
+	cancelSimpleFallback: (reason: unknown) => void;
 	simpleFallbackStarted: boolean;
 	free: (reason?: unknown) => void;
 	processController: AbortController;
@@ -863,6 +866,7 @@ type IncomingRatelessSyncProcess = {
 		symbols: CodedSymbolInput;
 	}) => Promise<IncomingRatelessProcessResult>;
 	requestAll: () => Promise<void>;
+	drain: () => Promise<void>;
 	fallbackToSimple: (reason?: unknown) => Promise<void>;
 	free: (reason?: unknown) => void;
 	complete: () => void;
@@ -1127,6 +1131,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(
@@ -1568,6 +1575,35 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 		);
 	}
 
+	private async settleIncomingReceive(
+		process: IncomingRatelessSyncProcess,
+		signal: AbortSignal,
+	): Promise<void> {
+		const errors: unknown[] = [];
+		try {
+			await process.drain();
+		} catch (error) {
+			errors.push(error);
+		}
+		if (signal.aborted) {
+			try {
+				process.free(signal.reason);
+			} catch (error) {
+				errors.push(error);
+			}
+		}
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) {
+			throw new AggregateError(
+				errors,
+				"incoming receive drain and cleanup failed",
+				{
+					cause: errors[0],
+				},
+			);
+		}
+	}
+
 	async onMaybeMissingEntries(properties: {
 		entries: Map<string, SyncEntryCoordinates<D>>;
 		targets: string[];
@@ -2005,6 +2041,7 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 			let symbolsProduced = startSyncSymbols.length;
 			let symbolBudgetExhausted = false;
 			let simpleFallbackPromise: Promise<void> | undefined;
+			const simpleFallbackController = new AbortController();
 			const symbolBudget = getOutgoingRatelessSymbolBudget(
 				properties.coordinates.length,
 				startSyncSymbols.length,
@@ -2052,7 +2089,14 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 						this.simple.onMaybeMissingHashes({
 							hashes: properties.outgoingHashes,
 							targets: [target],
-							signal: lifecycle.callerSignal,
+							// Encoder retirement must not cancel an admitted fallback.
+							// A receive awaiting that exact memoized operation can do so.
+							signal: lifecycle.callerSignal
+								? AbortSignal.any([
+										lifecycle.callerSignal,
+										simpleFallbackController.signal,
+									])
+								: simpleFallbackController.signal,
 						}),
 					);
 				}
@@ -2147,6 +2191,8 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 					return { symbols, exhaustedAfterSend };
 				},
 				startSimpleFallback,
+				cancelSimpleFallback: (reason) =>
+					simpleFallbackController.abort(reason),
 				simpleFallbackStarted: false,
 				free: clear,
 				outgoingHashes: properties.outgoingHashes,
@@ -2383,7 +2429,74 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 	async onMessage(
 		message: TransportMessage,
 		context: RequestContext,
+		options?: { signal?: AbortSignal },
+	): Promise<boolean> {
+		const signal = options?.signal;
+		if (!signal) {
+			return this.onMessageForReceive(message, context);
+		}
+		let cancel: (() => void) | undefined;
+		let settle: (() => Promise<void>) | undefined;
+		const onAbort = () => cancel?.();
+		signal.addEventListener("abort", onAbort, { once: true });
+		const errors: unknown[] = [];
+		let handled = false;
+		try {
+			handled = await this.onMessageForReceive(message, context, {
+				signal,
+				bind: (cancelWork, settleWork) => {
+					cancel = cancelWork;
+					settle = settleWork;
+					if (signal.aborted) {
+						onAbort();
+					}
+				},
+			});
+		} catch (error) {
+			errors.push(error);
+		} finally {
+			// Keep cancellation connected while a bounded fallback's logical
+			// completion still leaves its lower send physically draining.
+			try {
+				await settle?.();
+			} catch (error) {
+				if (!errors.includes(error)) {
+					errors.push(error);
+				}
+			} finally {
+				signal.removeEventListener("abort", onAbort);
+			}
+		}
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) {
+			throw new AggregateError(
+				errors,
+				"sync receive and physical cleanup failed",
+				{
+					cause: errors[0],
+				},
+			);
+		}
+		return handled;
+	}
+
+	private async onMessageForReceive(
+		message: TransportMessage,
+		context: RequestContext,
+		options?: {
+			signal: AbortSignal;
+			bind: (cancel: () => void, settle?: () => Promise<void>) => void;
+		},
 	): Promise<boolean> {
+		if (options?.signal.aborted) {
+			return (
+				message instanceof StartSync ||
+				message instanceof MoreSymbols ||
+				message instanceof RequestMoreSymbols ||
+				message instanceof RequestAll ||
+				(await this.simple.onMessage(message, context, options))
+			);
+		}
 		const profile = this.properties.sync?.profile;
 		if (message instanceof StartSync) {
 			const from = context.from;
@@ -2508,6 +2621,7 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 				symbolBudget: getIncomingRatelessSymbolBudget(message.symbols.length),
 				process: async () => undefined,
 				requestAll: async () => {},
+				drain: async () => {},
 				fallbackToSimple: async () => {},
 				free,
 				complete,
@@ -2519,6 +2633,10 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 				onOwnershipAbort,
 				{ once: true },
 			);
+			options?.bind(
+				() => controller.abort(options.signal.reason),
+				() => this.settleIncomingReceive(obj, options.signal),
+			);
 			obj.deadlineTimeout = setTimeout(() => {
 				void obj.fallbackToSimple(
 					new Error("incoming rateless process deadline exceeded"),
@@ -2531,6 +2649,9 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 			}
 
 			let requestAllPromise: Promise<void> | undefined;
+			obj.drain = async () => {
+				await requestAllPromise;
+			};
 			obj.requestAll = () => {
 				if (requestAllPromise) {
 					return requestAllPromise;
@@ -2563,6 +2684,12 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 								syncId,
 							});
 						}
+					} catch (error) {
+						// Classify before complete() aborts the process as normal cleanup;
+						// that cleanup must not disguise a genuine lower-send failure.
+						if (!isSyncDispatchCancellation(error, controller.signal)) {
+							throw error;
+						}
 					} finally {
 						fallbackSendPending = false;
 						if (this.isIncomingSyncProcessActive(obj)) {
@@ -2640,7 +2767,8 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 				const processAborted = controller.signal.aborted;
 				free(error);
 				if (
-					processAborted ||
+					(processAborted &&
+						isSyncDispatchCancellation(error, controller.signal)) ||
 					!this.isIncomingSyncGenerationActive(ownershipLifecycleController)
 				) {
 					return true;
@@ -2921,7 +3049,13 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 					},
 				);
 			} catch (error) {
-				if (!this.isIncomingSyncProcessActive(obj)) {
+				if (
+					isSyncDispatchCancellation(
+						error,
+						controller.signal,
+						!this.isIncomingSyncProcessActive(obj),
+					)
+				) {
 					return true;
 				}
 				free(error);
@@ -2956,6 +3090,10 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 			) {
 				return true;
 			}
+			options?.bind(
+				() => obj.controller.abort(options.signal.reason),
+				() => this.settleIncomingReceive(obj, options.signal),
+			);
 			let outProcess: IncomingRatelessProcessResult;
 			try {
 				outProcess = await obj.process(message);
@@ -3002,7 +3140,13 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 						signal: obj.controller.signal,
 					},
 				);
-			} catch {
+			} catch (error) {
+				if (
+					obj.controller.signal.reason instanceof SyncReceiveAbortError &&
+					!isSyncDispatchCancellation(error, obj.controller.signal)
+				) {
+					throw error;
+				}
 				if (profile) {
 					emitSyncProfileDuration(profile, sendStartedAt, {
 						name: "rateless.sendRequestMoreSymbols",
@@ -3036,6 +3180,14 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 			if (context.from?.hashcode() !== obj.target) {
 				return true;
 			}
+			options?.bind(
+				() => obj.processController.abort(options.signal.reason),
+				async () => {
+					if (options.signal.aborted) {
+						obj.free(options.signal.reason);
+					}
+				},
+			);
 			const signal = obj.signal;
 			if (signal.aborted) {
 				return true;
@@ -3063,7 +3215,7 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 					},
 				);
 			} catch (error) {
-				if (signal?.aborted) {
+				if (isSyncDispatchCancellation(error, signal)) {
 					return true;
 				}
 				throw error;
@@ -3098,7 +3250,14 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 			}
 			// RequestAll ends only this target's rateless attempt. Other target
 			// encoders and response authorizations remain independently owned.
-			const fallback = p.startSimpleFallback();
+			let fallback: Promise<void> | undefined;
+			options?.bind(
+				() => p.cancelSimpleFallback(options.signal.reason),
+				async () => {
+					await fallback;
+				},
+			);
+			fallback = p.startSimpleFallback();
 			p.free();
 			await fallback;
 			return true;
@@ -3171,13 +3330,17 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 						entries: 0,
 					};
 					try {
+						const signal = options?.signal
+							? AbortSignal.any([response.signal, options.signal])
+							: response.signal;
 						responseShipment =
 							await this.simple.shipAuthorizedMaybeSyncResponse({
 								hashes: response.authorized,
 								from,
 								response: message,
-								signal: response.signal,
+								signal,
 							});
+						rollbackRatelessAuthorization = signal.aborted;
 					} catch (error) {
 						firstError = error;
 						rollbackRatelessAuthorization = true;
@@ -3206,6 +3369,7 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 							leases: simpleLeases,
 							from,
 							response: simpleMessage,
+							signal: options?.signal,
 						});
 					} catch (error) {
 						firstError ??= error;
@@ -3226,7 +3390,7 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 				}
 			}
 		}
-		return this.simple.onMessage(message, context);
+		return this.simple.onMessage(message, context, options);
 	}
 
 	onReceivedEntries(properties: {
@@ -3303,13 +3467,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();
 		}