The cleanest expression of one real shared thread pool.

Bus is Arc<Inner>, cheap to clone and hand to consumers and callbacks — how a consumer re-publishes mid-pipeline. The pool is a fixed set of OS threads parked on a shared job queue; concurrency permits are a hand-rolled atomic-CAS loop (AtomicUsize + compare_exchange_weak), not a semaphore type. Per-hop attempts live on the channel, keyed by envelope id, since ra_common::Envelope carries none — that map is only touched when a stage's max attempts exceed one, so the default single-attempt case never pays for the lock.

A Consumer is a trait, blanket-implemented for any Fn(&mut Envelope) -> bool + Send + Sync, so closures subscribe directly with no adapter type. No persistence, no datatype filter, no pull model — the minimal core the shared design asks for, and nothing more.

Two real concurrency bugs were found and fixed by the benchmark comparison, in two separate parts of the pool. The pool's job queue originally used std::sync::mpsc, which parks a waiting worker immediately with no spin phase — a real cold-wake stall (up to ~260ms) on the benchmark's Docker host. Swapping to parking_lot's Mutex+Condvar (which spins briefly before parking, closer to what Java's ExecutorService does) fixed it for a real but small (~4.6%) throughput cost under contention. Separately, the channel's own data queue — originally Mutex<VecDeque<Envelope>>, shared by every producer and consumer on a stage — showed an 8-producer lock-contention cliff (p50 ~38µs, p99 66–70ms). Replacing it with crossbeam-queue's lock-free, bounded ArrayQueue, plus a waiter-count gate so poll() skips the lock entirely when nothing is waiting, took that config's throughput from 427,650 to 709,629 eps (+66%).