@peerbit/pubsub 5.2.11 → 5.3.1

package/dist/src/index.js

@@ -11,11 +11,28 @@ import { debouncedAccumulatorSetCounter, } from "./debounced-set.js";
 import { FanoutChannel } from "./fanout-channel.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
+// implementations are parity-tested against).
+export * as fanoutWire from "./fanout-tree-codec.js";
+export * as fanoutParentUpgrade from "./fanout-tree-parent-upgrade.js";
 export * from "./fanout-channel.js";
 export * from "./topic-root-control-plane.js";
 export { toUint8Array } from "./bytes.js";
 export const logger = loggerFn("peerbit:transport:topic-control-plane");
 const warn = logger.newScope("warn");
+const utf8Encoder = new TextEncoder();
+/**
+ * Offset of the `data` bytes inside a borsh-serialized `PubSubData`
+ * (variant byte + topics vec + strict bool + data length prefix).
+ */
+const preEncodedPubSubDataOffset = (topics) => {
+    let offset = 1 + 4; // variant + topics vec length
+    for (const topic of topics) {
+        offset += 4 + utf8Encoder.encode(topic).byteLength;
+    }
+    return offset + 1 + 4; // strict + data length prefix
+};
 const logError = (e) => {
     logger.error(e?.message);
 };
@@ -62,6 +79,7 @@ const AUTO_TOPIC_ROOT_CANDIDATES_MAX = 64;
 // 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;
