Struct WsHub 

pub struct WsHub { /* private fields */ }

High-performance WebSocket broadcast hub with sharded client storage.

Supports 10k+ concurrent connections with bounded thread count. Uses NUM_SHARDS (16) shards to reduce lock contention.

Architecture:

• Client connections are assigned to shards via round-robin (id % NUM_SHARDS).
• Each shard has a dedicated broadcast worker thread that consumes from a channel.
• Broadcast calls are non-blocking for the caller: they push to each shard’s channel and return immediately.
• Read-side threads use 64KB stacks (vs 2-8MB default) to keep memory bounded.
• Total thread count: NUM_SHARDS broadcast workers + 1 per connected client (with minimal stack), plus the accept thread.

Implementations

impl WsHub

pub fn new() -> Arc<Self>

pub fn subscriptions(&self) -> &Arc<CrdtSubscriptions>

Access the per-client CRDT subscription registry. The notifier looks up subscribers via subscriptions().subscribers(entity, row) and feeds them to broadcast_binary_to.

pub fn broadcast(&self, event: &ChangeEvent)

Broadcast a change event to ALL connected clients across all shards. Non-blocking: pushes to each shard’s channel and returns immediately.

Serializes the event JSON exactly once into an Arc<str> and shares it across the 16 shard senders. Each shard’s worker thread receives the same Arc and pays only a refcount bump.

pub fn broadcast_presence(&self, msg: &str)

Broadcast a raw string message to all clients (used for presence updates).

pub fn broadcast_binary(&self, bytes: Vec<u8>)

Broadcast a binary frame to every connected client across all shards. Used for CRDT updates (see pylon_router::encode_crdt_frame for the wire shape). The bytes are wrapped in an Arc so each shard’s per-client fanout shares one allocation; the per-send to_vec() cost is the tungstenite 0.24 contract.

Synchronous fanout — iterates shards directly rather than going through the per-shard mpsc workers. CRDT writes happen at most once per logical mutation so the throughput shape is “occasional burst” not “every keystroke”, and direct fanout avoids growing a second per-shard channel (Arc<u8> can’t share the Arc channel without an enum, which costs more than the bypass).

pub fn broadcast_binary_to(&self, client_ids: &[u64], bytes: Vec<u8>)

Send a binary frame to a specific subset of client IDs only. Used by the CRDT broadcast path to fan out only to clients subscribed to the row that just changed (instead of every connected client). Routes each id to its owning shard via id % NUM_SHARDS.

client_ids typically comes from CrdtSubscriptions::subscribers. An empty list is a no-op — the row had no subscribers, so the CRDT write is durable on the server but no client sees the binary frame (they’ll learn about the change via the JSON change-event broadcast which always fires).

pub fn send_binary_to_one(&self, client_id: u64, bytes: Vec<u8>)

Send a binary frame to a single client by id. Used by the subscribe path: when a client subscribes to a row, the server immediately ships the current snapshot so the new subscriber has the up-to-date state without waiting for the next write.

pub fn client_count(&self) -> usize

Total number of connected clients across all shards.