@peerbit/pubsub 5.4.4 → 5.4.6

package/dist/src/fanout-tree.js

@@ -104,6 +104,14 @@ const createEmptyMetrics = () => ({
     joinRejectSent: 0,
     joinRejectReceived: 0,
     joinPeerResets: 0,
+    joinBootstrapDialAttempts: 0,
+    joinBootstrapDialFailures: 0,
+    joinCandidateDialAttempts: 0,
+    joinCandidateDialFailures: 0,
+    joinConnectedCandidateAttempts: 0,
+    joinUnconnectedCandidateAttempts: 0,
+    joinReqTimeouts: 0,
+    joinDeadlineExpirations: 0,
     kickSent: 0,
     kickReceived: 0,
     reparentDisconnect: 0,
@@ -2465,7 +2473,10 @@ export class FanoutTree extends DirectStream {
             // Best-effort reset. The join loop keeps retrying other candidates.
         }
     }
-    async _sendControl(to, bytes) {
+    async _sendControl(to, bytes, signal) {
+        if (signal?.aborted) {
+            throw signal.reason ?? new AbortError("fanout control send aborted");
+        }
         const stream = this.peers.get(to);
         if (!stream)
             return;
@@ -2474,7 +2485,10 @@ export class FanoutTree extends DirectStream {
             mode: new AnyWhere(),
             priority: CONTROL_PRIORITY,
         });
-        await this.publishMessageMaybe(this.publicKey, message, [stream]);
+        if (signal?.aborted) {
+            throw signal.reason ?? new AbortError("fanout control send aborted");
+        }
+        await this.publishMessageMaybe(this.publicKey, message, [stream], undefined, signal);
     }
     async _sendControlMany(to, bytes) {
         if (to.length === 0)
@@ -3082,34 +3096,138 @@ export class FanoutTree extends DirectStream {
         }
         return out;
     }
-    async ensureBootstrapPeers(addrs, timeoutMs, signal, maxPeers = 0) {
+    isPeerReadyForJoin(hash) {
+        const stream = this.peers.get(hash);
+        if (!stream || !stream.isReadable || !stream.isWritable)
+            return false;
+        try {
+            return (this.components.connectionManager.getConnections(stream.peerId).length > 0);
+        }
+        catch {
+            // Test/mocked connection managers may not expose peer-scoped snapshots.
+            return true;
+        }
+    }
+    connectedPeerHashForBootstrap(address) {
+        const peerId = address
+            .getComponents()
+            .filter((component) => component.name === "p2p")
+            .at(-1)?.value;
+        if (!peerId)
+            return;
+        for (const [hash, stream] of this.peers) {
+            if (stream.peerId.toString() !== peerId)
+                continue;
+            if (this.isPeerReadyForJoin(hash))
+                return hash;
+        }
+        return;
+    }
+    createBoundedDialAttempt(signal, timeoutMs, deadlineAt) {
+        if (signal.aborted)
+            return;
+        const remainingMs = deadlineAt == null
+            ? Number.POSITIVE_INFINITY
+            : Math.max(0, deadlineAt - Date.now());
+        if (remainingMs <= 0)
+            return;
+        const boundedTimeoutMs = Math.max(1, Math.min(Math.max(1, Math.floor(timeoutMs)), remainingMs));
+        const timeoutSignal = AbortSignal.timeout(boundedTimeoutMs);
+        const combined = anySignal([signal, timeoutSignal]);
+        return {
+            signal: combined,
+            timeoutMs: boundedTimeoutMs,
+            clear: () => combined.clear?.(),
+        };
+    }
+    async ensureBootstrapPeers(addrs, timeoutMs, signal, maxPeers = 0, diagnostics) {
         if (addrs.length === 0)
             return [];
         const max = Math.max(0, Math.floor(maxPeers));
-        const shuffled = addrs.slice();
+        const connected = [];
+        const disconnected = [];
+        const connectedSeen = new Set();
+        for (const address of addrs) {
+            const readyHash = diagnostics
+                ? this.connectedPeerHashForBootstrap(address)
+                : undefined;
+            if (readyHash &&
+                diagnostics?.excludeReadyPeerHashes?.has(readyHash)) {
+                continue;
+            }
+            const hash = diagnostics?.preferConnected ? readyHash : undefined;
+            if (!hash) {
+                disconnected.push(address);
+                continue;
+            }
+            if (!connectedSeen.has(hash)) {
+                connectedSeen.add(hash);
+                connected.push(hash);
+            }
+        }
+        const connectedLimit = max > 0 ? Math.min(max, connected.length) : connected.length;
+        const out = connected.slice(0, connectedLimit);
+        if (diagnostics?.preferConnected && out.length > 0)
+            return out;
+        const shuffled = disconnected.slice();
         for (let i = shuffled.length - 1; i > 0; i--) {
             const j = Math.floor(this.random() * (i + 1));
             const tmp = shuffled[i];
             shuffled[i] = shuffled[j];
             shuffled[j] = tmp;
         }
-        const target = max > 0 ? Math.min(max, shuffled.length) : shuffled.length;
-        const out = [];
+        const target = max > 0 ? Math.min(max, addrs.length) : addrs.length;
         for (const a of shuffled) {
             if (signal.aborted)
                 break;
             if (target > 0 && out.length >= target)
                 break;
+            const attempt = diagnostics
+                ? this.createBoundedDialAttempt(signal, timeoutMs, diagnostics.deadlineAt)
+                : undefined;
+            if (diagnostics && !attempt)
+                break;
+            if (diagnostics)
+                diagnostics.metrics.joinBootstrapDialAttempts += 1;
+            let ready = false;
+            let skippedExcluded = false;
             try {
-                const conn = await this.components.connectionManager.openConnection(a);
+                const conn = attempt
+                    ? await this.components.connectionManager.openConnection(a, {
+                        signal: attempt.signal,
+                    })
+                    : await this.components.connectionManager.openConnection(a);
                 const h = getPublicKeyFromPeerId(conn.remotePeer).hashcode();
-                await this.waitFor(h, { seek: "present", timeout: timeoutMs, signal });
-                out.push(h);
+                await this.waitFor(h, {
+                    seek: "present",
+                    timeout: attempt?.timeoutMs ?? timeoutMs,
+                    signal: attempt?.signal ?? signal,
+                });
+                skippedExcluded =
+                    diagnostics?.excludeReadyPeerHashes?.has(h) === true;
+                ready =
+                    !skippedExcluded &&
+                        (diagnostics ? this.isPeerReadyForJoin(h) : true);
+                if (ready)
+                    out.push(h);
             }
             catch {
                 // ignore dial failures
             }
+            finally {
+                attempt?.clear();
+                if (!ready && !skippedExcluded && diagnostics) {
+                    diagnostics.metrics.joinBootstrapDialFailures += 1;
+                }
+            }
+            if (ready && diagnostics?.preferConnected)
+                break;
         }
+        // Exhaustion completes one bounded pass over the configured bootstrap set.
+        // Allow a later round to revisit ready trackers because their candidate view
+        // may have changed while this cold join was progressing.
+        if (out.length === 0)
+            diagnostics?.excludeReadyPeerHashes?.clear();
         return [...new Set(out)];
     }
     async announceToTrackers(ch, signal) {
@@ -3476,24 +3594,47 @@ export class FanoutTree extends DirectStream {
             return true;
         });
     }
-    async ensurePeerConnection(hash, addrs, timeoutMs, signal) {
-        if (this.peers.get(hash))
+    async ensurePeerConnection(hash, addrs, timeoutMs, signal, diagnostics) {
+        if (this.isPeerReadyForJoin(hash))
             return true;
         for (const a of addrs) {
             if (signal.aborted)
                 return false;
+            const attempt = diagnostics
+                ? this.createBoundedDialAttempt(signal, timeoutMs, diagnostics.deadlineAt)
+                : undefined;
+            if (diagnostics && !attempt)
+                return false;
+            if (diagnostics)
+                diagnostics.metrics.joinCandidateDialAttempts += 1;
+            let ready = false;
             try {
-                await this.components.connectionManager.openConnection(a);
+                if (attempt) {
+                    await this.components.connectionManager.openConnection(a, {
+                        signal: attempt.signal,
+                    });
+                }
+                else {
+                    await this.components.connectionManager.openConnection(a);
+                }
                 await this.waitFor(hash, {
                     seek: "present",
-                    timeout: timeoutMs,
-                    signal,
+                    timeout: attempt?.timeoutMs ?? timeoutMs,
+                    signal: attempt?.signal ?? signal,
                 });
-                return true;
+                ready = diagnostics ? this.isPeerReadyForJoin(hash) : true;
             }
             catch {
                 // ignore and try next
             }
+            finally {
+                attempt?.clear();
+                if (!ready && diagnostics) {
+                    diagnostics.metrics.joinCandidateDialFailures += 1;
+                }
+            }
+            if (ready)
+                return true;
         }
         return false;
     }
@@ -3613,6 +3754,9 @@ export class FanoutTree extends DirectStream {
             return;
         await this._sendControlMany(trackerPeers, this.codec.encodeTrackerFeedback(ch.id.key, candidateHash, event, reason));
     }
+    sendTrackerFeedbackBestEffort(ch, trackerPeers, candidateHash, event, reason = 0) {
+        void this.sendTrackerFeedback(ch, trackerPeers, candidateHash, event, reason).catch(() => { });
+    }
     pruneParentUpgradeReservations(ch, now = Date.now()) {
         for (const [hash, reservation] of ch.parentUpgradeReservationsByHash) {
             if (reservation.expiresAt <= now) {
@@ -3798,14 +3942,40 @@ export class FanoutTree extends DirectStream {
             source: Number(joinOpts.candidateScoringWeights?.source ?? 0.25),
         };
         const start = Date.now();
+        const initialJoinDeadlineAt = timeoutMs > 0 ? start + timeoutMs : undefined;
         const cooldownUntilByHash = new Map();
         const combinedSignal = joinOpts.signal
             ? anySignal([ch.closeController.signal, joinOpts.signal])
             : ch.closeController.signal;
         const signal = combinedSignal;
+        const initialJoinRemainingMs = () => !ch.joinedAtLeastOnce && initialJoinDeadlineAt != null
+            ? Math.max(0, initialJoinDeadlineAt - Date.now())
+            : undefined;
+        const clampInitialJoinWait = (requestedMs) => {
+            const remainingMs = initialJoinRemainingMs();
+            return remainingMs == null
+                ? requestedMs
+                : Math.min(requestedMs, remainingMs);
+        };
+        const throwInitialJoinTimeout = () => {
+            ch.metrics.joinDeadlineExpirations += 1;
+            const bootstrapsCount = this.getBootstrapsForChannel(ch).length;
+            const rootPeer = this.peers.get(ch.id.root);
+            const rootNeighbor = Boolean(rootPeer && rootPeer.isReadable && rootPeer.isWritable);
+            const bootstrapHint = bootstrapsCount === 0 && !rootNeighbor
+                ? " No fanout bootstraps are configured for this channel, and the root is not a direct neighbor. If this peer reached the network via a bootstrap or relay node, initialize it with Peerbit.bootstrap(...) instead of Peerbit.dial(...), or configure FanoutTree.setBootstraps(...) before joining sharded topics."
+                : "";
+            throw new Error(`fanout join timed out after ${timeoutMs}ms (topic=${ch.id.topic} root=${ch.id.root} self=${this.publicKeyHash} rootNeighbor=${rootNeighbor} peers=${this.peers.size} bootstraps=${bootstrapsCount} joinReqSent=${ch.metrics.joinReqSent} joinAcceptReceived=${ch.metrics.joinAcceptReceived} joinRejectReceived=${ch.metrics.joinRejectReceived} peerResets=${ch.metrics.joinPeerResets}).${bootstrapHint}`);
+        };
+        const throwIfInitialJoinTimedOut = () => {
+            if (initialJoinRemainingMs() === 0)
+                throwInitialJoinTimeout();
+        };
         let nextParentUpgradeCheckAt = 0;
         let parentUpgradeCheckSeq = 0;
         let parentUpgradeActiveGuardBackoffMs = 0;
+        const unsuccessfulColdBootstrapPeers = new Set();
+        let bootstrapFallbackRetryAt = 0;
         const scheduleNextParentUpgradeCheck = (now, first = false, minDelayMs = parentUpgrade.intervalMs) => {
             if (parentUpgrade.intervalMs <= 0) {
                 nextParentUpgradeCheckAt = 0;
@@ -4004,30 +4174,28 @@ export class FanoutTree extends DirectStream {
                     await delay(Math.max(retryMs, 1_000), { signal });
                     continue;
                 }
-                // `timeoutMs` is meant to bound the initial `joinChannel()` await, not to
-                // stop re-parenting attempts for long-running nodes.
-                if (!ch.joinedAtLeastOnce &&
-                    timeoutMs > 0 &&
-                    Date.now() - start > timeoutMs) {
-                    const bootstrapsCount = this.getBootstrapsForChannel(ch).length;
-                    const rootPeer = this.peers.get(ch.id.root);
-                    const rootNeighbor = Boolean(rootPeer && rootPeer.isReadable && rootPeer.isWritable);
-                    const bootstrapHint = bootstrapsCount === 0 && !rootNeighbor
-                        ? " No fanout bootstraps are configured for this channel, and the root is not a direct neighbor. If this peer reached the network via a bootstrap or relay node, initialize it with Peerbit.bootstrap(...) instead of Peerbit.dial(...), or configure FanoutTree.setBootstraps(...) before joining sharded topics."
-                        : "";
-                    throw new Error(`fanout join timed out after ${timeoutMs}ms (topic=${ch.id.topic} root=${ch.id.root} self=${this.publicKeyHash} rootNeighbor=${rootNeighbor} peers=${this.peers.size} bootstraps=${bootstrapsCount} joinReqSent=${ch.metrics.joinReqSent} joinAcceptReceived=${ch.metrics.joinAcceptReceived} joinRejectReceived=${ch.metrics.joinRejectReceived} peerResets=${ch.metrics.joinPeerResets}).${bootstrapHint}`);
-                }
+                // `timeoutMs` bounds only the initial `joinChannel()` await. Re-parenting
+                // remains unbounded after the first attachment, while every cold-open wait
+                // below is clamped to this same absolute deadline.
+                throwIfInitialJoinTimedOut();
                 const cooldownMs = ch.rejoinCooldownUntil - Date.now();
                 if (cooldownMs > 0) {
-                    await delay(cooldownMs, { signal });
+                    const waitMs = clampInitialJoinWait(cooldownMs);
+                    if (waitMs <= 0)
+                        throwInitialJoinTimeout();
+                    await delay(waitMs, { signal });
                     continue;
                 }
                 const bootstraps = this.getBootstrapsForChannel(ch);
                 let bootstrapPeers = [];
                 if (bootstraps.length > 0) {
                     const now = Date.now();
-                    const connectedCached = ch.cachedBootstrapPeers.filter((h) => Boolean(this.peers.get(h)));
-                    const due = ch.lastBootstrapEnsureAt === 0 ||
+                    const connectedCached = ch.cachedBootstrapPeers.filter((h) => this.isPeerReadyForJoin(h) &&
+                        !unsuccessfulColdBootstrapPeers.has(h));
+                    const hasExcludedReadyCached = ch.cachedBootstrapPeers.some((h) => this.isPeerReadyForJoin(h) &&
+                        unsuccessfulColdBootstrapPeers.has(h));
+                    const due = (hasExcludedReadyCached && now >= bootstrapFallbackRetryAt) ||
+                        ch.lastBootstrapEnsureAt === 0 ||
                         bootstrapEnsureIntervalMs === 0 ||
                         now - ch.lastBootstrapEnsureAt >= bootstrapEnsureIntervalMs;
                     const haveEnough = bootstrapMaxPeers > 0
@@ -4035,12 +4203,34 @@ export class FanoutTree extends DirectStream {
                         : false;
                     if (due && !haveEnough) {
                         ch.lastBootstrapEnsureAt = now;
-                        const peers = await this.ensureBootstrapPeers(bootstraps, bootstrapDialTimeoutMs, signal, bootstrapMaxPeers);
-                        if (peers.length > 0)
+                        const wasFallbackPass = unsuccessfulColdBootstrapPeers.size > 0;
+                        const diagnostics = !ch.joinedAtLeastOnce
+                            ? {
+                                metrics: ch.metrics,
+                                deadlineAt: initialJoinDeadlineAt,
+                                preferConnected: true,
+                                excludeReadyPeerHashes: unsuccessfulColdBootstrapPeers,
+                            }
+                            : undefined;
+                        const peers = await this.ensureBootstrapPeers(bootstraps, bootstrapDialTimeoutMs, signal, bootstrapMaxPeers, diagnostics);
+                        if (peers.length > 0) {
+                            const cohortChanged = peers.length !== ch.cachedBootstrapPeers.length ||
+                                peers.some((hash, index) => ch.cachedBootstrapPeers[index] !== hash);
                             ch.cachedBootstrapPeers = peers;
+                            if (cohortChanged) {
+                                ch.lastTrackerQueryAt = 0;
+                                ch.cachedTrackerCandidates = [];
+                            }
+                        }
+                        else if (wasFallbackPass) {
+                            bootstrapFallbackRetryAt =
+                                Date.now() + Math.max(1, bootstrapEnsureIntervalMs);
+                        }
                     }
-                    bootstrapPeers = ch.cachedBootstrapPeers.filter((h) => Boolean(this.peers.get(h)));
+                    bootstrapPeers = ch.cachedBootstrapPeers.filter((h) => this.isPeerReadyForJoin(h) &&
+                        !unsuccessfulColdBootstrapPeers.has(h));
                 }
+                throwIfInitialJoinTimedOut();
                 let tracker = [];
                 if (bootstrapPeers.length > 0 && trackerCandidates > 0) {
                     const now = Date.now();
@@ -4049,12 +4239,16 @@ export class FanoutTree extends DirectStream {
                         now - ch.lastTrackerQueryAt >= trackerQueryIntervalMs;
                     if (due) {
                         ch.lastTrackerQueryAt = now;
-                        const res = await this.queryTrackers(ch, bootstrapPeers, trackerCandidates, trackerQueryTimeoutMs, signal);
+                        const queryTimeoutMs = clampInitialJoinWait(Math.max(1, trackerQueryTimeoutMs));
+                        if (queryTimeoutMs <= 0)
+                            throwInitialJoinTimeout();
+                        const res = await this.queryTrackers(ch, bootstrapPeers, trackerCandidates, queryTimeoutMs, signal);
                         if (res.length > 0)
                             ch.cachedTrackerCandidates = res;
                     }
                     tracker = ch.cachedTrackerCandidates;
                 }
+                throwIfInitialJoinTimedOut();
                 const candidatesByHash = new Map();
                 const upsertCandidate = (c) => {
                     const prev = candidatesByHash.get(c.hash);
@@ -4072,7 +4266,8 @@ export class FanoutTree extends DirectStream {
                 // Fast path: if the designated root is already a direct neighbor, try it first.
                 // Without this, large join storms can repeatedly time out on arbitrary peers
                 // that don't host the channel yet, starving the real root candidate.
-                if (ch.id.root !== this.publicKeyHash && this.peers.has(ch.id.root)) {
+                if (ch.id.root !== this.publicKeyHash &&
+                    this.isPeerReadyForJoin(ch.id.root)) {
                     upsertCandidate({
                         hash: ch.id.root,
                         addrs: [],
@@ -4122,6 +4317,8 @@ export class FanoutTree extends DirectStream {
                 for (const h of this.peers.keys()) {
                     if (h === this.publicKeyHash)
                         continue;
+                    if (!this.isPeerReadyForJoin(h))
+                        continue;
                     if (bootstrapPeerSet.has(h) && candidatesByHash.has(h))
                         continue;
                     upsertCandidate({
@@ -4167,10 +4364,16 @@ export class FanoutTree extends DirectStream {
                             ? Math.max(1, nextAt - now)
                             : retryMs;
                         const capMs = Math.max(retryMs, trackerQueryIntervalMs > 0 ? trackerQueryIntervalMs : retryMs);
-                        await delay(Math.max(1, Math.min(waitMs, capMs)), { signal });
+                        const boundedWaitMs = clampInitialJoinWait(Math.max(1, Math.min(waitMs, capMs)));
+                        if (boundedWaitMs <= 0)
+                            throwInitialJoinTimeout();
+                        await delay(boundedWaitMs, { signal });
                         continue;
                     }
-                    await delay(retryMs, { signal });
+                    const waitMs = clampInitialJoinWait(retryMs);
+                    if (waitMs <= 0)
+                        throwInitialJoinTimeout();
+                    await delay(waitMs, { signal });
                     continue;
                 }
                 let ordered = [...candidates];
@@ -4185,6 +4388,13 @@ export class FanoutTree extends DirectStream {
                             ordered[j] = tmp;
                         }
                     }
+                    // Give one usable peer a latency advantage without moving every
+                    // connected fallback ahead of better-ranked dialable candidates.
+                    const firstReadyIndex = ordered.findIndex((candidate) => this.isPeerReadyForJoin(candidate.hash));
+                    if (firstReadyIndex > 0) {
+                        const [firstReady] = ordered.splice(firstReadyIndex, 1);
+                        ordered.unshift(firstReady);
+                    }
                 }
                 else if (candidateScoringMode === "weighted") {
                     const wLevel = Number.isFinite(candidateScoringWeights.level)
@@ -4266,20 +4476,24 @@ export class FanoutTree extends DirectStream {
                         break;
                     if (attempts >= joinAttemptsPerRound)
                         break;
+                    throwIfInitialJoinTimedOut();
                     const c = queue[i];
                     attempts += 1;
-                    const wasConnected = Boolean(this.peers.get(c.hash));
+                    const wasConnected = this.isPeerReadyForJoin(c.hash);
+                    if (wasConnected) {
+                        ch.metrics.joinConnectedCandidateAttempts += 1;
+                    }
+                    else {
+                        ch.metrics.joinUnconnectedCandidateAttempts += 1;
+                    }
                     let dialOk = wasConnected;
                     if (!dialOk && c.addrs.length > 0) {
-                        dialOk = await this.ensurePeerConnection(c.hash, c.addrs, bootstrapDialTimeoutMs, signal);
+                        dialOk = await this.ensurePeerConnection(c.hash, c.addrs, bootstrapDialTimeoutMs, signal, !ch.joinedAtLeastOnce
+                            ? { metrics: ch.metrics, deadlineAt: initialJoinDeadlineAt }
+                            : undefined);
                     }
                     if (!dialOk) {
-                        try {
-                            await this.sendTrackerFeedback(ch, bootstrapPeers, c.hash, TRACKER_FEEDBACK_DIAL_FAILED);
-                        }
-                        catch {
-                            // ignore
-                        }
+                        this.sendTrackerFeedbackBestEffort(ch, bootstrapPeers, c.hash, TRACKER_FEEDBACK_DIAL_FAILED);
                         if (candidateCooldownMs > 0) {
                             cooldownUntilByHash.set(c.hash, Date.now() + candidateCooldownMs * 5);
                         }
@@ -4289,7 +4503,10 @@ export class FanoutTree extends DirectStream {
                         dialedNew.add(c.hash);
                     }
                     const reqId = (this.random() * 0xffffffff) >>> 0;
-                    const res = await this.tryJoinOnce(ch, c.hash, reqId, joinReqTimeoutMs, signal);
+                    const requestTimeoutMs = clampInitialJoinWait(Math.max(1, joinReqTimeoutMs));
+                    if (requestTimeoutMs <= 0)
+                        throwInitialJoinTimeout();
+                    const res = await this.tryJoinOnce(ch, c.hash, reqId, requestTimeoutMs, signal);
                     if (res.redirects && res.redirects.length > 0) {
                         for (const r of res.redirects) {
                             if (queue.length >= JOIN_REJECT_REDIRECT_QUEUE_MAX)
@@ -4315,12 +4532,7 @@ export class FanoutTree extends DirectStream {
                         }
                     }
                     if (res.ok) {
-                        try {
-                            await this.sendTrackerFeedback(ch, bootstrapPeers, c.hash, TRACKER_FEEDBACK_JOINED);
-                        }
-                        catch {
-                            // ignore
-                        }
+                        this.sendTrackerFeedbackBestEffort(ch, bootstrapPeers, c.hash, TRACKER_FEEDBACK_JOINED);
                         cooldownUntilByHash.delete(c.hash);
                         break;
                     }
@@ -4336,13 +4548,9 @@ export class FanoutTree extends DirectStream {
                         }
                     }
                     if (res.timedOut) {
+                        ch.metrics.joinReqTimeouts += 1;
                         this.noteJoinTimeout(ch, c.hash);
-                        try {
-                            await this.sendTrackerFeedback(ch, bootstrapPeers, c.hash, TRACKER_FEEDBACK_JOIN_TIMEOUT);
-                        }
-                        catch {
-                            // ignore
-                        }
+                        this.sendTrackerFeedbackBestEffort(ch, bootstrapPeers, c.hash, TRACKER_FEEDBACK_JOIN_TIMEOUT);
                         if (candidateCooldownMs > 0) {
                             cooldownUntilByHash.set(c.hash, Date.now() + candidateCooldownMs * 2);
                         }
@@ -4359,12 +4567,7 @@ export class FanoutTree extends DirectStream {
                         }
                         cooldownUntilByHash.set(c.hash, Date.now() + candidateCooldownMs * factor);
                     }
-                    try {
-                        await this.sendTrackerFeedback(ch, bootstrapPeers, c.hash, TRACKER_FEEDBACK_JOIN_REJECT, rejectReason);
-                    }
-                    catch {
-                        // ignore
-                    }
+                    this.sendTrackerFeedbackBestEffort(ch, bootstrapPeers, c.hash, TRACKER_FEEDBACK_JOIN_REJECT, rejectReason);
                 }
                 if (ch.parent) {
                     // Keep only the selected parent + bootstraps. Everything else we dialed is
@@ -4383,7 +4586,16 @@ export class FanoutTree extends DirectStream {
                     }
                     continue;
                 }
-                await delay(retryMs, { signal });
+                if (bootstraps.length > 1 &&
+                    Date.now() >= bootstrapFallbackRetryAt) {
+                    for (const hash of bootstrapPeers) {
+                        unsuccessfulColdBootstrapPeers.add(hash);
+                    }
+                }
+                const waitMs = clampInitialJoinWait(retryMs);
+                if (waitMs <= 0)
+                    throwInitialJoinTimeout();
+                await delay(waitMs, { signal });
             }
         }
         finally {
@@ -5286,23 +5498,69 @@ export class FanoutTree extends DirectStream {
             return { ok: true };
         if (!this.peers.get(parentHash))
             return { ok: false, timedOut: true };
-        const p = new Promise((resolve) => {
-            ch.pendingJoin.set(reqId, {
-                resolve,
-                shadowAttach: options?.shadowAttach === true,
-            });
+        const attemptController = new AbortController();
+        let settled = false;
+        let resolveAttempt;
+        let rejectAttempt;
+        const attempt = new Promise((resolve, reject) => {
+            resolveAttempt = resolve;
+            rejectAttempt = reject;
         });
-        await this._sendControl(parentHash, this.codec.encodeJoinReq(ch.id.key, reqId, ch.bidPerByte, options?.parentUpgradeReservationToken));
-        const res = await Promise.race([
-            p,
-            delay(Math.max(1, timeoutMs), { signal }).then(() => ({
-                ok: false,
-                timedOut: true,
-            })),
-        ]);
-        if (res.timedOut)
+        const settleResult = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            resolveAttempt(result);
+        };
+        const settleError = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            rejectAttempt(error);
+        };
+        ch.pendingJoin.set(reqId, {
+            resolve: settleResult,
+            shadowAttach: options?.shadowAttach === true,
+        });
+        const onAbort = () => {
+            const reason = signal.reason ?? new AbortError("fanout join aborted");
+            if (!attemptController.signal.aborted) {
+                attemptController.abort(reason);
+            }
+            settleError(reason);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+        const timer = setTimeout(() => {
+            if (!attemptController.signal.aborted) {
+                attemptController.abort(new AbortError("fanout join attempt timed out"));
+            }
+            settleResult({ ok: false, timedOut: true });
+        }, Math.max(1, timeoutMs));
+        timer.unref?.();
+        const send = this._sendControl(parentHash, this.codec.encodeJoinReq(ch.id.key, reqId, ch.bidPerByte, options?.parentUpgradeReservationToken), attemptController.signal).catch((error) => {
+            if (settled)
+                return;
+            if (signal.aborted) {
+                settleError(signal.reason ?? error);
+                return;
+            }
+            if (!attemptController.signal.aborted)
+                settleError(error);
+        });
+        try {
+            return await attempt;
+        }
+        finally {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", onAbort);
             ch.pendingJoin.delete(reqId);
-        return res;
+            if (!attemptController.signal.aborted) {
+                attemptController.abort(new AbortError("fanout join attempt settled"));
+            }
+            void send;
+        }
     }
     async kickChildHashes(ch, children, options) {
         const unique = [...new Set(children)].filter((h) => ch.children.has(h));