fix(presence): fan out beacons concurrently

Send presence beacons to broadcast peers concurrently under a bounded timeout so one slow peer cannot delay delivery to the rest of the mesh. Increase the per-peer timeout to 15s now that fanout no longer has head-of-line blocking.\n\nBumps workspace crate version to 0.5.23 and documents the 0.5.22/0.5.23 presence fixes.

Author: dirvine

CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.23] - 2026-04-27
+
+### Fixed
+
+- Presence beacon fanout now sends to peers concurrently with a bounded timeout,
+  preventing one slow or wedged peer from delaying delivery to the rest of the
+  mesh.
+- Increased the per-peer presence beacon send timeout to 15 seconds now that
+  fanout is concurrent, reducing false timeouts on high-latency live links
+  without reintroducing head-of-line blocking.
+
+## [0.5.22] - 2026-04-26
+
+### Fixed
+
+- Presence beacon sends are bounded by a timeout so a stalled peer cannot wedge
+  the beacon task indefinitely.
+- Presence beacon fanout snapshots groups and broadcast peers before network I/O,
+  so no broadcast peer lock is held across awaited sends.
+- Added `PresenceManager::replace_broadcast_peers()` for authoritative fanout
+  refresh and stale-peer pruning by callers.
+
 ## [0.5.20] - 2026-04-23
 
 ### Changed

Cargo.toml

@@ -18,7 +18,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "0.5.22"
+version = "0.5.23"
 edition = "2021"
 authors = ["David Irvine <david@saorsalabs.com>"]
 license = "MIT OR Apache-2.0"

crates/presence/src/lib.rs

@@ -24,14 +24,14 @@ use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 use tokio::sync::RwLock;
-use tokio::task::JoinHandle;
+use tokio::task::{JoinHandle, JoinSet};
 use tracing::{debug, warn};
 
 /// Maximum time to spend attempting a single presence beacon send.
 ///
 /// Presence beacons are periodic best-effort liveness hints. A stalled peer must
 /// not be able to wedge the single beacon broadcast task indefinitely.
-const BEACON_SEND_TIMEOUT: Duration = Duration::from_secs(5);
+const BEACON_SEND_TIMEOUT: Duration = Duration::from_secs(15);
 
 /// Presence status for a peer
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -508,27 +508,40 @@ impl PresenceManager {
                                 .iter()
                                 .copied()
                                 .collect();
-                            let mut timed_out_peers = Vec::new();
+                            let mut send_tasks = JoinSet::new();
                             for target_peer in peers.iter().copied() {
-                                let send = transport.send_to_peer(
-                                    target_peer,
-                                    GossipStreamType::Bulk,
-                                    data.clone(),
-                                );
-                                match tokio::time::timeout(BEACON_SEND_TIMEOUT, send).await {
-                                    Ok(Ok(())) => {}
-                                    Ok(Err(e)) => {
+                                let transport = Arc::clone(&transport);
+                                let data = data.clone();
+                                send_tasks.spawn(async move {
+                                    let send = transport.send_to_peer(
+                                        target_peer,
+                                        GossipStreamType::Bulk,
+                                        data,
+                                    );
+                                    let result = tokio::time::timeout(BEACON_SEND_TIMEOUT, send).await;
+                                    (target_peer, result)
+                                });
+                            }
+
+                            let mut timed_out_peers = Vec::new();
+                            while let Some(result) = send_tasks.join_next().await {
+                                match result {
+                                    Ok((_, Ok(Ok(())))) => {}
+                                    Ok((target_peer, Ok(Err(e)))) => {
                                         debug!(?target_peer, ?e, "Failed to send beacon to peer");
                                         // Continue to next peer - don't fail entire broadcast
                                     }
-                                    Err(_) => {
+                                    Ok((target_peer, Err(_))) => {
                                         warn!(
                                             ?target_peer,
                                             timeout_secs = BEACON_SEND_TIMEOUT.as_secs(),
                                             "Timed out sending beacon to peer"
                                         );
                                         timed_out_peers.push(target_peer);
                                     }
+                                    Err(e) => {
+                                        warn!(?e, "Presence beacon send task failed");
+                                    }
                                 }
                             }