@peerbit/stream 4.6.0-bbf27fa → 4.6.0-cb91e7b

package/dist/src/index.js

@@ -3,7 +3,7 @@ import { multiaddr } from "@multiformats/multiaddr";
 import { Circuit } from "@multiformats/multiaddr-matcher";
 import { Cache } from "@peerbit/cache";
 import { PublicSignKey, getKeypairFromPrivateKey, getPublicKeyFromPeerId, ready, sha256Base64, toBase64, } from "@peerbit/crypto";
-import { ACK, AcknowledgeDelivery, AnyWhere, DataMessage, DeliveryError, Goodbye, InvalidMessageError, Message, MessageHeader, MultiAddrinfo, NotStartedError, SeekDelivery, SilentDelivery, TracedDelivery, coercePeerRefsToHashes, deliveryModeHasReceiver, getMsgId, } from "@peerbit/stream-interface";
+import { ACK, AcknowledgeAnyWhere, AcknowledgeDelivery, AnyWhere, DataMessage, DeliveryError, Goodbye, InvalidMessageError, Message, MessageHeader, MultiAddrinfo, NotStartedError, SilentDelivery, TracedDelivery, coercePeerRefsToHashes, deliveryModeHasReceiver, getMsgId, } from "@peerbit/stream-interface";
 import { AbortError, TimeoutError, delay } from "@peerbit/time";
 import { abortableSource } from "abortable-iterator";
 import { anySignal } from "any-signal";
@@ -13,6 +13,7 @@ import { pushable } from "it-pushable";
 import pDefer, {} from "p-defer";
 import Queue from "p-queue";
 import { Uint8ArrayList } from "uint8arraylist";
+import { computeSeekAckRouteUpdate, shouldAcknowledgeDataMessage, } from "./core/seek-routing.js";
 import { logger } from "./logger.js";
 import { pushableLanes } from "./pushable-lanes.js";
 import { MAX_ROUTE_DISTANCE, Routes } from "./routes.js";
@@ -82,7 +83,6 @@ const DEFAULT_PRUNE_CONNECTIONS_INTERVAL = 2e4;
 const DEFAULT_MIN_CONNECTIONS = 2;
 const DEFAULT_MAX_CONNECTIONS = 300;
 const DEFAULT_PRUNED_CONNNECTIONS_TIMEOUT = 30 * 1000;
