build(deps): bump the cargo group with 7 updates (#2888)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Luke Curley <kixelated@gmail.com>
Co-authored-by: OpenAI Codex <noreply@openai.com>

Author: 3 people

Cargo.lock

@@ -116,19 +116,19 @@ moq-vaapi = "0.0.3"
 # whole device graph into every one of them.
 moq-video = { version = "0.0.17", path = "rs/moq-video", default-features = false }
 percent-encoding = "2"
-qmux = { version = "0.4.0", default-features = false }
+qmux = { version = "0.5.0", default-features = false }
 serde = { version = "1", features = ["derive"] }
 tokio = "1.48"
 web-async = { version = "0.1.5", features = ["tracing"] }
-web-transport-iroh = "0.6"
+web-transport-iroh = "0.7"
 # default-features off so the QUIC crypto provider is chosen by moq-native's
 # aws-lc-rs / ring features (mirroring how the quinn dependency is wired).
-# 0.2.1 for the `qlog` passthrough feature moq-native's `qlog` forwards to.
-web-transport-noq = { version = "0.2.1", default-features = false }
+# Keep the `qlog` passthrough feature available for moq-native to forward.
+web-transport-noq = { version = "0.3.0", default-features = false }
 web-transport-proto = "0.6"
-web-transport-quiche = "0.5"
-web-transport-quinn = "0.11"
-web-transport-trait = "0.3.4"
+web-transport-quiche = "0.6"
+web-transport-quinn = "0.12"
+web-transport-trait = "0.4.0"
 
 [profile.dev]
 panic = "abort"

Cargo.toml

@@ -366,28 +366,17 @@ impl NoqClient {
 		.await?;
 		tracing::Span::current().record("id", connection.stable_id());
 
-		let mut request = web_transport_noq::proto::ConnectRequest::new(url.clone());
-		for alpn in versions.alpns() {
-			request = request.with_protocol(alpn.to_string());
-		}
-
 		let session = match url.scheme() {
-			"https" => web_transport_noq::Session::connect(connection, request)
-				.await
-				.map_err(map_client_error)?,
-			"moqt" | "moql" => {
-				let handshake = connection
-					.handshake_data()
-					.ok_or(Error::MissingHandshake)?
-					.downcast::<noq::crypto::rustls::HandshakeData>()
-					.unwrap();
-
-				let alpn = handshake.protocol.ok_or(Error::MissingAlpn)?;
-				let alpn = String::from_utf8(alpn)?;
-
-				let response = web_transport_noq::proto::ConnectResponse::OK.with_protocol(alpn);
-				web_transport_noq::Session::raw(connection, request, response)
+			"https" => {
+				let mut request = web_transport_noq::proto::ConnectRequest::new(url.clone());
+				for alpn in versions.alpns() {
+					request = request.with_protocol(alpn.to_string());
+				}
+				web_transport_noq::Session::connect(connection, request)
+					.await
+					.map_err(map_client_error)?
 			}
+			"moqt" | "moql" => web_transport_noq::Session::raw(connection),
 			_ => return Err(Error::UnsupportedScheme(url.scheme().to_string())),
 		};
 
@@ -654,22 +643,9 @@ pub(crate) async fn accept(
 		// this covers opt-in / work-in-progress versions (e.g. moq-lite-06-wip) that are
 		// deliberately absent from `moq_net::ALPNS`.
 		alpn if alpns.contains(&alpn) => {
-			// Raw QUIC carries no in-band request URL like WebTransport's CONNECT, so the TLS
-			// SNI is the only authority the client can offer, and it's optional. A client dialing
-			// a bare IP sends no SNI (RFC 6066 forbids IP literals), leaving `host` empty; the
-			// resulting hostless `moqt://` routes to the root path, exactly like a URL-less stream
-			// transport. `url()` returns `None` for the raw variant either way.
-			let host_str = if host.contains(':') {
-				format!("[{}]", host)
-			} else {
-				host.clone()
-			};
-			let url = format!("moqt://{}", host_str).parse::<Url>().map_err(Error::BuildUrl)?;
-			let request = web_transport_noq::proto::ConnectRequest::new(url);
-			let response = web_transport_noq::proto::ConnectResponse::OK.with_protocol(alpn);
 			let identity = crate::tls::PeerIdentity::from_any(conn.peer_identity());
 			// Raw QUIC carries no request URL; the path rides the SETUP.
-			let session = web_transport_noq::Session::raw(conn, request, response);
+			let session = web_transport_noq::Session::raw(conn);
 			Ok((session, None, identity))
 		}
 		_ => Err(Error::UnsupportedAlpn(alpn)),

rs/moq-native/src/noq.rs

@@ -379,28 +379,17 @@ impl QuinnClient {
 		.await?;
 		tracing::Span::current().record("id", connection.stable_id());
 
-		let mut request = web_transport_quinn::proto::ConnectRequest::new(url.clone());
-		for alpn in versions.alpns() {
-			request = request.with_protocol(alpn.to_string());
-		}
-
 		let session = match url.scheme() {
-			"https" => web_transport_quinn::Session::connect(connection, request)
-				.await
-				.map_err(map_client_error)?,
-			"moqt" | "moql" => {
-				let handshake = connection
-					.handshake_data()
-					.ok_or(Error::MissingHandshake)?
-					.downcast::<quinn::crypto::rustls::HandshakeData>()
-					.unwrap();
-
-				let alpn = handshake.protocol.ok_or(Error::MissingAlpn)?;
-				let alpn = String::from_utf8(alpn)?;
-
-				let response = web_transport_quinn::proto::ConnectResponse::OK.with_protocol(alpn);
-				web_transport_quinn::Session::raw(connection, request, response)
+			"https" => {
+				let mut request = web_transport_quinn::proto::ConnectRequest::new(url.clone());
+				for alpn in versions.alpns() {
+					request = request.with_protocol(alpn.to_string());
+				}
+				web_transport_quinn::Session::connect(connection, request)
+					.await
+					.map_err(map_client_error)?
 			}
+			"moqt" | "moql" => web_transport_quinn::Session::raw(connection),
 			_ => return Err(Error::UnsupportedScheme(url.scheme().to_string())),
 		};
 
@@ -666,22 +655,9 @@ pub(crate) async fn accept(
 		// this covers opt-in / work-in-progress versions (e.g. moq-lite-06-wip) that are
 		// deliberately absent from `moq_net::ALPNS`.
 		alpn if alpns.contains(&alpn) => {
-			// Raw QUIC carries no in-band request URL like WebTransport's CONNECT, so the TLS
-			// SNI is the only authority the client can offer, and it's optional. A client dialing
-			// a bare IP sends no SNI (RFC 6066 forbids IP literals), leaving `host` empty; the
-			// resulting hostless `moqt://` routes to the root path, exactly like a URL-less stream
-			// transport. `url()` returns `None` for the raw variant either way.
-			let host_str = if host.contains(':') {
-				format!("[{}]", host)
-			} else {
-				host.clone()
-			};
-			let url = format!("moqt://{}", host_str).parse::<Url>().map_err(Error::BuildUrl)?;
-			let request = web_transport_quinn::proto::ConnectRequest::new(url);
-			let response = web_transport_quinn::proto::ConnectResponse::OK.with_protocol(alpn);
 			let identity = crate::tls::PeerIdentity::from_any(conn.peer_identity());
 			// Raw QUIC carries no request URL; the path rides the SETUP.
-			let session = web_transport_quinn::Session::raw(conn, request, response);
+			let session = web_transport_quinn::Session::raw(conn);
 			Ok((session, None, identity))
 		}
 		_ => Err(Error::UnsupportedAlpn(alpn)),

rs/moq-native/src/quinn.rs

@@ -5,8 +5,8 @@
 //! a small head start ([`Client::delay`]), so WebSocket only wins when QUIC can't get
 //! through. Servers accept it on a separate TCP port via [`Listener`].
 
-use qmux::tokio_tungstenite;
-use qmux::tokio_tungstenite::tungstenite::{self, http};
+use qmux::ws::tokio_tungstenite;
+use qmux::ws::tokio_tungstenite::tungstenite::{self, http};
 use std::collections::HashSet;
 use std::sync::{Arc, LazyLock, Mutex};
 use std::{net, time};
@@ -188,10 +188,10 @@ pub(crate) async fn connect(
 	// restricts. qmux also offers the bare ALPNs (`qmux-01`, `qmux-00`,
 	// `webtransport`) by default so we still interop with relays that only know a
 	// wire-format version.
-	let session = qmux::Client::new()
+	let session = qmux::ws::Client::new()
 		.with_protocols(alpns.iter().map(|&a| (a, qmux_versions_for(a))))
 		.with_connector(connector)
-		.with_keep_alive(qmux::KeepAlive::default()) // 5s ping / 30s deadline, parity with QUIC
+		.with_keep_alive(qmux::ws::KeepAlive::default()) // 5s ping / 30s deadline, parity with QUIC
 		.connect(url.as_str())
 		.await
 		.map_err(Error::Connect)?;
@@ -202,7 +202,7 @@ pub(crate) async fn connect(
 	Ok(session)
 }
 
-/// The QMux drafts a moq ALPN is allowed to ride on, for `qmux::*::with_protocols`.
+/// The QMux drafts a moq ALPN is allowed to ride on, for `qmux::ws::Client::with_protocols`.
 ///
 /// moq-transport-18 and -19 require qmux-01, so we never pair them with qmux-00.
 /// This mirrors the policy in `js/net`'s `connect.ts`. Every other ALPN returns
@@ -349,7 +349,7 @@ impl Listener {
 				.unwrap()
 				.take()
 				.expect("successful upgrade selected a protocol");
-			let upgraded = qmux::ws::Upgraded::new(websocket).with_keep_alive(qmux::KeepAlive::default());
+			let upgraded = qmux::ws::Upgraded::new(websocket).with_keep_alive(qmux::ws::KeepAlive::default());
 			let session = match protocol {
 				Some(protocol) => upgraded.with_alpn(&protocol).accept(),
 				None => upgraded.accept(),