diff --git a/.gitignore b/.gitignore
index 7841c4680..aaf03e8b3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -19,16 +19,6 @@ result
 node_modules
 /.direnv
 
-# Don't leak dev stuff
-*.mp4
-*.fmp4
-*.crt
-*.key
-*.hex
-*.jwk
-*.jwt
-*.m3u8
-*.m4s
 
 # We're using bun
 package-lock.json
diff --git a/CLAUDE.md b/CLAUDE.md
index 7f090e198..ac037e796 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -116,6 +116,7 @@ match version {
 - Run `just fix` to automatically fix formating and easy things.
 - Rust tests are integrated within source files
 - Async tests that sleep should call `tokio::time::pause()` at the start to simulate time instantly
+- Use `tokio::time::sleep()` (not `advance()`) to move time forward in paused-time tests — `sleep` both advances the clock and yields to the runtime so spawned tasks can run
 
 ## Branching Strategy
 
@@ -123,6 +124,7 @@ match version {
 - **`dev`**: Development branch for breaking API changes. PRs with major API changes should target `dev`.
 - When ready for a new minor/major release, merge `dev` into `main`.
 - `cargo-semver-checks` enforces this on PRs to `main`.
+- When removing a public method on `dev`, mark it `#[deprecated]` first so downstream code gets warnings before the next breaking release.
 
 ## Workflow
 
diff --git a/Cargo.lock b/Cargo.lock
index 1d1f97781..a44fb5be4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -737,9 +737,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.58"
+version = "1.2.59"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1e928d4b69e3077709075a938a05ffbedfa53a84c8f766efbf8220bb1ff60e1"
+checksum = "b7a4d3ec6524d28a329fc53654bbadc9bdd7b0431f5d65f1a56ffb28a1ee5283"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -2217,6 +2217,7 @@ dependencies = [
  "hex",
  "lazy_static",
  "moq-lite",
+ "moq-mux",
  "moq-native",
  "regex",
  "serde",
@@ -3167,6 +3168,7 @@ dependencies = [
  "moq-lite",
  "moq-mux",
  "moq-native",
+ "serde_json",
  "thiserror 2.0.18",
  "tokio",
  "tracing",
@@ -3393,10 +3395,12 @@ dependencies = [
  "anyhow",
  "axum",
  "axum-server",
+ "base64 0.22.1",
  "clap",
  "hang",
  "moq-mux",
  "moq-native",
+ "mp4-atom",
  "rustls",
  "sd-notify",
  "tokio",
@@ -3433,6 +3437,7 @@ dependencies = [
  "moq-mux",
  "moq-native",
  "pollster",
+ "serde_json",
  "thiserror 2.0.18",
  "tokio",
  "tracing",
@@ -3486,6 +3491,8 @@ dependencies = [
  "reqwest",
  "scuffle-av1",
  "scuffle-h265",
+ "serde",
+ "serde_json",
  "thiserror 2.0.18",
  "tokio",
  "tracing",
@@ -6247,9 +6254,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.50.0"
+version = "1.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27ad5e34374e03cfffefc301becb44e9dc3c17584f414349ebe29ed26661822d"
+checksum = "2bd1c4c0fc4a7ab90fc15ef6daaa3ec3b893f004f915f2392557ed23237820cd"
 dependencies = [
  "bytes",
  "libc",
@@ -6265,9 +6272,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-macros"
-version = "2.6.1"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c55a2eff8b69ce66c84f85e1da1c233edc36ceb85a2058d11b0d6a3c7e7569c"
+checksum = "385a6cb71ab9ab790c5fe8d67f1645e6c450a7ce006a33de03daa956cf70a496"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/bun.lock b/bun.lock
index a5841d5f8..3bea58490 100644
--- a/bun.lock
+++ b/bun.lock
@@ -1,6 +1,5 @@
 {
   "lockfileVersion": 1,
-  "configVersion": 1,
   "workspaces": {
     "": {
       "name": "moq",
@@ -167,7 +166,7 @@
     },
     "js/token": {
       "name": "@moq/token",
-      "version": "0.1.2",
+      "version": "0.2.0",
       "bin": {
         "moq-token": "./src/cli.ts",
       },
@@ -208,6 +207,7 @@
         "@moq/lite": "workspace:^",
         "@moq/signals": "workspace:^",
         "@moq/ui-core": "workspace:^",
+        "zod": "^4.1.5",
       },
       "devDependencies": {
         "@types/audioworklet": "^0.0.77",
@@ -1669,7 +1669,7 @@
 
     "unified-args/chalk": ["chalk@5.6.2", "", {}, "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA=="],
 
-    "unified-engine/@types/node": ["@types/node@22.19.15", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-F0R/h2+dsy5wJAUe3tAU6oqa2qbWY5TpNfL/RGmo1y38hiyO1w3x2jPtt76wmuaJI4DQnOBu21cNXQ2STIUUWg=="],
+    "unified-engine/@types/node": ["@types/node@22.19.17", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-wGdMcf+vPYM6jikpS/qhg6WiqSV/OhG+jeeHT/KlVqxYfD40iYJf9/AE1uQxVWFvU7MipKRkRv8NSHiCGgPr8Q=="],
 
     "unified-engine/glob": ["glob@10.5.0", "", { "dependencies": { "foreground-child": "^3.1.0", "jackspeak": "^3.1.2", "minimatch": "^9.0.4", "minipass": "^7.1.2", "package-json-from-dist": "^1.0.0", "path-scurry": "^1.11.1" }, "bin": { "glob": "dist/esm/bin.mjs" } }, "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg=="],
 
diff --git a/cdn/input.tf b/cdn/input.tf
index 64187d887..51b7e7aee 100644
--- a/cdn/input.tf
+++ b/cdn/input.tf
@@ -36,17 +36,25 @@ variable "webhook" {
 # instance types: https://api.linode.com/v4/linode/types
 locals {
   relays = {
-    usc = {
-      region = "us-central"    # Dallas, TX
-      type   = "g6-standard-2" # 4GB RAM, 2 vCPU, $24/mo, 4TB out
+    usw = {
+      region  = "us-west"       # Fremont, CA
+      type    = "g6-standard-2" # 4GB RAM, 2 vCPU, $24/mo, 4TB out
+      connect = ["use"]
+    }
+    use = {
+      region  = "us-east" # Newark, NJ
+      type    = "g6-standard-2"
+      connect = ["usw", "euc"]
     }
     euc = {
-      region = "eu-central" # Frankfurt, Germany
-      type   = "g6-standard-2"
+      region  = "eu-central" # Frankfurt, Germany
+      type    = "g6-standard-2"
+      connect = ["use"]
     }
     sea = {
-      region = "ap-south" # Singapore
-      type   = "g6-standard-2"
+      region  = "ap-south" # Singapore
+      type    = "g6-standard-2"
+      connect = ["use"]
     }
   }
 }
diff --git a/cdn/main.tf b/cdn/main.tf
index 34121ffea..7b505350b 100644
--- a/cdn/main.tf
+++ b/cdn/main.tf
@@ -68,6 +68,7 @@ module "relay" {
 module "pub" {
   source          = "./pub"
   domain          = var.domain
+  relay           = "use.${var.domain}"
   ssh_keys        = var.ssh_keys
   stackscript_id  = linode_stackscript.bootstrap.id
   gcp_account_key = google_service_account_key.relay.private_key
diff --git a/cdn/pub/demo-bbb.service.tftpl b/cdn/pub/demo-bbb.service.tftpl
index fbfec0a6b..a42240730 100644
--- a/cdn/pub/demo-bbb.service.tftpl
+++ b/cdn/pub/demo-bbb.service.tftpl
@@ -23,7 +23,7 @@ ExecStart=/bin/bash -c '\
     -movflags cmaf+separate_moof+delay_moov+skip_trailer+frag_every_frame \
     - | \
   /var/lib/moq/pkg/bin/moq-cli publish \
-    --url "https://${domain}/demo?jwt=$(cat /var/lib/moq/demo-pub.jwt)" \
+    --url "https://${relay}/demo?jwt=$(cat /var/lib/moq/demo-pub.jwt)" \
     --name bbb \
     fmp4'
 
diff --git a/cdn/pub/main.tf b/cdn/pub/main.tf
index 860f80240..23c9207ba 100644
--- a/cdn/pub/main.tf
+++ b/cdn/pub/main.tf
@@ -1,7 +1,7 @@
 # Generate systemd service files from templates
 resource "local_file" "demo_bbb_service" {
   content = templatefile("${path.module}/demo-bbb.service.tftpl", {
-    domain = var.domain
+    relay = var.relay
   })
   filename = "${path.module}/gen/demo-bbb.service"
 }
@@ -9,7 +9,7 @@ resource "local_file" "demo_bbb_service" {
 # Publisher instance
 resource "linode_instance" "publisher" {
   label  = "publisher-moq"
-  region = "us-central" # Dallas, TX
+  region = "us-east" # Newark, NJ (colocated with use relay)
   type   = "g6-nanode-1"
 
   # Use Debian 12 as base, will be converted to NixOS via bootstrap
diff --git a/cdn/pub/variables.tf b/cdn/pub/variables.tf
index 05b348484..b5a5ace33 100644
--- a/cdn/pub/variables.tf
+++ b/cdn/pub/variables.tf
@@ -3,6 +3,11 @@ variable "domain" {
   type        = string
 }
 
+variable "relay" {
+  description = "Relay hostname to publish to (e.g. use.example.com)"
+  type        = string
+}
+
 variable "ssh_keys" {
   description = "SSH public keys for root access"
   type        = list(string)
diff --git a/cdn/relay/dns.tf b/cdn/relay/dns.tf
index 4056c3e05..cded1c990 100644
--- a/cdn/relay/dns.tf
+++ b/cdn/relay/dns.tf
@@ -32,7 +32,8 @@ resource "google_dns_record_set" "relay_global" {
 # GCP uses region codes like "us-east1", "us-west1", "europe-west3", "asia-southeast1"
 locals {
   relay_gcp_regions = {
-    usc = "us-central1"     # Dallas, TX -> closest GCP region
+    usw = "us-west1"        # Fremont, CA -> closest GCP region
+    use = "us-east1"        # Newark, NJ -> closest GCP region
     euc = "europe-west3"    # Frankfurt -> closest GCP region
     sea = "asia-southeast1" # Singapore -> closest GCP region
   }
diff --git a/cdn/relay/justfile b/cdn/relay/justfile
index a3c72c478..cbc218b33 100644
--- a/cdn/relay/justfile
+++ b/cdn/relay/justfile
@@ -26,13 +26,14 @@ host node:
 
 # List the available nodes.
 nodes:
-	@echo "usc: Dallas, TX"
+	@echo "usw: Fremont, CA"
+	@echo "use: Newark, NJ"
 	@echo "euc: Frankfurt, Germany"
 	@echo "sea: Singapore"
 
 # Deploy moq-relay and moq-cert to all nodes
 [parallel]
-deploy-all: (deploy "usc") (deploy "euc") (deploy "sea")
+deploy-all: (deploy "usw") (deploy "use") (deploy "euc") (deploy "sea")
 
 # Deploy moq-relay and moq-cert to a specific node
 deploy node:
@@ -78,7 +79,7 @@ status node:
 	echo "=== $HOST ==="
 	ssh root@$HOST "systemctl status moq-relay --no-pager"
 
-status-all: (status "usc") (status "euc") (status "sea")
+status-all: (status "usw") (status "use") (status "euc") (status "sea")
 
 ssh node:
 	#!/usr/bin/env bash
diff --git a/cdn/relay/main.tf b/cdn/relay/main.tf
index 05ff209cf..1a5f8c259 100644
--- a/cdn/relay/main.tf
+++ b/cdn/relay/main.tf
@@ -1,9 +1,12 @@
-# Generate systemd service files from templates
+# Generate per-node systemd service files from templates
 resource "local_file" "moq_relay_service" {
+  for_each = var.relays
+
   content = templatefile("${path.module}/moq-relay.service.tftpl", {
-    domain = var.domain
+    domain  = var.domain
+    connect = each.value.connect
   })
-  filename = "${path.module}/gen/moq-relay.service"
+  filename = "${path.module}/gen/${each.key}/moq-relay.service"
 }
 
 resource "local_file" "moq_cert_service" {
diff --git a/cdn/relay/moq-relay.service.tftpl b/cdn/relay/moq-relay.service.tftpl
index 8fe247453..d934d05e4 100644
--- a/cdn/relay/moq-relay.service.tftpl
+++ b/cdn/relay/moq-relay.service.tftpl
@@ -20,7 +20,9 @@ ExecStart=/var/lib/moq/pkg/bin/moq-relay \
   --web-https-listen [::]:443 \
   --web-https-cert /etc/letsencrypt/live/${domain}/fullchain.pem \
   --web-https-key /etc/letsencrypt/live/${domain}/privkey.pem \
-  --cluster-root usc.${domain} \
+%{ for peer in connect ~}
+  --cluster-connect ${peer}.${domain} \
+%{ endfor ~}
   --cluster-node %H \
   --cluster-token /var/lib/moq/cluster.jwt
 
diff --git a/cdn/relay/variables.tf b/cdn/relay/variables.tf
index 7be566435..e69728a97 100644
--- a/cdn/relay/variables.tf
+++ b/cdn/relay/variables.tf
@@ -16,8 +16,9 @@ variable "ssh_keys" {
 variable "relays" {
   description = "Map of relay node configurations"
   type = map(object({
-    region = string
-    type   = string
+    region  = string
+    type    = string
+    connect = list(string)
   }))
 }
 
diff --git a/dev/.gitignore b/dev/.gitignore
new file mode 100644
index 000000000..c6c8158db
--- /dev/null
+++ b/dev/.gitignore
@@ -0,0 +1,9 @@
+*.mp4
+*.fmp4
+*.crt
+*.key
+*.hex
+*.jwk
+*.jwt
+*.m3u8
+*.m4s
diff --git a/dev/boy/src/audio.rs b/dev/boy/src/audio.rs
index e992f4551..d29ac7082 100644
--- a/dev/boy/src/audio.rs
+++ b/dev/boy/src/audio.rs
@@ -4,7 +4,7 @@ use anyhow::{Context, Result};
 ///
 /// Uses ffmpeg-next for Opus encoding (same dependency as video H.264).
 pub struct AudioEncoder {
-    opus: moq_mux::import::Opus,
+    opus: moq_mux::producer::Opus,
     ffmpeg_encoder: ffmpeg_next::encoder::audio::Encoder,
     resampler: Option<ffmpeg_next::software::resampling::Context>,
     sample_buffer: Vec<i16>,
@@ -26,10 +26,10 @@ impl AudioEncoder {
         catalog: moq_mux::CatalogProducer,
         input_sample_rate: u32,
     ) -> Result<Self> {
-        let opus = moq_mux::import::Opus::new(
+        let opus = moq_mux::producer::Opus::new(
             broadcast,
             catalog,
-            moq_mux::import::OpusConfig {
+            moq_mux::producer::OpusConfig {
                 sample_rate: OPUS_SAMPLE_RATE,
                 channel_count: CHANNELS,
             },
diff --git a/dev/boy/src/index.ts b/dev/boy/src/index.ts
index 3d33f989f..b77783107 100644
--- a/dev/boy/src/index.ts
+++ b/dev/boy/src/index.ts
@@ -195,7 +195,7 @@ class GameCard {
 		const sync = new Watch.Sync({ jitter: 50 as Moq.Time.Milli });
 		this.#signals.cleanup(() => sync.close());
 
-		const videoSource = new Watch.Video.Source(sync, { broadcast });
+		const videoSource = new Watch.Video.Source({ sync, broadcast });
 		this.#signals.cleanup(() => videoSource.close());
 
 		// Set pixel budget based on expanded state.
@@ -220,7 +220,7 @@ class GameCard {
 		this.#signals.cleanup(() => videoRenderer.close());
 
 		// Set up audio — play on hover at 50% volume.
-		const audioSource = new Watch.Audio.Source(sync, { broadcast });
+		const audioSource = new Watch.Audio.Source({ sync, broadcast });
 		this.#signals.cleanup(() => audioSource.close());
 
 		const audioDecoder = new Watch.Audio.Decoder(audioSource);
diff --git a/dev/boy/src/input.rs b/dev/boy/src/input.rs
index 1947afe4e..666eb99fb 100644
--- a/dev/boy/src/input.rs
+++ b/dev/boy/src/input.rs
@@ -40,33 +40,21 @@ pub async fn handle_viewers(
     cmd_tx: &tokio::sync::mpsc::Sender<Command>,
 ) -> anyhow::Result<()> {
     loop {
-        let Some((path, broadcast)) = viewer_origin.announced().await else {
-            break;
-        };
+        let (path, broadcast) = viewer_origin.announced().await?;
 
         let viewer_id = path.to_string();
 
-        if let Some(broadcast) = broadcast {
-            tracing::info!(%viewer_id, "viewer connected");
-            let cmd_tx = cmd_tx.clone();
-            let vid = viewer_id.clone();
-            tokio::spawn(async move {
-                if let Err(e) = handle_viewer_commands(&vid, broadcast, &cmd_tx).await {
-                    tracing::warn!(viewer_id = %vid, error = %e, "viewer command error");
-                }
-                tracing::info!(viewer_id = %vid, "viewer disconnected");
-                let _ = cmd_tx.send(Command::ViewerLeft { viewer_id: vid }).await;
-            });
-        } else {
-            tracing::info!(%viewer_id, "viewer went offline");
-            let _ = cmd_tx
-                .send(Command::ViewerLeft {
-                    viewer_id: viewer_id.clone(),
-                })
-                .await;
-        }
+        tracing::info!(%viewer_id, "viewer connected");
+        let cmd_tx = cmd_tx.clone();
+        let vid = viewer_id.clone();
+        tokio::spawn(async move {
+            if let Err(e) = handle_viewer_commands(&vid, broadcast, &cmd_tx).await {
+                tracing::warn!(viewer_id = %vid, error = %e, "viewer command error");
+            }
+            tracing::info!(viewer_id = %vid, "viewer disconnected");
+            let _ = cmd_tx.send(Command::ViewerLeft { viewer_id: vid }).await;
+        });
     }
-    Ok(())
 }
 
 async fn handle_viewer_commands(
@@ -74,12 +62,10 @@ async fn handle_viewer_commands(
     broadcast: moq_lite::BroadcastConsumer,
     cmd_tx: &tokio::sync::mpsc::Sender<Command>,
 ) -> anyhow::Result<()> {
-    let command_track = moq_lite::Track {
-        name: "command".to_string(),
-        priority: 0,
-    };
+    let command_track = moq_lite::Track::new("command");
+    let sub = moq_lite::Subscription::default();
 
-    let mut track = broadcast.subscribe_track(&command_track)?;
+    let mut track = broadcast.subscribe_track(&command_track, sub)?;
 
     while let Some(mut group) = track.next_group().await? {
         while let Some(frame) = group.read_frame().await? {
diff --git a/dev/boy/src/main.rs b/dev/boy/src/main.rs
index 5b45d40d9..19fc666ff 100644
--- a/dev/boy/src/main.rs
+++ b/dev/boy/src/main.rs
@@ -54,7 +54,7 @@ async fn run(config: &Config) -> Result<()> {
     let client = config.client.clone().init()?;
 
     // Create the broadcast producer.
-    let mut broadcast = moq_lite::BroadcastProducer::default();
+    let broadcast = moq_lite::BroadcastProducer::default();
 
     // Publish origin: the GB session broadcast.
     let publish_origin = moq_lite::Origin::produce();
@@ -78,14 +78,11 @@ async fn run(config: &Config) -> Result<()> {
         .await?;
 
     // Set up catalog and video encoder.
-    let catalog = moq_mux::CatalogProducer::new(&mut broadcast)?;
+    let catalog = moq_mux::CatalogProducer::new(&broadcast)?;
     let video_encoder = video::VideoEncoder::spawn(broadcast.clone(), catalog.clone());
 
     // Create status track.
-    let status_track = moq_lite::Track {
-        name: "status".to_string(),
-        priority: 10,
-    };
+    let status_track = moq_lite::Track::new("status");
     let mut status_producer = broadcast.create_track(status_track)?;
 
     // Run the emulator on a blocking thread.
@@ -219,7 +216,7 @@ async fn run(config: &Config) -> Result<()> {
 #[tokio::main]
 async fn main() -> Result<()> {
     let config = Config::parse();
-    config.log.init();
+    let _ = config.log.init();
 
     tokio::select! {
         res = run(&config) => res,
diff --git a/dev/boy/src/video.rs b/dev/boy/src/video.rs
index 614fcb63e..542d2f0ff 100644
--- a/dev/boy/src/video.rs
+++ b/dev/boy/src/video.rs
@@ -23,7 +23,7 @@ impl VideoEncoder {
         catalog: moq_mux::CatalogProducer,
     ) -> Self {
         let (tx, rx) = tokio::sync::mpsc::channel(4);
-        let avc3 = moq_mux::import::Avc3::new(broadcast, catalog);
+        let avc3 = moq_mux::producer::Avc3::new(broadcast, catalog);
 
         let thread = std::thread::Builder::new()
             .name("video-encoder".into())
@@ -44,7 +44,7 @@ impl VideoEncoder {
 
 fn encoder_thread(
     mut rx: tokio::sync::mpsc::Receiver<EncoderMsg>,
-    mut avc3: moq_mux::import::Avc3,
+    mut avc3: moq_mux::producer::Avc3,
 ) {
     let mut encoder: Option<Encoder> = None;
     let mut scaler: Option<ffmpeg_next::software::scaling::Context> = None;
@@ -173,7 +173,7 @@ impl Encoder {
         &mut self,
         yuv: &ffmpeg_next::frame::Video,
         ts: hang::container::Timestamp,
-        output: &mut moq_mux::import::Avc3,
+        output: &mut moq_mux::producer::Avc3,
     ) -> Result<()> {
         self.encoder.send_frame(yuv)?;
 
diff --git a/dev/relay/leaf0.toml b/dev/relay/leaf0.toml
index 833341cea..966f16bd0 100644
--- a/dev/relay/leaf0.toml
+++ b/dev/relay/leaf0.toml
@@ -16,35 +16,16 @@ tls.generate = ["localhost"]
 # Listen for HTTP and WebSocket (TCP) connections on the given address.
 listen = "[::]:4444"
 
-# This clustering scheme is very very simple for now.
-#
-# There is a root node that is used to connect leaf nodes together.
-# Announcements flow from leaf -> root -> leaf, but any subscriptions are leaf -> leaf.
-# The root node can serve (user) subscriptions too.
-#
-# The root node is either missing the "root" field below or it's identifical to the "node" field.
-# This node acts a server only, accepting incoming connections from leaf nodes and users alike.
-#
-# There can be any number of leaf nodes.
-# These nodes will connect to the specified root address and announce themselves via MoQ as a "broadcast".
-# All nodes will discover these broadcasts and connect to other nodes.
-#
-# This forms an NxN mesh of nodes.
-# Broadcasts are announced between all nodes with no collision detection, so duplicates are possible.
-# Subscriptions will be relayed from leaf to leaf, so at most you can have:
-#  user -> leaf -> leaf -> user
+# Clustering: connect to the root node.
+# In this example, leaf nodes don't connect directly to each other; traffic gets proxied through the root.
+# `connect` can be an array to connect to multiple peers, creating a tiered CDN.
 [cluster]
-# Connect to this hostname in order to discover other nodes.
 connect = "localhost:4443"
 
 # Use the token in this file when connecting to other nodes.
 # `just auth-token` will populate this file.
 token = "root.jwt"
 
-# My hostname, which must be accessible from other nodes.
-node = "localhost:4444"
-
-# Each leaf node will connect to the root node and other nodes, using this configuration.
 [client]
 # QUIC uses TLS to have the client verify the server's identity.
 # However if you're not worried about man-in-the-middle attacks, you can disable verification:
diff --git a/dev/relay/leaf1.toml b/dev/relay/leaf1.toml
index 33fa1f7da..392954b6c 100644
--- a/dev/relay/leaf1.toml
+++ b/dev/relay/leaf1.toml
@@ -16,35 +16,16 @@ tls.generate = ["localhost"]
 # Listen for HTTP and WebSocket (TCP) connections on the given address.
 listen = "[::]:4445"
 
-# This clustering scheme is very very simple for now.
-#
-# There is a root node that is used to connect leaf nodes together.
-# Announcements flow from leaf -> root -> leaf, but any subscriptions are leaf -> leaf.
-# The root node can serve (user) subscriptions too.
-#
-# The root node is either missing the "root" field below or it's identical to the "node" field.
-# This node acts a server only, accepting incoming connections from leaf nodes and users alike.
-#
-# There can be any number of leaf nodes.
-# These nodes will connect to the specified root address and announce themselves via MoQ as a "broadcast".
-# All nodes will discover these broadcasts and connect to other nodes.
-#
-# This forms an NxN mesh of nodes.
-# Broadcasts are announced between all nodes with no collision detection, so duplicates are possible.
-# Subscriptions will be relayed from leaf to leaf, so at most you can have:
-#  user -> leaf -> leaf -> user
+# Clustering: connect to the root node.
+# In this example, leaf nodes don't connect directly to each other; traffic gets proxied through the root.
+# `connect` can be an array to connect to multiple peers, creating a tiered CDN.
 [cluster]
-# Connect to this hostname in order to discover other nodes.
 connect = "localhost:4443"
 
 # Use the token in this file when connecting to other nodes.
 # `just auth-token` will populate this file.
 token = "root.jwt"
 
-# My hostname, which must be accessible from other nodes.
-node = "localhost:4445"
-
-# Each leaf node will connect to the root node and other nodes, using this configuration.
 [client]
 # QUIC uses TLS to have the client verify the server's identity.
 # However if you're not worried about man-in-the-middle attacks, you can disable verification:
diff --git a/doc/js/@moq/lite.md b/doc/js/@moq/lite.md
index e1cb6b07f..577aab0a9 100644
--- a/doc/js/@moq/lite.md
+++ b/doc/js/@moq/lite.md
@@ -81,7 +81,7 @@ if (request) {
 
     // Read data as it arrives
     for (;;) {
-        const group = await track.nextGroup();
+        const group = await track.recvGroup();
         if (!group) break;
 
         for (;;) {
diff --git a/doc/rs/crate/libmoq.md b/doc/rs/crate/libmoq.md
index 09ff47c9d..360dcf39d 100644
--- a/doc/rs/crate/libmoq.md
+++ b/doc/rs/crate/libmoq.md
@@ -7,15 +7,19 @@ description: C bindings for MoQ
 
 [![docs.rs](https://docs.rs/libmoq/badge.svg)](https://docs.rs/libmoq)
 
-C bindings for `moq-lite` via FFI, enabling MoQ integration in C/C++ applications and other languages.
+C bindings for MoQ via FFI, providing media publish/subscribe functionality for C/C++ applications and other languages.
 
 ## Overview
 
-`libmoq` provides:
+`libmoq` provides a C API for real-time media delivery over QUIC. It wraps the Rust [moq-lite](/rs/crate/moq-lite) and [moq-mux](/rs/crate/moq-mux) crates, handling:
 
-- **C API** - Header files for C integration
-- **FFI bindings** - Safe Rust-to-C interface
-- **Build system integration** - CMake and pkg-config support
+- **Sessions** - QUIC/WebTransport connections to MoQ relays
+- **Origins** - Containers for broadcast discovery and routing
+- **Publishing** - Encoding and sending audio/video tracks
+- **Consuming** - Receiving, decoding, and rendering media tracks
+- **Catalogs** - Discovering available audio/video renditions
+
+All functions use opaque integer handles to reference resources. Negative return values indicate errors, zero indicates success, and positive values are resource handles.
 
 ## Installation
 
@@ -27,76 +31,183 @@ cd moq/rs/libmoq
 cargo build --release
 ```
 
-The library will be in `target/release/libmoq.a` (static) or `target/release/libmoq.so` (dynamic).
+The static library will be at `target/release/libmoq.a`.
+
+### Linking
+
+With CMake:
 
-### Using Cargo
+```cmake
+find_package(moq REQUIRED)
+target_link_libraries(myapp moq)
+```
+
+With pkg-config:
 
 ```bash
-cargo install libmoq
+gcc -o myapp myapp.c $(pkg-config --cflags --libs moq)
 ```
 
-## Usage
+## API
 
-### C Header
+### Initialization
 
-```c
-#include <moq.h>
+| Function | Description |
+|----------|-------------|
+| `moq_log_level(level, level_len)` | Set log level: `"error"`, `"warn"`, `"info"`, `"debug"`, `"trace"` |
 
-int main() {
-    // Initialize connection
-    moq_connection_t* conn = moq_connect("https://relay.example.com/demo");
-    if (!conn) {
-        fprintf(stderr, "Failed to connect\n");
-        return 1;
-    }
+### Sessions
 
-    // Create broadcast
-    moq_broadcast_t* broadcast = moq_broadcast_new("my-broadcast");
+Connect to a MoQ relay server over QUIC/WebTransport.
 
-    // Create track
-    moq_track_t* track = moq_track_new(broadcast, "chat");
+| Function | Description |
+|----------|-------------|
+| `moq_session_connect(url, url_len, origin_publish, origin_consume, on_status, user_data)` | Connect to a relay. Provide origin handles for publish/consume, or `0` to disable. Calls `on_status` on connect (code 0) and close (code non-zero). |
+| `moq_session_close(session)` | Close a session and cancel its background task. |
 
-    // Publish data
-    moq_group_t* group = moq_group_append(track);
-    moq_frame_write(group, "Hello, MoQ!", 11);
-    moq_group_close(group);
+### Origins
 
-    // Publish to relay
-    moq_publish(conn, broadcast);
+Origins group broadcasts by path. They can be shared across sessions for fanout/relaying.
 
-    // Cleanup
-    moq_broadcast_free(broadcast);
-    moq_connection_free(conn);
+| Function | Description |
+|----------|-------------|
+| `moq_origin_create()` | Create a new origin. |
+| `moq_origin_publish(origin, path, path_len, broadcast)` | Publish a broadcast to an origin at the given path. |
+| `moq_origin_consume(origin, path, path_len)` | Consume a broadcast from an origin by path. Returns a broadcast handle. |
+| `moq_origin_announced(origin, on_announce, user_data)` | Discover broadcasts published to an origin. Calls `on_announce` with an announced ID for each broadcast. |
+| `moq_origin_announced_info(announced, dst)` | Query the path and active status of an announced broadcast. |
+| `moq_origin_announced_close(announced)` | Stop listening for announcements. |
+| `moq_origin_close(origin)` | Close an origin. |
 
-    return 0;
-}
-```
+### Publishing
 
-### Linking
+Create broadcasts and write media frames.
 
-With CMake:
+| Function | Description |
+|----------|-------------|
+| `moq_publish_create()` | Create a new broadcast for publishing. |
+| `moq_publish_media_ordered(broadcast, format, format_len, init, init_size)` | Add a media track to a broadcast. `format` specifies the encoding. `init` is codec-specific initialization data. |
+| `moq_publish_media_frame(media, payload, payload_size, timestamp_us)` | Write a frame to a media track. Frames must be in decode order. Timestamp is in microseconds. |
+| `moq_publish_media_close(media)` | Remove a media track from a broadcast. |
+| `moq_publish_close(broadcast)` | Close a broadcast. |
 
-```cmake
-find_package(moq REQUIRED)
-target_link_libraries(myapp moq)
+### Consuming
+
+Subscribe to broadcasts and receive decoded media frames.
+
+| Function | Description |
+|----------|-------------|
+| `moq_consume_catalog_subscribe(broadcast, on_catalog, user_data)` | Subscribe to catalog updates. Calls `on_catalog` with a catalog snapshot ID when the catalog changes. |
+| `moq_consume_catalog_unsubscribe(catalog)` | Stop the catalog subscription background task. Previously delivered snapshots remain valid. |
+| `moq_consume_catalog_close(catalog)` | Close a catalog snapshot. Invalidates any borrowed pointers from config queries. |
+| `moq_consume_video_config(catalog, index, dst)` | Query video rendition info: name, codec, description, dimensions. |
+| `moq_consume_audio_config(catalog, index, dst)` | Query audio rendition info: name, codec, description, sample rate, channels. |
+| `moq_consume_video_ordered(catalog, index, max_latency_ms, on_frame, user_data)` | Subscribe to a video track. Delivers frames in order, skipping GoPs when latency exceeds `max_latency_ms`. |
+| `moq_consume_audio_ordered(catalog, index, max_latency_ms, on_frame, user_data)` | Subscribe to an audio track. Same latency behavior as video. |
+| `moq_consume_video_close(track)` | Close a video track subscription. |
+| `moq_consume_audio_close(track)` | Close an audio track subscription. |
+| `moq_consume_frame_chunk(frame, index, dst)` | Read a chunk of frame payload. Call with increasing `index` to get all chunks. |
+| `moq_consume_frame_close(frame)` | Close a frame and release its memory. |
+| `moq_consume_close(consume)` | Close a broadcast consumer. |
+
+### Data Structures
+
+```c
+// Video rendition configuration
+typedef struct {
+    const char *name;       // Track name (NOT null-terminated)
+    size_t name_len;
+    const char *codec;      // Codec string (NOT null-terminated)
+    size_t codec_len;
+    const uint8_t *description;  // Codec-specific init data, or NULL
+    size_t description_len;
+    const uint32_t *coded_width;   // Encoded width, or NULL
+    const uint32_t *coded_height;  // Encoded height, or NULL
+} moq_video_config;
+
+// Audio rendition configuration
+typedef struct {
+    const char *name;
+    size_t name_len;
+    const char *codec;
+    size_t codec_len;
+    const uint8_t *description;  // Codec-specific init data, or NULL
+    size_t description_len;
+    uint32_t sample_rate;    // Sample rate in Hz
+    uint32_t channel_count;  // Number of channels
+} moq_audio_config;
+
+// A frame of media data
+typedef struct {
+    const uint8_t *payload;  // Frame data, or NULL if stream ended
+    size_t payload_size;
+    uint64_t timestamp_us;   // Presentation timestamp in microseconds
+    bool keyframe;           // True if this starts a new GoP
+} moq_frame;
+
+// An announced broadcast
+typedef struct {
+    const char *path;    // Broadcast path (NOT null-terminated)
+    size_t path_len;
+    bool active;         // Whether the broadcast is currently active
+} moq_announced;
 ```
 
-With pkg-config:
+## Usage Example
 
-```bash
-gcc -o myapp myapp.c $(pkg-config --cflags --libs moq)
+### Publishing
+
+```c
+#include <moq.h>
+
+// Initialize logging
+moq_log_level("info", 4);
+
+// Create origin and session
+int origin = moq_origin_create();
+int session = moq_session_connect(url, url_len, origin, 0, on_status, NULL);
+
+// Create a broadcast with a video track
+int broadcast = moq_publish_create();
+int video = moq_publish_media_ordered(broadcast, "h264", 4, init_data, init_size);
+
+// Write frames
+moq_publish_media_frame(video, frame_data, frame_size, timestamp_us);
+
+// Publish to the relay
+moq_origin_publish(origin, "my-stream", 9, broadcast);
 ```
 
-## API Reference
+### Consuming
+
+```c
+// Create origin and connect
+int origin = moq_origin_create();
+int session = moq_session_connect(url, url_len, 0, origin, on_status, NULL);
 
-Full API documentation: [docs.rs/libmoq](https://docs.rs/libmoq)
+// Consume a broadcast
+int broadcast = moq_origin_consume(origin, "my-stream", 9);
 
-## Use Cases
+// Subscribe to the catalog
+moq_consume_catalog_subscribe(broadcast, on_catalog, NULL);
 
-- **C/C++ applications** - Native integration without Rust toolchain
-- **Language bindings** - Build bindings for Python, Go, etc.
-- **Legacy systems** - Integrate MoQ into existing C codebases
-- **Embedded systems** - Where Rust runtime isn't available
+// In the catalog callback:
+void on_catalog(void *user_data, int catalog) {
+    moq_video_config config;
+    moq_consume_video_config(catalog, 0, &config);
+
+    // Subscribe to the first video track
+    moq_consume_video_ordered(catalog, 0, 500, on_frame, NULL);
+}
+
+// In the frame callback:
+void on_frame(void *user_data, int frame) {
+    moq_frame chunk;
+    moq_consume_frame_chunk(frame, 0, &chunk);
+    // process chunk.payload, chunk.timestamp_us, chunk.keyframe
+    moq_consume_frame_close(frame);
+}
+```
 
 ## Next Steps
 
diff --git a/doc/rs/env/native.md b/doc/rs/env/native.md
index b6a2a9dae..48d0ced05 100644
--- a/doc/rs/env/native.md
+++ b/doc/rs/env/native.md
@@ -123,17 +123,18 @@ See the full [subscribe.rs](https://github.com/moq-dev/moq/blob/main/rs/hang/exa
 
 ## Reading Frames
 
-Subscribe to a media track and read frames using [`OrderedConsumer`](https://docs.rs/hang/latest/hang/container/struct.OrderedConsumer.html):
+Subscribe to a media track and read frames using [`OrderedConsumer`](https://docs.rs/moq-mux/latest/moq_mux/consumer/struct.OrderedConsumer.html):
 
 ```rust
 let track_consumer = broadcast.subscribe_track(&track);
-let mut ordered = hang::container::OrderedConsumer::new(
+let mut ordered = moq_mux::consumer::OrderedConsumer::new(
     track_consumer,
+    moq_mux::consumer::Legacy,
     Duration::from_millis(500), // max latency before skipping groups
 );
 
 while let Some(frame) = ordered.read().await? {
-    // frame.timestamp, frame.keyframe, frame.payload
+    // frame.timestamp, frame.is_keyframe(), frame.payload
 }
 ```
 
diff --git a/doc/rs/index.md b/doc/rs/index.md
index db6332a45..c929ec6f7 100644
--- a/doc/rs/index.md
+++ b/doc/rs/index.md
@@ -253,7 +253,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut track = broadcast.subscribe("chat").await?;
 
     // Read groups and frames
-    while let Some(group) = track.next_group().await? {
+    while let Some(group) = track.recv_group().await? {
         while let Some(frame) = group.read().await? {
             println!("Received: {:?}", frame);
         }
diff --git a/doc/spec/draft-ietf-moq-cmsf-00.txt b/doc/spec/draft-ietf-moq-cmsf-00.txt
new file mode 100644
index 000000000..872d1aac9
--- /dev/null
+++ b/doc/spec/draft-ietf-moq-cmsf-00.txt
@@ -0,0 +1,554 @@
+
+
+
+
+Media Over QUIC                                                   W. Law
+Internet-Draft                                                    Akamai
+Intended status: Informational                           1 December 2025
+Expires: 4 June 2026
+
+
+     CMSF- a CMAF compliant implementation of MOQT Streaming Format
+                         draft-ietf-moq-cmsf-00
+
+Abstract
+
+   This document updates [MSF] by defining a new optional feature for
+   the streaming format.  It specifies the syntax and semantics for
+   adding CMAF-packaged media [CMAF] to MSF.
+
+About This Document
+
+   This note is to be removed before publishing as an RFC.
+
+   The latest revision of this draft can be found at https://moq-
+   wg.github.io/cmsf/draft-wilaw-moq-cmsf.html.  Status information for
+   this document may be found at https://datatracker.ietf.org/doc/draft-
+   ietf-moq-cmsf/.
+
+   Discussion of this document takes place on the Media Over QUIC
+   Working Group mailing list (mailto:moq@ietf.org), which is archived
+   at https://mailarchive.ietf.org/arch/browse/moq/.  Subscribe at
+   https://www.ietf.org/mailman/listinfo/moq/.
+
+   Source for this draft and an issue tracker can be found at
+   https://github.com/moq-wg/cmsf.
+
+Status of This Memo
+
+   This Internet-Draft is submitted in full conformance with the
+   provisions of BCP 78 and BCP 79.
+
+   Internet-Drafts are working documents of the Internet Engineering
+   Task Force (IETF).  Note that other groups may also distribute
+   working documents as Internet-Drafts.  The list of current Internet-
+   Drafts is at https://datatracker.ietf.org/drafts/current/.
+
+   Internet-Drafts are draft documents valid for a maximum of six months
+   and may be updated, replaced, or obsoleted by other documents at any
+   time.  It is inappropriate to use Internet-Drafts as reference
+   material or to cite them other than as "work in progress."
+
+   This Internet-Draft will expire on 4 June 2026.
+
+
+
+Law                        Expires 4 June 2026                  [Page 1]
+
+Internet-Draft  CMSF- a CMAF compliant implementation of   December 2025
+
+
+Copyright Notice
+
+   Copyright (c) 2025 IETF Trust and the persons identified as the
+   document authors.  All rights reserved.
+
+   This document is subject to BCP 78 and the IETF Trust's Legal
+   Provisions Relating to IETF Documents (https://trustee.ietf.org/
+   license-info) in effect on the date of publication of this document.
+   Please review these documents carefully, as they describe your rights
+   and restrictions with respect to this document.  Code Components
+   extracted from this document must include Revised BSD License text as
+   described in Section 4.e of the Trust Legal Provisions and are
+   provided without warranty as described in the Revised BSD License.
+
+Table of Contents
+
+   1.  Introduction  . . . . . . . . . . . . . . . . . . . . . . . .   2
+   2.  MSF Extension . . . . . . . . . . . . . . . . . . . . . . . .   3
+   3.  CMAF Packaging  . . . . . . . . . . . . . . . . . . . . . . .   3
+     3.1.  Initialization headers  . . . . . . . . . . . . . . . . .   3
+     3.2.  Switching sets and tracks . . . . . . . . . . . . . . . .   3
+     3.3.  Object Packaging  . . . . . . . . . . . . . . . . . . . .   3
+     3.4.  Group Packaging . . . . . . . . . . . . . . . . . . . . .   4
+     3.5.  Catalog description . . . . . . . . . . . . . . . . . . .   4
+       3.5.1.  CMAF packaging type . . . . . . . . . . . . . . . . .   4
+       3.5.2.  Max SAP starting types  . . . . . . . . . . . . . . .   4
+     3.6.  Event Timelines . . . . . . . . . . . . . . . . . . . . .   5
+       3.6.1.  SAP Type timeline . . . . . . . . . . . . . . . . . .   5
+       3.6.2.  SAP-type timeline track example . . . . . . . . . . .   6
+   4.  Catalog Examples  . . . . . . . . . . . . . . . . . . . . . .   6
+     4.1.  Simulcast video tracks - 3 alternate video qualities along
+           with audio  . . . . . . . . . . . . . . . . . . . . . . .   7
+   5.  Conventions and Definitions . . . . . . . . . . . . . . . . .   8
+   6.  Security Considerations . . . . . . . . . . . . . . . . . . .   8
+   7.  IANA Considerations . . . . . . . . . . . . . . . . . . . . .   8
+   8.  Normative References  . . . . . . . . . . . . . . . . . . . .   8
+   Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . . .   9
+   Author's Address  . . . . . . . . . . . . . . . . . . . . . . . .   9
+
+1.  Introduction
+
+   CMAF compliant MOQT Streaming Format (CMSF) is a media format
+   designed to deliver CMAF [CMAF] and LOC [LOC] compliant media content
+   over MOQ Transport (MOQT) [MoQTransport].  CMSF extends MSF and
+   retains all the scope, capabilities and features of MSF including the
+   catalog format, timeline, ABR switching and LOC support.  MSF is
+   targeted at real-time and interactive levels of live latency, as well
+   as VOD content.
+
+
+
+Law                        Expires 4 June 2026                  [Page 2]
+
+Internet-Draft  CMSF- a CMAF compliant implementation of   December 2025
+
+
+   This document describes version 1 of the CMSF streaming format.
+
+2.  MSF Extension
+
+   All of the specifications, requirements, and terminology defined in
+   [MSF] apply to implementations of this extension unless explicitly
+   noted otherwise in this document.
+
+3.  CMAF Packaging
+
+3.1.  Initialization headers
+
+   A CMAF header is a sequence of CMAF constrained ISO BMFF boxes that
+   do not reference any media samples, but are associated with a CMAF
+   track and are necessary for initializing the decoding of the
+   subsequent CMAF fragments.
+
+   The header for a given MOQT Track MUST be packaged by encoding the
+   header using [BASE64] and then inserting that payload as the value of
+   the Initialization data "initData" field in the catalog entry for
+   that Track.
+
+3.2.  Switching sets and tracks
+
+   This specification defines a direct mapping between CMAF Tracks (
+   [CMAF] Sect 3.2.1) and MOQT tracks ([MoQTransport] Sect 2.3).
+
+   CMAF switching sets are a set of one or more CMAF tracks (3.2.1),
+   where each track is an alternative encoding of the same source
+   content and are constrained to enable seamless track switching
+   (3.3.9).
+
+   Each CMAF track in a switching set MUST be transmitted as a separate
+   MOQT Track.  The catalog entry for each of these tracks in the
+   switching set MUST carry a Alternate group (altGroup) key with a
+   common value.
+
+   The MOQT Group numbers within these switching set tracks MUST be
+   media time-aligned.  Mandating the track being media time-aligned
+   requires that the presentation time of the first media sample
+   contained within the first MOQT Object of each MOQT Group is
+   identical.
+
+3.3.  Object Packaging
+
+   The payload of each Object is subject to the following requirements:
+
+
+
+
+
+Law                        Expires 4 June 2026                  [Page 3]
+
+Internet-Draft  CMSF- a CMAF compliant implementation of   December 2025
+
+
+   *  MUST contain at least one Movie Fragment Box (moof) followed by a
+      Media Data Box (mdat).  This is equivalent to requiring that each
+      Object hold at least one CMAF Chunk.  The Media Fragment Box
+      (moof) MUST contain a Movie Fragment Header Box (mfhd) and Track
+      Box (trak) with a Track ID (track_ID) matching a Track Box in the
+      initialization fragment.
+
+   *  MAY contain multiple successive CMAF Chunks.
+
+   *  MUST contain a single [ISOBMFF] track.
+
+   *  MUST contain media content encoded in decode order.
+
+3.4.  Group Packaging
+
+   Each MOQT Group
+
+   *  MUST begin with an Object containing a stream access point (SAP
+      type 1 or 2).
+
+   *  MUST contain one or more contiguous Groups of Pictures (GOPs).
+
+   *  The Group boundary MUST align with a CMAF Fragment boundary.  CMAF
+      Fragments and CMAF Chunks MUST not span Groups.
+
+3.5.  Catalog description
+
+3.5.1.  CMAF packaging type
+
+   This specification extends the allowed packaging values defined in
+   [MSF] to include one new entry, as defined in Table 1 below:
+
+                       +======+=======+===========+
+                       | Name | Value | Reference |
+                       +======+=======+===========+
+                       | CMAF | cmaf  | This RFC  |
+                       +------+-------+-----------+
+
+                                 Table 1
+
+   Every Track entry in a CMSF catalog carrying CMAF-packaged media data
+   MUST declare a "packaging" type value of "cmaf".
+
+3.5.2.  Max SAP starting types
+
+   This specification adds two track-level catalog fields, as defined in
+   Table 2 below:
+
+
+
+
+Law                        Expires 4 June 2026                  [Page 4]
+
+Internet-Draft  CMSF- a CMAF compliant implementation of   December 2025
+
+
+   +=============================+=======================+============+
+   | Field                       | Name                  | Definition |
+   +=============================+=======================+============+
+   | Max Group SAP starting type | maxGrpSapStartingType | Section    |
+   |                             |                       | 3.5.2.1    |
+   +-----------------------------+-----------------------+------------+
+   | Max Object SAP starting     | maxObjSapStartingType | Section    |
+   | type                        |                       | 3.5.2.2    |
+   +-----------------------------+-----------------------+------------+
+
+                                 Table 2
+
+3.5.2.1.  Max Group SAP starting type
+
+   Location: T Required: Optional JSON Type: Number
+
+   A number indicating the maximum SAP type the MOQT Groups in the track
+   start with.
+
+3.5.2.2.  Max Object SAP starting type
+
+   Location: T Required: Optional JSON Type: Number
+
+   A number indicating the maximum SAP type the MOQT Objects in the
+   track start with.
+
+3.6.  Event Timelines
+
+3.6.1.  SAP Type timeline
+
+   CMSF defines a special instance of an Event Timeline track, termed
+   the SAP Type timeline track.  Its purpose is to convey information
+   about the distribution of Stream Access Point types and their
+   associated Earliest Presentation Times.
+
+   In the catalog, the SAP-type timeline track MUST include a
+   'packaging' value of 'eventtimeline' and MUST include an 'eventType'
+   value of 'org.ietf.moq.cmsf.sap'.
+
+   In the SAP Type timeline JSON payload:
+
+   *  The index reference MUST be 'l' for Location
+
+   *  The data field is a JSON Array containing two integers.  The first
+      integer defines SAP type with an allowed value of 0,1,2 or 3.  The
+      value 0 indicates that the Object does not start with an ISOBMFF
+      stream access point.  The value equal to 1, 2, or 3 indicates that
+      the Object begins with a stream access point of SAP type 1, 2, or
+
+
+
+Law                        Expires 4 June 2026                  [Page 5]
+
+Internet-Draft  CMSF- a CMAF compliant implementation of   December 2025
+
+
+      3, respectively.  When the Object is the first Object in the
+      Group, the value MUST be equal to 1 or 2.  The second integer
+      defines the earliest media presentation timestamp, rounded to the
+      nearest millisecond, of all media samples in the Object defined by
+      the Location of that record.
+
+3.6.2.  SAP-type timeline track example
+
+   This shows an example of 30-fps HEVC-encoded content, in which each
+   4s Group begins with SAP-type 2 (i.e., the first picture in the Group
+   is an IDR picture, while there may be one or more pictures in the
+   Group following the IDR picture in decoding order but preceding it in
+   output order).  After 2 seconds in each Group, there is a SAP-type 3,
+   i.e., a CRA picture, which is associated with one or more Random
+   Access Skipped Leading (RASL) pictures.  A small buffer of frames (10
+   frames at 30 fps) is skipped/discarded (RASL pictures) when the
+   streaming session starts from the SAP-type 3 location.  In this
+   example, the EPT is the presentation time of the first picture after
+   the RASL pictures in decoding order; all pictures after the RASL
+   pictures can be fully correctly decoded and are thus presentable when
+   the streaming session starts from the SAP-type 3 location.  Note that
+   if the streaming session starts from the start of the Group, then
+   these RASL pictures can be fully correctly decoded and are thus
+   presentable.
+
+   [
+       {
+           "l": [0,0],
+           "data": [2,0]
+       },
+       {
+           "l": [0,60],
+           "data": [3,2100]
+       },
+       {
+           "l": [1,0],
+           "data": [2,4000]
+       },
+       {
+           "l": [1,60],
+           "data": [3,6100]
+       }
+   ]
+
+4.  Catalog Examples
+
+   The following section provides non-normative JSON examples of various
+   catalogs compliant with this draft.
+
+
+
+Law                        Expires 4 June 2026                  [Page 6]
+
+Internet-Draft  CMSF- a CMAF compliant implementation of   December 2025
+
+
+4.1.  Simulcast video tracks - 3 alternate video qualities along with
+      audio
+
+   This example shows catalog for a media producer capable of sending 3
+   time-aligned video tracks for high definition, low definition and
+   medium definition video qualities, along with an audio track.
+
+   {
+     "version": 1,
+     "generatedAt": 1746104606044,
+     "tracks":[
+       {
+         "name": "hd",
+         "renderGroup": 1,
+         "packaging": "cmaf",
+         "isLive": true,
+         "initData": "AAAAIGZ0eXBpc281AAA...AAAAAAAAAAAAA",
+         "role": "video",
+         "codec":"avc1.640028",
+         "width":1920,
+         "height":1080,
+         "bitrate":5000000,
+         "framerate":30,
+         "altGroup":1
+       },
+       {
+         "name": "md",
+         "renderGroup": 1,
+         "packaging": "cmaf",
+         "isLive": true,
+         "initData": "AAAAHGZ0eXBpc281AAA...AAAAAAAAAAAAAA",
+         "role": "video",
+         "codec":"avc1.64001e",
+         "width":720,
+         "height":640,
+         "bitrate":3000000,
+         "framerate":30,
+         "altGroup":1
+       },
+       {
+         "name": "sd",
+         "renderGroup": 1,
+         "packaging": "cmaf",
+         "isLive": true,
+         "initData": "AAAAHGZ0eXBpc281AAA...AAAAAAAAAAAAAA",
+         "role": "video",
+         "codec":"avc1.64000d",
+         "width":192,
+
+
+
+Law                        Expires 4 June 2026                  [Page 7]
+
+Internet-Draft  CMSF- a CMAF compliant implementation of   December 2025
+
+
+         "height":144,
+         "bitrate":500000,
+         "framerate":30,
+         "altGroup":1
+       },
+       {
+         "name": "audio",
+         "renderGroup": 1,
+         "packaging": "cmaf",
+         "isLive": true,
+         "initData": "AAAAHGZ0eXBpc281AAA...AAAAAAAAAAAAAA",
+         "role": "audio",
+         "codec":"mp4a.40.5",
+         "samplerate":48000,
+         "channelConfig":"2",
+         "bitrate":67071
+       }
+      ]
+   }
+
+5.  Conventions and Definitions
+
+   The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
+   "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and
+   "OPTIONAL" in this document are to be interpreted as described in
+   BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all
+   capitals, as shown here.
+
+6.  Security Considerations
+
+   CMSF inherits the security properties of the underlying MoQ
+   Transport protocol [MoQTransport] and the WebTransport or QUIC
+   session over which it operates.  Implementations MUST ensure that
+   the transport layer provides confidentiality, integrity, and
+   authentication (e.g., via TLS 1.3).
+
+   Threat Model:  An attacker may be on-path or off-path and may
+      attempt to eavesdrop, inject, modify, or replay CMSF messages.
+      Attackers may also attempt to disrupt availability through
+      resource exhaustion.
+
+   Confidentiality:  Media content carried within CMSF Groups and
+      Objects is visible to relays and any entity with access to the
+      QUIC session keys.  Applications requiring end-to-end media
+      confidentiality SHOULD encrypt media payloads above the
+      transport layer (e.g., using Secure Frame [SFrame]).
+
+   Integrity:  CMSF metadata (SAP types, event timelines, timing
+      information) MUST be integrity-protected by the underlying
+      transport.  Receivers SHOULD validate that CMSF metadata is
+      consistent with the media content (e.g., declared SAP types
+      match actual Stream Access Points).
+
+   Authentication and Authorization:  Publishers and subscribers
+      SHOULD be authenticated before being allowed to announce or
+      consume CMSF content.  Authorization policies SHOULD restrict
+      which paths a client may publish to or subscribe from.
+      Credentials SHOULD have bounded lifetimes, and implementations
+      SHOULD support revocation mechanisms.
+
+   Replay and Impersonation:  Implementations MUST rely on the
+      transport's replay protection (e.g., QUIC's nonce-based
+      encryption).  CMSF itself does not introduce additional replay
+      vectors beyond those of the underlying MoQ Transport.
+
+   Availability:  Receivers MUST impose limits on the rate and size
+      of CMSF Objects and Groups to mitigate resource exhaustion
+      attacks.  Relays SHOULD apply backpressure or rate limiting
+      to protect downstream consumers.
+
+   Privacy:  CMSF track names and catalog metadata may reveal
+      information about the media content or its structure.
+      Implementations SHOULD consider the privacy implications of
+      exposing track names, codec parameters, and timing metadata
+      to untrusted intermediaries.
+
+   Operational Guidance:  Implementations SHOULD log security-
+      relevant events (authentication failures, authorization
+      denials, malformed messages) for monitoring and incident
+      response.  Error messages SHOULD NOT leak internal state or
+      configuration details to unauthenticated clients.
+
+7.  IANA Considerations
+
+   This document has no IANA actions.
+
+8.  Normative References
+
+   [BASE64]   Josefsson, S., "The Base16, Base32, and Base64 Data
+              Encodings", RFC 4648, DOI 10.17487/RFC4648, October 2006,
+              <https://www.rfc-editor.org/rfc/rfc4648>.
+
+   [CMAF]     Standardization, I. O. for., "Information technology —
+              Multimedia application format (MPEG-A) — Part 19: Common
+              media application format (CMAF) for segmented media",
+              October 2021.
+
+
+
+
+
+Law                        Expires 4 June 2026                  [Page 8]
+
+Internet-Draft  CMSF- a CMAF compliant implementation of   December 2025
+
+
+   [MoQTransport]
+              Curley, L., Pugin, K., Nandakumar, S., Vasiliev, V., and
+              I. Swett, "Media over QUIC Transport", Work in Progress,
+              Internet-Draft, draft-ietf-moq-transport-10, 3 March 2025,
+              <https://datatracker.ietf.org/doc/html/draft-ietf-moq-
+              transport-10>.
+
+   [MSF]      Law, W., Curley, L., Vasiliev, V., Nandakumar, S., and K.
+              Pugin, "WARP Streaming Format", Work in Progress,
+              Internet-Draft, draft-ietf-moq-warp-01, 22 July 2025,
+              <https://datatracker.ietf.org/doc/html/draft-ietf-moq-
+              warp-01>.
+
+   [RFC2119]  Bradner, S., "Key words for use in RFCs to Indicate
+              Requirement Levels", BCP 14, RFC 2119,
+              DOI 10.17487/RFC2119, March 1997,
+              <https://www.rfc-editor.org/rfc/rfc2119>.
+
+   [RFC8174]  Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC
+              2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174,
+              May 2017, <https://www.rfc-editor.org/rfc/rfc8174>.
+
+Acknowledgments
+
+   TODO acknowledge.
+
+Author's Address
+
+   Will Law
+   Akamai
+   Email: wilaw@akamai.com
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Law                        Expires 4 June 2026                  [Page 9]
diff --git a/doc/spec/draft-ietf-moq-msf-00.txt b/doc/spec/draft-ietf-moq-msf-00.txt
new file mode 100644
index 000000000..dafe4e045
--- /dev/null
+++ b/doc/spec/draft-ietf-moq-msf-00.txt
@@ -0,0 +1,1964 @@
+
+
+
+
+Media Over QUIC                                                   W. Law
+Internet-Draft                                                    Akamai
+Intended status: Informational                           19 January 2026
+Expires: 23 July 2026
+
+
+                         MOQT Streaming Format
+                         draft-ietf-moq-msf-00
+
+Abstract
+
+   This document specifies the MOQT Streaming Format, designed to
+   operate on Media Over QUIC Transport.
+
+About This Document
+
+   This note is to be removed before publishing as an RFC.
+
+   The latest revision of this draft can be found at https://moq-
+   wg.github.io/msf/draft-ietf-moq-msf.html.  Status information for
+   this document may be found at https://datatracker.ietf.org/doc/draft-
+   ietf-moq-msf/.
+
+   Discussion of this document takes place on the Media Over QUIC
+   Working Group mailing list (mailto:moq@ietf.org), which is archived
+   at https://mailarchive.ietf.org/arch/browse/moq/.  Subscribe at
+   https://www.ietf.org/mailman/listinfo/moq/.
+
+   Source for this draft and an issue tracker can be found at
+   https://github.com/moq-wg/msf.
+
+Status of This Memo
+
+   This Internet-Draft is submitted in full conformance with the
+   provisions of BCP 78 and BCP 79.
+
+   Internet-Drafts are working documents of the Internet Engineering
+   Task Force (IETF).  Note that other groups may also distribute
+   working documents as Internet-Drafts.  The list of current Internet-
+   Drafts is at https://datatracker.ietf.org/drafts/current/.
+
+   Internet-Drafts are draft documents valid for a maximum of six months
+   and may be updated, replaced, or obsoleted by other documents at any
+   time.  It is inappropriate to use Internet-Drafts as reference
+   material or to cite them other than as "work in progress."
+
+   This Internet-Draft will expire on 23 July 2026.
+
+
+
+
+Law                       Expires 23 July 2026                  [Page 1]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+Copyright Notice
+
+   Copyright (c) 2026 IETF Trust and the persons identified as the
+   document authors.  All rights reserved.
+
+   This document is subject to BCP 78 and the IETF Trust's Legal
+   Provisions Relating to IETF Documents (https://trustee.ietf.org/
+   license-info) in effect on the date of publication of this document.
+   Please review these documents carefully, as they describe your rights
+   and restrictions with respect to this document.  Code Components
+   extracted from this document must include Revised BSD License text as
+   described in Section 4.e of the Trust Legal Provisions and are
+   provided without warranty as described in the Revised BSD License.
+
+Table of Contents
+
+   1.  Introduction  . . . . . . . . . . . . . . . . . . . . . . . .   4
+   2.  Conventions and Definitions . . . . . . . . . . . . . . . . .   4
+   3.  Scope . . . . . . . . . . . . . . . . . . . . . . . . . . . .   4
+   4.  Media packaging . . . . . . . . . . . . . . . . . . . . . . .   6
+     4.1.  LOC packaging . . . . . . . . . . . . . . . . . . . . . .   6
+     4.2.  Time-alignment  . . . . . . . . . . . . . . . . . . . . .   6
+     4.3.  Content protection and encryption . . . . . . . . . . . .   6
+   5.  Catalog . . . . . . . . . . . . . . . . . . . . . . . . . . .   6
+     5.1.  Catalog Fields  . . . . . . . . . . . . . . . . . . . . .   7
+       5.1.1.  MSF version . . . . . . . . . . . . . . . . . . . . .   9
+       5.1.2.  Delta update  . . . . . . . . . . . . . . . . . . . .   9
+       5.1.3.  Add tracks  . . . . . . . . . . . . . . . . . . . . .   9
+       5.1.4.  Remove tracks . . . . . . . . . . . . . . . . . . . .   9
+       5.1.5.  Clone tracks  . . . . . . . . . . . . . . . . . . . .  10
+       5.1.6.  Generated at  . . . . . . . . . . . . . . . . . . . .  10
+       5.1.7.  Is Complete . . . . . . . . . . . . . . . . . . . . .  10
+       5.1.8.  Tracks  . . . . . . . . . . . . . . . . . . . . . . .  10
+       5.1.9.  Tracks object . . . . . . . . . . . . . . . . . . . .  10
+       5.1.10. Track namespace . . . . . . . . . . . . . . . . . . .  11
+       5.1.11. Track name  . . . . . . . . . . . . . . . . . . . . .  11
+       5.1.12. Packaging . . . . . . . . . . . . . . . . . . . . . .  11
+       5.1.13. Event timeline type . . . . . . . . . . . . . . . . .  11
+       5.1.14. Track role  . . . . . . . . . . . . . . . . . . . . .  12
+       5.1.15. Is Live . . . . . . . . . . . . . . . . . . . . . . .  13
+       5.1.16. Target latency  . . . . . . . . . . . . . . . . . . .  13
+       5.1.17. Track label . . . . . . . . . . . . . . . . . . . . .  13
+       5.1.18. Render group  . . . . . . . . . . . . . . . . . . . .  13
+       5.1.19. Alternate group . . . . . . . . . . . . . . . . . . .  14
+       5.1.20. Initialization data . . . . . . . . . . . . . . . . .  14
+       5.1.21. Dependencies  . . . . . . . . . . . . . . . . . . . .  14
+       5.1.22. Temporal ID . . . . . . . . . . . . . . . . . . . . .  14
+       5.1.23. Spatial ID  . . . . . . . . . . . . . . . . . . . . .  14
+
+
+
+Law                       Expires 23 July 2026                  [Page 2]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+       5.1.24. Codec . . . . . . . . . . . . . . . . . . . . . . . .  15
+       5.1.25. Mimetype  . . . . . . . . . . . . . . . . . . . . . .  15
+       5.1.26. Framerate . . . . . . . . . . . . . . . . . . . . . .  15
+       5.1.27. Timescale . . . . . . . . . . . . . . . . . . . . . .  15
+       5.1.28. Bitrate . . . . . . . . . . . . . . . . . . . . . . .  15
+       5.1.29. Width . . . . . . . . . . . . . . . . . . . . . . . .  15
+       5.1.30. Height  . . . . . . . . . . . . . . . . . . . . . . .  15
+       5.1.31. Audio sample rate . . . . . . . . . . . . . . . . . .  16
+       5.1.32. Channel configuration . . . . . . . . . . . . . . . .  16
+       5.1.33. Display width . . . . . . . . . . . . . . . . . . . .  16
+       5.1.34. Display height  . . . . . . . . . . . . . . . . . . .  16
+       5.1.35. Language  . . . . . . . . . . . . . . . . . . . . . .  16
+       5.1.36. Parent name . . . . . . . . . . . . . . . . . . . . .  16
+       5.1.37. Track duration  . . . . . . . . . . . . . . . . . . .  17
+     5.2.  Delta updates . . . . . . . . . . . . . . . . . . . . . .  17
+     5.3.  Catalog Examples  . . . . . . . . . . . . . . . . . . . .  18
+       5.3.1.  Time-aligned Audio/Video Tracks with single
+               quality . . . . . . . . . . . . . . . . . . . . . . .  18
+       5.3.2.  Simulcast video tracks - 3 alternate qualities along
+               with audio  . . . . . . . . . . . . . . . . . . . . .  19
+       5.3.3.  SVC video tracks with 2 spatial and 2 temporal
+               qualities . . . . . . . . . . . . . . . . . . . . . .  21
+       5.3.4.  Delta update - adding two tracks  . . . . . . . . . .  23
+       5.3.5.  Delta update removing tracks  . . . . . . . . . . . .  24
+       5.3.6.  Time-aligned Audio/Video Tracks with custom field
+               values  . . . . . . . . . . . . . . . . . . . . . . .  24
+       5.3.7.  Time-aligned VOD Audio/Video Tracks . . . . . . . . .  25
+       5.3.8.  Media timeline and Event timeline . . . . . . . . . .  26
+       5.3.9.  Terminating a live broadcast  . . . . . . . . . . . .  27
+   6.  Media transmission  . . . . . . . . . . . . . . . . . . . . .  28
+     6.1.  Group numbering . . . . . . . . . . . . . . . . . . . . .  28
+   7.  Media Timeline track  . . . . . . . . . . . . . . . . . . . .  28
+     7.1.  Media Timeline track payload  . . . . . . . . . . . . . .  28
+     7.2.  Media Timeline Catalog requirements . . . . . . . . . . .  29
+     7.3.  Media Timeline track updating . . . . . . . . . . . . . .  29
+   8.  Event Timeline track  . . . . . . . . . . . . . . . . . . . .  29
+     8.1.  Event Timeline data format  . . . . . . . . . . . . . . .  30
+     8.2.  Event Timeline Catalog requirements . . . . . . . . . . .  30
+     8.3.  Event Timeline track updating . . . . . . . . . . . . . .  31
+     8.4.  Event timeline track examples . . . . . . . . . . . . . .  31
+       8.4.1.  Event timeline track with wallclock time indexing . .  31
+       8.4.2.  Event timeline track with MOQT Location indexing  . .  31
+   9.  Workflow  . . . . . . . . . . . . . . . . . . . . . . . . . .  32
+     9.1.  Initiating a broadcast  . . . . . . . . . . . . . . . . .  32
+     9.2.  Ending a live broadcast . . . . . . . . . . . . . . . . .  32
+   10. Security Considerations . . . . . . . . . . . . . . . . . . .  32
+   11. IANA Considerations . . . . . . . . . . . . . . . . . . . . .  32
+   12. Normative References  . . . . . . . . . . . . . . . . . . . .  33
+
+
+
+Law                       Expires 23 July 2026                  [Page 3]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+   Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . . .  34
+   Contributors  . . . . . . . . . . . . . . . . . . . . . . . . . .  34
+   Author's Address  . . . . . . . . . . . . . . . . . . . . . . . .  34
+
+1.  Introduction
+
+   MOQT Streaming Format (MSF) is a media format designed to deliver LOC
+   [LOC] compliant media content over Media Over QUIC Transport (MOQT)
+   [MoQTransport].  MSF works by fragmenting the bitstream into objects
+   that can be independently transmitted.  MSF leverages a catalog
+   format to describe the output of the original publisher.  MSF
+   specifies how content should be packaged and signaled, defines how
+   the catalog communicates the content, specifies prioritization
+   strategies for real-time and workflows for beginning and terminating
+   broadcasts.  MSF also details how end-subscribers may perform
+   adaptive bitrate switching.  MSF is targeted at real-time and
+   interactive levels of live latency, as well as VOD content.
+
+   This document describes version 1 of the streaming format.
+
+2.  Conventions and Definitions
+
+   The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
+   "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and
+   "OPTIONAL" in this document are to be interpreted as described in
+   BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all
+   capitals, as shown here.
+
+   This document uses the conventions detailed in Section 1.3 of
+   [RFC9000] when describing the binary encoding.
+
+3.  Scope
+
+   The purpose of MSF is to provide an interoperable media streaming
+   format operating over [MoQTransport].  Interoperability implies that:
+
+   *  An original publisher can package incoming media content into
+      tracks, prepare a catalog and announce the availability of the
+      content to an MOQT relay.  Media content refers to audio and video
+      data, as well as ancillary data such as captions, subtitles,
+      accessibility and other timed-text data.
+
+   *  An MOQT relay can process the announcement as well as cache and
+      propagate the tracks, both to other relays or to the final
+      subscriber.
+
+   *  A final subscriber can parse the catalog, request tracks, decode
+      and render the received media data.
+
+
+
+Law                       Expires 23 July 2026                  [Page 4]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+   MSF is intended to provide a format for delivering commercial media
+   content.  To that end, the following features are within scope:
+
+   *  Video codecs - all codecs supported by [LOC]
+
+   *  Audio codecs - all audio codecs supported by [LOC]
+
+   *  Catalog track - describes the availability and characteristics of
+      content produced by the original publisher.
+
+   *  Timeline track - describes the relationship between MOQT Group and
+      Object IDs to media time.
+
+   *  Token-based authorization and access control
+
+   *  Captions + Subtitles - support for [WEBVTT] and [IMSC1]
+      transmission
+
+   *  Latency support across multiple regimes (thresholds are
+      informative only and describe the delay between the original
+      publisher placing the content on the wire and the final subscriber
+      rendering it)
+
+   *  Real-time - less than 500ms
+
+   *  Interactive - between 500ms and 2500ms
+
+   *  Standard - above 2500ms
+
+   *  VOD latency - content that was previously produced, is no longer
+      live and is available indefinitely.
+
+   *  Content encryption
+
+   *  ABR between time-synced tracks - subscribers may switch between
+      tracks at different quality levels in order to maximize visual or
+      audio quality under conditions of throughput variability.
+
+   *  Capable of delivering interstitial advertising.
+
+   *  Logs and analytics management - support for the reporting of
+      client-side QoE and relay delivery actions.
+
+   Initial versions of MSF will prioritize basic features necessary to
+   exercise interoperability across delivery systems.  Later versions
+   will add commercially necessary features.
+
+
+
+
+
+Law                       Expires 23 July 2026                  [Page 5]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+4.  Media packaging
+
+   MSF delivers LOC [LOC] packaged media bitstreams.
+
+4.1.  LOC packaging
+
+   This specification references Low Overhead Container (LOC) [LOC] to
+   define how audio and video content is packaged.  With this packaging
+   mode, each EncodedAudioChunk or EncodedVideoChunk sample is placed in
+   a separate MOQT Object.  Samples that belong to the same Group of
+   Pictures (GOP) MUST be placed within the same MOQT Group.
+
+   When LOC packaging is used for a track, the catalog packaging
+   attribute (Section 5.1.12) MUST be present and it MUST be populated
+   with a value of "loc".
+
+4.2.  Time-alignment
+
+   MSF Tracks MAY be time-aligned.  Those that are, are subject to the
+   following requirements:
+
+   *  Tracks advertised in the catalog as belonging to a common render
+      group MUST be time-aligned.
+
+   *  The render duration of the first media object of each equally
+      numbered MOQT Group, after decoding, MUST have overlapping
+      presentation time.
+
+   A consequence of this restriction is that an MSF receiver SHOULD be
+   able to cleanly switch between time-aligned media tracks at group
+   boundaries.
+
+4.3.  Content protection and encryption
+
+   ToDo - content protection for LOC-packaged content.
+
+5.  Catalog
+
+   A Catalog is an MOQT Track that provides information about the other
+   tracks being produced by a MSF publisher.  A Catalog is used by MSF
+   publishers for advertising their output and for subscribers in
+   consuming that output.  The payload of the Catalog object is opaque
+   to Relays and can be end-to-end encrypted.  The Catalog provides the
+   names and namespaces of the tracks being produced, along with the
+   relationship between tracks, properties of the tracks that consumers
+   may use for selection and any relevant initialization data.
+
+   The catalog track MUST have a case-sensitive Track Name of "catalog".
+
+
+
+Law                       Expires 23 July 2026                  [Page 6]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+   A catalog object MAY be independent of other catalog objects or it
+   MAY represent a delta update of a prior catalog object.  The first
+   catalog object published within a new group MUST be independent.  A
+   catalog object SHOULD be published only when the availability of
+   tracks changes.
+
+   Each catalog update MUST be mapped to an MOQT Object.
+
+5.1.  Catalog Fields
+
+   A catalog is a JSON [JSON] document, comprised of a series of
+   mandatory and optional fields.  At a minimum, a catalog MUST provide
+   all mandatory fields.  A producer MAY add additional fields to the
+   ones described in this draft.  Custom field names MUST NOT collide
+   with field names described in this draft.  The order of field names
+   within the JSON document is not important.
+
+   A parser MUST ignore fields it does not understand.
+
+   Table 1 provides an overview of all fields defined by this document.
+
+        +=======================+===============+================+
+        | Field                 | Name          | Definition     |
+        +=======================+===============+================+
+        | MSF version           | version       | Section 5.1.1  |
+        +-----------------------+---------------+----------------+
+        | Delta update          | deltaUpdate   | Section 5.1.2  |
+        +-----------------------+---------------+----------------+
+        | Add tracks            | addTracks     | Section 5.1.3  |
+        +-----------------------+---------------+----------------+
+        | Remove tracks         | removeTracks  | Section 5.1.4  |
+        +-----------------------+---------------+----------------+
+        | Clone tracks          | cloneTracks   | Section 5.1.5  |
+        +-----------------------+---------------+----------------+
+        | Generated at          | generatedAt   | Section 5.1.6  |
+        +-----------------------+---------------+----------------+
+        | Is Complete           | isComplete    | Section 5.1.7  |
+        +-----------------------+---------------+----------------+
+        | Tracks                | tracks        | Section 5.1.8  |
+        +-----------------------+---------------+----------------+
+        | Track namespace       | namespace     | Section 5.1.10 |
+        +-----------------------+---------------+----------------+
+        | Track name            | name          | Section 5.1.11 |
+        +-----------------------+---------------+----------------+
+        | Packaging             | packaging     | Section 5.1.12 |
+        +-----------------------+---------------+----------------+
+        | Event timeline type   | eventType     | Section 5.1.13 |
+        +-----------------------+---------------+----------------+
+
+
+
+Law                       Expires 23 July 2026                  [Page 7]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+        | Is Live               | isLive        | Section 5.1.15 |
+        +-----------------------+---------------+----------------+
+        | Target latency        | targetLatency | Section 5.1.16 |
+        +-----------------------+---------------+----------------+
+        | Track role            | role          | Section 5.1.14 |
+        +-----------------------+---------------+----------------+
+        | Track label           | label         | Section 5.1.17 |
+        +-----------------------+---------------+----------------+
+        | Render group          | renderGroup   | Section 5.1.18 |
+        +-----------------------+---------------+----------------+
+        | Alternate group       | altGroup      | Section 5.1.19 |
+        +-----------------------+---------------+----------------+
+        | Initialization data   | initData      | Section 5.1.20 |
+        +-----------------------+---------------+----------------+
+        | Dependencies          | depends       | Section 5.1.21 |
+        +-----------------------+---------------+----------------+
+        | Temporal ID           | temporalId    | Section 5.1.22 |
+        +-----------------------+---------------+----------------+
+        | Spatial ID            | spatialId     | Section 5.1.23 |
+        +-----------------------+---------------+----------------+
+        | Codec                 | codec         | Section 5.1.24 |
+        +-----------------------+---------------+----------------+
+        | Mime type             | mimeType      | Section 5.1.25 |
+        +-----------------------+---------------+----------------+
+        | Framerate             | framerate     | Section 5.1.26 |
+        +-----------------------+---------------+----------------+
+        | Timescale             | timescale     | Section 5.1.27 |
+        +-----------------------+---------------+----------------+
+        | Bitrate               | bitrate       | Section 5.1.28 |
+        +-----------------------+---------------+----------------+
+        | Width                 | width         | Section 5.1.29 |
+        +-----------------------+---------------+----------------+
+        | Height                | height        | Section 5.1.30 |
+        +-----------------------+---------------+----------------+
+        | Audio sample rate     | samplerate    | Section 5.1.31 |
+        +-----------------------+---------------+----------------+
+        | Channel configuration | channelConfig | Section 5.1.32 |
+        +-----------------------+---------------+----------------+
+        | Display width         | displayWidth  | Section 5.1.33 |
+        +-----------------------+---------------+----------------+
+        | Display height        | displayHeight | Section 5.1.34 |
+        +-----------------------+---------------+----------------+
+        | Language              | lang          | Section 5.1.35 |
+        +-----------------------+---------------+----------------+
+        | Parent name           | parentName    | Section 5.1.36 |
+        +-----------------------+---------------+----------------+
+        | Track duration        | trackDuration | Section 5.1.37 |
+        +-----------------------+---------------+----------------+
+
+
+
+Law                       Expires 23 July 2026                  [Page 8]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+                                 Table 1
+
+   Table 2 defines the allowed locations for these fields within the
+   document
+
+              +==========+=================================+
+              | Location | Allowed locations for the field |
+              +==========+=================================+
+              | R        | The Root of the JSON object     |
+              +----------+---------------------------------+
+              | T        | Track object                    |
+              +----------+---------------------------------+
+
+                                 Table 2
+
+5.1.1.  MSF version
+
+   Location: R Required: Yes JSON Type: Number
+
+   Specifies the version of MSF referenced by this catalog.  There is no
+   guarantee that future catalog versions are backwards compatible and
+   field definitions and interpretation may change between versions.  A
+   subscriber MUST NOT attempt to parse a catalog version which it does
+   not understand.
+
+5.1.2.  Delta update
+
+   Location: R Required: Optional JSON Type: Boolean
+
+   A Boolean that if true indicates that this catalog object represents
+   a delta (or partial) update.  A delta update has a restricted set of
+   fields and special processing rules - see Section 5.2.  This value
+   SHOULD NOT be added to a catalog if it is false.
+
+5.1.3.  Add tracks
+
+   Location: R Required: Optional JSON Type: Array
+
+   Indicates a delta processing instruction to add new tracks.  The
+   value of this field is an Array of track objects Section 5.1.9.
+
+5.1.4.  Remove tracks
+
+   Location: R Required: Optional JSON Type: Array
+
+
+
+
+
+
+
+Law                       Expires 23 July 2026                  [Page 9]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+   Indicates a delta processing instruction to remove new tracks.  The
+   value of this field is an Array of track objects Section 5.1.9.  Each
+   track object MUST include a Track Name Section 5.1.11 field, MAY
+   include a Track Namespace Section 5.1.10 field and MUST NOT hold any
+   other fields.
+
+5.1.5.  Clone tracks
+
+   Location: R Required: Optional JSON Type: Array
+
+   Indicates a delta processing instruction to clone new tracks from
+   previously declared tracks.  The value of this field is an Array of
+   track objects Section 5.1.9.  Each track object MUST include a Parent
+   Name Section 5.1.36 field.
+
+5.1.6.  Generated at
+
+   Location: R Required: Optional JSON Type: Number
+
+   The wallclock time at which this catalog instance was generated,
+   expressed as the number of milliseconds that have elapsed since
+   January 1, 1970 (midnight UTC/GMT).  This field SHOULD NOT be
+   included if the isLive field is false.
+
+5.1.7.  Is Complete
+
+   Location: R Required: Optional JSON Type: Boolean
+
+   Issued once a previously live broadcast is complete.  This is a
+   commitment that all tracks are complete, no new tracks will be added
+   and no new content will be published.  This field MUST NOT be
+   included if it is FALSE.  This field MUST NOT be removed from a
+   catalog once it has been added.
+
+5.1.8.  Tracks
+
+   Location: R Required: Yes JSON Type: Array
+
+   An array of track objects Section 5.1.9.
+
+5.1.9.  Tracks object
+
+   A track object is JSON Object containing a collection of fields whose
+   location is specified 'T' in Table 2.
+
+
+
+
+
+
+
+Law                       Expires 23 July 2026                 [Page 10]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+5.1.10.  Track namespace
+
+   Location: T Required: Optional JSON Type: String
+
+   The name space under which the track name is defined.  See section
+   2.3 of [MoQTransport].  The track namespace is optional.  If it is
+   not declared within a track, then each track MUST inherit the
+   namespace of the catalog track.  A namespace declared in a track
+   object overwrites any inherited name space.
+
+5.1.11.  Track name
+
+   Location: T Required: Yes JSON Type: String
+
+   A string defining the name of the track.  See section 2.3 of
+   [MoQTransport].  Within the catalog, track names MUST be unique per
+   namespace.
+
+5.1.12.  Packaging
+
+   Location: T Required: Yes JSON Type: String
+
+   A string defining the type of payload encapsulation.  Allowed values
+   are strings as defined in Table 3.
+
+   Table 3: Allowed packaging values
+
+            +================+===============+===============+
+            | Name           | Value         | Reference     |
+            +================+===============+===============+
+            | LOC            | loc           | See RFC XXXX  |
+            +----------------+---------------+---------------+
+            | Media Timeline | mediatimeline | See Section 7 |
+            +----------------+---------------+---------------+
+            | Event Timeline | eventtimeline | See Section 8 |
+            +----------------+---------------+---------------+
+
+                                 Table 3
+
+5.1.13.  Event timeline type
+
+   Location: T Required: Optional JSON Type: String
+
+
+
+
+
+
+
+
+
+Law                       Expires 23 July 2026                 [Page 11]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+   A String defining the type & structure of the data contained within
+   the data field of the Event timeline track.  Types are defined by the
+   application provider and are not centrally registered.  Implementers
+   are encouraged to use a unique naming scheme, such as Reverse Domain
+   Name Notation, to avoid naming collisions.  This field is required if
+   the Section 5.1.12 value is "eventtimeline".  This field MUST NOT be
+   used if the packaging value is not "eventtimeline".
+
+5.1.14.  Track role
+
+   Location: T Required: Optional JSON Type: String
+
+   A string defining the role of content carried by the track.
+   Specified roles are described in Table 4.  These role values are
+   case-sensitive.
+
+   This role field MAY be used in conjunction with the Mimetype
+   Section 5.1.25 to fully describe the content of the track.
+
+   Table 4: Reserved track roles
+
+              +==================+==========================+
+              | Role             | Description              |
+              +==================+==========================+
+              | audiodescription | An audio description for |
+              |                  | visually impaired users  |
+              +------------------+--------------------------+
+              | video            | Visual content           |
+              +------------------+--------------------------+
+              | audio            | Audio content            |
+              +------------------+--------------------------+
+              | mediatimeline    | An MSF media timeline    |
+              |                  | Section 7                |
+              +------------------+--------------------------+
+              | eventtimeline    | An MSF event timeline    |
+              |                  | Section 8                |
+              +------------------+--------------------------+
+              | caption          | A textual representation |
+              |                  | of the audio track       |
+              +------------------+--------------------------+
+              | subtitle         | A transcription of the   |
+              |                  | spoken dialogue          |
+              +------------------+--------------------------+
+              | signlanguage     | A visual track for       |
+              |                  | hearing impaired users.  |
+              +------------------+--------------------------+
+
+                                  Table 4
+
+
+
+Law                       Expires 23 July 2026                 [Page 12]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+   Custom roles MAY be used as long as they do not collide with the
+   specified roles.
+
+5.1.15.  Is Live
+
+   Location: T Required: Yes JSON Type: Boolean
+
+   True if new Objects will be added to the track.  False if no new
+   Objects will be added to the track.  This is sent under two possible
+   conditions: * the publisher of a previously live track has ended the
+   track. * the track is Video-On-Demand (VOD) and was never live.
+
+5.1.16.  Target latency
+
+   Location: T Required: Optional JSON Type: Number
+
+   The target latency in milliseconds.  Target latency is defined as the
+   offset in wallclock time between when content was encoded and when it
+   is displayed to the end user.  For example, if a frame of video is
+   encoded at 10:08:32.638 UTC and the target latency is 5000, then that
+   frame should be rendered to the end-user at 10:08:37.638 UTC.  This
+   field MUST NOT be included if isLive is FALSE.  All tracks belonging
+   to the same render group MUST have identical target latencies.  All
+   tracks belonging to the same alternate group MUST have identical
+   target latencies.  If this field is absent from the track definition,
+   then the player MAY choose the latency with which it renders the
+   content.
+
+5.1.17.  Track label
+
+   Location: T Required: Optional JSON Type: String
+
+   A string defining a human-readable label for the track.  Examples
+   might be "Overhead camera view" or "Deutscher Kommentar".  Note that
+   the [JSON] spec requires UTF-8 support by decoders.
+
+5.1.18.  Render group
+
+   Location: T Required: Optional JSON Type: Number
+
+   An integer specifying a group of tracks which are designed to be
+   rendered together.  Tracks with the same group number SHOULD be
+   rendered simultaneously, are time-aligned and are designed to
+   accompany one another.  A common example would be tying together
+   audio and video tracks.
+
+
+
+
+
+
+Law                       Expires 23 July 2026                 [Page 13]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+5.1.19.  Alternate group
+
+   Location: T Required: Optional JSON Type: Number
+
+   An integer specifying a group of tracks which are alternate versions
+   of one-another.  Alternate tracks represent the same media content,
+   but differ in their selection properties.  Alternate tracks MUST have
+   matching media time sequences.  A subscriber typically subscribes to
+   one track from a set of tracks specifying the same alternate group
+   number.  A common example would be a set video tracks of the same
+   content offered in alternate bitrates.
+
+5.1.20.  Initialization data
+
+   Location: T Required: Optional JSON Type: String
+
+   A string holding Base64 [BASE64] encoded initialization data for the
+   track.
+
+5.1.21.  Dependencies
+
+   Location: T Required: Optional JSON Type: Array
+
+   Certain tracks may depend on other tracks for decoding.  Dependencies
+   holds an array of track names Section 5.1.11 on which the current
+   track is dependent.  Since only the track name is signaled, the
+   namespace of the dependencies is assumed to match that of the track
+   declaring the dependencies.
+
+5.1.22.  Temporal ID
+
+   Location: T Required: Optional JSON Type: Number
+
+   A number identifying the temporal layer/sub-layer encoding of the
+   track, starting with 0 for the base layer, and increasing by 1 for
+   the next higher temporal fidelity.
+
+5.1.23.  Spatial ID
+
+   Location: T Required: Optional JSON Type: Number
+
+   A number identifying the spatial layer encoding of the track,
+   starting with 0 for the base layer, and increasing by 1 for the next
+   higher fidelity.
+
+
+
+
+
+
+
+Law                       Expires 23 July 2026                 [Page 14]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+5.1.24.  Codec
+
+   Location: T Required: Optional JSON Type: String
+
+   A string defining the codec used to encode the track.  For LOC
+   packaged content, the string codec registrations are defined in Sect
+   3 and Section 4 of [WEBCODECS-CODEC-REGISTRY].
+
+5.1.25.  Mimetype
+
+   Location: T Required: Optional JSON Type: String
+
+   A string defining the mime type [MIME] of the track.
+
+5.1.26.  Framerate
+
+   Location: T Required: Optional JSON Type: Number
+
+   A number defining the video framerate of the track, expressed as
+   frames per second.
+
+5.1.27.  Timescale
+
+   Location: T Required: Optional JSON Type: Number
+
+   The number of time units that pass per second.
+
+5.1.28.  Bitrate
+
+   Location: T Required: Optional JSON Type: Number
+
+   A number defining the bitrate of track, expressed in bits per second.
+
+5.1.29.  Width
+
+   Location: T Required: Optional JSON Type: Number
+
+   A number expressing the encoded width of the video frames in pixels.
+
+5.1.30.  Height
+
+   Location: T Required: Optional JSON Type: Number
+
+   A number expressing the encoded height of the video frames in pixels.
+
+
+
+
+
+
+
+Law                       Expires 23 July 2026                 [Page 15]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+5.1.31.  Audio sample rate
+
+   Location: T Required: Optional JSON Type: Number
+
+   The number of audio frame samples per second.  This property SHOULD
+   only accompany audio codecs.
+
+5.1.32.  Channel configuration
+
+   Location: T Required: Optional JSON Type: String
+
+   A string specifying the audio channel configuration.  This property
+   SHOULD only accompany audio codecs.  A string is used in order to
+   provide the flexibility to describe complex channel configurations
+   for multi-channel and Next Generation Audio schemas.
+
+5.1.33.  Display width
+
+   Location: T Required: Optional JSON Type: Number
+
+   A number expressing the intended display width of the track content
+   in pixels.
+
+5.1.34.  Display height
+
+   Location: T Required: Optional JSON Type: Number
+
+   A number expressing the intended display height of the track content
+   in pixels.
+
+5.1.35.  Language
+
+   Location: T Required: Optional JSON Type: String
+
+   A string defining the dominant language of the track.  The string
+   MUST be one of the standard Tags for Identifying Languages as defined
+   by [LANG].
+
+5.1.36.  Parent name
+
+   Location: T Required: Optional JSON Type: String
+
+   A string defining the parent track name Section 5.1.11 to be cloned.
+   This field MUST only be included inside a Clone tracks Section 5.1.5
+   object.
+
+
+
+
+
+
+Law                       Expires 23 July 2026                 [Page 16]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+5.1.37.  Track duration
+
+   Location: T Required: Optional JSON Type: Number
+
+   The duration of the track expressed in integer milliseconds.  This
+   field MUST NOT be included if the isLive Section 5.1.15 field value
+   is true.
+
+5.2.  Delta updates
+
+   A catalog update might contain incremental changes.  This is a useful
+   property if many tracks may be initially declared but then there are
+   small changes to a subset of tracks.  The producer can issue a delta
+   update to describe these changes.  Changes are described
+   incrementally, meaning that a delta update can itself modify a prior
+   delta update.
+
+   A restricted set of operations are allowed with each delta update: *
+   Add a new track that has not previously been declared. * Add a new
+   track by cloning a previously declared track. * Remove a track that
+   has been previously declared.
+
+   The following rules are to be followed in constructing and processing
+   delta updates:
+
+   *  A delta update MUST include the Delta Update Section 5.1.2 field
+      set to true.
+
+   *  A delta update catalog MUST contain at least one instance of Add
+      tracks Section 5.1.3, Remove tracks Section 5.1.4 or Clone Tracks
+      Section 5.1.5 fields and MAY contain more.  It MUST NOT contain an
+      instance of a Tracks Section 5.1.8 field or an MSF version
+      Section 5.1.1 field.
+
+   *  The Add, Delete and Clone operations are applied sequentially in
+      the order they are declared in the document.  Each operation in
+      the sequence is applied to the target document; the resulting
+      document becomes the target of the next operation.  Evaluation
+      continues until all operations are successfully applied.
+
+   *  A Cloned track inherits all the attributes of the track defined by
+      the Parent Name Section 5.1.36, except the Track Name which MUST
+      be new.  Attributes redefined in the cloning Object overwrite
+      inherited values.
+
+
+
+
+
+
+
+Law                       Expires 23 July 2026                 [Page 17]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+   *  The tuple of Track Namespace and Track Name defines a fixed set of
+      Track attributes which MUST NOT be modified after being declared.
+      To modify any attribute, a new track with a different
+      Namespace|Name tuple is created by Adding or Cloning and then the
+      old track is removed.
+
+5.3.  Catalog Examples
+
+   The following section provides non-normative JSON examples of various
+   catalogs compliant with this draft.
+
+5.3.1.  Time-aligned Audio/Video Tracks with single quality
+
+   This example shows a catalog for a media producer capable of sending
+   LOC packaged, time-aligned audio and video tracks.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Law                       Expires 23 July 2026                 [Page 18]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+   {
+     "version": 1,
+     "generatedAt": 1746104606044,
+     "tracks": [
+       {
+         "name": "1080p-video",
+         "namespace": "conference.example.com/conference123/alice",
+         "packaging": "loc",
+         "isLive": true,
+         "targetLatency": 2000,
+         "role": "video",
+         "renderGroup": 1,
+         "codec":"av01.0.08M.10.0.110.09",
+         "width":1920,
+         "height":1080,
+         "framerate":30,
+         "bitrate":1500000
+       },
+       {
+         "name": "audio",
+         "namespace": "conference.example.com/conference123/alice",
+         "packaging": "loc",
+         "isLive": true,
+         "targetLatency": 2000,
+         "role": "audio",
+         "renderGroup": 1,
+         "codec":"opus",
+         "samplerate":48000,
+         "channelConfig":"2",
+         "bitrate":32000
+       }
+      ]
+   }
+
+5.3.2.  Simulcast video tracks - 3 alternate qualities along with audio
+
+   This example shows catalog for a media producer capable of sending 3
+   time-aligned video tracks for high definition, low definition and
+   medium definition video qualities, along with an audio track.  In
+   this example the namespace is absent, which infers that each track
+   must inherit the namespace of the catalog.
+
+   {
+     "version": 1,
+     "generatedAt": 1746104606044,
+     "tracks":[
+       {
+         "name": "hd",
+
+
+
+Law                       Expires 23 July 2026                 [Page 19]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+         "renderGroup": 1,
+         "packaging": "loc",
+         "isLive": true,
+         "targetLatency": 1500,
+         "role": "video",
+         "codec":"av01",
+         "width":1920,
+         "height":1080,
+         "bitrate":5000000,
+         "framerate":30,
+         "altGroup":1
+       },
+       {
+         "name": "md",
+         "renderGroup": 1,
+         "packaging": "loc",
+         "isLive": true,
+         "targetLatency": 1500,
+         "role": "video",
+         "codec":"av01",
+         "width":720,
+         "height":640,
+         "bitrate":3000000,
+         "framerate":30,
+         "altGroup":1
+       },
+       {
+         "name": "sd",
+         "renderGroup": 1,
+         "packaging": "loc",
+         "isLive": true,
+         "targetLatency": 1500,
+         "role": "video",
+         "codec":"av01",
+         "width":192,
+         "height":144,
+         "bitrate":500000,
+         "framerate":30,
+         "altGroup":1
+       },
+       {
+         "name": "audio",
+         "renderGroup": 1,
+         "packaging": "loc",
+         "isLive": true,
+         "targetLatency": 1500,
+         "role": "audio",
+         "codec":"opus",
+
+
+
+Law                       Expires 23 July 2026                 [Page 20]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+         "samplerate":48000,
+         "channelConfig":"2",
+         "bitrate":32000
+       }
+      ]
+   }
+
+5.3.3.  SVC video tracks with 2 spatial and 2 temporal qualities
+
+   This example shows catalog for a media producer capable of sending
+   scalable video codec with 2 spatial and 2 temporal layers with a
+   dependency relation as shown below:
+
+                     +----------+
+        +----------->|  S1T1    |
+        |            | 1080p30  |
+        |            +----------+
+        |                  ^
+        |                  |
+   +----------+            |
+   |  S1TO    |            |
+   | 1080p15  |            |
+   +----------+      +-----+----+
+         ^           |  SOT1    |
+         |           | 480p30   |
+         |           +----------+
+         |               ^
+   +----------+          |
+   |  SOTO     |         |
+   | 480p15    |---------+
+   +----------+
+
+   The corresponding catalog uses "depends" attribute to express the
+   track relationships.
+
+   {
+     "version": 1,
+     "generatedAt": 1746104606044,
+     "tracks":[
+       {
+         "name": "480p15",
+         "namespace": "conference.example.com/conference123/alice",
+         "renderGroup": 1,
+         "packaging": "loc",
+         "isLive": true,
+         "role": "video",
+         "codec":"av01.0.01M.10.0.110.09",
+         "width":640,
+
+
+
+Law                       Expires 23 July 2026                 [Page 21]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+         "height":480,
+         "bitrate":3000000,
+         "framerate":15
+       },
+       {
+         "name": "480p30",
+         "namespace": "conference.example.com/conference123/alice",
+         "renderGroup": 1,
+         "packaging": "loc",
+         "isLive": true,
+         "role": "video",
+         "codec":"av01.0.04M.10.0.110.09",
+         "width":640,
+         "height":480,
+         "bitrate":3000000,
+         "framerate":30,
+         "depends": ["480p15"]
+       },
+       {
+         "name": "1080p15",
+         "namespace": "conference.example.com/conference123/alice",
+         "renderGroup": 1,
+         "packaging": "loc",
+         "isLive": true,
+         "role": "video",
+         "codec":"av01.0.05M.10.0.110.09",
+         "width":1920,
+         "height":1080,
+         "bitrate":3000000,
+         "framerate":15,
+         "depends":["480p15"]
+       },
+
+       {
+         "name": "1080p30",
+         "namespace": "conference.example.com/conference123/alice",
+         "renderGroup": 1,
+         "packaging": "loc",
+         "isLive": true,
+         "role": "video",
+         "codec":"av01.0.08M.10.0.110.09",
+         "width":1920,
+         "height":1080,
+         "bitrate":5000000,
+         "framerate":30,
+         "depends": ["480p30", "1080p15"]
+       },
+       {
+
+
+
+Law                       Expires 23 July 2026                 [Page 22]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+         "name": "audio",
+         "namespace": "conference.example.com/conference123/alice",
+         "renderGroup": 1,
+         "packaging": "loc",
+         "isLive": true,
+         "role": "audio",
+         "codec":"opus",
+         "samplerate":48000,
+         "channelConfig":"2",
+         "bitrate":32000
+       }
+      ]
+   }
+
+5.3.4.  Delta update - adding two tracks
+
+   This example shows the catalog delta update for a media producer
+   adding two tracks to an established video conference.  One track is
+   newly declared, the other is cloned from a previous track.
+
+   {
+     "deltaUpdate": true,
+     "generatedAt": 1746104606044,
+     "addTracks": [
+         {
+           "name": "slides",
+           "isLive": true,
+           "role": "video",
+           "codec": "av01.0.08M.10.0.110.09",
+           "width": 1920,
+           "height": 1080,
+           "framerate": 15,
+           "bitrate": 750000,
+           "renderGroup": 1
+         }
+      ],
+      "cloneTracks": [
+         {
+           "parentName": "video-1080",
+           "name": "video-720",
+           "width":1280,
+           "height":720,
+           "bitrate":600000
+         }
+      ]
+   }
+
+
+
+
+
+Law                       Expires 23 July 2026                 [Page 23]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+5.3.5.  Delta update removing tracks
+
+   This example shows a delta update for a media producer removing two
+   tracks from an established video conference.
+
+   {
+     "deltaUpdate": true,
+     "generatedAt": 1746104606044,
+     "removeTracks": [{"name": "video"},{"name": "slides"}]
+   }
+
+5.3.6.  Time-aligned Audio/Video Tracks with custom field values
+
+   This example shows catalog for a media producer capable of sending
+   LOC packaged, time-aligned audio and video tracks along with custom
+   fields in each track description.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Law                       Expires 23 July 2026                 [Page 24]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+   {
+     "version": 1,
+     "generatedAt": 1746104606044,
+     "tracks": [
+       {
+         "name": "1080p-video",
+         "namespace": "conference.example.com/conference123/alice",
+         "packaging": "loc",
+         "isLive": true,
+         "role": "video",
+         "renderGroup": 1,
+         "codec":"av01.0.08M.10.0.110.09",
+         "width":1920,
+         "height":1080,
+         "framerate":30,
+         "bitrate":1500000,
+         "com.example-billing-code": 3201,
+         "com.example-tier": "premium",
+         "com.example-debug": "h349835bfkjfg82394d945034jsdfn349fns"
+       },
+       {
+         "name": "audio",
+         "namespace": "conference.example.com/conference123/alice",
+         "packaging": "loc",
+         "isLive": true,
+         "role": "audio",
+         "renderGroup": 1,
+         "codec":"opus",
+         "samplerate":48000,
+         "channelConfig":"2",
+         "bitrate":32000
+       }
+      ]
+   }
+
+5.3.7.  Time-aligned VOD Audio/Video Tracks
+
+   This example shows catalog for a media producer offering VOD (video
+   on-demand) non-live content.  The content is LOC packaged, and
+   includes time-aligned audio and video tracks.
+
+
+
+
+
+
+
+
+
+
+
+Law                       Expires 23 July 2026                 [Page 25]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+   {
+     "version": 1,
+     "tracks": [
+       {
+         "name": "video",
+         "namespace": "movies.example.com/assets/boy-meets-girl-season3/episode5",
+         "packaging": "loc",
+         "isLive": false,
+         "trackDuration": 8072340,
+         "renderGroup": 1,
+         "codec":"av01.0.08M.10.0.110.09",
+         "width":1920,
+         "height":1080,
+         "framerate":30,
+         "bitrate":1500000
+       },
+       {
+         "name": "audio",
+         "namespace": "movies.example.com/assets/boy-meets-girl-season3/episode5",
+         "packaging": "loc",
+         "isLive": false,
+         "trackDuration": 8072340,
+         "renderGroup": 1,
+         "codec":"opus",
+         "samplerate":48000,
+         "channelConfig":"2",
+         "bitrate":32000
+       }
+      ]
+   }
+
+5.3.8.  Media timeline and Event timeline
+
+   This example shows a catalog for a media producer capable of sending
+   LOC packaged, time-aligned audio and video tracks, along with a Media
+   Timeline which describes the history of those tracks and an Event
+   Timeline providing synchronized data.
+
+   {
+     "version": 1,
+     "generatedAt": 1746104606044,
+     "tracks": [
+       {
+         "name": "history",
+         "namespace": "conference.example.com/conference123/alice",
+         "packaging": "mediatimeline",
+         "mimetype": "application/json",
+         "depends": ["1080p-video","audio"]
+
+
+
+Law                       Expires 23 July 2026                 [Page 26]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+       },
+       {
+         "name": "identified-objects",
+         "namespace": "another-provider/time-synchronized-data",
+         "packaging": "eventtimeline",
+         "eventType": "com.ai-extraction/appID/v3",
+         "mimetype": "application/json",
+         "depends": ["1080p-video"]
+       },
+       {
+         "name": "1080p-video",
+         "namespace": "conference.example.com/conference123/alice",
+         "packaging": "loc",
+         "isLive": true,
+         "targetLatency": 2000,
+         "role": "video",
+         "renderGroup": 1,
+         "codec":"av01.0.08M.10.0.110.09",
+         "width":1920,
+         "height":1080,
+         "framerate":30,
+         "bitrate":1500000
+       },
+       {
+         "name": "audio",
+         "namespace": "conference.example.com/conference123/alice",
+         "packaging": "loc",
+         "isLive": true,
+         "targetLatency": 2000,
+         "role": "audio",
+         "renderGroup": 1,
+         "codec":"opus",
+         "samplerate":48000,
+         "channelConfig":"2",
+         "bitrate":32000
+       }
+      ]
+   }
+
+5.3.9.  Terminating a live broadcast
+
+   This example shows catalog for a media producer terminating a
+   previously live broadcast containing a video and an audio track.
+
+
+
+
+
+
+
+
+Law                       Expires 23 July 2026                 [Page 27]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+   {
+     "version": 1,
+     "generatedAt": 1746104606044,
+     "isComplete": true,
+     "tracks": []
+   }
+
+6.  Media transmission
+
+   The MOQT Groups and MOQT Objects need to be mapped to MOQT Streams.
+   Irrespective of the Section 4 in place, each MOQT Object MUST be
+   mapped to a new MOQT Stream.
+
+6.1.  Group numbering
+
+   The Group ID of the first Group published in a track at application
+   startup MUST be a unique integer that will not repeat in the future.
+   One approach to achieve this is to set the initial Group ID to the
+   creation time of the first Object in the group, represented as the
+   number of milliseconds since the Unix epoch, rounded to the nearest
+   millisecond.  This ensures that republishing the same track in the
+   future, such as after a loss of connectivity or an encoder restart,
+   will not result in smaller or duplicate Group IDs for the same track
+   name.  Note that this method does not prevent duplication if more
+   than 1000 groups are published per second.
+
+   Each subsequent Group ID MUST increase by 1.
+
+   If a publisher is able to maintain state across a republish, it MUST
+   signal the gap in Group IDs using the MOQT Prior Group ID Gap
+   Extension header.
+
+7.  Media Timeline track
+
+   The media timeline track provides data about the previously published
+   groups and their relationship to wallclock time and media time.
+   Media timeline tracks allow players to seek to precise points behind
+   the live head in a live broadcast, or for random access in a VOD
+   asset.  Media timeline tracks are optional.  Multiple media timeline
+   tracks can exist inside a catalog.
+
+7.1.  Media Timeline track payload
+
+   A media timeline track is a JSON [JSON] document.  This document MAY
+   be compressed using GZIP [GZIP].  The document contains an array of
+   records.  Each record consists of an array of three required items,
+   whose ordinal position defines their type:
+
+
+
+
+Law                       Expires 23 July 2026                 [Page 28]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+   *  The first item holds the media presentation timestamp, expressed
+      as a JSON Number.  This value MUST match the media presentation
+      timestamp, rounded to the nearest millisecond, of the first media
+      sample in the referenced Object
+
+   *  The second item holds the MOQT Location of the entry, defined as a
+      tuple of the MOQT Group ID and MOQT Object ID, and expressed as a
+      JSON Array of Numbers, where the first number is the Group ID and
+      the second number is the Object ID.
+
+   *  The third time holds the wallclock time at which the media was
+      encoded, defined as the number of milliseconds that have elapsed
+      since January 1, 1970 (midnight UTC/GMT) and expressed as a JSON
+      Number.  For VOD assets, or if the wallclock time is not known,
+      the value SHOULD be 0.
+
+   An example media timeline is shown below:
+
+   [
+     [0, [0,0], 1759924158381],
+     [2002, [1,0], 1759924160383],
+     [4004, [2,0], 1759924162385],
+     [6006, [3,0], 1759924164387],
+     [8008, [4,0], 1759924166389]
+   ]
+
+7.2.  Media Timeline Catalog requirements
+
+   A media timeline track MUST carry a 'packaging' identifier in the
+   Catalog with a value of "mediatimeline".  A media timeline track MUST
+   carry a 'depends' attribute which contains an array of all track
+   names to which the media timeline track applies.  The mime-type of a media
+   timeline track MUST be specified as "application/json".
+
+7.3.  Media Timeline track updating
+
+   The publisher MUST publish an independent media timeline in the first
+   MOQT Object of each MOQT Group of a media timeline track.  The
+   publisher MAY publish incremental updates in the second and
+   subsequent Objects within each Group.  Incremental updates only
+   contain media timeline records since the last media timeline Object.
+
+8.  Event Timeline track
+
+   The event timeline track provides a mechanism to associate ad-hoc
+   event metadata with the broadcast.  Use-case examples include live
+   sports score data, GPS coordinates of race cars, SAP-types for media
+   segments or active speaker notifications in web conferences.
+
+
+
+Law                       Expires 23 July 2026                 [Page 29]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+   To allow the client to bind this event metadata with the broadcast
+   content described by the media timeline track, each event record MUST
+   contain a reference to one of Media PTS, wallclock time or MOQT
+   Location.
+
+   Event timeline tracks are optional.  Multiple event timeline tracks
+   can exist inside a catalog.  The type & structure of the data
+   contained within each event timeline track is declared in the
+   catalog, to facilitate client selection and parsing.
+
+8.1.  Event Timeline data format
+
+   An event timeline track is a JSON [JSON] document.  This document MAY
+   be compressed using GZIP [GZIP].  The document contains an array of
+   records.  Each record consists of a JSON Object containing the
+   following required fields:
+
+   *  An index reference, which MUST be either 't' for wallclock time,
+      'l' for Location or 'm' for Media PTS.  Only one of these index
+      values may be used within each record.  Event timelines SHOULD use
+      the same index reference type for each record.  The definitions
+      for wallclock time, Location and Media PTS are identical to those
+      defined for media timeline payload Section 7.1.  Wallclock time
+      and media PTS values are JSON Number, while Location value is an
+      Array of Numbers, where the first item represents the MOQT GroupID
+      and the second item the MOQT Object ID.
+
+   *  A 'data' Object, whose structure is defined by the Section 5.1.13
+      value declared for this track in the Catalog.
+
+8.2.  Event Timeline Catalog requirements
+
+   An event timeline track MUST carry:
+
+   *  a Section 5.1.12 attribute with a value of "eventtimeline".
+
+   *  a Section 5.1.21 attribute which contains an array of all track
+      names to which the event timeline track applies.
+
+   *  a Section 5.1.25 attribute with a value of "application/json".
+
+   *  an Section 5.1.13 attribute declaring the type & structure of data
+      contained in the event timeline track.
+
+
+
+
+
+
+
+
+Law                       Expires 23 July 2026                 [Page 30]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+8.3.  Event Timeline track updating
+
+   The publisher MUST publish an independent event timeline in the first
+   MOQT Object of each MOQT Group of an event timeline track.  The
+   publisher MAY publish incremental updates in the second and
+   subsequent Objects within each Group.  Incremental updates only
+   contain event timeline records since the last event timeline Object.
+
+8.4.  Event timeline track examples
+
+8.4.1.  Event timeline track with wallclock time indexing
+
+   This example shows how sports scores and game information might be
+   defined in a live sports broadcast.
+
+   [
+       {
+           "t": 1756885678361,
+           "data": {
+               "status": "in_progress",
+               "period": 1,
+               "clock": "12:00",
+               "homeScore": 0,
+               "awayScore": 0,
+               "lastPlay": "Game Start"
+           }
+       },
+       {
+           "t": 1756885981542,
+           "data": {
+               "status": "in_progress",
+               "period": 1,
+               "clock": "09:25",
+               "homeScore": 2,
+               "awayScore": 0,
+               "lastPlay": "Team A: #23 makes 2-pt jump shot"
+           }
+       }
+   ]
+
+8.4.2.  Event timeline track with MOQT Location indexing
+
+   This example shows drone GPS coordinates synched with the start of
+   each Group.
+
+
+
+
+
+
+
+Law                       Expires 23 July 2026                 [Page 31]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+   [
+       {
+           "l": [0,0],
+           "data": [47.1812,8.4592]
+       },
+       {
+           "l": [1,0],
+           "data": [47.1662,8.5155]
+       }
+   ]
+
+9.  Workflow
+
+9.1.  Initiating a broadcast
+
+   An MSF publisher MUST publish a catalog track object before
+   publishing any media track objects.
+
+9.2.  Ending a live broadcast
+
+   After publishing a catalog and defining tracks carrying live content,
+   an original publisher can deliver a deterministic signal to all
+   subscribers that the broadcast is complete by taking the following
+   steps:
+
+   *  Send a SUBSCRIBE_DONE (See MOQT Sect 8.1.2) message for all active
+      tracks using status code 0x2 Track Ended.
+
+   *  If the live stream is being converted instantly to a VOD asset,
+      then publish an independent (non-delta) catalog update which, for
+      each track, sets isLive Section 5.1.15 to FALSE and adds a track
+      duration Section 5.1.37 field.
+
+   *  If the live stream is being terminated permanently without
+      conversion to VOD, then publish an independent catalog update
+      which signals isComplete Section 5.1.7 as TRUE and which contains
+      an empty Tracks Section 5.1.8 field.
+
+10.  Security Considerations
+
+   MSF inherits the security properties of the underlying MoQ
+   Transport protocol [MoQTransport] and its associated transport
+   security mechanisms (TLS 1.3 over QUIC or WebTransport).
+
+   Threat Model:  Attackers may be on-path (e.g., compromised relays)
+      or off-path.  They may attempt to eavesdrop on media content,
+      inject or modify track data, replay previously captured Groups
+      or Objects, or disrupt service availability through resource
+      exhaustion or malformed messages.
+
+   Confidentiality and Integrity:  Media content and catalog metadata
+      are protected in transit by the underlying QUIC transport
+      encryption.  However, relay nodes can observe and modify
+      content.  Applications requiring end-to-end confidentiality
+      SHOULD apply payload-level encryption (e.g., Secure Frame
+      [SFrame]) above the MSF layer.
+
+   Authentication and Authorization:  Implementations MUST
+      authenticate publishers and subscribers before allowing them
+      to announce or consume MSF tracks.  Authorization SHOULD be
+      enforced per-track or per-broadcast path.  Credentials MUST
+      have bounded lifetimes and implementations SHOULD support
+      revocation.
+
+   Replay and Denial of Service:  The underlying QUIC transport
+      provides replay protection through its nonce-based encryption.
+      Implementations MUST impose limits on catalog size, track
+      count, Group rate, and Object sizes to prevent resource
+      exhaustion.  Relays SHOULD apply rate limiting and
+      backpressure to protect downstream consumers from floods of
+      data or announcements.
+
+   Catalog Integrity:  The MSF catalog (Section 5) describes the
+      structure of a broadcast and is critical to correct operation.
+      A malicious or compromised publisher could advertise misleading
+      codec parameters, invalid track dependencies, or excessive
+      track counts.  Receivers MUST validate catalog contents and
+      SHOULD reject catalogs that exceed implementation-defined
+      complexity limits.
+
+   Privacy and Metadata:  MSF track names, catalog fields (codec,
+      bitrate, resolution, temporal properties), and media timeline
+      metadata may reveal information about content and users.
+      Implementations SHOULD minimize metadata exposure to untrusted
+      intermediaries.  The 'renderGroup' and temporal ordering
+      metadata in particular may allow traffic analysis of media
+      structure even when payloads are encrypted.
+
+   Interoperability:  Implementations that do not fully validate
+      MSF catalog fields or track packaging types may be vulnerable
+      to unexpected behavior when interoperating with other
+      implementations.  Receivers MUST gracefully handle unknown
+      catalog fields and SHOULD ignore unrecognized packaging types
+      rather than crashing.
+
+   Operational Guidance:  Deployments SHOULD log authentication
+      failures, authorization denials, and malformed catalog or
+      track data for monitoring.  Error responses MUST NOT leak
+      internal state or configuration to unauthenticated peers.
+      Implementations SHOULD follow the guidance in [RFC3552] for
+      security considerations in protocol design.
+
+11.  IANA Considerations
+
+   This document creates a new entry in the "MoQ Streaming Format"
+   Registry (see [MoQTransport] Sect 8).  The type value is 0x001, the
+   name is "MOQT Streaming Format" and the RFC is XXX.
+
+
+
+
+Law                       Expires 23 July 2026                 [Page 32]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+12.  Normative References
+
+   [BASE64]   Josefsson, S., "The Base16, Base32, and Base64 Data
+              Encodings", RFC 4648, DOI 10.17487/RFC4648, October 2006,
+              <https://www.rfc-editor.org/rfc/rfc4648>.
+
+   [GZIP]     Deutsch, P., "GZIP file format specification version 4.3",
+              RFC 1952, DOI 10.17487/RFC1952, May 1996,
+              <https://www.rfc-editor.org/rfc/rfc1952>.
+
+   [IMSC1]    "W3C, TTML Profiles for Internet Media Subtitles and
+              Captions 1.0 (IMSC1)", April 2016,
+              <https://www.w3.org/TR/ttml-imsc1/>.
+
+   [JSON]     Bray, T., Ed., "The JavaScript Object Notation (JSON) Data
+              Interchange Format", STD 90, RFC 8259,
+              DOI 10.17487/RFC8259, December 2017,
+              <https://www.rfc-editor.org/rfc/rfc8259>.
+
+   [LANG]     Phillips, A., Ed. and M. Davis, Ed., "Tags for Identifying
+              Languages", BCP 47, RFC 5646, DOI 10.17487/RFC5646,
+              September 2009, <https://www.rfc-editor.org/rfc/rfc5646>.
+
+   [LOC]      Zanaty, M., Nandakumar, S., and P. Thatcher, "Low Overhead
+              Media Container", Work in Progress, Internet-Draft, draft-
+              mzanaty-moq-loc-05, 3 March 2025,
+              <https://datatracker.ietf.org/doc/html/draft-mzanaty-moq-
+              loc-05>.
+
+   [MIME]     Freed, N., Klensin, J., and T. Hansen, "Media Type
+              Specifications and Registration Procedures", BCP 13,
+              RFC 6838, DOI 10.17487/RFC6838, January 2013,
+              <https://www.rfc-editor.org/rfc/rfc6838>.
+
+   [MoQTransport]
+              Nandakumar, S., Vasiliev, V., Swett, I., and A. Frindell,
+              "Media over QUIC Transport", Work in Progress, Internet-
+              Draft, draft-ietf-moq-transport-11, 28 April 2025,
+              <https://datatracker.ietf.org/doc/html/draft-ietf-moq-
+              transport-11>.
+
+   [RFC2119]  Bradner, S., "Key words for use in RFCs to Indicate
+              Requirement Levels", BCP 14, RFC 2119,
+              DOI 10.17487/RFC2119, March 1997,
+              <https://www.rfc-editor.org/rfc/rfc2119>.
+
+
+
+
+
+
+Law                       Expires 23 July 2026                 [Page 33]
+
+Internet-Draft            MOQT Streaming Format             January 2026
+
+
+   [RFC4180]  Shafranovich, Y., "Common Format and MIME Type for Comma-
+              Separated Values (CSV) Files", RFC 4180,
+              DOI 10.17487/RFC4180, October 2005,
+              <https://www.rfc-editor.org/rfc/rfc4180>.
+
+   [RFC8174]  Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC
+              2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174,
+              May 2017, <https://www.rfc-editor.org/rfc/rfc8174>.
+
+   [RFC9000]  Iyengar, J., Ed. and M. Thomson, Ed., "QUIC: A UDP-Based
+              Multiplexed and Secure Transport", RFC 9000,
+              DOI 10.17487/RFC9000, May 2021,
+              <https://www.rfc-editor.org/rfc/rfc9000>.
+
+   [WEBCODECS-CODEC-REGISTRY]
+              "WebCodecs Codec Registry", September 2024,
+              <https://www.w3.org/TR/webcodecs-codec-registry/>.
+
+   [WEBVTT]   "World Wide Web Consortium (W3C), WebVTT: The Web Video
+              Text Tracks Format", April 2019,
+              <https://www.w3.org/TR/webvtt1/>.
+
+Acknowledgments
+
+   *  the MoQ Workgroup and mailing lists.
+
+Contributors
+
+   The following persons where the co-authors of the individual draft
+   (draft-law-moq-warpstreamingformat) this document is based on:
+
+   *  Luke Curley
+
+   *  Victor Vasiliev
+
+   *  Suhas Nandakumar
+
+   *  Kirill Pugin
+
+   *  Will Law
+
+Author's Address
+
+   Will Law
+   Akamai
+   Email: wilaw@akamai.com
+
+
+
+
+
+Law                       Expires 23 July 2026                 [Page 34]
diff --git a/js/clock/src/main.ts b/js/clock/src/main.ts
index 873e764e8..651646630 100755
--- a/js/clock/src/main.ts
+++ b/js/clock/src/main.ts
@@ -147,7 +147,7 @@ async function subscribe(config: Config) {
 
 	// Handle groups and frames like the Rust implementation
 	for (;;) {
-		const group = await track.nextGroup();
+		const group = await track.recvGroup();
 		if (!group) {
 			console.log("❌ Connection ended");
 			break;
diff --git a/js/hang/src/catalog/audio.ts b/js/hang/src/catalog/audio.ts
index 47178addc..2403aa545 100644
--- a/js/hang/src/catalog/audio.ts
+++ b/js/hang/src/catalog/audio.ts
@@ -1,6 +1,7 @@
 import * as z from "zod/mini";
 import { ContainerSchema } from "./container";
 import { u53Schema } from "./integers";
+import { Section } from "./section";
 
 // Backwards compatibility: old track schema
 const TrackSchema = z.object({
@@ -60,3 +61,6 @@ export const AudioSchema = z.union([
 
 export type Audio = z.infer<typeof AudioSchema>;
 export type AudioConfig = z.infer<typeof AudioConfigSchema>;
+
+/// Predefined section for audio catalog data.
+export const AUDIO = new Section("audio", AudioSchema);
diff --git a/js/hang/src/catalog/capabilities.ts b/js/hang/src/catalog/capabilities.ts
deleted file mode 100644
index b1f4df8ce..000000000
--- a/js/hang/src/catalog/capabilities.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import * as z from "zod/mini";
-
-export const VideoCapabilitiesSchema = z.object({
-	hardware: z.optional(z.array(z.string())),
-	software: z.optional(z.array(z.string())),
-	unsupported: z.optional(z.array(z.string())),
-});
-
-export const AudioCapabilitiesSchema = z.object({
-	hardware: z.optional(z.array(z.string())),
-	software: z.optional(z.array(z.string())),
-	unsupported: z.optional(z.array(z.string())),
-});
-
-export const CapabilitiesSchema = z.object({
-	video: z.optional(VideoCapabilitiesSchema),
-	audio: z.optional(AudioCapabilitiesSchema),
-});
-
-export type Capabilities = z.infer<typeof CapabilitiesSchema>;
-export type VideoCapabilities = z.infer<typeof VideoCapabilitiesSchema>;
-export type AudioCapabilities = z.infer<typeof AudioCapabilitiesSchema>;
diff --git a/js/hang/src/catalog/chat.ts b/js/hang/src/catalog/chat.ts
deleted file mode 100644
index d012b96fe..000000000
--- a/js/hang/src/catalog/chat.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-import * as z from "zod/mini";
-import { TrackSchema } from "./track";
-
-export const ChatSchema = z.object({
-	message: z.optional(TrackSchema),
-	typing: z.optional(TrackSchema),
-});
-
-export type Chat = z.infer<typeof ChatSchema>;
diff --git a/js/hang/src/catalog/container.ts b/js/hang/src/catalog/container.ts
index c5c14ff32..ee077ba8d 100644
--- a/js/hang/src/catalog/container.ts
+++ b/js/hang/src/catalog/container.ts
@@ -1,5 +1,4 @@
 import * as z from "zod/mini";
-import { u53Schema } from "./integers";
 
 /**
  * Container format for frame timestamp encoding and frame payload structure.
@@ -7,19 +6,17 @@ import { u53Schema } from "./integers";
  * - "legacy": Uses QUIC VarInt encoding (1-8 bytes, variable length), raw frame payloads.
  *             Timestamps are in microseconds.
  * - "cmaf": Fragmented MP4 container - frames contain complete moof+mdat fragments.
- *           Timestamps are in timescale units.
+ *           The init segment (ftyp+moov) is base64-encoded in the catalog.
  */
 export const ContainerSchema = z._default(
 	z.discriminatedUnion("kind", [
 		// The default hang container
 		z.object({ kind: z.literal("legacy") }),
-		// CMAF container with timescale for timestamp conversion
+		// CMAF container with base64-encoded init segment (ftyp+moov)
 		z.object({
 			kind: z.literal("cmaf"),
-			// Time units per second
-			timescale: u53Schema,
-			// Track ID used in the moof/mdat fragments
-			trackId: u53Schema,
+			// Base64-encoded init segment (ftyp+moov)
+			initData: z.base64(),
 		}),
 	]),
 	{ kind: "legacy" },
diff --git a/js/hang/src/catalog/index.ts b/js/hang/src/catalog/index.ts
index ecf4e9daf..86aee07be 100644
--- a/js/hang/src/catalog/index.ts
+++ b/js/hang/src/catalog/index.ts
@@ -1,12 +1,9 @@
 export * from "./audio";
-export * from "./capabilities";
-export * from "./chat";
 export * from "./container";
 export * from "./integers";
-export * from "./location";
-export * from "./preview";
 export * from "./priority";
-export * from "./root";
+export * from "./reader";
+export * from "./section";
 export * from "./track";
-export * from "./user";
 export * from "./video";
+export * from "./writer";
diff --git a/js/hang/src/catalog/location.ts b/js/hang/src/catalog/location.ts
deleted file mode 100644
index 52055e511..000000000
--- a/js/hang/src/catalog/location.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-import * as z from "zod/mini";
-import { TrackSchema } from "./track";
-
-export const PositionSchema = z.object({
-	// The relative X position of the broadcast, from -1 to +1.
-	// This should be used for audio panning but can also be used for video positioning.
-	x: z.optional(z.number()),
-
-	// The relative Y position of the broadcast, from -1 to +1.
-	// This can be used for video positioning, and maybe audio panning.
-	y: z.optional(z.number()),
-
-	// The relative Z index of the broadcast, where larger values are closer to the viewer.
-	// This is used to break ties when there are multiple broadcasts at the same position.
-	z: z.optional(z.number()),
-
-	// The scale of the broadcast, where 1 is 100%
-	s: z.optional(z.number()),
-});
-
-export const LocationSchema = z.object({
-	// The initial position of the broadcaster, from -1 to +1 in both dimensions.
-	// If not provided, then the broadcaster is assumed to be at (0,0)
-	// This should be used for audio panning but can also be used for video positioning.
-	initial: z.optional(PositionSchema),
-
-	// If provided, then updates to the position are done via a separate Moq track.
-	// This is used to avoid a full catalog update every time we want to update a few bytes.
-	// TODO: These updates currently use JSON for simplicity, but we should use a binary format.
-	track: z.optional(TrackSchema),
-
-	// If set, then this broadcaster allows other peers to request position updates via this handle.
-	// We will have to discover and subscribe to their position updates.
-	handle: z.optional(z.string()),
-
-	// If provided, this broadcaster is signaling the location of other peers.
-	// The payload is a JSON blob keyed by handle for each peer.
-	peers: z.optional(TrackSchema),
-});
-
-export type Location = z.infer<typeof LocationSchema>;
-export type Position = z.infer<typeof PositionSchema>;
-
-export const PeersSchema = z.record(z.string(), PositionSchema);
-export type Peers = z.infer<typeof PeersSchema>;
diff --git a/js/hang/src/catalog/preview.ts b/js/hang/src/catalog/preview.ts
deleted file mode 100644
index ae8183b07..000000000
--- a/js/hang/src/catalog/preview.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import * as z from "zod/mini";
-
-export const PreviewSchema = z.object({
-	name: z.optional(z.string()), // name
-	avatar: z.optional(z.string()), // avatar
-
-	audio: z.optional(z.boolean()), // audio enabled
-	video: z.optional(z.boolean()), // video enabled
-
-	typing: z.optional(z.boolean()), // actively typing
-	chat: z.optional(z.boolean()), // chatted recently
-	screen: z.optional(z.boolean()), // screen sharing
-});
-
-export type Preview = z.infer<typeof PreviewSchema>;
diff --git a/js/hang/src/catalog/reader.ts b/js/hang/src/catalog/reader.ts
new file mode 100644
index 000000000..a08bf6a0a
--- /dev/null
+++ b/js/hang/src/catalog/reader.ts
@@ -0,0 +1,68 @@
+import type * as Moq from "@moq/lite";
+import { type Effect, type Getter, Signal } from "@moq/signals";
+import type { z } from "zod/mini";
+import type { Section } from "./section";
+
+/// A catalog reader that provides per-section change notifications.
+///
+/// Sections are registered with a name and Zod schema. When the catalog track
+/// receives a new frame, JSON is parsed and each registered section is validated
+/// and updated. Signal equality checking ensures subscribers only fire when
+/// their specific section's value actually changed.
+export class CatalogReader {
+	// biome-ignore lint/suspicious/noExplicitAny: we store heterogeneous section types
+	#sections = new Map<string, { schema: z.ZodMiniType<any>; signal: Signal<any> }>();
+
+	/// Register interest in a section. Returns a Getter<T | undefined>.
+	///
+	/// The getter updates when the catalog is re-fetched and this section's value differs.
+	section<T>(def: Section<T>): Getter<T | undefined> {
+		const existing = this.#sections.get(def.name);
+		if (existing) return existing.signal as Getter<T | undefined>;
+
+		const signal = new Signal<T | undefined>(undefined);
+		this.#sections.set(def.name, { schema: def.schema, signal });
+		return signal;
+	}
+
+	/// Start consuming from a MoQ track.
+	///
+	/// Spawns an async loop that reads frames, parses JSON, and updates
+	/// per-section signals. Unregistered keys in the JSON are ignored.
+	consume(track: Moq.Track, effect: Effect): void {
+		effect.spawn(async () => {
+			try {
+				for (;;) {
+					const frame = await Promise.race([effect.cancel, track.readFrame()]);
+					if (!frame) break;
+
+					const decoder = new TextDecoder();
+					const str = decoder.decode(frame);
+					const json = JSON.parse(str);
+
+					for (const [name, { schema, signal }] of this.#sections) {
+						const raw = json[name];
+						if (raw !== undefined) {
+							try {
+								const parsed = schema.parse(raw);
+								signal.set(parsed);
+							} catch (err) {
+								console.warn(`invalid catalog section "${name}"`, err);
+								signal.set(undefined);
+							}
+						} else {
+							signal.set(undefined);
+						}
+					}
+				}
+			} catch (err) {
+				console.warn("error reading catalog", err);
+			} finally {
+				// Clear all sections when the track ends
+				for (const { signal } of this.#sections.values()) {
+					signal.set(undefined);
+				}
+			}
+		});
+	}
+}
diff --git a/js/hang/src/catalog/root.ts b/js/hang/src/catalog/root.ts
deleted file mode 100644
index a025c6160..000000000
--- a/js/hang/src/catalog/root.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-import type * as Moq from "@moq/lite";
-import * as z from "zod/mini";
-
-import { AudioSchema } from "./audio";
-import { CapabilitiesSchema } from "./capabilities";
-import { ChatSchema } from "./chat";
-import { LocationSchema } from "./location";
-import { TrackSchema } from "./track";
-import { UserSchema } from "./user";
-import { VideoSchema } from "./video";
-
-export const RootSchema = z.object({
-	video: z.optional(VideoSchema),
-	audio: z.optional(AudioSchema),
-	location: z.optional(LocationSchema),
-	user: z.optional(UserSchema),
-	chat: z.optional(ChatSchema),
-	capabilities: z.optional(CapabilitiesSchema),
-	preview: z.optional(TrackSchema),
-});
-
-export type Root = z.infer<typeof RootSchema>;
-
-export function encode(root: Root): Uint8Array {
-	const encoder = new TextEncoder();
-	return encoder.encode(JSON.stringify(root));
-}
-
-export function decode(raw: Uint8Array): Root {
-	const decoder = new TextDecoder();
-	const str = decoder.decode(raw);
-	try {
-		const json = JSON.parse(str);
-		return RootSchema.parse(json);
-	} catch (error) {
-		console.warn("invalid catalog", str);
-		throw error;
-	}
-}
-
-export async function fetch(track: Moq.Track): Promise<Root | undefined> {
-	const frame = await track.readFrame();
-	if (!frame) return undefined;
-	return decode(frame);
-}
diff --git a/js/hang/src/catalog/section.ts b/js/hang/src/catalog/section.ts
new file mode 100644
index 000000000..5ed7a6c64
--- /dev/null
+++ b/js/hang/src/catalog/section.ts
@@ -0,0 +1,15 @@
+import type { z } from "zod/mini";
+
+/// A section definition that pairs a JSON key name with a Zod schema.
+///
+/// Used to register interest in specific catalog sections for reading or writing.
+/// Audio and video sections are predefined but not registered by default.
+export class Section<T> {
+	readonly name: string;
+	readonly schema: z.ZodMiniType<T>;
+
+	constructor(name: string, schema: z.ZodMiniType<T>) {
+		this.name = name;
+		this.schema = schema;
+	}
+}
diff --git a/js/hang/src/catalog/user.ts b/js/hang/src/catalog/user.ts
deleted file mode 100644
index 7f4a699c2..000000000
--- a/js/hang/src/catalog/user.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import * as z from "zod/mini";
-
-export const UserSchema = z.object({
-	id: z.optional(z.string()),
-	name: z.optional(z.string()),
-	avatar: z.optional(z.string()), // TODO allow using a track instead of a URL?
-	color: z.optional(z.string()),
-});
-
-export type User = z.infer<typeof UserSchema>;
diff --git a/js/hang/src/catalog/video.ts b/js/hang/src/catalog/video.ts
index dffb5e7cb..cb44e8c24 100644
--- a/js/hang/src/catalog/video.ts
+++ b/js/hang/src/catalog/video.ts
@@ -1,6 +1,7 @@
 import * as z from "zod/mini";
 import { ContainerSchema } from "./container";
 import { u53Schema } from "./integers";
+import { Section } from "./section";
 
 // Backwards compatibility: old track schema
 const TrackSchema = z.object({
@@ -103,3 +104,6 @@ export const VideoSchema = z.union([
 
 export type Video = z.infer<typeof VideoSchema>;
 export type VideoConfig = z.infer<typeof VideoConfigSchema>;
+
+/// Predefined section for video catalog data.
+export const VIDEO = new Section("video", VideoSchema);
diff --git a/js/hang/src/catalog/writer.ts b/js/hang/src/catalog/writer.ts
new file mode 100644
index 000000000..b6863bc54
--- /dev/null
+++ b/js/hang/src/catalog/writer.ts
@@ -0,0 +1,44 @@
+import type * as Moq from "@moq/lite";
+import { type Effect, Signal } from "@moq/signals";
+import type { Section } from "./section";
+
+/// A catalog writer that manages typed sections and serializes them to a MoQ track.
+///
+/// Each section is a Signal that can be set independently. When served on a track,
+/// changes are reactively detected and the full catalog JSON is re-serialized.
+/// Microtask coalescing in Signal means multiple set() calls in the same tick
+/// produce a single write.
+export class CatalogWriter {
+	// biome-ignore lint/suspicious/noExplicitAny: we store heterogeneous section types
+	#sections = new Map<string, { signal: Signal<any> }>();
+
+	/// Register a section for writing. Returns a Signal<T | undefined> for read+write.
+	section<T>(def: Section<T>): Signal<T | undefined> {
+		const existing = this.#sections.get(def.name);
+		if (existing) return existing.signal as Signal<T | undefined>;
+
+		const signal = new Signal<T | undefined>(undefined);
+		this.#sections.set(def.name, { signal });
+		return signal;
+	}
+
+	/// Serve the catalog on a MoQ track.
+	///
+	/// Uses Effect to reactively subscribe to all registered section signals.
+	/// When any signal changes, re-serializes and writes a new frame.
+	serve(track: Moq.Track, effect: Effect): void {
+		effect.run((inner) => {
+			const obj: Record<string, unknown> = {};
+
+			for (const [name, { signal }] of this.#sections) {
+				const value = inner.get(signal);
+				if (value !== undefined) {
+					obj[name] = value;
+				}
+			}
+
+			const encoder = new TextEncoder();
+			track.writeFrame(encoder.encode(JSON.stringify(obj)));
+		});
+	}
+}
diff --git a/js/hang/src/container/cmaf/decode.ts b/js/hang/src/container/cmaf/decode.ts
index b34e0f54e..9efba5d9e 100644
--- a/js/hang/src/container/cmaf/decode.ts
+++ b/js/hang/src/container/cmaf/decode.ts
@@ -278,11 +278,6 @@ export function decodeDataSegment(segment: Uint8Array, timescale: number): Sampl
 			throw new Error(`Invalid sample size ${sampleSize} for sample ${i} in trun`);
 		}
 
-		// Validate sample duration - must be positive for proper timing
-		if (sampleDuration <= 0) {
-			throw new Error(`Invalid sample duration ${sampleDuration} for sample ${i} in trun`);
-		}
-
 		// Bounds check before slicing to prevent reading past mdat data
 		if (dataOffset + sampleSize > mdatData.length) {
 			throw new Error(
diff --git a/js/hang/src/container/cmaf/encode.ts b/js/hang/src/container/cmaf/encode.ts
index 104cb4b98..923b6bae3 100644
--- a/js/hang/src/container/cmaf/encode.ts
+++ b/js/hang/src/container/cmaf/encode.ts
@@ -232,17 +232,14 @@ function createAvc1Box(width: number, height: number, avcC: Uint8Array): Uint8Ar
  * ```
  */
 export function createVideoInitSegment(config: Catalog.VideoConfig): Uint8Array {
-	const { codedWidth, codedHeight, description, container } = config;
+	const { codedWidth, codedHeight, description } = config;
 	if (!codedWidth || !codedHeight || !description) {
-		// TODO: We could
 		throw new Error("Missing required fields to create video init segment");
 	}
 
-	// Use timescale from CMAF container, or microseconds for legacy
-	const timescale = container.kind === "cmaf" ? container.timescale : 1_000_000;
-
-	// Use track_id from CMAF container, or default to 1 for legacy
-	const trackId = container.kind === "cmaf" ? container.trackId : 1;
+	// Legacy container always uses microsecond timescale and track ID 1
+	const timescale = 1_000_000;
+	const trackId = 1;
 
 	// ftyp - File Type Box
 	const ftyp: FileTypeBox = {
@@ -442,13 +439,11 @@ export function createVideoInitSegment(config: Catalog.VideoConfig): Uint8Array
  * Supports AAC (mp4a) and Opus codecs.
  */
 export function createAudioInitSegment(config: Catalog.AudioConfig): Uint8Array {
-	const { sampleRate, numberOfChannels, description, codec, container } = config;
-
-	// Use timescale from CMAF container, or microseconds for legacy
-	const timescale = container.kind === "cmaf" ? container.timescale : 1_000_000;
+	const { sampleRate, numberOfChannels, description, codec } = config;
 
-	// Use track_id from CMAF container, or default to 1 for legacy
-	const trackId = container.kind === "cmaf" ? container.trackId : 1;
+	// Legacy container always uses microsecond timescale and track ID 1
+	const timescale = 1_000_000;
+	const trackId = 1;
 
 	// ftyp - File Type Box
 	const ftyp: FileTypeBox = {
diff --git a/js/hang/src/container/legacy.ts b/js/hang/src/container/legacy.ts
index 70e265894..68498f88e 100644
--- a/js/hang/src/container/legacy.ts
+++ b/js/hang/src/container/legacy.ts
@@ -109,7 +109,7 @@ export class Consumer {
 	async #run() {
 		// Start fetching groups in the background
 		for (;;) {
-			const consumer = await this.#track.nextGroup();
+			const consumer = await this.#track.recvGroup();
 			if (!consumer) break;
 
 			// To improve TTV, we always start with the first group.
diff --git a/js/lite/examples/subscribe.ts b/js/lite/examples/subscribe.ts
index e294fdd6a..d2b4ca913 100644
--- a/js/lite/examples/subscribe.ts
+++ b/js/lite/examples/subscribe.ts
@@ -12,7 +12,7 @@ async function main() {
 
 	// Read data as it arrives
 	for (;;) {
-		const group = await track.nextGroup();
+		const group = await track.recvGroup();
 		if (!group) break;
 
 		for (;;) {
diff --git a/js/lite/src/connection/accept.ts b/js/lite/src/connection/accept.ts
index 45eb53d61..0a29938b5 100644
--- a/js/lite/src/connection/accept.ts
+++ b/js/lite/src/connection/accept.ts
@@ -26,6 +26,8 @@ export async function accept(transport: WebTransport, url: URL, props?: AcceptPr
 		return acceptAlpnVersion(transport, url, Ietf.Version.DRAFT_16);
 	} else if (protocol === Ietf.ALPN.DRAFT_15) {
 		return acceptAlpnVersion(transport, url, Ietf.Version.DRAFT_15);
+	} else if (protocol === Lite.ALPN_04) {
+		return new Lite.Connection(url, transport, Lite.Version.DRAFT_04, undefined);
 	} else if (protocol === Lite.ALPN_03) {
 		return new Lite.Connection(url, transport, Lite.Version.DRAFT_03, undefined);
 	} else if (protocol === Lite.ALPN || protocol === "" || protocol === undefined) {
diff --git a/js/lite/src/connection/connect.ts b/js/lite/src/connection/connect.ts
index 6a9026fa1..3620a724a 100644
--- a/js/lite/src/connection/connect.ts
+++ b/js/lite/src/connection/connect.ts
@@ -152,6 +152,9 @@ export async function connect(url: URL, props?: ConnectProps): Promise<Establish
 		setupVersion = Ietf.Version.DRAFT_16;
 	} else if (protocol === Ietf.ALPN.DRAFT_15) {
 		setupVersion = Ietf.Version.DRAFT_15;
+	} else if (protocol === Lite.ALPN_04) {
+		// moq-lite draft-04 doesn't use a session stream, so we return immediately.
+		return new Lite.Connection(url, session, Lite.Version.DRAFT_04, undefined);
 	} else if (protocol === Lite.ALPN_03) {
 		// moq-lite draft-03 doesn't use a session stream, so we return immediately.
 		return new Lite.Connection(url, session, Lite.Version.DRAFT_03, undefined);
@@ -273,6 +276,8 @@ async function connectTransport(url: URL, session: WebTransport): Promise<Establ
 		setupVersion = Ietf.Version.DRAFT_16;
 	} else if (protocol === Ietf.ALPN.DRAFT_15) {
 		setupVersion = Ietf.Version.DRAFT_15;
+	} else if (protocol === Lite.ALPN_04) {
+		return new Lite.Connection(url, session, Lite.Version.DRAFT_04, undefined);
 	} else if (protocol === Lite.ALPN_03) {
 		return new Lite.Connection(url, session, Lite.Version.DRAFT_03, undefined);
 	} else if (protocol === Lite.ALPN || protocol === "" || protocol === undefined) {
diff --git a/js/lite/src/ietf/publisher.ts b/js/lite/src/ietf/publisher.ts
index 3bd31b6f4..216f47994 100644
--- a/js/lite/src/ietf/publisher.ts
+++ b/js/lite/src/ietf/publisher.ts
@@ -161,7 +161,7 @@ export class Publisher {
 			// Serve track groups, racing with stream close (= Unsubscribe)
 			const serving = (async () => {
 				for (;;) {
-					const group = await track.nextGroup();
+					const group = await track.recvGroup();
 					if (!group) return;
 					void this.#runGroup(msg.requestId, group);
 				}
diff --git a/js/lite/src/lite/announce.ts b/js/lite/src/lite/announce.ts
index 32da48ba4..be7a46ef4 100644
--- a/js/lite/src/lite/announce.ts
+++ b/js/lite/src/lite/announce.ts
@@ -1,18 +1,21 @@
 import * as Path from "../path.ts";
 import type { Reader, Writer } from "../stream.ts";
-import { unreachable } from "../util/error.ts";
 import * as Message from "./message.ts";
 import { Version } from "./version.ts";
 
+const MAX_HOPS = 32;
+
 export class Announce {
 	suffix: Path.Valid;
 	active: boolean;
-	hops: number;
 
-	constructor(props: { suffix: Path.Valid; active: boolean; hops?: number }) {
+	/// Ordered origin path. Draft03 populates with 0n (UNKNOWN) entries; Draft04+ uses real IDs.
+	hops: bigint[];
+
+	constructor(props: { suffix: Path.Valid; active: boolean; hops?: bigint[] }) {
 		this.suffix = props.suffix;
 		this.active = props.active;
-		this.hops = props.hops ?? 0;
+		this.hops = props.hops ?? [];
 	}
 
 	async #encode(w: Writer, version: Version) {
@@ -21,13 +24,23 @@ export class Announce {
 
 		switch (version) {
 			case Version.DRAFT_03:
-				await w.u53(this.hops);
+				if (this.hops.length > MAX_HOPS) {
+					throw new Error(`hop count ${this.hops.length} exceeds maximum of ${MAX_HOPS}`);
+				}
+				await w.u53(this.hops.length);
 				break;
 			case Version.DRAFT_01:
 			case Version.DRAFT_02:
 				break;
 			default:
-				unreachable(version);
+				if (this.hops.length > MAX_HOPS) {
+					throw new Error(`hop count ${this.hops.length} exceeds maximum of ${MAX_HOPS}`);
+				}
+				await w.u53(this.hops.length);
+				for (const hop of this.hops) {
+					await w.u62(hop);
+				}
+				break;
 		}
 	}
 
@@ -35,16 +48,32 @@ export class Announce {
 		const active = await r.bool();
 		const suffix = Path.from(await r.string());
 
-		let hops = 0;
+		const hops: bigint[] = [];
 		switch (version) {
-			case Version.DRAFT_03:
-				hops = await r.u53();
+			case Version.DRAFT_03: {
+				// Read count but don't know actual IDs; use 0 as unknown placeholder.
+				const count = await r.u53();
+				if (count > MAX_HOPS) {
+					throw new Error(`hop count ${count} exceeds maximum of ${MAX_HOPS}`);
+				}
+				for (let i = 0; i < count; i++) {
+					hops.push(0n);
+				}
 				break;
+			}
 			case Version.DRAFT_01:
 			case Version.DRAFT_02:
 				break;
-			default:
-				unreachable(version);
+			default: {
+				const count = await r.u53();
+				if (count > MAX_HOPS) {
+					throw new Error(`hop count ${count} exceeds maximum of ${MAX_HOPS}`);
+				}
+				for (let i = 0; i < count; i++) {
+					hops.push(await r.u62());
+				}
+				break;
+			}
 		}
 
 		return new Announce({ suffix, active, hops });
@@ -66,31 +95,57 @@ export class Announce {
 export class AnnounceInterest {
 	prefix: Path.Valid;
 
-	constructor(prefix: Path.Valid) {
-		this.prefix = prefix;
+	/// Filter out announces whose hops contain this hop ID. 0n means no filtering.
+	excludeHop: bigint;
+
+	constructor(props: { prefix: Path.Valid; excludeHop?: bigint }) {
+		this.prefix = props.prefix;
+		this.excludeHop = props.excludeHop ?? 0n;
 	}
 
-	async #encode(w: Writer) {
+	async #encode(w: Writer, version: Version) {
 		await w.string(this.prefix);
+
+		switch (version) {
+			case Version.DRAFT_01:
+			case Version.DRAFT_02:
+			case Version.DRAFT_03:
+				break;
+			default:
+				await w.u62(this.excludeHop);
+				break;
+		}
 	}
 
-	static async #decode(r: Reader): Promise<AnnounceInterest> {
+	static async #decode(r: Reader, version: Version): Promise<AnnounceInterest> {
 		const prefix = Path.from(await r.string());
-		return new AnnounceInterest(prefix);
+
+		let excludeHop = 0n;
+		switch (version) {
+			case Version.DRAFT_01:
+			case Version.DRAFT_02:
+			case Version.DRAFT_03:
+				break;
+			default:
+				excludeHop = await r.u62();
+				break;
+		}
+
+		return new AnnounceInterest({ prefix, excludeHop });
 	}
 
-	async encode(w: Writer): Promise<void> {
-		return Message.encode(w, this.#encode.bind(this));
+	async encode(w: Writer, version: Version): Promise<void> {
+		return Message.encode(w, (w) => this.#encode(w, version));
 	}
 
-	static async decode(r: Reader): Promise<AnnounceInterest> {
-		return Message.decode(r, AnnounceInterest.#decode);
+	static async decode(r: Reader, version: Version): Promise<AnnounceInterest> {
+		return Message.decode(r, (r) => AnnounceInterest.#decode(r, version));
 	}
 }
 
 /// Sent after setup to communicate the initially announced paths.
 ///
-/// Used by Draft01/Draft02 only. Draft03 uses individual Announce messages instead.
+/// Used by Draft01/Draft02 only. Draft03+ uses individual Announce messages instead.
 export class AnnounceInit {
 	suffixes: Path.Valid[];
 
@@ -103,10 +158,8 @@ export class AnnounceInit {
 			case Version.DRAFT_01:
 			case Version.DRAFT_02:
 				break;
-			case Version.DRAFT_03:
-				throw new Error("announce init not supported for Draft03");
 			default:
-				unreachable(version);
+				throw new Error("announce init not supported for this version");
 		}
 	}
 
diff --git a/js/lite/src/lite/connection.ts b/js/lite/src/lite/connection.ts
index b7684dd54..768dc1cd3 100644
--- a/js/lite/src/lite/connection.ts
+++ b/js/lite/src/lite/connection.ts
@@ -167,7 +167,7 @@ export class Connection implements Established {
 		if (typ === StreamId.Session) {
 			throw new Error("duplicate session stream");
 		} else if (typ === StreamId.Announce) {
-			const msg = await AnnounceInterest.decode(stream.reader);
+			const msg = await AnnounceInterest.decode(stream.reader, this.#version);
 			await this.#publisher.runAnnounce(msg, stream);
 			return;
 		} else if (typ === StreamId.Subscribe) {
diff --git a/js/lite/src/lite/fetch.ts b/js/lite/src/lite/fetch.ts
index 0035d018d..ba907d6fe 100644
--- a/js/lite/src/lite/fetch.ts
+++ b/js/lite/src/lite/fetch.ts
@@ -1,18 +1,16 @@
 import * as Path from "../path.ts";
 import type { Reader, Writer } from "../stream.ts";
-import { unreachable } from "../util/error.ts";
 import * as Message from "./message.ts";
 import { Version } from "./version.ts";
 
 function guardDraft03(version: Version) {
 	switch (version) {
-		case Version.DRAFT_03:
-			break;
 		case Version.DRAFT_01:
 		case Version.DRAFT_02:
 			throw new Error("fetch not supported for this version");
 		default:
-			unreachable(version);
+			// DRAFT_03+
+			break;
 	}
 }
 
diff --git a/js/lite/src/lite/probe.ts b/js/lite/src/lite/probe.ts
index 986c2a4c6..6244449f5 100644
--- a/js/lite/src/lite/probe.ts
+++ b/js/lite/src/lite/probe.ts
@@ -1,17 +1,15 @@
 import type { Reader, Writer } from "../stream.ts";
-import { unreachable } from "../util/error.ts";
 import * as Message from "./message.ts";
 import { Version } from "./version.ts";
 
 function guardDraft03(version: Version) {
 	switch (version) {
-		case Version.DRAFT_03:
-			break;
 		case Version.DRAFT_01:
 		case Version.DRAFT_02:
 			throw new Error("probe not supported for this version");
 		default:
-			unreachable(version);
+			// DRAFT_03+
+			break;
 	}
 }
 
diff --git a/js/lite/src/lite/publisher.ts b/js/lite/src/lite/publisher.ts
index e50d40a93..1a8ab62f9 100644
--- a/js/lite/src/lite/publisher.ts
+++ b/js/lite/src/lite/publisher.ts
@@ -83,19 +83,19 @@ export class Publisher {
 		}
 
 		switch (this.version) {
-			case Version.DRAFT_03:
-				// Draft03: send individual Announce messages for initial state.
-				for (const suffix of active) {
-					const wire = new Announce({ suffix, active: true });
-					await wire.encode(stream.writer, this.version);
-				}
-				break;
 			case Version.DRAFT_01:
 			case Version.DRAFT_02: {
 				const init = new AnnounceInit([...active]);
 				await init.encode(stream.writer, this.version);
 				break;
 			}
+			default:
+				// Draft03+: send individual Announce messages for initial state.
+				for (const suffix of active) {
+					const wire = new Announce({ suffix, active: true });
+					await wire.encode(stream.writer, this.version);
+				}
+				break;
 		}
 
 		// Wait for updates to the broadcasts.
@@ -201,7 +201,7 @@ export class Publisher {
 	async #runTrack(sub: bigint, broadcast: Path.Valid, track: Track, stream: Writer) {
 		try {
 			for (;;) {
-				const next = track.nextGroup();
+				const next = track.recvGroup();
 				const group = await Promise.race([next, stream.closed]);
 				if (!group) {
 					next.then((group) => group?.close()).catch(() => {});
diff --git a/js/lite/src/lite/session.ts b/js/lite/src/lite/session.ts
index 63893faab..dc085c224 100644
--- a/js/lite/src/lite/session.ts
+++ b/js/lite/src/lite/session.ts
@@ -1,5 +1,4 @@
 import type { Reader, Writer } from "../stream.ts";
-import { unreachable } from "../util/error.ts";
 import * as Message from "./message.ts";
 import { Version } from "./version.ts";
 
@@ -132,10 +131,9 @@ export class SessionInfo {
 			case Version.DRAFT_01:
 			case Version.DRAFT_02:
 				break;
-			case Version.DRAFT_03:
-				throw new Error("session info not supported for Draft03");
 			default:
-				unreachable(version);
+				// DRAFT_03+: session info not supported
+				throw new Error("session info not supported for this version");
 		}
 	}
 
diff --git a/js/lite/src/lite/subscribe.ts b/js/lite/src/lite/subscribe.ts
index 622e78799..e217b8850 100644
--- a/js/lite/src/lite/subscribe.ts
+++ b/js/lite/src/lite/subscribe.ts
@@ -1,6 +1,5 @@
 import * as Path from "../path.ts";
 import type { Reader, Writer } from "../stream.ts";
-import { unreachable } from "../util/error.ts";
 import * as Message from "./message.ts";
 import { Version } from "./version.ts";
 
@@ -27,25 +26,28 @@ export class SubscribeUpdate {
 
 	async #encode(w: Writer, version: Version) {
 		switch (version) {
-			case Version.DRAFT_03:
+			case Version.DRAFT_01:
+			case Version.DRAFT_02:
+				await w.u8(this.priority);
+				break;
+			default:
+				// DRAFT_03+
 				await w.u8(this.priority);
 				await w.bool(this.ordered);
 				await w.u53(this.maxLatency);
 				await w.u53(this.startGroup !== undefined ? this.startGroup + 1 : 0);
 				await w.u53(this.endGroup !== undefined ? this.endGroup + 1 : 0);
 				break;
-			case Version.DRAFT_01:
-			case Version.DRAFT_02:
-				await w.u8(this.priority);
-				break;
-			default:
-				unreachable(version);
 		}
 	}
 
 	static async #decode(r: Reader, version: Version): Promise<SubscribeUpdate> {
 		switch (version) {
-			case Version.DRAFT_03: {
+			case Version.DRAFT_01:
+			case Version.DRAFT_02:
+				return new SubscribeUpdate({ priority: await r.u8() });
+			default: {
+				// DRAFT_03+
 				const priority = await r.u8();
 				const ordered = await r.bool();
 				const maxLatency = await r.u53();
@@ -59,11 +61,6 @@ export class SubscribeUpdate {
 					endGroup: endGroup > 0 ? endGroup - 1 : undefined,
 				});
 			}
-			case Version.DRAFT_01:
-			case Version.DRAFT_02:
-				return new SubscribeUpdate({ priority: await r.u8() });
-			default:
-				unreachable(version);
 		}
 	}
 
@@ -118,17 +115,16 @@ export class Subscribe {
 		await w.u8(this.priority);
 
 		switch (version) {
-			case Version.DRAFT_03:
+			case Version.DRAFT_01:
+			case Version.DRAFT_02:
+				break;
+			default:
+				// DRAFT_03+
 				await w.bool(this.ordered);
 				await w.u53(this.maxLatency);
 				await w.u53(this.startGroup !== undefined ? this.startGroup + 1 : 0);
 				await w.u53(this.endGroup !== undefined ? this.endGroup + 1 : 0);
 				break;
-			case Version.DRAFT_01:
-			case Version.DRAFT_02:
-				break;
-			default:
-				unreachable(version);
 		}
 	}
 
@@ -139,7 +135,11 @@ export class Subscribe {
 		const priority = await r.u8();
 
 		switch (version) {
-			case Version.DRAFT_03: {
+			case Version.DRAFT_01:
+			case Version.DRAFT_02:
+				return new Subscribe({ id, broadcast, track, priority });
+			default: {
+				// DRAFT_03+
 				const ordered = await r.bool();
 				const maxLatency = await r.u53();
 				const startGroup = await r.u53();
@@ -155,11 +155,6 @@ export class Subscribe {
 					endGroup: endGroup > 0 ? endGroup - 1 : undefined,
 				});
 			}
-			case Version.DRAFT_01:
-			case Version.DRAFT_02:
-				return new Subscribe({ id, broadcast, track, priority });
-			default:
-				unreachable(version);
 		}
 	}
 
@@ -201,13 +196,6 @@ export class SubscribeOk {
 
 	async #encode(w: Writer, version: Version) {
 		switch (version) {
-			case Version.DRAFT_03:
-				await w.u8(this.priority);
-				await w.bool(this.ordered);
-				await w.u53(this.maxLatency);
-				await w.u53(this.startGroup !== undefined ? this.startGroup + 1 : 0);
-				await w.u53(this.endGroup !== undefined ? this.endGroup + 1 : 0);
-				break;
 			case Version.DRAFT_02:
 				// noop
 				break;
@@ -215,7 +203,13 @@ export class SubscribeOk {
 				await w.u8(this.priority ?? 0);
 				break;
 			default:
-				unreachable(version);
+				// DRAFT_03+
+				await w.u8(this.priority);
+				await w.bool(this.ordered);
+				await w.u53(this.maxLatency);
+				await w.u53(this.startGroup !== undefined ? this.startGroup + 1 : 0);
+				await w.u53(this.endGroup !== undefined ? this.endGroup + 1 : 0);
+				break;
 		}
 	}
 
@@ -227,13 +221,6 @@ export class SubscribeOk {
 		let endGroup: number | undefined;
 
 		switch (version) {
-			case Version.DRAFT_03:
-				priority = await r.u8();
-				ordered = await r.bool();
-				maxLatency = await r.u53();
-				startGroup = await r.u53();
-				endGroup = await r.u53();
-				break;
 			case Version.DRAFT_02:
 				// noop
 				break;
@@ -241,7 +228,13 @@ export class SubscribeOk {
 				priority = await r.u8();
 				break;
 			default:
-				unreachable(version);
+				// DRAFT_03+
+				priority = await r.u8();
+				ordered = await r.bool();
+				maxLatency = await r.u53();
+				startGroup = await r.u53();
+				endGroup = await r.u53();
+				break;
 		}
 
 		return new SubscribeOk({
@@ -308,31 +301,34 @@ export type SubscribeResponse = { ok: SubscribeOk } | { drop: SubscribeDrop };
 
 export async function encodeSubscribeResponse(w: Writer, resp: SubscribeResponse, version: Version): Promise<void> {
 	switch (version) {
-		case Version.DRAFT_03:
+		case Version.DRAFT_01:
+		case Version.DRAFT_02:
 			if ("ok" in resp) {
-				await w.u53(0x0);
 				await resp.ok.encode(w, version);
 			} else {
-				await w.u53(0x1);
-				await resp.drop.encode(w);
+				throw new Error("subscribe drop not supported for this version");
 			}
 			break;
-		case Version.DRAFT_01:
-		case Version.DRAFT_02:
+		default:
+			// DRAFT_03+
 			if ("ok" in resp) {
+				await w.u53(0x0);
 				await resp.ok.encode(w, version);
 			} else {
-				throw new Error("subscribe drop not supported for this version");
+				await w.u53(0x1);
+				await resp.drop.encode(w);
 			}
 			break;
-		default:
-			unreachable(version);
 	}
 }
 
 export async function decodeSubscribeResponse(r: Reader, version: Version): Promise<SubscribeResponse> {
 	switch (version) {
-		case Version.DRAFT_03: {
+		case Version.DRAFT_01:
+		case Version.DRAFT_02:
+			return { ok: await SubscribeOk.decode(r, version) };
+		default: {
+			// DRAFT_03+
 			const typ = await r.u53();
 			switch (typ) {
 				case 0x0:
@@ -343,10 +339,5 @@ export async function decodeSubscribeResponse(r: Reader, version: Version): Prom
 					throw new Error(`unknown subscribe response type: ${typ}`);
 			}
 		}
-		case Version.DRAFT_01:
-		case Version.DRAFT_02:
-			return { ok: await SubscribeOk.decode(r, version) };
-		default:
-			unreachable(version);
 	}
 }
diff --git a/js/lite/src/lite/subscriber.ts b/js/lite/src/lite/subscriber.ts
index 7f0fc0728..fd88df564 100644
--- a/js/lite/src/lite/subscriber.ts
+++ b/js/lite/src/lite/subscriber.ts
@@ -47,13 +47,13 @@ export class Subscriber {
 
 	async #runAnnounced(announced: Announced, prefix: Path.Valid): Promise<void> {
 		console.debug(`announced: prefix=${prefix}`);
-		const msg = new AnnounceInterest(prefix);
+		const msg = new AnnounceInterest({ prefix });
 
 		try {
 			// Open a stream and send the announce interest.
 			const stream = await Stream.open(this.#quic);
 			await stream.writer.u53(StreamId.Announce);
-			await msg.encode(stream.writer);
+			await msg.encode(stream.writer, this.version);
 
 			switch (this.version) {
 				case Version.DRAFT_01:
@@ -70,7 +70,8 @@ export class Subscriber {
 					break;
 				}
 				case Version.DRAFT_03:
-					// Draft03: no AnnounceInit, initial state comes via Announce messages.
+				case Version.DRAFT_04:
+					// Draft03+: no AnnounceInit, initial state comes via Announce messages.
 					break;
 			}
 
diff --git a/js/lite/src/lite/version.ts b/js/lite/src/lite/version.ts
index 18ce7ca3b..c66e0a697 100644
--- a/js/lite/src/lite/version.ts
+++ b/js/lite/src/lite/version.ts
@@ -2,6 +2,7 @@ export const Version = {
 	DRAFT_01: 0xff0dad01,
 	DRAFT_02: 0xff0dad02,
 	DRAFT_03: 0xff0dad03,
+	DRAFT_04: 0xff0dad04,
 } as const;
 
 export type Version = (typeof Version)[keyof typeof Version];
@@ -13,10 +14,14 @@ export const ALPN = "moql";
 /// The ALPN string for Draft03, which uses ALPN-based version negotiation.
 export const ALPN_03 = "moq-lite-03";
 
+/// The ALPN string for Draft04, which uses ALPN-based version negotiation.
+export const ALPN_04 = "moq-lite-04";
+
 const VERSION_NAMES: Record<number, string> = {
 	[Version.DRAFT_01]: "moq-lite-01",
 	[Version.DRAFT_02]: "moq-lite-02",
 	[Version.DRAFT_03]: "moq-lite-03",
+	[Version.DRAFT_04]: "moq-lite-04",
 };
 
 export function versionName(v: Version): string {
diff --git a/js/lite/src/track.ts b/js/lite/src/track.ts
index 16dfe17fe..0d4b0242f 100644
--- a/js/lite/src/track.ts
+++ b/js/lite/src/track.ts
@@ -91,7 +91,13 @@ export class Track {
 		group.close();
 	}
 
-	async nextGroup(): Promise<Group | undefined> {
+	/**
+	 * Receive the next group available on this track.
+	 *
+	 * Groups may arrive out of order or with gaps due to network conditions.
+	 * Use `OrderedConsumer` (in `@moq/hang`) if you need groups in sequence order.
+	 */
+	async recvGroup(): Promise<Group | undefined> {
 		for (;;) {
 			const groups = this.state.groups.peek();
 			if (groups.length > 0) {
@@ -106,6 +112,11 @@ export class Track {
 		}
 	}
 
+	/** @deprecated Use {@link recvGroup} instead. */
+	async nextGroup(): Promise<Group | undefined> {
+		return this.recvGroup();
+	}
+
 	async readFrame(): Promise<Uint8Array | undefined> {
 		return (await this.readFrameSequence())?.data;
 	}
diff --git a/js/publish/src/audio/encoder.ts b/js/publish/src/audio/encoder.ts
index 3266d2bd9..8ba0f256a 100644
--- a/js/publish/src/audio/encoder.ts
+++ b/js/publish/src/audio/encoder.ts
@@ -1,5 +1,5 @@
-import * as Catalog from "@moq/hang/catalog";
-import * as Container from "@moq/hang/container";
+import { type Audio, type AudioConfig, type Container, PRIORITY, u53 } from "@moq/hang/catalog";
+import * as ContainerMod from "@moq/hang/container";
 import * as Util from "@moq/hang/util";
 import type * as Moq from "@moq/lite";
 import { Time } from "@moq/lite";
@@ -25,12 +25,12 @@ export type EncoderProps = {
 	// NOTE: Each frame is always flushed to the network immediately.
 	groupDuration?: Time.Milli;
 
-	container?: Catalog.Container;
+	container?: Container;
 };
 
 export class Encoder {
 	static readonly TRACK = "audio/data";
-	static readonly PRIORITY = Catalog.PRIORITY.audio;
+	static readonly PRIORITY = PRIORITY.audio;
 
 	enabled: Signal<boolean>;
 
@@ -40,11 +40,11 @@ export class Encoder {
 
 	source: Signal<Source | undefined>;
 
-	#catalog = new Signal<Catalog.Audio | undefined>(undefined);
-	readonly catalog: Getter<Catalog.Audio | undefined> = this.#catalog;
+	#catalog = new Signal<Audio | undefined>(undefined);
+	readonly catalog: Getter<Audio | undefined> = this.#catalog;
 
-	#config = new Signal<Catalog.AudioConfig | undefined>(undefined);
-	readonly config: Getter<Catalog.AudioConfig | undefined> = this.#config;
+	#config = new Signal<AudioConfig | undefined>(undefined);
+	readonly config: Getter<AudioConfig | undefined> = this.#config;
 
 	#worklet = new Signal<AudioWorkletNode | undefined>(undefined);
 
@@ -120,9 +120,9 @@ export class Encoder {
 
 		const config = {
 			codec: "opus",
-			sampleRate: Catalog.u53(worklet.context.sampleRate),
-			numberOfChannels: Catalog.u53(worklet.channelCount),
-			bitrate: Catalog.u53(worklet.channelCount * 32_000),
+			sampleRate: u53(worklet.context.sampleRate),
+			numberOfChannels: u53(worklet.channelCount),
+			bitrate: u53(worklet.channelCount * 32_000),
 			container: { kind: "legacy" } as const,
 		};
 
@@ -151,7 +151,7 @@ export class Encoder {
 
 		effect.set(this.active, true, false);
 
-		const producer = new Container.Legacy.Producer(track);
+		const producer = new ContainerMod.Legacy.Producer(track);
 		effect.cleanup(() => producer.close());
 
 		let lastKeyframe: Time.Micro | undefined;
@@ -218,7 +218,7 @@ export class Encoder {
 		const config = effect.get(this.#config);
 		if (!config) return;
 
-		const catalog: Catalog.Audio = {
+		const catalog: Audio = {
 			renditions: { [Encoder.TRACK]: config },
 		};
 
diff --git a/js/publish/src/broadcast.ts b/js/publish/src/broadcast.ts
index 8000f6bb4..d3de87135 100644
--- a/js/publish/src/broadcast.ts
+++ b/js/publish/src/broadcast.ts
@@ -1,4 +1,3 @@
-import * as Catalog from "@moq/hang/catalog";
 import * as Moq from "@moq/lite";
 import { Effect, Signal } from "@moq/signals";
 import * as Audio from "./audio";
@@ -116,23 +115,32 @@ export class Broadcast {
 
 	#serveCatalog(track: Moq.Track, effect: Effect): void {
 		if (!effect.get(this.enabled)) {
-			// Clear the catalog.
-			track.writeFrame(Catalog.encode({}));
+			// Write an empty catalog when disabled.
+			track.writeFrame(new TextEncoder().encode("{}"));
 			return;
 		}
 
-		// Create the new catalog.
-		const catalog: Catalog.Root = {
-			video: effect.get(this.video.catalog),
-			audio: effect.get(this.audio.catalog),
-			location: effect.get(this.location.catalog),
-			user: effect.get(this.user.catalog),
-			chat: effect.get(this.chat.catalog),
-			preview: effect.get(this.preview.catalog),
-		};
-
-		const encoded = Catalog.encode(catalog);
-		track.writeFrame(encoded);
+		const obj: Record<string, unknown> = {};
+
+		const video = effect.get(this.video.catalog);
+		if (video) obj.video = video;
+
+		const audio = effect.get(this.audio.catalog);
+		if (audio) obj.audio = audio;
+
+		const location = effect.get(this.location.catalog);
+		if (location) obj.location = location;
+
+		const user = effect.get(this.user.catalog);
+		if (user) obj.user = user;
+
+		const chat = effect.get(this.chat.catalog);
+		if (chat) obj.chat = chat;
+
+		const preview = effect.get(this.preview.catalog);
+		if (preview) obj.preview = preview;
+
+		track.writeFrame(new TextEncoder().encode(JSON.stringify(obj)));
 	}
 
 	close() {
diff --git a/js/publish/src/chat/index.ts b/js/publish/src/chat/index.ts
index 080bd9c23..276f0a826 100644
--- a/js/publish/src/chat/index.ts
+++ b/js/publish/src/chat/index.ts
@@ -1,4 +1,4 @@
-import type * as Catalog from "@moq/hang/catalog";
+import type { Track } from "@moq/hang/catalog";
 import { Effect, type Getter, Signal } from "@moq/signals";
 import { Message, type MessageProps } from "./message";
 import { Typing, type TypingProps } from "./typing";
@@ -11,12 +11,17 @@ export type Props = {
 	typing?: TypingProps;
 };
 
+export type ChatCatalog = {
+	message?: Track;
+	typing?: Track;
+};
+
 export class Root {
 	message: Message;
 	typing: Typing;
 
-	#catalog = new Signal<Catalog.Chat | undefined>(undefined);
-	readonly catalog: Getter<Catalog.Chat | undefined> = this.#catalog;
+	#catalog = new Signal<ChatCatalog | undefined>(undefined);
+	readonly catalog: Getter<ChatCatalog | undefined> = this.#catalog;
 
 	#signals = new Effect();
 
diff --git a/js/publish/src/chat/message.ts b/js/publish/src/chat/message.ts
index 76187c80f..2ad6533b5 100644
--- a/js/publish/src/chat/message.ts
+++ b/js/publish/src/chat/message.ts
@@ -1,4 +1,4 @@
-import * as Catalog from "@moq/hang/catalog";
+import { PRIORITY, type Track } from "@moq/hang/catalog";
 import type * as Moq from "@moq/lite";
 import { Effect, Signal } from "@moq/signals";
 
@@ -8,14 +8,14 @@ export type MessageProps = {
 
 export class Message {
 	static readonly TRACK = "chat/message.txt";
-	static readonly PRIORITY = Catalog.PRIORITY.chat;
+	static readonly PRIORITY = PRIORITY.chat;
 
 	enabled: Signal<boolean>;
 
 	// The latest message to publish.
 	latest: Signal<string>;
 
-	catalog = new Signal<Catalog.Track | undefined>(undefined);
+	catalog = new Signal<Track | undefined>(undefined);
 
 	#signals = new Effect();
 
diff --git a/js/publish/src/chat/typing.ts b/js/publish/src/chat/typing.ts
index 25d9b0676..863ad5103 100644
--- a/js/publish/src/chat/typing.ts
+++ b/js/publish/src/chat/typing.ts
@@ -1,4 +1,4 @@
-import * as Catalog from "@moq/hang/catalog";
+import { PRIORITY, type Track } from "@moq/hang/catalog";
 import type * as Moq from "@moq/lite";
 import { Effect, Signal } from "@moq/signals";
 
@@ -8,14 +8,14 @@ export type TypingProps = {
 
 export class Typing {
 	static readonly TRACK = "chat/typing.bool";
-	static readonly PRIORITY = Catalog.PRIORITY.typing;
+	static readonly PRIORITY = PRIORITY.typing;
 
 	enabled: Signal<boolean>;
 
 	// Whether the user is typing.
 	active: Signal<boolean>;
 
-	catalog = new Signal<Catalog.Track | undefined>(undefined);
+	catalog = new Signal<Track | undefined>(undefined);
 
 	#signals = new Effect();
 
diff --git a/js/publish/src/location/index.ts b/js/publish/src/location/index.ts
index 106311934..edfebf11d 100644
--- a/js/publish/src/location/index.ts
+++ b/js/publish/src/location/index.ts
@@ -1,9 +1,9 @@
-import type * as Catalog from "@moq/hang/catalog";
 import { Effect, Signal } from "@moq/signals";
 import { Peers, type PeersProps } from "./peers";
-import { Window, type WindowProps } from "./window";
+import { type LocationCatalog, Window, type WindowProps } from "./window";
 
 export * from "./peers";
+export type { Position } from "./types";
 export * from "./window";
 
 export type Props = {
@@ -15,7 +15,7 @@ export class Root {
 	window: Window;
 	peers: Peers;
 
-	catalog = new Signal<Catalog.Location | undefined>(undefined);
+	catalog = new Signal<LocationCatalog | undefined>(undefined);
 	signals = new Effect();
 
 	constructor(props?: Props) {
diff --git a/js/publish/src/location/peers.ts b/js/publish/src/location/peers.ts
index efb69eb5d..2fe3b6961 100644
--- a/js/publish/src/location/peers.ts
+++ b/js/publish/src/location/peers.ts
@@ -1,21 +1,21 @@
-import * as Catalog from "@moq/hang/catalog";
+import { PRIORITY, type Track } from "@moq/hang/catalog";
 import type * as Moq from "@moq/lite";
-import * as Zod from "@moq/lite/zod";
 import { Effect, Signal } from "@moq/signals";
+import type { Position } from "./types";
 
 export interface PeersProps {
 	enabled?: boolean | Signal<boolean>;
-	positions?: Record<string, Catalog.Position> | Signal<Record<string, Catalog.Position>>;
+	positions?: Record<string, Position> | Signal<Record<string, Position>>;
 }
 
 export class Peers {
 	static readonly TRACK = "location/peers.json";
-	static readonly PRIORITY = Catalog.PRIORITY.location;
+	static readonly PRIORITY = PRIORITY.location;
 
 	enabled: Signal<boolean>;
-	positions = new Signal<Record<string, Catalog.Position>>({});
+	positions = new Signal<Record<string, Position>>({});
 
-	catalog = new Signal<Catalog.Track | undefined>(undefined);
+	catalog = new Signal<Track | undefined>(undefined);
 	signals = new Effect();
 
 	constructor(props?: PeersProps) {
@@ -35,7 +35,7 @@ export class Peers {
 		if (!values) return;
 		const [_, positions] = values;
 
-		Zod.write(track, positions, Catalog.PeersSchema);
+		track.writeJson(positions);
 	}
 
 	close() {
diff --git a/js/publish/src/location/types.ts b/js/publish/src/location/types.ts
new file mode 100644
index 000000000..ee9284aef
--- /dev/null
+++ b/js/publish/src/location/types.ts
@@ -0,0 +1,8 @@
+export type Position = {
+	x?: number;
+	y?: number;
+	z?: number;
+	s?: number;
+};
+
+export type Peers = Record<string, Position>;
diff --git a/js/publish/src/location/window.ts b/js/publish/src/location/window.ts
index c76172078..856e23bee 100644
--- a/js/publish/src/location/window.ts
+++ b/js/publish/src/location/window.ts
@@ -1,28 +1,35 @@
-import * as Catalog from "@moq/hang/catalog";
+import { PRIORITY, type Track } from "@moq/hang/catalog";
 import type * as Moq from "@moq/lite";
-import * as Zod from "@moq/lite/zod";
 import { Effect, Signal } from "@moq/signals";
+import type { Position } from "./types";
 
 export type WindowProps = {
 	// If true, then we'll publish our position to the broadcast.
 	enabled?: boolean | Signal<boolean>;
 
 	// Our current position.
-	position?: Catalog.Position | Signal<Catalog.Position | undefined>;
+	position?: Position | Signal<Position | undefined>;
 
 	// If set, then this broadcaster allows other peers to request position updates via this handle.
 	handle?: string | Signal<string | undefined>;
 };
 
+export type LocationCatalog = {
+	initial?: Position;
+	track?: Track;
+	handle?: string;
+	peers?: Track;
+};
+
 export class Window {
 	static readonly TRACK = "location/window.json";
-	static readonly PRIORITY = Catalog.PRIORITY.location;
+	static readonly PRIORITY = PRIORITY.location;
 
 	enabled: Signal<boolean>;
-	position: Signal<Catalog.Position | undefined>;
+	position: Signal<Position | undefined>;
 	handle: Signal<string | undefined>; // Allow other peers to request position updates via this handle.
 
-	catalog = new Signal<Catalog.Location | undefined>(undefined);
+	catalog = new Signal<LocationCatalog | undefined>(undefined);
 
 	signals = new Effect();
 
@@ -48,7 +55,7 @@ export class Window {
 		if (!values) return;
 		const [_, position] = values;
 
-		Zod.write(track, position, Catalog.PositionSchema);
+		track.writeJson(position);
 	}
 
 	close() {
diff --git a/js/publish/src/preview.ts b/js/publish/src/preview.ts
index 65d330b72..763c5ee83 100644
--- a/js/publish/src/preview.ts
+++ b/js/publish/src/preview.ts
@@ -1,20 +1,30 @@
-import * as Catalog from "@moq/hang/catalog";
+import { PRIORITY, type Track } from "@moq/hang/catalog";
 import type * as Moq from "@moq/lite";
 import { Effect, Signal } from "@moq/signals";
 
+export type PreviewInfo = {
+	name?: string;
+	avatar?: string;
+	audio?: boolean;
+	video?: boolean;
+	screen?: boolean;
+	typing?: boolean;
+	chat?: boolean;
+};
+
 export type PreviewProps = {
 	enabled?: boolean | Signal<boolean>;
-	info?: Catalog.Preview | Signal<Catalog.Preview | undefined>;
+	info?: PreviewInfo | Signal<PreviewInfo | undefined>;
 };
 
 export class Preview {
 	static readonly TRACK = "preview.json";
-	static readonly PRIORITY = Catalog.PRIORITY.preview;
+	static readonly PRIORITY = PRIORITY.preview;
 
 	enabled: Signal<boolean>;
-	info: Signal<Catalog.Preview | undefined>;
+	info: Signal<PreviewInfo | undefined>;
 
-	catalog = new Signal<Catalog.Track | undefined>(undefined);
+	catalog = new Signal<Track | undefined>(undefined);
 
 	signals = new Effect();
 
diff --git a/js/publish/src/user.ts b/js/publish/src/user.ts
index 417b197ce..1e6e8301c 100644
--- a/js/publish/src/user.ts
+++ b/js/publish/src/user.ts
@@ -1,4 +1,3 @@
-import type * as Catalog from "@moq/hang/catalog";
 import { Effect, Signal } from "@moq/signals";
 
 export type Props = {
@@ -9,6 +8,13 @@ export type Props = {
 	color?: string | Signal<string | undefined>;
 };
 
+export type UserCatalog = {
+	id?: string;
+	name?: string;
+	avatar?: string;
+	color?: string;
+};
+
 export class Info {
 	enabled: Signal<boolean>;
 
@@ -17,7 +23,7 @@ export class Info {
 	avatar: Signal<string | undefined>;
 	color: Signal<string | undefined>;
 
-	catalog = new Signal<Catalog.User | undefined>(undefined);
+	catalog = new Signal<UserCatalog | undefined>(undefined);
 
 	signals = new Effect();
 
diff --git a/js/publish/src/video/encoder.ts b/js/publish/src/video/encoder.ts
index c7fc7234a..ac0964925 100644
--- a/js/publish/src/video/encoder.ts
+++ b/js/publish/src/video/encoder.ts
@@ -1,5 +1,5 @@
-import * as Catalog from "@moq/hang/catalog";
-import * as Container from "@moq/hang/container";
+import { type Container, u53, type VideoConfig } from "@moq/hang/catalog";
+import * as ContainerMod from "@moq/hang/container";
 import * as Util from "@moq/hang/util";
 import type * as Moq from "@moq/lite";
 import { Time } from "@moq/lite";
@@ -9,7 +9,7 @@ import type { Source } from "./types";
 export interface EncoderProps {
 	enabled?: boolean | Signal<boolean>;
 	config?: EncoderConfig | Signal<EncoderConfig | undefined>;
-	container?: Catalog.Container;
+	container?: Container;
 }
 
 // TODO support signals?
@@ -40,8 +40,8 @@ export class Encoder {
 	source: Signal<Source | undefined>;
 	frame: Getter<VideoFrame | undefined>;
 
-	#catalog = new Signal<Catalog.VideoConfig | undefined>(undefined);
-	readonly catalog: Getter<Catalog.VideoConfig | undefined> = this.#catalog;
+	#catalog = new Signal<VideoConfig | undefined>(undefined);
+	readonly catalog: Getter<VideoConfig | undefined> = this.#catalog;
 
 	#signals = new Effect();
 
@@ -71,7 +71,7 @@ export class Encoder {
 	serve(track: Moq.Track, effect: Effect): void {
 		if (!effect.get(this.enabled)) return;
 
-		const producer = new Container.Legacy.Producer(track);
+		const producer = new ContainerMod.Legacy.Producer(track);
 		effect.cleanup(() => producer.close());
 
 		let lastKeyframe: Time.Micro | undefined;
@@ -127,12 +127,12 @@ export class Encoder {
 		if (!values) return;
 		const [_, config] = values;
 
-		const catalog: Catalog.VideoConfig = {
+		const catalog: VideoConfig = {
 			codec: config.codec,
-			bitrate: config.bitrate ? Catalog.u53(config.bitrate) : undefined,
+			bitrate: config.bitrate ? u53(config.bitrate) : undefined,
 			framerate: config.framerate,
-			codedWidth: Catalog.u53(config.width),
-			codedHeight: Catalog.u53(config.height),
+			codedWidth: u53(config.width),
+			codedHeight: u53(config.height),
 			optimizeForLatency: true,
 			container: { kind: "legacy" } as const,
 		};
diff --git a/js/publish/src/video/index.ts b/js/publish/src/video/index.ts
index 164b37ad4..1fbd9bf06 100644
--- a/js/publish/src/video/index.ts
+++ b/js/publish/src/video/index.ts
@@ -1,4 +1,4 @@
-import * as Catalog from "@moq/hang/catalog";
+import { PRIORITY, u53, type Video, type VideoConfig } from "@moq/hang/catalog";
 import { Effect, Signal } from "@moq/signals";
 import { Encoder, type EncoderProps } from "./encoder";
 import { TrackProcessor } from "./polyfill";
@@ -17,7 +17,7 @@ export type Props = {
 export class Root {
 	static readonly TRACK_HD = "video/hd";
 	static readonly TRACK_SD = "video/sd";
-	static readonly PRIORITY = Catalog.PRIORITY.video;
+	static readonly PRIORITY = PRIORITY.video;
 
 	source: Signal<Source | undefined>;
 	hd: Encoder;
@@ -25,7 +25,7 @@ export class Root {
 
 	frame = new Signal<VideoFrame | undefined>(undefined);
 
-	catalog = new Signal<Catalog.Video | undefined>(undefined);
+	catalog = new Signal<Video | undefined>(undefined);
 	display = new Signal<{ width: number; height: number } | undefined>(undefined);
 	flip = new Signal<boolean>(false);
 
@@ -85,15 +85,15 @@ export class Root {
 		const hdConfig = effect.get(this.hd.catalog);
 		const sdConfig = effect.get(this.sd.catalog);
 
-		const renditions: Record<string, Catalog.VideoConfig> = {};
+		const renditions: Record<string, VideoConfig> = {};
 		if (hdConfig) renditions[Root.TRACK_HD] = hdConfig;
 		if (sdConfig) renditions[Root.TRACK_SD] = sdConfig;
 
-		const catalog: Catalog.Video = {
+		const catalog: Video = {
 			renditions,
 			display: {
-				width: Catalog.u53(display.width),
-				height: Catalog.u53(display.height),
+				width: u53(display.width),
+				height: u53(display.height),
 			},
 			flip: effect.get(this.flip) ?? undefined,
 		};
diff --git a/js/watch/package.json b/js/watch/package.json
index 3570a396d..d8ffb5572 100644
--- a/js/watch/package.json
+++ b/js/watch/package.json
@@ -27,7 +27,8 @@
 		"@moq/hang": "workspace:^",
 		"@moq/lite": "workspace:^",
 		"@moq/signals": "workspace:^",
-		"@moq/ui-core": "workspace:^"
+		"@moq/ui-core": "workspace:^",
+		"zod": "^4.1.5"
 	},
 	"devDependencies": {
 		"@types/audioworklet": "^0.0.77",
diff --git a/js/watch/src/audio/decoder.ts b/js/watch/src/audio/decoder.ts
index 3631b8bcd..e2dc082b4 100644
--- a/js/watch/src/audio/decoder.ts
+++ b/js/watch/src/audio/decoder.ts
@@ -244,7 +244,9 @@ export class Decoder {
 	#runCmafDecoder(effect: Effect, sub: Moq.Track, config: Catalog.AudioConfig): void {
 		if (config.container.kind !== "cmaf") return; // just to help typescript
 
-		const { timescale } = config.container;
+		// Decode the base64 init segment to extract timescale
+		const initBytes = Uint8Array.from(atob(config.container.initData), (c) => c.charCodeAt(0));
+		const { timescale } = Container.Cmaf.decodeInitSegment(initBytes);
 		const description = config.description ? Util.Hex.toBytes(config.description) : undefined;
 
 		// For CMAF, just use decode buffer (no network jitter buffer yet)
@@ -275,7 +277,7 @@ export class Decoder {
 			// Process data segments
 			// TODO: Use a consumer wrapper for CMAF to support latency control
 			for (;;) {
-				const group = await sub.nextGroup();
+				const group = await sub.recvGroup();
 				if (!group) break;
 
 				effect.spawn(async () => {
diff --git a/js/watch/src/audio/mse.ts b/js/watch/src/audio/mse.ts
index 8b4ccb309..89cd8e00c 100644
--- a/js/watch/src/audio/mse.ts
+++ b/js/watch/src/audio/mse.ts
@@ -103,12 +103,13 @@ export class Mse implements Backend {
 	): void {
 		if (config.container.kind !== "cmaf") throw new Error("unreachable");
 
-		const timescale = config.container.timescale;
+		// Decode the base64 init segment from the catalog
+		const initBytes = Uint8Array.from(atob(config.container.initData), (c) => c.charCodeAt(0));
+		const { timescale } = Container.Cmaf.decodeInitSegment(initBytes);
 
 		effect.spawn(async () => {
-			// Generate init segment from catalog config (uses track_id from container)
-			const initSegment = Container.Cmaf.createAudioInitSegment(config);
-			await this.#appendBuffer(sourceBuffer, initSegment);
+			// Append the passthrough init segment directly
+			await this.#appendBuffer(sourceBuffer, initBytes);
 
 			for (;;) {
 				// TODO: Use Frame.Consumer for CMAF so we can support higher latencies.
diff --git a/js/watch/src/audio/source.ts b/js/watch/src/audio/source.ts
index d112c44fa..1c78c10e7 100644
--- a/js/watch/src/audio/source.ts
+++ b/js/watch/src/audio/source.ts
@@ -2,7 +2,7 @@ import type * as Catalog from "@moq/hang/catalog";
 import type * as Moq from "@moq/lite";
 import { Effect, type Getter, Signal } from "@moq/signals";
 import type { Broadcast } from "../broadcast";
-import type { Sync } from "../sync";
+import { Sync, type SyncTrack } from "../sync";
 
 export type Target = {
 	// Optional manual override for the selected rendition name.
@@ -22,6 +22,9 @@ export type SourceProps = {
 
 	// A function that checks if an audio configuration is supported by the backend.
 	supported?: Supported;
+
+	// Shared Sync instance for synchronizing playback across tracks. Defaults to a standalone Sync.
+	sync?: Sync;
 };
 
 /**
@@ -48,11 +51,13 @@ export class Source {
 
 	// Used to target a latency and synchronize playback of video with audio.
 	sync: Sync;
+	#syncTrack: SyncTrack;
 
 	#signals = new Effect();
 
-	constructor(sync: Sync, props?: SourceProps) {
-		this.sync = sync;
+	constructor(props: SourceProps) {
+		this.sync = props.sync ?? new Sync();
+		this.#syncTrack = this.sync.track();
 
 		this.broadcast = Signal.from(props?.broadcast);
 		this.target = Signal.from(props?.target);
@@ -67,7 +72,7 @@ export class Source {
 		const broadcast = effect.get(this.broadcast);
 		if (!broadcast) return;
 
-		const catalog = effect.get(broadcast.catalog)?.audio;
+		const catalog = effect.get(broadcast.audio);
 		if (!catalog) return;
 
 		effect.set(this.#catalog, catalog);
@@ -113,7 +118,7 @@ export class Source {
 
 		effect.set(this.#track, selected.track);
 		effect.set(this.#config, selected.config);
-		effect.set(this.sync.audio, selected.config.jitter as Moq.Time.Milli | undefined);
+		this.#syncTrack.set(selected.config.jitter as Moq.Time.Milli | undefined);
 	}
 
 	/**
@@ -141,6 +146,7 @@ export class Source {
 	}
 
 	close(): void {
+		this.#syncTrack.close();
 		this.#signals.close();
 	}
 }
diff --git a/js/watch/src/backend.ts b/js/watch/src/backend.ts
index 1a6ebd272..27cacc5c0 100644
--- a/js/watch/src/backend.ts
+++ b/js/watch/src/backend.ts
@@ -119,10 +119,12 @@ export class MultiBackend implements Backend {
 		this.jitter = Signal.from(props?.jitter ?? (100 as Moq.Time.Milli));
 		this.#sync = new Sync({ jitter: this.jitter });
 
-		this.#videoSource = new Video.Source(this.#sync, {
+		this.#videoSource = new Video.Source({
+			sync: this.#sync,
 			broadcast: this.broadcast,
 		});
-		this.#audioSource = new Audio.Source(this.#sync, {
+		this.#audioSource = new Audio.Source({
+			sync: this.#sync,
 			broadcast: this.broadcast,
 		});
 
@@ -175,7 +177,8 @@ export class MultiBackend implements Backend {
 	}
 
 	#runMse(effect: Effect, element: HTMLVideoElement): void {
-		const mse = new Muxer(this.#sync, {
+		const mse = new Muxer({
+			sync: this.#sync,
 			paused: this.paused,
 			element,
 		});
diff --git a/js/watch/src/broadcast.ts b/js/watch/src/broadcast.ts
index 5ebc9181c..6b4f316fc 100644
--- a/js/watch/src/broadcast.ts
+++ b/js/watch/src/broadcast.ts
@@ -1,7 +1,8 @@
-import * as Catalog from "@moq/hang/catalog";
+import { AUDIO, type Audio, CatalogReader, PRIORITY, VIDEO, type Video } from "@moq/hang/catalog";
 import type * as Moq from "@moq/lite";
 import { Path } from "@moq/lite";
 import { Effect, type Getter, Signal } from "@moq/signals";
+import { CHAT, type Chat, LOCATION, type Location, PREVIEW, type PreviewTrack, USER, type User } from "./sections";
 
 export interface BroadcastProps {
 	connection?: Moq.Connection.Established | Signal<Moq.Connection.Established | undefined>;
@@ -33,8 +34,15 @@ export class Broadcast {
 	#active = new Signal<Moq.Broadcast | undefined>(undefined);
 	readonly active: Getter<Moq.Broadcast | undefined> = this.#active;
 
-	#catalog = new Signal<Catalog.Root | undefined>(undefined);
-	readonly catalog: Getter<Catalog.Root | undefined> = this.#catalog;
+	// Per-section catalog getters
+	#catalogReader = new CatalogReader();
+
+	readonly video: Getter<Video | undefined>;
+	readonly audio: Getter<Audio | undefined>;
+	readonly chat: Getter<Chat | undefined>;
+	readonly user: Getter<User | undefined>;
+	readonly preview: Getter<PreviewTrack | undefined>;
+	readonly location: Getter<Location | undefined>;
 
 	// All actively announced broadcast paths from the connection.
 	#announced: Getter<Set<Moq.Path.Valid>>;
@@ -49,6 +57,14 @@ export class Broadcast {
 
 		this.#announced = props?.announced ?? new Signal(new Set());
 
+		// Register all known sections
+		this.video = this.#catalogReader.section(VIDEO);
+		this.audio = this.#catalogReader.section(AUDIO);
+		this.chat = this.#catalogReader.section(CHAT);
+		this.user = this.#catalogReader.section(USER);
+		this.preview = this.#catalogReader.section(PREVIEW);
+		this.location = this.#catalogReader.section(LOCATION);
+
 		this.signals.run(this.#runBroadcast.bind(this));
 		this.signals.run(this.#runCatalog.bind(this));
 	}
@@ -86,27 +102,29 @@ export class Broadcast {
 
 		this.status.set("loading");
 
-		const catalog = broadcast.subscribe("catalog.json", Catalog.PRIORITY.catalog);
+		const catalog = broadcast.subscribe("catalog.json", PRIORITY.catalog);
 		effect.cleanup(() => catalog.close());
 
-		effect.spawn(async () => {
-			try {
-				for (;;) {
-					const update = await Promise.race([effect.cancel, Catalog.fetch(catalog)]);
-					if (!update) break;
-
-					console.debug("received catalog", this.name.peek(), update);
-
-					this.#catalog.set(update);
-					this.status.set("live");
-				}
-			} catch (err) {
-				console.warn("error fetching catalog", this.name.peek(), err);
-			} finally {
-				this.#catalog.set(undefined);
-				this.status.set("offline");
+		// Use CatalogReader to consume the catalog track and update per-section signals.
+		this.#catalogReader.consume(catalog, effect);
+
+		// Track status based on whether any section has a value.
+		effect.run((inner) => {
+			const video = inner.get(this.video);
+			const audio = inner.get(this.audio);
+			const chat = inner.get(this.chat);
+			const user = inner.get(this.user);
+			const preview = inner.get(this.preview);
+			const location = inner.get(this.location);
+
+			if (video || audio || chat || user || preview || location) {
+				this.status.set("live");
 			}
 		});
+
+		effect.cleanup(() => {
+			this.status.set("offline");
+		});
 	}
 
 	close() {
diff --git a/js/watch/src/chat/index.ts b/js/watch/src/chat/index.ts
index 20009d4f4..09de2bd4c 100644
--- a/js/watch/src/chat/index.ts
+++ b/js/watch/src/chat/index.ts
@@ -1,6 +1,6 @@
-import type * as Catalog from "@moq/hang/catalog";
 import type * as Moq from "@moq/lite";
-import { Effect, Signal } from "@moq/signals";
+import { Effect, type Getter, Signal } from "@moq/signals";
+import type { Chat as ChatSection } from "../sections";
 import { Message, type MessageProps } from "./message";
 import { Typing, type TypingProps } from "./typing";
 
@@ -13,16 +13,16 @@ export class Chat {
 	message: Message;
 	typing: Typing;
 
-	#catalog = new Signal<Catalog.Chat | undefined>(undefined);
+	#catalog = new Signal<ChatSection | undefined>(undefined);
 	#signals = new Effect();
 
 	constructor(
 		broadcast: Signal<Moq.Broadcast | undefined>,
-		catalog: Signal<Catalog.Root | undefined>,
+		chatSection: Getter<ChatSection | undefined>,
 		props?: ChatProps,
 	) {
-		this.message = new Message(broadcast, catalog, props?.message);
-		this.typing = new Typing(broadcast, catalog, props?.typing);
+		this.message = new Message(broadcast, chatSection, props?.message);
+		this.typing = new Typing(broadcast, chatSection, props?.typing);
 
 		// Grab the chat section from the catalog (if it's changed).
 		this.#signals.run((effect) => {
diff --git a/js/watch/src/chat/message.ts b/js/watch/src/chat/message.ts
index 182dc5dae..4795249f2 100644
--- a/js/watch/src/chat/message.ts
+++ b/js/watch/src/chat/message.ts
@@ -1,6 +1,7 @@
-import * as Catalog from "@moq/hang/catalog";
+import { PRIORITY, type Track } from "@moq/hang/catalog";
 import type * as Moq from "@moq/lite";
 import { Effect, type Getter, Signal } from "@moq/signals";
+import type { Chat } from "../sections";
 
 export interface MessageProps {
 	// Whether to start downloading the chat.
@@ -16,23 +17,23 @@ export class Message {
 	#latest = new Signal<string | undefined>(undefined);
 	readonly latest: Getter<string | undefined> = this.#latest;
 
-	#catalog = new Signal<Catalog.Track | undefined>(undefined);
-	readonly catalog: Getter<Catalog.Track | undefined> = this.#catalog;
+	#catalog = new Signal<Track | undefined>(undefined);
+	readonly catalog: Getter<Track | undefined> = this.#catalog;
 
 	#signals = new Effect();
 
 	constructor(
 		broadcast: Signal<Moq.Broadcast | undefined>,
-		catalog: Signal<Catalog.Root | undefined>,
+		chatSection: Getter<Chat | undefined>,
 		props?: MessageProps,
 	) {
 		this.broadcast = broadcast;
 		this.enabled = Signal.from(props?.enabled ?? false);
 
-		// Grab the chat section from the catalog (if it's changed).
+		// Grab the chat.message track from the catalog section (if it's changed).
 		this.#signals.run((effect) => {
 			if (!effect.get(this.enabled)) return;
-			this.#catalog.set(effect.get(catalog)?.chat?.message);
+			this.#catalog.set(effect.get(chatSection)?.message);
 		});
 
 		this.#signals.run(this.#run.bind(this));
@@ -43,7 +44,7 @@ export class Message {
 		if (!values) return;
 		const [_, catalog, broadcast] = values;
 
-		const track = broadcast.subscribe(catalog.name, Catalog.PRIORITY.chat);
+		const track = broadcast.subscribe(catalog.name, PRIORITY.chat);
 		effect.cleanup(() => track.close());
 
 		// Undefined is only when we're not subscribed to the track.
diff --git a/js/watch/src/chat/typing.ts b/js/watch/src/chat/typing.ts
index 7aed7030b..412bd7c3d 100644
--- a/js/watch/src/chat/typing.ts
+++ b/js/watch/src/chat/typing.ts
@@ -1,6 +1,7 @@
-import * as Catalog from "@moq/hang/catalog";
+import { PRIORITY, type Track } from "@moq/hang/catalog";
 import type * as Moq from "@moq/lite";
 import { Effect, type Getter, Signal } from "@moq/signals";
+import type { Chat } from "../sections";
 
 export interface TypingProps {
 	// Whether to start downloading the chat.
@@ -13,24 +14,24 @@ export class Typing {
 	enabled: Signal<boolean>;
 	active: Signal<boolean | undefined>;
 
-	#catalog = new Signal<Catalog.Track | undefined>(undefined);
-	readonly catalog: Getter<Catalog.Track | undefined> = this.#catalog;
+	#catalog = new Signal<Track | undefined>(undefined);
+	readonly catalog: Getter<Track | undefined> = this.#catalog;
 
 	#signals = new Effect();
 
 	constructor(
 		broadcast: Signal<Moq.Broadcast | undefined>,
-		catalog: Signal<Catalog.Root | undefined>,
+		chatSection: Getter<Chat | undefined>,
 		props?: TypingProps,
 	) {
 		this.broadcast = broadcast;
 		this.active = new Signal<boolean | undefined>(undefined);
 		this.enabled = Signal.from(props?.enabled ?? false);
 
-		// Grab the chat section from the catalog (if it's changed).
+		// Grab the chat.typing track from the catalog section (if it's changed).
 		this.#signals.run((effect) => {
 			if (!effect.get(this.enabled)) return;
-			this.#catalog.set(effect.get(catalog)?.chat?.typing);
+			this.#catalog.set(effect.get(chatSection)?.typing);
 		});
 
 		this.#signals.run(this.#run.bind(this));
@@ -41,7 +42,7 @@ export class Typing {
 		if (!values) return;
 		const [_, catalog, broadcast] = values;
 
-		const track = broadcast.subscribe(catalog.name, Catalog.PRIORITY.typing);
+		const track = broadcast.subscribe(catalog.name, PRIORITY.typing);
 		effect.cleanup(() => track.close());
 
 		effect.spawn(async () => {
diff --git a/js/watch/src/location/index.ts b/js/watch/src/location/index.ts
index 58988ef47..34b73279f 100644
--- a/js/watch/src/location/index.ts
+++ b/js/watch/src/location/index.ts
@@ -1,6 +1,6 @@
-import type * as Catalog from "@moq/hang/catalog";
 import type * as Moq from "@moq/lite";
-import { Effect, type Signal } from "@moq/signals";
+import { Effect, type Getter, type Signal } from "@moq/signals";
+import type { Location as LocationSection } from "../sections";
 import { Peers, type PeersProps } from "./peers";
 import { Window, type WindowProps } from "./window";
 
@@ -17,11 +17,11 @@ export class Root {
 
 	constructor(
 		broadcast: Signal<Moq.Broadcast | undefined>,
-		catalog: Signal<Catalog.Root | undefined>,
+		locationSection: Getter<LocationSection | undefined>,
 		props?: Props,
 	) {
-		this.window = new Window(broadcast, catalog, props?.window);
-		this.peers = new Peers(broadcast, catalog, props?.peers);
+		this.window = new Window(broadcast, locationSection, props?.window);
+		this.peers = new Peers(broadcast, locationSection, props?.peers);
 	}
 
 	close() {
diff --git a/js/watch/src/location/peers.ts b/js/watch/src/location/peers.ts
index 65be38e5a..9f7333cbd 100644
--- a/js/watch/src/location/peers.ts
+++ b/js/watch/src/location/peers.ts
@@ -1,7 +1,8 @@
-import * as Catalog from "@moq/hang/catalog";
+import { PRIORITY } from "@moq/hang/catalog";
 import type * as Moq from "@moq/lite";
 import * as Zod from "@moq/lite/zod";
 import { Effect, type Getter, Signal } from "@moq/signals";
+import { type Location, PeersSchema, type Position } from "../sections";
 
 export interface PeersProps {
 	enabled?: boolean | Signal<boolean>;
@@ -11,32 +12,32 @@ export class Peers {
 	enabled: Signal<boolean>;
 	broadcast: Signal<Moq.Broadcast | undefined>;
 
-	#catalog = new Signal<Catalog.Track | undefined>(undefined);
-	#positions = new Signal<Record<string, Catalog.Position> | undefined>(undefined);
+	#peersTrack = new Signal<{ name: string } | undefined>(undefined);
+	#positions = new Signal<Record<string, Position> | undefined>(undefined);
 
 	signals = new Effect();
 
 	constructor(
 		broadcast: Signal<Moq.Broadcast | undefined>,
-		catalog: Signal<Catalog.Root | undefined>,
+		locationSection: Getter<Location | undefined>,
 		props?: PeersProps,
 	) {
 		this.broadcast = broadcast;
 		this.enabled = Signal.from(props?.enabled ?? false);
 
 		this.signals.run((effect) => {
-			this.#catalog.set(effect.get(catalog)?.location?.peers);
+			this.#peersTrack.set(effect.get(locationSection)?.peers);
 		});
 
 		this.signals.run(this.#run.bind(this));
 	}
 
 	#run(effect: Effect) {
-		const values = effect.getAll([this.enabled, this.#catalog, this.broadcast]);
+		const values = effect.getAll([this.enabled, this.#peersTrack, this.broadcast]);
 		if (!values) return;
 		const [_, catalog, broadcast] = values;
 
-		const track = broadcast.subscribe(catalog.name, Catalog.PRIORITY.location);
+		const track = broadcast.subscribe(catalog.name, PRIORITY.location);
 		effect.cleanup(() => track.close());
 
 		effect.spawn(this.#runTrack.bind(this, track));
@@ -45,7 +46,7 @@ export class Peers {
 	async #runTrack(track: Moq.Track) {
 		try {
 			for (;;) {
-				const frame = await Zod.read(track, Catalog.PeersSchema);
+				const frame = await Zod.read(track, PeersSchema);
 				if (!frame) break;
 
 				this.#positions.set(frame);
@@ -56,7 +57,7 @@ export class Peers {
 		}
 	}
 
-	get positions(): Getter<Record<string, Catalog.Position> | undefined> {
+	get positions(): Getter<Record<string, Position> | undefined> {
 		return this.#positions;
 	}
 
diff --git a/js/watch/src/location/window.ts b/js/watch/src/location/window.ts
index 3a15840cf..d7c7abe93 100644
--- a/js/watch/src/location/window.ts
+++ b/js/watch/src/location/window.ts
@@ -1,7 +1,8 @@
-import * as Catalog from "@moq/hang/catalog";
+import { PRIORITY } from "@moq/hang/catalog";
 import type * as Moq from "@moq/lite";
 import * as Zod from "@moq/lite/zod";
 import { Effect, type Getter, Signal } from "@moq/signals";
+import { type Location, type Position, PositionSchema } from "../sections";
 
 export interface WindowProps {
 	enabled?: boolean | Signal<boolean>;
@@ -15,42 +16,42 @@ export class Window {
 	#handle = new Signal<string | undefined>(undefined);
 	readonly handle: Getter<string | undefined> = this.#handle;
 
-	#catalog = new Signal<Catalog.Location | undefined>(undefined);
+	#location = new Signal<Location | undefined>(undefined);
 
-	#position = new Signal<Catalog.Position | undefined>(undefined);
-	readonly position: Getter<Catalog.Position | undefined> = this.#position;
+	#position = new Signal<Position | undefined>(undefined);
+	readonly position: Getter<Position | undefined> = this.#position;
 
 	signals = new Effect();
 
 	constructor(
 		broadcast: Signal<Moq.Broadcast | undefined>,
-		catalog: Signal<Catalog.Root | undefined>,
+		locationSection: Getter<Location | undefined>,
 		props?: WindowProps,
 	) {
 		this.broadcast = broadcast;
 		this.enabled = Signal.from(props?.enabled ?? false);
 
 		this.signals.run((effect) => {
-			this.#catalog.set(effect.get(catalog)?.location);
+			this.#location.set(effect.get(locationSection));
 		});
 
 		this.signals.run((effect) => {
 			if (!effect.get(this.enabled)) return;
-			this.#position.set(effect.get(this.#catalog)?.initial);
+			this.#position.set(effect.get(this.#location)?.initial);
 		});
 
 		this.signals.run((effect) => {
-			this.#handle.set(effect.get(this.#catalog)?.handle);
+			this.#handle.set(effect.get(this.#location)?.handle);
 		});
 
 		this.signals.run((effect) => {
 			const broadcast = effect.get(this.broadcast);
 			if (!broadcast) return;
 
-			const updates = effect.get(this.#catalog)?.track;
+			const updates = effect.get(this.#location)?.track;
 			if (!updates) return;
 
-			const track = broadcast.subscribe(updates.name, Catalog.PRIORITY.location);
+			const track = broadcast.subscribe(updates.name, PRIORITY.location);
 			effect.cleanup(() => track.close());
 
 			effect.spawn(this.#runTrack.bind(this, track));
@@ -60,7 +61,7 @@ export class Window {
 	async #runTrack(track: Moq.Track) {
 		try {
 			for (;;) {
-				const position = await Zod.read(track, Catalog.PositionSchema);
+				const position = await Zod.read(track, PositionSchema);
 				if (!position) break;
 
 				this.#position.set(position);
diff --git a/js/watch/src/mse.ts b/js/watch/src/mse.ts
index 615fe13d8..632c31de8 100644
--- a/js/watch/src/mse.ts
+++ b/js/watch/src/mse.ts
@@ -1,10 +1,12 @@
 import { Time } from "@moq/lite";
 import { Effect, type Getter, Signal } from "@moq/signals";
-import type { Sync } from "./sync";
+import { Sync } from "./sync";
 
 export type MuxerProps = {
 	element?: HTMLMediaElement | Signal<HTMLMediaElement | undefined>;
 	paused?: boolean | Signal<boolean>;
+	// Shared Sync instance for synchronizing playback across tracks. Defaults to a standalone Sync.
+	sync?: Sync;
 };
 
 /**
@@ -23,10 +25,10 @@ export class Muxer {
 
 	#signals = new Effect();
 
-	constructor(sync: Sync, props?: MuxerProps) {
+	constructor(props: MuxerProps) {
 		this.element = Signal.from(props?.element);
 		this.paused = Signal.from(props?.paused ?? false);
-		this.#sync = sync;
+		this.#sync = props.sync ?? new Sync();
 
 		this.#signals.run(this.#runMediaSource.bind(this));
 		this.#signals.run(this.#runSkip.bind(this));
diff --git a/js/watch/src/preview.ts b/js/watch/src/preview.ts
index 1065c9ebc..d4bdcfe19 100644
--- a/js/watch/src/preview.ts
+++ b/js/watch/src/preview.ts
@@ -1,7 +1,8 @@
-import * as Catalog from "@moq/hang/catalog";
+import { PRIORITY } from "@moq/hang/catalog";
 import type * as Moq from "@moq/lite";
 import * as Zod from "@moq/lite/zod";
-import { Effect, Signal } from "@moq/signals";
+import { Effect, type Getter, Signal } from "@moq/signals";
+import { type Preview as PreviewInfo, PreviewSchema, type PreviewTrack } from "./sections";
 
 export interface PreviewProps {
 	enabled?: boolean | Signal<boolean>;
@@ -10,35 +11,33 @@ export interface PreviewProps {
 export class Preview {
 	broadcast: Signal<Moq.Broadcast | undefined>;
 	enabled: Signal<boolean>;
-	preview = new Signal<Catalog.Preview | undefined>(undefined);
-	#catalog = new Signal<Catalog.Track | undefined>(undefined);
+	preview = new Signal<PreviewInfo | undefined>(undefined);
 
 	#signals = new Effect();
 
 	constructor(
 		broadcast: Signal<Moq.Broadcast | undefined>,
-		catalog: Signal<Catalog.Root | undefined>,
+		previewSection: Getter<PreviewTrack | undefined>,
 		props?: PreviewProps,
 	) {
 		this.broadcast = broadcast;
 		this.enabled = Signal.from(props?.enabled ?? false);
 
 		this.#signals.run((effect) => {
-			this.#catalog.set(effect.get(catalog)?.preview);
-		});
-
-		this.#signals.run((effect) => {
-			const values = effect.getAll([this.enabled, this.broadcast, this.#catalog]);
+			const values = effect.getAll([this.enabled, this.broadcast]);
 			if (!values) return;
-			const [_, broadcast, catalog] = values;
+			const [_, broadcast] = values;
+
+			const catalog = effect.get(previewSection);
+			if (!catalog) return;
 
 			// Subscribe to the preview.json track directly
-			const track = broadcast.subscribe(catalog.name, Catalog.PRIORITY.preview);
+			const track = broadcast.subscribe(catalog.name, PRIORITY.preview);
 			effect.cleanup(() => track.close());
 
 			effect.spawn(async () => {
 				try {
-					const info = await Zod.read(track, Catalog.PreviewSchema);
+					const info = await Zod.read(track, PreviewSchema);
 					if (!info) return;
 
 					this.preview.set(info);
diff --git a/js/watch/src/sections.ts b/js/watch/src/sections.ts
new file mode 100644
index 000000000..06cd1eb92
--- /dev/null
+++ b/js/watch/src/sections.ts
@@ -0,0 +1,63 @@
+// Application-specific catalog section definitions.
+// These define the JSON keys and Zod schemas for sections
+// that are not part of the core media catalog (video/audio).
+
+import { Section } from "@moq/hang/catalog";
+import { z } from "zod";
+
+const TrackSchema = z.object({
+	name: z.string(),
+});
+
+export const ChatSchema = z.object({
+	message: TrackSchema.optional(),
+	typing: TrackSchema.optional(),
+});
+export type Chat = z.infer<typeof ChatSchema>;
+export const CHAT = new Section("chat", ChatSchema);
+
+export const UserSchema = z.object({
+	id: z.string().optional(),
+	name: z.string().optional(),
+	avatar: z.string().optional(),
+	color: z.string().optional(),
+});
+export type User = z.infer<typeof UserSchema>;
+export const USER = new Section("user", UserSchema);
+
+export const PreviewTrackSchema = z.object({
+	name: z.string(),
+});
+export type PreviewTrack = z.infer<typeof PreviewTrackSchema>;
+export const PREVIEW = new Section("preview", PreviewTrackSchema);
+
+export const PreviewSchema = z.object({
+	name: z.string().optional(),
+	avatar: z.string().optional(),
+	audio: z.boolean().optional(),
+	video: z.boolean().optional(),
+	typing: z.boolean().optional(),
+	chat: z.boolean().optional(),
+	screen: z.boolean().optional(),
+});
+export type Preview = z.infer<typeof PreviewSchema>;
+
+export const PositionSchema = z.object({
+	x: z.number().optional(),
+	y: z.number().optional(),
+	z: z.number().optional(),
+	s: z.number().optional(),
+});
+export type Position = z.infer<typeof PositionSchema>;
+
+export const LocationSchema = z.object({
+	initial: PositionSchema.optional(),
+	track: TrackSchema.optional(),
+	handle: z.string().optional(),
+	peers: TrackSchema.optional(),
+});
+export type Location = z.infer<typeof LocationSchema>;
+export const LOCATION = new Section("location", LocationSchema);
+
+export const PeersSchema = z.record(z.string(), PositionSchema);
+export type Peers = z.infer<typeof PeersSchema>;
diff --git a/js/watch/src/sync.ts b/js/watch/src/sync.ts
index 567bc5d75..8233f8659 100644
--- a/js/watch/src/sync.ts
+++ b/js/watch/src/sync.ts
@@ -1,10 +1,29 @@
 import { Time } from "@moq/lite";
-import { Effect, Signal } from "@moq/signals";
+import { Effect, type Getter, Signal } from "@moq/signals";
+
+export class SyncTrack {
+	#jitter = new Signal<Time.Milli | undefined>(undefined);
+	readonly jitter: Getter<Time.Milli | undefined> = this.#jitter;
+	#onClose: () => void;
+	#closed = false;
+
+	constructor(onClose: () => void) {
+		this.#onClose = onClose;
+	}
+
+	set(jitter: Time.Milli | undefined): void {
+		this.#jitter.set(jitter);
+	}
+
+	close(): void {
+		if (this.#closed) return;
+		this.#closed = true;
+		this.#onClose();
+	}
+}
 
 export interface SyncProps {
 	jitter?: Time.Milli | Signal<Time.Milli>;
-	audio?: Time.Milli | Signal<Time.Milli | undefined>;
-	video?: Time.Milli | Signal<Time.Milli | undefined>;
 }
 
 export class Sync {
@@ -17,9 +36,9 @@ export class Sync {
 	// The minimum buffer size, to account for network jitter.
 	jitter: Signal<Time.Milli>;
 
-	// Any additional delay required for audio or video.
-	audio: Signal<Time.Milli | undefined>;
-	video: Signal<Time.Milli | undefined>;
+	// Dynamic set of track consumers.
+	#tracks = new Set<SyncTrack>();
+	#tracksVersion = new Signal(0);
 
 	// The buffer required, based on both audio and video.
 	#latency = new Signal<Time.Milli>(Time.Milli.zero);
@@ -33,20 +52,33 @@ export class Sync {
 
 	constructor(props?: SyncProps) {
 		this.jitter = Signal.from(props?.jitter ?? (100 as Time.Milli));
-		this.audio = Signal.from(props?.audio);
-		this.video = Signal.from(props?.video);
 
 		this.#update = Promise.withResolvers();
 
 		this.signals.run(this.#runLatency.bind(this));
 	}
 
+	track(): SyncTrack {
+		const t = new SyncTrack(() => {
+			this.#tracks.delete(t);
+			this.#tracksVersion.update((v) => v + 1);
+		});
+		this.#tracks.add(t);
+		this.#tracksVersion.update((v) => v + 1);
+		return t;
+	}
+
 	#runLatency(effect: Effect): void {
 		const jitter = effect.get(this.jitter);
-		const video = effect.get(this.video) ?? Time.Milli.zero;
-		const audio = effect.get(this.audio) ?? Time.Milli.zero;
+		effect.get(this.#tracksVersion);
+
+		let max = Time.Milli.zero;
+		for (const t of this.#tracks) {
+			const v = effect.get(t.jitter) ?? Time.Milli.zero;
+			max = Time.Milli.max(max, v);
+		}
 
-		const latency = Time.Milli.add(Time.Milli.max(video, audio), jitter);
+		const latency = Time.Milli.add(max, jitter);
 		this.#latency.set(latency);
 
 		this.#update.resolve();
diff --git a/js/watch/src/user.ts b/js/watch/src/user.ts
index 4bc209b30..c42fc5f0d 100644
--- a/js/watch/src/user.ts
+++ b/js/watch/src/user.ts
@@ -1,5 +1,5 @@
-import type * as Catalog from "@moq/hang/catalog";
 import { Effect, type Getter, Signal } from "@moq/signals";
+import type { User } from "./sections";
 
 export interface Props {
 	enabled?: boolean | Signal<boolean>;
@@ -15,16 +15,17 @@ export class Info {
 
 	signals = new Effect();
 
-	constructor(catalog: Signal<Catalog.Root | undefined>, props?: Props) {
+	constructor(user: Getter<User | undefined>, props?: Props) {
 		this.enabled = Signal.from(props?.enabled ?? false);
 
 		this.signals.run((effect) => {
 			if (!effect.get(this.enabled)) return;
 
-			this.#id.set(effect.get(catalog)?.user?.id);
-			this.#name.set(effect.get(catalog)?.user?.name);
-			this.#avatar.set(effect.get(catalog)?.user?.avatar);
-			this.#color.set(effect.get(catalog)?.user?.color);
+			const u = effect.get(user);
+			this.#id.set(u?.id);
+			this.#name.set(u?.name);
+			this.#avatar.set(u?.avatar);
+			this.#color.set(u?.color);
 		});
 	}
 
diff --git a/js/watch/src/video/decoder.ts b/js/watch/src/video/decoder.ts
index 0f00f9811..495c171ec 100644
--- a/js/watch/src/video/decoder.ts
+++ b/js/watch/src/video/decoder.ts
@@ -355,7 +355,9 @@ class DecoderTrack {
 	#runCmaf(effect: Effect, sub: Moq.Track, decoder: VideoDecoder): void {
 		if (this.config.container.kind !== "cmaf") return;
 
-		const { timescale } = this.config.container;
+		// Decode the base64 init segment to extract timescale
+		const initBytes = Uint8Array.from(atob(this.config.container.initData), (c) => c.charCodeAt(0));
+		const { timescale } = Container.Cmaf.decodeInitSegment(initBytes);
 		const description = this.config.description ? Util.Hex.toBytes(this.config.description) : undefined;
 
 		// Configure decoder with description from catalog
@@ -377,7 +379,7 @@ class DecoderTrack {
 			// Process data segments
 			// TODO: Use a consumer wrapper for CMAF to support latency control
 			for (;;) {
-				const group = await Promise.race([sub.nextGroup(), effect.cancel]);
+				const group = await Promise.race([sub.recvGroup(), effect.cancel]);
 				if (!group) break;
 
 				effect.spawn(async () => {
diff --git a/js/watch/src/video/mse.ts b/js/watch/src/video/mse.ts
index 50cdc9a68..88f3420a7 100644
--- a/js/watch/src/video/mse.ts
+++ b/js/watch/src/video/mse.ts
@@ -107,12 +107,13 @@ export class Mse implements Backend {
 		const data = active.subscribe(track, Catalog.PRIORITY.video);
 		effect.cleanup(() => data.close());
 
-		const timescale = config.container.timescale;
+		// Decode the base64 init segment from the catalog
+		const initBytes = Uint8Array.from(atob(config.container.initData), (c) => c.charCodeAt(0));
+		const { timescale } = Container.Cmaf.decodeInitSegment(initBytes);
 
 		effect.spawn(async () => {
-			// Generate init segment from catalog config (uses track_id from container)
-			const initSegment = Container.Cmaf.createVideoInitSegment(config);
-			await this.#appendBuffer(sourceBuffer, initSegment);
+			// Append the passthrough init segment directly
+			await this.#appendBuffer(sourceBuffer, initBytes);
 
 			for (;;) {
 				// TODO: Use Frame.Consumer for CMAF so we can support higher latencies.
diff --git a/js/watch/src/video/source.ts b/js/watch/src/video/source.ts
index e3c0c9b57..71cefb25d 100644
--- a/js/watch/src/video/source.ts
+++ b/js/watch/src/video/source.ts
@@ -2,7 +2,7 @@ import type * as Catalog from "@moq/hang/catalog";
 import type * as Moq from "@moq/lite";
 import { Effect, type Getter, Signal } from "@moq/signals";
 import type { Broadcast } from "../broadcast";
-import type { Sync } from "../sync";
+import { Sync, type SyncTrack } from "../sync";
 
 /**
  * A function that checks if a video configuration is supported by the backend.
@@ -13,6 +13,8 @@ export type SourceProps = {
 	broadcast?: Broadcast | Signal<Broadcast | undefined>;
 	target?: Target | Signal<Target | undefined>;
 	supported?: Supported;
+	// Shared Sync instance for synchronizing playback across tracks. Defaults to a standalone Sync.
+	sync?: Sync;
 };
 
 export type Target = {
@@ -159,14 +161,16 @@ export class Source {
 	readonly config: Getter<Catalog.VideoConfig | undefined> = this.#config;
 
 	sync: Sync;
+	#syncTrack: SyncTrack;
 	supported: Signal<Supported | undefined>;
 
 	#signals = new Effect();
 
-	constructor(sync: Sync, props?: SourceProps) {
+	constructor(props: SourceProps) {
 		this.broadcast = Signal.from(props?.broadcast);
 		this.target = Signal.from(props?.target);
-		this.sync = sync;
+		this.sync = props.sync ?? new Sync();
+		this.#syncTrack = this.sync.track();
 		this.supported = Signal.from(props?.supported);
 
 		this.#signals.run(this.#runCatalog.bind(this));
@@ -178,7 +182,7 @@ export class Source {
 		const broadcast = effect.get(this.broadcast);
 		if (!broadcast) return;
 
-		const catalog = effect.get(broadcast.catalog)?.video;
+		const catalog = effect.get(broadcast.video);
 		if (!catalog) return;
 
 		effect.set(this.#catalog, catalog);
@@ -221,7 +225,7 @@ export class Source {
 
 		effect.set(this.#track, selected);
 		effect.set(this.#config, config);
-		effect.set(this.sync.video, config.jitter as Moq.Time.Milli | undefined);
+		this.#syncTrack.set(config.jitter as Moq.Time.Milli | undefined);
 	}
 
 	/**
@@ -268,6 +272,7 @@ export class Source {
 	}
 
 	close(): void {
+		this.#syncTrack.close();
 		this.#signals.close();
 	}
 }
diff --git a/justfile b/justfile
index cc11a903a..c8a85f76e 100644
--- a/justfile
+++ b/justfile
@@ -18,7 +18,7 @@ default:
 # Install any dependencies.
 install:
 	bun install
-	cargo install --locked cargo-shear cargo-sort cargo-upgrades cargo-edit cargo-sweep cargo-semver-checks release-plz
+	cargo install --locked cargo-shear cargo-sort cargo-upgrades cargo-edit cargo-hack cargo-sweep cargo-semver-checks release-plz
 
 # Run the CI checks
 check:
@@ -78,9 +78,9 @@ ci:
 	# Make sure everything builds
 	just build
 
-	# Check feature edge cases for all crates
-	cargo check --workspace --no-default-features --exclude moq-ffi
-	cargo check --workspace --all-features --exclude moq-ffi
+	# Check all feature combinations for all crates
+	# requires: cargo install cargo-hack
+	cargo hack check --workspace --each-feature --no-dev-deps --exclude moq-ffi
 
 # Check semver compatibility against crates.io
 # requires: cargo install cargo-semver-checks
diff --git a/rs/conducer/src/consumer.rs b/rs/conducer/src/consumer.rs
index c1cab6a33..fb5b58b94 100644
--- a/rs/conducer/src/consumer.rs
+++ b/rs/conducer/src/consumer.rs
@@ -8,6 +8,7 @@ use crate::{
 	lock::*,
 	producer::{Producer, Ref},
 	waiter::*,
+	weak::Weak,
 };
 
 /// The consuming side of a shared state channel.
@@ -106,6 +107,14 @@ impl<T> Consumer<T> {
 		}
 	}
 
+	/// Create a [`Weak`] reference that doesn't affect the producer/consumer ref counts.
+	pub fn weak(&self) -> Weak<T> {
+		Weak {
+			state: self.state.clone(),
+			counts: self.counts.clone(),
+		}
+	}
+
 	/// Returns `true` if both consumers share the same underlying state.
 	pub fn same_channel(&self, other: &Self) -> bool {
 		self.state.is_clone(&other.state)
diff --git a/rs/hang/Cargo.toml b/rs/hang/Cargo.toml
index 0a602cfe5..f03dde994 100644
--- a/rs/hang/Cargo.toml
+++ b/rs/hang/Cargo.toml
@@ -28,7 +28,7 @@ serde = { workspace = true }
 serde_json = "1"
 serde_with = { version = "3", features = ["hex"] }
 thiserror = "2"
-tokio = { workspace = true, features = ["macros", "fs"] }
+tokio = { workspace = true, features = ["macros"] }
 tracing = "0.1"
 url = "2"
 
@@ -38,6 +38,8 @@ features = ["from", "display", "debug"]
 
 [dev-dependencies]
 anyhow = "1"
-moq-native = { path = "../moq-native" }
+moq-mux = { workspace = true }
+moq-native = { workspace = true, default-features = true }
+tokio = { workspace = true, features = ["macros", "fs"] }
 tracing = "0.1"
 url = "2"
diff --git a/rs/hang/examples/subscribe.rs b/rs/hang/examples/subscribe.rs
index f624eb9ab..01cd0de8f 100644
--- a/rs/hang/examples/subscribe.rs
+++ b/rs/hang/examples/subscribe.rs
@@ -5,7 +5,7 @@ use std::time::Duration;
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
 	// Optional: Use moq_native to configure a logger.
-	moq_native::Log::new(tracing::Level::DEBUG).init();
+	moq_native::Log::new(tracing::Level::DEBUG).init()?;
 
 	// Create an origin that the session can publish incoming broadcasts to.
 	let origin = moq_lite::Origin::produce();
@@ -39,24 +39,30 @@ async fn run_session(origin: moq_lite::OriginProducer) -> anyhow::Result<()> {
 // Subscribe to a broadcast and read media frames.
 async fn run_subscribe(mut consumer: moq_lite::OriginConsumer) -> anyhow::Result<()> {
 	// Wait for a broadcast to be announced.
-	let (path, broadcast) = consumer
-		.announced()
-		.await
-		.ok_or_else(|| anyhow::anyhow!("origin closed"))?;
-
-	let broadcast = broadcast.ok_or_else(|| anyhow::anyhow!("broadcast unannounced: {path}"))?;
+	let (path, broadcast) = consumer.announced().await?;
 
 	tracing::info!(%path, "broadcast announced");
 
 	// Read the catalog to discover available tracks.
-	let catalog_track = broadcast.subscribe_track(&hang::Catalog::default_track())?;
+	let catalog_track =
+		broadcast.subscribe_track(&hang::catalog::default_track(), moq_lite::Subscription::default())?;
 	let mut catalog = hang::CatalogConsumer::new(catalog_track);
 
-	let info = catalog.next().await?.ok_or_else(|| anyhow::anyhow!("no catalog"))?;
+	// Register interest in the video section
+	let video_section = catalog.reader().section(&hang::catalog::VIDEO);
+
+	// Run until we get the first video section update
+	tokio::select! {
+		res = catalog.run() => { res?; anyhow::bail!("catalog closed before first update"); },
+		_ = video_section.changed() => {},
+	}
+
+	let video = video_section
+		.get()?
+		.ok_or_else(|| anyhow::anyhow!("no video section"))?;
 
 	// Find the first video track.
-	let (name, config) = info
-		.video
+	let (name, config) = video
 		.renditions
 		.iter()
 		.next()
@@ -71,13 +77,13 @@ async fn run_subscribe(mut consumer: moq_lite::OriginConsumer) -> anyhow::Result
 	);
 
 	// Subscribe to the video track.
-	let track = moq_lite::Track {
-		name: name.clone(),
-		priority: 1,
-	};
+	let track = moq_lite::Track::new(name.clone());
+
+	let track_sub = broadcast.subscribe_track(&track, moq_lite::Subscription::default())?;
 
-	let track_consumer = broadcast.subscribe_track(&track)?;
-	let mut ordered = hang::container::OrderedConsumer::new(track_consumer, Duration::from_millis(500));
+	// Skip over groups where all frames are older than 500ms to maintain low latency.
+	let mut ordered =
+		moq_mux::consumer::OrderedConsumer::new(track_sub, moq_mux::consumer::Legacy, Duration::from_millis(500));
 
 	// Read frames in presentation order.
 	while let Some(frame) = ordered.read().await? {
diff --git a/rs/hang/examples/video.rs b/rs/hang/examples/video.rs
index 1dd4dc5dd..b416dbcc6 100644
--- a/rs/hang/examples/video.rs
+++ b/rs/hang/examples/video.rs
@@ -4,7 +4,7 @@ use bytes::Bytes;
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
 	// Optional: Use moq_native to configure a logger.
-	moq_native::Log::new(tracing::Level::DEBUG).init();
+	moq_native::Log::new(tracing::Level::DEBUG).init()?;
 
 	// Create an origin that we can publish to and the session can consume from.
 	let origin = moq_lite::Origin::produce();
@@ -38,12 +38,9 @@ async fn run_session(origin: moq_lite::OriginConsumer) -> anyhow::Result<()> {
 
 // Create a video track with a catalog that describes it.
 // The catalog can contain multiple tracks, used by the viewer to choose the best track.
-fn create_track(broadcast: &mut moq_lite::BroadcastProducer) -> anyhow::Result<moq_lite::TrackProducer> {
+fn create_track(broadcast: &moq_lite::BroadcastProducer) -> anyhow::Result<moq_lite::TrackProducer> {
 	// Basic information about the video track.
-	let video_track = moq_lite::Track {
-		name: "video".to_string(),
-		priority: 1, // Video typically has lower priority than audio
-	};
+	let video_track = moq_lite::Track::new("video");
 
 	// Example video configuration
 	// In a real application, you would get this from the encoder
@@ -75,21 +72,21 @@ fn create_track(broadcast: &mut moq_lite::BroadcastProducer) -> anyhow::Result<m
 	let mut renditions = std::collections::BTreeMap::new();
 	renditions.insert(video_track.name.clone(), video_config);
 
-	// Create the catalog describing our video track.
-	let catalog = hang::catalog::Catalog {
-		video: hang::catalog::Video {
-			renditions,
-			display: None,
-			rotation: None,
-			flip: None,
-		},
-		..Default::default()
+	// Create the video section describing our video track.
+	let video = hang::catalog::Video {
+		renditions,
+		display: None,
+		rotation: None,
+		flip: None,
 	};
 
-	// Publish the catalog as a "catalog.json" track in the broadcast.
-	let mut catalog_track = broadcast.create_track(hang::Catalog::default_track())?;
+	// Publish the catalog as a "catalog.json" track in the broadcast using CatalogWriter.
+	let writer = hang::CatalogWriter::new();
+	writer.set(&hang::catalog::VIDEO, &video)?;
+
+	let mut catalog_track = broadcast.create_track(hang::catalog::default_track())?;
 	let mut group = catalog_track.append_group()?;
-	group.write_frame(catalog.to_string()?)?;
+	group.write_frame(writer.encode()?)?;
 	group.finish()?;
 
 	// Actually create the media track now.
@@ -101,8 +98,8 @@ fn create_track(broadcast: &mut moq_lite::BroadcastProducer) -> anyhow::Result<m
 // Produce a broadcast and publish it to the origin.
 async fn run_broadcast(origin: moq_lite::OriginProducer) -> anyhow::Result<()> {
 	// Create and publish a broadcast to the origin.
-	let mut broadcast = moq_lite::Broadcast::produce();
-	let track = create_track(&mut broadcast)?;
+	let broadcast = moq_lite::Broadcast::new().produce();
+	let track = create_track(&broadcast)?;
 
 	// NOTE: The path is empty because we're using the URL to scope the broadcast.
 	// OPTIONAL: We publish after inserting the tracks just to avoid a nearly impossible race condition.
diff --git a/rs/hang/src/catalog/audio/mod.rs b/rs/hang/src/catalog/audio/mod.rs
index 1958183c2..80459684f 100644
--- a/rs/hang/src/catalog/audio/mod.rs
+++ b/rs/hang/src/catalog/audio/mod.rs
@@ -11,7 +11,10 @@ use bytes::Bytes;
 use serde::{Deserialize, Serialize};
 use serde_with::{DisplayFromStr, hex::Hex};
 
-use crate::catalog::Container;
+use crate::catalog::{Container, Section};
+
+/// Predefined section for audio catalog data.
+pub const AUDIO: Section<Audio> = Section::new("audio");
 
 /// Information about an audio track in the catalog.
 ///
@@ -38,8 +41,7 @@ impl Audio {
 
 			if let btree_map::Entry::Vacant(entry) = self.renditions.entry(name.clone()) {
 				entry.insert(config.clone());
-				// TODO: Remove priority
-				return moq_lite::Track { name, priority: 2 };
+				return moq_lite::Track::new(name);
 			}
 		}
 
diff --git a/rs/hang/src/catalog/chat.rs b/rs/hang/src/catalog/chat.rs
deleted file mode 100644
index 67be2c12a..000000000
--- a/rs/hang/src/catalog/chat.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-/// Chat track metadata
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
-#[serde(rename_all = "camelCase")]
-pub struct Chat {
-	pub message: Option<moq_lite::Track>,
-	pub typing: Option<moq_lite::Track>,
-}
diff --git a/rs/hang/src/catalog/consumer.rs b/rs/hang/src/catalog/consumer.rs
index 7db8518ab..218a68dc4 100644
--- a/rs/hang/src/catalog/consumer.rs
+++ b/rs/hang/src/catalog/consumer.rs
@@ -1,46 +1,74 @@
-use crate::{Catalog, Result};
+use crate::Result;
 
-/// A catalog consumer, used to receive catalog updates and discover tracks.
-///
-/// This wraps a `moq_lite::TrackConsumer` and automatically deserializes JSON
-/// catalog data to discover available audio and video tracks in a broadcast.
-#[derive(Clone)]
+use super::CatalogReader;
+
+/// The default name for the catalog track.
+pub const DEFAULT_TRACK_NAME: &str = "catalog.json";
+
+/// The default priority for the catalog track.
+pub const DEFAULT_TRACK_PRIORITY: u8 = 100;
+
+/// Returns the default track descriptor for the catalog.
+pub fn default_track() -> moq_lite::Track {
+	moq_lite::Track::new(DEFAULT_TRACK_NAME)
+}
+
+/// A catalog consumer that reads JSON frames from a MoQ track and
+/// feeds them into a `CatalogReader` for per-section change notification.
 pub struct CatalogConsumer {
-	/// Access to the underlying track consumer.
-	pub track: moq_lite::TrackConsumer,
+	/// Access to the underlying track subscriber.
+	pub track: moq_lite::TrackSubscriber,
+
+	/// The reader that distributes per-section updates.
+	reader: CatalogReader,
+
 	group: Option<moq_lite::GroupConsumer>,
 }
 
 impl CatalogConsumer {
-	/// Create a new catalog consumer from a MoQ track consumer.
-	pub fn new(track: moq_lite::TrackConsumer) -> Self {
-		Self { track, group: None }
+	/// Create a new catalog consumer from a MoQ track subscriber.
+	pub fn new(track: moq_lite::TrackSubscriber) -> Self {
+		Self {
+			track,
+			reader: CatalogReader::new(),
+			group: None,
+		}
+	}
+
+	/// Get a reference to the reader for registering section interest.
+	pub fn reader(&self) -> &CatalogReader {
+		&self.reader
 	}
 
-	/// Get the next catalog update.
+	/// Run the background loop that reads frames and dispatches to sections.
 	///
-	/// This method waits for the next catalog publication and returns the
-	/// catalog data. If there are no more updates, `None` is returned.
-	pub async fn next(&mut self) -> Result<Option<Catalog>> {
-		loop {
-			tokio::select! {
-				res = self.track.next_group() => {
-					match res? {
-						Some(group) => {
-							// Use the new group.
-							self.group = Some(group);
+	/// This method blocks until the track is closed.
+	pub async fn run(&mut self) -> Result<()> {
+		let result = async {
+			loop {
+				tokio::select! {
+					res = self.track.recv_group() => {
+						match res? {
+							Some(group) => {
+								self.group = Some(group);
+							}
+							None => return Ok(()),
 						}
-						// The track has ended, so we should return None.
-						None => return Ok(None),
+					},
+					Some(frame) = async { self.group.as_mut()?.read_frame().await.transpose() } => {
+						self.group.take(); // We don't support deltas yet
+
+						let json: serde_json::Map<String, serde_json::Value> =
+							serde_json::from_slice(&frame?)?;
+						self.reader.update(json);
 					}
-				},
-				Some(frame) = async { self.group.as_mut()?.read_frame().await.transpose() } => {
-					self.group.take(); // We don't support deltas yet
-					let catalog = Catalog::from_slice(&frame?)?;
-					return Ok(Some(catalog));
 				}
 			}
 		}
+		.await;
+
+		self.reader.close();
+		result
 	}
 
 	/// Wait until the catalog track is closed.
@@ -49,8 +77,8 @@ impl CatalogConsumer {
 	}
 }
 
-impl From<moq_lite::TrackConsumer> for CatalogConsumer {
-	fn from(inner: moq_lite::TrackConsumer) -> Self {
+impl From<moq_lite::TrackSubscriber> for CatalogConsumer {
+	fn from(inner: moq_lite::TrackSubscriber) -> Self {
 		Self::new(inner)
 	}
 }
diff --git a/rs/hang/src/catalog/container.rs b/rs/hang/src/catalog/container.rs
index ea7a416d5..b6f6083d9 100644
--- a/rs/hang/src/catalog/container.rs
+++ b/rs/hang/src/catalog/container.rs
@@ -5,11 +5,11 @@ use serde::{Deserialize, Serialize};
 /// - "legacy": Uses QUIC VarInt encoding (1-8 bytes, variable length), raw frame payloads.
 ///   Timestamps are in microseconds.
 /// - "cmaf": Fragmented MP4 container - frames contain complete moof+mdat fragments.
-///   Timestamps are in timescale units.
+///   The init segment (ftyp+moov) is base64-encoded in the catalog.
 ///
 /// JSON example:
 /// ```json
-/// { "kind": "cmaf", "timescale": 1000000, "trackId": 1 }
+/// { "kind": "cmaf", "initData": "<base64-encoded ftyp+moov>" }
 /// ```
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Default)]
 #[serde(rename_all = "camelCase")]
@@ -19,10 +19,8 @@ pub enum Container {
 	#[default]
 	Legacy,
 	Cmaf {
-		/// Time units per second
-		timescale: u64,
-		/// Track ID used in the moof/mdat fragments
-		#[serde(rename = "trackId")]
-		track_id: u32,
+		/// Base64-encoded init segment (ftyp+moov)
+		#[serde(rename = "initData")]
+		init_data: String,
 	},
 }
diff --git a/rs/hang/src/catalog/mod.rs b/rs/hang/src/catalog/mod.rs
index b1d89985c..18c865d80 100644
--- a/rs/hang/src/catalog/mod.rs
+++ b/rs/hang/src/catalog/mod.rs
@@ -1,23 +1,21 @@
 //! The catalog describes available media tracks and codecs.
 //!
 //! This is a JSON blob that can be live updated like any other track in MoQ.
-//! It describes the available audio and video tracks, including codec information,
-//! resolution, bitrates, and other metadata.
+//! The catalog is a flat JSON object where each top-level key is a "section"
+//! that can be independently registered, read, and written with typed schemas.
 
 mod audio;
-mod chat;
 mod consumer;
 mod container;
-mod preview;
-mod root;
-mod user;
+mod reader;
+mod section;
 mod video;
+mod writer;
 
 pub use audio::*;
-pub use chat::*;
 pub use consumer::*;
 pub use container::*;
-pub use preview::*;
-pub use root::*;
-pub use user::*;
+pub use reader::*;
+pub use section::*;
 pub use video::*;
+pub use writer::*;
diff --git a/rs/hang/src/catalog/preview.rs b/rs/hang/src/catalog/preview.rs
deleted file mode 100644
index e0f20a5bf..000000000
--- a/rs/hang/src/catalog/preview.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-/// Preview information about a broadcast
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
-#[serde(rename_all = "camelCase")]
-pub struct Preview {
-	pub name: Option<String>,   // name
-	pub avatar: Option<String>, // avatar
-
-	pub audio: Option<bool>,  // audio enabled
-	pub video: Option<bool>,  // video enabled
-	pub screen: Option<bool>, // screen sharing
-
-	pub typing: Option<bool>, // actively typing
-	pub chat: Option<bool>,   // chatted recently
-}
diff --git a/rs/hang/src/catalog/reader.rs b/rs/hang/src/catalog/reader.rs
new file mode 100644
index 000000000..9a2241c60
--- /dev/null
+++ b/rs/hang/src/catalog/reader.rs
@@ -0,0 +1,150 @@
+use std::collections::HashMap;
+use std::marker::PhantomData;
+use std::ops::Deref;
+use std::sync::{Arc, Mutex};
+use std::task::Poll;
+
+use serde::de::DeserializeOwned;
+
+use crate::Result;
+
+use super::Section;
+
+/// A catalog reader that distributes per-section change notifications.
+///
+/// When new JSON is fed via `update()`, each registered section is diffed
+/// against its previous value. Only sections whose values actually changed
+/// get their consumers notified.
+#[derive(Clone)]
+pub struct CatalogReader {
+	inner: Arc<Mutex<CatalogReaderInner>>,
+}
+
+struct CatalogReaderInner {
+	sections: HashMap<String, conducer::Producer<Option<serde_json::Value>>>,
+	last: serde_json::Map<String, serde_json::Value>,
+}
+
+impl Default for CatalogReader {
+	fn default() -> Self {
+		Self::new()
+	}
+}
+
+impl CatalogReader {
+	pub fn new() -> Self {
+		Self {
+			inner: Arc::new(Mutex::new(CatalogReaderInner {
+				sections: HashMap::new(),
+				last: serde_json::Map::new(),
+			})),
+		}
+	}
+
+	/// Register interest in a section. Returns a `SectionConsumer<T>`.
+	///
+	/// If the section was already seen in a previous update, the consumer
+	/// will immediately have the current value available.
+	pub fn section<T: DeserializeOwned>(&self, section: &Section<T>) -> SectionConsumer<T> {
+		let mut inner = self.inner.lock().unwrap();
+		let name = section.name.to_string();
+		let initial = inner.last.get(section.name).cloned();
+		let producer = inner
+			.sections
+			.entry(name)
+			.or_insert_with(|| conducer::Producer::new(initial));
+		SectionConsumer {
+			consumer: producer.consume(),
+			_phantom: PhantomData,
+		}
+	}
+
+	/// Feed a raw JSON map into the reader.
+	///
+	/// For each registered section, diffs against the previous value.
+	/// Only updates (and notifies) sections whose values actually changed.
+	pub fn update(&self, json: serde_json::Map<String, serde_json::Value>) {
+		let mut inner = self.inner.lock().unwrap();
+
+		for (name, producer) in &inner.sections {
+			let new_value = json.get(name).cloned();
+			let old_value = inner.last.get(name).cloned();
+
+			if new_value != old_value {
+				if let Ok(mut guard) = producer.write() {
+					*guard = new_value;
+				}
+			}
+		}
+
+		inner.last = json;
+	}
+
+	/// Close all section producers, notifying consumers.
+	pub fn close(&self) {
+		let inner = self.inner.lock().unwrap();
+		for producer in inner.sections.values() {
+			let _ = producer.close();
+		}
+	}
+}
+
+/// A consumer for a single catalog section, backed by conducer.
+///
+/// Provides typed access to the section's current value and async
+/// notification when the value changes. Automatically unregisters
+/// when dropped (via conducer ref counting).
+pub struct SectionConsumer<T> {
+	consumer: conducer::Consumer<Option<serde_json::Value>>,
+	_phantom: PhantomData<T>,
+}
+
+impl<T: DeserializeOwned> SectionConsumer<T> {
+	/// Get the current value of this section.
+	pub fn get(&self) -> Result<Option<T>> {
+		let state = self.consumer.read();
+		match state.deref() {
+			Some(value) => Ok(Some(serde_json::from_value(value.clone())?)),
+			None => Ok(None),
+		}
+	}
+
+	/// Wait for the next change to this section, returning the new value.
+	///
+	/// Returns `Ok(None)` if the section was removed.
+	/// Returns `Err` if the catalog was closed.
+	pub async fn changed(&self) -> Result<Option<T>> {
+		let mut first = true;
+		let value: Option<serde_json::Value> = self
+			.consumer
+			.wait(|state| {
+				if first {
+					first = false;
+					Poll::Pending
+				} else {
+					Poll::Ready(state.deref().clone())
+				}
+			})
+			.await
+			.map_err(|_| crate::Error::Closed)?;
+
+		match value {
+			Some(v) => Ok(Some(serde_json::from_value(v)?)),
+			None => Ok(None),
+		}
+	}
+
+	/// Wait until this section's catalog is closed.
+	pub async fn closed(&self) {
+		self.consumer.closed().await;
+	}
+}
+
+impl<T> Clone for SectionConsumer<T> {
+	fn clone(&self) -> Self {
+		Self {
+			consumer: self.consumer.clone(),
+			_phantom: PhantomData,
+		}
+	}
+}
diff --git a/rs/hang/src/catalog/root.rs b/rs/hang/src/catalog/root.rs
deleted file mode 100644
index 731005b25..000000000
--- a/rs/hang/src/catalog/root.rs
+++ /dev/null
@@ -1,183 +0,0 @@
-//! This module contains the structs and functions for the MoQ catalog format
-use crate::Result;
-use crate::catalog::{Audio, Chat, User, Video};
-use serde::{Deserialize, Serialize};
-
-/// A catalog track, created by a broadcaster to describe the tracks available in a broadcast.
-#[serde_with::serde_as]
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
-#[serde(default, rename_all = "camelCase")]
-pub struct Catalog {
-	/// Video track information with multiple renditions.
-	///
-	/// Contains a map of video track renditions that the viewer can choose from
-	/// based on their preferences (resolution, bitrate, codec, etc).
-	#[serde(default)]
-	pub video: Video,
-
-	/// Audio track information with multiple renditions.
-	///
-	/// Contains a map of audio track renditions that the viewer can choose from
-	/// based on their preferences (codec, bitrate, language, etc).
-	#[serde(default)]
-	pub audio: Audio,
-
-	/// User metadata for the broadcaster
-	#[serde(default)]
-	pub user: Option<User>,
-
-	/// Chat track metadata
-	#[serde(default)]
-	pub chat: Option<Chat>,
-
-	/// Preview information about the broadcast
-	#[serde(default)]
-	pub preview: Option<moq_lite::Track>,
-}
-
-impl Catalog {
-	/// The default name for the catalog track.
-	pub const DEFAULT_NAME: &str = "catalog.json";
-
-	/// Parse a catalog from a string.
-	#[allow(clippy::should_implement_trait)]
-	pub fn from_str(s: &str) -> Result<Self> {
-		Ok(serde_json::from_str(s)?)
-	}
-
-	/// Parse a catalog from a slice of bytes.
-	pub fn from_slice(v: &[u8]) -> Result<Self> {
-		Ok(serde_json::from_slice(v)?)
-	}
-
-	/// Parse a catalog from a reader.
-	pub fn from_reader(reader: impl std::io::Read) -> Result<Self> {
-		Ok(serde_json::from_reader(reader)?)
-	}
-
-	/// Serialize the catalog to a string.
-	pub fn to_string(&self) -> Result<String> {
-		Ok(serde_json::to_string(self)?)
-	}
-
-	/// Serialize the catalog to a pretty string.
-	pub fn to_string_pretty(&self) -> Result<String> {
-		Ok(serde_json::to_string_pretty(self)?)
-	}
-
-	/// Serialize the catalog to a vector of bytes.
-	pub fn to_vec(&self) -> Result<Vec<u8>> {
-		Ok(serde_json::to_vec(self)?)
-	}
-
-	/// Serialize the catalog to a writer.
-	pub fn to_writer(&self, writer: impl std::io::Write) -> Result<()> {
-		Ok(serde_json::to_writer(writer, self)?)
-	}
-
-	pub fn default_track() -> moq_lite::Track {
-		moq_lite::Track {
-			name: Catalog::DEFAULT_NAME.to_string(),
-			priority: 100,
-		}
-	}
-}
-
-#[cfg(test)]
-mod test {
-	use std::collections::BTreeMap;
-
-	use crate::catalog::{AudioCodec::Opus, AudioConfig, Container, H264, VideoConfig};
-
-	use super::*;
-
-	#[test]
-	fn simple() {
-		let mut encoded = r#"{
-			"video": {
-				"renditions": {
-					"video": {
-						"codec": "avc1.64001f",
-						"codedWidth": 1280,
-						"codedHeight": 720,
-						"bitrate": 6000000,
-						"framerate": 30.0,
-						"container": {"kind": "legacy"}
-					}
-				}
-			},
-			"audio": {
-				"renditions": {
-					"audio": {
-						"codec": "opus",
-						"sampleRate": 48000,
-						"numberOfChannels": 2,
-						"bitrate": 128000,
-						"container": {"kind": "legacy"}
-					}
-				}
-			}
-		}"#
-		.to_string();
-
-		encoded.retain(|c| !c.is_whitespace());
-
-		let mut video_renditions = BTreeMap::new();
-		video_renditions.insert(
-			"video".to_string(),
-			VideoConfig {
-				codec: H264 {
-					profile: 0x64,
-					constraints: 0x00,
-					level: 0x1f,
-					inline: false,
-				}
-				.into(),
-				description: None,
-				coded_width: Some(1280),
-				coded_height: Some(720),
-				display_ratio_width: None,
-				display_ratio_height: None,
-				bitrate: Some(6_000_000),
-				framerate: Some(30.0),
-				optimize_for_latency: None,
-				container: Container::Legacy,
-				jitter: None,
-			},
-		);
-
-		let mut audio_renditions = BTreeMap::new();
-		audio_renditions.insert(
-			"audio".to_string(),
-			AudioConfig {
-				codec: Opus,
-				sample_rate: 48_000,
-				channel_count: 2,
-				bitrate: Some(128_000),
-				description: None,
-				container: Container::Legacy,
-				jitter: None,
-			},
-		);
-
-		let decoded = Catalog {
-			video: Video {
-				renditions: video_renditions,
-				display: None,
-				rotation: None,
-				flip: None,
-			},
-			audio: Audio {
-				renditions: audio_renditions,
-			},
-			..Default::default()
-		};
-
-		let output = Catalog::from_str(&encoded).expect("failed to decode");
-		assert_eq!(decoded, output, "wrong decoded output");
-
-		let output = decoded.to_string().expect("failed to encode");
-		assert_eq!(encoded, output, "wrong encoded output");
-	}
-}
diff --git a/rs/hang/src/catalog/section.rs b/rs/hang/src/catalog/section.rs
new file mode 100644
index 000000000..ee6af8e8b
--- /dev/null
+++ b/rs/hang/src/catalog/section.rs
@@ -0,0 +1,19 @@
+use std::marker::PhantomData;
+
+/// A section definition that pairs a JSON key name with a typed schema.
+///
+/// Used to register interest in specific catalog sections for reading or writing.
+/// Audio and video sections are predefined but not registered by default.
+pub struct Section<T> {
+	pub name: &'static str,
+	_phantom: PhantomData<T>,
+}
+
+impl<T> Section<T> {
+	pub const fn new(name: &'static str) -> Self {
+		Self {
+			name,
+			_phantom: PhantomData,
+		}
+	}
+}
diff --git a/rs/hang/src/catalog/user.rs b/rs/hang/src/catalog/user.rs
deleted file mode 100644
index 0a5fa654a..000000000
--- a/rs/hang/src/catalog/user.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-/// User metadata in the catalog
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
-#[serde(rename_all = "camelCase")]
-pub struct User {
-	pub id: Option<String>,
-	pub name: Option<String>,
-	pub avatar: Option<String>, // TODO allow using a track instead of a URL?
-	pub color: Option<String>,
-}
diff --git a/rs/hang/src/catalog/video/mod.rs b/rs/hang/src/catalog/video/mod.rs
index f3ef4ff9b..4baa303e2 100644
--- a/rs/hang/src/catalog/video/mod.rs
+++ b/rs/hang/src/catalog/video/mod.rs
@@ -16,7 +16,10 @@ use bytes::Bytes;
 use serde::{Deserialize, Serialize};
 use serde_with::{DisplayFromStr, hex::Hex};
 
-use crate::catalog::Container;
+use crate::catalog::{Container, Section};
+
+/// Predefined section for video catalog data.
+pub const VIDEO: Section<Video> = Section::new("video");
 
 /// Information about a video track in the catalog.
 ///
@@ -58,8 +61,7 @@ impl Video {
 			};
 			if let btree_map::Entry::Vacant(entry) = self.renditions.entry(name.clone()) {
 				entry.insert(config.clone());
-				// TODO: Remove priority
-				return moq_lite::Track { name, priority: 1 };
+				return moq_lite::Track::new(name);
 			}
 		}
 
@@ -85,7 +87,7 @@ pub struct Display {
 /// This struct contains all the information needed to initialize a video decoder,
 /// including codec-specific parameters, resolution, and optional metadata.
 ///
-/// Reference: <https://w3c.github.io/webcodecs/#video-decoder-config>
+/// Reference: <https://www.w3.org/TR/webcodecs/#video-decoder-config>
 #[serde_with::serde_as]
 #[serde_with::skip_serializing_none]
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
diff --git a/rs/hang/src/catalog/writer.rs b/rs/hang/src/catalog/writer.rs
new file mode 100644
index 000000000..db685e240
--- /dev/null
+++ b/rs/hang/src/catalog/writer.rs
@@ -0,0 +1,74 @@
+use std::collections::HashMap;
+
+use serde::Serialize;
+
+use crate::Result;
+
+use super::Section;
+
+/// Shared state for catalog sections.
+#[derive(Default)]
+pub struct CatalogState {
+	pub sections: HashMap<String, serde_json::Value>,
+}
+
+/// A catalog writer that manages typed sections and serializes them to JSON.
+///
+/// Each section is identified by a name and stores a typed value.
+/// The writer can encode all sections into a single JSON object for publishing.
+#[derive(Clone)]
+pub struct CatalogWriter {
+	state: conducer::Producer<CatalogState>,
+}
+
+impl Default for CatalogWriter {
+	fn default() -> Self {
+		Self::new()
+	}
+}
+
+impl CatalogWriter {
+	pub fn new() -> Self {
+		Self {
+			state: conducer::Producer::new(CatalogState::default()),
+		}
+	}
+
+	/// Write a section value. Serializes T to a JSON Value and stores it.
+	/// Consumers are notified of the change.
+	pub fn set<T: Serialize>(&self, section: &Section<T>, value: &T) -> Result<()> {
+		let json = serde_json::to_value(value)?;
+		let mut state = self.state.write().map_err(|_| crate::Error::Closed)?;
+		state.sections.insert(section.name.to_string(), json);
+		Ok(())
+	}
+
+	/// Remove a section from the catalog.
+	/// Consumers are notified of the change.
+	pub fn remove(&self, name: &str) -> Result<()> {
+		let mut state = self.state.write().map_err(|_| crate::Error::Closed)?;
+		state.sections.remove(name);
+		Ok(())
+	}
+
+	/// Create a consumer that gets notified on any catalog change.
+	pub fn consume(&self) -> conducer::Consumer<CatalogState> {
+		self.state.consume()
+	}
+
+	/// Get read-only access to the current state.
+	pub fn read(&self) -> conducer::Ref<'_, CatalogState> {
+		self.state.read()
+	}
+
+	/// Serialize all sections to a JSON byte vector.
+	pub fn encode(&self) -> Result<Vec<u8>> {
+		let state = self.state.read();
+		Ok(serde_json::to_vec(&state.sections)?)
+	}
+
+	/// Close the writer, notifying all consumers.
+	pub fn close(&self) {
+		let _ = self.state.close();
+	}
+}
diff --git a/rs/hang/src/container/consumer.rs b/rs/hang/src/container/consumer.rs
index e19e2ea60..924fc03cb 100644
--- a/rs/hang/src/container/consumer.rs
+++ b/rs/hang/src/container/consumer.rs
@@ -1,38 +1,24 @@
-use std::collections::VecDeque;
-use std::task::{Poll, ready};
-
-use buf_list::BufList;
-
 use super::{Frame, Timestamp};
-use crate::Error;
+use buf_list::BufList;
 
 /// A frame returned by [`OrderedConsumer::read()`] with group context.
+#[deprecated(note = "use moq_mux::consumer::OrderedFrame instead")]
 #[derive(Clone, Debug)]
 pub struct OrderedFrame {
-	/// The presentation timestamp for this frame.
 	pub timestamp: Timestamp,
-
-	/// The encoded media data for this frame, split into chunks.
 	pub payload: BufList,
-
-	/// The group sequence number this frame belongs to.
 	pub group: u64,
-
-	/// The frame index within the group (0 = first frame in the group).
-	///
-	/// With duration-based grouping (e.g. audio), the first frame is not
-	/// necessarily a keyframe — it only denotes position within the group.
 	pub index: usize,
 }
 
+#[allow(deprecated)]
 impl OrderedFrame {
-	/// Returns true if this is the first frame in the group (index 0).
 	pub fn is_keyframe(&self) -> bool {
 		self.index == 0
 	}
 }
 
-/// Lossy conversion: discards ordering metadata (`group` and `frame` fields).
+#[allow(deprecated)]
 impl From<OrderedFrame> for Frame {
 	fn from(ordered: OrderedFrame) -> Self {
 		Frame {
@@ -42,1172 +28,22 @@ impl From<OrderedFrame> for Frame {
 	}
 }
 
-/// A consumer for hang-formatted media tracks with timestamp reordering.
-///
-/// This wraps a `moq_lite::TrackConsumer` and adds hang-specific functionality
-/// like timestamp decoding, latency management, and frame buffering.
+/// Deprecated: use `moq_mux::consumer::OrderedConsumer` instead.
 ///
-/// ## Latency Management
-///
-/// The consumer can skip groups that are too far behind to maintain low latency.
-/// Configure the maximum acceptable delay through the consumer's latency settings.
+/// This stub exists only to provide a deprecation warning.
+/// The implementation has been moved to `moq_mux::consumer::OrderedConsumer`.
+#[deprecated(note = "use moq_mux::consumer::OrderedConsumer instead")]
 pub struct OrderedConsumer {
-	pub track: moq_lite::TrackConsumer,
-
-	// The current group that we want to read from
-	current: u64,
-
-	// Groups that we are monitoring, sorted by sequence ascending.
-	pending: VecDeque<GroupBuffer>,
-
-	// When true, we haven't returned a frame yet and need to select the first group.
-	// We wait until we have at least one frame before finalizing `current`
-	startup: bool,
-
-	// The maximum buffer size before skipping a group.
-	max_latency: std::time::Duration,
+	_private: (),
 }
 
+#[allow(deprecated)]
 impl OrderedConsumer {
-	/// Create a new OrderedConsumer wrapping the given moq-lite consumer.
-	pub fn new(track: moq_lite::TrackConsumer, max_latency: std::time::Duration) -> Self {
-		Self {
-			track,
-			current: 0,
-			pending: VecDeque::new(),
-			startup: true,
-			max_latency,
-		}
-	}
-
-	/// Read the next frame from the track.
-	///
-	/// This method handles timestamp decoding, group ordering, and latency management
-	/// automatically. It will skip groups that are too far behind to maintain the
-	/// configured latency target.
-	///
-	/// Returns `None` when the track has ended.
-	pub async fn read(&mut self) -> Result<Option<OrderedFrame>, Error> {
-		conducer::wait(|waiter| self.poll_read(waiter)).await
-	}
-
-	/// Poll-based implementation of the read loop.
-	///
-	/// Uses a single waiter that gets registered on all relevant conducer channels,
-	/// avoiding the need for `tokio::select!` or `FuturesUnordered`.
-	fn poll_read(&mut self, waiter: &conducer::Waiter) -> Poll<Result<Option<OrderedFrame>, Error>> {
-		// Grab any new groups from the track, recording whether the track is finished.
-		let finished = self.poll_read_finish(waiter)?.is_ready();
-
-		// On startup, we want to poll every pending group and advance self.current to the first with a frame.
-		if self.startup {
-			// NOTE: We loop in ascending order, so earlier groups will win the race.
-			for (i, group) in self.pending.iter_mut().enumerate() {
-				// We call poll_min_timestamp to try to buffer at least one frame per group.
-				// This returns Ready(Ok) if there is a buffered frame.
-				if !matches!(group.poll_min_timestamp(waiter), Poll::Ready(Ok(_))) {
-					continue;
-				}
-
-				// Start reading from this group and skip any previous groups.
-				self.current = group.info.sequence;
-				self.startup = false;
-				self.pending.drain(0..i);
-				break;
-			}
-		}
-
-		loop {
-			// Return the next frame from the current group if possible.
-			// If the current group is finished or errored, advance to the next group.
-			while let Some(group) = self.pending.front_mut()
-				&& group.info.sequence <= self.current
-			{
-				match group.poll_read(waiter) {
-					Poll::Ready(Ok(Some(frame))) => return Poll::Ready(Ok(Some(frame))),
-					// Still blocked on this group, don't skip it yet.
-					Poll::Pending => break,
-					Poll::Ready(Err(e)) => {
-						tracing::warn!(error = ?e, "error reading current group, skipping");
-					}
-					// No more frames, advance to next group.
-					Poll::Ready(Ok(None)) => {}
-				}
-
-				self.pending.pop_front();
-				self.current += 1
-			}
-
-			// Loop in ascending order to get the min, avoiding spurious wakeups.
-			let mut min_timestamp = std::time::Duration::MAX;
-			let mut min_idx = None;
-
-			for (i, group) in self.pending.iter_mut().enumerate() {
-				if group.info.sequence <= self.current {
-					continue;
-				}
-
-				if let Poll::Ready(Ok(ts)) = group.poll_min_timestamp(waiter) {
-					min_timestamp = min_timestamp.min(ts.into());
-					min_idx = Some(i);
-					break; // We know future groups won't be older than this.
-				}
-			}
-
-			// Loop in descending order to get the max, avoiding spurious wakeups.
-			let mut max_timestamp = std::time::Duration::ZERO;
-			for group in self.pending.iter_mut().rev() {
-				if group.info.sequence <= self.current {
-					break;
-				}
-
-				if let Poll::Ready(Ok(ts)) = group.poll_max_timestamp(waiter) {
-					max_timestamp = max_timestamp.max(ts.into());
-					break; // We know older groups won't be newer than this.
-				}
-			}
-
-			if let Some(new_idx) = min_idx
-				&& max_timestamp.saturating_sub(min_timestamp) >= self.max_latency
-			{
-				self.pending.drain(0..new_idx);
-				let new_current = self.pending.front().map(|g| g.info.sequence).unwrap();
-
-				tracing::debug!(old = self.current, new = new_current, "skipping slow groups");
-
-				self.current = new_current;
-				continue;
-			}
-
-			if finished && self.pending.is_empty() {
-				return Poll::Ready(Ok(None));
-			}
-
-			return Poll::Pending;
-		}
-	}
-
-	// Reads any new groups from the track until we're completely finished.
-	//
-	// Returns Pending until all groups have been consumed.
-	fn poll_read_finish(&mut self, waiter: &conducer::Waiter) -> Poll<Result<(), Error>> {
-		loop {
-			let Some(group) = ready!(self.track.poll_next_group(waiter)?) else {
-				// Track is finished.
-				return Poll::Ready(Ok(()));
-			};
-
-			let reader = GroupBuffer::new(group);
-			if reader.group.info.sequence < self.current {
-				tracing::debug!(
-					old = ?reader.group.info.sequence,
-					current = ?self.current,
-					"skipping old group"
-				);
-				continue;
-			}
-
-			let idx = self
-				.pending
-				.partition_point(|g| g.group.info.sequence < reader.group.info.sequence);
-			self.pending.insert(idx, reader);
-		}
-	}
-
-	/// Set the maximum latency tolerance for this consumer.
-	///
-	/// Groups with timestamps older than `max_timestamp - max_latency` will be skipped.
-	pub fn set_max_latency(&mut self, max: std::time::Duration) {
-		self.max_latency = max;
-	}
-
-	/// Wait until the track is closed.
-	pub async fn closed(&self) -> Result<(), Error> {
-		Ok(self.track.closed().await?)
-	}
-}
-
-impl From<OrderedConsumer> for moq_lite::TrackConsumer {
-	fn from(inner: OrderedConsumer) -> Self {
-		inner.track
-	}
-}
-
-impl std::ops::Deref for OrderedConsumer {
-	type Target = moq_lite::TrackConsumer;
-
-	fn deref(&self) -> &Self::Target {
-		&self.track
-	}
-}
-
-/// Internal reader for a group of frames.
-///
-/// Handles two-phase frame reading (get FrameConsumer, then read all data),
-/// timestamp parsing, and min/max timestamp tracking for latency decisions.
-struct GroupBuffer {
-	group: moq_lite::GroupConsumer,
-
-	// The current frame index within the group.
-	index: usize,
-
-	// Read frames that haven't been consumed yet.
-	buffered: VecDeque<OrderedFrame>,
-
-	// The minimum timestamp in the group.
-	min_timestamp: Option<Timestamp>,
-
-	// The maximum timestamp in the group.
-	max_timestamp: Option<Timestamp>,
-}
-
-impl GroupBuffer {
-	fn new(group: moq_lite::GroupConsumer) -> Self {
-		Self {
-			group,
-			index: 0,
-			buffered: VecDeque::new(),
-			max_timestamp: None,
-			min_timestamp: None,
-		}
-	}
-
-	/// Poll for the next frame from this group.
-	pub fn poll_read(&mut self, waiter: &conducer::Waiter) -> Poll<Result<Option<OrderedFrame>, Error>> {
-		if let Some(frame) = self.buffered.pop_front() {
-			return Poll::Ready(Ok(Some(frame)));
-		}
-
-		match ready!(self.buffer_one(waiter)?) {
-			true => Poll::Ready(Ok(Some(self.buffered.pop_front().unwrap()))),
-			false => Poll::Ready(Ok(None)),
-		}
-	}
-
-	// Add one more frame to the buffer if possible.
-	//
-	// Returns false if the track is finished.
-	fn buffer_once(&mut self, waiter: &conducer::Waiter) -> Poll<Result<bool, Error>> {
-		let Some(chunks) = ready!(self.group.poll_read_frame_chunks(waiter)?) else {
-			return Poll::Ready(Ok(false));
-		};
-
-		let mut payload = BufList::from_iter(chunks);
-		let timestamp = Timestamp::decode(&mut payload)?;
-
-		self.min_timestamp = Some(match self.min_timestamp {
-			Some(existing) => existing.min(timestamp),
-			None => timestamp,
-		});
-
-		self.max_timestamp = Some(match self.max_timestamp {
-			Some(existing) => existing.max(timestamp),
-			None => timestamp,
-		});
-
-		let index = self.index;
-		self.index += 1;
-
-		self.buffered.push_back(OrderedFrame {
-			timestamp,
-			payload,
-			group: self.group.info.sequence,
-			index,
-		});
-
-		Poll::Ready(Ok(true))
-	}
-
-	fn buffer_one(&mut self, waiter: &conducer::Waiter) -> Poll<Result<bool, Error>> {
-		if self.buffered.is_empty() {
-			self.buffer_once(waiter)
-		} else {
-			Poll::Ready(Ok(true))
-		}
-	}
-
-	fn buffer_all(&mut self, waiter: &conducer::Waiter) -> Poll<Result<(), Error>> {
-		while ready!(self.buffer_once(waiter)?) {}
-		Poll::Ready(Ok(()))
-	}
-
-	/// Poll for the maximum timestamp in this group.
-	pub fn poll_max_timestamp(&mut self, waiter: &conducer::Waiter) -> Poll<Result<Timestamp, Error>> {
-		// Keep reading more frames just to advance the max timestamp.
-		let _ = self.buffer_all(waiter)?;
-
-		if let Some(max) = self.max_timestamp {
-			return Poll::Ready(Ok(max));
-		}
-
-		if let Poll::Ready(_frames) = self.group.poll_finished(waiter)? {
-			return Poll::Ready(Err(Error::EmptyGroup));
-		}
-
-		Poll::Pending
-	}
-
-	pub fn poll_min_timestamp(&mut self, waiter: &conducer::Waiter) -> Poll<Result<Timestamp, Error>> {
-		let _ = self.buffer_one(waiter)?;
-
-		if let Some(min) = self.min_timestamp {
-			return Poll::Ready(Ok(min));
-		}
-
-		if let Poll::Ready(_frames) = self.group.poll_finished(waiter)? {
-			return Poll::Ready(Err(Error::EmptyGroup));
-		}
-
-		Poll::Pending
-	}
-}
-
-impl std::ops::Deref for GroupBuffer {
-	type Target = moq_lite::GroupConsumer;
-
-	fn deref(&self) -> &Self::Target {
-		&self.group
-	}
-}
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-	use std::time::Duration;
-
-	use bytes::Bytes;
-
-	fn ts(micros: u64) -> Timestamp {
-		Timestamp::from_micros(micros).unwrap()
-	}
-
-	/// Write a finished group with explicit sequence and timestamps.
-	fn write_group(track: &mut moq_lite::TrackProducer, sequence: u64, timestamps: &[Timestamp]) {
-		let mut group = track.create_group(moq_lite::Group { sequence }).unwrap();
-		for &timestamp in timestamps {
-			let frame = Frame {
-				timestamp,
-				payload: BufList::from_iter(vec![Bytes::from_static(&[0xDE, 0xAD])]),
-			};
-			frame.encode(&mut group).unwrap();
-		}
-		group.finish().unwrap();
-	}
-
-	/// Drain all available frames with a per-read timeout.
-	async fn read_all(consumer: &mut OrderedConsumer) -> Result<Vec<OrderedFrame>, crate::Error> {
-		let mut frames = Vec::new();
-		loop {
-			match tokio::time::timeout(Duration::from_millis(200), consumer.read()).await {
-				Ok(Ok(Some(frame))) => frames.push(frame),
-				Ok(Ok(None)) => break,
-				Ok(Err(e)) => return Err(e),
-				Err(_) => panic!(
-					"read_all: OrderedConsumer::read timed out after 200ms ({} frames collected so far)",
-					frames.len()
-				),
-			}
-		}
-		Ok(frames)
-	}
-
-	// ---- Basic Reading ----
-
-	#[tokio::test]
-	async fn read_single_group() {
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(500));
-
-		write_group(&mut track, 0, &[ts(0)]);
-		track.finish().unwrap();
-
-		let frames = read_all(&mut consumer).await.unwrap();
-		assert_eq!(frames.len(), 1);
-		assert_eq!(frames[0].timestamp, ts(0));
-		assert_eq!(frames[0].index, 0);
-
-		// Next read returns None (track ended)
-		assert!(consumer.read().await.unwrap().is_none());
-	}
-
-	#[tokio::test]
-	async fn read_multiple_frames_single_group() {
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(500));
-
-		write_group(&mut track, 0, &[ts(0), ts(33_000), ts(66_000)]);
-		track.finish().unwrap();
-
-		let frames = read_all(&mut consumer).await.unwrap();
-		assert_eq!(frames.len(), 3);
-		assert_eq!(frames[0].timestamp, ts(0));
-		assert_eq!(frames[1].timestamp, ts(33_000));
-		assert_eq!(frames[2].timestamp, ts(66_000));
-
-		assert_eq!(frames[0].index, 0);
-		assert_eq!(frames[1].index, 1);
-		assert_eq!(frames[2].index, 2);
-	}
-
-	#[tokio::test]
-	async fn read_multiple_groups_within_latency() {
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(500));
-
-		// 5 groups, 20ms spacing. Total span = 80ms, well within 500ms latency.
-		for i in 0..5u64 {
-			write_group(&mut track, i, &[ts(i * 20_000)]);
-		}
-		track.finish().unwrap();
-
-		let frames = read_all(&mut consumer).await.unwrap();
-		assert_eq!(frames.len(), 5);
-	}
-
-	// ---- Latency Skipping ----
-	//
-	// These tests verify that the poll-based latency skip logic correctly
-	// promotes pending groups to current when the timestamp span exceeds
-	// max_latency.
-
-	#[tokio::test]
-	async fn latency_skip_delivers_recent_groups() {
-		tokio::time::pause();
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(100));
-
-		// Group 0: 5 frames, NOT finished (blocks consumer)
-		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
-		for f in 0..5u64 {
-			Frame {
-				timestamp: ts(f * 2_000),
-				payload: BufList::from_iter(vec![Bytes::from_static(&[0xDE, 0xAD])]),
-			}
-			.encode(&mut group0)
-			.unwrap();
-		}
-
-		// Groups 1-19: finished, 15ms spacing, 5 frames each
-		for g in 1..20u64 {
-			let timestamps: Vec<_> = (0..5).map(|f| ts(g * 15_000 + f * 2_000)).collect();
-			write_group(&mut track, g, &timestamps);
-		}
-		track.finish().unwrap();
-
-		// Finish group 0 after consumer has had time to accumulate pending groups
-		let finisher = tokio::spawn(async move {
-			tokio::time::sleep(Duration::from_millis(50)).await;
-			group0.finish().unwrap();
-		});
-
-		let frames = read_all(&mut consumer).await.unwrap();
-		// Group 0's 5 frames + some later groups (earlier ones skipped by latency)
-		assert!(frames.len() >= 25, "Expected >= 25 frames, got {}", frames.len());
-		finisher.await.expect("finisher task panicked");
-	}
-
-	#[tokio::test]
-	async fn zero_latency_skips_aggressively() {
-		tokio::time::pause();
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::ZERO);
-
-		// Group 0: 1 frame at a HIGH timestamp, NOT finished.
-		// This makes the cutoff high (max_timestamp + 0 = 400ms), so
-		// buffer_until blocks for groups whose timestamps are < 400ms.
-		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
-		Frame {
-			timestamp: ts(400_000),
-			payload: BufList::from_iter(vec![Bytes::from_static(&[0xDE, 0xAD])]),
-		}
-		.encode(&mut group0)
-		.unwrap();
-
-		// Groups 1-9: finished, 50ms spacing, 3 frames each
-		// Groups 1-7 have max timestamps < 400ms (blocked by buffer_until)
-		// Group 8+ have timestamps >= 400ms (trigger latency skip)
-		for g in 1..10u64 {
-			let timestamps: Vec<_> = (0..3).map(|f| ts(g * 50_000 + f * 5_000)).collect();
-			write_group(&mut track, g, &timestamps);
-		}
-		track.finish().unwrap();
-
-		let finisher = tokio::spawn(async move {
-			tokio::time::sleep(Duration::from_millis(50)).await;
-			group0.finish().unwrap();
-		});
-
-		let frames = read_all(&mut consumer).await.unwrap();
-		// The latency skip bridges past the blocking group 0 to the nearest
-		// pending group with data. All subsequent finished groups are delivered
-		// instantly. Group 0's 1 frame + groups 1-9 (3 frames each) = 28.
-		assert_eq!(frames.len(), 28, "Expected group 0 frame + groups 1-9");
-		assert!(!frames.is_empty(), "Expected at least some frames");
-		finisher.await.expect("finisher task panicked");
-	}
-
-	#[tokio::test]
-	async fn latency_skip_correctness() {
-		tokio::time::pause();
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(100));
-
-		// Group 0: 1 frame, NOT finished
-		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
-		Frame {
-			timestamp: ts(0),
-			payload: BufList::from_iter(vec![Bytes::from_static(&[0xDE, 0xAD])]),
-		}
-		.encode(&mut group0)
-		.unwrap();
-
-		// Groups 1-9: 30ms spacing, 1 frame each
-		for g in 1..10u64 {
-			write_group(&mut track, g, &[ts(g * 30_000)]);
-		}
-		track.finish().unwrap();
-
-		let finisher = tokio::spawn(async move {
-			tokio::time::sleep(Duration::from_millis(50)).await;
-			group0.finish().unwrap();
-		});
-
-		let frames = read_all(&mut consumer).await.unwrap();
-		assert!(!frames.is_empty(), "Expected at least some frames");
-
-		// The latency skip bridges past the blocking group 0 to the nearest
-		// pending group with data. All subsequent groups are delivered since
-		// they can be read instantly (already finished). Group 0's frame (ts=0)
-		// is returned before the skip, then groups 1-9 after.
-		assert_eq!(frames.len(), 10, "Expected group 0 frame + groups 1-9");
-		assert_eq!(frames[0].timestamp, ts(0));
-
-		// Groups should be delivered in sequence order
-		for i in 1..10u64 {
-			assert_eq!(frames[i as usize].timestamp, ts(i * 30_000));
-		}
-		finisher.await.expect("finisher task panicked");
-	}
-
-	// ---- Group Ordering ----
-
-	#[tokio::test]
-	async fn groups_delivered_in_sequence_order() {
-		tokio::time::pause();
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(500));
-
-		// Group 0: 1 frame, NOT finished (blocks consumer, lets groups 2 and 1 accumulate in pending)
-		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
-		Frame {
-			timestamp: ts(0),
-			payload: BufList::from_iter(vec![Bytes::from_static(&[0xDE, 0xAD])]),
-		}
-		.encode(&mut group0)
-		.unwrap();
-
-		// Write groups 2 then 1 (out of sequence order)
-		write_group(&mut track, 2, &[ts(60_000)]);
-		write_group(&mut track, 1, &[ts(30_000)]);
-		track.finish().unwrap();
-
-		// Finish group 0 so the consumer can proceed to pending groups
-		let finisher = tokio::spawn(async move {
-			tokio::time::sleep(Duration::from_millis(10)).await;
-			group0.finish().unwrap();
-		});
-
-		let frames = read_all(&mut consumer).await.unwrap();
-		assert_eq!(frames.len(), 3);
-
-		// Pending queue sorts by sequence, so delivery order is 0, 1, 2
-		assert_eq!(frames[0].timestamp, ts(0));
-		assert_eq!(frames[1].timestamp, ts(30_000));
-		assert_eq!(frames[2].timestamp, ts(60_000));
-		finisher.await.expect("finisher task panicked");
-	}
-
-	#[tokio::test]
-	async fn adjacent_group_flushed_immediately() {
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(500));
-
-		write_group(&mut track, 0, &[ts(0)]);
-		write_group(&mut track, 1, &[ts(30_000)]);
-		track.finish().unwrap();
-
-		let frames = read_all(&mut consumer).await.unwrap();
-		assert_eq!(frames.len(), 2);
-		assert_eq!(frames[0].timestamp, ts(0));
-		assert_eq!(frames[1].timestamp, ts(30_000));
-	}
-
-	// ---- B-frames ----
-
-	#[tokio::test]
-	async fn bframes_within_group() {
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(500));
-
-		// B-frame decode order: timestamps [0, 66ms, 33ms]
-		write_group(&mut track, 0, &[ts(0), ts(66_000), ts(33_000)]);
-		track.finish().unwrap();
-
-		let frames = read_all(&mut consumer).await.unwrap();
-		assert_eq!(frames.len(), 3);
-		// Delivered in write order (decode order), not presentation order
-		assert_eq!(frames[0].timestamp, ts(0));
-		assert_eq!(frames[1].timestamp, ts(66_000));
-		assert_eq!(frames[2].timestamp, ts(33_000));
-	}
-
-	// ---- Track Lifecycle ----
-
-	#[tokio::test]
-	async fn empty_track_returns_none() {
-		tokio::time::pause();
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(500));
-
-		track.finish().unwrap();
-
-		let result = tokio::time::timeout(Duration::from_millis(200), consumer.read()).await;
-		match result {
-			Ok(Ok(None)) => {} // expected: track ended
-			Ok(Ok(Some(_))) => panic!("expected None for empty track, got Some"),
-			Ok(Err(e)) => panic!("expected None for empty track, got error: {e}"),
-			Err(_) => panic!("should not hang on empty track"),
-		}
-	}
-
-	#[tokio::test]
-	async fn track_closed_with_error() {
-		tokio::time::pause();
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(500));
-
-		write_group(&mut track, 0, &[ts(0)]);
-		track.abort(moq_lite::Error::Cancel).unwrap();
-
-		// Consumer should not hang; it should return frames or error gracefully
-		let result = tokio::time::timeout(Duration::from_millis(500), async {
-			let mut frames = Vec::new();
-			while let Ok(Some(frame)) = consumer.read().await {
-				frames.push(frame);
-			}
-			frames
-		})
-		.await;
-
-		assert!(result.is_ok(), "Consumer should not hang after track error");
-	}
-
-	#[tokio::test]
-	async fn closed_resolves_when_track_ends() {
-		tokio::time::pause();
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(500));
-
-		// closed() should not resolve yet
-		assert!(
-			tokio::time::timeout(Duration::from_millis(50), consumer.closed())
-				.await
-				.is_err()
-		);
-
-		// finish() + drop triggers the Closed/Dropped state that closed() waits for
-		track.finish().unwrap();
-		drop(track);
-
-		// closed() should resolve now
-		tokio::time::timeout(Duration::from_millis(200), consumer.closed())
-			.await
-			.expect("timeout expired waiting for closed()")
-			.expect("consumer.closed() returned an error");
-	}
-
-	// ---- Gap Recovery ----
-
-	#[tokio::test]
-	async fn gap_in_group_sequence_recovery() {
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(100));
-
-		// Groups 0, 1 then skip 2, write 3-6
-		write_group(&mut track, 0, &[ts(0), ts(20_000)]);
-		write_group(&mut track, 1, &[ts(40_000), ts(60_000)]);
-		// Gap at group 2
-		write_group(&mut track, 3, &[ts(120_000), ts(140_000)]);
-		write_group(&mut track, 4, &[ts(160_000), ts(180_000)]);
-		write_group(&mut track, 5, &[ts(200_000), ts(220_000)]);
-		write_group(&mut track, 6, &[ts(240_000), ts(260_000)]);
-		track.finish().unwrap();
-
-		// Consumer must not deadlock on the missing group 2
-		let frames = read_all(&mut consumer).await.unwrap();
-		assert!(frames.len() >= 4, "Expected >= 4 frames, got {}", frames.len());
-	}
-
-	#[tokio::test]
-	async fn gap_at_start_of_sequence() {
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(80));
-
-		// First group at sequence 5 (simulating joining mid-stream), gap at 6
-		write_group(&mut track, 5, &[ts(0), ts(20_000)]);
-		write_group(&mut track, 7, &[ts(80_000), ts(100_000)]);
-		write_group(&mut track, 8, &[ts(120_000), ts(140_000)]);
-		write_group(&mut track, 9, &[ts(160_000), ts(180_000)]);
-		track.finish().unwrap();
-
-		let frames = read_all(&mut consumer).await.unwrap();
-		assert!(frames.len() >= 4, "Expected >= 4 frames, got {}", frames.len());
-	}
-
-	// ---- Frame Decoding ----
-
-	#[tokio::test]
-	async fn frame_timestamp_and_index_decoding() {
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(500));
-
-		write_group(&mut track, 0, &[ts(0), ts(33_333), ts(66_666)]);
-		track.finish().unwrap();
-
-		let frames = read_all(&mut consumer).await.unwrap();
-		assert_eq!(frames.len(), 3);
-
-		assert_eq!(frames[0].timestamp, ts(0));
-		assert_eq!(frames[0].index, 0);
-
-		assert_eq!(frames[1].timestamp, ts(33_333));
-		assert_eq!(frames[1].index, 1);
-
-		assert_eq!(frames[2].timestamp, ts(66_666));
-		assert_eq!(frames[2].index, 2);
-	}
-
-	#[tokio::test]
-	async fn frame_payload_preserved() {
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(500));
-
-		let payload_bytes = vec![0x01, 0x02, 0x03, 0x04, 0x05];
-		let mut group = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
-		Frame {
-			timestamp: ts(0),
-			payload: BufList::from_iter(vec![Bytes::from(payload_bytes.clone())]),
-		}
-		.encode(&mut group)
-		.unwrap();
-		group.finish().unwrap();
-		track.finish().unwrap();
-
-		let frames = read_all(&mut consumer).await.unwrap();
-		assert_eq!(frames.len(), 1);
-
-		use bytes::Buf;
-		let mut received = Vec::new();
-		let mut payload = frames[0].payload.clone();
-		while payload.has_remaining() {
-			received.push(payload.get_u8());
-		}
-		assert_eq!(received, payload_bytes);
-	}
-
-	// ---- Regression ----
-
-	/// Regression test for de92d2c7: the old select!-based implementation had an
-	/// infinite loop when a pending group had buffered frames from a prior
-	/// (dropped) buffer_until call.
-	///
-	/// The poll-based rewrite avoids this by design: frames are only read on-demand,
-	/// and buffered frames are consumed before polling for new ones.
-	#[tokio::test]
-	async fn no_infinite_loop_with_buffered_frames() {
-		tokio::time::pause();
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_secs(10));
-
-		// Group 0: 1 frame, NOT finished
-		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
-		Frame {
-			timestamp: ts(0),
-			payload: BufList::from_iter(vec![Bytes::from_static(&[0xDE, 0xAD])]),
-		}
-		.encode(&mut group0)
-		.unwrap();
-
-		// Group 1: finished (buffer_until will buffer its frames)
-		write_group(&mut track, 1, &[ts(100_000)]);
-
-		let finisher = tokio::spawn(async move {
-			// After consumer has buffered group 1's frames via buffer_until...
-			tokio::time::sleep(Duration::from_millis(20)).await;
-			// Write group 2: next_group fires, drops current buffer_until for group 1
-			write_group(&mut track, 2, &[ts(200_000)]);
-			// Then finish group 0: consumer proceeds, re-creates buffer_until for group 1
-			tokio::time::sleep(Duration::from_millis(20)).await;
-			group0.finish().unwrap();
-			track.finish().unwrap();
-		});
-
-		// Must complete within 2 seconds (with the bug, this would hang)
-		let frames = tokio::time::timeout(Duration::from_secs(2), async {
-			let mut frames = Vec::new();
-			while let Some(frame) = consumer.read().await.unwrap() {
-				frames.push(frame);
-			}
-			frames
-		})
-		.await
-		.expect("consumer hung — possible infinite loop regression");
-
-		assert_eq!(frames.len(), 3);
-		finisher.await.expect("finisher task panicked");
-	}
-
-	// ---- Edge Cases ----
-
-	#[tokio::test]
-	async fn large_timestamps() {
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_secs(3700));
-
-		// 1 hour = 3,600,000,000 microseconds
-		let one_hour = 3_600_000_000u64;
-		write_group(&mut track, 0, &[ts(one_hour)]);
-		track.finish().unwrap();
-
-		let frames = read_all(&mut consumer).await.unwrap();
-		assert_eq!(frames.len(), 1);
-		assert_eq!(frames[0].timestamp, ts(one_hour));
-		assert_eq!(frames[0].timestamp.as_micros(), one_hour as u128);
+	pub fn new(_track: moq_lite::TrackConsumer, _max_latency: std::time::Duration) -> Self {
+		panic!("hang::container::OrderedConsumer has been moved to moq_mux::consumer::OrderedConsumer")
 	}
 
-	#[tokio::test]
-	async fn set_max_latency_changes_behavior() {
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_secs(10));
-
-		write_group(&mut track, 0, &[ts(0)]);
-		track.finish().unwrap();
-
-		// Read with initial large latency
-		let frame = consumer.read().await.unwrap().unwrap();
-		assert_eq!(frame.timestamp, ts(0));
-
-		// Change latency — verify it doesn't panic and consumer still works
-		consumer.set_max_latency(Duration::from_millis(100));
-
-		// Track is already finished, so next read returns None
-		assert!(consumer.read().await.unwrap().is_none());
-	}
-
-	/// Verify max_timestamp tracks the true maximum through B-frame reordering.
-	///
-	/// With B-frame decode order [0, 66ms, 33ms], the bug assigned max_timestamp = 33ms
-	/// (last frame) instead of 66ms (true max). This lowered the latency cutoff, causing
-	/// premature skipping of subsequent groups under tight latency settings.
-	///
-	/// Setup: group 0 is unfinished with B-frames, group 1 at ts(100ms), latency = 40ms.
-	/// Bug:   cutoff = 33ms + 40ms = 73ms → group 1's buffer_until sees 100ms >= 73ms → skip
-	/// Fix:   cutoff = 66ms + 40ms = 106ms → 100ms < 106ms → no skip, all groups delivered
-	#[tokio::test]
-	async fn max_timestamp_tracks_through_bframes() {
-		tokio::time::pause();
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(40));
-
-		// Group 0: B-frame decode order [0, 66ms, 33ms], NOT finished (blocks consumer)
-		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
-		for &timestamp in &[ts(0), ts(66_000), ts(33_000)] {
-			Frame {
-				timestamp,
-				payload: BufList::from_iter(vec![Bytes::from_static(&[0xDE, 0xAD])]),
-			}
-			.encode(&mut group0)
-			.unwrap();
-		}
-
-		// Group 1: finished, at ts(100ms)
-		write_group(&mut track, 1, &[ts(100_000)]);
-		track.finish().unwrap();
-
-		// Finish group 0 after consumer has had time to accumulate pending groups
-		let finisher = tokio::spawn(async move {
-			tokio::time::sleep(Duration::from_millis(50)).await;
-			group0.finish().unwrap();
-		});
-
-		let frames = tokio::time::timeout(Duration::from_secs(2), async {
-			let mut frames = Vec::new();
-			while let Some(frame) = consumer.read().await.unwrap() {
-				frames.push(frame);
-			}
-			frames
-		})
-		.await
-		.expect("consumer hung — max_timestamp regression");
-
-		assert_eq!(frames.len(), 4, "Expected all 4 frames, got {}", frames.len());
-		assert_eq!(frames[0].timestamp, ts(0));
-		assert_eq!(frames[1].timestamp, ts(66_000));
-		assert_eq!(frames[2].timestamp, ts(33_000));
-		assert_eq!(frames[3].timestamp, ts(100_000));
-		finisher.await.expect("finisher task panicked");
-	}
-
-	// ---- Startup Behavior ----
-
-	#[tokio::test]
-	async fn startup_selects_earliest_group() {
-		tokio::time::pause();
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		// max_latency = 100ms.
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(100));
-
-		// Groups 3, 5, 7 — non-sequential with gaps.
-		// After startup selects group 3 (earliest with data), consumer reads it,
-		// then blocks on gap (waiting for group 4 which never arrives).
-		write_group(&mut track, 3, &[ts(0)]);
-		write_group(&mut track, 5, &[ts(150_000)]);
-
-		// Group 7: write one frame now, push a second later to trigger the latency skip.
-		let mut group7 = track.create_group(moq_lite::Group { sequence: 7 }).unwrap();
-		Frame {
-			timestamp: ts(300_000),
-			payload: BufList::from_iter(vec![Bytes::from_static(&[0xDE, 0xAD])]),
-		}
-		.encode(&mut group7)
-		.unwrap();
-
-		let finisher = tokio::spawn(async move {
-			// Wait for the consumer to process groups 3 and 5, then push
-			// a second frame on group 7 with a high enough timestamp to
-			// trigger the latency skip past the gap at group 6.
-			tokio::time::sleep(Duration::from_millis(50)).await;
-			Frame {
-				timestamp: ts(400_000),
-				payload: BufList::from_iter(vec![Bytes::from_static(&[0xBE, 0xEF])]),
-			}
-			.encode(&mut group7)
-			.unwrap();
-			group7.finish().unwrap();
-			track.finish().unwrap();
-		});
-
-		let frames = tokio::time::timeout(Duration::from_secs(2), async {
-			let mut frames = Vec::new();
-			while let Some(frame) = consumer.read().await.unwrap() {
-				frames.push(frame);
-			}
-			frames
-		})
-		.await
-		.expect("should not hang");
-
-		// Startup picks group 3 (earliest with data), reads it.
-		// Blocks on gap at 4. Latency skip: min(5)=150ms, max(7)=400ms → skip to 5.
-		// Reads group 5, blocks on gap at 6. Another skip to group 7.
-		assert_eq!(frames[0].group, 3);
-		assert_eq!(frames[1].group, 5);
-		assert!(frames.iter().skip(2).all(|f| f.group == 7));
-		finisher.await.unwrap();
-	}
-
-	#[tokio::test]
-	async fn startup_skips_groups_without_data() {
-		tokio::time::pause();
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(500));
-
-		// Group 5: no frames written yet (pending)
-		let _group5 = track.create_group(moq_lite::Group { sequence: 5 }).unwrap();
-		// Group 7: has data
-		write_group(&mut track, 7, &[ts(210_000)]);
-		track.finish().unwrap();
-
-		let frames = tokio::time::timeout(Duration::from_millis(500), async {
-			let mut frames = Vec::new();
-			while let Some(frame) = consumer.read().await.unwrap() {
-				frames.push(frame);
-			}
-			frames
-		})
-		.await
-		.expect("should not hang");
-
-		assert!(!frames.is_empty());
-		// Group 7 should be selected since group 5 has no data.
-		assert_eq!(frames[0].group, 7);
-	}
-
-	#[tokio::test]
-	async fn startup_single_group_mid_stream() {
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(500));
-
-		// Only group 100 exists.
-		write_group(&mut track, 100, &[ts(3_000_000)]);
-		track.finish().unwrap();
-
-		let frames = read_all(&mut consumer).await.unwrap();
-		assert_eq!(frames.len(), 1);
-		assert_eq!(frames[0].group, 100);
-	}
-
-	#[tokio::test]
-	async fn multiple_sequential_latency_skips() {
-		tokio::time::pause();
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(50));
-
-		// Group 0: blocks
-		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
-		Frame {
-			timestamp: ts(0),
-			payload: BufList::from_iter(vec![Bytes::from_static(&[0xAA])]),
-		}
-		.encode(&mut group0)
-		.unwrap();
-
-		// Groups 1-3: each 100ms apart, triggering skips (> 50ms latency)
-		write_group(&mut track, 1, &[ts(100_000)]);
-		write_group(&mut track, 2, &[ts(200_000)]);
-		write_group(&mut track, 3, &[ts(300_000)]);
-		track.finish().unwrap();
-
-		let finisher = tokio::spawn(async move {
-			tokio::time::sleep(Duration::from_millis(20)).await;
-			group0.finish().unwrap();
-		});
-
-		let frames = read_all(&mut consumer).await.unwrap();
-		assert!(!frames.is_empty());
-		finisher.await.unwrap();
-	}
-
-	#[tokio::test]
-	async fn latency_skip_boundary_exact() {
-		tokio::time::pause();
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(100));
-
-		// Group 0: blocks
-		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
-		Frame {
-			timestamp: ts(0),
-			payload: BufList::from_iter(vec![Bytes::from_static(&[0xAA])]),
-		}
-		.encode(&mut group0)
-		.unwrap();
-
-		// Group 1: exactly 100ms span (>= max_latency should trigger skip)
-		write_group(&mut track, 1, &[ts(100_000)]);
-		track.finish().unwrap();
-
-		let finisher = tokio::spawn(async move {
-			tokio::time::sleep(Duration::from_millis(20)).await;
-			group0.finish().unwrap();
-		});
-
-		let frames = read_all(&mut consumer).await.unwrap();
-		assert!(!frames.is_empty());
-		finisher.await.unwrap();
-	}
-
-	#[tokio::test]
-	async fn group_error_skips_to_next() {
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(500));
-
-		// Group 0: aborted
-		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
-		group0.abort(moq_lite::Error::Cancel).unwrap();
-
-		// Group 1: valid
-		write_group(&mut track, 1, &[ts(30_000)]);
-		track.finish().unwrap();
-
-		let frames = read_all(&mut consumer).await.unwrap();
-		assert_eq!(frames.len(), 1);
-		assert_eq!(frames[0].group, 1);
-	}
-
-	#[tokio::test]
-	async fn track_finishes_while_reading() {
-		tokio::time::pause();
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(500));
-
-		write_group(&mut track, 0, &[ts(0)]);
-
-		// Finish the track after a delay, simulating incremental arrival.
-		let finisher = tokio::spawn(async move {
-			tokio::time::sleep(Duration::from_millis(20)).await;
-			write_group(&mut track, 1, &[ts(30_000)]);
-			tokio::time::sleep(Duration::from_millis(20)).await;
-			track.finish().unwrap();
-		});
-
-		let frames = tokio::time::timeout(Duration::from_secs(2), async {
-			let mut frames = Vec::new();
-			while let Some(frame) = consumer.read().await.unwrap() {
-				frames.push(frame);
-			}
-			frames
-		})
-		.await
-		.expect("consumer should not hang");
-
-		assert_eq!(frames.len(), 2);
-		finisher.await.unwrap();
-	}
-
-	#[tokio::test]
-	async fn empty_group_advances() {
-		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
-		let mut consumer = OrderedConsumer::new(consumer_track, Duration::from_millis(500));
-
-		// Group 0: empty (no frames, just finished)
-		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
-		group0.finish().unwrap();
-
-		// Group 1: has data
-		write_group(&mut track, 1, &[ts(30_000)]);
-		track.finish().unwrap();
-
-		let frames = read_all(&mut consumer).await.unwrap();
-		assert_eq!(frames.len(), 1);
-		assert_eq!(frames[0].group, 1);
+	pub async fn read(&mut self) -> Result<Option<OrderedFrame>, crate::Error> {
+		panic!("hang::container::OrderedConsumer has been moved to moq_mux::consumer::OrderedConsumer")
 	}
 }
diff --git a/rs/hang/src/container/mod.rs b/rs/hang/src/container/mod.rs
index e917ead2c..78d6ca642 100644
--- a/rs/hang/src/container/mod.rs
+++ b/rs/hang/src/container/mod.rs
@@ -2,6 +2,7 @@ mod consumer;
 mod frame;
 mod producer;
 
+#[allow(deprecated)]
 pub use consumer::*;
 pub use frame::*;
 pub use producer::*;
diff --git a/rs/hang/src/container/producer.rs b/rs/hang/src/container/producer.rs
index f179e364d..0b56eb696 100644
--- a/rs/hang/src/container/producer.rs
+++ b/rs/hang/src/container/producer.rs
@@ -1,4 +1,4 @@
-use super::{Frame, OrderedConsumer, Timestamp};
+use super::{Frame, Timestamp};
 use crate::Error;
 
 /// A producer for media tracks with group management.
@@ -128,14 +128,6 @@ impl OrderedProducer {
 		self.track.finish()?;
 		Ok(())
 	}
-
-	/// Create a consumer for this track.
-	///
-	/// Multiple consumers can be created from the same producer, each receiving
-	/// a copy of all data written to the track.
-	pub fn consume(&self, max_latency: std::time::Duration) -> OrderedConsumer {
-		OrderedConsumer::new(self.track.consume(), max_latency)
-	}
 }
 
 impl From<moq_lite::TrackProducer> for OrderedProducer {
diff --git a/rs/hang/src/error.rs b/rs/hang/src/error.rs
index 53b54d3bb..7480c6aab 100644
--- a/rs/hang/src/error.rs
+++ b/rs/hang/src/error.rs
@@ -43,6 +43,10 @@ pub enum Error {
 	#[error("url parse error: {0}")]
 	Url(#[from] url::ParseError),
 
+	/// The catalog or section channel has been closed.
+	#[error("closed")]
+	Closed,
+
 	/// A group contained zero frames.
 	#[error("empty group")]
 	EmptyGroup,
diff --git a/rs/hang/src/lib.rs b/rs/hang/src/lib.rs
index ef96d742d..b31e66cde 100644
--- a/rs/hang/src/lib.rs
+++ b/rs/hang/src/lib.rs
@@ -23,5 +23,5 @@ pub mod container;
 /// Export the moq-lite version we use.
 pub use moq_lite;
 
-pub use catalog::{Catalog, CatalogConsumer};
+pub use catalog::{CatalogConsumer, CatalogReader, CatalogWriter, Section, SectionConsumer};
 pub use error::*;
diff --git a/rs/libmoq/Cargo.toml b/rs/libmoq/Cargo.toml
index 996f38416..bc4455875 100644
--- a/rs/libmoq/Cargo.toml
+++ b/rs/libmoq/Cargo.toml
@@ -23,6 +23,7 @@ hang = { workspace = true }
 moq-lite = { workspace = true, features = ["serde"] }
 moq-mux = { workspace = true }
 moq-native = { workspace = true, default-features = true }
+serde_json = "1"
 thiserror = "2"
 tokio = { workspace = true, features = ["macros"] }
 tracing = "0.1"
diff --git a/rs/libmoq/README.md b/rs/libmoq/README.md
index 726fc5da4..b958561e1 100644
--- a/rs/libmoq/README.md
+++ b/rs/libmoq/README.md
@@ -48,9 +48,9 @@ int32_t moq_publish_media_frame(uint32_t media, const uint8_t *payload, uintptr_
 int32_t moq_consume_close(uint32_t consume);
 
 // Consuming: Catalog
-int32_t moq_consume_catalog(uint32_t broadcast, void (*on_catalog)(void *user_data, int32_t catalog), void *user_data);
+int32_t moq_consume_catalog_subscribe(uint32_t broadcast, void (*on_catalog)(void *user_data, int32_t catalog), void *user_data);
+int32_t moq_consume_catalog_unsubscribe(uint32_t catalog);
 int32_t moq_consume_catalog_close(uint32_t catalog);
-int32_t moq_consume_catalog_free(uint32_t catalog);
 int32_t moq_consume_video_config(uint32_t catalog, uint32_t index, moq_video_config *dst);
 int32_t moq_consume_audio_config(uint32_t catalog, uint32_t index, moq_audio_config *dst);
 
diff --git a/rs/libmoq/src/api.rs b/rs/libmoq/src/api.rs
index 075d8d8b8..368f73e5f 100644
--- a/rs/libmoq/src/api.rs
+++ b/rs/libmoq/src/api.rs
@@ -76,8 +76,8 @@ pub struct moq_announced {
 	pub path: *const c_char,
 	pub path_len: usize,
 
-	/// Whether the broadcast is active or has ended
-	/// This MUST toggle between true and false over the lifetime of the broadcast
+	/// Whether the broadcast is active (always true; unannouncements are no longer sent).
+	#[deprecated(note = "always true — use BroadcastConsumer::closed() to detect end of broadcast")]
 	pub active: bool,
 }
 
@@ -97,7 +97,8 @@ pub unsafe extern "C" fn moq_log_level(level: *const c_char, level_len: usize) -
 			"" => moq_native::Log::default(),
 			level => moq_native::Log::new(Level::from_str(level)?),
 		}
-		.init();
+		.init()
+		.map_err(|_| crate::error::Error::LogInit)?;
 
 		Ok(())
 	})
@@ -359,7 +360,7 @@ pub unsafe extern "C" fn moq_publish_media_frame(
 	})
 }
 
-/// Create a catalog consumer for a broadcast.
+/// Subscribe to catalog updates for a broadcast.
 ///
 /// The callback is called with a catalog ID when a new catalog is available.
 /// The catalog ID can be used to query video/audio track information.
@@ -367,9 +368,9 @@ pub unsafe extern "C" fn moq_publish_media_frame(
 /// Returns a non-zero handle on success, or a negative code on failure.
 ///
 /// # Safety
-/// - The caller must ensure that `on_catalog` is valid until [moq_consume_catalog_close] is called.
+/// - The caller must ensure that `on_catalog` is valid until [moq_consume_catalog_unsubscribe] is called.
 #[unsafe(no_mangle)]
-pub unsafe extern "C" fn moq_consume_catalog(
+pub unsafe extern "C" fn moq_consume_catalog_subscribe(
 	broadcast: u32,
 	on_catalog: Option<extern "C" fn(user_data: *mut c_void, catalog: i32)>,
 	user_data: *mut c_void,
@@ -377,36 +378,36 @@ pub unsafe extern "C" fn moq_consume_catalog(
 	ffi::enter(move || {
 		let broadcast = ffi::parse_id(broadcast)?;
 		let on_catalog = unsafe { ffi::OnStatus::new(user_data, on_catalog) };
-		State::lock().consume.catalog(broadcast, on_catalog)
+		State::lock().consume.catalog_subscribe(broadcast, on_catalog)
 	})
 }
 
-/// Close a catalog consumer and cancel its background task.
+/// Unsubscribe from catalog updates and cancel the background task.
 ///
 /// This only stops the background subscription; catalog snapshots previously
-/// delivered via the [moq_consume_catalog] callback remain valid until freed
-/// with [moq_consume_catalog_free].
+/// delivered via the [moq_consume_catalog_subscribe] callback remain valid until closed
+/// with [moq_consume_catalog_close].
 ///
 /// Returns a zero on success, or a negative code on failure.
 #[unsafe(no_mangle)]
-pub extern "C" fn moq_consume_catalog_close(catalog: u32) -> i32 {
+pub extern "C" fn moq_consume_catalog_unsubscribe(catalog: u32) -> i32 {
 	ffi::enter(move || {
 		let catalog = ffi::parse_id(catalog)?;
-		State::lock().consume.catalog_close(catalog)
+		State::lock().consume.catalog_unsubscribe(catalog)
 	})
 }
 
-/// Free a catalog snapshot received via the [moq_consume_catalog] callback.
+/// Close a catalog snapshot received via the [moq_consume_catalog_subscribe] callback.
 ///
 /// This releases the snapshot and invalidates any borrowed references (e.g. pointers
 /// returned by [moq_consume_video_config] or [moq_consume_audio_config]).
 ///
 /// Returns a zero on success, or a negative code on failure.
 #[unsafe(no_mangle)]
-pub extern "C" fn moq_consume_catalog_free(catalog: u32) -> i32 {
+pub extern "C" fn moq_consume_catalog_close(catalog: u32) -> i32 {
 	ffi::enter(move || {
 		let catalog = ffi::parse_id(catalog)?;
-		State::lock().consume.catalog_free(catalog)
+		State::lock().consume.catalog_close(catalog)
 	})
 }
 
@@ -418,7 +419,7 @@ pub extern "C" fn moq_consume_catalog_free(catalog: u32) -> i32 {
 ///
 /// # Safety
 /// - The caller must ensure that `dst` is a valid pointer to a [moq_video_config] struct.
-/// - The caller must ensure that `dst` is not used after [moq_consume_catalog_free] is called.
+/// - The caller must ensure that `dst` is not used after [moq_consume_catalog_close] is called.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn moq_consume_video_config(catalog: u32, index: u32, dst: *mut moq_video_config) -> i32 {
 	ffi::enter(move || {
@@ -437,7 +438,7 @@ pub unsafe extern "C" fn moq_consume_video_config(catalog: u32, index: u32, dst:
 ///
 /// # Safety
 /// - The caller must ensure that `dst` is a valid pointer to a [moq_audio_config] struct.
-/// - The caller must ensure that `dst` is not used after [moq_consume_catalog_free] is called.
+/// - The caller must ensure that `dst` is not used after [moq_consume_catalog_close] is called.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn moq_consume_audio_config(catalog: u32, index: u32, dst: *mut moq_audio_config) -> i32 {
 	ffi::enter(move || {
diff --git a/rs/libmoq/src/consume.rs b/rs/libmoq/src/consume.rs
index 5fbfdd6ae..81389ae8b 100644
--- a/rs/libmoq/src/consume.rs
+++ b/rs/libmoq/src/consume.rs
@@ -5,10 +5,13 @@ use tokio::sync::oneshot;
 use crate::ffi::OnStatus;
 use crate::{Error, Id, NonZeroSlab, State, moq_audio_config, moq_frame, moq_video_config};
 
+type LegacyConsumer = moq_mux::consumer::OrderedConsumer<moq_mux::consumer::Legacy>;
+
 struct ConsumeCatalog {
 	broadcast: moq_lite::BroadcastConsumer,
 
-	catalog: hang::catalog::Catalog,
+	video: hang::catalog::Video,
+	audio: hang::catalog::Audio,
 
 	/// We need to store the codec information on the heap unfortunately.
 	audio_codec: Vec<String>,
@@ -38,7 +41,7 @@ pub struct Consume {
 	track_task: NonZeroSlab<Option<TaskEntry>>,
 
 	/// Buffered frames ready for consumption.
-	frame: NonZeroSlab<hang::container::OrderedFrame>,
+	frame: NonZeroSlab<moq_mux::consumer::OrderedFrame>,
 }
 
 impl Consume {
@@ -46,9 +49,9 @@ impl Consume {
 		self.broadcast.insert(broadcast)
 	}
 
-	pub fn catalog(&mut self, broadcast: Id, on_catalog: OnStatus) -> Result<Id, Error> {
+	pub fn catalog_subscribe(&mut self, broadcast: Id, on_catalog: OnStatus) -> Result<Id, Error> {
 		let broadcast = self.broadcast.get(broadcast).ok_or(Error::BroadcastNotFound)?.clone();
-		let catalog = broadcast.subscribe_track(&hang::catalog::Catalog::default_track())?;
+		let catalog = broadcast.subscribe_track(&hang::catalog::default_track(), Default::default())?;
 
 		let channel = oneshot::channel();
 		let entry = TaskEntry {
@@ -59,12 +62,12 @@ impl Consume {
 
 		tokio::spawn(async move {
 			let res = tokio::select! {
-				res = Self::run_catalog(id, broadcast, catalog.into()) => res,
+				res = Self::run_catalog(id, broadcast, catalog) => res,
 				_ = channel.1 => Ok(()),
 			};
 
-			// The lock is dropped before the callback is invoked.
-			if let Some(entry) = State::lock().consume.catalog_task.remove(id).flatten() {
+			let entry = State::lock().consume.catalog_task.remove(id).flatten();
+			if let Some(entry) = entry {
 				entry.callback.call(res);
 			}
 		});
@@ -75,44 +78,63 @@ impl Consume {
 	async fn run_catalog(
 		task_id: Id,
 		broadcast: moq_lite::BroadcastConsumer,
-		mut catalog: hang::CatalogConsumer,
+		mut track: moq_lite::TrackSubscriber,
 	) -> Result<(), Error> {
-		while let Some(catalog) = catalog.next().await? {
-			// Unfortunately we need to store the codec information on the heap.
-			let audio_codec = catalog
-				.audio
-				.renditions
-				.values()
-				.map(|config| config.codec.to_string())
-				.collect();
-
-			let video_codec = catalog
-				.video
-				.renditions
-				.values()
-				.map(|config| config.codec.to_string())
-				.collect();
-
-			let catalog = ConsumeCatalog {
-				broadcast: broadcast.clone(),
-				catalog,
-				audio_codec,
-				video_codec,
-			};
-
-			let mut state = State::lock();
-
-			// Stop if the callback was revoked by close.
-			let Some(Some(entry)) = state.consume.catalog_task.get(task_id) else {
-				return Ok(());
-			};
-			let callback = entry.callback;
-
-			let snapshot_id = state.consume.catalog.insert(catalog)?;
-			drop(state);
-
-			// The lock is dropped before the callback is invoked.
-			callback.call(Ok(snapshot_id));
+		while let Some(mut group) = track.recv_group().await? {
+			// Read only the first frame per group (catalog doesn't support deltas yet)
+			if let Some(frame) = group.read_frame().await? {
+				let json: serde_json::Map<String, serde_json::Value> =
+					serde_json::from_slice(&frame).map_err(hang::Error::from)?;
+
+				let video: hang::catalog::Video = json
+					.get("video")
+					.map(|v| serde_json::from_value(v.clone()))
+					.transpose()
+					.map_err(hang::Error::from)?
+					.unwrap_or_default();
+
+				let audio: hang::catalog::Audio = json
+					.get("audio")
+					.map(|v| serde_json::from_value(v.clone()))
+					.transpose()
+					.map_err(hang::Error::from)?
+					.unwrap_or_default();
+
+				// Unfortunately we need to store the codec information on the heap.
+				let audio_codec = audio
+					.renditions
+					.values()
+					.map(|config| config.codec.to_string())
+					.collect();
+
+				let video_codec = video
+					.renditions
+					.values()
+					.map(|config| config.codec.to_string())
+					.collect();
+
+				let catalog = ConsumeCatalog {
+					broadcast: broadcast.clone(),
+					video,
+					audio,
+					audio_codec,
+					video_codec,
+				};
+
+				let mut state = State::lock();
+
+				// Stop if the callback was revoked by close.
+				let Some(Some(entry)) = state.consume.catalog_task.get(task_id) else {
+					return Ok(());
+				};
+				let callback = entry.callback;
+
+				let snapshot_id = state.consume.catalog.insert(catalog)?;
+				drop(state);
+
+				// The lock is dropped before the callback is invoked.
+				callback.call(Ok(snapshot_id));
+			}
 		}
 
 		Ok(())
@@ -121,13 +143,7 @@ impl Consume {
 	pub fn video_config(&mut self, catalog: Id, index: usize, dst: &mut moq_video_config) -> Result<(), Error> {
 		let consume = self.catalog.get(catalog).ok_or(Error::CatalogNotFound)?;
 
-		let (rendition, config) = consume
-			.catalog
-			.video
-			.renditions
-			.iter()
-			.nth(index)
-			.ok_or(Error::NoIndex)?;
+		let (rendition, config) = consume.video.renditions.iter().nth(index).ok_or(Error::NoIndex)?;
 		let codec = consume.video_codec.get(index).ok_or(Error::NoIndex)?;
 
 		*dst = moq_video_config {
@@ -159,13 +175,7 @@ impl Consume {
 	pub fn audio_config(&mut self, catalog: Id, index: usize, dst: &mut moq_audio_config) -> Result<(), Error> {
 		let consume = self.catalog.get(catalog).ok_or(Error::CatalogNotFound)?;
 
-		let (rendition, config) = consume
-			.catalog
-			.audio
-			.renditions
-			.iter()
-			.nth(index)
-			.ok_or(Error::NoIndex)?;
+		let (rendition, config) = consume.audio.renditions.iter().nth(index).ok_or(Error::NoIndex)?;
 		let codec = consume.audio_codec.get(index).ok_or(Error::NoIndex)?;
 
 		*dst = moq_audio_config {
@@ -186,7 +196,7 @@ impl Consume {
 		Ok(())
 	}
 
-	pub fn catalog_close(&mut self, catalog: Id) -> Result<(), Error> {
+	pub fn catalog_unsubscribe(&mut self, catalog: Id) -> Result<(), Error> {
 		// Take the entire entry: drops the sender (signals shutdown) and revokes the callback.
 		self.catalog_task
 			.get_mut(catalog)
@@ -196,7 +206,7 @@ impl Consume {
 		Ok(())
 	}
 
-	pub fn catalog_free(&mut self, catalog: Id) -> Result<(), Error> {
+	pub fn catalog_close(&mut self, catalog: Id) -> Result<(), Error> {
 		self.catalog.remove(catalog).ok_or(Error::CatalogNotFound)?;
 		Ok(())
 	}
@@ -209,19 +219,11 @@ impl Consume {
 		on_frame: OnStatus,
 	) -> Result<Id, Error> {
 		let consume = self.catalog.get(catalog).ok_or(Error::CatalogNotFound)?;
-		let rendition = consume
-			.catalog
-			.video
-			.renditions
-			.keys()
-			.nth(index)
-			.ok_or(Error::NoIndex)?;
-
-		let track = consume.broadcast.subscribe_track(&moq_lite::Track {
-			name: rendition.clone(),
-			priority: 1, // TODO: Remove priority
-		})?;
-		let track = hang::container::OrderedConsumer::new(track, latency);
+		let rendition = consume.video.renditions.keys().nth(index).ok_or(Error::NoIndex)?;
+
+		let track = consume
+			.broadcast
+			.subscribe_track(&moq_lite::Track::new(rendition.clone()), Default::default())?;
 
 		let channel = oneshot::channel();
 		let entry = TaskEntry {
@@ -232,12 +234,12 @@ impl Consume {
 
 		tokio::spawn(async move {
 			let res = tokio::select! {
-				res = Self::run_track(id, track) => res,
+				res = Self::run_track(id, track, latency) => res,
 				_ = channel.1 => Ok(()),
 			};
 
-			// The lock is dropped before the callback is invoked.
-			if let Some(entry) = State::lock().consume.track_task.remove(id).flatten() {
+			let entry = State::lock().consume.track_task.remove(id).flatten();
+			if let Some(entry) = entry {
 				entry.callback.call(res);
 			}
 		});
@@ -253,19 +255,11 @@ impl Consume {
 		on_frame: OnStatus,
 	) -> Result<Id, Error> {
 		let consume = self.catalog.get(catalog).ok_or(Error::CatalogNotFound)?;
-		let rendition = consume
-			.catalog
-			.audio
-			.renditions
-			.keys()
-			.nth(index)
-			.ok_or(Error::NoIndex)?;
-
-		let track = consume.broadcast.subscribe_track(&moq_lite::Track {
-			name: rendition.clone(),
-			priority: 2, // TODO: Remove priority
-		})?;
-		let track = hang::container::OrderedConsumer::new(track, latency);
+		let rendition = consume.audio.renditions.keys().nth(index).ok_or(Error::NoIndex)?;
+
+		let track = consume
+			.broadcast
+			.subscribe_track(&moq_lite::Track::new(rendition.clone()), Default::default())?;
 
 		let channel = oneshot::channel();
 		let entry = TaskEntry {
@@ -276,12 +270,12 @@ impl Consume {
 
 		tokio::spawn(async move {
 			let res = tokio::select! {
-				res = Self::run_track(id, track) => res,
+				res = Self::run_track(id, track, latency) => res,
 				_ = channel.1 => Ok(()),
 			};
 
-			// The lock is dropped before the callback is invoked.
-			if let Some(entry) = State::lock().consume.track_task.remove(id).flatten() {
+			let entry = State::lock().consume.track_task.remove(id).flatten();
+			if let Some(entry) = entry {
 				entry.callback.call(res);
 			}
 		});
@@ -289,7 +283,12 @@ impl Consume {
 		Ok(id)
 	}
 
-	async fn run_track(task_id: Id, mut track: hang::container::OrderedConsumer) -> Result<(), Error> {
+	async fn run_track(
+		task_id: Id,
+		track: moq_lite::TrackSubscriber,
+		latency: std::time::Duration,
+	) -> Result<(), Error> {
+		let mut track = LegacyConsumer::new(track, moq_mux::consumer::Legacy, latency);
 		while let Some(mut ordered) = track.read().await? {
 			// TODO add a chunking API so we don't have to (potentially) allocate a contiguous buffer for the frame.
 			let mut new_payload = hang::container::BufList::new();
@@ -301,7 +300,7 @@ impl Consume {
 				ordered.payload.copy_to_bytes(ordered.payload.num_bytes())
 			});
 
-			let new_frame = hang::container::OrderedFrame {
+			let new_frame = moq_mux::consumer::OrderedFrame {
 				timestamp: ordered.timestamp,
 				payload: new_payload,
 				group: ordered.group,
diff --git a/rs/libmoq/src/error.rs b/rs/libmoq/src/error.rs
index 57659c832..fe250ffca 100644
--- a/rs/libmoq/src/error.rs
+++ b/rs/libmoq/src/error.rs
@@ -99,6 +99,10 @@ pub enum Error {
 	#[error("level error: {0}")]
 	Level(Arc<tracing::metadata::ParseLevelError>),
 
+	/// Log initialization failed.
+	#[error("log init failed")]
+	LogInit,
+
 	/// Invalid error code conversion.
 	#[error("invalid code")]
 	InvalidCode,
@@ -124,6 +128,15 @@ pub enum Error {
 	NulError(#[from] std::ffi::NulError),
 }
 
+impl From<moq_mux::consumer::Error> for Error {
+	fn from(err: moq_mux::consumer::Error) -> Self {
+		match err {
+			moq_mux::consumer::Error::Moq(e) => Error::Moq(e),
+			e => Error::DecodeFailed(Arc::new(e.into())),
+		}
+	}
+}
+
 impl From<tracing::metadata::ParseLevelError> for Error {
 	fn from(err: tracing::metadata::ParseLevelError) -> Self {
 		Error::Level(Arc::new(err))
@@ -153,6 +166,7 @@ impl ffi::ReturnCode for Error {
 			Error::Hang(_) => -18,
 			Error::NoIndex => -19,
 			Error::NulError(_) => -20,
+			Error::LogInit => -29,
 			Error::SessionNotFound => -21,
 			Error::OriginNotFound => -22,
 			Error::AnnouncementNotFound => -23,
diff --git a/rs/libmoq/src/origin.rs b/rs/libmoq/src/origin.rs
index e51437a0e..8c089b61c 100644
--- a/rs/libmoq/src/origin.rs
+++ b/rs/libmoq/src/origin.rs
@@ -65,7 +65,7 @@ impl Origin {
 	}
 
 	async fn run_announced(task_id: Id, mut consumer: moq_lite::OriginConsumer) -> Result<(), Error> {
-		while let Some((path, broadcast)) = consumer.announced().await {
+		while let Ok((path, _broadcast)) = consumer.announced().await {
 			let mut state = State::lock();
 
 			// Stop if the callback was revoked by close.
@@ -74,7 +74,7 @@ impl Origin {
 			};
 			let callback = entry.callback;
 
-			let announced_id = state.origin.announced.insert((path.to_string(), broadcast.is_some()))?;
+			let announced_id = state.origin.announced.insert((path.to_string(), true))?;
 			drop(state);
 
 			// The lock is dropped before the callback is invoked.
@@ -84,6 +84,7 @@ impl Origin {
 		Ok(())
 	}
 
+	#[allow(deprecated)]
 	pub fn announced_info(&self, announced: Id, dst: &mut moq_announced) -> Result<(), Error> {
 		let announced = self.announced.get(announced).ok_or(Error::AnnouncementNotFound)?;
 		*dst = moq_announced {
@@ -106,7 +107,10 @@ impl Origin {
 
 	pub fn consume<P: moq_lite::AsPath>(&mut self, origin: Id, path: P) -> Result<moq_lite::BroadcastConsumer, Error> {
 		let origin = self.active.get_mut(origin).ok_or(Error::OriginNotFound)?;
-		origin.consume().consume_broadcast(path).ok_or(Error::BroadcastNotFound)
+		origin
+			.consume()
+			.try_consume_broadcast(path)
+			.ok_or(Error::BroadcastNotFound)
 	}
 
 	pub fn publish<P: moq_lite::AsPath>(
diff --git a/rs/libmoq/src/publish.rs b/rs/libmoq/src/publish.rs
index c85bbebf0..aab0e770d 100644
--- a/rs/libmoq/src/publish.rs
+++ b/rs/libmoq/src/publish.rs
@@ -1,7 +1,7 @@
 use std::{str::FromStr, sync::Arc};
 
 use bytes::Buf;
-use moq_mux::import;
+use moq_mux::producer;
 
 use crate::{Error, Id, NonZeroSlab};
 
@@ -11,13 +11,13 @@ pub struct Publish {
 	broadcasts: NonZeroSlab<(moq_lite::BroadcastProducer, moq_mux::CatalogProducer)>,
 
 	/// Active media encoders/decoders for publishing.
-	media: NonZeroSlab<import::Decoder>,
+	media: NonZeroSlab<producer::Framed>,
 }
 
 impl Publish {
 	pub fn create(&mut self) -> Result<Id, Error> {
-		let mut broadcast = moq_lite::BroadcastProducer::new();
-		let catalog = moq_mux::CatalogProducer::new(&mut broadcast)?;
+		let broadcast = moq_lite::Broadcast::new().produce();
+		let catalog = moq_mux::CatalogProducer::new(&broadcast)?;
 
 		let id = self.broadcasts.insert((broadcast, catalog))?;
 		Ok(id)
@@ -38,8 +38,8 @@ impl Publish {
 	pub fn media_ordered(&mut self, broadcast: Id, format: &str, mut init: &[u8]) -> Result<Id, Error> {
 		let (broadcast, catalog) = self.broadcasts.get(broadcast).ok_or(Error::BroadcastNotFound)?;
 
-		let format = import::DecoderFormat::from_str(format).map_err(|_| Error::UnknownFormat(format.to_string()))?;
-		let decoder = import::Decoder::new(broadcast.clone(), catalog.clone(), format, &mut init)
+		let format = producer::FramedFormat::from_str(format).map_err(|_| Error::UnknownFormat(format.to_string()))?;
+		let decoder = producer::Framed::new(broadcast.clone(), catalog.clone(), format, &mut init)
 			.map_err(|err| Error::InitFailed(Arc::new(err)))?;
 
 		let id = self.media.insert(decoder)?;
diff --git a/rs/libmoq/src/test.rs b/rs/libmoq/src/test.rs
index ab57c5298..92be780de 100644
--- a/rs/libmoq/src/test.rs
+++ b/rs/libmoq/src/test.rs
@@ -172,7 +172,7 @@ fn double_close_all_resource_types() {
 
 	let consume = id(unsafe { moq_origin_consume(origin, path.as_ptr() as *const c_char, path.len()) });
 	let catalog_cb = Callback::new();
-	let catalog_task = id(unsafe { moq_consume_catalog(consume, Some(channel_callback), catalog_cb.ptr) });
+	let catalog_task = id(unsafe { moq_consume_catalog_subscribe(consume, Some(channel_callback), catalog_cb.ptr) });
 
 	let catalog_id = id(catalog_cb.recv());
 
@@ -192,11 +192,11 @@ fn double_close_all_resource_types() {
 	assert_eq!(moq_consume_audio_close(track), 0);
 	assert!(moq_consume_audio_close(track) < 0);
 
-	assert_eq!(moq_consume_catalog_free(catalog_id), 0);
-	assert!(moq_consume_catalog_free(catalog_id) < 0);
+	assert_eq!(moq_consume_catalog_close(catalog_id), 0);
+	assert!(moq_consume_catalog_close(catalog_id) < 0);
 
-	assert_eq!(moq_consume_catalog_close(catalog_task), 0);
-	assert!(moq_consume_catalog_close(catalog_task) < 0);
+	assert_eq!(moq_consume_catalog_unsubscribe(catalog_task), 0);
+	assert!(moq_consume_catalog_unsubscribe(catalog_task) < 0);
 
 	assert_eq!(moq_consume_close(consume), 0);
 	assert_eq!(moq_publish_media_close(media), 0);
@@ -225,6 +225,7 @@ fn unknown_format() {
 }
 
 #[test]
+#[allow(deprecated)]
 fn local_announce() {
 	let origin = id(moq_origin_create());
 
@@ -259,6 +260,7 @@ fn local_announce() {
 }
 
 #[test]
+#[allow(deprecated)]
 fn announced_deactivation() {
 	let origin = id(moq_origin_create());
 	let cb = Callback::new();
@@ -280,11 +282,15 @@ fn announced_deactivation() {
 	assert_eq!(unsafe { moq_origin_announced_info(announced_id, &mut info) }, 0);
 	assert!(info.active);
 
+	// Closing the broadcast no longer triggers an unannounce callback.
+	// C consumers should watch BroadcastConsumer::closed() to detect end of broadcast.
 	assert_eq!(moq_publish_close(broadcast), 0);
 
-	let deactivated_id = id(cb.recv());
-	assert_eq!(unsafe { moq_origin_announced_info(deactivated_id, &mut info) }, 0);
-	assert!(!info.active, "broadcast should be inactive after publisher closes");
+	// No deactivation callback is expected.
+	assert!(
+		cb.try_recv(Duration::from_millis(100)).is_none(),
+		"should not receive deactivation callback"
+	);
 
 	assert_eq!(moq_origin_announced_close(announced_task), 0);
 	assert_eq!(moq_origin_close(origin), 0);
@@ -315,7 +321,7 @@ fn local_publish_consume() {
 
 	let consume = id(unsafe { moq_origin_consume(origin, path.as_ptr() as *const c_char, path.len()) });
 	let catalog_cb = Callback::new();
-	let catalog_task = id(unsafe { moq_consume_catalog(consume, Some(channel_callback), catalog_cb.ptr) });
+	let catalog_task = id(unsafe { moq_consume_catalog_subscribe(consume, Some(channel_callback), catalog_cb.ptr) });
 
 	let catalog_id = id(catalog_cb.recv());
 
@@ -386,8 +392,8 @@ fn local_publish_consume() {
 
 	assert_eq!(moq_consume_frame_close(frame_id), 0);
 	assert_eq!(moq_consume_audio_close(track), 0);
-	assert_eq!(moq_consume_catalog_free(catalog_id), 0);
-	assert_eq!(moq_consume_catalog_close(catalog_task), 0);
+	assert_eq!(moq_consume_catalog_close(catalog_id), 0);
+	assert_eq!(moq_consume_catalog_unsubscribe(catalog_task), 0);
 	assert_eq!(moq_consume_close(consume), 0);
 	assert_eq!(moq_publish_media_close(media), 0);
 	assert_eq!(moq_publish_close(broadcast), 0);
@@ -419,7 +425,7 @@ fn video_publish_consume() {
 
 	let consume = id(unsafe { moq_origin_consume(origin, path.as_ptr() as *const c_char, path.len()) });
 	let catalog_cb = Callback::new();
-	let catalog_task = id(unsafe { moq_consume_catalog(consume, Some(channel_callback), catalog_cb.ptr) });
+	let catalog_task = id(unsafe { moq_consume_catalog_subscribe(consume, Some(channel_callback), catalog_cb.ptr) });
 
 	let catalog_id = id(catalog_cb.recv());
 
@@ -495,8 +501,8 @@ fn video_publish_consume() {
 
 	assert_eq!(moq_consume_frame_close(frame_id), 0);
 	assert_eq!(moq_consume_video_close(track), 0);
-	assert_eq!(moq_consume_catalog_free(catalog_id), 0);
-	assert_eq!(moq_consume_catalog_close(catalog_task), 0);
+	assert_eq!(moq_consume_catalog_close(catalog_id), 0);
+	assert_eq!(moq_consume_catalog_unsubscribe(catalog_task), 0);
 	assert_eq!(moq_consume_close(consume), 0);
 	assert_eq!(moq_publish_media_close(media), 0);
 	assert_eq!(moq_publish_close(broadcast), 0);
@@ -528,7 +534,7 @@ fn multiple_frames_ordering() {
 
 	let consume = id(unsafe { moq_origin_consume(origin, path.as_ptr() as *const c_char, path.len()) });
 	let catalog_cb = Callback::new();
-	let catalog_task = id(unsafe { moq_consume_catalog(consume, Some(channel_callback), catalog_cb.ptr) });
+	let catalog_task = id(unsafe { moq_consume_catalog_subscribe(consume, Some(channel_callback), catalog_cb.ptr) });
 	let catalog_id = id(catalog_cb.recv());
 
 	let frame_cb = Callback::new();
@@ -562,8 +568,8 @@ fn multiple_frames_ordering() {
 	}
 
 	assert_eq!(moq_consume_audio_close(track), 0);
-	assert_eq!(moq_consume_catalog_free(catalog_id), 0);
-	assert_eq!(moq_consume_catalog_close(catalog_task), 0);
+	assert_eq!(moq_consume_catalog_close(catalog_id), 0);
+	assert_eq!(moq_consume_catalog_unsubscribe(catalog_task), 0);
 	assert_eq!(moq_consume_close(consume), 0);
 	assert_eq!(moq_publish_media_close(media), 0);
 	assert_eq!(moq_publish_close(broadcast), 0);
@@ -595,7 +601,7 @@ fn catalog_update_on_new_track() {
 
 	let consume = id(unsafe { moq_origin_consume(origin, path.as_ptr() as *const c_char, path.len()) });
 	let catalog_cb = Callback::new();
-	let catalog_task = id(unsafe { moq_consume_catalog(consume, Some(channel_callback), catalog_cb.ptr) });
+	let catalog_task = id(unsafe { moq_consume_catalog_subscribe(consume, Some(channel_callback), catalog_cb.ptr) });
 
 	let catalog_id1 = id(catalog_cb.recv());
 	let mut audio_cfg = moq_audio_config {
@@ -626,9 +632,9 @@ fn catalog_update_on_new_track() {
 	assert_eq!(unsafe { moq_consume_audio_config(catalog_id2, 0, &mut audio_cfg) }, 0);
 	assert_eq!(unsafe { moq_consume_audio_config(catalog_id2, 1, &mut audio_cfg) }, 0);
 
-	assert_eq!(moq_consume_catalog_free(catalog_id1), 0);
-	assert_eq!(moq_consume_catalog_free(catalog_id2), 0);
-	assert_eq!(moq_consume_catalog_close(catalog_task), 0);
+	assert_eq!(moq_consume_catalog_close(catalog_id1), 0);
+	assert_eq!(moq_consume_catalog_close(catalog_id2), 0);
+	assert_eq!(moq_consume_catalog_unsubscribe(catalog_task), 0);
 	assert_eq!(moq_consume_close(consume), 0);
 	assert_eq!(moq_publish_media_close(media1), 0);
 	assert_eq!(moq_publish_media_close(media2), 0);
diff --git a/rs/moq-cli/Cargo.toml b/rs/moq-cli/Cargo.toml
index 305f44eed..2a2361399 100644
--- a/rs/moq-cli/Cargo.toml
+++ b/rs/moq-cli/Cargo.toml
@@ -23,10 +23,12 @@ websocket = ["moq-native/websocket"]
 anyhow = { version = "1", features = ["backtrace"] }
 axum = { version = "0.8", features = ["tokio"] }
 axum-server = { version = "0.8", features = ["tls-rustls"] }
+base64 = "0.22"
 clap = { version = "4", features = ["derive"] }
 hang = { workspace = true }
 moq-mux = { workspace = true }
 moq-native = { workspace = true, default-features = false, features = ["aws-lc-rs"] }
+mp4-atom = "0.10.0"
 rustls = { version = "0.23", features = ["aws-lc-rs"], default-features = false }
 tokio = { workspace = true, features = ["full"] }
 tower-http = { version = "0.6", features = ["cors", "fs"] }
diff --git a/rs/moq-cli/src/main.rs b/rs/moq-cli/src/main.rs
index e26a177b5..7a59cb410 100644
--- a/rs/moq-cli/src/main.rs
+++ b/rs/moq-cli/src/main.rs
@@ -1,14 +1,13 @@
-mod client;
 mod publish;
-mod server;
+mod subscribe;
 mod web;
 
-use client::*;
 use publish::*;
-use server::*;
+use subscribe::*;
 use web::*;
 
 use clap::{Parser, Subcommand};
+use hang::moq_lite;
 use std::path::PathBuf;
 use url::Url;
 
@@ -17,10 +16,9 @@ pub struct Cli {
 	#[command(flatten)]
 	log: moq_native::Log,
 
-	/// Iroh configuration
-	#[command(flatten)]
 	#[cfg(feature = "iroh")]
-	iroh: moq_native::IrohEndpointConfig,
+	#[command(flatten)]
+	iroh: moq_native::iroh::EndpointConfig,
 
 	#[command(subcommand)]
 	command: Command,
@@ -28,71 +26,66 @@ pub struct Cli {
 
 #[derive(Subcommand, Clone)]
 pub enum Command {
-	Serve {
+	/// Run as a server (listen for connections)
+	Server {
 		#[command(flatten)]
 		config: moq_native::ServerConfig,
 
-		/// The name of the broadcast to serve.
-		#[arg(long)]
-		name: String,
-
 		/// Optionally serve static files from the given directory.
 		#[arg(long)]
 		dir: Option<PathBuf>,
 
-		/// The format of the input media.
 		#[command(subcommand)]
-		format: PublishFormat,
+		action: Action,
 	},
-	Publish {
-		/// The MoQ client configuration.
+	/// Run as a client (connect to a server)
+	Client {
 		#[command(flatten)]
 		config: moq_native::ClientConfig,
 
 		/// The URL of the MoQ server.
-		///
-		/// The URL must start with `https://` or `http://`.
-		/// - If `http` is used, a HTTP fetch to "/certificate.sha256" is first made to get the TLS certificiate fingerprint (insecure).
-		/// - If `https` is used, then A WebTransport connection is made via QUIC to the provided host/port.
-		///
-		/// The `?jwt=` query parameter is used to provide a JWT token from moq-token-cli.
-		/// Otherwise, the public path (if any) is used instead.
-		///
-		/// The path currently must be `/` or you'll get an error on connect.
 		#[arg(long)]
 		url: Url,
 
-		/// The name of the broadcast to publish.
+		#[command(subcommand)]
+		action: Action,
+	},
+}
+
+#[derive(Subcommand, Clone)]
+pub enum Action {
+	/// Publish media from stdin
+	Publish {
 		#[arg(long)]
 		name: String,
 
-		/// The format of the input media.
-		#[command(subcommand)]
-		format: PublishFormat,
+		#[command(flatten)]
+		args: PublishArgs,
+	},
+	/// Subscribe to media, write to stdout
+	Subscribe {
+		#[arg(long)]
+		name: String,
+
+		#[command(flatten)]
+		args: SubscribeArgs,
 	},
 }
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
-	// TODO: It would be nice to remove this and rely on feature flags only.
-	// However, some dependency is pulling in `ring` and I don't know why, so meh for now.
 	rustls::crypto::aws_lc_rs::default_provider()
 		.install_default()
 		.expect("failed to install default crypto provider");
 
 	let cli = Cli::parse();
-	cli.log.init();
-
-	let publish = Publish::new(match &cli.command {
-		Command::Serve { format, .. } => format,
-		Command::Publish { format, .. } => format,
-	})?;
+	cli.log.init()?;
 
 	#[cfg(feature = "iroh")]
 	let iroh = cli.iroh.bind().await?;
 
 	match cli.command {
-		Command::Serve { config, dir, name, .. } => {
+		Command::Server { config, dir, action } => {
 			let web_bind = config.bind.unwrap_or("[::]:443".parse().unwrap());
 
 			let server = config.init()?;
@@ -101,19 +94,167 @@ async fn main() -> anyhow::Result<()> {
 
 			let web_tls = server.tls_info();
 
-			tokio::select! {
-				res = run_server(server, name, publish.consume()) => res,
-				res = run_web(web_bind, web_tls, dir) => res,
-				res = publish.run() => res,
+			match action {
+				Action::Publish { name, args } => {
+					let publish = Publish::new(&args)?;
+					let broadcast = publish.consume();
+
+					tokio::select! {
+						res = run_publish_server(server, name, broadcast) => res,
+						res = publish.run() => res,
+						res = run_web(web_bind, web_tls, dir) => res,
+					}
+				}
+				Action::Subscribe { name, args } => {
+					let origin = moq_lite::Origin::produce();
+					let mut consumer = origin.consume();
+					let server = server.with_consume(origin);
+
+					tokio::select! {
+						res = run_accept(server) => res,
+						res = async {
+							let broadcast = wait_broadcast(&mut consumer, &name).await?;
+							Subscribe::new(broadcast, args).run().await
+						} => res,
+						res = run_web(web_bind, web_tls, dir) => res,
+					}
+				}
 			}
 		}
-		Command::Publish { config, url, name, .. } => {
+		Command::Client { config, url, action } => {
 			let client = config.init()?;
 
 			#[cfg(feature = "iroh")]
 			let client = client.with_iroh(iroh);
 
-			run_client(client, url, name, publish).await
+			match action {
+				Action::Publish { name, args } => {
+					let publish = Publish::new(&args)?;
+					let origin = moq_lite::Origin::produce();
+					origin.publish_broadcast(&name, publish.consume());
+
+					tracing::info!(%url, %name, "connecting");
+					let session = client.with_publish(origin.consume()).connect(url).await?;
+
+					run_client(session, publish.run()).await
+				}
+				Action::Subscribe { name, args } => {
+					let origin = moq_lite::Origin::produce();
+					let mut consumer = origin.consume();
+
+					tracing::info!(%url, %name, "connecting");
+					let session = client.with_consume(origin).connect(url).await?;
+
+					let broadcast = wait_broadcast(&mut consumer, &name).await?;
+					let subscribe = Subscribe::new(broadcast, args);
+
+					run_client(session, subscribe.run()).await
+				}
+			}
 		}
 	}
 }
+
+/// Run a client session, waiting for the action to complete, the session to close, or ctrl_c.
+async fn run_client(
+	mut session: moq_lite::Session,
+	action: impl std::future::Future<Output = anyhow::Result<()>>,
+) -> anyhow::Result<()> {
+	#[cfg(unix)]
+	let _ = sd_notify::notify(&[sd_notify::NotifyState::Ready]);
+
+	tokio::select! {
+		res = action => res,
+		res = session.closed() => res.map_err(Into::into),
+		_ = tokio::signal::ctrl_c() => {
+			session.close(moq_lite::Error::Cancel);
+			tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+			Ok(())
+		},
+	}
+}
+
+/// Wait for a named broadcast to be announced on the origin.
+async fn wait_broadcast(
+	consumer: &mut moq_lite::OriginConsumer,
+	name: &str,
+) -> anyhow::Result<moq_lite::BroadcastConsumer> {
+	loop {
+		let (path, broadcast) = consumer
+			.announced()
+			.await
+			.map_err(|_| anyhow::anyhow!("origin closed"))?;
+
+		if path.as_ref() == name {
+			return Ok(broadcast);
+		}
+	}
+}
+
+/// Accept connections in a loop, publishing the same broadcast to each.
+async fn run_publish_server(
+	mut server: moq_native::Server,
+	name: String,
+	broadcast: moq_lite::BroadcastConsumer,
+) -> anyhow::Result<()> {
+	#[cfg(unix)]
+	let _ = sd_notify::notify(&[sd_notify::NotifyState::Ready]);
+
+	let mut conn_id: u64 = 0;
+
+	tracing::info!(addr = ?server.local_addr(), "listening");
+
+	while let Some(request) = server.accept().await {
+		let id = conn_id;
+		conn_id += 1;
+
+		let name = name.clone();
+		let broadcast = broadcast.clone();
+
+		tokio::spawn(async move {
+			let origin = moq_lite::Origin::produce();
+			origin.publish_broadcast(&name, broadcast);
+
+			match request.with_publish(origin.consume()).ok().await {
+				Ok(session) => {
+					tracing::info!(id, "accepted session");
+					if let Err(err) = session.closed().await {
+						tracing::warn!(id, %err, "session error");
+					}
+				}
+				Err(err) => tracing::warn!(id, %err, "failed to accept session"),
+			}
+		});
+	}
+
+	Ok(())
+}
+
+/// Accept connections in a loop (origin already configured on the server).
+async fn run_accept(mut server: moq_native::Server) -> anyhow::Result<()> {
+	#[cfg(unix)]
+	let _ = sd_notify::notify(&[sd_notify::NotifyState::Ready]);
+
+	let mut conn_id: u64 = 0;
+
+	tracing::info!(addr = ?server.local_addr(), "listening");
+
+	while let Some(request) = server.accept().await {
+		let id = conn_id;
+		conn_id += 1;
+
+		tokio::spawn(async move {
+			match request.ok().await {
+				Ok(session) => {
+					tracing::info!(id, "accepted session");
+					if let Err(err) = session.closed().await {
+						tracing::warn!(id, %err, "session error");
+					}
+				}
+				Err(err) => tracing::warn!(id, %err, "failed to accept session"),
+			}
+		});
+	}
+
+	Ok(())
+}
diff --git a/rs/moq-cli/src/publish.rs b/rs/moq-cli/src/publish.rs
index 9d13eadbc..4ae8256f7 100644
--- a/rs/moq-cli/src/publish.rs
+++ b/rs/moq-cli/src/publish.rs
@@ -1,88 +1,143 @@
-use clap::Subcommand;
+use clap::ValueEnum;
 use hang::moq_lite;
-use moq_mux::import;
+use moq_mux::producer;
 
-#[derive(Subcommand, Clone)]
-pub enum PublishFormat {
+#[derive(ValueEnum, Clone, Copy)]
+pub enum InputFormat {
+	Fmp4,
 	Avc3,
-	Fmp4 {
-		/// Transmit the fMP4 container directly instead of decoding it.
-		#[arg(long)]
-		passthrough: bool,
-	},
-	// NOTE: No aac support because it needs framing.
-	Hls {
-		/// URL or file path of an HLS playlist to ingest.
-		#[arg(long)]
-		playlist: String,
-
-		/// Transmit the fMP4 segments directly instead of decoding them.
-		#[arg(long)]
-		passthrough: bool,
-	},
+	Hls,
 }
 
-enum PublishDecoder {
-	Avc3(Box<import::Avc3>),
-	Fmp4(Box<import::Fmp4>),
-	Hls(Box<import::Hls>),
+#[derive(ValueEnum, Clone, Copy)]
+pub enum ExportFormat {
+	Hang,
+	Fmp4,
+}
+
+#[derive(clap::Args, Clone)]
+pub struct PublishArgs {
+	/// Input format (what's being read from stdin).
+	/// For hls, provide the playlist URL on stdin.
+	#[arg(long)]
+	pub input: InputFormat,
+
+	/// Convert to a different format before publishing.
+	/// If not specified, publishes in the import's native format.
+	#[arg(long)]
+	pub export: Option<ExportFormat>,
+}
+
+enum PublishKind {
+	Avc3(Box<producer::Avc3>),
+	Fmp4(Box<producer::Fmp4>),
+	Hls(Box<producer::Hls>),
 }
 
 pub struct Publish {
-	decoder: PublishDecoder,
-	broadcast: moq_lite::BroadcastProducer,
+	kind: PublishKind,
+	export: Option<ExportFormat>,
+
+	/// The broadcast the importer writes into.
+	import_broadcast: moq_lite::BroadcastProducer,
+
+	/// The broadcast that gets published (after optional conversion).
+	output_broadcast: moq_lite::BroadcastProducer,
 }
 
 impl Publish {
-	pub fn new(format: &PublishFormat) -> anyhow::Result<Self> {
-		let mut broadcast = moq_lite::BroadcastProducer::default();
-		let catalog = moq_mux::CatalogProducer::new(&mut broadcast)?;
-
-		let decoder = match format {
-			PublishFormat::Avc3 => {
-				let avc3 = import::Avc3::new(broadcast.clone(), catalog.clone());
-				PublishDecoder::Avc3(Box::new(avc3))
+	pub fn new(args: &PublishArgs) -> anyhow::Result<Self> {
+		let import_broadcast = moq_lite::Broadcast::new().produce();
+		let catalog = moq_mux::CatalogProducer::new(&import_broadcast)?;
+
+		let kind = match args.input {
+			InputFormat::Avc3 => {
+				let avc3 = producer::Avc3::new(import_broadcast.clone(), catalog.clone());
+				PublishKind::Avc3(Box::new(avc3))
 			}
-			PublishFormat::Fmp4 { passthrough } => {
-				let fmp4 = import::Fmp4::new(
-					broadcast.clone(),
-					catalog.clone(),
-					import::Fmp4Config {
-						passthrough: *passthrough,
-					},
-				);
-				PublishDecoder::Fmp4(Box::new(fmp4))
+			InputFormat::Fmp4 => {
+				let fmp4 = producer::Fmp4::new(import_broadcast.clone(), catalog.clone());
+				PublishKind::Fmp4(Box::new(fmp4))
 			}
-			PublishFormat::Hls { playlist, passthrough } => {
-				let hls = import::Hls::new(
-					broadcast.clone(),
-					catalog.clone(),
-					import::HlsConfig {
-						playlist: playlist.clone(),
-						client: None,
-						passthrough: *passthrough,
-					},
-				)?;
-				PublishDecoder::Hls(Box::new(hls))
+			InputFormat::Hls => {
+				// Read playlist URL from stdin (first line)
+				let mut playlist = String::new();
+				std::io::stdin().read_line(&mut playlist)?;
+				let playlist = playlist.trim().to_string();
+				anyhow::ensure!(!playlist.is_empty(), "expected HLS playlist URL on stdin");
+
+				let config = producer::HlsConfig::new(playlist);
+				let hls = producer::Hls::new(import_broadcast.clone(), catalog.clone(), config)?;
+				PublishKind::Hls(Box::new(hls))
 			}
 		};
 
-		Ok(Self { decoder, broadcast })
+		// If exporting, create a separate output broadcast for the converter.
+		// Otherwise, the output is the same as the import.
+		let output_broadcast = if args.export.is_some() {
+			moq_lite::Broadcast::new().produce()
+		} else {
+			import_broadcast.clone()
+		};
+
+		Ok(Self {
+			kind,
+			export: args.export,
+			import_broadcast,
+			output_broadcast,
+		})
 	}
 
 	pub fn consume(&self) -> moq_lite::BroadcastConsumer {
-		self.broadcast.consume()
+		self.output_broadcast.consume()
 	}
-}
 
-impl Publish {
-	pub async fn run(mut self) -> anyhow::Result<()> {
-		let mut stdin = tokio::io::stdin();
+	pub async fn run(self) -> anyhow::Result<()> {
+		let Self {
+			mut kind,
+			export,
+			import_broadcast,
+			output_broadcast,
+		} = self;
+
+		let Some(export) = export else {
+			return run_import(&mut kind).await;
+		};
+
+		let import_consumer = import_broadcast.consume();
+
+		match export {
+			ExportFormat::Fmp4 => {
+				let converter = moq_mux::cmaf::Convert::new(import_consumer, output_broadcast);
+				tokio::select! {
+					res = run_import(&mut kind) => res,
+					res = converter.run() => res,
+				}
+			}
+			ExportFormat::Hang => {
+				let converter = moq_mux::hang::Convert::new(import_consumer, output_broadcast);
+				tokio::select! {
+					res = run_import(&mut kind) => res,
+					res = converter.run() => res,
+				}
+			}
+		}
+	}
+}
 
-		match &mut self.decoder {
-			PublishDecoder::Avc3(decoder) => decoder.decode_from(&mut stdin).await,
-			PublishDecoder::Fmp4(decoder) => decoder.decode_from(&mut stdin).await,
-			PublishDecoder::Hls(decoder) => decoder.run().await,
+async fn run_import(kind: &mut PublishKind) -> anyhow::Result<()> {
+	match kind {
+		PublishKind::Avc3(decoder) => {
+			let mut stdin = tokio::io::stdin();
+			decoder.decode_from(&mut stdin).await
+		}
+		PublishKind::Fmp4(decoder) => {
+			let mut stdin = tokio::io::stdin();
+			decoder.decode_from(&mut stdin).await
+		}
+		PublishKind::Hls(hls) => {
+			hls.init().await?;
+			hls.run().await
 		}
 	}
 }
diff --git a/rs/moq-cli/src/subscribe.rs b/rs/moq-cli/src/subscribe.rs
new file mode 100644
index 000000000..0ded8fcc0
--- /dev/null
+++ b/rs/moq-cli/src/subscribe.rs
@@ -0,0 +1,155 @@
+use anyhow::Context;
+use clap::ValueEnum;
+use hang::moq_lite;
+use tokio::io::AsyncWriteExt;
+
+#[derive(ValueEnum, Clone, Copy)]
+pub enum OutputFormat {
+	Fmp4,
+}
+
+#[derive(clap::Args, Clone)]
+pub struct SubscribeArgs {
+	/// Output format for stdout
+	#[arg(long)]
+	pub output: OutputFormat,
+
+	/// Maximum latency in milliseconds before skipping groups
+	#[arg(long, default_value = "500")]
+	pub max_latency: u64,
+}
+
+pub struct Subscribe {
+	broadcast: moq_lite::BroadcastConsumer,
+	args: SubscribeArgs,
+}
+
+impl Subscribe {
+	pub fn new(broadcast: moq_lite::BroadcastConsumer, args: SubscribeArgs) -> Self {
+		Self { broadcast, args }
+	}
+
+	pub async fn run(self) -> anyhow::Result<()> {
+		match self.args.output {
+			OutputFormat::Fmp4 => self.run_fmp4().await,
+		}
+	}
+
+	async fn run_fmp4(self) -> anyhow::Result<()> {
+		// Always convert to CMAF — this is a no-op for tracks already in CMAF.
+		let cmaf_output = moq_lite::Broadcast::new().produce();
+		let cmaf_consumer = cmaf_output.consume();
+		let converter = moq_mux::cmaf::Convert::new(self.broadcast, cmaf_output);
+
+		// Subscribe to the catalog before the converter starts, so we don't miss it.
+		let catalog_track =
+			cmaf_consumer.subscribe_track(&hang::catalog::default_track(), moq_lite::Subscription::default())?;
+
+		let max_latency = std::time::Duration::from_millis(self.args.max_latency);
+
+		// Run the converter concurrently — it blocks until all tracks finish,
+		// so we must read from the output broadcast in parallel.
+		tokio::try_join!(converter.run(), mux_fmp4(catalog_track, cmaf_consumer, max_latency))?;
+
+		Ok(())
+	}
+}
+
+async fn mux_fmp4(
+	catalog_track: moq_lite::TrackSubscriber,
+	cmaf_consumer: moq_lite::BroadcastConsumer,
+	max_latency: std::time::Duration,
+) -> anyhow::Result<()> {
+	let mut stdout = tokio::io::stdout();
+
+	let mut catalog_consumer = hang::CatalogConsumer::new(catalog_track);
+	let video_section = catalog_consumer.reader().section(&hang::catalog::VIDEO);
+	let audio_section = catalog_consumer.reader().section(&hang::catalog::AUDIO);
+
+	// Run until first catalog update
+	tokio::select! {
+		res = catalog_consumer.run() => { res?; anyhow::bail!("catalog closed before first update"); },
+		_ = video_section.changed() => {},
+		_ = audio_section.changed() => {},
+	}
+
+	let video = video_section.get()?.unwrap_or_default();
+	let audio = audio_section.get()?.unwrap_or_default();
+
+	// Build exporter from catalog sections (for init segment)
+	let exporter = moq_mux::consumer::Fmp4::new(&video, &audio)?;
+
+	// Write init segment (merged multi-track moov)
+	let init = exporter.init(&video, &audio)?;
+	stdout.write_all(&init).await?;
+	stdout.flush().await?;
+
+	// Build OrderedMuxer from all track consumers (all CMAF after conversion)
+	let mut muxer_tracks = Vec::new();
+
+	for (name, config) in &video.renditions {
+		let track = cmaf_consumer.subscribe_track(
+			&moq_lite::Track { name: name.clone() },
+			moq_lite::Subscription::default(),
+		)?;
+
+		let timescale = match &config.container {
+			hang::catalog::Container::Cmaf { init_data } => parse_timescale_from_init(init_data)?,
+			hang::catalog::Container::Legacy => {
+				anyhow::bail!("unexpected Legacy track after conversion")
+			}
+		};
+
+		let consumer =
+			moq_mux::consumer::OrderedConsumer::new(track, moq_mux::consumer::Cmaf { timescale }, max_latency);
+		muxer_tracks.push((name.clone(), consumer));
+	}
+
+	for (name, config) in &audio.renditions {
+		let track = cmaf_consumer.subscribe_track(
+			&moq_lite::Track { name: name.clone() },
+			moq_lite::Subscription::default(),
+		)?;
+
+		let timescale = match &config.container {
+			hang::catalog::Container::Cmaf { init_data } => parse_timescale_from_init(init_data)?,
+			hang::catalog::Container::Legacy => {
+				anyhow::bail!("unexpected Legacy track after conversion")
+			}
+		};
+
+		let consumer =
+			moq_mux::consumer::OrderedConsumer::new(track, moq_mux::consumer::Cmaf { timescale }, max_latency);
+		muxer_tracks.push((name.clone(), consumer));
+	}
+
+	// Use OrderedMuxer for timestamp-ordered multi-track merge
+	let mut muxer = moq_mux::consumer::OrderedMuxer::new(muxer_tracks);
+
+	while let Some(muxed) = muxer.read().await? {
+		// CMAF passthrough: payload is already moof+mdat
+		for chunk in &muxed.frame.payload {
+			stdout.write_all(chunk).await?;
+		}
+		stdout.flush().await?;
+	}
+
+	Ok(())
+}
+
+fn parse_timescale_from_init(init_data_b64: &str) -> anyhow::Result<u64> {
+	use base64::Engine;
+	use mp4_atom::DecodeMaybe;
+
+	let data = base64::engine::general_purpose::STANDARD
+		.decode(init_data_b64)
+		.context("invalid base64")?;
+	let mut cursor = std::io::Cursor::new(&data);
+	while let Some(atom) = mp4_atom::Any::decode_maybe(&mut cursor)? {
+		if let mp4_atom::Any::Moov(moov) = atom {
+			let trak = moov.trak.first().context("no tracks in moov")?;
+			return Ok(trak.mdia.mdhd.timescale as u64);
+		}
+	}
+	anyhow::bail!("no moov in init data")
+}
diff --git a/rs/moq-clock/src/clock.rs b/rs/moq-clock/src/clock.rs
index 2c6ef7f2e..67e16f3e3 100644
--- a/rs/moq-clock/src/clock.rs
+++ b/rs/moq-clock/src/clock.rs
@@ -71,16 +71,16 @@ impl Publisher {
 	}
 }
 pub struct Subscriber {
-	track: TrackConsumer,
+	track: TrackSubscriber,
 }
 
 impl Subscriber {
-	pub fn new(track: TrackConsumer) -> Self {
+	pub fn new(track: TrackSubscriber) -> Self {
 		Self { track }
 	}
 
 	pub async fn run(mut self) -> anyhow::Result<()> {
-		while let Some(mut group) = self.track.next_group().await? {
+		while let Some(mut group) = self.track.recv_group().await? {
 			let base = group
 				.read_frame()
 				.await
diff --git a/rs/moq-clock/src/main.rs b/rs/moq-clock/src/main.rs
index 37e8ec942..38832f961 100644
--- a/rs/moq-clock/src/main.rs
+++ b/rs/moq-clock/src/main.rs
@@ -47,22 +47,19 @@ pub enum Command {
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
 	let config = Config::parse();
-	config.log.init();
+	config.log.init()?;
 
 	let client = config.client.init()?;
 
 	tracing::info!(url = ?config.url, "connecting to server");
 
-	let track = Track {
-		name: config.track,
-		priority: 0,
-	};
+	let track = Track::new(config.track);
 
 	let origin = moq_lite::Origin::produce();
 
 	match config.role {
 		Command::Publish => {
-			let mut broadcast = moq_lite::Broadcast::produce();
+			let broadcast = moq_lite::Broadcast::new().produce();
 			let track = broadcast.create_track(track)?;
 			let clock = clock::Publisher::new(track);
 
@@ -78,15 +75,15 @@ async fn main() -> anyhow::Result<()> {
 		Command::Subscribe => {
 			let session = client.with_consume(origin.clone()).connect(config.url).await?;
 
-			// NOTE: We could just call `session.consume_broadcast(&config.broadcast)` instead,
-			// However that won't work with IETF MoQ and the current OriginConsumer API the moment.
-			// So instead we do the cooler thing and loop while the broadcast is announced.
+			// We use announced() to watch for the broadcast to come online/reconnect,
+			// rather than a one-shot consume_broadcast() call.
 
 			tracing::info!(broadcast = %config.broadcast, "waiting for broadcast to be online");
 
 			let path: moq_lite::Path<'_> = config.broadcast.into();
 			let mut origin = origin
-				.consume_only(&[path])
+				.consume()
+				.with_filter(&[path])
 				.context("not allowed to consume broadcast")?;
 
 			// The current subscriber if any, dropped after each announce.
@@ -94,15 +91,11 @@ async fn main() -> anyhow::Result<()> {
 
 			loop {
 				tokio::select! {
-					Some(announce) = origin.announced() => match announce {
-						(path, Some(broadcast)) => {
-							tracing::info!(broadcast = %path, "broadcast is online, subscribing to track");
-							let track = broadcast.subscribe_track(&track)?;
-							clock = Some(clock::Subscriber::new(track));
-						}
-						(path, None) => {
-							tracing::warn!(broadcast = %path, "broadcast is offline, waiting...");
-						}
+					res = origin.announced() => {
+						let (path, broadcast) = res.context("origin closed")?;
+						tracing::info!(broadcast = %path, "broadcast is online, subscribing to track");
+						let subscribed_track = broadcast.subscribe_track(&track, Subscription::default())?;
+						clock = Some(clock::Subscriber::new(subscribed_track));
 					},
 					res = session.closed() => return res.context("session closed"),
 					// NOTE: This drops clock when a new announce arrives, canceling it.
diff --git a/rs/moq-ffi/Cargo.toml b/rs/moq-ffi/Cargo.toml
index b15c92157..41a52f064 100644
--- a/rs/moq-ffi/Cargo.toml
+++ b/rs/moq-ffi/Cargo.toml
@@ -25,6 +25,7 @@ hang = { workspace = true }
 moq-lite = { workspace = true, features = ["serde"] }
 moq-mux = { workspace = true }
 moq-native = { workspace = true, default-features = true }
+serde_json = "1"
 thiserror = "2"
 tokio = { workspace = true, features = ["macros"] }
 tracing = "0.1"
diff --git a/rs/moq-ffi/src/consumer.rs b/rs/moq-ffi/src/consumer.rs
index 1f2729d82..5e3191b9a 100644
--- a/rs/moq-ffi/src/consumer.rs
+++ b/rs/moq-ffi/src/consumer.rs
@@ -23,15 +23,47 @@ pub struct MoqCatalogConsumer {
 }
 
 struct Catalog {
-	inner: hang::CatalogConsumer,
+	track: moq_lite::TrackSubscriber,
+	group: Option<moq_lite::GroupConsumer>,
 }
 
 impl Catalog {
 	async fn next(&mut self) -> Result<Option<MoqCatalog>, MoqError> {
-		match self.inner.next().await {
-			Ok(Some(catalog)) => Ok(Some(convert_catalog(&catalog))),
-			Ok(None) => Ok(None),
-			Err(e) => Err(e.into()),
+		loop {
+			tokio::select! {
+				res = self.track.recv_group() => {
+					match res? {
+						Some(group) => {
+							self.group = Some(group);
+						}
+						None => return Ok(None),
+					}
+				},
+				Some(frame) = async { self.group.as_mut()?.read_frame().await.transpose() } => {
+					self.group.take(); // We don't support deltas yet
+
+					let frame_data = frame?;
+					let json: serde_json::Map<String, serde_json::Value> =
+						serde_json::from_slice(&frame_data)
+							.map_err(|e| MoqError::Codec(e.to_string()))?;
+
+					let video: hang::catalog::Video = json
+						.get("video")
+						.map(|v| serde_json::from_value(v.clone()))
+						.transpose()
+						.map_err(|e| MoqError::Codec(e.to_string()))?
+						.unwrap_or_default();
+
+					let audio: hang::catalog::Audio = json
+						.get("audio")
+						.map(|v| serde_json::from_value(v.clone()))
+						.transpose()
+						.map_err(|e| MoqError::Codec(e.to_string()))?
+						.unwrap_or_default();
+
+					return Ok(Some(convert_catalog(&video, &audio)));
+				}
+			}
 		}
 	}
 }
@@ -42,7 +74,7 @@ pub struct MoqMediaConsumer {
 }
 
 struct Media {
-	inner: moq_mux::ordered::Consumer<hang::catalog::Container>,
+	inner: moq_mux::ordered::Consumer<moq_mux::hang::Media>,
 }
 
 impl Media {
@@ -77,10 +109,11 @@ impl MoqBroadcastConsumer {
 	/// Subscribe to the catalog for this broadcast.
 	pub fn subscribe_catalog(&self) -> Result<Arc<MoqCatalogConsumer>, MoqError> {
 		let _guard = crate::ffi::RUNTIME.enter();
-		let track = self.inner.subscribe_track(&hang::catalog::Catalog::default_track())?;
-		let consumer = hang::CatalogConsumer::from(track);
+		let track = self
+			.inner
+			.subscribe_track(&hang::catalog::default_track(), moq_lite::Subscription::default())?;
 		Ok(Arc::new(MoqCatalogConsumer {
-			task: Task::new(Catalog { inner: consumer }),
+			task: Task::new(Catalog { track, group: None }),
 		}))
 	}
 
@@ -94,11 +127,13 @@ impl MoqBroadcastConsumer {
 		container: Container,
 		max_latency_ms: u64,
 	) -> Result<Arc<MoqMediaConsumer>, MoqError> {
-		let _guard = crate::ffi::RUNTIME.enter();
-		let track = self.inner.subscribe_track(&moq_lite::Track { name, priority: 0 })?;
+		let track = self
+			.inner
+			.subscribe_track(&moq_lite::Track::new(name), moq_lite::Subscription::default())?;
 		let container: hang::catalog::Container = container.into();
 		let latency = std::time::Duration::from_millis(max_latency_ms);
-		let consumer = moq_mux::ordered::Consumer::new(track, container).with_latency(latency);
+		let media = moq_mux::hang::Media::try_from(&container)?;
+		let consumer = moq_mux::ordered::Consumer::new(track, media).with_latency(latency);
 		Ok(Arc::new(MoqMediaConsumer {
 			task: Task::new(Media { inner: consumer }),
 		}))
diff --git a/rs/moq-ffi/src/log.rs b/rs/moq-ffi/src/log.rs
index 65886a7df..fd9923fe8 100644
--- a/rs/moq-ffi/src/log.rs
+++ b/rs/moq-ffi/src/log.rs
@@ -21,7 +21,7 @@ pub fn moq_log_level(level: String) -> Result<(), MoqError> {
 		return Err(MoqError::Log("logging already initialized".into()));
 	}
 
-	log.init();
+	log.init().map_err(|e| MoqError::Log(e.to_string()))?;
 
 	Ok(())
 }
diff --git a/rs/moq-ffi/src/media.rs b/rs/moq-ffi/src/media.rs
index 221ca8ecf..89d75ff6c 100644
--- a/rs/moq-ffi/src/media.rs
+++ b/rs/moq-ffi/src/media.rs
@@ -9,14 +9,14 @@ pub struct MoqDimensions {
 #[derive(Clone, uniffi::Enum)]
 pub enum Container {
 	Legacy,
-	Cmaf { timescale: u64, track_id: u32 },
+	Cmaf { init_data: String },
 }
 
 impl From<hang::catalog::Container> for Container {
 	fn from(container: hang::catalog::Container) -> Self {
 		match container {
 			hang::catalog::Container::Legacy => Self::Legacy,
-			hang::catalog::Container::Cmaf { timescale, track_id } => Self::Cmaf { timescale, track_id },
+			hang::catalog::Container::Cmaf { init_data } => Self::Cmaf { init_data },
 		}
 	}
 }
@@ -25,7 +25,7 @@ impl From<Container> for hang::catalog::Container {
 	fn from(container: Container) -> Self {
 		match container {
 			Container::Legacy => Self::Legacy,
-			Container::Cmaf { timescale, track_id } => Self::Cmaf { timescale, track_id },
+			Container::Cmaf { init_data } => Self::Cmaf { init_data },
 		}
 	}
 }
@@ -68,9 +68,8 @@ pub struct MoqFrame {
 	pub keyframe: bool,
 }
 
-pub fn convert_catalog(catalog: &hang::catalog::Catalog) -> MoqCatalog {
-	let video = catalog
-		.video
+pub fn convert_catalog(video: &hang::catalog::Video, audio: &hang::catalog::Audio) -> MoqCatalog {
+	let video_map = video
 		.renditions
 		.iter()
 		.map(|(name, config)| {
@@ -95,8 +94,7 @@ pub fn convert_catalog(catalog: &hang::catalog::Catalog) -> MoqCatalog {
 		})
 		.collect();
 
-	let audio = catalog
-		.audio
+	let audio_map = audio
 		.renditions
 		.iter()
 		.map(|(name, config)| {
@@ -114,16 +112,16 @@ pub fn convert_catalog(catalog: &hang::catalog::Catalog) -> MoqCatalog {
 		})
 		.collect();
 
-	let display = catalog.video.display.as_ref().map(|d| MoqDimensions {
+	let display = video.display.as_ref().map(|d| MoqDimensions {
 		width: d.width,
 		height: d.height,
 	});
 
 	MoqCatalog {
-		video,
-		audio,
+		video: video_map,
+		audio: audio_map,
 		display,
-		rotation: catalog.video.rotation,
-		flip: catalog.video.flip,
+		rotation: video.rotation,
+		flip: video.flip,
 	}
 }
diff --git a/rs/moq-ffi/src/origin.rs b/rs/moq-ffi/src/origin.rs
index 4ca10b0fc..d3d4dae56 100644
--- a/rs/moq-ffi/src/origin.rs
+++ b/rs/moq-ffi/src/origin.rs
@@ -26,32 +26,18 @@ struct Announced {
 
 impl Announced {
 	async fn next(&mut self) -> Result<Option<Arc<MoqAnnouncement>>, MoqError> {
-		loop {
-			match self.inner.announced().await {
-				Some((path, Some(broadcast))) => {
-					return Ok(Some(Arc::new(MoqAnnouncement {
-						path: path.to_string(),
-						broadcast: Arc::new(MoqBroadcastConsumer::new(broadcast)),
-					})));
-				}
-				// TODO moq-lite will change to not emit None (unannounce) events here.
-				Some((_path, None)) => continue,
-				None => return Ok(None),
-			}
+		match self.inner.announced().await {
+			Ok((path, broadcast)) => Ok(Some(Arc::new(MoqAnnouncement {
+				path: path.to_string(),
+				broadcast: Arc::new(MoqBroadcastConsumer::new(broadcast)),
+			}))),
+			Err(_) => Ok(None),
 		}
 	}
 
 	async fn available(&mut self) -> Result<Arc<MoqBroadcastConsumer>, MoqError> {
-		loop {
-			match self.inner.announced().await {
-				Some((_path, Some(broadcast))) => {
-					return Ok(Arc::new(MoqBroadcastConsumer::new(broadcast)));
-				}
-				// TODO moq-lite will change to not emit None (unannounce) events here.
-				Some((_path, None)) => continue,
-				None => return Err(MoqError::Closed),
-			}
-		}
+		let (_path, broadcast) = self.inner.announced().await.map_err(|_| MoqError::Closed)?;
+		Ok(Arc::new(MoqBroadcastConsumer::new(broadcast)))
 	}
 }
 
diff --git a/rs/moq-ffi/src/producer.rs b/rs/moq-ffi/src/producer.rs
index 8b2edecab..0da77fcdc 100644
--- a/rs/moq-ffi/src/producer.rs
+++ b/rs/moq-ffi/src/producer.rs
@@ -27,7 +27,7 @@ impl MoqBroadcastProducer {
 
 #[derive(uniffi::Object)]
 pub struct MoqMediaProducer {
-	inner: std::sync::Mutex<Option<moq_mux::import::Decoder>>,
+	inner: std::sync::Mutex<Option<moq_mux::producer::Framed>>,
 }
 
 #[uniffi::export]
@@ -38,8 +38,8 @@ impl MoqBroadcastProducer {
 	#[uniffi::constructor]
 	pub fn new() -> Result<Arc<Self>, MoqError> {
 		let _guard = crate::ffi::RUNTIME.enter();
-		let mut broadcast = moq_lite::BroadcastProducer::new();
-		let catalog = moq_mux::CatalogProducer::new(&mut broadcast)?;
+		let broadcast = moq_lite::Broadcast::new().produce();
+		let catalog = moq_mux::CatalogProducer::new(&broadcast)?;
 		Ok(Arc::new(Self {
 			state: std::sync::Mutex::new(Some(BroadcastProducer { broadcast, catalog })),
 		}))
@@ -52,11 +52,11 @@ impl MoqBroadcastProducer {
 		let _guard = crate::ffi::RUNTIME.enter();
 		let guard = self.state.lock().unwrap();
 		let state = guard.as_ref().ok_or_else(|| MoqError::Closed)?;
-		let format = moq_mux::import::DecoderFormat::from_str(&format)
+		let format = moq_mux::producer::FramedFormat::from_str(&format)
 			.map_err(|_| MoqError::Codec(format!("unknown format: {format}")))?;
 
 		let mut buf = init.as_slice();
-		let decoder = moq_mux::import::Decoder::new(state.broadcast.clone(), state.catalog.clone(), format, &mut buf)
+		let decoder = moq_mux::producer::Framed::new(state.broadcast.clone(), state.catalog.clone(), format, &mut buf)
 			.map_err(|err| MoqError::Codec(format!("init failed: {err}")))?;
 
 		if buf.has_remaining() {
diff --git a/rs/moq-lite/src/error.rs b/rs/moq-lite/src/error.rs
index 09d30d5ec..d4c08cab8 100644
--- a/rs/moq-lite/src/error.rs
+++ b/rs/moq-lite/src/error.rs
@@ -47,9 +47,16 @@ pub enum Error {
 	#[error("app code={0}")]
 	App(u16),
 
+	#[deprecated(note = "Use UnknownBroadcast or UnknownTrack instead")]
 	#[error("not found")]
 	NotFound,
 
+	#[error("unknown broadcast")]
+	UnknownBroadcast,
+
+	#[error("unknown track")]
+	UnknownTrack,
+
 	#[error("wrong frame size")]
 	WrongSize,
 
@@ -84,6 +91,7 @@ pub enum Error {
 	Closed,
 }
 
+#[allow(deprecated)]
 impl Error {
 	/// An integer code that is sent over the wire.
 	pub fn to_code(&self) -> u32 {
@@ -100,6 +108,8 @@ impl Error {
 			Self::BoundsExceeded => 11,
 			Self::Duplicate => 12,
 			Self::NotFound => 13,
+			Self::UnknownBroadcast => 26,
+			Self::UnknownTrack => 27,
 			Self::WrongSize => 14,
 			Self::ProtocolViolation => 15,
 			Self::UnexpectedMessage => 16,
@@ -138,6 +148,8 @@ impl Error {
 			20 => Self::InvalidRole,
 			24 => Self::Dropped,
 			25 => Self::Closed,
+			26 => Self::UnknownBroadcast,
+			27 => Self::UnknownTrack,
 			code if code >= 64 => match u16::try_from(code - 64) {
 				Ok(app) => Self::App(app),
 				Err(_) => Self::ProtocolViolation,
diff --git a/rs/moq-lite/src/ietf/adapter.rs b/rs/moq-lite/src/ietf/adapter.rs
index 6fda7848c..42080d93d 100644
--- a/rs/moq-lite/src/ietf/adapter.rs
+++ b/rs/moq-lite/src/ietf/adapter.rs
@@ -634,7 +634,7 @@ impl<S: web_transport_trait::Session> ControlStreamAdapter<S> {
 			.unwrap()
 			.get(&ns)
 			.copied()
-			.ok_or(Error::NotFound)
+			.ok_or(Error::UnknownBroadcast)
 	}
 }
 
diff --git a/rs/moq-lite/src/ietf/fetch.rs b/rs/moq-lite/src/ietf/fetch.rs
index 4ac5c5dc6..23a5b3b5a 100644
--- a/rs/moq-lite/src/ietf/fetch.rs
+++ b/rs/moq-lite/src/ietf/fetch.rs
@@ -288,6 +288,7 @@ impl Message for FetchError<'_> {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[allow(dead_code)]
 pub struct FetchCancel {
 	pub request_id: RequestId,
 }
diff --git a/rs/moq-lite/src/ietf/publish_namespace.rs b/rs/moq-lite/src/ietf/publish_namespace.rs
index 4061cff1a..03e5199e5 100644
--- a/rs/moq-lite/src/ietf/publish_namespace.rs
+++ b/rs/moq-lite/src/ietf/publish_namespace.rs
@@ -148,6 +148,7 @@ impl Message for PublishNamespaceDone<'_> {
 /// PublishNamespaceCancel message (0x0c)
 /// v14/v15: uses track_namespace. v16: uses request_id.
 #[derive(Clone, Debug)]
+#[allow(dead_code)]
 pub struct PublishNamespaceCancel<'a> {
 	/// v14/v15: the namespace being cancelled
 	pub track_namespace: Path<'a>,
diff --git a/rs/moq-lite/src/ietf/publisher.rs b/rs/moq-lite/src/ietf/publisher.rs
index 60b6e4744..5c9051b26 100644
--- a/rs/moq-lite/src/ietf/publisher.rs
+++ b/rs/moq-lite/src/ietf/publisher.rs
@@ -5,7 +5,7 @@ use web_async::FuturesExt;
 use web_transport_trait::SendStream;
 
 use crate::{
-	AsPath, Error, Origin, OriginConsumer, Track, TrackConsumer,
+	AsPath, Error, Origin, OriginConsumer, Subscription, Track, TrackSubscriber,
 	coding::{Stream, Writer},
 	ietf::{self, Control, FetchHeader, FetchType, FilterType, GroupOrder, Location, RequestId},
 	model::GroupConsumer,
@@ -105,18 +105,15 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 
 		tracing::info!(id = %request_id, broadcast = %absolute, track = %track_name, "subscribe started");
 
-		let Some(broadcast) = self.origin.consume_broadcast(&msg.track_namespace) else {
+		let Some(broadcast) = self.origin.try_consume_broadcast(&msg.track_namespace) else {
 			self.write_subscribe_error(&mut stream.writer, request_id, 404, "Broadcast not found")
 				.await?;
 			return Ok(());
 		};
 
-		let track = Track {
-			name: msg.track_name.to_string(),
-			priority: msg.subscriber_priority,
-		};
+		let track = Track::new(msg.track_name.to_string());
 
-		let track = match broadcast.subscribe_track(&track) {
+		let track = match broadcast.subscribe_track(&track, Subscription::default()) {
 			Ok(track) => track,
 			Err(err) => {
 				self.write_subscribe_error(&mut stream.writer, request_id, 404, &err.to_string())
@@ -125,6 +122,9 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 			}
 		};
 
+		// Wait until we have at least one group before sending OK
+		track.ready().await?;
+
 		// Send SubscribeOk on the stream
 		stream.writer.encode(&ietf::SubscribeOk::ID).await?;
 		stream
@@ -138,9 +138,11 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 			})
 			.await?;
 
+		let priority = msg.subscriber_priority;
+
 		// Run the track, cancelling on reader close (Unsubscribe or stream close)
 		let res = tokio::select! {
-			res = self.run_track(track, request_id) => res,
+			res = self.run_track(track, request_id, priority) => res,
 			_ = stream.reader.closed() => Ok(()),
 			_ = self.session.closed() => Ok(()),
 		};
@@ -215,7 +217,7 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 	}
 
 	/// Serve a track using FuturesUnordered for unlimited concurrent groups.
-	async fn run_track(&self, mut track: TrackConsumer, request_id: RequestId) -> Result<(), Error> {
+	async fn run_track(&self, mut track: TrackSubscriber, request_id: RequestId, priority: u8) -> Result<(), Error> {
 		let mut tasks = FuturesUnordered::new();
 
 		loop {
@@ -225,7 +227,7 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 					while tasks.next().await.is_some() {}
 					false
 				} => unreachable!(),
-				Some(group) = track.next_group().transpose() => group,
+				Some(group) = track.recv_group().transpose() => group,
 				else => return Ok(()),
 			}?;
 
@@ -236,12 +238,11 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 				track_alias: request_id.0,
 				group_id: sequence,
 				sub_group_id: 0,
-				publisher_priority: 0,
+				publisher_priority: priority,
 				flags: Default::default(),
 			};
 
-			tasks
-				.push(Self::run_group(self.session.clone(), msg, track.info.priority, group, self.version).map(|_| ()));
+			tasks.push(Self::run_group(self.session.clone(), msg, priority, group, self.version).map(|_| ()));
 		}
 	}
 
@@ -435,103 +436,113 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 		Ok(())
 	}
 
+	/// Send PublishNamespaceDone and close the stream for a namespace.
+	async fn close_namespace(
+		version: Version,
+		suffix: &crate::Path<'_>,
+		request_id: RequestId,
+		mut stream: Stream<S, Version>,
+	) {
+		match version {
+			Version::Draft14 | Version::Draft15 | Version::Draft16 => {
+				let _ = stream
+					.writer
+					.encode_message(&ietf::PublishNamespaceDone {
+						track_namespace: suffix.to_owned(),
+						request_id,
+					})
+					.await;
+			}
+			_ => {}
+		}
+		stream.writer.finish().ok();
+	}
+
 	/// Outgoing PublishNamespace: announce each namespace via a bidi stream.
 	async fn run_announce(mut self) -> Result<(), Error> {
 		let mut namespace_streams: HashMap<crate::PathOwned, (RequestId, Stream<S, Version>)> = HashMap::new();
+		let mut active: HashMap<crate::PathOwned, crate::BroadcastConsumer> = HashMap::new();
+		let mut closures: FuturesUnordered<crate::OriginClosureFuture> = FuturesUnordered::new();
 
 		loop {
-			let announced = tokio::select! {
+			tokio::select! {
 				biased;
-				_ = self.session.closed() => return Ok(()),
-				announced = self.origin.announced() => announced,
-			};
-
-			let Some((path, active)) = announced else {
-				break;
-			};
+				_ = self.session.closed() => break,
+				Some((path, broadcast)) = closures.next() => {
+					// Only send unannounce if this broadcast is still the active one
+					if active.get(&path).is_some_and(|b| b.is_clone(&broadcast)) {
+						active.remove(&path);
+						let suffix = path.to_owned();
+						tracing::debug!(broadcast = %self.origin.absolute(&path), "unannounce");
+						if let Some((request_id, stream)) = namespace_streams.remove(&suffix) {
+							Self::close_namespace(self.version, &suffix, request_id, stream).await;
+						}
+					}
+				}
+				res = self.origin.announced() => {
+					let (path, broadcast) = res?;
+					let suffix = path.to_owned();
+
+					// If same path already active, send done first (reannounce)
+					if active.contains_key(&path) {
+						if let Some((request_id, stream)) = namespace_streams.remove(&suffix) {
+							Self::close_namespace(self.version, &suffix, request_id, stream).await;
+						}
+					}
 
-			let suffix = path.to_owned();
+					tracing::debug!(broadcast = %self.origin.absolute(&path), "announce");
 
-			if active.is_some() {
-				tracing::debug!(broadcast = %self.origin.absolute(&path), "announce");
+					let request_id = self.control.next_request_id().await?;
+					let mut stream = Stream::open(&self.session, self.version).await?;
 
-				let request_id = self.control.next_request_id().await?;
-				let mut stream = Stream::open(&self.session, self.version).await?;
+					stream.writer.encode(&ietf::PublishNamespace::ID).await?;
+					stream
+						.writer
+						.encode(&ietf::PublishNamespace {
+							request_id,
+							track_namespace: suffix.as_path(),
+						})
+						.await?;
 
-				// Write the PublishNamespace message
-				stream.writer.encode(&ietf::PublishNamespace::ID).await?;
-				stream
-					.writer
-					.encode(&ietf::PublishNamespace {
-						request_id,
-						track_namespace: suffix.as_path(),
-					})
-					.await?;
+					let type_id: u64 = stream.reader.decode().await?;
+					let size: u16 = stream.reader.decode().await?;
+					let mut data = stream.reader.read_exact(size as usize).await?;
 
-				// Read response from stream.reader
-				let type_id: u64 = stream.reader.decode().await?;
-				let size: u16 = stream.reader.decode().await?;
-				let mut data = stream.reader.read_exact(size as usize).await?;
-
-				match (self.version, type_id) {
-					// Draft14 uses PublishNamespaceOk (0x07) / PublishNamespaceError (0x08)
-					(Version::Draft14, ietf::PublishNamespaceOk::ID) => {
-						let msg = ietf::PublishNamespaceOk::decode_msg(&mut data, self.version)?;
-						tracing::debug!(message = ?msg, "publish namespace ok");
-						namespace_streams.insert(suffix, (request_id, stream));
-					}
-					(Version::Draft14, ietf::PublishNamespaceError::ID) => {
-						let msg = ietf::PublishNamespaceError::decode_msg(&mut data, self.version)?;
-						tracing::warn!(message = ?msg, "publish namespace error");
-					}
-					// Draft15+ uses RequestOk (0x07) / RequestError (0x05)
-					(_, ietf::RequestOk::ID) => {
-						let msg = ietf::RequestOk::decode_msg(&mut data, self.version)?;
-						tracing::debug!(message = ?msg, "publish namespace ok");
-						namespace_streams.insert(suffix, (request_id, stream));
-					}
-					(_, ietf::RequestError::ID) => {
-						let msg = ietf::RequestError::decode_msg(&mut data, self.version)?;
-						tracing::warn!(message = ?msg, "publish namespace error");
-					}
-					_ => return Err(Error::UnexpectedMessage),
-				}
-			} else {
-				tracing::debug!(broadcast = %self.origin.absolute(&path), "unannounce");
-				if let Some((request_id, mut stream)) = namespace_streams.remove(&suffix) {
-					// For v14-16, send PublishNamespaceDone. For v17, just close the stream.
-					match self.version {
-						Version::Draft14 | Version::Draft15 | Version::Draft16 => {
-							let _ = stream
-								.writer
-								.encode_message(&ietf::PublishNamespaceDone {
-									track_namespace: suffix.as_path(),
-									request_id,
-								})
-								.await;
+					match (self.version, type_id) {
+						(Version::Draft14, ietf::PublishNamespaceOk::ID) => {
+							let msg = ietf::PublishNamespaceOk::decode_msg(&mut data, self.version)?;
+							tracing::debug!(message = ?msg, "publish namespace ok");
+							namespace_streams.insert(suffix.clone(), (request_id, stream));
+						}
+						(Version::Draft14, ietf::PublishNamespaceError::ID) => {
+							let msg = ietf::PublishNamespaceError::decode_msg(&mut data, self.version)?;
+							tracing::warn!(message = ?msg, "publish namespace error");
+						}
+						(_, ietf::RequestOk::ID) => {
+							let msg = ietf::RequestOk::decode_msg(&mut data, self.version)?;
+							tracing::debug!(message = ?msg, "publish namespace ok");
+							namespace_streams.insert(suffix.clone(), (request_id, stream));
+						}
+						(_, ietf::RequestError::ID) => {
+							let msg = ietf::RequestError::decode_msg(&mut data, self.version)?;
+							tracing::warn!(message = ?msg, "publish namespace error");
 						}
-						Version::Draft17 => {}
+						_ => return Err(Error::UnexpectedMessage),
 					}
-					stream.writer.finish().ok();
+
+					active.insert(path.clone(), broadcast.clone());
+					let bc = broadcast.clone();
+					closures.push(Box::pin(async move {
+						bc.closed().await;
+						(path, broadcast)
+					}));
 				}
 			}
 		}
 
 		// Clean up remaining streams
-		for (suffix, (request_id, mut stream)) in namespace_streams {
-			match self.version {
-				Version::Draft14 | Version::Draft15 | Version::Draft16 => {
-					let _ = stream
-						.writer
-						.encode_message(&ietf::PublishNamespaceDone {
-							track_namespace: suffix.as_path(),
-							request_id,
-						})
-						.await;
-				}
-				Version::Draft17 => {}
-			}
-			stream.writer.finish().ok();
+		for (suffix, (request_id, stream)) in namespace_streams {
+			Self::close_namespace(self.version, &suffix, request_id, stream).await;
 		}
 
 		Ok(())
@@ -549,7 +560,7 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 
 		let mut origin = self
 			.origin
-			.consume_only(&[prefix.as_path()])
+			.with_filter(&[prefix.as_path()])
 			.ok_or(Error::Unauthorized)?;
 
 		// Send OK response
@@ -587,19 +598,27 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 			}
 			// v16+: Send Namespace/NamespaceDone entries on this bidi stream.
 			_ => {
+				let mut active_broadcasts: HashMap<crate::PathOwned, crate::BroadcastConsumer> = HashMap::new();
+				let mut closures: FuturesUnordered<crate::OriginClosureFuture> = FuturesUnordered::new();
+
 				// Send initial NAMESPACE messages for currently active namespaces
-				while let Some((path, active)) = origin.try_announced() {
+				while let Some((path, broadcast)) = origin.try_announced() {
 					let suffix = path.strip_prefix(&prefix).expect("origin returned invalid path");
-					if active.is_some() {
-						tracing::debug!(broadcast = %origin.absolute(&path), "namespace");
-						stream.writer.encode(&ietf::Namespace::ID).await?;
-						stream
-							.writer
-							.encode(&ietf::Namespace {
-								suffix: suffix.to_owned(),
-							})
-							.await?;
-					}
+					tracing::debug!(broadcast = %origin.absolute(&path), "namespace");
+					stream.writer.encode(&ietf::Namespace::ID).await?;
+					stream
+						.writer
+						.encode(&ietf::Namespace {
+							suffix: suffix.to_owned(),
+						})
+						.await?;
+
+					active_broadcasts.insert(path.clone(), broadcast.clone());
+					let bc = broadcast.clone();
+					closures.push(Box::pin(async move {
+						bc.closed().await;
+						(path, broadcast)
+					}));
 				}
 
 				// Stream updates
@@ -607,26 +626,37 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 					tokio::select! {
 						biased;
 						res = stream.reader.closed() => return res,
-						announced = origin.announced() => {
-							match announced {
-								Some((path, active)) => {
-									let suffix = path.strip_prefix(&prefix).expect("origin returned invalid path").to_owned();
-									if active.is_some() {
-										tracing::debug!(broadcast = %origin.absolute(&path), "namespace");
-										stream.writer.encode(&ietf::Namespace::ID).await?;
-										stream.writer.encode(&ietf::Namespace { suffix }).await?;
-									} else {
-										tracing::debug!(broadcast = %origin.absolute(&path), "namespace_done");
-										stream.writer.encode(&ietf::NamespaceDone::ID).await?;
-										stream.writer.encode(&ietf::NamespaceDone { suffix }).await?;
-									}
-								}
-								None => {
-									stream.writer.finish()?;
-									return stream.writer.closed().await;
-								}
+						Some((path, broadcast)) = closures.next() => {
+							if active_broadcasts.get(&path).is_some_and(|b| b.is_clone(&broadcast)) {
+								active_broadcasts.remove(&path);
+								let suffix = path.strip_prefix(&prefix).expect("origin returned invalid path").to_owned();
+								tracing::debug!(broadcast = %origin.absolute(&path), "namespace_done");
+								stream.writer.encode(&ietf::NamespaceDone::ID).await?;
+								stream.writer.encode(&ietf::NamespaceDone { suffix }).await?;
 							}
 						}
+						res = origin.announced() => {
+							let (path, broadcast) = res?;
+							let suffix = path.strip_prefix(&prefix).expect("origin returned invalid path").to_owned();
+
+							// If same path already active, send done then namespace (reannounce)
+							if active_broadcasts.contains_key(&path) {
+								tracing::debug!(broadcast = %origin.absolute(&path), "namespace_done (reannounce)");
+								stream.writer.encode(&ietf::NamespaceDone::ID).await?;
+								stream.writer.encode(&ietf::NamespaceDone { suffix: suffix.clone() }).await?;
+							}
+
+							tracing::debug!(broadcast = %origin.absolute(&path), "namespace");
+							stream.writer.encode(&ietf::Namespace::ID).await?;
+							stream.writer.encode(&ietf::Namespace { suffix }).await?;
+
+							active_broadcasts.insert(path.clone(), broadcast.clone());
+							let bc = broadcast.clone();
+							closures.push(Box::pin(async move {
+								bc.closed().await;
+								(path, broadcast)
+							}));
+						}
 					}
 				}
 			}
diff --git a/rs/moq-lite/src/ietf/request.rs b/rs/moq-lite/src/ietf/request.rs
index bc8c3f17b..94e390382 100644
--- a/rs/moq-lite/src/ietf/request.rs
+++ b/rs/moq-lite/src/ietf/request.rs
@@ -42,6 +42,7 @@ impl Decode<Version> for RequestId {
 }
 
 #[derive(Clone, Debug)]
+#[allow(dead_code)]
 pub struct MaxRequestId {
 	pub request_id: RequestId,
 }
@@ -61,6 +62,7 @@ impl Message for MaxRequestId {
 }
 
 #[derive(Clone, Debug)]
+#[allow(dead_code)]
 pub struct RequestsBlocked {
 	pub request_id: RequestId,
 }
diff --git a/rs/moq-lite/src/ietf/subscribe.rs b/rs/moq-lite/src/ietf/subscribe.rs
index 7bc788ae8..b3d5e9e70 100644
--- a/rs/moq-lite/src/ietf/subscribe.rs
+++ b/rs/moq-lite/src/ietf/subscribe.rs
@@ -267,6 +267,7 @@ impl Message for SubscribeError<'_> {
 
 /// Unsubscribe message (0x0a)
 #[derive(Clone, Debug)]
+#[allow(dead_code)]
 pub struct Unsubscribe {
 	pub request_id: RequestId,
 }
@@ -287,6 +288,7 @@ impl Message for Unsubscribe {
 
 /// SubscribeUpdate message (0x02)
 #[derive(Debug)]
+#[allow(dead_code)]
 pub struct SubscribeUpdate {
 	pub request_id: RequestId,
 	pub subscription_request_id: Option<RequestId>,
diff --git a/rs/moq-lite/src/ietf/subscribe_namespace.rs b/rs/moq-lite/src/ietf/subscribe_namespace.rs
index 10aaa350e..05e483575 100644
--- a/rs/moq-lite/src/ietf/subscribe_namespace.rs
+++ b/rs/moq-lite/src/ietf/subscribe_namespace.rs
@@ -110,6 +110,7 @@ impl Message for SubscribeNamespaceError<'_> {
 
 /// UnsubscribeNamespace message (0x14) — v14/v15 only (v16 uses stream close)
 #[derive(Clone, Debug)]
+#[allow(dead_code)]
 pub struct UnsubscribeNamespace {
 	pub request_id: RequestId,
 }
diff --git a/rs/moq-lite/src/ietf/subscriber.rs b/rs/moq-lite/src/ietf/subscriber.rs
index 9231eaf5b..f13874120 100644
--- a/rs/moq-lite/src/ietf/subscriber.rs
+++ b/rs/moq-lite/src/ietf/subscriber.rs
@@ -1,8 +1,8 @@
 use std::collections::{HashMap, hash_map::Entry};
 
 use crate::{
-	Broadcast, BroadcastDynamic, Error, Frame, FrameProducer, Group, GroupProducer, OriginProducer, Path, PathOwned,
-	Track, TrackProducer,
+	Broadcast, BroadcastDynamic, Error, Frame, FrameProducer, Group, GroupProducer, OriginId, OriginProducer, Path,
+	PathOwned, Track, TrackProducer,
 	coding::{Reader, Stream},
 	ietf::{self, Control, FilterType, GroupOrder, RequestId},
 	model::BroadcastProducer,
@@ -413,7 +413,8 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 				return Ok(entry.get().producer.clone());
 			}
 			Entry::Vacant(entry) => {
-				let broadcast = Broadcast::produce();
+				// IETF protocol doesn't have hops; use a single unknown hop (remote source).
+				let broadcast = Broadcast::new().with_hops(vec![OriginId::UNKNOWN]).produce();
 				origin.publish_broadcast(path.clone(), broadcast.consume());
 				entry.insert(BroadcastState {
 					producer: broadcast.clone(),
@@ -453,7 +454,7 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 					entry.remove();
 				}
 			}
-			Entry::Vacant(_) => return Err(Error::NotFound),
+			Entry::Vacant(_) => return Err(Error::UnknownBroadcast),
 		};
 
 		Ok(())
@@ -462,11 +463,7 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 	fn start_publish(&mut self, msg: &ietf::Publish<'_>) -> Result<(), Error> {
 		let request_id = msg.request_id;
 
-		let track = Track {
-			name: msg.track_name.to_string(),
-			priority: 0,
-		}
-		.produce();
+		let track = Track::new(msg.track_name.to_string()).produce();
 
 		let mut state = self.state.lock();
 		match state.subscribes.entry(request_id) {
@@ -491,8 +488,8 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 		state.publishes.insert(request_id, msg.track_namespace.to_owned());
 		drop(state);
 
-		let mut broadcast = self.start_announce(msg.track_namespace.to_owned())?;
-		broadcast.insert_track(&track)?;
+		let broadcast = self.start_announce(msg.track_namespace.to_owned())?;
+		broadcast.insert_track(track.consume())?;
 
 		Ok(())
 	}
@@ -500,8 +497,8 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 	async fn run_broadcast(&self, path: Path<'_>, mut broadcast: BroadcastDynamic) -> Result<(), Error> {
 		loop {
 			let track = tokio::select! {
-				producer = broadcast.requested_track() => match producer {
-					Ok(producer) => producer,
+				track = broadcast.requested_track() => match track {
+					Ok(track) => track,
 					Err(err) => {
 						tracing::debug!(%err, "broadcast closed");
 						break;
@@ -521,7 +518,8 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 		Ok(())
 	}
 
-	async fn run_subscribe(&mut self, broadcast: Path<'_>, mut track: TrackProducer) {
+	async fn run_subscribe(&mut self, broadcast_path: Path<'_>, mut track: TrackProducer) {
+		let broadcast = broadcast_path;
 		let request_id = match self.control.next_request_id().await {
 			Ok(id) => id,
 			Err(err) => {
@@ -626,7 +624,7 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 				request_id,
 				track_namespace: broadcast.to_owned(),
 				track_name: (&track.info.name).into(),
-				subscriber_priority: track.info.priority,
+				subscriber_priority: 0,
 				group_order: GroupOrder::Descending,
 				filter_type: FilterType::LargestObject,
 			})
@@ -677,7 +675,7 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 					RequestId(group.track_alias)
 				}
 			};
-			let track = state.subscribes.get_mut(&request_id).ok_or(Error::NotFound)?;
+			let track = state.subscribes.get_mut(&request_id).ok_or(Error::UnknownTrack)?;
 
 			let group = Group {
 				sequence: group.group_id,
diff --git a/rs/moq-lite/src/ietf/track.rs b/rs/moq-lite/src/ietf/track.rs
index 132b73cb9..9865af474 100644
--- a/rs/moq-lite/src/ietf/track.rs
+++ b/rs/moq-lite/src/ietf/track.rs
@@ -19,6 +19,7 @@ use super::Version;
 /// v14: own format (TrackStatusRequest-like with subscribe fields)
 /// v15: same wire format as SUBSCRIBE. Response is REQUEST_OK.
 #[derive(Clone, Debug)]
+#[allow(dead_code)]
 pub struct TrackStatus<'a> {
 	pub request_id: RequestId,
 	pub track_namespace: Path<'a>,
diff --git a/rs/moq-lite/src/lib.rs b/rs/moq-lite/src/lib.rs
index 179576808..422ad469c 100644
--- a/rs/moq-lite/src/lib.rs
+++ b/rs/moq-lite/src/lib.rs
@@ -35,5 +35,6 @@ pub use server::*;
 pub use session::*;
 pub use version::*;
 
-// Re-export the bytes crate
+// Re-export crates that are part of the public API
 pub use bytes;
+pub use conducer;
diff --git a/rs/moq-lite/src/lite/announce.rs b/rs/moq-lite/src/lite/announce.rs
index 3b265a99f..927683989 100644
--- a/rs/moq-lite/src/lite/announce.rs
+++ b/rs/moq-lite/src/lite/announce.rs
@@ -1,9 +1,22 @@
 use num_enum::{IntoPrimitive, TryFromPrimitive};
 
-use crate::{Path, coding::*};
+use crate::{OriginId, Path, coding::*};
 
 use super::{Message, Version};
 
+impl Decode<Version> for OriginId {
+	fn decode<R: bytes::Buf>(r: &mut R, version: Version) -> Result<Self, DecodeError> {
+		let value = u64::decode(r, version)?;
+		Self::try_from(value).map_err(|_| DecodeError::InvalidValue)
+	}
+}
+
+impl Encode<Version> for OriginId {
+	fn encode<W: bytes::BufMut>(&self, w: &mut W, version: Version) -> Result<(), EncodeError> {
+		self.into_inner().encode(w, version)
+	}
+}
+
 /// Sent by the publisher to announce the availability of a track.
 /// The payload contains the contents of the wildcard.
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -12,12 +25,12 @@ pub enum Announce<'a> {
 	Active {
 		#[cfg_attr(feature = "serde", serde(borrow))]
 		suffix: Path<'a>,
-		hops: u64,
+		hops: Vec<OriginId>,
 	},
 	Ended {
 		#[cfg_attr(feature = "serde", serde(borrow))]
 		suffix: Path<'a>,
-		hops: u64,
+		hops: Vec<OriginId>,
 	},
 }
 
@@ -26,8 +39,27 @@ impl Message for Announce<'_> {
 		let status = AnnounceStatus::decode(r, version)?;
 		let suffix = Path::decode(r, version)?;
 		let hops = match version {
-			Version::Lite03 => u64::decode(r, version)?,
-			Version::Lite01 | Version::Lite02 => 0,
+			Version::Lite01 | Version::Lite02 => Vec::new(),
+			Version::Lite03 => {
+				// Lite03 sends a single varint count; we don't know the actual IDs.
+				let count = u64::decode(r, version)? as usize;
+				if count > 32 {
+					return Err(DecodeError::InvalidValue);
+				}
+				vec![OriginId::UNKNOWN; count]
+			}
+			_ => {
+				// Lite04+: count followed by that many OriginId varints.
+				let count = u64::decode(r, version)? as usize;
+				if count > 32 {
+					return Err(DecodeError::InvalidValue);
+				}
+				let mut ids = Vec::with_capacity(count);
+				for _ in 0..count {
+					ids.push(OriginId::decode(r, version)?);
+				}
+				ids
+			}
 		};
 
 		Ok(match status {
@@ -37,21 +69,29 @@ impl Message for Announce<'_> {
 	}
 
 	fn encode_msg<W: bytes::BufMut>(&self, w: &mut W, version: Version) -> Result<(), EncodeError> {
-		match self {
-			Self::Active { suffix, hops } => {
-				AnnounceStatus::Active.encode(w, version)?;
-				suffix.encode(w, version)?;
-				match version {
-					Version::Lite03 => hops.encode(w, version)?,
-					Version::Lite01 | Version::Lite02 => {}
+		let (status, suffix, hops) = match self {
+			Self::Active { suffix, hops } => (AnnounceStatus::Active, suffix, hops),
+			Self::Ended { suffix, hops } => (AnnounceStatus::Ended, suffix, hops),
+		};
+
+		status.encode(w, version)?;
+		suffix.encode(w, version)?;
+
+		match version {
+			Version::Lite01 | Version::Lite02 => {}
+			Version::Lite03 => {
+				if hops.len() > 32 {
+					return Err(EncodeError::TooMany);
 				}
+				(hops.len() as u64).encode(w, version)?;
 			}
-			Self::Ended { suffix, hops } => {
-				AnnounceStatus::Ended.encode(w, version)?;
-				suffix.encode(w, version)?;
-				match version {
-					Version::Lite03 => hops.encode(w, version)?,
-					Version::Lite01 | Version::Lite02 => {}
+			_ => {
+				if hops.len() > 32 {
+					return Err(EncodeError::TooMany);
+				}
+				(hops.len() as u64).encode(w, version)?;
+				for id in hops {
+					id.encode(w, version)?;
 				}
 			}
 		}
@@ -65,16 +105,38 @@ impl Message for Announce<'_> {
 pub struct AnnouncePlease<'a> {
 	// Request tracks with this prefix.
 	pub prefix: Path<'a>,
+
+	/// Skip announces whose hops list contains this hop ID.
+	/// Used to avoid loops in the relay cluster.
+	/// Defaults to 0 (unknown), which means no filtering.
+	pub exclude_hop: OriginId,
 }
 
 impl Message for AnnouncePlease<'_> {
 	fn decode_msg<R: bytes::Buf>(r: &mut R, version: Version) -> Result<Self, DecodeError> {
 		let prefix = Path::decode(r, version)?;
-		Ok(Self { prefix })
+		let exclude_hop = match version {
+			Version::Lite01 | Version::Lite02 | Version::Lite03 => OriginId::UNKNOWN,
+			_ => {
+				let value = u64::decode(r, version)?;
+				if value == 0 {
+					OriginId::UNKNOWN
+				} else {
+					OriginId::try_from(value).map_err(|_| DecodeError::InvalidValue)?
+				}
+			}
+		};
+		Ok(Self { prefix, exclude_hop })
 	}
 
 	fn encode_msg<W: bytes::BufMut>(&self, w: &mut W, version: Version) -> Result<(), EncodeError> {
 		self.prefix.encode(w, version)?;
+		match version {
+			Version::Lite01 | Version::Lite02 | Version::Lite03 => {}
+			_ => {
+				self.exclude_hop.into_inner().encode(w, version)?;
+			}
+		}
 
 		Ok(())
 	}
@@ -116,7 +178,7 @@ impl Message for AnnounceInit<'_> {
 	fn decode_msg<R: bytes::Buf>(r: &mut R, version: Version) -> Result<Self, DecodeError> {
 		match version {
 			Version::Lite01 | Version::Lite02 => {}
-			Version::Lite03 => {
+			_ => {
 				return Err(DecodeError::Version);
 			}
 		}
@@ -136,7 +198,7 @@ impl Message for AnnounceInit<'_> {
 	fn encode_msg<W: bytes::BufMut>(&self, w: &mut W, version: Version) -> Result<(), EncodeError> {
 		match version {
 			Version::Lite01 | Version::Lite02 => {}
-			Version::Lite03 => {
+			_ => {
 				return Err(EncodeError::Version);
 			}
 		}
diff --git a/rs/moq-lite/src/lite/fetch.rs b/rs/moq-lite/src/lite/fetch.rs
index 04a53679c..a298c2f20 100644
--- a/rs/moq-lite/src/lite/fetch.rs
+++ b/rs/moq-lite/src/lite/fetch.rs
@@ -22,10 +22,10 @@ pub struct Fetch<'a> {
 impl Message for Fetch<'_> {
 	fn decode_msg<R: bytes::Buf>(r: &mut R, version: Version) -> Result<Self, DecodeError> {
 		match version {
-			Version::Lite03 => {}
 			Version::Lite01 | Version::Lite02 => {
 				return Err(DecodeError::Version);
 			}
+			_ => {}
 		}
 
 		let broadcast = Path::decode(r, version)?;
@@ -43,10 +43,10 @@ impl Message for Fetch<'_> {
 
 	fn encode_msg<W: bytes::BufMut>(&self, w: &mut W, version: Version) -> Result<(), EncodeError> {
 		match version {
-			Version::Lite03 => {}
 			Version::Lite01 | Version::Lite02 => {
 				return Err(EncodeError::Version);
 			}
+			_ => {}
 		}
 
 		self.broadcast.encode(w, version)?;
diff --git a/rs/moq-lite/src/lite/info.rs b/rs/moq-lite/src/lite/info.rs
index 74ce5e92e..d85827e8f 100644
--- a/rs/moq-lite/src/lite/info.rs
+++ b/rs/moq-lite/src/lite/info.rs
@@ -11,7 +11,7 @@ impl Message for SessionInfo {
 	fn decode_msg<R: bytes::Buf>(r: &mut R, version: Version) -> Result<Self, DecodeError> {
 		match version {
 			Version::Lite01 | Version::Lite02 => {}
-			Version::Lite03 => {
+			_ => {
 				return Err(DecodeError::Version);
 			}
 		}
@@ -27,7 +27,7 @@ impl Message for SessionInfo {
 	fn encode_msg<W: bytes::BufMut>(&self, w: &mut W, version: Version) -> Result<(), EncodeError> {
 		match version {
 			Version::Lite01 | Version::Lite02 => {}
-			Version::Lite03 => {
+			_ => {
 				return Err(EncodeError::Version);
 			}
 		}
diff --git a/rs/moq-lite/src/lite/probe.rs b/rs/moq-lite/src/lite/probe.rs
index 3e3d8edec..d91febcc1 100644
--- a/rs/moq-lite/src/lite/probe.rs
+++ b/rs/moq-lite/src/lite/probe.rs
@@ -4,7 +4,7 @@ use super::{Message, Version};
 
 /// Sent to probe the available bitrate.
 ///
-/// Lite03 only.
+/// Lite03 and later.
 #[derive(Clone, Debug)]
 pub struct Probe {
 	pub bitrate: u64,
@@ -13,10 +13,10 @@ pub struct Probe {
 impl Message for Probe {
 	fn decode_msg<R: bytes::Buf>(r: &mut R, version: Version) -> Result<Self, DecodeError> {
 		match version {
-			Version::Lite03 => {}
 			Version::Lite01 | Version::Lite02 => {
 				return Err(DecodeError::Version);
 			}
+			_ => {}
 		}
 
 		let bitrate = u64::decode(r, version)?;
@@ -26,10 +26,10 @@ impl Message for Probe {
 
 	fn encode_msg<W: bytes::BufMut>(&self, w: &mut W, version: Version) -> Result<(), EncodeError> {
 		match version {
-			Version::Lite03 => {}
 			Version::Lite01 | Version::Lite02 => {
 				return Err(EncodeError::Version);
 			}
+			_ => {}
 		}
 
 		self.bitrate.encode(w, version)?;
diff --git a/rs/moq-lite/src/lite/publisher.rs b/rs/moq-lite/src/lite/publisher.rs
index 9b1b69629..e2d7e5064 100644
--- a/rs/moq-lite/src/lite/publisher.rs
+++ b/rs/moq-lite/src/lite/publisher.rs
@@ -1,11 +1,11 @@
-use std::time::Duration;
+use std::{collections::HashMap, time::Duration};
 
 use futures::{FutureExt, StreamExt, stream::FuturesUnordered};
 use web_async::FuturesExt;
 use web_transport_trait::Stats;
 
 use crate::{
-	AsPath, BroadcastConsumer, Error, Origin, OriginConsumer, Track, TrackConsumer,
+	AsPath, BroadcastConsumer, Error, Origin, OriginConsumer, Subscription, Track, TrackSubscriber,
 	coding::{Stream, Writer},
 	lite::{
 		self,
@@ -119,15 +119,16 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 	pub async fn recv_announce(&mut self, mut stream: Stream<S, Version>) -> Result<(), Error> {
 		let interest = stream.reader.decode::<lite::AnnouncePlease>().await?;
 		let prefix = interest.prefix.to_owned();
+		let exclude_hop = interest.exclude_hop;
 
 		let mut origin = self
 			.origin
-			.consume_only(&[prefix.as_path()])
+			.with_filter(&[prefix.as_path()])
 			.ok_or(Error::Unauthorized)?;
 
 		let version = self.version;
 		web_async::spawn(async move {
-			if let Err(err) = Self::run_announce(&mut stream, &mut origin, &prefix, version).await {
+			if let Err(err) = Self::run_announce(&mut stream, &mut origin, &prefix, version, exclude_hop).await {
 				match &err {
 					Error::Cancel => {
 						tracing::debug!(prefix = %origin.absolute(prefix), "announcing cancelled");
@@ -152,33 +153,41 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 		origin: &mut OriginConsumer,
 		prefix: impl AsPath,
 		version: Version,
+		exclude_hop: crate::OriginId,
 	) -> Result<(), Error> {
 		let prefix = prefix.as_path();
 
+		let mut active: HashMap<crate::PathOwned, BroadcastConsumer> = HashMap::new();
+		let mut closures: FuturesUnordered<crate::OriginClosureFuture> = FuturesUnordered::new();
+
 		match version {
 			Version::Lite01 | Version::Lite02 => {
 				let mut init = Vec::new();
 
 				// Send ANNOUNCE_INIT as the first message with all currently active paths
-				// We use `try_next()` to synchronously get the initial updates.
-				while let Some((path, active)) = origin.try_announced() {
+				while let Some((path, broadcast)) = origin.try_announced() {
 					let suffix = path.strip_prefix(&prefix).expect("origin returned invalid path");
+					tracing::debug!(broadcast = %origin.absolute(&path), "announce");
+					init.push(suffix.to_owned());
 
-					if active.is_some() {
-						tracing::debug!(broadcast = %origin.absolute(&path), "announce");
-						init.push(suffix.to_owned());
-					} else {
-						// A potential race.
-						tracing::debug!(broadcast = %origin.absolute(&path), "unannounce");
-						init.retain(|path| path != &suffix);
+					// Skip if the broadcast's hops contain the excluded hop ID.
+					if exclude_hop != crate::OriginId::UNKNOWN && broadcast.info.hops.contains(&exclude_hop) {
+						continue;
 					}
+
+					active.insert(path.clone(), broadcast.clone());
+					let bc = broadcast.clone();
+					closures.push(Box::pin(async move {
+						bc.closed().await;
+						(path, broadcast)
+					}));
 				}
 
 				let announce_init = lite::AnnounceInit { suffixes: init };
 				stream.writer.encode(&announce_init).await?;
 			}
-			Version::Lite03 => {
-				// No more announce init in Lite03.
+			_ => {
+				// No more announce init starting with Lite03.
 			}
 		}
 
@@ -187,26 +196,48 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 			tokio::select! {
 				biased;
 				res = stream.reader.closed() => return res,
-				announced = origin.announced() => {
-					match announced {
-						Some((path, active)) => {
-							let suffix = path.strip_prefix(&prefix).expect("origin returned invalid path").to_owned();
-
-							if active.is_some() {
-								tracing::debug!(broadcast = %origin.absolute(&path), "announce");
-								let msg = lite::Announce::Active { suffix, hops: 0 };
-								stream.writer.encode(&msg).await?;
-							} else {
-								tracing::debug!(broadcast = %origin.absolute(&path), "unannounce");
-								let msg = lite::Announce::Ended { suffix, hops: 0 };
-								stream.writer.encode(&msg).await?;
-							}
-						},
-						None => {
-							stream.writer.finish()?;
-							return stream.writer.closed().await;
+				Some((path, broadcast)) = closures.next() => {
+					// Only send Ended if this broadcast is still the active one (not replaced)
+					if active.get(&path).is_some_and(|b| b.is_clone(&broadcast)) {
+						active.remove(&path);
+						let suffix = path.strip_prefix(&prefix).expect("origin returned invalid path").to_owned();
+						tracing::debug!(broadcast = %origin.absolute(&path), "unannounce");
+						let msg = lite::Announce::Ended { suffix, hops: Vec::new() };
+						stream.writer.encode(&msg).await?;
+					}
+				}
+				res = origin.announced() => {
+					let (path, broadcast) = res?;
+					let suffix = path.strip_prefix(&prefix).expect("origin returned invalid path").to_owned();
+
+					// Skip if the broadcast's hops contain the excluded hop ID.
+					if exclude_hop != crate::OriginId::UNKNOWN && broadcast.info.hops.contains(&exclude_hop) {
+						// If we previously announced this path, send Ended
+						if active.remove(&path).is_some() {
+							tracing::debug!(broadcast = %origin.absolute(&path), "unannounce (excluded hop)");
+							let msg = lite::Announce::Ended { suffix, hops: Vec::new() };
+							stream.writer.encode(&msg).await?;
 						}
+						continue;
 					}
+
+					// If same path already active, send Ended then Active (reannounce)
+					if active.contains_key(&path) {
+						tracing::debug!(broadcast = %origin.absolute(&path), "reannounce (ended)");
+						let msg = lite::Announce::Ended { suffix: suffix.clone(), hops: Vec::new() };
+						stream.writer.encode(&msg).await?;
+					}
+
+					tracing::debug!(broadcast = %origin.absolute(&path), hops = broadcast.info.hops.len(), "announce");
+					let msg = lite::Announce::Active { suffix, hops: broadcast.info.hops.clone() };
+					stream.writer.encode(&msg).await?;
+
+					active.insert(path.clone(), broadcast.clone());
+					let bc = broadcast.clone();
+					closures.push(Box::pin(async move {
+						bc.closed().await;
+						(path, broadcast)
+					}));
 				}
 			}
 		}
@@ -221,7 +252,7 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 
 		tracing::info!(%id, broadcast = %absolute, %track, "subscribed started");
 
-		let broadcast = self.origin.consume_broadcast(&subscribe.broadcast);
+		let broadcast = self.origin.try_consume_broadcast(&subscribe.broadcast);
 		let priority = self.priority.clone();
 		let version = self.version;
 
@@ -255,20 +286,18 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 		priority: PriorityQueue,
 		version: Version,
 	) -> Result<(), Error> {
-		let track = Track {
-			name: subscribe.track.to_string(),
-			priority: subscribe.priority,
-		};
+		let track = Track::new(subscribe.track.to_string());
 
-		let broadcast = consumer.ok_or(Error::NotFound)?;
-		let track = broadcast.subscribe_track(&track)?;
+		let broadcast = consumer.ok_or(Error::UnknownBroadcast)?;
+		let subscriber = broadcast.subscribe_track(&track, Subscription::default())?;
 
-		// TODO wait until track.info() to get the *real* priority
+		// Wait for at least one group before sending SUBSCRIBE_OK
+		subscriber.ready().await?;
 
 		let info = lite::SubscribeOk {
-			priority: track.info.priority,
+			priority: 0,
 			ordered: false,
-			max_latency: std::time::Duration::ZERO,
+			max_latency: Duration::ZERO,
 			start_group: None,
 			end_group: None,
 		};
@@ -276,7 +305,7 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 		stream.writer.encode(&lite::SubscribeResponse::Ok(info)).await?;
 
 		tokio::select! {
-			res = Self::run_track(session, track, subscribe, priority, version) => res?,
+			res = Self::run_track(session, subscriber, subscribe, priority, version) => res?,
 			res = stream.reader.closed() => res?,
 		}
 
@@ -286,18 +315,13 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 
 	async fn run_track(
 		session: S,
-		mut track: TrackConsumer,
+		mut track: TrackSubscriber,
 		subscribe: &lite::Subscribe<'_>,
 		priority: PriorityQueue,
 		version: Version,
 	) -> Result<(), Error> {
 		let mut tasks = FuturesUnordered::new();
 
-		// Start the consumer at the specified sequence, otherwise start at the latest group.
-		if let Some(start_group) = subscribe.start_group.or_else(|| track.latest()) {
-			track.start_at(start_group);
-		}
-
 		loop {
 			let group = tokio::select! {
 				// Poll all active group futures; never matches but keeps them running.
@@ -305,7 +329,7 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 					while tasks.next().await.is_some() {}
 					false
 				} => unreachable!(),
-				Some(group) = track.next_group().transpose() => group,
+				Some(group) = track.recv_group().transpose() => group,
 				else => return Ok(()),
 			}?;
 
@@ -317,7 +341,7 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 				sequence,
 			};
 
-			let priority = priority.insert(track.info.priority, sequence);
+			let priority = priority.insert(subscribe.priority, sequence);
 			tasks.push(Self::serve_group(session.clone(), msg, priority, group, version).map(|_| ()));
 		}
 	}
diff --git a/rs/moq-lite/src/lite/subscribe.rs b/rs/moq-lite/src/lite/subscribe.rs
index fe8fce14d..f22a522b4 100644
--- a/rs/moq-lite/src/lite/subscribe.rs
+++ b/rs/moq-lite/src/lite/subscribe.rs
@@ -30,14 +30,14 @@ impl Message for Subscribe<'_> {
 		let priority = u8::decode(r, version)?;
 
 		let (ordered, max_latency, start_group, end_group) = match version {
-			Version::Lite03 => {
+			Version::Lite01 | Version::Lite02 => (false, std::time::Duration::ZERO, None, None),
+			_ => {
 				let ordered = u8::decode(r, version)? != 0;
 				let max_latency = std::time::Duration::decode(r, version)?;
 				let start_group = Option::<u64>::decode(r, version)?;
 				let end_group = Option::<u64>::decode(r, version)?;
 				(ordered, max_latency, start_group, end_group)
 			}
-			Version::Lite01 | Version::Lite02 => (false, std::time::Duration::ZERO, None, None),
 		};
 
 		Ok(Self {
@@ -59,13 +59,13 @@ impl Message for Subscribe<'_> {
 		self.priority.encode(w, version)?;
 
 		match version {
-			Version::Lite03 => {
+			Version::Lite01 | Version::Lite02 => {}
+			_ => {
 				(self.ordered as u8).encode(w, version)?;
 				self.max_latency.encode(w, version)?;
 				self.start_group.encode(w, version)?;
 				self.end_group.encode(w, version)?;
 			}
-			Version::Lite01 | Version::Lite02 => {}
 		}
 
 		Ok(())
@@ -84,17 +84,17 @@ pub struct SubscribeOk {
 impl Message for SubscribeOk {
 	fn encode_msg<W: bytes::BufMut>(&self, w: &mut W, version: Version) -> Result<(), EncodeError> {
 		match version {
-			Version::Lite03 => {
+			Version::Lite01 => {
+				self.priority.encode(w, version)?;
+			}
+			Version::Lite02 => {}
+			_ => {
 				self.priority.encode(w, version)?;
 				(self.ordered as u8).encode(w, version)?;
 				self.max_latency.encode(w, version)?;
 				self.start_group.encode(w, version)?;
 				self.end_group.encode(w, version)?;
 			}
-			Version::Lite01 => {
-				self.priority.encode(w, version)?;
-			}
-			Version::Lite02 => {}
 		}
 
 		Ok(())
@@ -102,21 +102,6 @@ impl Message for SubscribeOk {
 
 	fn decode_msg<R: bytes::Buf>(r: &mut R, version: Version) -> Result<Self, DecodeError> {
 		match version {
-			Version::Lite03 => {
-				let priority = u8::decode(r, version)?;
-				let ordered = u8::decode(r, version)? != 0;
-				let max_latency = std::time::Duration::decode(r, version)?;
-				let start_group = Option::<u64>::decode(r, version)?;
-				let end_group = Option::<u64>::decode(r, version)?;
-
-				Ok(Self {
-					priority,
-					ordered,
-					max_latency,
-					start_group,
-					end_group,
-				})
-			}
 			Version::Lite01 => Ok(Self {
 				priority: u8::decode(r, version)?,
 				ordered: false,
@@ -131,6 +116,21 @@ impl Message for SubscribeOk {
 				start_group: None,
 				end_group: None,
 			}),
+			_ => {
+				let priority = u8::decode(r, version)?;
+				let ordered = u8::decode(r, version)? != 0;
+				let max_latency = std::time::Duration::decode(r, version)?;
+				let start_group = Option::<u64>::decode(r, version)?;
+				let end_group = Option::<u64>::decode(r, version)?;
+
+				Ok(Self {
+					priority,
+					ordered,
+					max_latency,
+					start_group,
+					end_group,
+				})
+			}
 		}
 	}
 }
@@ -151,10 +151,10 @@ pub struct SubscribeUpdate {
 impl Message for SubscribeUpdate {
 	fn decode_msg<R: bytes::Buf>(r: &mut R, version: Version) -> Result<Self, DecodeError> {
 		match version {
-			Version::Lite03 => {}
 			Version::Lite01 | Version::Lite02 => {
 				return Err(DecodeError::Version);
 			}
+			_ => {}
 		}
 
 		let priority = u8::decode(r, version)?;
@@ -180,10 +180,10 @@ impl Message for SubscribeUpdate {
 
 	fn encode_msg<W: bytes::BufMut>(&self, w: &mut W, version: Version) -> Result<(), EncodeError> {
 		match version {
-			Version::Lite03 => {}
 			Version::Lite01 | Version::Lite02 => {
 				return Err(EncodeError::Version);
 			}
+			_ => {}
 		}
 
 		self.priority.encode(w, version)?;
@@ -232,10 +232,10 @@ pub struct SubscribeDrop {
 impl Message for SubscribeDrop {
 	fn decode_msg<R: bytes::Buf>(r: &mut R, version: Version) -> Result<Self, DecodeError> {
 		match version {
-			Version::Lite03 => {}
 			Version::Lite01 | Version::Lite02 => {
 				return Err(DecodeError::Version);
 			}
+			_ => {}
 		}
 
 		Ok(Self {
@@ -247,10 +247,10 @@ impl Message for SubscribeDrop {
 
 	fn encode_msg<W: bytes::BufMut>(&self, w: &mut W, version: Version) -> Result<(), EncodeError> {
 		match version {
-			Version::Lite03 => {}
 			Version::Lite01 | Version::Lite02 => {
 				return Err(EncodeError::Version);
 			}
+			_ => {}
 		}
 
 		self.start.encode(w, version)?;
@@ -277,32 +277,32 @@ pub enum SubscribeResponse {
 impl Encode<Version> for SubscribeResponse {
 	fn encode<W: bytes::BufMut>(&self, w: &mut W, version: Version) -> Result<(), EncodeError> {
 		match version {
-			Version::Lite03 => match self {
+			Version::Lite01 | Version::Lite02 => match self {
 				Self::Ok(ok) => {
-					0u64.encode(w, version)?;
-					// Write size-prefixed body using Message trait
 					let mut sizer = Sizer::default();
 					Message::encode_msg(ok, &mut sizer, version)?;
 					sizer.size.encode(w, version)?;
 					Message::encode_msg(ok, w, version)?;
 				}
-				Self::Drop(drop) => {
-					1u64.encode(w, version)?;
-					let mut sizer = Sizer::default();
-					Message::encode_msg(drop, &mut sizer, version)?;
-					sizer.size.encode(w, version)?;
-					Message::encode_msg(drop, w, version)?;
+				Self::Drop(_) => {
+					return Err(EncodeError::Version);
 				}
 			},
-			Version::Lite01 | Version::Lite02 => match self {
+			_ => match self {
 				Self::Ok(ok) => {
+					0u64.encode(w, version)?;
+					// Write size-prefixed body using Message trait
 					let mut sizer = Sizer::default();
 					Message::encode_msg(ok, &mut sizer, version)?;
 					sizer.size.encode(w, version)?;
 					Message::encode_msg(ok, w, version)?;
 				}
-				Self::Drop(_) => {
-					return Err(EncodeError::Version);
+				Self::Drop(drop) => {
+					1u64.encode(w, version)?;
+					let mut sizer = Sizer::default();
+					Message::encode_msg(drop, &mut sizer, version)?;
+					sizer.size.encode(w, version)?;
+					Message::encode_msg(drop, w, version)?;
 				}
 			},
 		}
@@ -314,7 +314,8 @@ impl Encode<Version> for SubscribeResponse {
 impl Decode<Version> for SubscribeResponse {
 	fn decode<B: bytes::Buf>(buf: &mut B, version: Version) -> Result<Self, DecodeError> {
 		match version {
-			Version::Lite03 => {
+			Version::Lite01 | Version::Lite02 => Ok(Self::Ok(SubscribeOk::decode(buf, version)?)),
+			_ => {
 				let typ = u64::decode(buf, version)?;
 				match typ {
 					0 => Ok(Self::Ok(SubscribeOk::decode(buf, version)?)),
@@ -322,7 +323,6 @@ impl Decode<Version> for SubscribeResponse {
 					_ => Err(DecodeError::InvalidMessage(typ)),
 				}
 			}
-			Version::Lite01 | Version::Lite02 => Ok(Self::Ok(SubscribeOk::decode(buf, version)?)),
 		}
 	}
 }
diff --git a/rs/moq-lite/src/lite/subscriber.rs b/rs/moq-lite/src/lite/subscriber.rs
index 51c21f39c..177459af0 100644
--- a/rs/moq-lite/src/lite/subscriber.rs
+++ b/rs/moq-lite/src/lite/subscriber.rs
@@ -1,11 +1,12 @@
 use std::{
 	collections::{HashMap, hash_map::Entry},
 	sync::{Arc, atomic},
+	time::Duration,
 };
 
 use crate::{
-	AsPath, Broadcast, BroadcastDynamic, Error, Frame, FrameProducer, Group, GroupProducer, OriginProducer, Path,
-	PathOwned, TrackProducer,
+	AsPath, Broadcast, BroadcastDynamic, Error, Frame, FrameProducer, Group, GroupProducer, OriginId, OriginProducer,
+	Path, PathOwned, TrackProducer,
 	coding::{Reader, Stream},
 	lite,
 	model::BroadcastProducer,
@@ -20,6 +21,7 @@ pub(super) struct Subscriber<S: web_transport_trait::Session> {
 	session: S,
 
 	origin: Option<OriginProducer>,
+	origin_id: OriginId,
 	subscribes: Lock<HashMap<u64, TrackProducer>>,
 	next_id: Arc<atomic::AtomicU64>,
 	version: Version,
@@ -27,9 +29,14 @@ pub(super) struct Subscriber<S: web_transport_trait::Session> {
 
 impl<S: web_transport_trait::Session> Subscriber<S> {
 	pub fn new(session: S, origin: Option<OriginProducer>, version: Version) -> Self {
+		let origin_id = match &origin {
+			Some(o) => o.id(),
+			None => OriginId::UNKNOWN,
+		};
 		Self {
 			session,
 			origin,
+			origin_id,
 			subscribes: Default::default(),
 			next_id: Default::default(),
 			version,
@@ -83,7 +90,10 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 
 		// Ask for everything.
 		// TODO This should actually ask for each root.
-		let msg = lite::AnnouncePlease { prefix: "".into() };
+		let msg = lite::AnnouncePlease {
+			prefix: "".into(),
+			exclude_hop: self.origin_id,
+		};
 		stream.writer.encode(&msg).await?;
 
 		let mut producers = HashMap::new();
@@ -92,24 +102,30 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 			Version::Lite01 | Version::Lite02 => {
 				let msg: lite::AnnounceInit = stream.reader.decode().await?;
 				for path in msg.suffixes {
-					self.start_announce(path, &mut producers)?;
+					// Lite01/02 don't have hops on the wire; use unknown since the actual origin is not known.
+					let hops = vec![OriginId::UNKNOWN];
+					self.start_announce(path, Broadcast::new().with_hops(hops), &mut producers)?;
 				}
 			}
-			Version::Lite03 => {
-				// Lite03: no AnnounceInit, initial state comes via Announce messages.
+			_ => {
+				// Lite03+: no AnnounceInit, initial state comes via Announce messages.
 			}
 		}
 
 		while let Some(announce) = stream.reader.decode_maybe::<lite::Announce>().await? {
 			match announce {
-				lite::Announce::Active { suffix: path, .. } => {
-					self.start_announce(path, &mut producers)?;
+				lite::Announce::Active { suffix: path, hops } => {
+					let mut new_hops = hops;
+					if self.origin_id != OriginId::UNKNOWN {
+						new_hops.push(self.origin_id);
+					}
+					self.start_announce(path, Broadcast::new().with_hops(new_hops), &mut producers)?;
 				}
 				lite::Announce::Ended { suffix: path, .. } => {
 					tracing::debug!(broadcast = %self.log_path(&path), "unannounced");
 
 					// Abort the producer.
-					let mut producer = producers.remove(&path.into_owned()).ok_or(Error::NotFound)?;
+					let producer = producers.remove(&path.into_owned()).ok_or(Error::UnknownBroadcast)?;
 					producer.abort(Error::Cancel).ok();
 				}
 			}
@@ -123,11 +139,12 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 	fn start_announce(
 		&mut self,
 		path: PathOwned,
+		info: Broadcast,
 		producers: &mut HashMap<PathOwned, BroadcastProducer>,
 	) -> Result<(), Error> {
-		tracing::debug!(broadcast = %self.log_path(&path), "announce");
+		tracing::debug!(broadcast = %self.log_path(&path), hops = info.hops.len(), "announce");
 
-		let broadcast = Broadcast::produce();
+		let broadcast = info.produce();
 
 		// Make sure the peer doesn't double announce.
 		match producers.entry(path.to_owned()) {
@@ -158,8 +175,8 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 			// Keep serving requests until there are no more consumers.
 			// This way we'll clean up the task when the broadcast is no longer needed.
 			let track = tokio::select! {
-				producer = broadcast.requested_track() => match producer {
-					Ok(producer) => producer,
+				track = broadcast.requested_track() => match track {
+					Ok(track) => track,
 					Err(err) => {
 						tracing::debug!(%err, "broadcast closed");
 						break;
@@ -179,21 +196,23 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 		}
 	}
 
-	async fn run_subscribe(&mut self, id: u64, broadcast: Path<'_>, mut track: TrackProducer) {
+	async fn run_subscribe(&mut self, id: u64, broadcast_path: Path<'_>, mut track: TrackProducer) {
+		let track_name = track.info.name.clone();
+
 		self.subscribes.lock().insert(id, track.clone());
 
 		let msg = lite::Subscribe {
 			id,
-			broadcast: broadcast.to_owned(),
+			broadcast: broadcast_path.to_owned(),
 			track: (&track.info.name).into(),
-			priority: track.info.priority,
-			ordered: true,
-			max_latency: std::time::Duration::ZERO,
+			priority: 0,
+			ordered: false,
+			max_latency: Duration::ZERO,
 			start_group: None,
 			end_group: None,
 		};
 
-		tracing::info!(id, broadcast = %self.log_path(&broadcast), track = %track.info.name, "subscribe started");
+		tracing::info!(id, broadcast = %self.log_path(&broadcast_path), track = %track_name, "subscribe started");
 
 		let res = tokio::select! {
 			_ = track.unused() => Err(Error::Cancel),
@@ -202,15 +221,15 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 
 		match res {
 			Err(Error::Cancel) => {
-				tracing::info!(id, broadcast = %self.log_path(&broadcast), track = %track.info.name, "subscribe cancelled");
+				tracing::info!(id, broadcast = %self.log_path(&broadcast_path), track = %track_name, "subscribe cancelled");
 				let _ = track.abort(Error::Cancel);
 			}
 			Err(err) => {
-				tracing::warn!(id, broadcast = %self.log_path(&broadcast), track = %track.info.name, %err, "subscribe error");
+				tracing::warn!(id, broadcast = %self.log_path(&broadcast_path), track = %track_name, %err, "subscribe error");
 				let _ = track.abort(err);
 			}
 			_ => {
-				tracing::info!(id, broadcast = %self.log_path(&broadcast), track = %track.info.name, "subscribe complete");
+				tracing::info!(id, broadcast = %self.log_path(&broadcast_path), track = %track_name, "subscribe complete");
 				let _ = track.finish();
 			}
 		}
diff --git a/rs/moq-lite/src/lite/version.rs b/rs/moq-lite/src/lite/version.rs
index d811bf3f0..07de44e68 100644
--- a/rs/moq-lite/src/lite/version.rs
+++ b/rs/moq-lite/src/lite/version.rs
@@ -6,6 +6,7 @@ pub enum Version {
 	Lite01,
 	Lite02,
 	Lite03,
+	Lite04,
 }
 
 impl fmt::Display for Version {
@@ -14,6 +15,7 @@ impl fmt::Display for Version {
 			Self::Lite01 => write!(f, "moq-lite-01"),
 			Self::Lite02 => write!(f, "moq-lite-02"),
 			Self::Lite03 => write!(f, "moq-lite-03"),
+			Self::Lite04 => write!(f, "moq-lite-04"),
 		}
 	}
 }
@@ -24,6 +26,7 @@ impl From<Version> for crate::Version {
 			Version::Lite01 => crate::Version::Lite(Version::Lite01),
 			Version::Lite02 => crate::Version::Lite(Version::Lite02),
 			Version::Lite03 => crate::Version::Lite(Version::Lite03),
+			Version::Lite04 => crate::Version::Lite(Version::Lite04),
 		}
 	}
 }
diff --git a/rs/moq-lite/src/model/broadcast.rs b/rs/moq-lite/src/model/broadcast.rs
index 4f8c540e6..52bbf0bd2 100644
--- a/rs/moq-lite/src/model/broadcast.rs
+++ b/rs/moq-lite/src/model/broadcast.rs
@@ -3,21 +3,34 @@ use std::{
 	task::{Poll, ready},
 };
 
-use crate::{Error, TrackConsumer, TrackProducer, model::track::TrackWeak};
+use std::ops::Deref;
 
-use super::Track;
+use crate::{Error, Subscription, TrackConsumer, TrackProducer, TrackSubscriber, model::track::TrackWeak};
+
+use super::{OriginId, Track};
 
 /// A collection of media tracks that can be published and subscribed to.
 ///
 /// Create via [`Broadcast::produce`] to obtain both [`BroadcastProducer`] and [`BroadcastConsumer`] pair.
-#[derive(Clone, Default)]
+#[derive(Clone, Debug, Default)]
+#[non_exhaustive]
 pub struct Broadcast {
-	// NOTE: Broadcasts have no names because they're often relative.
+	/// The list of origin IDs representing the path from the origin.
+	pub hops: Vec<OriginId>,
 }
 
 impl Broadcast {
-	pub fn produce() -> BroadcastProducer {
-		BroadcastProducer::new()
+	pub fn new() -> Self {
+		Self::default()
+	}
+
+	pub fn with_hops(mut self, hops: Vec<OriginId>) -> Self {
+		self.hops = hops;
+		self
+	}
+
+	pub fn produce(self) -> BroadcastProducer {
+		BroadcastProducer::new(self)
 	}
 }
 
@@ -26,17 +39,35 @@ struct State {
 	// Weak references for deduplication. Doesn't prevent track auto-close.
 	tracks: HashMap<String, TrackWeak>,
 
-	// Dynamic tracks that have been requested.
-	requests: Vec<TrackProducer>,
+	// Track producers queued by consume_track for the dynamic handler.
+	requested: Vec<TrackProducer>,
 
 	// The current number of dynamic producers.
-	// If this is 0, requests must be empty.
+	// If this is 0, requests will fail with NotFound.
 	dynamic: usize,
 
 	// The error that caused the broadcast to be aborted, if any.
 	abort: Option<Error>,
 }
 
+impl State {
+	/// Insert a track into the lookup, returning an error if a live track with the same name exists.
+	fn insert_track(&mut self, weak: TrackWeak) -> Result<(), Error> {
+		match self.tracks.entry(weak.info.name.clone()) {
+			hash_map::Entry::Occupied(mut entry) => {
+				if !entry.get().is_closed() {
+					return Err(Error::Duplicate);
+				}
+				entry.insert(weak);
+			}
+			hash_map::Entry::Vacant(entry) => {
+				entry.insert(weak);
+			}
+		}
+		Ok(())
+	}
+}
+
 fn modify(state: &conducer::Producer<State>) -> Result<conducer::Mut<'_, State>, Error> {
 	match state.write() {
 		Ok(state) => Ok(state),
@@ -50,65 +81,64 @@ fn modify(state: &conducer::Producer<State>) -> Result<conducer::Mut<'_, State>,
 /// or handle on-demand requests via [Self::dynamic].
 #[derive(Clone)]
 pub struct BroadcastProducer {
+	pub info: Broadcast,
 	state: conducer::Producer<State>,
 }
 
 impl Default for BroadcastProducer {
 	fn default() -> Self {
-		Self::new()
+		Self::new(Broadcast::default())
 	}
 }
 
 impl BroadcastProducer {
-	pub fn new() -> Self {
+	pub fn new(info: Broadcast) -> Self {
 		Self {
+			info,
 			state: Default::default(),
 		}
 	}
 
-	/// Insert a track into the lookup, returning an error on duplicate.
+	/// Insert a track consumer into the lookup, returning an error on duplicate.
 	///
-	/// NOTE: You probably want to [TrackProducer::clone] first to keep publishing to the track.
-	pub fn insert_track(&mut self, track: &TrackProducer) -> Result<(), Error> {
-		let mut state = modify(&self.state)?;
-
-		let hash_map::Entry::Vacant(entry) = state.tracks.entry(track.info.name.clone()) else {
-			return Err(Error::Duplicate);
-		};
-
-		entry.insert(track.weak());
-
+	/// This allows sharing a track from another broadcast without copying data.
+	pub fn insert_track(&self, track: TrackConsumer) -> Result<(), Error> {
+		let mut guard = modify(&self.state)?;
+		guard.insert_track(track.weak())?;
 		Ok(())
 	}
 
 	/// Remove a track from the lookup.
-	pub fn remove_track(&mut self, name: &str) -> Result<(), Error> {
+	pub fn remove_track(&self, name: &str) -> Result<(), Error> {
 		let mut state = modify(&self.state)?;
-		state.tracks.remove(name).ok_or(Error::NotFound)?;
+		state.tracks.remove(name).ok_or(Error::UnknownTrack)?;
 		Ok(())
 	}
 
 	/// Produce a new track and insert it into the broadcast.
-	pub fn create_track(&mut self, track: Track) -> Result<TrackProducer, Error> {
+	pub fn create_track(&self, track: Track) -> Result<TrackProducer, Error> {
 		let track = TrackProducer::new(track);
-		self.insert_track(&track)?;
+		let mut guard = modify(&self.state)?;
+		guard.insert_track(track.weak())?;
+		drop(guard);
 		Ok(track)
 	}
 
 	/// Create a dynamic producer that handles on-demand track requests from consumers.
 	pub fn dynamic(&self) -> BroadcastDynamic {
-		BroadcastDynamic::new(self.state.clone())
+		BroadcastDynamic::new(self.info.clone(), self.state.clone())
 	}
 
 	/// Create a consumer that can subscribe to tracks in this broadcast.
 	pub fn consume(&self) -> BroadcastConsumer {
 		BroadcastConsumer {
+			info: self.info.clone(),
 			state: self.state.consume(),
 		}
 	}
 
 	/// Abort the broadcast and all child tracks with the given error.
-	pub fn abort(&mut self, err: Error) -> Result<(), Error> {
+	pub fn abort(&self, err: Error) -> Result<(), Error> {
 		let mut guard = modify(&self.state)?;
 
 		// Cascade abort to all child tracks.
@@ -116,9 +146,9 @@ impl BroadcastProducer {
 			weak.abort(err.clone());
 		}
 
-		// Abort any pending dynamic track requests.
-		for mut request in guard.requests.drain(..) {
-			request.abort(err.clone()).ok();
+		// Abort any pending requested track producers.
+		for mut track in guard.requested.drain(..) {
+			let _ = track.abort(err.clone());
 		}
 
 		guard.abort = Some(err);
@@ -132,35 +162,43 @@ impl BroadcastProducer {
 	}
 }
 
+impl Deref for BroadcastProducer {
+	type Target = Broadcast;
+
+	fn deref(&self) -> &Self::Target {
+		&self.info
+	}
+}
+
 #[cfg(test)]
 impl BroadcastProducer {
-	pub fn assert_create_track(&mut self, track: &Track) -> TrackProducer {
+	pub fn assert_create_track(&self, track: &Track) -> TrackProducer {
 		self.create_track(track.clone()).expect("should not have errored")
 	}
 
-	pub fn assert_insert_track(&mut self, track: &TrackProducer) {
-		self.insert_track(track).expect("should not have errored")
+	pub fn assert_insert_track(&self, track: &TrackProducer) {
+		self.insert_track(track.consume()).expect("should not have errored")
 	}
 }
 
 /// Handles on-demand track creation for a broadcast.
 ///
-/// When a consumer requests a track that doesn't exist, a [TrackProducer] is created
-/// and queued for the dynamic producer to fulfill via [Self::requested_track].
-/// Dropped when no longer needed; pending requests are automatically aborted.
+/// When a consumer requests a track that doesn't exist, a [`TrackProducer`] is
+/// created and queued. The dynamic handler receives it via [`Self::requested_track`]
+/// and starts filling it with data.
 #[derive(Clone)]
 pub struct BroadcastDynamic {
+	info: Broadcast,
 	state: conducer::Producer<State>,
 }
 
 impl BroadcastDynamic {
-	fn new(state: conducer::Producer<State>) -> Self {
+	fn new(info: Broadcast, state: conducer::Producer<State>) -> Self {
 		if let Ok(mut state) = state.write() {
-			// If the broadcast is already closed, we can't handle any new requests.
 			state.dynamic += 1;
 		}
 
-		Self { state }
+		Self { info, state }
 	}
 
 	// A helper to automatically apply Dropped if the state is closed without an error.
@@ -175,26 +213,37 @@ impl BroadcastDynamic {
 	}
 
 	pub fn poll_requested_track(&mut self, waiter: &conducer::Waiter) -> Poll<Result<TrackProducer, Error>> {
-		self.poll(waiter, |state| match state.requests.pop() {
+		self.poll(waiter, |state| match state.requested.pop() {
 			Some(producer) => Poll::Ready(producer),
 			None => Poll::Pending,
 		})
 	}
 
-	/// Block until a consumer requests a track, returning its producer.
+	/// Block until a consumer requests a track, returning the producer.
+	///
+	/// The handler should start filling the [`TrackProducer`] with data
+	/// (e.g., by subscribing upstream).
 	pub async fn requested_track(&mut self) -> Result<TrackProducer, Error> {
 		conducer::wait(|waiter| self.poll_requested_track(waiter)).await
 	}
 
+	/// Insert a track into the broadcast lookup.
+	pub fn insert_track(&self, track: TrackConsumer) -> Result<(), Error> {
+		let mut guard = modify(&self.state)?;
+		guard.insert_track(track.weak())?;
+		Ok(())
+	}
+
 	/// Create a consumer that can subscribe to tracks in this broadcast.
 	pub fn consume(&self) -> BroadcastConsumer {
 		BroadcastConsumer {
+			info: self.info.clone(),
 			state: self.state.consume(),
 		}
 	}
 
 	/// Abort the broadcast with the given error.
-	pub fn abort(&mut self, err: Error) -> Result<(), Error> {
+	pub fn abort(&self, err: Error) -> Result<(), Error> {
 		let mut guard = modify(&self.state)?;
 
 		// Cascade abort to all child tracks.
@@ -202,9 +251,9 @@ impl BroadcastDynamic {
 			weak.abort(err.clone());
 		}
 
-		// Abort any pending dynamic track requests.
-		for mut request in guard.requests.drain(..) {
-			request.abort(err.clone()).ok();
+		// Abort any pending requested track producers.
+		for mut track in guard.requested.drain(..) {
+			let _ = track.abort(err.clone());
 		}
 
 		guard.abort = Some(err);
@@ -227,9 +276,9 @@ impl Drop for BroadcastDynamic {
 				return;
 			}
 
-			// Abort all pending requests since there's no dynamic producer to handle them.
-			for mut request in state.requests.drain(..) {
-				request.abort(Error::Cancel).ok();
+			// Abort all pending requested tracks since there's no dynamic producer to handle them.
+			for mut track in state.requested.drain(..) {
+				let _ = track.abort(Error::Cancel);
 			}
 		}
 	}
@@ -255,12 +304,21 @@ impl BroadcastDynamic {
 /// Subscribe to arbitrary broadcast/tracks.
 #[derive(Clone)]
 pub struct BroadcastConsumer {
+	pub info: Broadcast,
 	state: conducer::Consumer<State>,
 }
 
+impl Deref for BroadcastConsumer {
+	type Target = Broadcast;
+
+	fn deref(&self) -> &Self::Target {
+		&self.info
+	}
+}
+
 impl BroadcastConsumer {
-	pub fn subscribe_track(&self, track: &Track) -> Result<TrackConsumer, Error> {
-		// Upgrade to a temporary producer so we can modify the state.
+	/// Returns the track if it exists, otherwise tries to route it to [`BroadcastDynamic`].
+	pub fn consume_track(&self, track: &Track) -> Result<TrackConsumer, Error> {
 		let producer = self
 			.state
 			.produce()
@@ -275,42 +333,27 @@ impl BroadcastConsumer {
 			state.tracks.remove(&track.name);
 		}
 
-		// Otherwise we have never seen this track before and need to create a new producer.
-		let producer = track.clone().produce();
-		let consumer = producer.consume();
-
 		if state.dynamic == 0 {
-			return Err(Error::NotFound);
+			return Err(Error::UnknownTrack);
 		}
 
-		// Insert a weak reference for deduplication.
-		let weak = producer.weak();
-		state.tracks.insert(producer.info.name.clone(), weak.clone());
-		state.requests.push(producer);
-
-		// Remove the track from the lookup when it's unused.
-		let consumer_state = self.state.clone();
-		web_async::spawn(async move {
-			let _ = weak.unused().await;
-
-			let Some(producer) = consumer_state.produce() else {
-				return;
-			};
-			let Ok(mut state) = producer.write() else {
-				return;
-			};
-
-			// Remove the entry, but reinsert if it was replaced by a different reference.
-			if let Some(current) = state.tracks.remove(&weak.info.name)
-				&& !current.is_clone(&weak)
-			{
-				state.tracks.insert(current.info.name.clone(), current);
-			}
-		});
+		// Create a new TrackProducer, insert into lookup, and queue for dynamic handler.
+		let track_producer = TrackProducer::new(track.clone());
+		state.insert_track(track_producer.weak())?;
+		let consumer = track_producer.consume();
+		state.requested.push(track_producer);
 
 		Ok(consumer)
 	}
 
+	/// Subscribe to a track.
+	///
+	/// Convenience: calls [`Self::consume_track`] then [`TrackConsumer::subscribe`].
+	pub fn subscribe_track(&self, track: &Track, sub: Subscription) -> Result<TrackSubscriber, Error> {
+		let consumer = self.consume_track(track)?;
+		consumer.subscribe(sub)
+	}
+
 	pub async fn closed(&self) -> Error {
 		self.state.closed().await;
 		self.state.read().abort.clone().unwrap_or(Error::Dropped)
@@ -324,8 +367,8 @@ impl BroadcastConsumer {
 
 #[cfg(test)]
 impl BroadcastConsumer {
-	pub fn assert_subscribe_track(&self, track: &Track) -> TrackConsumer {
-		self.subscribe_track(track).expect("should not have errored")
+	pub fn assert_consume_track(&self, track: &Track) -> TrackConsumer {
+		self.consume_track(track).expect("should not have errored")
 	}
 
 	pub fn assert_not_closed(&self) {
@@ -343,7 +386,7 @@ mod test {
 
 	#[tokio::test]
 	async fn insert() {
-		let mut producer = BroadcastProducer::new();
+		let producer = Broadcast::new().produce();
 		let mut track1 = Track::new("track1").produce();
 
 		// Make sure we can insert before a consumer is created.
@@ -352,167 +395,163 @@ mod test {
 
 		let consumer = producer.consume();
 
-		let mut track1_sub = consumer.assert_subscribe_track(&Track::new("track1"));
-		track1_sub.assert_group();
+		let track1_consumer = consumer.assert_consume_track(&Track::new("track1"));
+		assert_eq!(track1_consumer.latest(), Some(0));
 
 		let mut track2 = Track::new("track2").produce();
 		producer.assert_insert_track(&track2);
 
 		let consumer2 = producer.consume();
-		let mut track2_consumer = consumer2.assert_subscribe_track(&Track::new("track2"));
-		track2_consumer.assert_no_group();
+		let track2_consumer = consumer2.assert_consume_track(&Track::new("track2"));
+		assert_eq!(track2_consumer.latest(), None);
 
 		track2.append_group().unwrap();
-
-		track2_consumer.assert_group();
+		assert_eq!(track2_consumer.latest(), Some(0));
 	}
 
 	#[tokio::test]
 	async fn closed() {
-		let mut producer = BroadcastProducer::new();
-		let _dynamic = producer.dynamic();
+		let producer = Broadcast::new().produce();
+		let dynamic = producer.dynamic();
 
 		let consumer = producer.consume();
 		consumer.assert_not_closed();
 
 		// Create a new track and insert it into the broadcast.
 		let track1 = producer.assert_create_track(&Track::new("track1"));
-		let track1c = consumer.assert_subscribe_track(&track1.info);
-		let track2 = consumer.assert_subscribe_track(&Track::new("track2"));
+		let track1c = consumer.assert_consume_track(&track1.info);
 
 		// Explicitly aborting the broadcast should cascade to child tracks.
+		drop(dynamic);
 		producer.abort(Error::Cancel).unwrap();
 
-		// The requested TrackProducer should have been aborted.
-		track2.assert_error();
-
-		// track1 should also be closed because close() cascades.
+		// track1 should be closed because close() cascades.
 		track1c.assert_error();
-
-		// track1's producer should also be closed.
 		assert!(track1.is_closed());
 	}
 
 	#[tokio::test]
 	async fn requests() {
-		let mut producer = BroadcastProducer::new().dynamic();
+		let broadcast = Broadcast::new().produce();
+		let mut dynamic = broadcast.dynamic();
 
-		let consumer = producer.consume();
+		let consumer = broadcast.consume();
 		let consumer2 = consumer.clone();
 
-		let mut track1 = consumer.assert_subscribe_track(&Track::new("track1"));
-		track1.assert_not_closed();
-		track1.assert_no_group();
-
-		// Make sure we deduplicate requests while track1 is still active.
-		let mut track2 = consumer2.assert_subscribe_track(&Track::new("track1"));
-		track2.assert_is_clone(&track1);
-
-		// Get the requested track, and there should only be one.
-		let mut track3 = producer.assert_request();
-		producer.assert_no_request();
-
-		// Make sure the consumer is the same.
-		track3.consume().assert_is_clone(&track1);
+		// consume_track with dynamic handler should create a producer and queue it.
+		let track1_consumer = consumer.assert_consume_track(&Track::new("track1"));
+		assert_eq!(track1_consumer.latest(), None);
 
-		// Append a group and make sure they all get it.
-		track3.append_group().unwrap();
-		track1.assert_group();
-		track2.assert_group();
+		// Get the request -- there should be exactly one.
+		let mut track1_producer = dynamic.assert_request();
+		dynamic.assert_no_request();
+		assert_eq!(track1_producer.info.name, "track1");
 
-		// Make sure that tracks are cancelled when the producer is dropped.
-		let track4 = consumer.assert_subscribe_track(&Track::new("track2"));
-		drop(producer);
+		// Dedup: consuming the same track again should return the existing one.
+		let track1_dup = consumer2.assert_consume_track(&Track::new("track1"));
+		track1_dup.assert_is_clone(&track1_consumer);
 
-		// Make sure the track is errored, not closed.
-		track4.assert_error();
+		// No new request should be queued.
+		dynamic.assert_no_request();
 
-		let track5 = consumer2.subscribe_track(&Track::new("track3"));
-		assert!(track5.is_err(), "should have errored");
+		// Append a group and make sure both see it.
+		track1_producer.append_group().unwrap();
+		assert_eq!(track1_consumer.latest(), Some(0));
+		assert_eq!(track1_dup.latest(), Some(0));
 	}
 
 	#[tokio::test]
 	async fn stale_producer() {
-		let mut broadcast = Broadcast::produce().dynamic();
+		tokio::time::pause();
+
+		let broadcast = Broadcast::new().produce();
+		let mut dynamic = broadcast.dynamic();
 		let consumer = broadcast.consume();
 
-		// Subscribe to a track, creating a request
-		let track1 = consumer.assert_subscribe_track(&Track::new("track1"));
+		// Subscribe to a track (creates producer via dynamic).
+		let track1_consumer = consumer.assert_consume_track(&Track::new("track1"));
+
+		// Handle the request.
+		let mut producer1 = dynamic.assert_request();
 
-		// Get the requested producer and close it (simulating publisher disconnect)
-		let mut producer1 = broadcast.assert_request();
+		// Close the producer (simulating publisher disconnect).
 		producer1.append_group().unwrap();
 		producer1.finish().unwrap();
 		drop(producer1);
 
-		// The consumer should see the track as closed
-		track1.assert_closed();
+		// The consumer should see the track as closed.
+		track1_consumer.assert_closed();
+		drop(track1_consumer);
 
-		// Subscribe again to the same track - should get a NEW producer, not the stale one
-		let mut track2 = consumer.assert_subscribe_track(&Track::new("track1"));
-		track2.assert_not_closed();
-		track2.assert_not_clone(&track1);
+		// Subscribe again to the same track -- should get a new request
+		// because the old producer was dropped (weak ref is closed).
+		let track2_consumer = consumer.assert_consume_track(&Track::new("track1"));
 
-		// There should be a new request for the track
-		let mut producer2 = broadcast.assert_request();
-		producer2.append_group().unwrap();
+		let mut producer2 = dynamic.assert_request();
 
-		// The new consumer should receive the new group
-		track2.assert_group();
+		producer2.append_group().unwrap();
+		assert_eq!(track2_consumer.latest(), Some(0));
 	}
 
 	#[tokio::test]
 	async fn requested_unused() {
-		let mut broadcast = Broadcast::produce().dynamic();
+		let broadcast = Broadcast::new().produce();
+		let mut dynamic = broadcast.dynamic();
 
-		// Subscribe to a track that doesn't exist - this creates a request
-		let consumer1 = broadcast.consume().assert_subscribe_track(&Track::new("unknown_track"));
+		// Subscribe to a track.
+		let c1 = broadcast.consume();
+		let consumer1 = c1.assert_consume_track(&Track::new("unknown_track"));
 
-		// Get the requested track producer
-		let producer1 = broadcast.assert_request();
+		// Handle the request.
+		let producer1 = dynamic.assert_request();
 
-		// The track producer should NOT be unused yet because there's a consumer
+		// The track producer should NOT be unused yet because there's a consumer.
 		assert!(
 			producer1.unused().now_or_never().is_none(),
 			"track producer should be used"
 		);
 
-		// Making a new consumer will keep the producer alive
-		let consumer2 = broadcast.consume().assert_subscribe_track(&Track::new("unknown_track"));
+		// Making a new consumer will keep the producer alive.
+		let consumer2 = c1.assert_consume_track(&Track::new("unknown_track"));
 		consumer2.assert_is_clone(&consumer1);
 
-		// Drop the consumer subscription
 		drop(consumer1);
-
-		// The track producer should NOT be unused yet because there's a consumer
 		assert!(
 			producer1.unused().now_or_never().is_none(),
 			"track producer should be used"
 		);
 
-		// Drop the second consumer, now the producer should be unused
+		// Drop the second consumer, now the producer should be unused.
 		drop(consumer2);
-
-		// BUG: The track producer should become unused after dropping the consumer,
-		// but it won't because the broadcast keeps a reference in the lookup HashMap
-		// This assertion will fail, demonstrating the bug
 		assert!(
 			producer1.unused().now_or_never().is_some(),
 			"track producer should be unused after consumer is dropped"
 		);
 
-		// TODO Unfortunately, we need to sleep for a little bit to detect when unused.
-		tokio::time::sleep(std::time::Duration::from_millis(1)).await;
+		// Drop the producer so the weak ref is closed.
+		drop(producer1);
 
-		// Now the cleanup task should have run and we can subscribe again to the unknown track.
-		let consumer3 = broadcast.consume().subscribe_track(&Track::new("unknown_track"));
-		let producer2 = broadcast.assert_request();
+		// Now consume_track finds the stale entry, removes it, and creates a new request.
+		let c2 = broadcast.consume();
+		let _consumer3 = c2.assert_consume_track(&Track::new("unknown_track"));
 
-		// Drop the consumer, now the producer should be unused
-		drop(consumer3);
-		assert!(
-			producer2.unused().now_or_never().is_some(),
-			"track producer should be unused after consumer is dropped"
-		);
+		let _producer2 = dynamic.assert_request();
+		dynamic.assert_no_request();
+	}
+
+	#[tokio::test]
+	async fn pending_requests_rejected_on_drop() {
+		let broadcast = Broadcast::new().produce();
+		let dynamic = broadcast.dynamic();
+		let consumer = broadcast.consume();
+
+		// consume_track creates a producer and queues it.
+		let track_consumer = consumer.assert_consume_track(&Track::new("track2"));
+
+		// Drop dynamic -- pending producers should be aborted.
+		drop(dynamic);
+
+		// Track consumer should see an error.
+		track_consumer.assert_error();
 	}
 }
diff --git a/rs/moq-lite/src/model/group.rs b/rs/moq-lite/src/model/group.rs
index e07cdbdb5..475e0a78e 100644
--- a/rs/moq-lite/src/model/group.rs
+++ b/rs/moq-lite/src/model/group.rs
@@ -206,6 +206,11 @@ impl GroupProducer {
 			.await
 			.map_err(|r| r.abort.clone().unwrap_or(Error::Dropped))
 	}
+
+	/// Returns true if this group was aborted (closed with an error).
+	pub fn is_aborted(&self) -> bool {
+		self.state.read().abort.is_some()
+	}
 }
 
 impl Clone for GroupProducer {
diff --git a/rs/moq-lite/src/model/origin.rs b/rs/moq-lite/src/model/origin.rs
index bd68a2059..b519e960e 100644
--- a/rs/moq-lite/src/model/origin.rs
+++ b/rs/moq-lite/src/model/origin.rs
@@ -1,3 +1,90 @@
+use std::fmt;
+
+use rand::Rng;
+
+use crate::Version;
+use crate::coding::{Decode, DecodeError, Encode, EncodeError};
+
+/// A unique identifier for an origin, encoded as a varint on the wire.
+///
+/// Must be a non-zero 62-bit value (1 <= value < 2^62).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+pub struct OriginId(u64);
+
+/// The maximum valid OriginId value (2^62 - 1).
+const ORIGIN_ID_MAX: u64 = (1u64 << 62) - 1;
+
+impl OriginId {
+	/// A placeholder value used when the actual OriginId is unknown (e.g., Lite03 hop placeholders).
+	pub const UNKNOWN: Self = Self(0);
+
+	/// Generate a random non-zero 62-bit origin ID.
+	pub fn random() -> Self {
+		let mut rng = rand::rng();
+		let value = rng.random_range(1..(1u64 << 62));
+		Self(value)
+	}
+
+	/// Get the inner u64 value.
+	pub fn into_inner(self) -> u64 {
+		self.0
+	}
+}
+
+impl TryFrom<u64> for OriginId {
+	type Error = InvalidOriginId;
+
+	fn try_from(value: u64) -> Result<Self, Self::Error> {
+		if value == 0 || value > ORIGIN_ID_MAX {
+			return Err(InvalidOriginId(value));
+		}
+		Ok(Self(value))
+	}
+}
+
+/// Error returned when constructing an OriginId with an invalid value.
+#[derive(Debug, Clone)]
+pub struct InvalidOriginId(pub u64);
+
+impl fmt::Display for InvalidOriginId {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		write!(f, "invalid OriginId: {} (must be 1 <= value < 2^62)", self.0)
+	}
+}
+
+impl std::error::Error for InvalidOriginId {}
+
+impl fmt::Display for OriginId {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		self.0.fmt(f)
+	}
+}
+
+impl Encode<Version> for OriginId {
+	fn encode<W: bytes::BufMut>(&self, w: &mut W, version: Version) -> Result<(), EncodeError> {
+		self.0.encode(w, version)
+	}
+}
+
+impl Decode<Version> for OriginId {
+	fn decode<R: bytes::Buf>(r: &mut R, version: Version) -> Result<Self, DecodeError> {
+		let value = u64::decode(r, version)?;
+		Self::try_from(value).map_err(|_| DecodeError::InvalidValue)
+	}
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for OriginId {
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: serde::Deserializer<'de>,
+	{
+		let value = u64::deserialize(deserializer)?;
+		Self::try_from(value).map_err(serde::de::Error::custom)
+	}
+}
+
 use std::{
 	collections::HashMap,
 	sync::atomic::{AtomicU64, Ordering},
@@ -5,8 +92,14 @@ use std::{
 use tokio::sync::mpsc;
 use web_async::Lock;
 
+use std::time::Duration;
+
 use super::BroadcastConsumer;
-use crate::{AsPath, Broadcast, BroadcastProducer, Path, PathOwned};
+use crate::{AsPath, Broadcast, BroadcastProducer, Error, Path, PathOwned};
+
+/// Delay before reannouncing a promoted backup broadcast.
+/// This avoids churn when a cascade of closures propagates through the network.
+const REANNOUNCE_HOLD_DOWN: Duration = Duration::from_millis(250);
 
 static NEXT_CONSUMER_ID: AtomicU64 = AtomicU64::new(0);
 
@@ -35,18 +128,7 @@ struct OriginConsumerNotify {
 impl OriginConsumerNotify {
 	fn announce(&self, path: impl AsPath, broadcast: BroadcastConsumer) {
 		let path = path.as_path().strip_prefix(&self.root).unwrap().to_owned();
-		self.tx.send((path, Some(broadcast))).expect("consumer closed");
-	}
-
-	fn reannounce(&self, path: impl AsPath, broadcast: BroadcastConsumer) {
-		let path = path.as_path().strip_prefix(&self.root).unwrap().to_owned();
-		self.tx.send((path.clone(), None)).expect("consumer closed");
-		self.tx.send((path, Some(broadcast))).expect("consumer closed");
-	}
-
-	fn unannounce(&self, path: impl AsPath) {
-		let path = path.as_path().strip_prefix(&self.root).unwrap().to_owned();
-		self.tx.send((path, None)).expect("consumer closed");
+		self.tx.send((path, broadcast)).expect("consumer closed");
 	}
 }
 
@@ -75,26 +157,6 @@ impl NotifyNode {
 			parent.lock().announce(path, broadcast);
 		}
 	}
-
-	fn reannounce(&mut self, path: impl AsPath, broadcast: &BroadcastConsumer) {
-		for consumer in self.consumers.values() {
-			consumer.reannounce(path.as_path(), broadcast.clone());
-		}
-
-		if let Some(parent) = &self.parent {
-			parent.lock().reannounce(path, broadcast);
-		}
-	}
-
-	fn unannounce(&mut self, path: impl AsPath) {
-		for consumer in self.consumers.values() {
-			consumer.unannounce(path.as_path());
-		}
-
-		if let Some(parent) = &self.parent {
-			parent.lock().unannounce(path);
-		}
-	}
 }
 
 struct OriginNode {
@@ -145,11 +207,28 @@ impl OriginNode {
 			self.entry(dir).lock().publish(&full, broadcast, &relative);
 		} else if let Some(existing) = &mut self.broadcast {
 			// This node is a leaf with an existing broadcast.
-			let old = existing.active.clone();
-			existing.active = broadcast.clone();
-			existing.backup.push(old);
 
-			self.notify.lock().reannounce(full, broadcast);
+			// Prefix check: if the existing broadcast's hops are a strict prefix of the new one,
+			// the new broadcast is routing through us (loop). Reject it.
+			// Identical hop lists are not treated as loops (could be a re-announcement).
+			if !existing.active.info.hops.is_empty()
+				&& broadcast.info.hops.len() > existing.active.info.hops.len()
+				&& broadcast.info.hops.starts_with(&existing.active.info.hops)
+			{
+				tracing::debug!(broadcast = %full, "rejecting broadcast: hops are prefix of existing");
+				return;
+			}
+
+			if broadcast.info.hops.len() < existing.active.info.hops.len() {
+				// New broadcast has fewer hops, so it becomes active.
+				let old = existing.active.clone();
+				existing.active = broadcast.clone();
+				existing.backup.push(old);
+				self.notify.lock().announce(full, broadcast);
+			} else {
+				// Same or more hops, just add to backup.
+				existing.backup.push(broadcast.clone());
+			}
 		} else {
 			// This node is a leaf with no existing broadcast.
 			self.broadcast = Some(OriginBroadcast {
@@ -196,46 +275,89 @@ impl OriginNode {
 		}
 	}
 
-	// Returns true if the broadcast should be unannounced.
-	fn remove(&mut self, full: impl AsPath, broadcast: BroadcastConsumer, relative: impl AsPath) {
+	/// Remove a broadcast from this node.
+	///
+	/// Returns `Some(promoted)` if a backup was promoted to active and needs a delayed reannounce.
+	/// Unannounces immediately if there are no backups.
+	fn remove(
+		&mut self,
+		full: impl AsPath,
+		broadcast: BroadcastConsumer,
+		relative: impl AsPath,
+	) -> Option<BroadcastConsumer> {
 		let full = full.as_path();
 		let relative = relative.as_path();
 
 		if let Some((dir, relative)) = relative.next_part() {
 			let nested = self.entry(dir);
 			let mut locked = nested.lock();
-			locked.remove(&full, broadcast, &relative);
+			let result = locked.remove(&full, broadcast, &relative);
 
 			if locked.is_empty() {
 				drop(locked);
 				self.nested.remove(dir);
 			}
-		} else {
-			let entry = match &mut self.broadcast {
-				Some(existing) => existing,
-				None => return,
-			};
 
-			// See if we can remove the broadcast from the backup list.
-			let pos = entry.backup.iter().position(|b| b.is_clone(&broadcast));
-			if let Some(pos) = pos {
-				entry.backup.remove(pos);
-				// Nothing else to do
-				return;
-			}
+			return result;
+		}
 
-			// Okay so it must be the active broadcast or else we fucked up.
-			assert!(entry.active.is_clone(&broadcast));
+		let entry = match &mut self.broadcast {
+			Some(existing) => existing,
+			None => return None,
+		};
 
-			// If there's a backup broadcast, then announce it.
-			if let Some(active) = entry.backup.pop() {
-				entry.active = active;
-				self.notify.lock().reannounce(full, &entry.active);
-			} else {
-				// No more backups, so remove the entry.
-				self.broadcast = None;
-				self.notify.lock().unannounce(full);
+		// See if we can remove the broadcast from the backup list.
+		let pos = entry.backup.iter().position(|b| b.is_clone(&broadcast));
+		if let Some(pos) = pos {
+			entry.backup.remove(pos);
+			return None;
+		}
+
+		// Okay so it must be the active broadcast or else we fucked up.
+		assert!(entry.active.is_clone(&broadcast));
+
+		// If there's a backup broadcast, pick the one with fewest hops (most recent as tiebreaker).
+		if !entry.backup.is_empty() {
+			// Reverse enumerate so that ties prefer the most recently added (last in vec).
+			let best = entry
+				.backup
+				.iter()
+				.enumerate()
+				.rev()
+				.min_by_key(|(_, b)| b.info.hops.len())
+				.map(|(i, _)| i)
+				.unwrap();
+			let active = entry.backup.swap_remove(best);
+			entry.active = active.clone();
+
+			// Don't reannounce immediately — return the promoted backup so the caller
+			// can schedule a delayed reannounce (hold-down timer) to avoid churn when
+			// a cascade of closures is propagating through the network.
+			Some(active)
+		} else {
+			// No more backups, so remove the entry.
+			self.broadcast = None;
+			None
+		}
+	}
+
+	/// Announce a promoted backup if it's still the active broadcast.
+	///
+	/// Called after the hold-down delay. If a better broadcast arrived in the meantime
+	/// (via publish with fewer hops), the promoted one will no longer be active and
+	/// this is a no-op.
+	fn maybe_reannounce(&mut self, full: impl AsPath, relative: impl AsPath, promoted: &BroadcastConsumer) {
+		let full = full.as_path();
+		let relative = relative.as_path();
+
+		if let Some((dir, relative)) = relative.next_part() {
+			if let Some(nested) = self.nested.get(dir) {
+				nested.lock().maybe_reannounce(&full, &relative, promoted);
 			}
+		} else if let Some(entry) = &self.broadcast
+			&& entry.active.is_clone(promoted)
+		{
+			self.notify.lock().announce(full, &entry.active);
 		}
 	}
 
@@ -327,8 +449,12 @@ impl Default for OriginNodes {
 	}
 }
 
-/// A broadcast path and its associated consumer, or None if closed.
-pub type OriginAnnounce = (PathOwned, Option<BroadcastConsumer>);
+/// A broadcast path and its associated consumer.
+pub type OriginAnnounce = (PathOwned, BroadcastConsumer);
+
+/// A boxed future that resolves when a broadcast closes, yielding (path, broadcast).
+pub type OriginClosureFuture =
+	std::pin::Pin<Box<dyn std::future::Future<Output = (PathOwned, BroadcastConsumer)> + Send>>;
 
 /// A collection of broadcasts that can be published and subscribed to.
 pub struct Origin {}
@@ -340,8 +466,11 @@ impl Origin {
 }
 
 /// Announces broadcasts to consumers over the network.
-#[derive(Clone, Default)]
+#[derive(Clone)]
 pub struct OriginProducer {
+	/// A unique identifier for this origin.
+	id: OriginId,
+
 	// The roots of the tree that we are allowed to publish.
 	// A path of "" means we can publish anything.
 	nodes: OriginNodes,
@@ -350,31 +479,56 @@ pub struct OriginProducer {
 	root: PathOwned,
 }
 
+impl Default for OriginProducer {
+	fn default() -> Self {
+		Self {
+			id: OriginId::random(),
+			nodes: OriginNodes::default(),
+			root: PathOwned::default(),
+		}
+	}
+}
+
 impl OriginProducer {
 	pub fn new() -> Self {
 		Self::default()
 	}
 
+	/// Set the origin ID.
+	pub fn with_id(mut self, id: OriginId) -> Self {
+		self.id = id;
+		self
+	}
+
+	/// Get the origin ID.
+	pub fn id(&self) -> OriginId {
+		self.id
+	}
+
 	/// Create and publish a new broadcast, returning the producer.
 	///
 	/// This is a helper method when you only want to publish a broadcast to a single origin.
 	/// Returns [None] if the broadcast is not allowed to be published.
 	pub fn create_broadcast(&self, path: impl AsPath) -> Option<BroadcastProducer> {
-		let broadcast = Broadcast::produce();
+		let broadcast = Broadcast::new().produce();
 		self.publish_broadcast(path, broadcast.consume()).then_some(broadcast)
 	}
 
 	/// Publish a broadcast, announcing it to all consumers.
 	///
 	/// The broadcast will be unannounced when it is closed.
-	/// If there is already a broadcast with the same path, then it will be replaced and reannounced.
-	/// If the old broadcast is closed before the new one, then nothing will happen.
-	/// If the new broadcast is closed before the old one, then the old broadcast will be reannounced.
+	/// If there is already a broadcast with the same path and more hops, it will be replaced and reannounced.
+	/// If the old broadcast is closed before the new one, the new broadcast will be reannounced after a hold-down delay.
+	/// If the new broadcast is closed before the old one, then nothing will happen.
 	///
 	/// Returns false if the broadcast is not allowed to be published.
 	pub fn publish_broadcast(&self, path: impl AsPath, broadcast: BroadcastConsumer) -> bool {
 		let path = path.as_path();
 
+		if broadcast.info.hops.len() > 32 {
+			return false;
+		}
+
 		let (root, rest) = match self.nodes.get(&path) {
 			Some(root) => root,
 			None => return false,
@@ -387,7 +541,15 @@ impl OriginProducer {
 
 		web_async::spawn(async move {
 			broadcast.closed().await;
-			root.lock().remove(&full, broadcast, &rest);
+			let promoted = root.lock().remove(&full, broadcast, &rest);
+
+			if let Some(promoted) = promoted {
+				// Hold-down timer: delay the reannounce to avoid churn when a cascade
+				// of closures propagates through the network. If a better path arrives
+				// during this window, it will reannounce immediately and this becomes a no-op.
+				tokio::time::sleep(REANNOUNCE_HOLD_DOWN).await;
+				root.lock().maybe_reannounce(&full, &rest, &promoted);
+			}
 		});
 
 		true
@@ -396,8 +558,9 @@ impl OriginProducer {
 	/// Returns a new OriginProducer where all published broadcasts MUST match one of the prefixes.
 	///
 	/// Returns None if there are no legal prefixes.
-	pub fn publish_only(&self, prefixes: &[Path]) -> Option<OriginProducer> {
+	pub fn with_filter(&self, prefixes: &[Path]) -> Option<OriginProducer> {
 		Some(OriginProducer {
+			id: self.id,
 			nodes: self.nodes.select(prefixes)?,
 			root: self.root.clone(),
 		})
@@ -408,32 +571,14 @@ impl OriginProducer {
 		OriginConsumer::new(self.root.clone(), self.nodes.clone())
 	}
 
-	/// Subscribe to all announced broadcasts matching the prefix.
-	///
-	/// TODO: Don't use overlapping prefixes or duplicates will be published.
-	///
-	/// Returns None if there are no legal prefixes.
-	pub fn consume_only(&self, prefixes: &[Path]) -> Option<OriginConsumer> {
-		Some(OriginConsumer::new(self.root.clone(), self.nodes.select(prefixes)?))
-	}
-
-	/// Subscribe to a specific broadcast.
-	///
-	/// Returns None if the broadcast is not found.
-	pub fn consume_broadcast(&self, path: impl AsPath) -> Option<BroadcastConsumer> {
-		let path = path.as_path();
-		let (root, rest) = self.nodes.get(&path)?;
-		let state = root.lock();
-		state.consume_broadcast(&rest)
-	}
-
 	/// Returns a new OriginProducer that automatically strips out the provided prefix.
 	///
-	/// Returns None if the provided root is not authorized; when publish_only was already used without a wildcard.
+	/// Returns None if the provided root is not authorized; when with_filter was already used without a wildcard.
 	pub fn with_root(&self, prefix: impl AsPath) -> Option<Self> {
 		let prefix = prefix.as_path();
 
 		Some(Self {
+			id: self.id,
 			root: self.root.join(&prefix).to_owned(),
 			nodes: self.nodes.root(&prefix)?,
 		})
@@ -488,51 +633,62 @@ impl OriginConsumer {
 		}
 	}
 
-	/// Returns the next (un)announced broadcast and the absolute path.
+	/// Returns the next announced broadcast and its path relative to this consumer's root.
 	///
-	/// The broadcast will only be announced if it was previously unannounced.
-	/// The same path won't be announced/unannounced twice, instead it will toggle.
-	/// Returns None if the consumer is closed.
+	/// If the same path is announced twice, the new broadcast replaces the old one.
+	/// The old broadcast's `closed()` future will resolve when it is no longer active.
+	/// Returns `Err(Error::Dropped)` if the consumer is closed.
 	///
-	/// Note: The returned path is absolute and will always match this consumer's prefix.
-	pub async fn announced(&mut self) -> Option<OriginAnnounce> {
-		self.updates.recv().await
+	/// Note: The returned path has had this consumer's root prefix stripped.
+	pub async fn announced(&mut self) -> Result<OriginAnnounce, Error> {
+		self.updates.recv().await.ok_or(Error::Dropped)
 	}
 
-	/// Returns the next (un)announced broadcast and the absolute path without blocking.
+	/// Returns the next announced broadcast without blocking.
 	///
-	/// Returns None if there is no update available; NOT because the consumer is closed.
-	/// You have to use `is_closed` to check if the consumer is closed.
+	/// Returns None if there is no update available.
 	pub fn try_announced(&mut self) -> Option<OriginAnnounce> {
 		self.updates.try_recv().ok()
 	}
 
-	pub fn consume(&self) -> Self {
-		self.clone()
-	}
-
-	/// Get a specific broadcast by path.
-	///
-	/// TODO This should include announcement support.
+	/// Get a specific broadcast by path, returning immediately.
 	///
 	/// Returns None if the path hasn't been announced yet.
-	pub fn consume_broadcast(&self, path: impl AsPath) -> Option<BroadcastConsumer> {
+	pub fn try_consume_broadcast(&self, path: impl AsPath) -> Option<BroadcastConsumer> {
 		let path = path.as_path();
 		let (root, rest) = self.nodes.get(&path)?;
 		let state = root.lock();
 		state.consume_broadcast(&rest)
 	}
 
+	/// Get a specific broadcast by path, waiting for it to be announced if needed.
+	pub async fn consume_broadcast(&self, path: impl AsPath) -> Result<BroadcastConsumer, Error> {
+		let path = path.as_path();
+		if let Some(bc) = self.try_consume_broadcast(&path) {
+			return Ok(bc);
+		}
+		let mut scoped = self
+			.with_filter(std::slice::from_ref(&path))
+			.ok_or(Error::UnknownBroadcast)?;
+		loop {
+			let (announced_path, broadcast) = scoped.announced().await?;
+			if announced_path == path {
+				return Ok(broadcast);
+			}
+			// Skip descendant announcements that don't match the exact path.
+		}
+	}
+
 	/// Returns a new OriginConsumer that only consumes broadcasts matching one of the prefixes.
 	///
 	/// Returns None if there are no legal prefixes (would always return None).
-	pub fn consume_only(&self, prefixes: &[Path]) -> Option<OriginConsumer> {
+	pub fn with_filter(&self, prefixes: &[Path]) -> Option<OriginConsumer> {
 		Some(OriginConsumer::new(self.root.clone(), self.nodes.select(prefixes)?))
 	}
 
 	/// Returns a new OriginConsumer that automatically strips out the provided prefix.
 	///
-	/// Returns None if the provided root is not authorized; when consume_only was already used without a wildcard.
+	/// Returns None if the provided root is not authorized; when with_filter was already used without a wildcard.
 	pub fn with_root(&self, prefix: impl AsPath) -> Option<Self> {
 		let prefix = prefix.as_path();
 
@@ -575,23 +731,20 @@ use futures::FutureExt;
 impl OriginConsumer {
 	pub fn assert_next(&mut self, expected: impl AsPath, broadcast: &BroadcastConsumer) {
 		let expected = expected.as_path();
-		let (path, active) = self.announced().now_or_never().expect("next blocked").expect("no next");
+		let (path, active) = self
+			.announced()
+			.now_or_never()
+			.expect("next blocked")
+			.expect("announced returned error");
 		assert_eq!(path, expected, "wrong path");
-		assert!(active.unwrap().is_clone(broadcast), "should be the same broadcast");
+		assert!(active.is_clone(broadcast), "should be the same broadcast");
 	}
 
 	pub fn assert_try_next(&mut self, expected: impl AsPath, broadcast: &BroadcastConsumer) {
 		let expected = expected.as_path();
 		let (path, active) = self.try_announced().expect("no next");
 		assert_eq!(path, expected, "wrong path");
-		assert!(active.unwrap().is_clone(broadcast), "should be the same broadcast");
-	}
-
-	pub fn assert_next_none(&mut self, expected: impl AsPath) {
-		let expected = expected.as_path();
-		let (path, active) = self.announced().now_or_never().expect("next blocked").expect("no next");
-		assert_eq!(path, expected, "wrong path");
-		assert!(active.is_none(), "should be unannounced");
+		assert!(active.is_clone(broadcast), "should be the same broadcast");
 	}
 
 	pub fn assert_next_wait(&mut self) {
@@ -599,15 +752,6 @@ impl OriginConsumer {
 			panic!("next should block: got {:?}", res.map(|(path, _)| path));
 		}
 	}
-
-	/*
-	pub fn assert_next_closed(&mut self) {
-		assert!(
-			self.announced().now_or_never().expect("next blocked").is_none(),
-			"next should be closed"
-		);
-	}
-	*/
 }
 
 #[cfg(test)]
@@ -618,9 +762,11 @@ mod tests {
 
 	#[tokio::test]
 	async fn test_announce() {
+		tokio::time::pause();
+
 		let origin = Origin::produce();
-		let broadcast1 = Broadcast::produce();
-		let broadcast2 = Broadcast::produce();
+		let broadcast1 = Broadcast::new().produce();
+		let broadcast2 = Broadcast::new().produce();
 
 		let mut consumer1 = origin.consume();
 		// Make a new consumer that should get it.
@@ -647,46 +793,49 @@ mod tests {
 		consumer2.assert_next_wait();
 
 		// Close the first broadcast.
+		let bc1 = broadcast1.consume();
 		drop(broadcast1);
 
 		// Wait for the async task to run.
 		tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
 
-		// All consumers should get a None now.
-		consumer1.assert_next_none("test1");
-		consumer2.assert_next_none("test1");
+		// No unannounce message is sent; instead, the broadcast's closed() resolves.
+		// Verify consumers don't receive anything.
 		consumer1.assert_next_wait();
 		consumer2.assert_next_wait();
 
+		// The closed broadcast should be detected.
+		assert!(bc1.closed().now_or_never().is_some());
+
 		// And a new consumer only gets the last broadcast.
 		let mut consumer3 = origin.consume();
 		consumer3.assert_next("test2", &broadcast2.consume());
 		consumer3.assert_next_wait();
 
 		// Close the other producer and make sure it cleans up
+		let bc2 = broadcast2.consume();
 		drop(broadcast2);
 
 		// Wait for the async task to run.
 		tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
 
-		consumer1.assert_next_none("test2");
-		consumer2.assert_next_none("test2");
-		consumer3.assert_next_none("test2");
-
-		/* TODO close the origin consumer when the producer is dropped
-		consumer1.assert_next_closed();
-		consumer2.assert_next_closed();
-		consumer3.assert_next_closed();
-		*/
+		// No unannounce messages, just verify broadcasts are closed.
+		consumer1.assert_next_wait();
+		consumer2.assert_next_wait();
+		consumer3.assert_next_wait();
+		assert!(bc2.closed().now_or_never().is_some());
 	}
 
 	#[tokio::test]
 	async fn test_duplicate() {
+		tokio::time::pause();
+
 		let origin = Origin::produce();
 
-		let broadcast1 = Broadcast::produce();
-		let broadcast2 = Broadcast::produce();
-		let broadcast3 = Broadcast::produce();
+		// All same hops (0), so first becomes active, rest go to backup.
+		let broadcast1 = Broadcast::new().produce();
+		let broadcast2 = Broadcast::new().produce();
+		let broadcast3 = Broadcast::new().produce();
 
 		let consumer1 = broadcast1.consume();
 		let consumer2 = broadcast2.consume();
@@ -697,91 +846,330 @@ mod tests {
 		origin.publish_broadcast("test", consumer1.clone());
 		origin.publish_broadcast("test", consumer2.clone());
 		origin.publish_broadcast("test", consumer3.clone());
-		assert!(consumer.consume_broadcast("test").is_some());
+		assert!(consumer.try_consume_broadcast("test").is_some());
 
+		// Only the first publish triggers an announce (same hops = no reannounce).
 		consumer.assert_next("test", &consumer1);
-		consumer.assert_next_none("test");
-		consumer.assert_next("test", &consumer2);
-		consumer.assert_next_none("test");
-		consumer.assert_next("test", &consumer3);
+		consumer.assert_next_wait();
 
-		// Drop the backup, nothing should change.
+		// Drop a backup, nothing should change.
 		drop(broadcast2);
 
-		// Wait for the async task to run.
+		// Wait for the async cleanup task to run.
 		tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
 
-		assert!(consumer.consume_broadcast("test").is_some());
+		assert!(consumer.try_consume_broadcast("test").is_some());
 		consumer.assert_next_wait();
 
-		// Drop the active, we should reannounce.
-		drop(broadcast3);
+		// Drop the active — backup is promoted but reannounce is delayed (hold-down timer).
+		drop(broadcast1);
 
-		// Wait for the async task to run.
+		// Wait for the remove task to run, but not the hold-down.
 		tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
+		consumer.assert_next_wait();
 
-		assert!(consumer.consume_broadcast("test").is_some());
-		consumer.assert_next_none("test");
-		consumer.assert_next("test", &consumer1);
+		// Advance past the hold-down timer. Now the reannounce should fire.
+		tokio::time::sleep(REANNOUNCE_HOLD_DOWN + tokio::time::Duration::from_millis(1)).await;
 
-		// Drop the final broadcast, we should unannounce.
-		drop(broadcast1);
+		assert!(consumer.try_consume_broadcast("test").is_some());
+		consumer.assert_next("test", &consumer3);
+
+		// Drop the final broadcast, no more messages.
+		drop(broadcast3);
 
-		// Wait for the async task to run.
 		tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
-		assert!(consumer.consume_broadcast("test").is_none());
+		assert!(consumer.try_consume_broadcast("test").is_none());
 
-		consumer.assert_next_none("test");
+		// No unannounce message, just verify the broadcast is gone.
 		consumer.assert_next_wait();
 	}
 
 	#[tokio::test]
 	async fn test_duplicate_reverse() {
+		tokio::time::pause();
+
 		let origin = Origin::produce();
-		let broadcast1 = Broadcast::produce();
-		let broadcast2 = Broadcast::produce();
+		let broadcast1 = Broadcast::new().produce();
+		let broadcast2 = Broadcast::new().produce();
 
 		origin.publish_broadcast("test", broadcast1.consume());
 		origin.publish_broadcast("test", broadcast2.consume());
-		assert!(origin.consume_broadcast("test").is_some());
+		assert!(origin.consume().try_consume_broadcast("test").is_some());
 
 		// This is harder, dropping the new broadcast first.
 		drop(broadcast2);
 
-		// Wait for the cleanup async task to run.
 		tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
-		assert!(origin.consume_broadcast("test").is_some());
+		assert!(origin.consume().try_consume_broadcast("test").is_some());
 
 		drop(broadcast1);
 
-		// Wait for the cleanup async task to run.
 		tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
-		assert!(origin.consume_broadcast("test").is_none());
+		assert!(origin.consume().try_consume_broadcast("test").is_none());
+	}
+
+	/// Create a hops vector with `n` random OriginIds for testing.
+	/// Each call returns a completely independent set of IDs.
+	fn test_hops(n: usize) -> Vec<OriginId> {
+		(0..n).map(|_| OriginId::random()).collect()
+	}
+
+	#[tokio::test]
+	async fn test_hops_ordering() {
+		tokio::time::pause();
+
+		let origin = Origin::produce();
+
+		// Publish a broadcast with 3 hops.
+		let far = Broadcast::new().with_hops(test_hops(3)).produce();
+		let far_consumer = far.consume();
+
+		let mut consumer = origin.consume();
+
+		origin.publish_broadcast("test", far_consumer.clone());
+		consumer.assert_next("test", &far_consumer);
+		consumer.assert_next_wait();
+
+		// Now publish a closer broadcast (1 hop). It should replace the active and reannounce immediately.
+		let close = Broadcast::new().with_hops(test_hops(1)).produce();
+		let close_consumer = close.consume();
+
+		origin.publish_broadcast("test", close_consumer.clone());
+		consumer.assert_next("test", &close_consumer);
+		consumer.assert_next_wait();
+
+		// Publish a broadcast with more hops (5). Should go to backup silently.
+		let farther = Broadcast::new().with_hops(test_hops(5)).produce();
+		let farther_consumer = farther.consume();
+
+		origin.publish_broadcast("test", farther_consumer.clone());
+		consumer.assert_next_wait();
+
+		// Drop the active (1 hop). Best backup is 3 hops. Reannounce is delayed.
+		drop(close);
+		tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
+		consumer.assert_next_wait();
+
+		// After the hold-down, the 3-hop backup is reannounced.
+		tokio::time::sleep(REANNOUNCE_HOLD_DOWN + tokio::time::Duration::from_millis(1)).await;
+		consumer.assert_next("test", &far_consumer);
+
+		// Drop the 3-hop broadcast. Best backup is 5 hops. Reannounce is delayed.
+		drop(far);
+		tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
+		consumer.assert_next_wait();
+
+		tokio::time::sleep(REANNOUNCE_HOLD_DOWN + tokio::time::Duration::from_millis(1)).await;
+		consumer.assert_next("test", &farther_consumer);
+
+		// Drop the last one. No message sent.
+		drop(farther);
+		tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
+		consumer.assert_next_wait();
+	}
+
+	#[tokio::test]
+	async fn test_hops_same_no_reannounce() {
+		let origin = Origin::produce();
+
+		let b1 = Broadcast::new().with_hops(test_hops(2)).produce();
+		let b1c = b1.consume();
+
+		let mut consumer = origin.consume();
+
+		origin.publish_broadcast("test", b1c.clone());
+		consumer.assert_next("test", &b1c);
+
+		// Publish another broadcast with same hops. Should go to backup, no reannounce.
+		let b2 = Broadcast::new().with_hops(test_hops(2)).produce();
+		let _b2c = b2.consume();
+
+		origin.publish_broadcast("test", _b2c.clone());
+		consumer.assert_next_wait();
+	}
+
+	/// When the active closes and a backup is promoted, a better publish arriving
+	/// during the hold-down should reannounce immediately and cancel the delayed one.
+	#[tokio::test]
+	async fn test_hold_down_superseded_by_better_publish() {
+		tokio::time::pause();
+
+		let origin = Origin::produce();
+
+		let b1 = Broadcast::new().with_hops(test_hops(1)).produce();
+		let b1c = b1.consume();
+		let b2 = Broadcast::new().with_hops(test_hops(3)).produce();
+		let b2c = b2.consume();
+
+		let mut consumer = origin.consume();
+
+		origin.publish_broadcast("test", b1c.clone());
+		origin.publish_broadcast("test", b2c.clone());
+		consumer.assert_next("test", &b1c);
+		consumer.assert_next_wait();
+
+		// Drop the active (1 hop). Backup (3 hops) is promoted, hold-down starts.
+		drop(b1);
+		tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
+		consumer.assert_next_wait(); // No reannounce yet.
+
+		// During hold-down, a better broadcast arrives (0 hops).
+		let b3 = Broadcast::new().with_hops(test_hops(0)).produce();
+		let b3c = b3.consume();
+		origin.publish_broadcast("test", b3c.clone());
+
+		// The better broadcast reannounces immediately.
+		consumer.assert_next("test", &b3c);
+		consumer.assert_next_wait();
+
+		// After the hold-down expires, nothing happens (superseded).
+		tokio::time::sleep(REANNOUNCE_HOLD_DOWN).await;
+		consumer.assert_next_wait();
+	}
+
+	/// When the active closes and the promoted backup also closes during the hold-down,
+	/// we should unannounce immediately.
+	#[tokio::test]
+	async fn test_hold_down_backup_also_closes() {
+		tokio::time::pause();
+
+		let origin = Origin::produce();
+
+		let b1 = Broadcast::new().produce();
+		let b1c = b1.consume();
+		let b2 = Broadcast::new().produce();
+		let b2c = b2.consume();
+
+		let mut consumer = origin.consume();
+
+		origin.publish_broadcast("test", b1c.clone());
+		origin.publish_broadcast("test", b2c.clone());
+		consumer.assert_next("test", &b1c);
+		consumer.assert_next_wait();
+
+		// Drop the active. Backup promoted, hold-down starts.
+		drop(b1);
+		tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
+		consumer.assert_next_wait();
+
+		// Drop the promoted backup during the hold-down.
+		drop(b2);
+		tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
+
+		// No message sent — last broadcast gone.
+		consumer.assert_next_wait();
+		assert!(origin.consume().try_consume_broadcast("test").is_none());
+
+		// After the hold-down expires, nothing happens.
+		tokio::time::sleep(REANNOUNCE_HOLD_DOWN).await;
+		consumer.assert_next_wait();
+	}
+
+	/// Cascading closures: active closes, backup promoted, backup closes too.
+	/// The hold-down prevents churn — downstream only sees the final state.
+	#[tokio::test]
+	async fn test_hold_down_cascade() {
+		tokio::time::pause();
+
+		let origin = Origin::produce();
+
+		let b1 = Broadcast::new().with_hops(test_hops(1)).produce();
+		let b1c = b1.consume();
+		let b2 = Broadcast::new().with_hops(test_hops(2)).produce();
+		let b2c = b2.consume();
+		let b3 = Broadcast::new().with_hops(test_hops(3)).produce();
+		let b3c = b3.consume();
+
+		let mut consumer = origin.consume();
+
+		origin.publish_broadcast("test", b1c.clone());
+		origin.publish_broadcast("test", b2c.clone());
+		origin.publish_broadcast("test", b3c.clone());
+		consumer.assert_next("test", &b1c);
+		consumer.assert_next_wait();
+
+		// Drop b1 (active). b2 promoted, hold-down starts.
+		drop(b1);
+		tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
+		consumer.assert_next_wait();
+
+		// Drop b2 (promoted) during hold-down. b3 promoted, new hold-down starts.
+		drop(b2);
+		tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
+		consumer.assert_next_wait();
+
+		// After the hold-down, b3 is reannounced.
+		tokio::time::sleep(REANNOUNCE_HOLD_DOWN + tokio::time::Duration::from_millis(1)).await;
+		consumer.assert_next("test", &b3c);
+		consumer.assert_next_wait();
 	}
 
 	#[tokio::test]
 	async fn test_double_publish() {
+		tokio::time::pause();
+
 		let origin = Origin::produce();
-		let broadcast = Broadcast::produce();
+		let broadcast = Broadcast::new().produce();
 
 		// Ensure it doesn't crash.
 		origin.publish_broadcast("test", broadcast.consume());
 		origin.publish_broadcast("test", broadcast.consume());
 
-		assert!(origin.consume_broadcast("test").is_some());
+		assert!(origin.consume().try_consume_broadcast("test").is_some());
 
 		drop(broadcast);
 
-		// Wait for the async task to run.
 		tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
-		assert!(origin.consume_broadcast("test").is_none());
+		assert!(origin.consume().try_consume_broadcast("test").is_none());
 	}
+	#[tokio::test]
+	async fn test_consume_broadcast_async() {
+		use tokio::sync::oneshot;
+
+		let origin = Origin::produce();
+		let consumer = origin.consume();
+
+		let (tx, rx) = oneshot::channel();
+
+		// consume_broadcast should wait for the broadcast to appear.
+		tokio::spawn(async move {
+			let result = consumer.consume_broadcast("test").await;
+			tx.send(result).ok();
+		});
+
+		// Give the task a chance to start waiting.
+		tokio::task::yield_now().await;
+
+		// Now publish the broadcast.
+		let broadcast = Broadcast::new().produce();
+		origin.publish_broadcast("test", broadcast.consume());
+
+		// The async consume_broadcast should resolve.
+		let result = rx.await.unwrap();
+		assert!(result.is_ok());
+		assert!(result.unwrap().is_clone(&broadcast.consume()));
+	}
+
+	#[tokio::test]
+	async fn test_consume_broadcast_sync() {
+		let origin = Origin::produce();
+		let broadcast = Broadcast::new().produce();
+
+		// try_consume_broadcast returns None when not yet published.
+		let consumer = origin.consume();
+		assert!(consumer.try_consume_broadcast("test").is_none());
+
+		// After publishing, returns Some.
+		origin.publish_broadcast("test", broadcast.consume());
+		assert!(consumer.try_consume_broadcast("test").is_some());
+	}
+
 	// There was a tokio bug where only the first 127 broadcasts would be received instantly.
 	#[tokio::test]
 	#[should_panic]
 	async fn test_128() {
 		let origin = Origin::produce();
-		let broadcast = Broadcast::produce();
+		let broadcast = Broadcast::new().produce();
 
 		let mut consumer = origin.consume();
 		for i in 0..256 {
@@ -796,7 +1184,7 @@ mod tests {
 	#[tokio::test]
 	async fn test_128_fix() {
 		let origin = Origin::produce();
-		let broadcast = Broadcast::produce();
+		let broadcast = Broadcast::new().produce();
 
 		let mut consumer = origin.consume();
 		for i in 0..256 {
@@ -812,7 +1200,7 @@ mod tests {
 	#[tokio::test]
 	async fn test_with_root_basic() {
 		let origin = Origin::produce();
-		let broadcast = Broadcast::produce();
+		let broadcast = Broadcast::new().produce();
 
 		// Create a producer with root "/foo"
 		let foo_producer = origin.with_root("foo").expect("should create root");
@@ -833,7 +1221,7 @@ mod tests {
 	#[tokio::test]
 	async fn test_with_root_nested() {
 		let origin = Origin::produce();
-		let broadcast = Broadcast::produce();
+		let broadcast = Broadcast::new().produce();
 
 		// Create nested roots
 		let foo_producer = origin.with_root("foo").expect("should create foo root");
@@ -853,13 +1241,13 @@ mod tests {
 	}
 
 	#[tokio::test]
-	async fn test_publish_only_allows() {
+	async fn test_with_filter_allows() {
 		let origin = Origin::produce();
-		let broadcast = Broadcast::produce();
+		let broadcast = Broadcast::new().produce();
 
 		// Create a producer that can only publish to "allowed" paths
 		let limited_producer = origin
-			.publish_only(&["allowed/path1".into(), "allowed/path2".into()])
+			.with_filter(&["allowed/path1".into(), "allowed/path2".into()])
 			.expect("should create limited producer");
 
 		// Should be able to publish to allowed paths
@@ -874,19 +1262,19 @@ mod tests {
 	}
 
 	#[tokio::test]
-	async fn test_publish_only_empty() {
+	async fn test_with_filter_empty() {
 		let origin = Origin::produce();
 
 		// Creating a producer with no allowed paths should return None
-		assert!(origin.publish_only(&[]).is_none());
+		assert!(origin.with_filter(&[]).is_none());
 	}
 
 	#[tokio::test]
-	async fn test_consume_only_filters() {
+	async fn test_consume_with_filter() {
 		let origin = Origin::produce();
-		let broadcast1 = Broadcast::produce();
-		let broadcast2 = Broadcast::produce();
-		let broadcast3 = Broadcast::produce();
+		let broadcast1 = Broadcast::new().produce();
+		let broadcast2 = Broadcast::new().produce();
+		let broadcast3 = Broadcast::new().produce();
 
 		let mut consumer = origin.consume();
 
@@ -897,7 +1285,8 @@ mod tests {
 
 		// Create a consumer that only sees "allowed" paths
 		let mut limited_consumer = origin
-			.consume_only(&["allowed".into()])
+			.consume()
+			.with_filter(&["allowed".into()])
 			.expect("should create limited consumer");
 
 		// Should only receive broadcasts under "allowed"
@@ -912,11 +1301,11 @@ mod tests {
 	}
 
 	#[tokio::test]
-	async fn test_consume_only_multiple_prefixes() {
+	async fn test_consume_with_filter_multiple_prefixes() {
 		let origin = Origin::produce();
-		let broadcast1 = Broadcast::produce();
-		let broadcast2 = Broadcast::produce();
-		let broadcast3 = Broadcast::produce();
+		let broadcast1 = Broadcast::new().produce();
+		let broadcast2 = Broadcast::new().produce();
+		let broadcast3 = Broadcast::new().produce();
 
 		origin.publish_broadcast("foo/test", broadcast1.consume());
 		origin.publish_broadcast("bar/test", broadcast2.consume());
@@ -924,7 +1313,8 @@ mod tests {
 
 		// Consumer that only sees "foo" and "bar" paths
 		let mut limited_consumer = origin
-			.consume_only(&["foo".into(), "bar".into()])
+			.consume()
+			.with_filter(&["foo".into(), "bar".into()])
 			.expect("should create limited consumer");
 
 		limited_consumer.assert_next("foo/test", &broadcast1.consume());
@@ -933,16 +1323,16 @@ mod tests {
 	}
 
 	#[tokio::test]
-	async fn test_with_root_and_publish_only() {
+	async fn test_with_root_and_with_filter() {
 		let origin = Origin::produce();
-		let broadcast = Broadcast::produce();
+		let broadcast = Broadcast::new().produce();
 
 		// User connects to /foo root
 		let foo_producer = origin.with_root("foo").expect("should create foo root");
 
 		// Limit them to publish only to "bar" and "goop/pee" within /foo
 		let limited_producer = foo_producer
-			.publish_only(&["bar".into(), "goop/pee".into()])
+			.with_filter(&["bar".into(), "goop/pee".into()])
 			.expect("should create limited producer");
 
 		let mut consumer = origin.consume();
@@ -966,11 +1356,11 @@ mod tests {
 	}
 
 	#[tokio::test]
-	async fn test_with_root_and_consume_only() {
+	async fn test_with_root_and_consume_with_filter() {
 		let origin = Origin::produce();
-		let broadcast1 = Broadcast::produce();
-		let broadcast2 = Broadcast::produce();
-		let broadcast3 = Broadcast::produce();
+		let broadcast1 = Broadcast::new().produce();
+		let broadcast2 = Broadcast::new().produce();
+		let broadcast3 = Broadcast::new().produce();
 
 		// Publish broadcasts
 		origin.publish_broadcast("foo/bar/test", broadcast1.consume());
@@ -982,7 +1372,8 @@ mod tests {
 
 		// Create consumer limited to "bar" and "goop/pee" within /foo
 		let mut limited_consumer = foo_producer
-			.consume_only(&["bar".into(), "goop/pee".into()])
+			.consume()
+			.with_filter(&["bar".into(), "goop/pee".into()])
 			.expect("should create limited consumer");
 
 		// Should only see allowed paths (without foo prefix)
@@ -997,7 +1388,7 @@ mod tests {
 
 		// First limit the producer to specific paths
 		let limited_producer = origin
-			.publish_only(&["allowed".into()])
+			.with_filter(&["allowed".into()])
 			.expect("should create limited producer");
 
 		// Trying to create a root outside allowed paths should fail
@@ -1013,7 +1404,7 @@ mod tests {
 	#[tokio::test]
 	async fn test_wildcard_permission() {
 		let origin = Origin::produce();
-		let broadcast = Broadcast::produce();
+		let broadcast = Broadcast::new().produce();
 
 		// Producer with root access (empty string means wildcard)
 		let root_producer = origin.clone();
@@ -1030,39 +1421,40 @@ mod tests {
 	#[tokio::test]
 	async fn test_consume_broadcast_with_permissions() {
 		let origin = Origin::produce();
-		let broadcast1 = Broadcast::produce();
-		let broadcast2 = Broadcast::produce();
+		let broadcast1 = Broadcast::new().produce();
+		let broadcast2 = Broadcast::new().produce();
 
 		origin.publish_broadcast("allowed/test", broadcast1.consume());
 		origin.publish_broadcast("notallowed/test", broadcast2.consume());
 
 		// Create limited consumer
 		let limited_consumer = origin
-			.consume_only(&["allowed".into()])
+			.consume()
+			.with_filter(&["allowed".into()])
 			.expect("should create limited consumer");
 
 		// Should be able to get allowed broadcast
-		let result = limited_consumer.consume_broadcast("allowed/test");
+		let result = limited_consumer.try_consume_broadcast("allowed/test");
 		assert!(result.is_some());
 		assert!(result.unwrap().is_clone(&broadcast1.consume()));
 
 		// Should not be able to get disallowed broadcast
-		assert!(limited_consumer.consume_broadcast("notallowed/test").is_none());
+		assert!(limited_consumer.try_consume_broadcast("notallowed/test").is_none());
 
 		// Original consumer can get both
 		let consumer = origin.consume();
-		assert!(consumer.consume_broadcast("allowed/test").is_some());
-		assert!(consumer.consume_broadcast("notallowed/test").is_some());
+		assert!(consumer.try_consume_broadcast("allowed/test").is_some());
+		assert!(consumer.try_consume_broadcast("notallowed/test").is_some());
 	}
 
 	#[tokio::test]
 	async fn test_nested_paths_with_permissions() {
 		let origin = Origin::produce();
-		let broadcast = Broadcast::produce();
+		let broadcast = Broadcast::new().produce();
 
 		// Create producer limited to "a/b/c"
 		let limited_producer = origin
-			.publish_only(&["a/b/c".into()])
+			.with_filter(&["a/b/c".into()])
 			.expect("should create limited producer");
 
 		// Should be able to publish to exact path and nested paths
@@ -1079,9 +1471,9 @@ mod tests {
 	#[tokio::test]
 	async fn test_multiple_consumers_with_different_permissions() {
 		let origin = Origin::produce();
-		let broadcast1 = Broadcast::produce();
-		let broadcast2 = Broadcast::produce();
-		let broadcast3 = Broadcast::produce();
+		let broadcast1 = Broadcast::new().produce();
+		let broadcast2 = Broadcast::new().produce();
+		let broadcast3 = Broadcast::new().produce();
 
 		// Publish to different paths
 		origin.publish_broadcast("foo/test", broadcast1.consume());
@@ -1090,15 +1482,18 @@ mod tests {
 
 		// Create consumers with different permissions
 		let mut foo_consumer = origin
-			.consume_only(&["foo".into()])
+			.consume()
+			.with_filter(&["foo".into()])
 			.expect("should create foo consumer");
 
 		let mut bar_consumer = origin
-			.consume_only(&["bar".into()])
+			.consume()
+			.with_filter(&["bar".into()])
 			.expect("should create bar consumer");
 
 		let mut foobar_consumer = origin
-			.consume_only(&["foo".into(), "bar".into()])
+			.consume()
+			.with_filter(&["foo".into(), "bar".into()])
 			.expect("should create foobar consumer");
 
 		// Each consumer should only see their allowed paths
@@ -1116,22 +1511,23 @@ mod tests {
 	#[tokio::test]
 	async fn test_select_with_empty_prefix() {
 		let origin = Origin::produce();
-		let broadcast1 = Broadcast::produce();
-		let broadcast2 = Broadcast::produce();
+		let broadcast1 = Broadcast::new().produce();
+		let broadcast2 = Broadcast::new().produce();
 
 		// User with root "demo" allowed to subscribe to "worm-node" and "foobar"
 		let demo_producer = origin.with_root("demo").expect("should create demo root");
 		let limited_producer = demo_producer
-			.publish_only(&["worm-node".into(), "foobar".into()])
+			.with_filter(&["worm-node".into(), "foobar".into()])
 			.expect("should create limited producer");
 
 		// Publish some broadcasts
 		assert!(limited_producer.publish_broadcast("worm-node/test", broadcast1.consume()));
 		assert!(limited_producer.publish_broadcast("foobar/test", broadcast2.consume()));
 
-		// consume_only with empty prefix should keep the exact same "worm-node" and "foobar" nodes
+		// with_filter with empty prefix should keep the exact same "worm-node" and "foobar" nodes
 		let mut consumer = limited_producer
-			.consume_only(&["".into()])
+			.consume()
+			.with_filter(&["".into()])
 			.expect("should create consumer with empty prefix");
 
 		// Should still see both broadcasts
@@ -1143,14 +1539,14 @@ mod tests {
 	#[tokio::test]
 	async fn test_select_narrowing_scope() {
 		let origin = Origin::produce();
-		let broadcast1 = Broadcast::produce();
-		let broadcast2 = Broadcast::produce();
-		let broadcast3 = Broadcast::produce();
+		let broadcast1 = Broadcast::new().produce();
+		let broadcast2 = Broadcast::new().produce();
+		let broadcast3 = Broadcast::new().produce();
 
 		// User with root "demo" allowed to subscribe to "worm-node" and "foobar"
 		let demo_producer = origin.with_root("demo").expect("should create demo root");
 		let limited_producer = demo_producer
-			.publish_only(&["worm-node".into(), "foobar".into()])
+			.with_filter(&["worm-node".into(), "foobar".into()])
 			.expect("should create limited producer");
 
 		// Publish broadcasts at different levels
@@ -1158,9 +1554,10 @@ mod tests {
 		assert!(limited_producer.publish_broadcast("worm-node/foo", broadcast2.consume()));
 		assert!(limited_producer.publish_broadcast("foobar/bar", broadcast3.consume()));
 
-		// Test 1: consume_only("worm-node") should result in a single "" node with contents of "worm-node" ONLY
+		// Test 1: with_filter("worm-node") should result in a single "" node with contents of "worm-node" ONLY
 		let mut worm_consumer = limited_producer
-			.consume_only(&["worm-node".into()])
+			.consume()
+			.with_filter(&["worm-node".into()])
 			.expect("should create worm-node consumer");
 
 		// Should see worm-node content with paths stripped to ""
@@ -1168,9 +1565,10 @@ mod tests {
 		worm_consumer.assert_next("worm-node/foo", &broadcast2.consume());
 		worm_consumer.assert_next_wait(); // Should NOT see foobar content
 
-		// Test 2: consume_only("worm-node/foo") should result in a "" node with contents of "worm-node/foo"
+		// Test 2: with_filter("worm-node/foo") should result in a "" node with contents of "worm-node/foo"
 		let mut foo_consumer = limited_producer
-			.consume_only(&["worm-node/foo".into()])
+			.consume()
+			.with_filter(&["worm-node/foo".into()])
 			.expect("should create worm-node/foo consumer");
 
 		foo_consumer.assert_next("worm-node/foo", &broadcast2.consume());
@@ -1180,13 +1578,13 @@ mod tests {
 	#[tokio::test]
 	async fn test_select_multiple_roots_with_empty_prefix() {
 		let origin = Origin::produce();
-		let broadcast1 = Broadcast::produce();
-		let broadcast2 = Broadcast::produce();
-		let broadcast3 = Broadcast::produce();
+		let broadcast1 = Broadcast::new().produce();
+		let broadcast2 = Broadcast::new().produce();
+		let broadcast3 = Broadcast::new().produce();
 
 		// Producer with multiple allowed roots
 		let limited_producer = origin
-			.publish_only(&["app1".into(), "app2".into(), "shared".into()])
+			.with_filter(&["app1".into(), "app2".into(), "shared".into()])
 			.expect("should create limited producer");
 
 		// Publish to each root
@@ -1194,9 +1592,10 @@ mod tests {
 		assert!(limited_producer.publish_broadcast("app2/config", broadcast2.consume()));
 		assert!(limited_producer.publish_broadcast("shared/resource", broadcast3.consume()));
 
-		// consume_only with empty prefix should maintain all roots
+		// with_filter with empty prefix should maintain all roots
 		let mut consumer = limited_producer
-			.consume_only(&["".into()])
+			.consume()
+			.with_filter(&["".into()])
 			.expect("should create consumer with empty prefix");
 
 		// Should see all broadcasts from all roots
@@ -1207,18 +1606,18 @@ mod tests {
 	}
 
 	#[tokio::test]
-	async fn test_publish_only_with_empty_prefix() {
+	async fn test_with_filter_with_empty_prefix() {
 		let origin = Origin::produce();
-		let broadcast = Broadcast::produce();
+		let broadcast = Broadcast::new().produce();
 
 		// Producer with specific allowed paths
 		let limited_producer = origin
-			.publish_only(&["services/api".into(), "services/web".into()])
+			.with_filter(&["services/api".into(), "services/web".into()])
 			.expect("should create limited producer");
 
-		// publish_only with empty prefix should keep the same restrictions
+		// with_filter with empty prefix should keep the same restrictions
 		let same_producer = limited_producer
-			.publish_only(&["".into()])
+			.with_filter(&["".into()])
 			.expect("should create producer with empty prefix");
 
 		// Should still have the same publishing restrictions
@@ -1231,13 +1630,13 @@ mod tests {
 	#[tokio::test]
 	async fn test_select_narrowing_to_deeper_path() {
 		let origin = Origin::produce();
-		let broadcast1 = Broadcast::produce();
-		let broadcast2 = Broadcast::produce();
-		let broadcast3 = Broadcast::produce();
+		let broadcast1 = Broadcast::new().produce();
+		let broadcast2 = Broadcast::new().produce();
+		let broadcast3 = Broadcast::new().produce();
 
 		// Producer with broad permission
 		let limited_producer = origin
-			.publish_only(&["org".into()])
+			.with_filter(&["org".into()])
 			.expect("should create limited producer");
 
 		// Publish at various depths
@@ -1247,7 +1646,8 @@ mod tests {
 
 		// Narrow down to team2 only
 		let mut team2_consumer = limited_producer
-			.consume_only(&["org/team2".into()])
+			.consume()
+			.with_filter(&["org/team2".into()])
 			.expect("should create team2 consumer");
 
 		team2_consumer.assert_next("org/team2/project1", &broadcast3.consume());
@@ -1255,7 +1655,8 @@ mod tests {
 
 		// Further narrow down to team1/project1
 		let mut project1_consumer = limited_producer
-			.consume_only(&["org/team1/project1".into()])
+			.consume()
+			.with_filter(&["org/team1/project1".into()])
 			.expect("should create project1 consumer");
 
 		// Should only see project1 content at root
@@ -1269,14 +1670,19 @@ mod tests {
 
 		// Producer with specific allowed paths
 		let limited_producer = origin
-			.publish_only(&["allowed/path".into()])
+			.with_filter(&["allowed/path".into()])
 			.expect("should create limited producer");
 
-		// Trying to consume_only with a completely different prefix should return None
-		assert!(limited_producer.consume_only(&["different/path".into()]).is_none());
+		// Trying to with_filter with a completely different prefix should return None (consumer)
+		assert!(
+			limited_producer
+				.consume()
+				.with_filter(&["different/path".into()])
+				.is_none()
+		);
 
-		// Similarly for publish_only
-		assert!(limited_producer.publish_only(&["other/path".into()]).is_none());
+		// Similarly for with_filter (producer)
+		assert!(limited_producer.with_filter(&["other/path".into()]).is_none());
 	}
 
 	// Regression test for https://github.com/moq-dev/moq/issues/910
@@ -1308,45 +1714,50 @@ mod tests {
 		consumer.assert_next("test", &b.consume());
 	}
 
-	// Verify unannounce also doesn't panic with trailing slash
+	// Verify close doesn't panic with trailing slash
 	#[tokio::test]
-	async fn test_with_root_trailing_slash_unannounce() {
+	async fn test_with_root_trailing_slash_close() {
+		tokio::time::pause();
+
 		let origin = Origin::produce();
 
 		let prefix = "some_prefix/".to_string();
 		let mut consumer = origin.consume().with_root(prefix).unwrap();
 
 		let b = origin.create_broadcast("some_prefix/test").unwrap();
-		consumer.assert_next("test", &b.consume());
+		let bc = b.consume();
+		consumer.assert_next("test", &bc);
 
-		// Drop the broadcast producer to trigger unannounce
+		// Drop the broadcast producer to trigger close
 		drop(b);
 		tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
 
-		// unannounce also calls strip_prefix(&self.root).unwrap()
-		consumer.assert_next_none("test");
+		// No unannounce message, just verify the broadcast is closed.
+		consumer.assert_next_wait();
+		assert!(bc.closed().now_or_never().is_some());
 	}
 
 	#[tokio::test]
 	async fn test_select_maintains_access_with_wider_prefix() {
 		let origin = Origin::produce();
-		let broadcast1 = Broadcast::produce();
-		let broadcast2 = Broadcast::produce();
+		let broadcast1 = Broadcast::new().produce();
+		let broadcast2 = Broadcast::new().produce();
 
 		// Setup: user with root "demo" allowed to subscribe to specific paths
 		let demo_producer = origin.with_root("demo").expect("should create demo root");
 		let user_producer = demo_producer
-			.publish_only(&["worm-node".into(), "foobar".into()])
+			.with_filter(&["worm-node".into(), "foobar".into()])
 			.expect("should create user producer");
 
 		// Publish some data
 		assert!(user_producer.publish_broadcast("worm-node/data", broadcast1.consume()));
 		assert!(user_producer.publish_broadcast("foobar", broadcast2.consume()));
 
-		// Key test: consume_only with "" should maintain access to allowed roots
+		// Key test: with_filter with "" should maintain access to allowed roots
 		let mut consumer = user_producer
-			.consume_only(&["".into()])
-			.expect("consume_only with empty prefix should not fail when user has specific permissions");
+			.consume()
+			.with_filter(&["".into()])
+			.expect("with_filter with empty prefix should not fail when user has specific permissions");
 
 		// Should still receive broadcasts from allowed paths
 		consumer.assert_next("worm-node/data", &broadcast1.consume());
@@ -1355,7 +1766,8 @@ mod tests {
 
 		// Also test that we can still narrow the scope
 		let mut narrow_consumer = user_producer
-			.consume_only(&["worm-node".into()])
+			.consume()
+			.with_filter(&["worm-node".into()])
 			.expect("should be able to narrow scope to worm-node");
 
 		narrow_consumer.assert_next("worm-node/data", &broadcast1.consume());
diff --git a/rs/moq-lite/src/model/track.rs b/rs/moq-lite/src/model/track.rs
index d5baa2634..c9e4375d1 100644
--- a/rs/moq-lite/src/model/track.rs
+++ b/rs/moq-lite/src/model/track.rs
@@ -26,20 +26,16 @@ use std::{
 // TODO: Replace with a configurable cache size.
 const MAX_GROUP_AGE: Duration = Duration::from_secs(30);
 
-/// A track is a collection of groups, delivered out-of-order until expired.
-#[derive(Clone, Debug, PartialEq, Eq)]
+/// A track is a collection of groups, identified by name.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Track {
 	pub name: String,
-	pub priority: u8,
 }
 
 impl Track {
 	pub fn new<T: Into<String>>(name: T) -> Self {
-		Self {
-			name: name.into(),
-			priority: 0,
-		}
+		Self { name: name.into() }
 	}
 
 	pub fn produce(self) -> TrackProducer {
@@ -47,6 +43,23 @@ impl Track {
 	}
 }
 
+/// Subscription preferences for a subscription or producer cap.
+///
+/// Describes how groups should be delivered: priority, ordering, latency bounds,
+/// and the range of groups requested.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct Subscription {
+	pub priority: u8,
+	pub ordered: bool,
+	/// Maximum cache/latency. `Duration::ZERO` means unlimited.
+	pub max_latency: Duration,
+	/// First group sequence to deliver. `None` means no preference.
+	/// Use [`TrackSubscriber::update`] to set a concrete value once `latest()` is known.
+	pub start: Option<u64>,
+	/// Last group sequence to deliver. `None` means no preference (live).
+	pub end: Option<u64>,
+}
+
 #[derive(Default)]
 struct State {
 	/// Groups in arrival order. `None` entries are tombstones for evicted groups.
@@ -56,13 +69,16 @@ struct State {
 	max_sequence: Option<u64>,
 	final_sequence: Option<u64>,
 	abort: Option<Error>,
+
+	/// Per-subscriber subscription values, read by the producer for aggregation.
+	subscriptions: Vec<conducer::Consumer<Subscription>>,
 }
 
 impl State {
 	/// Find the next non-tombstoned group at or after `index`.
 	///
 	/// Returns the group and its absolute index so the consumer can advance past it.
-	fn poll_next_group(&self, index: usize, min_sequence: u64) -> Poll<Result<Option<(GroupConsumer, usize)>>> {
+	fn poll_recv_group(&self, index: usize, min_sequence: u64) -> Poll<Result<Option<(GroupConsumer, usize)>>> {
 		let start = index.saturating_sub(self.offset);
 		for (i, slot) in self.groups.iter().enumerate().skip(start) {
 			if let Some((group, _)) = slot
@@ -143,6 +159,83 @@ impl State {
 		}
 	}
 
+	/// Compute the aggregate subscription from all active (non-closed) subscribers.
+	///
+	/// Aggregation rules:
+	/// - `priority`: max across all subscribers (highest-priority wins).
+	/// - `ordered`: AND of all subscribers (true only if every subscriber requests ordered).
+	/// - `max_latency`: max across subscribers, with `Duration::ZERO` meaning unlimited (ZERO wins).
+	/// - `start`/`end`: min/max of concrete values; `None` means no preference (deferred to others).
+	///
+	/// Returns `None` if there are no active subscriptions.
+	fn subscription(&self) -> Option<Subscription> {
+		if self.subscriptions.is_empty() {
+			return None;
+		}
+
+		// Read each subscriber's current subscription value into owned copies.
+		let subs: Vec<Subscription> = self
+			.subscriptions
+			.iter()
+			.filter_map(|c| {
+				let r = c.read();
+				if r.is_closed() { None } else { Some(r.clone()) }
+			})
+			.collect();
+
+		if subs.is_empty() {
+			return None;
+		}
+
+		let priority = subs.iter().map(|s| s.priority).max().unwrap();
+
+		// ordered is true only if ALL subscribers want ordered.
+		let ordered = subs.iter().all(|s| s.ordered);
+
+		// max_latency: max across subscriptions. ZERO = unlimited wins.
+		let max_latency = subs
+			.iter()
+			.map(|s| s.max_latency)
+			.reduce(|a, b| {
+				if a.is_zero() || b.is_zero() {
+					Duration::ZERO
+				} else {
+					a.max(b)
+				}
+			})
+			.unwrap();
+
+		// start: min across all concrete values. None = no preference (defer to others).
+		let start = subs
+			.iter()
+			.map(|s| s.start)
+			.reduce(|a, b| match (a, b) {
+				(Some(a), Some(b)) => Some(a.min(b)),
+				(Some(a), None) | (None, Some(a)) => Some(a),
+				(None, None) => None,
+			})
+			.unwrap();
+
+		// end: max across all concrete values. None = no end (defer to others).
+		let end = subs
+			.iter()
+			.map(|s| s.end)
+			.reduce(|a, b| match (a, b) {
+				(Some(a), Some(b)) => Some(a.max(b)),
+				(Some(a), None) | (None, Some(a)) => Some(a),
+				(None, None) => None,
+			})
+			.unwrap();
+
+		Some(Subscription {
+			priority,
+			ordered,
+			max_latency,
+			start,
+			end,
+		})
+	}
+
 	fn poll_finished(&self) -> Poll<Result<u64>> {
 		if let Some(fin) = self.final_sequence {
 			Poll::Ready(Ok(fin))
@@ -152,12 +245,26 @@ impl State {
 			Poll::Pending
 		}
 	}
+
+	/// Check if the track is "ready" for a subscriber: has at least one group,
+	/// is finished (with 0+ groups), or is aborted.
+	fn poll_ready(&self) -> Poll<Result<()>> {
+		if self.max_sequence.is_some() || self.final_sequence.is_some() {
+			Poll::Ready(Ok(()))
+		} else if let Some(err) = &self.abort {
+			Poll::Ready(Err(err.clone()))
+		} else {
+			Poll::Pending
+		}
+	}
 }
 
 /// A producer for a track, used to create new groups.
 pub struct TrackProducer {
 	pub info: Track,
 	state: conducer::Producer<State>,
+	/// The last aggregate subscription returned by [`Self::subscription`].
+	prev_subscription: Option<Subscription>,
 }
 
 impl TrackProducer {
@@ -165,10 +272,15 @@ impl TrackProducer {
 		Self {
 			info,
 			state: conducer::Producer::default(),
+			prev_subscription: None,
 		}
 	}
 
 	/// Create a new group with the given sequence number.
+	///
+	/// If a group with the same sequence already exists but was aborted (e.g. due to a
+	/// cancelled subscription), it will be replaced with a tombstone and the new group
+	/// pushed to the end. Successfully completed groups return `Err(Error::Duplicate)`.
 	pub fn create_group(&mut self, info: Group) -> Result<GroupProducer> {
 		let group = info.produce();
 
@@ -180,7 +292,25 @@ impl TrackProducer {
 		}
 
 		if !state.duplicates.insert(group.info.sequence) {
-			return Err(Error::Duplicate);
+			// Sequence exists -- check if the existing group was aborted.
+			for slot in state.groups.iter_mut() {
+				if let Some((existing, _)) = slot {
+					if existing.info.sequence == group.info.sequence {
+						if !existing.is_aborted() {
+							return Err(Error::Duplicate);
+						}
+						// Tombstone the old entry and push the new group at the end.
+						*slot = None;
+						break;
+					}
+				}
+			}
+
+			let now = tokio::time::Instant::now();
+			state.max_sequence = Some(state.max_sequence.unwrap_or(0).max(group.info.sequence));
+			state.groups.push_back(Some((group.clone(), now)));
+			state.evict_expired(now);
+			return Ok(group);
 		}
 
 		let now = tokio::time::Instant::now();
@@ -285,8 +415,6 @@ impl TrackProducer {
 		TrackConsumer {
 			info: self.info.clone(),
 			state: self.state.consume(),
-			index: 0,
-			min_sequence: 0,
 		}
 	}
 
@@ -316,6 +444,49 @@ impl TrackProducer {
 		}
 	}
 
+	/// Poll for changes to the aggregate subscription.
+	///
+	/// Returns `Ready(sub)` when the aggregate differs from the last value returned.
+	/// Returns `Ready(None)` when no subscriptions are active (or the track is closed).
+	pub fn poll_subscription(&mut self, waiter: &conducer::Waiter) -> Poll<Option<Subscription>> {
+		let prev = self.prev_subscription.as_ref();
+		match self.state.poll(waiter, |state| {
+			// Remove closed subscription consumers.
+			state.subscriptions.retain(|c| !c.read().is_closed());
+
+			// Also poll each subscription consumer so the waiter is registered
+			// on inner changes too.
+			for sub in &state.subscriptions {
+				// Register the waiter on each subscription's conducer channel.
+				let _ = sub.poll(waiter, |_| Poll::<()>::Pending);
+			}
+
+			let current = state.subscription();
+			if current.as_ref() != prev {
+				Poll::Ready(current)
+			} else {
+				Poll::Pending
+			}
+		}) {
+			Poll::Ready(Ok(sub)) => {
+				self.prev_subscription = sub.clone();
+				Poll::Ready(sub)
+			}
+			Poll::Ready(Err(_)) => {
+				self.prev_subscription = None;
+				Poll::Ready(None)
+			}
+			Poll::Pending => Poll::Pending,
+		}
+	}
+
+	/// Block until the aggregate subscription changes.
+	///
+	/// Returns `None` when all subscriptions are dropped or the track is closed.
+	pub async fn subscription(&mut self) -> Option<Subscription> {
+		conducer::wait(|waiter| self.poll_subscription(waiter)).await
+	}
+
 	fn modify(&self) -> Result<conducer::Mut<'_, State>> {
 		self.state
 			.write()
@@ -328,13 +499,14 @@ impl Clone for TrackProducer {
 		Self {
 			info: self.info.clone(),
 			state: self.state.clone(),
+			prev_subscription: self.prev_subscription.clone(),
 		}
 	}
 }
 
-impl From<Track> for TrackProducer {
-	fn from(info: Track) -> Self {
-		TrackProducer::new(info)
+impl<T: Into<Track>> From<T> for TrackProducer {
+	fn from(info: T) -> Self {
+		TrackProducer::new(info.into())
 	}
 }
 
@@ -366,20 +538,142 @@ impl TrackWeak {
 		TrackConsumer {
 			info: self.info.clone(),
 			state: self.state.consume(),
-			index: 0,
-			min_sequence: 0,
 		}
 	}
+}
 
-	pub async fn unused(&self) -> crate::Result<()> {
-		self.state
-			.unused()
-			.await
-			.map_err(|r| r.abort.clone().unwrap_or(Error::Dropped))
+/// Iterates groups from a track while managing this subscriber's subscription lifecycle.
+///
+/// Created via [`TrackConsumer::subscribe`]. Registers a subscription in the
+/// shared state on creation; automatically removes it on drop.
+/// Blocks in `subscribe()` until the first group exists (or finish/abort).
+pub struct TrackSubscriber {
+	pub info: Track,
+	state: conducer::Consumer<State>,
+	sub: conducer::Producer<Subscription>,
+	index: usize,
+
+	// The next largest sequence number that we want to return for next_group
+	next: u64,
+}
+
+impl TrackSubscriber {
+	/// Poll whether the track is "ready": has at least one group, is finished, or aborted.
+	pub fn poll_ready(&self, waiter: &conducer::Waiter) -> Poll<Result<()>> {
+		self.poll(waiter, |state| state.poll_ready())
 	}
 
-	pub fn is_clone(&self, other: &Self) -> bool {
-		self.state.same_channel(&other.state)
+	/// Wait until the track is ready (has at least one group, is finished, or aborted).
+	pub async fn ready(&self) -> Result<()> {
+		conducer::wait(|waiter| self.poll_ready(waiter)).await
+	}
+
+	/// A group respecting the subscription start/end range.
+	///
+	/// NOTE: This may not be sequential, as groups are delivered out of order.
+	/// Use [Self::next_group] to only receive newer groups.
+	pub async fn recv_group(&mut self) -> Result<Option<GroupConsumer>> {
+		conducer::wait(|waiter| self.poll_recv_group(waiter)).await
+	}
+
+	pub fn poll_recv_group(&mut self, waiter: &conducer::Waiter) -> Poll<Result<Option<GroupConsumer>>> {
+		let sub = self.sub.read();
+		let min_sequence = sub.start.unwrap_or(0);
+		let end = sub.end;
+		drop(sub);
+
+		let Some((consumer, found_index)) =
+			ready!(self.poll(waiter, |state| { state.poll_recv_group(self.index, min_sequence) })?)
+		else {
+			return Poll::Ready(Ok(None));
+		};
+
+		// Check end bound.
+		if let Some(end) = end {
+			if consumer.info.sequence > end {
+				return Poll::Ready(Ok(None));
+			}
+		}
+
+		self.index = found_index + 1;
+		self.next = consumer.info.sequence + 1;
+
+		Poll::Ready(Ok(Some(consumer)))
+	}
+
+	pub async fn next_group(&mut self) -> Result<Option<GroupConsumer>> {
+		conducer::wait(|waiter| self.poll_recv_group(waiter)).await
+	}
+
+	pub fn poll_next_group(&mut self, waiter: &conducer::Waiter) -> Poll<Result<Option<GroupConsumer>>> {
+		let sub = self.sub.read();
+		let min_sequence = self.next.max(sub.start.unwrap_or(0));
+		let end = sub.end;
+		drop(sub);
+
+		let Some((consumer, found_index)) =
+			ready!(self.poll(waiter, |state| { state.poll_recv_group(self.index, min_sequence) })?)
+		else {
+			return Poll::Ready(Ok(None));
+		};
+
+		// Check end bound.
+		if let Some(end) = end {
+			if consumer.info.sequence > end {
+				return Poll::Ready(Ok(None));
+			}
+		}
+
+		self.index = found_index + 1;
+		self.next = consumer.info.sequence + 1;
+
+		Poll::Ready(Ok(Some(consumer)))
+	}
+
+	/// Update this subscription's preferences.
+	pub fn update(&mut self, sub: Subscription) {
+		if let Ok(mut guard) = self.sub.write() {
+			*guard = sub;
+		}
+	}
+
+	/// Return the latest sequence number in the track.
+	pub fn latest(&self) -> Option<u64> {
+		self.state.read().max_sequence
+	}
+
+	/// The current subscription preferences.
+	pub fn subscription(&self) -> Subscription {
+		self.sub.read().clone()
+	}
+
+	/// Poll for track closure, without blocking.
+	pub fn poll_closed(&self, waiter: &conducer::Waiter) -> Poll<Result<()>> {
+		self.poll(waiter, |state| state.poll_closed())
+	}
+
+	/// Block until the track is closed.
+	pub async fn closed(&self) -> Result<()> {
+		conducer::wait(|waiter| self.poll_closed(waiter)).await
+	}
+
+	// A helper to automatically apply Dropped if the state is closed without an error.
+	fn poll<F, R>(&self, waiter: &conducer::Waiter, f: F) -> Poll<Result<R>>
+	where
+		F: Fn(&conducer::Ref<'_, State>) -> Poll<Result<R>>,
+	{
+		Poll::Ready(match ready!(self.state.poll(waiter, f)) {
+			Ok(res) => res,
+			Err(state) => Err(state.abort.clone().unwrap_or(Error::Dropped)),
+		})
+	}
+}
+
+impl Drop for TrackSubscriber {
+	fn drop(&mut self) {
+		// Close the subscription producer so the TrackProducer knows to remove it.
+		// The producer's poll_subscription will clean up closed consumers.
+		let _ = self.sub.close();
 	}
 }
 
@@ -388,9 +682,6 @@ impl TrackWeak {
 pub struct TrackConsumer {
 	pub info: Track,
 	state: conducer::Consumer<State>,
-	index: usize,
-
-	min_sequence: u64,
 }
 
 impl TrackConsumer {
@@ -406,28 +697,16 @@ impl TrackConsumer {
 		})
 	}
 
-	/// Poll for the next group without blocking.
-	///
-	/// Returns `Poll::Ready(Ok(Some(group)))` when a group is available,
-	/// `Poll::Ready(Ok(None))` when the track is finished,
-	/// `Poll::Ready(Err(e))` when the track has been aborted, or
-	/// `Poll::Pending` when no group is available yet.
-	pub fn poll_next_group(&mut self, waiter: &conducer::Waiter) -> Poll<Result<Option<GroupConsumer>>> {
-		let Some((consumer, found_index)) =
-			ready!(self.poll(waiter, |state| state.poll_next_group(self.index, self.min_sequence))?)
-		else {
-			return Poll::Ready(Ok(None));
-		};
-
-		self.index = found_index + 1;
-		Poll::Ready(Ok(Some(consumer)))
+	/// Removed: Use [`TrackSubscriber::recv_group`] instead.
+	#[deprecated(note = "Use TrackSubscriber::recv_group instead")]
+	pub async fn next_group(&mut self) -> Result<Option<GroupConsumer>> {
+		unimplemented!("Use TrackSubscriber::recv_group instead")
 	}
 
-	/// Return the next group in order.
-	///
-	/// NOTE: This can have gaps if the reader is too slow or there were network slowdowns.
-	pub async fn next_group(&mut self) -> Result<Option<GroupConsumer>> {
-		conducer::wait(|waiter| self.poll_next_group(waiter)).await
+	/// Removed: Use [`TrackSubscriber::poll_recv_group`] instead.
+	#[deprecated(note = "Use TrackSubscriber::poll_recv_group instead")]
+	pub fn poll_next_group(&mut self, _waiter: &conducer::Waiter) -> Poll<Result<Option<GroupConsumer>>> {
+		unimplemented!("Use TrackSubscriber::poll_recv_group instead")
 	}
 
 	/// Poll for the group with the given sequence, without blocking.
@@ -468,9 +747,43 @@ impl TrackConsumer {
 		conducer::wait(|waiter| self.poll_finished(waiter)).await
 	}
 
-	/// Start the consumer at the specified sequence.
-	pub fn start_at(&mut self, sequence: u64) {
-		self.min_sequence = sequence;
+	/// Register a subscription and return a [`TrackSubscriber`] immediately.
+	///
+	/// The subscriber can be used right away, but callers may want to call
+	/// [`TrackSubscriber::ready`] or poll [`TrackSubscriber::poll_ready`] to
+	/// wait until the first group exists (or finish/abort).
+	///
+	/// Dropping the subscriber removes the subscription from the aggregate.
+	pub fn subscribe(&self, sub: Subscription) -> Result<TrackSubscriber> {
+		// Create a conducer channel for this subscription's preferences.
+		let sub_producer = conducer::Producer::new(sub);
+		let sub_consumer = sub_producer.consume();
+
+		{
+			// Use weak write access to insert the subscription consumer.
+			// If the channel is closed (track finished/dropped), skip — the subscriber
+			// can still read existing groups without an active subscription.
+			let weak = self.state.weak();
+			if let Ok(mut state) = weak.write() {
+				state.subscriptions.push(sub_consumer);
+			}
+		}
+
+		Ok(TrackSubscriber {
+			info: self.info.clone(),
+			state: self.state.clone(),
+			sub: sub_producer,
+			index: 0,
+			next: 0,
+		})
+	}
+
+	/// Create a weak reference that doesn't prevent auto-close.
+	pub(crate) fn weak(&self) -> TrackWeak {
+		TrackWeak {
+			info: self.info.clone(),
+			state: self.state.weak(),
+		}
 	}
 
 	/// Return the latest sequence number in the track.
@@ -483,6 +796,7 @@ impl TrackConsumer {
 use futures::FutureExt;
 
 #[cfg(test)]
+#[allow(deprecated)]
 impl TrackConsumer {
 	pub fn assert_group(&mut self) -> GroupConsumer {
 		self.next_group()
@@ -495,7 +809,7 @@ impl TrackConsumer {
 	pub fn assert_no_group(&mut self) {
 		assert!(
 			self.next_group().now_or_never().is_none(),
-			"next group would not have blocked"
+			"next_group would not have blocked"
 		);
 	}
 
@@ -522,6 +836,11 @@ impl TrackConsumer {
 	pub fn assert_not_clone(&self, other: &Self) {
 		assert!(!self.is_clone(other), "should not be clone");
 	}
+
+	pub fn assert_subscribe(&self) -> TrackSubscriber {
+		self.subscribe(Subscription::default())
+			.expect("subscribe should not have errored")
+	}
 }
 
 #[cfg(test)]
@@ -613,19 +932,20 @@ mod test {
 	}
 
 	#[tokio::test]
-	async fn consumer_skips_evicted_groups() {
+	async fn subscriber_skips_evicted_groups() {
 		tokio::time::pause();
 
 		let mut producer = Track::new("test").produce();
 		producer.append_group().unwrap(); // seq 0
 
-		let mut consumer = producer.consume();
+		let consumer = producer.consume();
+		let mut subscriber = consumer.subscribe(Subscription::default()).unwrap();
 
 		tokio::time::advance(MAX_GROUP_AGE + Duration::from_secs(1)).await;
 		producer.append_group().unwrap(); // seq 1
 
-		// Group 0 was evicted. Consumer should get group 1.
-		let group = consumer.assert_group();
+		// Group 0 was evicted. Subscriber should get group 1.
+		let group = subscriber.recv_group().now_or_never().unwrap().unwrap().unwrap();
 		assert_eq!(group.info.sequence, 1);
 	}
 
@@ -706,10 +1026,11 @@ mod test {
 			assert!(state.duplicates.contains(&2));
 		}
 
-		// Consumer should still be able to read through the hole.
-		let mut consumer = producer.consume();
-		let group = consumer.assert_group();
-		// consume() starts at index 0, first non-tombstoned group is seq 5.
+		// Subscriber should still be able to read through the hole.
+		let consumer = producer.consume();
+		let mut subscriber = consumer.subscribe(Subscription::default()).unwrap();
+		let group = subscriber.recv_group().now_or_never().unwrap().unwrap().unwrap();
+		// subscribe() starts at index 0, first non-tombstoned group is seq 5.
 		assert_eq!(group.info.sequence, 5);
 	}
 
@@ -753,16 +1074,27 @@ mod test {
 	}
 
 	#[tokio::test]
-	async fn next_group_finishes_without_waiting_for_gaps() {
+	async fn recv_group_finishes_without_waiting_for_gaps() {
 		let mut producer = Track::new("test").produce();
 		producer.create_group(Group { sequence: 1 }).unwrap();
 		producer.finish_at(1).unwrap();
 
-		let mut consumer = producer.consume();
-		assert_eq!(consumer.assert_group().info.sequence, 1);
+		let consumer = producer.consume();
+		let mut subscriber = consumer.subscribe(Subscription::default()).unwrap();
+		assert_eq!(
+			subscriber
+				.recv_group()
+				.now_or_never()
+				.expect("should not block")
+				.expect("would have errored")
+				.expect("track was closed")
+				.info
+				.sequence,
+			1
+		);
 
-		let done = consumer
-			.next_group()
+		let done = subscriber
+			.recv_group()
 			.now_or_never()
 			.expect("should not block")
 			.expect("would have errored");
@@ -802,4 +1134,134 @@ mod test {
 
 		assert!(matches!(producer.append_group(), Err(Error::BoundsExceeded)));
 	}
+
+	#[tokio::test]
+	async fn create_group_replaces_aborted() {
+		let mut producer = Track::new("test").produce();
+
+		// Create and abort a group.
+		let mut group = producer.create_group(Group { sequence: 5 }).unwrap();
+		group.abort(Error::Cancel).unwrap();
+
+		// Creating the same group again should succeed (replaces aborted).
+		let group2 = producer.create_group(Group { sequence: 5 });
+		assert!(group2.is_ok(), "should replace aborted group");
+
+		// Creating again on a non-aborted group should fail.
+		let group3 = producer.create_group(Group { sequence: 5 });
+		assert!(
+			matches!(group3, Err(Error::Duplicate)),
+			"should not replace active group"
+		);
+	}
+
+	#[tokio::test]
+	async fn create_group_does_not_replace_finished() {
+		let mut producer = Track::new("test").produce();
+
+		// Create and finish a group.
+		let mut group = producer.create_group(Group { sequence: 5 }).unwrap();
+		group.finish().unwrap();
+
+		// Should fail because the group finished successfully.
+		let result = producer.create_group(Group { sequence: 5 });
+		assert!(matches!(result, Err(Error::Duplicate)));
+	}
+
+	#[tokio::test]
+	async fn subscribe_unblocks_on_first_group() {
+		let mut producer = Track::new("test").produce();
+		let consumer = producer.consume();
+
+		// ready() blocks until a group exists.
+		let handle = tokio::spawn(async move {
+			let sub = consumer.subscribe(Subscription::default()).unwrap();
+			sub.ready().await?;
+			Ok::<_, Error>(sub)
+		});
+
+		// Yield to let ready() start waiting.
+		tokio::task::yield_now().await;
+
+		// Write a group to unblock ready().
+		producer.append_group().unwrap();
+
+		let subscriber = handle.await.unwrap().unwrap();
+		assert_eq!(subscriber.latest(), Some(0));
+	}
+
+	#[tokio::test]
+	async fn subscribe_unblocks_on_finish() {
+		let mut producer = Track::new("test").produce();
+		let consumer = producer.consume();
+
+		let handle = tokio::spawn(async move {
+			let sub = consumer.subscribe(Subscription::default()).unwrap();
+			sub.ready().await?;
+			Ok::<_, Error>(sub)
+		});
+
+		tokio::task::yield_now().await;
+
+		// Finishing without any groups should also unblock ready().
+		producer.finish().unwrap();
+
+		let subscriber = handle.await.unwrap().unwrap();
+		assert!(subscriber.latest().is_none());
+	}
+
+	#[tokio::test]
+	async fn subscribe_unblocks_on_abort() {
+		let mut producer = Track::new("test").produce();
+		let consumer = producer.consume();
+
+		let handle = tokio::spawn(async move {
+			let sub = consumer.subscribe(Subscription::default()).unwrap();
+			sub.ready().await
+		});
+
+		tokio::task::yield_now().await;
+
+		// Aborting should unblock ready() with an error.
+		producer.abort(Error::Cancel).unwrap();
+
+		let result = handle.await.unwrap();
+		assert!(result.is_err(), "ready() should return error on abort");
+	}
+
+	#[tokio::test]
+	async fn subscribe_returns_immediately_if_group_exists() {
+		let mut producer = Track::new("test").produce();
+		producer.append_group().unwrap();
+
+		let consumer = producer.consume();
+
+		// subscribe is sync now; ready() should not block since a group already exists.
+		let subscriber = consumer.subscribe(Subscription::default()).expect("should not error");
+		subscriber
+			.ready()
+			.now_or_never()
+			.expect("should not block")
+			.expect("should not error");
+
+		assert_eq!(subscriber.latest(), Some(0));
+	}
+
+	#[tokio::test]
+	async fn subscribe_returns_immediately_if_finished() {
+		let mut producer = Track::new("test").produce();
+		producer.finish().unwrap();
+
+		let consumer = producer.consume();
+
+		// subscribe is sync now; ready() should not block since the track is finished.
+		let subscriber = consumer.subscribe(Subscription::default()).expect("should not error");
+		subscriber
+			.ready()
+			.now_or_never()
+			.expect("should not block")
+			.expect("should not error");
+
+		assert!(subscriber.latest().is_none());
+	}
 }
diff --git a/rs/moq-lite/src/setup.rs b/rs/moq-lite/src/setup.rs
index 321f79404..e377a0d1f 100644
--- a/rs/moq-lite/src/setup.rs
+++ b/rs/moq-lite/src/setup.rs
@@ -75,7 +75,7 @@ impl SetupVersion {
 			Version::Ietf(ietf::Version::Draft15) | Version::Ietf(ietf::Version::Draft16) => Self::Draft15Plus,
 			Version::Ietf(ietf::Version::Draft17) => Self::Draft17,
 			Version::Lite(lite::Version::Lite01) | Version::Lite(lite::Version::Lite02) => Self::LiteLegacy,
-			Version::Lite(lite::Version::Lite03) => Self::Unsupported,
+			Version::Lite(_) => Self::Unsupported,
 		}
 	}
 }
diff --git a/rs/moq-lite/src/version.rs b/rs/moq-lite/src/version.rs
index ceccd5f05..d4df19d18 100644
--- a/rs/moq-lite/src/version.rs
+++ b/rs/moq-lite/src/version.rs
@@ -20,6 +20,7 @@ pub const ALPNS: &[&str] = &[ALPN_LITE_03, ALPN_LITE, ALPN_17, ALPN_16, ALPN_15,
 // ALPN constants
 pub const ALPN_LITE: &str = "moql";
 pub const ALPN_LITE_03: &str = "moq-lite-03";
+pub const ALPN_LITE_04: &str = "moq-lite-04";
 pub const ALPN_14: &str = "moq-00";
 pub const ALPN_15: &str = "moqt-15";
 pub const ALPN_16: &str = "moqt-16";
@@ -40,6 +41,7 @@ impl Version {
 			0xff0dad01 => Some(Self::Lite(lite::Version::Lite01)),
 			0xff0dad02 => Some(Self::Lite(lite::Version::Lite02)),
 			0xff0dad03 => Some(Self::Lite(lite::Version::Lite03)),
+			0xff0dad04 => Some(Self::Lite(lite::Version::Lite04)),
 			0xff00000e => Some(Self::Ietf(ietf::Version::Draft14)),
 			0xff00000f => Some(Self::Ietf(ietf::Version::Draft15)),
 			0xff000010 => Some(Self::Ietf(ietf::Version::Draft16)),
@@ -54,6 +56,7 @@ impl Version {
 			Self::Lite(lite::Version::Lite01) => 0xff0dad01,
 			Self::Lite(lite::Version::Lite02) => 0xff0dad02,
 			Self::Lite(lite::Version::Lite03) => 0xff0dad03,
+			Self::Lite(lite::Version::Lite04) => 0xff0dad04,
 			Self::Ietf(ietf::Version::Draft14) => 0xff00000e,
 			Self::Ietf(ietf::Version::Draft15) => 0xff00000f,
 			Self::Ietf(ietf::Version::Draft16) => 0xff000010,
@@ -69,6 +72,7 @@ impl Version {
 		match alpn {
 			ALPN_LITE => None, // Multiple versions share this ALPN, need SETUP negotiation
 			ALPN_LITE_03 => Some(Self::Lite(lite::Version::Lite03)),
+			ALPN_LITE_04 => Some(Self::Lite(lite::Version::Lite04)),
 			ALPN_14 => Some(Self::Ietf(ietf::Version::Draft14)),
 			ALPN_15 => Some(Self::Ietf(ietf::Version::Draft15)),
 			ALPN_16 => Some(Self::Ietf(ietf::Version::Draft16)),
@@ -80,6 +84,7 @@ impl Version {
 	/// Returns the ALPN string for this version.
 	pub fn alpn(&self) -> &'static str {
 		match self {
+			Self::Lite(lite::Version::Lite04) => ALPN_LITE_04,
 			Self::Lite(lite::Version::Lite03) => ALPN_LITE_03,
 			Self::Lite(lite::Version::Lite01 | lite::Version::Lite02) => ALPN_LITE,
 			Self::Ietf(ietf::Version::Draft14) => ALPN_14,
@@ -132,6 +137,7 @@ impl FromStr for Version {
 			"moq-lite-01" => Ok(Self::Lite(lite::Version::Lite01)),
 			"moq-lite-02" => Ok(Self::Lite(lite::Version::Lite02)),
 			"moq-lite-03" => Ok(Self::Lite(lite::Version::Lite03)),
+			"moq-lite-04" => Ok(Self::Lite(lite::Version::Lite04)),
 			"moq-transport-14" => Ok(Self::Ietf(ietf::Version::Draft14)),
 			"moq-transport-15" => Ok(Self::Ietf(ietf::Version::Draft15)),
 			"moq-transport-16" => Ok(Self::Ietf(ietf::Version::Draft16)),
diff --git a/rs/moq-mux/Cargo.toml b/rs/moq-mux/Cargo.toml
index 9fd80ee4e..9acde4886 100644
--- a/rs/moq-mux/Cargo.toml
+++ b/rs/moq-mux/Cargo.toml
@@ -16,33 +16,24 @@ categories = ["multimedia", "network-programming", "web-programming"]
 doctest = false
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
-[features]
-default = ["mp4", "h264", "h265", "hls", "av1", "aac", "opus"]
-mp4 = ["dep:mp4-atom"]
-h264 = ["dep:h264-parser"]
-h265 = ["dep:scuffle-h265"]
-hls = ["dep:m3u8-rs", "dep:reqwest", "mp4"]
-av1 = ["dep:scuffle-av1"]
-# Feature flags for codec support; no gated dependencies yet
-aac = []
-opus = []
-
 [dependencies]
 anyhow = "1"
 base64 = "0.22"
 buf-list = "1"
 bytes = "1"
 conducer = { workspace = true }
-h264-parser = { version = "0.4.0", optional = true }
+h264-parser = { version = "0.4.0" }
 hang = { workspace = true }
-m3u8-rs = { version = "6", optional = true }
+m3u8-rs = { version = "6" }
 moq-lite = { workspace = true, features = ["serde"] }
 moq-msf = { workspace = true }
-mp4-atom = { version = "0.10.0", features = ["tokio", "bytes", "serde"], optional = true }
+mp4-atom = { version = "0.10.0", features = ["tokio", "bytes", "serde"] }
 num_enum = "0.7"
-reqwest = { version = "0.12", default-features = false, features = ["rustls-tls", "gzip"], optional = true }
-scuffle-av1 = { version = "0.1.4", optional = true }
-scuffle-h265 = { version = "0.2.2", optional = true }
+reqwest = { version = "0.12", default-features = false, features = ["rustls-tls", "gzip"] }
+scuffle-av1 = { version = "0.1.4" }
+scuffle-h265 = { version = "0.2.2" }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
 thiserror = "2"
 tokio = { workspace = true, features = ["macros", "fs"] }
 tracing = "0.1"
diff --git a/rs/moq-mux/src/catalog.rs b/rs/moq-mux/src/catalog.rs
index dcf6fecf4..27e918c41 100644
--- a/rs/moq-mux/src/catalog.rs
+++ b/rs/moq-mux/src/catalog.rs
@@ -1,11 +1,10 @@
-use std::ops::{Deref, DerefMut};
-use std::sync::{Arc, Mutex, MutexGuard};
+use hang::catalog::{Audio, Section, Video};
+use serde::Serialize;
 
 /// Produces both a hang and MSF catalog track for a broadcast.
 ///
-/// The JSON catalog is updated when tracks are added/removed but is *not* automatically published.
-/// You'll have to call [`lock`](Self::lock) to update and publish the catalog.
-/// Both the hang (`catalog.json`) and MSF (`catalog`) tracks are published on drop of the guard.
+/// Wraps a [`hang::CatalogWriter`] and publishes updates to both
+/// the hang (`catalog.json`) and MSF (`catalog`) tracks when [`flush`](Self::flush) is called.
 #[derive(Clone)]
 pub struct CatalogProducer {
 	/// Access to the underlying hang catalog track producer.
@@ -14,98 +13,83 @@ pub struct CatalogProducer {
 	/// Access to the underlying MSF catalog track producer.
 	pub msf_track: moq_lite::TrackProducer,
 
-	current: Arc<Mutex<hang::Catalog>>,
+	writer: hang::CatalogWriter,
 }
 
 impl CatalogProducer {
 	/// Create a new catalog producer, inserting both catalog tracks into the broadcast.
-	pub fn new(broadcast: &mut moq_lite::BroadcastProducer) -> Result<Self, moq_lite::Error> {
-		Self::with_catalog(broadcast, hang::Catalog::default())
-	}
-
-	/// Create a new catalog producer with the given initial catalog.
-	pub fn with_catalog(
-		broadcast: &mut moq_lite::BroadcastProducer,
-		catalog: hang::Catalog,
-	) -> Result<Self, moq_lite::Error> {
-		let hang_track = broadcast.create_track(hang::Catalog::default_track())?;
+	pub fn new(broadcast: &moq_lite::BroadcastProducer) -> Result<Self, moq_lite::Error> {
+		let hang_track = broadcast.create_track(hang::catalog::default_track())?;
 		let msf_track = broadcast.create_track(moq_lite::Track {
 			name: moq_msf::DEFAULT_NAME.to_string(),
-			priority: 100,
 		})?;
 
 		Ok(Self {
 			hang_track,
 			msf_track,
-			current: Arc::new(Mutex::new(catalog)),
+			writer: hang::CatalogWriter::new(),
 		})
 	}
 
-	/// Get mutable access to the catalog, publishing it after any changes.
-	pub fn lock(&mut self) -> CatalogGuard<'_> {
-		CatalogGuard {
-			catalog: self.current.lock().unwrap(),
-			hang_track: &mut self.hang_track,
-			msf_track: &mut self.msf_track,
-			updated: false,
-		}
-	}
-
-	/// Create a consumer for this catalog, receiving updates as they're published.
-	pub fn consume(&self) -> hang::CatalogConsumer {
-		hang::CatalogConsumer::new(self.hang_track.consume())
-	}
-
-	/// Finish publishing to this catalog.
-	pub fn finish(&mut self) -> Result<(), moq_lite::Error> {
-		self.hang_track.finish()?;
-		self.msf_track.finish()?;
-		Ok(())
-	}
-}
-
-/// RAII guard for modifying a catalog with automatic publishing on drop.
-///
-/// Obtained via [`CatalogProducer::lock`].
-///
-/// On drop, both the hang and MSF catalog tracks are updated if the catalog was mutated.
-pub struct CatalogGuard<'a> {
-	catalog: MutexGuard<'a, hang::Catalog>,
-	hang_track: &'a mut moq_lite::TrackProducer,
-	msf_track: &'a mut moq_lite::TrackProducer,
-	updated: bool,
-}
-
-impl<'a> Deref for CatalogGuard<'a> {
-	type Target = hang::Catalog;
-
-	fn deref(&self) -> &Self::Target {
-		&self.catalog
+	/// Set a typed section in the catalog.
+	///
+	/// This does NOT publish the update. Call [`flush`](Self::flush) to publish.
+	pub fn set<T: Serialize>(&self, section: &Section<T>, value: &T) -> Result<(), hang::Error> {
+		self.writer.set(section, value)
 	}
-}
 
-impl<'a> DerefMut for CatalogGuard<'a> {
-	fn deref_mut(&mut self) -> &mut Self::Target {
-		self.updated = true;
-		&mut self.catalog
+	/// Remove a section from the catalog by name.
+	///
+	/// This does NOT publish the update. Call [`flush`](Self::flush) to publish.
+	pub fn remove(&self, name: &str) -> Result<(), hang::Error> {
+		self.writer.remove(name)
 	}
-}
-
-impl Drop for CatalogGuard<'_> {
-	fn drop(&mut self) {
-		if !self.updated {
-			return;
-		}
 
+	/// Publish the current catalog state to both the hang and MSF tracks.
+	pub fn flush(&mut self) {
 		// Publish hang catalog
+		let Ok(encoded) = self.writer.encode() else {
+			return;
+		};
 		let Ok(mut group) = self.hang_track.append_group() else {
 			return;
 		};
-		let frame = self.catalog.to_string().expect("invalid catalog");
-		let _ = group.write_frame(frame);
+		let _ = group.write_frame(encoded);
 		let _ = group.finish();
 
 		// Publish MSF catalog
-		crate::msf::publish(&self.catalog, self.msf_track);
+		// Read video and audio sections from the writer state for MSF conversion.
+		let state = self.writer.read();
+		let video: Option<Video> = state
+			.sections
+			.get("video")
+			.and_then(|v| serde_json::from_value(v.clone()).ok());
+		let audio: Option<Audio> = state
+			.sections
+			.get("audio")
+			.and_then(|v| serde_json::from_value(v.clone()).ok());
+		drop(state);
+
+		crate::msf::publish(video.as_ref(), audio.as_ref(), &mut self.msf_track);
+	}
+
+	/// Get a reference to the underlying [`hang::CatalogWriter`].
+	pub fn writer(&self) -> &hang::CatalogWriter {
+		&self.writer
+	}
+
+	/// Create a consumer for the hang catalog track, receiving updates as they're published.
+	pub fn consume(&self) -> hang::CatalogConsumer {
+		let track = self.hang_track.consume();
+		let subscriber = track.subscribe(moq_lite::Subscription::default()).unwrap();
+		hang::CatalogConsumer::new(subscriber)
+	}
+
+	/// Finish publishing to this catalog.
+	pub fn finish(&mut self) -> Result<(), moq_lite::Error> {
+		self.writer.close();
+		self.hang_track.finish()?;
+		self.msf_track.finish()?;
+		Ok(())
 	}
 }
diff --git a/rs/moq-mux/src/cmaf/container.rs b/rs/moq-mux/src/cmaf/container.rs
index 5e1d0a4d8..0b87fb16d 100644
--- a/rs/moq-mux/src/cmaf/container.rs
+++ b/rs/moq-mux/src/cmaf/container.rs
@@ -5,6 +5,20 @@ use bytes::Bytes;
 use super::Error;
 use crate::container::{Container, Frame, Timestamp};
 
+/// Parse the timescale from a CMAF init segment (ftyp+moov).
+pub(crate) fn parse_timescale(init_data: &[u8]) -> Result<u64, Error> {
+	use mp4_atom::DecodeMaybe;
+
+	let mut cursor = std::io::Cursor::new(init_data);
+	while let Some(atom) = mp4_atom::Any::decode_maybe(&mut cursor)? {
+		if let mp4_atom::Any::Moov(moov) = atom {
+			let trak = moov.trak.first().ok_or(Error::NoTracks)?;
+			return Ok(trak.mdia.mdhd.timescale as u64);
+		}
+	}
+	Err(Error::NoMoov)
+}
+
 pub(crate) fn decode(data: Bytes, timescale: u64) -> Result<Vec<Frame>, Error> {
 	use mp4_atom::DecodeMaybe;
 
@@ -42,8 +56,9 @@ pub(crate) fn decode(data: Bytes, timescale: u64) -> Result<Vec<Frame>, Error> {
 				return Ok(frames);
 			}
 
-			let pts = dts as i64 + entry.cts.unwrap_or(0) as i64;
-			let timestamp = Timestamp::from_scale(pts.max(0) as u64, timescale)?;
+			let cts = entry.cts.unwrap_or_default() as i64;
+			let pts = dts.checked_add_signed(cts).ok_or(Error::PtsOverflow)?;
+			let timestamp = Timestamp::from_scale(pts, timescale)?;
 			let payload = Bytes::copy_from_slice(&mdat_data[offset..end]);
 			let flags = entry.flags.unwrap_or(0);
 			// depends_on_no_other (bits 24-25 == 0x2) means keyframe
diff --git a/rs/moq-mux/src/cmaf/convert.rs b/rs/moq-mux/src/cmaf/convert.rs
new file mode 100644
index 000000000..1b4bc01de
--- /dev/null
+++ b/rs/moq-mux/src/cmaf/convert.rs
@@ -0,0 +1,862 @@
+use anyhow::Context;
+use base64::Engine;
+use bytes::Bytes;
+use hang::catalog::{AUDIO, Audio, AudioCodec, AudioConfig, Container, VIDEO, Video, VideoCodec, VideoConfig};
+use mp4_atom::{Atom, Encode};
+
+/// Converts a broadcast from any format to CMAF format.
+///
+/// If tracks are already CMAF, they are passed through unchanged.
+/// If tracks are hang/Legacy, each frame is individually wrapped in moof+mdat.
+pub struct Convert {
+	input: moq_lite::BroadcastConsumer,
+	output: moq_lite::BroadcastProducer,
+}
+
+impl Convert {
+	pub fn new(input: moq_lite::BroadcastConsumer, output: moq_lite::BroadcastProducer) -> Self {
+		Self { input, output }
+	}
+
+	/// Run the converter.
+	///
+	/// Reads the hang catalog from the input broadcast. If tracks are already CMAF,
+	/// passes them through unchanged (no-op). If tracks are hang/Legacy, converts
+	/// each frame to moof+mdat.
+	pub async fn run(self) -> anyhow::Result<()> {
+		let input = self.input;
+		let broadcast = self.output;
+		let mut catalog_producer = crate::CatalogProducer::new(&broadcast)?;
+
+		let catalog_track =
+			input.subscribe_track(&hang::catalog::default_track(), moq_lite::Subscription::default())?;
+
+		let mut catalog_consumer = hang::CatalogConsumer::new(catalog_track);
+		let video_section = catalog_consumer.reader().section(&VIDEO);
+		let audio_section = catalog_consumer.reader().section(&AUDIO);
+
+		// Run until first catalog update
+		tokio::select! {
+			res = catalog_consumer.run() => { res?; anyhow::bail!("catalog closed before first update"); },
+			_ = video_section.changed() => {},
+			_ = audio_section.changed() => {},
+		}
+
+		let video = video_section.get()?.unwrap_or_default();
+		let audio = audio_section.get()?.unwrap_or_default();
+
+		run_with_catalog(&input, &broadcast, &mut catalog_producer, &video, &audio).await
+	}
+}
+
+async fn run_with_catalog(
+	input: &moq_lite::BroadcastConsumer,
+	broadcast: &moq_lite::BroadcastProducer,
+	catalog_producer: &mut crate::CatalogProducer,
+	video: &Video,
+	audio: &Audio,
+) -> anyhow::Result<()> {
+	let mut output_video = Video::default();
+	let mut output_audio = Audio::default();
+	let mut tasks = tokio::task::JoinSet::new();
+
+	for (name, config) in &video.renditions {
+		let input_track = input.subscribe_track(
+			&moq_lite::Track { name: name.clone() },
+			moq_lite::Subscription::default(),
+		)?;
+
+		match &config.container {
+			Container::Cmaf { .. } => {
+				output_video.renditions.insert(name.clone(), config.clone());
+				let output_track = broadcast.create_track(moq_lite::Track { name: name.clone() })?;
+				let track_name = name.clone();
+				tasks.spawn(async move {
+					if let Err(e) = passthrough_track(input_track, output_track).await {
+						tracing::error!(%e, track = %track_name, "passthrough_track failed");
+					}
+				});
+			}
+			Container::Legacy => {
+				let init_data = build_video_init(config)?;
+				let timescale = guess_video_timescale(config);
+
+				let mut cmaf_config = config.clone();
+				cmaf_config.container = Container::Cmaf {
+					init_data: base64::engine::general_purpose::STANDARD.encode(&init_data),
+				};
+				output_video.renditions.insert(name.clone(), cmaf_config);
+
+				let output_track = broadcast.create_track(moq_lite::Track { name: name.clone() })?;
+
+				let track_name = name.clone();
+				tasks.spawn(async move {
+					if let Err(e) = convert_legacy_to_cmaf(input_track, output_track, timescale, true).await {
+						tracing::error!(%e, track = %track_name, "convert_legacy_to_cmaf failed");
+					}
+				});
+			}
+		}
+	}
+
+	for (name, config) in &audio.renditions {
+		let input_track = input.subscribe_track(
+			&moq_lite::Track { name: name.clone() },
+			moq_lite::Subscription::default(),
+		)?;
+
+		match &config.container {
+			Container::Cmaf { .. } => {
+				output_audio.renditions.insert(name.clone(), config.clone());
+				let output_track = broadcast.create_track(moq_lite::Track { name: name.clone() })?;
+				let track_name = name.clone();
+				tasks.spawn(async move {
+					if let Err(e) = passthrough_track(input_track, output_track).await {
+						tracing::error!(%e, track = %track_name, "passthrough_track failed");
+					}
+				});
+			}
+			Container::Legacy => {
+				let init_data = build_audio_init(config)?;
+
+				let mut cmaf_config = config.clone();
+				cmaf_config.container = Container::Cmaf {
+					init_data: base64::engine::general_purpose::STANDARD.encode(&init_data),
+				};
+				output_audio.renditions.insert(name.clone(), cmaf_config);
+
+				let output_track = broadcast.create_track(moq_lite::Track { name: name.clone() })?;
+
+				let timescale = config.sample_rate as u64;
+				let track_name = name.clone();
+				tasks.spawn(async move {
+					if let Err(e) = convert_legacy_to_cmaf(input_track, output_track, timescale, false).await {
+						tracing::error!(%e, track = %track_name, "convert_legacy_to_cmaf failed");
+					}
+				});
+			}
+		}
+	}
+
+	// Publish the output catalog
+	catalog_producer.set(&VIDEO, &output_video)?;
+	catalog_producer.set(&AUDIO, &output_audio)?;
+	catalog_producer.flush();
+
+	// Keep broadcast and catalog alive until all track tasks complete.
+	while tasks.join_next().await.is_some() {}
+
+	Ok(())
+}
+
+async fn passthrough_track(
+	mut input: moq_lite::TrackSubscriber,
+	mut output: moq_lite::TrackProducer,
+) -> anyhow::Result<()> {
+	while let Some(group) = input.recv_group().await? {
+		let mut out_group = output.append_group()?;
+		let mut reader = group;
+		while let Some(data) = reader.read_frame().await? {
+			out_group.write_frame(data)?;
+		}
+		out_group.finish()?;
+	}
+	output.finish()?;
+	Ok(())
+}
+
+async fn convert_legacy_to_cmaf(
+	input: moq_lite::TrackSubscriber,
+	mut output: moq_lite::TrackProducer,
+	timescale: u64,
+	is_video: bool,
+) -> anyhow::Result<()> {
+	let mut consumer = crate::consumer::OrderedConsumer::new(input, crate::consumer::Legacy, std::time::Duration::MAX);
+	let mut seq: u32 = 1;
+	let mut current_group: Option<moq_lite::GroupProducer> = None;
+
+	while let Some(frame) = consumer.read().await? {
+		let keyframe = frame.is_keyframe();
+
+		if is_video && keyframe {
+			if let Some(mut prev) = current_group.take() {
+				prev.finish()?;
+			}
+			current_group = Some(output.append_group()?);
+		} else if current_group.is_none() {
+			current_group = Some(output.append_group()?);
+		}
+
+		let group = current_group.as_mut().unwrap();
+
+		let payload: Vec<u8> = frame.payload.into_iter().flat_map(|chunk| chunk.into_iter()).collect();
+		let dts = frame.timestamp.as_micros() as u64 * timescale / 1_000_000;
+		let moof_mdat = build_moof_mdat(seq, 1, dts, &payload, keyframe)?;
+		seq += 1;
+
+		group.write_frame(moof_mdat)?;
+	}
+
+	if let Some(mut g) = current_group.take() {
+		g.finish()?;
+	}
+	output.finish()?;
+	Ok(())
+}
+
+pub(crate) fn build_moof_mdat(seq: u32, track_id: u32, dts: u64, data: &[u8], keyframe: bool) -> anyhow::Result<Bytes> {
+	let flags = if keyframe { 0x0200_0000 } else { 0x0001_0000 };
+
+	// First pass to get moof size (use Some(0) so trun includes the data_offset field)
+	let moof = build_moof(seq, track_id, dts, data.len() as u32, flags, Some(0));
+	let mut buf = Vec::new();
+	moof.encode(&mut buf)?;
+	let moof_size = buf.len();
+
+	// Second pass with data_offset
+	let data_offset = (moof_size + 8) as i32; // 8 = mdat header
+	let moof = build_moof(seq, track_id, dts, data.len() as u32, flags, Some(data_offset));
+	buf.clear();
+	moof.encode(&mut buf)?;
+
+	let mdat = mp4_atom::Mdat { data: data.to_vec() };
+	mdat.encode(&mut buf)?;
+
+	Ok(Bytes::from(buf))
+}
+
+fn build_moof(seq: u32, track_id: u32, dts: u64, size: u32, flags: u32, data_offset: Option<i32>) -> mp4_atom::Moof {
+	mp4_atom::Moof {
+		mfhd: mp4_atom::Mfhd { sequence_number: seq },
+		traf: vec![mp4_atom::Traf {
+			tfhd: mp4_atom::Tfhd {
+				track_id,
+				..Default::default()
+			},
+			tfdt: Some(mp4_atom::Tfdt {
+				base_media_decode_time: dts,
+			}),
+			trun: vec![mp4_atom::Trun {
+				data_offset,
+				entries: vec![mp4_atom::TrunEntry {
+					size: Some(size),
+					flags: Some(flags),
+					..Default::default()
+				}],
+			}],
+			..Default::default()
+		}],
+	}
+}
+
+pub(crate) fn build_video_init(config: &VideoConfig) -> anyhow::Result<Vec<u8>> {
+	let ftyp = mp4_atom::Ftyp {
+		major_brand: b"isom".into(),
+		minor_version: 0x200,
+		compatible_brands: vec![b"isom".into(), b"iso6".into(), b"mp41".into()],
+	};
+
+	let codec = build_video_codec(config)?;
+	let timescale = guess_video_timescale(config) as u32;
+
+	let moov = mp4_atom::Moov {
+		mvhd: mp4_atom::Mvhd {
+			timescale,
+			..Default::default()
+		},
+		trak: vec![mp4_atom::Trak {
+			tkhd: mp4_atom::Tkhd {
+				track_id: 1,
+				width: mp4_atom::FixedPoint::new(config.coded_width.unwrap_or(0) as u16, 0),
+				height: mp4_atom::FixedPoint::new(config.coded_height.unwrap_or(0) as u16, 0),
+				..Default::default()
+			},
+			mdia: mp4_atom::Mdia {
+				mdhd: mp4_atom::Mdhd {
+					timescale,
+					..Default::default()
+				},
+				hdlr: mp4_atom::Hdlr {
+					handler: b"vide".into(),
+					name: "VideoHandler".into(),
+				},
+				minf: mp4_atom::Minf {
+					vmhd: Some(mp4_atom::Vmhd::default()),
+					dinf: mp4_atom::Dinf {
+						dref: mp4_atom::Dref { urls: vec![] },
+					},
+					stbl: mp4_atom::Stbl {
+						stsd: mp4_atom::Stsd { codecs: vec![codec] },
+						..Default::default()
+					},
+					..Default::default()
+				},
+			},
+			..Default::default()
+		}],
+		mvex: Some(mp4_atom::Mvex {
+			trex: vec![mp4_atom::Trex {
+				track_id: 1,
+				default_sample_description_index: 1,
+				..Default::default()
+			}],
+			..Default::default()
+		}),
+		..Default::default()
+	};
+
+	let mut buf = Vec::new();
+	ftyp.encode(&mut buf)?;
+	moov.encode(&mut buf)?;
+	Ok(buf)
+}
+
+pub(crate) fn build_audio_init(config: &AudioConfig) -> anyhow::Result<Vec<u8>> {
+	let ftyp = mp4_atom::Ftyp {
+		major_brand: b"isom".into(),
+		minor_version: 0x200,
+		compatible_brands: vec![b"isom".into(), b"iso6".into(), b"mp41".into()],
+	};
+
+	let codec = build_audio_codec(config)?;
+	let timescale = config.sample_rate;
+
+	let moov = mp4_atom::Moov {
+		mvhd: mp4_atom::Mvhd {
+			timescale,
+			..Default::default()
+		},
+		trak: vec![mp4_atom::Trak {
+			tkhd: mp4_atom::Tkhd {
+				track_id: 1,
+				..Default::default()
+			},
+			mdia: mp4_atom::Mdia {
+				mdhd: mp4_atom::Mdhd {
+					timescale,
+					..Default::default()
+				},
+				hdlr: mp4_atom::Hdlr {
+					handler: b"soun".into(),
+					name: "SoundHandler".into(),
+				},
+				minf: mp4_atom::Minf {
+					smhd: Some(mp4_atom::Smhd::default()),
+					dinf: mp4_atom::Dinf {
+						dref: mp4_atom::Dref { urls: vec![] },
+					},
+					stbl: mp4_atom::Stbl {
+						stsd: mp4_atom::Stsd { codecs: vec![codec] },
+						..Default::default()
+					},
+					..Default::default()
+				},
+			},
+			..Default::default()
+		}],
+		mvex: Some(mp4_atom::Mvex {
+			trex: vec![mp4_atom::Trex {
+				track_id: 1,
+				default_sample_description_index: 1,
+				..Default::default()
+			}],
+			..Default::default()
+		}),
+		..Default::default()
+	};
+
+	let mut buf = Vec::new();
+	ftyp.encode(&mut buf)?;
+	moov.encode(&mut buf)?;
+	Ok(buf)
+}
+
+fn build_video_codec(config: &VideoConfig) -> anyhow::Result<mp4_atom::Codec> {
+	let visual = mp4_atom::Visual {
+		width: config.coded_width.unwrap_or(0) as u16,
+		height: config.coded_height.unwrap_or(0) as u16,
+		..Default::default()
+	};
+
+	match &config.codec {
+		VideoCodec::H264(_) => {
+			let mut data = config
+				.description
+				.as_ref()
+				.context("H264 requires description")?
+				.clone();
+			let avcc = mp4_atom::Avcc::decode_body(&mut data)?;
+			Ok(mp4_atom::Codec::Avc1(mp4_atom::Avc1 {
+				visual,
+				avcc,
+				..Default::default()
+			}))
+		}
+		VideoCodec::H265(h265) => {
+			let mut data = config
+				.description
+				.as_ref()
+				.context("H265 requires description")?
+				.clone();
+			let hvcc = mp4_atom::Hvcc::decode_body(&mut data)?;
+			if h265.in_band {
+				Ok(mp4_atom::Codec::Hev1(mp4_atom::Hev1 {
+					visual,
+					hvcc,
+					..Default::default()
+				}))
+			} else {
+				Ok(mp4_atom::Codec::Hvc1(mp4_atom::Hvc1 {
+					visual,
+					hvcc,
+					..Default::default()
+				}))
+			}
+		}
+		VideoCodec::VP9(vp9) => Ok(mp4_atom::Codec::Vp09(mp4_atom::Vp09 {
+			visual,
+			vpcc: mp4_atom::VpcC {
+				profile: vp9.profile,
+				level: vp9.level,
+				bit_depth: vp9.bit_depth,
+				chroma_subsampling: vp9.chroma_subsampling,
+				video_full_range_flag: vp9.full_range,
+				color_primaries: vp9.color_primaries,
+				transfer_characteristics: vp9.transfer_characteristics,
+				matrix_coefficients: vp9.matrix_coefficients,
+				codec_initialization_data: vec![],
+			},
+			..Default::default()
+		})),
+		VideoCodec::AV1(av1) => Ok(mp4_atom::Codec::Av01(mp4_atom::Av01 {
+			visual,
+			av1c: mp4_atom::Av1c {
+				seq_profile: av1.profile,
+				seq_level_idx_0: av1.level,
+				seq_tier_0: av1.tier == 'H',
+				high_bitdepth: av1.bitdepth >= 10,
+				twelve_bit: av1.bitdepth >= 12,
+				monochrome: av1.mono_chrome,
+				chroma_subsampling_x: av1.chroma_subsampling_x,
+				chroma_subsampling_y: av1.chroma_subsampling_y,
+				chroma_sample_position: av1.chroma_sample_position,
+				..Default::default()
+			},
+			..Default::default()
+		})),
+		VideoCodec::VP8 => Ok(mp4_atom::Codec::Vp08(mp4_atom::Vp08 {
+			visual,
+			..Default::default()
+		})),
+		_ => anyhow::bail!("unsupported video codec for CMAF conversion"),
+	}
+}
+
+fn build_audio_codec(config: &AudioConfig) -> anyhow::Result<mp4_atom::Codec> {
+	let audio = mp4_atom::Audio {
+		data_reference_index: 1,
+		channel_count: config.channel_count as u16,
+		sample_size: 16,
+		sample_rate: mp4_atom::FixedPoint::new(config.sample_rate as u16, 0),
+	};
+
+	match &config.codec {
+		AudioCodec::AAC(aac) => {
+			let freq_index: u8 = match config.sample_rate {
+				96000 => 0,
+				88200 => 1,
+				64000 => 2,
+				48000 => 3,
+				44100 => 4,
+				32000 => 5,
+				24000 => 6,
+				22050 => 7,
+				16000 => 8,
+				12000 => 9,
+				11025 => 10,
+				8000 => 11,
+				7350 => 12,
+				_ => 0xF,
+			};
+
+			Ok(mp4_atom::Codec::Mp4a(mp4_atom::Mp4a {
+				audio,
+				esds: mp4_atom::Esds {
+					es_desc: mp4_atom::esds::EsDescriptor {
+						es_id: 1,
+						dec_config: mp4_atom::esds::DecoderConfig {
+							object_type_indication: 0x40,
+							stream_type: 5,
+							max_bitrate: config.bitrate.unwrap_or(0) as u32,
+							avg_bitrate: config.bitrate.unwrap_or(0) as u32,
+							dec_specific: mp4_atom::esds::DecoderSpecific {
+								profile: aac.profile,
+								freq_index,
+								chan_conf: config.channel_count as u8,
+							},
+							..Default::default()
+						},
+						sl_config: mp4_atom::esds::SLConfig {},
+					},
+				},
+				btrt: None,
+				taic: None,
+			}))
+		}
+		AudioCodec::Opus => Ok(mp4_atom::Codec::Opus(mp4_atom::Opus {
+			audio,
+			dops: mp4_atom::Dops {
+				output_channel_count: config.channel_count as u8,
+				pre_skip: 0,
+				input_sample_rate: config.sample_rate,
+				output_gain: 0,
+			},
+			btrt: None,
+		})),
+		_ => anyhow::bail!("unsupported audio codec for CMAF conversion"),
+	}
+}
+
+fn guess_video_timescale(config: &VideoConfig) -> u64 {
+	if let Some(fps) = config.framerate {
+		(fps * 1000.0) as u64
+	} else {
+		90000
+	}
+}
+
+#[cfg(test)]
+pub(crate) mod test {
+	use std::time::Duration;
+
+	use base64::Engine;
+	use bytes::{Bytes, BytesMut};
+	use hang::catalog::{Container, H264, VideoCodec, VideoConfig};
+	use hang::container::{Frame, Timestamp};
+	use mp4_atom::{Atom, DecodeMaybe};
+
+	use buf_list::BufList;
+
+	fn ts(micros: u64) -> Timestamp {
+		Timestamp::from_micros(micros).unwrap()
+	}
+
+	pub(crate) fn build_avcc_description() -> Bytes {
+		let avcc = mp4_atom::Avcc {
+			configuration_version: 1,
+			avc_profile_indication: 0x64,
+			profile_compatibility: 0x00,
+			avc_level_indication: 0x1F,
+			length_size: 4,
+			sequence_parameter_sets: vec![vec![
+				0x67, 0x64, 0x00, 0x1F, 0xAC, 0xD9, 0x40, 0x50, 0x05, 0xBB, 0x01, 0x10, 0x00, 0x00, 0x03, 0x00, 0x10,
+				0x00, 0x00, 0x03, 0x03, 0xC0, 0xF1, 0x62, 0xE4, 0x80,
+			]],
+			picture_parameter_sets: vec![vec![0x68, 0xEB, 0xE3, 0xCB, 0x22, 0xC0]],
+			..Default::default()
+		};
+
+		let mut buf = BytesMut::new();
+		avcc.encode_body(&mut buf).expect("encode avcc");
+		buf.freeze()
+	}
+
+	pub(crate) fn test_video_config() -> VideoConfig {
+		VideoConfig {
+			codec: VideoCodec::H264(H264 {
+				profile: 0x64,
+				constraints: 0x00,
+				level: 0x1F,
+				inline: false,
+			}),
+			description: Some(build_avcc_description()),
+			coded_width: Some(1920),
+			coded_height: Some(1080),
+			framerate: Some(30.0),
+			container: Container::Legacy,
+			bitrate: None,
+			display_ratio_width: None,
+			display_ratio_height: None,
+			optimize_for_latency: None,
+			jitter: None,
+		}
+	}
+
+	pub(crate) fn setup_input(
+		video_config: &VideoConfig,
+	) -> (
+		moq_lite::BroadcastConsumer,
+		moq_lite::TrackProducer,
+		moq_lite::BroadcastProducer,
+		moq_lite::TrackProducer,
+	) {
+		let broadcast = moq_lite::Broadcast::new().produce();
+
+		let mut catalog_track = broadcast.create_track(hang::catalog::default_track()).unwrap();
+		let mut video = hang::catalog::Video::default();
+		video.renditions.insert("video".to_string(), video_config.clone());
+
+		let mut sections = serde_json::Map::new();
+		sections.insert("video".to_string(), serde_json::to_value(&video).unwrap());
+		let catalog_json = serde_json::to_vec(&sections).unwrap();
+		let mut group = catalog_track.append_group().unwrap();
+		group.write_frame(catalog_json).unwrap();
+		group.finish().unwrap();
+
+		let video_track = broadcast
+			.create_track(moq_lite::Track {
+				name: "video".to_string(),
+			})
+			.unwrap();
+
+		let consumer = broadcast.consume();
+
+		(consumer, video_track, broadcast, catalog_track)
+	}
+
+	pub(crate) fn write_legacy_frames(track: &mut moq_lite::TrackProducer, frames: &[(Timestamp, Vec<u8>, bool)]) {
+		let mut current_group: Option<moq_lite::GroupProducer> = None;
+		for (timestamp, payload, is_keyframe) in frames {
+			if *is_keyframe {
+				if let Some(mut g) = current_group.take() {
+					g.finish().unwrap();
+				}
+				current_group = Some(track.append_group().unwrap());
+			} else if current_group.is_none() {
+				current_group = Some(track.append_group().unwrap());
+			}
+
+			let frame = Frame {
+				timestamp: *timestamp,
+				payload: BufList::from_iter(vec![Bytes::from(payload.clone())]),
+			};
+			frame.encode(current_group.as_mut().unwrap()).unwrap();
+		}
+
+		if let Some(mut g) = current_group.take() {
+			g.finish().unwrap();
+		}
+		track.finish().unwrap();
+	}
+
+	pub(crate) fn write_cmaf_frames(track: &mut moq_lite::TrackProducer, frames: &[(u64, Vec<u8>, bool)]) {
+		let mut current_group: Option<moq_lite::GroupProducer> = None;
+		let mut seq: u32 = 1;
+		for (dts, payload, keyframe) in frames {
+			if *keyframe {
+				if let Some(mut g) = current_group.take() {
+					g.finish().unwrap();
+				}
+				current_group = Some(track.append_group().unwrap());
+			} else if current_group.is_none() {
+				current_group = Some(track.append_group().unwrap());
+			}
+
+			let moof_mdat = super::build_moof_mdat(seq, 1, *dts, payload, *keyframe).unwrap();
+			seq += 1;
+			current_group.as_mut().unwrap().write_frame(moof_mdat).unwrap();
+		}
+
+		if let Some(mut g) = current_group.take() {
+			g.finish().unwrap();
+		}
+		track.finish().unwrap();
+	}
+
+	pub(crate) async fn read_legacy_frames(track: moq_lite::TrackSubscriber) -> Vec<(Timestamp, Vec<u8>, bool)> {
+		let mut ordered = crate::consumer::OrderedConsumer::new(track, crate::consumer::Legacy, Duration::MAX);
+
+		let mut result = Vec::new();
+		while let Some(frame) = tokio::time::timeout(Duration::from_millis(500), ordered.read())
+			.await
+			.expect("read_legacy_frames timed out")
+			.expect("read_legacy_frames error")
+		{
+			let is_keyframe = frame.is_keyframe();
+			let timestamp = frame.timestamp;
+			let payload: Vec<u8> = frame.payload.into_iter().flat_map(|c| c.into_iter()).collect();
+			result.push((timestamp, payload, is_keyframe));
+		}
+		result
+	}
+
+	pub(crate) async fn read_cmaf_raw_frames(mut track: moq_lite::TrackSubscriber) -> Vec<Bytes> {
+		let mut result = Vec::new();
+		while let Some(group) = tokio::time::timeout(Duration::from_millis(500), track.recv_group())
+			.await
+			.expect("read_cmaf_raw_frames timed out")
+			.expect("read_cmaf_raw_frames error")
+		{
+			let mut reader = group;
+			while let Some(data) = tokio::time::timeout(Duration::from_millis(500), reader.read_frame())
+				.await
+				.expect("read_cmaf_raw_frames timed out on frame")
+				.expect("read_cmaf_raw_frames frame error")
+			{
+				result.push(data);
+			}
+		}
+		result
+	}
+
+	fn parse_cmaf_frame(data: &Bytes, timescale: u64) -> (Timestamp, Vec<u8>, bool) {
+		let mut cursor = std::io::Cursor::new(data.as_ref());
+		let mut moof_found = None;
+		let mut mdat_found = None;
+
+		while let Some(atom) = mp4_atom::Any::decode_maybe(&mut cursor).unwrap() {
+			match atom {
+				mp4_atom::Any::Moof(m) => moof_found = Some(m),
+				mp4_atom::Any::Mdat(m) => mdat_found = Some(m),
+				_ => {}
+			}
+		}
+
+		let moof = moof_found.expect("no moof");
+		let mdat = mdat_found.expect("no mdat");
+		let traf = &moof.traf[0];
+		let tfdt = traf.tfdt.as_ref().expect("no tfdt");
+		let timestamp = Timestamp::from_scale(tfdt.base_media_decode_time, timescale).unwrap();
+		let flags = traf.trun[0].entries[0].flags.unwrap_or(0);
+		let keyframe = (flags >> 24) & 0x3 == 0x2 && (flags >> 16) & 0x1 == 0;
+
+		(timestamp, mdat.data.clone(), keyframe)
+	}
+
+	pub(crate) async fn subscribe_video(consumer: &moq_lite::BroadcastConsumer) -> moq_lite::TrackSubscriber {
+		let track = moq_lite::Track {
+			name: "video".to_string(),
+		};
+		loop {
+			match consumer.subscribe_track(&track, moq_lite::Subscription::default()) {
+				Ok(t) => return t,
+				Err(_) => tokio::task::yield_now().await,
+			}
+		}
+	}
+
+	#[tokio::test]
+	async fn legacy_to_cmaf_video() {
+		let config = test_video_config();
+		let frames = vec![
+			(ts(0), vec![0x01, 0x02, 0x03], true),
+			(ts(33_000), vec![0x04, 0x05], false),
+			(ts(66_000), vec![0x06, 0x07, 0x08], true),
+		];
+
+		let (consumer, mut video_track, _broadcast, _catalog_track) = setup_input(&config);
+		let output = moq_lite::Broadcast::new().produce();
+		let output_consumer = output.consume();
+
+		let converter = super::Convert::new(consumer, output);
+
+		let frames_clone = frames.clone();
+		tokio::spawn(async move {
+			tokio::task::yield_now().await;
+			write_legacy_frames(&mut video_track, &frames_clone);
+		});
+
+		let (convert_result, cmaf_frames) = tokio::join!(converter.run(), async {
+			let output_video = subscribe_video(&output_consumer).await;
+			read_cmaf_raw_frames(output_video).await
+		});
+		convert_result.unwrap();
+
+		let timescale = config.framerate.map(|f| (f * 1000.0) as u64).unwrap();
+		assert_eq!(cmaf_frames.len(), 3, "expected 3 CMAF frames");
+
+		for (i, cmaf_data) in cmaf_frames.iter().enumerate() {
+			let (parsed_ts, payload, keyframe) = parse_cmaf_frame(cmaf_data, timescale);
+			assert_eq!(parsed_ts, frames[i].0, "timestamp mismatch at frame {i}");
+			assert_eq!(payload, frames[i].1, "payload mismatch at frame {i}");
+			assert_eq!(keyframe, frames[i].2, "keyframe flag mismatch at frame {i}");
+		}
+	}
+
+	#[tokio::test]
+	async fn cmaf_passthrough() {
+		let config = test_video_config();
+		let init_data = super::build_video_init(&config).unwrap();
+		let timescale = config.framerate.map(|f| (f * 1000.0) as u64).unwrap();
+
+		let cmaf_frames: Vec<(u64, Vec<u8>, bool)> = vec![
+			(0, vec![0x01, 0x02], true),
+			(33_000u64 * timescale / 1_000_000, vec![0x03, 0x04], false),
+		];
+
+		let mut cmaf_config = config.clone();
+		cmaf_config.container = Container::Cmaf {
+			init_data: base64::engine::general_purpose::STANDARD.encode(&init_data),
+		};
+
+		let (consumer, mut video_track, _broadcast, _catalog_track) = setup_input(&cmaf_config);
+		let output = moq_lite::Broadcast::new().produce();
+		let output_consumer = output.consume();
+
+		let converter = super::Convert::new(consumer, output);
+
+		let cmaf_frames_clone = cmaf_frames.clone();
+		tokio::spawn(async move {
+			tokio::task::yield_now().await;
+			write_cmaf_frames(&mut video_track, &cmaf_frames_clone);
+		});
+
+		let (convert_result, output_frames) = tokio::join!(converter.run(), async {
+			let output_video = subscribe_video(&output_consumer).await;
+			read_cmaf_raw_frames(output_video).await
+		});
+		convert_result.unwrap();
+
+		assert_eq!(output_frames.len(), cmaf_frames.len());
+
+		let mut seq = 1u32;
+		for (i, (dts, payload, keyframe)) in cmaf_frames.iter().enumerate() {
+			let expected = super::build_moof_mdat(seq, 1, *dts, payload, *keyframe).unwrap();
+			seq += 1;
+			assert_eq!(output_frames[i], expected, "frame {i} should be byte-identical");
+		}
+	}
+
+	#[tokio::test]
+	async fn roundtrip_legacy_cmaf_legacy() {
+		let config = test_video_config();
+		let frames = vec![
+			(ts(0), vec![0xAA, 0xBB], true),
+			(ts(33_000), vec![0xCC], false),
+			(ts(66_000), vec![0xDD, 0xEE, 0xFF], true),
+			(ts(99_000), vec![0x11, 0x22], false),
+		];
+
+		let (consumer, mut video_track, _broadcast, _catalog_track) = setup_input(&config);
+
+		// Legacy -> CMAF
+		let cmaf_output = moq_lite::Broadcast::new().produce();
+		let cmaf_consumer = cmaf_output.consume();
+		let fmp4_converter = super::Convert::new(consumer, cmaf_output);
+
+		// CMAF -> Legacy
+		let legacy_output = moq_lite::Broadcast::new().produce();
+		let legacy_consumer = legacy_output.consume();
+		let hang_converter = crate::hang::Convert::new(cmaf_consumer, legacy_output);
+
+		let frames_clone = frames.clone();
+		tokio::spawn(async move {
+			tokio::task::yield_now().await;
+			write_legacy_frames(&mut video_track, &frames_clone);
+		});
+
+		let (r1, r2, result) = tokio::join!(fmp4_converter.run(), hang_converter.run(), async {
+			let legacy_video = subscribe_video(&legacy_consumer).await;
+			read_legacy_frames(legacy_video).await
+		});
+		r1.unwrap();
+		r2.unwrap();
+
+		assert_eq!(result.len(), frames.len(), "frame count mismatch after roundtrip");
+
+		for (i, (expected_ts, expected_payload, _)) in frames.iter().enumerate() {
+			assert_eq!(result[i].0, *expected_ts, "timestamp mismatch at frame {i}");
+			assert_eq!(result[i].1, *expected_payload, "payload mismatch at frame {i}");
+		}
+	}
+}
diff --git a/rs/moq-mux/src/cmaf/error.rs b/rs/moq-mux/src/cmaf/error.rs
index 752218b3d..f9a5901d7 100644
--- a/rs/moq-mux/src/cmaf/error.rs
+++ b/rs/moq-mux/src/cmaf/error.rs
@@ -16,12 +16,18 @@ pub enum Error {
 	#[error("no tfdt in traf")]
 	NoTfdt,
 
+	#[error("PTS overflow")]
+	PtsOverflow,
+
 	#[error("no moof found in CMAF frame data")]
 	NoMoof,
 
 	#[error("no mdat found in CMAF frame data")]
 	NoMdat,
 
+	#[error("no moov found in init data")]
+	NoMoov,
+
 	#[error("no tracks in moov")]
 	NoTracks,
 
diff --git a/rs/moq-mux/src/cmaf/mod.rs b/rs/moq-mux/src/cmaf/mod.rs
index 0cfb372ff..fc4b5eb36 100644
--- a/rs/moq-mux/src/cmaf/mod.rs
+++ b/rs/moq-mux/src/cmaf/mod.rs
@@ -1,7 +1,9 @@
 mod container;
+mod convert;
 mod error;
 
-pub(crate) use container::{decode, encode};
+pub(crate) use container::{decode, parse_timescale};
+pub use convert::*;
 pub use error::Error;
 
 pub type Consumer = crate::ordered::Consumer<mp4_atom::Moov>;
diff --git a/rs/moq-mux/src/consumer/container.rs b/rs/moq-mux/src/consumer/container.rs
new file mode 100644
index 000000000..9a83ea095
--- /dev/null
+++ b/rs/moq-mux/src/consumer/container.rs
@@ -0,0 +1,98 @@
+use buf_list::BufList;
+
+pub type Timestamp = moq_lite::Timescale<1_000_000>;
+
+/// Trait for parsing container-formatted frame data.
+///
+/// Different container formats encode timestamps differently:
+/// - Legacy (hang): VarInt timestamp prefix, stripped from payload
+/// - CMAF: timestamp in moof tfdt, payload passed through unchanged
+pub trait ContainerFormat {
+	type Error: Into<Error>;
+
+	/// Parse timestamp from raw frame data.
+	///
+	/// Returns (timestamp, payload) where payload may have the timestamp
+	/// stripped (Legacy) or be the full original data (CMAF passthrough).
+	fn parse(&self, payload: BufList) -> Result<(Timestamp, BufList), Self::Error>;
+}
+
+/// Errors from container format operations.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	#[error("moq: {0}")]
+	Moq(#[from] moq_lite::Error),
+
+	#[error("mp4: {0}")]
+	Mp4(#[from] mp4_atom::Error),
+
+	#[error("{0}")]
+	Other(String),
+}
+
+/// hang Legacy format: VarInt timestamp prefix.
+pub struct Legacy;
+
+impl ContainerFormat for Legacy {
+	type Error = moq_lite::Error;
+
+	fn parse(&self, mut payload: BufList) -> Result<(Timestamp, BufList), Self::Error> {
+		let timestamp = Timestamp::decode(&mut payload)?;
+		Ok((timestamp, payload))
+	}
+}
+
+/// CMAF format: parse moof tfdt for timestamp, return full moof+mdat unchanged.
+pub struct Cmaf {
+	pub timescale: u64,
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum CmafError {
+	#[error("mp4: {0}")]
+	Mp4(#[from] mp4_atom::Error),
+
+	#[error("timestamp overflow")]
+	TimestampOverflow(#[from] moq_lite::TimeOverflow),
+
+	#[error("no traf in moof")]
+	NoTraf,
+
+	#[error("no tfdt in traf")]
+	NoTfdt,
+
+	#[error("no moof found in CMAF frame data")]
+	NoMoof,
+}
+
+impl From<CmafError> for Error {
+	fn from(e: CmafError) -> Self {
+		match e {
+			CmafError::Mp4(e) => Error::Mp4(e),
+			e => Error::Other(e.to_string()),
+		}
+	}
+}
+
+impl ContainerFormat for Cmaf {
+	type Error = CmafError;
+
+	fn parse(&self, payload: BufList) -> Result<(Timestamp, BufList), Self::Error> {
+		use mp4_atom::DecodeMaybe;
+
+		// Collect payload into contiguous bytes for parsing
+		let data: Vec<u8> = payload.iter().flat_map(|c| c.iter().copied()).collect();
+		let mut cursor = std::io::Cursor::new(&data);
+
+		while let Some(atom) = mp4_atom::Any::decode_maybe(&mut cursor)? {
+			if let mp4_atom::Any::Moof(moof) = atom {
+				let traf = moof.traf.first().ok_or(CmafError::NoTraf)?;
+				let tfdt = traf.tfdt.as_ref().ok_or(CmafError::NoTfdt)?;
+				let timestamp = Timestamp::from_scale(tfdt.base_media_decode_time, self.timescale)?;
+				return Ok((timestamp, BufList::from_iter(vec![bytes::Bytes::from(data)])));
+			}
+		}
+
+		Err(CmafError::NoMoof)
+	}
+}
diff --git a/rs/moq-mux/src/consumer/fmp4.rs b/rs/moq-mux/src/consumer/fmp4.rs
new file mode 100644
index 000000000..cbd2c1f91
--- /dev/null
+++ b/rs/moq-mux/src/consumer/fmp4.rs
@@ -0,0 +1,223 @@
+use anyhow::Context;
+use base64::Engine;
+use bytes::Bytes;
+use hang::catalog::{Audio, Container, Video, VideoConfig};
+use mp4_atom::{DecodeMaybe, Encode};
+
+use super::OrderedFrame;
+
+/// Produces fMP4 init segments and per-frame moof+mdat fragments from catalog info.
+///
+/// Used for exporting a broadcast to stdout as a playable fMP4 stream.
+pub struct Fmp4 {
+	tracks: Vec<Fmp4ExportTrack>,
+}
+
+struct Fmp4ExportTrack {
+	name: String,
+	track_id: u32,
+	timescale: u64,
+	sequence_number: u32,
+}
+
+impl Fmp4 {
+	/// Build from video and audio section configuration.
+	pub fn new(video: &Video, audio: &Audio) -> anyhow::Result<Self> {
+		let mut tracks = Vec::new();
+		let mut track_id = 1u32;
+
+		for (name, config) in &video.renditions {
+			let timescale = match &config.container {
+				Container::Cmaf { init_data } => parse_timescale_from_init(init_data)?,
+				Container::Legacy => guess_video_timescale(config),
+			};
+
+			tracks.push(Fmp4ExportTrack {
+				name: name.clone(),
+				track_id,
+				timescale,
+				sequence_number: 1,
+			});
+			track_id += 1;
+		}
+
+		for (name, config) in &audio.renditions {
+			let timescale = match &config.container {
+				Container::Cmaf { init_data } => parse_timescale_from_init(init_data)?,
+				Container::Legacy => config.sample_rate as u64,
+			};
+
+			tracks.push(Fmp4ExportTrack {
+				name: name.clone(),
+				track_id,
+				timescale,
+				sequence_number: 1,
+			});
+			track_id += 1;
+		}
+
+		Ok(Self { tracks })
+	}
+
+	/// Generate the init segment (ftyp + moov) for all tracks.
+	///
+	/// For multi-track output, decodes each track's init_data, extracts trak+trex,
+	/// and builds a merged ftyp+moov with renumbered track IDs.
+	pub fn init(&self, video: &Video, audio: &Audio) -> anyhow::Result<Bytes> {
+		let mut traks = Vec::new();
+		let mut trexs = Vec::new();
+		let mut ftyp_data = None;
+
+		// Collect all track init data
+		let mut track_inits: Vec<&str> = Vec::new();
+		for config in video.renditions.values() {
+			match &config.container {
+				Container::Cmaf { init_data } => track_inits.push(init_data),
+				Container::Legacy => anyhow::bail!("track is not CMAF"),
+			}
+		}
+		for config in audio.renditions.values() {
+			match &config.container {
+				Container::Cmaf { init_data } => track_inits.push(init_data),
+				Container::Legacy => anyhow::bail!("track is not CMAF"),
+			}
+		}
+
+		for init_data_b64 in &track_inits {
+			let data = base64::engine::general_purpose::STANDARD
+				.decode(init_data_b64)
+				.context("invalid base64 init_data")?;
+
+			let mut cursor = std::io::Cursor::new(&data);
+			while let Some(atom) = mp4_atom::Any::decode_maybe(&mut cursor)? {
+				match atom {
+					mp4_atom::Any::Ftyp(f) => {
+						if ftyp_data.is_none() {
+							ftyp_data = Some(f);
+						}
+					}
+					mp4_atom::Any::Moov(moov) => {
+						// Preserve original track IDs to match CMAF passthrough fragments
+						for trak in moov.trak {
+							traks.push(trak);
+						}
+
+						if let Some(mvex) = moov.mvex {
+							for trex in mvex.trex {
+								trexs.push(trex);
+							}
+						}
+					}
+					_ => {}
+				}
+			}
+		}
+
+		let ftyp = ftyp_data.context("no ftyp found in any init segment")?;
+
+		let timescale = traks.first().map(|t| t.mdia.mdhd.timescale).unwrap_or(90000);
+
+		let moov = mp4_atom::Moov {
+			mvhd: mp4_atom::Mvhd {
+				timescale,
+				..Default::default()
+			},
+			trak: traks,
+			mvex: if trexs.is_empty() {
+				None
+			} else {
+				Some(mp4_atom::Mvex {
+					trex: trexs,
+					..Default::default()
+				})
+			},
+			..Default::default()
+		};
+
+		let mut buf = Vec::new();
+		ftyp.encode(&mut buf)?;
+		moov.encode(&mut buf)?;
+		Ok(Bytes::from(buf))
+	}
+
+	/// Encode a single frame as a moof+mdat fragment.
+	pub fn frame(&mut self, track_name: &str, frame: &OrderedFrame) -> anyhow::Result<Bytes> {
+		let track = self
+			.tracks
+			.iter_mut()
+			.find(|t| t.name == track_name)
+			.context("unknown track")?;
+
+		let dts = frame.timestamp.as_micros() as u64 * track.timescale / 1_000_000;
+		let payload: Vec<u8> = frame.payload.clone().into_iter().flat_map(|c| c.into_iter()).collect();
+		let keyframe = frame.is_keyframe();
+
+		let flags = if keyframe { 0x0200_0000 } else { 0x0001_0000 };
+
+		let seq = track.sequence_number;
+		track.sequence_number += 1;
+
+		// First pass to get moof size (use Some(0) so trun includes the data_offset field)
+		let moof = build_moof(seq, track.track_id, dts, payload.len() as u32, flags, Some(0));
+		let mut buf = Vec::new();
+		moof.encode(&mut buf)?;
+		let moof_size = buf.len();
+
+		// Second pass with data_offset
+		let data_offset = (moof_size + 8) as i32;
+		let moof = build_moof(seq, track.track_id, dts, payload.len() as u32, flags, Some(data_offset));
+		buf.clear();
+		moof.encode(&mut buf)?;
+
+		let mdat = mp4_atom::Mdat { data: payload };
+		mdat.encode(&mut buf)?;
+
+		Ok(Bytes::from(buf))
+	}
+}
+
+fn build_moof(seq: u32, track_id: u32, dts: u64, size: u32, flags: u32, data_offset: Option<i32>) -> mp4_atom::Moof {
+	mp4_atom::Moof {
+		mfhd: mp4_atom::Mfhd { sequence_number: seq },
+		traf: vec![mp4_atom::Traf {
+			tfhd: mp4_atom::Tfhd {
+				track_id,
+				..Default::default()
+			},
+			tfdt: Some(mp4_atom::Tfdt {
+				base_media_decode_time: dts,
+			}),
+			trun: vec![mp4_atom::Trun {
+				data_offset,
+				entries: vec![mp4_atom::TrunEntry {
+					size: Some(size),
+					flags: Some(flags),
+					..Default::default()
+				}],
+			}],
+			..Default::default()
+		}],
+	}
+}
+
+fn parse_timescale_from_init(init_data_b64: &str) -> anyhow::Result<u64> {
+	let data = base64::engine::general_purpose::STANDARD
+		.decode(init_data_b64)
+		.context("invalid base64")?;
+	let mut cursor = std::io::Cursor::new(&data);
+	while let Some(atom) = mp4_atom::Any::decode_maybe(&mut cursor)? {
+		if let mp4_atom::Any::Moov(moov) = atom {
+			let trak = moov.trak.first().context("no tracks in moov")?;
+			return Ok(trak.mdia.mdhd.timescale as u64);
+		}
+	}
+	anyhow::bail!("no moov in init data")
+}
+
+fn guess_video_timescale(config: &VideoConfig) -> u64 {
+	if let Some(fps) = config.framerate {
+		(fps * 1000.0) as u64
+	} else {
+		90000
+	}
+}
diff --git a/rs/moq-mux/src/consumer/frame.rs b/rs/moq-mux/src/consumer/frame.rs
new file mode 100644
index 000000000..4789054bc
--- /dev/null
+++ b/rs/moq-mux/src/consumer/frame.rs
@@ -0,0 +1,29 @@
+use buf_list::BufList;
+
+use super::Timestamp;
+
+/// A frame returned by [`super::OrderedConsumer::read()`] with group context.
+#[derive(Clone, Debug)]
+pub struct OrderedFrame {
+	/// The presentation timestamp for this frame.
+	pub timestamp: Timestamp,
+
+	/// The encoded media data for this frame, split into chunks.
+	pub payload: BufList,
+
+	/// The group sequence number this frame belongs to.
+	pub group: u64,
+
+	/// The frame index within the group (0 = first frame in the group).
+	///
+	/// With duration-based grouping (e.g. audio), the first frame is not
+	/// necessarily a keyframe — it only denotes position within the group.
+	pub index: usize,
+}
+
+impl OrderedFrame {
+	/// Returns true if this is the first frame in the group (index 0).
+	pub fn is_keyframe(&self) -> bool {
+		self.index == 0
+	}
+}
diff --git a/rs/moq-mux/src/consumer/mod.rs b/rs/moq-mux/src/consumer/mod.rs
new file mode 100644
index 000000000..f119603f0
--- /dev/null
+++ b/rs/moq-mux/src/consumer/mod.rs
@@ -0,0 +1,11 @@
+mod container;
+mod fmp4;
+mod frame;
+mod muxer;
+mod ordered;
+
+pub use container::*;
+pub use fmp4::*;
+pub use frame::*;
+pub use muxer::*;
+pub use ordered::*;
diff --git a/rs/moq-mux/src/consumer/muxer.rs b/rs/moq-mux/src/consumer/muxer.rs
new file mode 100644
index 000000000..b9b072422
--- /dev/null
+++ b/rs/moq-mux/src/consumer/muxer.rs
@@ -0,0 +1,103 @@
+use std::task::Poll;
+
+use super::container::Error;
+use super::{ContainerFormat, OrderedConsumer, OrderedFrame};
+
+/// A frame returned by [`OrderedMuxer::read()`] with its track name.
+pub struct MuxedFrame {
+	/// The track name this frame belongs to.
+	pub name: String,
+	/// The frame data.
+	pub frame: OrderedFrame,
+}
+
+/// Merges multiple track consumers into a single timestamp-ordered stream.
+///
+/// Given N consumers (one per track), yields frames in ascending timestamp order
+/// across all tracks. This enables proper interleaving for multi-track fMP4 output.
+pub struct OrderedMuxer<F: ContainerFormat> {
+	tracks: Vec<MuxerTrack<F>>,
+}
+
+struct MuxerTrack<F: ContainerFormat> {
+	name: String,
+	consumer: OrderedConsumer<F>,
+	pending: Option<OrderedFrame>,
+	finished: bool,
+}
+
+impl<F: ContainerFormat> OrderedMuxer<F> {
+	/// Create a new muxer from a list of (name, consumer) pairs.
+	pub fn new(tracks: Vec<(String, OrderedConsumer<F>)>) -> Self {
+		Self {
+			tracks: tracks
+				.into_iter()
+				.map(|(name, consumer)| MuxerTrack {
+					name,
+					consumer,
+					pending: None,
+					finished: false,
+				})
+				.collect(),
+		}
+	}
+
+	/// Read the next frame in timestamp order across all tracks.
+	///
+	/// Returns `None` when all tracks have ended.
+	pub async fn read(&mut self) -> Result<Option<MuxedFrame>, Error> {
+		conducer::wait(|waiter| self.poll_read(waiter)).await
+	}
+
+	/// Poll-based implementation.
+	pub fn poll_read(&mut self, waiter: &conducer::Waiter) -> Poll<Result<Option<MuxedFrame>, Error>> {
+		// Fill empty pending slots
+		for track in &mut self.tracks {
+			if track.pending.is_none() && !track.finished {
+				match track.consumer.poll_read(waiter) {
+					Poll::Ready(Ok(Some(frame))) => {
+						track.pending = Some(frame);
+					}
+					Poll::Ready(Ok(None)) => {
+						track.finished = true;
+					}
+					Poll::Ready(Err(e)) => {
+						track.finished = true;
+						tracing::warn!(track = %track.name, error = ?e, "track error, marking finished");
+					}
+					Poll::Pending => {}
+				}
+			}
+		}
+
+		// Find minimum timestamp across pending frames
+		let mut min_idx = None;
+		let mut min_ts = None;
+
+		for (i, track) in self.tracks.iter().enumerate() {
+			if let Some(frame) = &track.pending {
+				let ts: std::time::Duration = frame.timestamp.into();
+				if min_ts.is_none() || ts < min_ts.unwrap() {
+					min_ts = Some(ts);
+					min_idx = Some(i);
+				}
+			}
+		}
+
+		// Return the frame with the smallest timestamp
+		if let Some(idx) = min_idx {
+			let track = &mut self.tracks[idx];
+			let frame = track.pending.take().unwrap();
+			let name = track.name.clone();
+			return Poll::Ready(Ok(Some(MuxedFrame { name, frame })));
+		}
+
+		// All finished + no pending → None
+		if self.tracks.iter().all(|t| t.finished) {
+			return Poll::Ready(Ok(None));
+		}
+
+		// Still waiting for data
+		Poll::Pending
+	}
+}
diff --git a/rs/moq-mux/src/consumer/ordered.rs b/rs/moq-mux/src/consumer/ordered.rs
new file mode 100644
index 000000000..e27942573
--- /dev/null
+++ b/rs/moq-mux/src/consumer/ordered.rs
@@ -0,0 +1,1192 @@
+use std::collections::VecDeque;
+use std::task::{Poll, ready};
+
+use buf_list::BufList;
+
+use super::container::Error;
+use super::{ContainerFormat, OrderedFrame, Timestamp};
+
+/// A consumer for media tracks with timestamp reordering.
+///
+/// This wraps a `moq_lite::TrackSubscriber` and adds functionality
+/// like timestamp decoding, latency management, and frame buffering.
+///
+/// Generic over `F: ContainerFormat` to support different container encodings.
+///
+/// ## Latency Management
+///
+/// The consumer can skip groups that are too far behind to maintain low latency.
+/// Configure the maximum acceptable delay through the consumer's latency settings.
+pub struct OrderedConsumer<F: ContainerFormat> {
+	pub track: moq_lite::TrackSubscriber,
+
+	format: F,
+
+	// The current group that we want to read from
+	current: u64,
+
+	// Groups that we are monitoring, sorted by sequence ascending.
+	pending: VecDeque<GroupBuffer>,
+
+	// When true, we haven't returned a frame yet and need to select the first group.
+	// We wait until we have at least one frame before finalizing `current`
+	startup: bool,
+
+	// The maximum buffer size before skipping a group.
+	max_latency: std::time::Duration,
+}
+
+impl<F: ContainerFormat> OrderedConsumer<F> {
+	/// Create a new OrderedConsumer wrapping the given moq-lite consumer.
+	pub fn new(track: moq_lite::TrackSubscriber, format: F, max_latency: std::time::Duration) -> Self {
+		Self {
+			track,
+			format,
+			current: 0,
+			pending: VecDeque::new(),
+			startup: true,
+			max_latency,
+		}
+	}
+
+	/// Read the next frame from the track.
+	///
+	/// This method handles timestamp decoding, group ordering, and latency management
+	/// automatically. It will skip groups that are too far behind to maintain the
+	/// configured latency target.
+	///
+	/// Returns `None` when the track has ended.
+	pub async fn read(&mut self) -> Result<Option<OrderedFrame>, Error> {
+		conducer::wait(|waiter| self.poll_read(waiter)).await
+	}
+
+	/// Poll-based implementation of the read loop.
+	///
+	/// Uses a single waiter that gets registered on all relevant conducer channels,
+	/// avoiding the need for `tokio::select!` or `FuturesUnordered`.
+	pub fn poll_read(&mut self, waiter: &conducer::Waiter) -> Poll<Result<Option<OrderedFrame>, Error>> {
+		// Grab any new groups from the track, recording whether the track is finished.
+		let finished = self.poll_read_finish(waiter)?.is_ready();
+
+		// On startup, we want to poll every pending group and advance self.current to the first with a frame.
+		if self.startup {
+			// NOTE: We loop in ascending order, so earlier groups will win the race.
+			for (i, group) in self.pending.iter_mut().enumerate() {
+				// We call poll_min_timestamp to try to buffer at least one frame per group.
+				// This returns Ready(Ok) if there is a buffered frame.
+				if !matches!(group.poll_min_timestamp(waiter, &self.format), Poll::Ready(Ok(_))) {
+					continue;
+				}
+
+				// Start reading from this group and skip any previous groups.
+				self.current = group.info.sequence;
+				self.startup = false;
+				self.pending.drain(0..i);
+				break;
+			}
+		}
+
+		loop {
+			// Return the next frame from the current group if possible.
+			// If the current group is finished or errored, advance to the next group.
+			while let Some(group) = self.pending.front_mut()
+				&& group.info.sequence <= self.current
+			{
+				match group.poll_read(waiter, &self.format) {
+					Poll::Ready(Ok(Some(frame))) => return Poll::Ready(Ok(Some(frame))),
+					// Still blocked on this group, don't skip it yet.
+					Poll::Pending => break,
+					Poll::Ready(Err(e)) => {
+						tracing::warn!(error = ?e, "error reading current group, skipping");
+					}
+					// No more frames, advance to next group.
+					Poll::Ready(Ok(None)) => {}
+				}
+
+				self.pending.pop_front();
+				self.current += 1
+			}
+
+			// Get the current group's min timestamp as the reference for latency comparison.
+			let oldest_timestamp = if let Some(current) = self.pending.front_mut()
+				&& current.info.sequence <= self.current
+			{
+				match current.poll_min_timestamp(waiter, &self.format) {
+					Poll::Ready(Ok(ts)) => Some::<std::time::Duration>(ts.into()),
+					_ => None,
+				}
+			} else {
+				None
+			};
+
+			// Find the first newer group with data (our skip target).
+			let mut min_idx = None;
+			for (i, group) in self.pending.iter_mut().enumerate() {
+				if group.info.sequence <= self.current {
+					continue;
+				}
+
+				if let Poll::Ready(Ok(_)) = group.poll_min_timestamp(waiter, &self.format) {
+					min_idx = Some(i);
+					break;
+				}
+			}
+
+			// Find the max timestamp across all newer groups.
+			let mut max_timestamp = std::time::Duration::ZERO;
+			for group in self.pending.iter_mut().rev() {
+				if group.info.sequence <= self.current {
+					break;
+				}
+
+				if let Poll::Ready(Ok(ts)) = group.poll_max_timestamp(waiter, &self.format) {
+					max_timestamp = max_timestamp.max(ts.into());
+					break; // We know older groups won't be newer than this.
+				}
+			}
+
+			let should_skip = if min_idx.is_some() {
+				if let Some(oldest) = oldest_timestamp {
+					// Current group is blocking: skip if newer groups exceed latency threshold
+					max_timestamp.saturating_sub(oldest) >= self.max_latency
+				} else {
+					// Sequence gap: current group consumed but next sequence missing.
+					// Only skip if track is fully received (no more groups coming).
+					finished
+				}
+			} else {
+				false
+			};
+
+			if let Some(new_idx) = min_idx
+				&& should_skip
+			{
+				self.pending.drain(0..new_idx);
+				let new_current = self.pending.front().map(|g| g.info.sequence).unwrap();
+
+				tracing::debug!(old = self.current, new = new_current, "skipping slow groups");
+
+				self.current = new_current;
+				continue;
+			}
+
+			if finished && self.pending.is_empty() {
+				return Poll::Ready(Ok(None));
+			}
+
+			return Poll::Pending;
+		}
+	}
+
+	// Reads any new groups from the track until we're completely finished.
+	//
+	// Returns Pending until all groups have been consumed.
+	fn poll_read_finish(&mut self, waiter: &conducer::Waiter) -> Poll<Result<(), Error>> {
+		loop {
+			let Some(group) = ready!(self.track.poll_recv_group(waiter)?) else {
+				// Track is finished.
+				return Poll::Ready(Ok(()));
+			};
+
+			let reader = GroupBuffer::new(group);
+			if reader.group.info.sequence < self.current {
+				tracing::debug!(
+					old = ?reader.group.info.sequence,
+					current = ?self.current,
+					"skipping old group"
+				);
+				continue;
+			}
+
+			let idx = self
+				.pending
+				.partition_point(|g| g.group.info.sequence < reader.group.info.sequence);
+			self.pending.insert(idx, reader);
+		}
+	}
+
+	/// Set the maximum latency tolerance for this consumer.
+	///
+	/// Groups with timestamps older than `max_timestamp - max_latency` will be skipped.
+	pub fn set_max_latency(&mut self, max: std::time::Duration) {
+		self.max_latency = max;
+	}
+
+	/// Wait until the track is closed.
+	pub async fn closed(&self) -> Result<(), Error> {
+		Ok(self.track.closed().await?)
+	}
+}
+
+impl<F: ContainerFormat> From<OrderedConsumer<F>> for moq_lite::TrackSubscriber {
+	fn from(inner: OrderedConsumer<F>) -> Self {
+		inner.track
+	}
+}
+
+impl<F: ContainerFormat> std::ops::Deref for OrderedConsumer<F> {
+	type Target = moq_lite::TrackSubscriber;
+
+	fn deref(&self) -> &Self::Target {
+		&self.track
+	}
+}
+
+/// Internal reader for a group of frames.
+///
+/// Handles two-phase frame reading (get FrameConsumer, then read all data),
+/// timestamp parsing, and min/max timestamp tracking for latency decisions.
+struct GroupBuffer {
+	group: moq_lite::GroupConsumer,
+
+	// The current frame index within the group.
+	index: usize,
+
+	// Read frames that haven't been consumed yet.
+	buffered: VecDeque<OrderedFrame>,
+
+	// The minimum timestamp in the group.
+	min_timestamp: Option<Timestamp>,
+
+	// The maximum timestamp in the group.
+	max_timestamp: Option<Timestamp>,
+}
+
+impl GroupBuffer {
+	fn new(group: moq_lite::GroupConsumer) -> Self {
+		Self {
+			group,
+			index: 0,
+			buffered: VecDeque::new(),
+			max_timestamp: None,
+			min_timestamp: None,
+		}
+	}
+
+	/// Poll for the next frame from this group.
+	fn poll_read<F: ContainerFormat>(
+		&mut self,
+		waiter: &conducer::Waiter,
+		format: &F,
+	) -> Poll<Result<Option<OrderedFrame>, Error>> {
+		if let Some(frame) = self.buffered.pop_front() {
+			return Poll::Ready(Ok(Some(frame)));
+		}
+
+		match ready!(self.buffer_one(waiter, format)?) {
+			true => Poll::Ready(Ok(Some(self.buffered.pop_front().unwrap()))),
+			false => Poll::Ready(Ok(None)),
+		}
+	}
+
+	// Add one more frame to the buffer if possible.
+	//
+	// Returns false if the track is finished.
+	fn buffer_once<F: ContainerFormat>(&mut self, waiter: &conducer::Waiter, format: &F) -> Poll<Result<bool, Error>> {
+		let Some(chunks) = ready!(self.group.poll_read_frame_chunks(waiter)?) else {
+			return Poll::Ready(Ok(false));
+		};
+
+		let payload = BufList::from_iter(chunks);
+		let (timestamp, payload) = format.parse(payload).map_err(Into::into)?;
+
+		self.min_timestamp = Some(match self.min_timestamp {
+			Some(existing) => existing.min(timestamp),
+			None => timestamp,
+		});
+
+		self.max_timestamp = Some(match self.max_timestamp {
+			Some(existing) => existing.max(timestamp),
+			None => timestamp,
+		});
+
+		let index = self.index;
+		self.index += 1;
+
+		self.buffered.push_back(OrderedFrame {
+			timestamp,
+			payload,
+			group: self.group.info.sequence,
+			index,
+		});
+
+		Poll::Ready(Ok(true))
+	}
+
+	fn buffer_one<F: ContainerFormat>(&mut self, waiter: &conducer::Waiter, format: &F) -> Poll<Result<bool, Error>> {
+		if self.buffered.is_empty() {
+			self.buffer_once(waiter, format)
+		} else {
+			Poll::Ready(Ok(true))
+		}
+	}
+
+	fn buffer_all<F: ContainerFormat>(&mut self, waiter: &conducer::Waiter, format: &F) -> Poll<Result<(), Error>> {
+		while ready!(self.buffer_once(waiter, format)?) {}
+		Poll::Ready(Ok(()))
+	}
+
+	/// Poll for the maximum timestamp in this group.
+	fn poll_max_timestamp<F: ContainerFormat>(
+		&mut self,
+		waiter: &conducer::Waiter,
+		format: &F,
+	) -> Poll<Result<Timestamp, Error>> {
+		// Keep reading more frames just to advance the max timestamp.
+		let _ = self.buffer_all(waiter, format)?;
+
+		if let Some(max) = self.max_timestamp {
+			return Poll::Ready(Ok(max));
+		}
+
+		if let Poll::Ready(_frames) = self.group.poll_finished(waiter)? {
+			return Poll::Ready(Err(Error::Other("empty group".into())));
+		}
+
+		Poll::Pending
+	}
+
+	fn poll_min_timestamp<F: ContainerFormat>(
+		&mut self,
+		waiter: &conducer::Waiter,
+		format: &F,
+	) -> Poll<Result<Timestamp, Error>> {
+		let _ = self.buffer_one(waiter, format)?;
+
+		if let Some(min) = self.min_timestamp {
+			return Poll::Ready(Ok(min));
+		}
+
+		if let Poll::Ready(_frames) = self.group.poll_finished(waiter)? {
+			return Poll::Ready(Err(Error::Other("empty group".into())));
+		}
+
+		Poll::Pending
+	}
+}
+
+impl std::ops::Deref for GroupBuffer {
+	type Target = moq_lite::GroupConsumer;
+
+	fn deref(&self) -> &Self::Target {
+		&self.group
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::consumer::Legacy;
+	use std::time::Duration;
+
+	use bytes::Bytes;
+	use hang::container::Frame;
+
+	fn ts(micros: u64) -> Timestamp {
+		Timestamp::from_micros(micros).unwrap()
+	}
+
+	/// Write a finished group with explicit sequence and timestamps (Legacy format).
+	fn write_group(track: &mut moq_lite::TrackProducer, sequence: u64, timestamps: &[Timestamp]) {
+		let mut group = track.create_group(moq_lite::Group { sequence }).unwrap();
+		for &timestamp in timestamps {
+			let frame = Frame {
+				timestamp,
+				payload: BufList::from_iter(vec![Bytes::from_static(&[0xDE, 0xAD])]),
+			};
+			frame.encode(&mut group).unwrap();
+		}
+		group.finish().unwrap();
+	}
+
+	/// Drain all available frames with a per-read timeout.
+	async fn read_all(consumer: &mut OrderedConsumer<Legacy>) -> Result<Vec<OrderedFrame>, Error> {
+		let mut frames = Vec::new();
+		loop {
+			match tokio::time::timeout(Duration::from_millis(200), consumer.read()).await {
+				Ok(Ok(Some(frame))) => frames.push(frame),
+				Ok(Ok(None)) => break,
+				Ok(Err(e)) => return Err(e),
+				Err(_) => panic!(
+					"read_all: OrderedConsumer::read timed out after 200ms ({} frames collected so far)",
+					frames.len()
+				),
+			}
+		}
+		Ok(frames)
+	}
+
+	// ---- Basic Reading ----
+
+	#[tokio::test]
+	async fn read_single_group() {
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(500));
+
+		write_group(&mut track, 0, &[ts(0)]);
+		track.finish().unwrap();
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		assert_eq!(frames.len(), 1);
+		assert_eq!(frames[0].timestamp, ts(0));
+		assert_eq!(frames[0].index, 0);
+
+		// Next read returns None (track ended)
+		assert!(consumer.read().await.unwrap().is_none());
+	}
+
+	#[tokio::test]
+	async fn read_multiple_frames_single_group() {
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(500));
+
+		write_group(&mut track, 0, &[ts(0), ts(33_000), ts(66_000)]);
+		track.finish().unwrap();
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		assert_eq!(frames.len(), 3);
+		assert_eq!(frames[0].timestamp, ts(0));
+		assert_eq!(frames[1].timestamp, ts(33_000));
+		assert_eq!(frames[2].timestamp, ts(66_000));
+
+		assert_eq!(frames[0].index, 0);
+		assert_eq!(frames[1].index, 1);
+		assert_eq!(frames[2].index, 2);
+	}
+
+	#[tokio::test]
+	async fn read_multiple_groups_within_latency() {
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(500));
+
+		// 5 groups, 20ms spacing. Total span = 80ms, well within 500ms latency.
+		for i in 0..5u64 {
+			write_group(&mut track, i, &[ts(i * 20_000)]);
+		}
+		track.finish().unwrap();
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		assert_eq!(frames.len(), 5);
+	}
+
+	// ---- Latency Skipping ----
+
+	#[tokio::test]
+	async fn latency_skip_delivers_recent_groups() {
+		tokio::time::pause();
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(100));
+
+		// Group 0: 5 frames, NOT finished (blocks consumer)
+		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
+		for f in 0..5u64 {
+			Frame {
+				timestamp: ts(f * 2_000),
+				payload: BufList::from_iter(vec![Bytes::from_static(&[0xDE, 0xAD])]),
+			}
+			.encode(&mut group0)
+			.unwrap();
+		}
+
+		// Groups 1-19: finished, 15ms spacing, 5 frames each
+		for g in 1..20u64 {
+			let timestamps: Vec<_> = (0..5).map(|f| ts(g * 15_000 + f * 2_000)).collect();
+			write_group(&mut track, g, &timestamps);
+		}
+		track.finish().unwrap();
+
+		// Finish group 0 after consumer has had time to accumulate pending groups
+		let finisher = tokio::spawn(async move {
+			tokio::time::sleep(Duration::from_millis(50)).await;
+			group0.finish().unwrap();
+		});
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		// Group 0's 5 frames + some later groups (earlier ones skipped by latency)
+		assert!(frames.len() >= 25, "Expected >= 25 frames, got {}", frames.len());
+		finisher.await.expect("finisher task panicked");
+	}
+
+	#[tokio::test]
+	async fn zero_latency_skips_aggressively() {
+		tokio::time::pause();
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::ZERO);
+
+		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
+		Frame {
+			timestamp: ts(400_000),
+			payload: BufList::from_iter(vec![Bytes::from_static(&[0xDE, 0xAD])]),
+		}
+		.encode(&mut group0)
+		.unwrap();
+
+		for g in 1..10u64 {
+			let timestamps: Vec<_> = (0..3).map(|f| ts(g * 50_000 + f * 5_000)).collect();
+			write_group(&mut track, g, &timestamps);
+		}
+		track.finish().unwrap();
+
+		let finisher = tokio::spawn(async move {
+			tokio::time::sleep(Duration::from_millis(50)).await;
+			group0.finish().unwrap();
+		});
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		assert_eq!(frames.len(), 28, "Expected group 0 frame + groups 1-9");
+		assert!(!frames.is_empty(), "Expected at least some frames");
+		finisher.await.expect("finisher task panicked");
+	}
+
+	#[tokio::test]
+	async fn latency_skip_correctness() {
+		tokio::time::pause();
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(100));
+
+		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
+		Frame {
+			timestamp: ts(0),
+			payload: BufList::from_iter(vec![Bytes::from_static(&[0xDE, 0xAD])]),
+		}
+		.encode(&mut group0)
+		.unwrap();
+
+		for g in 1..10u64 {
+			write_group(&mut track, g, &[ts(g * 30_000)]);
+		}
+		track.finish().unwrap();
+
+		let finisher = tokio::spawn(async move {
+			tokio::time::sleep(Duration::from_millis(50)).await;
+			group0.finish().unwrap();
+		});
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		assert!(!frames.is_empty(), "Expected at least some frames");
+		assert_eq!(frames.len(), 10, "Expected group 0 frame + groups 1-9");
+		assert_eq!(frames[0].timestamp, ts(0));
+
+		for i in 1..10u64 {
+			assert_eq!(frames[i as usize].timestamp, ts(i * 30_000));
+		}
+		finisher.await.expect("finisher task panicked");
+	}
+
+	// ---- Group Ordering ----
+
+	#[tokio::test]
+	async fn groups_delivered_in_sequence_order() {
+		tokio::time::pause();
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(500));
+
+		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
+		Frame {
+			timestamp: ts(0),
+			payload: BufList::from_iter(vec![Bytes::from_static(&[0xDE, 0xAD])]),
+		}
+		.encode(&mut group0)
+		.unwrap();
+
+		write_group(&mut track, 2, &[ts(60_000)]);
+		write_group(&mut track, 1, &[ts(30_000)]);
+		track.finish().unwrap();
+
+		let finisher = tokio::spawn(async move {
+			tokio::time::sleep(Duration::from_millis(10)).await;
+			group0.finish().unwrap();
+		});
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		assert_eq!(frames.len(), 3);
+		assert_eq!(frames[0].timestamp, ts(0));
+		assert_eq!(frames[1].timestamp, ts(30_000));
+		assert_eq!(frames[2].timestamp, ts(60_000));
+		finisher.await.expect("finisher task panicked");
+	}
+
+	#[tokio::test]
+	async fn adjacent_group_flushed_immediately() {
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(500));
+
+		write_group(&mut track, 0, &[ts(0)]);
+		write_group(&mut track, 1, &[ts(30_000)]);
+		track.finish().unwrap();
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		assert_eq!(frames.len(), 2);
+		assert_eq!(frames[0].timestamp, ts(0));
+		assert_eq!(frames[1].timestamp, ts(30_000));
+	}
+
+	// ---- B-frames ----
+
+	#[tokio::test]
+	async fn bframes_within_group() {
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(500));
+
+		write_group(&mut track, 0, &[ts(0), ts(66_000), ts(33_000)]);
+		track.finish().unwrap();
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		assert_eq!(frames.len(), 3);
+		assert_eq!(frames[0].timestamp, ts(0));
+		assert_eq!(frames[1].timestamp, ts(66_000));
+		assert_eq!(frames[2].timestamp, ts(33_000));
+	}
+
+	// ---- Track Lifecycle ----
+
+	#[tokio::test]
+	async fn empty_track_returns_none() {
+		tokio::time::pause();
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(500));
+
+		track.finish().unwrap();
+
+		let result = tokio::time::timeout(Duration::from_millis(200), consumer.read()).await;
+		match result {
+			Ok(Ok(None)) => {} // expected: track ended
+			Ok(Ok(Some(_))) => panic!("expected None for empty track, got Some"),
+			Ok(Err(e)) => panic!("expected None for empty track, got error: {e}"),
+			Err(_) => panic!("should not hang on empty track"),
+		}
+	}
+
+	#[tokio::test]
+	async fn track_closed_with_error() {
+		tokio::time::pause();
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(500));
+
+		write_group(&mut track, 0, &[ts(0)]);
+		track.abort(moq_lite::Error::Cancel).unwrap();
+
+		let result = tokio::time::timeout(Duration::from_millis(500), async {
+			let mut frames = Vec::new();
+			while let Ok(Some(frame)) = consumer.read().await {
+				frames.push(frame);
+			}
+			frames
+		})
+		.await;
+
+		assert!(result.is_ok(), "Consumer should not hang after track error");
+	}
+
+	#[tokio::test]
+	async fn closed_resolves_when_track_ends() {
+		tokio::time::pause();
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(500));
+
+		assert!(
+			tokio::time::timeout(Duration::from_millis(50), consumer.closed())
+				.await
+				.is_err()
+		);
+
+		track.finish().unwrap();
+		drop(track);
+
+		tokio::time::timeout(Duration::from_millis(200), consumer.closed())
+			.await
+			.expect("timeout expired waiting for closed()")
+			.expect("consumer.closed() returned an error");
+	}
+
+	// ---- Gap Recovery ----
+
+	#[tokio::test]
+	async fn gap_in_group_sequence_recovery() {
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(100));
+
+		write_group(&mut track, 0, &[ts(0), ts(20_000)]);
+		write_group(&mut track, 1, &[ts(40_000), ts(60_000)]);
+		write_group(&mut track, 3, &[ts(120_000), ts(140_000)]);
+		write_group(&mut track, 4, &[ts(160_000), ts(180_000)]);
+		write_group(&mut track, 5, &[ts(200_000), ts(220_000)]);
+		write_group(&mut track, 6, &[ts(240_000), ts(260_000)]);
+		track.finish().unwrap();
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		assert!(frames.len() >= 4, "Expected >= 4 frames, got {}", frames.len());
+	}
+
+	#[tokio::test]
+	async fn gap_at_start_of_sequence() {
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(80));
+
+		write_group(&mut track, 5, &[ts(0), ts(20_000)]);
+		write_group(&mut track, 7, &[ts(80_000), ts(100_000)]);
+		write_group(&mut track, 8, &[ts(120_000), ts(140_000)]);
+		write_group(&mut track, 9, &[ts(160_000), ts(180_000)]);
+		track.finish().unwrap();
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		assert!(frames.len() >= 4, "Expected >= 4 frames, got {}", frames.len());
+	}
+
+	// ---- Frame Decoding ----
+
+	#[tokio::test]
+	async fn frame_timestamp_and_index_decoding() {
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(500));
+
+		write_group(&mut track, 0, &[ts(0), ts(33_333), ts(66_666)]);
+		track.finish().unwrap();
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		assert_eq!(frames.len(), 3);
+
+		assert_eq!(frames[0].timestamp, ts(0));
+		assert_eq!(frames[0].index, 0);
+
+		assert_eq!(frames[1].timestamp, ts(33_333));
+		assert_eq!(frames[1].index, 1);
+
+		assert_eq!(frames[2].timestamp, ts(66_666));
+		assert_eq!(frames[2].index, 2);
+	}
+
+	#[tokio::test]
+	async fn frame_payload_preserved() {
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(500));
+
+		let payload_bytes = vec![0x01, 0x02, 0x03, 0x04, 0x05];
+		let mut group = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
+		Frame {
+			timestamp: ts(0),
+			payload: BufList::from_iter(vec![Bytes::from(payload_bytes.clone())]),
+		}
+		.encode(&mut group)
+		.unwrap();
+		group.finish().unwrap();
+		track.finish().unwrap();
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		assert_eq!(frames.len(), 1);
+
+		use bytes::Buf;
+		let mut received = Vec::new();
+		let mut payload = frames[0].payload.clone();
+		while payload.has_remaining() {
+			received.push(payload.get_u8());
+		}
+		assert_eq!(received, payload_bytes);
+	}
+
+	// ---- Regression ----
+
+	#[tokio::test]
+	async fn no_infinite_loop_with_buffered_frames() {
+		tokio::time::pause();
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_secs(10));
+
+		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
+		Frame {
+			timestamp: ts(0),
+			payload: BufList::from_iter(vec![Bytes::from_static(&[0xDE, 0xAD])]),
+		}
+		.encode(&mut group0)
+		.unwrap();
+
+		write_group(&mut track, 1, &[ts(100_000)]);
+
+		let finisher = tokio::spawn(async move {
+			tokio::time::sleep(Duration::from_millis(20)).await;
+			// Write group 2: recv_group fires, drops current buffer_until for group 1
+			write_group(&mut track, 2, &[ts(200_000)]);
+			tokio::time::sleep(Duration::from_millis(20)).await;
+			group0.finish().unwrap();
+			track.finish().unwrap();
+		});
+
+		let frames = tokio::time::timeout(Duration::from_secs(2), async {
+			let mut frames = Vec::new();
+			while let Some(frame) = consumer.read().await.unwrap() {
+				frames.push(frame);
+			}
+			frames
+		})
+		.await
+		.expect("consumer hung — possible infinite loop regression");
+
+		assert_eq!(frames.len(), 3);
+		finisher.await.expect("finisher task panicked");
+	}
+
+	// ---- Edge Cases ----
+
+	#[tokio::test]
+	async fn large_timestamps() {
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_secs(3700));
+
+		let one_hour = 3_600_000_000u64;
+		write_group(&mut track, 0, &[ts(one_hour)]);
+		track.finish().unwrap();
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		assert_eq!(frames.len(), 1);
+		assert_eq!(frames[0].timestamp, ts(one_hour));
+		assert_eq!(frames[0].timestamp.as_micros(), one_hour as u128);
+	}
+
+	#[tokio::test]
+	async fn set_max_latency_changes_behavior() {
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_secs(10));
+
+		write_group(&mut track, 0, &[ts(0)]);
+		track.finish().unwrap();
+
+		let frame = consumer.read().await.unwrap().unwrap();
+		assert_eq!(frame.timestamp, ts(0));
+
+		consumer.set_max_latency(Duration::from_millis(100));
+
+		assert!(consumer.read().await.unwrap().is_none());
+	}
+
+	#[tokio::test]
+	async fn max_timestamp_tracks_through_bframes() {
+		tokio::time::pause();
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		// max_latency must exceed (group1_max - group0_min) = 100ms - 0ms = 100ms
+		// to avoid the latency skip and test B-frame timestamp tracking.
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(110));
+
+		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
+		for &timestamp in &[ts(0), ts(66_000), ts(33_000)] {
+			Frame {
+				timestamp,
+				payload: BufList::from_iter(vec![Bytes::from_static(&[0xDE, 0xAD])]),
+			}
+			.encode(&mut group0)
+			.unwrap();
+		}
+
+		write_group(&mut track, 1, &[ts(100_000)]);
+		track.finish().unwrap();
+
+		let finisher = tokio::spawn(async move {
+			tokio::time::sleep(Duration::from_millis(50)).await;
+			group0.finish().unwrap();
+		});
+
+		let frames = tokio::time::timeout(Duration::from_secs(2), async {
+			let mut frames = Vec::new();
+			while let Some(frame) = consumer.read().await.unwrap() {
+				frames.push(frame);
+			}
+			frames
+		})
+		.await
+		.expect("consumer hung — max_timestamp regression");
+
+		assert_eq!(frames.len(), 4, "Expected all 4 frames, got {}", frames.len());
+		assert_eq!(frames[0].timestamp, ts(0));
+		assert_eq!(frames[1].timestamp, ts(66_000));
+		assert_eq!(frames[2].timestamp, ts(33_000));
+		assert_eq!(frames[3].timestamp, ts(100_000));
+		finisher.await.expect("finisher task panicked");
+	}
+
+	// ---- Startup Behavior ----
+
+	#[tokio::test]
+	async fn startup_selects_earliest_group() {
+		tokio::time::pause();
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(100));
+
+		write_group(&mut track, 3, &[ts(0)]);
+		write_group(&mut track, 5, &[ts(150_000)]);
+
+		let mut group7 = track.create_group(moq_lite::Group { sequence: 7 }).unwrap();
+		Frame {
+			timestamp: ts(300_000),
+			payload: BufList::from_iter(vec![Bytes::from_static(&[0xDE, 0xAD])]),
+		}
+		.encode(&mut group7)
+		.unwrap();
+
+		let finisher = tokio::spawn(async move {
+			tokio::time::sleep(Duration::from_millis(50)).await;
+			Frame {
+				timestamp: ts(400_000),
+				payload: BufList::from_iter(vec![Bytes::from_static(&[0xBE, 0xEF])]),
+			}
+			.encode(&mut group7)
+			.unwrap();
+			group7.finish().unwrap();
+			track.finish().unwrap();
+		});
+
+		let frames = tokio::time::timeout(Duration::from_secs(2), async {
+			let mut frames = Vec::new();
+			while let Some(frame) = consumer.read().await.unwrap() {
+				frames.push(frame);
+			}
+			frames
+		})
+		.await
+		.expect("should not hang");
+
+		assert_eq!(frames[0].group, 3);
+		assert_eq!(frames[1].group, 5);
+		assert!(frames.iter().skip(2).all(|f| f.group == 7));
+		finisher.await.unwrap();
+	}
+
+	#[tokio::test]
+	async fn startup_skips_groups_without_data() {
+		tokio::time::pause();
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(500));
+
+		let _group5 = track.create_group(moq_lite::Group { sequence: 5 }).unwrap();
+		write_group(&mut track, 7, &[ts(210_000)]);
+		track.finish().unwrap();
+
+		let frames = tokio::time::timeout(Duration::from_millis(500), async {
+			let mut frames = Vec::new();
+			while let Some(frame) = consumer.read().await.unwrap() {
+				frames.push(frame);
+			}
+			frames
+		})
+		.await
+		.expect("should not hang");
+
+		assert!(!frames.is_empty());
+		assert_eq!(frames[0].group, 7);
+	}
+
+	#[tokio::test]
+	async fn startup_single_group_mid_stream() {
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(500));
+
+		write_group(&mut track, 100, &[ts(3_000_000)]);
+		track.finish().unwrap();
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		assert_eq!(frames.len(), 1);
+		assert_eq!(frames[0].group, 100);
+	}
+
+	#[tokio::test]
+	async fn multiple_sequential_latency_skips() {
+		tokio::time::pause();
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(50));
+
+		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
+		Frame {
+			timestamp: ts(0),
+			payload: BufList::from_iter(vec![Bytes::from_static(&[0xAA])]),
+		}
+		.encode(&mut group0)
+		.unwrap();
+
+		write_group(&mut track, 1, &[ts(100_000)]);
+		write_group(&mut track, 2, &[ts(200_000)]);
+		write_group(&mut track, 3, &[ts(300_000)]);
+		track.finish().unwrap();
+
+		let finisher = tokio::spawn(async move {
+			tokio::time::sleep(Duration::from_millis(20)).await;
+			group0.finish().unwrap();
+		});
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		assert!(!frames.is_empty());
+		finisher.await.unwrap();
+	}
+
+	#[tokio::test]
+	async fn latency_skip_boundary_exact() {
+		tokio::time::pause();
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(100));
+
+		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
+		Frame {
+			timestamp: ts(0),
+			payload: BufList::from_iter(vec![Bytes::from_static(&[0xAA])]),
+		}
+		.encode(&mut group0)
+		.unwrap();
+
+		write_group(&mut track, 1, &[ts(100_000)]);
+		track.finish().unwrap();
+
+		let finisher = tokio::spawn(async move {
+			tokio::time::sleep(Duration::from_millis(20)).await;
+			group0.finish().unwrap();
+		});
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		assert!(!frames.is_empty());
+		finisher.await.unwrap();
+	}
+
+	/// Regression: a single stalled group with one newer group should trigger
+	/// a latency skip when the timestamp difference exceeds max_latency.
+	/// Previously, the span was computed across newer groups only (zero for one
+	/// group), so the skip never fired.
+	#[tokio::test]
+	async fn single_newer_group_triggers_skip() {
+		tokio::time::pause();
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(100));
+
+		// Group 0: stalled at ts=0, NOT finished
+		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
+		Frame {
+			timestamp: ts(0),
+			payload: BufList::from_iter(vec![Bytes::from_static(&[0xDE, 0xAD])]),
+		}
+		.encode(&mut group0)
+		.unwrap();
+
+		// Group 1: finished, 200ms ahead (well beyond 100ms max_latency)
+		write_group(&mut track, 1, &[ts(200_000)]);
+		track.finish().unwrap();
+
+		let finisher = tokio::spawn(async move {
+			tokio::time::sleep(Duration::from_millis(50)).await;
+			group0.finish().unwrap();
+		});
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		assert_eq!(frames.len(), 2, "Expected group 0 frame + group 1 frame");
+		assert_eq!(frames[0].group, 0);
+		assert_eq!(frames[1].group, 1);
+		finisher.await.unwrap();
+	}
+
+	/// Regression: when the current group is fully consumed and the next sequence
+	/// is missing (gap), the consumer should skip to the next available group
+	/// once the track is fully received, rather than hanging forever.
+	#[tokio::test]
+	async fn single_missing_sequence_near_eof_skips() {
+		tokio::time::pause();
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(100));
+
+		// Group 0: finished normally
+		write_group(&mut track, 0, &[ts(0), ts(20_000)]);
+		// Group 2: finished (group 1 is missing — sequence gap)
+		write_group(&mut track, 2, &[ts(200_000)]);
+		track.finish().unwrap();
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		assert_eq!(frames.len(), 3, "Expected group 0 (2 frames) + group 2 (1 frame)");
+		assert_eq!(frames[0].group, 0);
+		assert_eq!(frames[1].group, 0);
+		assert_eq!(frames[2].group, 2);
+	}
+
+	#[tokio::test]
+	async fn group_error_skips_to_next() {
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(500));
+
+		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
+		group0.abort(moq_lite::Error::Cancel).unwrap();
+
+		write_group(&mut track, 1, &[ts(30_000)]);
+		track.finish().unwrap();
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		assert_eq!(frames.len(), 1);
+		assert_eq!(frames[0].group, 1);
+	}
+
+	#[tokio::test]
+	async fn track_finishes_while_reading() {
+		tokio::time::pause();
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(500));
+
+		write_group(&mut track, 0, &[ts(0)]);
+
+		let finisher = tokio::spawn(async move {
+			tokio::time::sleep(Duration::from_millis(20)).await;
+			write_group(&mut track, 1, &[ts(30_000)]);
+			tokio::time::sleep(Duration::from_millis(20)).await;
+			track.finish().unwrap();
+		});
+
+		let frames = tokio::time::timeout(Duration::from_secs(2), async {
+			let mut frames = Vec::new();
+			while let Some(frame) = consumer.read().await.unwrap() {
+				frames.push(frame);
+			}
+			frames
+		})
+		.await
+		.expect("consumer should not hang");
+
+		assert_eq!(frames.len(), 2);
+		finisher.await.unwrap();
+	}
+
+	#[tokio::test]
+	async fn empty_group_advances() {
+		let mut track = moq_lite::Track::new("test").produce();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = OrderedConsumer::new(consumer_track, Legacy, Duration::from_millis(500));
+
+		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
+		group0.finish().unwrap();
+
+		write_group(&mut track, 1, &[ts(30_000)]);
+		track.finish().unwrap();
+
+		let frames = read_all(&mut consumer).await.unwrap();
+		assert_eq!(frames.len(), 1);
+		assert_eq!(frames[0].group, 1);
+	}
+}
diff --git a/rs/moq-mux/src/error.rs b/rs/moq-mux/src/error.rs
index a789d88d5..720430186 100644
--- a/rs/moq-mux/src/error.rs
+++ b/rs/moq-mux/src/error.rs
@@ -8,7 +8,6 @@ pub enum Error {
 	#[error("hang: {0}")]
 	Hang(#[from] hang::Error),
 
-	#[cfg(feature = "mp4")]
 	#[error("cmaf: {0}")]
 	Cmaf(#[from] crate::cmaf::Error),
 }
diff --git a/rs/moq-mux/src/hang/container.rs b/rs/moq-mux/src/hang/container.rs
index 421ce6fc4..9ca751be8 100644
--- a/rs/moq-mux/src/hang/container.rs
+++ b/rs/moq-mux/src/hang/container.rs
@@ -45,16 +45,48 @@ impl Container for Legacy {
 	}
 }
 
-#[cfg(feature = "mp4")]
-impl Container for hang::catalog::Container {
+/// A container that dispatches between Legacy and CMAF based on the catalog config.
+///
+/// Constructed from a `VideoConfig` or `AudioConfig`, parsing init_data once upfront.
+pub enum Media {
+	Legacy,
+	Cmaf(Box<mp4_atom::Moov>),
+}
+
+impl TryFrom<&hang::catalog::Container> for Media {
+	type Error = crate::Error;
+
+	fn try_from(container: &hang::catalog::Container) -> Result<Self, Self::Error> {
+		use base64::Engine;
+		use mp4_atom::DecodeMaybe;
+
+		match container {
+			hang::catalog::Container::Legacy => Ok(Self::Legacy),
+			hang::catalog::Container::Cmaf { init_data } => {
+				let init_bytes = base64::engine::general_purpose::STANDARD
+					.decode(init_data)
+					.map_err(|e| crate::cmaf::Error::Mp4(mp4_atom::Error::Io(std::io::Error::other(e))))?;
+
+				let mut cursor = std::io::Cursor::new(&init_bytes);
+				while let Some(atom) = mp4_atom::Any::decode_maybe(&mut cursor).map_err(crate::cmaf::Error::from)? {
+					if let mp4_atom::Any::Moov(moov) = atom {
+						return Ok(Self::Cmaf(Box::new(moov)));
+					}
+				}
+
+				Err(crate::cmaf::Error::NoMoov.into())
+			}
+		}
+	}
+}
+
+impl Container for Media {
 	type Error = crate::Error;
 
 	fn write(&self, group: &mut moq_lite::GroupProducer, frames: &[Frame]) -> Result<(), Self::Error> {
 		match self {
-			hang::catalog::Container::Legacy => Legacy.write(group, frames).map_err(Into::into),
-			hang::catalog::Container::Cmaf { timescale, track_id } => {
-				crate::cmaf::encode(group, frames, *timescale, *track_id).map_err(Into::into)
-			}
+			Self::Legacy => Legacy.write(group, frames).map_err(Into::into),
+			Self::Cmaf(moov) => moov.write(group, frames).map_err(Into::into),
 		}
 	}
 
@@ -64,16 +96,8 @@ impl Container for hang::catalog::Container {
 		waiter: &conducer::Waiter,
 	) -> Poll<Result<Option<Vec<Frame>>, Self::Error>> {
 		match self {
-			hang::catalog::Container::Legacy => Legacy.poll_read(group, waiter).map(|r| r.map_err(Into::into)),
-			hang::catalog::Container::Cmaf { timescale, .. } => {
-				use std::task::ready;
-
-				let Some(data) = ready!(group.poll_read_frame(waiter)?) else {
-					return Poll::Ready(Ok(None));
-				};
-
-				Poll::Ready(crate::cmaf::decode(data, *timescale).map(Some).map_err(Into::into))
-			}
+			Self::Legacy => Legacy.poll_read(group, waiter).map(|r| r.map_err(Into::into)),
+			Self::Cmaf(moov) => moov.poll_read(group, waiter).map(|r| r.map_err(Into::into)),
 		}
 	}
 }
diff --git a/rs/moq-mux/src/hang/convert.rs b/rs/moq-mux/src/hang/convert.rs
new file mode 100644
index 000000000..6de21c212
--- /dev/null
+++ b/rs/moq-mux/src/hang/convert.rs
@@ -0,0 +1,302 @@
+use anyhow::Context;
+use base64::Engine;
+use hang::catalog::{AUDIO, Audio, Container, VIDEO, Video};
+use hang::container::{Frame, OrderedProducer, Timestamp};
+
+/// Converts a broadcast from any format to hang/Legacy format.
+///
+/// If tracks are already Legacy, they are passed through unchanged.
+/// If tracks are CMAF, parses moof+mdat and converts to hang frames.
+pub struct Convert {
+	input: moq_lite::BroadcastConsumer,
+	output: moq_lite::BroadcastProducer,
+}
+
+// Make a new audio group every 100ms.
+const MAX_AUDIO_GROUP_DURATION: Timestamp = Timestamp::from_millis_unchecked(100);
+
+impl Convert {
+	pub fn new(input: moq_lite::BroadcastConsumer, output: moq_lite::BroadcastProducer) -> Self {
+		Self { input, output }
+	}
+
+	/// Run the converter.
+	///
+	/// Reads the hang catalog from the input broadcast. If tracks are already Legacy,
+	/// passes them through unchanged (no-op). If tracks are CMAF, parses moof+mdat
+	/// and converts to hang frames.
+	pub async fn run(self) -> anyhow::Result<()> {
+		let input = self.input;
+		let broadcast = self.output;
+		let mut catalog_producer = crate::CatalogProducer::new(&broadcast)?;
+
+		// Subscribe to the input catalog
+		let catalog_track =
+			input.subscribe_track(&hang::catalog::default_track(), moq_lite::Subscription::default())?;
+
+		let mut catalog_consumer = hang::CatalogConsumer::new(catalog_track);
+		let video_section = catalog_consumer.reader().section(&VIDEO);
+		let audio_section = catalog_consumer.reader().section(&AUDIO);
+
+		// Run until first catalog update
+		tokio::select! {
+			res = catalog_consumer.run() => { res?; anyhow::bail!("catalog closed before first update"); },
+			_ = video_section.changed() => {},
+			_ = audio_section.changed() => {},
+		}
+
+		let video = video_section.get()?.unwrap_or_default();
+		let audio = audio_section.get()?.unwrap_or_default();
+
+		run_with_catalog(&input, &broadcast, &mut catalog_producer, &video, &audio).await
+	}
+}
+
+async fn run_with_catalog(
+	input: &moq_lite::BroadcastConsumer,
+	broadcast: &moq_lite::BroadcastProducer,
+	catalog_producer: &mut crate::CatalogProducer,
+	video: &Video,
+	audio: &Audio,
+) -> anyhow::Result<()> {
+	let mut output_video = Video::default();
+	let mut output_audio = Audio::default();
+	let mut tasks: tokio::task::JoinSet<()> = tokio::task::JoinSet::new();
+
+	// Convert video tracks
+	for (name, config) in &video.renditions {
+		let input_track = input.subscribe_track(
+			&moq_lite::Track { name: name.clone() },
+			moq_lite::Subscription::default(),
+		)?;
+
+		match &config.container {
+			Container::Legacy => {
+				// Already Legacy -- pass through
+				output_video.renditions.insert(name.clone(), config.clone());
+				let output_track = broadcast.create_track(moq_lite::Track { name: name.clone() })?;
+				let track_name = name.clone();
+				tasks.spawn(async move {
+					if let Err(e) = passthrough_track(input_track, output_track).await {
+						tracing::error!(%e, track = %track_name, "passthrough_track failed");
+					}
+				});
+			}
+			Container::Cmaf { init_data } => {
+				let init_bytes = base64::engine::general_purpose::STANDARD
+					.decode(init_data)
+					.context("invalid base64 init_data")?;
+
+				let timescale = crate::cmaf::parse_timescale(&init_bytes)?;
+
+				let mut legacy_config = config.clone();
+				legacy_config.container = Container::Legacy;
+				output_video.renditions.insert(name.clone(), legacy_config);
+
+				let output_track = broadcast.create_track(moq_lite::Track { name: name.clone() })?;
+
+				let track_name = name.clone();
+				tasks.spawn(async move {
+					if let Err(e) = convert_cmaf_to_legacy(input_track, output_track, timescale, true).await {
+						tracing::error!(%e, track = %track_name, "convert_cmaf_to_legacy failed");
+					}
+				});
+			}
+		}
+	}
+
+	// Convert audio tracks
+	for (name, config) in &audio.renditions {
+		let input_track = input.subscribe_track(
+			&moq_lite::Track { name: name.clone() },
+			moq_lite::Subscription::default(),
+		)?;
+
+		match &config.container {
+			Container::Legacy => {
+				output_audio.renditions.insert(name.clone(), config.clone());
+				let output_track = broadcast.create_track(moq_lite::Track { name: name.clone() })?;
+				let track_name = name.clone();
+				tasks.spawn(async move {
+					if let Err(e) = passthrough_track(input_track, output_track).await {
+						tracing::error!(%e, track = %track_name, "passthrough_track failed");
+					}
+				});
+			}
+			Container::Cmaf { init_data } => {
+				let init_bytes = base64::engine::general_purpose::STANDARD
+					.decode(init_data)
+					.context("invalid base64 init_data")?;
+
+				let timescale = crate::cmaf::parse_timescale(&init_bytes)?;
+
+				let mut legacy_config = config.clone();
+				legacy_config.container = Container::Legacy;
+				output_audio.renditions.insert(name.clone(), legacy_config);
+
+				let output_track = broadcast.create_track(moq_lite::Track { name: name.clone() })?;
+
+				let track_name = name.clone();
+				tasks.spawn(async move {
+					if let Err(e) = convert_cmaf_to_legacy(input_track, output_track, timescale, false).await {
+						tracing::error!(%e, track = %track_name, "convert_cmaf_to_legacy failed");
+					}
+				});
+			}
+		}
+	}
+
+	// Publish the output catalog
+	catalog_producer.set(&VIDEO, &output_video)?;
+	catalog_producer.set(&AUDIO, &output_audio)?;
+	catalog_producer.flush();
+
+	// Keep broadcast and catalog alive until all track tasks complete.
+	while tasks.join_next().await.is_some() {}
+
+	Ok(())
+}
+
+/// Pass a track through unchanged.
+async fn passthrough_track(
+	mut input: moq_lite::TrackSubscriber,
+	mut output: moq_lite::TrackProducer,
+) -> anyhow::Result<()> {
+	while let Some(group) = input.recv_group().await? {
+		let mut out_group = output.append_group()?;
+		let mut frame_reader = group;
+		while let Some(frame_data) = frame_reader.read_frame().await? {
+			out_group.write_frame(frame_data)?;
+		}
+		out_group.finish()?;
+	}
+	output.finish()?;
+	Ok(())
+}
+
+/// Convert CMAF moof+mdat frames to hang Legacy frames.
+async fn convert_cmaf_to_legacy(
+	mut input: moq_lite::TrackSubscriber,
+	output: moq_lite::TrackProducer,
+	timescale: u64,
+	is_video: bool,
+) -> anyhow::Result<()> {
+	let mut ordered = OrderedProducer::new(output);
+
+	if !is_video {
+		ordered = ordered.with_max_group_duration(MAX_AUDIO_GROUP_DURATION);
+	}
+
+	while let Some(group) = input.recv_group().await? {
+		let mut frame_reader = group;
+		let mut is_first_in_group = true;
+
+		while let Some(frame_data) = frame_reader.read_frame().await? {
+			let frames = crate::cmaf::decode(frame_data, timescale)?;
+
+			for (i, frame) in frames.into_iter().enumerate() {
+				if is_video && is_first_in_group && i == 0 && frame.keyframe {
+					ordered.keyframe()?;
+				}
+
+				ordered.write(Frame {
+					timestamp: frame.timestamp,
+					payload: frame.payload.into(),
+				})?;
+			}
+
+			is_first_in_group = false;
+		}
+	}
+
+	ordered.finish()?;
+	Ok(())
+}
+
+#[cfg(test)]
+mod test {
+	use hang::container::Timestamp;
+
+	use crate::cmaf::test::*;
+
+	fn ts(micros: u64) -> Timestamp {
+		Timestamp::from_micros(micros).unwrap()
+	}
+
+	#[tokio::test]
+	async fn cmaf_to_legacy_video() {
+		use base64::Engine;
+		use hang::catalog::Container;
+
+		let config = test_video_config();
+		let init_data = crate::cmaf::build_video_init(&config).unwrap();
+		let timescale = config.framerate.map(|f| (f * 1000.0) as u64).unwrap();
+
+		let cmaf_frames: Vec<(u64, Vec<u8>, bool)> = vec![
+			(0, vec![0x01, 0x02, 0x03], true),
+			(33_000u64 * timescale / 1_000_000, vec![0x04, 0x05], false),
+			(66_000u64 * timescale / 1_000_000, vec![0x06, 0x07, 0x08], true),
+		];
+
+		let mut cmaf_config = config.clone();
+		cmaf_config.container = Container::Cmaf {
+			init_data: base64::engine::general_purpose::STANDARD.encode(&init_data),
+		};
+
+		let (consumer, mut video_track, _broadcast, _catalog_track) = setup_input(&cmaf_config);
+		let output = moq_lite::Broadcast::new().produce();
+		let output_consumer = output.consume();
+		let converter = super::Convert::new(consumer, output);
+
+		let cmaf_frames_clone = cmaf_frames.clone();
+		tokio::spawn(async move {
+			tokio::task::yield_now().await;
+			write_cmaf_frames(&mut video_track, &cmaf_frames_clone);
+		});
+
+		let (convert_result, legacy_frames) = tokio::join!(converter.run(), async {
+			let output_video = subscribe_video(&output_consumer).await;
+			read_legacy_frames(output_video).await
+		});
+		convert_result.unwrap();
+
+		assert_eq!(legacy_frames.len(), 3, "expected 3 Legacy frames");
+		assert_eq!(legacy_frames[0].0, ts(0));
+		assert_eq!(legacy_frames[0].1, vec![0x01, 0x02, 0x03]);
+		assert_eq!(legacy_frames[1].0, ts(33_000));
+		assert_eq!(legacy_frames[1].1, vec![0x04, 0x05]);
+		assert_eq!(legacy_frames[2].0, ts(66_000));
+		assert_eq!(legacy_frames[2].1, vec![0x06, 0x07, 0x08]);
+	}
+
+	#[tokio::test]
+	async fn legacy_passthrough() {
+		let config = test_video_config();
+		let frames = vec![(ts(0), vec![0xAA, 0xBB], true), (ts(33_000), vec![0xCC, 0xDD], false)];
+
+		let (consumer, mut video_track, _broadcast, _catalog_track) = setup_input(&config);
+		let output = moq_lite::Broadcast::new().produce();
+		let output_consumer = output.consume();
+
+		let converter = super::Convert::new(consumer, output);
+
+		let frames_clone = frames.clone();
+		tokio::spawn(async move {
+			tokio::task::yield_now().await;
+			write_legacy_frames(&mut video_track, &frames_clone);
+		});
+
+		let (convert_result, result) = tokio::join!(converter.run(), async {
+			let output_video = subscribe_video(&output_consumer).await;
+			read_legacy_frames(output_video).await
+		});
+		convert_result.expect("converter.run() failed");
+
+		assert_eq!(result.len(), frames.len());
+
+		for (i, (expected_ts, expected_payload, _)) in frames.iter().enumerate() {
+			assert_eq!(result[i].0, *expected_ts, "timestamp mismatch at frame {i}");
+			assert_eq!(result[i].1, *expected_payload, "payload mismatch at frame {i}");
+		}
+	}
+}
diff --git a/rs/moq-mux/src/hang/mod.rs b/rs/moq-mux/src/hang/mod.rs
index f2677e5e4..ae916a2c2 100644
--- a/rs/moq-mux/src/hang/mod.rs
+++ b/rs/moq-mux/src/hang/mod.rs
@@ -1,7 +1,9 @@
 mod container;
+mod convert;
 
-pub use container::Legacy;
+pub use container::{Legacy, Media};
+pub use convert::*;
 
-pub type Consumer = crate::ordered::Consumer<Legacy>;
-pub type Producer = crate::ordered::Producer<Legacy>;
+pub type Consumer = crate::ordered::Consumer<Media>;
+pub type Producer = crate::ordered::Producer<Media>;
 pub use crate::container::Frame;
diff --git a/rs/moq-mux/src/import/mod.rs b/rs/moq-mux/src/import/mod.rs
deleted file mode 100644
index c5d03c6f8..000000000
--- a/rs/moq-mux/src/import/mod.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-//! Media demuxers for MoQ.
-//!
-//! This crate provides modules for converting existing media formats into MoQ broadcasts.
-//! It supports various container and codec formats, optionally enabled via feature flags.
-//!
-//! **Feature flags:**
-//! - `aac`: Raw AAC frames (not ADTS).
-//! - `opus`: Raw Opus frames (not Ogg).
-//! - `avc3`: H.264 with inline SPS/PPS.
-//! - `fmp4`: fMP4/CMAF container.
-//! - `hev1`: H.265 with inline SPS/PPS.
-//! - `hls`: HLS playlist.
-//!
-//! The [Decoder] module provides a generic interface for importing a stream of media.
-//! If you know the format in advance, use the specific decoder instead.
-
-mod aac;
-#[cfg(any(feature = "h264", feature = "h265"))]
-mod annexb;
-#[cfg(feature = "av1")]
-mod av01;
-#[cfg(feature = "h264")]
-mod avc1;
-#[cfg(feature = "h264")]
-mod avc3;
-mod decoder;
-#[cfg(feature = "mp4")]
-mod fmp4;
-#[cfg(feature = "h265")]
-mod hev1;
-#[cfg(feature = "hls")]
-mod hls;
-mod opus;
-
-pub use aac::*;
-#[cfg(feature = "av1")]
-pub use av01::*;
-#[cfg(feature = "h264")]
-pub use avc1::*;
-#[cfg(feature = "h264")]
-pub use avc3::*;
-pub use decoder::*;
-#[cfg(feature = "mp4")]
-pub use fmp4::*;
-#[cfg(feature = "h265")]
-pub use hev1::*;
-#[cfg(feature = "hls")]
-pub use hls::*;
-pub use opus::*;
diff --git a/rs/moq-mux/src/lib.rs b/rs/moq-mux/src/lib.rs
index d357476c3..4a65b6579 100644
--- a/rs/moq-mux/src/lib.rs
+++ b/rs/moq-mux/src/lib.rs
@@ -1,14 +1,14 @@
 //! Media muxers and demuxers for MoQ.
 
 mod catalog;
-#[cfg(feature = "mp4")]
 pub mod cmaf;
+pub mod consumer;
 pub mod container;
 mod error;
 pub mod hang;
-pub mod import;
 pub mod msf;
 pub mod ordered;
+pub mod producer;
 
 pub use catalog::*;
 pub use error::*;
diff --git a/rs/moq-mux/src/msf.rs b/rs/moq-mux/src/msf.rs
index a924d2b3e..757e014e9 100644
--- a/rs/moq-mux/src/msf.rs
+++ b/rs/moq-mux/src/msf.rs
@@ -1,26 +1,29 @@
 //! MSF catalog conversion and helpers.
 //!
-//! Converts a [`hang::Catalog`] to an MSF [`moq_msf::Catalog`].
+//! Converts hang catalog sections to an MSF [`moq_msf::Catalog`].
 
 use base64::Engine;
+use hang::catalog::{Audio, Video};
 
-/// Convert a hang catalog to an MSF catalog.
-pub fn to_msf(catalog: &hang::Catalog) -> moq_msf::Catalog {
+/// Convert hang video and audio sections to an MSF catalog.
+pub fn to_msf(video: Option<&Video>, audio: Option<&Audio>) -> moq_msf::Catalog {
 	let mut tracks = Vec::new();
 
-	let has_multiple_video = catalog.video.renditions.len() > 1;
-	for (name, config) in &catalog.video.renditions {
+	let video_renditions = video.map(|v| &v.renditions);
+	let has_multiple_video = video_renditions.is_some_and(|r| r.len() > 1);
+	for (name, config) in video_renditions.into_iter().flatten() {
 		let packaging = match &config.container {
 			hang::catalog::Container::Cmaf { .. } => moq_msf::Packaging::Cmaf,
-			// TODO: For CMAF packaging, build proper CMAF init segments (ftyp+moov).
-			// See draft-ietf-moq-cmsf-00 for the required structure.
 			_ => moq_msf::Packaging::Legacy,
 		};
 
-		let init_data = config
-			.description
-			.as_ref()
-			.map(|d| base64::engine::general_purpose::STANDARD.encode(d.as_ref()));
+		let init_data = match &config.container {
+			hang::catalog::Container::Cmaf { init_data } => Some(init_data.clone()),
+			_ => config
+				.description
+				.as_ref()
+				.map(|d| base64::engine::general_purpose::STANDARD.encode(d.as_ref())),
+		};
 
 		tracks.push(moq_msf::Track {
 			name: name.clone(),
@@ -40,17 +43,21 @@ pub fn to_msf(catalog: &hang::Catalog) -> moq_msf::Catalog {
 		});
 	}
 
-	let has_multiple_audio = catalog.audio.renditions.len() > 1;
-	for (name, config) in &catalog.audio.renditions {
+	let audio_renditions = audio.map(|a| &a.renditions);
+	let has_multiple_audio = audio_renditions.is_some_and(|r| r.len() > 1);
+	for (name, config) in audio_renditions.into_iter().flatten() {
 		let packaging = match &config.container {
 			hang::catalog::Container::Cmaf { .. } => moq_msf::Packaging::Cmaf,
 			_ => moq_msf::Packaging::Legacy,
 		};
 
-		let init_data = config
-			.description
-			.as_ref()
-			.map(|d| base64::engine::general_purpose::STANDARD.encode(d.as_ref()));
+		let init_data = match &config.container {
+			hang::catalog::Container::Cmaf { init_data } => Some(init_data.clone()),
+			_ => config
+				.description
+				.as_ref()
+				.map(|d| base64::engine::general_purpose::STANDARD.encode(d.as_ref())),
+		};
 
 		tracks.push(moq_msf::Track {
 			name: name.clone(),
@@ -73,9 +80,9 @@ pub fn to_msf(catalog: &hang::Catalog) -> moq_msf::Catalog {
 	moq_msf::Catalog { version: 1, tracks }
 }
 
-/// Publish the MSF catalog derived from a hang catalog to the given track.
-pub fn publish(catalog: &hang::Catalog, track: &mut moq_lite::TrackProducer) {
-	let msf = to_msf(catalog);
+/// Publish the MSF catalog derived from hang video/audio sections to the given track.
+pub fn publish(video: Option<&Video>, audio: Option<&Audio>, track: &mut moq_lite::TrackProducer) {
+	let msf = to_msf(video, audio);
 	let Ok(mut group) = track.append_group() else {
 		return;
 	};
@@ -132,20 +139,17 @@ mod test {
 			},
 		);
 
-		let catalog = hang::Catalog {
-			video: Video {
-				renditions: video_renditions,
-				display: None,
-				rotation: None,
-				flip: None,
-			},
-			audio: Audio {
-				renditions: audio_renditions,
-			},
-			..Default::default()
+		let video = Video {
+			renditions: video_renditions,
+			display: None,
+			rotation: None,
+			flip: None,
+		};
+		let audio = Audio {
+			renditions: audio_renditions,
 		};
 
-		let msf = to_msf(&catalog);
+		let msf = to_msf(Some(&video), Some(&audio));
 
 		assert_eq!(msf.version, 1);
 		assert_eq!(msf.tracks.len(), 2);
@@ -197,25 +201,21 @@ mod test {
 			},
 		);
 
-		let catalog = hang::Catalog {
-			video: Video {
-				renditions: video_renditions,
-				display: None,
-				rotation: None,
-				flip: None,
-			},
-			..Default::default()
+		let video = Video {
+			renditions: video_renditions,
+			display: None,
+			rotation: None,
+			flip: None,
 		};
 
-		let msf = to_msf(&catalog);
+		let msf = to_msf(Some(&video), None);
 		let video = &msf.tracks[0];
 		assert_eq!(video.init_data, Some("AQID".to_string()));
 	}
 
 	#[test]
 	fn convert_empty() {
-		let catalog = hang::Catalog::default();
-		let msf = to_msf(&catalog);
+		let msf = to_msf(None, None);
 		assert_eq!(msf.version, 1);
 		assert!(msf.tracks.is_empty());
 	}
@@ -242,25 +242,22 @@ mod test {
 				framerate: None,
 				optimize_for_latency: None,
 				container: Container::Cmaf {
-					timescale: 90000,
-					track_id: 1,
+					init_data: "AAAYZ2Z0eXA=".to_string(),
 				},
 				jitter: None,
 			},
 		);
 
-		let catalog = hang::Catalog {
-			video: Video {
-				renditions: video_renditions,
-				display: None,
-				rotation: None,
-				flip: None,
-			},
-			..Default::default()
+		let video = Video {
+			renditions: video_renditions,
+			display: None,
+			rotation: None,
+			flip: None,
 		};
 
-		let msf = to_msf(&catalog);
+		let msf = to_msf(Some(&video), None);
 		let video = &msf.tracks[0];
 		assert_eq!(video.packaging, moq_msf::Packaging::Cmaf);
+		assert_eq!(video.init_data, Some("AAAYZ2Z0eXA=".to_string()));
 	}
 }
diff --git a/rs/moq-mux/src/ordered/consumer.rs b/rs/moq-mux/src/ordered/consumer.rs
index e665d81dc..3384ecd2e 100644
--- a/rs/moq-mux/src/ordered/consumer.rs
+++ b/rs/moq-mux/src/ordered/consumer.rs
@@ -15,7 +15,7 @@ use crate::container::{Container, Frame, Timestamp};
 /// The consumer can skip groups that are too far behind to maintain low latency.
 /// Configure the maximum acceptable delay through the consumer's latency settings.
 pub struct Consumer<F: Container> {
-	track: moq_lite::TrackConsumer,
+	pub track: moq_lite::TrackSubscriber,
 
 	format: F,
 
@@ -34,8 +34,8 @@ pub struct Consumer<F: Container> {
 }
 
 impl<F: Container> Consumer<F> {
-	/// Create a new Consumer wrapping the given moq-lite consumer.
-	pub fn new(track: moq_lite::TrackConsumer, format: F) -> Self {
+	/// Create a new Consumer wrapping the given moq-lite subscriber.
+	pub fn new(track: moq_lite::TrackSubscriber, format: F) -> Self {
 		Self {
 			track,
 			format,
@@ -189,7 +189,7 @@ impl<F: Container> Consumer<F> {
 	// Returns Pending until all groups have been consumed.
 	fn poll_read_finish(&mut self, waiter: &conducer::Waiter) -> Poll<Result<(), F::Error>> {
 		loop {
-			let Some(group) = ready!(self.track.poll_next_group(waiter)?) else {
+			let Some(group) = ready!(self.track.poll_recv_group(waiter)?) else {
 				// Track is finished.
 				return Poll::Ready(Ok(()));
 			};
@@ -221,8 +221,8 @@ impl<F: Container> Consumer<F> {
 		Ok(self.track.closed().await?)
 	}
 
-	/// Unwrap into the inner TrackConsumer.
-	pub fn into_inner(self) -> moq_lite::TrackConsumer {
+	/// Unwrap into the inner TrackSubscriber.
+	pub fn into_inner(self) -> moq_lite::TrackSubscriber {
 		self.track
 	}
 }
@@ -418,7 +418,7 @@ mod tests {
 	#[tokio::test]
 	async fn read_single_group() {
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(500));
 
 		write_group(&mut track, 0, &[ts(0)]);
@@ -436,7 +436,7 @@ mod tests {
 	#[tokio::test]
 	async fn read_multiple_frames_single_group() {
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(500));
 
 		write_group(&mut track, 0, &[ts(0), ts(33_000), ts(66_000)]);
@@ -454,7 +454,7 @@ mod tests {
 	#[tokio::test]
 	async fn read_multiple_groups_within_latency() {
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(500));
 
 		// 5 groups, 20ms spacing. Total span = 80ms, well within 500ms latency.
@@ -473,7 +473,7 @@ mod tests {
 	async fn latency_skip_delivers_recent_groups() {
 		tokio::time::pause();
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(100));
 
 		// Group 0: 5 frames, NOT finished (blocks consumer)
@@ -514,7 +514,7 @@ mod tests {
 	async fn zero_latency_skips_aggressively() {
 		tokio::time::pause();
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::ZERO);
 
 		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
@@ -550,7 +550,7 @@ mod tests {
 	async fn latency_skip_correctness() {
 		tokio::time::pause();
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(100));
 
 		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
@@ -592,7 +592,7 @@ mod tests {
 	async fn groups_delivered_in_sequence_order() {
 		tokio::time::pause();
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(500));
 
 		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
@@ -627,7 +627,7 @@ mod tests {
 	#[tokio::test]
 	async fn adjacent_group_flushed_immediately() {
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(500));
 
 		write_group(&mut track, 0, &[ts(0)]);
@@ -645,7 +645,7 @@ mod tests {
 	#[tokio::test]
 	async fn bframes_within_group() {
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(500));
 
 		write_group(&mut track, 0, &[ts(0), ts(66_000), ts(33_000)]);
@@ -664,7 +664,7 @@ mod tests {
 	async fn empty_track_returns_none() {
 		tokio::time::pause();
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(500));
 
 		track.finish().unwrap();
@@ -682,7 +682,7 @@ mod tests {
 	async fn track_closed_with_error() {
 		tokio::time::pause();
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(500));
 
 		write_group(&mut track, 0, &[ts(0)]);
@@ -704,7 +704,7 @@ mod tests {
 	async fn closed_resolves_when_track_ends() {
 		tokio::time::pause();
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(500));
 
 		assert!(
@@ -727,7 +727,7 @@ mod tests {
 	#[tokio::test]
 	async fn gap_in_group_sequence_recovery() {
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(100));
 
 		write_group(&mut track, 0, &[ts(0), ts(20_000)]);
@@ -745,7 +745,7 @@ mod tests {
 	#[tokio::test]
 	async fn gap_at_start_of_sequence() {
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(80));
 
 		write_group(&mut track, 5, &[ts(0), ts(20_000)]);
@@ -763,7 +763,7 @@ mod tests {
 	#[tokio::test]
 	async fn frame_timestamp_and_index_decoding() {
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(500));
 
 		write_group(&mut track, 0, &[ts(0), ts(33_333), ts(66_666)]);
@@ -783,7 +783,7 @@ mod tests {
 	#[tokio::test]
 	async fn frame_payload_preserved() {
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(500));
 
 		let payload_bytes = vec![0x01, 0x02, 0x03, 0x04, 0x05];
@@ -820,7 +820,7 @@ mod tests {
 	async fn no_infinite_loop_with_buffered_frames() {
 		tokio::time::pause();
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_secs(10));
 
 		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
@@ -865,7 +865,7 @@ mod tests {
 	#[tokio::test]
 	async fn large_timestamps() {
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_secs(3700));
 
 		let one_hour = 3_600_000_000u64;
@@ -881,7 +881,7 @@ mod tests {
 	#[tokio::test]
 	async fn set_latency_changes_behavior() {
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_secs(10));
 
 		write_group(&mut track, 0, &[ts(0)]);
@@ -899,7 +899,7 @@ mod tests {
 	async fn max_timestamp_tracks_through_bframes() {
 		tokio::time::pause();
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		// latency must exceed (group1_max - group0_min) = 100ms - 0ms = 100ms
 		// to avoid the latency skip and test B-frame timestamp tracking.
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(110));
@@ -950,7 +950,7 @@ mod tests {
 	async fn startup_selects_earliest_group() {
 		tokio::time::pause();
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(100));
 
 		write_group(&mut track, 3, &[ts(0)]);
@@ -1001,7 +1001,7 @@ mod tests {
 	async fn startup_skips_groups_without_data() {
 		tokio::time::pause();
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(500));
 
 		let _group5 = track.create_group(moq_lite::Group { sequence: 5 }).unwrap();
@@ -1024,7 +1024,7 @@ mod tests {
 	#[tokio::test]
 	async fn startup_single_group_mid_stream() {
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(500));
 
 		write_group(&mut track, 100, &[ts(3_000_000)]);
@@ -1038,7 +1038,7 @@ mod tests {
 	async fn multiple_sequential_latency_skips() {
 		tokio::time::pause();
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(50));
 
 		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
@@ -1073,7 +1073,7 @@ mod tests {
 	async fn latency_skip_boundary_exact() {
 		tokio::time::pause();
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(100));
 
 		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
@@ -1110,7 +1110,7 @@ mod tests {
 	async fn single_newer_group_triggers_skip() {
 		tokio::time::pause();
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(100));
 
 		// Group 0: stalled at ts=0, NOT finished
@@ -1147,7 +1147,7 @@ mod tests {
 	async fn single_missing_sequence_near_eof_skips() {
 		tokio::time::pause();
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(100));
 
 		// Group 0: finished normally
@@ -1163,7 +1163,7 @@ mod tests {
 	#[tokio::test]
 	async fn group_error_skips_to_next() {
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(500));
 
 		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
@@ -1180,7 +1180,7 @@ mod tests {
 	async fn track_finishes_while_reading() {
 		tokio::time::pause();
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(500));
 
 		write_group(&mut track, 0, &[ts(0)]);
@@ -1209,7 +1209,7 @@ mod tests {
 	#[tokio::test]
 	async fn empty_group_advances() {
 		let mut track = moq_lite::Track::new("test").produce();
-		let consumer_track = track.consume();
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
 		let mut consumer = Consumer::new(consumer_track, Legacy).with_latency(Duration::from_millis(500));
 
 		let mut group0 = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
@@ -1222,17 +1222,17 @@ mod tests {
 		assert_eq!(frames.len(), 1);
 	}
 
-	// ---- VideoConfig Container ----
+	// ---- Media Container ----
 
-	#[cfg(feature = "mp4")]
 	#[tokio::test]
-	async fn video_container_legacy() {
+	async fn media_container_legacy() {
 		tokio::time::pause();
 
+		let media = crate::hang::Media::try_from(&hang::catalog::Container::Legacy).unwrap();
+
 		let mut track = moq_lite::Track::new("video").produce();
-		let consumer_track = track.consume();
-		let mut consumer =
-			Consumer::new(consumer_track, hang::catalog::Container::Legacy).with_latency(Duration::from_millis(500));
+		let consumer_track = track.consume().subscribe(moq_lite::Subscription::default()).unwrap();
+		let mut consumer = Consumer::new(consumer_track, media).with_latency(Duration::from_millis(500));
 
 		// Write frames using Legacy encoding
 		let mut group = track.create_group(moq_lite::Group { sequence: 0 }).unwrap();
diff --git a/rs/moq-mux/src/import/aac.rs b/rs/moq-mux/src/producer/aac.rs
similarity index 84%
rename from rs/moq-mux/src/import/aac.rs
rename to rs/moq-mux/src/producer/aac.rs
index c89e90e14..7e4d4e5cb 100644
--- a/rs/moq-mux/src/import/aac.rs
+++ b/rs/moq-mux/src/producer/aac.rs
@@ -102,39 +102,50 @@ impl AacConfig {
 /// AAC decoder, initialized via AudioSpecificConfig (variable length from ESDS box).
 pub struct Aac {
 	catalog: crate::CatalogProducer,
+	audio: hang::catalog::Audio,
 	track: hang::container::OrderedProducer,
 	zero: Option<tokio::time::Instant>,
 }
 
 impl Aac {
 	pub fn new(
-		mut broadcast: moq_lite::BroadcastProducer,
+		broadcast: moq_lite::BroadcastProducer,
 		mut catalog: crate::CatalogProducer,
 		config: AacConfig,
 	) -> anyhow::Result<Self> {
-		let track = {
-			let mut cat = catalog.lock();
-
-			let audio_config = hang::catalog::AudioConfig {
-				codec: hang::catalog::AAC {
-					profile: config.profile,
-				}
-				.into(),
-				sample_rate: config.sample_rate,
-				channel_count: config.channel_count,
-				bitrate: None,
-				description: None,
-				container: hang::catalog::Container::Legacy,
-				jitter: None,
-			};
-			let track = cat.audio.create_track("aac", audio_config.clone());
-			tracing::debug!(name = ?track.name, config = ?audio_config, "starting track");
-
-			broadcast.create_track(track)?
+		// Read the current audio section from the catalog, if any
+		let mut audio: hang::catalog::Audio = {
+			let state = catalog.writer().read();
+			state
+				.sections
+				.get("audio")
+				.and_then(|v| serde_json::from_value(v.clone()).ok())
+				.unwrap_or_default()
 		};
 
+		let audio_config = hang::catalog::AudioConfig {
+			codec: hang::catalog::AAC {
+				profile: config.profile,
+			}
+			.into(),
+			sample_rate: config.sample_rate,
+			channel_count: config.channel_count,
+			bitrate: None,
+			description: None,
+			container: hang::catalog::Container::Legacy,
+			jitter: None,
+		};
+		let track_info = audio.create_track("aac", audio_config.clone());
+		tracing::debug!(name = ?track_info.name, config = ?audio_config, "starting track");
+
+		let _ = catalog.set(&hang::catalog::AUDIO, &audio);
+		catalog.flush();
+
+		let track = broadcast.create_track(track_info)?;
+
 		Ok(Self {
 			catalog,
+			audio,
 			track: hang::container::OrderedProducer::new(track).with_max_group_duration(MAX_GROUP_DURATION),
 			zero: None,
 		})
@@ -180,7 +191,9 @@ impl Aac {
 impl Drop for Aac {
 	fn drop(&mut self) {
 		tracing::debug!(name = ?self.track.info.name, "ending track");
-		self.catalog.lock().audio.remove_track(&self.track.info);
+		self.audio.remove_track(&self.track.info);
+		let _ = self.catalog.set(&hang::catalog::AUDIO, &self.audio);
+		self.catalog.flush();
 	}
 }
 
diff --git a/rs/moq-mux/src/import/annexb.rs b/rs/moq-mux/src/producer/annexb.rs
similarity index 100%
rename from rs/moq-mux/src/import/annexb.rs
rename to rs/moq-mux/src/producer/annexb.rs
diff --git a/rs/moq-mux/src/import/av01.rs b/rs/moq-mux/src/producer/av01.rs
similarity index 92%
rename from rs/moq-mux/src/import/av01.rs
rename to rs/moq-mux/src/producer/av01.rs
index f14b47ec4..0d525d377 100644
--- a/rs/moq-mux/src/import/av01.rs
+++ b/rs/moq-mux/src/producer/av01.rs
@@ -11,6 +11,9 @@ pub struct Av01 {
 	// The catalog being produced.
 	catalog: crate::CatalogProducer,
 
+	// Local video section state.
+	video: hang::catalog::Video,
+
 	// The track being produced.
 	track: Option<hang::container::OrderedProducer>,
 
@@ -33,9 +36,20 @@ struct Frame {
 
 impl Av01 {
 	pub fn new(broadcast: moq_lite::BroadcastProducer, catalog: crate::CatalogProducer) -> Self {
+		// Read the current video section from the catalog, if any
+		let video: hang::catalog::Video = {
+			let state = catalog.writer().read();
+			state
+				.sections
+				.get("video")
+				.and_then(|v| serde_json::from_value(v.clone()).ok())
+				.unwrap_or_default()
+		};
+
 		Self {
 			broadcast,
 			catalog,
+			video,
 			track: None,
 			config: None,
 			current: Default::default(),
@@ -93,13 +107,14 @@ impl Av01 {
 
 		if let Some(track) = &self.track.take() {
 			tracing::debug!(name = ?track.info.name, "reinitializing track");
-			self.catalog.lock().video.remove_track(&track.info);
+			self.video.remove_track(&track.info);
 		}
 
-		let mut catalog = self.catalog.lock();
-		let track = catalog.video.create_track("av01", config.clone());
+		let track = self.video.create_track("av01", config.clone());
 		tracing::debug!(name = ?track.name, ?config, "starting track");
-		drop(catalog);
+
+		let _ = self.catalog.set(&hang::catalog::VIDEO, &self.video);
+		self.catalog.flush();
 
 		let track = self.broadcast.create_track(track)?;
 
@@ -139,10 +154,11 @@ impl Av01 {
 			jitter: None,
 		};
 
-		let mut catalog = self.catalog.lock();
-		let track = catalog.video.create_track("av01", config.clone());
+		let track = self.video.create_track("av01", config.clone());
 		tracing::debug!(name = ?track.name, "starting track with minimal config");
-		drop(catalog);
+
+		let _ = self.catalog.set(&hang::catalog::VIDEO, &self.video);
+		self.catalog.flush();
 
 		let track = self.broadcast.create_track(track)?;
 
@@ -225,12 +241,13 @@ impl Av01 {
 		}
 
 		if let Some(track) = &self.track.take() {
-			self.catalog.lock().video.remove_track(&track.info);
+			self.video.remove_track(&track.info);
 		}
 
-		let mut catalog = self.catalog.lock();
-		let track = catalog.video.create_track("av01", config.clone());
-		drop(catalog);
+		let track = self.video.create_track("av01", config.clone());
+
+		let _ = self.catalog.set(&hang::catalog::VIDEO, &self.video);
+		self.catalog.flush();
 
 		let track = self.broadcast.create_track(track)?;
 		self.config = Some(config);
@@ -418,7 +435,9 @@ impl Drop for Av01 {
 	fn drop(&mut self) {
 		if let Some(track) = self.track.take() {
 			tracing::debug!(name = ?track.info.name, "ending track");
-			self.catalog.lock().video.remove_track(&track.info);
+			self.video.remove_track(&track.info);
+			let _ = self.catalog.set(&hang::catalog::VIDEO, &self.video);
+			self.catalog.flush();
 		}
 	}
 }
diff --git a/rs/moq-mux/src/import/avc1.rs b/rs/moq-mux/src/producer/avc1.rs
similarity index 88%
rename from rs/moq-mux/src/import/avc1.rs
rename to rs/moq-mux/src/producer/avc1.rs
index e3c66f96f..7cefca7f1 100644
--- a/rs/moq-mux/src/import/avc1.rs
+++ b/rs/moq-mux/src/producer/avc1.rs
@@ -90,16 +90,21 @@ impl Avc1 {
 			return Ok(());
 		}
 
-		let mut catalog = self.catalog.lock();
+		let mut video = self.current_video();
 
 		if let Some(track) = &self.track.take() {
 			tracing::debug!(name = ?track.info.name, "reinitializing avc1 track");
-			catalog.video.remove_track(&track.info);
+			video.remove_track(&track.info);
 		}
 
-		let track = catalog.video.create_track("avc1", config.clone());
+		let track = video.create_track("avc1", config.clone());
 		tracing::debug!(name = ?track.name, ?config, "starting avc1 track");
 
+		self.catalog
+			.set(&hang::catalog::VIDEO, &video)
+			.map_err(|e| anyhow::anyhow!(e))?;
+		self.catalog.flush();
+
 		let track = self.broadcast.create_track(track)?;
 
 		self.config = Some(config);
@@ -191,13 +196,26 @@ impl Avc1 {
 			zero.elapsed().as_micros() as u64
 		)?)
 	}
+
+	/// Read the current video section from the catalog writer, or return a default.
+	fn current_video(&self) -> hang::catalog::Video {
+		let state = self.catalog.writer().read();
+		state
+			.sections
+			.get("video")
+			.and_then(|v| serde_json::from_value(v.clone()).ok())
+			.unwrap_or_default()
+	}
 }
 
 impl Drop for Avc1 {
 	fn drop(&mut self) {
 		if let Some(track) = self.track.take() {
 			tracing::debug!(name = ?track.info.name, "ending avc1 track");
-			self.catalog.lock().video.remove_track(&track.info);
+			let mut video = self.current_video();
+			video.remove_track(&track.info);
+			let _ = self.catalog.set(&hang::catalog::VIDEO, &video);
+			self.catalog.flush();
 		}
 	}
 }
diff --git a/rs/moq-mux/src/import/avc3.rs b/rs/moq-mux/src/producer/avc3.rs
similarity index 93%
rename from rs/moq-mux/src/import/avc3.rs
rename to rs/moq-mux/src/producer/avc3.rs
index 5c0d2980c..a9b1f8cb9 100644
--- a/rs/moq-mux/src/import/avc3.rs
+++ b/rs/moq-mux/src/producer/avc3.rs
@@ -13,6 +13,9 @@ pub struct Avc3 {
 	// The catalog being produced.
 	catalog: crate::CatalogProducer,
 
+	// Local video section state.
+	video: hang::catalog::Video,
+
 	// The track being produced.
 	track: Option<hang::container::OrderedProducer>,
 
@@ -33,9 +36,20 @@ pub struct Avc3 {
 
 impl Avc3 {
 	pub fn new(broadcast: moq_lite::BroadcastProducer, catalog: crate::CatalogProducer) -> Self {
+		// Read the current video section from the catalog, if any
+		let video: hang::catalog::Video = {
+			let state = catalog.writer().read();
+			state
+				.sections
+				.get("video")
+				.and_then(|v| serde_json::from_value(v.clone()).ok())
+				.unwrap_or_default()
+		};
+
 		Self {
 			broadcast,
 			catalog,
+			video,
 			track: None,
 			config: None,
 			current: Default::default(),
@@ -80,16 +94,17 @@ impl Avc3 {
 			return Ok(());
 		}
 
-		let mut catalog = self.catalog.lock();
-
 		if let Some(track) = &self.track.take() {
 			tracing::debug!(name = ?track.info.name, "reinitializing track");
-			catalog.video.remove_track(&track.info);
+			self.video.remove_track(&track.info);
 		}
 
-		let track = catalog.video.create_track("avc3", config.clone());
+		let track = self.video.create_track("avc3", config.clone());
 		tracing::debug!(name = ?track.name, ?config, "starting track");
 
+		let _ = self.catalog.set(&hang::catalog::VIDEO, &self.video);
+		self.catalog.flush();
+
 		let track = self.broadcast.create_track(track)?;
 
 		self.config = Some(config);
@@ -315,7 +330,9 @@ impl Drop for Avc3 {
 	fn drop(&mut self) {
 		if let Some(track) = self.track.take() {
 			tracing::debug!(name = ?track.info.name, "ending track");
-			self.catalog.lock().video.remove_track(&track.info);
+			self.video.remove_track(&track.info);
+			let _ = self.catalog.set(&hang::catalog::VIDEO, &self.video);
+			self.catalog.flush();
 		}
 	}
 }
diff --git a/rs/moq-mux/src/import/decoder.rs b/rs/moq-mux/src/producer/decoder.rs
similarity index 60%
rename from rs/moq-mux/src/import/decoder.rs
rename to rs/moq-mux/src/producer/decoder.rs
index 20ace9cd7..75d3c3a1c 100644
--- a/rs/moq-mux/src/import/decoder.rs
+++ b/rs/moq-mux/src/producer/decoder.rs
@@ -3,79 +3,60 @@ use std::{fmt, str::FromStr};
 use bytes::Buf;
 use hang::Error;
 
-/// The supported decoder formats.
+/// The supported framed formats (known frame boundaries).
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 #[non_exhaustive]
-pub enum DecoderFormat {
+pub enum FramedFormat {
+	/// H264 with AVCC framing (length-prefixed NALUs, out-of-band SPS/PPS).
+	Avc1,
 	/// H264 with Annex B framing (start code prefixed, inline SPS/PPS).
-	#[cfg(feature = "h264")]
 	Avc3,
 	/// fMP4/CMAF container.
-	#[cfg(feature = "mp4")]
 	Fmp4,
 	/// aka H265 with inline SPS/PPS
-	#[cfg(feature = "h265")]
 	Hev1,
 	/// AV1 with inline sequence headers
-	#[cfg(feature = "av1")]
 	Av01,
 	/// Raw AAC frames (not ADTS).
-	#[cfg(feature = "aac")]
 	Aac,
 	/// Raw Opus frames (not Ogg).
-	#[cfg(feature = "opus")]
 	Opus,
-	/// H264 with AVCC framing (length-prefixed NALUs, out-of-band SPS/PPS).
-	#[cfg(feature = "h264")]
-	Avc1,
 }
 
-impl FromStr for DecoderFormat {
+#[deprecated(note = "use FramedFormat instead")]
+pub type DecoderFormat = FramedFormat;
+
+impl FromStr for FramedFormat {
 	type Err = Error;
 
 	fn from_str(s: &str) -> Result<Self, Self::Err> {
 		match s {
-			#[cfg(feature = "h264")]
-			"avc1" | "avcc" => Ok(DecoderFormat::Avc1),
-			#[cfg(feature = "h264")]
-			"avc3" => Ok(DecoderFormat::Avc3),
-			#[cfg(feature = "h264")]
+			"avc1" | "avcc" => Ok(FramedFormat::Avc1),
+			"avc3" => Ok(FramedFormat::Avc3),
 			"h264" | "annex-b" => {
 				tracing::warn!("format '{s}' is deprecated, use 'avc3' instead");
-				Ok(DecoderFormat::Avc3)
+				Ok(FramedFormat::Avc3)
 			}
-			#[cfg(feature = "h265")]
-			"hev1" => Ok(DecoderFormat::Hev1),
-			#[cfg(feature = "mp4")]
-			"fmp4" | "cmaf" => Ok(DecoderFormat::Fmp4),
-			#[cfg(feature = "av1")]
-			"av01" | "av1" | "av1C" => Ok(DecoderFormat::Av01),
-			#[cfg(feature = "aac")]
-			"aac" => Ok(DecoderFormat::Aac),
-			#[cfg(feature = "opus")]
-			"opus" => Ok(DecoderFormat::Opus),
+			"hev1" => Ok(FramedFormat::Hev1),
+			"fmp4" | "cmaf" => Ok(FramedFormat::Fmp4),
+			"av01" | "av1" | "av1C" => Ok(FramedFormat::Av01),
+			"aac" => Ok(FramedFormat::Aac),
+			"opus" => Ok(FramedFormat::Opus),
 			_ => Err(Error::UnknownFormat(s.to_string())),
 		}
 	}
 }
 
-impl fmt::Display for DecoderFormat {
+impl fmt::Display for FramedFormat {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		match *self {
-			#[cfg(feature = "h264")]
-			DecoderFormat::Avc1 => write!(f, "avc1"),
-			#[cfg(feature = "h264")]
-			DecoderFormat::Avc3 => write!(f, "avc3"),
-			#[cfg(feature = "mp4")]
-			DecoderFormat::Fmp4 => write!(f, "fmp4"),
-			#[cfg(feature = "h265")]
-			DecoderFormat::Hev1 => write!(f, "hev1"),
-			#[cfg(feature = "av1")]
-			DecoderFormat::Av01 => write!(f, "av01"),
-			#[cfg(feature = "aac")]
-			DecoderFormat::Aac => write!(f, "aac"),
-			#[cfg(feature = "opus")]
-			DecoderFormat::Opus => write!(f, "opus"),
+			FramedFormat::Avc1 => write!(f, "avc1"),
+			FramedFormat::Avc3 => write!(f, "avc3"),
+			FramedFormat::Fmp4 => write!(f, "fmp4"),
+			FramedFormat::Hev1 => write!(f, "hev1"),
+			FramedFormat::Av01 => write!(f, "av01"),
+			FramedFormat::Aac => write!(f, "aac"),
+			FramedFormat::Opus => write!(f, "opus"),
 		}
 	}
 }
@@ -85,16 +66,12 @@ impl fmt::Display for DecoderFormat {
 #[non_exhaustive]
 pub enum StreamFormat {
 	/// aka H264 with inline SPS/PPS
-	#[cfg(feature = "h264")]
 	Avc3,
 	/// fMP4/CMAF container.
-	#[cfg(feature = "mp4")]
 	Fmp4,
 	/// aka H265 with inline SPS/PPS
-	#[cfg(feature = "h265")]
 	Hev1,
 	/// AV1 with inline sequence headers
-	#[cfg(feature = "av1")]
 	Av01,
 }
 
@@ -103,18 +80,13 @@ impl FromStr for StreamFormat {
 
 	fn from_str(s: &str) -> Result<Self, Self::Err> {
 		match s {
-			#[cfg(feature = "h264")]
 			"avc3" => Ok(StreamFormat::Avc3),
-			#[cfg(feature = "h264")]
 			"h264" | "annex-b" => {
 				tracing::warn!("format '{s}' is deprecated, use 'avc3' instead");
 				Ok(StreamFormat::Avc3)
 			}
-			#[cfg(feature = "h265")]
 			"hev1" => Ok(StreamFormat::Hev1),
-			#[cfg(feature = "mp4")]
 			"fmp4" | "cmaf" => Ok(StreamFormat::Fmp4),
-			#[cfg(feature = "av1")]
 			"av01" | "av1" | "av1C" => Ok(StreamFormat::Av01),
 			_ => Err(Error::UnknownFormat(s.to_string())),
 		}
@@ -124,29 +96,21 @@ impl FromStr for StreamFormat {
 impl fmt::Display for StreamFormat {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		match *self {
-			#[cfg(feature = "h264")]
 			StreamFormat::Avc3 => write!(f, "avc3"),
-			#[cfg(feature = "mp4")]
 			StreamFormat::Fmp4 => write!(f, "fmp4"),
-			#[cfg(feature = "h265")]
 			StreamFormat::Hev1 => write!(f, "hev1"),
-			#[cfg(feature = "av1")]
 			StreamFormat::Av01 => write!(f, "av01"),
 		}
 	}
 }
 
-impl From<StreamFormat> for DecoderFormat {
+impl From<StreamFormat> for FramedFormat {
 	fn from(format: StreamFormat) -> Self {
 		match format {
-			#[cfg(feature = "h264")]
-			StreamFormat::Avc3 => DecoderFormat::Avc3,
-			#[cfg(feature = "mp4")]
-			StreamFormat::Fmp4 => DecoderFormat::Fmp4,
-			#[cfg(feature = "h265")]
-			StreamFormat::Hev1 => DecoderFormat::Hev1,
-			#[cfg(feature = "av1")]
-			StreamFormat::Av01 => DecoderFormat::Av01,
+			StreamFormat::Avc3 => FramedFormat::Avc3,
+			StreamFormat::Fmp4 => FramedFormat::Fmp4,
+			StreamFormat::Hev1 => FramedFormat::Hev1,
+			StreamFormat::Av01 => FramedFormat::Av01,
 		}
 	}
 }
@@ -154,59 +118,47 @@ impl From<StreamFormat> for DecoderFormat {
 #[derive(derive_more::From)]
 enum StreamKind {
 	/// aka H264 with inline SPS/PPS
-	#[cfg(feature = "h264")]
 	Avc3(super::Avc3),
 	// Boxed because it's a large struct and clippy complains about the size.
-	#[cfg(feature = "mp4")]
 	Fmp4(Box<super::Fmp4>),
 	/// aka H265 with inline SPS/PPS
-	#[cfg(feature = "h265")]
 	Hev1(super::Hev1),
-	#[cfg(feature = "av1")]
 	Av01(super::Av01),
 }
 
 #[derive(derive_more::From)]
-enum DecoderKind {
+enum FramedKind {
 	/// H264 with AVCC framing
-	#[cfg(feature = "h264")]
 	Avc1(super::Avc1),
 	/// H264 with Annex B framing
-	#[cfg(feature = "h264")]
 	Avc3(super::Avc3),
 	// Boxed because it's a large struct and clippy complains about the size.
-	#[cfg(feature = "mp4")]
 	Fmp4(Box<super::Fmp4>),
 	/// aka H265 with inline SPS/PPS
-	#[cfg(feature = "h265")]
 	Hev1(super::Hev1),
-	#[cfg(feature = "av1")]
 	Av01(super::Av01),
-	#[cfg(feature = "aac")]
 	Aac(super::Aac),
-	#[cfg(feature = "opus")]
 	Opus(super::Opus),
 }
 
-/// A decoder for formats that support stream decoding (unknown frame boundaries).
+/// An importer for formats that support stream decoding (unknown frame boundaries).
 ///
 /// This includes formats like H.264 (AVC3), H.265 (HEV1), and fMP4/CMAF.
 /// Use this when the caller does not know the frame boundaries.
-pub struct StreamDecoder {
+pub struct Stream {
 	decoder: StreamKind,
 }
 
-impl StreamDecoder {
-	/// Create a new stream decoder with the given format.
+#[deprecated(note = "use Stream instead")]
+pub type StreamDecoder = Stream;
+
+impl Stream {
+	/// Create a new stream importer with the given format.
 	pub fn new(broadcast: moq_lite::BroadcastProducer, catalog: crate::CatalogProducer, format: StreamFormat) -> Self {
 		let decoder = match format {
-			#[cfg(feature = "h264")]
 			StreamFormat::Avc3 => super::Avc3::new(broadcast, catalog).into(),
-			#[cfg(feature = "mp4")]
-			StreamFormat::Fmp4 => Box::new(super::Fmp4::new(broadcast, catalog, super::Fmp4Config::default())).into(),
-			#[cfg(feature = "h265")]
+			StreamFormat::Fmp4 => Box::new(super::Fmp4::new(broadcast, catalog)).into(),
 			StreamFormat::Hev1 => super::Hev1::new(broadcast, catalog).into(),
-			#[cfg(feature = "av1")]
 			StreamFormat::Av01 => super::Av01::new(broadcast, catalog).into(),
 		};
 
@@ -220,13 +172,9 @@ impl StreamDecoder {
 	/// The buffer will be fully consumed, or an error will be returned.
 	pub fn initialize<T: Buf + AsRef<[u8]>>(&mut self, buf: &mut T) -> anyhow::Result<()> {
 		match self.decoder {
-			#[cfg(feature = "h264")]
 			StreamKind::Avc3(ref mut decoder) => decoder.initialize(buf)?,
-			#[cfg(feature = "mp4")]
 			StreamKind::Fmp4(ref mut decoder) => decoder.decode(buf)?,
-			#[cfg(feature = "h265")]
 			StreamKind::Hev1(ref mut decoder) => decoder.initialize(buf)?,
-			#[cfg(feature = "av1")]
 			StreamKind::Av01(ref mut decoder) => decoder.initialize(buf)?,
 		}
 
@@ -246,13 +194,9 @@ impl StreamDecoder {
 	/// If the buffer is not fully consumed, more data is needed.
 	pub fn decode_stream<T: Buf + AsRef<[u8]>>(&mut self, buf: &mut T) -> anyhow::Result<()> {
 		match self.decoder {
-			#[cfg(feature = "h264")]
 			StreamKind::Avc3(ref mut decoder) => decoder.decode_stream(buf, None),
-			#[cfg(feature = "mp4")]
 			StreamKind::Fmp4(ref mut decoder) => decoder.decode(buf),
-			#[cfg(feature = "h265")]
 			StreamKind::Hev1(ref mut decoder) => decoder.decode_stream(buf, None),
-			#[cfg(feature = "av1")]
 			StreamKind::Av01(ref mut decoder) => decoder.decode_stream(buf, None),
 		}
 	}
@@ -263,13 +207,9 @@ impl StreamDecoder {
 	/// group is properly finalized.
 	pub fn finish(&mut self) -> anyhow::Result<()> {
 		match self.decoder {
-			#[cfg(feature = "h264")]
 			StreamKind::Avc3(ref mut decoder) => decoder.finish(),
-			#[cfg(feature = "mp4")]
 			StreamKind::Fmp4(ref mut decoder) => decoder.finish(),
-			#[cfg(feature = "h265")]
 			StreamKind::Hev1(ref mut decoder) => decoder.finish(),
-			#[cfg(feature = "av1")]
 			StreamKind::Av01(ref mut decoder) => decoder.finish(),
 		}
 	}
@@ -277,73 +217,65 @@ impl StreamDecoder {
 	/// Check if the decoder has read enough data to be initialized.
 	pub fn is_initialized(&self) -> bool {
 		match self.decoder {
-			#[cfg(feature = "h264")]
 			StreamKind::Avc3(ref decoder) => decoder.is_initialized(),
-			#[cfg(feature = "mp4")]
 			StreamKind::Fmp4(ref decoder) => decoder.is_initialized(),
-			#[cfg(feature = "h265")]
 			StreamKind::Hev1(ref decoder) => decoder.is_initialized(),
-			#[cfg(feature = "av1")]
 			StreamKind::Av01(ref decoder) => decoder.is_initialized(),
 		}
 	}
 }
 
-/// A decoder for formats with known frame boundaries.
+/// An importer for formats with known frame boundaries.
 ///
 /// This supports all formats and should be used when the caller knows the frame boundaries.
-pub struct Decoder {
-	decoder: DecoderKind,
+pub struct Framed {
+	decoder: FramedKind,
 }
 
-impl Decoder {
-	/// Create a new decoder with the given format and initialization data.
+#[deprecated(note = "use Framed instead")]
+pub type Decoder = Framed;
+
+impl Framed {
+	/// Create a new framed importer with the given format and initialization data.
 	///
 	/// The buffer will be fully consumed, or an error will be returned.
 	pub fn new<T: Buf + AsRef<[u8]>>(
 		broadcast: moq_lite::BroadcastProducer,
 		catalog: crate::CatalogProducer,
-		format: DecoderFormat,
+		format: FramedFormat,
 		buf: &mut T,
 	) -> anyhow::Result<Self> {
 		let decoder = match format {
-			#[cfg(feature = "h264")]
-			DecoderFormat::Avc1 => {
+			FramedFormat::Avc1 => {
 				let mut decoder = super::Avc1::new(broadcast, catalog);
 				decoder.initialize(buf)?;
 				decoder.into()
 			}
-			#[cfg(feature = "h264")]
-			DecoderFormat::Avc3 => {
+			FramedFormat::Avc3 => {
 				let mut decoder = super::Avc3::new(broadcast, catalog);
 				decoder.initialize(buf)?;
 				decoder.into()
 			}
-			#[cfg(feature = "mp4")]
-			DecoderFormat::Fmp4 => {
-				let mut decoder = Box::new(super::Fmp4::new(broadcast, catalog, super::Fmp4Config::default()));
+			FramedFormat::Fmp4 => {
+				let mut decoder = Box::new(super::Fmp4::new(broadcast, catalog));
 				decoder.decode(buf)?;
 				decoder.into()
 			}
-			#[cfg(feature = "h265")]
-			DecoderFormat::Hev1 => {
+			FramedFormat::Hev1 => {
 				let mut decoder = super::Hev1::new(broadcast, catalog);
 				decoder.initialize(buf)?;
 				decoder.into()
 			}
-			#[cfg(feature = "av1")]
-			DecoderFormat::Av01 => {
+			FramedFormat::Av01 => {
 				let mut decoder = super::Av01::new(broadcast, catalog);
 				decoder.initialize(buf)?;
 				decoder.into()
 			}
-			#[cfg(feature = "aac")]
-			DecoderFormat::Aac => {
+			FramedFormat::Aac => {
 				let config = super::AacConfig::parse(buf)?;
 				super::Aac::new(broadcast, catalog, config)?.into()
 			}
-			#[cfg(feature = "opus")]
-			DecoderFormat::Opus => {
+			FramedFormat::Opus => {
 				let config = super::OpusConfig::parse(buf)?;
 				super::Opus::new(broadcast, catalog, config)?.into()
 			}
@@ -360,20 +292,13 @@ impl Decoder {
 	/// group is properly finalized.
 	pub fn finish(&mut self) -> anyhow::Result<()> {
 		match self.decoder {
-			#[cfg(feature = "h264")]
-			DecoderKind::Avc1(ref mut decoder) => decoder.finish(),
-			#[cfg(feature = "h264")]
-			DecoderKind::Avc3(ref mut decoder) => decoder.finish(),
-			#[cfg(feature = "mp4")]
-			DecoderKind::Fmp4(ref mut decoder) => decoder.finish(),
-			#[cfg(feature = "h265")]
-			DecoderKind::Hev1(ref mut decoder) => decoder.finish(),
-			#[cfg(feature = "av1")]
-			DecoderKind::Av01(ref mut decoder) => decoder.finish(),
-			#[cfg(feature = "aac")]
-			DecoderKind::Aac(ref mut decoder) => decoder.finish(),
-			#[cfg(feature = "opus")]
-			DecoderKind::Opus(ref mut decoder) => decoder.finish(),
+			FramedKind::Avc1(ref mut decoder) => decoder.finish(),
+			FramedKind::Avc3(ref mut decoder) => decoder.finish(),
+			FramedKind::Fmp4(ref mut decoder) => decoder.finish(),
+			FramedKind::Hev1(ref mut decoder) => decoder.finish(),
+			FramedKind::Av01(ref mut decoder) => decoder.finish(),
+			FramedKind::Aac(ref mut decoder) => decoder.finish(),
+			FramedKind::Opus(ref mut decoder) => decoder.finish(),
 		}
 	}
 
@@ -392,20 +317,13 @@ impl Decoder {
 		pts: Option<hang::container::Timestamp>,
 	) -> anyhow::Result<()> {
 		match self.decoder {
-			#[cfg(feature = "h264")]
-			DecoderKind::Avc1(ref mut decoder) => decoder.decode(buf, pts)?,
-			#[cfg(feature = "h264")]
-			DecoderKind::Avc3(ref mut decoder) => decoder.decode_frame(buf, pts)?,
-			#[cfg(feature = "mp4")]
-			DecoderKind::Fmp4(ref mut decoder) => decoder.decode(buf)?,
-			#[cfg(feature = "h265")]
-			DecoderKind::Hev1(ref mut decoder) => decoder.decode_frame(buf, pts)?,
-			#[cfg(feature = "av1")]
-			DecoderKind::Av01(ref mut decoder) => decoder.decode_frame(buf, pts)?,
-			#[cfg(feature = "aac")]
-			DecoderKind::Aac(ref mut decoder) => decoder.decode(buf, pts)?,
-			#[cfg(feature = "opus")]
-			DecoderKind::Opus(ref mut decoder) => decoder.decode(buf, pts)?,
+			FramedKind::Avc1(ref mut decoder) => decoder.decode(buf, pts)?,
+			FramedKind::Avc3(ref mut decoder) => decoder.decode_frame(buf, pts)?,
+			FramedKind::Fmp4(ref mut decoder) => decoder.decode(buf)?,
+			FramedKind::Hev1(ref mut decoder) => decoder.decode_frame(buf, pts)?,
+			FramedKind::Av01(ref mut decoder) => decoder.decode_frame(buf, pts)?,
+			FramedKind::Aac(ref mut decoder) => decoder.decode(buf, pts)?,
+			FramedKind::Opus(ref mut decoder) => decoder.decode(buf, pts)?,
 		}
 
 		anyhow::ensure!(!buf.has_remaining(), "buffer was not fully consumed");
@@ -414,15 +332,13 @@ impl Decoder {
 	}
 }
 
-#[cfg(feature = "opus")]
-impl From<super::Opus> for Decoder {
+impl From<super::Opus> for Framed {
 	fn from(opus: super::Opus) -> Self {
 		Self { decoder: opus.into() }
 	}
 }
 
-#[cfg(feature = "aac")]
-impl From<super::Aac> for Decoder {
+impl From<super::Aac> for Framed {
 	fn from(aac: super::Aac) -> Self {
 		Self { decoder: aac.into() }
 	}
diff --git a/rs/moq-mux/src/import/fmp4.rs b/rs/moq-mux/src/producer/fmp4.rs
similarity index 72%
rename from rs/moq-mux/src/import/fmp4.rs
rename to rs/moq-mux/src/producer/fmp4.rs
index 9a7574190..875ced7d3 100644
--- a/rs/moq-mux/src/import/fmp4.rs
+++ b/rs/moq-mux/src/producer/fmp4.rs
@@ -1,24 +1,18 @@
 use anyhow::Context;
+use base64::Engine;
 use bytes::{Buf, Bytes, BytesMut};
-use hang::catalog::{AAC, AV1, AudioCodec, AudioConfig, Container, H264, H265, VP9, VideoCodec, VideoConfig};
+use hang::catalog::{
+	AAC, AUDIO, AV1, Audio, AudioCodec, AudioConfig, Container, H264, H265, VIDEO, VP9, Video, VideoCodec, VideoConfig,
+};
 use hang::container::Timestamp;
-use mp4_atom::{Any, Atom, DecodeMaybe, Mdat, Moof, Moov, Trak};
+use mp4_atom::{Any, Atom, DecodeMaybe, Encode, Mdat, Moof, Moov, Trak};
 use std::collections::HashMap;
 use tokio::io::{AsyncRead, AsyncReadExt};
 
-/// Configuration for the fMP4 importer.
-#[derive(Clone, Default)]
-pub struct Fmp4Config {
-	/// When true, transport fMP4 fragments directly (passthrough mode)
-	///
-	/// This requires a player that can decode the fragments directly.
-	pub passthrough: bool,
-}
-
-/// Converts fMP4/CMAF files into hang broadcast streams.
+/// Converts fMP4/CMAF files into MoQ broadcast streams using CMAF passthrough.
 ///
-/// This struct processes fragmented MP4 (fMP4) files and converts them into hang broadcasts.
-/// Not all MP4 features are supported.
+/// This struct processes fragmented MP4 (fMP4) files and transports complete
+/// moof+mdat fragments directly as MoQ frames, preserving the CMAF container format.
 ///
 /// ## Supported Codecs
 ///
@@ -39,6 +33,12 @@ pub struct Fmp4 {
 	/// The catalog being produced
 	catalog: crate::CatalogProducer,
 
+	/// Local video section state
+	video: Video,
+
+	/// Local audio section state
+	audio: Audio,
+
 	// A lookup to tracks in the broadcast
 	tracks: HashMap<u32, Fmp4Track>,
 
@@ -49,10 +49,7 @@ pub struct Fmp4 {
 	moof: Option<Moof>,
 	moof_size: usize,
 
-	/// Configuration for the fMP4 importer.
-	config: Fmp4Config,
-
-	// -- PASSTHROUGH ONLY --
+	// The raw moof bytes for passthrough
 	moof_raw: Option<Bytes>,
 }
 
@@ -62,32 +59,11 @@ enum TrackKind {
 	Audio,
 }
 
-// Make a new audio group every 100ms.
-const MAX_AUDIO_GROUP_DURATION: Timestamp = Timestamp::from_millis_unchecked(100);
-
-enum Fmp4Producer {
-	/// Manual group management (video, passthrough audio).
-	Manual {
-		track: moq_lite::TrackProducer,
-		group: Option<moq_lite::GroupProducer>,
-	},
-	/// Automatic duration-based group management (non-passthrough audio).
-	Ordered(hang::container::OrderedProducer),
-}
-
-impl Fmp4Producer {
-	fn info(&self) -> &moq_lite::Track {
-		match self {
-			Self::Manual { track, .. } => &track.info,
-			Self::Ordered(ordered) => &ordered.track.info,
-		}
-	}
-}
-
 struct Fmp4Track {
 	kind: TrackKind,
 
-	producer: Fmp4Producer,
+	track: moq_lite::TrackProducer,
+	group: Option<moq_lite::GroupProducer>,
 
 	// The minimum buffer required for the track.
 	jitter: Option<Timestamp>,
@@ -103,15 +79,16 @@ impl Fmp4 {
 	/// Create a new CMAF importer that will write to the given broadcast.
 	///
 	/// The broadcast will be populated with tracks as they're discovered in the fMP4 file.
-	pub fn new(broadcast: moq_lite::BroadcastProducer, catalog: crate::CatalogProducer, config: Fmp4Config) -> Self {
+	pub fn new(broadcast: moq_lite::BroadcastProducer, catalog: crate::CatalogProducer) -> Self {
 		Self {
 			catalog,
+			video: Video::default(),
+			audio: Audio::default(),
 			tracks: HashMap::default(),
 			moov: None,
 			moof: None,
 			moof_size: 0,
 			broadcast,
-			config,
 			moof_raw: None,
 		}
 	}
@@ -147,10 +124,7 @@ impl Fmp4 {
 					anyhow::ensure!(self.moof.is_none(), "duplicate moof box");
 					self.moof.replace(moof);
 					self.moof_size = size;
-
-					if self.config.passthrough {
-						self.moof_raw.replace(Bytes::copy_from_slice(raw));
-					}
+					self.moof_raw.replace(Bytes::copy_from_slice(raw));
 				}
 				Any::Mdat(mdat) => {
 					self.extract(mdat, raw)?;
@@ -175,24 +149,20 @@ impl Fmp4 {
 	}
 
 	fn init(&mut self, moov: Moov) -> anyhow::Result<()> {
-		// Clone the catalog to avoid the borrow checker.
-		let mut catalog = self.catalog.clone();
-		let mut catalog = catalog.lock();
-
 		for trak in &moov.trak {
 			let track_id = trak.tkhd.track_id;
 			let handler = &trak.mdia.hdlr.handler;
-			let ext = if self.config.passthrough { "m4s" } else { "hang" };
+			let ext = "m4s";
 
 			let (kind, track) = match handler.as_ref() {
 				b"vide" => {
-					let config = self.init_video(trak)?;
-					let track = catalog.video.create_track(ext, config.clone());
+					let config = self.init_video(trak, &moov)?;
+					let track = self.video.create_track(ext, config.clone());
 					(TrackKind::Video, track)
 				}
 				b"soun" => {
-					let config = self.init_audio(trak)?;
-					let track = catalog.audio.create_track(ext, config.clone());
+					let config = self.init_audio(trak, &moov)?;
+					let track = self.audio.create_track(ext, config.clone());
 					(TrackKind::Audio, track)
 				}
 				b"sbtl" => anyhow::bail!("subtitle tracks are not supported"),
@@ -201,19 +171,12 @@ impl Fmp4 {
 
 			let track = self.broadcast.create_track(track)?;
 
-			let producer = if kind == TrackKind::Audio && !self.config.passthrough {
-				Fmp4Producer::Ordered(
-					hang::container::OrderedProducer::new(track).with_max_group_duration(MAX_AUDIO_GROUP_DURATION),
-				)
-			} else {
-				Fmp4Producer::Manual { track, group: None }
-			};
-
 			self.tracks.insert(
 				track_id,
 				Fmp4Track {
 					kind,
-					producer,
+					track,
+					group: None,
 					jitter: None,
 					last_timestamp: None,
 					min_duration: None,
@@ -221,26 +184,60 @@ impl Fmp4 {
 			);
 		}
 
-		drop(catalog);
+		// Publish the catalog with the new tracks
+		let _ = self.catalog.set(&VIDEO, &self.video);
+		let _ = self.catalog.set(&AUDIO, &self.audio);
+		self.catalog.flush();
 
 		self.moov = Some(moov);
 
 		Ok(())
 	}
 
-	fn container(&self, trak: &Trak) -> Container {
-		if self.config.passthrough {
-			Container::Cmaf {
-				timescale: trak.mdia.mdhd.timescale as u64,
-				track_id: trak.tkhd.track_id,
-			}
-		} else {
-			Container::Legacy
+	fn container(&self, trak: &Trak, moov: &Moov) -> anyhow::Result<Container> {
+		// Build a single-track init segment (ftyp+moov) for this track.
+		{
+			let ftyp = mp4_atom::Ftyp {
+				major_brand: b"isom".into(),
+				minor_version: 0x200,
+				compatible_brands: vec![b"isom".into(), b"iso6".into(), b"mp41".into()],
+			};
+
+			// Build a moov with just this single track and matching mvex/trex.
+			let track_id = trak.tkhd.track_id;
+			let trex = moov
+				.mvex
+				.as_ref()
+				.and_then(|mvex| mvex.trex.iter().find(|trex| trex.track_id == track_id))
+				.cloned()
+				.unwrap_or(mp4_atom::Trex {
+					track_id,
+					default_sample_description_index: 1,
+					..Default::default()
+				});
+
+			let single_moov = Moov {
+				mvhd: moov.mvhd.clone(),
+				trak: vec![trak.clone()],
+				mvex: Some(mp4_atom::Mvex {
+					mehd: None,
+					trex: vec![trex],
+				}),
+				meta: None,
+				udta: None,
+			};
+
+			let mut buf = Vec::new();
+			ftyp.encode(&mut buf)?;
+			single_moov.encode(&mut buf)?;
+
+			let init_data = base64::engine::general_purpose::STANDARD.encode(&buf);
+			Ok(Container::Cmaf { init_data })
 		}
 	}
 
-	fn init_video(&mut self, trak: &Trak) -> anyhow::Result<VideoConfig> {
-		let container = self.container(trak);
+	fn init_video(&mut self, trak: &Trak, moov: &Moov) -> anyhow::Result<VideoConfig> {
+		let container = self.container(trak, moov)?;
 		let stsd = &trak.mdia.minf.stbl.stsd;
 
 		let codec = match stsd.codecs.len() {
@@ -363,7 +360,6 @@ impl Fmp4 {
 		Ok(config)
 	}
 
-	// There's two almost identical hvcc atoms in the wild.
 	fn init_h265(
 		&mut self,
 		in_band: bool,
@@ -399,8 +395,8 @@ impl Fmp4 {
 		})
 	}
 
-	fn init_audio(&mut self, trak: &Trak) -> anyhow::Result<AudioConfig> {
-		let container = self.container(trak);
+	fn init_audio(&mut self, trak: &Trak, moov: &Moov) -> anyhow::Result<AudioConfig> {
+		let container = self.container(trak, moov)?;
 		let stsd = &trak.mdia.minf.stbl.stsd;
 
 		let codec = match stsd.codecs.len() {
@@ -455,7 +451,7 @@ impl Fmp4 {
 		Ok(config)
 	}
 
-	// Extract all frames out of an mdat atom.
+	// Extract all frames out of an mdat atom using CMAF passthrough.
 	fn extract(&mut self, mdat: Mdat, mdat_raw: &[u8]) -> anyhow::Result<()> {
 		let moov = self.moov.as_ref().context("missing moov box")?;
 		let moof = self.moof.take().context("missing moof box")?;
@@ -488,13 +484,13 @@ impl Fmp4 {
 			let timescale = trak.mdia.mdhd.timescale as u64;
 
 			let mut offset = traf.tfhd.base_data_offset.unwrap_or_default() as usize;
+			let mut track_data_start: Option<usize> = None;
 
 			if traf.trun.is_empty() {
 				anyhow::bail!("missing trun box");
 			}
 
 			// Keep track of the minimum and maximum timestamp for this track to compute the jitter.
-			// Ideally these should both be the same value (a single frame lul).
 			let mut min_timestamp = None;
 			let mut max_timestamp = None;
 			let mut contains_keyframe = false;
@@ -504,24 +500,24 @@ impl Fmp4 {
 
 				if let Some(data_offset) = trun.data_offset {
 					let base_offset = tfhd.base_data_offset.unwrap_or_default() as usize;
-					// This is relative to the start of the MOOF, not the MDAT.
-					// Note: The trun data offset can be negative, but... that's not supported here.
 					let data_offset: usize = data_offset.try_into().context("invalid data offset")?;
 
-					// Use checked arithmetic to prevent underflow
 					let relative_offset = data_offset
 						.checked_sub(moof_size)
 						.and_then(|v| v.checked_sub(header_size))
 						.context("invalid data offset: underflow")?;
 
-					// Reset offset if the TRUN has a data offset
 					offset = base_offset
 						.checked_add(relative_offset)
 						.context("invalid data offset: overflow")?;
 				}
 
+				// Capture the actual start offset for this traf before consuming samples
+				if track_data_start.is_none() {
+					track_data_start = Some(offset);
+				}
+
 				for entry in &trun.entries {
-					// Use the moof defaults if the sample doesn't have its own values.
 					let flags = entry
 						.flags
 						.unwrap_or(tfhd.default_sample_flags.unwrap_or(default_sample_flags));
@@ -541,49 +537,15 @@ impl Fmp4 {
 
 					let keyframe = match track.kind {
 						TrackKind::Video => {
-							// https://chromium.googlesource.com/chromium/src/media/+/master/formats/mp4/track_run_iterator.cc#177
-							let keyframe = (flags >> 24) & 0x3 == 0x2; // kSampleDependsOnNoOther
-							let non_sync = (flags >> 16) & 0x1 == 0x1; // kSampleIsNonSyncSample
-
+							let keyframe = (flags >> 24) & 0x3 == 0x2;
+							let non_sync = (flags >> 16) & 0x1 == 0x1;
 							keyframe && !non_sync
 						}
-						TrackKind::Audio => {
-							// Audio frames are always keyframes.
-							// TODO: Optionally bundle audio frames into groups to
-							true
-						}
+						TrackKind::Audio => true,
 					};
 
 					contains_keyframe |= keyframe;
 
-					if !self.config.passthrough {
-						// TODO Avoid a copy if mp4-atom switches to using Bytes?
-						let payload = Bytes::copy_from_slice(&mdat.data[offset..(offset + size)]);
-
-						let frame = hang::container::Frame {
-							timestamp,
-							payload: payload.into(),
-						};
-
-						match &mut track.producer {
-							Fmp4Producer::Manual { track: raw, group } => {
-								let mut g = if keyframe {
-									if let Some(mut prev) = group.take() {
-										prev.finish()?;
-									}
-									raw.append_group()?
-								} else {
-									group.take().context("no keyframe at start")?
-								};
-								frame.encode(&mut g)?;
-								*group = Some(g);
-							}
-							Fmp4Producer::Ordered(ordered) => {
-								ordered.write(frame)?;
-							}
-						}
-					}
-
 					if timestamp >= max_timestamp.unwrap_or(Timestamp::ZERO) {
 						max_timestamp = Some(timestamp);
 					}
@@ -605,65 +567,107 @@ impl Fmp4 {
 				}
 			}
 
-			// If we're doing passthrough mode, then we write one giant fragment instead of individual frames.
-			if self.config.passthrough {
-				let Fmp4Producer::Manual { track: raw, group } = &mut track.producer else {
-					unreachable!("passthrough always uses Manual");
-				};
-
-				let mut g = if contains_keyframe {
-					if let Some(mut prev) = group.take() {
-						prev.finish()?;
-					}
-					raw.append_group()?
-				} else {
-					group.take().context("no keyframe at start")?
-				};
+			// Build a per-track moof containing only this traf, and a per-track mdat
+			// with only the samples belonging to this track.
+			let single_traf_moof = Moof {
+				mfhd: moof.mfhd.clone(),
+				traf: vec![traf.clone()],
+			};
 
-				let moof_raw = self.moof_raw.as_ref().context("missing moof box")?;
+			// Compute the data range within the original mdat for this traf's samples.
+			let track_data_start = track_data_start.unwrap_or(0);
+			let track_data_end = offset; // offset was advanced past all samples above
 
-				// To avoid an extra allocation, we use the chunked API to write the moof and mdat atoms separately.
-				let mut frame = g.create_frame(moq_lite::Frame {
-					size: moof_raw.len() as u64 + mdat_raw.len() as u64,
-				})?;
+			// Adjust the trun data_offset to point into the new per-track mdat.
+			let mut adjusted_moof = single_traf_moof;
+			let mut moof_buf = Vec::new();
+			adjusted_moof.encode(&mut moof_buf)?;
+			let new_moof_size = moof_buf.len();
 
-				frame.write(moof_raw.clone())?;
-				frame.write(Bytes::copy_from_slice(mdat_raw))?;
-				frame.finish()?;
+			// Slice out this track's data from the full mdat
+			let track_mdat_data = if track_data_start < mdat.data.len() && track_data_end <= mdat.data.len() {
+				&mdat.data[track_data_start..track_data_end]
+			} else {
+				// Fallback: use the full mdat data (single-track case)
+				&mdat.data[..]
+			};
 
-				*group = Some(g);
+			// Re-encode moof with corrected per-trun data_offset for the per-track fragment.
+			// Each trun's data_offset points to the start of that run's data within the new mdat.
+			let mdat_header_size_new = 8u64; // 4 bytes size + 4 bytes 'mdat'
+			let mut cumulative_offset = 0u64;
+			for traf_mut in &mut adjusted_moof.traf {
+				// Clear base_data_offset since data_offset is now relative to moof start
+				traf_mut.tfhd.base_data_offset = None;
+
+				for trun_mut in &mut traf_mut.trun {
+					trun_mut.data_offset =
+						Some((new_moof_size as u64 + mdat_header_size_new + cumulative_offset) as i32);
+
+					// Advance past this trun's sample data
+					let trun_data_size: u64 = trun_mut
+						.entries
+						.iter()
+						.map(|e| {
+							e.size
+								.unwrap_or(traf_mut.tfhd.default_sample_size.unwrap_or(default_sample_size)) as u64
+						})
+						.sum();
+					cumulative_offset += trun_data_size;
+				}
 			}
 
+			moof_buf.clear();
+			adjusted_moof.encode(&mut moof_buf)?;
+
+			let per_track_mdat = Mdat {
+				data: track_mdat_data.to_vec(),
+			};
+			per_track_mdat.encode(&mut moof_buf)?;
+
+			let fragment_bytes = Bytes::from(moof_buf);
+
+			// Write the per-track fragment as a single MoQ frame (passthrough).
+			let mut g = if contains_keyframe {
+				if let Some(mut prev) = track.group.take() {
+					prev.finish()?;
+				}
+				track.track.append_group()?
+			} else {
+				track.group.take().context("no keyframe at start")?
+			};
+
+			g.write_frame(fragment_bytes)?;
+
+			track.group = Some(g);
+
 			if let (Some(min), Some(max), Some(min_duration)) = (min_timestamp, max_timestamp, track.min_duration) {
-				// We report the minimum buffer required as the difference between the min and max frames.
-				// We also add the duration between frames to account for the frame rate.
-				// ex. for 2s fragments, this should be exactly 2s if we did everything correctly.
 				let jitter = max - min + min_duration;
 
 				if jitter < track.jitter.unwrap_or(Timestamp::MAX) {
 					track.jitter = Some(jitter);
 
-					// Update the catalog with the new jitter
-					let mut catalog = self.catalog.lock();
-
 					match track.kind {
 						TrackKind::Video => {
-							let config = catalog
+							let config = self
 								.video
 								.renditions
-								.get_mut(&track.producer.info().name)
+								.get_mut(&track.track.info.name)
 								.context("missing video config")?;
 							config.jitter = Some(jitter.convert()?);
+							let _ = self.catalog.set(&VIDEO, &self.video);
 						}
 						TrackKind::Audio => {
-							let config = catalog
+							let config = self
 								.audio
 								.renditions
-								.get_mut(&track.producer.info().name)
+								.get_mut(&track.track.info.name)
 								.context("missing audio config")?;
 							config.jitter = Some(jitter.convert()?);
+							let _ = self.catalog.set(&AUDIO, &self.audio);
 						}
 					}
+					self.catalog.flush();
 				}
 			}
 		}
@@ -676,17 +680,10 @@ impl Fmp4 {
 	/// Finish all tracks, flushing current groups.
 	pub fn finish(&mut self) -> anyhow::Result<()> {
 		for track in self.tracks.values_mut() {
-			match &mut track.producer {
-				Fmp4Producer::Manual { track: raw, group } => {
-					if let Some(mut g) = group.take() {
-						g.finish()?;
-					}
-					raw.finish()?;
-				}
-				Fmp4Producer::Ordered(ordered) => {
-					ordered.finish()?;
-				}
+			if let Some(mut g) = track.group.take() {
+				g.finish()?;
 			}
+			track.track.finish()?;
 		}
 		Ok(())
 	}
@@ -694,14 +691,16 @@ impl Fmp4 {
 
 impl Drop for Fmp4 {
 	fn drop(&mut self) {
-		let mut catalog = self.catalog.lock();
-
 		for track in self.tracks.values() {
 			match track.kind {
-				TrackKind::Video => catalog.video.remove_track(track.producer.info()).is_some(),
-				TrackKind::Audio => catalog.audio.remove_track(track.producer.info()).is_some(),
+				TrackKind::Video => self.video.remove_track(&track.track.info).is_some(),
+				TrackKind::Audio => self.audio.remove_track(&track.track.info).is_some(),
 			};
 		}
+
+		let _ = self.catalog.set(&VIDEO, &self.video);
+		let _ = self.catalog.set(&AUDIO, &self.audio);
+		self.catalog.flush();
 	}
 }
 
diff --git a/rs/moq-mux/src/import/hev1.rs b/rs/moq-mux/src/producer/hev1.rs
similarity index 95%
rename from rs/moq-mux/src/import/hev1.rs
rename to rs/moq-mux/src/producer/hev1.rs
index 46412922c..1c54d889b 100644
--- a/rs/moq-mux/src/import/hev1.rs
+++ b/rs/moq-mux/src/producer/hev1.rs
@@ -14,6 +14,9 @@ pub struct Hev1 {
 	// The catalog being produced.
 	catalog: crate::CatalogProducer,
 
+	// Local video section state.
+	video: hang::catalog::Video,
+
 	// The track being produced.
 	track: Option<hang::container::OrderedProducer>,
 
@@ -35,9 +38,20 @@ pub struct Hev1 {
 
 impl Hev1 {
 	pub fn new(broadcast: moq_lite::BroadcastProducer, catalog: crate::CatalogProducer) -> Self {
+		// Read the current video section from the catalog, if any
+		let video: hang::catalog::Video = {
+			let state = catalog.writer().read();
+			state
+				.sections
+				.get("video")
+				.and_then(|v| serde_json::from_value(v.clone()).ok())
+				.unwrap_or_default()
+		};
+
 		Self {
 			broadcast,
 			catalog,
+			video,
 			track: None,
 			config: None,
 			current: Default::default(),
@@ -81,16 +95,17 @@ impl Hev1 {
 			return Ok(());
 		}
 
-		let mut catalog = self.catalog.lock();
-
 		if let Some(track) = &self.track.take() {
 			tracing::debug!(name = ?track.info.name, "reinitializing track");
-			catalog.video.remove_track(&track.info);
+			self.video.remove_track(&track.info);
 		}
 
-		let track = catalog.video.create_track("hev1", config.clone());
+		let track = self.video.create_track("hev1", config.clone());
 		tracing::debug!(name = ?track.name, ?config, "starting track");
 
+		let _ = self.catalog.set(&hang::catalog::VIDEO, &self.video);
+		self.catalog.flush();
+
 		let track = self.broadcast.create_track(track)?;
 
 		self.config = Some(config);
@@ -335,7 +350,9 @@ impl Drop for Hev1 {
 	fn drop(&mut self) {
 		if let Some(track) = &self.track {
 			tracing::debug!(name = ?track.info.name, "ending track");
-			self.catalog.lock().video.remove_track(&track.info);
+			self.video.remove_track(&track.info);
+			let _ = self.catalog.set(&hang::catalog::VIDEO, &self.video);
+			self.catalog.flush();
 		}
 	}
 }
diff --git a/rs/moq-mux/src/import/hls.rs b/rs/moq-mux/src/producer/hls.rs
similarity index 96%
rename from rs/moq-mux/src/import/hls.rs
rename to rs/moq-mux/src/producer/hls.rs
index ff77a62ad..2711c550b 100644
--- a/rs/moq-mux/src/import/hls.rs
+++ b/rs/moq-mux/src/producer/hls.rs
@@ -19,7 +19,7 @@ use reqwest::Client;
 use tracing::{debug, info, warn};
 use url::Url;
 
-use super::{Fmp4, Fmp4Config};
+use super::Fmp4;
 
 /// Configuration for the single-rendition HLS ingest loop.
 #[derive(Clone)]
@@ -30,20 +30,11 @@ pub struct HlsConfig {
 	/// An optional HTTP client to use for fetching the playlist and segments.
 	/// If not provided, a default client will be created.
 	pub client: Option<Client>,
-
-	/// Enable passthrough mode for CMAF fragment transport.
-	/// When enabled, complete fMP4 fragments (moof+mdat) are transported directly
-	/// instead of being decomposed into individual samples.
-	pub passthrough: bool,
 }
 
 impl HlsConfig {
 	pub fn new(playlist: String) -> Self {
-		Self {
-			playlist,
-			client: None,
-			passthrough: false,
-		}
+		Self { playlist, client: None }
 	}
 
 	/// Parse the playlist string into a URL.
@@ -97,7 +88,6 @@ pub struct Hls {
 	video: Vec<TrackState>,
 	/// Optional audio track shared across variants.
 	audio: Option<TrackState>,
-	passthrough: bool,
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -136,12 +126,10 @@ impl Hls {
 				.build()
 				.unwrap()
 		});
-		let passthrough = cfg.passthrough;
 		Ok(Self {
 			broadcast,
 			catalog,
 			video_importers: Vec::new(),
-			passthrough,
 			audio_importer: None,
 			client,
 			base_url,
@@ -487,13 +475,7 @@ impl Hls {
 	/// independent while still contributing to the same shared catalog.
 	fn ensure_video_importer_for(&mut self, index: usize) -> &mut Fmp4 {
 		while self.video_importers.len() <= index {
-			let importer = Fmp4::new(
-				self.broadcast.clone(),
-				self.catalog.clone(),
-				Fmp4Config {
-					passthrough: self.passthrough,
-				},
-			);
+			let importer = Fmp4::new(self.broadcast.clone(), self.catalog.clone());
 			self.video_importers.push(importer);
 		}
 
@@ -502,9 +484,8 @@ impl Hls {
 
 	/// Create or retrieve the fMP4 importer for the audio rendition.
 	fn ensure_audio_importer(&mut self) -> &mut Fmp4 {
-		let passthrough = self.passthrough;
 		self.audio_importer
-			.get_or_insert_with(|| Fmp4::new(self.broadcast.clone(), self.catalog.clone(), Fmp4Config { passthrough }))
+			.get_or_insert_with(|| Fmp4::new(self.broadcast.clone(), self.catalog.clone()))
 	}
 
 	#[cfg(test)]
@@ -634,8 +615,8 @@ mod tests {
 
 	#[test]
 	fn hls_ingest_starts_without_importers() {
-		let mut broadcast = moq_lite::Broadcast::produce();
-		let catalog = crate::CatalogProducer::new(&mut broadcast).unwrap();
+		let broadcast = moq_lite::Broadcast::new().produce();
+		let catalog = crate::CatalogProducer::new(&broadcast).unwrap();
 		let url = "https://example.com/master.m3u8".to_string();
 		let cfg = HlsConfig::new(url);
 		let hls = Hls::new(broadcast, catalog, cfg).unwrap();
diff --git a/rs/moq-mux/src/producer/mod.rs b/rs/moq-mux/src/producer/mod.rs
new file mode 100644
index 000000000..c7ef38869
--- /dev/null
+++ b/rs/moq-mux/src/producer/mod.rs
@@ -0,0 +1,32 @@
+//! Media demuxers for MoQ.
+//!
+//! This crate provides modules for converting existing media formats into MoQ broadcasts.
+//! It supports various container and codec formats.
+//!
+//! The [Framed] and [Stream] types provide generic interfaces for importing media.
+//! [Framed] is for formats with known frame boundaries, [Stream] for unknown boundaries.
+//! If you know the format in advance, use the specific codec module instead.
+
+mod aac;
+mod annexb;
+mod av01;
+mod avc1;
+mod avc3;
+mod decoder;
+mod fmp4;
+mod hev1;
+mod hls;
+mod opus;
+
+pub use aac::*;
+pub use av01::*;
+pub use avc1::*;
+pub use avc3::*;
+pub use decoder::*;
+pub use fmp4::*;
+pub use hev1::*;
+pub use hls::*;
+pub use opus::*;
+
+#[cfg(test)]
+mod test;
diff --git a/rs/moq-mux/src/import/opus.rs b/rs/moq-mux/src/producer/opus.rs
similarity index 73%
rename from rs/moq-mux/src/import/opus.rs
rename to rs/moq-mux/src/producer/opus.rs
index 0bb51dbf1..51c75606b 100644
--- a/rs/moq-mux/src/import/opus.rs
+++ b/rs/moq-mux/src/producer/opus.rs
@@ -45,37 +45,48 @@ impl OpusConfig {
 /// Opus decoder, initialized via a OpusHead. Does not support Ogg.
 pub struct Opus {
 	catalog: crate::CatalogProducer,
+	audio: hang::catalog::Audio,
 	track: hang::container::OrderedProducer,
 	zero: Option<tokio::time::Instant>,
 }
 
 impl Opus {
 	pub fn new(
-		mut broadcast: moq_lite::BroadcastProducer,
+		broadcast: moq_lite::BroadcastProducer,
 		mut catalog: crate::CatalogProducer,
 		config: OpusConfig,
 	) -> anyhow::Result<Self> {
-		let track = {
-			let mut cat = catalog.lock();
-
-			let audio_config = hang::catalog::AudioConfig {
-				codec: hang::catalog::AudioCodec::Opus,
-				sample_rate: config.sample_rate,
-				channel_count: config.channel_count,
-				bitrate: None,
-				description: None,
-				container: hang::catalog::Container::Legacy,
-				jitter: None,
-			};
-
-			let track = cat.audio.create_track("opus", audio_config.clone());
-			tracing::debug!(name = ?track.name, config = ?audio_config, "starting track");
-
-			broadcast.create_track(track)?
+		// Read the current audio section from the catalog, if any
+		let mut audio: hang::catalog::Audio = {
+			let state = catalog.writer().read();
+			state
+				.sections
+				.get("audio")
+				.and_then(|v| serde_json::from_value(v.clone()).ok())
+				.unwrap_or_default()
 		};
 
+		let audio_config = hang::catalog::AudioConfig {
+			codec: hang::catalog::AudioCodec::Opus,
+			sample_rate: config.sample_rate,
+			channel_count: config.channel_count,
+			bitrate: None,
+			description: None,
+			container: hang::catalog::Container::Legacy,
+			jitter: None,
+		};
+
+		let track_info = audio.create_track("opus", audio_config.clone());
+		tracing::debug!(name = ?track_info.name, config = ?audio_config, "starting track");
+
+		let _ = catalog.set(&hang::catalog::AUDIO, &audio);
+		catalog.flush();
+
+		let track = broadcast.create_track(track_info)?;
+
 		Ok(Self {
 			catalog,
+			audio,
 			track: hang::container::OrderedProducer::new(track).with_max_group_duration(MAX_GROUP_DURATION),
 			zero: None,
 		})
@@ -121,6 +132,8 @@ impl Opus {
 impl Drop for Opus {
 	fn drop(&mut self) {
 		tracing::debug!(name = ?self.track.info.name, "ending track");
-		self.catalog.lock().audio.remove_track(&self.track.info);
+		self.audio.remove_track(&self.track.info);
+		let _ = self.catalog.set(&hang::catalog::AUDIO, &self.audio);
+		self.catalog.flush();
 	}
 }
diff --git a/rs/moq-mux/src/producer/test/av1.mp4 b/rs/moq-mux/src/producer/test/av1.mp4
new file mode 100644
index 000000000..fd0272dbd
Binary files /dev/null and b/rs/moq-mux/src/producer/test/av1.mp4 differ
diff --git a/rs/moq-mux/src/producer/test/bbb.mp4 b/rs/moq-mux/src/producer/test/bbb.mp4
new file mode 100644
index 000000000..1c42daf3f
Binary files /dev/null and b/rs/moq-mux/src/producer/test/bbb.mp4 differ
diff --git a/rs/moq-mux/src/producer/test/mod.rs b/rs/moq-mux/src/producer/test/mod.rs
new file mode 100644
index 000000000..cb9b3bc7e
--- /dev/null
+++ b/rs/moq-mux/src/producer/test/mod.rs
@@ -0,0 +1,153 @@
+use base64::Engine;
+use hang::catalog::{Audio, Container, Video};
+use mp4_atom::{Decode, Encode};
+
+struct CatalogSnapshot {
+	video: Video,
+	audio: Audio,
+}
+
+fn run_fmp4(data: &[u8]) -> CatalogSnapshot {
+	let broadcast = moq_lite::Broadcast::new().produce();
+	let catalog = crate::CatalogProducer::new(&broadcast).unwrap();
+
+	let mut fmp4 = super::Fmp4::new(broadcast, catalog.clone());
+
+	let mut buf = bytes::BytesMut::from(data);
+	// Ignore errors from incomplete/malformed trailing fragments in test files.
+	let _ = fmp4.decode(&mut buf);
+
+	// Read video and audio sections from the catalog writer
+	let state = catalog.writer().read();
+	let video: Video = state
+		.sections
+		.get("video")
+		.and_then(|v| serde_json::from_value(v.clone()).ok())
+		.unwrap_or_default();
+	let audio: Audio = state
+		.sections
+		.get("audio")
+		.and_then(|v| serde_json::from_value(v.clone()).ok())
+		.unwrap_or_default();
+
+	CatalogSnapshot { video, audio }
+}
+
+fn decode_init_data(init_data: &str) -> (mp4_atom::Ftyp, mp4_atom::Moov) {
+	let bytes = base64::engine::general_purpose::STANDARD
+		.decode(init_data)
+		.expect("invalid base64");
+	let mut cursor = std::io::Cursor::new(&bytes);
+	let ftyp = mp4_atom::Ftyp::decode(&mut cursor).expect("invalid ftyp");
+	let moov = mp4_atom::Moov::decode(&mut cursor).expect("invalid moov");
+	(ftyp, moov)
+}
+
+#[test]
+fn test_bbb_catalog() {
+	let data = include_bytes!("bbb.mp4");
+	let catalog = run_fmp4(data);
+
+	assert_eq!(catalog.video.renditions.len(), 1);
+	assert_eq!(catalog.audio.renditions.len(), 1);
+
+	let video = catalog.video.renditions.values().next().unwrap();
+	assert_eq!(video.codec.to_string(), "avc1.64001f");
+	assert_eq!(video.coded_width, Some(1280));
+	assert_eq!(video.coded_height, Some(720));
+	assert!(matches!(video.container, Container::Cmaf { .. }));
+
+	let audio = catalog.audio.renditions.values().next().unwrap();
+	assert_eq!(audio.codec.to_string(), "mp4a.40.2");
+	assert_eq!(audio.sample_rate, 44100);
+	assert_eq!(audio.channel_count, 2);
+	assert!(matches!(audio.container, Container::Cmaf { .. }));
+}
+
+#[test]
+fn test_bbb_init_data_roundtrip() {
+	let data = include_bytes!("bbb.mp4");
+	let catalog = run_fmp4(data);
+
+	// Check video init data
+	let video = catalog.video.renditions.values().next().unwrap();
+	let Container::Cmaf { init_data } = &video.container else {
+		panic!("expected Cmaf container");
+	};
+	let (ftyp, moov) = decode_init_data(init_data);
+	assert_eq!(ftyp.major_brand, mp4_atom::FourCC::new(b"isom"));
+	assert_eq!(moov.trak.len(), 1);
+	assert_eq!(moov.trak[0].tkhd.track_id, 1);
+	assert_eq!(moov.trak[0].mdia.mdhd.timescale, 24000);
+	let mvex = moov.mvex.as_ref().unwrap();
+	assert_eq!(mvex.trex.len(), 1);
+	assert_eq!(mvex.trex[0].track_id, 1);
+
+	// Verify it round-trips through encode/decode
+	let mut buf = Vec::new();
+	ftyp.encode(&mut buf).unwrap();
+	moov.encode(&mut buf).unwrap();
+	let (ftyp2, moov2) = decode_init_data(&base64::engine::general_purpose::STANDARD.encode(&buf));
+	assert_eq!(ftyp2.major_brand, mp4_atom::FourCC::new(b"isom"));
+	assert_eq!(moov2.trak.len(), 1);
+
+	// Check audio init data
+	let audio = catalog.audio.renditions.values().next().unwrap();
+	let Container::Cmaf { init_data } = &audio.container else {
+		panic!("expected Cmaf container");
+	};
+	let (ftyp, moov) = decode_init_data(init_data);
+	assert_eq!(ftyp.major_brand, mp4_atom::FourCC::new(b"isom"));
+	assert_eq!(moov.trak.len(), 1);
+	assert_eq!(moov.trak[0].tkhd.track_id, 2);
+	assert_eq!(moov.trak[0].mdia.mdhd.timescale, 44100);
+	let mvex = moov.mvex.as_ref().unwrap();
+	assert_eq!(mvex.trex.len(), 1);
+	assert_eq!(mvex.trex[0].track_id, 2);
+}
+
+#[test]
+fn test_av1_catalog() {
+	let data = include_bytes!("av1.mp4");
+	let catalog = run_fmp4(data);
+
+	assert_eq!(catalog.video.renditions.len(), 1);
+	assert_eq!(catalog.audio.renditions.len(), 0);
+
+	let video = catalog.video.renditions.values().next().unwrap();
+	assert!(video.codec.to_string().starts_with("av01."), "codec: {}", video.codec);
+	assert!(matches!(video.container, Container::Cmaf { .. }));
+
+	let Container::Cmaf { init_data } = &video.container else {
+		panic!("expected Cmaf container");
+	};
+	let (ftyp, moov) = decode_init_data(init_data);
+	assert_eq!(ftyp.major_brand, mp4_atom::FourCC::new(b"isom"));
+	assert_eq!(moov.trak.len(), 1);
+	let mvex = moov.mvex.as_ref().unwrap();
+	assert_eq!(mvex.trex.len(), 1);
+	assert_eq!(mvex.trex[0].track_id, moov.trak[0].tkhd.track_id);
+}
+
+#[test]
+fn test_vp9_catalog() {
+	let data = include_bytes!("vp9.mp4");
+	let catalog = run_fmp4(data);
+
+	assert_eq!(catalog.video.renditions.len(), 1);
+	assert_eq!(catalog.audio.renditions.len(), 0);
+
+	let video = catalog.video.renditions.values().next().unwrap();
+	assert!(video.codec.to_string().starts_with("vp09."), "codec: {}", video.codec);
+	assert!(matches!(video.container, Container::Cmaf { .. }));
+
+	let Container::Cmaf { init_data } = &video.container else {
+		panic!("expected Cmaf container");
+	};
+	let (ftyp, moov) = decode_init_data(init_data);
+	assert_eq!(ftyp.major_brand, mp4_atom::FourCC::new(b"isom"));
+	assert_eq!(moov.trak.len(), 1);
+	let mvex = moov.mvex.as_ref().unwrap();
+	assert_eq!(mvex.trex.len(), 1);
+	assert_eq!(mvex.trex[0].track_id, moov.trak[0].tkhd.track_id);
+}
diff --git a/rs/moq-mux/src/producer/test/vp9.mp4 b/rs/moq-mux/src/producer/test/vp9.mp4
new file mode 100644
index 000000000..12a6ae236
Binary files /dev/null and b/rs/moq-mux/src/producer/test/vp9.mp4 differ
diff --git a/rs/moq-native/examples/chat.rs b/rs/moq-native/examples/chat.rs
index 66e2480c3..69261fdd8 100644
--- a/rs/moq-native/examples/chat.rs
+++ b/rs/moq-native/examples/chat.rs
@@ -3,7 +3,7 @@
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
 	// Optional: Use moq_native to configure a logger.
-	moq_native::Log::new(tracing::Level::DEBUG).init();
+	moq_native::Log::new(tracing::Level::DEBUG).init()?;
 
 	// Create an origin that we can publish to and the session can consume from.
 	let origin = moq_lite::Origin::produce();
@@ -37,14 +37,11 @@ async fn run_session(origin: moq_lite::OriginConsumer) -> anyhow::Result<()> {
 async fn run_broadcast(origin: moq_lite::OriginProducer) -> anyhow::Result<()> {
 	// Create and publish a broadcast to the origin..
 	// A broadcast is a collection of tracks, but in this example we'll only create one.
-	let mut broadcast = moq_lite::Broadcast::produce();
+	let broadcast = moq_lite::Broadcast::new().produce();
 
 	// Create a track that we'll insert into the broadcast.
 	// A track is a series of groups representing a live stream.
-	let mut track = broadcast.create_track(moq_lite::Track {
-		name: "chat".to_string(),
-		priority: 0,
-	})?;
+	let mut track = broadcast.create_track(moq_lite::Track::new("chat"))?;
 
 	// NOTE: The path is empty because we're using the URL to scope the broadcast.
 	// If you put "alice" here, it would be published as "anon/chat-example/alice".
diff --git a/rs/moq-native/src/client.rs b/rs/moq-native/src/client.rs
index 01951a499..7068a4c92 100644
--- a/rs/moq-native/src/client.rs
+++ b/rs/moq-native/src/client.rs
@@ -8,6 +8,7 @@ use url::Url;
 /// TLS configuration for the client.
 #[derive(Clone, Default, Debug, clap::Args, serde::Serialize, serde::Deserialize)]
 #[serde(default, deny_unknown_fields)]
+#[group(id = "client-tls")]
 #[non_exhaustive]
 pub struct ClientTls {
 	/// Use the TLS root at this path, encoded as PEM.
@@ -37,6 +38,7 @@ pub struct ClientTls {
 /// Configuration for the MoQ client.
 #[derive(Clone, Debug, clap::Parser, serde::Serialize, serde::Deserialize)]
 #[serde(deny_unknown_fields, default)]
+#[group(id = "client")]
 #[non_exhaustive]
 pub struct ClientConfig {
 	/// Listen for UDP packets on the given address.
@@ -80,7 +82,7 @@ pub struct ClientConfig {
 	#[cfg(feature = "websocket")]
 	#[command(flatten)]
 	#[serde(default)]
-	pub websocket: super::ClientWebSocket,
+	pub websocket: super::ws::ClientConfig,
 }
 
 impl ClientConfig {
@@ -96,6 +98,36 @@ impl ClientConfig {
 			moq_lite::Versions::from(self.version.clone())
 		}
 	}
+
+	pub fn with_bind(mut self, bind: net::SocketAddr) -> Self {
+		self.bind = bind;
+		self
+	}
+
+	pub fn with_backend(mut self, backend: QuicBackend) -> Self {
+		self.backend = Some(backend);
+		self
+	}
+
+	pub fn with_max_streams(mut self, max_streams: u64) -> Self {
+		self.max_streams = Some(max_streams);
+		self
+	}
+
+	pub fn with_version(mut self, version: moq_lite::Version) -> Self {
+		self.version.push(version);
+		self
+	}
+
+	pub fn with_tls_disable_verify(mut self, disable: bool) -> Self {
+		self.tls.disable_verify = Some(disable);
+		self
+	}
+
+	pub fn with_tls_root(mut self, root: PathBuf) -> Self {
+		self.tls.root.push(root);
+		self
+	}
 }
 
 impl Default for ClientConfig {
@@ -107,7 +139,7 @@ impl Default for ClientConfig {
 			version: Vec::new(),
 			tls: ClientTls::default(),
 			#[cfg(feature = "websocket")]
-			websocket: super::ClientWebSocket::default(),
+			websocket: super::ws::ClientConfig::default(),
 		}
 	}
 }
@@ -120,14 +152,14 @@ pub struct Client {
 	moq: moq_lite::Client,
 	versions: moq_lite::Versions,
 	#[cfg(feature = "websocket")]
-	websocket: super::ClientWebSocket,
+	websocket: super::ws::ClientConfig,
 	tls: rustls::ClientConfig,
 	#[cfg(feature = "noq")]
-	noq: Option<crate::noq::NoqClient>,
+	noq: Option<crate::noq::Client>,
 	#[cfg(feature = "quinn")]
-	quinn: Option<crate::quinn::QuinnClient>,
+	quinn: Option<crate::quinn::Client>,
 	#[cfg(feature = "quiche")]
-	quiche: Option<crate::quiche::QuicheClient>,
+	quiche: Option<crate::quiche::Client>,
 	#[cfg(feature = "iroh")]
 	iroh: Option<web_transport_iroh::iroh::Endpoint>,
 	#[cfg(feature = "iroh")]
@@ -211,20 +243,20 @@ impl Client {
 		#[cfg(feature = "noq")]
 		#[allow(unreachable_patterns)]
 		let noq = match backend {
-			QuicBackend::Noq => Some(crate::noq::NoqClient::new(&config)?),
+			QuicBackend::Noq => Some(crate::noq::Client::new(&config)?),
 			_ => None,
 		};
 
 		#[cfg(feature = "quinn")]
 		#[allow(unreachable_patterns)]
 		let quinn = match backend {
-			QuicBackend::Quinn => Some(crate::quinn::QuinnClient::new(&config)?),
+			QuicBackend::Quinn => Some(crate::quinn::Client::new(&config)?),
 			_ => None,
 		};
 
 		#[cfg(feature = "quiche")]
 		let quiche = match backend {
-			QuicBackend::Quiche => Some(crate::quiche::QuicheClient::new(&config)?),
+			QuicBackend::Quiche => Some(crate::quiche::Client::new(&config)?),
 			_ => None,
 		};
 
@@ -291,7 +323,8 @@ impl Client {
 		#[cfg(feature = "iroh")]
 		if url.scheme() == "iroh" {
 			let endpoint = self.iroh.as_ref().context("Iroh support is not enabled")?;
-			let session = crate::iroh::connect(endpoint, url, self.iroh_addrs.iter().copied()).await?;
+			let alpns = self.versions.alpns();
+			let session = crate::iroh::connect(endpoint, url, self.iroh_addrs.iter().copied(), &alpns).await?;
 			let session = self.moq.connect(session).await?;
 			return Ok(session);
 		}
@@ -311,7 +344,7 @@ impl Client {
 			#[cfg(feature = "websocket")]
 			{
 				let alpns = self.versions.alpns();
-				let ws_handle = crate::websocket::race_handle(&self.websocket, &self.tls, url, &alpns);
+				let ws_handle = crate::ws::race_handle(&self.websocket, &self.tls, url, &alpns);
 
 				return Ok(tokio::select! {
 					Ok(quic) = quic_handle => self.moq.connect(quic).await?,
@@ -342,7 +375,7 @@ impl Client {
 			#[cfg(feature = "websocket")]
 			{
 				let alpns = self.versions.alpns();
-				let ws_handle = crate::websocket::race_handle(&self.websocket, &self.tls, url, &alpns);
+				let ws_handle = crate::ws::race_handle(&self.websocket, &self.tls, url, &alpns);
 
 				return Ok(tokio::select! {
 					Ok(quic) = quic_handle => self.moq.connect(quic).await?,
@@ -372,7 +405,7 @@ impl Client {
 			#[cfg(feature = "websocket")]
 			{
 				let alpns = self.versions.alpns();
-				let ws_handle = crate::websocket::race_handle(&self.websocket, &self.tls, url, &alpns);
+				let ws_handle = crate::ws::race_handle(&self.websocket, &self.tls, url, &alpns);
 
 				return Ok(tokio::select! {
 					Ok(quic) = quic_handle => self.moq.connect(quic).await?,
diff --git a/rs/moq-native/src/iroh.rs b/rs/moq-native/src/iroh.rs
index 82846b596..82a241ac7 100644
--- a/rs/moq-native/src/iroh.rs
+++ b/rs/moq-native/src/iroh.rs
@@ -9,12 +9,13 @@ use web_transport_iroh::{
 // NOTE: web-transport-iroh should re-export proto like web-transport-quinn does.
 use web_transport_proto::{ConnectRequest, ConnectResponse};
 
-pub use iroh::Endpoint as IrohEndpoint;
+pub use iroh::Endpoint;
 
 #[derive(clap::Args, Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[serde(deny_unknown_fields, default)]
+#[group(id = "iroh")]
 #[non_exhaustive]
-pub struct IrohEndpointConfig {
+pub struct EndpointConfig {
 	/// Whether to enable iroh support.
 	#[arg(
 		id = "iroh-enabled",
@@ -55,8 +56,8 @@ pub struct IrohEndpointConfig {
 	pub disable_relay: Option<bool>,
 }
 
-impl IrohEndpointConfig {
-	pub async fn bind(self) -> anyhow::Result<Option<IrohEndpoint>> {
+impl EndpointConfig {
+	pub async fn bind(self) -> anyhow::Result<Option<Endpoint>> {
 		if !self.enabled.unwrap_or(false) {
 			return Ok(None);
 		}
@@ -66,15 +67,21 @@ impl IrohEndpointConfig {
 			secret
 		} else if let Some(path) = self.secret {
 			let path = PathBuf::from(path);
-			if !path.exists() {
-				// Generate a new random secret and write it to the file.
-				let secret = SecretKey::generate(&mut rand::rng());
-				tokio::fs::write(path, hex::encode(secret.to_bytes())).await?;
-				secret
-			} else {
-				// Otherwise, read the secret from a file.
-				let key_str = tokio::fs::read_to_string(&path).await?;
-				SecretKey::from_str(&key_str)?
+			// Generate a new random secret and attempt to write it atomically.
+			// If the file already exists (AlreadyExists), read the existing secret instead.
+			// This avoids a TOCTOU race between exists() and create_new().
+			let secret = SecretKey::generate(&mut rand::rng());
+			let data = hex::encode(secret.to_bytes());
+			match write_secret_file(&path, data.as_bytes()).await {
+				Ok(()) => secret,
+				Err(e)
+					if e.downcast_ref::<std::io::Error>()
+						.is_some_and(|io| io.kind() == std::io::ErrorKind::AlreadyExists) =>
+				{
+					let key_str = tokio::fs::read_to_string(&path).await?;
+					SecretKey::from_str(&key_str)?
+				}
+				Err(e) => return Err(e),
 			}
 		} else {
 			// Otherwise, generate a new random secret.
@@ -86,9 +93,9 @@ impl IrohEndpointConfig {
 		alpns.push(web_transport_iroh::ALPN_H3.as_bytes().to_vec());
 
 		let mut builder = if self.disable_relay.unwrap_or(false) {
-			IrohEndpoint::builder(iroh::endpoint::presets::N0DisableRelay)
+			Endpoint::builder(iroh::endpoint::presets::N0DisableRelay)
 		} else {
-			IrohEndpoint::builder(iroh::endpoint::presets::N0)
+			Endpoint::builder(iroh::endpoint::presets::N0)
 		}
 		.secret_key(secret_key)
 		.alpns(alpns);
@@ -106,17 +113,19 @@ impl IrohEndpointConfig {
 	}
 }
 
-pub enum IrohRequest {
+pub enum Request {
 	Quic {
 		request: web_transport_iroh::QuicRequest,
+		alpns: Vec<&'static str>,
 	},
 	WebTransport {
 		request: Box<web_transport_iroh::H3Request>,
+		alpns: Vec<&'static str>,
 	},
 }
 
-impl IrohRequest {
-	pub async fn accept(conn: iroh::endpoint::Incoming) -> anyhow::Result<Self> {
+impl Request {
+	pub async fn accept(conn: iroh::endpoint::Incoming, alpns: Vec<&'static str>) -> anyhow::Result<Self> {
 		let conn = conn.accept()?.await?;
 		let alpn = String::from_utf8(conn.alpn().to_vec()).context("failed to decode ALPN")?;
 		tracing::Span::current().record("id", conn.stable_id());
@@ -128,10 +137,12 @@ impl IrohRequest {
 					.context("failed to receive WebTransport request")?;
 				Ok(Self::WebTransport {
 					request: Box::new(request),
+					alpns,
 				})
 			}
-			alpn if moq_lite::ALPNS.contains(&alpn) => Ok(Self::Quic {
+			alpn if alpns.contains(&alpn) => Ok(Self::Quic {
 				request: web_transport_iroh::QuicRequest::accept(conn),
+				alpns,
 			}),
 			_ => Err(anyhow::anyhow!("unsupported ALPN: {alpn}")),
 		}
@@ -140,10 +151,10 @@ impl IrohRequest {
 	/// Accept the session.
 	pub async fn ok(self) -> Result<web_transport_iroh::Session, web_transport_iroh::ServerError> {
 		match self {
-			IrohRequest::Quic { request } => Ok(request.ok()),
-			IrohRequest::WebTransport { request } => {
+			Request::Quic { request, .. } => Ok(request.ok()),
+			Request::WebTransport { request, alpns } => {
 				let mut response = ConnectResponse::OK;
-				if let Some(protocol) = request.protocols.first() {
+				if let Some(protocol) = request.protocols.iter().find(|p| alpns.contains(&p.as_str())) {
 					response = response.with_protocol(protocol);
 				}
 				request.respond(response).await
@@ -154,26 +165,27 @@ impl IrohRequest {
 	/// Reject the session.
 	pub async fn close(self, status: http::StatusCode) -> Result<(), web_transport_iroh::ServerError> {
 		match self {
-			IrohRequest::Quic { request } => {
+			Request::Quic { request, .. } => {
 				request.close(status);
 				Ok(())
 			}
-			IrohRequest::WebTransport { request, .. } => request.reject(status).await,
+			Request::WebTransport { request, .. } => request.reject(status).await,
 		}
 	}
 
 	pub fn url(&self) -> Option<&Url> {
 		match self {
-			IrohRequest::Quic { .. } => None,
-			IrohRequest::WebTransport { request } => Some(&request.url),
+			Request::Quic { .. } => None,
+			Request::WebTransport { request, .. } => Some(&request.url),
 		}
 	}
 }
 
 pub(crate) async fn connect(
-	endpoint: &IrohEndpoint,
+	endpoint: &Endpoint,
 	url: Url,
 	addrs: impl IntoIterator<Item = std::net::SocketAddr>,
+	alpns: &[&str],
 ) -> anyhow::Result<web_transport_iroh::Session> {
 	let host = url.host().context("Invalid URL: missing host")?.to_string();
 	let endpoint_id: iroh::EndpointId = host.parse().context("Invalid URL: host is not an iroh endpoint id")?;
@@ -186,11 +198,9 @@ pub(crate) async fn connect(
 
 	// We need to use this API to provide multiple ALPNs.
 	// H3 is last because it requires WebTransport framing which not all H3 endpoints support.
-	let alpn = moq_lite::ALPNS[0].as_bytes();
-	let mut additional: Vec<Vec<u8>> = moq_lite::ALPNS[1..]
-		.iter()
-		.map(|alpn| alpn.as_bytes().to_vec())
-		.collect();
+	anyhow::ensure!(!alpns.is_empty(), "no ALPNs configured");
+	let alpn = alpns[0].as_bytes();
+	let mut additional: Vec<Vec<u8>> = alpns[1..].iter().map(|alpn| alpn.as_bytes().to_vec()).collect();
 	additional.push(b"h3".to_vec());
 	let opts = iroh::endpoint::ConnectOptions::new().with_additional_alpns(additional);
 
@@ -204,13 +214,13 @@ pub(crate) async fn connect(
 			let url = url_set_scheme(url, "https")?;
 
 			let mut request = ConnectRequest::new(url);
-			for alpn in moq_lite::ALPNS {
+			for alpn in alpns {
 				request = request.with_protocol(alpn.to_string());
 			}
 
 			web_transport_iroh::Session::connect_h3(conn, request).await?
 		}
-		alpn if moq_lite::ALPNS.contains(&alpn) => {
+		alpn if alpns.contains(&alpn) => {
 			let conn = connecting.await?;
 			web_transport_iroh::Session::raw(conn)
 		}
@@ -235,3 +245,21 @@ fn url_set_scheme(url: Url, scheme: &str) -> anyhow::Result<Url> {
 	.parse()?;
 	Ok(url)
 }
+
+/// Write secret key data to a file with owner-only permissions (0o600 on Unix).
+///
+/// Uses `create_new(true)` so the call fails with `AlreadyExists` if the file
+/// already exists, which callers can use to handle races atomically.
+async fn write_secret_file(path: &std::path::Path, data: &[u8]) -> anyhow::Result<()> {
+	use tokio::io::AsyncWriteExt;
+
+	let mut opts = tokio::fs::OpenOptions::new();
+	opts.write(true).create_new(true);
+
+	#[cfg(unix)]
+	opts.mode(0o600);
+
+	let mut file = opts.open(path).await?;
+	file.write_all(data).await.context("failed to write secret key")?;
+	Ok(())
+}
diff --git a/rs/moq-native/src/lib.rs b/rs/moq-native/src/lib.rs
index 57df6c129..b4387e45a 100644
--- a/rs/moq-native/src/lib.rs
+++ b/rs/moq-native/src/lib.rs
@@ -14,40 +14,39 @@ pub(crate) const DEFAULT_MAX_STREAMS: u64 = 1024;
 mod client;
 mod crypto;
 mod log;
+mod server;
+
+#[cfg(any(feature = "noq", feature = "quinn"))]
+mod tls;
+
 #[cfg(feature = "noq")]
 mod noq;
+#[cfg(feature = "quiche")]
+mod quiche;
 #[cfg(feature = "quinn")]
 mod quinn;
-mod server;
-#[cfg(any(feature = "noq", feature = "quinn"))]
-mod tls;
-#[cfg(feature = "websocket")]
-mod websocket;
 
-pub use client::*;
-pub use log::*;
-pub use server::*;
 #[cfg(feature = "websocket")]
-pub use websocket::*;
+pub mod ws;
+
+#[cfg(feature = "iroh")]
+pub mod iroh;
+
+// Re-export core types at root
+pub use client::{Client, ClientConfig, ClientTls};
+pub use log::Log;
+pub use server::{Request, Server, ServerConfig, ServerId, ServerTlsConfig, ServerTlsInfo};
 
-// Re-export these crates.
+// Re-export dependency crates
 pub use moq_lite;
 pub use rustls;
 
 #[cfg(feature = "noq")]
 pub use web_transport_noq;
-#[cfg(feature = "quinn")]
-pub use web_transport_quinn;
-
-#[cfg(feature = "quiche")]
-mod quiche;
 #[cfg(feature = "quiche")]
 pub use web_transport_quiche;
-
-#[cfg(feature = "iroh")]
-mod iroh;
-#[cfg(feature = "iroh")]
-pub use iroh::*;
+#[cfg(feature = "quinn")]
+pub use web_transport_quinn;
 
 /// The QUIC backend to use for connections.
 #[derive(Clone, Debug, clap::ValueEnum, serde::Serialize, serde::Deserialize)]
diff --git a/rs/moq-native/src/log.rs b/rs/moq-native/src/log.rs
index c5e9db02e..a2164e951 100644
--- a/rs/moq-native/src/log.rs
+++ b/rs/moq-native/src/log.rs
@@ -34,7 +34,7 @@ impl Log {
 		LevelFilter::from_level(self.level)
 	}
 
-	pub fn init(&self) {
+	pub fn init(&self) -> anyhow::Result<()> {
 		let filter = EnvFilter::builder()
 			.with_default_directive(self.level().into()) // Default to our -q/-v args
 			.from_env_lossy() // Allow overriding with RUST_LOG
@@ -57,17 +57,19 @@ impl Log {
 			tracing_subscriber::registry()
 				.with(fmt_layer)
 				.with(console_layer)
-				.init();
+				.try_init()?;
 		}
 
 		#[cfg(not(feature = "tokio-console"))]
 		{
-			tracing_subscriber::registry().with(fmt_layer).init();
+			tracing_subscriber::registry().with(fmt_layer).try_init()?;
 		}
 
 		// Start deadlock detection thread (only in debug builds)
 		#[cfg(debug_assertions)]
 		std::thread::spawn(Self::deadlock_detector);
+
+		Ok(())
 	}
 
 	#[cfg(debug_assertions)]
diff --git a/rs/moq-native/src/noq.rs b/rs/moq-native/src/noq.rs
index 865d0b192..51a23ac4d 100644
--- a/rs/moq-native/src/noq.rs
+++ b/rs/moq-native/src/noq.rs
@@ -12,13 +12,13 @@ use web_transport_noq::noq;
 // ── Client ──────────────────────────────────────────────────────────
 
 #[derive(Clone)]
-pub(crate) struct NoqClient {
+pub(crate) struct Client {
 	pub quic: noq::Endpoint,
 	pub transport: Arc<noq::TransportConfig>,
 	pub versions: moq_lite::Versions,
 }
 
-impl NoqClient {
+impl Client {
 	pub fn new(config: &ClientConfig) -> anyhow::Result<Self> {
 		let socket = std::net::UdpSocket::bind(config.bind).context("failed to bind UDP socket")?;
 
@@ -140,12 +140,12 @@ impl NoqClient {
 
 // ── Server ──────────────────────────────────────────────────────────
 
-pub(crate) struct NoqServer {
+pub(crate) struct Server {
 	pub quic: noq::Endpoint,
 	pub certs: Arc<ServeCerts>,
 }
 
-impl NoqServer {
+impl Server {
 	pub fn new(config: ServerConfig) -> anyhow::Result<Self> {
 		let mut transport = noq::TransportConfig::default();
 		transport.max_idle_timeout(Some(Duration::from_secs(10).try_into().unwrap()));
@@ -238,10 +238,10 @@ impl NoqServer {
 	}
 }
 
-// ── NoqRequest ──────────────────────────────────────────────────────
+// ── Request ──────────────────────────────────────────────────────
 
 /// A raw QUIC connection request without WebTransport framing (noq backend).
-pub(crate) enum NoqRequest {
+pub(crate) enum Request {
 	Raw {
 		request: web_transport_noq::proto::ConnectRequest,
 		response: web_transport_noq::proto::ConnectResponse,
@@ -253,7 +253,7 @@ pub(crate) enum NoqRequest {
 	},
 }
 
-impl NoqRequest {
+impl Request {
 	pub async fn accept(conn: noq::Incoming, alpns: Vec<&'static str>) -> anyhow::Result<Self> {
 		let mut conn = conn.accept()?;
 
@@ -309,12 +309,12 @@ impl NoqRequest {
 	/// Accept the session, returning a 200 OK if using WebTransport.
 	pub async fn ok(self) -> Result<web_transport_noq::Session, web_transport_noq::ServerError> {
 		match self {
-			NoqRequest::Raw {
+			Request::Raw {
 				connection,
 				request,
 				response,
 			} => Ok(web_transport_noq::Session::raw(connection, request, response)),
-			NoqRequest::WebTransport { request, alpns } => {
+			Request::WebTransport { request, alpns } => {
 				let mut response = web_transport_noq::proto::ConnectResponse::OK;
 				if let Some(protocol) = request.protocols.iter().find(|p| alpns.contains(&p.as_str())) {
 					response = response.with_protocol(protocol);
@@ -327,8 +327,8 @@ impl NoqRequest {
 	/// Returns the URL provided by the client.
 	pub fn url(&self) -> Option<&Url> {
 		match self {
-			NoqRequest::Raw { .. } => None,
-			NoqRequest::WebTransport { request, .. } => Some(&request.url),
+			Request::Raw { .. } => None,
+			Request::WebTransport { request, .. } => Some(&request.url),
 		}
 	}
 
@@ -338,11 +338,11 @@ impl NoqRequest {
 		status: web_transport_noq::http::StatusCode,
 	) -> Result<(), web_transport_noq::ServerError> {
 		match self {
-			NoqRequest::Raw { connection, .. } => {
+			Request::Raw { connection, .. } => {
 				connection.close(status.as_u16().into(), status.as_str().as_bytes());
 				Ok(())
 			}
-			NoqRequest::WebTransport { request, alpns: _, .. } => request.reject(status).await,
+			Request::WebTransport { request, alpns: _, .. } => request.reject(status).await,
 		}
 	}
 }
diff --git a/rs/moq-native/src/quiche.rs b/rs/moq-native/src/quiche.rs
index 684702c43..5e8237e7d 100644
--- a/rs/moq-native/src/quiche.rs
+++ b/rs/moq-native/src/quiche.rs
@@ -14,14 +14,14 @@ use web_transport_quiche::proto::ConnectRequest;
 // ── Client ──────────────────────────────────────────────────────────
 
 #[derive(Clone)]
-pub(crate) struct QuicheClient {
+pub(crate) struct Client {
 	pub bind: net::SocketAddr,
 	pub disable_verify: bool,
 	pub max_streams: u64,
 	pub versions: moq_lite::Versions,
 }
 
-impl QuicheClient {
+impl Client {
 	pub fn new(config: &ClientConfig) -> anyhow::Result<Self> {
 		if !config.tls.root.is_empty() {
 			tracing::warn!("--tls-root is not supported with the quiche backend; system roots will be used");
@@ -103,12 +103,12 @@ impl QuicheClient {
 
 // ── Server ──────────────────────────────────────────────────────────
 
-pub(crate) struct QuicheServer {
+pub(crate) struct Server {
 	pub server: web_transport_quiche::ez::Server,
 	pub fingerprints: Arc<RwLock<ServerTlsInfo>>,
 }
 
-impl QuicheServer {
+impl Server {
 	pub fn new(config: ServerConfig) -> anyhow::Result<Self> {
 		if config.quic_lb_id.is_some() {
 			tracing::warn!("QUIC-LB is not supported with the quiche backend; ignoring server ID");
@@ -247,7 +247,7 @@ fn generate_quiche_cert(
 // ── QuicheQuicRequest ───────────────────────────────────────────────
 
 /// A raw QUIC connection request via the quiche backend (not using HTTP/3).
-pub(crate) enum QuicheRequest {
+pub(crate) enum Request {
 	Raw {
 		connection: web_transport_quiche::ez::Connection,
 		request: web_transport_quiche::proto::ConnectRequest,
@@ -259,7 +259,7 @@ pub(crate) enum QuicheRequest {
 	},
 }
 
-impl QuicheRequest {
+impl Request {
 	pub async fn accept(
 		incoming: web_transport_quiche::ez::Incoming,
 		alpns: Vec<&'static str>,
@@ -295,12 +295,12 @@ impl QuicheRequest {
 	/// Accept the session, wrapping as a raw WebTransport-compatible connection.
 	pub async fn ok(self) -> Result<web_transport_quiche::Connection, web_transport_quiche::ServerError> {
 		match self {
-			QuicheRequest::Raw {
+			Request::Raw {
 				connection,
 				request,
 				response,
 			} => Ok(web_transport_quiche::Connection::raw(connection, request, response)),
-			QuicheRequest::WebTransport { request, alpns } => {
+			Request::WebTransport { request, alpns } => {
 				let mut response = web_transport_quiche::proto::ConnectResponse::OK;
 				// Pick the first sub-protocol that we actually support.
 				// This is the WebTransport equivalent of ALPN negotiation.
@@ -315,8 +315,8 @@ impl QuicheRequest {
 	/// Returns the URL for this connection.
 	pub fn url(&self) -> Option<&Url> {
 		match self {
-			QuicheRequest::Raw { .. } => None,
-			QuicheRequest::WebTransport { request, .. } => Some(&request.url),
+			Request::Raw { .. } => None,
+			Request::WebTransport { request, .. } => Some(&request.url),
 		}
 	}
 
@@ -326,11 +326,11 @@ impl QuicheRequest {
 		status: web_transport_quiche::http::StatusCode,
 	) -> Result<(), web_transport_quiche::ServerError> {
 		match self {
-			QuicheRequest::Raw { connection, .. } => {
+			Request::Raw { connection, .. } => {
 				let _: () = connection.close(status.as_u16().into(), status.as_str());
 				Ok(())
 			}
-			QuicheRequest::WebTransport { request, alpns: _, .. } => request.reject(status).await,
+			Request::WebTransport { request, alpns: _, .. } => request.reject(status).await,
 		}
 	}
 }
diff --git a/rs/moq-native/src/quinn.rs b/rs/moq-native/src/quinn.rs
index 3ac07bd61..04d860672 100644
--- a/rs/moq-native/src/quinn.rs
+++ b/rs/moq-native/src/quinn.rs
@@ -10,13 +10,13 @@ use url::Url;
 // ── Client ──────────────────────────────────────────────────────────
 
 #[derive(Clone)]
-pub(crate) struct QuinnClient {
+pub(crate) struct Client {
 	pub quic: quinn::Endpoint,
 	pub transport: Arc<quinn::TransportConfig>,
 	pub versions: moq_lite::Versions,
 }
 
-impl QuinnClient {
+impl Client {
 	pub fn new(config: &ClientConfig) -> anyhow::Result<Self> {
 		let socket = std::net::UdpSocket::bind(config.bind).context("failed to bind UDP socket")?;
 
@@ -139,12 +139,12 @@ impl QuinnClient {
 
 // ── Server ──────────────────────────────────────────────────────────
 
-pub(crate) struct QuinnServer {
+pub(crate) struct Server {
 	pub quic: quinn::Endpoint,
 	pub certs: Arc<ServeCerts>,
 }
 
-impl QuinnServer {
+impl Server {
 	pub fn new(config: ServerConfig) -> anyhow::Result<Self> {
 		// Enable BBR congestion control
 		// TODO Validate the BBR implementation before enabling it
@@ -239,10 +239,10 @@ impl QuinnServer {
 	}
 }
 
-// ── QuinnRequest ────────────────────────────────────────────────────
+// ── Request ────────────────────────────────────────────────────
 
 /// A raw QUIC connection request without WebTransport framing (quinn backend).
-pub(crate) enum QuinnRequest {
+pub(crate) enum Request {
 	Raw {
 		request: web_transport_quinn::proto::ConnectRequest,
 		response: web_transport_quinn::proto::ConnectResponse,
@@ -254,7 +254,7 @@ pub(crate) enum QuinnRequest {
 	},
 }
 
-impl QuinnRequest {
+impl Request {
 	pub async fn accept(conn: quinn::Incoming, alpns: Vec<&'static str>) -> anyhow::Result<Self> {
 		let mut conn = conn.accept()?;
 
@@ -310,12 +310,12 @@ impl QuinnRequest {
 	/// Accept the session, returning a 200 OK if using WebTransport.
 	pub async fn ok(self) -> Result<web_transport_quinn::Session, web_transport_quinn::ServerError> {
 		match self {
-			QuinnRequest::Raw {
+			Request::Raw {
 				connection,
 				request,
 				response,
 			} => Ok(web_transport_quinn::Session::raw(connection, request, response)),
-			QuinnRequest::WebTransport { request, alpns } => {
+			Request::WebTransport { request, alpns } => {
 				let mut response = web_transport_quinn::proto::ConnectResponse::OK;
 				// Pick the first sub-protocol that we actually support.
 				// This is the WebTransport equivalent of ALPN negotiation.
@@ -333,8 +333,8 @@ impl QuinnRequest {
 	/// Returns the URL provided by the client.
 	pub fn url(&self) -> Option<&Url> {
 		match self {
-			QuinnRequest::Raw { .. } => None,
-			QuinnRequest::WebTransport { request, .. } => Some(&request.url),
+			Request::Raw { .. } => None,
+			Request::WebTransport { request, .. } => Some(&request.url),
 		}
 	}
 
@@ -344,11 +344,11 @@ impl QuinnRequest {
 		status: web_transport_quinn::http::StatusCode,
 	) -> Result<(), web_transport_quinn::ServerError> {
 		match self {
-			QuinnRequest::Raw { connection, .. } => {
+			Request::Raw { connection, .. } => {
 				connection.close(status.as_u16().into(), status.as_str().as_bytes());
 				Ok(())
 			}
-			QuinnRequest::WebTransport { request, alpns: _, .. } => request.reject(status).await,
+			Request::WebTransport { request, alpns: _, .. } => request.reject(status).await,
 		}
 	}
 }
diff --git a/rs/moq-native/src/server.rs b/rs/moq-native/src/server.rs
index 591f60732..3e3f1618b 100644
--- a/rs/moq-native/src/server.rs
+++ b/rs/moq-native/src/server.rs
@@ -21,6 +21,7 @@ use futures::stream::StreamExt;
 /// Alternatively, you can generate a self-signed certificate given a list of hostnames.
 #[derive(clap::Args, Clone, Default, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(deny_unknown_fields)]
+#[group(id = "server-tls")]
 #[non_exhaustive]
 pub struct ServerTlsConfig {
 	/// Load the given certificate from disk.
@@ -48,6 +49,7 @@ pub struct ServerTlsConfig {
 /// Configuration for the MoQ server.
 #[derive(clap::Args, Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[serde(deny_unknown_fields, default)]
+#[group(id = "server")]
 #[non_exhaustive]
 pub struct ServerConfig {
 	/// Listen for UDP packets on the given address.
@@ -116,6 +118,51 @@ impl ServerConfig {
 			moq_lite::Versions::from(self.version.clone())
 		}
 	}
+
+	pub fn with_bind(mut self, bind: net::SocketAddr) -> Self {
+		self.bind = Some(bind);
+		self
+	}
+
+	pub fn with_backend(mut self, backend: QuicBackend) -> Self {
+		self.backend = Some(backend);
+		self
+	}
+
+	pub fn with_max_streams(mut self, max_streams: u64) -> Self {
+		self.max_streams = Some(max_streams);
+		self
+	}
+
+	pub fn with_version(mut self, version: moq_lite::Version) -> Self {
+		self.version.push(version);
+		self
+	}
+
+	pub fn with_tls_cert(mut self, cert: PathBuf) -> Self {
+		self.tls.cert.push(cert);
+		self
+	}
+
+	pub fn with_tls_key(mut self, key: PathBuf) -> Self {
+		self.tls.key.push(key);
+		self
+	}
+
+	pub fn with_tls_generate(mut self, hostname: impl Into<String>) -> Self {
+		self.tls.generate.push(hostname.into());
+		self
+	}
+
+	pub fn with_quic_lb_id(mut self, id: ServerId) -> Self {
+		self.quic_lb_id = Some(id);
+		self
+	}
+
+	pub fn with_quic_lb_nonce(mut self, nonce: usize) -> Self {
+		self.quic_lb_nonce = Some(nonce);
+		self
+	}
 }
 
 /// Server for accepting MoQ connections over QUIC.
@@ -128,13 +175,13 @@ pub struct Server {
 	#[cfg(feature = "iroh")]
 	iroh: Option<iroh::Endpoint>,
 	#[cfg(feature = "noq")]
-	noq: Option<crate::noq::NoqServer>,
+	noq: Option<crate::noq::Server>,
 	#[cfg(feature = "quinn")]
-	quinn: Option<crate::quinn::QuinnServer>,
+	quinn: Option<crate::quinn::Server>,
 	#[cfg(feature = "quiche")]
-	quiche: Option<crate::quiche::QuicheServer>,
+	quiche: Option<crate::quiche::Server>,
 	#[cfg(feature = "websocket")]
-	websocket: Option<crate::websocket::WebSocketListener>,
+	websocket: Option<crate::ws::Listener>,
 }
 
 impl Server {
@@ -161,20 +208,20 @@ impl Server {
 		#[cfg(feature = "noq")]
 		#[allow(unreachable_patterns)]
 		let noq = match backend {
-			QuicBackend::Noq => Some(crate::noq::NoqServer::new(config.clone())?),
+			QuicBackend::Noq => Some(crate::noq::Server::new(config.clone())?),
 			_ => None,
 		};
 
 		#[cfg(feature = "quinn")]
 		#[allow(unreachable_patterns)]
 		let quinn = match backend {
-			QuicBackend::Quinn => Some(crate::quinn::QuinnServer::new(config.clone())?),
+			QuicBackend::Quinn => Some(crate::quinn::Server::new(config.clone())?),
 			_ => None,
 		};
 
 		#[cfg(feature = "quiche")]
 		let quiche = match backend {
-			QuicBackend::Quiche => Some(crate::quiche::QuicheServer::new(config)?),
+			QuicBackend::Quiche => Some(crate::quiche::Server::new(config)?),
 			_ => None,
 		};
 
@@ -201,7 +248,7 @@ impl Server {
 	/// For applications that need WebSocket on the same HTTP port (e.g. moq-relay),
 	/// use `qmux::Session::accept()` with your own HTTP framework instead.
 	#[cfg(feature = "websocket")]
-	pub fn with_websocket(mut self, websocket: Option<crate::websocket::WebSocketListener>) -> Self {
+	pub fn with_websocket(mut self, websocket: Option<crate::ws::Listener>) -> Self {
 		self.websocket = websocket;
 		self
 	}
@@ -320,7 +367,7 @@ impl Server {
 					{
 						let alpns = versions.alpns();
 						self.accept.push(async move {
-							let noq = super::noq::NoqRequest::accept(_conn, alpns).await?;
+							let noq = super::noq::Request::accept(_conn, alpns).await?;
 							Ok(Request {
 								server,
 								kind: RequestKind::Noq(noq),
@@ -333,7 +380,7 @@ impl Server {
 					{
 						let alpns = versions.alpns();
 						self.accept.push(async move {
-							let quinn = super::quinn::QuinnRequest::accept(_conn, alpns).await?;
+							let quinn = super::quinn::Request::accept(_conn, alpns).await?;
 							Ok(Request {
 								server,
 								kind: RequestKind::Quinn(Box::new(quinn)),
@@ -346,7 +393,7 @@ impl Server {
 					{
 						let alpns = versions.alpns();
 						self.accept.push(async move {
-							let quiche = super::quiche::QuicheRequest::accept(_conn, alpns).await?;
+							let quiche = super::quiche::Request::accept(_conn, alpns).await?;
 							Ok(Request {
 								server,
 								kind: RequestKind::Quiche(quiche),
@@ -356,13 +403,16 @@ impl Server {
 				}
 				Some(_conn) = iroh_accept => {
 					#[cfg(feature = "iroh")]
-					self.accept.push(async move {
-						let iroh = super::iroh::IrohRequest::accept(_conn).await?;
-						Ok(Request {
-							server,
-							kind: RequestKind::Iroh(iroh),
-						})
-					}.boxed());
+					{
+						let alpns = versions.alpns();
+						self.accept.push(async move {
+							let iroh = super::iroh::Request::accept(_conn, alpns).await?;
+							Ok(Request {
+								server,
+								kind: RequestKind::Iroh(iroh),
+							})
+						}.boxed());
+					}
 				}
 				Some(_res) = ws_accept => {
 					#[cfg(feature = "websocket")]
@@ -448,13 +498,13 @@ impl Server {
 /// An incoming connection that can be accepted or rejected.
 pub(crate) enum RequestKind {
 	#[cfg(feature = "noq")]
-	Noq(crate::noq::NoqRequest),
+	Noq(crate::noq::Request),
 	#[cfg(feature = "quinn")]
-	Quinn(Box<crate::quinn::QuinnRequest>),
+	Quinn(Box<crate::quinn::Request>),
 	#[cfg(feature = "quiche")]
-	Quiche(crate::quiche::QuicheRequest),
+	Quiche(crate::quiche::Request),
 	#[cfg(feature = "iroh")]
-	Iroh(crate::iroh::IrohRequest),
+	Iroh(crate::iroh::Request),
 	#[cfg(feature = "websocket")]
 	WebSocket(qmux::Session),
 }
diff --git a/rs/moq-native/src/websocket.rs b/rs/moq-native/src/ws.rs
similarity index 96%
rename from rs/moq-native/src/websocket.rs
rename to rs/moq-native/src/ws.rs
index e1a0446f0..114ebe1d1 100644
--- a/rs/moq-native/src/websocket.rs
+++ b/rs/moq-native/src/ws.rs
@@ -11,8 +11,9 @@ static WEBSOCKET_WON: LazyLock<Mutex<HashSet<(String, u16)>>> = LazyLock::new(||
 /// WebSocket configuration for the client.
 #[derive(Clone, Debug, clap::Args, serde::Serialize, serde::Deserialize)]
 #[serde(default, deny_unknown_fields)]
+#[group(id = "ws-client")]
 #[non_exhaustive]
-pub struct ClientWebSocket {
+pub struct ClientConfig {
 	/// Whether to enable WebSocket support.
 	#[arg(
 		id = "websocket-enabled",
@@ -36,7 +37,7 @@ pub struct ClientWebSocket {
 	pub delay: Option<time::Duration>,
 }
 
-impl Default for ClientWebSocket {
+impl Default for ClientConfig {
 	fn default() -> Self {
 		Self {
 			enabled: true,
@@ -46,7 +47,7 @@ impl Default for ClientWebSocket {
 }
 
 pub(crate) async fn race_handle(
-	config: &ClientWebSocket,
+	config: &ClientConfig,
 	tls: &rustls::ClientConfig,
 	url: Url,
 	alpns: &[&str],
@@ -70,7 +71,7 @@ pub(crate) async fn race_handle(
 }
 
 pub(crate) async fn connect(
-	config: &ClientWebSocket,
+	config: &ClientConfig,
 	tls: &rustls::ClientConfig,
 	mut url: Url,
 	alpns: &[&str],
@@ -138,12 +139,12 @@ pub(crate) async fn connect(
 ///
 /// Use with [`crate::Server::with_websocket`] to accept WebSocket connections
 /// alongside QUIC connections on a separate port.
-pub struct WebSocketListener {
+pub struct Listener {
 	listener: tokio::net::TcpListener,
 	server: qmux::Server,
 }
 
-impl WebSocketListener {
+impl Listener {
 	pub async fn bind(addr: net::SocketAddr) -> anyhow::Result<Self> {
 		Self::bind_with_alpns(addr, moq_lite::ALPNS).await
 	}
diff --git a/rs/moq-native/tests/backend.rs b/rs/moq-native/tests/backend.rs
index 39739f469..05adae762 100644
--- a/rs/moq-native/tests/backend.rs
+++ b/rs/moq-native/tests/backend.rs
@@ -15,7 +15,7 @@ const TIMEOUT: Duration = Duration::from_secs(10);
 async fn backend_test(scheme: &str, backend: moq_native::QuicBackend) {
 	// ── publisher (server) ──────────────────────────────────────────
 	let pub_origin = Origin::produce();
-	let mut broadcast = pub_origin.create_broadcast("test").expect("failed to create broadcast");
+	let broadcast = pub_origin.create_broadcast("test").expect("failed to create broadcast");
 	let mut track = broadcast
 		.create_track(Track::new("video"))
 		.expect("failed to create track");
@@ -67,16 +67,15 @@ async fn backend_test(scheme: &str, backend: moq_native::QuicBackend) {
 		.expect("origin closed");
 
 	assert_eq!(path.as_str(), "test");
-	let bc = bc.expect("expected announce, got unannounce");
 
-	let mut track_sub = bc
-		.subscribe_track(&Track::new("video"))
+	let mut subscriber = bc
+		.subscribe_track(&Track::new("video"), Default::default())
 		.expect("subscribe_track failed");
 
-	let mut group_sub = tokio::time::timeout(TIMEOUT, track_sub.next_group())
+	let mut group_sub = tokio::time::timeout(TIMEOUT, subscriber.recv_group())
 		.await
-		.expect("next_group timed out")
-		.expect("next_group failed")
+		.expect("recv_group timed out")
+		.expect("recv_group failed")
 		.expect("track closed prematurely");
 
 	let frame = tokio::time::timeout(TIMEOUT, group_sub.read_frame())
@@ -133,11 +132,11 @@ async fn quiche_webtransport() {
 #[tracing_test::traced_test]
 #[tokio::test]
 async fn iroh_connect() {
-	use moq_native::IrohEndpointConfig;
+	use moq_native::iroh::EndpointConfig;
 
 	// ── publisher (server) ──────────────────────────────────────────
 	let pub_origin = Origin::produce();
-	let mut broadcast = pub_origin.create_broadcast("test").expect("failed to create broadcast");
+	let broadcast = pub_origin.create_broadcast("test").expect("failed to create broadcast");
 	let mut track = broadcast
 		.create_track(Track::new("video"))
 		.expect("failed to create track");
@@ -147,7 +146,7 @@ async fn iroh_connect() {
 	group.finish().expect("failed to finish group");
 
 	// Create server iroh endpoint
-	let mut server_iroh_config = IrohEndpointConfig::default();
+	let mut server_iroh_config = EndpointConfig::default();
 	server_iroh_config.enabled = Some(true);
 	let server_endpoint = server_iroh_config
 		.bind()
@@ -176,7 +175,7 @@ async fn iroh_connect() {
 	let mut announcements = sub_origin.consume();
 
 	// Create client iroh endpoint
-	let mut client_iroh_config = IrohEndpointConfig::default();
+	let mut client_iroh_config = EndpointConfig::default();
 	client_iroh_config.enabled = Some(true);
 	let client_endpoint = client_iroh_config
 		.bind()
@@ -219,16 +218,15 @@ async fn iroh_connect() {
 		.expect("origin closed");
 
 	assert_eq!(path.as_str(), "test");
-	let bc = bc.expect("expected announce, got unannounce");
 
-	let mut track_sub = bc
-		.subscribe_track(&Track::new("video"))
+	let mut subscriber = bc
+		.subscribe_track(&Track::new("video"), Default::default())
 		.expect("subscribe_track failed");
 
-	let mut group_sub = tokio::time::timeout(TIMEOUT, track_sub.next_group())
+	let mut group_sub = tokio::time::timeout(TIMEOUT, subscriber.recv_group())
 		.await
-		.expect("next_group timed out")
-		.expect("next_group failed")
+		.expect("recv_group timed out")
+		.expect("recv_group failed")
 		.expect("track closed prematurely");
 
 	let frame = tokio::time::timeout(TIMEOUT, group_sub.read_frame())
diff --git a/rs/moq-native/tests/broadcast.rs b/rs/moq-native/tests/broadcast.rs
index c1ec6d93e..f1de2ad28 100644
--- a/rs/moq-native/tests/broadcast.rs
+++ b/rs/moq-native/tests/broadcast.rs
@@ -24,7 +24,7 @@ async fn broadcast_test(scheme: &str, client_version: Option<&str>, server_versi
 
 	// ── publisher (server) ──────────────────────────────────────────
 	let pub_origin = Origin::produce();
-	let mut broadcast = pub_origin.create_broadcast("test").expect("failed to create broadcast");
+	let broadcast = pub_origin.create_broadcast("test").expect("failed to create broadcast");
 	let mut track = broadcast
 		.create_track(Track::new("video"))
 		.expect("failed to create track");
@@ -84,18 +84,17 @@ async fn broadcast_test(scheme: &str, client_version: Option<&str>, server_versi
 		.expect("origin closed");
 
 	assert_eq!(path.as_str(), "test");
-	let bc = bc.expect("expected announce, got unannounce");
 
 	// Subscribe to the track.
-	let mut track_sub = bc
-		.subscribe_track(&Track::new("video"))
+	let mut subscriber = bc
+		.subscribe_track(&Track::new("video"), Default::default())
 		.expect("subscribe_track failed");
 
 	// Read one group.
-	let mut group_sub = tokio::time::timeout(TIMEOUT, track_sub.next_group())
+	let mut group_sub = tokio::time::timeout(TIMEOUT, subscriber.recv_group())
 		.await
-		.expect("next_group timed out")
-		.expect("next_group failed")
+		.expect("recv_group timed out")
+		.expect("recv_group failed")
 		.expect("track closed prematurely");
 
 	// Read one frame and verify the payload.
@@ -362,7 +361,7 @@ async fn broadcast_websocket() {
 
 	// ── publisher (server) ──────────────────────────────────────────
 	let pub_origin = Origin::produce();
-	let mut broadcast = pub_origin.create_broadcast("test").expect("failed to create broadcast");
+	let broadcast = pub_origin.create_broadcast("test").expect("failed to create broadcast");
 	let mut track = broadcast
 		.create_track(Track::new("video"))
 		.expect("failed to create track");
@@ -376,7 +375,7 @@ async fn broadcast_websocket() {
 	server_config.bind = Some("[::]:0".parse().unwrap());
 	server_config.tls.generate = vec!["localhost".into()];
 
-	let ws_listener = moq_native::WebSocketListener::bind("[::]:0".parse().unwrap())
+	let ws_listener = moq_native::ws::Listener::bind("[::]:0".parse().unwrap())
 		.await
 		.expect("failed to bind WebSocket listener");
 	let ws_addr = ws_listener.local_addr().expect("failed to get ws addr");
@@ -424,18 +423,17 @@ async fn broadcast_websocket() {
 		.expect("origin closed");
 
 	assert_eq!(path.as_str(), "test");
-	let bc = bc.expect("expected announce, got unannounce");
 
 	// Subscribe to the track.
-	let mut track_sub = bc
-		.subscribe_track(&Track::new("video"))
+	let mut subscriber = bc
+		.subscribe_track(&Track::new("video"), Default::default())
 		.expect("subscribe_track failed");
 
 	// Read one group.
-	let mut group_sub = tokio::time::timeout(TIMEOUT, track_sub.next_group())
+	let mut group_sub = tokio::time::timeout(TIMEOUT, subscriber.recv_group())
 		.await
-		.expect("next_group timed out")
-		.expect("next_group failed")
+		.expect("recv_group timed out")
+		.expect("recv_group failed")
 		.expect("track closed prematurely");
 
 	// Read one frame and verify the payload.
@@ -466,7 +464,7 @@ async fn broadcast_websocket_fallback() {
 
 	// ── publisher (server) ──────────────────────────────────────────
 	let pub_origin = Origin::produce();
-	let mut broadcast = pub_origin.create_broadcast("test").expect("failed to create broadcast");
+	let broadcast = pub_origin.create_broadcast("test").expect("failed to create broadcast");
 	let mut track = broadcast
 		.create_track(Track::new("video"))
 		.expect("failed to create track");
@@ -480,7 +478,7 @@ async fn broadcast_websocket_fallback() {
 	server_config.bind = Some("[::]:0".parse().unwrap());
 	server_config.tls.generate = vec!["localhost".into()];
 
-	let ws_listener = moq_native::WebSocketListener::bind("[::]:0".parse().unwrap())
+	let ws_listener = moq_native::ws::Listener::bind("[::]:0".parse().unwrap())
 		.await
 		.expect("failed to bind WebSocket listener");
 	let ws_addr = ws_listener.local_addr().expect("failed to get ws addr");
@@ -531,17 +529,16 @@ async fn broadcast_websocket_fallback() {
 		.expect("origin closed");
 
 	assert_eq!(path.as_str(), "test");
-	let bc = bc.expect("expected announce, got unannounce");
 
 	// Subscribe to the track.
-	let mut track_sub = bc
-		.subscribe_track(&Track::new("video"))
+	let mut subscriber = bc
+		.subscribe_track(&Track::new("video"), Default::default())
 		.expect("subscribe_track failed");
 
-	let mut group_sub = tokio::time::timeout(TIMEOUT, track_sub.next_group())
+	let mut group_sub = tokio::time::timeout(TIMEOUT, subscriber.recv_group())
 		.await
-		.expect("next_group timed out")
-		.expect("next_group failed")
+		.expect("recv_group timed out")
+		.expect("recv_group failed")
 		.expect("track closed prematurely");
 
 	let frame = tokio::time::timeout(TIMEOUT, group_sub.read_frame())
diff --git a/rs/moq-relay/Cargo.toml b/rs/moq-relay/Cargo.toml
index 34f2643c7..e9f8aa95f 100644
--- a/rs/moq-relay/Cargo.toml
+++ b/rs/moq-relay/Cargo.toml
@@ -49,7 +49,7 @@ rustls = { version = "0.23", features = [
     "aws-lc-rs",
 ], default-features = false }
 serde = { version = "1", features = ["derive"] }
-serde_with = { version = "3", features = ["json", "base64"] }
+serde_with = "3"
 thiserror = "2"
 tikv-jemalloc-ctl = { version = "0.6", optional = true }
 tikv-jemallocator = { version = "0.6", features = ["profiling", "unprefixed_malloc_on_supported_platforms"], optional = true }
diff --git a/rs/moq-relay/src/auth.rs b/rs/moq-relay/src/auth.rs
index 134068f99..26e766d54 100644
--- a/rs/moq-relay/src/auth.rs
+++ b/rs/moq-relay/src/auth.rs
@@ -10,18 +10,17 @@ use std::sync::Arc;
 
 /// Parameters extracted from an incoming connection URL for authentication.
 #[derive(Default, Debug)]
-pub struct AuthParams {
+pub(crate) struct AuthParams {
 	/// The URL path identifying the broadcast root.
 	pub path: String,
 	/// A JWT token, if provided via the `jwt` query parameter.
 	pub jwt: Option<String>,
-	/// A cluster registration identifier, if provided via the `register` query parameter.
-	pub register: Option<String>,
 }
 
 impl AuthParams {
-	/// Creates params with just a path and no token or registration.
-	pub fn new(path: impl Into<String>) -> Self {
+	/// Creates params with just a path and no token.
+	#[cfg(test)]
+	fn new(path: impl Into<String>) -> Self {
 		Self {
 			path: path.into(),
 			..Default::default()
@@ -32,20 +31,17 @@ impl AuthParams {
 	pub fn from_url(url: &url::Url) -> Self {
 		let path = url.path().to_string();
 		let mut jwt = None;
-		let mut register = None;
 
 		for (k, v) in url.query_pairs() {
 			if v.is_empty() {
 				continue;
 			}
-			match k.as_ref() {
-				"jwt" => jwt = Some(v.into_owned()),
-				"register" => register = Some(v.into_owned()),
-				_ => {}
+			if k.as_ref() == "jwt" {
+				jwt = Some(v.into_owned())
 			}
 		}
 
-		Self { path, jwt, register }
+		Self { path, jwt }
 	}
 }
 
@@ -65,9 +61,6 @@ pub enum AuthError {
 	#[error("the path does not match the root")]
 	IncorrectRoot,
 
-	#[error("a cluster token was expected")]
-	ExpectedCluster,
-
 	#[error("key not found")]
 	KeyNotFound,
 
@@ -91,6 +84,10 @@ impl axum::response::IntoResponse for AuthError {
 }
 
 /// Configuration for JWT-based authentication.
+///
+/// Supports both local key files and remote JWK set URIs with optional
+/// periodic refresh. When no key is configured, a public prefix can
+/// still grant unauthenticated access to a subset of paths.
 #[derive(clap::Args, Clone, Debug, Serialize, Deserialize, Default)]
 #[serde(default)]
 #[non_exhaustive]
@@ -131,10 +128,6 @@ pub struct AuthToken {
 	pub subscribe: Vec<PathOwned>,
 	/// Paths the holder is allowed to publish to, relative to `root`.
 	pub publish: Vec<PathOwned>,
-	/// Whether this token grants cluster-level privileges.
-	pub cluster: bool,
-	/// The cluster node name to register, if this is a cluster connection.
-	pub register: Option<String>,
 }
 
 enum KeySource {
@@ -310,6 +303,10 @@ impl Auth {
 		result
 	}
 
+	/// Creates a new authenticator from the given configuration.
+	///
+	/// If the key is a URL, the JWK set is fetched immediately and an
+	/// optional background task is spawned to refresh it periodically.
 	pub async fn new(config: AuthConfig) -> anyhow::Result<Self> {
 		let public = config.public.as_ref().map(|p| {
 			tracing::warn!("--auth-public is deprecated; use --guest when generating an auth key instead");
@@ -364,7 +361,7 @@ impl Auth {
 
 	/// Parse the token from the user provided URL, returning the claims if successful.
 	/// If no token is provided, then the claims will use the public path if it is set.
-	pub async fn verify(&self, params: &AuthParams) -> Result<AuthToken, AuthError> {
+	pub(crate) async fn verify(&self, params: &AuthParams) -> Result<AuthToken, AuthError> {
 		let claims = if let Some(token) = params.jwt.as_deref() {
 			let Some(resolver) = &self.resolver else {
 				return Err(AuthError::UnexpectedToken);
@@ -462,23 +459,10 @@ impl Auth {
 			})
 			.collect();
 
-		let register = match (params.register.as_deref(), claims.cluster) {
-			(Some(node), true) => Some(node.to_owned()),
-			(Some(_), false) => return Err(AuthError::ExpectedCluster),
-			_ => None,
-		};
-
-		// Reject connections that end up with no permissions after reduction
-		if subscribe.is_empty() && publish.is_empty() && !claims.cluster {
-			return Err(AuthError::IncorrectRoot);
-		}
-
 		Ok(AuthToken {
 			root: root.to_owned(),
 			subscribe,
 			publish,
-			cluster: claims.cluster,
-			register,
 		})
 	}
 }
@@ -587,11 +571,11 @@ mod tests {
 		})
 		.await?;
 
+		// Should fail when token provided but no key configured
 		let result = auth
 			.verify(&AuthParams {
 				path: "/any/path".into(),
 				jwt: Some("fake-token".into()),
-				..Default::default()
 			})
 			.await;
 		assert!(result.is_err());
@@ -618,11 +602,11 @@ mod tests {
 		};
 		let token = key.encode(&claims)?;
 
+		// Should succeed with valid token and matching path
 		let token = auth
 			.verify(&AuthParams {
 				path: "/room/123".into(),
 				jwt: Some(token),
-				..Default::default()
 			})
 			.await?;
 		assert_eq!(token.root, "room/123".as_path());
@@ -651,11 +635,11 @@ mod tests {
 		};
 		let token = key.encode(&claims)?;
 
+		// Should fail when trying to access wrong path
 		let result = auth
 			.verify(&AuthParams {
 				path: "/secret".into(),
 				jwt: Some(token),
-				..Default::default()
 			})
 			.await;
 		assert!(result.is_err());
@@ -682,11 +666,11 @@ mod tests {
 		};
 		let token = key.encode(&claims)?;
 
+		// Verify the restrictions are preserved
 		let token = auth
 			.verify(&AuthParams {
 				path: "/room/123".into(),
 				jwt: Some(token),
-				..Default::default()
 			})
 			.await?;
 		assert_eq!(token.root, "room/123".as_path());
@@ -719,7 +703,6 @@ mod tests {
 			.verify(&AuthParams {
 				path: "/room/123".into(),
 				jwt: Some(token),
-				..Default::default()
 			})
 			.await?;
 		assert_eq!(token.subscribe, vec!["".as_path()]);
@@ -751,7 +734,6 @@ mod tests {
 			.verify(&AuthParams {
 				path: "/room/123".into(),
 				jwt: Some(token),
-				..Default::default()
 			})
 			.await?;
 		assert_eq!(token.subscribe, vec![]);
@@ -779,11 +761,11 @@ mod tests {
 		};
 		let token = key.encode(&claims)?;
 
+		// Connect to more specific path room/123/alice
 		let token = auth
 			.verify(&AuthParams {
 				path: "/room/123/alice".into(),
 				jwt: Some(token),
-				..Default::default()
 			})
 			.await?;
 
@@ -813,11 +795,11 @@ mod tests {
 		};
 		let token = key.encode(&claims)?;
 
+		// Connect to room/123/alice - should remove alice prefix from publish
 		let token = auth
 			.verify(&AuthParams {
 				path: "/room/123/alice".into(),
 				jwt: Some(token),
-				..Default::default()
 			})
 			.await?;
 
@@ -847,11 +829,11 @@ mod tests {
 		};
 		let token = key.encode(&claims)?;
 
+		// Connect to room/123/bob - should remove bob prefix from subscribe
 		let token = auth
 			.verify(&AuthParams {
 				path: "/room/123/bob".into(),
 				jwt: Some(token),
-				..Default::default()
 			})
 			.await?;
 
@@ -881,11 +863,11 @@ mod tests {
 		};
 		let token = key.encode(&claims)?;
 
+		// Connect to room/123/alice - loses ability to subscribe to bob
 		let verified = auth
 			.verify(&AuthParams {
 				path: "/room/123/alice".into(),
 				jwt: Some(token.clone()),
-				..Default::default()
 			})
 			.await?;
 
@@ -893,11 +875,11 @@ mod tests {
 		assert_eq!(verified.subscribe, vec![]);
 		assert_eq!(verified.publish, vec!["".as_path()]);
 
+		// Connect to room/123/bob - loses ability to publish to alice
 		let verified = auth
 			.verify(&AuthParams {
 				path: "/room/123/bob".into(),
 				jwt: Some(token),
-				..Default::default()
 			})
 			.await?;
 
@@ -927,11 +909,11 @@ mod tests {
 		};
 		let token = key.encode(&claims)?;
 
+		// Connect to room/123/users - permissions should be reduced
 		let verified = auth
 			.verify(&AuthParams {
 				path: "/room/123/users".into(),
 				jwt: Some(token.clone()),
-				..Default::default()
 			})
 			.await?;
 
@@ -939,11 +921,11 @@ mod tests {
 		assert_eq!(verified.subscribe, vec!["bob/screen".as_path()]);
 		assert_eq!(verified.publish, vec!["alice/camera".as_path()]);
 
+		// Connect to room/123/users/alice - further reduction
 		let verified = auth
 			.verify(&AuthParams {
 				path: "/room/123/users/alice".into(),
 				jwt: Some(token),
-				..Default::default()
 			})
 			.await?;
 
@@ -973,11 +955,11 @@ mod tests {
 		};
 		let token = key.encode(&claims)?;
 
+		// Connect to more specific path
 		let verified = auth
 			.verify(&AuthParams {
 				path: "/room/123/alice".into(),
 				jwt: Some(token),
-				..Default::default()
 			})
 			.await?;
 
@@ -996,7 +978,6 @@ mod tests {
 			.verify(&AuthParams {
 				path: "/room/123/alice".into(),
 				jwt: Some(token),
-				..Default::default()
 			})
 			.await?;
 
@@ -1027,7 +1008,6 @@ mod tests {
 			.verify(&AuthParams {
 				path: "/test".into(),
 				jwt: Some(token),
-				..Default::default()
 			})
 			.await;
 		assert!(matches!(result, Err(AuthError::KeyNotFound)));
@@ -1093,7 +1073,6 @@ mod tests {
 			.verify(&AuthParams {
 				path: "/room/1".into(),
 				jwt: Some(token1),
-				..Default::default()
 			})
 			.await?;
 		assert_eq!(verified.root, "room/1".as_path());
@@ -1110,7 +1089,6 @@ mod tests {
 			.verify(&AuthParams {
 				path: "/room/2".into(),
 				jwt: Some(token2),
-				..Default::default()
 			})
 			.await?;
 		assert_eq!(verified.root, "room/2".as_path());
@@ -1167,7 +1145,6 @@ mod tests {
 			.verify(&AuthParams {
 				path: "/test".into(),
 				jwt: Some(token),
-				..Default::default()
 			})
 			.await;
 		assert!(matches!(result, Err(AuthError::MissingKeyId)));
@@ -1235,7 +1212,6 @@ mod tests {
 			.verify(&AuthParams {
 				path: "/secret".into(),
 				jwt: Some(jwt),
-				..Default::default()
 			})
 			.await?;
 		assert_eq!(token.root, "secret".as_path());
diff --git a/rs/moq-relay/src/cluster.rs b/rs/moq-relay/src/cluster.rs
index ec6a1119f..25a604b7f 100644
--- a/rs/moq-relay/src/cluster.rs
+++ b/rs/moq-relay/src/cluster.rs
@@ -1,12 +1,10 @@
-use std::{collections::HashMap, path::PathBuf};
+use std::path::PathBuf;
 
 use anyhow::Context;
-use moq_lite::{Broadcast, BroadcastConsumer, BroadcastProducer, Origin, OriginConsumer, OriginProducer};
+use moq_lite::{BroadcastConsumer, Origin, OriginId, OriginProducer};
 use tracing::Instrument;
 use url::Url;
 
-use crate::AuthToken;
-
 /// Configuration for relay clustering.
 ///
 /// When a root URL and node name are both set, the relay joins a
@@ -17,124 +15,51 @@ use crate::AuthToken;
 #[serde(default, deny_unknown_fields)]
 #[non_exhaustive]
 pub struct ClusterConfig {
-	/// Connect to this hostname in order to discover other nodes.
-	#[serde(alias = "connect")]
+	/// Connect to these hostnames to form the cluster.
 	#[arg(
-		id = "cluster-root",
-		long = "cluster-root",
-		env = "MOQ_CLUSTER_ROOT",
-		alias = "cluster-connect"
+		id = "cluster-connect",
+		long = "cluster-connect",
+		env = "MOQ_CLUSTER_CONNECT",
+		value_delimiter = ','
 	)]
-	pub root: Option<String>,
+	#[serde_as(as = "serde_with::OneOrMany<_>")]
+	pub connect: Vec<String>,
 
 	/// Use the token in this file when connecting to other nodes.
 	#[arg(id = "cluster-token", long = "cluster-token", env = "MOQ_CLUSTER_TOKEN")]
 	pub token: Option<PathBuf>,
 
-	/// Our hostname which we advertise to other nodes.
-	///
-	// TODO Remove alias once we've migrated to the new name.
-	#[serde(alias = "advertise")]
-	#[arg(
-		id = "cluster-node",
-		long = "cluster-node",
-		env = "MOQ_CLUSTER_NODE",
-		alias = "cluster-advertise"
-	)]
-	pub node: Option<String>,
-
-	/// The prefix to use for cluster announcements.
-	/// Defaults to "internal/origins".
-	///
-	/// WARNING: This should not be accessible by users unless authentication is disabled (YOLO).
-	#[arg(
-		id = "cluster-prefix",
-		long = "cluster-prefix",
-		default_value = "internal/origins",
-		env = "MOQ_CLUSTER_PREFIX"
-	)]
-	pub prefix: String,
+	/// Optional explicit origin ID for this node. If not set, a random one is generated.
+	#[arg(long = "cluster-origin-id", env = "MOQ_CLUSTER_ORIGIN_ID")]
+	pub origin_id: Option<u64>,
 }
 
 /// Manages broadcast origins across local and remote relay nodes.
-///
-/// Broadcasts are split into three tiers: [`primary`](Self::primary)
-/// holds locally announced broadcasts, [`secondary`](Self::secondary)
-/// holds those learned from other cluster nodes, and
-/// [`combined`](Self::combined) merges both for serving to end users.
 #[derive(Clone)]
 pub struct Cluster {
 	config: ClusterConfig,
 	client: moq_native::Client,
 
-	/// Broadcasts announced by local clients (users).
-	pub primary: OriginProducer,
-
-	/// Broadcasts announced by remote servers (cluster).
-	pub secondary: OriginProducer,
-
-	/// Broadcasts announced by local clients and remote servers.
-	pub combined: OriginProducer,
+	// All broadcasts, both local and remote.
+	// Hops-based routing ensures the shortest path is preferred.
+	pub origin: OriginProducer,
 }
 
 impl Cluster {
 	/// Creates a new cluster with the given configuration and QUIC client.
 	pub fn new(config: ClusterConfig, client: moq_native::Client) -> Self {
-		Cluster {
-			config,
-			client,
-			primary: Origin::produce(),
-			secondary: Origin::produce(),
-			combined: Origin::produce(),
-		}
-	}
-
-	/// For a given auth token, return the origin that should be used for the session.
-	pub fn subscriber(&self, token: &AuthToken) -> Option<OriginConsumer> {
-		// These broadcasts will be served to the session (when it subscribes).
-		// If this is a cluster node, then only publish our primary broadcasts.
-		// Otherwise publish everything.
-		let subscribe_origin = match token.cluster {
-			true => &self.primary,
-			false => &self.combined,
-		};
-
-		// Scope the origin to our root.
-		let subscribe_origin = subscribe_origin.with_root(&token.root)?;
-		subscribe_origin.consume_only(&token.subscribe)
-	}
-
-	/// For a given auth token, return the origin that should be used for the session.
-	pub fn publisher(&self, token: &AuthToken) -> Option<OriginProducer> {
-		// If this is a cluster node, then add its broadcasts to the secondary origin.
-		// That way we won't publish them to other cluster nodes.
-		let publish_origin = match token.cluster {
-			true => &self.secondary,
-			false => &self.primary,
+		let origin = if let Some(id) = config.origin_id {
+			Origin::produce().with_id(OriginId::try_from(id).expect("invalid origin ID: must be 1 <= value < 2^62"))
+		} else {
+			Origin::produce()
 		};
 
-		let publish_origin = publish_origin.with_root(&token.root)?;
-		publish_origin.publish_only(&token.publish)
-	}
-
-	/// Register a cluster node's presence.
-	///
-	/// Returns a [`ClusterRegistration`] that should be kept alive for the duration of the session.
-	pub fn register(&self, token: &AuthToken) -> Option<ClusterRegistration> {
-		let node = token.register.clone()?;
-		let broadcast = Broadcast::produce();
-
-		let path = moq_lite::Path::new(&self.config.prefix).join(&node);
-		self.primary.publish_broadcast(path, broadcast.consume());
-
-		Some(ClusterRegistration::new(node, broadcast))
+		Cluster { config, client, origin }
 	}
 
 	/// Looks up a broadcast by name across primary and secondary origins.
 	pub fn get(&self, broadcast: &str) -> Option<BroadcastConsumer> {
-		self.primary
-			.consume_broadcast(broadcast)
-			.or_else(|| self.secondary.consume_broadcast(broadcast))
+		self.origin.consume().try_consume_broadcast(broadcast)
 	}
 
 	/// Runs the cluster event loop, connecting to remote nodes and
@@ -143,28 +68,11 @@ impl Cluster {
 	/// This future runs until the cluster is shut down or a fatal error
 	/// occurs.
 	pub async fn run(self) -> anyhow::Result<()> {
-		// If we're using a root node, then we have to connect to it.
-		// Otherwise, we're the root node so we wait for other nodes to connect to us.
-		let Some(root) = self
-			.config
-			.root
-			.clone()
-			.filter(|connect| Some(connect) != self.config.node.as_ref())
-		else {
-			tracing::info!("running as root, accepting leaf nodes");
-			self.run_combined().await?;
-			anyhow::bail!("combined connection closed");
-		};
-
-		// Subscribe to available origins from secondary (what we learn from other nodes).
-		// Use with_root to automatically strip the prefix from announced paths.
-		let origins = self
-			.secondary
-			.with_root(&self.config.prefix)
-			.context("no authorized origins")?;
+		if self.config.connect.is_empty() {
+			return Ok(());
+		}
 
 		// If the token is provided, read it from the disk and use it in the query parameter.
-		// TODO put this in an AUTH header once WebTransport supports it.
 		let token = match &self.config.token {
 			Some(path) => std::fs::read_to_string(path)
 				.context("failed to read token")?
@@ -173,114 +81,31 @@ impl Cluster {
 			None => "".to_string(),
 		};
 
-		let local = self.config.node.clone().context("missing node")?;
-
-		// Create a dummy broadcast that we don't close so run_remote doesn't close.
-		let noop = Broadcast::produce();
-
-		// Despite returning a Result, we should NEVER return an Ok
-		tokio::select! {
-			res = self.clone().run_remote(&root, Some(local.as_str()), token.clone(), noop.consume()) => {
-				res.context("failed to connect to root")?;
-				anyhow::bail!("connection to root closed");
-			}
-			res = self.clone().run_remotes(origins.consume(), token) => {
-				res.context("failed to connect to remotes")?;
-				anyhow::bail!("connection to remotes closed");
-			}
-			res = self.run_combined() => {
-				res.context("failed to run combined")?;
-				anyhow::bail!("combined connection closed");
-			}
-		}
-	}
-
-	// Shovel broadcasts from the primary and secondary origins into the combined origin.
-	async fn run_combined(self) -> anyhow::Result<()> {
-		let mut primary = self.primary.consume();
-		let mut secondary = self.secondary.consume();
-
-		loop {
-			let (name, broadcast) = tokio::select! {
-				biased;
-				Some(primary) = primary.announced() => primary,
-				Some(secondary) = secondary.announced() => secondary,
-				else => return Ok(()),
-			};
-
-			if let Some(broadcast) = broadcast {
-				self.combined.publish_broadcast(&name, broadcast);
-			}
-		}
-	}
-
-	async fn run_remotes(self, mut origins: OriginConsumer, token: String) -> anyhow::Result<()> {
-		// Cancel tasks when the origin is closed.
-		let mut active: HashMap<String, tokio::task::AbortHandle> = HashMap::new();
-
-		// Discover other origins.
-		// NOTE: The root node will connect to all other nodes as a client, ignoring the existing (server) connection.
-		// This ensures that nodes are advertising a valid hostname before any tracks get announced.
-		while let Some((node, origin)) = origins.announced().await {
-			if self.config.node.as_deref() == Some(node.as_str()) {
-				// Skip ourselves.
-				continue;
-			}
-
-			let Some(origin) = origin else {
-				tracing::info!(%node, "origin cancelled");
-				active.remove(node.as_str()).unwrap().abort();
-				continue;
-			};
-
-			tracing::info!(%node, "discovered origin");
-
+		let mut tasks = tokio::task::JoinSet::new();
+		for remote in self.config.connect.clone() {
 			let this = self.clone();
 			let token = token.clone();
-			let node2 = node.clone();
-
-			let handle = tokio::spawn(
-				async move {
-					match this.run_remote(node2.as_str(), None, token, origin).await {
-						Ok(()) => tracing::info!(%node2, "origin closed"),
-						Err(err) => tracing::warn!(%err, %node2, "origin error"),
-					}
-				}
-				.in_current_span(),
-			);
+			tasks.spawn(async move { this.run_remote(&remote, token).await }.in_current_span());
+		}
 
-			active.insert(node.to_string(), handle.abort_handle());
+		while let Some(res) = tasks.join_next().await {
+			res??;
 		}
 
 		Ok(())
 	}
 
 	#[tracing::instrument("remote", skip_all, err, fields(%remote))]
-	async fn run_remote(
-		mut self,
-		remote: &str,
-		register: Option<&str>,
-		token: String,
-		origin: BroadcastConsumer,
-	) -> anyhow::Result<()> {
+	async fn run_remote(self, remote: &str, token: String) -> anyhow::Result<()> {
 		let mut url = Url::parse(&format!("https://{remote}/"))?;
-		{
-			let mut q = url.query_pairs_mut();
-			if !token.is_empty() {
-				q.append_pair("jwt", &token);
-			}
-			if let Some(register) = register {
-				q.append_pair("register", register);
-			}
+		if !token.is_empty() {
+			url.query_pairs_mut().append_pair("jwt", &token);
 		}
+
 		let mut backoff = 1;
 
 		loop {
-			let res = tokio::select! {
-				biased;
-				_ = origin.closed() => break,
-				res = self.run_remote_once(&url) => res,
-			};
+			let res = self.run_remote_once(&url).await;
 
 			match res {
 				Ok(()) => backoff = 1,
@@ -292,17 +117,14 @@ impl Cluster {
 
 			let timeout = tokio::time::Duration::from_secs(backoff);
 			if timeout > tokio::time::Duration::from_secs(300) {
-				// 5 minutes of backoff is enough, just give up.
 				anyhow::bail!("remote connection keep failing, giving up");
 			}
 
 			tokio::time::sleep(timeout).await;
 		}
-
-		Ok(())
 	}
 
-	async fn run_remote_once(&mut self, url: &Url) -> anyhow::Result<()> {
+	async fn run_remote_once(&self, url: &Url) -> anyhow::Result<()> {
 		let mut log_url = url.clone();
 		log_url.set_query(None);
 		tracing::info!(url = %log_url, "connecting to remote");
@@ -310,8 +132,8 @@ impl Cluster {
 		let session = self
 			.client
 			.clone()
-			.with_publish(self.primary.consume())
-			.with_consume(self.secondary.clone())
+			.with_publish(self.origin.consume())
+			.with_consume(self.origin.clone())
 			.connect(url.clone())
 			.await
 			.context("failed to connect to remote")?;
@@ -319,27 +141,3 @@ impl Cluster {
 		session.closed().await.map_err(Into::into)
 	}
 }
-
-/// A handle that keeps a cluster node registered. Dropping it
-/// unregisters the node and aborts its broadcast.
-pub struct ClusterRegistration {
-	// The name of the node.
-	node: String,
-
-	// The announcement, send to other nodes.
-	broadcast: BroadcastProducer,
-}
-
-impl ClusterRegistration {
-	/// Creates a new registration for the given node.
-	pub fn new(node: String, broadcast: BroadcastProducer) -> Self {
-		tracing::info!(%node, "registered cluster client");
-		ClusterRegistration { node, broadcast }
-	}
-}
-impl Drop for ClusterRegistration {
-	fn drop(&mut self) {
-		tracing::info!(%self.node, "unregistered cluster client");
-		let _ = self.broadcast.abort(moq_lite::Error::Cancel);
-	}
-}
diff --git a/rs/moq-relay/src/config.rs b/rs/moq-relay/src/config.rs
index b0e69fff8..97bd79765 100644
--- a/rs/moq-relay/src/config.rs
+++ b/rs/moq-relay/src/config.rs
@@ -47,7 +47,7 @@ pub struct Config {
 	#[command(flatten)]
 	#[serde(default)]
 	#[cfg(feature = "iroh")]
-	pub iroh: moq_native::IrohEndpointConfig,
+	pub iroh: moq_native::iroh::EndpointConfig,
 }
 
 impl Config {
@@ -63,7 +63,7 @@ impl Config {
 			config.update_from(std::env::args());
 		}
 
-		config.log.init();
+		config.log.init()?;
 		tracing::trace!(?config, "final config");
 
 		Ok(config)
diff --git a/rs/moq-relay/src/connection.rs b/rs/moq-relay/src/connection.rs
index 92821d8ad..5be27976f 100644
--- a/rs/moq-relay/src/connection.rs
+++ b/rs/moq-relay/src/connection.rs
@@ -37,9 +37,9 @@ impl Connection {
 			}
 		};
 
-		let publish = self.cluster.publisher(&token);
-		let subscribe = self.cluster.subscriber(&token);
-		let registration = self.cluster.register(&token);
+		let origin = self.cluster.origin.with_root(&token.root);
+		let publish = origin.as_ref().and_then(|o| o.with_filter(&token.publish));
+		let subscribe = origin.as_ref().and_then(|o| o.consume().with_filter(&token.subscribe));
 		let transport = self.request.transport();
 
 		match (&publish, &subscribe) {
@@ -71,9 +71,7 @@ impl Connection {
 		tracing::info!(version = %session.version(), transport, "negotiated");
 
 		// Wait until the session is closed.
-		// Keep registration alive so the cluster node stays announced.
 		session.closed().await?;
-		drop(registration);
 		Ok(())
 	}
 }
diff --git a/rs/moq-relay/src/web.rs b/rs/moq-relay/src/web.rs
index 4f47cc481..4795633c9 100644
--- a/rs/moq-relay/src/web.rs
+++ b/rs/moq-relay/src/web.rs
@@ -176,7 +176,6 @@ async fn serve_fingerprint(State(state): State<Arc<WebState>>) -> String {
 #[derive(Debug, serde::Deserialize)]
 pub(crate) struct AuthQuery {
 	pub(crate) jwt: Option<String>,
-	pub(crate) register: Option<String>,
 }
 
 #[derive(Debug, serde::Deserialize)]
@@ -248,19 +247,17 @@ async fn serve_announced(
 	let params = AuthParams {
 		path: prefix,
 		jwt: query.jwt,
-		register: query.register,
 	};
 	let token = state.auth.verify(&params).await?;
-	let Some(mut origin) = state.cluster.subscriber(&token) else {
+	let scoped = state.cluster.origin.with_root(&token.root);
+	let Some(mut origin) = scoped.and_then(|o| o.consume().with_filter(&token.subscribe)) else {
 		return Err(StatusCode::UNAUTHORIZED.into());
 	};
 
 	let mut broadcasts = Vec::new();
 
-	while let Some((suffix, active)) = origin.try_announced() {
-		if active.is_some() {
-			broadcasts.push(suffix);
-		}
+	while let Some((suffix, _broadcast)) = origin.try_announced() {
+		broadcasts.push(suffix);
 	}
 
 	Ok(broadcasts.iter().map(|p| p.to_string()).collect::<Vec<_>>().join("\n"))
@@ -285,44 +282,44 @@ async fn serve_fetch(
 	let auth = AuthParams {
 		path: broadcast.clone(),
 		jwt: params.auth.jwt,
-		register: params.auth.register,
 	};
 	let token = state.auth.verify(&auth).await?;
 
-	let Some(origin) = state.cluster.subscriber(&token) else {
+	let scoped = state.cluster.origin.with_root(&token.root);
+	let Some(origin) = scoped.and_then(|o| o.consume().with_filter(&token.subscribe)) else {
 		return Err(StatusCode::UNAUTHORIZED.into());
 	};
 
 	tracing::info!(%broadcast, %track, "fetching track");
 
-	let track = moq_lite::Track {
-		name: track,
-		priority: 0,
-	};
+	let track = moq_lite::Track::new(track);
 
 	// NOTE: The auth token is already scoped to the broadcast.
-	let broadcast = origin.consume_broadcast("").ok_or(StatusCode::NOT_FOUND)?;
-	let mut track = broadcast.subscribe_track(&track).map_err(|err| match err {
-		moq_lite::Error::NotFound => StatusCode::NOT_FOUND,
+	let broadcast = origin.try_consume_broadcast("").ok_or(StatusCode::NOT_FOUND)?;
+	let track = broadcast.consume_track(&track).map_err(|err| match err {
+		moq_lite::Error::UnknownTrack | moq_lite::Error::UnknownBroadcast => StatusCode::NOT_FOUND,
 		_ => StatusCode::INTERNAL_SERVER_ERROR,
 	})?;
 
 	let deadline = tokio::time::Instant::now() + tokio::time::Duration::from_secs(30);
 
 	let result = tokio::time::timeout_at(deadline, async {
+		let to_err = |err: moq_lite::Error| match err {
+			moq_lite::Error::UnknownTrack | moq_lite::Error::UnknownBroadcast => StatusCode::NOT_FOUND,
+			_ => StatusCode::INTERNAL_SERVER_ERROR,
+		};
+
 		let group = match params.group {
 			FetchGroup::Latest => match track.latest() {
-				Some(sequence) => track.get_group(sequence).await,
-				None => track.next_group().await,
+				Some(sequence) => track.get_group(sequence).await.map_err(to_err)?,
+				None => {
+					let mut sub = track.subscribe(moq_lite::Subscription::default()).map_err(to_err)?;
+					sub.recv_group().await.map_err(to_err)?
+				}
 			},
-			FetchGroup::Num(sequence) => track.get_group(sequence).await,
-		};
-
-		let group = match group {
-			Ok(Some(group)) => group,
-			Ok(None) => return Err(StatusCode::NOT_FOUND),
-			Err(_) => return Err(StatusCode::INTERNAL_SERVER_ERROR),
-		};
+			FetchGroup::Num(sequence) => track.get_group(sequence).await.map_err(to_err)?,
+		}
+		.ok_or(StatusCode::NOT_FOUND)?;
 
 		tracing::info!(track = %track.info.name, group = %group.info.sequence, "serving group");
 
diff --git a/rs/moq-relay/src/websocket.rs b/rs/moq-relay/src/websocket.rs
index 828b1b3fc..2b4b29fec 100644
--- a/rs/moq-relay/src/websocket.rs
+++ b/rs/moq-relay/src/websocket.rs
@@ -23,15 +23,11 @@ pub(crate) async fn serve_ws(
 ) -> axum::response::Result<Response> {
 	let ws = ws.protocols(["webtransport"]);
 
-	let params = AuthParams {
-		path,
-		jwt: query.jwt,
-		register: query.register,
-	};
+	let params = AuthParams { path, jwt: query.jwt };
 	let token = state.auth.verify(&params).await?;
-	let publish = state.cluster.publisher(&token);
-	let subscribe = state.cluster.subscriber(&token);
-	let registration = state.cluster.register(&token);
+	let origin = state.cluster.origin.with_root(&token.root);
+	let publish = origin.as_ref().and_then(|o| o.with_filter(&token.publish));
+	let subscribe = origin.as_ref().and_then(|o| o.consume().with_filter(&token.subscribe));
 
 	if publish.is_none() && subscribe.is_none() {
 		// Bad token, we can't publish or subscribe.
@@ -52,7 +48,6 @@ pub(crate) async fn serve_ws(
 			})
 			.with(tungstenite_to_axum);
 		let _ = handle_socket(id, socket, publish, subscribe).await;
-		drop(registration);
 	}))
 }
 
diff --git a/rs/moq-token-cli/src/main.rs b/rs/moq-token-cli/src/main.rs
index 55739b0fc..0462225a7 100644
--- a/rs/moq-token-cli/src/main.rs
+++ b/rs/moq-token-cli/src/main.rs
@@ -74,8 +74,8 @@ enum Commands {
 		#[arg(long)]
 		publish: Vec<String>,
 
-		/// Mark this token as a cluster node.
-		#[arg(long)]
+		/// Deprecated: Previously used to mark cluster nodes. No longer has any effect.
+		#[arg(long, hide = true)]
 		cluster: bool,
 
 		/// Paths the user can subscribe to (repeatable).
@@ -152,6 +152,7 @@ fn main() -> anyhow::Result<()> {
 			}
 		}
 
+		#[allow(deprecated)]
 		Commands::Sign {
 			key,
 			root,
diff --git a/rs/moq-token/src/claims.rs b/rs/moq-token/src/claims.rs
index db1186629..1ec6f1915 100644
--- a/rs/moq-token/src/claims.rs
+++ b/rs/moq-token/src/claims.rs
@@ -21,11 +21,9 @@ pub struct Claims {
 	#[serde_as(as = "OneOrMany<_, PreferMany>")]
 	pub publish: Vec<String>,
 
-	/// If true, then this client is considered a cluster node.
-	/// Both the client and server will only announce broadcasts from non-cluster clients.
-	/// This avoids convoluted routing, as only the primary origin will announce.
-	//
-	// TODO This shouldn't be part of the token.
+	/// Deprecated: Previously used to mark cluster nodes.
+	/// Kept for backwards compatibility with existing tokens.
+	#[deprecated]
 	#[serde(default, rename = "cluster", skip_serializing_if = "is_false")]
 	pub cluster: bool,
 
@@ -58,6 +56,7 @@ impl Claims {
 }
 
 #[cfg(test)]
+#[allow(deprecated)]
 mod tests {
 	use super::*;
 
diff --git a/rs/moq-token/src/key.rs b/rs/moq-token/src/key.rs
index a0d6e7c26..24013c295 100644
--- a/rs/moq-token/src/key.rs
+++ b/rs/moq-token/src/key.rs
@@ -543,6 +543,7 @@ where
 }
 
 #[cfg(test)]
+#[allow(deprecated)]
 mod tests {
 	use super::*;
 	use std::time::{Duration, SystemTime};
diff --git a/rs/moq-token/src/set.rs b/rs/moq-token/src/set.rs
index 9622a3b2c..b63026195 100644
--- a/rs/moq-token/src/set.rs
+++ b/rs/moq-token/src/set.rs
@@ -123,6 +123,7 @@ pub async fn load_keys(jwks_uri: &str) -> crate::Result<KeySet> {
 }
 
 #[cfg(test)]
+#[allow(deprecated)]
 mod tests {
 	use super::*;
 	use crate::Algorithm;