build(deps): bump the cargo group (with code fixes for rand/rubato/rcgen) (#1603)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Claude <noreply@anthropic.com>

Author: 3 people

Cargo.lock

@@ -52,15 +52,15 @@ moq-mux = { version = "0.5", path = "rs/moq-mux" }
 moq-native = { version = "0.16", path = "rs/moq-native", default-features = false }
 moq-net = { version = "0.1", path = "rs/moq-net" }
 moq-token = { version = "0.6", path = "rs/moq-token" }
-qmux = { version = "0.0.7", default-features = false }
+qmux = { version = "0.0.8", default-features = false }
 
 serde = { version = "1", features = ["derive"] }
 tokio = "1.48"
 web-async = { version = "0.1.3", features = ["tracing"] }
 web-transport-iroh = "0.5"
-web-transport-noq = "0.0.3"
+web-transport-noq = "0.1.1"
 web-transport-proto = "0.6"
-web-transport-quiche = "0.2"
+web-transport-quiche = "0.4"
 web-transport-quinn = "0.11"
 web-transport-trait = "0.3.4"
 

Cargo.toml

@@ -20,7 +20,9 @@ bytes = "1"
 hang = { workspace = true }
 moq-mux = { workspace = true }
 moq-net = { workspace = true }
-rubato = "0.16"
+# We only use the sinc resampler (Async::new_sinc), so skip the default
+# fft_resampler feature and its RustFFT/realfft dependencies.
+rubato = { version = "3.0", default-features = false }
 thiserror = "2"
 # Pure-Rust transpilation of libopus 1.3.1. No CMake toolchain, no C
 # linker hackery, and crucially still maintained, unlike the

rs/moq-audio/Cargo.toml

@@ -4,19 +4,21 @@
 //! producer/consumer doesn't have to convert to planar on every call.
 //! Currently sample-rate only; channel up/downmix is rejected upstream.
 
+use rubato::audioadapter_buffers::direct::SequentialSliceOfVecs;
 use rubato::{
-	Resampler as RubatoTrait, SincFixedIn, SincInterpolationParameters, SincInterpolationType, WindowFunction,
+	Async, FixedAsync, Resampler as RubatoTrait, SincInterpolationParameters, SincInterpolationType, WindowFunction,
 };
 
 use crate::AudioError;
 
 /// Sample-rate converter over interleaved `f32` PCM.
 pub struct Resampler {
-	resampler: SincFixedIn<f32>,
+	resampler: Async<f32>,
 	chunk_frames: usize,
 	channels: usize,
 	input_planar: Vec<Vec<f32>>,
 	output_planar: Vec<Vec<f32>>,
+	output_frames_max: usize,
 	pending: Vec<f32>,
 }
 
@@ -39,23 +41,26 @@ impl Resampler {
 			oversampling_factor: 128,
 			window: WindowFunction::BlackmanHarris2,
 		};
-		let resampler = SincFixedIn::<f32>::new(
+		let resampler = Async::<f32>::new_sinc(
 			output_rate as f64 / input_rate as f64,
 			1.0,
-			params,
+			&params,
 			chunk_frames,
 			channels as usize,
+			FixedAsync::Input,
 		)?;
 
 		let input_planar = (0..channels as usize).map(|_| vec![0.0f32; chunk_frames]).collect();
-		let output_planar = resampler.output_buffer_allocate(true);
+		let output_frames_max = resampler.output_frames_max();
+		let output_planar = vec![vec![0.0f32; output_frames_max]; channels as usize];
 
 		Ok(Self {
 			resampler,
 			chunk_frames,
 			channels: channels as usize,
 			input_planar,
 			output_planar,
+			output_frames_max,
 			pending: Vec::new(),
 		})
 	}
@@ -83,9 +88,12 @@ impl Resampler {
 				}
 			}
 
-			let (_, produced) =
-				self.resampler
-					.process_into_buffer(&self.input_planar, &mut self.output_planar, None)?;
+			let input = SequentialSliceOfVecs::new(&self.input_planar, self.channels, self.chunk_frames)
+				.expect("resampler input buffer dimensions");
+			let mut output =
+				SequentialSliceOfVecs::new_mut(&mut self.output_planar, self.channels, self.output_frames_max)
+					.expect("resampler output buffer dimensions");
+			let (_, produced) = self.resampler.process_into_buffer(&input, &mut output, None)?;
 
 			let prev_len = out.len();
 			out.resize(prev_len + produced * self.channels, 0.0);

rs/moq-audio/src/resample.rs

@@ -41,7 +41,7 @@ moq-net = { workspace = true, features = ["serde"] }
 parking_lot = { version = "0.12", features = ["deadlock_detection"] }
 qmux = { workspace = true, features = ["wss", "tls"], optional = true }
 quinn = { version = "0.11", default-features = false, features = ["platform-verifier", "runtime-tokio", "bloom"], optional = true }