-const ROUTE_UPDATE_DELAY_FACTOR = 3e4;
 const DEFAULT_CREATE_OUTBOUND_STREAM_TIMEOUT = 30_000;
 const PRIORITY_LANES = 4;
 const getLaneFromPriority = (priority) => {
@@ -148,6 +148,19 @@ export class PeerStreams extends TypedEventEmitter {
     _getActiveOutboundPushable() {
         return this.outboundStreams[0]?.pushable;
     }
+    getOutboundQueuedBytes() {
+        return this._getActiveOutboundPushable()?.readableLength ?? 0;
+    }
+    getOutboundQueuedBytesByLane() {
+        const p = this._getActiveOutboundPushable();
+        if (!p)
+            return Array(PRIORITY_LANES).fill(0);
+        const out = [];
+        for (let lane = 0; lane < PRIORITY_LANES; lane++) {
+            out.push(p.getReadableLength(lane));
+        }
+        return out;
+    }
     _getOutboundCount() {
         return this.outboundStreams.length;
     }
@@ -349,7 +362,10 @@ export class PeerStreams extends TypedEventEmitter {
             this.write(bytes, priority);
             return;
         }
-        const timeoutMs = 3_000;
+        // Outbound stream negotiation can legitimately take several seconds in CI
+        // (identify/protocol discovery, resource contention, etc). Keep this fairly
+        // generous so control-plane messages (joins/subscriptions) don't flap.
+        const timeoutMs = 10_000;
         await new Promise((resolve, reject) => {
             const onOutbound = () => {
                 cleanup();
@@ -626,7 +642,16 @@ export class PeerStreams extends TypedEventEmitter {
                     logger.error("Failed to abort inbound stream");
                 }
                 try {
-                    await inbound.raw.close?.();
+                    // Best-effort shutdown: on some transports (notably websockets),
+                    // awaiting a graceful close can hang indefinitely if the remote is
+                    // concurrently stopping. Abort immediately and do not await close.
+                    try {
+                        inbound.raw.abort?.(new AbortError("Closed"));
+                    }
+                    catch {
+                        // ignore
+                    }
+                    void Promise.resolve(inbound.raw.close?.()).catch(() => { });
                 }
                 catch {
                     logger.error("Failed to close inbound stream");
@@ -641,6 +666,7 @@ export class PeerStreams extends TypedEventEmitter {
         this.inboundStreams = [];
     }
 }
+const sharedRoutingByPrivateKey = new WeakMap();
 export class DirectStream extends TypedEventEmitter {
     components;
     peerId;
@@ -666,6 +692,8 @@ export class DirectStream extends TypedEventEmitter {
     multicodecs;
     seenCache;
     _registrarTopologyIds;
+    _peerConnectListener;
+    _peerDisconnectListener;
     maxInboundStreams;
     maxOutboundStreams;
     connectionManagerOptions;
@@ -673,10 +701,17 @@ export class DirectStream extends TypedEventEmitter {
     healthChecks;
     pruneConnectionsTimeout;
     prunedConnectionsCache;
+    pruneToLimitsInFlight;
+    _startInFlight;
     routeMaxRetentionPeriod;
+    routeCacheMaxFromEntries;
+    routeCacheMaxTargetsPerFrom;
+    routeCacheMaxRelaysPerTarget;
+    sharedRouting;
+    sharedRoutingKey;
+    sharedRoutingState;
     // for sequential creation of outbound streams
     outboundInflightQueue;
-    routeSeekInterval;
     seekTimeout;
     closeController;
     session;
@@ -685,7 +720,7 @@ export class DirectStream extends TypedEventEmitter {
     constructor(components, multicodecs, options) {
         super();
         this.components = components;
-        const { canRelayMessage = true, messageProcessingConcurrency = 10, maxInboundStreams, maxOutboundStreams, connectionManager, routeSeekInterval = ROUTE_UPDATE_DELAY_FACTOR, seekTimeout = SEEK_DELIVERY_TIMEOUT, routeMaxRetentionPeriod = ROUTE_MAX_RETANTION_PERIOD, inboundIdleTimeout, } = options || {};
+        const { canRelayMessage = true, messageProcessingConcurrency = 10, maxInboundStreams, maxOutboundStreams, connectionManager, seekTimeout = SEEK_DELIVERY_TIMEOUT, routeMaxRetentionPeriod = ROUTE_MAX_RETANTION_PERIOD, routeCacheMaxFromEntries, routeCacheMaxTargetsPerFrom, routeCacheMaxRelaysPerTarget, sharedRouting = true, seenCacheMax = 1e6, seenCacheTtlMs = 10 * 60 * 1e3, inboundIdleTimeout, } = options || {};
         const signKey = getKeypairFromPrivateKey(components.privateKey);
         this.seekTimeout = seekTimeout;
         this.sign = signKey.sign.bind(signKey);
@@ -701,12 +736,18 @@ export class DirectStream extends TypedEventEmitter {
         this.peers = new Map();
         this.canRelayMessage = canRelayMessage;
         this.healthChecks = new Map();
-        this.routeSeekInterval = routeSeekInterval;
         this.queue = new Queue({ concurrency: messageProcessingConcurrency });
         this.maxInboundStreams = maxInboundStreams;
         this.maxOutboundStreams = maxOutboundStreams;
-        this.seenCache = new Cache({ max: 1e6, ttl: 10 * 60 * 1e3 });
+        this.seenCache = new Cache({
+            max: Math.max(1, Math.floor(seenCacheMax)),
+            ttl: Math.max(1, Math.floor(seenCacheTtlMs)),
+        });
         this.routeMaxRetentionPeriod = routeMaxRetentionPeriod;
+        this.routeCacheMaxFromEntries = routeCacheMaxFromEntries;
+        this.routeCacheMaxTargetsPerFrom = routeCacheMaxTargetsPerFrom;
+        this.routeCacheMaxRelaysPerTarget = routeCacheMaxRelaysPerTarget;
+        this.sharedRouting = sharedRouting !== false;
         this.peerKeyHashToPublicKey = new Map();
         this._onIncomingStream = this._onIncomingStream.bind(this);
         this.onPeerConnected = this.onPeerConnected.bind(this);
@@ -753,11 +794,46 @@ export class DirectStream extends TypedEventEmitter {
             })
             : undefined;
     }
+    pruneConnectionsToLimits() {
+        if (this.pruneToLimitsInFlight) {
+            return this.pruneToLimitsInFlight;
+        }
+        this.pruneToLimitsInFlight = (async () => {
+            // Respect minConnections as a hard floor.
+            const maxConnections = Math.max(this.connectionManagerOptions.minConnections, this.connectionManagerOptions.maxConnections);
+            if (this.peers.size <= maxConnections) {
+                return;
+            }
+            // Prune in batches so we can quickly recover from join storms without waiting
+            // for repeated pruner ticks. Bound work per run to avoid starving the event loop.
+            const maxPrunes = Math.min(256, Math.max(1, this.peers.size - maxConnections));
+            for (let i = 0; i < maxPrunes; i++) {
+                if (this.peers.size <= maxConnections)
+                    break;
+                const before = this.peers.size;
+                await this.pruneConnections();
+                if (this.peers.size >= before)
+                    break; // nothing prunable
+            }
+        })().finally(() => {
+            this.pruneToLimitsInFlight = undefined;
+        });
+        return this.pruneToLimitsInFlight;
+    }
     async start() {
+        if (this.started)
+            return;
+        if (this._startInFlight)
+            return this._startInFlight;
+        this._startInFlight = this._startImpl().finally(() => {
+            this._startInFlight = undefined;
+        });
+        return this._startInFlight;
+    }
+    async _startImpl() {
         if (this.started) {
             return;
         }
-        this.session = +new Date();
         await ready;
         this.closeController = new AbortController();
         this.outboundInflightQueue = pushable({ objectMode: true });
@@ -810,10 +886,45 @@ export class DirectStream extends TypedEventEmitter {
         this.closeController.signal.addEventListener("abort", () => {
             this.outboundInflightQueue.return();
         });
-        this.routes = new Routes(this.publicKeyHash, {
-            routeMaxRetentionPeriod: this.routeMaxRetentionPeriod,
-            signal: this.closeController.signal,
-        });
+        if (this.sharedRouting) {
+            const key = this.components.privateKey;
+            this.sharedRoutingKey = key;
+            let state = sharedRoutingByPrivateKey.get(key);
+            if (!state) {
+                const controller = new AbortController();
+                state = {
+                    session: Date.now(),
+                    controller,
+                    routes: new Routes(this.publicKeyHash, {
+                        routeMaxRetentionPeriod: this.routeMaxRetentionPeriod,
+                        signal: controller.signal,
+                        maxFromEntries: this.routeCacheMaxFromEntries,
+                        maxTargetsPerFrom: this.routeCacheMaxTargetsPerFrom,
+                        maxRelaysPerTarget: this.routeCacheMaxRelaysPerTarget,
+                    }),
+                    refs: 0,
+                };
+                sharedRoutingByPrivateKey.set(key, state);
+            }
+            else {
+                // Best-effort: prefer the strictest cleanup policy among co-located protocols.
+                state.routes.routeMaxRetentionPeriod = Math.min(state.routes.routeMaxRetentionPeriod, this.routeMaxRetentionPeriod);
+            }
+            state.refs += 1;
+            this.sharedRoutingState = state;
+            this.session = state.session;
+            this.routes = state.routes;
+        }
+        else {
+            this.session = Date.now();
+            this.routes = new Routes(this.publicKeyHash, {
+                routeMaxRetentionPeriod: this.routeMaxRetentionPeriod,
+                signal: this.closeController.signal,
+                maxFromEntries: this.routeCacheMaxFromEntries,
+                maxTargetsPerFrom: this.routeCacheMaxTargetsPerFrom,
+                maxRelaysPerTarget: this.routeCacheMaxRelaysPerTarget,
+            });
+        }
         this.started = true;
         this.stopping = false;
         logger.trace("starting");
@@ -831,6 +942,45 @@ export class DirectStream extends TypedEventEmitter {
             onDisconnect: this.onPeerDisconnected.bind(this),
             notifyOnLimitedConnection: false,
         })));
+        // Best-effort fallback: topology callbacks can depend on identify/protocol
+        // discovery. Some test environments connect peers without triggering the
+        // per-protocol topology immediately. Listening to peer connection events
+        // ensures we still attempt to open outbound streams opportunistically.
+        this._peerConnectListener = (ev) => {
+            if (this.stopping || !this.started)
+                return;
+            const peerId = ev?.detail ?? ev?.peerId;
+            if (!peerId)
+                return;
+            const conns = this.components.connectionManager.getConnections(peerId);
+            if (!conns || conns.length === 0)
+                return;
+            let conn = conns[0];
+            for (const c of conns) {
+                if (!isWebsocketConnection(c)) {
+                    conn = c;
+                    break;
+                }
+            }
+            void this.onPeerConnected(peerId, conn);
+        };
+        this._peerDisconnectListener = (ev) => {
+            if (this.stopping || !this.started)
+                return;
+            const peerId = ev?.detail ?? ev?.peerId;
+            if (!peerId)
+                return;
+            const conns = this.components.connectionManager.getConnections(peerId);
+            const conn = conns && conns.length > 0 ? conns[0] : undefined;
+            void this.onPeerDisconnected(peerId, conn);
+        };
+        try {
+            this.components.events.addEventListener("peer:connect", this._peerConnectListener);
+            this.components.events.addEventListener("peer:disconnect", this._peerDisconnectListener);
+        }
+        catch {
+            // ignore unsupported event targets
+        }
         // All existing connections are like new ones for us. To deduplication on remotes so we only resuse one connection for this protocol (we could be connected with many connections)
         const peerToConnections = new Map();
         const connections = this.components.connectionManager.getConnections();
@@ -877,7 +1027,22 @@ export class DirectStream extends TypedEventEmitter {
         if (!this.started) {
             return;
         }
+        const sharedState = this.sharedRoutingState;
+        const sharedKey = this.sharedRoutingKey;
         clearTimeout(this.pruneConnectionsTimeout);
+        try {
+            if (this._peerConnectListener) {
+                this.components.events.removeEventListener("peer:connect", this._peerConnectListener);
+            }
+            if (this._peerDisconnectListener) {
+                this.components.events.removeEventListener("peer:disconnect", this._peerDisconnectListener);
+            }
+        }
+        catch {
+            // ignore unsupported event targets
+        }
+        this._peerConnectListener = undefined;
+        this._peerDisconnectListener = undefined;
         await Promise.all(this.multicodecs.map((x) => this.components.registrar.unhandle(x)));
         // unregister protocol and handlers
         if (this._registrarTopologyIds != null) {
@@ -899,12 +1064,36 @@ export class DirectStream extends TypedEventEmitter {
         this.queue.clear();
         this.peers.clear();
         this.seenCache.clear();
-        this.routes.clear();
+        // When routing is shared across co-located protocols, only clear once the last
+        // instance stops. Otherwise we'd wipe routes still in use by other services.
+        if (!sharedState) {
+            this.routes.clear();
+        }
         this.peerKeyHashToPublicKey.clear();
         for (const [_k, v] of this._ackCallbacks) {
             v.clear();
         }
         this._ackCallbacks.clear();
+        this.sharedRoutingState = undefined;
+        this.sharedRoutingKey = undefined;
+        if (sharedState && sharedKey) {
+            sharedState.refs = Math.max(0, sharedState.refs - 1);
+            if (sharedState.refs === 0) {
+                try {
+                    sharedState.routes.clear();
+                }
+                catch {
+                    // ignore
+                }
+                try {
+                    sharedState.controller.abort();
+                }
+                catch {
+                    // ignore
+                }
+                sharedRoutingByPrivateKey.delete(sharedKey);
+            }
+        }
         logger.trace("stopped");
         this.stopping = false;
     }
@@ -1056,7 +1245,8 @@ export class DirectStream extends TypedEventEmitter {
                     }),
                 }).sign(this.sign)).catch(dontThrowIfDeliveryError);
             }
-            this.checkIsAlive([peerKeyHash]);
+            // Best-effort liveness probe; never let background probe failures crash callers.
+            void this.checkIsAlive([peerKeyHash]).catch(() => false);
         }
         logger.trace("connection ended:" + peerKey.toString());
     }
@@ -1072,12 +1262,16 @@ export class DirectStream extends TypedEventEmitter {
     }
     addRouteConnection(from, neighbour, target, distance, session, remoteSession) {
         const targetHash = typeof target === "string" ? target : target.hashcode();
+        // Best-effort: keep a hash -> public key map for any routed targets so
+        // peer:unreachable events can always carry a PublicSignKey when we have seen it.
+        if (typeof target !== "string") {
+            this.peerKeyHashToPublicKey.set(targetHash, target);
+        }
         const update = this.routes.add(from, neighbour, targetHash, distance, session, remoteSession);
         // second condition is that we don't want to emit 'reachable' events for routes where we act only as a relay
         // in this case, from is != this.publicKeyhash
         if (from === this.publicKeyHash) {
             if (update === "new") {
-                this.peerKeyHashToPublicKey.set(target.hashcode(), target);
                 this.onPeerReachable(target);
             }
         }
@@ -1088,11 +1282,15 @@ export class DirectStream extends TypedEventEmitter {
     }
     onPeerUnreachable(hash) {
         // override this fns
+        const key = this.peerKeyHashToPublicKey.get(hash);
+        if (!key) {
+            // Best-effort: we may only have the hash (no public key) for some routes.
+            // Avoid crashing downstream listeners that assume `detail` is a PublicSignKey.
+            return;
+        }
         this.dispatchEvent(
         // TODO types
-        new CustomEvent("peer:unreachable", {
-            detail: this.peerKeyHashToPublicKey.get(hash),
-        }));
+        new CustomEvent("peer:unreachable", { detail: key }));
     }
     updateSession(key, session) {
         if (this.routes.updateSession(key.hashcode(), session)) {
@@ -1145,6 +1343,11 @@ export class DirectStream extends TypedEventEmitter {
             peerStreams.removeEventListener("stream:inbound", forwardInbound);
         }, { once: true });
         this.addRouteConnection(this.publicKeyHash, publicKey.hashcode(), publicKey, -1, +new Date(), -1);
+        // Enforce connection manager limits eagerly when new peers are added. Without this,
+        // join storms can create large temporary peer sets and OOM in single-process sims.
+        if (this.peers.size > this.connectionManagerOptions.maxConnections) {
+            void this.pruneConnectionsToLimits().catch(() => { });
+        }
         return peerStreams;
     }
     /**
@@ -1260,32 +1463,33 @@ export class DirectStream extends TypedEventEmitter {
         }
     }
     shouldIgnore(message, seenBefore) {
-        const fromMe = message.header.signatures?.publicKeys.find((x) => x.equals(this.publicKey));
-        if (fromMe) {
+        const signedBySelf = message.header.signatures?.publicKeys.some((x) => x.equals(this.publicKey)) ?? false;
+        if (signedBySelf) {
             return true;
         }
-        if ((seenBefore > 0 &&
-            message.header.mode instanceof SeekDelivery === false) ||
-            (message.header.mode instanceof SeekDelivery &&
-                seenBefore >= message.header.mode.redundancy)) {
-            return true;
+        // For acknowledged modes, allow limited duplicate forwarding so that we can
+        // discover and maintain multiple candidate routes (distance=seenCounter).
+        if (message.header.mode instanceof AcknowledgeDelivery ||
+            message.header.mode instanceof AcknowledgeAnyWhere) {
+            return seenBefore >= message.header.mode.redundancy;
         }
-        return false;
+        return seenBefore > 0;
     }
     async onDataMessage(from, peerStream, message, seenBefore) {
         if (this.shouldIgnore(message, seenBefore)) {
             return false;
         }
         let isForMe = false;
-        if (message.header.mode instanceof AnyWhere) {
+        if (message.header.mode instanceof AnyWhere ||
+            message.header.mode instanceof AcknowledgeAnyWhere) {
             isForMe = true;
         }
         else {
             const isFromSelf = this.publicKey.equals(from);
-            if (!isFromSelf) {
-                isForMe =
-                    message.header.mode.to == null ||
-                        message.header.mode.to.find((x) => x === this.publicKeyHash) != null;
+            if (!isFromSelf &&
+                (message.header.mode instanceof SilentDelivery ||
+                    message.header.mode instanceof AcknowledgeDelivery)) {
+                isForMe = message.header.mode.to.includes(this.publicKeyHash);
             }
         }
         if (isForMe) {
@@ -1311,19 +1515,13 @@ export class DirectStream extends TypedEventEmitter {
             }
         }
         // Forward
-        if (message.header.mode instanceof SeekDelivery || seenBefore === 0) {
+        const shouldForward = seenBefore === 0 ||
+            ((message.header.mode instanceof AcknowledgeDelivery ||
+                message.header.mode instanceof AcknowledgeAnyWhere) &&
+                seenBefore < message.header.mode.redundancy);
+        if (shouldForward) {
             // DONT await this since it might introduce a dead-lock
-            if (message.header.mode instanceof SeekDelivery) {
-                if (seenBefore < message.header.mode.redundancy) {
-                    const to = [...this.peers.values()].filter((x) => !message.header.signatures?.publicKeys.find((y) => y.equals(x.publicKey)) && x !== peerStream);
-                    if (to.length > 0) {
-                        this.relayMessage(from, message, to);
-                    }
-                }
-            }
-            else {
-                this.relayMessage(from, message);
-            }
+            this.relayMessage(from, message);
         }
     }
     async verifyAndProcess(message) {
@@ -1341,12 +1539,16 @@ export class DirectStream extends TypedEventEmitter {
         return true;
     }
     async maybeAcknowledgeMessage(peerStream, message, seenBefore) {
-        if ((message.header.mode instanceof SeekDelivery ||
-            message.header.mode instanceof AcknowledgeDelivery) &&
-            seenBefore < message.header.mode.redundancy) {
-            const shouldAcknowldege = message.header.mode.to == null ||
-                message.header.mode.to.includes(this.publicKeyHash);
-            if (!shouldAcknowldege) {
+        if (message.header.mode instanceof AcknowledgeDelivery ||
+            message.header.mode instanceof AcknowledgeAnyWhere) {
+            const isRecipient = message.header.mode instanceof AcknowledgeAnyWhere
+                ? true
+                : message.header.mode.to.includes(this.publicKeyHash);
+            if (!shouldAcknowledgeDataMessage({
+                isRecipient,
+                seenBefore,
+                redundancy: message.header.mode.redundancy,
+            })) {
                 return;
             }
             const signers = message.header.signatures.publicKeys.map((x) => x.hashcode());
@@ -1357,8 +1559,12 @@ export class DirectStream extends TypedEventEmitter {
                 header: new MessageHeader({
                     mode: new TracedDelivery(signers),
                     session: this.session,
-                    // include our origin if message is SeekDelivery and we have not recently pruned a connection to this peer
-                    origin: message.header.mode instanceof SeekDelivery &&
+                    // include our origin for route-learning/dialer hints (best-effort privacy/anti-spam control):
+                    // only include once (seenBefore=0) and only if we have not recently pruned
+                    // a connection to any signer in the path
+                    origin: (message.header.mode instanceof AcknowledgeAnyWhere ||
+                        message.header.mode instanceof AcknowledgeDelivery) &&
+                        seenBefore === 0 &&
                         !message.header.signatures.publicKeys.find((x) => this.prunedConnectionsCache?.has(x.hashcode()))
                         ? new MultiAddrinfo(this.components.addressManager
                             .getAddresses()
@@ -1443,37 +1649,40 @@ export class DirectStream extends TypedEventEmitter {
         for (const remote of remotes) {
             this.invalidateSession(remote);
         }
-        this.checkIsAlive(remotes);
+        // Best-effort liveness probe; never let background probe failures crash callers.
+        void this.checkIsAlive(remotes).catch(() => false);
     }
     async checkIsAlive(remotes) {
         if (this.peers.size === 0) {
             return false;
         }
         if (remotes.length > 0) {
-            return this.publish(undefined, {
-                mode: new SeekDelivery({
-                    to: remotes,
-                    redundancy: DEFAULT_SEEK_MESSAGE_REDUDANCY,
-                }),
-            })
-                .then(() => true)
-                .catch((e) => {
-                if (e instanceof DeliveryError) {
-                    return false;
-                }
-                else if (e instanceof NotStartedError) {
-                    return false;
-                }
-                else if (e instanceof TimeoutError) {
-                    return false;
-                }
-                else if (e instanceof AbortError) {
+            try {
+                // Keepalive probes are best-effort, but must still require ACKs so we can
+                // conclusively prune stale routes when peers actually went away.
+                await this.publish(undefined, {
+                    mode: new AcknowledgeDelivery({
+                        to: remotes,
+                        redundancy: DEFAULT_SILENT_MESSAGE_REDUDANCY,
+                    }),
+                });
+                return true;
+            }
+            catch (e) {
+                const errorName = e?.name ?? e?.constructor?.name ?? "UnknownError";
+                if (e instanceof DeliveryError ||
+                    e instanceof NotStartedError ||
+                    e instanceof TimeoutError ||
+                    e instanceof AbortError ||
+                    errorName === "DeliveryError" ||
+                    errorName === "NotStartedError" ||
+                    errorName === "TimeoutError" ||
+                    errorName === "AbortError") {
                     return false;
                 }
-                else {
-                    throw e;
-                }
-            }); // this will remove the target if it is still not reable
+                warn(`checkIsAlive unexpected error: ${errorName}`);
+                return false;
+            }
         }
         return false;
     }
@@ -1486,8 +1695,7 @@ export class DirectStream extends TypedEventEmitter {
                 redundancy: DEFAULT_SILENT_MESSAGE_REDUDANCY,
             });
         if (mode instanceof AcknowledgeDelivery ||
-            mode instanceof SilentDelivery ||
-            mode instanceof SeekDelivery) {
+            mode instanceof SilentDelivery) {
             if (mode.to) {
                 let preLength = mode.to.length;
                 mode.to = mode.to.filter((x) => x !== this.publicKeyHash);
@@ -1495,7 +1703,7 @@ export class DirectStream extends TypedEventEmitter {
                     if (preLength > 0 && mode.to?.length === 0) {
                         throw new InvalidMessageError("Unexpected to create a message with self as the only receiver");
                     }
-                    if (mode.to.length === 0 && mode instanceof SeekDelivery === false) {
+                    if (mode.to.length === 0) {
                         throw new InvalidMessageError("Unexpected to deliver message with mode: " +
                             mode.constructor.name +
                             " without recipents");
@@ -1503,24 +1711,6 @@ export class DirectStream extends TypedEventEmitter {
                 }
             }
         }
-        if (mode instanceof AcknowledgeDelivery || mode instanceof SilentDelivery) {
-            const now = +new Date();
-            for (const hash of mode.to) {
-                const neighbourRoutes = this.routes.routes
-                    .get(this.publicKeyHash)
-                    ?.get(hash);
-                if (!neighbourRoutes ||
-                    now - neighbourRoutes.session >
-                        neighbourRoutes.list.length * this.routeSeekInterval ||
-                    !this.routes.isUpToDate(hash, neighbourRoutes)) {
-                    mode = new SeekDelivery({
-                        to: mode.to,
-                        redundancy: DEFAULT_SEEK_MESSAGE_REDUDANCY,
-                    });
-                    break;
-                }
-            }
-        }
         const message = new DataMessage({
             data: data instanceof Uint8ArrayList ? data.subarray() : data,
             header: new MessageHeader({
@@ -1543,7 +1733,9 @@ export class DirectStream extends TypedEventEmitter {
      * Publishes messages to all peers
      */
     async publish(data, options = {
-        mode: new SeekDelivery({ redundancy: DEFAULT_SEEK_MESSAGE_REDUDANCY }),
+        mode: new AcknowledgeAnyWhere({
+            redundancy: DEFAULT_SEEK_MESSAGE_REDUDANCY,
+        }),
     }) {
         if (!this.started) {
             throw new NotStartedError();
@@ -1579,7 +1771,7 @@ export class DirectStream extends TypedEventEmitter {
         if (this.canRelayMessage) {
             if (message instanceof DataMessage) {
                 if (message.header.mode instanceof AcknowledgeDelivery ||
-                    message.header.mode instanceof SeekDelivery) {
+                    message.header.mode instanceof AcknowledgeAnyWhere) {
                     await message.sign(this.sign);
                 }
             }
@@ -1600,6 +1792,31 @@ export class DirectStream extends TypedEventEmitter {
         clearTimeout(timer);
         this.healthChecks.delete(to);
     }
+    formatDeliveryDebugState(targets, fastestNodesReached) {
+        const sampleSize = 16;
+        const sampledTargets = [...targets].slice(0, sampleSize);
+        const sampled = sampledTargets.map((target) => {
+            const route = this.routes.findNeighbor(this.publicKeyHash, target);
+            const routeSample = route?.list
+                .slice(0, 3)
+                .map((r) => `${r.hash}:${r.distance}${r.expireAt ? ":old" : ""}`)
+                .join(",") ?? "-";
+            const reachable = this.routes.isReachable(this.publicKeyHash, target);
+            const stream = this.peers.get(target);
+            let openConnections = 0;
+            if (stream) {
+                try {
+                    openConnections = this.components.connectionManager.getConnections(stream.peerId).length;
+                }
+                catch {
+                    openConnections = stream.isReadable || stream.isWritable ? 1 : 0;
+                }
+            }
+            return `${target}{reachable=${reachable ? 1 : 0},ack=${fastestNodesReached.has(target) ? 1 : 0},stream=${stream ? 1 : 0},conns=${openConnections},routes=${routeSample}}`;
+        });
+        const more = targets.size - sampledTargets.length;
+        return `deliveryState peers=${this.peers.size} routesLocal=${this.routes.count()} routesAll=${this.routes.countAll()} targets=[${sampled.join(";")}]${more > 0 ? ` (+${more} more)` : ""}`;
+    }
     async createDeliveryPromise(from, message, relayed, signal) {
         if (message.header.mode instanceof AnyWhere) {
             return {
@@ -1615,11 +1832,10 @@ export class DirectStream extends TypedEventEmitter {
         }
         const fastestNodesReached = new Map();
         const messageToSet = new Set();
-        if (message.header.mode.to) {
+        if (deliveryModeHasReceiver(message.header.mode)) {
             for (const to of message.header.mode.to) {
-                if (to === from.hashcode()) {
+                if (to === from.hashcode())
                     continue;
-                }
                 messageToSet.add(to);
                 if (!relayed && !this.healthChecks.has(to)) {
                     this.healthChecks.set(to, setTimeout(() => {
@@ -1640,20 +1856,16 @@ export class DirectStream extends TypedEventEmitter {
         }
         const willGetAllAcknowledgements = !relayed; // Only the origin will get all acks
         // Expected to receive at least 'filterMessageForSeenCounter' acknowledgements from each peer
-        const filterMessageForSeenCounter = relayed
-            ? undefined
-            : message.header.mode instanceof SeekDelivery
-                ? Math.min(this.peers.size, message.header.mode.redundancy)
-                : 1; /*  message.deliveryMode instanceof SeekDelivery ? Math.min(this.peers.size - (relayed ? 1 : 0), message.deliveryMode.redundancy) : 1 */
+        const filterMessageForSeenCounter = relayed ? undefined : 1;
         const uniqueAcks = new Set();
         const session = +new Date();
         const onUnreachable = !relayed &&
             ((ev) => {
-                const deletedReceiver = messageToSet.delete(ev.detail.hashcode());
-                if (deletedReceiver) {
-                    // Only reject if we are the sender
-                    clear();
-                    deliveryDeferredPromise.reject(new DeliveryError(`At least one recipent became unreachable while delivering messsage of type ${message.constructor.name}} to ${ev.detail.hashcode()}`));
+                const target = ev.detail.hashcode();
+                if (messageToSet.has(target)) {
+                    // A peer can transiently appear unreachable while routes are being updated.
+                    // Keep waiting for ACK/timeout instead of failing delivery immediately.
+                    logger.trace("peer unreachable during delivery (msg=%s, target=%s); waiting for ACK/timeout", idString, target);
                 }
             });
         onUnreachable && this.addEventListener("peer:unreachable", onUnreachable);
@@ -1680,9 +1892,13 @@ export class DirectStream extends TypedEventEmitter {
                 }
             }
             if (!hasAll && willGetAllAcknowledgements) {
+                const debugState = this.formatDeliveryDebugState(messageToSet, fastestNodesReached);
+                const msgMeta = `msgType=${message.constructor.name} dataBytes=${message instanceof DataMessage
+                    ? (message.data?.byteLength ?? 0)
+                    : 0} relayed=${relayed ? 1 : 0}`;
                 deliveryDeferredPromise.reject(new DeliveryError(`Failed to get message ${idString} ${filterMessageForSeenCounter} ${[
                     ...messageToSet,
-                ]} delivery acknowledges from all nodes (${fastestNodesReached.size}/${messageToSet.size}). Mode: ${message.header.mode.constructor.name}. Redundancy: ${message.header.mode["redundancy"]}`));
+                ]} delivery acknowledges from all nodes (${fastestNodesReached.size}/${messageToSet.size}). Mode: ${message.header.mode.constructor.name}. Redundancy: ${message.header.mode["redundancy"]}. ${msgMeta}. ${debugState}`));
             }
             else {
                 deliveryDeferredPromise.resolve();
@@ -1705,11 +1921,22 @@ export class DirectStream extends TypedEventEmitter {
             // know how many ACKs we will get
             if (filterMessageForSeenCounter != null &&
                 uniqueAcks.size >= messageToSet.size * filterMessageForSeenCounter) {
-                if (haveReceivers) {
-                    // this statement exist beacuse if we do SEEK and have to = [], then it means we try to reach as many as possible hence we never want to delete this ACK callback
-                    // only remove callback function if we actually expected a expected amount of responses
+                const shouldKeepCallbackForRouteLearning = !relayed &&
+                    message.header.mode instanceof AcknowledgeDelivery &&
+                    message.header.mode.redundancy > 1;
+                if (haveReceivers && !shouldKeepCallbackForRouteLearning) {
+                    // If we have an explicit recipient list we can clear the ACK callback once we
+                    // got the expected acknowledgements.
                     clear();
                 }
+                else if (haveReceivers && shouldKeepCallbackForRouteLearning) {
+                    // Resolve delivery early, but keep ACK callbacks alive until timeout so we can
+                    // learn additional redundant routes (seenCounter=1..redundancy-1).
+                    onUnreachable &&
+                        this.removeEventListener("peer:unreachable", onUnreachable);
+                    onAbort && signal?.removeEventListener("abort", onAbort);
+                    onAbort = undefined;
+                }
                 deliveryDeferredPromise.resolve();
                 return true;
             }
@@ -1723,25 +1950,35 @@ export class DirectStream extends TypedEventEmitter {
                 const seenCounter = ack.seenCounter;
                 // remove the automatic removal of route timeout since we have observed lifesigns of a peer
                 this.clearHealthcheckTimer(messageTargetHash);
-                // if the target is not inside the original message to, we still ad the target to our routes
-                // this because a relay might modify the 'to' list and we might receive more answers than initially set
-                if (message.header.mode instanceof SeekDelivery) {
-                    this.addRouteConnection(messageFrom?.publicKey.hashcode() || this.publicKeyHash, messageThrough.publicKey.hashcode(), messageTarget, seenCounter, session, Number(ack.header.session)); // we assume the seenCounter = distance. The more the message has been seen by the target the longer the path is to the target
+                // If the target is not inside the original message `to`, we can still add the target to our routes.
+                // This matters because relays may modify `to`, and because "ack-anywhere" style probes intentionally
+                // do not provide an explicit recipient list.
+                if (message.header.mode instanceof AcknowledgeDelivery ||
+                    message.header.mode instanceof AcknowledgeAnyWhere) {
+                    const upstreamHash = messageFrom?.publicKey.hashcode();
+                    const routeUpdate = computeSeekAckRouteUpdate({
+                        current: this.publicKeyHash,
+                        upstream: upstreamHash,
+                        downstream: messageThrough.publicKey.hashcode(),
+                        target: messageTargetHash,
+                        // Route "distance" is based on recipient-seen order (0 = fastest). This is relied upon by
+                        // `Routes.getFanout(...)` which uses `distance < redundancy` to select redundant next-hops.
+                        distance: seenCounter,
+                    });
+                    this.addRouteConnection(routeUpdate.from, routeUpdate.neighbour, messageTarget, routeUpdate.distance, session, Number(ack.header.session));
                 }
                 if (messageToSet.has(messageTargetHash)) {
-                    // Only keep track of relevant acks
-                    if (filterMessageForSeenCounter == null ||
-                        seenCounter < filterMessageForSeenCounter) {
-                        // TODO set limit correctly
-                        if (seenCounter < MAX_ROUTE_DISTANCE) {
-                            let arr = fastestNodesReached.get(messageTargetHash);
-                            if (!arr) {
-                                arr = [];
-                                fastestNodesReached.set(messageTargetHash, arr);
-                            }
-                            arr.push(seenCounter);
-                            uniqueAcks.add(messageTargetHash + seenCounter);
+                    // Any ACK from the target should satisfy delivery semantics.
+                    // Relying on only seenCounter=0 can fail under churn if the first ACK
+                    // is lost but a later ACK (seenCounter>0) arrives.
+                    if (seenCounter < MAX_ROUTE_DISTANCE) {
+                        let arr = fastestNodesReached.get(messageTargetHash);
+                        if (!arr) {
+                            arr = [];
+                            fastestNodesReached.set(messageTargetHash, arr);
                         }
+                        arr.push(seenCounter);
+                        uniqueAcks.add(messageTargetHash);
                     }
                 }
                 checkDone();
@@ -1757,7 +1994,9 @@ export class DirectStream extends TypedEventEmitter {
         if (this.stopping || !this.started) {
             throw new NotStartedError();
         }
+        const isRelayed = relayed ?? from.hashcode() !== this.publicKeyHash;
         let delivereyPromise = undefined;
+        let ackCallbackId;
         if ((!message.header.signatures ||
             message.header.signatures.publicKeys.length === 0) &&
             message instanceof DataMessage &&
@@ -1767,85 +2006,145 @@ export class DirectStream extends TypedEventEmitter {
         /**
          * Logic for handling acknowledge messages when we receive them (later)
          */
-        if (message instanceof DataMessage &&
-            message.header.mode instanceof SeekDelivery &&
-            !relayed) {
-            to = this.peers; // seek delivery will not work unless we try all possible paths
-        }
-        if (message.header.mode instanceof AcknowledgeDelivery) {
-            to = undefined;
-        }
         if ((message instanceof DataMessage || message instanceof Goodbye) &&
-            (message.header.mode instanceof SeekDelivery ||
-                message.header.mode instanceof AcknowledgeDelivery)) {
-            const deliveryDeferredPromise = await this.createDeliveryPromise(from, message, relayed, signal);
+            (message.header.mode instanceof AcknowledgeDelivery ||
+                message.header.mode instanceof AcknowledgeAnyWhere)) {
+            const deliveryDeferredPromise = await this.createDeliveryPromise(from, message, isRelayed, signal);
             delivereyPromise = deliveryDeferredPromise.promise;
+            ackCallbackId = toBase64(message.id);
         }
-        const bytes = message.bytes();
-        if (!relayed) {
-            const bytesArray = bytes instanceof Uint8Array ? bytes : bytes.subarray();
-            await this.modifySeenCache(bytesArray);
-        }
-        /**
-         * For non SEEKing message delivery modes, use routing
-         */
-        if (message instanceof DataMessage) {
-            if ((message.header.mode instanceof AcknowledgeDelivery ||
-                message.header.mode instanceof SilentDelivery) &&
-                !to) {
-                if (message.header.mode.to.length === 0) {
-                    return delivereyPromise; // we defintely know that we should not forward the message anywhere
-                }
-                const fanout = this.routes.getFanout(from.hashcode(), message.header.mode.to, message.header.mode.redundancy);
-                if (fanout) {
-                    if (fanout.size > 0) {
+        try {
+            const bytes = message.bytes();
+            if (!isRelayed) {
+                const bytesArray = bytes instanceof Uint8Array ? bytes : bytes.subarray();
+                await this.modifySeenCache(bytesArray);
+            }
+            /**
+             * For non SEEKing message delivery modes, use routing
+             */
+            if (message instanceof DataMessage) {
+                if ((message.header.mode instanceof AcknowledgeDelivery ||
+                    message.header.mode instanceof SilentDelivery) &&
+                    !to) {
+                    if (message.header.mode.to.length === 0) {
+                        // we definitely know that we should not forward the message anywhere
+                        return delivereyPromise;
+                    }
+                    const fanout = this.routes.getFanout(from.hashcode(), message.header.mode.to, message.header.mode.redundancy);
+                    // If we have explicit routing information, send only along the chosen next-hops.
+                    // If `fanout` is empty (no route info yet), fall through to the flooding logic below
+                    // so acknowledged deliveries can discover/repair routes instead of timing out.
+                    if (fanout && fanout.size > 0) {
                         const promises = [];
+                        const usedNeighbours = new Set();
+                        const originalTo = message.header.mode.to;
                         for (const [neighbour, _distantPeers] of fanout) {
                             const stream = this.peers.get(neighbour);
-                            stream &&
+                            if (!stream)
+                                continue;
+                            if (message.header.mode instanceof SilentDelivery) {
+                                message.header.mode.to = [..._distantPeers.keys()];
+                                promises.push(stream.waitForWrite(message.bytes(), message.header.priority));
+                            }
+                            else {
+                                promises.push(stream.waitForWrite(bytes, message.header.priority));
+                            }
+                            usedNeighbours.add(neighbour);
+                        }
+                        if (message.header.mode instanceof SilentDelivery) {
+                            message.header.mode.to = originalTo;
+                        }
+                        // If the sender requested redundancy but we don't yet have enough distinct
+                        // next-hops for the target(s), opportunistically probe additional neighbours.
+                        // This replaces the previous "greedy fanout" probing behavior without needing
+                        // a separate delivery mode.
+                        if (!isRelayed &&
+                            message.header.mode instanceof AcknowledgeDelivery &&
+                            usedNeighbours.size < message.header.mode.redundancy) {
+                            for (const [neighbour, stream] of this.peers) {
+                                if (usedNeighbours.size >= message.header.mode.redundancy) {
+                                    break;
+                                }
+                                if (usedNeighbours.has(neighbour))
+                                    continue;
+                                usedNeighbours.add(neighbour);
                                 promises.push(stream.waitForWrite(bytes, message.header.priority));
+                            }
                         }
                         await Promise.all(promises);
-                        return delivereyPromise; // we are done sending the message in all direction with updates 'to' lists
+                        return delivereyPromise;
+                    }
+                    // If we don't have routing information:
+                    // - For acknowledged deliveries, fall through to flooding (route discovery / repair).
+                    // - For silent deliveries, relays should not flood (prevents unnecessary fanout); origin may still flood.
+                    //   We still allow direct neighbour delivery to explicit recipients (if connected).
+                    if (isRelayed && message.header.mode instanceof SilentDelivery) {
+                        const promises = [];
+                        const originalTo = message.header.mode.to;
+                        for (const recipient of originalTo) {
+                            if (recipient === this.publicKeyHash)
+                                continue;
+                            if (recipient === from.hashcode())
+                                continue; // never send back to previous hop
+                            const stream = this.peers.get(recipient);
+                            if (!stream)
+                                continue;
+                            if (message.header.signatures?.publicKeys.find((x) => x.hashcode() === recipient)) {
+                                continue; // recipient already signed/seen this message
+                            }
+                            message.header.mode.to = [recipient];
+                            promises.push(stream.waitForWrite(message.bytes(), message.header.priority));
+                        }
+                        message.header.mode.to = originalTo;
+                        if (promises.length > 0) {
+                            await Promise.all(promises);
+                        }
+                        return delivereyPromise;
                     }
-                    return; // we defintely know that we should not forward the message anywhere
-                }
-                // we end up here because we don't have enough information yet in how to send data to the peer (TODO test this codepath)
-                if (relayed) {
-                    return;
                 }
-            } // else send to all (fallthrough to code below)
-        }
-        // We fils to send the message directly, instead fallback to floodsub
-        const peers = to || this.peers;
-        if (peers == null ||
-            (Array.isArray(peers) && peers.length === 0) ||
-            (peers instanceof Map && peers.size === 0)) {
-            logger.trace("No peers to send to");
-            return delivereyPromise;
-        }
-        let sentOnce = false;
-        const promises = [];
-        for (const stream of peers.values()) {
-            const id = stream;
-            // Dont sent back to the sender
-            if (id.publicKey.equals(from)) {
-                continue;
             }
-            // Dont send message back to any of the signers (they have already seen the message)
-            if (message.header.signatures?.publicKeys.find((x) => x.equals(id.publicKey))) {
-                continue;
+            // We fail to send the message directly, instead fallback to floodsub
+            const peers = to || this.peers;
+            if (peers == null ||
+                (Array.isArray(peers) && peers.length === 0) ||
+                (peers instanceof Map && peers.size === 0)) {
+                logger.trace("No peers to send to");
+                return delivereyPromise;
+            }
+            let sentOnce = false;
+            const promises = [];
+            for (const stream of peers.values()) {
+                const id = stream;
+                // Dont sent back to the sender
+                if (id.publicKey.equals(from)) {
+                    continue;
+                }
+                // Dont send message back to any of the signers (they have already seen the message)
+                if (message.header.signatures?.publicKeys.find((x) => x.equals(id.publicKey))) {
+                    continue;
+                }
+                sentOnce = true;
+                promises.push(id.waitForWrite(bytes, message.header.priority));
+            }
+            await Promise.all(promises);
+            if (!sentOnce) {
+                // If the caller provided an explicit peer list, treat "no valid receivers" as an error
+                // even when forwarding. This catches programming mistakes early and matches test expectations.
+                if (!isRelayed || to != null) {
+                    throw new DeliveryError("Message did not have any valid receivers");
+                }
             }
-            sentOnce = true;
-            promises.push(id.waitForWrite(bytes, message.header.priority));
+            return delivereyPromise;
         }
-        await Promise.all(promises);
-        if (!sentOnce) {
-            if (!relayed) {
-                throw new DeliveryError("Message did not have any valid receivers");
+        catch (error) {
+            // If message fanout/write fails before publishMessage returns its delivery
+            // promise, clear any ACK callback to avoid late timer rejections leaking as
+            // unhandled rejections in fire-and-forget call paths.
+            if (ackCallbackId) {
+                this._ackCallbacks.get(ackCallbackId)?.clear();
             }
+            throw error;
         }
-        return delivereyPromise;
     }
     async maybeConnectDirectly(toHash, origin) {
         if (this.peers.has(toHash) || this.prunedConnectionsCache?.has(toHash)) {
@@ -1926,10 +2225,12 @@ export class DirectStream extends TypedEventEmitter {
         for (const h of admitted)
             if (reached(h, target))
                 wins.add(h);
+        // Preserve input order in the returned list (important for deterministic callers/tests).
+        const orderedWins = () => admitted.filter((h) => wins.has(h));
         if (settle === "any" && wins.size > 0)
-            return [...wins];
+            return orderedWins();
         if (settle === "all" && wins.size === admitted.length)
-            return [...wins];
+            return orderedWins();
         // Abort/timeout
         const abortSignals = [this.closeController.signal];
         if (signal) {
@@ -1949,7 +2250,7 @@ export class DirectStream extends TypedEventEmitter {
                 signals: abortSignals,
                 timeout,
             });
-            return [...wins];
+            return orderedWins();
         }
         catch (e) {
             const abortSignal = abortSignals.find((s) => s.aborted);
@@ -1959,112 +2260,23 @@ export class DirectStream extends TypedEventEmitter {
                 }
                 throw new AbortError("Aborted waiting for peers: " + abortSignal.reason);
             }
-            if (e instanceof Error) {
-                throw e;
+            if (e instanceof TimeoutError) {
+                if (settle === "any") {
+                    if (wins.size > 0)
+                        return orderedWins();
+                    throw new TimeoutError(`Timeout waiting for peers (target=${target}, seek=${seek}, missing=${admitted.length}/${admitted.length})`);
+                }
+                const missing = admitted.filter((h) => !wins.has(h));
+                const preview = missing.slice(0, 5).join(", ");
+                throw new TimeoutError(`Timeout waiting for peers (target=${target}, seek=${seek}, missing=${missing.length}/${admitted.length}${preview ? `, e.g. ${preview}` : ""})`);
             }
+            if (e instanceof Error)
+                throw e;
             if (settle === "all")
                 throw new TimeoutError("Timeout waiting for peers");
-            return [...wins]; // settle:any: return whatever successes we got
-        }
-    }
-    /* async waitFor(
-        peer: PeerId | PublicSignKey | string,
-        options?: {
-            timeout?: number;
-            signal?: AbortSignal;
-            neighbour?: boolean;
-            inflight?: boolean;
-        },
-    ) {
-        const hash =
-            typeof peer === "string"
-                ? peer
-                : (peer instanceof PublicSignKey
-                    ? peer
-                    : getPublicKeyFromPeerId(peer)
-                ).hashcode();
-        if (hash === this.publicKeyHash) {
-            return; // TODO throw error instead?
-        }
-
-        if (options?.inflight) {
-            // if peer is not in active connections or dialQueue, return silenty
-            if (
-                !this.peers.has(hash) &&
-                !this.components.connectionManager
-                    .getDialQueue()
-                    .some((x) => getPublicKeyFromPeerId(x.peerId).hashcode() === hash) &&
-                !this.components.connectionManager
-                    .getConnections()
-                    .some((x) => getPublicKeyFromPeerId(x.remotePeer).hashcode() === hash)
-            ) {
-                return;
-            }
-        }
-
-        const checkIsReachable = (deferred: DeferredPromise<void>) => {
-            if (options?.neighbour && !this.peers.has(hash)) {
-                return;
-            }
-
-            if (!this.routes.isReachable(this.publicKeyHash, hash, 0)) {
-                return;
-            }
-
-            deferred.resolve();
-        };
-        const abortSignals = [this.closeController.signal];
-        if (options?.signal) {
-            abortSignals.push(options.signal);
+            return orderedWins(); // settle:any: return whatever successes we got
         }
-
-        try {
-            await waitForEvent(this, ["peer:reachable"], checkIsReachable, {
-                signals: abortSignals,
-                timeout: options?.timeout,
-            });
-        } catch (error) {
-            throw new Error(
-                "Stream to " +
-                hash +
-                " from " +
-                this.publicKeyHash +
-                " does not exist. Connection exist: " +
-                this.peers.has(hash) +
-                ". Route exist: " +
-                this.routes.isReachable(this.publicKeyHash, hash, 0),
-            );
-        }
-
-        if (options?.neighbour) {
-            const stream = this.peers.get(hash)!;
-            try {
-                let checkIsWritable = (pDefer: DeferredPromise<void>) => {
-                    if (stream.isReadable && stream.isWritable) {
-                        pDefer.resolve();
-                    }
-                };
-                await waitForEvent(
-                    stream,
-                    ["stream:outbound", "stream:inbound"],
-                    checkIsWritable,
-                    {
-                        signals: abortSignals,
-                        timeout: options?.timeout,
-                    },
-                );
-            } catch (error) {
-                throw new Error(
-                    "Stream to " +
-                    stream.publicKey.hashcode() +
-                    " not ready. Readable: " +
-                    stream.isReadable +
-                    ". Writable " +
-                    stream.isWritable,
-                );
-            }
-        }
-    } */
+    }
     getPublicKey(hash) {
         return this.peerKeyHashToPublicKey.get(hash);
     }
@@ -2073,6 +2285,10 @@ export class DirectStream extends TypedEventEmitter {
     }
     // make this into a job? run every few ms
     maybePruneConnections() {
+        // Hard cap on peer streams: treat as a primary pruning signal.
+        if (this.peers.size > this.connectionManagerOptions.maxConnections) {
+            return this.pruneConnectionsToLimits();
+        }
         if (this.connectionManagerOptions.pruner) {
             if (this.connectionManagerOptions.pruner.bandwidth != null) {
                 let usedBandwidth = 0;
@@ -2108,7 +2324,7 @@ export class DirectStream extends TypedEventEmitter {
             return;
         }
         const stream = this.peers.get(prunables[0]);
-        this.prunedConnectionsCache.add(stream.publicKey.hashcode());
+        this.prunedConnectionsCache?.add(stream.publicKey.hashcode());
         await this.onPeerDisconnected(stream.peerId);
         return this.components.connectionManager.closeConnections(stream.peerId);
     }