@peerbit/pubsub 5.3.5 → 5.3.7

package/dist/src/index.js

@@ -3,7 +3,7 @@ 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 { DirectStream, } from "@peerbit/stream";
-import { AcknowledgeAnyWhere, AcknowledgeDelivery, AnyWhere, DataMessage, DeliveryError, MessageHeader, NotStartedError, SilentDelivery, deliveryModeHasReceiver, getMsgId, } from "@peerbit/stream-interface";
+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";
 import { Uint8ArrayList } from "uint8arraylist";
 import { toUint8Array } from "./bytes.js";
@@ -148,6 +148,9 @@ export class TopicControlPlane extends DirectStream {
     autoTopicRootCandidates = false;
     autoTopicRootCandidateSet;
     reconcileShardOverlaysInFlight;
+    reconcileShardOverlaysDirty = false;
+    topicControlPlaneStopping = false;
+    topicControlPlaneLifecycleRevision = 0;
     hostOwnedShardRootsInFlight;
     hostOwnedShardRootsDirty = false;
     autoCandidatesBroadcastTimers = [];
@@ -155,6 +158,7 @@ export class TopicControlPlane extends DirectStream {
     autoCandidatesGossipUntil = 0;
     _onFanoutPeerUnreachable;
     fanoutChannels = new Map();
+    ensureFanoutChannelInFlight = new Map();
     pendingTopicRootQueries = new Map();
     nextTopicRootQueryId = 1;
     constructor(components, props) {
@@ -263,6 +267,7 @@ export class TopicControlPlane extends DirectStream {
         this.scheduleReconcileShardOverlays();
     }
     async start() {
+        this.topicControlPlaneStopping = false;
         await this.fanout.start();
         this._onFanoutPeerUnreachable =
             this._onFanoutPeerUnreachable ||
@@ -275,8 +280,15 @@ export class TopicControlPlane extends DirectStream {
         if (this.hostOwnedShardRootsDirty) {
             this.scheduleHostOwnedShardRoots();
         }
+        if (this.reconcileShardOverlaysDirty) {
+            this.scheduleReconcileShardOverlays();
+        }
     }
     async stop() {
+        this.topicControlPlaneStopping = true;
+        this.topicControlPlaneLifecycleRevision += 1;
+        this.reconcileShardOverlaysDirty = false;
+        this.ensureFanoutChannelInFlight.clear();
         if (this._onFanoutPeerUnreachable) {
             this.fanout.removeEventListener("fanout:peer-unreachable", this._onFanoutPeerUnreachable);
         }
@@ -338,7 +350,8 @@ export class TopicControlPlane extends DirectStream {
         this.pendingTopicRootQueries.clear();
         this.debounceSubscribeAggregator.close();
         this.debounceUnsubscribeAggregator.close();
-        return super.stop();
+        await super.stop();
+        this.reconcileShardOverlaysDirty = false;
     }
     async onPeerConnected(peerId, connection) {
         await super.onPeerConnected(peerId, connection);
@@ -554,22 +567,45 @@ export class TopicControlPlane extends DirectStream {
         });
     }
     scheduleReconcileShardOverlays() {
+        this.reconcileShardOverlaysDirty = true;
+        if (!this.started || this.stopping || this.topicControlPlaneStopping)
+            return;
         if (this.reconcileShardOverlaysInFlight)
             return;
-        this.reconcileShardOverlaysInFlight = this.reconcileShardOverlays()
-            .catch(() => {
-            // best-effort retry: fanout streams/roots might not be ready yet.
-            if (!this.started || this.stopping)
-                return;
-            const t = setTimeout(() => this.scheduleReconcileShardOverlays(), 250);
-            t.unref?.();
-        })
-            .finally(() => {
+        this.reconcileShardOverlaysInFlight = (async () => {
+            for (;;) {
+                if (!this.started || this.stopping || this.topicControlPlaneStopping)
+                    return;
+                if (!this.reconcileShardOverlaysDirty)
+                    return;
+                this.reconcileShardOverlaysDirty = false;
+                try {
+                    await this.reconcileShardOverlays();
+                }
+                catch {
+                    // Fanout streams or roots might not be ready yet. Preserve both
+                    // failures and root changes that arrived during the active pass.
+                    if (!this.started || this.stopping || this.topicControlPlaneStopping)
+                        return;
+                    this.reconcileShardOverlaysDirty = true;
+                    await new Promise((resolve) => {
+                        const timer = setTimeout(resolve, 250);
+                        timer.unref?.();
+                    });
+                }
+            }
+        })().finally(() => {
             this.reconcileShardOverlaysInFlight = undefined;
+            if (this.reconcileShardOverlaysDirty &&
+                this.started &&
+                !this.stopping &&
+                !this.topicControlPlaneStopping) {
+                this.scheduleReconcileShardOverlays();
+            }
         });
     }
     async reconcileShardOverlays() {
-        if (!this.started)
+        if (!this.started || this.topicControlPlaneStopping)
             return;
         const byShard = new Map();
         for (const topic of this.subscriptions.keys()) {
@@ -819,6 +855,30 @@ export class TopicControlPlane extends DirectStream {
         }
         return PubSubMessage.from(bytes);
     }
+    getTopicRootCandidateGeneration() {
+        return JSON.stringify([
+            this.autoTopicRootCandidates,
+            this.topicRootControlPlane.getTopicRootCandidates(),
+        ]);
+    }
+    assertTopicControlPlaneActive(lifecycleRevision) {
+        if (lifecycleRevision !== this.topicControlPlaneLifecycleRevision ||
+            !this.started ||
+            this.stopping ||
+            this.topicControlPlaneStopping) {
+            throw new NotStartedError();
+        }
+    }
+    normalizePeerTopicRootState(topic, root) {
+        const deterministic = this.topicRootControlPlane.resolveDeterministicTopicRoot(topic);
+        if (this.autoTopicRootCandidates &&
+            topic.startsWith(this.shardTopicPrefix) &&
+            deterministic &&
+            root !== deterministic) {
+            return { root: deterministic, authoritative: false };
+        }
+        return { root, authoritative: true };
+    }
     async resolveTopicRootState(topic) {
         const tracked = await this.topicRootControlPlane.resolveTrackedTopicRoot(topic);
         if (tracked) {
@@ -826,7 +886,12 @@ export class TopicControlPlane extends DirectStream {
         }
         const resolvedThroughPeers = await this.resolveTopicRootThroughPeers(topic);
         if (resolvedThroughPeers) {
-            return { root: resolvedThroughPeers, authoritative: true };
+            // Unconfigured peer-query replies cannot override the locally
+            // deterministic root for internal shards in auto mode. Roots, resolvers,
+            // and trackers explicitly configured on this control plane are resolved
+            // above and remain authoritative. A leaf relying on a queried gateway for
+            // shard roots must first disable auto mode with setTopicRootCandidates([]).
+            return this.normalizePeerTopicRootState(topic, resolvedThroughPeers);
         }
         const deterministic = this.topicRootControlPlane.resolveDeterministicTopicRoot(topic);
         if (deterministic === this.publicKeyHash &&
@@ -836,38 +901,50 @@ export class TopicControlPlane extends DirectStream {
                 await delay(150 * (attempt < 4 ? 1 : 2));
                 const retried = await this.resolveTopicRootThroughPeers(topic);
                 if (retried) {
-                    return { root: retried, authoritative: true };
+                    return this.normalizePeerTopicRootState(topic, retried);
                 }
             }
         }
-        return { root: deterministic, authoritative: false };
+        return {
+            root: this.topicRootControlPlane.resolveDeterministicTopicRoot(topic),
+            authoritative: false,
+        };
     }
     async resolveTopicRoot(topic) {
         return (await this.resolveTopicRootState(topic)).root;
     }
-    async resolveShardRoot(shardTopic) {
-        // If someone configured topic-root candidates externally (e.g. TestSession router
-        // selection or Peerbit.bootstrap) after this peer entered auto mode, disable auto
-        // mode before we cache any roots based on a stale candidate set.
-        if (this.autoTopicRootCandidates) {
-            this.maybeDisableAutoTopicRootCandidatesIfExternallyConfigured();
-        }
-        const hasConnectedTrackers = this.getConnectedTopicRootTrackers().length > 0;
-        const cached = this.shardRootCache.get(shardTopic);
-        if (cached && (cached.authoritative || !hasConnectedTrackers)) {
-            return cached.root;
-        }
-        const resolved = await this.resolveTopicRootState(shardTopic);
-        if (!resolved.root) {
-            throw new Error(`No root resolved for shard topic ${shardTopic}. Configure TopicRootControlPlane candidates/resolver/trackers, or dial/bootstrap a peer that can resolve shard roots.`);
-        }
-        if (resolved.authoritative || !hasConnectedTrackers) {
-            this.shardRootCache.set(shardTopic, resolved);
-        }
-        else {
-            this.shardRootCache.delete(shardTopic);
+    async resolveShardRootState(shardTopic) {
+        const lifecycleRevision = this.topicControlPlaneLifecycleRevision;
+        for (;;) {
+            this.assertTopicControlPlaneActive(lifecycleRevision);
+            // If someone configured topic-root candidates externally (e.g.
+            // TestSession router selection or Peerbit.bootstrap) after this peer
+            // entered auto mode, disable auto mode before caching a root.
+            if (this.autoTopicRootCandidates) {
+                this.maybeDisableAutoTopicRootCandidatesIfExternallyConfigured();
+            }
+            const candidateGeneration = this.getTopicRootCandidateGeneration();
+            const hasConnectedTrackers = this.getConnectedTopicRootTrackers().length > 0;
+            const cached = this.shardRootCache.get(shardTopic);
+            if (cached && (cached.authoritative || !hasConnectedTrackers)) {
+                return { root: cached.root, candidateGeneration };
+            }
+            const resolved = await this.resolveTopicRootState(shardTopic);
+            this.assertTopicControlPlaneActive(lifecycleRevision);
+            if (candidateGeneration !== this.getTopicRootCandidateGeneration()) {
+                continue;
+            }
+            if (!resolved.root) {
+                throw new Error(`No root resolved for shard topic ${shardTopic}. Configure TopicRootControlPlane candidates/resolver/trackers, or dial/bootstrap a peer that can resolve shard roots.`);
+            }
+            if (resolved.authoritative || !hasConnectedTrackers) {
+                this.shardRootCache.set(shardTopic, resolved);
+            }
+            else {
+                this.shardRootCache.delete(shardTopic);
+            }
+            return { root: resolved.root, candidateGeneration };
         }
-        return resolved.root;
     }
     getConnectedTopicRootTrackers() {
         return [...this.peers.values()]
@@ -900,9 +977,11 @@ export class TopicControlPlane extends DirectStream {
         });
         await this.publishMessage(this.publicKey, embedded, [peer]);
     }
-    resolvePendingTopicRootQuery(message) {
+    resolvePendingTopicRootQuery(message, responderPeerHash) {
         const pending = this.pendingTopicRootQueries.get(message.requestId);
-        if (!pending || pending.topic !== message.topic) {
+        if (!pending ||
+            pending.topic !== message.topic ||
+            pending.expectedPeerHash !== responderPeerHash) {
             return false;
         }
         this.pendingTopicRootQueries.delete(message.requestId);
@@ -913,6 +992,7 @@ export class TopicControlPlane extends DirectStream {
     async queryTopicRootFromPeer(peer, topic, timeoutMs = DEFAULT_TOPIC_ROOT_QUERY_TIMEOUT_MS) {
         if (!this.started || this.stopping)
             return undefined;
+        const expectedPeerHash = peer.publicKey.hashcode();
         const requestId = this.nextTopicRootRequestIdValue();
         const responsePromise = new Promise((resolve) => {
             const timer = setTimeout(() => {
@@ -920,7 +1000,12 @@ export class TopicControlPlane extends DirectStream {
                 resolve(undefined);
             }, Math.max(1, Math.floor(timeoutMs)));
             timer.unref?.();
-            this.pendingTopicRootQueries.set(requestId, { topic, resolve, timer });
+            this.pendingTopicRootQueries.set(requestId, {
+                expectedPeerHash,
+                topic,
+                resolve,
+                timer,
+            });
         });
         try {
             await this.sendDirectControlMessage(peer, new TopicRootQuery({ requestId, topic }));
@@ -935,38 +1020,64 @@ export class TopicControlPlane extends DirectStream {
         }
         return responsePromise;
     }
-    async confirmDirectShardRoot(shardTopic, root, signal) {
+    async confirmDirectShardRoot(shardTopic, root, candidateGeneration, lifecycleRevision, signal) {
+        this.assertTopicControlPlaneActive(lifecycleRevision);
         if (root === this.publicKeyHash)
             return root;
         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);
+        this.assertTopicControlPlaneActive(lifecycleRevision);
+        if (candidateGeneration !== this.getTopicRootCandidateGeneration()) {
+            return root;
+        }
         if (!confirmation)
             return root;
-        if (confirmation !== root) {
+        const resolved = this.normalizePeerTopicRootState(shardTopic, confirmation);
+        if (!resolved.authoritative) {
+            this.shardRootCache.delete(shardTopic);
+        }
+        else if (resolved.root !== root) {
             this.shardRootCache.set(shardTopic, {
-                root: confirmation,
+                root: resolved.root,
                 authoritative: true,
             });
         }
-        return confirmation;
+        return resolved.root;
     }
     async resolveQueryableTopicRoot(topic) {
-        const root = await this.topicRootControlPlane.resolveCanonicalTopicRoot(topic);
-        if (root !== this.publicKeyHash) {
-            return root;
-        }
-        if (!topic.startsWith(this.shardTopicPrefix)) {
-            return root;
-        }
-        try {
-            await this.ensureFanoutChannel(topic, { pin: true, 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;
+        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,
+                });
+                this.assertTopicControlPlaneActive(lifecycleRevision);
+                if (rootCandidateGeneration !== this.getTopicRootCandidateGeneration()) {
+                    continue;
+                }
+                return root;
+            }
+            catch (error) {
+                warn(`Failed to host shard root ${topic} before answering root query: ${error instanceof Error ? error.message : String(error)}`);
+                return undefined;
+            }
         }
     }
     async resolveTopicRootThroughPeers(topic) {
@@ -988,18 +1099,86 @@ export class TopicControlPlane extends DirectStream {
         return undefined;
     }
     async ensureFanoutChannel(shardTopic, options) {
-        if (!this.started)
-            throw new NotStartedError();
+        const topic = shardTopic.toString();
+        const lifecycleRevision = this.topicControlPlaneLifecycleRevision;
+        for (;;) {
+            this.assertTopicControlPlaneActive(lifecycleRevision);
+            const candidateGeneration = this.getTopicRootCandidateGeneration();
+            const active = this.ensureFanoutChannelInFlight.get(topic);
+            if (active?.candidateGeneration === candidateGeneration &&
+                active.lifecycleRevision === lifecycleRevision) {
+                try {
+                    await withAbort(active.opening, options?.signal);
+                }
+                catch (error) {
+                    if (options?.signal?.aborted)
+                        throw error;
+                    this.assertTopicControlPlaneActive(lifecycleRevision);
+                }
+                continue;
+            }
+            const opening = this.ensureFanoutChannelOnce(topic, options, lifecycleRevision, candidateGeneration);
+            const inFlight = {
+                candidateGeneration,
+                lifecycleRevision,
+                opening,
+            };
+            this.ensureFanoutChannelInFlight.set(topic, inFlight);
+            try {
+                await opening;
+                this.assertTopicControlPlaneActive(lifecycleRevision);
+                if (candidateGeneration !== this.getTopicRootCandidateGeneration()) {
+                    continue;
+                }
+                return;
+            }
+            catch (error) {
+                if (options?.signal?.aborted)
+                    throw error;
+                this.assertTopicControlPlaneActive(lifecycleRevision);
+                if (candidateGeneration !== this.getTopicRootCandidateGeneration()) {
+                    continue;
+                }
+                throw error;
+            }
+            finally {
+                if (this.ensureFanoutChannelInFlight.get(topic) === inFlight) {
+                    this.ensureFanoutChannelInFlight.delete(topic);
+                }
+            }
+        }
+    }
+    async ensureFanoutChannelOnce(shardTopic, options, lifecycleRevision, candidateGeneration) {
+        this.assertTopicControlPlaneActive(lifecycleRevision);
+        if (candidateGeneration !== this.getTopicRootCandidateGeneration())
+            return;
         const t = shardTopic.toString();
         const pin = options?.pin === true;
         const wantEphemeral = options?.ephemeral === true;
         // Allow callers that already resolved the shard root (e.g. hostShardRootsNow)
         // to pass it through to avoid a race where the candidate set changes between
         // two resolve calls, causing an unnecessary (and potentially slow) join.
-        let root = options?.root;
+        const suppliedRoot = options?.root;
+        const suppliedRootGeneration = options?.rootCandidateGeneration;
+        if (suppliedRoot !== undefined &&
+            suppliedRootGeneration !== candidateGeneration) {
+            return;
+        }
+        this.assertTopicControlPlaneActive(lifecycleRevision);
+        let resolvedGeneration = candidateGeneration;
+        let root = suppliedRoot;
         const existing = this.fanoutChannels.get(t);
         if (existing) {
-            root = root ?? (await this.resolveShardRoot(t));
+            if (!root) {
+                const resolved = await this.resolveShardRootState(t);
+                this.assertTopicControlPlaneActive(lifecycleRevision);
+                root = resolved.root;
+                resolvedGeneration = resolved.candidateGeneration;
+            }
+            if (resolvedGeneration !== candidateGeneration ||
+                candidateGeneration !== this.getTopicRootCandidateGeneration()) {
+                return;
+            }
             if (root === existing.root) {
                 existing.lastUsedAt = Date.now();
                 if (existing.ephemeral && !wantEphemeral) {
@@ -1012,13 +1191,33 @@ export class TopicControlPlane extends DirectStream {
                 if (pin)
                     this.pinnedShards.add(t);
                 await withAbort(existing.join, options?.signal);
+                this.assertTopicControlPlaneActive(lifecycleRevision);
+                if (resolvedGeneration !== candidateGeneration ||
+                    candidateGeneration !== this.getTopicRootCandidateGeneration()) {
+                    return;
+                }
                 return;
             }
-            // Root mapping changed (candidate set updated): migrate to the new overlay.
+            // Root mapping changed (candidate set updated): migrate to the new
+            // overlay.
             await withAbort(this.closeFanoutChannel(t, { force: true }), options?.signal);
+            this.assertTopicControlPlaneActive(lifecycleRevision);
+            if (candidateGeneration !== this.getTopicRootCandidateGeneration()) {
+                return;
+            }
+        }
+        if (!root) {
+            const resolved = await this.resolveShardRootState(t);
+            this.assertTopicControlPlaneActive(lifecycleRevision);
+            root = resolved.root;
+            resolvedGeneration = resolved.candidateGeneration;
+        }
+        root = await this.confirmDirectShardRoot(t, root, resolvedGeneration, lifecycleRevision, options?.signal);
+        this.assertTopicControlPlaneActive(lifecycleRevision);
+        if (resolvedGeneration !== candidateGeneration ||
+            candidateGeneration !== this.getTopicRootCandidateGeneration()) {
+            return;
         }
-        root = root ?? (await this.resolveShardRoot(t));
-        root = await this.confirmDirectShardRoot(t, root, options?.signal);
         const channel = new FanoutChannel(this.fanout, { topic: t, root });
         const onPayload = (payload) => {
             let dm;
@@ -1160,7 +1359,7 @@ export class TopicControlPlane extends DirectStream {
         const lastUsedAt = Date.now();
         if (pin)
             this.pinnedShards.add(t);
-        this.fanoutChannels.set(t, {
+        const channelState = {
             root,
             channel,
             join,
@@ -1168,15 +1367,19 @@ export class TopicControlPlane extends DirectStream {
             onUnicast,
             ephemeral: wantEphemeral,
             lastUsedAt,
-        });
+        };
+        this.fanoutChannels.set(t, channelState);
         join.catch(() => {
-            this.fanoutChannels.delete(t);
+            if (this.fanoutChannels.get(t) === channelState) {
+                this.fanoutChannels.delete(t);
+            }
         });
         join
             .then(() => {
             const st = this.fanoutChannels.get(t);
-            if (st?.ephemeral)
+            if (st === channelState && st.ephemeral) {
                 this.scheduleFanoutIdleClose(t);
+            }
         })
             .catch(() => {
             // ignore
@@ -1185,6 +1388,7 @@ export class TopicControlPlane extends DirectStream {
             this.evictEphemeralFanoutChannels(t);
         }
         await withAbort(join, options?.signal);
+        this.assertTopicControlPlaneActive(lifecycleRevision);
     }
     async closeFanoutChannel(shardTopic, options) {
         const t = shardTopic.toString();
@@ -1227,10 +1431,14 @@ export class TopicControlPlane extends DirectStream {
         const joins = [];
         for (let i = 0; i < this.shardCount; i++) {
             const shardTopic = `${this.shardTopicPrefix}${i}`;
-            const root = await this.resolveShardRoot(shardTopic);
-            if (root !== this.publicKeyHash)
+            const resolved = await this.resolveShardRootState(shardTopic);
+            if (resolved.root !== this.publicKeyHash)
                 continue;
-            joins.push(this.ensureFanoutChannel(shardTopic, { pin: true, root }));
+            joins.push(this.ensureFanoutChannel(shardTopic, {
+                pin: true,
+                root: resolved.root,
+                rootCandidateGeneration: resolved.candidateGeneration,
+            }));
         }
         await Promise.all(joins);
     }
@@ -1563,7 +1771,7 @@ export class TopicControlPlane extends DirectStream {
                     }),
                 }));
             }
-            const silentDelivery = options?.mode instanceof SilentDelivery;
+            const silentDelivery = options?.mode != null && isSilentDeliveryMode(options.mode);
             try {
                 await this.publishMessage(this.publicKey, message, undefined, undefined, options?.signal);
             }
@@ -1665,7 +1873,7 @@ export class TopicControlPlane extends DirectStream {
                 message,
             }),
         }));
-        const silentDelivery = options.mode instanceof SilentDelivery;
+        const silentDelivery = isSilentDeliveryMode(options.mode);
         try {
             await this.publishMessage(this.publicKey, message, undefined, undefined, options?.signal);
         }
@@ -1932,6 +2140,16 @@ export class TopicControlPlane extends DirectStream {
     }
     async processDirectPubSubMessage(input) {
         const { pubsubMessage, message, from, stream } = input;
+        const isDirectRootControl = pubsubMessage instanceof TopicRootCandidates ||
+            pubsubMessage instanceof TopicRootQuery ||
+            pubsubMessage instanceof TopicRootQueryResponse;
+        const directRootSigner = isDirectRootControl
+            ? message.header.signatures?.publicKeys[0]
+            : undefined;
+        if (isDirectRootControl &&
+            (!directRootSigner || !directRootSigner.equals(stream.publicKey))) {
+            return;
+        }
         if (pubsubMessage instanceof TopicRootCandidates) {
             // Used only to converge deterministic shard-root candidates in auto mode.
             this.mergeAutoTopicRootCandidatesFromPeer(pubsubMessage.candidates);
@@ -1947,7 +2165,8 @@ export class TopicControlPlane extends DirectStream {
             return;
         }
         if (pubsubMessage instanceof TopicRootQueryResponse) {
-            this.resolvePendingTopicRootQuery(pubsubMessage);
+            const senderHash = directRootSigner.hashcode();
+            this.resolvePendingTopicRootQuery(pubsubMessage, senderHash);
             return;
         }
         if (pubsubMessage instanceof Subscribe) {
@@ -2197,8 +2416,8 @@ export class TopicControlPlane extends DirectStream {
         if (deliveryModeHasReceiver(message.header.mode)) {
             isForMe = message.header.mode.to.includes(this.publicKeyHash);
         }
-        else if (message.header.mode instanceof AnyWhere ||
-            message.header.mode instanceof AcknowledgeAnyWhere) {
+        else if (isAnyWhereDeliveryMode(message.header.mode) ||
+            isAcknowledgeAnyWhereDeliveryMode(message.header.mode)) {
             isForMe = true;
         }
         if (pubsubMessage instanceof PubSubData) {
@@ -2222,16 +2441,16 @@ export class TopicControlPlane extends DirectStream {
         if (!(pubsubMessage instanceof PubSubData)) {
             return true;
         }
-        if (message.header.mode instanceof SilentDelivery ||
-            message.header.mode instanceof AcknowledgeDelivery) {
+        if (isSilentDeliveryMode(message.header.mode) ||
+            isAcknowledgeDeliveryMode(message.header.mode)) {
             if (message.header.mode.to.length === 1 &&
                 message.header.mode.to[0] === this.publicKeyHash) {
                 return true;
             }
         }
         const shouldForward = seenBefore === 0 ||
-            ((message.header.mode instanceof AcknowledgeDelivery ||
-                message.header.mode instanceof AcknowledgeAnyWhere) &&
+            ((isAcknowledgeDeliveryMode(message.header.mode) ||
+                isAcknowledgeAnyWhereDeliveryMode(message.header.mode)) &&
                 seenBefore < message.header.mode.redundancy);
         if (shouldForward) {
             this.relayMessage(from, message).catch(logErrorIfStarted);