feat!: transports take shared types; qmux names no tungstenite type

Cargo.toml

@@ -113,6 +113,7 @@ hashbrown = { version = "0.17.1", default-features = false }
 hashlink = "0.12.2"
 hex = "0.4"
 http-body = "1.0.1"
+httparse = "1.10"
 humantime = "2.3"
 humantime-serde = "1.1.1"
 hyper = "1.11"

quest/m2/api-shape/README.md

@@ -60,5 +60,4 @@ Rejected in planning:
 ## Required
 
 - [moq-net's route stream goes public](/quest/m2/api-shape/net.md) - un-hide `origin::Consumer::routes` and reshape `RouteEvent`, now that #8063 merged
-- [Transports take shared types](/quest/m2/api-shape/transport.md) - moq-uring takes a congestion factory and rustls configs, and the tokio server request stops exposing its QUIC internals
 - [JS Key.sign takes exactly Claims](/quest/m2/api-shape/auth-sign.md) - `@moq/auth` signs only `Claims`, with no legacy `put`/`get` input, like Rust

quest/m4/perf/stream/codec.md

@@ -51,11 +51,8 @@ The subset to implement, from the 2026-10-22 audit:
 A maintained crate was weighed against this. The codec is small, sits on the
 hot path, and must write into the driver's buffers, so qmux owns it.
 
-Public API: the `tokio_tungstenite` and `tungstenite` types in
-`Client::with_config`, `Client::with_connector`, `Upgraded`, and
-`Error::WebSocket` go away. The Impact bullet says how to
-migrate in `qmux` and `moq-tokio`. The existing qmux interop tests (the `qmux06`
+Public API: none, since qmux already names no tungstenite type. The existing qmux interop tests (the `qmux06`
 dev-dependency) and the browser path in `js/qmux` must keep passing
 unchanged.
 
-Changed 2026-11-07 (maintainer, /quest-plan from the API sweep of open PRs and remaining quests): qmux's tungstenite exposure is removed before the cut in [api-shape/transport](/quest/m2/api-shape/transport.md), whatever this bench finds; this quest is perf-only.
+Changed 2026-11-07 (maintainer, /quest-plan from the API sweep of open PRs and remaining quests): qmux's tungstenite exposure is removed before the cut (done in [moq-dev/moq#8300](https://github.com/moq-dev/moq/pull/8300)), whatever this bench finds; this quest is perf-only.

rs/moq-relay/Cargo.toml

@@ -48,7 +48,7 @@ websocket = ["moq-tokio/websocket", "dep:qmux", "dep:hyper", "dep:tokio-tungsten
 uds = ["moq-tokio/uds"]
 # Serve QUIC from io_uring workers (`--runtime-io-uring`), Linux-only.
 # This is off by default: the relay is useful without io_uring.
-io-uring = ["_uring", "moq-uring/quic"]
+io-uring = ["_uring", "moq-tokio/driver", "moq-uring/quic"]
 # The listener machinery shared by the feature above.
 _uring = ["dep:moq-sock", "dep:moq-uring", "dep:web-transport-proto"]
 
@@ -92,7 +92,7 @@ sysinfo = { version = "0.40", default-features = false, features = ["system"] }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["full"] }
 tokio-rustls = { workspace = true }
-# Reclaims the socket under a WebSocket upgrade as a WebSocket stream.
+# The upgrade's accept key; qmux runs the frames after it.
 tokio-tungstenite = { workspace = true, features = ["connect", "handshake"], optional = true }
 toml = { workspace = true }
 tower-service = "0.3"

rs/moq-relay/src/incoming.rs

@@ -123,9 +123,9 @@ impl Sealed for moq_tokio::server::Request {
 
 	#[cfg(feature = "quic")]
 	fn pacer(&self) -> Option<auth::Pacer> {
-		let quic = moq_tokio::server::Request::quic(self)?.clone();
+		let quic = moq_tokio::server::Request::quic_limits(self)?;
 		Some(auth::Pacer::new(move |caps| {
-			if let Err(err) = quic.set_limits(caps.limits()) {
+			if let Err(err) = quic.set(caps.limits()) {
 				tracing::warn!(%err, "failed to apply bitrate caps");
 			}
 		}))

rs/moq-relay/src/uring.rs

@@ -484,11 +484,6 @@ fn transport(quic: &moq_tokio::quic::Resolved) -> anyhow::Result<moq_uring::quic
 		moq_net::transport::MIN_RECEIVE_WINDOW
 	);
 
-	anyhow::ensure!(
-		!quic.has_controller(),
-		"the io_uring runtime cannot run a custom congestion controller; drop quic.controller or use the tokio runtime"
-	);
-
 	let mut transport = moq_uring::quic::transport::Config::default();
 	#[cfg(feature = "qlog")]
 	if let Some(dir) = quic.qlog.as_deref() {
@@ -507,15 +502,17 @@ fn transport(quic: &moq_tokio::quic::Resolved) -> anyhow::Result<moq_uring::quic
 	transport.limits.receive_window = NonZeroU64::new(quic.receive_window);
 	transport.limits.stream_receive_window = NonZeroU64::new(quic.stream_receive_window);
 	transport.limits.send_window = NonZeroU64::new(quic.send_window);
-	transport.congestion = match quic.congestion_control {
-		Some(moq_tokio::quic::CongestionControl::Loss) => moq_uring::quic::Congestion::Loss,
+	transport.congestion = match (&quic.controller, quic.congestion_control) {
+		// The application's own controller wins over a family, as on the tokio path.
+		(Some(controller), _) => controller.0.clone(),
+		(None, Some(moq_tokio::quic::CongestionControl::Loss)) => moq_uring::quic::Congestion::Loss.into(),
 		// Unset means the backend's own default, and live media wants a steady
 		// send rate an encoder can track over CUBIC's sawtooth.
-		Some(moq_tokio::quic::CongestionControl::Delay) | None => moq_uring::quic::Congestion::Delay,
-		Some(moq_tokio::quic::CongestionControl::None) => moq_uring::quic::Congestion::None,
+		(None, Some(moq_tokio::quic::CongestionControl::Delay) | None) => moq_uring::quic::Congestion::Delay.into(),
+		(None, Some(moq_tokio::quic::CongestionControl::None)) => moq_uring::quic::Congestion::None.into(),
 		// A family added to the tokio stack later, rather than a silent
 		// substitution the operator would never learn about.
-		Some(other) => anyhow::bail!("io_uring workers cannot run the {other:?} congestion controller"),
+		(None, Some(other)) => anyhow::bail!("io_uring workers cannot run the {other:?} congestion controller"),
 	};
 	Ok(transport)
 }

rs/moq-relay/src/web.rs

@@ -2857,13 +2857,7 @@ mod tests {
 				"{}",
 				String::from_utf8_lossy(&response)
 			);
-			let socket = tokio_tungstenite::WebSocketStream::from_raw_socket(
-				stream,
-				tokio_tungstenite::tungstenite::protocol::Role::Client,
-				None,
-			)
-			.await;
-			let (transport, driver) = qmux::ws::Upgraded::new(socket, "qmux-01.moq-lite-06")
+			let (transport, driver) = qmux::ws::Upgraded::new(stream, "qmux-01.moq-lite-06")
 				.connect()
 				.await
 				.unwrap();