+const DIRECT_SHARD_ROOT_CONFIRM_TIMEOUT_MS = 2_000;
 const DEFAULT_PUBSUB_FANOUT_CHANNEL_OPTIONS = {
     msgRate: 30,
     msgSize: 1024,
@@ -89,11 +107,26 @@ export class TopicControlPlane extends DirectStream {
     subscriptions;
     // Local topics requested via debounced subscribe, not yet applied in `subscriptions`.
     pendingSubscriptions;
+    /**
+     * Per-shard batching of Subscribe{requestSubscribers} responses. When many
+     * peers announce subscriptions in a burst (group subscribe), answering each
+     * announcer with a routed unicast is quadratic in subscriber count and
+     * melts the fanout route-resolution machinery (#983); a short window lets
+     * one broadcast answer all concurrent announcers instead.
+     */
+    pendingSubscriberResponses = new Map();
     lastSubscriptionMessages = new Map();
     dispatchEventOnSelfPublish;
     topicRootControlPlane;
     subscriberCacheMaxEntries;
     fanout;
+    // Native topic-control components of the rust-core DirectStream engine
+    // (`@peerbit/network-rust`). When set, the PubSubMessage codec, the topic
+    // hashing behind shard mapping and root selection, the root-directory
+    // state and the subscribe-state convergence rules run natively; the
+    // observable subscription maps and all events stay unchanged. Unset (the
+    // default) leaves every code path as-is.
+    nativeTopicControl;
     debounceSubscribeAggregator;
     debounceUnsubscribeAggregator;
     shardCount;
@@ -132,6 +165,10 @@ export class TopicControlPlane extends DirectStream {
         this.peerToTopic = new Map();
         this.topicRootControlPlane =
             props?.topicRootControlPlane || new TopicRootControlPlane();
+        this.nativeTopicControl = this.rustCore?.topicControl;
+        if (this.nativeTopicControl) {
+            this.topicRootControlPlane.adoptNativeDirectoryState(this.nativeTopicControl.createRootDirectoryState());
+        }
         this.dispatchEventOnSelfPublish =
             props?.dispatchEventOnSelfPublish || false;
         if (!props?.fanout) {
@@ -173,10 +210,10 @@ export class TopicControlPlane extends DirectStream {
         this.fanoutPublishMaxEphemeralChannels = Math.max(0, Math.floor(requestedMaxEphemeral));
         const requestedSubscriberCacheMaxEntries = props?.subscriberCacheMaxEntries ?? SUBSCRIBER_CACHE_DEFAULT_MAX_ENTRIES;
         this.subscriberCacheMaxEntries = Math.min(SUBSCRIBER_CACHE_MAX_ENTRIES_HARD_CAP, Math.max(1, Math.floor(requestedSubscriberCacheMaxEntries)));
-        this.debounceSubscribeAggregator = debouncedAccumulatorSetCounter((set) => this._subscribe([...set.values()]), props?.subscriptionDebounceDelay ?? 50);
+        this.debounceSubscribeAggregator = debouncedAccumulatorSetCounter((set) => this._subscribe([...set.values()]), props?.subscriptionDebounceDelay ?? 50, (error) => logger.error(`Debounced subscribe failed: ${error?.message ?? error}`));
         // NOTE: Unsubscribe should update local state immediately and batch only the
         // best-effort network announcements to avoid teardown stalls (program close).
-        this.debounceUnsubscribeAggregator = debouncedAccumulatorSetCounter((set) => this._announceUnsubscribe([...set.values()]), props?.subscriptionDebounceDelay ?? 50);
+        this.debounceUnsubscribeAggregator = debouncedAccumulatorSetCounter((set) => this._announceUnsubscribe([...set.values()]), props?.subscriptionDebounceDelay ?? 50, (error) => logger.error(`Debounced unsubscribe announce failed: ${error?.message ?? error}`));
     }
     /**
      * Configure deterministic topic-root candidates and disable the pubsub "auto"
@@ -268,6 +305,10 @@ export class TopicControlPlane extends DirectStream {
         this.hostOwnedShardRootsDirty = false;
         this.subscriptions.clear();
         this.pendingSubscriptions.clear();
+        for (const entry of this.pendingSubscriberResponses.values()) {
+            clearTimeout(entry.timer);
+        }
+        this.pendingSubscriberResponses.clear();
         this.topics.clear();
         this.peerToTopic.clear();
         this.lastSubscriptionMessages.clear();
@@ -362,6 +403,9 @@ export class TopicControlPlane extends DirectStream {
         this.scheduleAutoTopicRootCandidatesBroadcast();
     }
     normalizeAutoTopicRootCandidates(candidates) {
+        if (this.nativeTopicControl) {
+            return this.nativeTopicControl.normalizeAutoCandidates(candidates, this.publicKeyHash);
+        }
         const unique = new Set();
         for (const c of candidates) {
             if (!c)
@@ -430,7 +474,7 @@ export class TopicControlPlane extends DirectStream {
         if (candidates.length === 0)
             return;
         const msg = new TopicRootCandidates({ candidates });
-        const embedded = await this.createMessage(toUint8Array(msg.bytes()), {
+        const embedded = await this.createMessage(this.encodePubSubMessage(msg), {
             mode: new AnyWhere(),
             priority: 1,
             skipRecipientValidation: true,
@@ -527,7 +571,7 @@ export class TopicControlPlane extends DirectStream {
                 topics: userTopics,
                 requestSubscribers: true,
             });
-            const embedded = await this.createMessage(toUint8Array(msg.bytes()), {
+            const embedded = await this.createMessage(this.encodePubSubMessage(msg), {
                 mode: new AnyWhere(),
                 priority: 1,
                 skipRecipientValidation: true,
@@ -671,11 +715,95 @@ export class TopicControlPlane extends DirectStream {
         const cached = this.shardTopicCache.get(t);
         if (cached)
             return cached;
-        const index = topicHash32(t) % this.shardCount;
-        const shardTopic = `${this.shardTopicPrefix}${index}`;
+        const shardTopic = this.nativeTopicControl
+            ? this.nativeTopicControl.shardTopic(t, this.shardCount, this.shardTopicPrefix)
+            : `${this.shardTopicPrefix}${topicHash32(t) % this.shardCount}`;
         this.shardTopicCache.set(t, shardTopic);
         return shardTopic;
     }
+    /**
+     * Serialize a control-plane message (borsh `PubSubMessage`); rust-core
+     * mode encodes natively (byte-identical, covered by the parity suite).
+     */
+    encodePubSubMessage(message) {
+        const native = this.nativeTopicControl;
+        if (native) {
+            if (message instanceof PubSubData) {
+                return native.encodePubSubData(message.topics, message.strict, message.data);
+            }
+            if (message instanceof Subscribe) {
+                return native.encodeSubscribe(message.topics, message.requestSubscribers);
+            }
+            if (message instanceof Unsubscribe) {
+                return native.encodeUnsubscribe(message.topics);
+            }
+            if (message instanceof GetSubscribers) {
+                return native.encodeGetSubscribers(message.topics);
+            }
+            if (message instanceof TopicRootCandidates) {
+                return native.encodeTopicRootCandidates(message.candidates);
+            }
+            if (message instanceof PeerUnavailable) {
+                return native.encodePeerUnavailable(message.publicKeyHash, message.session, message.timestamp, message.topics);
+            }
+            if (message instanceof TopicRootQuery) {
+                return native.encodeTopicRootQuery(message.requestId, message.topic);
+            }
+            if (message instanceof TopicRootQueryResponse) {
+                return native.encodeTopicRootQueryResponse(message.requestId, message.topic, message.root);
+            }
+        }
+        return toUint8Array(message.bytes());
+    }
+    /**
+     * Parse a control-plane payload; rust-core mode decodes natively into the
+     * same message classes (decode failures throw either way, so callers keep
+     * their fallback behavior).
+     */
+    decodePubSubMessage(bytes) {
+        const native = this.nativeTopicControl;
+        if (native) {
+            const decoded = native.decodePubSubMessage(bytes);
+            switch (decoded.type) {
+                case "data":
+                    return new PubSubData({
+                        topics: decoded.topics,
+                        data: decoded.data,
+                        strict: decoded.strict,
+                    });
+                case "subscribe":
+                    return new Subscribe({
+                        topics: decoded.topics,
+                        requestSubscribers: decoded.requestSubscribers,
+                    });
+                case "unsubscribe":
+                    return new Unsubscribe({ topics: decoded.topics });
+                case "get-subscribers":
+                    return new GetSubscribers({ topics: decoded.topics });
+                case "topic-root-candidates":
+                    return new TopicRootCandidates({ candidates: decoded.candidates });
+                case "peer-unavailable":
+                    return new PeerUnavailable({
+                        publicKeyHash: decoded.publicKeyHash,
+                        session: decoded.session,
+                        timestamp: decoded.timestamp,
+                        topics: decoded.topics,
+                    });
+                case "topic-root-query":
+                    return new TopicRootQuery({
+                        requestId: decoded.requestId,
+                        topic: decoded.topic,
+                    });
+                case "topic-root-query-response":
+                    return new TopicRootQueryResponse({
+                        requestId: decoded.requestId,
+                        topic: decoded.topic,
+                        root: decoded.root,
+                    });
+            }
+        }
+        return PubSubMessage.from(bytes);
+    }
     async resolveTopicRootState(topic) {
         const tracked = await this.topicRootControlPlane.resolveTrackedTopicRoot(topic);
         if (tracked) {
@@ -747,7 +875,7 @@ export class TopicControlPlane extends DirectStream {
         } while (true);
     }
     async sendDirectControlMessage(peer, pubsubMessage) {
-        const embedded = await this.createMessage(toUint8Array(pubsubMessage.bytes()), {
+        const embedded = await this.createMessage(this.encodePubSubMessage(pubsubMessage), {
             mode: new SilentDelivery({
                 to: [peer.publicKey.hashcode()],
                 redundancy: 1,
@@ -767,7 +895,7 @@ export class TopicControlPlane extends DirectStream {
         pending.resolve(message.root);
         return true;
     }
-    async queryTopicRootFromPeer(peer, topic) {
+    async queryTopicRootFromPeer(peer, topic, timeoutMs = DEFAULT_TOPIC_ROOT_QUERY_TIMEOUT_MS) {
         if (!this.started || this.stopping)
             return undefined;
         const requestId = this.nextTopicRootRequestIdValue();
@@ -775,7 +903,7 @@ export class TopicControlPlane extends DirectStream {
             const timer = setTimeout(() => {
                 this.pendingTopicRootQueries.delete(requestId);
                 resolve(undefined);
-            }, DEFAULT_TOPIC_ROOT_QUERY_TIMEOUT_MS);
+            }, Math.max(1, Math.floor(timeoutMs)));
             timer.unref?.();
             this.pendingTopicRootQueries.set(requestId, { topic, resolve, timer });
         });
@@ -792,6 +920,23 @@ export class TopicControlPlane extends DirectStream {
         }
         return responsePromise;
     }
+    async confirmDirectShardRoot(shardTopic, root, signal) {
+        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);
+        if (!confirmation)
+            return root;
+        if (confirmation !== root) {
+            this.shardRootCache.set(shardTopic, {
+                root: confirmation,
+                authoritative: true,
+            });
+        }
+        return confirmation;
+    }
     async resolveQueryableTopicRoot(topic) {
         const root = await this.topicRootControlPlane.resolveCanonicalTopicRoot(topic);
         if (root !== this.publicKeyHash) {
@@ -828,6 +973,8 @@ export class TopicControlPlane extends DirectStream {
         return undefined;
     }
     async ensureFanoutChannel(shardTopic, options) {
+        if (!this.started)
+            throw new NotStartedError();
         const t = shardTopic.toString();
         const pin = options?.pin === true;
         const wantEphemeral = options?.ephemeral === true;
@@ -856,6 +1003,7 @@ export class TopicControlPlane extends DirectStream {
             await withAbort(this.closeFanoutChannel(t, { force: true }), options?.signal);
         }
         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;
@@ -874,7 +1022,7 @@ export class TopicControlPlane extends DirectStream {
                 return;
             let pubsubMessage;
             try {
-                pubsubMessage = PubSubMessage.from(dm.data);
+                pubsubMessage = this.decodePubSubMessage(dm.data);
             }
             catch {
                 return;
@@ -915,6 +1063,9 @@ export class TopicControlPlane extends DirectStream {
                 this.seenCache.add(msgId, seen ? seen + 1 : 1);
                 if (seen)
                     return;
+                // fanout-delivered frames bypass the inbound stream decode, so
+                // the nested envelope is verified natively here when possible
+                this.seedNativeWireVerification(dm, payload);
                 if ((await this.verifyAndProcess(dm)) === false) {
                     return;
                 }
@@ -983,10 +1134,10 @@ export class TopicControlPlane extends DirectStream {
                     // ignore
                 }
                 try {
-                    channel.close();
+                    await channel.leave({ notifyParent: false, kickChildren: false });
                 }
                 catch {
-                    // ignore
+                    channel.close();
                 }
                 throw error;
             }
@@ -1106,7 +1257,7 @@ export class TopicControlPlane extends DirectStream {
                 topics: userTopics,
                 requestSubscribers: true,
             });
-            const embedded = await this.createMessage(toUint8Array(msg.bytes()), {
+            const embedded = await this.createMessage(this.encodePubSubMessage(msg), {
                 mode: new AnyWhere(),
                 priority: 1,
                 skipRecipientValidation: true,
@@ -1173,7 +1324,7 @@ export class TopicControlPlane extends DirectStream {
             // Announce first.
             try {
                 const msg = new Unsubscribe({ topics: userTopics });
-                const embedded = await this.createMessage(toUint8Array(msg.bytes()), {
+                const embedded = await this.createMessage(this.encodePubSubMessage(msg), {
                     mode: new AnyWhere(),
                     priority: 1,
                     skipRecipientValidation: true,
@@ -1238,7 +1389,7 @@ export class TopicControlPlane extends DirectStream {
                     timestamp: batch.timestamp,
                     topics: batch.topics,
                 });
-                const embedded = await this.createMessage(toUint8Array(msg.bytes()), {
+                const embedded = await this.createMessage(this.encodePubSubMessage(msg), {
                     mode: new AnyWhere(),
                     priority: 1,
                     skipRecipientValidation: true,
@@ -1265,7 +1416,7 @@ export class TopicControlPlane extends DirectStream {
                 timestamp: 0n,
                 topics: [],
             });
-            const embedded = await this.createMessage(toUint8Array(msg.bytes()), {
+            const embedded = await this.createMessage(this.encodePubSubMessage(msg), {
                 mode: new AnyWhere(),
                 priority: 1,
                 skipRecipientValidation: true,
@@ -1349,7 +1500,7 @@ export class TopicControlPlane extends DirectStream {
             }
             const persistent = (this.shardRefCounts.get(shardTopic) ?? 0) > 0;
             await this.ensureFanoutChannel(shardTopic, { ephemeral: !persistent });
-            const embedded = await this.createMessage(toUint8Array(msg.bytes()), {
+            const embedded = await this.createMessage(this.encodePubSubMessage(msg), {
                 mode: new AnyWhere(),
                 priority: 1,
                 skipRecipientValidation: true,
@@ -1384,7 +1535,7 @@ export class TopicControlPlane extends DirectStream {
             const msg = data
                 ? new PubSubData({ topics: topicsAll, data, strict: true })
                 : undefined;
-            const message = await this.createMessage(msg?.bytes(), {
+            const message = await this.createMessage(msg ? this.encodePubSubMessage(msg) : undefined, {
                 ...options,
                 skipRecipientValidation: this.dispatchEventOnSelfPublish,
             });
@@ -1417,7 +1568,7 @@ export class TopicControlPlane extends DirectStream {
             }
         }
         const msg = new PubSubData({ topics: topicsAll, data, strict: false });
-        const embedded = await this.createMessage(toUint8Array(msg.bytes()), {
+        const embedded = await this.createMessage(this.encodePubSubMessage(msg), {
             mode: new AnyWhere(),
             priority: options?.priority,
             responsePriority: options?.responsePriority,
@@ -1467,6 +1618,50 @@ export class TopicControlPlane extends DirectStream {
         }
         return embedded.id;
     }
+    /**
+     * Publish a pre-encoded `PubSubData` payload to explicit recipients.
+     *
+     * `payload` must be the exact borsh serialization of
+     * `new PubSubData({ topics, data, strict: true })` — callers that encode
+     * the payload elsewhere (e.g. the shared-log fused send path serializing
+     * inside wasm) hand the finished bytes here so the wrapping `PubSubData`
+     * copy of the regular `publish` path is skipped. Everything else matches
+     * the explicit-recipient branch of {@link publish}: the payload becomes a
+     * signed `DataMessage` delivered over DirectStream.
+     */
+    async publishPreEncodedData(payload, properties, options) {
+        if (!this.started)
+            throw new NotStartedError();
+        if (!options?.mode || !deliveryModeHasReceiver(options.mode)) {
+            throw new Error("publishPreEncodedData requires a delivery mode with explicit recipients");
+        }
+        const message = await this.createMessage(payload, {
+            ...options,
+            skipRecipientValidation: this.dispatchEventOnSelfPublish,
+        });
+        this.dispatchEvent(new CustomEvent("publish", {
+            detail: new PublishEvent({
+                client: options?.client,
+                data: new PubSubData({
+                    topics: properties.topics,
+                    data: payload.subarray(preEncodedPubSubDataOffset(properties.topics)),
+                    strict: true,
+                }),
+                message,
+            }),
+        }));
+        const silentDelivery = options.mode instanceof SilentDelivery;
+        try {
+            await this.publishMessage(this.publicKey, message, undefined, undefined, options?.signal);
+        }
+        catch (error) {
+            if (error instanceof DeliveryError && silentDelivery !== false) {
+                return message.id;
+            }
+            throw error;
+        }
+        return message.id;
+    }
     onPeerSession(key, _session) {
         if (!Number.isFinite(_session) || _session < 0) {
             return;
@@ -1575,20 +1770,36 @@ export class TopicControlPlane extends DirectStream {
         return changed;
     }
     subscriptionStateIsLatest(subscriberKey, session, timestamp, relevantTopics) {
-        for (const topic of relevantTopics) {
-            const last = this.lastSubscriptionMessages
-                .get(subscriberKey)
-                ?.get(topic);
-            if (!last) {
-                continue;
+        if (this.nativeTopicControl) {
+            const lasts = [];
+            for (const topic of relevantTopics) {
+                const last = this.lastSubscriptionMessages
+                    .get(subscriberKey)
+                    ?.get(topic);
+                if (last) {
+                    lasts.push(last.session, last.timestamp);
+                }
             }
-            if (last.session > session) {
+            if (!this.nativeTopicControl.subscriptionIsLatest(BigUint64Array.from(lasts), session, timestamp)) {
                 return false;
             }
-            if (timestamp !== 0n &&
-                last.session === session &&
-                last.timestamp > timestamp) {
-                return false;
+        }
+        else {
+            for (const topic of relevantTopics) {
+                const last = this.lastSubscriptionMessages
+                    .get(subscriberKey)
+                    ?.get(topic);
+                if (!last) {
+                    continue;
+                }
+                if (last.session > session) {
+                    return false;
+                }
+                if (timestamp !== 0n &&
+                    last.session === session &&
+                    last.timestamp > timestamp) {
+                    return false;
+                }
             }
         }
         for (const topic of relevantTopics) {
@@ -1604,10 +1815,80 @@ export class TopicControlPlane extends DirectStream {
         }
         return true;
     }
+    /**
+     * `Subscribe` replaces tracked subscription data for new subscribers or
+     * strictly newer sessions; equal/older sessions only refresh cache order.
+     */
+    subscribeShouldReplace(existing, session) {
+        if (this.nativeTopicControl) {
+            return this.nativeTopicControl.subscribeShouldReplace(existing?.session, session);
+        }
+        return !existing || existing.session < session;
+    }
     subscriptionMessageIsLatest(message, _pubsubMessage, relevantTopics) {
         const subscriber = message.header.signatures.signatures[0].publicKey;
         return this.subscriptionStateIsLatest(subscriber.hashcode(), message.header.session, message.header.timestamp, relevantTopics);
     }
+    /**
+     * Answer Subscribe{requestSubscribers} announces without letting bursts go
+     * quadratic (#983). Leading edge: the first announcer is answered
+     * immediately with a targeted unicast — a lone joiner sees no added
+     * latency. Announcers arriving within the trailing window that this opens
+     * are batched and answered with ONE broadcast, instead of S(S-1) routed
+     * unicasts whose cold route resolutions flood the shard tree.
+     */
+    queueSubscriberResponse(shardTopic, targetHash, topics) {
+        let entry = this.pendingSubscriberResponses.get(shardTopic);
+        if (!entry) {
+            const created = {
+                targets: new Set(),
+                topics: new Set(),
+                timer: setTimeout(() => {
+                    this.pendingSubscriberResponses.delete(shardTopic);
+                    if (created.targets.size === 0)
+                        return;
+                    void this.flushSubscriberResponses(shardTopic, created).catch(logErrorIfStarted);
+                }, 150 + Math.floor(Math.random() * 150)),
+            };
+            this.pendingSubscriberResponses.set(shardTopic, created);
+            // Leading edge: respond to the burst opener right away.
+            void this.flushSubscriberResponses(shardTopic, {
+                targets: new Set([targetHash]),
+                topics: new Set(topics),
+            }).catch(logErrorIfStarted);
+            return;
+        }
+        entry.targets.add(targetHash);
+        for (const t of topics)
+            entry.topics.add(t);
+    }
+    async flushSubscriberResponses(shardTopic, entry) {
+        if (!this.started)
+            return;
+        // Re-filter: our subscriptions may have changed within the window.
+        const topics = this.getSubscriptionOverlap([...entry.topics]);
+        if (topics.length === 0)
+            return;
+        const response = new Subscribe({
+            topics,
+            requestSubscribers: false,
+        });
+        const embedded = await this.createMessage(this.encodePubSubMessage(response), {
+            mode: new AnyWhere(),
+            priority: 1,
+            skipRecipientValidation: true,
+        });
+        const payload = toUint8Array(embedded.bytes());
+        const [firstTarget] = entry.targets;
+        if (entry.targets.size === 1 && firstTarget) {
+            await this.sendFanoutUnicastOrBroadcast(shardTopic, firstTarget, payload);
+            return;
+        }
+        const st = this.fanoutChannels.get(shardTopic);
+        if (!st)
+            return;
+        await st.channel.publishMaybe(payload);
+    }
     async sendFanoutUnicastOrBroadcast(shardTopic, targetHash, payload) {
         const st = this.fanoutChannels.get(shardTopic);
         if (!st)
@@ -1667,7 +1948,7 @@ export class TopicControlPlane extends DirectStream {
                         continue;
                     this.initializePeer(sender);
                     const existing = peers.get(senderKey);
-                    if (!existing || existing.session < message.header.session) {
+                    if (this.subscribeShouldReplace(existing, message.header.session)) {
                         peers.delete(senderKey);
                         peers.set(senderKey, new SubscriptionData({
                             session: message.header.session,
@@ -1746,7 +2027,7 @@ export class TopicControlPlane extends DirectStream {
                         continue;
                     this.initializePeer(sender);
                     const existing = peers.get(senderKey);
-                    if (!existing || existing.session < message.header.session) {
+                    if (this.subscribeShouldReplace(existing, message.header.session)) {
                         peers.delete(senderKey);
                         peers.set(senderKey, new SubscriptionData({
                             session: message.header.session,
@@ -1773,17 +2054,7 @@ export class TopicControlPlane extends DirectStream {
             if (pubsubMessage.requestSubscribers) {
                 const overlap = this.getSubscriptionOverlap(pubsubMessage.topics);
                 if (overlap.length > 0) {
-                    const response = new Subscribe({
-                        topics: overlap,
-                        requestSubscribers: false,
-                    });
-                    const embedded = await this.createMessage(toUint8Array(response.bytes()), {
-                        mode: new AnyWhere(),
-                        priority: 1,
-                        skipRecipientValidation: true,
-                    });
-                    const payload = toUint8Array(embedded.bytes());
-                    await this.sendFanoutUnicastOrBroadcast(shardTopic, senderKey, payload);
+                    this.queueSubscriberResponse(shardTopic, senderKey, overlap);
                 }
             }
             return;
@@ -1873,7 +2144,7 @@ export class TopicControlPlane extends DirectStream {
                 topics: overlap,
                 requestSubscribers: false,
             });
-            const embedded = await this.createMessage(toUint8Array(response.bytes()), {
+            const embedded = await this.createMessage(this.encodePubSubMessage(response), {
                 mode: new AnyWhere(),
                 priority: 1,
                 skipRecipientValidation: true,
@@ -1891,7 +2162,7 @@ export class TopicControlPlane extends DirectStream {
             return false;
         let pubsubMessage;
         try {
-            pubsubMessage = PubSubMessage.from(message.data);
+            pubsubMessage = this.decodePubSubMessage(message.data);
         }
         catch {
             return super.onDataMessage(from, stream, message, seenBefore);