feat(relay)!: construct the cluster origin once

doc/bin/relay/config.md

@@ -193,7 +193,7 @@ waiting forever).
 seconds and resizes the pool. Embedders calling `CacheConfig::init` directly
 should know that the task is owned by the `cache::Pool` it resizes, not by the
 `Cache` struct or the `Relay`: it stops on its next tick once the last `Pool`
-clone drops. Handing the `Cache` to `Cluster::with_cache` therefore moves the
+clone drops. Handing the `Cache` to `Cluster::new` therefore moves the
 task's lifetime onto the cluster, and keeping a `Pool` clone of your own keeps
 the task running for as long as you hold it.
 

quest/m1/README.md

@@ -36,7 +36,6 @@ quest here and merged main into dev.
 - [HLS 404](/quest/m1/hls-cache-miss-codes.md) - a relay miss and a disconnected publisher answer 404 over moq-lite; IETF upstreams stay 500
 - [HLS sibling restart](/quest/m1/hls-sibling-epoch-identity.md) - a replaced sibling publisher restarts its rendition instead of serving stale rows
 - [A/V clock](/quest/m1/plan-av-clock.md) - the audio playhead drives Sync.reference while audio plays, through per-track sync handles
-- [Cluster construction](/quest/m1/cluster-construction.md) - construct one stable origin after its cache settings are known, deleting the rebuilding builder
 - [LAN discovery app id](/quest/m1/lan-app.md) - every advertisement names an application as a DNS-SD subtype bound into the proofs, so unrelated apps on one network never meet
 - [One LAN mesh](/quest/m1/lan-mesh.md) - moq-cli drives the relay's Cluster, LAN peers authenticate by mDNS credential, and the two binaries mesh with each other
 - [Native Go context](/quest/m1/go-native-context.md) - the Go generator emits context.Context itself, retiring the hand-rolled cancellation token

quest/m1/lan-mesh.md

@@ -25,9 +25,8 @@ One implementation: the relay's `Cluster`.
 - moq-cli depends on the moq-relay library; its `cluster-lan` feature becomes
   `moq-relay/cluster-lan`. `MoqSide.cluster` nests `moq_relay::ClusterConfig`,
   so the CLI's `--cluster-*` flags are the relay's, LAN and WAN alike, and the
-  stages publish and subscribe on the cluster's origin (the one
-  [cluster construction](/quest/m1/cluster-construction.md) builds once).
-  Delete `rs/moq-cli/src/cluster.rs`.
+  stages publish and subscribe on the cluster's origin (built once at
+  construction). Delete `rs/moq-cli/src/cluster.rs`.
 - Advertise: the listener's fingerprint whenever its certificate was
   generated, the node URL when one is configured, and at least one of them
   (the `UnboundSecret` rule). A relay without `--cluster-node` advertises its
@@ -63,5 +62,4 @@ Branch from `dev`.
 
 ## Related
 
-- [Cluster construction](/quest/m1/cluster-construction.md) - the origin the CLI's stages attach to
 - [`moq relay`](/quest/m2/moq-relay-subcommand.md) - the second place the CLI hosts the relay library

rs/moq-relay/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- *(relay)* `ClusterOptions` so the origin is constructed with its cache settings
+
+### Removed
+
+- *(relay)* `Cluster::with_cache`; pass the cache to `Cluster::new` via `ClusterOptions`
+
 ## [0.14.16](https://github.com/moq-dev/moq/compare/moq-relay-v0.14.15...moq-relay-v0.14.16) - 2026-09-09
 
 ### Fixed

rs/moq-relay/src/cache.rs

@@ -71,11 +71,11 @@ pub struct CacheConfig {
 /// The headroom governor, when configured, is owned by [`Self::pool`] rather than
 /// by this struct: it holds only a [`cache::PoolWeak`] and stops on its next tick
 /// once every [`cache::Pool`] clone has dropped. Handing this to
-/// [`Cluster::with_cache`](crate::Cluster::with_cache) therefore moves the
-/// governor's lifetime onto the cluster, and dropping this struct afterwards keeps
-/// it running. Conversely, holding a clone of [`Self::pool`] past the relay keeps
-/// the governor running too, deliberately: as long as anything can still cache into
-/// the budget, resizing it is still the right thing to do.
+/// [`Cluster::new`](crate::Cluster::new) therefore moves the governor's lifetime
+/// onto the cluster, and dropping this struct afterwards keeps it running.
+/// Conversely, holding a clone of [`Self::pool`] past the relay keeps the governor
+/// running too, deliberately: as long as anything can still cache into the budget,
+/// resizing it is still the right thing to do.
 pub struct Cache {
 	/// The shared pool every session's groups register with: the byte budget plus
 	/// the wall-clock LRU window that reclaims idle groups.
@@ -266,7 +266,7 @@ mod tests {
 	/// hand it to a cluster whose construction can still fail.
 	fn attach(cache: &CacheConfig, cluster: crate::ClusterConfig) -> anyhow::Result<crate::Cluster> {
 		let cache = cache.init()?;
-		Ok(crate::Cluster::new(cluster)?.with_cache(cache))
+		crate::Cluster::new(crate::ClusterOptions::new(cluster).with_cache(cache))
 	}
 
 	#[tokio::test(start_paused = true)]