@peerbit/pubsub 5.3.8 → 5.3.10

package/dist/src/index.js

@@ -1,7 +1,7 @@
 import {} from "@libp2p/interface";
 import { PublicSignKey, getPublicKeyFromPeerId } from "@peerbit/crypto";
 import { logger as loggerFn } from "@peerbit/logger";
-import { DataEvent, GetSubscribers, PeerUnavailable, PubSubData, PubSubMessage, PublishEvent, Subscribe, SubscriptionData, SubscriptionEvent, TopicRootCandidates, TopicRootQuery, TopicRootQueryResponse, UnsubcriptionEvent, Unsubscribe, } from "@peerbit/pubsub-interface";
+import { assertCanonicalTopicRootCandidates, assertTopicRootCandidatesFrame, DataEvent, GetSubscribers, isCanonicalTopicRootCandidate, PeerUnavailable, PubSubData, PubSubMessage, PublishEvent, Subscribe, SubscriptionData, SubscriptionEvent, TOPIC_ROOT_CANDIDATES_MAX, TopicRootCandidates, TopicRootQuery, TopicRootQueryResponse, UnsubcriptionEvent, Unsubscribe, } from "@peerbit/pubsub-interface";
 import { DirectStream, } from "@peerbit/stream";
 import { AcknowledgeAnyWhere, AcknowledgeDelivery, AnyWhere, DataMessage, DeliveryError, MessageHeader, NotStartedError, SilentDelivery, deliveryModeHasReceiver, getMsgId, isAcknowledgeAnyWhereDeliveryMode, isAcknowledgeDeliveryMode, isAnyWhereDeliveryMode, isSilentDeliveryMode, } from "@peerbit/stream-interface";
 import { AbortError, TimeoutError, delay } from "@peerbit/time";
@@ -9,7 +9,7 @@ import { Uint8ArrayList } from "uint8arraylist";
 import { toUint8Array } from "./bytes.js";
 import { debouncedAccumulatorSetCounter, } from "./debounced-set.js";
 import { FanoutChannel } from "./fanout-channel.js";
-import { TopicRootControlPlane } from "./topic-root-control-plane.js";
+import { TopicRootControlPlane, } from "./topic-root-control-plane.js";
 export * from "./fanout-tree.js";
 // The complete /peerbit/fanout-tree/0.5.0 wire codec and the
 // parent-upgrade decision module (the TS references the native rust-core
@@ -43,6 +43,7 @@ const withAbort = async (promise, signal) => {
     if (!signal)
         return promise;
     if (signal.aborted) {
+        void promise.catch(() => { });
         throw signal.reason ?? new AbortError("Operation was aborted");
     }
     return new Promise((resolve, reject) => {
@@ -68,6 +69,41 @@ const withAbort = async (promise, signal) => {
         });
     });
 };
