fix(moq-rtc): address review — keep ts/export parsing, docs, non_exhaustive configs

- Revert the `avcc_params`/`hvcc_params` delegation: the new typed `Avcc`/`Hvcc`
  parsers stay for moq-rtc, but the existing pub(crate) flatteners that MPEG-TS
  export relies on are restored verbatim, so ts/export output is byte-identical
  (the delegation had silently dropped non-VPS/SPS/PPS hvcC arrays and could
  reorder them). Also drops a duplicated doc comment.
- Add `#[non_exhaustive]` to the public `server::Config` / `client::Config` so
  future fields stay additive; build them via `Default` + field assignment.
- Document the public `codec::{h264,vp8,vp9,opus}::Bridge` items.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: kixelated

rs/moq-mux/src/codec/h264/mod.rs

@@ -180,13 +180,20 @@ pub(crate) fn build_avcc(sps_nals: &[Bytes], pps_nals: &[Bytes]) -> anyhow::Resu
 /// Extract the parameter-set NALs (SPS then PPS) and the NALU length size from
 /// an AVCDecoderConfigurationRecord. The inverse of [`build_avcc`]; used to
 /// re-emit out-of-band avc1 parameter sets as inline Annex-B (e.g. for MPEG-TS).
-/// The SPS+PPS NALs (in that order) and NALU length size, flattened for callers
-/// that re-emit every parameter set as one Annex-B prefix (e.g. MPEG-TS export).
 pub(crate) fn avcc_params(avcc: &[u8]) -> anyhow::Result<(usize, Vec<Bytes>)> {
-	let avcc = Avcc::parse(avcc)?;
-	let mut params = avcc.sps;
-	params.extend(avcc.pps);
-	Ok((avcc.length_size, params))
+	anyhow::ensure!(avcc.len() >= 6, "AVCDecoderConfigurationRecord too short");
+	let length_size = (avcc[4] & 0x03) as usize + 1;
+
+	let mut params = Vec::new();
+	let num_sps = avcc[5] & 0x1f;
+	let mut pos = read_param_set_array(avcc, 6, num_sps as usize, &mut params)?;
+
+	anyhow::ensure!(avcc.len() > pos, "avcC missing PPS count");
+	let num_pps = avcc[pos];
+	pos += 1;
+	read_param_set_array(avcc, pos, num_pps as usize, &mut params)?;
+
+	Ok((length_size, params))
 }
 
 /// Read `count` u16-length-prefixed NALs starting at `pos`, appending each to

rs/moq-mux/src/codec/h265/mod.rs

