@peerbit/pubsub 5.3.8 → 5.3.10

package/src/index.ts

@@ -5,8 +5,11 @@ import {
 import { PublicSignKey, getPublicKeyFromPeerId } from "@peerbit/crypto";
 import { logger as loggerFn } from "@peerbit/logger";
 import {
+	assertCanonicalTopicRootCandidates,
+	assertTopicRootCandidatesFrame,
 	DataEvent,
 	GetSubscribers,
+	isCanonicalTopicRootCandidate,
 	PeerUnavailable,
 	type PubSub,
 	PubSubData,
@@ -16,6 +19,7 @@ import {
 	Subscribe,
 	SubscriptionData,
 	SubscriptionEvent,
+	TOPIC_ROOT_CANDIDATES_MAX,
 	TopicRootCandidates,
 	TopicRootQuery,
 	TopicRootQueryResponse,
@@ -66,7 +70,10 @@ import type {
 	FanoutTreeDataEvent,
 	FanoutTreeJoinOptions,
 } from "./fanout-tree.js";
-import { TopicRootControlPlane } from "./topic-root-control-plane.js";
+import {
+	TopicRootControlPlane,
+	type TopicRootResolutionOptions,
+} from "./topic-root-control-plane.js";
 
 export * from "./fanout-tree.js";
 // The complete /peerbit/fanout-tree/0.5.0 wire codec and the
@@ -103,6 +110,7 @@ const logErrorIfStarted = (e?: { message: string }) => {
 const withAbort = async <T>(promise: Promise<T>, signal?: AbortSignal): Promise<T> => {
 	if (!signal) return promise;
 	if (signal.aborted) {
+		void promise.catch(() => {});
 		throw signal.reason ?? new AbortError("Operation was aborted");
 	}
 	return new Promise<T>((resolve, reject) => {
@@ -131,6 +139,53 @@ const withAbort = async <T>(promise: Promise<T>, signal?: AbortSignal): Promise<
 	});
 };
 
+const throwIfAborted = (signal?: AbortSignal): void => {
+	if (signal?.aborted) {
+		throw signal.reason ?? new AbortError("Operation was aborted");
+	}
+};
+
+type AbortSignalLink = {
+	signal: AbortSignal;
+	clear: () => void;
+};
+
+const linkAbortSignals = (
+	signals: Array<AbortSignal | undefined>,
+): AbortSignalLink => {
+	const unique = [...new Set(signals.filter((signal) => signal !== undefined))];
+	if (unique.length === 1) {
+		return { signal: unique[0]!, clear: () => {} };
+	}
+
+	const controller = new AbortController();
+	const listeners = new Map<AbortSignal, () => void>();
+	const clear = () => {
+		for (const [signal, listener] of listeners) {
+			signal.removeEventListener("abort", listener);
+		}
+		listeners.clear();
+	};
+	const abortFrom = (signal: AbortSignal) => {
+		clear();
+		controller.abort(
+			signal.reason ?? new AbortError("Topic-root resolution aborted"),
+		);
+	};
+
+	const aborted = unique.find((signal) => signal.aborted);
+	if (aborted) {
+		abortFrom(aborted);
+	} else {
+		for (const signal of unique) {
+			const listener = () => abortFrom(signal);
+			listeners.set(signal, listener);
+			signal.addEventListener("abort", listener, { once: true });
+		}
+	}
+	return { signal: controller.signal, clear };
+};
+
 const SUBSCRIBER_CACHE_MAX_ENTRIES_HARD_CAP = 100_000;
 const SUBSCRIBER_CACHE_DEFAULT_MAX_ENTRIES = 4_096;
 const DEFAULT_FANOUT_PUBLISH_IDLE_CLOSE_MS = 60_000;
@@ -138,7 +193,10 @@ const DEFAULT_FANOUT_PUBLISH_MAX_EPHEMERAL_CHANNELS = 64;
 const DEFAULT_PUBSUB_SHARD_COUNT = 256;
 const PUBSUB_SHARD_COUNT_HARD_CAP = 16_384;
 const DEFAULT_PUBSUB_SHARD_TOPIC_PREFIX = "/peerbit/pubsub-shard/1/";
-const AUTO_TOPIC_ROOT_CANDIDATES_MAX = 64;
+const AUTO_TOPIC_ROOT_CANDIDATE_UPDATE_COOLDOWN_MS = 2_000;
+const sameCandidates = (left: string[], right: string[]) =>
+	left.length === right.length &&
+	left.every((candidate, index) => candidate === right[index]);
 // Topic-root queries may need to wait for the responder to finish opening an
 // outbound stream back to the requester after an inbound-only dial.
 const DEFAULT_TOPIC_ROOT_QUERY_TIMEOUT_MS = 12_000;
@@ -344,10 +402,15 @@ export class TopicControlPlane
 	// This keeps small ad-hoc networks working without explicit bootstraps.
 	private autoTopicRootCandidates = false;
 	private autoTopicRootCandidateSet?: Set<string>;
+	private pendingAutoTopicRootCandidates?: string[];
+	private autoTopicRootCandidateUpdateTimer?: ReturnType<typeof setTimeout>;
 	private reconcileShardOverlaysInFlight?: Promise<void>;
 	private reconcileShardOverlaysDirty = false;
 	private topicControlPlaneStopping = false;
 	private topicControlPlaneLifecycleRevision = 0;
+	private topicRootResolutionAbortController = new AbortController();
+	private topicRootCandidateResolutionGeneration?: string;
+	private topicRootCandidateResolutionAbortController = new AbortController();
 	private hostOwnedShardRootsInFlight?: Promise<void>;
 	private hostOwnedShardRootsDirty = false;
 	private autoCandidatesBroadcastTimers: Array<ReturnType<typeof setTimeout>> =
@@ -531,6 +594,7 @@ export class TopicControlPlane
 		// Disable auto mode and stop its background gossip/timers.
 		this.autoTopicRootCandidates = false;
 		this.autoTopicRootCandidateSet = undefined;
+		this.clearAutoTopicRootCandidateUpdateSchedule();
 		for (const t of this.autoCandidatesBroadcastTimers) clearTimeout(t);
 		this.autoCandidatesBroadcastTimers = [];
 		if (this.autoCandidatesGossipInterval) {
@@ -551,6 +615,9 @@ export class TopicControlPlane
 
 	public override async start() {
 		this.topicControlPlaneStopping = false;
+		if (this.topicRootResolutionAbortController.signal.aborted) {
+			this.topicRootResolutionAbortController = new AbortController();
+		}
 		await this.fanout.start();
 		this._onFanoutPeerUnreachable =
 			this._onFanoutPeerUnreachable ||
@@ -574,6 +641,10 @@ export class TopicControlPlane
 
 	public override async stop() {
 		this.topicControlPlaneStopping = true;
+		this.topicRootResolutionAbortController.abort(
+			new AbortError("topic control plane stopped"),
+		);
+		this.clearAutoTopicRootCandidateUpdateSchedule();
 		this.topicControlPlaneLifecycleRevision += 1;
 		this.reconcileShardOverlaysDirty = false;
 		for (const opening of this.ensureFanoutChannelInFlight.values()) {
@@ -697,6 +768,7 @@ export class TopicControlPlane
 		// intact and reconcile shard overlays under the new mapping.
 		this.autoTopicRootCandidates = false;
 		this.autoTopicRootCandidateSet = undefined;
+		this.clearAutoTopicRootCandidateUpdateSchedule();
 		this.shardRootCache.clear();
 
 		// Ensure we host any shard roots we're now responsible for. This is important
@@ -710,52 +782,34 @@ export class TopicControlPlane
 
 	private maybeUpdateAutoTopicRootCandidates(peerHash: string) {
 		if (!this.autoTopicRootCandidates) return;
-		if (!peerHash || peerHash === this.publicKeyHash) return;
-
-		if (this.maybeDisableAutoTopicRootCandidatesIfExternallyConfigured())
+		if (
+			!isCanonicalTopicRootCandidate(peerHash) ||
+			peerHash === this.publicKeyHash
+		)
 			return;
 
-		const current = this.topicRootControlPlane.getTopicRootCandidates();
-		const managed = this.autoTopicRootCandidateSet;
-
-		if (current.includes(peerHash)) return;
-
-		managed?.add(peerHash);
-		const next = this.normalizeAutoTopicRootCandidates(
-			managed ? [...managed] : [...current, peerHash],
-		);
-		this.autoTopicRootCandidateSet = new Set(next);
-		this.topicRootControlPlane.setTopicRootCandidates(next);
-		this.shardRootCache.clear();
-		this.scheduleReconcileShardOverlays();
-
-		// In auto-candidate mode, shard roots are selected deterministically across
-		// *all* connected peers (not just those currently subscribed to a shard).
-		// That means a peer can be selected as root for shards it isn't using yet.
-		// Ensure we proactively host the shard roots we're responsible for so other
-		// peers can join without timing out in small ad-hoc networks.
-		this.scheduleHostOwnedShardRoots();
-
-		// Share the updated candidate set so other peers converge on the same
-		// deterministic mapping even in partially connected topologies.
-		this.scheduleAutoTopicRootCandidatesBroadcast();
+		this.queueAutoTopicRootCandidateUpdate([peerHash]);
 	}
 
 	private normalizeAutoTopicRootCandidates(candidates: string[]): string[] {
+		const canonicalCandidates = candidates.filter(
+			isCanonicalTopicRootCandidate,
+		);
 		if (this.nativeTopicControl) {
 			return this.nativeTopicControl.normalizeAutoCandidates(
-				candidates,
+				canonicalCandidates,
 				this.publicKeyHash,
 			);
 		}
 		const unique = new Set<string>();
-		for (const c of candidates) {
-			if (!c) continue;
+		for (const c of canonicalCandidates) {
 			unique.add(c);
 		}
-		unique.add(this.publicKeyHash);
+		if (isCanonicalTopicRootCandidate(this.publicKeyHash)) {
+			unique.add(this.publicKeyHash);
+		}
 		const sorted = [...unique].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
-		return sorted.slice(0, AUTO_TOPIC_ROOT_CANDIDATES_MAX);
+		return sorted.slice(0, TOPIC_ROOT_CANDIDATES_MAX);
 	}
 
 	private scheduleAutoTopicRootCandidatesBroadcast(targets?: PeerStreams[]) {
@@ -827,31 +881,88 @@ export class TopicControlPlane
 
 	private mergeAutoTopicRootCandidatesFromPeer(candidates: string[]): boolean {
 		if (!this.autoTopicRootCandidates) return false;
+		return this.queueAutoTopicRootCandidateUpdate(candidates);
+	}
+
+	private queueAutoTopicRootCandidateUpdate(
+		candidates: readonly string[],
+	): boolean {
+		if (
+			!this.autoTopicRootCandidates ||
+			this.stopping ||
+			this.topicControlPlaneStopping
+		)
+			return false;
 		if (this.maybeDisableAutoTopicRootCandidatesIfExternallyConfigured())
 			return false;
 		const managed = this.autoTopicRootCandidateSet;
 		if (!managed) return false;
 
-		const before = this.topicRootControlPlane.getTopicRootCandidates();
-		for (const c of candidates) {
-			if (!c) continue;
-			managed.add(c);
-		}
-		const next = this.normalizeAutoTopicRootCandidates([...managed]);
-		if (
-			before.length === next.length &&
-			before.every((c, i) => c === next[i])
-		) {
-			return false;
+		const before = this.pendingAutoTopicRootCandidates ?? [...managed];
+		const next = this.normalizeAutoTopicRootCandidates([
+			...before,
+			...candidates,
+		]);
+		if (sameCandidates(before, next)) return false;
+
+		if (this.autoTopicRootCandidateUpdateTimer) {
+			this.pendingAutoTopicRootCandidates = next;
+			return true;
 		}
 
+		this.scheduleAutoTopicRootCandidateUpdateCooldown();
+		this.applyAutoTopicRootCandidates(next);
+		return true;
+	}
+
+	private applyAutoTopicRootCandidates(next: string[]) {
 		this.autoTopicRootCandidateSet = new Set(next);
 		this.topicRootControlPlane.setTopicRootCandidates(next);
 		this.shardRootCache.clear();
 		this.scheduleReconcileShardOverlays();
 		this.scheduleHostOwnedShardRoots();
 		this.scheduleAutoTopicRootCandidatesBroadcast();
-		return true;
+	}
+
+	private scheduleAutoTopicRootCandidateUpdateCooldown() {
+		if (this.autoTopicRootCandidateUpdateTimer) return;
+		const timer = setTimeout(() => {
+			if (this.autoTopicRootCandidateUpdateTimer !== timer) return;
+			this.flushPendingAutoTopicRootCandidateUpdate();
+		}, AUTO_TOPIC_ROOT_CANDIDATE_UPDATE_COOLDOWN_MS);
+		timer.unref?.();
+		this.autoTopicRootCandidateUpdateTimer = timer;
+	}
+
+	private flushPendingAutoTopicRootCandidateUpdate() {
+		if (this.autoTopicRootCandidateUpdateTimer) {
+			clearTimeout(this.autoTopicRootCandidateUpdateTimer);
+			this.autoTopicRootCandidateUpdateTimer = undefined;
+		}
+		const next = this.pendingAutoTopicRootCandidates;
+		this.pendingAutoTopicRootCandidates = undefined;
+		if (!next) return;
+		if (
+			!this.autoTopicRootCandidates ||
+			this.stopping ||
+			this.topicControlPlaneStopping
+		)
+			return;
+		if (this.maybeDisableAutoTopicRootCandidatesIfExternallyConfigured())
+			return;
+
+		// The trailing update starts its own fixed window so another inbound update
+		// cannot create a second candidate generation immediately afterwards.
+		this.scheduleAutoTopicRootCandidateUpdateCooldown();
+		this.applyAutoTopicRootCandidates(next);
+	}
+
+	private clearAutoTopicRootCandidateUpdateSchedule() {
+		if (this.autoTopicRootCandidateUpdateTimer) {
+			clearTimeout(this.autoTopicRootCandidateUpdateTimer);
+			this.autoTopicRootCandidateUpdateTimer = undefined;
+		}
+		this.pendingAutoTopicRootCandidates = undefined;
 	}
 
 	private scheduleHostOwnedShardRoots() {
@@ -881,6 +992,7 @@ export class TopicControlPlane
 
 	private scheduleReconcileShardOverlays() {
 		const candidateGeneration = this.getTopicRootCandidateGeneration();
+		this.syncTopicRootCandidateResolutionSignal(candidateGeneration);
 		for (const opening of this.ensureFanoutChannelInFlight.values()) {
 			if (opening.candidateGeneration !== candidateGeneration) {
 				opening.abortController.abort(
@@ -1162,6 +1274,9 @@ export class TopicControlPlane
 	 * their fallback behavior).
 	 */
 	private decodePubSubMessage(bytes: Uint8Array): PubSubMessage {
+		if (bytes[0] === 4) {
+			assertTopicRootCandidatesFrame(bytes);
+		}
 		const native = this.nativeTopicControl;
 		if (native) {
 			const decoded = native.decodePubSubMessage(bytes);
@@ -1182,6 +1297,7 @@ export class TopicControlPlane
 				case "get-subscribers":
 					return new GetSubscribers({ topics: decoded.topics });
 				case "topic-root-candidates":
+					assertCanonicalTopicRootCandidates(decoded.candidates);
 					return new TopicRootCandidates({ candidates: decoded.candidates });
 				case "peer-unavailable":
 					return new PeerUnavailable({
@@ -1224,6 +1340,67 @@ export class TopicControlPlane
 		}
 	}
 
+	private syncTopicRootCandidateResolutionSignal(
+		candidateGeneration = this.getTopicRootCandidateGeneration(),
+	): AbortSignal {
+		if (this.topicRootCandidateResolutionGeneration === undefined) {
+			this.topicRootCandidateResolutionGeneration = candidateGeneration;
+		} else if (
+			candidateGeneration !== this.topicRootCandidateResolutionGeneration
+		) {
+			this.topicRootCandidateResolutionAbortController.abort(
+				new AbortError("topic root candidates changed"),
+			);
+			this.topicRootCandidateResolutionAbortController = new AbortController();
+			this.topicRootCandidateResolutionGeneration = candidateGeneration;
+		}
+		return this.topicRootCandidateResolutionAbortController.signal;
+	}
+
+	private async withTopicRootCandidateResolution<T>(
+		operation: (context: {
+			candidateGeneration: string;
+			signal: AbortSignal;
+		}) => Promise<T>,
+		terminalSignals: Array<AbortSignal | undefined> = [],
+	): Promise<T> {
+		for (;;) {
+			for (const signal of terminalSignals) throwIfAborted(signal);
+			const candidateGeneration = this.getTopicRootCandidateGeneration();
+			const candidateSignal = this.syncTopicRootCandidateResolutionSignal(
+				candidateGeneration,
+			);
+			const linked = linkAbortSignals([...terminalSignals, candidateSignal]);
+			try {
+				const result = await operation({
+					candidateGeneration,
+					signal: linked.signal,
+				});
+				for (const signal of terminalSignals) throwIfAborted(signal);
+				if (
+					candidateSignal.aborted ||
+					candidateGeneration !== this.getTopicRootCandidateGeneration()
+				) {
+					continue;
+				}
+				return result;
+			} catch (error) {
+				for (const signal of terminalSignals) {
+					if (signal?.aborted) throw signal.reason ?? error;
+				}
+				if (
+					candidateSignal.aborted ||
+					candidateGeneration !== this.getTopicRootCandidateGeneration()
+				) {
+					continue;
+				}
+				throw error;
+			} finally {
+				linked.clear();
+			}
+		}
+	}
+
 	private normalizePeerTopicRootState(
 		topic: string,
 		root: string,
@@ -1243,13 +1420,21 @@ export class TopicControlPlane
 
 	private async resolveTopicRootState(
 		topic: string,
+		options?: TopicRootResolutionOptions,
 	): Promise<{ root?: string; authoritative: boolean }> {
-		const tracked = await this.topicRootControlPlane.resolveTrackedTopicRoot(topic);
+		throwIfAborted(options?.signal);
+		const tracked = await this.topicRootControlPlane.resolveTrackedTopicRoot(
+			topic,
+			options,
+		);
 		if (tracked) {
 			return { root: tracked, authoritative: true };
 		}
 
-		const resolvedThroughPeers = await this.resolveTopicRootThroughPeers(topic);
+		const resolvedThroughPeers = await this.resolveTopicRootThroughPeers(
+			topic,
+			options,
+		);
 		if (resolvedThroughPeers) {
 			// Unconfigured peer-query replies cannot override the locally
 			// deterministic root for internal shards in auto mode. Roots, resolvers,
@@ -1266,8 +1451,11 @@ export class TopicControlPlane
 			this.getConnectedTopicRootTrackers().length > 0
 		) {
 			for (let attempt = 0; attempt < 8; attempt++) {
-				await delay(150 * (attempt < 4 ? 1 : 2));
-				const retried = await this.resolveTopicRootThroughPeers(topic);
+				await withAbort(
+					delay(150 * (attempt < 4 ? 1 : 2), options),
+					options?.signal,
+				);
+				const retried = await this.resolveTopicRootThroughPeers(topic, options);
 				if (retried) {
 					return this.normalizePeerTopicRootState(topic, retried);
 				}
@@ -1280,15 +1468,28 @@ export class TopicControlPlane
 		};
 	}
 
-	public async resolveTopicRoot(topic: string): Promise<string | undefined> {
-		return (await this.resolveTopicRootState(topic)).root;
+	public async resolveTopicRoot(
+		topic: string,
+		options?: TopicRootResolutionOptions,
+	): Promise<string | undefined> {
+		const lifecycleSignal =
+			this.started && !this.stopping && !this.topicControlPlaneStopping
+				? this.topicRootResolutionAbortController.signal
+				: undefined;
+		return this.withTopicRootCandidateResolution(
+			async ({ signal }) =>
+				(await this.resolveTopicRootState(topic, { signal })).root,
+			[lifecycleSignal, options?.signal],
+		);
 	}
 
 	private async resolveShardRootState(
 		shardTopic: string,
+		options?: TopicRootResolutionOptions,
 	): Promise<{ root: string; candidateGeneration: string }> {
 		const lifecycleRevision = this.topicControlPlaneLifecycleRevision;
 		for (;;) {
+			throwIfAborted(options?.signal);
 			this.assertTopicControlPlaneActive(lifecycleRevision);
 			// If someone configured topic-root candidates externally (e.g.
 			// TestSession router selection or Peerbit.bootstrap) after this peer
@@ -1305,7 +1506,7 @@ export class TopicControlPlane
 				return { root: cached.root, candidateGeneration };
 			}
 
-			const resolved = await this.resolveTopicRootState(shardTopic);
+			const resolved = await this.resolveTopicRootState(shardTopic, options);
 			this.assertTopicControlPlaneActive(lifecycleRevision);
 			if (candidateGeneration !== this.getTopicRootCandidateGeneration()) {
 				continue;
@@ -1391,40 +1592,65 @@ export class TopicControlPlane
 		peer: PeerStreams,
 		topic: string,
 		timeoutMs = DEFAULT_TOPIC_ROOT_QUERY_TIMEOUT_MS,
+		signal?: AbortSignal,
 	): Promise<string | undefined> {
+		throwIfAborted(signal);
 		if (!this.started || this.stopping) return undefined;
 
 		const expectedPeerHash = peer.publicKey.hashcode();
 		const requestId = this.nextTopicRootRequestIdValue();
 		const responsePromise = new Promise<string | undefined>((resolve) => {
-			const timer = setTimeout(() => {
-				this.pendingTopicRootQueries.delete(requestId);
-				resolve(undefined);
-			}, Math.max(1, Math.floor(timeoutMs)));
+			let settled = false;
+			const settle = (root: string | undefined) => {
+				if (settled) return;
+				settled = true;
+				const pending = this.pendingTopicRootQueries.get(requestId);
+				if (pending?.resolve === settle) {
+					this.pendingTopicRootQueries.delete(requestId);
+				}
+				clearTimeout(timer);
+				if (signal && onAbort) {
+					signal.removeEventListener("abort", onAbort);
+				}
+				resolve(root);
+			};
+			const onAbort = signal ? () => settle(undefined) : undefined;
+			const timer = setTimeout(
+				() => settle(undefined),
+				Math.max(1, Math.floor(timeoutMs)),
+			);
 			timer.unref?.();
 			this.pendingTopicRootQueries.set(requestId, {
 				expectedPeerHash,
 				topic,
-				resolve,
+				resolve: settle,
 				timer,
 			});
+			if (signal && onAbort) {
+				signal.addEventListener("abort", onAbort, { once: true });
+				if (signal.aborted) onAbort();
+			}
 		});
 
 		try {
-			await this.sendDirectControlMessage(
-				peer,
-				new TopicRootQuery({ requestId, topic }),
+			await withAbort(
+				this.sendDirectControlMessage(
+					peer,
+					new TopicRootQuery({ requestId, topic }),
+				),
+				signal,
 			);
-		} catch {
+		} catch (error) {
 			const pending = this.pendingTopicRootQueries.get(requestId);
 			if (pending) {
 				this.pendingTopicRootQueries.delete(requestId);
 				clearTimeout(pending.timer);
 				pending.resolve(undefined);
 			}
+			if (signal?.aborted) throw error;
 		}
 
-		return responsePromise;
+		return withAbort(responsePromise, signal);
 	}
 
 	private async confirmDirectShardRoot(
@@ -1444,6 +1670,7 @@ export class TopicControlPlane
 				rootPeer,
 				shardTopic,
 				DIRECT_SHARD_ROOT_CONFIRM_TIMEOUT_MS,
+				signal,
 			),
 			signal,
 		);
@@ -1468,49 +1695,56 @@ export class TopicControlPlane
 		topic: string,
 	): Promise<string | undefined> {
 		const lifecycleRevision = this.topicControlPlaneLifecycleRevision;
-		for (;;) {
-			this.assertTopicControlPlaneActive(lifecycleRevision);
-			const rootCandidateGeneration = this.getTopicRootCandidateGeneration();
-			const root =
-				await this.topicRootControlPlane.resolveCanonicalTopicRoot(topic);
-			this.assertTopicControlPlaneActive(lifecycleRevision);
-			if (rootCandidateGeneration !== this.getTopicRootCandidateGeneration()) {
-				continue;
-			}
-			if (root !== this.publicKeyHash) {
-				return root;
-			}
-			if (!topic.startsWith(this.shardTopicPrefix)) {
-				return root;
-			}
-
-			try {
-				await this.ensureFanoutChannel(topic, {
-					pin: true,
-					root,
-					rootCandidateGeneration,
-				});
+		const lifecycleSignal = this.topicRootResolutionAbortController.signal;
+		return this.withTopicRootCandidateResolution(
+			async ({ candidateGeneration, signal }) => {
+				throwIfAborted(signal);
 				this.assertTopicControlPlaneActive(lifecycleRevision);
-				if (
-					rootCandidateGeneration !== this.getTopicRootCandidateGeneration()
-				) {
-					continue;
+				const root =
+					await this.topicRootControlPlane.resolveCanonicalTopicRoot(topic, {
+						signal,
+					});
+				this.assertTopicControlPlaneActive(lifecycleRevision);
+				if (root !== this.publicKeyHash) {
+					return root;
 				}
-				return root;
-			} catch (error) {
-				warn(
-					`Failed to host shard root ${topic} before answering root query: ${
-						error instanceof Error ? error.message : String(error)
-					}`,
-				);
-				return undefined;
-			}
-		}
+				if (!topic.startsWith(this.shardTopicPrefix)) {
+					return root;
+				}
+
+				try {
+					await this.ensureFanoutChannel(topic, {
+						pin: true,
+						root,
+						rootCandidateGeneration: candidateGeneration,
+						signal,
+					});
+					this.assertTopicControlPlaneActive(lifecycleRevision);
+					return root;
+				} catch (error) {
+					if (
+						signal.aborted ||
+						candidateGeneration !== this.getTopicRootCandidateGeneration()
+					) {
+						throw error;
+					}
+					warn(
+						`Failed to host shard root ${topic} before answering root query: ${
+							error instanceof Error ? error.message : String(error)
+						}`,
+					);
+					return undefined;
+				}
+			},
+			[lifecycleSignal],
+		);
 	}
 
 	private async resolveTopicRootThroughPeers(
 		topic: string,
+		options?: TopicRootResolutionOptions,
 	): Promise<string | undefined> {
+		throwIfAborted(options?.signal);
 		const peers = this.getConnectedTopicRootTrackers();
 		if (peers.length === 0) {
 			return undefined;
@@ -1518,14 +1752,22 @@ export class TopicControlPlane
 
 		for (let attempt = 0; attempt < 3; attempt++) {
 			for (const peer of peers) {
-				const resolved = await this.queryTopicRootFromPeer(peer, topic);
+				const resolved = await this.queryTopicRootFromPeer(
+					peer,
+					topic,
+					DEFAULT_TOPIC_ROOT_QUERY_TIMEOUT_MS,
+					options?.signal,
+				);
 				if (resolved) {
 					return resolved;
 				}
 			}
 
 			if (attempt < 2) {
-				await delay(150 * (attempt + 1));
+				await withAbort(
+					delay(150 * (attempt + 1), options),
+					options?.signal,
+				);
 			}
 		}
 		return undefined;
@@ -1669,7 +1911,9 @@ export class TopicControlPlane
 		const existing = this.fanoutChannels.get(t);
 		if (existing) {
 			if (!root) {
-				const resolved = await this.resolveShardRootState(t);
+				const resolved = await this.resolveShardRootState(t, {
+					signal: options?.signal,
+				});
 				this.assertTopicControlPlaneActive(lifecycleRevision);
 				root = resolved.root;
 				resolvedGeneration = resolved.candidateGeneration;
@@ -1713,7 +1957,9 @@ export class TopicControlPlane
 		}
 
 		if (!root) {
-			const resolved = await this.resolveShardRootState(t);
+			const resolved = await this.resolveShardRootState(t, {
+				signal: options?.signal,
+			});
 			this.assertTopicControlPlaneActive(lifecycleRevision);
 			root = resolved.root;
 			resolvedGeneration = resolved.candidateGeneration;
@@ -1938,22 +2184,37 @@ export class TopicControlPlane
 		}
 	}
 
-	public async hostShardRootsNow() {
+	public async hostShardRootsNow(options?: TopicRootResolutionOptions) {
 		if (!this.started) throw new NotStartedError();
-		const joins: Promise<void>[] = [];
-		for (let i = 0; i < this.shardCount; i++) {
-			const shardTopic = `${this.shardTopicPrefix}${i}`;
-			const resolved = await this.resolveShardRootState(shardTopic);
-			if (resolved.root !== this.publicKeyHash) continue;
-			joins.push(
-				this.ensureFanoutChannel(shardTopic, {
-					pin: true,
-					root: resolved.root,
-					rootCandidateGeneration: resolved.candidateGeneration,
-				}),
-			);
-		}
-		await Promise.all(joins);
+		const lifecycleSignal = this.topicRootResolutionAbortController.signal;
+		return this.withTopicRootCandidateResolution(
+			async ({ candidateGeneration, signal }) => {
+				const joins: Promise<void>[] = [];
+				try {
+					for (let i = 0; i < this.shardCount; i++) {
+						throwIfAborted(signal);
+						const shardTopic = `${this.shardTopicPrefix}${i}`;
+						const resolved = await this.resolveShardRootState(shardTopic, {
+							signal,
+						});
+						if (resolved.root !== this.publicKeyHash) continue;
+						const joining = this.ensureFanoutChannel(shardTopic, {
+							pin: true,
+							root: resolved.root,
+							rootCandidateGeneration: resolved.candidateGeneration,
+							signal,
+						});
+						void joining.catch(() => {});
+						joins.push(joining);
+					}
+					await Promise.all(joins);
+				} catch (error) {
+					await Promise.allSettled(joins);
+					throw error;
+				}
+			},
+			[lifecycleSignal, options?.signal],
+		);
 	}
 
 	async subscribe(topic: string) {