-rand = "0.9.2"
+rand = "0.10.1"
 rcgen = { version = "0.14", default-features = false, optional = true }
 reqwest = { version = "0.12", default-features = false, optional = true }
 rustls = "0.23"
@@ -68,5 +68,5 @@ tracing-android = { version = "0.2", optional = true }
 [dev-dependencies]
 bytes = "1"
 chrono = "0.4"
-toml = "0.9"
+toml = "1.1"
 tracing-test = "0.2"

rs/moq-native/Cargo.toml

@@ -209,7 +209,9 @@ impl NoqServer {
 				nonce_len,
 				"using QUIC-LB compatible connection ID generation"
 			);
-			endpoint_config.cid_generator(move || Box::new(ServerIdGenerator::new(server_id.clone(), nonce_len)));
+			endpoint_config.cid_generator(Arc::new(move || {
+				Box::new(ServerIdGenerator::new(server_id.clone(), nonce_len))
+			}));
 		}
 
 		let socket = std::net::UdpSocket::bind(listen).context("failed to bind UDP socket")?;
@@ -272,14 +274,17 @@ impl NoqRequest {
 		let alpn = String::from_utf8(alpn).context("failed to decode ALPN")?;
 		let host = handshake.server_name.unwrap_or_default();
 
-		tracing::debug!(%host, ip = %conn.remote_address(), %alpn, "accepting");
+		// The established Connection no longer exposes a single peer address (noq 1.0
+		// supports multipath), so capture it from the Connecting before awaiting.
+		let remote = conn.remote_address();
+		tracing::debug!(%host, ip = %remote, %alpn, "accepting");
 
 		// Wait for the QUIC connection to be established.
 		let conn = conn.await.context("failed to establish QUIC connection")?;
 
 		let span = tracing::Span::current();
 		span.record("id", conn.stable_id());
-		tracing::debug!(%host, ip = %conn.remote_address(), %alpn, "accepted");
+		tracing::debug!(%host, ip = %remote, %alpn, "accepted");
 
 		match alpn.as_str() {
 			web_transport_noq::ALPN => {
@@ -367,7 +372,7 @@ impl ServerIdGenerator {
 
 impl noq::ConnectionIdGenerator for ServerIdGenerator {
 	fn generate_cid(&mut self) -> noq::ConnectionId {
-		use rand::Rng;
+		use rand::RngExt;
 		let cid_len = self.cid_len();
 		let mut cid = Vec::with_capacity(cid_len);
 		// First byte has "self-encoded length" of server ID + nonce

rs/moq-native/src/noq.rs

@@ -78,7 +78,10 @@ impl QuicheClient {
 				let conn = builder
 					.connect(&host, port)
 					.await
-					.context("failed to connect to quiche server")?;
+					.context("failed to connect to quiche server")?
+					.established()
+					.await
+					.context("failed to establish quiche connection")?;
 				let session = web_transport_quiche::Connection::connect(conn, request)
 					.await
 					.context("failed to connect to quiche server")?;
@@ -89,7 +92,10 @@ impl QuicheClient {
 				let conn = builder
 					.connect(&host, port)
 					.await
-					.context("failed to connect to quiche server")?;
+					.context("failed to connect to quiche server")?
+					.established()
+					.await
+					.context("failed to establish quiche connection")?;
 
 				let alpn = conn.alpn().context("missing ALPN")?;
 				let alpn = std::str::from_utf8(&alpn).context("failed to decode ALPN")?;

rs/moq-native/src/quiche.rs

@@ -403,7 +403,7 @@ impl ServerIdGenerator {
 
 impl quinn::ConnectionIdGenerator for ServerIdGenerator {
 	fn generate_cid(&mut self) -> quinn::ConnectionId {
-		use rand::Rng;
+		use rand::RngExt;
 		let cid_len = self.cid_len();
 		let mut cid = Vec::with_capacity(cid_len);
 		// First byte has "self-encoded length" of server ID + nonce

rs/moq-native/src/quinn.rs

@@ -21,7 +21,7 @@ bytes = "1"
 futures = "0.3"
 kio = { workspace = true }
 num_enum = "0.7"
-rand = "0.9.2"
+rand = "0.10.1"
 serde = { workspace = true, features = ["rc"] }
 serde_json = "1"
 thiserror = "2"

rs/moq-net/Cargo.toml

@@ -5,7 +5,7 @@ use std::{
 	task::Poll,
 };
 
-use rand::Rng;
+use rand::RngExt;
 use web_async::Lock;
 
 use super::BroadcastConsumer;