+const throwIfAborted = (signal) => {
+    if (signal?.aborted) {
+        throw signal.reason ?? new AbortError("Operation was aborted");
+    }
+};
+const linkAbortSignals = (signals) => {
+    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();
+    const clear = () => {
+        for (const [signal, listener] of listeners) {
+            signal.removeEventListener("abort", listener);
+        }
+        listeners.clear();
+    };
+    const abortFrom = (signal) => {
+        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;
@@ -75,7 +111,9 @@ 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, right) => 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;
@@ -147,10 +185,15 @@ export class TopicControlPlane extends DirectStream {
     // This keeps small ad-hoc networks working without explicit bootstraps.
     autoTopicRootCandidates = false;
     autoTopicRootCandidateSet;
+    pendingAutoTopicRootCandidates;
+    autoTopicRootCandidateUpdateTimer;
     reconcileShardOverlaysInFlight;
     reconcileShardOverlaysDirty = false;
     topicControlPlaneStopping = false;
     topicControlPlaneLifecycleRevision = 0;
+    topicRootResolutionAbortController = new AbortController();
+    topicRootCandidateResolutionGeneration;
+    topicRootCandidateResolutionAbortController = new AbortController();
     hostOwnedShardRootsInFlight;
     hostOwnedShardRootsDirty = false;
     autoCandidatesBroadcastTimers = [];
@@ -249,6 +292,7 @@ export class TopicControlPlane extends DirectStream {
         // 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 = [];
@@ -268,6 +312,9 @@ export class TopicControlPlane extends DirectStream {
     }
     async start() {
         this.topicControlPlaneStopping = false;
+        if (this.topicRootResolutionAbortController.signal.aborted) {
+            this.topicRootResolutionAbortController = new AbortController();
+        }
         await this.fanout.start();
         this._onFanoutPeerUnreachable =
             this._onFanoutPeerUnreachable ||
@@ -286,6 +333,8 @@ export class TopicControlPlane extends DirectStream {
     }
     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()) {
@@ -397,6 +446,7 @@ export class TopicControlPlane extends DirectStream {
         // 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
         // in tests where candidates may be configured before protocol streams have
@@ -409,43 +459,25 @@ export class TopicControlPlane extends DirectStream {
     maybeUpdateAutoTopicRootCandidates(peerHash) {
         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]);
     }
     normalizeAutoTopicRootCandidates(candidates) {
+        const canonicalCandidates = candidates.filter(isCanonicalTopicRootCandidate);
         if (this.nativeTopicControl) {
-            return this.nativeTopicControl.normalizeAutoCandidates(candidates, this.publicKeyHash);
+            return this.nativeTopicControl.normalizeAutoCandidates(canonicalCandidates, this.publicKeyHash);
         }
         const unique = new Set();
-        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);
     }
     scheduleAutoTopicRootCandidatesBroadcast(targets) {
         if (!this.autoTopicRootCandidates)
@@ -515,29 +547,78 @@ export class TopicControlPlane extends DirectStream {
     mergeAutoTopicRootCandidatesFromPeer(candidates) {
         if (!this.autoTopicRootCandidates)
             return false;
+        return this.queueAutoTopicRootCandidateUpdate(candidates);
+    }
+    queueAutoTopicRootCandidateUpdate(candidates) {
+        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])) {
+        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;
+    }
+    applyAutoTopicRootCandidates(next) {
         this.autoTopicRootCandidateSet = new Set(next);
         this.topicRootControlPlane.setTopicRootCandidates(next);
         this.shardRootCache.clear();
         this.scheduleReconcileShardOverlays();
         this.scheduleHostOwnedShardRoots();
         this.scheduleAutoTopicRootCandidatesBroadcast();
-        return true;
+    }
+    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;
+    }
+    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);
+    }
+    clearAutoTopicRootCandidateUpdateSchedule() {
+        if (this.autoTopicRootCandidateUpdateTimer) {
+            clearTimeout(this.autoTopicRootCandidateUpdateTimer);
+            this.autoTopicRootCandidateUpdateTimer = undefined;
+        }
+        this.pendingAutoTopicRootCandidates = undefined;
     }
     scheduleHostOwnedShardRoots() {
         this.hostOwnedShardRootsDirty = true;
@@ -571,6 +652,7 @@ export class TopicControlPlane extends DirectStream {
     }
     scheduleReconcileShardOverlays() {
         const candidateGeneration = this.getTopicRootCandidateGeneration();
+        this.syncTopicRootCandidateResolutionSignal(candidateGeneration);
         for (const opening of this.ensureFanoutChannelInFlight.values()) {
             if (opening.candidateGeneration !== candidateGeneration) {
                 opening.abortController.abort(new AbortError("topic root candidates changed"));
@@ -821,6 +903,9 @@ export class TopicControlPlane extends DirectStream {
      * their fallback behavior).
      */
     decodePubSubMessage(bytes) {
+        if (bytes[0] === 4) {
+            assertTopicRootCandidatesFrame(bytes);
+        }
         const native = this.nativeTopicControl;
         if (native) {
             const decoded = native.decodePubSubMessage(bytes);
@@ -841,6 +926,7 @@ export class TopicControlPlane extends DirectStream {
                 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({
@@ -878,6 +964,53 @@ export class TopicControlPlane extends DirectStream {
             throw new NotStartedError();
         }
     }
+    syncTopicRootCandidateResolutionSignal(candidateGeneration = this.getTopicRootCandidateGeneration()) {
+        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;
+    }
+    async withTopicRootCandidateResolution(operation, terminalSignals = []) {
+        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();
+            }
+        }
+    }
     normalizePeerTopicRootState(topic, root) {
         const deterministic = this.topicRootControlPlane.resolveDeterministicTopicRoot(topic);
         if (this.autoTopicRootCandidates &&
@@ -888,12 +1021,13 @@ export class TopicControlPlane extends DirectStream {
         }
         return { root, authoritative: true };
     }
-    async resolveTopicRootState(topic) {
-        const tracked = await this.topicRootControlPlane.resolveTrackedTopicRoot(topic);
+    async resolveTopicRootState(topic, options) {
+        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,
@@ -907,8 +1041,8 @@ export class TopicControlPlane extends DirectStream {
             this.autoTopicRootCandidates &&
             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);
                 }
@@ -919,12 +1053,16 @@ export class TopicControlPlane extends DirectStream {
             authoritative: false,
         };
     }
-    async resolveTopicRoot(topic) {
-        return (await this.resolveTopicRootState(topic)).root;
+    async resolveTopicRoot(topic, options) {
+        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]);
     }
-    async resolveShardRootState(shardTopic) {
+    async resolveShardRootState(shardTopic, options) {
         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
@@ -938,7 +1076,7 @@ export class TopicControlPlane extends DirectStream {
             if (cached && (cached.authoritative || !hasConnectedTrackers)) {
                 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;
@@ -998,36 +1136,57 @@ export class TopicControlPlane extends DirectStream {
         pending.resolve(message.root);
         return true;
     }
-    async queryTopicRootFromPeer(peer, topic, timeoutMs = DEFAULT_TOPIC_ROOT_QUERY_TIMEOUT_MS) {
+    async queryTopicRootFromPeer(peer, topic, timeoutMs = DEFAULT_TOPIC_ROOT_QUERY_TIMEOUT_MS, signal) {
+        throwIfAborted(signal);
         if (!this.started || this.stopping)
             return undefined;
         const expectedPeerHash = peer.publicKey.hashcode();
         const requestId = this.nextTopicRootRequestIdValue();
         const responsePromise = new Promise((resolve) => {
-            const timer = setTimeout(() => {
-                this.pendingTopicRootQueries.delete(requestId);
-                resolve(undefined);
-            }, Math.max(1, Math.floor(timeoutMs)));
+            let settled = false;
+            const settle = (root) => {
+                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);
     }
     async confirmDirectShardRoot(shardTopic, root, candidateGeneration, lifecycleRevision, signal) {
         this.assertTopicControlPlaneActive(lifecycleRevision);
@@ -1036,7 +1195,7 @@ export class TopicControlPlane extends DirectStream {
         const rootPeer = this.peers.get(root);
         if (!rootPeer)
             return root;
-        const confirmation = await withAbort(this.queryTopicRootFromPeer(rootPeer, shardTopic, DIRECT_SHARD_ROOT_CONFIRM_TIMEOUT_MS), signal);
+        const confirmation = await withAbort(this.queryTopicRootFromPeer(rootPeer, shardTopic, DIRECT_SHARD_ROOT_CONFIRM_TIMEOUT_MS, signal), signal);
         this.assertTopicControlPlaneActive(lifecycleRevision);
         if (candidateGeneration !== this.getTopicRootCandidateGeneration()) {
             return root;
@@ -1057,14 +1216,14 @@ export class TopicControlPlane extends DirectStream {
     }
     async resolveQueryableTopicRoot(topic) {
         const lifecycleRevision = this.topicControlPlaneLifecycleRevision;
-        for (;;) {
+        const lifecycleSignal = this.topicRootResolutionAbortController.signal;
+        return this.withTopicRootCandidateResolution(async ({ candidateGeneration, signal }) => {
+            throwIfAborted(signal);
             this.assertTopicControlPlaneActive(lifecycleRevision);
-            const rootCandidateGeneration = this.getTopicRootCandidateGeneration();
-            const root = await this.topicRootControlPlane.resolveCanonicalTopicRoot(topic);
+            const root = await this.topicRootControlPlane.resolveCanonicalTopicRoot(topic, {
+                signal,
+            });
             this.assertTopicControlPlaneActive(lifecycleRevision);
-            if (rootCandidateGeneration !== this.getTopicRootCandidateGeneration()) {
-                continue;
-            }
             if (root !== this.publicKeyHash) {
                 return root;
             }
@@ -1075,34 +1234,37 @@ export class TopicControlPlane extends DirectStream {
                 await this.ensureFanoutChannel(topic, {
                     pin: true,
                     root,
-                    rootCandidateGeneration,
+                    rootCandidateGeneration: candidateGeneration,
+                    signal,
                 });
                 this.assertTopicControlPlaneActive(lifecycleRevision);
-                if (rootCandidateGeneration !== this.getTopicRootCandidateGeneration()) {
-                    continue;
-                }
                 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]);
     }
-    async resolveTopicRootThroughPeers(topic) {
+    async resolveTopicRootThroughPeers(topic, options) {
+        throwIfAborted(options?.signal);
         const peers = this.getConnectedTopicRootTrackers();
         if (peers.length === 0) {
             return undefined;
         }
         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;
@@ -1226,7 +1388,9 @@ export class TopicControlPlane extends DirectStream {
         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;
@@ -1263,7 +1427,9 @@ export class TopicControlPlane extends DirectStream {
             }
         }
         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;
@@ -1481,22 +1647,37 @@ export class TopicControlPlane extends DirectStream {
             }
         }
     }
-    async hostShardRootsNow() {
+    async hostShardRootsNow(options) {
         if (!this.started)
             throw new NotStartedError();
-        const joins = [];
-        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 = [];
+            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) {
         this.pendingSubscriptions.add(topic);