@@ -282,15 +282,34 @@ pub(crate) fn build_hvcc(vps_nals: &[Bytes], sps_nals: &[Bytes], pps_nals: &[Byt
 	Ok(out.freeze())
 }
 
-/// The VPS+SPS+PPS NALs (in that order) and NALU length size, flattened for
-/// callers that re-emit every parameter set as one Annex-B prefix (e.g. MPEG-TS
-/// export).
+/// Extract the parameter-set NALs (VPS, SPS, PPS in array order) and the NALU
+/// length size from an HEVCDecoderConfigurationRecord. The inverse of
+/// [`build_hvcc`]; used to re-emit out-of-band hvc1 parameter sets as inline
+/// Annex-B (e.g. for MPEG-TS).
 pub(crate) fn hvcc_params(hvcc: &[u8]) -> anyhow::Result<(usize, Vec<Bytes>)> {
-	let hvcc = Hvcc::parse(hvcc)?;
-	let mut params = hvcc.vps;
-	params.extend(hvcc.sps);
-	params.extend(hvcc.pps);
-	Ok((hvcc.length_size, params))
+	anyhow::ensure!(hvcc.len() >= 23, "HEVCDecoderConfigurationRecord too short");
+	let length_size = (hvcc[21] & 0x03) as usize + 1;
+	let num_arrays = hvcc[22];
+
+	let mut params = Vec::new();
+	let mut pos = 23;
+	for _ in 0..num_arrays {
+		// Skip the array_completeness | NAL_unit_type byte.
+		anyhow::ensure!(hvcc.len() >= pos + 3, "truncated hvcC NAL array header");
+		pos += 1;
+		let num_nalus = u16::from_be_bytes([hvcc[pos], hvcc[pos + 1]]);
+		pos += 2;
+		for _ in 0..num_nalus {
+			anyhow::ensure!(hvcc.len() >= pos + 2, "truncated hvcC NAL length");
+			let len = u16::from_be_bytes([hvcc[pos], hvcc[pos + 1]]) as usize;
+			pos += 2;
+			anyhow::ensure!(hvcc.len() >= pos + len, "hvcC NAL exceeds buffer");
+			params.push(Bytes::copy_from_slice(&hvcc[pos..pos + len]));
+			pos += len;
+		}
+	}
+
+	Ok((length_size, params))
 }
 
 /// The parameter sets carried out-of-band in an HEVCDecoderConfigurationRecord,

rs/moq-rtc/bin/moq-rtc.rs

@@ -185,10 +185,9 @@ async fn run_server(
 	tls_key: Option<PathBuf>,
 	direction: Direction,
 ) -> anyhow::Result<()> {
-	let config = moq_rtc::server::Config {
-		ice_candidates: public_addr,
-		udp_bind,
-	};
+	let mut config = moq_rtc::server::Config::default();
+	config.ice_candidates = public_addr;
+	config.udp_bind = udp_bind;
 	let server = Server::new(config, publisher, subscriber);
 
 	let app = match direction {
@@ -209,9 +208,8 @@ async fn run_client(
 	url: Url,
 	direction: Direction,
 ) -> anyhow::Result<()> {
-	let config = moq_rtc::client::Config {
-		ice_candidates: public_addr,
-	};
+	let mut config = moq_rtc::client::Config::default();
+	config.ice_candidates = public_addr;
 	let client = Client::new(config);
 
 	match direction {

rs/moq-rtc/src/client/mod.rs

@@ -15,6 +15,7 @@ use url::Url;
 
 /// Configuration shared by both `client publish` and `client subscribe`.
 #[derive(Clone, Debug, Default)]
+#[non_exhaustive]
 pub struct Config {
 	/// Public UDP socket addresses to advertise as ICE host candidates in
 	/// our outbound offer. Same semantics as [`crate::server::Config`].

rs/moq-rtc/src/codec/h264.rs

@@ -7,11 +7,13 @@
 
 use crate::{Result, codec};
 
+/// Feeds str0m's Annex-B H.264 access units into a moq-mux avc3 importer.
 pub struct Bridge {
 	import: moq_mux::codec::h264::Import<moq_mux::catalog::hang::Extra>,
 }
 
 impl Bridge {
+	/// Publish an `.avc3` track on `broadcast`, registering it in `catalog`.
 	pub fn new(broadcast: moq_net::BroadcastProducer, catalog: moq_mux::catalog::Producer) -> Result<Self> {
 		// Pin avc3 (Annex-B, inline SPS/PPS) up front: str0m always hands us that wire shape.
 		let import =

rs/moq-rtc/src/codec/opus.rs

@@ -5,11 +5,13 @@
 
 use crate::{Result, codec};
 
+/// Feeds str0m's Opus packets into a moq-mux Opus importer.
 pub struct Bridge {
 	import: moq_mux::codec::opus::Import,
 }
 
 impl Bridge {
+	/// Publish an `.opus` track on `broadcast` at the negotiated sample rate / channel count.
 	pub fn new(
 		mut broadcast: moq_net::BroadcastProducer,
 		catalog: moq_mux::catalog::Producer,

rs/moq-rtc/src/codec/vp8.rs

@@ -6,13 +6,15 @@
 
 use crate::{Result, codec};
 
+/// Forwards str0m's VP8 frames to a `.vp8` track, detecting keyframes inline.
 pub struct Bridge {
 	catalog: moq_mux::catalog::Producer,
 	track: moq_mux::container::Producer<moq_mux::catalog::hang::Container>,
 	announced: bool,
 }
 
 impl Bridge {
+	/// Publish a `.vp8` track on `broadcast`; the catalog rendition is added on the first frame.
 	pub fn new(mut broadcast: moq_net::BroadcastProducer, catalog: moq_mux::catalog::Producer) -> Result<Self> {
 		let track = broadcast.unique_track(".vp8")?;
 		let producer = moq_mux::container::Producer::new(track, moq_mux::catalog::hang::Container::Legacy);

rs/moq-rtc/src/codec/vp9.rs

@@ -5,13 +5,15 @@
 
 use crate::{Result, codec};
 
+/// Forwards str0m's VP9 frames to a `.vp9` track, detecting keyframes inline.
 pub struct Bridge {
 	catalog: moq_mux::catalog::Producer,
 	track: moq_mux::container::Producer<moq_mux::catalog::hang::Container>,
 	announced: bool,
 }
 
 impl Bridge {
+	/// Publish a `.vp9` track on `broadcast`; the catalog rendition is added on the first frame.
 	pub fn new(mut broadcast: moq_net::BroadcastProducer, catalog: moq_mux::catalog::Producer) -> Result<Self> {
 		let track = broadcast.unique_track(".vp9")?;
 		let producer = moq_mux::container::Producer::new(track, moq_mux::catalog::hang::Container::Legacy);

rs/moq-rtc/src/server/mod.rs

@@ -36,6 +36,7 @@ pub struct Response {
 
 /// Configuration shared by both `server publish` and `server subscribe`.
 #[derive(Clone, Debug)]
+#[non_exhaustive]
 pub struct Config {
 	/// Public UDP socket addresses that should be advertised as ICE host
 	/// candidates. Each is sent as a separate `candidate` line in the SDP