diff --git a/Cargo.lock b/Cargo.lock
index 736930f39..90dce7215 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -398,9 +398,9 @@ checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
 
 [[package]]
 name = "base16ct"
-version = "1.0.0"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd307490d624467aa6f74b0eabb77633d1f758a7b25f12bceb0b22e08d9726f6"
+checksum = "d8b59d472eab27ade8d770dcb11da7201c11234bef9f82ce7aa517be028d462b"
 
 [[package]]
 name = "base32"
@@ -422,9 +422,9 @@ checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
 name = "base64ct"
-version = "1.8.2"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d809780667f4410e7c41b07f52439b94d2bdf8528eeedc287fa38d3b7f95d82"
+checksum = "0e050f626429857a27ddccb31e0aca21356bfa709c04041aefddac081a8f068a"
 
 [[package]]
 name = "bitflags"
@@ -434,16 +434,15 @@ checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
 
 [[package]]
 name = "blake3"
-version = "1.8.3"
+version = "1.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2468ef7d57b3fb7e16b576e8377cdbde2320c60e1491e961d11da40fc4f02a2d"
+checksum = "3888aaa89e4b2a40fca9848e400f6a658a5a3978de7be858e209cafa8be9a4a0"
 dependencies = [
  "arrayref",
  "arrayvec",
  "cc",
  "cfg-if",
  "constant_time_eq",
- "cpufeatures",
 ]
 
 [[package]]
@@ -512,7 +511,7 @@ checksum = "befbfd072a8e81c02f8c507aefce431fe5e7d051f83d48a23ffc9b9fe5a11799"
 dependencies = [
  "clap",
  "heck",
- "indexmap 2.13.0",
+ "indexmap 2.12.1",
  "log",
  "proc-macro2",
  "quote",
@@ -525,9 +524,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.52"
+version = "1.2.51"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd4932aefd12402b36c60956a4fe0035421f544799057659ff86f923657aada3"
+checksum = "7a0aeaff4ff1a90589618835a598e545176939b97874f7abc7851caa0618f203"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -593,9 +592,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.54"
+version = "4.5.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6e6ff9dcd79cff5cd969a17a545d79e84ab086e444102a591e288a8aa3ce394"
+checksum = "c9e340e012a1bf4935f5282ed1436d1489548e8f72308207ea5df0e23d2d03f8"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -603,9 +602,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.54"
+version = "4.5.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa42cf4d2b7a41bc8f663a7cab4031ebafa1bf3875705bfaf8466dc60ab52c00"
+checksum = "d76b5d13eaa18c901fd2f7fca939fefe3a0727a953561fefdf3b2922b8569d00"
 dependencies = [
  "anstream",
  "anstyle",
@@ -739,15 +738,15 @@ checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
 
 [[package]]
 name = "const-oid"
-version = "0.10.2"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c"
+checksum = "0dabb6555f92fb9ee4140454eb5dcd14c7960e1225c6d1a6cc361f032947713e"
 
 [[package]]
 name = "constant_time_eq"
-version = "0.4.2"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b"
+checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
 
 [[package]]
 name = "convert_case"
@@ -993,7 +992,7 @@ version = "0.8.0-rc.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "02c1d73e9668ea6b6a28172aa55f3ebec38507131ce179051c8033b5c6037653"
 dependencies = [
- "const-oid 0.10.2",
+ "const-oid 0.10.1",
  "pem-rfc7468 1.0.0",
  "zeroize",
 ]
@@ -1022,13 +1021,34 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "derive_more"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a9b99b9cbbe49445b21764dc0625032a89b145a2642e67603e1c936f5458d05"
+dependencies = [
+ "derive_more-impl 1.0.0",
+]
+
 [[package]]
 name = "derive_more"
 version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"
 dependencies = [
- "derive_more-impl",
+ "derive_more-impl 2.1.1",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "unicode-xid",
 ]
 
 [[package]]
@@ -1070,7 +1090,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dac89f8a64533a9b0eaa73a68e424db0fb1fd6271c74cc0125336a05f090568d"
 dependencies = [
  "block-buffer 0.11.0",
- "const-oid 0.10.2",
+ "const-oid 0.10.1",
  "crypto-common 0.2.0-rc.4",
 ]
 
@@ -1139,7 +1159,7 @@ checksum = "594435fe09e345ee388e4e8422072ff7dfeca8729389fbd997b3f5504c44cd47"
 dependencies = [
  "pkcs8 0.11.0-rc.8",
  "serde",
- "signature 3.0.0-rc.6",
+ "signature 3.0.0-rc.5",
 ]
 
 [[package]]
@@ -1153,7 +1173,7 @@ dependencies = [
  "rand_core 0.9.3",
  "serde",
  "sha2 0.11.0-rc.2",
- "signature 3.0.0-rc.6",
+ "signature 3.0.0-rc.5",
  "subtle",
  "zeroize",
 ]
@@ -1282,9 +1302,9 @@ checksum = "64cd1e32ddd350061ae6edb1b082d7c54915b5c672c389143b9a63403a109f24"
 
 [[package]]
 name = "find-msvc-tools"
-version = "0.1.7"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f449e6c6c08c865631d4890cfacf252b3d396c9bcc83adb6623cdb02a8336c41"
+checksum = "645cbb3a84e60b7531617d5ae4e57f7e27308f6445f5abf653209ea76dec8dff"
 
 [[package]]
 name = "fixedbitset"
@@ -1538,9 +1558,9 @@ dependencies = [
 
 [[package]]
 name = "h2"
-version = "0.4.13"
+version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f44da3a8150a6703ed5d34e164b875fd14c2cdab9af1252a9a1020bde2bdc54"
+checksum = "f3c0b69cfcb4e1b9f1bf2f53f95f766e4661169728ec61cd3fe5a0166f2d1386"
 dependencies = [
  "atomic-waker",
  "bytes",
@@ -1548,7 +1568,7 @@ dependencies = [
  "futures-core",
  "futures-sink",
  "http",
- "indexmap 2.13.0",
+ "indexmap 2.12.1",
  "slab",
  "tokio",
  "tokio-util",
@@ -1557,9 +1577,9 @@ dependencies = [
 
 [[package]]
 name = "h264-parser"
-version = "0.4.1"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "253b313319f7109de64e480ffb606f89475cd758bae82e096e00c5d95341d30e"
+checksum = "ab2f85be813ce08f0569fcd816f256c6f4287c975d69a9a14ceacc309f1de967"
 
 [[package]]
 name = "hang"
@@ -1568,8 +1588,7 @@ dependencies = [
  "anyhow",
  "buf-list",
  "bytes",
- "derive_more",
- "futures",
+ "derive_more 2.1.1",
  "h264-parser",
  "hex",
  "lazy_static",
@@ -2065,9 +2084,9 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.13.0"
+version = "2.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+checksum = "0ad4bb2b565bca0645f4d68c5c9af97fba094e9791da685bf83cb5f3ce74acf2"
 dependencies = [
  "equivalent",
  "hashbrown 0.16.1",
@@ -2077,9 +2096,9 @@ dependencies = [
 
 [[package]]
 name = "inout"
-version = "0.2.2"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4250ce6452e92010fdf7268ccc5d14faa80bb12fc741938534c58f16804e03c7"
+checksum = "c7357b6e7aa75618c7864ebd0634b115a7218b0615f4cb1df33ac3eca23943d4"
 dependencies = [
  "hybrid-array",
 ]
@@ -2116,9 +2135,9 @@ checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
 
 [[package]]
 name = "iri-string"
-version = "0.7.10"
+version = "0.7.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c91338f0783edbd6195decb37bae672fd3b165faffb89bf7b9e6942f8b1a731a"
+checksum = "4f867b9d1d896b67beb18518eda36fdb77a32ea590de864f1325b294a6d14397"
 dependencies = [
  "memchr",
  "serde",
@@ -2136,7 +2155,7 @@ dependencies = [
  "cfg_aliases",
  "crypto_box",
  "data-encoding",
- "derive_more",
+ "derive_more 2.1.1",
  "ed25519-dalek",
  "futures-util",
  "getrandom 0.3.4",
@@ -2187,7 +2206,7 @@ checksum = "25a8c5fb1cc65589f0d7ab44269a76f615a8c4458356952c9b0ef1c93ea45ff8"
 dependencies = [
  "curve25519-dalek",
  "data-encoding",
- "derive_more",
+ "derive_more 2.1.1",
  "ed25519-dalek",
  "n0-error",
  "rand_core 0.9.3",
@@ -2289,7 +2308,7 @@ dependencies = [
  "bytes",
  "cfg_aliases",
  "data-encoding",
- "derive_more",
+ "derive_more 2.1.1",
  "getrandom 0.3.4",
  "hickory-resolver",
  "http",
@@ -2300,7 +2319,7 @@ dependencies = [
  "iroh-metrics",
  "iroh-quinn",
  "iroh-quinn-proto",
- "lru",
+ "lru 0.16.2",
  "n0-error",
  "n0-future",
  "num_enum",
@@ -2417,9 +2436,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.180"
+version = "0.2.178"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcc35a38544a891a5f7c865aca548a982ccb3b8650a5b06d0fd33a10283c56fc"
+checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
 
 [[package]]
 name = "libm"
@@ -2491,9 +2510,15 @@ dependencies = [
 
 [[package]]
 name = "lru"
-version = "0.16.3"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "227748d55f2f0ab4735d87fd623798cb6b664512fe979705f829c9f81c934465"
+
+[[package]]
+name = "lru"
+version = "0.16.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1dc47f592c06f33f8e3aea9591776ec7c9f9e4124778ff8a3c3b87159f7e593"
+checksum = "96051b46fc183dc9cd4a223960ef37b9af631b55191852a8274bfef064cda20f"
 dependencies = [
  "hashbrown 0.16.1",
 ]
@@ -2580,9 +2605,9 @@ dependencies = [
 
 [[package]]
 name = "moka"
-version = "0.12.12"
+version = "0.12.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3dec6bd31b08944e08b58fd99373893a6c17054d6f3ea5006cc894f4f4eee2a"
+checksum = "8261cd88c312e0004c1d51baad2980c66528dfdb2bee62003e643a4d8f86b077"
 dependencies = [
  "crossbeam-channel",
  "crossbeam-epoch",
@@ -2590,6 +2615,7 @@ dependencies = [
  "equivalent",
  "parking_lot",
  "portable-atomic",
+ "rustc_version",
  "smallvec",
  "tagptr",
  "uuid",
@@ -2618,6 +2644,7 @@ dependencies = [
  "futures",
  "hex",
  "num_enum",
+ "priority-queue",
  "rand 0.9.2",
  "serde",
  "thiserror 2.0.17",
@@ -2722,7 +2749,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "58b9fcf396d53fdf1c43a9afd38953412b9d782d11391807b473927317bb28f9"
 dependencies = [
  "bytes",
- "derive_more",
+ "derive_more 2.1.1",
  "num",
  "paste",
  "serde",
@@ -2754,12 +2781,12 @@ dependencies = [
 
 [[package]]
 name = "n0-future"
-version = "0.3.2"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2ab99dfb861450e68853d34ae665243a88b8c493d01ba957321a1e9b2312bbe"
+checksum = "8c0709ac8235ce13b82bc4d180ee3c42364b90c1a8a628c3422d991d75a728b5"
 dependencies = [
  "cfg_aliases",
- "derive_more",
+ "derive_more 1.0.0",
  "futures-buffered",
  "futures-lite",
  "futures-util",
@@ -2779,7 +2806,7 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "38acf13c1ddafc60eb7316d52213467f8ccb70b6f02b65e7d97f7799b1f50be4"
 dependencies = [
- "derive_more",
+ "derive_more 2.1.1",
  "n0-error",
  "n0-future",
 ]
@@ -2858,7 +2885,7 @@ dependencies = [
  "atomic-waker",
  "bytes",
  "cfg_aliases",
- "derive_more",
+ "derive_more 2.1.1",
  "iroh-quinn-udp",
  "js-sys",
  "libc",
@@ -3080,9 +3107,9 @@ checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
 [[package]]
 name = "openssl-probe"
-version = "0.2.0"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f50d9b3dabb09ecd771ad0aa242ca6894994c130308ca3d7684634df8037391"
+checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
 
 [[package]]
 name = "p256"
@@ -3186,7 +3213,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
 dependencies = [
  "fixedbitset",
- "indexmap 2.13.0",
+ "indexmap 2.12.1",
 ]
 
 [[package]]
@@ -3233,9 +3260,9 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
 [[package]]
 name = "pkarr"
-version = "5.0.2"
+version = "5.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1d346b545765a0ef58b6a7e160e17ddaa7427f439b7b9a287df6c88c9e04bf2"
+checksum = "792c1328860f6874e90e3b387b4929819cc7783a6bd5a4728e918706eb436a48"
 dependencies = [
  "async-compat",
  "base32",
@@ -3248,7 +3275,7 @@ dependencies = [
  "futures-lite",
  "getrandom 0.3.4",
  "log",
- "lru",
+ "lru 0.13.0",
  "ntimestamp",
  "reqwest",
  "self_cell",
@@ -3305,9 +3332,9 @@ dependencies = [
 
 [[package]]
 name = "portable-atomic"
-version = "1.13.0"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f89776e4d69bb58bc6993e99ffa1d11f228b839984854c7daeb5d37f87cbe950"
+checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
 
 [[package]]
 name = "portmapper"
@@ -3317,7 +3344,7 @@ checksum = "7b575f975dcf03e258b0c7ab3f81497d7124f508884c37da66a7314aa2a8d467"
 dependencies = [
  "base64 0.22.1",
  "bytes",
- "derive_more",
+ "derive_more 2.1.1",
  "futures-lite",
  "futures-util",
  "hyper-util",
@@ -3397,6 +3424,17 @@ dependencies = [
  "elliptic-curve",
 ]
 
+[[package]]
+name = "priority-queue"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93980406f12d9f8140ed5abe7155acb10bb1e69ea55c88960b9c2f117445ef96"
+dependencies = [
+ "equivalent",
+ "indexmap 2.12.1",
+ "serde",
+]
+
 [[package]]
 name = "proc-macro-crate"
 version = "3.4.0"
@@ -3408,9 +3446,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.105"
+version = "1.0.103"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "535d180e0ecab6268a3e718bb9fd44db66bbbc256257165fc699dadf70d16fe7"
+checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
 dependencies = [
  "unicode-ident",
 ]
@@ -3507,9 +3545,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.43"
+version = "1.0.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc74d9a594b72ae6656596548f56f667211f8a97b3d4c3d467150794690dc40a"
+checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
 dependencies = [
  "proc-macro2",
 ]
@@ -3787,9 +3825,9 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.36"
+version = "0.23.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c665f33d38cea657d9614f766881e4d510e0eda4239891eea56b4cadcf01801b"
+checksum = "533f54bc6a7d4f647e46ad909549eda97bf5afc1585190ef692b4286b198bd8f"
 dependencies = [
  "aws-lc-rs",
  "log",
@@ -3803,9 +3841,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-native-certs"
-version = "0.8.3"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63"
+checksum = "9980d917ebb0c0536119ba501e90834767bffc3d60641457fd84a1f3fd337923"
 dependencies = [
  "openssl-probe",
  "rustls-pki-types",
@@ -3870,7 +3908,7 @@ dependencies = [
  "rustls-webpki",
  "security-framework",
  "security-framework-sys",
- "webpki-root-certs 1.0.5",
+ "webpki-root-certs 1.0.4",
  "windows-sys 0.61.2",
 ]
 
@@ -4059,9 +4097,9 @@ dependencies = [
 
 [[package]]
 name = "self_cell"
-version = "1.2.2"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b12e76d157a900eb52e81bc6e9f3069344290341720e9178cde2407113ac8d89"
+checksum = "16c2f82143577edb4921b71ede051dac62ca3c16084e918bf7b40c96ae10eb33"
 
 [[package]]
 name = "semver"
@@ -4117,9 +4155,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.149"
+version = "1.0.148"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+checksum = "3084b546a1dd6289475996f182a22aba973866ea8e8b02c51d9f46b1336a22da"
 dependencies = [
  "itoa",
  "memchr",
@@ -4170,7 +4208,7 @@ dependencies = [
  "chrono",
  "hex",
  "indexmap 1.9.3",
- "indexmap 2.13.0",
+ "indexmap 2.12.1",
  "schemars 0.9.0",
  "schemars 1.2.0",
  "serde_core",
@@ -4193,11 +4231,11 @@ dependencies = [
 
 [[package]]
 name = "serdect"
-version = "0.4.2"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9af4a3e75ebd5599b30d4de5768e00b5095d518a79fefc3ecbaf77e665d1ec06"
+checksum = "d3ef0e35b322ddfaecbc60f34ab448e157e48531288ee49fafbb053696b8ffe2"
 dependencies = [
- "base16ct 1.0.0",
+ "base16ct 0.3.0",
  "serde",
 ]
 
@@ -4288,9 +4326,9 @@ dependencies = [
 
 [[package]]
 name = "signature"
-version = "3.0.0-rc.6"
+version = "3.0.0-rc.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "597a96996ccff7dfa16f052bd995b4cecc72af22c35138738dc029f0ead6608d"
+checksum = "2a0251c9d6468f4ba853b6352b190fb7c1e405087779917c238445eb03993826"
 
 [[package]]
 name = "simd-adler32"
@@ -4450,9 +4488,9 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "syn"
-version = "2.0.114"
+version = "2.0.111"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a"
+checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4627,9 +4665,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.49.0"
+version = "1.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86"
+checksum = "ff360e02eab121e0bc37a2d3b4d4dc622e6eda3a8e5253d5435ecf5bd4c68408"
 dependencies = [
  "bytes",
  "libc",
@@ -4666,9 +4704,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-stream"
-version = "0.1.18"
+version = "0.1.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32da49809aab5c3bc678af03902d4ccddea2a87d028d86392a4b1560c6906c70"
+checksum = "eca58d7bba4a75707817a2c44174253f9236b2d5fbd055602e9d5c07c139a047"
 dependencies = [
  "futures-core",
  "pin-project-lite",
@@ -4702,9 +4740,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.18"
+version = "0.7.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
+checksum = "2efa149fe76073d6e8fd97ef4f4eca7b67f599660115591483572e406e165594"
 dependencies = [
  "bytes",
  "futures-core",
@@ -4738,11 +4776,11 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.9.11+spec-1.1.0"
+version = "0.9.10+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3afc9a848309fe1aaffaed6e1546a7a14de1f935dc9d89d32afd9a44bab7c46"
+checksum = "0825052159284a1a8b4d6c0c86cbc801f2da5afd2b225fa548c72f2e74002f48"
 dependencies = [
- "indexmap 2.13.0",
+ "indexmap 2.12.1",
  "serde_core",
  "serde_spanned",
  "toml_datetime",
@@ -4766,7 +4804,7 @@ version = "0.23.10+spec-1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "84c8b9f757e028cee9fa244aea147aab2a9ec09d5325a9b01e0a49730c2b5269"
 dependencies = [
- "indexmap 2.13.0",
+ "indexmap 2.12.1",
  "toml_datetime",
  "toml_parser",
  "winnow",
@@ -4835,7 +4873,7 @@ checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9"
 dependencies = [
  "futures-core",
  "futures-util",
- "indexmap 2.13.0",
+ "indexmap 2.12.1",
  "pin-project-lite",
  "slab",
  "sync_wrapper",
@@ -4998,9 +5036,9 @@ checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
 
 [[package]]
 name = "unicase"
-version = "2.9.0"
+version = "2.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
+checksum = "75b844d17643ee918803943289730bec8aac480150456169e647ed0b576ba539"
 
 [[package]]
 name = "unicode-ident"
@@ -5044,15 +5082,14 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
 [[package]]
 name = "url"
-version = "2.5.8"
+version = "2.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b"
 dependencies = [
  "form_urlencoded",
  "idna",
  "percent-encoding",
  "serde",
- "serde_derive",
 ]
 
 [[package]]
@@ -5254,9 +5291,9 @@ dependencies = [
 
 [[package]]
 name = "web-transport-proto"
-version = "0.3.1"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "660175a6d1643adb93b71c4f853d4f20f0fce47f53ae579afe9f7711fe84870d"
+checksum = "4b5400535d6dd4c07dc86e83651a838fd513de7f5011d4e4eafa239fa4d0ded4"
 dependencies = [
  "bytes",
  "http",
@@ -5267,19 +5304,19 @@ dependencies = [
 
 [[package]]
 name = "web-transport-quinn"
-version = "0.10.2"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f44b4e68a3e7adb790793e24ec8b5923a610a8c2df1d6cd58849f9e4759d04"
+checksum = "91815d3170c715230c94b5107a71ccf81646513e548ee1408c3ce285d021d6ca"
 dependencies = [
  "bytes",
  "futures",
  "http",
+ "log",
  "quinn",
  "rustls",
  "rustls-native-certs",
  "thiserror 2.0.17",
  "tokio",
- "tracing",
  "url",
  "web-transport-proto",
  "web-transport-trait",
@@ -5287,18 +5324,18 @@ dependencies = [
 
 [[package]]
 name = "web-transport-trait"
-version = "0.3.1"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ae5c857e6b426610648b39c6b48f9e66ae97b27b166d7c2f1ec369596548271"
+checksum = "8f4bafa8c6ff708042f67ef8031ca0f342822fd785b70f36a4b2c014760fc442"
 dependencies = [
  "bytes",
 ]
 
 [[package]]
 name = "web-transport-ws"
-version = "0.2.1"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cbd8d2d2a57b83ba70523e6a8df268a5bfe9f43aabba2d01b16389181f4a8ea"
+checksum = "7690a94b7f9e843f6b07be25a03bdec6356b909840b52961c249c0bd75df6564"
 dependencies = [
  "bytes",
  "futures",
@@ -5315,23 +5352,23 @@ version = "0.26.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "75c7f0ef91146ebfb530314f5f1d24528d7f0767efbfd31dce919275413e393e"
 dependencies = [
- "webpki-root-certs 1.0.5",
+ "webpki-root-certs 1.0.4",
 ]
 
 [[package]]
 name = "webpki-root-certs"
-version = "1.0.5"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36a29fc0408b113f68cf32637857ab740edfafdf460c326cd2afaa2d84cc05dc"
+checksum = "ee3e3b5f5e80bc89f30ce8d0343bf4e5f12341c51f3e26cbeecbc7c85443e85b"
 dependencies = [
  "rustls-pki-types",
 ]
 
 [[package]]
 name = "webpki-roots"
-version = "1.0.5"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12bed680863276c63889429bfd6cab3b99943659923822de1c8a39c49e4d722c"
+checksum = "b2878ef029c47c6e8cf779119f20fcf52bde7ad42a731b2a304bc221df17571e"
 dependencies = [
  "rustls-pki-types",
 ]
@@ -5919,18 +5956,18 @@ checksum = "2164e798d9e3d84ee2c91139ace54638059a3b23e361f5c11781c2c6459bde0f"
 
 [[package]]
 name = "zerocopy"
-version = "0.8.33"
+version = "0.8.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "668f5168d10b9ee831de31933dc111a459c97ec93225beb307aed970d1372dfd"
+checksum = "fd74ec98b9250adb3ca554bdde269adf631549f51d8a8f8f0a10b50f1cb298c3"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.33"
+version = "0.8.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c7962b26b0a8685668b671ee4b54d007a67d4eaf05fda79ac0ecf41e32270f1"
+checksum = "d8a8d209fdf45cf5138cbb5a506f6b52522a25afccc534d1475dad8e31105c6a"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -5969,9 +6006,9 @@ dependencies = [
 
 [[package]]
 name = "zeroize_derive"
-version = "1.4.3"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e"
+checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -6013,6 +6050,6 @@ dependencies = [
 
 [[package]]
 name = "zmij"
-version = "1.0.12"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fc5a66a20078bf1251bde995aa2fdcc4b800c70b5d92dd2c62abc5c60f679f8"
+checksum = "e6d6085d62852e35540689d1f97ad663e3971fc19cf5eceab364d62c646ea167"
diff --git a/js/clock/src/main.ts b/js/clock/src/main.ts
index e13db2af5..468ec7629 100755
--- a/js/clock/src/main.ts
+++ b/js/clock/src/main.ts
@@ -80,13 +80,13 @@ async function publish(config: Config) {
 
 	// Wait until we get a subscription for the track
 	for (;;) {
-		const request = await broadcast.requested();
-		if (!request) break;
+		const track = await broadcast.requested();
+		if (!track) break;
 
-		if (request.track.name === config.track) {
-			publishTrack(request.track);
+		if (track.name === config.track) {
+			publishTrack(track);
 		} else {
-			request.track.close(new Error("not found"));
+			track.close(new Error("not found"));
 		}
 	}
 }
@@ -103,7 +103,8 @@ async function publishTrack(track: Moq.Track) {
 
 		// Send the base timestamp (everything but seconds) - matching Rust format
 		const base = `${now.toISOString().slice(0, 16).replace("T", " ")}:`;
-		group.writeString(base);
+		const frame = Moq.Frame.fromString(base);
+		group.writeFrame(frame);
 
 		// Send individual seconds for this minute
 		const currentMinute = now.getMinutes();
@@ -112,7 +113,8 @@ async function publishTrack(track: Moq.Track) {
 			const secondsNow = new Date();
 			const seconds = secondsNow.getSeconds().toString().padStart(2, "0");
 
-			group.writeString(seconds);
+			const frame = Moq.Frame.fromString(seconds);
+			group.writeFrame(frame);
 
 			// Wait until next second
 			const nextSecond = new Date(secondsNow);
@@ -138,7 +140,7 @@ async function subscribe(config: Config) {
 	console.log("✅ Connected to relay:", config.url);
 
 	const broadcast = connection.consume(Moq.Path.from(config.broadcast));
-	const track = broadcast.subscribe(config.track, 0);
+	const track = broadcast.subscribe({ name: config.track });
 
 	console.log("✅ Subscribed to track:", config.track);
 
@@ -157,16 +159,16 @@ async function subscribe(config: Config) {
 			continue;
 		}
 
-		const base = new TextDecoder().decode(baseFrame);
+		const base = baseFrame.toString();
 
 		// Read individual second frames
 		for (;;) {
-			const frame = await group.readString();
+			const frame = await group.readFrame();
 			if (!frame) {
 				break; // End of group
 			}
 
-			const seconds = parseInt(frame, 10);
+			const seconds = parseInt(frame.toString(), 10);
 
 			// Clock emoji positions
 			const clockEmojis = ["🕛", "🕐", "🕑", "🕒", "🕓", "🕔", "🕕", "🕖", "🕗", "🕘", "🕙", "🕚"];
diff --git a/js/hang/src/catalog/audio.ts b/js/hang/src/catalog/audio.ts
index e57710bf2..6189b8608 100644
--- a/js/hang/src/catalog/audio.ts
+++ b/js/hang/src/catalog/audio.ts
@@ -1,12 +1,7 @@
 import { z } from "zod";
 import { ContainerSchema, DEFAULT_CONTAINER } from "./container";
 import { u53Schema } from "./integers";
-
-// Backwards compatibility: old track schema
-const TrackSchema = z.object({
-	name: z.string(),
-	priority: z.number().int().min(0).max(255),
-});
+import { TrackSchema } from "./track";
 
 // Mirrors AudioDecoderConfig
 // https://w3c.github.io/webcodecs/#audio-decoder-config
@@ -40,8 +35,9 @@ export const AudioSchema = z
 		// This is not an array so it will work with JSON Merge Patch.
 		renditions: z.record(z.string(), AudioConfigSchema),
 
-		// The priority of the audio track, relative to other tracks in the broadcast.
-		priority: z.number().int().min(0).max(255),
+		// DEPRECATED: The priority of the audio track, relative to other tracks in the broadcast.
+		// The subscriber is expected to choose its own priority, instead of being told.
+		priority: z.number().int().min(0).max(255).default(0),
 	})
 	.or(
 		// Backwards compatibility: transform old {track, config} format to new object format
diff --git a/js/hang/src/catalog/root.ts b/js/hang/src/catalog/root.ts
index 7c9684c3e..7cf6f1e4d 100644
--- a/js/hang/src/catalog/root.ts
+++ b/js/hang/src/catalog/root.ts
@@ -41,5 +41,5 @@ export function decode(raw: Uint8Array): Root {
 export async function fetch(track: Moq.Track): Promise<Root | undefined> {
 	const frame = await track.readFrame();
 	if (!frame) return undefined;
-	return decode(frame);
+	return decode(frame.payload);
 }
diff --git a/js/hang/src/catalog/track.ts b/js/hang/src/catalog/track.ts
index 7eb18e5ac..29fd12ea5 100644
--- a/js/hang/src/catalog/track.ts
+++ b/js/hang/src/catalog/track.ts
@@ -2,6 +2,8 @@ import { z } from "zod";
 
 export const TrackSchema = z.object({
 	name: z.string(),
-	priority: z.number().int().min(0).max(255),
+	// DEPRECATED: The priority of the track, relative to other tracks in the broadcast.
+	// The subscriber is supposed to choose its own priority, instead of being told.
+	priority: z.number().int().min(0).max(255).default(0),
 });
 export type Track = z.infer<typeof TrackSchema>;
diff --git a/js/hang/src/catalog/video.ts b/js/hang/src/catalog/video.ts
index b8b77883f..f6a20f7f2 100644
--- a/js/hang/src/catalog/video.ts
+++ b/js/hang/src/catalog/video.ts
@@ -1,12 +1,7 @@
 import { z } from "zod";
 import { ContainerSchema, DEFAULT_CONTAINER } from "./container";
 import { u53Schema } from "./integers";
-
-// Backwards compatibility: old track schema
-const TrackSchema = z.object({
-	name: z.string(),
-	priority: z.number().int().min(0).max(255),
-});
+import { TrackSchema } from "./track";
 
 // Based on VideoDecoderConfig
 export const VideoConfigSchema = z.object({
@@ -54,7 +49,8 @@ export const VideoSchema = z
 		renditions: z.record(z.string(), VideoConfigSchema),
 
 		// The priority of the video track, relative to other tracks in the broadcast.
-		priority: z.number().int().min(0).max(255),
+		// TODO: Remove this; it's for backwards compatibility only
+		priority: z.number().int().min(0).max(255).default(0),
 
 		// Render the video at this size in pixels.
 		// This is separate from the display aspect ratio because it does not require reinitialization.
diff --git a/js/hang/src/frame.ts b/js/hang/src/frame.ts
index a0fd86219..6fac8639c 100644
--- a/js/hang/src/frame.ts
+++ b/js/hang/src/frame.ts
@@ -1,4 +1,4 @@
-import type * as Moq from "@moq/lite";
+import * as Moq from "@moq/lite";
 import { Time } from "@moq/lite";
 import { Effect, Signal } from "@moq/signals";
 import type * as Catalog from "./catalog";
@@ -16,8 +16,9 @@ export interface Frame {
 	group: number;
 }
 
-export function encode(source: Uint8Array | Source, timestamp: Time.Micro, container?: Catalog.Container): Uint8Array {
+export function encode(source: Uint8Array | Source, timestamp: Time.Micro, container?: Catalog.Container): Moq.Frame {
 	// Encode timestamp using the specified container format
+	// TODO This should be delta encoded, not the full timestamp.
 	const timestampBytes = Container.encodeTimestamp(timestamp, container);
 
 	// Allocate buffer for timestamp + payload
@@ -34,14 +35,18 @@ export function encode(source: Uint8Array | Source, timestamp: Time.Micro, conta
 		source.copyTo(data.subarray(timestampBytes.byteLength));
 	}
 
-	return data;
+	// NOTE: We encode the timestamp into the MoQ layer as well, but in milliseconds.
+	// TODO: Once this is widespread enough, we should use it at least as the base.
+	return new Moq.Frame({ payload: data, instant: Time.Milli.fromMicro(timestamp) });
 }
 
 // NOTE: A keyframe is always the first frame in a group, so it's not encoded on the wire.
-export function decode(buffer: Uint8Array, container?: Catalog.Container): { data: Uint8Array; timestamp: Time.Micro } {
+export function decode(frame: Moq.Frame, container?: Catalog.Container): { data: Uint8Array; timestamp: Time.Micro } {
 	// Decode timestamp using the specified container format
-	const [timestamp, data] = Container.decodeTimestamp(buffer, container);
-	return { timestamp: timestamp as Time.Micro, data };
+	// TODO This should be delta encoded, not the full timestamp.
+	// TODO: Use frame.instant to avoid double encoding the timestamp.
+	const [timestamp, data] = Container.decodeTimestamp(frame.payload, container);
+	return { timestamp, data };
 }
 
 export class Producer {
diff --git a/js/hang/src/publish/priority.ts b/js/hang/src/priority.ts
similarity index 100%
rename from js/hang/src/publish/priority.ts
rename to js/hang/src/priority.ts
diff --git a/js/hang/src/publish/audio/encoder.ts b/js/hang/src/publish/audio/encoder.ts
index a19e096f0..9587621f0 100644
--- a/js/hang/src/publish/audio/encoder.ts
+++ b/js/hang/src/publish/audio/encoder.ts
@@ -5,8 +5,8 @@ import type * as Catalog from "../../catalog";
 import { DEFAULT_CONTAINER } from "../../catalog";
 import { u53 } from "../../catalog/integers";
 import * as Frame from "../../frame";
+import { PRIORITY } from "../../priority";
 import * as libav from "../../util/libav";
-import { PRIORITY } from "../priority";
 import type * as Capture from "./capture";
 import type { Source } from "./types";
 
diff --git a/js/hang/src/publish/broadcast.ts b/js/hang/src/publish/broadcast.ts
index b152fb3d5..fc07f4201 100644
--- a/js/hang/src/publish/broadcast.ts
+++ b/js/hang/src/publish/broadcast.ts
@@ -72,45 +72,43 @@ export class Broadcast {
 
 	async #runBroadcast(broadcast: Moq.Broadcast, effect: Effect) {
 		for (;;) {
-			const request = await broadcast.requested();
-			if (!request) break;
+			const track = await broadcast.requested();
+			if (!track) break;
 
-			effect.cleanup(() => request.track.close());
+			effect.cleanup(() => track.close());
 
 			effect.effect((effect) => {
-				if (effect.get(request.track.state.closed)) return;
-
-				switch (request.track.name) {
+				switch (track.name) {
 					case Broadcast.CATALOG_TRACK:
-						this.#serveCatalog(request.track, effect);
+						this.#serveCatalog(track, effect);
 						break;
 					case Location.Window.TRACK:
-						this.location.window.serve(request.track, effect);
+						this.location.window.serve(track, effect);
 						break;
 					case Location.Peers.TRACK:
-						this.location.peers.serve(request.track, effect);
+						this.location.peers.serve(track, effect);
 						break;
 					case Preview.TRACK:
-						this.preview.serve(request.track, effect);
+						this.preview.serve(track, effect);
 						break;
 					case Chat.Typing.TRACK:
-						this.chat.typing.serve(request.track, effect);
+						this.chat.typing.serve(track, effect);
 						break;
 					case Chat.Message.TRACK:
-						this.chat.message.serve(request.track, effect);
+						this.chat.message.serve(track, effect);
 						break;
 					case Audio.Encoder.TRACK:
-						this.audio.serve(request.track, effect);
+						this.audio.serve(track, effect);
 						break;
 					case Video.Root.TRACK_HD:
-						this.video.hd.serve(request.track, effect);
+						this.video.hd.serve(track, effect);
 						break;
 					case Video.Root.TRACK_SD:
-						this.video.sd.serve(request.track, effect);
+						this.video.sd.serve(track, effect);
 						break;
 					default:
-						console.error("received subscription for unknown track", request.track.name);
-						request.track.close(new Error(`Unknown track: ${request.track.name}`));
+						console.error("received subscription for unknown track", track.name);
+						track.close(new Error(`Unknown track: ${track.name}`));
 						break;
 				}
 			});
@@ -120,7 +118,8 @@ export class Broadcast {
 	#serveCatalog(track: Moq.Track, effect: Effect): void {
 		if (!effect.get(this.enabled)) {
 			// Clear the catalog.
-			track.writeFrame(Catalog.encode({}));
+			const frame = new Moq.Frame({ payload: Catalog.encode({}) });
+			track.writeFrame(frame);
 			return;
 		}
 
@@ -134,8 +133,8 @@ export class Broadcast {
 			preview: effect.get(this.preview.catalog),
 		};
 
-		const encoded = Catalog.encode(catalog);
-		track.writeFrame(encoded);
+		const frame = new Moq.Frame({ payload: Catalog.encode(catalog) });
+		track.writeFrame(frame);
 	}
 
 	close() {
diff --git a/js/hang/src/publish/chat/message.ts b/js/hang/src/publish/chat/message.ts
index 343f715ef..c3c07bddd 100644
--- a/js/hang/src/publish/chat/message.ts
+++ b/js/hang/src/publish/chat/message.ts
@@ -1,7 +1,7 @@
-import type * as Moq from "@moq/lite";
+import * as Moq from "@moq/lite";
 import { Effect, Signal } from "@moq/signals";
 import type * as Catalog from "../../catalog";
-import { PRIORITY } from "../priority";
+import { PRIORITY } from "../../priority";
 
 export type MessageProps = {
 	enabled?: boolean | Signal<boolean>;
@@ -37,7 +37,8 @@ export class Message {
 		if (!enabled) return;
 
 		const latest = effect.get(this.latest);
-		track.writeString(latest ?? "");
+		const frame = Moq.Frame.fromString(latest ?? "");
+		track.writeFrame(frame);
 	}
 
 	close() {
diff --git a/js/hang/src/publish/chat/typing.ts b/js/hang/src/publish/chat/typing.ts
index 419ad56cf..7d0af2b75 100644
--- a/js/hang/src/publish/chat/typing.ts
+++ b/js/hang/src/publish/chat/typing.ts
@@ -1,7 +1,7 @@
-import type * as Moq from "@moq/lite";
+import * as Moq from "@moq/lite";
 import { Effect, Signal } from "@moq/signals";
 import type * as Catalog from "../../catalog";
-import { PRIORITY } from "../priority";
+import { PRIORITY } from "../../priority";
 
 export type TypingProps = {
 	enabled?: boolean | Signal<boolean>;
@@ -37,7 +37,8 @@ export class Typing {
 		if (!enabled) return;
 
 		const active = effect.get(this.active);
-		track.writeBool(active);
+		const frame = Moq.Frame.fromBool(active);
+		track.writeFrame(frame);
 	}
 
 	close() {
diff --git a/js/hang/src/publish/location/peers.ts b/js/hang/src/publish/location/peers.ts
index 9811431ac..3bfc2f281 100644
--- a/js/hang/src/publish/location/peers.ts
+++ b/js/hang/src/publish/location/peers.ts
@@ -2,7 +2,7 @@ import type * as Moq from "@moq/lite";
 import * as Zod from "@moq/lite/zod";
 import { Effect, Signal } from "@moq/signals";
 import * as Catalog from "../../catalog";
-import { PRIORITY } from "../priority";
+import { PRIORITY } from "../../priority";
 
 export interface PeersProps {
 	enabled?: boolean | Signal<boolean>;
diff --git a/js/hang/src/publish/location/window.ts b/js/hang/src/publish/location/window.ts
index dd72bbe02..0a9574b5e 100644
--- a/js/hang/src/publish/location/window.ts
+++ b/js/hang/src/publish/location/window.ts
@@ -2,7 +2,7 @@ import type * as Moq from "@moq/lite";
 import * as Zod from "@moq/lite/zod";
 import { Effect, Signal } from "@moq/signals";
 import * as Catalog from "../../catalog";
-import { PRIORITY } from "../priority";
+import { PRIORITY } from "../../priority";
 
 export type WindowProps = {
 	// If true, then we'll publish our position to the broadcast.
diff --git a/js/hang/src/publish/preview.ts b/js/hang/src/publish/preview.ts
index 91df96d1f..22909884b 100644
--- a/js/hang/src/publish/preview.ts
+++ b/js/hang/src/publish/preview.ts
@@ -1,7 +1,7 @@
-import type * as Moq from "@moq/lite";
+import * as Moq from "@moq/lite";
 import { Effect, Signal } from "@moq/signals";
 import type * as Catalog from "../catalog";
-import { PRIORITY } from "./priority";
+import { PRIORITY } from "../priority";
 
 export type PreviewProps = {
 	enabled?: boolean | Signal<boolean>;
@@ -35,7 +35,8 @@ export class Preview {
 		const info = effect.get(this.info);
 		if (!info) return;
 
-		track.writeJson(info);
+		const frame = Moq.Frame.fromJson(info);
+		track.writeFrame(frame);
 	}
 
 	close() {
diff --git a/js/hang/src/publish/video/index.ts b/js/hang/src/publish/video/index.ts
index 18c838891..c8f07b950 100644
--- a/js/hang/src/publish/video/index.ts
+++ b/js/hang/src/publish/video/index.ts
@@ -1,6 +1,6 @@
 import { Effect, Signal } from "@moq/signals";
 import * as Catalog from "../../catalog";
-import { PRIORITY } from "../priority";
+import { PRIORITY } from "../../priority";
 import { Encoder, type EncoderProps } from "./encoder";
 import { TrackProcessor } from "./polyfill";
 import type { Source } from "./types";
diff --git a/js/hang/src/watch/audio/source.ts b/js/hang/src/watch/audio/source.ts
index fad996840..d3bb721e9 100644
--- a/js/hang/src/watch/audio/source.ts
+++ b/js/hang/src/watch/audio/source.ts
@@ -3,6 +3,7 @@ import type { Time } from "@moq/lite";
 import { Effect, type Getter, Signal } from "@moq/signals";
 import type * as Catalog from "../../catalog";
 import * as Frame from "../../frame";
+import { PRIORITY } from "../../priority";
 import * as Hex from "../../util/hex";
 import * as libav from "../../util/libav";
 import type * as Render from "./render";
@@ -163,7 +164,7 @@ export class Source {
 		const active = effect.get(this.active);
 		if (!active) return;
 
-		const sub = broadcast.subscribe(active, catalog.priority);
+		const sub = broadcast.subscribe({ name: active, priority: PRIORITY.audio, maxLatency: this.latency });
 		effect.cleanup(() => sub.close());
 
 		// Create consumer with slightly less latency than the render worklet to avoid underflowing.
diff --git a/js/hang/src/watch/broadcast.ts b/js/hang/src/watch/broadcast.ts
index c8fe30a1a..104dfc962 100644
--- a/js/hang/src/watch/broadcast.ts
+++ b/js/hang/src/watch/broadcast.ts
@@ -1,7 +1,7 @@
 import type * as Moq from "@moq/lite";
 import { Effect, type Getter, Signal } from "@moq/signals";
 import * as Catalog from "../catalog";
-import { PRIORITY } from "../publish/priority";
+import { PRIORITY } from "../priority";
 import * as Audio from "./audio";
 import { Chat, type ChatProps } from "./chat";
 import * as Location from "./location";
@@ -101,7 +101,6 @@ export class Broadcast {
 
 				// Require full equality
 				if (update.path !== path) {
-					console.warn("ignoring announce", update.path);
 					continue;
 				}
 
@@ -131,7 +130,7 @@ export class Broadcast {
 
 		this.status.set("loading");
 
-		const catalog = broadcast.subscribe("catalog.json", PRIORITY.catalog);
+		const catalog = broadcast.subscribe({ name: "catalog.json", priority: PRIORITY.catalog });
 		effect.cleanup(() => catalog.close());
 
 		effect.spawn(this.#fetchCatalog.bind(this, catalog));
diff --git a/js/hang/src/watch/chat/message.ts b/js/hang/src/watch/chat/message.ts
index a4d5e5417..0b0f99e50 100644
--- a/js/hang/src/watch/chat/message.ts
+++ b/js/hang/src/watch/chat/message.ts
@@ -1,6 +1,7 @@
 import type * as Moq from "@moq/lite";
 import { Effect, type Getter, Signal } from "@moq/signals";
 import type * as Catalog from "../../catalog";
+import { PRIORITY } from "../../priority";
 
 export interface MessageProps {
 	// Whether to start downloading the chat.
@@ -47,7 +48,7 @@ export class Message {
 		const broadcast = effect.get(this.broadcast);
 		if (!broadcast) return;
 
-		const track = broadcast.subscribe(catalog.name, catalog.priority);
+		const track = broadcast.subscribe({ name: catalog.name, priority: PRIORITY.chat });
 		effect.cleanup(() => track.close());
 
 		// Undefined is only when we're not subscribed to the track.
@@ -56,11 +57,11 @@ export class Message {
 
 		effect.spawn(async () => {
 			for (;;) {
-				const frame = await track.readString();
+				const frame = await track.readFrame();
 				if (frame === undefined) break;
 
 				// Use a function to avoid the dequal check.
-				this.#latest.set(frame);
+				this.#latest.set(frame.toString());
 			}
 		});
 	}
diff --git a/js/hang/src/watch/chat/typing.ts b/js/hang/src/watch/chat/typing.ts
index 39139d582..32d0df91c 100644
--- a/js/hang/src/watch/chat/typing.ts
+++ b/js/hang/src/watch/chat/typing.ts
@@ -1,6 +1,7 @@
 import type * as Moq from "@moq/lite";
 import { Effect, type Getter, Signal } from "@moq/signals";
 import type * as Catalog from "../../catalog";
+import { PRIORITY } from "../../priority";
 
 export interface TypingProps {
 	// Whether to start downloading the chat.
@@ -45,15 +46,15 @@ export class Typing {
 		const broadcast = effect.get(this.broadcast);
 		if (!broadcast) return;
 
-		const track = broadcast.subscribe(catalog.name, catalog.priority);
+		const track = broadcast.subscribe({ name: catalog.name, priority: PRIORITY.typing });
 		effect.cleanup(() => track.close());
 
 		effect.spawn(async () => {
 			for (;;) {
-				const value = await track.readBool();
-				if (value === undefined) break;
+				const frame = await track.readFrame();
+				if (frame === undefined) break;
 
-				this.active.set(value);
+				this.active.set(frame.toBool());
 			}
 		});
 
diff --git a/js/hang/src/watch/location/peers.ts b/js/hang/src/watch/location/peers.ts
index 56acbbdce..c8806a1cf 100644
--- a/js/hang/src/watch/location/peers.ts
+++ b/js/hang/src/watch/location/peers.ts
@@ -2,6 +2,7 @@ import type * as Moq from "@moq/lite";
 import * as Zod from "@moq/lite/zod";
 import { Effect, type Getter, Signal } from "@moq/signals";
 import * as Catalog from "../../catalog";
+import { PRIORITY } from "../../priority";
 
 export interface PeersProps {
 	enabled?: boolean | Signal<boolean>;
@@ -41,7 +42,7 @@ export class Peers {
 		const broadcast = effect.get(this.broadcast);
 		if (!broadcast) return;
 
-		const track = broadcast.subscribe(catalog.name, catalog.priority);
+		const track = broadcast.subscribe({ name: catalog.name, priority: PRIORITY.location });
 		effect.cleanup(() => track.close());
 
 		effect.spawn(this.#runTrack.bind(this, track));
diff --git a/js/hang/src/watch/location/window.ts b/js/hang/src/watch/location/window.ts
index 79b7c53d2..2db6e1a01 100644
--- a/js/hang/src/watch/location/window.ts
+++ b/js/hang/src/watch/location/window.ts
@@ -2,6 +2,7 @@ import type * as Moq from "@moq/lite";
 import * as Zod from "@moq/lite/zod";
 import { Effect, type Getter, Signal } from "@moq/signals";
 import * as Catalog from "../../catalog";
+import { PRIORITY } from "../../priority";
 
 export interface WindowProps {
 	enabled?: boolean | Signal<boolean>;
@@ -50,7 +51,7 @@ export class Window {
 			const updates = effect.get(this.#catalog)?.track;
 			if (!updates) return;
 
-			const track = broadcast.subscribe(updates.name, updates.priority);
+			const track = broadcast.subscribe({ name: updates.name, priority: PRIORITY.location });
 			effect.cleanup(() => track.close());
 
 			effect.spawn(this.#runTrack.bind(this, track));
diff --git a/js/hang/src/watch/preview.ts b/js/hang/src/watch/preview.ts
index bfa0bf523..8558dbd52 100644
--- a/js/hang/src/watch/preview.ts
+++ b/js/hang/src/watch/preview.ts
@@ -2,6 +2,7 @@ import type * as Moq from "@moq/lite";
 import * as Zod from "@moq/lite/zod";
 import { Effect, Signal } from "@moq/signals";
 import * as Catalog from "../catalog";
+import { PRIORITY } from "../priority";
 
 export interface PreviewProps {
 	enabled?: boolean | Signal<boolean>;
@@ -37,7 +38,8 @@ export class Preview {
 			if (!catalog) return;
 
 			// Subscribe to the preview.json track directly
-			const track = broadcast.subscribe(catalog.name, catalog.priority);
+			// TODO maxLatency
+			const track = broadcast.subscribe({ name: catalog.name, priority: PRIORITY.preview });
 			effect.cleanup(() => track.close());
 
 			effect.spawn(async () => {
diff --git a/js/hang/src/watch/video/source.ts b/js/hang/src/watch/video/source.ts
index 406a600bb..f53087795 100644
--- a/js/hang/src/watch/video/source.ts
+++ b/js/hang/src/watch/video/source.ts
@@ -3,7 +3,7 @@ import type { Time } from "@moq/lite";
 import { Effect, type Getter, Signal } from "@moq/signals";
 import type * as Catalog from "../../catalog";
 import * as Frame from "../../frame";
-import { PRIORITY } from "../../publish/priority";
+import { PRIORITY } from "../../priority";
 import * as Hex from "../../util/hex";
 
 export type SourceProps = {
@@ -192,7 +192,11 @@ export class Source {
 	}
 
 	#runTrack(effect: Effect, broadcast: Moq.Broadcast, name: string, config: RequiredDecoderConfig): void {
-		const sub = broadcast.subscribe(name, PRIORITY.video); // TODO use priority from catalog
+		const sub = broadcast.subscribe({
+			name: name,
+			priority: PRIORITY.video,
+			maxLatency: this.latency,
+		}); // TODO use priority from catalog
 		effect.cleanup(() => sub.close());
 
 		// Create consumer that reorders groups/frames up to the provided latency.
diff --git a/js/lite/examples/publish.ts b/js/lite/examples/publish.ts
index ffd345059..296c07d21 100644
--- a/js/lite/examples/publish.ts
+++ b/js/lite/examples/publish.ts
@@ -13,15 +13,15 @@ async function main() {
 
 	// Wait for subscription requests
 	for (;;) {
-		const request = await broadcast.requested();
-		if (!request) break;
+		const track = await broadcast.requested();
+		if (!track) break;
 
 		// Accept the request for the "chat" track
-		if (request.track.name === "chat") {
-			publishTrack(request.track);
+		if (track.name === "chat") {
+			publishTrack(track);
 		} else {
 			// Reject other tracks
-			request.track.close(new Error("track not found"));
+			track.close(new Error("track not found"));
 		}
 	}
 }
@@ -32,10 +32,9 @@ async function publishTrack(track: Moq.Track) {
 	// Create a group (e.g., keyframe boundary)
 	const group = track.appendGroup();
 
-	// Write two frames to the group
-	for (const frame of ["Hello", "MoQ!"]) {
-		group.writeString(frame);
-	}
+	// Write frames to the group
+	const frame = Moq.Frame.fromString("Hello, MoQ!");
+	group.writeFrame(frame);
 
 	// Mark the group as complete
 	group.close();
diff --git a/js/lite/examples/subscribe.ts b/js/lite/examples/subscribe.ts
index e294fdd6a..a675b1a79 100644
--- a/js/lite/examples/subscribe.ts
+++ b/js/lite/examples/subscribe.ts
@@ -7,8 +7,8 @@ async function main() {
 	// Subscribe to a broadcast
 	const broadcast = connection.consume(Moq.Path.from("my-broadcast"));
 
-	// Subscribe to a specific track (with priority 0)
-	const track = broadcast.subscribe("chat", 0);
+	// Subscribe to a specific track
+	const track = broadcast.subscribe({ name: "chat" });
 
 	// Read data as it arrives
 	for (;;) {
@@ -16,10 +16,10 @@ async function main() {
 		if (!group) break;
 
 		for (;;) {
-			const frame = await group.readString();
+			const frame = await group.readFrame();
 			if (!frame) break;
 
-			console.log("Received:", frame);
+			console.log("Received:", frame.toString());
 		}
 	}
 
diff --git a/js/lite/src/broadcast.ts b/js/lite/src/broadcast.ts
index f3e13805f..fd48e3a81 100644
--- a/js/lite/src/broadcast.ts
+++ b/js/lite/src/broadcast.ts
@@ -1,15 +1,5 @@
 import { Signal } from "@moq/signals";
-import { Track } from "./track.ts";
-
-export interface TrackRequest {
-	track: Track;
-	priority: number;
-}
-
-export class BroadcastState {
-	requested = new Signal<TrackRequest[]>([]);
-	closed = new Signal<boolean | Error>(false);
-}
+import { Track, type TrackProps } from "./track.js";
 
 /**
  * Handles writing and managing tracks in a broadcast.
@@ -17,13 +7,14 @@ export class BroadcastState {
  * @public
  */
 export class Broadcast {
-	state = new BroadcastState();
+	#requested = new Signal<Track[]>([]);
+	#closed = new Signal<boolean | Error>(false);
 
 	readonly closed: Promise<Error | undefined>;
 
 	constructor() {
 		this.closed = new Promise((resolve) => {
-			const dispose = this.state.closed.subscribe((closed) => {
+			const dispose = this.#closed.subscribe((closed) => {
 				if (!closed) return;
 				resolve(closed instanceof Error ? closed : undefined);
 				dispose();
@@ -34,33 +25,38 @@ export class Broadcast {
 	/**
 	 * A track requested over the network.
 	 */
-	async requested(): Promise<TrackRequest | undefined> {
+	async requested(): Promise<Track | undefined> {
 		for (;;) {
 			// We use pop instead of shift because it's slightly more efficient.
-			const track = this.state.requested.peek().pop();
+			const track = this.#requested.peek().pop();
 			if (track) return track;
 
-			const closed = this.state.closed.peek();
+			const closed = this.#closed.peek();
 			if (closed instanceof Error) throw closed;
 			if (closed) return undefined;
 
-			await Signal.race(this.state.requested, this.state.closed);
+			await Signal.race(this.#requested, this.#closed);
 		}
 	}
 
 	/**
-	 * Populates the provided track over the network.
+	 * Creates a new track and serves it over the network.
 	 */
-	subscribe(name: string, priority: number): Track {
-		const track = new Track(name);
+	subscribe(track: TrackProps): Track {
+		const t = new Track(track);
+		this.serve(t);
+		return t;
+	}
 
-		if (this.state.closed.peek()) {
-			throw new Error(`broadcast is closed: ${this.state.closed.peek()}`);
+	/**
+	 * Populates the provided track over the network.
+	 */
+	serve(track: Track) {
+		if (this.#closed.peek()) {
+			throw new Error(`broadcast is closed: ${this.#closed.peek()}`);
 		}
-		this.state.requested.mutate((requested) => {
-			requested.push({ track, priority });
-			// Sort the tracks by priority in ascending order (we will pop)
-			requested.sort((a, b) => a.priority - b.priority);
+		this.#requested.mutate((requested) => {
+			requested.push(track);
 		});
 
 		return track;
@@ -72,11 +68,11 @@ export class Broadcast {
 	 * @param abort - If provided, throw this exception instead of returning undefined.
 	 */
 	close(abort?: Error) {
-		this.state.closed.set(abort ?? true);
-		for (const { track } of this.state.requested.peek()) {
+		this.#closed.set(abort ?? true);
+		for (const track of this.#requested.peek()) {
 			track.close(abort);
 		}
-		this.state.requested.mutate((requested) => {
+		this.#requested.mutate((requested) => {
 			requested.length = 0;
 		});
 	}
diff --git a/js/lite/src/connection/connect.ts b/js/lite/src/connection/connect.ts
index 3bf642d1e..9708d483e 100644
--- a/js/lite/src/connection/connect.ts
+++ b/js/lite/src/connection/connect.ts
@@ -2,9 +2,12 @@ import WebTransportWs from "@moq/web-transport-ws";
 import * as Ietf from "../ietf/index.ts";
 import * as Lite from "../lite/index.ts";
 import { Stream } from "../stream.ts";
+import type * as Time from "../time.ts";
 import * as Hex from "../util/hex.ts";
 import type { Established } from "./established.ts";
 
+const SUPPORTED = [Lite.Version.DRAFT_03, Lite.Version.DRAFT_02, Lite.Version.DRAFT_01, Ietf.Version.DRAFT_14];
+
 export interface WebSocketOptions {
 	// If true (default), enable the WebSocket fallback.
 	enabled?: boolean;
@@ -13,9 +16,9 @@ export interface WebSocketOptions {
 	// By default, `https` => `wss` and `http` => `ws`.
 	url?: URL;
 
-	// The delay in milliseconds before attempting the WebSocket fallback. (default: 200)
+	// The delay in milliseconds before attempting the WebSocket fallback. (default: 500)
 	// If WebSocket won the previous race for a given URL, this will be 0.
-	delay?: DOMHighResTimeStamp;
+	delay?: Time.Milli;
 }
 
 export interface ConnectProps {
@@ -44,9 +47,9 @@ export async function connect(url: URL, props?: ConnectProps): Promise<Establish
 
 	const webtransport = globalThis.WebTransport ? connectWebTransport(url, cancel, props?.webtransport) : undefined;
 
-	// Give QUIC a 200ms head start to connect before trying WebSocket, unless WebSocket has won in the past.
+	// Give QUIC a 500ms head start to connect before trying WebSocket, unless WebSocket has won in the past.
 	// NOTE that QUIC should be faster because it involves 1/2 fewer RTTs.
-	const headstart = !webtransport || websocketWon.has(url.toString()) ? 0 : (props?.websocket?.delay ?? 200);
+	const headstart = !webtransport || websocketWon.has(url.toString()) ? 0 : (props?.websocket?.delay ?? 500);
 	const websocket =
 		props?.websocket?.enabled !== false
 			? connectWebSocket(props?.websocket?.url ?? url, headstart, cancel)
@@ -82,7 +85,7 @@ export async function connect(url: URL, props?: ConnectProps): Promise<Establish
 	params.setVarint(Ietf.Parameter.MaxRequestId, 42069n); // Allow a ton of request IDs.
 	params.setBytes(Ietf.Parameter.Implementation, encoder.encode("moq-lite-js")); // Put the implementation name in the parameters.
 
-	const client = new Ietf.ClientSetup([Lite.Version.DRAFT_02, Lite.Version.DRAFT_01, Ietf.Version.DRAFT_14], params);
+	const client = new Ietf.ClientSetup(SUPPORTED, params);
 	console.debug(url.toString(), "sending client setup", client);
 	await client.encode(stream.writer);
 
diff --git a/js/lite/src/connection/reload.ts b/js/lite/src/connection/reload.ts
index 916589978..55389b681 100644
--- a/js/lite/src/connection/reload.ts
+++ b/js/lite/src/connection/reload.ts
@@ -1,11 +1,12 @@
 import { Effect, Signal } from "@moq/signals";
+import type * as Time from "../time.ts";
 import { type ConnectProps, connect, type WebSocketOptions } from "./connect.ts";
 import type { Established } from "./established.ts";
 
 export type ReloadDelay = {
 	// The delay in milliseconds before reconnecting.
 	// default: 1000
-	initial: DOMHighResTimeStamp;
+	initial: Time.Milli;
 
 	// The multiplier for the delay.
 	// default: 2
@@ -13,7 +14,7 @@ export type ReloadDelay = {
 
 	// The maximum delay in milliseconds.
 	// default: 30000
-	max: DOMHighResTimeStamp;
+	max: Time.Milli;
 };
 
 export type ReloadProps = ConnectProps & {
@@ -48,7 +49,7 @@ export class Reload {
 
 	signals = new Effect();
 
-	#delay: DOMHighResTimeStamp;
+	#delay: Time.Milli;
 
 	// Increased by 1 each time to trigger a reload.
 	#tick = new Signal(0);
@@ -56,7 +57,7 @@ export class Reload {
 	constructor(props?: ReloadProps) {
 		this.url = Signal.from(props?.url);
 		this.enabled = Signal.from(props?.enabled ?? false);
-		this.delay = props?.delay ?? { initial: 1000, multiplier: 2, max: 30000 };
+		this.delay = props?.delay ?? { initial: 1000 as Time.Milli, multiplier: 2, max: 30000 as Time.Milli };
 		this.webtransport = props?.webtransport;
 		this.websocket = props?.websocket;
 
@@ -103,7 +104,7 @@ export class Reload {
 				const tick = this.#tick.peek() + 1;
 				effect.timer(() => this.#tick.update((prev) => Math.max(prev, tick)), this.#delay);
 
-				this.#delay = Math.min(this.#delay * this.delay.multiplier, this.delay.max);
+				this.#delay = Math.min(this.#delay * this.delay.multiplier, this.delay.max) as Time.Milli;
 			}
 		});
 	}
diff --git a/js/lite/src/frame.ts b/js/lite/src/frame.ts
new file mode 100644
index 000000000..0a45ba98d
--- /dev/null
+++ b/js/lite/src/frame.ts
@@ -0,0 +1,38 @@
+import * as Time from "./time";
+
+export class Frame {
+	instant: Time.Milli;
+	payload: Uint8Array;
+
+	constructor({ payload, instant = Time.Milli.now() }: { payload: Uint8Array; instant?: Time.Milli }) {
+		this.instant = instant;
+		this.payload = payload;
+	}
+
+	static fromString(str: string, instant = Time.Milli.now()) {
+		return new Frame({ payload: new TextEncoder().encode(str), instant });
+	}
+
+	static fromJson(json: unknown, instant = Time.Milli.now()) {
+		return new Frame({ payload: new TextEncoder().encode(JSON.stringify(json)), instant });
+	}
+
+	static fromBool(bool: boolean, instant = Time.Milli.now()) {
+		return new Frame({ payload: new Uint8Array([bool ? 1 : 0]), instant });
+	}
+
+	toString() {
+		return new TextDecoder().decode(this.payload);
+	}
+
+	toJson() {
+		return JSON.parse(this.toString());
+	}
+
+	toBool() {
+		if (this.payload.byteLength !== 1) throw new Error("invalid bool frame");
+		if (this.payload[0] === 0) return false;
+		if (this.payload[0] === 1) return true;
+		throw new Error("invalid bool frame");
+	}
+}
diff --git a/js/lite/src/group.ts b/js/lite/src/group.ts
index 6aefa47c6..b271fea6e 100644
--- a/js/lite/src/group.ts
+++ b/js/lite/src/group.ts
@@ -1,7 +1,8 @@
 import { Signal } from "@moq/signals";
+import type { Frame } from "./frame";
 
 export class GroupState {
-	frames = new Signal<Uint8Array[]>([]);
+	frames = new Signal<Frame[]>([]);
 	closed = new Signal<boolean | Error>(false);
 	total = new Signal<number>(0); // The total number of frames in the group thus far
 }
@@ -29,7 +30,7 @@ export class Group {
 	 * Writes a frame to the group.
 	 * @param frame - The frame to write
 	 */
-	writeFrame(frame: Uint8Array) {
+	writeFrame(frame: Frame) {
 		if (this.state.closed.peek()) throw new Error("group is closed");
 
 		this.state.frames.mutate((frames) => {
@@ -39,23 +40,11 @@ export class Group {
 		this.state.total.update((total) => total + 1);
 	}
 
-	writeString(str: string) {
-		this.writeFrame(new TextEncoder().encode(str));
-	}
-
-	writeJson(json: unknown) {
-		this.writeString(JSON.stringify(json));
-	}
-
-	writeBool(bool: boolean) {
-		this.writeFrame(new Uint8Array([bool ? 1 : 0]));
-	}
-
 	/**
 	 * Reads the next frame from the group.
 	 * @returns A promise that resolves to the next frame or undefined
 	 */
-	async readFrame(): Promise<Uint8Array | undefined> {
+	async readFrame(): Promise<Frame | undefined> {
 		for (;;) {
 			const frames = this.state.frames.peek();
 			const frame = frames.shift();
@@ -69,11 +58,11 @@ export class Group {
 		}
 	}
 
-	async readFrameSequence(): Promise<{ sequence: number; data: Uint8Array } | undefined> {
+	async readFrameSequence(): Promise<{ sequence: number; frame: Frame } | undefined> {
 		for (;;) {
 			const frames = this.state.frames.peek();
 			const frame = frames.shift();
-			if (frame) return { sequence: this.state.total.peek() - frames.length - 1, data: frame };
+			if (frame) return { sequence: this.state.total.peek() - frames.length - 1, frame };
 
 			const closed = this.state.closed.peek();
 			if (closed instanceof Error) throw closed;
@@ -83,21 +72,6 @@ export class Group {
 		}
 	}
 
-	async readString(): Promise<string | undefined> {
-		const frame = await this.readFrame();
-		return frame ? new TextDecoder().decode(frame) : undefined;
-	}
-
-	async readJson(): Promise<unknown | undefined> {
-		const frame = await this.readString();
-		return frame ? JSON.parse(frame) : undefined;
-	}
-
-	async readBool(): Promise<boolean | undefined> {
-		const frame = await this.readFrame();
-		return frame ? frame[0] === 1 : undefined;
-	}
-
 	close(abort?: Error) {
 		this.state.closed.set(abort ?? true);
 	}
diff --git a/js/lite/src/ietf/publisher.ts b/js/lite/src/ietf/publisher.ts
index ab5031bea..1dd66e39c 100644
--- a/js/lite/src/ietf/publisher.ts
+++ b/js/lite/src/ietf/publisher.ts
@@ -2,10 +2,11 @@ import type { Broadcast } from "../broadcast.ts";
 import type { Group } from "../group.ts";
 import type * as Path from "../path.ts";
 import { Writer } from "../stream.ts";
-import type { Track } from "../track.ts";
+import type * as Time from "../time.ts";
+import { Track } from "../track.js";
 import { error } from "../util/error.ts";
 import type * as Control from "./control.ts";
-import { Frame, Group as GroupMessage } from "./object.ts";
+import { Frame as FrameMessage, Group as GroupMessage } from "./object.ts";
 import { PublishDone } from "./publish.ts";
 import {
 	PublishNamespace,
@@ -94,7 +95,12 @@ export class Publisher {
 			return;
 		}
 
-		const track = broadcast.subscribe(msg.trackName, msg.subscriberPriority);
+		const track = new Track({
+			name: msg.trackName,
+			priority: msg.subscriberPriority,
+			maxLatency: 100 as Time.Milli, // TODO delivery timeout
+		});
+		broadcast.serve(track);
 
 		// Send SUBSCRIBE_OK response on control stream
 		const okMsg = new SubscribeOk(msg.requestId, msg.requestId);
@@ -164,7 +170,8 @@ export class Publisher {
 					if (!frame) break;
 
 					// Write each frame as an object
-					const obj = new Frame(frame);
+					// TODO support timestamps
+					const obj = new FrameMessage(frame.payload);
 					await obj.encode(stream, header.flags);
 				}
 
diff --git a/js/lite/src/ietf/subscriber.ts b/js/lite/src/ietf/subscriber.ts
index 8d93f144a..9b2a72ca7 100644
--- a/js/lite/src/ietf/subscriber.ts
+++ b/js/lite/src/ietf/subscriber.ts
@@ -1,12 +1,13 @@
 import { Announced } from "../announced.ts";
-import { Broadcast, type TrackRequest } from "../broadcast.ts";
+import { Broadcast } from "../broadcast.ts";
+import { Frame } from "../frame.ts";
 import { Group } from "../group.ts";
 import * as Path from "../path.ts";
 import type { Reader } from "../stream.ts";
 import type { Track } from "../track.ts";
 import { error } from "../util/error.ts";
 import type * as Control from "./control.ts";
-import { Frame, type Group as GroupMessage } from "./object.ts";
+import { Frame as FrameMessage, type Group as GroupMessage } from "./object.ts";
 import { type Publish, type PublishDone, PublishError } from "./publish.ts";
 import type { PublishNamespace, PublishNamespaceDone } from "./publish_namespace.ts";
 import { Subscribe, type SubscribeError, type SubscribeOk, Unsubscribe } from "./subscribe.ts";
@@ -114,15 +115,15 @@ export class Subscriber {
 		return broadcast;
 	}
 
-	async #runSubscribe(broadcast: Path.Valid, request: TrackRequest) {
+	async #runSubscribe(broadcast: Path.Valid, track: Track) {
 		const requestId = await this.#control.nextRequestId();
 		if (requestId === undefined) return;
 
-		this.#subscribes.set(requestId, request.track);
+		this.#subscribes.set(requestId, track);
 
-		console.debug(`subscribe start: id=${requestId} broadcast=${broadcast} track=${request.track.name}`);
+		console.debug(`subscribe start: id=${requestId} broadcast=${broadcast} track=${track.name}`);
 
-		const msg = new Subscribe(requestId, broadcast, request.track.name, request.priority);
+		const msg = new Subscribe(requestId, broadcast, track.name, track.priority.peek());
 
 		// Send SUBSCRIBE message on control stream and wait for response
 		const responsePromise = new Promise<SubscribeOk>((resolve, reject) => {
@@ -134,23 +135,23 @@ export class Subscriber {
 		try {
 			const ok = await responsePromise;
 			this.#trackAliases.set(ok.trackAlias, requestId);
-			console.debug(`subscribe ok: id=${requestId} broadcast=${broadcast} track=${request.track.name}`);
+			console.debug(`subscribe ok: id=${requestId} broadcast=${broadcast} track=${track.name}`);
 
 			try {
-				await request.track.closed;
+				await track.closed;
 
 				const msg = new Unsubscribe(requestId);
 				await this.#control.write(msg);
-				console.debug(`unsubscribe: id=${requestId} broadcast=${broadcast} track=${request.track.name}`);
+				console.debug(`unsubscribe: id=${requestId} broadcast=${broadcast} track=${track.name}`);
 			} finally {
 				this.#trackAliases.delete(ok.trackAlias);
 			}
 		} catch (err) {
 			const e = error(err);
-			request.track.close(e);
+			track.close(e);
 
 			console.warn(
-				`subscribe error: id=${requestId} broadcast=${broadcast} track=${request.track.name} error=${e.message}`,
+				`subscribe error: id=${requestId} broadcast=${broadcast} track=${track.name} error=${e.message}`,
 			);
 		} finally {
 			this.#subscribes.delete(requestId);
@@ -225,11 +226,14 @@ export class Subscriber {
 				const done = await Promise.race([stream.done(), producer.closed, track.closed]);
 				if (done !== false) break;
 
-				const frame = await Frame.decode(stream, group.flags);
-				if (frame.payload === undefined) break;
+				const msg = await FrameMessage.decode(stream, group.flags);
+				if (msg.payload === undefined) break;
+
+				// TODO support timestamps
+				const frame = new Frame({ payload: msg.payload });
 
 				// Treat each object payload as a frame
-				producer.writeFrame(frame.payload);
+				producer.writeFrame(frame);
 			}
 
 			producer.close();
diff --git a/js/lite/src/index.ts b/js/lite/src/index.ts
index cf64a4705..21c947500 100644
--- a/js/lite/src/index.ts
+++ b/js/lite/src/index.ts
@@ -1,6 +1,7 @@
 export * from "./announced.ts";
 export * from "./broadcast.ts";
 export * as Connection from "./connection/index.ts";
+export * from "./frame.ts";
 export * from "./group.ts";
 export * as Path from "./path.ts";
 export * as Time from "./time.ts";
diff --git a/js/lite/src/lite/announce.ts b/js/lite/src/lite/announce.ts
index 3a5140f68..76e1b19b7 100644
--- a/js/lite/src/lite/announce.ts
+++ b/js/lite/src/lite/announce.ts
@@ -29,10 +29,6 @@ export class Announce {
 	static async decode(r: Reader): Promise<Announce> {
 		return Message.decode(r, Announce.#decode);
 	}
-
-	static async decodeMaybe(r: Reader): Promise<Announce | undefined> {
-		return Message.decodeMaybe(r, Announce.#decode);
-	}
 }
 
 export class AnnounceInterest {
diff --git a/js/lite/src/lite/connection.ts b/js/lite/src/lite/connection.ts
index a7ce8c922..f31f41fe6 100644
--- a/js/lite/src/lite/connection.ts
+++ b/js/lite/src/lite/connection.ts
@@ -125,10 +125,10 @@ export class Connection implements Established {
 	async #runSession() {
 		try {
 			// Receive messages until the connection is closed.
-			for (;;) {
-				const msg = await SessionInfo.decodeMaybe(this.#session.reader);
-				if (!msg) break;
-				// TODO use the session info
+			while (!(await this.#session.reader.done())) {
+				const msg = await SessionInfo.decode(this.#session.reader);
+				// TODO use SessionInfo
+				console.debug("session info", msg);
 			}
 		} finally {
 			console.warn("session stream closed");
@@ -162,7 +162,7 @@ export class Connection implements Established {
 			await this.#publisher.runAnnounce(msg, stream);
 			return;
 		} else if (typ === StreamId.Subscribe) {
-			const msg = await Subscribe.decode(stream.reader);
+			const msg = await Subscribe.decode(stream.reader, this.version);
 			await this.#publisher.runSubscribe(msg, stream);
 			return;
 		} else {
@@ -184,6 +184,7 @@ export class Connection implements Established {
 					stream.stop(new Error("cancel"));
 				})
 				.catch((err: unknown) => {
+					console.warn("error running uni stream", err);
 					stream.stop(err);
 				});
 		}
diff --git a/js/lite/src/lite/frame.ts b/js/lite/src/lite/frame.ts
new file mode 100644
index 000000000..9db31ddda
--- /dev/null
+++ b/js/lite/src/lite/frame.ts
@@ -0,0 +1,61 @@
+import type { Reader, Writer } from "../stream";
+import * as Time from "../time.ts";
+import * as Message from "./message.ts";
+import { Version } from "./version.js";
+
+export class Frame {
+	delta: Time.Milli;
+	payload: Uint8Array;
+
+	constructor({ payload, delta }: { delta: Time.Milli; payload: Uint8Array }) {
+		this.payload = payload;
+		this.delta = delta;
+	}
+
+	async #encode(w: Writer, version: Version) {
+		switch (version) {
+			case Version.DRAFT_03:
+				await w.u53(this.delta);
+				break;
+			case Version.DRAFT_01:
+			case Version.DRAFT_02:
+				break;
+			default: {
+				const v: never = version;
+				throw new Error(`unsupported version: ${v}`);
+			}
+		}
+
+		await w.write(this.payload);
+	}
+
+	static async #decode(r: Reader, version: Version): Promise<Frame> {
+		let delta: Time.Milli;
+
+		switch (version) {
+			case Version.DRAFT_03:
+				delta = (await r.u53()) as Time.Milli;
+				break;
+			case Version.DRAFT_01:
+			case Version.DRAFT_02:
+				// NOTE: The caller is responsible for calling Time.Milli.now()
+				delta = Time.Milli.zero;
+				break;
+			default: {
+				const v: never = version;
+				throw new Error(`unsupported version: ${v}`);
+			}
+		}
+
+		const payload = await r.readAll();
+		return new Frame({ delta, payload });
+	}
+
+	async encode(w: Writer, v: Version): Promise<void> {
+		return Message.encode(w, (w) => this.#encode(w, v));
+	}
+
+	static async decode(r: Reader, v: Version): Promise<Frame> {
+		return Message.decode(r, (r) => Frame.#decode(r, v));
+	}
+}
diff --git a/js/lite/src/lite/group.ts b/js/lite/src/lite/group.ts
index 9cbc8d358..9dae19c9f 100644
--- a/js/lite/src/lite/group.ts
+++ b/js/lite/src/lite/group.ts
@@ -26,10 +26,6 @@ export class Group {
 	static async decode(r: Reader): Promise<Group> {
 		return Message.decode(r, Group.#decode);
 	}
-
-	static async decodeMaybe(r: Reader): Promise<Group | undefined> {
-		return Message.decodeMaybe(r, Group.#decode);
-	}
 }
 
 export class GroupDrop {
@@ -60,33 +56,4 @@ export class GroupDrop {
 	static async decode(r: Reader): Promise<GroupDrop> {
 		return Message.decode(r, GroupDrop.#decode);
 	}
-
-	static async decodeMaybe(r: Reader): Promise<GroupDrop | undefined> {
-		return Message.decodeMaybe(r, GroupDrop.#decode);
-	}
-}
-
-export class Frame {
-	payload: Uint8Array;
-
-	constructor(payload: Uint8Array) {
-		this.payload = payload;
-	}
-
-	async #encode(w: Writer) {
-		await w.write(this.payload);
-	}
-
-	static async #decode(r: Reader): Promise<Frame> {
-		const payload = await r.readAll();
-		return new Frame(payload);
-	}
-
-	async encode(w: Writer): Promise<void> {
-		return Message.encode(w, this.#encode.bind(this));
-	}
-
-	static async decode(r: Reader): Promise<Frame> {
-		return Message.decode(r, Frame.#decode);
-	}
 }
diff --git a/js/lite/src/lite/message.ts b/js/lite/src/lite/message.ts
index 208f76f58..a05482223 100644
--- a/js/lite/src/lite/message.ts
+++ b/js/lite/src/lite/message.ts
@@ -52,8 +52,3 @@ export async function decode<T>(reader: Reader, f: (r: Reader) => Promise<T>): P
 
 	return msg;
 }
-
-export async function decodeMaybe<T>(reader: Reader, f: (r: Reader) => Promise<T>): Promise<T | undefined> {
-	if (await reader.done()) return;
-	return await decode(reader, f);
-}
diff --git a/js/lite/src/lite/publisher.ts b/js/lite/src/lite/publisher.ts
index 95ff646fe..f33f86e6c 100644
--- a/js/lite/src/lite/publisher.ts
+++ b/js/lite/src/lite/publisher.ts
@@ -3,9 +3,11 @@ import type { Broadcast } from "../broadcast.ts";
 import type { Group } from "../group.ts";
 import * as Path from "../path.ts";
 import { type Stream, Writer } from "../stream.ts";
-import type { Track } from "../track.ts";
+import * as Time from "../time.ts";
+import { Track } from "../track.js";
 import { error } from "../util/error.ts";
 import { Announce, AnnounceInit, type AnnounceInterest } from "./announce.ts";
+import { Frame as FrameMessage } from "./frame.ts";
 import { Group as GroupMessage } from "./group.ts";
 import { type Subscribe, SubscribeOk, SubscribeUpdate } from "./subscribe.ts";
 import type { Version } from "./version.ts";
@@ -138,26 +140,44 @@ export class Publisher {
 			return;
 		}
 
-		const track = broadcast.subscribe(msg.track, msg.priority);
+		const track = new Track({
+			name: msg.track,
+			priority: msg.priority,
+			maxLatency: msg.maxLatency,
+			ordered: msg.ordered,
+		});
+		broadcast.serve(track);
+
+		// When any of the properties are updated, send the SubscribeOk message
+		const sendOk = async () => {
+			const msg = new SubscribeOk({
+				priority: track.priority.peek(),
+				maxLatency: track.maxLatency.peek(),
+				ordered: track.ordered.peek(),
+			});
+			await msg.encode(stream.writer, this.version);
+		};
+
+		// TODO: There's no backpressure, so this could fail, but I hate javascript.
+		const dispose = track.priority.subscribe(sendOk);
+		const dispose2 = track.maxLatency.subscribe(sendOk);
+		const dispose3 = track.ordered.subscribe(sendOk);
 
 		try {
-			const info = new SubscribeOk({ version: this.version, priority: msg.priority });
-			await info.encode(stream.writer);
+			await sendOk();
 
 			console.debug(`publish ok: broadcast=${msg.broadcast} track=${track.name}`);
 
 			const serving = this.#runTrack(msg.id, msg.broadcast, track, stream.writer);
 
 			for (;;) {
-				const decode = SubscribeUpdate.decodeMaybe(stream.reader);
-
-				const result = await Promise.any([serving, decode]);
-				if (!result) break;
+				const done = await Promise.any([serving, stream.reader.done()]);
+				if (done) break;
 
-				if (result instanceof SubscribeUpdate) {
-					// TODO use the update
-					console.warn("subscribe update not supported", result);
-				}
+				const update = await SubscribeUpdate.decode(stream.reader, this.version);
+				track.priority.set(update.priority);
+				track.maxLatency.set(update.maxLatency);
+				track.ordered.set(update.ordered);
 			}
 
 			console.debug(`publish done: broadcast=${msg.broadcast} track=${track.name}`);
@@ -168,6 +188,10 @@ export class Publisher {
 			console.warn(`publish error: broadcast=${msg.broadcast} track=${track.name} error=${e.message}`);
 			track.close(e);
 			stream.abort(e);
+		} finally {
+			dispose();
+			dispose2();
+			dispose3();
 		}
 	}
 
@@ -218,13 +242,25 @@ export class Publisher {
 			await stream.u8(0); // stream type
 			await msg.encode(stream);
 
+			let instant = Time.Milli.zero;
+
 			try {
 				for (;;) {
 					const frame = await Promise.race([group.readFrame(), stream.closed]);
 					if (!frame) break;
 
-					await stream.u53(frame.byteLength);
-					await stream.write(frame);
+					let delta = (frame.instant - instant) as Time.Milli;
+					if (delta < 0) {
+						// TODO We either need to support this at the MoQ layer.
+						// Or we need to prevent this at the hang layer.
+						console.warn("MoQ timestamp went backwards");
+						delta = Time.Milli.zero;
+					} else {
+						instant = frame.instant;
+					}
+
+					const msg = new FrameMessage({ payload: frame.payload, delta });
+					await msg.encode(stream, this.version);
 				}
 
 				stream.close();
diff --git a/js/lite/src/lite/session.ts b/js/lite/src/lite/session.ts
index 55c7367ad..4394d2666 100644
--- a/js/lite/src/lite/session.ts
+++ b/js/lite/src/lite/session.ts
@@ -141,8 +141,4 @@ export class SessionInfo {
 	static async decode(r: Reader): Promise<SessionInfo> {
 		return Message.decode(r, SessionInfo.#decode);
 	}
-
-	static async decodeMaybe(r: Reader): Promise<SessionInfo | undefined> {
-		return Message.decodeMaybe(r, SessionInfo.#decode);
-	}
 }
diff --git a/js/lite/src/lite/subscribe.ts b/js/lite/src/lite/subscribe.ts
index 7f2c0a756..10dbbf4d7 100644
--- a/js/lite/src/lite/subscribe.ts
+++ b/js/lite/src/lite/subscribe.ts
@@ -1,34 +1,68 @@
 import * as Path from "../path.ts";
 import type { Reader, Writer } from "../stream.ts";
+import * as Time from "../time.ts";
 import * as Message from "./message.ts";
 import { Version } from "./version.ts";
 
 export class SubscribeUpdate {
 	priority: number;
+	ordered: boolean;
+	maxLatency: Time.Milli;
 
-	constructor(priority: number) {
+	constructor({ priority, maxLatency, ordered }: { priority: number; maxLatency: Time.Milli; ordered: boolean }) {
 		this.priority = priority;
+		this.maxLatency = maxLatency;
+		this.ordered = ordered;
+	}
+
+	async #encode(w: Writer, version: Version) {
+		switch (version) {
+			case Version.DRAFT_01:
+			case Version.DRAFT_02:
+				await w.u8(this.priority);
+				break;
+			case Version.DRAFT_03:
+				await w.u8(this.priority);
+				await w.bool(this.ordered);
+				await w.u53(this.maxLatency);
+				break;
+			default: {
+				const v: never = version;
+				throw new Error(`unsupported version: ${v}`);
+			}
+		}
 	}
 
-	async #encode(w: Writer) {
-		await w.u8(this.priority);
-	}
-
-	static async #decode(r: Reader): Promise<SubscribeUpdate> {
-		const priority = await r.u8();
-		return new SubscribeUpdate(priority);
-	}
+	static async #decode(r: Reader, version: Version): Promise<SubscribeUpdate> {
+		let priority: number;
+		let maxLatency = Time.Milli.zero;
+		let ordered = false;
+
+		switch (version) {
+			case Version.DRAFT_01:
+			case Version.DRAFT_02:
+				priority = await r.u8();
+				break;
+			case Version.DRAFT_03:
+				priority = await r.u8();
+				ordered = await r.bool();
+				maxLatency = (await r.u53()) as Time.Milli;
+				break;
+			default: {
+				const v: never = version;
+				throw new Error(`unsupported version: ${v}`);
+			}
+		}
 
-	async encode(w: Writer): Promise<void> {
-		return Message.encode(w, this.#encode.bind(this));
+		return new SubscribeUpdate({ priority, maxLatency, ordered });
 	}
 
-	static async decode(r: Reader): Promise<SubscribeUpdate> {
-		return Message.decode(r, SubscribeUpdate.#decode);
+	async encode(w: Writer, version: Version): Promise<void> {
+		return Message.encode(w, (w) => this.#encode(w, version));
 	}
 
-	static async decodeMaybe(r: Reader): Promise<SubscribeUpdate | undefined> {
-		return Message.decodeMaybe(r, SubscribeUpdate.#decode);
+	static async decode(r: Reader, version: Version): Promise<SubscribeUpdate> {
+		return Message.decode(r, (r) => SubscribeUpdate.#decode(r, version));
 	}
 }
 
@@ -37,78 +71,148 @@ export class Subscribe {
 	broadcast: Path.Valid;
 	track: string;
 	priority: number;
-
-	constructor(id: bigint, broadcast: Path.Valid, track: string, priority: number) {
+	ordered: boolean;
+	maxLatency: Time.Milli;
+
+	constructor({
+		id,
+		broadcast,
+		track,
+		priority,
+		ordered,
+		maxLatency,
+	}: {
+		id: bigint;
+		broadcast: Path.Valid;
+		track: string;
+		priority: number;
+		ordered: boolean;
+		maxLatency: Time.Milli;
+	}) {
 		this.id = id;
 		this.broadcast = broadcast;
 		this.track = track;
 		this.priority = priority;
+		this.ordered = ordered;
+		this.maxLatency = maxLatency;
 	}
 
-	async #encode(w: Writer) {
+	async #encode(w: Writer, version: Version) {
 		await w.u62(this.id);
 		await w.string(this.broadcast);
 		await w.string(this.track);
 		await w.u8(this.priority);
+
+		switch (version) {
+			case Version.DRAFT_03:
+				await w.bool(this.ordered);
+				await w.u53(this.maxLatency);
+				break;
+			case Version.DRAFT_01:
+			case Version.DRAFT_02:
+				break;
+			default: {
+				const v: never = version;
+				throw new Error(`unsupported version: ${v}`);
+			}
+		}
 	}
 
-	static async #decode(r: Reader): Promise<Subscribe> {
+	static async #decode(r: Reader, version: Version): Promise<Subscribe> {
 		const id = await r.u62();
 		const broadcast = Path.from(await r.string());
 		const track = await r.string();
 		const priority = await r.u8();
-		return new Subscribe(id, broadcast, track, priority);
+		let maxLatency = Time.Milli.zero;
+		let ordered = false;
+
+		switch (version) {
+			case Version.DRAFT_03:
+				ordered = await r.bool();
+				maxLatency = (await r.u53()) as Time.Milli;
+				break;
+			case Version.DRAFT_01:
+			case Version.DRAFT_02:
+				break;
+			default: {
+				const v: never = version;
+				throw new Error(`unsupported version: ${v}`);
+			}
+		}
+
+		return new Subscribe({ id, broadcast, track, priority, maxLatency, ordered });
 	}
 
-	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<Subscribe> {
-		return Message.decode(r, Subscribe.#decode);
+	static async decode(r: Reader, version: Version): Promise<Subscribe> {
+		return Message.decode(r, (r) => Subscribe.#decode(r, version));
 	}
 }
 
 export class SubscribeOk {
-	// The version
-	readonly version: Version;
-	priority?: number;
+	priority: number;
+	ordered: boolean;
+	maxLatency: Time.Milli;
 
-	constructor({ version, priority = undefined }: { version: Version; priority?: number }) {
-		this.version = version;
+	constructor({ priority, maxLatency, ordered }: { priority: number; maxLatency: Time.Milli; ordered: boolean }) {
 		this.priority = priority;
-	}
-
-	async #encode(w: Writer) {
-		if (this.version === Version.DRAFT_02) {
-			// noop
-		} else if (this.version === Version.DRAFT_01) {
-			await w.u8(this.priority ?? 0);
-		} else {
-			const version: never = this.version;
-			throw new Error(`unsupported version: ${version}`);
+		this.maxLatency = maxLatency;
+		this.ordered = ordered;
+	}
+
+	async #encode(version: Version, w: Writer) {
+		switch (version) {
+			case Version.DRAFT_01:
+				await w.u8(this.priority);
+				break;
+			case Version.DRAFT_02:
+				break;
+			case Version.DRAFT_03:
+				await w.u8(this.priority);
+				await w.bool(this.ordered);
+				await w.u53(this.maxLatency);
+				break;
+			default: {
+				const v: never = version;
+				throw new Error(`unsupported version: ${v}`);
+			}
 		}
 	}
 
 	static async #decode(version: Version, r: Reader): Promise<SubscribeOk> {
-		let priority: number | undefined;
-		if (version === Version.DRAFT_02) {
-			// noop
-		} else if (version === Version.DRAFT_01) {
-			priority = await r.u8();
-		} else {
-			const v: never = version;
-			throw new Error(`unsupported version: ${v}`);
+		let priority = 0;
+		let ordered = false;
+		let maxLatency = Time.Milli.zero;
+
+		switch (version) {
+			case Version.DRAFT_01:
+				priority = await r.u8();
+				break;
+			case Version.DRAFT_02:
+				// noop
+				break;
+			case Version.DRAFT_03:
+				priority = await r.u8();
+				ordered = await r.bool();
+				maxLatency = (await r.u53()) as Time.Milli;
+				break;
+			default: {
+				const v: never = version;
+				throw new Error(`unsupported version: ${v}`);
+			}
 		}
 
-		return new SubscribeOk({ version, priority });
+		return new SubscribeOk({ priority, maxLatency, ordered });
 	}
 
-	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, this.#encode.bind(this, version));
 	}
 
 	static async decode(r: Reader, version: Version): Promise<SubscribeOk> {
-		return Message.decode(r, SubscribeOk.#decode.bind(SubscribeOk, version));
+		return Message.decode(r, (r) => SubscribeOk.#decode(version, r));
 	}
 }
diff --git a/js/lite/src/lite/subscriber.ts b/js/lite/src/lite/subscriber.ts
index 4fe755dad..532606b1b 100644
--- a/js/lite/src/lite/subscriber.ts
+++ b/js/lite/src/lite/subscriber.ts
@@ -1,15 +1,18 @@
 import { Announced } from "../announced.ts";
-import { Broadcast, type TrackRequest } from "../broadcast.ts";
+import { Broadcast } from "../broadcast.ts";
+import { Frame } from "../frame.ts";
 import { Group } from "../group.ts";
 import * as Path from "../path.ts";
 import { type Reader, Stream } from "../stream.ts";
+import * as Time from "../time.ts";
 import type { Track } from "../track.ts";
 import { error } from "../util/error.ts";
 import { Announce, AnnounceInit, AnnounceInterest } from "./announce.ts";
+import { Frame as FrameMessage } from "./frame.ts";
 import type { Group as GroupMessage } from "./group.ts";
 import { StreamId } from "./stream.ts";
-import { Subscribe, SubscribeOk } from "./subscribe.ts";
-import type { Version } from "./version.ts";
+import { Subscribe, SubscribeOk, SubscribeUpdate } from "./subscribe.ts";
+import { Version } from "./version.js";
 
 /**
  * Handles subscribing to broadcasts and managing their lifecycle.
@@ -67,10 +70,11 @@ export class Subscriber {
 
 			// Then receive updates
 			for (;;) {
-				const announce = await Promise.race([Announce.decodeMaybe(stream.reader), announced.closed]);
-				if (!announce) break;
-				if (announce instanceof Error) throw announce;
+				const done = await Promise.any([stream.reader.done(), announced.closed]);
+				if (done instanceof Error) throw done;
+				if (done) break;
 
+				const announce = await Announce.decode(stream.reader);
 				const path = Path.join(prefix, announce.suffix);
 
 				console.debug(`announced: broadcast=${path} active=${announce.active}`);
@@ -103,38 +107,67 @@ export class Subscriber {
 		return broadcast;
 	}
 
-	async #runSubscribe(broadcast: Path.Valid, request: TrackRequest) {
+	async #runSubscribe(broadcast: Path.Valid, track: Track) {
 		const id = this.#subscribeNext++;
 
 		// Save the writer so we can append groups to it.
-		this.#subscribes.set(id, request.track);
+		this.#subscribes.set(id, track);
 
-		console.debug(`subscribe start: id=${id} broadcast=${broadcast} track=${request.track.name}`);
+		console.debug(`subscribe start: id=${id} broadcast=${broadcast} track=${track.name}`);
 
-		const msg = new Subscribe(id, broadcast, request.track.name, request.priority);
+		const msg = new Subscribe({
+			id,
+			broadcast,
+			track: track.name,
+			priority: track.priority.peek(),
+			maxLatency: track.maxLatency.peek(),
+			ordered: track.ordered.peek(),
+		});
 
 		const stream = await Stream.open(this.#quic);
 		await stream.writer.u53(StreamId.Subscribe);
-		await msg.encode(stream.writer);
+
+		await msg.encode(stream.writer, this.version);
+
+		const sendUpdate = async () => {
+			const msg = new SubscribeUpdate({
+				priority: track.priority.peek(),
+				maxLatency: track.maxLatency.peek(),
+				ordered: track.ordered.peek(),
+			});
+			await msg.encode(stream.writer, this.version);
+		};
+
+		// TODO: There's no backpressure, so this could fail, but I hate javascript.
+		const dispose = track.priority.subscribe(sendUpdate);
+		const dispose2 = track.maxLatency.subscribe(sendUpdate);
+		const dispose3 = track.ordered.subscribe(sendUpdate);
 
 		try {
-			await SubscribeOk.decode(stream.reader, this.version);
-			console.debug(`subscribe ok: id=${id} broadcast=${broadcast} track=${request.track.name}`);
+			for (;;) {
+				// TODO do something with the publisher's priority/latency/ordered
+				await SubscribeOk.decode(stream.reader, this.version);
+				console.debug(`subscribe ok: id=${id} broadcast=${broadcast} track=${track.name} `);
 
-			await Promise.race([stream.reader.closed, request.track.closed]);
+				const done = await Promise.race([stream.reader.done(), track.closed]);
+				if (done instanceof Error) throw done;
+				if (done !== false) break; // false means a new SubscribeOk
+			}
 
-			request.track.close();
+			track.close();
 			stream.close();
-			console.debug(`subscribe close: id=${id} broadcast=${broadcast} track=${request.track.name}`);
+			console.debug(`subscribe close: id=${id} broadcast=${broadcast} track=${track.name}`);
 		} catch (err) {
 			const e = error(err);
-			request.track.close(e);
-			console.warn(
-				`subscribe error: id=${id} broadcast=${broadcast} track=${request.track.name} error=${e.message}`,
-			);
+			track.close(e);
+			console.warn(`subscribe error: id=${id} broadcast=${broadcast} track=${track.name} error=${e.message}`);
 			stream.abort(e);
 		} finally {
 			this.#subscribes.delete(id);
+
+			dispose();
+			dispose2();
+			dispose3();
 		}
 	}
 
@@ -158,16 +191,28 @@ export class Subscriber {
 		const producer = new Group(group.sequence);
 		subscribe.writeGroup(producer);
 
+		let instant = Time.Milli.zero;
+
 		try {
 			for (;;) {
 				const done = await Promise.race([stream.done(), subscribe.closed, producer.closed]);
+				if (done instanceof Error) throw done;
 				if (done !== false) break;
 
-				const size = await stream.u53();
-				const payload = await stream.read(size);
-				if (!payload) break;
+				const frame = await FrameMessage.decode(stream, this.version);
+
+				switch (this.version) {
+					case Version.DRAFT_03:
+						instant = (instant + frame.delta) as Time.Milli;
+						break;
+					case Version.DRAFT_02:
+					case Version.DRAFT_01:
+						// Nothing was encoded on the wire, so we use the receive time instead.
+						instant = Time.Milli.now();
+						break;
+				}
 
-				producer.writeFrame(payload);
+				producer.writeFrame(new Frame({ payload: frame.payload, instant }));
 			}
 
 			producer.close();
diff --git a/js/lite/src/lite/version.ts b/js/lite/src/lite/version.ts
index 9657ee761..200352e20 100644
--- a/js/lite/src/lite/version.ts
+++ b/js/lite/src/lite/version.ts
@@ -1,6 +1,7 @@
 export const Version = {
 	DRAFT_01: 0xff0dad01,
 	DRAFT_02: 0xff0dad02,
+	DRAFT_03: 0xff0dad03,
 } as const;
 
 export type Version = (typeof Version)[keyof typeof Version];
diff --git a/js/lite/src/stream.ts b/js/lite/src/stream.ts
index 9e5d053e5..2a19c02f6 100644
--- a/js/lite/src/stream.ts
+++ b/js/lite/src/stream.ts
@@ -250,7 +250,8 @@ export class Writer {
 		await this.write(setInt32(this.#scratch, v));
 	}
 
-	async u53(v: number) {
+	// Returns the number of bytes written
+	async u53(v: number): Promise<number> {
 		if (v < 0) {
 			throw new Error(`underflow, value is negative: ${v.toString()}`);
 		}
@@ -258,10 +259,14 @@ export class Writer {
 			throw new Error(`overflow, value larger than 53-bits: ${v.toString()}`);
 		}
 
-		await this.write(setVint53(this.#scratch, v));
+		const buffer = setVint53(this.#scratch, v);
+
+		await this.write(buffer);
+		return buffer.byteLength;
 	}
 
-	async u62(v: bigint) {
+	// Returns the number of bytes written
+	async u62(v: bigint): Promise<number> {
 		if (v < 0) {
 			throw new Error(`underflow, value is negative: ${v.toString()}`);
 		}
@@ -271,17 +276,21 @@ export class Writer {
 		}
 		*/
 
-		await this.write(setVint62(this.#scratch, v));
+		const buffer = setVint62(this.#scratch, v);
+		await this.write(buffer);
+		return buffer.byteLength;
 	}
 
 	async write(v: Uint8Array) {
 		await this.#writer.write(v);
 	}
 
-	async string(str: string) {
+	// Returns the number of bytes written
+	async string(str: string): Promise<number> {
 		const data = new TextEncoder().encode(str);
-		await this.u53(data.byteLength);
+		const length = await this.u53(data.byteLength);
 		await this.write(data);
+		return length + data.byteLength;
 	}
 
 	close() {
diff --git a/js/lite/src/track.ts b/js/lite/src/track.ts
index 1cd1e3e93..8c3128741 100644
--- a/js/lite/src/track.ts
+++ b/js/lite/src/track.ts
@@ -1,24 +1,36 @@
 import { Signal } from "@moq/signals";
+import type { Frame } from "./frame.ts";
 import { Group } from "./group.ts";
+import * as Time from "./time.ts";
 
-export class TrackState {
-	groups = new Signal<Group[]>([]);
-	closed = new Signal<boolean | Error>(false);
+export interface TrackProps {
+	name: string;
+	priority?: number | Signal<number>;
+	maxLatency?: Time.Milli | Signal<Time.Milli>;
+	ordered?: boolean;
 }
 
 export class Track {
 	readonly name: string;
 
-	state = new TrackState();
-	#next?: number;
+	#groups = new Signal<Group[]>([]);
+	maxLatency: Signal<Time.Milli>;
+	priority: Signal<number>;
+	ordered: Signal<boolean>;
 
+	#closed = new Signal<boolean | Error>(false);
 	readonly closed: Promise<Error | undefined>;
 
-	constructor(name: string) {
-		this.name = name;
+	#next?: number;
+
+	constructor(props: TrackProps) {
+		this.name = props.name;
+		this.priority = Signal.from(props.priority ?? 0);
+		this.maxLatency = Signal.from(props.maxLatency ?? Time.Milli.zero);
+		this.ordered = Signal.from(props.ordered ?? false);
 
 		this.closed = new Promise((resolve) => {
-			const dispose = this.state.closed.subscribe((closed) => {
+			const dispose = this.#closed.watch((closed) => {
 				if (!closed) return;
 				resolve(closed instanceof Error ? closed : undefined);
 				dispose();
@@ -31,12 +43,12 @@ export class Track {
 	 * @returns A GroupProducer for the new group
 	 */
 	appendGroup(): Group {
-		if (this.state.closed.peek()) throw new Error("track is closed");
+		if (this.#closed.peek()) throw new Error("track is closed");
 
 		const group = new Group(this.#next ?? 0);
 
 		this.#next = group.sequence + 1;
-		this.state.groups.mutate((groups) => {
+		this.#groups.mutate((groups) => {
 			groups.push(group);
 			groups.sort((a, b) => a.sequence - b.sequence);
 		});
@@ -49,7 +61,7 @@ export class Track {
 	 * @param group - The group to insert
 	 */
 	writeGroup(group: Group) {
-		if (this.state.closed.peek()) throw new Error("track is closed");
+		if (this.#closed.peek()) throw new Error("track is closed");
 
 		if (group.sequence < (this.#next ?? 0)) {
 			group.close();
@@ -57,7 +69,7 @@ export class Track {
 		}
 
 		this.#next = group.sequence + 1;
-		this.state.groups.mutate((groups) => {
+		this.#groups.mutate((groups) => {
 			groups.push(group);
 			groups.sort((a, b) => a.sequence - b.sequence);
 		});
@@ -68,61 +80,43 @@ export class Track {
 	 *
 	 * @param frame - The frame to append
 	 */
-	writeFrame(frame: Uint8Array) {
+	writeFrame(frame: Frame) {
 		const group = this.appendGroup();
 		group.writeFrame(frame);
 		group.close();
 	}
 
-	writeString(str: string) {
-		const group = this.appendGroup();
-		group.writeString(str);
-		group.close();
-	}
-
-	writeJson(json: unknown) {
-		const group = this.appendGroup();
-		group.writeJson(json);
-		group.close();
-	}
-
-	writeBool(bool: boolean) {
-		const group = this.appendGroup();
-		group.writeBool(bool);
-		group.close();
-	}
-
 	async nextGroup(): Promise<Group | undefined> {
 		for (;;) {
-			const groups = this.state.groups.peek();
+			const groups = this.#groups.peek();
 			if (groups.length > 0) {
 				return groups.shift();
 			}
 
-			const closed = this.state.closed.peek();
+			const closed = this.#closed.peek();
 			if (closed instanceof Error) throw closed;
 			if (closed) return undefined;
 
-			await Signal.race(this.state.groups, this.state.closed);
+			await Signal.race(this.#groups, this.#closed);
 		}
 	}
 
-	async readFrame(): Promise<Uint8Array | undefined> {
-		return (await this.readFrameSequence())?.data;
+	async readFrame(): Promise<Frame | undefined> {
+		return (await this.readFrameSequence())?.frame;
 	}
 
 	// Returns the sequence number of the group and frame, not just the data.
-	async readFrameSequence(): Promise<{ group: number; frame: number; data: Uint8Array } | undefined> {
+	async readFrameSequence(): Promise<{ group: number; sequence: number; frame: Frame } | undefined> {
 		for (;;) {
-			const groups = this.state.groups.peek();
+			const groups = this.#groups.peek();
 
 			// Discard old groups.
 			while (groups.length > 1) {
 				const frames = groups[0].state.frames.peek();
 				const next = frames.shift();
 				if (next) {
-					const frame = groups[0].state.total.peek() - frames.length - 1;
-					return { group: groups[0].sequence, frame, data: next };
+					const sequence = groups[0].state.total.peek() - frames.length - 1;
+					return { group: groups[0].sequence, sequence, frame: next };
 				}
 
 				// Skip this old group
@@ -131,11 +125,11 @@ export class Track {
 
 			// If there's no groups, wait for a new one.
 			if (groups.length === 0) {
-				const closed = this.state.closed.peek();
+				const closed = this.#closed.peek();
 				if (closed instanceof Error) throw closed;
 				if (closed) return undefined;
 
-				await Signal.race(this.state.groups, this.state.closed);
+				await Signal.race(this.#groups, this.#closed);
 				continue;
 			}
 
@@ -144,46 +138,27 @@ export class Track {
 			const frames = group.state.frames.peek();
 			const next = frames.shift();
 			if (next) {
-				const frame = group.state.total.peek() - frames.length - 1;
-				return { group: group.sequence, frame, data: next };
+				const sequence = group.state.total.peek() - frames.length - 1;
+				return { group: group.sequence, sequence, frame: next };
 			}
 
 			// If the track is closed, return undefined.
-			const closed = this.state.closed.peek();
+			const closed = this.#closed.peek();
 			if (closed instanceof Error) throw closed;
 			if (closed) return undefined;
 
 			// NOTE: We don't care if the latest group was closed or not.
-			await Signal.race(this.state.groups, this.state.closed, group.state.frames);
+			await Signal.race(this.#groups, this.#closed, group.state.frames);
 		}
 	}
 
-	async readString(): Promise<string | undefined> {
-		const next = await this.readFrame();
-		if (!next) return undefined;
-		return new TextDecoder().decode(next);
-	}
-
-	async readJson(): Promise<unknown | undefined> {
-		const next = await this.readString();
-		if (!next) return undefined;
-		return JSON.parse(next);
-	}
-
-	async readBool(): Promise<boolean | undefined> {
-		const next = await this.readFrame();
-		if (!next) return undefined;
-		if (next.byteLength !== 1 || !(next[0] === 0 || next[0] === 1)) throw new Error("invalid bool frame");
-		return next[0] === 1;
-	}
-
 	/**
 	 * Closes the publisher and all associated groups.
 	 */
 	close(abort?: Error) {
-		this.state.closed.set(abort ?? true);
+		this.#closed.set(abort ?? true);
 
-		for (const group of this.state.groups.peek()) {
+		for (const group of this.#groups.peek()) {
 			group.close(abort);
 		}
 	}
diff --git a/js/lite/src/zod.ts b/js/lite/src/zod.ts
index 936cd1ab0..49c6fc452 100644
--- a/js/lite/src/zod.ts
+++ b/js/lite/src/zod.ts
@@ -1,16 +1,17 @@
 // Helper containers for Zod-validated track encoding/decoding.
 
 import type * as z from "zod";
+import { Frame } from "./frame.ts";
 import type { Group } from "./group.ts";
 import type { Track } from "./track.ts";
 
 export async function read<T = unknown>(source: Track | Group, schema: z.ZodSchema<T>): Promise<T | undefined> {
-	const next = await source.readJson();
-	if (next === undefined) return undefined; // only treat undefined as EOF, not other falsy values
-	return schema.parse(next);
+	const next = await source.readFrame();
+	if (next === undefined) return; // only treat undefined as EOF, not other falsy values
+	return schema.parse(next.toJson());
 }
 
 export function write<T = unknown>(source: Track | Group, value: T, schema: z.ZodSchema<T>) {
 	const valid = schema.parse(value);
-	source.writeJson(valid);
+	source.writeFrame(Frame.fromJson(valid));
 }
diff --git a/js/signals/src/index.ts b/js/signals/src/index.ts
index 467b884e6..47da348c4 100644
--- a/js/signals/src/index.ts
+++ b/js/signals/src/index.ts
@@ -153,6 +153,16 @@ export class Signal<T> implements Getter<T>, Setter<T> {
 		for (const fn of dispose) fn();
 		return result;
 	}
+
+	// Spawn a promise that resolves when the signal changes.
+	promise(): Promise<T> {
+		return new Promise<T>((resolve) => {
+			const dispose = this.changed((value) => {
+				resolve(value);
+				dispose();
+			});
+		});
+	}
 }
 
 type SetterType<S> = S extends Setter<infer T> ? T : never;
diff --git a/justfile b/justfile
index 391f3c9e4..7125a0fc1 100644
--- a/justfile
+++ b/justfile
@@ -321,7 +321,7 @@ test:
 		bun run --filter='*' test
 	fi
 
-	cargo test --all-targets --all-features
+	RUST_BACKTRACE=1 cargo test --all-targets --all-features
 
 # Automatically fix some issues.
 fix:
diff --git a/rs/hang-cli/src/publish.rs b/rs/hang-cli/src/publish.rs
index eb12d8771..14b4e506c 100644
--- a/rs/hang-cli/src/publish.rs
+++ b/rs/hang-cli/src/publish.rs
@@ -2,8 +2,7 @@ use bytes::BytesMut;
 use clap::Subcommand;
 use hang::{
 	import::{Decoder, DecoderFormat},
-	moq_lite::BroadcastConsumer,
-	BroadcastProducer,
+	moq_lite,
 };
 use tokio::io::AsyncReadExt;
 
@@ -26,28 +25,30 @@ enum PublishDecoder {
 
 pub struct Publish {
 	decoder: PublishDecoder,
-	broadcast: BroadcastProducer,
+	broadcast: moq_lite::BroadcastProducer,
 	buffer: BytesMut,
 }
 
 impl Publish {
 	pub fn new(format: &PublishFormat) -> anyhow::Result<Self> {
-		let broadcast = BroadcastProducer::default();
+		let broadcast = moq_lite::BroadcastProducer::default();
+		let catalog = hang::CatalogProducer::new(broadcast.clone())?;
 
 		let decoder = match format {
 			PublishFormat::Avc3 => {
 				let format = DecoderFormat::Avc3;
-				let stream = Decoder::new(broadcast.clone(), format);
+				let stream = Decoder::new(broadcast.clone(), catalog, format);
 				PublishDecoder::Decoder(Box::new(stream))
 			}
 			PublishFormat::Fmp4 => {
 				let format = DecoderFormat::Fmp4;
-				let stream = Decoder::new(broadcast.clone(), format);
+				let stream = Decoder::new(broadcast.clone(), catalog, format);
 				PublishDecoder::Decoder(Box::new(stream))
 			}
 			PublishFormat::Hls { playlist } => {
 				let hls = hang::import::Hls::new(
 					broadcast.clone(),
+					catalog,
 					hang::import::HlsConfig {
 						playlist: playlist.clone(),
 						client: None,
@@ -64,7 +65,7 @@ impl Publish {
 		})
 	}
 
-	pub fn consume(&self) -> BroadcastConsumer {
+	pub fn consume(&self) -> moq_lite::BroadcastConsumer {
 		self.broadcast.consume()
 	}
 }
diff --git a/rs/hang/Cargo.toml b/rs/hang/Cargo.toml
index 797426ec1..3c5cd4980 100644
--- a/rs/hang/Cargo.toml
+++ b/rs/hang/Cargo.toml
@@ -16,7 +16,6 @@ categories = ["multimedia", "network-programming", "web-programming"]
 anyhow = "1"
 buf-list = "1"
 bytes = "1"
-futures = "0.3"
 h264-parser = "0.4.0"
 hex = "0.4"
 lazy_static = "1"
diff --git a/rs/hang/examples/video.rs b/rs/hang/examples/video.rs
index e86a47ebb..fc8eb4b36 100644
--- a/rs/hang/examples/video.rs
+++ b/rs/hang/examples/video.rs
@@ -1,3 +1,4 @@
+use anyhow::Context;
 // cargo run --example video
 use moq_lite::coding::Bytes;
 
@@ -12,17 +13,6 @@ async fn main() -> anyhow::Result<()> {
 	// Create an origin that we can publish to and the session can consume from.
 	let origin = moq_lite::Origin::produce();
 
-	// Run the broadcast production and the session in parallel.
-	// This is a simple example of how you can concurrently run multiple tasks.
-	// tokio::spawn works too.
-	tokio::select! {
-		res = run_broadcast(origin.producer) => res,
-		res = run_session(origin.consumer) => res,
-	}
-}
-
-// Connect to the server and publish our origin of broadcasts.
-async fn run_session(origin: moq_lite::OriginConsumer) -> anyhow::Result<()> {
 	// Optional: Use moq_native to make a QUIC client.
 	let client = moq_native::ClientConfig::default().init()?;
 
@@ -33,25 +23,23 @@ async fn run_session(origin: moq_lite::OriginConsumer) -> anyhow::Result<()> {
 	// Establish a WebTransport/QUIC connection and MoQ handshake.
 	// None means we're not consuming anything from the session, otherwise we would provide an OriginProducer.
 	// Optional: Use connect_with_fallback if you also want to support WebSocket.
-	let session = client.connect(url, origin, None).await?;
+	let session = client.connect(url, origin.consumer, None).await?;
 
-	// Wait until the session is closed.
-	session.closed().await.map_err(Into::into)
-}
+	// 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.
+	let mut broadcast = origin.producer.create_broadcast("").context("not allowed to publish")?;
 
-// 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) -> hang::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
-	};
+	// We also need a catalog to describe our tracks.
+	// NOTE: You would reuse this for all tracks; we're creating a new one here for simplicity.
+	let mut catalog = hang::CatalogProducer::new(broadcast.clone())?;
+
+	// Once we unlock (drop) the catalog, it will be published to the broadcast.
+	let mut catalog = catalog.lock();
 
 	// Example video configuration
 	// In a real application, you would get this from the encoder
-	let video_config = hang::catalog::VideoConfig {
-		codec: hang::catalog::H264 {
+	let config = hang::VideoConfig {
+		codec: hang::H264 {
 			profile: 0x4D, // Main profile
 			constraints: 0,
 			level: 0x28,  // Level 4.0
@@ -71,75 +59,61 @@ fn create_track(broadcast: &mut moq_lite::BroadcastProducer) -> hang::TrackProdu
 		optimize_for_latency: None,
 	};
 
-	// Create a map of video renditions
-	// Multiple renditions allow the viewer to choose based on their capabilities
-	let mut renditions = std::collections::BTreeMap::new();
-	renditions.insert(video_track.name.clone(), video_config);
+	// This is a helper that creates a unique track name and adds it to the catalog.
+	// You can also set `catalog.video` fields directly.
+	let track = catalog.video.create("example", config);
 
-	// Create the video catalog entry with the renditions
-	let video = hang::catalog::Video {
-		renditions,
+	// We also need some details on how to deliver the track over the network.
+	let delivery = moq_lite::Delivery {
+		// Video typically has lower priority than audio; we'll try to transmit it later
 		priority: 1,
-		display: None,
-		rotation: None,
-		flip: None,
+		// You can configure the amount of time to keep old groups in cache.
+		max_latency: moq_lite::Time::from_secs(10).unwrap(),
+		// You can even tell the CDN if it should try to delver in group order.
+		ordered: false,
 	};
 
-	// Create a producer/consumer pair for the catalog.
-	// This JSON encodes the catalog as a "catalog.json" track.
-	let catalog = hang::catalog::Catalog {
-		video: Some(video),
-		..Default::default()
-	}
-	.produce();
-
-	// Publish the catalog track to the broadcast.
-	broadcast.insert_track(catalog.consumer.track);
-
-	// Actually create the media track now.
-	let track = broadcast.create_track(video_track);
+	let mut track = broadcast.create_track(track, delivery)?;
 
-	// Wrap the track in a hang:TrackProducer for convenience methods.
-	track.into()
-}
-
-// 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 mut track = create_track(&mut broadcast.producer);
-
-	// 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.
-	origin.publish_broadcast("", broadcast.consumer);
+	// Create a group of frames.
+	// Each group must start with a keyframe.
+	let mut group = track.append_group()?;
 
-	// Not real frames of course.
-	track.write(hang::Frame {
-		keyframe: true,
+	// Encode a simple container that consists of a timestamp and a payload.
+	// NOTE: This will be removed in the future; it's for backwards compatibility.
+	hang::Container {
 		timestamp: hang::Timestamp::from_secs(1).unwrap(),
 		payload: Bytes::from_static(b"keyframe NAL data").into(),
-	})?;
+	}
+	.encode(&mut group)?;
 
 	tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
 
-	track.write(hang::Frame {
-		keyframe: false,
+	hang::Container {
 		timestamp: hang::Timestamp::from_secs(2).unwrap(),
 		payload: Bytes::from_static(b"delta NAL data").into(),
-	})?;
+	}
+	.encode(&mut group)?;
 
 	tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
 
-	// Automatically creates a new group if you write a new keyframe.
+	// You can create a new group for each keyframe.
+	group.close()?;
+	let mut group = track.append_group()?;
 
-	track.write(hang::Frame {
-		keyframe: true,
+	hang::Container {
 		timestamp: hang::Timestamp::from_secs(3).unwrap(),
 		payload: Bytes::from_static(b"keyframe NAL data").into(),
-	})?;
+	}
+	.encode(&mut group)?;
+
+	tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+
+	// You can also abort a group if you want to abandon delivery immediately.
+	group.abort(moq_lite::Error::Expired)?;
 
-	// Sleep before exiting and closing the broadcast.
-	tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;
+	// Wait until the session is closed, I guess
+	session.closed().await?;
 
 	Ok(())
 }
diff --git a/rs/hang/src/catalog/audio/mod.rs b/rs/hang/src/catalog/audio/mod.rs
index 7322bc307..5aa5256a9 100644
--- a/rs/hang/src/catalog/audio/mod.rs
+++ b/rs/hang/src/catalog/audio/mod.rs
@@ -4,12 +4,11 @@ mod codec;
 pub use aac::*;
 pub use codec::*;
 
-use std::collections::BTreeMap;
-
 use bytes::Bytes;
-
+use moq_lite::Track;
 use serde::{Deserialize, Serialize};
 use serde_with::{hex::Hex, DisplayFromStr};
+use std::collections::{btree_map, BTreeMap};
 
 /// Information about an audio track in the catalog.
 ///
@@ -22,12 +21,43 @@ pub struct Audio {
 	/// A map of track name to rendition configuration.
 	/// This is not an array so it will work with JSON Merge Patch.
 	/// We use a BTreeMap so keys are sorted alphabetically for *some* deterministic behavior.
-	pub renditions: BTreeMap<String, AudioConfig>,
+	pub renditions: BTreeMap<Track, AudioConfig>,
 
 	/// The priority of the audio track, relative to other tracks in the broadcast.
+	///
+	/// TODO: Remove this; it's for backwards compatibility only
+	#[serde(default)]
 	pub priority: u8,
 }
 
+impl Audio {
+	// Don't serialize if there are no renditions.
+	pub fn is_empty(&self) -> bool {
+		self.renditions.is_empty()
+	}
+
+	/// Create a new audio track with a configuration and generate a unique name.
+	pub fn create(&mut self, name: &str, config: AudioConfig) -> Track {
+		let mut index = 0;
+
+		loop {
+			let track = Track::from(format!("audio:{}:{}", name, index));
+			match self.renditions.entry(track.clone()) {
+				btree_map::Entry::Vacant(entry) => {
+					entry.insert(config);
+					return track;
+				}
+				btree_map::Entry::Occupied(_) => index += 1,
+			}
+		}
+	}
+
+	/// Remove a audio track from the catalog.
+	pub fn remove(&mut self, track: &Track) -> Option<AudioConfig> {
+		self.renditions.remove(track)
+	}
+}
+
 /// Audio decoder configuration based on WebCodecs AudioDecoderConfig.
 ///
 /// This struct contains all the information needed to initialize an audio decoder,
diff --git a/rs/hang/src/catalog/mod.rs b/rs/hang/src/catalog/mod.rs
index ea48eee01..0677a8959 100644
--- a/rs/hang/src/catalog/mod.rs
+++ b/rs/hang/src/catalog/mod.rs
@@ -7,6 +7,7 @@
 mod audio;
 mod chat;
 mod preview;
+mod produce;
 mod root;
 mod user;
 mod video;
@@ -14,6 +15,7 @@ mod video;
 pub use audio::*;
 pub use chat::*;
 pub use preview::*;
+pub use produce::*;
 pub use root::*;
 pub use user::*;
 pub use video::*;
diff --git a/rs/hang/src/catalog/produce.rs b/rs/hang/src/catalog/produce.rs
new file mode 100644
index 000000000..3c659afd0
--- /dev/null
+++ b/rs/hang/src/catalog/produce.rs
@@ -0,0 +1,115 @@
+use crate::Catalog;
+use crate::Error;
+
+use std::{
+	ops::{Deref, DerefMut},
+	sync::{Arc, Mutex, MutexGuard},
+};
+
+/// Produces a catalog track that describes the available media tracks.
+///
+/// Use [Self::lock] to update the catalog, publishing any changes on [CatalogGuard::drop].
+#[derive(Debug, Clone)]
+pub struct CatalogProducer {
+	track: moq_lite::TrackProducer,
+	current: Arc<Mutex<Catalog>>,
+}
+
+impl CatalogProducer {
+	/// Create a new catalog producer for the given broadcast.
+	pub fn new(mut broadcast: moq_lite::BroadcastProducer) -> Result<Self, Error> {
+		let track = broadcast.create_track(Catalog::default_track(), Catalog::default_delivery())?;
+		Ok(Self {
+			current: Arc::new(Mutex::new(Catalog::default())),
+			track,
+		})
+	}
+
+	/// Get mutable access to the catalog, publishing it after any changes.
+	pub fn lock(&mut self) -> CatalogGuard<'_> {
+		CatalogGuard {
+			catalog: self.current.lock().unwrap(),
+			track: &mut self.track,
+		}
+	}
+
+	/// Finish publishing to this catalog and close the track.
+	pub fn close(mut self) -> Result<(), Error> {
+		self.track.close()?;
+		Ok(())
+	}
+}
+
+pub struct CatalogGuard<'a> {
+	catalog: MutexGuard<'a, Catalog>,
+	track: &'a mut moq_lite::TrackProducer,
+}
+
+impl<'a> Deref for CatalogGuard<'a> {
+	type Target = Catalog;
+
+	fn deref(&self) -> &Self::Target {
+		&self.catalog
+	}
+}
+
+impl<'a> DerefMut for CatalogGuard<'a> {
+	fn deref_mut(&mut self) -> &mut Self::Target {
+		&mut self.catalog
+	}
+}
+
+impl Drop for CatalogGuard<'_> {
+	fn drop(&mut self) {
+		if let Ok(mut group) = self.track.append_group() {
+			// TODO decide if this should return an error, or be impossible to fail
+			let frame = self.catalog.to_string().expect("invalid catalog");
+			group.write_frame(frame, moq_lite::Time::now()).ok();
+			group.close().ok();
+		}
+	}
+}
+
+/// Consumes the catalog track, returning the next catalog update.
+pub struct CatalogConsumer {
+	broadcast: Option<moq_lite::BroadcastConsumer>,
+	track: Option<moq_lite::TrackConsumer>,
+	group: Option<moq_lite::GroupConsumer>,
+}
+
+impl CatalogConsumer {
+	/// Create a new catalog consumer from a broadcast.
+	pub fn new(broadcast: moq_lite::BroadcastConsumer) -> Self {
+		Self {
+			broadcast: Some(broadcast),
+			track: None,
+			group: None,
+		}
+	}
+
+	/// Get the next catalog update.
+	///
+	/// 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>, Error> {
+		if let Some(broadcast) = &mut self.broadcast {
+			let track = broadcast.subscribe_track(Catalog::default_track(), Catalog::default_delivery())?;
+			self.track = Some(track);
+			self.broadcast = None;
+		}
+
+		loop {
+			tokio::select! {
+				biased;
+				Some(track) = async { self.track.as_mut()?.next_group().await.transpose() } => {
+					self.group = Some(track?);
+				}
+				Some(frame) = async { self.group.as_mut()?.read_frame().await.transpose() } => {
+					let catalog = Catalog::from_slice(&frame?)?;
+					return Ok(Some(catalog));
+				}
+				else => return Ok(None),
+			}
+		}
+	}
+}
diff --git a/rs/hang/src/catalog/root.rs b/rs/hang/src/catalog/root.rs
index 1f2e80b3d..d9a40acd8 100644
--- a/rs/hang/src/catalog/root.rs
+++ b/rs/hang/src/catalog/root.rs
@@ -1,13 +1,10 @@
-//! This module contains the structs and functions for the MoQ catalog format
-use std::ops::{Deref, DerefMut};
-use std::sync::{Arc, Mutex, MutexGuard};
-
-/// The catalog format is a JSON file that describes the tracks available in a broadcast.
+//! This module contains the structs and functions for the MoQ catalog format.
+//!
+//! The catalog format is a JSON file that describes the tracks available in a broadcast.
 use serde::{Deserialize, Serialize};
 
-use crate::catalog::{Audio, AudioConfig, Chat, User, Video, VideoConfig};
 use crate::Result;
-use moq_lite::Produce;
+use crate::{Audio, Chat, User, Video};
 
 /// A catalog track, created by a broadcaster to describe the tracks available in a broadcast.
 #[serde_with::serde_as]
@@ -19,15 +16,15 @@ pub struct Catalog {
 	///
 	/// 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: Option<Video>,
+	#[serde(default, skip_serializing_if = "Video::is_empty")]
+	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: Option<Audio>,
+	#[serde(default, skip_serializing_if = "Audio::is_empty")]
+	pub audio: Audio,
 
 	/// User metadata for the broadcaster
 	#[serde(default)]
@@ -82,197 +79,23 @@ impl Catalog {
 		Ok(serde_json::to_writer(writer, self)?)
 	}
 
-	/// Produce a catalog track that describes the available media tracks.
-	pub fn produce(self) -> Produce<CatalogProducer, CatalogConsumer> {
-		let track = Catalog::default_track().produce();
-
-		Produce {
-			producer: CatalogProducer::new(track.producer, self),
-			consumer: track.consumer.into(),
-		}
-	}
-
 	pub fn default_track() -> moq_lite::Track {
-		moq_lite::Track {
-			name: Catalog::DEFAULT_NAME.to_string(),
-			priority: 100,
-		}
-	}
-
-	// A silly helpers to change None -> Some or Some -> None based on the number of renditions.
-	pub fn insert_video(&mut self, name: String, config: VideoConfig) -> &mut Video {
-		let mut video = self.video.take().unwrap_or_default();
-		video.renditions.insert(name, config);
-		self.video = Some(video);
-		self.video.as_mut().unwrap()
-	}
-
-	pub fn insert_audio(&mut self, name: String, config: AudioConfig) -> &mut Audio {
-		let mut audio = self.audio.take().unwrap_or_default();
-		audio.renditions.insert(name, config);
-		self.audio = Some(audio);
-		self.audio.as_mut().unwrap()
-	}
-
-	pub fn remove_video(&mut self, name: &str) {
-		let mut video = self.video.take().unwrap_or_default();
-		video.renditions.remove(name);
-
-		match video.renditions.is_empty() {
-			true => self.video = None,
-			false => self.video = Some(video),
-		}
-	}
-
-	pub fn remove_audio(&mut self, name: &str) {
-		let mut audio = self.audio.take().unwrap_or_default();
-		audio.renditions.remove(name);
-
-		match audio.renditions.is_empty() {
-			true => self.audio = None,
-			false => self.audio = Some(audio),
-		}
-	}
-}
-
-/// Produces a catalog track that describes the available media tracks.
-///
-/// 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.
-#[derive(Clone)]
-pub struct CatalogProducer {
-	/// Access to the underlying track producer.
-	pub track: moq_lite::TrackProducer,
-	current: Arc<Mutex<Catalog>>,
-}
-
-impl CatalogProducer {
-	/// Create a new catalog producer with the given track and initial catalog.
-	fn new(track: moq_lite::TrackProducer, init: Catalog) -> Self {
-		Self {
-			current: Arc::new(Mutex::new(init)),
-			track,
-		}
+		Catalog::DEFAULT_NAME.into()
 	}
 
-	/// Get mutable access to the catalog, publishing it after any changes.
-	pub fn lock(&mut self) -> CatalogGuard<'_> {
-		CatalogGuard {
-			catalog: self.current.lock().unwrap(),
-			track: &mut self.track,
-		}
-	}
-
-	/// Create a consumer for this catalog, receiving updates as they're published.
-	pub fn consume(&self) -> CatalogConsumer {
-		CatalogConsumer::new(self.track.consume())
-	}
-
-	/// Finish publishing to this catalog and close the track.
-	pub fn close(self) {
-		self.track.close();
-	}
-}
-
-impl From<moq_lite::TrackProducer> for CatalogProducer {
-	fn from(inner: moq_lite::TrackProducer) -> Self {
-		Self::new(inner, Catalog::default())
-	}
-}
-
-/// RAII guard for modifying a catalog with automatic publishing on drop.
-///
-/// Obtained via [`CatalogProducer::lock`].
-pub struct CatalogGuard<'a> {
-	catalog: MutexGuard<'a, Catalog>,
-	track: &'a mut moq_lite::TrackProducer,
-}
-
-impl<'a> Deref for CatalogGuard<'a> {
-	type Target = Catalog;
-
-	fn deref(&self) -> &Self::Target {
-		&self.catalog
-	}
-}
-
-impl<'a> DerefMut for CatalogGuard<'a> {
-	fn deref_mut(&mut self) -> &mut Self::Target {
-		&mut self.catalog
-	}
-}
-
-impl Drop for CatalogGuard<'_> {
-	fn drop(&mut self) {
-		let mut group = self.track.append_group();
-
-		// TODO decide if this should return an error, or be impossible to fail
-		let frame = self.catalog.to_string().expect("invalid catalog");
-		group.write_frame(frame);
-		group.close();
-	}
-}
-
-/// 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)]
-pub struct CatalogConsumer {
-	/// Access to the underlying track consumer.
-	pub track: moq_lite::TrackConsumer,
-	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 }
-	}
-
-	/// Get the next catalog update.
-	///
-	/// 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);
-						}
-						// 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 catalog = Catalog::from_slice(&frame?)?;
-					return Ok(Some(catalog));
-				}
-			}
+	pub fn default_delivery() -> moq_lite::Delivery {
+		moq_lite::Delivery {
+			priority: u8::MAX,
+			..Default::default()
 		}
 	}
-
-	/// Wait until the catalog track is closed.
-	pub async fn closed(&self) -> Result<()> {
-		Ok(self.track.closed().await?)
-	}
-}
-
-impl From<moq_lite::TrackConsumer> for CatalogConsumer {
-	fn from(inner: moq_lite::TrackConsumer) -> Self {
-		Self::new(inner)
-	}
 }
 
 #[cfg(test)]
 mod test {
 	use std::collections::BTreeMap;
 
-	use crate::catalog::{AudioCodec::Opus, AudioConfig, VideoConfig, H264};
+	use crate::{AudioCodec::Opus, AudioConfig, VideoConfig, H264};
 
 	use super::*;
 
@@ -309,7 +132,7 @@ mod test {
 
 		let mut video_renditions = BTreeMap::new();
 		video_renditions.insert(
-			"video".to_string(),
+			"video".into(),
 			VideoConfig {
 				codec: H264 {
 					profile: 0x64,
@@ -331,7 +154,7 @@ mod test {
 
 		let mut audio_renditions = BTreeMap::new();
 		audio_renditions.insert(
-			"audio".to_string(),
+			"audio".into(),
 			AudioConfig {
 				codec: Opus,
 				sample_rate: 48_000,
@@ -342,17 +165,17 @@ mod test {
 		);
 
 		let decoded = Catalog {
-			video: Some(Video {
+			video: Video {
 				renditions: video_renditions,
 				priority: 1,
 				display: None,
 				rotation: None,
 				flip: None,
-			}),
-			audio: Some(Audio {
+			},
+			audio: Audio {
 				renditions: audio_renditions,
 				priority: 2,
-			}),
+			},
 			..Default::default()
 		};
 
diff --git a/rs/hang/src/catalog/video/av1.rs b/rs/hang/src/catalog/video/av1.rs
index 724a6a979..99ba8c486 100644
--- a/rs/hang/src/catalog/video/av1.rs
+++ b/rs/hang/src/catalog/video/av1.rs
@@ -151,7 +151,7 @@ impl Default for AV1 {
 mod test {
 	use std::str::FromStr;
 
-	use crate::catalog::VideoCodec;
+	use crate::VideoCodec;
 
 	use super::*;
 
diff --git a/rs/hang/src/catalog/video/h264.rs b/rs/hang/src/catalog/video/h264.rs
index 34866317a..a8a246da8 100644
--- a/rs/hang/src/catalog/video/h264.rs
+++ b/rs/hang/src/catalog/video/h264.rs
@@ -64,7 +64,7 @@ impl FromStr for H264 {
 mod tests {
 	use std::str::FromStr;
 
-	use crate::catalog::VideoCodec;
+	use crate::VideoCodec;
 
 	use super::*;
 
diff --git a/rs/hang/src/catalog/video/h265.rs b/rs/hang/src/catalog/video/h265.rs
index 2213485c1..d781ae1e0 100644
--- a/rs/hang/src/catalog/video/h265.rs
+++ b/rs/hang/src/catalog/video/h265.rs
@@ -137,7 +137,7 @@ impl FromStr for H265 {
 
 #[cfg(test)]
 mod tests {
-	use crate::catalog::VideoCodec;
+	use crate::VideoCodec;
 
 	use super::*;
 
diff --git a/rs/hang/src/catalog/video/mod.rs b/rs/hang/src/catalog/video/mod.rs
index 0bb59b076..38f86558c 100644
--- a/rs/hang/src/catalog/video/mod.rs
+++ b/rs/hang/src/catalog/video/mod.rs
@@ -10,11 +10,11 @@ pub use h264::*;
 pub use h265::*;
 pub use vp9::*;
 
-use std::collections::BTreeMap;
-
 use bytes::Bytes;
+use moq_lite::Track;
 use serde::{Deserialize, Serialize};
 use serde_with::{hex::Hex, DisplayFromStr};
+use std::collections::{btree_map, BTreeMap};
 
 /// Information about a video track in the catalog.
 ///
@@ -28,9 +28,12 @@ pub struct Video {
 	/// A map of track name to rendition configuration.
 	/// This is not an array in order for it to work with JSON Merge Patch.
 	/// We use a BTreeMap so keys are sorted alphabetically for *some* deterministic behavior.
-	pub renditions: BTreeMap<String, VideoConfig>,
+	pub renditions: BTreeMap<Track, VideoConfig>,
 
 	/// The priority of the video track, relative to other tracks in the broadcast.
+	///
+	/// TODO: Default is for backwards compatibility with old catalogs
+	#[serde(default)]
 	pub priority: u8,
 
 	/// Render the video at this size in pixels.
@@ -49,6 +52,34 @@ pub struct Video {
 	pub flip: Option<bool>,
 }
 
+impl Video {
+	/// Don't serialize if there are no renditions.
+	pub fn is_empty(&self) -> bool {
+		self.renditions.is_empty()
+	}
+
+	/// Create a new video track with a configuration and generate a unique name.
+	pub fn create(&mut self, name: &str, config: VideoConfig) -> Track {
+		let mut index = 0;
+
+		loop {
+			let track = Track::from(format!("video:{}:{}", name, index));
+			match self.renditions.entry(track.clone()) {
+				btree_map::Entry::Vacant(entry) => {
+					entry.insert(config);
+					return track;
+				}
+				btree_map::Entry::Occupied(_) => index += 1,
+			}
+		}
+	}
+
+	/// Remove a video track from the catalog.
+	pub fn remove(&mut self, track: &Track) -> Option<VideoConfig> {
+		self.renditions.remove(track)
+	}
+}
+
 /// Display size for rendering video
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
 #[serde(rename_all = "camelCase")]
diff --git a/rs/hang/src/catalog/video/vp9.rs b/rs/hang/src/catalog/video/vp9.rs
index ec255dd41..617661d6e 100644
--- a/rs/hang/src/catalog/video/vp9.rs
+++ b/rs/hang/src/catalog/video/vp9.rs
@@ -112,7 +112,7 @@ impl Default for VP9 {
 mod test {
 	use std::str::FromStr;
 
-	use crate::catalog::VideoCodec;
+	use crate::VideoCodec;
 
 	use super::*;
 
diff --git a/rs/hang/src/container.rs b/rs/hang/src/container.rs
new file mode 100644
index 000000000..ba43ef78b
--- /dev/null
+++ b/rs/hang/src/container.rs
@@ -0,0 +1,59 @@
+use buf_list::BufList;
+use bytes::BytesMut;
+use moq_lite::coding::{Decode, Encode};
+
+use crate::Error;
+
+/// A timestamp representing the presentation time in microseconds.
+///
+/// [moq_lite::Time] is in milliseconds, but that's not quiiite precise enough for audio.
+/// (technically you could make it work, but it's a pain in the butt)
+/// We encode microseconds instead to match the WebCodecs API.
+pub type Timestamp = moq_lite::Timescale<1_000_000>;
+
+pub struct Container {
+	pub timestamp: Timestamp,
+	pub payload: BufList,
+}
+
+impl Container {
+	pub async fn decode(group: &mut moq_lite::GroupConsumer) -> Result<Option<Self>, Error> {
+		let Some(mut frame) = group.next_frame().await? else {
+			return Ok(None);
+		};
+
+		// NOTE: We currently don't use `frame.timestamp` for backwards compatibility with versions < draft03.
+		// TODO: Remove legacy support and stop double encoding the timestamp.
+
+		// TODO: Ideally we don't buffer the entire payload in memory; some decoders can handle it.
+		let payload = frame.read_chunks().await?;
+
+		let mut payload = BufList::from_iter(payload);
+		let timestamp = Timestamp::decode(&mut payload, moq_lite::lite::Version::Draft03)?;
+		let container = Self { timestamp, payload };
+
+		Ok(Some(container))
+	}
+
+	pub fn encode(&self, group: &mut moq_lite::GroupProducer) -> Result<(), Error> {
+		let mut header = BytesMut::new();
+		self.timestamp.encode(&mut header, moq_lite::lite::Version::Draft03);
+
+		let size = self.payload.num_bytes() + header.len();
+		let frame = moq_lite::Frame {
+			size,
+			// NOTE: We encode the timestamp into the MoQ layer as well.
+			// The MoQ layer uses milliseconds, so we convert from our microsecond timestamp.
+			instant: self.timestamp.convert().expect("timestamp conversion overflow"),
+		};
+
+		let mut chunked = group.create_frame(frame)?;
+		chunked.write_chunk(header.freeze())?;
+		for chunk in &self.payload {
+			chunked.write_chunk(chunk.clone())?;
+		}
+		chunked.close()?;
+
+		Ok(())
+	}
+}
diff --git a/rs/hang/src/error.rs b/rs/hang/src/error.rs
index 0cacef551..420a04680 100644
--- a/rs/hang/src/error.rs
+++ b/rs/hang/src/error.rs
@@ -54,7 +54,6 @@ pub enum Error {
 	#[error("hex error: {0}")]
 	Hex(#[from] hex::FromHexError),
 
-	/// The timestamp is too large.
 	#[error("timestamp overflow")]
 	TimestampOverflow(#[from] moq_lite::TimeOverflow),
 
diff --git a/rs/hang/src/import/aac.rs b/rs/hang/src/import/aac.rs
index 065282374..0a556806e 100644
--- a/rs/hang/src/import/aac.rs
+++ b/rs/hang/src/import/aac.rs
@@ -2,21 +2,20 @@ use crate as hang;
 use anyhow::Context;
 use buf_list::BufList;
 use bytes::Buf;
-use moq_lite as moq;
 
 /// AAC decoder, initialized via AudioSpecificConfig (variable length from ESDS box).
 pub struct Aac {
-	broadcast: hang::BroadcastProducer,
-	track: Option<hang::TrackProducer>,
-	zero: Option<tokio::time::Instant>,
+	broadcast: moq_lite::BroadcastProducer,
+	catalog: hang::CatalogProducer,
+	track: Option<moq_lite::TrackProducer>,
 }
 
 impl Aac {
-	pub fn new(broadcast: hang::BroadcastProducer) -> Self {
+	pub fn new(broadcast: moq_lite::BroadcastProducer, catalog: hang::CatalogProducer) -> Self {
 		Self {
 			broadcast,
 			track: None,
-			zero: None,
+			catalog,
 		}
 	}
 
@@ -96,29 +95,27 @@ impl Aac {
 			(object_type, sample_rate, channel_count)
 		};
 
-		let track = moq::Track {
-			name: self.broadcast.track_name("audio"),
-			priority: 2,
-		};
+		let mut catalog = self.catalog.lock();
 
-		let config = hang::catalog::AudioConfig {
-			codec: hang::catalog::AAC { profile }.into(),
+		let config = hang::AudioConfig {
+			codec: hang::AAC { profile }.into(),
 			sample_rate,
 			channel_count,
 			bitrate: None,
 			description: None,
 		};
 
-		tracing::debug!(name = ?track.name, ?config, "starting track");
+		let track = catalog.audio.create("aac", config.clone());
+		tracing::info!(%track, ?config, "started track");
 
-		let track = track.produce();
-		self.broadcast.insert_track(track.consumer);
-
-		let mut catalog = self.broadcast.catalog.lock();
-		let audio = catalog.insert_audio(track.producer.info.name.clone(), config);
-		audio.priority = 2;
+		let delivery = moq_lite::Delivery {
+			priority: 2,
+			max_latency: super::DEFAULT_MAX_LATENCY,
+			ordered: false,
+		};
 
-		self.track = Some(track.producer.into());
+		let producer = self.broadcast.create_track(track, delivery)?;
+		self.track = Some(producer);
 
 		Ok(())
 	}
@@ -133,13 +130,15 @@ impl Aac {
 			payload.push_chunk(buf.copy_to_bytes(buf.chunk().len()));
 		}
 
-		let frame = hang::Frame {
+		let container = hang::Container {
 			timestamp: pts,
-			keyframe: true,
 			payload,
 		};
 
-		track.write(frame)?;
+		// Each audio frame is a single group, because they are independent.
+		let mut group = track.append_group()?;
+		container.encode(&mut group)?;
+		group.close()?;
 
 		Ok(())
 	}
@@ -153,17 +152,18 @@ impl Aac {
 			return Ok(pts);
 		}
 
-		let zero = self.zero.get_or_insert_with(tokio::time::Instant::now);
-		Ok(hang::Timestamp::from_micros(zero.elapsed().as_micros() as u64)?)
+		// Default to the unix timestamp
+		Ok(hang::Timestamp::now())
 	}
 }
 
 impl Drop for Aac {
 	fn drop(&mut self) {
-		if let Some(track) = self.track.take() {
-			tracing::debug!(name = ?track.info.name, "ending track");
-			self.broadcast.catalog.lock().remove_audio(&track.info.name);
-		}
+		let Some(mut track) = self.track.take() else { return };
+		track.close().ok();
+
+		let config = self.catalog.lock().audio.remove(&track).unwrap();
+		tracing::debug!(track = %track.info(), ?config, "ended track");
 	}
 }
 
diff --git a/rs/hang/src/import/avc3.rs b/rs/hang/src/import/avc3.rs
index 51f2094c5..e5ac70a7e 100644
--- a/rs/hang/src/import/avc3.rs
+++ b/rs/hang/src/import/avc3.rs
@@ -4,36 +4,38 @@ use crate::import::annexb::{NalIterator, START_CODE};
 use anyhow::Context;
 use buf_list::BufList;
 use bytes::{Buf, Bytes};
-use moq_lite as moq;
 
 /// A decoder for H.264 with inline SPS/PPS.
 pub struct Avc3 {
 	// The broadcast being produced.
-	// This `hang` variant includes a catalog.
-	broadcast: hang::BroadcastProducer,
+	broadcast: moq_lite::BroadcastProducer,
+
+	// The catalog being produced.
+	catalog: hang::CatalogProducer,
 
 	// The track being produced.
-	track: Option<hang::TrackProducer>,
+	track: Option<moq_lite::TrackProducer>,
+
+	// The group being built, None if there's no i-frame yet.
+	group: Option<moq_lite::GroupProducer>,
 
 	// Whether the track has been initialized.
 	// If it changes, then we'll reinitialize with a new track.
-	config: Option<hang::catalog::VideoConfig>,
+	config: Option<hang::VideoConfig>,
 
 	// The current frame being built.
 	current: Frame,
-
-	// Used to compute wall clock timestamps if needed.
-	zero: Option<tokio::time::Instant>,
 }
 
 impl Avc3 {
-	pub fn new(broadcast: hang::BroadcastProducer) -> Self {
+	pub fn new(broadcast: moq_lite::BroadcastProducer, catalog: hang::CatalogProducer) -> Self {
 		Self {
 			broadcast,
+			catalog,
 			track: None,
+			group: None,
 			config: None,
 			current: Default::default(),
-			zero: None,
 		}
 	}
 
@@ -45,10 +47,10 @@ impl Avc3 {
 			| ((sps.constraint_set4_flag as u8) << 3)
 			| ((sps.constraint_set5_flag as u8) << 2);
 
-		let config = hang::catalog::VideoConfig {
+		let config = hang::VideoConfig {
 			coded_width: Some(sps.width),
 			coded_height: Some(sps.height),
-			codec: hang::catalog::H264 {
+			codec: hang::H264 {
 				profile: sps.profile_idc,
 				constraints: constraint_flags,
 				level: sps.level_idc,
@@ -70,29 +72,25 @@ impl Avc3 {
 			}
 		}
 
+		let mut catalog = self.catalog.lock();
+
 		if let Some(track) = &self.track.take() {
-			tracing::debug!(name = ?track.info.name, "reinitializing track");
-			self.broadcast.catalog.lock().remove_video(&track.info.name);
+			tracing::info!(track = %track.info(), "reinitializing track");
+			catalog.video.remove(&track.info());
 		}
 
-		let track = moq::Track {
-			name: self.broadcast.track_name("video"),
+		let track = catalog.video.create("avc3", config.clone());
+		let delivery = moq_lite::Delivery {
 			priority: 2,
+			max_latency: super::DEFAULT_MAX_LATENCY,
+			ordered: false,
 		};
 
-		tracing::debug!(name = ?track.name, ?config, "starting track");
-
-		{
-			let mut catalog = self.broadcast.catalog.lock();
-			let video = catalog.insert_video(track.name.clone(), config.clone());
-			video.priority = 2;
-		}
-
-		let track = track.produce();
-		self.broadcast.insert_track(track.consumer);
+		tracing::info!(%track, ?config, "started track");
 
+		let track = self.broadcast.create_track(track, delivery)?;
 		self.config = Some(config);
-		self.track = Some(track.producer.into());
+		self.track = Some(track);
 
 		Ok(())
 	}
@@ -227,13 +225,21 @@ impl Avc3 {
 		let pts = pts.context("missing timestamp")?;
 
 		let payload = std::mem::take(&mut self.current.chunks);
-		let frame = hang::Frame {
+
+		if self.current.contains_idr {
+			if let Some(mut group) = self.group.take() {
+				group.close()?;
+			}
+			self.group = Some(track.append_group()?);
+		}
+
+		let container = hang::Container {
 			timestamp: pts,
-			keyframe: self.current.contains_idr,
 			payload,
 		};
 
-		track.write(frame)?;
+		let group = self.group.as_mut().context("expected first frame to be an i-frame")?;
+		container.encode(group)?;
 
 		self.current.contains_idr = false;
 		self.current.contains_slice = false;
@@ -250,17 +256,18 @@ impl Avc3 {
 			return Ok(pts);
 		}
 
-		let zero = self.zero.get_or_insert_with(tokio::time::Instant::now);
-		Ok(hang::Timestamp::from_micros(zero.elapsed().as_micros() as u64)?)
+		// Default to the unix timestamp
+		Ok(hang::Timestamp::now())
 	}
 }
 
 impl Drop for Avc3 {
 	fn drop(&mut self) {
-		if let Some(track) = &self.track {
-			tracing::debug!(name = ?track.info.name, "ending track");
-			self.broadcast.catalog.lock().remove_video(&track.info.name);
-		}
+		let Some(mut track) = self.track.take() else { return };
+		track.close().ok();
+
+		let config = self.catalog.lock().video.remove(&track).unwrap();
+		tracing::info!(track = %track.info(), ?config, "ended track");
 	}
 }
 
diff --git a/rs/hang/src/import/decoder.rs b/rs/hang/src/import/decoder.rs
index 0759d00d6..4d097057e 100644
--- a/rs/hang/src/import/decoder.rs
+++ b/rs/hang/src/import/decoder.rs
@@ -74,13 +74,13 @@ pub struct Decoder {
 
 impl Decoder {
 	/// Create a new decoder with the given format.
-	pub fn new(broadcast: hang::BroadcastProducer, format: DecoderFormat) -> Self {
+	pub fn new(broadcast: moq_lite::BroadcastProducer, catalog: hang::CatalogProducer, format: DecoderFormat) -> Self {
 		let decoder = match format {
-			DecoderFormat::Avc3 => Avc3::new(broadcast).into(),
-			DecoderFormat::Fmp4 => Box::new(Fmp4::new(broadcast)).into(),
-			DecoderFormat::Hev1 => Hev1::new(broadcast).into(),
-			DecoderFormat::Aac => Aac::new(broadcast).into(),
-			DecoderFormat::Opus => Opus::new(broadcast).into(),
+			DecoderFormat::Avc3 => Avc3::new(broadcast, catalog).into(),
+			DecoderFormat::Fmp4 => Box::new(Fmp4::new(broadcast, catalog)).into(),
+			DecoderFormat::Hev1 => Hev1::new(broadcast, catalog).into(),
+			DecoderFormat::Aac => Aac::new(broadcast, catalog).into(),
+			DecoderFormat::Opus => Opus::new(broadcast, catalog).into(),
 		};
 
 		Self { decoder }
diff --git a/rs/hang/src/import/fmp4.rs b/rs/hang/src/import/fmp4.rs
index 551b6595f..a7d4ec9a9 100644
--- a/rs/hang/src/import/fmp4.rs
+++ b/rs/hang/src/import/fmp4.rs
@@ -1,11 +1,12 @@
-use crate::catalog::{AudioCodec, AudioConfig, CatalogProducer, VideoCodec, VideoConfig, AAC, AV1, H264, H265, VP9};
-use crate::{self as hang, Timestamp};
+use crate::{self as hang};
+use crate::{AudioCodec, AudioConfig, VideoCodec, VideoConfig, AAC, AV1, H264, H265, VP9};
 use anyhow::Context;
 use bytes::{Buf, Bytes, BytesMut};
-use moq_lite as moq;
 use mp4_atom::{Any, Atom, DecodeMaybe, Mdat, Moof, Moov, Trak};
 use std::collections::HashMap;
 
+const MAX_GOP: hang::Timestamp = hang::Timestamp::from_secs_unchecked(10);
+
 /// Converts fMP4/CMAF files into hang broadcast streams.
 ///
 /// This struct processes fragmented MP4 (fMP4) files and converts them into hang broadcasts.
@@ -25,15 +26,13 @@ use std::collections::HashMap;
 /// - Opus
 pub struct Fmp4 {
 	// The broadcast being produced
-	// This `hang` variant includes a catalog.
-	broadcast: hang::BroadcastProducer,
+	broadcast: moq_lite::BroadcastProducer,
 
-	// A clone of the broadcast's catalog for mutable access.
-	// This is the same underlying catalog (via Arc), just a separate binding.
-	catalog: CatalogProducer,
+	// The catalog being produced
+	catalog: hang::CatalogProducer,
 
-	// A lookup to tracks in the broadcast
-	tracks: HashMap<u32, hang::TrackProducer>,
+	// A map of track id to track/group producer.
+	tracks: HashMap<u32, (moq_lite::TrackProducer, Option<moq_lite::GroupProducer>)>,
 
 	// The timestamp of the last keyframe for each track
 	last_keyframe: HashMap<u32, hang::Timestamp>,
@@ -50,9 +49,8 @@ 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. The catalog from the `hang::BroadcastProducer` is used automatically.
-	pub fn new(broadcast: hang::BroadcastProducer) -> Self {
-		let catalog = broadcast.catalog.clone();
+	/// fMP4 file.
+	pub fn new(broadcast: moq_lite::BroadcastProducer, catalog: hang::CatalogProducer) -> Self {
 		Self {
 			broadcast,
 			catalog,
@@ -119,46 +117,40 @@ impl Fmp4 {
 			let track_id = trak.tkhd.track_id;
 			let handler = &trak.mdia.hdlr.handler;
 
-			let track = match handler.as_ref() {
+			let (track, delivery) = match handler.as_ref() {
 				b"vide" => {
 					let config = Self::init_video(trak)?;
 
-					let track = moq::Track {
-						name: self.broadcast.track_name("video"),
+					let track = catalog.video.create("fmp4", config.clone());
+					let delivery = moq_lite::Delivery {
 						priority: 1,
+						max_latency: super::DEFAULT_MAX_LATENCY,
+						ordered: false,
 					};
 
-					tracing::debug!(name = ?track.name, ?config, "starting track");
-
-					let video = catalog.insert_video(track.name.clone(), config);
-					video.priority = 1;
+					tracing::info!(%track, ?config, "started track");
 
-					let track = track.produce();
-					self.broadcast.insert_track(track.consumer);
-					track.producer
+					(track, delivery)
 				}
 				b"soun" => {
 					let config = Self::init_audio(trak)?;
 
-					let track = moq::Track {
-						name: self.broadcast.track_name("audio"),
+					let track = catalog.audio.create("fmp4", config.clone());
+					let delivery = moq_lite::Delivery {
 						priority: 2,
+						max_latency: super::DEFAULT_MAX_LATENCY,
+						ordered: false,
 					};
+					tracing::info!(%track, ?config, "started track");
 
-					tracing::debug!(name = ?track.name, ?config, "starting track");
-
-					let audio = catalog.insert_audio(track.name.clone(), config);
-					audio.priority = 2;
-
-					let track = track.produce();
-					self.broadcast.insert_track(track.consumer);
-					track.producer
+					(track, delivery)
 				}
 				b"sbtl" => anyhow::bail!("subtitle tracks are not supported"),
 				handler => anyhow::bail!("unknown track type: {:?}", handler),
 			};
 
-			self.tracks.insert(track_id, track.into());
+			let producer = self.broadcast.create_track(track, delivery)?;
+			self.tracks.insert(track_id, (producer, None));
 		}
 
 		self.moov = Some(moov);
@@ -370,7 +362,7 @@ impl Fmp4 {
 		// Loop over all of the traf boxes in the moof.
 		for traf in &moof.traf {
 			let track_id = traf.tfhd.track_id;
-			let track = self.tracks.get_mut(&track_id).context("unknown track")?;
+			let (track, group) = self.tracks.get_mut(&track_id).context("unknown track")?;
 
 			// Find the track information in the moov
 			let trak = moov
@@ -449,23 +441,28 @@ impl Fmp4 {
 					} else {
 						match self.last_keyframe.get(&track_id) {
 							// Force an audio keyframe at least every 10 seconds, but ideally at video keyframes
-							Some(prev) => timestamp - *prev > Timestamp::from_secs(10).unwrap(),
+							Some(prev) => timestamp - *prev > MAX_GOP,
 							None => true,
 						}
 					};
 
 					if keyframe {
 						self.last_keyframe.insert(track_id, timestamp);
+						if let Some(mut group) = group.take() {
+							group.close()?;
+						}
+						*group = Some(track.append_group()?);
 					}
 
 					let payload = mdat.slice(offset..(offset + size));
 
-					let frame = hang::Frame {
+					let container = hang::Container {
 						timestamp,
-						keyframe,
 						payload: payload.into(),
 					};
-					track.write(frame)?;
+
+					let group = group.as_mut().context("group must start with a keyframe")?;
+					container.encode(group)?;
 
 					dts += duration as u64;
 					offset += size;
@@ -483,7 +480,7 @@ impl Fmp4 {
 		if let (Some(min), Some(max)) = (min_timestamp, max_timestamp) {
 			let diff = max - min;
 
-			if diff > Timestamp::from_millis(1).unwrap() {
+			if diff > hang::Timestamp::from_millis(1).unwrap() {
 				tracing::warn!("fMP4 introduced {:?} of latency", diff);
 			}
 		}
@@ -494,14 +491,21 @@ impl Fmp4 {
 
 impl Drop for Fmp4 {
 	fn drop(&mut self) {
-		let mut catalog = self.broadcast.catalog.lock();
+		let mut catalog = self.catalog.lock();
 
-		for track in self.tracks.values() {
-			tracing::debug!(name = ?track.info.name, "ending track");
+		for (_, (mut track, mut group)) in self.tracks.drain() {
+			if let Some(mut group) = group.take() {
+				group.close().ok();
+			}
+
+			track.close().ok();
 
 			// We're too lazy to keep track of if this track is for audio or video, so we just remove both.
-			catalog.remove_video(&track.info.name);
-			catalog.remove_audio(&track.info.name);
+			if let Some(config) = catalog.video.remove(&track) {
+				tracing::info!(track = %track.info(), ?config, "ended track");
+			} else if let Some(config) = catalog.audio.remove(&track) {
+				tracing::info!(track = %track.info(), ?config, "ended track");
+			}
 		}
 	}
 }
diff --git a/rs/hang/src/import/hev1.rs b/rs/hang/src/import/hev1.rs
index 57d3ff111..75e43ef4c 100644
--- a/rs/hang/src/import/hev1.rs
+++ b/rs/hang/src/import/hev1.rs
@@ -4,18 +4,22 @@ use crate::import::annexb::{NalIterator, START_CODE};
 use anyhow::Context;
 use buf_list::BufList;
 use bytes::{Buf, Bytes};
-use moq_lite as moq;
 use scuffle_h265::{NALUnitType, SpsNALUnit};
 
 /// A decoder for H.265 with inline SPS/PPS.
 /// Only supports single layer streams, ignores VPS.
 pub struct Hev1 {
 	// The broadcast being produced.
-	// This `hang` variant includes a catalog.
-	broadcast: hang::BroadcastProducer,
+	broadcast: moq_lite::BroadcastProducer,
+
+	// The catalog being produced.
+	catalog: hang::CatalogProducer,
 
 	// The track being produced.
-	track: Option<hang::TrackProducer>,
+	track: Option<moq_lite::TrackProducer>,
+
+	// The group being built, None if there's no i-frame yet.
+	group: Option<moq_lite::GroupProducer>,
 
 	// Whether the track has been initialized.
 	// If it changes, then we'll reinitialize with a new track.
@@ -23,19 +27,17 @@ pub struct Hev1 {
 
 	// The current frame being built.
 	current: Frame,
-
-	// Used to compute wall clock timestamps if needed.
-	zero: Option<tokio::time::Instant>,
 }
 
 impl Hev1 {
-	pub fn new(broadcast: hang::BroadcastProducer) -> Self {
+	pub fn new(broadcast: moq_lite::BroadcastProducer, catalog: hang::CatalogProducer) -> Self {
 		Self {
 			broadcast,
+			catalog,
 			track: None,
+			group: None,
 			config: None,
 			current: Default::default(),
-			zero: None,
 		}
 	}
 
@@ -70,29 +72,25 @@ impl Hev1 {
 			}
 		}
 
+		let mut catalog = self.catalog.lock();
+
 		if let Some(track) = &self.track.take() {
-			tracing::debug!(name = ?track.info.name, "reinitializing track");
-			self.broadcast.catalog.lock().remove_video(&track.info.name);
+			tracing::info!(track = %track.info(), "reinitializing track");
+			catalog.video.remove(&track.info());
 		}
 
-		let track = moq::Track {
-			name: self.broadcast.track_name("video"),
+		let track = catalog.video.create("hev1", config.clone());
+		let delivery = moq_lite::Delivery {
 			priority: 2,
+			max_latency: super::DEFAULT_MAX_LATENCY,
+			ordered: false,
 		};
 
-		tracing::debug!(name = ?track.name, ?config, "starting track");
-
-		{
-			let mut catalog = self.broadcast.catalog.lock();
-			let video = catalog.insert_video(track.name.clone(), config.clone());
-			video.priority = 2;
-		}
-
-		let track = track.produce();
-		self.broadcast.insert_track(track.consumer);
+		tracing::info!(%track, ?config, "started track");
 
+		let track = self.broadcast.create_track(track, delivery)?;
 		self.config = Some(config);
-		self.track = Some(track.producer.into());
+		self.track = Some(track);
 
 		Ok(())
 	}
@@ -242,13 +240,21 @@ impl Hev1 {
 		let pts = pts.context("missing timestamp")?;
 
 		let payload = std::mem::take(&mut self.current.chunks);
-		let frame = hang::Frame {
+
+		if self.current.contains_idr {
+			if let Some(mut group) = self.group.take() {
+				group.close()?;
+			}
+			self.group = Some(track.append_group()?);
+		}
+
+		let container = hang::Container {
 			timestamp: pts,
-			keyframe: self.current.contains_idr,
 			payload,
 		};
 
-		track.write(frame)?;
+		let group = self.group.as_mut().context("expected first frame to be an i-frame")?;
+		container.encode(group)?;
 
 		self.current.contains_idr = false;
 		self.current.contains_slice = false;
@@ -265,17 +271,18 @@ impl Hev1 {
 			return Ok(pts);
 		}
 
-		let zero = self.zero.get_or_insert_with(tokio::time::Instant::now);
-		Ok(hang::Timestamp::from_micros(zero.elapsed().as_micros() as u64)?)
+		// Default to the unix timestamp
+		Ok(hang::Timestamp::now())
 	}
 }
 
 impl Drop for Hev1 {
 	fn drop(&mut self) {
-		if let Some(track) = &self.track {
-			tracing::debug!(name = ?track.info.name, "ending track");
-			self.broadcast.catalog.lock().remove_video(&track.info.name);
-		}
+		let Some(mut track) = self.track.take() else { return };
+		track.close().ok();
+
+		let config = self.catalog.lock().video.remove(&track).unwrap();
+		tracing::info!(track = %track.info(), ?config, "ended track");
 	}
 }
 
diff --git a/rs/hang/src/import/hls.rs b/rs/hang/src/import/hls.rs
index 992822be4..d0296652a 100644
--- a/rs/hang/src/import/hls.rs
+++ b/rs/hang/src/import/hls.rs
@@ -19,8 +19,8 @@ use reqwest::Client;
 use tracing::{debug, info, warn};
 use url::Url;
 
+use crate as hang;
 use crate::import::Fmp4;
-use crate::BroadcastProducer;
 
 /// Configuration for the single-rendition HLS ingest loop.
 #[derive(Clone)]
@@ -70,7 +70,10 @@ struct StepOutcome {
 /// to run the continuous ingest loop.
 pub struct Hls {
 	/// Broadcast that all CMAF importers write into.
-	broadcast: BroadcastProducer,
+	broadcast: moq_lite::BroadcastProducer,
+
+	/// Catalog being produced.
+	catalog: hang::CatalogProducer,
 
 	/// fMP4 importers for each discovered video rendition.
 	/// Each importer feeds a separate MoQ track but shares the same catalog.
@@ -112,7 +115,11 @@ impl TrackState {
 
 impl Hls {
 	/// Create a new HLS ingest that will write into the given broadcast.
-	pub fn new(broadcast: BroadcastProducer, cfg: HlsConfig) -> anyhow::Result<Self> {
+	pub fn new(
+		broadcast: moq_lite::BroadcastProducer,
+		catalog: hang::CatalogProducer,
+		cfg: HlsConfig,
+	) -> anyhow::Result<Self> {
 		let base_url = cfg.parse_playlist()?;
 		let client = cfg.client.unwrap_or_else(|| {
 			Client::builder()
@@ -122,6 +129,7 @@ impl Hls {
 		});
 		Ok(Self {
 			broadcast,
+			catalog,
 			video_importers: Vec::new(),
 			audio_importer: None,
 			client,
@@ -403,7 +411,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());
+			let importer = Fmp4::new(self.broadcast.clone(), self.catalog.clone());
 			self.video_importers.push(importer);
 		}
 
@@ -413,7 +421,7 @@ impl Hls {
 	/// Create or retrieve the fMP4 importer for the audio rendition.
 	fn ensure_audio_importer(&mut self) -> &mut Fmp4 {
 		self.audio_importer
-			.get_or_insert_with(|| Fmp4::new(self.broadcast.clone()))
+			.get_or_insert_with(|| Fmp4::new(self.broadcast.clone(), self.catalog.clone()))
 	}
 
 	#[cfg(test)]
@@ -543,10 +551,12 @@ mod tests {
 
 	#[test]
 	fn hls_ingest_starts_without_importers() {
-		let broadcast = moq_lite::Broadcast::produce().producer.into();
+		let broadcast = moq_lite::BroadcastProducer::default();
+		let catalog = hang::CatalogProducer::new(broadcast.clone()).unwrap();
+
 		let url = "https://example.com/master.m3u8".to_string();
 		let cfg = HlsConfig::new(url);
-		let hls = Hls::new(broadcast, cfg).unwrap();
+		let hls = Hls::new(broadcast, catalog, cfg).unwrap();
 
 		assert!(!hls.has_video_importer());
 		assert!(!hls.has_audio_importer());
diff --git a/rs/hang/src/import/mod.rs b/rs/hang/src/import/mod.rs
index eedf41bb2..00ba4e08a 100644
--- a/rs/hang/src/import/mod.rs
+++ b/rs/hang/src/import/mod.rs
@@ -16,3 +16,6 @@ pub use fmp4::*;
 pub use hev1::*;
 pub use hls::*;
 pub use opus::*;
+
+// TODO this should be configurable
+pub const DEFAULT_MAX_LATENCY: moq_lite::Time = moq_lite::Time::from_secs_unchecked(30);
diff --git a/rs/hang/src/import/opus.rs b/rs/hang/src/import/opus.rs
index ed5282ab7..b145c0f5a 100644
--- a/rs/hang/src/import/opus.rs
+++ b/rs/hang/src/import/opus.rs
@@ -2,21 +2,20 @@ use crate as hang;
 use anyhow::Context;
 use buf_list::BufList;
 use bytes::Buf;
-use moq_lite as moq;
 
 /// Opus decoder, initialized via a OpusHead. Does not support Ogg.
 pub struct Opus {
-	broadcast: hang::BroadcastProducer,
-	track: Option<hang::TrackProducer>,
-	zero: Option<tokio::time::Instant>,
+	broadcast: moq_lite::BroadcastProducer,
+	catalog: hang::CatalogProducer,
+	track: Option<moq_lite::TrackProducer>,
 }
 
 impl Opus {
-	pub fn new(broadcast: hang::BroadcastProducer) -> Self {
+	pub fn new(broadcast: moq_lite::BroadcastProducer, catalog: hang::CatalogProducer) -> Self {
 		Self {
 			broadcast,
+			catalog,
 			track: None,
-			zero: None,
 		}
 	}
 
@@ -42,29 +41,27 @@ impl Opus {
 			buf.advance(buf.remaining());
 		}
 
-		let track = moq::Track {
-			name: self.broadcast.track_name("audio"),
-			priority: 2,
-		};
+		let mut catalog = self.catalog.lock();
 
-		let config = hang::catalog::AudioConfig {
-			codec: hang::catalog::AudioCodec::Opus,
+		let config = hang::AudioConfig {
+			codec: hang::AudioCodec::Opus,
 			sample_rate,
 			channel_count,
 			bitrate: None,
 			description: None,
 		};
 
-		tracing::debug!(name = ?track.name, ?config, "starting track");
+		let track = catalog.audio.create("opus", config.clone());
+		tracing::info!(%track, ?config, "started track");
 
-		let track = track.produce();
-		self.broadcast.insert_track(track.consumer);
-
-		let mut catalog = self.broadcast.catalog.lock();
-		let audio = catalog.insert_audio(track.producer.info.name.clone(), config);
-		audio.priority = 2;
+		let delivery = moq_lite::Delivery {
+			priority: 2,
+			max_latency: super::DEFAULT_MAX_LATENCY,
+			ordered: false,
+		};
 
-		self.track = Some(track.producer.into());
+		let producer = self.broadcast.create_track(track, delivery)?;
+		self.track = Some(producer);
 
 		Ok(())
 	}
@@ -79,13 +76,15 @@ impl Opus {
 			payload.push_chunk(buf.copy_to_bytes(buf.chunk().len()));
 		}
 
-		let frame = hang::Frame {
+		let container = hang::Container {
 			timestamp: pts,
-			keyframe: true,
 			payload,
 		};
 
-		track.write(frame)?;
+		// Each audio frame is a single group, because they are independent.
+		let mut group = track.append_group()?;
+		container.encode(&mut group)?;
+		group.close()?;
 
 		Ok(())
 	}
@@ -99,16 +98,17 @@ impl Opus {
 			return Ok(pts);
 		}
 
-		let zero = self.zero.get_or_insert_with(tokio::time::Instant::now);
-		Ok(hang::Timestamp::from_micros(zero.elapsed().as_micros() as u64)?)
+		// Default to the unix timestamp
+		Ok(hang::Timestamp::now())
 	}
 }
 
 impl Drop for Opus {
 	fn drop(&mut self) {
-		if let Some(track) = self.track.take() {
-			tracing::debug!(name = ?track.info.name, "ending track");
-			self.broadcast.catalog.lock().remove_audio(&track.info.name);
-		}
+		let Some(mut track) = self.track.take() else { return };
+		track.close().ok();
+
+		let config = self.catalog.lock().audio.remove(&track).unwrap();
+		tracing::debug!(track = %track.info(), ?config, "ended track");
 	}
 }
diff --git a/rs/hang/src/lib.rs b/rs/hang/src/lib.rs
index 58bfba227..881db57fd 100644
--- a/rs/hang/src/lib.rs
+++ b/rs/hang/src/lib.rs
@@ -18,14 +18,15 @@
 //!
 //! This simple format works directly with WebCodecs APIs in browsers.
 //!
+mod catalog;
+mod container;
 mod error;
 
-pub mod catalog;
 pub mod import;
-pub mod model;
 
 // export the moq-lite version in use
 pub use moq_lite;
 
+pub use catalog::*;
+pub use container::*;
 pub use error::*;
-pub use model::*;
diff --git a/rs/hang/src/model/broadcast.rs b/rs/hang/src/model/broadcast.rs
deleted file mode 100644
index 62fb6eed4..000000000
--- a/rs/hang/src/model/broadcast.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-use std::{
-	ops::{Deref, DerefMut},
-	sync::{atomic, Arc},
-};
-
-use crate::{
-	catalog::{Catalog, CatalogConsumer, CatalogProducer},
-	TrackConsumer,
-};
-
-#[derive(Clone)]
-pub struct BroadcastProducer {
-	pub inner: moq_lite::BroadcastProducer,
-	pub catalog: CatalogProducer,
-
-	track_id: Arc<atomic::AtomicUsize>,
-}
-
-impl BroadcastProducer {
-	pub fn new(mut inner: moq_lite::BroadcastProducer) -> Self {
-		let catalog = Catalog::default().produce();
-		inner.insert_track(catalog.consumer.track);
-
-		Self {
-			inner,
-			catalog: catalog.producer,
-			track_id: Default::default(),
-		}
-	}
-
-	// A helper to generate a unique track name.
-	pub fn track_name(&self, prefix: &str) -> String {
-		let track_id = self.track_id.fetch_add(1, atomic::Ordering::Relaxed);
-		format!("{}{}", prefix, track_id)
-	}
-}
-
-impl Default for BroadcastProducer {
-	fn default() -> Self {
-		Self::new(moq_lite::BroadcastProducer::default())
-	}
-}
-
-impl Deref for BroadcastProducer {
-	type Target = moq_lite::BroadcastProducer;
-
-	fn deref(&self) -> &Self::Target {
-		&self.inner
-	}
-}
-
-impl DerefMut for BroadcastProducer {
-	fn deref_mut(&mut self) -> &mut Self::Target {
-		&mut self.inner
-	}
-}
-
-impl From<moq_lite::BroadcastProducer> for BroadcastProducer {
-	fn from(inner: moq_lite::BroadcastProducer) -> Self {
-		Self::new(inner)
-	}
-}
-
-impl From<BroadcastProducer> for moq_lite::BroadcastProducer {
-	fn from(producer: BroadcastProducer) -> Self {
-		producer.inner
-	}
-}
-
-#[derive(Clone)]
-pub struct BroadcastConsumer {
-	pub inner: moq_lite::BroadcastConsumer,
-	pub catalog: CatalogConsumer,
-}
-
-impl BroadcastConsumer {
-	pub fn new(inner: moq_lite::BroadcastConsumer) -> Self {
-		let catalog = inner.subscribe_track(&Catalog::default_track()).into();
-		Self { inner, catalog }
-	}
-
-	pub fn subscribe(&self, track: &moq_lite::Track, latency: std::time::Duration) -> TrackConsumer {
-		TrackConsumer::new(self.inner.subscribe_track(track), latency)
-	}
-}
-
-impl Deref for BroadcastConsumer {
-	type Target = moq_lite::BroadcastConsumer;
-
-	fn deref(&self) -> &Self::Target {
-		&self.inner
-	}
-}
-
-impl From<moq_lite::BroadcastConsumer> for BroadcastConsumer {
-	fn from(inner: moq_lite::BroadcastConsumer) -> Self {
-		Self::new(inner)
-	}
-}
diff --git a/rs/hang/src/model/frame.rs b/rs/hang/src/model/frame.rs
deleted file mode 100644
index 6432dc05c..000000000
--- a/rs/hang/src/model/frame.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-use derive_more::Debug;
-
-pub use buf_list::BufList;
-
-pub type Timestamp = moq_lite::Timescale<1_000_000>;
-
-/// A media frame with a timestamp and codec-specific payload.
-///
-/// Frames are the fundamental unit of media data in hang. Each frame contains:
-/// - A timestamp when they should be rendered.
-/// - A keyframe flag indicating whether this frame can be decoded independently
-/// - A codec-specific payload.
-#[derive(Clone, Debug)]
-pub struct Frame {
-	/// The presentation timestamp for this frame.
-	///
-	/// This indicates when the frame should be displayed relative to the
-	/// start of the stream or some other reference point.
-	/// This is NOT a wall clock time.
-	pub timestamp: Timestamp,
-
-	/// Whether this frame is a keyframe (can be decoded independently).
-	///
-	/// Keyframes are used as group boundaries and entry points for new subscribers.
-	/// It's necessary to periodically encode keyframes to support new subscribers.
-	pub keyframe: bool,
-
-	/// The encoded media data for this frame, split into chunks.
-	///
-	/// The format depends on the codec being used (H.264, AV1, Opus, etc.).
-	/// The debug implementation shows only the payload length for brevity.
-	#[debug("{} bytes", payload.num_bytes())]
-	pub payload: BufList,
-}
diff --git a/rs/hang/src/model/group.rs b/rs/hang/src/model/group.rs
deleted file mode 100644
index 912a15108..000000000
--- a/rs/hang/src/model/group.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-use std::collections::VecDeque;
-
-use crate::model::{Frame, Timestamp};
-use crate::Result;
-
-use buf_list::BufList;
-use moq_lite::coding::Decode;
-
-/// A consumer for a group of frames.
-///
-/// Groups represent collections of frames that belong together, typically
-/// bounded by keyframes in video streams. The first frame in a group is
-/// automatically marked as a keyframe.
-///
-/// This wraps a `moq_lite::GroupConsumer` and provides hang-specific functionality:
-/// - Timestamp decoding from frame headers.
-/// - Keyframe detection based on frame position
-/// - Frame buffering for latency management
-/// - Maximum timestamp tracking for group boundaries
-pub struct GroupConsumer {
-	// The group.
-	group: moq_lite::GroupConsumer,
-
-	// The current frame index
-	index: usize,
-
-	// The any buffered frames in the group.
-	buffered: VecDeque<Frame>,
-
-	// The max timestamp in the group
-	max_timestamp: Option<Timestamp>,
-}
-
-impl GroupConsumer {
-	/// Create a new group consumer from a MoQ group consumer.
-	pub fn new(group: moq_lite::GroupConsumer) -> Self {
-		Self {
-			group,
-			index: 0,
-			buffered: VecDeque::new(),
-			max_timestamp: None,
-		}
-	}
-
-	/// Read the next frame from the group.
-	///
-	/// This method automatically:
-	/// - Decodes timestamps from frame headers
-	/// - Marks the first frame as a keyframe
-	/// - Returns buffered frames when available
-	/// - Tracks the maximum timestamp seen
-	///
-	/// Returns `None` when the group has ended.
-	pub async fn read(&mut self) -> Result<Option<Frame>> {
-		if let Some(frame) = self.buffered.pop_front() {
-			Ok(Some(frame))
-		} else {
-			self.read_unbuffered().await
-		}
-	}
-
-	async fn read_unbuffered(&mut self) -> Result<Option<Frame>> {
-		let payload = match self.group.next_frame().await? {
-			Some(mut frame) => frame.read_chunks().await?,
-			None => return Ok(None),
-		};
-
-		let mut payload = BufList::from_iter(payload);
-
-		let timestamp = Timestamp::decode(&mut payload, ())?;
-
-		let frame = Frame {
-			keyframe: (self.index == 0),
-			timestamp,
-			payload,
-		};
-
-		self.index += 1;
-		self.max_timestamp = Some(self.max_timestamp.unwrap_or_default().max(timestamp));
-
-		Ok(Some(frame))
-	}
-
-	// Keep reading and buffering new frames, returning when `max` is larger than or equal to the cutoff.
-	// Not publish because the API is super weird.
-	// This will BLOCK FOREVER if the group has ended early; it's intended to be used within select!
-	pub(super) async fn buffer_until(&mut self, cutoff: Timestamp) -> Timestamp {
-		loop {
-			match self.max_timestamp {
-				Some(timestamp) if timestamp >= cutoff => return timestamp,
-				_ => (),
-			}
-
-			match self.read().await {
-				Ok(Some(frame)) => self.buffered.push_back(frame),
-				// Otherwise block forever so we don't return from FuturesUnordered
-				_ => std::future::pending().await,
-			}
-		}
-	}
-
-	/// Get the maximum timestamp seen in this group so far.
-	///
-	/// Returns `None` if no frames have been read yet.
-	pub fn max_timestamp(&self) -> Option<Timestamp> {
-		self.max_timestamp
-	}
-}
-
-impl std::ops::Deref for GroupConsumer {
-	type Target = moq_lite::GroupConsumer;
-
-	fn deref(&self) -> &Self::Target {
-		&self.group
-	}
-}
diff --git a/rs/hang/src/model/mod.rs b/rs/hang/src/model/mod.rs
deleted file mode 100644
index 4ecec6679..000000000
--- a/rs/hang/src/model/mod.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! The core model for hang, including tracks, groups, and frames.
-
-mod broadcast;
-mod frame;
-mod group;
-mod track;
-
-pub use broadcast::*;
-pub use frame::*;
-pub use group::*;
-pub use track::*;
diff --git a/rs/hang/src/model/track.rs b/rs/hang/src/model/track.rs
deleted file mode 100644
index cef4d8588..000000000
--- a/rs/hang/src/model/track.rs
+++ /dev/null
@@ -1,251 +0,0 @@
-use std::collections::VecDeque;
-use std::ops::Deref;
-
-use crate::model::{Frame, GroupConsumer, Timestamp};
-use crate::Error;
-use futures::{stream::FuturesUnordered, StreamExt};
-
-use moq_lite::{coding::*, lite};
-
-/// A producer for media tracks.
-///
-/// This wraps a `moq_lite::TrackProducer` and adds hang-specific functionality
-/// like automatic timestamp encoding and keyframe-based group management.
-///
-/// ## Group Management
-///
-/// Groups are automatically created and managed based on keyframes:
-/// - When a keyframe is written, the current group is finished and a new one begins.
-/// - Non-keyframes are appended to the current group.
-/// - Each frame includes a timestamp header for proper playback timing.
-#[derive(Clone)]
-pub struct TrackProducer {
-	pub inner: moq_lite::TrackProducer,
-	group: Option<moq_lite::GroupProducer>,
-	keyframe: Option<Timestamp>,
-}
-
-impl TrackProducer {
-	/// Create a new TrackProducer wrapping the given moq-lite producer.
-	pub fn new(inner: moq_lite::TrackProducer) -> Self {
-		Self {
-			inner,
-			group: None,
-			keyframe: None,
-		}
-	}
-
-	/// Write a frame to the track.
-	///
-	/// The frame's timestamp is automatically encoded as a header, and keyframes
-	/// trigger the creation of new groups for efficient seeking and caching.
-	///
-	/// All frames should be in *decode order*.
-	///
-	/// The timestamp is usually monotonically increasing, but it depends on the encoding.
-	/// For example, H.264 B-frames will introduce jitter and reordering.
-	pub fn write(&mut self, frame: Frame) -> Result<(), Error> {
-		tracing::trace!(?frame, "write frame");
-
-		let mut header = BytesMut::new();
-		frame.timestamp.encode(&mut header, lite::Version::Draft02);
-
-		if frame.keyframe {
-			if let Some(group) = self.group.take() {
-				group.close();
-			}
-
-			// Make sure this frame's timestamp doesn't go backwards relative to the last keyframe.
-			// We can't really enforce this for frames generally because b-frames suck.
-			if let Some(keyframe) = self.keyframe {
-				if frame.timestamp < keyframe {
-					return Err(Error::TimestampBackwards);
-				}
-			}
-
-			self.keyframe = Some(frame.timestamp);
-		}
-
-		let mut group = match self.group.take() {
-			Some(group) => group,
-			None if frame.keyframe => self.inner.append_group(),
-			// The first frame must be a keyframe.
-			None => return Err(Error::MissingKeyframe),
-		};
-
-		let size = header.len() + frame.payload.remaining();
-
-		let mut chunked = group.create_frame(size.into());
-		chunked.write_chunk(header.freeze());
-		for chunk in frame.payload {
-			chunked.write_chunk(chunk);
-		}
-		chunked.close();
-
-		self.group.replace(group);
-
-		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) -> TrackConsumer {
-		TrackConsumer::new(self.inner.consume(), max_latency)
-	}
-}
-
-impl From<moq_lite::TrackProducer> for TrackProducer {
-	fn from(inner: moq_lite::TrackProducer) -> Self {
-		Self::new(inner)
-	}
-}
-
-impl Deref for TrackProducer {
-	type Target = moq_lite::TrackProducer;
-
-	fn deref(&self) -> &Self::Target {
-		&self.inner
-	}
-}
-
-/// A consumer for hang-formatted media tracks.
-///
-/// This wraps a `moq_lite::TrackConsumer` and adds hang-specific functionality
-/// like timestamp decoding, latency management, and frame buffering.
-///
-/// ## 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 TrackConsumer {
-	pub inner: moq_lite::TrackConsumer,
-
-	// The current group that we are reading from.
-	current: Option<GroupConsumer>,
-
-	// Future groups that we are monitoring, deciding based on [latency] whether to skip.
-	pending: VecDeque<GroupConsumer>,
-
-	// The maximum timestamp seen thus far, or zero because that's easier than None.
-	max_timestamp: Timestamp,
-
-	// The maximum buffer size before skipping a group.
-	max_latency: std::time::Duration,
-}
-
-impl TrackConsumer {
-	/// Create a new TrackConsumer wrapping the given moq-lite consumer.
-	pub fn new(inner: moq_lite::TrackConsumer, max_latency: std::time::Duration) -> Self {
-		Self {
-			inner,
-			current: None,
-			pending: VecDeque::new(),
-			max_timestamp: Timestamp::default(),
-			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_frame(&mut self) -> Result<Option<Frame>, Error> {
-		let latency = self.max_latency.try_into()?;
-		loop {
-			let cutoff = self.max_timestamp.checked_add(latency)?;
-
-			// Keep track of all pending groups, buffering until we detect a timestamp far enough in the future.
-			// This is a race; only the first group will succeed.
-			// TODO is there a way to do this without FuturesUnordered?
-			let mut buffering = FuturesUnordered::new();
-			for (index, pending) in self.pending.iter_mut().enumerate() {
-				buffering.push(async move { (index, pending.buffer_until(cutoff).await) })
-			}
-
-			tokio::select! {
-				biased;
-				Some(res) = async { Some(self.current.as_mut()?.read().await) } => {
-					drop(buffering);
-
-					match res {
-						// Got the next frame.
-						Ok(Some(frame)) => {
-							tracing::trace!(?frame, "read frame");
-							self.max_timestamp = frame.timestamp;
-							return Ok(Some(frame));
-						}
-						Ok(None) | Err(_) => {
-							// Group ended, instantly move to the next group.
-							// We don't care about errors, which will happen if the group is closed early.
-							self.current = self.pending.pop_front();
-							continue;
-						}
-					};
-				},
-				Some(res) = async { self.inner.next_group().await.transpose() } => {
-					let group = GroupConsumer::new(res?);
-					drop(buffering);
-
-					match self.current.as_ref() {
-						Some(current) if group.info.sequence < current.info.sequence => {
-							// Ignore old groups
-							tracing::debug!(old = ?group.info.sequence, current = ?current.info.sequence, "skipping old group");
-						},
-						Some(_) => {
-							// Insert into pending based on the sequence number ascending.
-							let index = self.pending.partition_point(|g| g.info.sequence < group.info.sequence);
-							self.pending.insert(index, group);
-						},
-						None => self.current = Some(group),
-					};
-				},
-				Some((index, timestamp)) = buffering.next() => {
-					if self.current.is_some() {
-						tracing::debug!(old = ?self.max_timestamp, new = ?timestamp, buffer = ?self.max_latency, "skipping slow group");
-					}
-
-					drop(buffering);
-
-					if index > 0 {
-						self.pending.drain(0..index);
-						tracing::debug!(count = index, "skipping additional groups");
-					}
-
-					self.current = self.pending.pop_front();
-				}
-				else => return Ok(None),
-			}
-		}
-	}
-
-	/// 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.inner.closed().await?)
-	}
-}
-
-impl From<TrackConsumer> for moq_lite::TrackConsumer {
-	fn from(inner: TrackConsumer) -> Self {
-		inner.inner
-	}
-}
-
-impl Deref for TrackConsumer {
-	type Target = moq_lite::TrackConsumer;
-
-	fn deref(&self) -> &Self::Target {
-		&self.inner
-	}
-}
diff --git a/rs/libmoq/src/api.rs b/rs/libmoq/src/api.rs
index d3d3b0b0b..ef1f4fd13 100644
--- a/rs/libmoq/src/api.rs
+++ b/rs/libmoq/src/api.rs
@@ -193,7 +193,7 @@ pub unsafe extern "C" fn moq_origin_publish(origin: u32, path: *const c_char, pa
 		let broadcast = ffi::parse_id(broadcast)?;
 
 		let mut state = State::lock();
-		let broadcast = state.publish.get(broadcast)?.consume();
+		let broadcast = state.publish.get(broadcast)?.0.consume();
 		state.origin.publish(origin, path, broadcast)
 	})
 }
@@ -264,7 +264,7 @@ pub unsafe extern "C" fn moq_origin_consume(origin: u32, path: *const c_char, pa
 
 		let mut state = State::lock();
 		let broadcast = state.origin.consume(origin, path)?;
-		Ok(state.consume.start(broadcast.into()))
+		Ok(state.consume.start(broadcast))
 	})
 }
 
@@ -451,7 +451,7 @@ pub unsafe extern "C" fn moq_consume_video_ordered(
 	ffi::enter(move || {
 		let broadcast = ffi::parse_id(broadcast)?;
 		let index = index as usize;
-		let max_latency = std::time::Duration::from_millis(max_latency_ms);
+		let max_latency = moq_lite::Time::from_millis(max_latency_ms)?;
 		let on_frame = ffi::OnStatus::new(user_data, on_frame);
 		State::lock()
 			.consume
@@ -490,7 +490,7 @@ pub unsafe extern "C" fn moq_consume_audio_ordered(
 	ffi::enter(move || {
 		let broadcast = ffi::parse_id(broadcast)?;
 		let index = index as usize;
-		let max_latency = std::time::Duration::from_millis(max_latency_ms);
+		let max_latency = moq_lite::Time::from_millis(max_latency_ms)?;
 		let on_frame = ffi::OnStatus::new(user_data, on_frame);
 		State::lock()
 			.consume
diff --git a/rs/libmoq/src/consume.rs b/rs/libmoq/src/consume.rs
index 167fc654d..9835f3b72 100644
--- a/rs/libmoq/src/consume.rs
+++ b/rs/libmoq/src/consume.rs
@@ -1,16 +1,14 @@
 use std::ffi::c_char;
 
-use hang::TrackConsumer;
-use moq_lite::coding::Buf;
 use tokio::sync::oneshot;
 
 use crate::ffi::OnStatus;
 use crate::{moq_audio_config, moq_frame, moq_video_config, Error, Id, NonZeroSlab, State};
 
 struct ConsumeCatalog {
-	broadcast: hang::BroadcastConsumer,
+	broadcast: moq_lite::BroadcastConsumer,
 
-	catalog: hang::catalog::Catalog,
+	catalog: hang::Catalog,
 
 	/// We need to store the codec information on the heap unfortunately.
 	audio_codec: Vec<String>,
@@ -20,7 +18,7 @@ struct ConsumeCatalog {
 #[derive(Default)]
 pub struct Consume {
 	/// Active broadcast consumers.
-	broadcast: NonZeroSlab<hang::BroadcastConsumer>,
+	broadcast: NonZeroSlab<moq_lite::BroadcastConsumer>,
 
 	/// Active catalog consumers and their broadcast references.
 	catalog: NonZeroSlab<ConsumeCatalog>,
@@ -34,12 +32,12 @@ pub struct Consume {
 	/// Video track consumer task cancellation channels.
 	video_task: NonZeroSlab<oneshot::Sender<()>>,
 
-	/// Buffered frames ready for consumption.
-	frame: NonZeroSlab<hang::Frame>,
+	/// Buffered frames ready for consumption, true if a keyframe.
+	frame: NonZeroSlab<(hang::Container, bool)>,
 }
 
 impl Consume {
-	pub fn start(&mut self, broadcast: hang::BroadcastConsumer) -> Id {
+	pub fn start(&mut self, broadcast: moq_lite::BroadcastConsumer) -> Id {
 		self.broadcast.insert(broadcast)
 	}
 
@@ -62,32 +60,24 @@ impl Consume {
 		Ok(id)
 	}
 
-	async fn run_catalog(mut broadcast: hang::BroadcastConsumer, on_catalog: &mut OnStatus) -> Result<(), Error> {
-		while let Some(catalog) = broadcast.catalog.next().await? {
+	async fn run_catalog(broadcast: moq_lite::BroadcastConsumer, on_catalog: &mut OnStatus) -> Result<(), Error> {
+		let mut catalog = hang::CatalogConsumer::new(broadcast.clone());
+
+		while let Some(catalog) = catalog.next().await? {
 			// Unfortunately we need to store the codec information on the heap.
 			let audio_codec = catalog
 				.audio
-				.as_ref()
-				.map(|audio| {
-					audio
-						.renditions
-						.values()
-						.map(|config| config.codec.to_string())
-						.collect()
-				})
-				.unwrap_or_default();
+				.renditions
+				.values()
+				.map(|config| config.codec.to_string())
+				.collect();
 
 			let video_codec = catalog
 				.video
-				.as_ref()
-				.map(|video| {
-					video
-						.renditions
-						.values()
-						.map(|config| config.codec.to_string())
-						.collect()
-				})
-				.unwrap_or_default();
+				.renditions
+				.values()
+				.map(|config| config.codec.to_string())
+				.collect();
 
 			let catalog = ConsumeCatalog {
 				broadcast: broadcast.clone(),
@@ -108,13 +98,18 @@ 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::NotFound)?;
 
-		let video = consume.catalog.video.as_ref().ok_or(Error::NoIndex)?;
-		let (rendition, config) = video.renditions.iter().nth(index).ok_or(Error::NoIndex)?;
+		let (rendition, config) = consume
+			.catalog
+			.video
+			.renditions
+			.iter()
+			.nth(index)
+			.ok_or(Error::NoIndex)?;
 		let codec = consume.video_codec.get(index).ok_or(Error::NoIndex)?;
 
 		*dst = moq_video_config {
 			name: rendition.as_str().as_ptr() as *const c_char,
-			name_len: rendition.len(),
+			name_len: rendition.as_str().len(),
 			codec: codec.as_str().as_ptr() as *const c_char,
 			codec_len: codec.len(),
 			description: config
@@ -141,13 +136,18 @@ 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::NotFound)?;
 
-		let audio = consume.catalog.audio.as_ref().ok_or(Error::NoIndex)?;
-		let (rendition, config) = audio.renditions.iter().nth(index).ok_or(Error::NoIndex)?;
+		let (rendition, config) = consume
+			.catalog
+			.audio
+			.renditions
+			.iter()
+			.nth(index)
+			.ok_or(Error::NoIndex)?;
 		let codec = consume.audio_codec.get(index).ok_or(Error::NoIndex)?;
 
 		*dst = moq_audio_config {
 			name: rendition.as_str().as_ptr() as *const c_char,
-			name_len: rendition.len(),
+			name_len: rendition.as_str().len(),
 			codec: codec.as_str().as_ptr() as *const c_char,
 			codec_len: codec.len(),
 			description: config
@@ -172,18 +172,28 @@ impl Consume {
 		&mut self,
 		catalog: Id,
 		index: usize,
-		latency: std::time::Duration,
+		max_latency: moq_lite::Time,
 		mut on_frame: OnStatus,
 	) -> Result<Id, Error> {
 		let consume = self.catalog.get(catalog).ok_or(Error::NotFound)?;
-		let video = consume.catalog.video.as_ref().ok_or(Error::NotFound)?;
-		let rendition = video.renditions.keys().nth(index).ok_or(Error::NotFound)?;
+		let broadcast = consume.broadcast.clone();
+		let rendition = consume
+			.catalog
+			.video
+			.renditions
+			.keys()
+			.nth(index)
+			.ok_or(Error::NoIndex)?
+			.clone();
+
+		// TODO expose all of these via the C API
+		let delivery = moq_lite::Delivery {
+			max_latency,
+			priority: 1,
+			ordered: false,
+		};
 
-		let track = consume.broadcast.subscribe_track(&moq_lite::Track {
-			name: rendition.clone(),
-			priority: video.priority,
-		});
-		let track = TrackConsumer::new(track, latency);
+		let track = broadcast.subscribe_track(rendition, delivery)?.ordered();
 
 		let channel = oneshot::channel();
 		let id = self.video_task.insert(channel.0);
@@ -206,18 +216,28 @@ impl Consume {
 		&mut self,
 		catalog: Id,
 		index: usize,
-		latency: std::time::Duration,
+		max_latency: moq_lite::Time,
 		mut on_frame: OnStatus,
 	) -> Result<Id, Error> {
 		let consume = self.catalog.get(catalog).ok_or(Error::NotFound)?;
-		let audio = consume.catalog.audio.as_ref().ok_or(Error::NotFound)?;
-		let rendition = audio.renditions.keys().nth(index).ok_or(Error::NotFound)?;
+		let broadcast = consume.broadcast.clone();
+		let rendition = consume
+			.catalog
+			.audio
+			.renditions
+			.keys()
+			.nth(index)
+			.ok_or(Error::NoIndex)?
+			.clone();
+
+		// TODO expose all of these via the C API
+		let delivery = moq_lite::Delivery {
+			max_latency,
+			priority: 2,
+			ordered: false,
+		};
 
-		let track = consume.broadcast.subscribe_track(&moq_lite::Track {
-			name: rendition.clone(),
-			priority: audio.priority,
-		});
-		let track = TrackConsumer::new(track, latency);
+		let track = broadcast.subscribe_track(rendition, delivery)?.ordered();
 
 		let channel = oneshot::channel();
 		let id = self.audio_task.insert(channel.0);
@@ -236,30 +256,23 @@ impl Consume {
 		Ok(id)
 	}
 
-	async fn run_track(mut track: TrackConsumer, on_frame: &mut OnStatus) -> Result<(), Error> {
-		while let Some(mut frame) = track.read_frame().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::BufList::new();
-			new_payload.push_chunk(if frame.payload.num_chunks() == 1 {
-				// We can avoid allocating
-				frame.payload.get_chunk(0).expect("frame has zero chunks").clone()
-			} else {
-				// We need to allocate
-				frame.payload.copy_to_bytes(frame.payload.num_bytes())
-			});
-
-			let new_frame = hang::Frame {
-				payload: new_payload,
-				timestamp: frame.timestamp,
-				keyframe: frame.keyframe,
+	async fn run_track(mut track: moq_lite::TrackConsumerOrdered, on_frame: &mut OnStatus) -> Result<(), Error> {
+		loop {
+			let Some(mut group) = track.next_group().await? else {
+				return Ok(());
 			};
 
-			// Important: Don't hold the mutex during this callback.
-			let id = State::lock().consume.frame.insert(new_frame);
-			on_frame.call(Ok(id));
-		}
+			let mut keyframe = true;
 
-		Ok(())
+			// NOTE: We ignore errors for frames because the group can be aborted/expired at any time.
+			while let Ok(Some(frame)) = hang::Container::decode(&mut group).await {
+				// Important: Don't hold the mutex during this callback.
+				let id = State::lock().consume.frame.insert((frame, keyframe));
+				on_frame.call(Ok(id));
+
+				keyframe = false;
+			}
+		}
 	}
 
 	pub fn audio_close(&mut self, track: Id) -> Result<(), Error> {
@@ -274,9 +287,10 @@ impl Consume {
 
 	// NOTE: You're supposed to call this multiple times to get all of the chunks.
 	pub fn frame_chunk(&self, frame: Id, index: usize, dst: &mut moq_frame) -> Result<(), Error> {
-		let frame = self.frame.get(frame).ok_or(Error::NotFound)?;
+		let (frame, keyframe) = self.frame.get(frame).ok_or(Error::NotFound)?;
 		let chunk = frame.payload.get_chunk(index).ok_or(Error::NoIndex)?;
 
+		// We can't use the u128 directly because it's not a C primitive type.
 		let timestamp_us = frame
 			.timestamp
 			.as_micros()
@@ -287,7 +301,7 @@ impl Consume {
 			payload: chunk.as_ptr(),
 			payload_size: chunk.len(),
 			timestamp_us,
-			keyframe: frame.keyframe,
+			keyframe: *keyframe,
 		};
 
 		Ok(())
diff --git a/rs/libmoq/src/error.rs b/rs/libmoq/src/error.rs
index cfb5d4315..474324943 100644
--- a/rs/libmoq/src/error.rs
+++ b/rs/libmoq/src/error.rs
@@ -58,7 +58,7 @@ pub enum Error {
 	#[error("decode failed: {0}")]
 	DecodeFailed(Arc<anyhow::Error>),
 
-	/// Timestamp value overflow.
+	/// Timestamp overflow.
 	#[error("timestamp overflow")]
 	TimestampOverflow(#[from] moq_lite::TimeOverflow),
 
diff --git a/rs/libmoq/src/publish.rs b/rs/libmoq/src/publish.rs
index 27747780a..729c4bfa2 100644
--- a/rs/libmoq/src/publish.rs
+++ b/rs/libmoq/src/publish.rs
@@ -7,7 +7,7 @@ use crate::{Error, Id, NonZeroSlab};
 #[derive(Default)]
 pub struct Publish {
 	/// Active broadcast producers for publishing.
-	broadcasts: NonZeroSlab<hang::BroadcastProducer>,
+	broadcasts: NonZeroSlab<(moq_lite::BroadcastProducer, hang::CatalogProducer)>,
 
 	/// Active media encoders/decoders for publishing.
 	media: NonZeroSlab<hang::import::Decoder>,
@@ -15,12 +15,13 @@ pub struct Publish {
 
 impl Publish {
 	pub fn create(&mut self) -> Result<Id, Error> {
-		let broadcast = hang::BroadcastProducer::default();
-		let id = self.broadcasts.insert(broadcast);
+		let broadcast = moq_lite::BroadcastProducer::default();
+		let catalog = hang::CatalogProducer::new(broadcast.clone())?;
+		let id = self.broadcasts.insert((broadcast, catalog));
 		Ok(id)
 	}
 
-	pub fn get(&self, id: Id) -> Result<&hang::BroadcastProducer, Error> {
+	pub fn get(&self, id: Id) -> Result<&(moq_lite::BroadcastProducer, hang::CatalogProducer), Error> {
 		self.broadcasts.get(id).ok_or(Error::NotFound)
 	}
 
@@ -30,11 +31,11 @@ impl Publish {
 	}
 
 	pub fn media_ordered(&mut self, broadcast: Id, format: &str, mut init: &[u8]) -> Result<Id, Error> {
-		let broadcast = self.broadcasts.get(broadcast).ok_or(Error::NotFound)?;
+		let (broadcast, catalog) = self.broadcasts.get(broadcast).ok_or(Error::NotFound)?;
 
 		let format =
 			hang::import::DecoderFormat::from_str(format).map_err(|_| Error::UnknownFormat(format.to_string()))?;
-		let mut decoder = hang::import::Decoder::new(broadcast.clone(), format);
+		let mut decoder = hang::import::Decoder::new(broadcast.clone(), catalog.clone(), format);
 
 		decoder
 			.initialize(&mut init)
diff --git a/rs/moq-clock/src/clock.rs b/rs/moq-clock/src/clock.rs
index 9d74ba9cd..727813e52 100644
--- a/rs/moq-clock/src/clock.rs
+++ b/rs/moq-clock/src/clock.rs
@@ -20,7 +20,7 @@ impl Publisher {
 		let mut sequence = start.minute();
 
 		loop {
-			let segment = self.track.create_group(sequence.into()).unwrap();
+			let segment = self.track.create_group(sequence).unwrap();
 
 			sequence += 1;
 
@@ -44,11 +44,15 @@ impl Publisher {
 		// Everything but the second.
 		let base = now.format("%Y-%m-%d %H:%M:").to_string();
 
-		segment.write_frame(base.clone());
+		// The moq-lite layer needs a timestamp, so might as well use the current Unix time.
+		// It's kinda silly that we're also encoding a human-readable string but this is a toy example.
+		let timestamp = Time::from_millis(now.timestamp_millis() as u64)?;
+		segment.write_frame(base, timestamp)?;
 
 		loop {
 			let delta = now.format("%S").to_string();
-			segment.write_frame(delta.clone());
+			let timestamp = Time::from_millis(now.timestamp_millis() as u64)?;
+			segment.write_frame(delta, timestamp)?;
 
 			let next = now + chrono::Duration::try_seconds(1).unwrap();
 			let next = next.with_nanosecond(0).unwrap();
@@ -65,7 +69,7 @@ impl Publisher {
 			now = next;
 		}
 
-		segment.close();
+		segment.close()?;
 
 		Ok(())
 	}
@@ -89,7 +93,7 @@ impl Subscriber {
 
 			let base = String::from_utf8_lossy(&base);
 
-			while let Some(object) = group.read_frame().await? {
+			while let Ok(Some(object)) = group.read_frame().await {
 				let str = String::from_utf8_lossy(&object);
 				println!("{base}{str}");
 			}
diff --git a/rs/moq-clock/src/main.rs b/rs/moq-clock/src/main.rs
index f1a2ce50a..ee24c12f3 100644
--- a/rs/moq-clock/src/main.rs
+++ b/rs/moq-clock/src/main.rs
@@ -9,7 +9,6 @@ use anyhow::Context;
 use clap::Parser;
 
 mod clock;
-use moq_lite::*;
 
 #[derive(Parser, Clone)]
 pub struct Config {
@@ -53,17 +52,14 @@ async fn main() -> anyhow::Result<()> {
 
 	tracing::info!(url = ?config.url, "connecting to server");
 
-	let track = Track {
-		name: config.track,
-		priority: 0,
-	};
-
 	let origin = moq_lite::Origin::produce();
+	let mut broadcast = moq_lite::Broadcast::produce();
 
 	match config.role {
 		Command::Publish => {
-			let mut broadcast = moq_lite::Broadcast::produce();
-			let track = broadcast.producer.create_track(track);
+			let track = broadcast
+				.producer
+				.create_track(config.track, moq_lite::Delivery::default())?;
 			let clock = clock::Publisher::new(track);
 
 			origin.producer.publish_broadcast(&config.broadcast, broadcast.consumer);
@@ -100,7 +96,7 @@ async fn main() -> anyhow::Result<()> {
 					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);
+							let track = broadcast.subscribe_track(config.track.clone(), moq_lite::Delivery::default())?;
 							clock = Some(clock::Subscriber::new(track));
 						}
 						(path, None) => {
diff --git a/rs/moq-lite/Cargo.toml b/rs/moq-lite/Cargo.toml
index e22c034e0..48687697a 100644
--- a/rs/moq-lite/Cargo.toml
+++ b/rs/moq-lite/Cargo.toml
@@ -20,6 +20,7 @@ bytes = "1"
 futures = "0.3"
 hex = "0.4"
 num_enum = "0.7"
+priority-queue = "2"
 rand = "0.9.2"
 serde = { workspace = true, optional = true, features = ["rc"] }
 thiserror = "2"
diff --git a/rs/moq-lite/src/coding/reader.rs b/rs/moq-lite/src/coding/reader.rs
index daafd6456..ee5397004 100644
--- a/rs/moq-lite/src/coding/reader.rs
+++ b/rs/moq-lite/src/coding/reader.rs
@@ -1,4 +1,4 @@
-use std::{cmp, fmt::Debug, io, sync::Arc};
+use std::{cmp, io, sync::Arc};
 
 use bytes::{Buf, Bytes, BytesMut};
 
@@ -21,7 +21,7 @@ impl<S: web_transport_trait::RecvStream, V> Reader<S, V> {
 	}
 
 	/// Decode the next message from the stream.
-	pub async fn decode<T: Decode<V> + Debug>(&mut self) -> Result<T, Error>
+	pub async fn decode<T: Decode<V>>(&mut self) -> Result<T, Error>
 	where
 		V: Clone,
 	{
@@ -51,7 +51,7 @@ impl<S: web_transport_trait::RecvStream, V> Reader<S, V> {
 	}
 
 	/// Decode the next message unless the stream is closed.
-	pub async fn decode_maybe<T: Decode<V> + Debug>(&mut self) -> Result<Option<T>, Error>
+	pub async fn decode_maybe<T: Decode<V>>(&mut self) -> Result<Option<T>, Error>
 	where
 		V: Clone,
 	{
@@ -63,7 +63,7 @@ impl<S: web_transport_trait::RecvStream, V> Reader<S, V> {
 	}
 
 	/// Decode the next message from the stream without consuming it.
-	pub async fn decode_peek<T: Decode<V> + Debug>(&mut self) -> Result<T, Error>
+	pub async fn decode_peek<T: Decode<V>>(&mut self) -> Result<T, Error>
 	where
 		V: Clone,
 	{
@@ -148,18 +148,24 @@ impl<S: web_transport_trait::RecvStream, V> Reader<S, V> {
 
 	/// Wait until the stream is closed, erroring if there are any additional bytes.
 	pub async fn closed(&mut self) -> Result<(), Error> {
-		if self.buffer.is_empty()
-			&& self
-				.stream
-				.read_buf(&mut self.buffer)
-				.await
-				.map_err(|e| Error::Transport(Arc::new(e)))?
-				.is_none()
-		{
-			return Ok(());
+		if !self.buffer.is_empty() {
+			return Err(DecodeError::ExpectedEnd.into());
 		}
 
-		Err(DecodeError::ExpectedEnd.into())
+		// Ensure buffer has capacity to avoid read_buf with empty slice
+		if self.buffer.capacity() == 0 {
+			self.buffer.reserve(1024);
+		}
+
+		match self
+			.stream
+			.read_buf(&mut self.buffer)
+			.await
+			.map_err(|e| Error::Transport(Arc::new(e)))?
+		{
+			None => Ok(()),
+			Some(_) => Err(DecodeError::ExpectedEnd.into()),
+		}
 	}
 
 	/// Abort the stream with the given error.
diff --git a/rs/moq-lite/src/coding/writer.rs b/rs/moq-lite/src/coding/writer.rs
index 9ff9d5dbe..c5d33c411 100644
--- a/rs/moq-lite/src/coding/writer.rs
+++ b/rs/moq-lite/src/coding/writer.rs
@@ -1,4 +1,4 @@
-use std::{fmt::Debug, sync::Arc};
+use std::sync::Arc;
 
 use crate::{coding::*, Error};
 
@@ -20,7 +20,7 @@ impl<S: web_transport_trait::SendStream, V> Writer<S, V> {
 	}
 
 	/// Encode the given message to the stream.
-	pub async fn encode<T: Encode<V> + Debug>(&mut self, msg: &T) -> Result<(), Error>
+	pub async fn encode<T: Encode<V>>(&mut self, msg: &T) -> Result<(), Error>
 	where
 		V: Clone,
 	{
diff --git a/rs/moq-lite/src/error.rs b/rs/moq-lite/src/error.rs
index 6c9a6d4ad..a14f84ef4 100644
--- a/rs/moq-lite/src/error.rs
+++ b/rs/moq-lite/src/error.rs
@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use crate::coding;
+use crate::{coding, TimeOverflow};
 use web_transport_trait::{MaybeSend, MaybeSync};
 
 /// A trait that is Send+Sync except on WASM.
@@ -80,6 +80,15 @@ pub enum Error {
 
 	#[error("invalid role")]
 	InvalidRole,
+
+	#[error("expired")]
+	Expired,
+
+	#[error("time overflow")]
+	TimeOverflow(#[from] TimeOverflow),
+
+	#[error("dropped")]
+	Dropped,
 }
 
 impl Error {
@@ -105,7 +114,10 @@ impl Error {
 			Self::TooLarge => 18,
 			Self::TooManyParameters => 19,
 			Self::InvalidRole => 20,
+			Self::Expired => 22,
+			Self::TimeOverflow(_) => 23,
 			Self::App(app) => *app + 64,
+			Self::Dropped => 24,
 		}
 	}
 }
diff --git a/rs/moq-lite/src/ietf/parameters.rs b/rs/moq-lite/src/ietf/parameters.rs
index 5f5a26da0..1562b1191 100644
--- a/rs/moq-lite/src/ietf/parameters.rs
+++ b/rs/moq-lite/src/ietf/parameters.rs
@@ -1,40 +1,18 @@
 use std::collections::{hash_map, HashMap};
 
-use num_enum::{FromPrimitive, IntoPrimitive};
-
 use crate::coding::*;
 
 const MAX_PARAMS: u64 = 64;
 
-#[derive(Debug, Copy, Clone, FromPrimitive, IntoPrimitive, Eq, Hash, PartialEq)]
-#[repr(u64)]
-pub enum ParameterVarInt {
-	MaxRequestId = 2,
-	MaxAuthTokenCacheSize = 4,
-	#[num_enum(catch_all)]
-	Unknown(u64),
-}
-
-#[derive(Debug, Copy, Clone, FromPrimitive, IntoPrimitive, Eq, Hash, PartialEq)]
-#[repr(u64)]
-pub enum ParameterBytes {
-	Path = 1,
-	AuthorizationToken = 3,
-	Authority = 5,
-	Implementation = 7,
-	#[num_enum(catch_all)]
-	Unknown(u64),
-}
-
 #[derive(Default, Debug, Clone)]
 pub struct Parameters {
-	vars: HashMap<ParameterVarInt, u64>,
-	bytes: HashMap<ParameterBytes, Vec<u8>>,
+	ints: HashMap<u64, u64>,
+	bytes: HashMap<u64, Vec<u8>>,
 }
 
 impl<V: Clone> Decode<V> for Parameters {
 	fn decode<R: bytes::Buf>(mut r: &mut R, version: V) -> Result<Self, DecodeError> {
-		let mut vars = HashMap::new();
+		let mut ints = HashMap::new();
 		let mut bytes = HashMap::new();
 
 		// I hate this encoding so much; let me encode my role and get on with my life.
@@ -48,13 +26,11 @@ impl<V: Clone> Decode<V> for Parameters {
 			let kind = u64::decode(r, version.clone())?;
 
 			if kind % 2 == 0 {
-				let kind = ParameterVarInt::from(kind);
-				match vars.entry(kind) {
+				match ints.entry(kind) {
 					hash_map::Entry::Occupied(_) => return Err(DecodeError::Duplicate),
 					hash_map::Entry::Vacant(entry) => entry.insert(u64::decode(&mut r, version.clone())?),
 				};
 			} else {
-				let kind = ParameterBytes::from(kind);
 				match bytes.entry(kind) {
 					hash_map::Entry::Occupied(_) => return Err(DecodeError::Duplicate),
 					hash_map::Entry::Vacant(entry) => entry.insert(Vec::<u8>::decode(&mut r, version.clone())?),
@@ -62,40 +38,44 @@ impl<V: Clone> Decode<V> for Parameters {
 			}
 		}
 
-		Ok(Parameters { vars, bytes })
+		Ok(Parameters { ints, bytes })
 	}
 }
 
 impl<V: Clone> Encode<V> for Parameters {
 	fn encode<W: bytes::BufMut>(&self, w: &mut W, version: V) {
-		(self.vars.len() + self.bytes.len()).encode(w, version.clone());
+		(self.ints.len() + self.bytes.len()).encode(w, version.clone());
 
-		for (kind, value) in self.vars.iter() {
-			u64::from(*kind).encode(w, version.clone());
+		for (kind, value) in self.ints.iter() {
+			kind.encode(w, version.clone());
 			value.encode(w, version.clone());
 		}
 
 		for (kind, value) in self.bytes.iter() {
-			u64::from(*kind).encode(w, version.clone());
+			kind.encode(w, version.clone());
 			value.encode(w, version.clone());
 		}
 	}
 }
 
 impl Parameters {
-	pub fn get_varint(&self, kind: ParameterVarInt) -> Option<u64> {
-		self.vars.get(&kind).copied()
+	pub fn get_int(&self, kind: u64) -> Option<u64> {
+		assert!(kind.is_multiple_of(2));
+		self.ints.get(&kind).copied()
 	}
 
-	pub fn set_varint(&mut self, kind: ParameterVarInt, value: u64) {
-		self.vars.insert(kind, value);
+	pub fn set_int(&mut self, kind: u64, value: u64) {
+		assert!(kind.is_multiple_of(2));
+		self.ints.insert(kind, value);
 	}
 
-	pub fn get_bytes(&self, kind: ParameterBytes) -> Option<&[u8]> {
+	pub fn get_bytes(&self, kind: u64) -> Option<&[u8]> {
+		assert!(!kind.is_multiple_of(2));
 		self.bytes.get(&kind).map(|v| v.as_slice())
 	}
 
-	pub fn set_bytes(&mut self, kind: ParameterBytes, value: Vec<u8>) {
+	pub fn set_bytes(&mut self, kind: u64, value: Vec<u8>) {
+		assert!(!kind.is_multiple_of(2));
 		self.bytes.insert(kind, value);
 	}
 }
diff --git a/rs/moq-lite/src/ietf/publish.rs b/rs/moq-lite/src/ietf/publish.rs
index 84d6b4cfb..4a5e5c46f 100644
--- a/rs/moq-lite/src/ietf/publish.rs
+++ b/rs/moq-lite/src/ietf/publish.rs
@@ -110,9 +110,9 @@ use crate::{
 	coding::{Decode, DecodeError, Encode},
 	ietf::{
 		namespace::{decode_namespace, encode_namespace},
-		FilterType, GroupOrder, Location, Message, Parameters, RequestId, Version,
+		FilterType, GroupOrder, Location, Message, Parameters, RequestId, SubscribeParameter, Version,
 	},
-	Path,
+	Path, Time,
 };
 
 /// Used to be called SubscribeDone
@@ -157,8 +157,7 @@ pub struct Publish<'a> {
 	pub track_alias: u64,
 	pub group_order: GroupOrder,
 	pub largest_location: Option<Location>,
-	pub forward: bool,
-	// pub parameters: Parameters,
+	pub delivery_timeout: Time,
 }
 
 impl<'a> Message for Publish<'a> {
@@ -177,9 +176,14 @@ impl<'a> Message for Publish<'a> {
 			false.encode(w, version);
 		}
 
-		self.forward.encode(w, version);
-		// parameters
-		0u8.encode(w, version);
+		true.encode(w, version);
+
+		let mut params = Parameters::default();
+		params.set_int(
+			SubscribeParameter::DeliveryTimeout.into(),
+			self.delivery_timeout.as_millis() as u64,
+		);
+		params.encode(w, version);
 	}
 
 	fn decode_msg<R: bytes::Buf>(r: &mut R, version: Version) -> Result<Self, DecodeError> {
@@ -194,8 +198,15 @@ impl<'a> Message for Publish<'a> {
 			false => None,
 		};
 		let forward = bool::decode(r, version)?;
+		if !forward {
+			return Err(DecodeError::Unsupported);
+		}
+
 		// parameters
-		let _params = Parameters::decode(r, version)?;
+		let params = Parameters::decode(r, version)?;
+		let delivery_timeout = params.get_int(SubscribeParameter::DeliveryTimeout.into()).unwrap_or(0);
+		let delivery_timeout = Time::from_millis(delivery_timeout).map_err(|_| DecodeError::InvalidValue)?;
+
 		Ok(Self {
 			request_id,
 			track_namespace,
@@ -203,7 +214,7 @@ impl<'a> Message for Publish<'a> {
 			track_alias,
 			group_order,
 			largest_location,
-			forward,
+			delivery_timeout,
 		})
 	}
 }
@@ -211,11 +222,10 @@ impl<'a> Message for Publish<'a> {
 #[derive(Debug)]
 pub struct PublishOk {
 	pub request_id: RequestId,
-	pub forward: bool,
 	pub subscriber_priority: u8,
 	pub group_order: GroupOrder,
 	pub filter_type: FilterType,
-	// pub parameters: Parameters,
+	pub delivery_timeout: Time,
 }
 
 impl Message for PublishOk {
@@ -223,21 +233,28 @@ impl Message for PublishOk {
 
 	fn encode_msg<W: bytes::BufMut>(&self, w: &mut W, version: Version) {
 		self.request_id.encode(w, version);
-		self.forward.encode(w, version);
+		true.encode(w, version);
 		self.subscriber_priority.encode(w, version);
 		self.group_order.encode(w, version);
 		self.filter_type.encode(w, version);
-		assert!(
-			matches!(self.filter_type, FilterType::LargestObject | FilterType::NextGroup),
-			"absolute subscribe not supported"
+		assert!(matches!(
+			self.filter_type,
+			FilterType::LargestObject | FilterType::NextGroup
+		));
+		let mut params = Parameters::default();
+		params.set_int(
+			SubscribeParameter::DeliveryTimeout.into(),
+			self.delivery_timeout.as_millis() as u64,
 		);
-		// no parameters
-		0u8.encode(w, version);
+		params.encode(w, version);
 	}
 
 	fn decode_msg<R: bytes::Buf>(r: &mut R, version: Version) -> Result<Self, DecodeError> {
 		let request_id = RequestId::decode(r, version)?;
 		let forward = bool::decode(r, version)?;
+		if !forward {
+			return Err(DecodeError::Unsupported);
+		}
 		let subscriber_priority = u8::decode(r, version)?;
 		let group_order = GroupOrder::decode(r, version)?;
 		let filter_type = FilterType::decode(r, version)?;
@@ -253,14 +270,16 @@ impl Message for PublishOk {
 		};
 
 		// no parameters
-		let _params = Parameters::decode(r, version)?;
+		let params = Parameters::decode(r, version)?;
+		let delivery_timeout = params.get_int(SubscribeParameter::DeliveryTimeout.into()).unwrap_or(0);
+		let delivery_timeout = Time::from_millis(delivery_timeout).map_err(|_| DecodeError::InvalidValue)?;
 
 		Ok(Self {
 			request_id,
-			forward,
 			subscriber_priority,
 			group_order,
 			filter_type,
+			delivery_timeout,
 		})
 	}
 }
diff --git a/rs/moq-lite/src/ietf/publisher.rs b/rs/moq-lite/src/ietf/publisher.rs
index f01a6955a..b92eef09f 100644
--- a/rs/moq-lite/src/ietf/publisher.rs
+++ b/rs/moq-lite/src/ietf/publisher.rs
@@ -8,7 +8,7 @@ use crate::{
 	coding::Writer,
 	ietf::{self, Control, FetchHeader, FetchType, FilterType, GroupOrder, Location, RequestId, Version},
 	model::GroupConsumer,
-	Error, Origin, OriginConsumer, Track, TrackConsumer,
+	Delivery, Error, Origin, OriginConsumer, Time, TrackConsumer,
 };
 
 #[derive(Clone)]
@@ -91,48 +91,63 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 			}
 		};
 
-		let track = Track {
-			name: msg.track_name.to_string(),
+		let track = msg.track_name.to_string();
+
+		let delivery = Delivery {
 			priority: msg.subscriber_priority,
+			// TODO Delivery Timeout
+			max_latency: Time::from_millis(100).unwrap(),
+			// TODO Delivery order
+			ordered: false,
 		};
 
-		let track = broadcast.subscribe_track(&track);
-
 		let (tx, rx) = oneshot::channel();
 		let mut subscribes = self.subscribes.lock();
 		subscribes.insert(request_id, tx);
 
-		self.control.send(ietf::SubscribeOk {
-			request_id,
-			track_alias: request_id.0, // NOTE: using track alias as request id for now
-		})?;
-
 		let session = self.session.clone();
 		let control = self.control.clone();
 		let request_id = msg.request_id;
 		let subscribes = self.subscribes.clone();
 		let version = self.version;
 
+		let mut track = broadcast.subscribe_track(track, delivery)?;
+
 		web_async::spawn(async move {
-			if let Err(err) = Self::run_track(session, track, request_id, rx, version).await {
-				control
+			let delivery = track.delivery().current();
+
+			// TODO: This is wrong, as we haven't actually gotten a response from the origin yet.
+			control
+				.send(ietf::SubscribeOk {
+					request_id,
+					track_alias: request_id.0, // NOTE: using track alias as request id for now
+					delivery_timeout: delivery.max_latency,
+					group_order: if delivery.ordered {
+						GroupOrder::Ascending
+					} else {
+						GroupOrder::Descending
+					},
+				})
+				.ok();
+
+			match Self::run_track(session, track, request_id, rx, version).await {
+				Err(err) => control
 					.send(ietf::PublishDone {
 						request_id,
 						status_code: 500,
 						stream_count: 0, // TODO send the correct value if we want the peer to block.
 						reason_phrase: err.to_string().into(),
 					})
-					.ok();
-			} else {
-				control
+					.ok(),
+				Ok(_) => control
 					.send(ietf::PublishDone {
 						request_id,
 						status_code: 200,
 						stream_count: 0, // TODO send the correct value if we want the peer to block.
 						reason_phrase: "OK".into(),
 					})
-					.ok();
-			}
+					.ok(),
+			};
 
 			subscribes.lock().remove(&request_id);
 		});
@@ -188,15 +203,15 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 				else => return Ok(()),
 			}?;
 
-			let sequence = group.info.sequence;
+			let sequence = group.sequence;
 			let latest = new_sequence.as_ref().unwrap_or(&0);
 
-			tracing::debug!(subscribe = %request_id, track = %track.info.name, sequence, latest, "serving group");
+			tracing::debug!(subscribe = %request_id, track = %track.name, sequence, latest, "serving group");
 
 			// If this group is older than the oldest group we're serving, skip it.
 			// We always serve at most two groups, but maybe we should serve only sequence >= MAX-1.
 			if sequence < *old_sequence.as_ref().unwrap_or(&0) {
-				tracing::debug!(subscribe = %request_id, track = %track.info.name, old = %sequence, %latest, "skipping group");
+				tracing::debug!(subscribe = %request_id, track = %track.name, old = %sequence, %latest, "skipping group");
 				continue;
 			}
 
@@ -213,14 +228,14 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 			let handle = Box::pin(Self::run_group(
 				session.clone(),
 				msg,
-				track.info.priority,
+				track.subscriber().current().priority,
 				group,
 				version,
 			));
 
 			// Terminate the old group if it's still running.
 			if let Some(old_sequence) = old_sequence.take() {
-				tracing::debug!(subscribe = %request_id, track = %track.info.name, old = %old_sequence, %latest, "aborting group");
+				tracing::debug!(subscribe = %request_id, track = %track.name, old = %old_sequence, %latest, "aborting group");
 				old_group.take(); // Drop the future to cancel it.
 			}
 
@@ -281,9 +296,9 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 			}
 
 			// Write the size of the frame.
-			stream.encode(&frame.info.size).await?;
+			stream.encode(&frame.size).await?;
 
-			if frame.info.size == 0 {
+			if frame.size == 0 {
 				// Have to write the object status too.
 				stream.encode(&0u8).await?;
 			} else {
diff --git a/rs/moq-lite/src/ietf/request.rs b/rs/moq-lite/src/ietf/request.rs
index 729cb6ca0..7978c9a85 100644
--- a/rs/moq-lite/src/ietf/request.rs
+++ b/rs/moq-lite/src/ietf/request.rs
@@ -3,7 +3,7 @@ use crate::{
 	ietf::{Message, Version},
 };
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Default)]
 pub struct RequestId(pub u64);
 
 impl RequestId {
diff --git a/rs/moq-lite/src/ietf/setup.rs b/rs/moq-lite/src/ietf/setup.rs
index 27171d343..02ea6b6a9 100644
--- a/rs/moq-lite/src/ietf/setup.rs
+++ b/rs/moq-lite/src/ietf/setup.rs
@@ -2,6 +2,18 @@ use crate::{
 	coding::*,
 	ietf::{Message, Parameters, Version as IetfVersion},
 };
+use num_enum::IntoPrimitive;
+
+#[derive(Debug, Copy, Clone, IntoPrimitive, Eq, Hash, PartialEq)]
+#[repr(u64)]
+pub enum SetupParameter {
+	Path = 1,
+	MaxRequestId = 2,
+	AuthorizationToken = 3,
+	MaxAuthTokenCacheSize = 4,
+	Authority = 5,
+	Implementation = 7,
+}
 
 /// Sent by the client to setup the session.
 #[derive(Debug, Clone)]
diff --git a/rs/moq-lite/src/ietf/subscribe.rs b/rs/moq-lite/src/ietf/subscribe.rs
index 69aff38a6..dcd88568f 100644
--- a/rs/moq-lite/src/ietf/subscribe.rs
+++ b/rs/moq-lite/src/ietf/subscribe.rs
@@ -7,11 +7,18 @@ use num_enum::{IntoPrimitive, TryFromPrimitive};
 use crate::{
 	coding::*,
 	ietf::{GroupOrder, Location, Message, Parameters, RequestId, Version},
-	Path,
+	Path, Time,
 };
 
 use super::namespace::{decode_namespace, encode_namespace};
 
+#[derive(Debug, Copy, Clone, IntoPrimitive, Eq, Hash, PartialEq)]
+#[repr(u64)]
+pub enum SubscribeParameter {
+	DeliveryTimeout = 0x2,
+	MaxCacheDuration = 0x4,
+}
+
 #[derive(Clone, Copy, Debug, TryFromPrimitive, IntoPrimitive)]
 #[repr(u64)]
 pub enum FilterType {
@@ -43,6 +50,7 @@ pub struct Subscribe<'a> {
 	pub subscriber_priority: u8,
 	pub group_order: GroupOrder,
 	pub filter_type: FilterType,
+	pub delivery_timeout: Time,
 }
 
 impl<'a> Message for Subscribe<'a> {
@@ -76,14 +84,16 @@ impl<'a> Message for Subscribe<'a> {
 			FilterType::NextGroup | FilterType::LargestObject => {}
 		};
 
-		// Ignore parameters, who cares.
-		let _params = Parameters::decode(r, version)?;
+		let params = Parameters::decode(r, version)?;
+		let delivery_timeout = params.get_int(SubscribeParameter::DeliveryTimeout.into()).unwrap_or(0);
+		let delivery_timeout = Time::from_millis(delivery_timeout).map_err(|_| DecodeError::InvalidValue)?;
 
 		Ok(Self {
 			request_id,
 			track_namespace,
 			track_name,
 			subscriber_priority,
+			delivery_timeout,
 			group_order,
 			filter_type,
 		})
@@ -103,7 +113,13 @@ impl<'a> Message for Subscribe<'a> {
 		);
 
 		self.filter_type.encode(w, version);
-		0u8.encode(w, version); // no parameters
+
+		let mut params = Parameters::default();
+		params.set_int(
+			SubscribeParameter::DeliveryTimeout.into(),
+			self.delivery_timeout.as_millis() as u64,
+		);
+		params.encode(w, version);
 	}
 }
 
@@ -112,6 +128,8 @@ impl<'a> Message for Subscribe<'a> {
 pub struct SubscribeOk {
 	pub request_id: RequestId,
 	pub track_alias: u64,
+	pub delivery_timeout: Time,
+	pub group_order: GroupOrder,
 }
 
 impl Message for SubscribeOk {
@@ -120,10 +138,16 @@ impl Message for SubscribeOk {
 	fn encode_msg<W: bytes::BufMut>(&self, w: &mut W, version: Version) {
 		self.request_id.encode(w, version);
 		self.track_alias.encode(w, version);
-		0u64.encode(w, version); // expires = 0
-		GroupOrder::Descending.encode(w, version);
+		0u8.encode(w, version); // subscription expires
+		self.group_order.encode(w, version);
 		false.encode(w, version); // no content
-		0u8.encode(w, version); // no parameters
+
+		let mut params = Parameters::default();
+		params.set_int(
+			SubscribeParameter::DeliveryTimeout.into(),
+			self.delivery_timeout.as_millis() as u64,
+		);
+		params.encode(w, version);
 	}
 
 	fn decode_msg<R: bytes::Buf>(r: &mut R, version: Version) -> Result<Self, DecodeError> {
@@ -135,8 +159,7 @@ impl Message for SubscribeOk {
 			return Err(DecodeError::Unsupported);
 		}
 
-		// Ignore group order, who cares.
-		let _group_order = u8::decode(r, version)?;
+		let group_order = GroupOrder::decode(r, version)?;
 
 		// TODO: We don't support largest group/object yet
 		if bool::decode(r, version)? {
@@ -144,12 +167,15 @@ impl Message for SubscribeOk {
 			let _object = u64::decode(r, version)?;
 		}
 
-		// Ignore parameters, who cares.
-		let _params = Parameters::decode(r, version)?;
+		let params = Parameters::decode(r, version)?;
+		let delivery_timeout = params.get_int(SubscribeParameter::DeliveryTimeout.into()).unwrap_or(0);
+		let delivery_timeout = Time::from_millis(delivery_timeout).map_err(|_| DecodeError::InvalidValue)?;
 
 		Ok(Self {
 			request_id,
 			track_alias,
+			delivery_timeout,
+			group_order,
 		})
 	}
 }
@@ -221,8 +247,7 @@ pub struct SubscribeUpdate {
 	pub start_location: Location,
 	pub end_group: u64,
 	pub subscriber_priority: u8,
-	pub forward: bool,
-	// pub parameters: Parameters,
+	pub delivery_timeout: Time,
 }
 
 impl Message for SubscribeUpdate {
@@ -234,8 +259,14 @@ impl Message for SubscribeUpdate {
 		self.start_location.encode(w, version);
 		self.end_group.encode(w, version);
 		self.subscriber_priority.encode(w, version);
-		self.forward.encode(w, version);
-		0u8.encode(w, version); // no parameters
+		true.encode(w, version); // forward
+
+		let mut params = Parameters::default();
+		params.set_int(
+			SubscribeParameter::DeliveryTimeout.into(),
+			self.delivery_timeout.as_millis() as u64,
+		);
+		params.encode(w, version);
 	}
 
 	fn decode_msg<R: bytes::Buf>(r: &mut R, version: Version) -> Result<Self, DecodeError> {
@@ -245,7 +276,15 @@ impl Message for SubscribeUpdate {
 		let end_group = u64::decode(r, version)?;
 		let subscriber_priority = u8::decode(r, version)?;
 		let forward = bool::decode(r, version)?;
-		let _parameters = Parameters::decode(r, version)?;
+		if !forward {
+			return Err(DecodeError::Unsupported);
+		}
+
+		let parameters = Parameters::decode(r, version)?;
+		let delivery_timeout = parameters
+			.get_int(SubscribeParameter::DeliveryTimeout.into())
+			.unwrap_or(0);
+		let delivery_timeout = Time::from_millis(delivery_timeout).map_err(|_| DecodeError::InvalidValue)?;
 
 		Ok(Self {
 			request_id,
@@ -253,7 +292,7 @@ impl Message for SubscribeUpdate {
 			start_location,
 			end_group,
 			subscriber_priority,
-			forward,
+			delivery_timeout,
 		})
 	}
 }
@@ -283,6 +322,7 @@ mod tests {
 			subscriber_priority: 128,
 			group_order: GroupOrder::Descending,
 			filter_type: FilterType::LargestObject,
+			delivery_timeout: Time::from_millis(1000).unwrap(),
 		};
 
 		let encoded = encode_message(&msg);
@@ -292,6 +332,7 @@ mod tests {
 		assert_eq!(decoded.track_namespace.as_str(), "test");
 		assert_eq!(decoded.track_name, "video");
 		assert_eq!(decoded.subscriber_priority, 128);
+		assert_eq!(decoded.delivery_timeout, Time::from_millis(1000).unwrap());
 	}
 
 	#[test]
@@ -303,12 +344,14 @@ mod tests {
 			subscriber_priority: 255,
 			group_order: GroupOrder::Descending,
 			filter_type: FilterType::LargestObject,
+			delivery_timeout: Time::from_millis(1000).unwrap(),
 		};
 
 		let encoded = encode_message(&msg);
 		let decoded: Subscribe = decode_message(&encoded).unwrap();
 
 		assert_eq!(decoded.track_namespace.as_str(), "conference/room123");
+		assert_eq!(decoded.delivery_timeout, Time::from_millis(1000).unwrap());
 	}
 
 	#[test]
@@ -316,12 +359,17 @@ mod tests {
 		let msg = SubscribeOk {
 			request_id: RequestId(42),
 			track_alias: 42,
+			delivery_timeout: Time::from_millis(1000).unwrap(),
+			group_order: GroupOrder::Ascending,
 		};
 
 		let encoded = encode_message(&msg);
 		let decoded: SubscribeOk = decode_message(&encoded).unwrap();
 
 		assert_eq!(decoded.request_id, RequestId(42));
+		assert_eq!(decoded.track_alias, 42);
+		assert_eq!(decoded.delivery_timeout, Time::from_millis(1000).unwrap());
+		assert_eq!(decoded.group_order, GroupOrder::Ascending);
 	}
 
 	#[test]
diff --git a/rs/moq-lite/src/ietf/subscriber.rs b/rs/moq-lite/src/ietf/subscriber.rs
index 8f0de0d9c..f095b120e 100644
--- a/rs/moq-lite/src/ietf/subscriber.rs
+++ b/rs/moq-lite/src/ietf/subscriber.rs
@@ -7,7 +7,7 @@ use crate::{
 	coding::Reader,
 	ietf::{self, Control, FetchHeader, FilterType, GroupFlags, GroupOrder, RequestId, Version},
 	model::BroadcastProducer,
-	Broadcast, Error, Frame, FrameProducer, Group, GroupProducer, OriginProducer, Path, PathOwned, Track,
+	Broadcast, Delivery, Error, Frame, FrameProducer, Group, GroupProducer, OriginProducer, Path, PathOwned, Track,
 	TrackProducer,
 };
 
@@ -98,7 +98,7 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 			}
 		};
 
-		tracing::debug!(broadcast = %origin.absolute(&path), "announce");
+		tracing::debug!(broadcast = %origin.absolute(&path), "announced");
 
 		let mut this = self.clone();
 		let producer = broadcast.clone();
@@ -143,7 +143,18 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 	pub fn recv_subscribe_ok(&mut self, msg: ietf::SubscribeOk) -> Result<(), Error> {
 		// Save the track alias
 		let mut state = self.state.lock();
+
 		if let Some(subscribe) = state.subscribes.get_mut(&msg.request_id) {
+			// Respond that we got an okay.
+			let mut producer = subscribe.producer.clone();
+
+			// Update the track with information we learned from the network.
+			producer.delivery().update(Delivery {
+				priority: 0, // TODO petition to get publisher priority in SubscribeOk
+				max_latency: msg.delivery_timeout,
+				ordered: msg.group_order == GroupOrder::Ascending,
+			});
+
 			subscribe.alias = Some(msg.track_alias);
 			state.aliases.insert(msg.track_alias, msg.request_id);
 		}
@@ -154,8 +165,8 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 	pub fn recv_subscribe_error(&mut self, msg: ietf::SubscribeError) -> Result<(), Error> {
 		let mut state = self.state.lock();
 
-		if let Some(track) = state.subscribes.remove(&msg.request_id) {
-			track.producer.abort(Error::Cancel);
+		if let Some(mut track) = state.subscribes.remove(&msg.request_id) {
+			track.producer.abort(Error::Cancel)?;
 			if let Some(alias) = track.alias {
 				state.aliases.remove(&alias);
 			}
@@ -167,8 +178,8 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 	pub fn recv_publish_done(&mut self, msg: ietf::PublishDone<'_>) -> Result<(), Error> {
 		let mut state = self.state.lock();
 
-		if let Some(track) = state.subscribes.remove(&msg.request_id) {
-			track.producer.close();
+		if let Some(mut track) = state.subscribes.remove(&msg.request_id) {
+			track.producer.close()?;
 			if let Some(alias) = track.alias {
 				state.aliases.remove(&alias);
 			}
@@ -224,8 +235,8 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 			// This way we'll clean up the task when the broadcast is no longer needed.
 			let track = tokio::select! {
 				_ = broadcast.unused() => break,
-				producer = broadcast.requested_track() => match producer {
-					Some(producer) => producer,
+				track = broadcast.requested_track() => match track {
+					Some(track) => track,
 					None => break,
 				},
 				_ = self.session.closed() => break,
@@ -259,27 +270,35 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 		&mut self,
 		request_id: RequestId,
 		broadcast: Path<'_>,
-		track: TrackProducer,
+		mut track: TrackProducer,
 	) -> Result<(), Error> {
+		let mut subscribers = track.subscribers().clone();
+		let delivery = subscribers.latest().unwrap_or_default();
+
 		self.control.send(ietf::Subscribe {
 			request_id,
 			track_namespace: broadcast.to_owned(),
-			track_name: (&track.info.name).into(),
-			subscriber_priority: track.info.priority,
-			group_order: GroupOrder::Descending,
+			track_name: track.name.as_ref().into(),
+			subscriber_priority: delivery.priority,
+			group_order: if delivery.ordered {
+				GroupOrder::Ascending
+			} else {
+				GroupOrder::Descending
+			},
 			// we want largest group
 			filter_type: FilterType::LargestObject,
+			delivery_timeout: delivery.max_latency,
 		})?;
 
 		// TODO we should send a joining fetch, but it's annoying to implement.
 		// We hope instead that publisher start subscriptions at group boundaries.
 
-		tracing::info!(id = %request_id, broadcast = %self.origin.as_ref().unwrap().absolute(&broadcast), track = %track.info.name, "subscribe started");
+		tracing::info!(id = %request_id, broadcast = %self.origin.as_ref().unwrap().absolute(&broadcast), track = %track.name, "subscribe started");
 
 		track.unused().await;
-		tracing::info!(id = %request_id, broadcast = %self.origin.as_ref().unwrap().absolute(&broadcast), track = %track.info.name, "subscribe cancelled");
+		tracing::warn!(id = %request_id, broadcast = %self.origin.as_ref().unwrap().absolute(&broadcast), track = %track.name, "subscribe cancelled");
 
-		track.abort(Error::Cancel);
+		track.abort(Error::Cancel)?;
 
 		Ok(())
 	}
@@ -292,7 +311,7 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 			tracing::warn!(sub_group_id = %group.sub_group_id, "subgroup ID is not supported, stripping");
 		}
 
-		let producer = {
+		let mut producer = {
 			let mut state = self.state.lock();
 			let request_id = match state.aliases.get(&group.track_alias) {
 				Some(request_id) => *request_id,
@@ -306,7 +325,7 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 			let group = Group {
 				sequence: group.group_id,
 			};
-			track.producer.create_group(group).ok_or(Error::Old)?
+			track.producer.create_group(group)?
 		};
 
 		let res = tokio::select! {
@@ -316,16 +335,16 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 
 		match res {
 			Err(Error::Cancel) | Err(Error::Transport(_)) => {
-				tracing::trace!(group = %producer.info.sequence, "group cancelled");
-				producer.abort(Error::Cancel);
+				tracing::trace!(group = %producer.sequence, "group cancelled");
+				producer.abort(Error::Cancel)?;
 			}
 			Err(err) => {
-				tracing::debug!(%err, group = %producer.info.sequence, "group error");
-				producer.abort(err);
+				tracing::debug!(%err, group = %producer.sequence, "group error");
+				producer.abort(err)?;
 			}
 			_ => {
-				tracing::trace!(group = %producer.info.sequence, "group complete");
-				producer.close();
+				tracing::trace!(group = %producer.sequence, "group complete");
+				producer.close()?;
 			}
 		}
 
@@ -348,14 +367,19 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 				stream.skip(size).await?;
 			}
 
-			let size: u64 = stream.decode().await?;
+			let size: usize = stream.decode().await?;
 			if size == 0 {
 				// Have to read the object status.
 				let status: u64 = stream.decode().await?;
 				if status == 0 {
 					// Empty frame
-					let frame = producer.create_frame(Frame { size: 0 });
-					frame.close();
+					let mut frame = producer.create_frame(Frame {
+						// Use the receive time as the timestamp.
+						// TODO use an extension instead.
+						instant: crate::Time::now(),
+						size: 0,
+					})?;
+					frame.close()?;
 				} else if status == 3 && !group.flags.has_end {
 					// End of group
 					break;
@@ -363,22 +387,20 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 					return Err(Error::Unsupported);
 				}
 			} else {
-				let frame = producer.create_frame(Frame { size });
-
-				let res = tokio::select! {
-					_ = frame.unused() => Err(Error::Cancel),
-					res = self.run_frame(stream, frame.clone()) => res,
-				};
-
-				if let Err(err) = res {
-					frame.abort(err.clone());
+				let mut frame = producer.create_frame(Frame {
+					// Use the receive time as the timestamp.
+					// TODO use an extension instead
+					instant: crate::Time::now(),
+					size,
+				})?;
+
+				if let Err(err) = self.run_frame(stream, frame.clone()).await {
+					frame.abort(err.clone())?;
 					return Err(err);
 				}
 			}
 		}
 
-		producer.close();
-
 		Ok(())
 	}
 
@@ -387,19 +409,17 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 		stream: &mut Reader<S::RecvStream, Version>,
 		mut frame: FrameProducer,
 	) -> Result<(), Error> {
-		let mut remain = frame.info.size;
+		let mut remain = frame.size;
 
-		tracing::trace!(size = %frame.info.size, "reading frame");
+		tracing::trace!(size = %frame.size, "reading frame");
 
 		while remain > 0 {
-			let chunk = stream.read(remain as usize).await?.ok_or(Error::WrongSize)?;
-			remain = remain.checked_sub(chunk.len() as u64).ok_or(Error::WrongSize)?;
-			frame.write_chunk(chunk);
+			let chunk = stream.read(remain).await?.ok_or(Error::WrongSize)?;
+			remain = remain.checked_sub(chunk.len()).ok_or(Error::WrongSize)?;
+			frame.write_chunk(chunk)?;
 		}
 
-		tracing::trace!(size = %frame.info.size, "read frame");
-
-		frame.close();
+		frame.close()?;
 
 		Ok(())
 	}
@@ -430,10 +450,11 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 		} else {
 			self.control.send(ietf::PublishOk {
 				request_id: msg.request_id,
-				forward: true,
 				subscriber_priority: 0,
 				group_order: GroupOrder::Descending,
 				filter_type: FilterType::LargestObject,
+				// How are you even supposed to use this?
+				delivery_timeout: msg.delivery_timeout,
 			})?;
 		}
 
@@ -443,17 +464,25 @@ 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(),
+		// Announce our namespace if we haven't already.
+		// NOTE: This is debated in the IETF draft, but is significantly easier to implement.
+		let mut broadcast = self.start_announce(msg.track_namespace.to_owned())?;
+
+		let track = Track::from(msg.track_name.to_string());
+		let delivery = Delivery {
+			// TODO petition to get publisher priority in PublishOk
 			priority: 0,
-		}
-		.produce();
+			max_latency: msg.delivery_timeout,
+			ordered: msg.group_order == GroupOrder::Ascending,
+		};
+
+		let track = broadcast.create_track(track, delivery)?;
 
 		let mut state = self.state.lock();
 		match state.subscribes.entry(request_id) {
 			Entry::Vacant(entry) => {
 				entry.insert(TrackState {
-					producer: track.producer,
+					producer: track.clone(),
 					alias: Some(msg.track_alias),
 				});
 			}
@@ -462,16 +491,6 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 
 		// Save that we're implicitly announcing this track.
 		state.publishes.insert(request_id, msg.track_namespace.to_owned());
-		drop(state);
-
-		// Announce our namespace if we haven't already.
-		// NOTE: This is debated in the IETF draft, but is significantly easier to implement.
-		let mut broadcast = self.start_announce(msg.track_namespace.to_owned())?;
-
-		let exists = broadcast.insert_track(track.consumer);
-		if exists {
-			tracing::warn!(track = %msg.track_name, "track already exists, replacing it");
-		}
 
 		Ok(())
 	}
diff --git a/rs/moq-lite/src/lite/frame.rs b/rs/moq-lite/src/lite/frame.rs
new file mode 100644
index 000000000..7f239d22e
--- /dev/null
+++ b/rs/moq-lite/src/lite/frame.rs
@@ -0,0 +1,64 @@
+use bytes::Buf;
+
+use crate::{
+	coding::{Decode, DecodeError, Encode},
+	lite::Version,
+	Time,
+};
+
+#[derive(Clone, Debug)]
+pub struct FrameHeader {
+	/// The timestamp delta (in milliseconds) since the previous frame in the group.
+	pub delta: Time,
+
+	// NOTE: This is the size of the payload that still needs to be read/written.
+	// We do not encode/decode here so we can perform chunking.
+	pub size: usize,
+}
+
+// NOTE: We do not implement Message so we can perform chunking.
+// The caller is expected to read/write `size` bytes immediately afterwards.
+impl Decode<Version> for FrameHeader {
+	fn decode<R: bytes::Buf>(r: &mut R, version: Version) -> Result<Self, DecodeError> {
+		// NOTE: This is the message size.
+		let size = usize::decode(r, version)?;
+		if size > r.remaining() {
+			return Err(DecodeError::Short);
+		}
+
+		let r = &mut r.take(size);
+
+		let delta = match version {
+			Version::Draft03 => Time::decode(r, version)?,
+			// If no timestamp is provided for this protocol version, we use the current (receive) time.
+			// NOTE: The (correct) media timestamp is still in the payload for backwards compatibility.
+			Version::Draft02 | Version::Draft01 => Time::now(),
+		};
+
+		let size = r.remaining();
+
+		Ok(Self { delta, size })
+	}
+}
+
+impl Encode<Version> for FrameHeader {
+	fn encode<W: bytes::BufMut>(&self, w: &mut W, version: Version) {
+		// Unfortunately, we need to know the size of the header to calculate the message size.
+		// Encode the timestamp to the maximum buffer size first.
+		let mut tmp = [0u8; 8];
+		let mut buf = &mut tmp[..];
+
+		match version {
+			Version::Draft03 => self.delta.encode(&mut buf, version),
+			Version::Draft02 | Version::Draft01 => {}
+		}
+
+		// Compute the number of bytes used for the timestamp and write it.
+		let size = 8 - buf.len();
+
+		// Encode the total size of the timestamp and payload.
+		(self.size + size).encode(w, version);
+
+		w.put(&tmp[..size]);
+	}
+}
diff --git a/rs/moq-lite/src/lite/mod.rs b/rs/moq-lite/src/lite/mod.rs
index 1390ac283..6c8867155 100644
--- a/rs/moq-lite/src/lite/mod.rs
+++ b/rs/moq-lite/src/lite/mod.rs
@@ -5,6 +5,7 @@
 //! Specification: [<https://github.com/moq-dev/drafts>]
 
 mod announce;
+mod frame;
 mod group;
 mod info;
 mod message;
@@ -19,6 +20,7 @@ mod subscriber;
 mod version;
 
 pub use announce::*;
+pub use frame::*;
 pub use group::*;
 pub use info::*;
 pub use message::*;
diff --git a/rs/moq-lite/src/lite/publisher.rs b/rs/moq-lite/src/lite/publisher.rs
index 867db672c..3de307ea0 100644
--- a/rs/moq-lite/src/lite/publisher.rs
+++ b/rs/moq-lite/src/lite/publisher.rs
@@ -1,5 +1,6 @@
 use std::sync::Arc;
 
+use futures::{stream::FuturesUnordered, FutureExt, StreamExt};
 use web_async::FuturesExt;
 
 use crate::{
@@ -10,7 +11,7 @@ use crate::{
 		Version,
 	},
 	model::GroupConsumer,
-	AsPath, BroadcastConsumer, Error, Origin, OriginConsumer, Track, TrackConsumer,
+	AsPath, BroadcastConsumer, Delivery, Error, OriginConsumer, OriginProducer, Time, Track,
 };
 
 pub(super) struct Publisher<S: web_transport_trait::Session> {
@@ -23,7 +24,7 @@ pub(super) struct Publisher<S: web_transport_trait::Session> {
 impl<S: web_transport_trait::Session> Publisher<S> {
 	pub fn new(session: S, origin: Option<OriginConsumer>, version: Version) -> Self {
 		// Default to a dummy origin that is immediately closed.
-		let origin = origin.unwrap_or_else(|| Origin::produce().consumer);
+		let origin = origin.unwrap_or_else(|| OriginProducer::new().consume());
 		Self {
 			session,
 			origin,
@@ -65,10 +66,7 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 		web_async::spawn(async move {
 			if let Err(err) = Self::run_announce(&mut stream, &mut origin, &prefix).await {
 				match &err {
-					Error::Cancel => {
-						tracing::debug!(prefix = %origin.absolute(prefix), "announcing cancelled");
-					}
-					Error::Transport(_) => {
+					Error::Cancel | Error::Transport(_) => {
 						tracing::debug!(prefix = %origin.absolute(prefix), "announcing cancelled");
 					}
 					err => {
@@ -148,8 +146,6 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 		let track = subscribe.track.clone();
 		let absolute = self.origin.absolute(&subscribe.broadcast).to_owned();
 
-		tracing::info!(%id, broadcast = %absolute, %track, "subscribed started");
-
 		let broadcast = self.origin.consume_broadcast(&subscribe.broadcast);
 		let priority = self.priority.clone();
 		let version = self.version;
@@ -180,116 +176,103 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 		session: S,
 		stream: &mut Stream<S, Version>,
 		subscribe: &lite::Subscribe<'_>,
-		consumer: Option<BroadcastConsumer>,
+		broadcast: Option<BroadcastConsumer>,
 		priority: PriorityQueue,
 		version: Version,
 	) -> Result<(), Error> {
-		let track = Track {
-			name: subscribe.track.to_string(),
+		let track = Track::from(subscribe.track.to_string());
+
+		let delivery = Delivery {
 			priority: subscribe.priority,
+			max_latency: subscribe.max_latency,
+			ordered: subscribe.ordered,
 		};
 
-		let broadcast = consumer.ok_or(Error::NotFound)?;
-		let track = broadcast.subscribe_track(&track);
+		tracing::info!(id = %subscribe.id, broadcast = %subscribe.broadcast, track = %track.name, ?delivery, "subscribed started");
 
-		// TODO wait until track.info() to get the *real* priority
+		let mut track = broadcast.ok_or(Error::NotFound)?.subscribe_track(track, delivery)?;
+		let delivery = track.delivery().current();
 
 		let info = lite::SubscribeOk {
-			priority: track.info.priority,
+			priority: delivery.priority,
+			max_latency: delivery.max_latency,
+			ordered: delivery.ordered,
 		};
 
+		tracing::trace!(subscribe = %subscribe.id, broadcast = %subscribe.broadcast, track = %track.name, ?delivery, "subscribed ok");
+
 		stream.writer.encode(&info).await?;
 
-		tokio::select! {
-			res = Self::run_track(session, track, subscribe, priority, version) => res?,
-			res = stream.reader.closed() => res?,
-		}
+		// Just to get around ownership issues.
+		let mut delivery = track.delivery().clone();
 
-		stream.writer.finish()?;
-		stream.writer.closed().await
-	}
+		// All of the groups we're currently serving.
+		let mut tasks = FuturesUnordered::new();
 
-	async fn run_track(
-		session: S,
-		mut track: TrackConsumer,
-		subscribe: &lite::Subscribe<'_>,
-		priority: PriorityQueue,
-		version: Version,
-	) -> Result<(), Error> {
-		// TODO use a BTreeMap serve the latest N groups by sequence.
-		// Until then, we'll implement N=2 manually.
-		// Also, this is more complicated because we can't use tokio because of WASM.
-		// We need to drop futures in order to cancel them and keep polling them with select!
-		let mut old_group = None;
-		let mut new_group = None;
-
-		// Annoying that we can't use a tuple here as we need the compiler to infer the type.
-		// Otherwise we'd have to pick Send or !Send...
-		let mut old_sequence = None;
-		let mut new_sequence = None;
-
-		// Keep reading groups from the track, some of which may arrive out of order.
 		loop {
 			let group = tokio::select! {
-				biased;
 				Some(group) = track.next_group().transpose() => group,
-				Some(_) = async { Some(old_group.as_mut()?.await) } => {
-					old_group = None;
-					old_sequence = None;
+				update = stream.reader.decode_maybe::<lite::SubscribeUpdate>() => {
+					// The stream is closed, so we're done.
+					// TODO also cancel outstanding groups.
+					let Some(update) = update? else {break};
+
+					let delivery = Delivery {
+						priority: update.priority,
+						max_latency: update.max_latency,
+						ordered: update.ordered,
+					};
+
+					tracing::info!(subscribe = %subscribe.id, broadcast = %subscribe.broadcast, track = %track.name, ?delivery, "subscribed update");
+					track.subscriber().update(delivery);
+
+					// TODO update the priority of all outstanding groups.
+
 					continue;
 				},
-				Some(_) = async { Some(new_group.as_mut()?.await) } => {
-					new_group = old_group;
-					new_sequence = old_sequence;
-					old_group = None;
-					old_sequence = None;
+				Some(delivery) = delivery.changed() => {
+					let info = lite::SubscribeOk {
+						priority: delivery.priority,
+						max_latency: delivery.max_latency,
+						ordered: delivery.ordered,
+					};
+
+					tracing::info!(subscribe = %subscribe.id, broadcast = %subscribe.broadcast, track = %track.name, ?delivery, "subscribed ok");
+					stream.writer.encode(&info).await?;
+
 					continue;
+
 				},
-				else => return Ok(()),
+				// This is a hack to avoid waking up the select! loop each time a group completes.
+				// We poll all of the groups until they're all complete, only matching `else` when all are complete.
+				// We don't use tokio::spawn so we can wait until done, clean up on Drop, and support non-tokio.
+				true = async {
+					// Constantly poll all of the groups until they're all complete.
+					while tasks.next().await.is_some() {}
+					// Never match
+					false
+				} => unreachable!("never match"),
+				else => break,
 			}?;
 
-			let sequence = group.info.sequence;
-			let latest = new_sequence.as_ref().unwrap_or(&0);
-
-			tracing::debug!(subscribe = %subscribe.id, track = %track.info.name, sequence, latest, "serving group");
-
-			// If this group is older than the oldest group we're serving, skip it.
-			// We always serve at most two groups, but maybe we should serve only sequence >= MAX-1.
-			if sequence < *old_sequence.as_ref().unwrap_or(&0) {
-				tracing::debug!(subscribe = %subscribe.id, track = %track.info.name, old = %sequence, %latest, "skipping group");
-				continue;
-			}
+			tracing::debug!(subscribe = %subscribe.id, broadcast = %subscribe.broadcast, track = %track.name, group = %group.sequence, "serving group");
 
 			let msg = lite::Group {
 				subscribe: subscribe.id,
-				sequence,
+				sequence: group.sequence,
 			};
 
-			let priority = priority.insert(track.info.priority, sequence);
-
-			// Spawn a task to serve this group, ignoring any errors because they don't really matter.
-			// TODO add some logging at least.
-			let handle = Box::pin(Self::serve_group(session.clone(), msg, priority, group, version));
-
-			// Terminate the old group if it's still running.
-			if let Some(old_sequence) = old_sequence.take() {
-				tracing::debug!(subscribe = %subscribe.id, track = %track.info.name, old = %old_sequence, %latest, "aborting group");
-				old_group.take(); // Drop the future to cancel it.
-			}
+			// TODO factor in ordered.
+			let priority = priority.insert(track.subscriber().current().priority, group.sequence);
 
-			assert!(old_group.is_none());
+			// Run the group until it's closed or expires.
+			tasks.push(Self::serve_group(session.clone(), msg, priority, group, version).map(|_| ()));
+		}
 
-			if sequence >= *latest {
-				old_group = new_group;
-				old_sequence = new_sequence;
+		stream.writer.finish()?;
+		stream.writer.closed().await?;
 
-				new_group = Some(handle);
-				new_sequence = Some(sequence);
-			} else {
-				old_group = Some(handle);
-				old_sequence = Some(sequence);
-			}
-		}
+		Ok(())
 	}
 
 	async fn serve_group(
@@ -310,9 +293,11 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 		stream.encode(&lite::DataType::Group).await?;
 		stream.encode(&msg).await?;
 
+		// The maximum instant of the frames in the group.
+		let mut instant_max = Time::ZERO;
+
 		loop {
 			let frame = tokio::select! {
-				biased;
 				_ = stream.closed() => return Err(Error::Cancel),
 				frame = group.next_frame() => frame,
 				// Update the priority if it changes.
@@ -327,13 +312,26 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 				None => break,
 			};
 
-			tracing::trace!(size = %frame.info.size, "writing frame");
+			let delta = match frame.instant.checked_sub(instant_max) {
+				Ok(delta) => {
+					instant_max = frame.instant;
+					delta
+				}
+				Err(_) => {
+					tracing::warn!("frame instant went backwards");
+					Default::default()
+				}
+			};
 
-			stream.encode(&frame.info.size).await?;
+			stream
+				.encode(&lite::FrameHeader {
+					delta,
+					size: frame.size,
+				})
+				.await?;
 
 			loop {
 				let chunk = tokio::select! {
-					biased;
 					_ = stream.closed() => return Err(Error::Cancel),
 					chunk = frame.read_chunk() => chunk,
 					// Update the priority if it changes.
@@ -343,20 +341,16 @@ impl<S: web_transport_trait::Session> Publisher<S> {
 					}
 				};
 
-				match chunk? {
-					Some(mut chunk) => stream.write_all(&mut chunk).await?,
-					None => break,
-				}
+				let Some(mut chunk) = chunk? else {
+					break;
+				};
+				stream.write_all(&mut chunk).await?;
 			}
-
-			tracing::trace!(size = %frame.info.size, "wrote frame");
 		}
 
 		stream.finish()?;
 		stream.closed().await?;
 
-		tracing::debug!(sequence = %msg.sequence, "finished group");
-
 		Ok(())
 	}
 }
diff --git a/rs/moq-lite/src/lite/session.rs b/rs/moq-lite/src/lite/session.rs
index b303f8654..290597c3d 100644
--- a/rs/moq-lite/src/lite/session.rs
+++ b/rs/moq-lite/src/lite/session.rs
@@ -1,3 +1,4 @@
+use futures::FutureExt;
 use tokio::sync::oneshot;
 
 use crate::{
@@ -24,28 +25,7 @@ pub(crate) async fn start<S: web_transport_trait::Session>(
 
 	let init = oneshot::channel();
 
-	web_async::spawn(async move {
-		let res = tokio::select! {
-			res = run_session(setup) => res,
-			res = publisher.run() => res,
-			res = subscriber.run(init.0) => res,
-		};
-
-		match res {
-			Err(Error::Transport(_)) => {
-				tracing::info!("session terminated");
-				session.close(1, "");
-			}
-			Err(err) => {
-				tracing::warn!(%err, "session error");
-				session.close(err.to_code(), err.to_string().as_ref());
-			}
-			_ => {
-				tracing::info!("session closed");
-				session.close(0, "");
-			}
-		}
-	});
+	web_async::spawn(run(session, setup, publisher, subscriber, init.0).boxed());
 
 	// Wait until receiving the initial announcements to prevent some race conditions.
 	// Otherwise, `consume()` might return not found if we don't wait long enough, so just wait.
@@ -56,6 +36,35 @@ pub(crate) async fn start<S: web_transport_trait::Session>(
 	Ok(())
 }
 
+async fn run<S: web_transport_trait::Session>(
+	session: S,
+	setup: Stream<S, Version>,
+	publisher: Publisher<S>,
+	subscriber: Subscriber<S>,
+	init: oneshot::Sender<()>,
+) {
+	let res = tokio::select! {
+		res = run_session(setup) => res,
+		res = publisher.run() => res,
+		res = subscriber.run(init) => res,
+	};
+
+	match res {
+		Err(Error::Transport(_)) => {
+			tracing::info!("session terminated");
+			session.close(1, "");
+		}
+		Err(err) => {
+			tracing::warn!(%err, "session error");
+			session.close(err.to_code(), err.to_string().as_ref());
+		}
+		_ => {
+			tracing::info!("session closed");
+			session.close(0, "");
+		}
+	}
+}
+
 // TODO do something useful with this
 async fn run_session<S: web_transport_trait::Session>(mut stream: Stream<S, Version>) -> Result<(), Error> {
 	while let Some(_info) = stream.reader.decode_maybe::<SessionInfo>().await? {}
diff --git a/rs/moq-lite/src/lite/subscribe.rs b/rs/moq-lite/src/lite/subscribe.rs
index 8c3f42bd2..d4905f677 100644
--- a/rs/moq-lite/src/lite/subscribe.rs
+++ b/rs/moq-lite/src/lite/subscribe.rs
@@ -3,7 +3,7 @@ use std::borrow::Cow;
 use crate::{
 	coding::{Decode, DecodeError, Encode},
 	lite::{Message, Version},
-	Path,
+	Path, Time,
 };
 
 /// Sent by the subscriber to request all future objects for the given track.
@@ -15,6 +15,8 @@ pub struct Subscribe<'a> {
 	pub broadcast: Path<'a>,
 	pub track: Cow<'a, str>,
 	pub priority: u8,
+	pub ordered: bool,
+	pub max_latency: Time,
 }
 
 impl<'a> Message for Subscribe<'a> {
@@ -24,11 +26,18 @@ impl<'a> Message for Subscribe<'a> {
 		let track = Cow::<str>::decode(r, version)?;
 		let priority = u8::decode(r, version)?;
 
+		let (ordered, max_latency) = match version {
+			Version::Draft01 | Version::Draft02 => Default::default(),
+			Version::Draft03 => (bool::decode(r, version)?, Time::decode(r, version)?),
+		};
+
 		Ok(Self {
 			id,
 			broadcast,
 			track,
 			priority,
+			ordered,
+			max_latency,
 		})
 	}
 
@@ -37,28 +46,91 @@ impl<'a> Message for Subscribe<'a> {
 		self.broadcast.encode(w, version);
 		self.track.encode(w, version);
 		self.priority.encode(w, version);
+
+		match version {
+			Version::Draft01 | Version::Draft02 => {}
+			Version::Draft03 => {
+				self.ordered.encode(w, version);
+				self.max_latency.encode(w, version);
+			}
+		}
 	}
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default)]
 pub struct SubscribeOk {
 	pub priority: u8,
+	pub ordered: bool,
+	pub max_latency: Time,
 }
 
 impl Message for SubscribeOk {
 	fn encode_msg<W: bytes::BufMut>(&self, w: &mut W, version: Version) {
-		if version == Version::Draft01 {
-			self.priority.encode(w, version);
+		match version {
+			Version::Draft01 | Version::Draft03 => self.priority.encode(w, version),
+			Version::Draft02 => {}
+		}
+
+		match version {
+			Version::Draft01 | Version::Draft02 => {}
+			Version::Draft03 => {
+				self.ordered.encode(w, version);
+				self.max_latency.encode(w, version);
+			}
 		}
 	}
 
 	fn decode_msg<R: bytes::Buf>(r: &mut R, version: Version) -> Result<Self, DecodeError> {
-		let priority = if version == Version::Draft01 {
-			u8::decode(r, version)?
-		} else {
-			0
+		let priority = match version {
+			Version::Draft01 | Version::Draft03 => u8::decode(r, version)?,
+			Version::Draft02 => 0,
+		};
+
+		let (ordered, max_latency) = match version {
+			Version::Draft01 | Version::Draft02 => Default::default(),
+			Version::Draft03 => (bool::decode(r, version)?, Time::decode(r, version)?),
 		};
 
-		Ok(Self { priority })
+		Ok(Self {
+			priority,
+			max_latency,
+			ordered,
+		})
+	}
+}
+
+#[derive(Clone, Debug)]
+pub struct SubscribeUpdate {
+	pub priority: u8,
+	pub ordered: bool,
+	pub max_latency: Time,
+}
+
+impl Message for SubscribeUpdate {
+	fn encode_msg<W: bytes::BufMut>(&self, w: &mut W, version: Version) {
+		self.priority.encode(w, version);
+
+		match version {
+			Version::Draft01 | Version::Draft02 => {}
+			Version::Draft03 => {
+				self.ordered.encode(w, version);
+				self.max_latency.encode(w, version);
+			}
+		}
+	}
+
+	fn decode_msg<R: bytes::Buf>(r: &mut R, version: Version) -> Result<Self, DecodeError> {
+		let priority = u8::decode(r, version)?;
+
+		let (ordered, max_latency) = match version {
+			Version::Draft01 | Version::Draft02 => Default::default(),
+			Version::Draft03 => (bool::decode(r, version)?, Time::decode(r, version)?),
+		};
+
+		Ok(Self {
+			priority,
+			max_latency,
+			ordered,
+		})
 	}
 }
diff --git a/rs/moq-lite/src/lite/subscriber.rs b/rs/moq-lite/src/lite/subscriber.rs
index 6b35ff651..9ebeb0fb9 100644
--- a/rs/moq-lite/src/lite/subscriber.rs
+++ b/rs/moq-lite/src/lite/subscriber.rs
@@ -7,7 +7,7 @@ use crate::{
 	coding::{Reader, Stream},
 	lite::{self, Version},
 	model::BroadcastProducer,
-	AsPath, Broadcast, Error, Frame, FrameProducer, Group, GroupProducer, OriginProducer, Path, PathOwned,
+	AsPath, Broadcast, Delivery, Error, Frame, FrameProducer, Group, GroupProducer, OriginProducer, Path, PathOwned,
 	TrackProducer,
 };
 
@@ -112,7 +112,7 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 
 					// Close the producer.
 					let mut producer = producers.remove(&path.into_owned()).ok_or(Error::NotFound)?;
-					producer.close();
+					producer.close()?;
 				}
 			}
 		}
@@ -154,9 +154,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! {
-				_ = broadcast.unused() => break,
-				producer = broadcast.requested_track() => match producer {
-					Some(producer) => producer,
+				track = broadcast.requested_track() => match track {
+					Some(track) => track,
 					None => break,
 				},
 				_ = self.session.closed() => break,
@@ -167,70 +166,102 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 
 			let path = path.clone();
 			web_async::spawn(async move {
-				this.run_subscribe(id, path, track).await;
+				if let Err(err) = this.run_subscribe(id, path, track).await {
+					tracing::warn!(%err, id = %id, "error running subscribe");
+				}
+
 				this.subscribes.lock().remove(&id);
 			});
 		}
 	}
 
-	async fn run_subscribe(&mut self, id: u64, broadcast: Path<'_>, track: TrackProducer) {
+	async fn run_subscribe(&mut self, id: u64, broadcast: Path<'_>, mut track: TrackProducer) -> Result<(), Error> {
 		self.subscribes.lock().insert(id, track.clone());
 
-		let msg = lite::Subscribe {
-			id,
-			broadcast: broadcast.to_owned(),
-			track: (&track.info.name).into(),
-			priority: track.info.priority,
-		};
-
-		tracing::info!(id, broadcast = %self.log_path(&broadcast), track = %track.info.name, "subscribe started");
-
-		let res = tokio::select! {
-			_ = track.unused() => Err(Error::Cancel),
-			res = self.run_track(msg) => res,
-		};
-
-		match res {
-			Err(Error::Cancel) | Err(Error::Transport(_)) => {
-				tracing::info!(id, broadcast = %self.log_path(&broadcast), track = %track.info.name, "subscribe cancelled");
-				track.abort(Error::Cancel);
+		match self.run_track(id, &broadcast, &mut track).await {
+			Err(Error::Cancel) => {
+				tracing::info!(id, broadcast = %self.log_path(&broadcast), track = %track.name, "subscribe cancelled");
+				track.abort(Error::Cancel)?;
 			}
 			Err(err) => {
-				tracing::warn!(id, broadcast = %self.log_path(&broadcast), track = %track.info.name, %err, "subscribe error");
-				track.abort(err);
+				tracing::warn!(id, broadcast = %self.log_path(&broadcast), track = %track.name, %err, "subscribe error");
+				track.abort(err)?;
 			}
 			_ => {
-				tracing::info!(id, broadcast = %self.log_path(&broadcast), track = %track.info.name, "subscribe complete");
-				track.close();
+				tracing::info!(id, broadcast = %self.log_path(&broadcast), track = %track.name, "subscribe complete");
 			}
 		}
+
+		Ok(())
 	}
 
-	async fn run_track(&mut self, msg: lite::Subscribe<'_>) -> Result<(), Error> {
+	async fn run_track(&mut self, id: u64, broadcast: &Path<'_>, track: &mut TrackProducer) -> Result<(), Error> {
+		// If None, then the TrackConsumer was already closed.
+		let delivery = track.subscribers().latest().ok_or(Error::Cancel)?;
+
 		let mut stream = Stream::open(&self.session, self.version).await?;
 		stream.writer.encode(&lite::ControlType::Subscribe).await?;
 
-		if let Err(err) = self.run_track_stream(&mut stream, msg).await {
-			stream.writer.abort(&err);
-			return Err(err);
-		}
+		tracing::info!(id, broadcast = %self.log_path(broadcast), track = %track.name, ?delivery, "subscribe started");
 
-		stream.writer.finish()?;
-		stream.writer.closed().await
-	}
+		let msg = lite::Subscribe {
+			id,
+			// NOTE: Makes a copy because we're not cool.
+			broadcast: broadcast.to_owned(),
+			// NOTE: Avoids making a copy because we're cool.
+			track: track.name.as_ref().into(),
+			priority: delivery.priority,
+			max_latency: delivery.max_latency,
+			ordered: delivery.ordered,
+		};
 
-	async fn run_track_stream(
-		&mut self,
-		stream: &mut Stream<S, Version>,
-		msg: lite::Subscribe<'_>,
-	) -> Result<(), Error> {
 		stream.writer.encode(&msg).await?;
 
-		// TODO use the response correctly populate the track info
-		let _info: lite::SubscribeOk = stream.reader.decode().await?;
+		let info: lite::SubscribeOk = stream.reader.decode().await?;
 
-		// Wait until the stream is closed
-		stream.reader.closed().await?;
+		// Update the track with the delivery information we learned from the network.
+		track.delivery().update(Delivery {
+			max_latency: info.max_latency,
+			priority: info.priority,
+			ordered: info.ordered,
+		});
+
+		loop {
+			tokio::select! {
+				// Wait until the priority/latency is updated
+				// This is the same result as `track.unused()`
+				delivery = track.subscribers().changed() => {
+					// Cancel when there are no more subscribers.
+					let delivery = delivery.ok_or(Error::Cancel)?;
+					tracing::info!(subscribe = %id, track = %track.name, ?delivery, "subscribe update");
+
+					stream
+						.writer
+						.encode(&lite::SubscribeUpdate {
+							priority: delivery.priority,
+							max_latency: delivery.max_latency,
+							ordered: delivery.ordered,
+						})
+						.await?;
+				},
+				// Wait until the stream is closed
+				update = stream.reader.decode_maybe::<lite::SubscribeOk>() => {
+					let Some(update) = update? else {break};
+
+					let delivery = Delivery {
+						priority: update.priority,
+						max_latency: update.max_latency,
+						ordered: update.ordered,
+					};
+
+					tracing::info!(subscribe = %id, track = %track.name, ?delivery, "subscribe ok");
+					track.delivery().update(delivery);
+				}
+			};
+		}
+
+		stream.writer.finish()?;
+		stream.writer.closed().await?;
 
 		Ok(())
 	}
@@ -238,12 +269,12 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 	pub async fn recv_group(&mut self, stream: &mut Reader<S::RecvStream, Version>) -> Result<(), Error> {
 		let hdr: lite::Group = stream.decode().await?;
 
-		let group = {
+		let mut group = {
 			let mut subs = self.subscribes.lock();
 			let track = subs.get_mut(&hdr.subscribe).ok_or(Error::Cancel)?;
 
 			let group = Group { sequence: hdr.sequence };
-			track.create_group(group).ok_or(Error::Old)?
+			track.create_group(group)?
 		};
 
 		let res = tokio::select! {
@@ -253,16 +284,15 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 
 		match res {
 			Err(Error::Cancel) | Err(Error::Transport(_)) => {
-				tracing::trace!(group = %group.info.sequence, "group cancelled");
-				group.abort(Error::Cancel);
+				tracing::trace!(group = %group.sequence, "group cancelled");
+				group.abort(Error::Cancel)?;
 			}
 			Err(err) => {
-				tracing::debug!(%err, group = %group.info.sequence, "group error");
-				group.abort(err);
+				tracing::debug!(%err, group = %group.sequence, "group error");
+				group.abort(err)?;
 			}
 			_ => {
-				tracing::trace!(group = %group.info.sequence, "group complete");
-				group.close();
+				tracing::trace!(group = %group.sequence, "group complete");
 			}
 		}
 
@@ -274,21 +304,23 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 		stream: &mut Reader<S::RecvStream, Version>,
 		mut group: GroupProducer,
 	) -> Result<(), Error> {
-		while let Some(size) = stream.decode_maybe::<u64>().await? {
-			let frame = group.create_frame(Frame { size });
+		let mut instant = crate::Time::ZERO;
 
-			let res = tokio::select! {
-				_ = frame.unused() => Err(Error::Cancel),
-				res = self.run_frame(stream, frame.clone()) => res,
-			};
+		while let Some(frame) = stream.decode_maybe::<lite::FrameHeader>().await? {
+			instant = instant.checked_add(frame.delta)?;
+
+			let mut frame = group.create_frame(Frame {
+				instant,
+				size: frame.size,
+			})?;
 
-			if let Err(err) = res {
-				frame.abort(err.clone());
+			if let Err(err) = self.run_frame(stream, group.sequence, frame.clone()).await {
+				frame.abort(err.clone())?;
 				return Err(err);
 			}
 		}
 
-		group.close();
+		group.close()?;
 
 		Ok(())
 	}
@@ -296,25 +328,19 @@ impl<S: web_transport_trait::Session> Subscriber<S> {
 	async fn run_frame(
 		&mut self,
 		stream: &mut Reader<S::RecvStream, Version>,
+		_group: u64,
 		mut frame: FrameProducer,
 	) -> Result<(), Error> {
-		let mut remain = frame.info.size;
-
-		tracing::trace!(size = %frame.info.size, "reading frame");
+		let mut remain = frame.size;
 
 		const MAX_CHUNK: usize = 1024 * 1024; // 1 MiB
 		while remain > 0 {
-			let chunk = stream
-				.read(MAX_CHUNK.min(remain as usize))
-				.await?
-				.ok_or(Error::WrongSize)?;
-			remain = remain.checked_sub(chunk.len() as u64).ok_or(Error::WrongSize)?;
-			frame.write_chunk(chunk);
+			let chunk = stream.read(MAX_CHUNK.min(remain)).await?.ok_or(Error::WrongSize)?;
+			remain = remain.checked_sub(chunk.len()).ok_or(Error::WrongSize)?;
+			frame.write_chunk(chunk)?;
 		}
 
-		tracing::trace!(size = %frame.info.size, "read frame");
-
-		frame.close();
+		frame.close()?;
 
 		Ok(())
 	}
diff --git a/rs/moq-lite/src/lite/version.rs b/rs/moq-lite/src/lite/version.rs
index 62e462f8d..91b496371 100644
--- a/rs/moq-lite/src/lite/version.rs
+++ b/rs/moq-lite/src/lite/version.rs
@@ -11,6 +11,7 @@ pub const ALPN: &str = "moql";
 pub enum Version {
 	Draft01 = 0xff0dad01,
 	Draft02 = 0xff0dad02,
+	Draft03 = 0xff0dad03,
 }
 
 impl TryFrom<coding::Version> for Version {
@@ -21,6 +22,8 @@ impl TryFrom<coding::Version> for Version {
 			Ok(Self::Draft01)
 		} else if value == Self::Draft02.coding() {
 			Ok(Self::Draft02)
+		} else if value == Self::Draft03.coding() {
+			Ok(Self::Draft03)
 		} else {
 			Err(())
 		}
diff --git a/rs/moq-lite/src/model/broadcast.rs b/rs/moq-lite/src/model/broadcast.rs
index 35bdd2121..a7ba0d270 100644
--- a/rs/moq-lite/src/model/broadcast.rs
+++ b/rs/moq-lite/src/model/broadcast.rs
@@ -1,27 +1,11 @@
 use std::{
-	collections::HashMap,
+	collections::{hash_map, HashMap},
 	future::Future,
-	sync::{
-		atomic::{AtomicUsize, Ordering},
-		Arc,
-	},
+	sync::Arc,
 };
 
-use crate::{Error, Produce, TrackConsumer, TrackProducer};
-use tokio::sync::watch;
-use web_async::Lock;
-
-use super::Track;
-
-struct State {
-	// When explicitly publishing, we hold a reference to the consumer.
-	// This prevents the track from being marked as "unused".
-	published: HashMap<String, TrackConsumer>,
-
-	// When requesting, we hold a reference to the producer for dynamic tracks.
-	// The track will be marked as "unused" when the last consumer is dropped.
-	requested: HashMap<String, TrackProducer>,
-}
+use super::{Consumer, Delivery, Produce, Producer, Track, TrackConsumer, TrackProducer, TrackProducerWeak};
+use crate::Error;
 
 /// A collection of media tracks that can be published and subscribed to.
 ///
@@ -34,20 +18,27 @@ pub struct Broadcast {
 impl Broadcast {
 	pub fn produce() -> Produce<BroadcastProducer, BroadcastConsumer> {
 		let producer = BroadcastProducer::new();
-		let consumer = producer.consume();
-		Produce { producer, consumer }
+		Produce {
+			consumer: producer.consume(),
+			producer,
+		}
 	}
 }
 
 /// Receive broadcast/track requests and return if we can fulfill them.
+#[derive(Clone)]
 pub struct BroadcastProducer {
-	state: Lock<State>,
-	closed: watch::Sender<bool>,
+	producer: Producer<HashMap<String, TrackProducerWeak>>,
+	consumer: Producer<HashMap<String, TrackProducerWeak>>,
+
 	requested: (
+		// We need the sender so we can clone new consumers
 		async_channel::Sender<TrackProducer>,
 		async_channel::Receiver<TrackProducer>,
 	),
-	cloned: Arc<AtomicUsize>,
+
+	// Used to cancel any pending requests on drop
+	_drop: Arc<BroadcastDrop>,
 }
 
 impl Default for BroadcastProducer {
@@ -57,103 +48,159 @@ impl Default for BroadcastProducer {
 }
 
 impl BroadcastProducer {
-	fn new() -> Self {
+	pub fn new() -> Self {
+		let requested = async_channel::unbounded();
+
 		Self {
-			state: Lock::new(State {
-				published: HashMap::new(),
-				requested: HashMap::new(),
-			}),
-			closed: Default::default(),
-			requested: async_channel::unbounded(),
-			cloned: Default::default(),
+			producer: Producer::default(),
+			consumer: Producer::default(),
+			_drop: Arc::new(BroadcastDrop::new(requested.1.clone())),
+			requested,
 		}
 	}
 
-	/// Return the next requested track.
+	/// Return the next requested track, or None if there are no Consumers active.
 	pub async fn requested_track(&mut self) -> Option<TrackProducer> {
-		self.requested.1.recv().await.ok()
+		tokio::select! {
+			request = self.requested.1.recv() => request.ok(),
+			_ = self.producer.unused() => None,
+		}
 	}
 
 	/// Produce a new track and insert it into the broadcast.
-	pub fn create_track(&mut self, track: Track) -> TrackProducer {
-		let track = track.clone().produce();
-		self.insert_track(track.consumer);
-		track.producer
+	pub fn create_track<T: Into<Track>>(&mut self, track: T, delivery: Delivery) -> Result<TrackProducer, Error> {
+		let track = TrackProducer::new(track.into(), delivery);
+		self.publish_track(track.clone())?;
+		Ok(track)
 	}
 
-	/// Insert a track into the lookup, returning true if it was unique.
-	pub fn insert_track(&mut self, track: TrackConsumer) -> bool {
-		let mut state = self.state.lock();
-		let unique = state.published.insert(track.info.name.clone(), track.clone()).is_none();
-		let removed = state.requested.remove(&track.info.name).is_some();
+	/// Insert a track into the broadcast.
+	pub fn publish_track(&mut self, track: TrackProducer) -> Result<(), Error> {
+		let name = track.name.to_string();
 
-		unique && !removed
+		self.producer.modify(|state| match state.entry(name) {
+			hash_map::Entry::Vacant(entry) => {
+				entry.insert(track.weak());
+				Ok(())
+			}
+			hash_map::Entry::Occupied(_) => Err(Error::Duplicate),
+		})?
 	}
 
 	/// Remove a track from the lookup.
-	pub fn remove_track(&mut self, name: &str) -> bool {
-		let mut state = self.state.lock();
-		state.published.remove(name).is_some() || state.requested.remove(name).is_some()
+	pub fn remove_track(&mut self, name: &str) -> Result<(), Error> {
+		self.producer
+			.modify(|state| state.remove(name))?
+			.ok_or(Error::NotFound)?;
+		Ok(())
 	}
 
 	pub fn consume(&self) -> BroadcastConsumer {
 		BroadcastConsumer {
-			state: self.state.clone(),
-			closed: self.closed.subscribe(),
+			producer: self.producer.consume(),
+			consumer: self.consumer.clone(),
 			requested: self.requested.0.clone(),
 		}
 	}
 
-	pub fn close(&mut self) {
-		self.closed.send_modify(|closed| *closed = true);
+	pub fn close(&mut self) -> Result<(), Error> {
+		self.producer.close()
+	}
+
+	pub fn abort(&mut self, err: Error) -> Result<(), Error> {
+		self.producer.abort(err)
 	}
 
 	/// Block until there are no more consumers.
 	///
 	/// A new consumer can be created by calling [Self::consume] and this will block again.
 	pub fn unused(&self) -> impl Future<Output = ()> {
-		let closed = self.closed.clone();
-		async move { closed.closed().await }
+		self.producer.unused()
 	}
 
 	pub fn is_clone(&self, other: &Self) -> bool {
-		self.closed.same_channel(&other.closed)
+		self.producer.is_clone(&other.producer)
 	}
 }
 
-impl Clone for BroadcastProducer {
-	fn clone(&self) -> Self {
-		self.cloned.fetch_add(1, Ordering::Relaxed);
-		Self {
-			state: self.state.clone(),
-			closed: self.closed.clone(),
-			requested: self.requested.clone(),
-			cloned: self.cloned.clone(),
-		}
+struct BroadcastDrop {
+	requested: async_channel::Receiver<TrackProducer>,
+}
+
+impl BroadcastDrop {
+	pub fn new(requested: async_channel::Receiver<TrackProducer>) -> Self {
+		Self { requested }
 	}
 }
 
-impl Drop for BroadcastProducer {
+impl Drop for BroadcastDrop {
 	fn drop(&mut self) {
-		if self.cloned.fetch_sub(1, Ordering::Relaxed) > 0 {
-			return;
+		while let Ok(mut track) = self.requested.try_recv() {
+			track.abort(Error::Cancel).ok();
 		}
+	}
+}
 
-		// Cleanup any lingering state when the last producer is dropped.
+/// Subscribe to abitrary broadcast/tracks.
+#[derive(Clone)]
+pub struct BroadcastConsumer {
+	producer: Consumer<HashMap<String, TrackProducerWeak>>,
+	consumer: Producer<HashMap<String, TrackProducerWeak>>,
+	requested: async_channel::Sender<TrackProducer>,
+}
 
-		// Close the sender so consumers can't send any more requests.
-		self.requested.0.close();
+impl BroadcastConsumer {
+	/// Starts fetches the Track over the network, using the given settings.
+	pub fn subscribe_track(&self, track: impl Into<Track>, delivery: Delivery) -> Result<TrackConsumer, Error> {
+		let track = track.into();
 
-		// Drain any remaining requests.
-		while let Ok(producer) = self.requested.1.try_recv() {
-			producer.abort(Error::Cancel);
+		// If the track is already published, return it.
+		if let Some(existing) = self.producer.borrow().get(track.name.as_ref()).cloned() {
+			return Ok(existing.upgrade()?.subscribe(delivery));
 		}
 
-		let mut state = self.state.lock();
+		self.consumer.modify(|state| {
+			if let Some(existing) = state.get(track.name.as_ref()).cloned() {
+				if let Ok(existing) = existing.upgrade() {
+					return existing.subscribe(delivery);
+				}
+			}
+
+			// Create a new track producer using this first request's delivery information.
+			// The publisher SHOULD replace them with their own settigns on OK.
+			let mut track = TrackProducer::new(track, delivery);
+
+			let consumer = track.subscribe(delivery);
 
-		// Cleanup any published tracks.
-		state.published.clear();
-		state.requested.clear();
+			if self.requested.try_send(track.clone()).is_err() {
+				track.abort(Error::Cancel).ok();
+				return consumer;
+			}
+
+			state.insert(track.name.to_string(), track.weak());
+
+			let state = self.consumer.clone();
+
+			web_async::spawn(async move {
+				track.unused().await;
+				let _ = state.modify(|state| {
+					state.remove(track.name.as_ref());
+				});
+			});
+
+			consumer
+		})
+	}
+
+	pub async fn closed(&self) -> Result<(), Error> {
+		self.producer.closed().await
+	}
+
+	/// Check if this is the exact same instance of a broadcast.
+	///
+	/// Duplicate names are allowed in the case of resumption.
+	pub fn is_clone(&self, other: &Self) -> bool {
+		self.producer.is_clone(&other.producer)
 	}
 }
 
@@ -173,80 +220,15 @@ impl BroadcastProducer {
 	pub fn assert_request(&mut self) -> TrackProducer {
 		self.requested_track()
 			.now_or_never()
-			.expect("should not have blocked")
-			.expect("should be a request")
+			.expect("request would have blocked")
+			.expect("no request")
 	}
 
 	pub fn assert_no_request(&mut self) {
-		assert!(self.requested_track().now_or_never().is_none(), "should have blocked");
-	}
-}
-
-/// Subscribe to abitrary broadcast/tracks.
-#[derive(Clone)]
-pub struct BroadcastConsumer {
-	state: Lock<State>,
-	closed: watch::Receiver<bool>,
-	requested: async_channel::Sender<TrackProducer>,
-}
-
-impl BroadcastConsumer {
-	pub fn subscribe_track(&self, track: &Track) -> TrackConsumer {
-		let mut state = self.state.lock();
-
-		// Return any explictly published track.
-		if let Some(consumer) = state.published.get(&track.name).cloned() {
-			return consumer;
-		}
-
-		// Return any requested tracks.
-		if let Some(producer) = state.requested.get(&track.name) {
-			return producer.consume();
-		}
-
-		// Otherwise we have never seen this track before and need to create a new producer.
-		let track = track.clone().produce();
-		let producer = track.producer;
-		let consumer = track.consumer;
-
-		// Insert the producer into the lookup so we will deduplicate requests.
-		// This is not a subscriber so it doesn't count towards "used" subscribers.
-		match self.requested.try_send(producer.clone()) {
-			Ok(()) => {}
-			Err(_) => {
-				// If the BroadcastProducer is closed, immediately close the track.
-				// This is a bit more ergonomic than returning None.
-				producer.abort(Error::Cancel);
-				return consumer;
-			}
-		}
-
-		// Insert the producer into the lookup so we will deduplicate requests.
-		state.requested.insert(producer.info.name.clone(), producer.clone());
-
-		// Remove the track from the lookup when it's unused.
-		let state = self.state.clone();
-		web_async::spawn(async move {
-			producer.unused().await;
-			state.lock().requested.remove(&producer.info.name);
-		});
-
-		consumer
-	}
-
-	pub fn closed(&self) -> impl Future<Output = ()> {
-		// A hacky way to check if the broadcast is closed.
-		let mut closed = self.closed.clone();
-		async move {
-			closed.wait_for(|closed| *closed).await.ok();
-		}
-	}
-
-	/// Check if this is the exact same instance of a broadcast.
-	///
-	/// Duplicate names are allowed in the case of resumption.
-	pub fn is_clone(&self, other: &Self) -> bool {
-		self.closed.same_channel(&other.closed)
+		assert!(
+			self.requested_track().now_or_never().is_none(),
+			"request would not have blocked"
+		);
 	}
 }
 
@@ -259,34 +241,39 @@ impl BroadcastConsumer {
 	pub fn assert_closed(&self) {
 		assert!(self.closed().now_or_never().is_some(), "should be closed");
 	}
+
+	pub fn assert_subscribe(&self, track: impl Into<Track>, delivery: Delivery) -> TrackConsumer {
+		self.subscribe_track(track, delivery).expect("subscribe error")
+	}
 }
 
 #[cfg(test)]
 mod test {
 	use super::*;
+	use futures::FutureExt;
 
 	#[tokio::test]
 	async fn insert() {
 		let mut producer = BroadcastProducer::new();
-		let mut track1 = Track::new("track1").produce();
+		let mut track1 = TrackProducer::new("track1", Delivery::default());
 
-		// Make sure we can insert before a consumer is created.
-		producer.insert_track(track1.consumer);
-		track1.producer.append_group();
+		// Make sure we can publish before a consumer is created.
+		producer.publish_track(track1.clone()).unwrap();
+		track1.append_group().unwrap();
 
 		let consumer = producer.consume();
 
-		let mut track1_sub = consumer.subscribe_track(&track1.producer.info);
+		let mut track1_sub = consumer.assert_subscribe(track1.info(), Delivery::default());
 		track1_sub.assert_group();
 
-		let mut track2 = Track::new("track2").produce();
-		producer.insert_track(track2.consumer);
+		let mut track2 = TrackProducer::new("track2", Delivery::default());
+		producer.publish_track(track2.clone()).unwrap();
 
 		let consumer2 = producer.consume();
-		let mut track2_consumer = consumer2.subscribe_track(&track2.producer.info);
+		let mut track2_consumer = consumer2.assert_subscribe(track2.info(), Delivery::default());
 		track2_consumer.assert_no_group();
 
-		track2.producer.append_group();
+		track2.append_group().unwrap();
 
 		track2_consumer.assert_group();
 	}
@@ -315,7 +302,7 @@ mod test {
 		let consumer3 = producer.consume();
 		producer.assert_used();
 
-		let track1 = consumer3.subscribe_track(&Track::new("track1"));
+		let track1 = consumer3.subscribe_track(Track::new("track1"), Delivery::default());
 
 		// It doesn't matter if a subscription is alive, we only care about the broadcast handle.
 		// TODO is this the right behavior?
@@ -332,13 +319,13 @@ mod test {
 		let consumer = producer.consume();
 		consumer.assert_not_closed();
 
-		// Create a new track and insert it into the broadcast.
-		let mut track1 = Track::new("track1").produce();
-		track1.producer.append_group();
-		producer.insert_track(track1.consumer);
+		// Create a new track and publish it to the broadcast.
+		let mut track1 = TrackProducer::new("track1", Delivery::default());
+		track1.append_group().unwrap();
+		producer.publish_track(track1.clone()).unwrap();
 
-		let mut track1c = consumer.subscribe_track(&track1.producer.info);
-		let track2 = consumer.subscribe_track(&Track::new("track2"));
+		let mut track1c = consumer.assert_subscribe("track1", Delivery::default());
+		let track2 = consumer.assert_subscribe(Track::new("track2"), Delivery::default());
 
 		drop(producer);
 		consumer.assert_closed();
@@ -352,7 +339,7 @@ mod test {
 		track1c.assert_not_closed();
 
 		// TODO: We should probably cascade the closed state.
-		drop(track1.producer);
+		drop(track1);
 		track1c.assert_closed();
 	}
 
@@ -374,12 +361,12 @@ mod test {
 		let consumer = producer.consume();
 		let consumer2 = consumer.clone();
 
-		let mut track1 = consumer.subscribe_track(&Track::new("track1"));
+		let mut track1 = consumer.assert_subscribe(Track::new("track1"), Delivery::default());
 		track1.assert_not_closed();
 		track1.assert_no_group();
 
 		// Make sure we deduplicate requests while track1 is still active.
-		let mut track2 = consumer2.subscribe_track(&Track::new("track1"));
+		let mut track2 = consumer2.assert_subscribe(Track::new("track1"), Delivery::default());
 		track2.assert_is_clone(&track1);
 
 		// Get the requested track, and there should only be one.
@@ -387,21 +374,21 @@ mod test {
 		producer.assert_no_request();
 
 		// Make sure the consumer is the same.
-		track3.consume().assert_is_clone(&track1);
+		track3.subscribe(Delivery::default()).assert_is_clone(&track1);
 
 		// Append a group and make sure they all get it.
-		track3.append_group();
+		track3.append_group().unwrap();
 		track1.assert_group();
 		track2.assert_group();
 
 		// Make sure that tracks are cancelled when the producer is dropped.
-		let track4 = consumer.subscribe_track(&Track::new("track2"));
+		let track4 = consumer.assert_subscribe(Track::new("track2"), Delivery::default());
 		drop(producer);
 
 		// Make sure the track is errored, not closed.
 		track4.assert_error();
 
-		let track5 = consumer2.subscribe_track(&Track::new("track3"));
+		let track5 = consumer2.assert_subscribe(Track::new("track3"), Delivery::default());
 		track5.assert_error();
 	}
 
@@ -410,7 +397,9 @@ mod test {
 		let mut broadcast = Broadcast::produce();
 
 		// Subscribe to a track that doesn't exist - this creates a request
-		let consumer1 = broadcast.consumer.subscribe_track(&Track::new("unknown_track"));
+		let consumer1 = broadcast
+			.consumer
+			.assert_subscribe(Track::new("unknown_track"), Delivery::default());
 
 		// Get the requested track producer
 		let producer1 = broadcast.producer.assert_request();
@@ -422,7 +411,9 @@ mod test {
 		);
 
 		// Making a new consumer will keep the producer alive
-		let consumer2 = broadcast.consumer.subscribe_track(&Track::new("unknown_track"));
+		let consumer2 = broadcast
+			.consumer
+			.assert_subscribe(Track::new("unknown_track"), Delivery::default());
 		consumer2.assert_is_clone(&consumer1);
 
 		// Drop the consumer subscription
@@ -449,7 +440,9 @@ mod test {
 		tokio::time::sleep(std::time::Duration::from_millis(1)).await;
 
 		// Now the cleanup task should have run and we can subscribe again to the unknown track.
-		let consumer3 = broadcast.consumer.subscribe_track(&Track::new("unknown_track"));
+		let consumer3 = broadcast
+			.consumer
+			.subscribe_track(Track::new("unknown_track"), Delivery::default());
 		let producer2 = broadcast.producer.assert_request();
 
 		// Drop the consumer, now the producer should be unused
diff --git a/rs/moq-lite/src/model/delivery.rs b/rs/moq-lite/src/model/delivery.rs
new file mode 100644
index 000000000..cae87b610
--- /dev/null
+++ b/rs/moq-lite/src/model/delivery.rs
@@ -0,0 +1,197 @@
+use std::fmt;
+
+use std::ops::Deref;
+use tokio::sync::watch;
+
+use crate::Time;
+
+/// Delivery information for a track.
+///
+/// Both the publisher and subscriber can set their own values.
+#[derive(Clone, Debug, PartialEq, Eq, Copy, Default)]
+pub struct Delivery {
+	/// Higher priority tracks will be served first during congestion.
+	pub priority: u8,
+
+	/// Groups will be dropped if they are this much older than the latest group.
+	pub max_latency: Time,
+
+	/// Try to deliver groups in sequence order (for VOD).
+	pub ordered: bool,
+}
+
+impl Delivery {
+	pub fn max(&self, other: &Self) -> Self {
+		Self {
+			priority: self.priority.max(other.priority),
+			max_latency: self.max_latency.max(other.max_latency),
+			// Only use ordered if all are ordered.
+			ordered: self.ordered && other.ordered,
+		}
+	}
+}
+
+#[derive(Clone)]
+pub struct DeliveryProducer {
+	state: watch::Sender<Delivery>,
+}
+
+impl fmt::Debug for DeliveryProducer {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		f.debug_struct("DeliveryProducer")
+			.field("state", &self.state.borrow().deref())
+			.finish()
+	}
+}
+
+impl DeliveryProducer {
+	pub fn new(delivery: Delivery) -> Self {
+		Self {
+			state: watch::Sender::new(delivery),
+		}
+	}
+
+	pub fn consume(&self) -> DeliveryConsumer {
+		DeliveryConsumer {
+			state: self.state.subscribe(),
+		}
+	}
+
+	pub fn update(&self, delivery: Delivery) {
+		self.state.send_modify(|state| *state = delivery);
+	}
+}
+
+#[derive(Clone)]
+pub struct DeliveryConsumer {
+	state: watch::Receiver<Delivery>,
+}
+
+impl fmt::Debug for DeliveryConsumer {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		f.debug_struct("DeliveryConsumer")
+			.field("state", &self.state.borrow().deref())
+			.finish()
+	}
+}
+
+impl DeliveryConsumer {
+	pub fn current(&self) -> Delivery {
+		*self.state.borrow()
+	}
+
+	pub async fn changed(&mut self) -> Option<Delivery> {
+		self.state.changed().await.ok()?;
+		Some(*self.state.borrow_and_update())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn test_delivery_max() {
+		let d1 = Delivery {
+			priority: 5,
+			max_latency: Time::from_millis(100).unwrap(),
+			ordered: true,
+		};
+		let d2 = Delivery {
+			priority: 3,
+			max_latency: Time::from_millis(200).unwrap(),
+			ordered: false,
+		};
+
+		let result = d1.max(&d2);
+		assert_eq!(result.priority, 5);
+		assert_eq!(result.max_latency, Time::from_millis(200).unwrap());
+		assert!(!result.ordered); // false if any is false
+	}
+
+	#[test]
+	fn test_delivery_max_all_ordered() {
+		let d1 = Delivery {
+			priority: 5,
+			max_latency: Time::from_millis(100).unwrap(),
+			ordered: true,
+		};
+		let d2 = Delivery {
+			priority: 3,
+			max_latency: Time::from_millis(50).unwrap(),
+			ordered: true,
+		};
+
+		let result = d1.max(&d2);
+		assert!(result.ordered); // true only if all are ordered
+	}
+
+	#[test]
+	fn test_delivery_producer_consumer() {
+		let delivery = Delivery {
+			priority: 10,
+			max_latency: Time::from_millis(500).unwrap(),
+			ordered: false,
+		};
+
+		let producer = DeliveryProducer::new(delivery);
+		let consumer = producer.consume();
+
+		assert_eq!(consumer.current(), delivery);
+	}
+
+	#[tokio::test]
+	async fn test_delivery_update() {
+		let initial = Delivery {
+			priority: 5,
+			max_latency: Time::from_millis(100).unwrap(),
+			ordered: false,
+		};
+
+		let producer = DeliveryProducer::new(initial);
+		let mut consumer = producer.consume();
+
+		assert_eq!(consumer.current(), initial);
+
+		// Update delivery
+		let updated = Delivery {
+			priority: 10,
+			max_latency: Time::from_millis(200).unwrap(),
+			ordered: true,
+		};
+		producer.update(updated);
+
+		// Consumer should receive the update
+		let changed = consumer.changed().await.expect("should receive update");
+		assert_eq!(changed, updated);
+		assert_eq!(consumer.current(), updated);
+	}
+
+	#[tokio::test]
+	async fn test_delivery_multiple_consumers() {
+		let initial = Delivery::default();
+		let producer = DeliveryProducer::new(initial);
+
+		let mut consumer1 = producer.consume();
+		let mut consumer2 = producer.consume();
+
+		let updated = Delivery {
+			priority: 15,
+			max_latency: Time::from_millis(300).unwrap(),
+			ordered: true,
+		};
+		producer.update(updated);
+
+		// Both consumers should receive the update
+		assert_eq!(consumer1.changed().await, Some(updated));
+		assert_eq!(consumer2.changed().await, Some(updated));
+	}
+
+	#[test]
+	fn test_delivery_default() {
+		let d = Delivery::default();
+		assert_eq!(d.priority, 0);
+		assert_eq!(d.max_latency, Time::ZERO);
+		assert!(!d.ordered);
+	}
+}
diff --git a/rs/moq-lite/src/model/expires.rs b/rs/moq-lite/src/model/expires.rs
new file mode 100644
index 000000000..dc71afa86
--- /dev/null
+++ b/rs/moq-lite/src/model/expires.rs
@@ -0,0 +1,119 @@
+use std::fmt;
+use std::ops::Deref;
+
+use tokio::sync::watch;
+
+use crate::{DeliveryConsumer, Error, Time};
+
+#[derive(Debug, Default)]
+struct State {
+	max_instant: Time,
+	max_group: u64,
+}
+
+impl State {
+	fn create_frame(&mut self, group: u64, instant: Time, max_latency: Time) -> Result<bool, Error> {
+		let new_group = group > self.max_group;
+		let new_instant = instant > self.max_instant;
+
+		if new_group {
+			self.max_group = group;
+		}
+
+		if new_instant {
+			self.max_instant = instant;
+		}
+
+		if !new_group && !new_instant && instant + max_latency <= self.max_instant {
+			return Err(Error::Expired);
+		}
+
+		Ok(new_group || new_instant)
+	}
+}
+
+// TODO Also add a way to expire when too many bytes are cached.
+#[derive(Clone)]
+pub struct ExpiresProducer {
+	state: watch::Sender<State>,
+
+	// TODO expire when max_latency changes without waiting for a new frame/group.
+	delivery: DeliveryConsumer,
+}
+
+impl fmt::Debug for ExpiresProducer {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		f.debug_struct("State")
+			.field("state", &self.state.borrow().deref())
+			.finish()
+	}
+}
+
+impl ExpiresProducer {
+	pub fn new(delivery: DeliveryConsumer) -> Self {
+		Self {
+			state: Default::default(),
+			delivery,
+		}
+	}
+
+	pub(super) fn create_frame(&self, group: u64, instant: Time) -> Result<(), Error> {
+		let max_latency = self.delivery.current().max_latency;
+
+		let mut result = Ok(false);
+		self.state.send_if_modified(|state| {
+			result = state.create_frame(group, instant, max_latency);
+			result.as_ref().is_ok_and(|modify| *modify)
+		});
+		result.map(|_| ())
+	}
+
+	pub fn consume(&self) -> ExpiresConsumer {
+		ExpiresConsumer {
+			state: self.state.subscribe(),
+			delivery: self.delivery.clone(),
+		}
+	}
+}
+
+#[derive(Clone)]
+pub struct ExpiresConsumer {
+	state: watch::Receiver<State>,
+	delivery: DeliveryConsumer,
+}
+
+impl fmt::Debug for ExpiresConsumer {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		f.debug_struct("ExpiresConsumer")
+			.field("state", &self.state.borrow().deref())
+			.finish()
+	}
+}
+
+impl ExpiresConsumer {
+	// Blocks until the given group/instant is expired.
+	pub async fn wait_expired(&mut self, group: u64, instant: Time) -> Error {
+		let mut max_latency = self.delivery.current().max_latency;
+
+		loop {
+			tokio::select! {
+				state = self
+				.state
+				.wait_for(|state| group < state.max_group && instant + max_latency <= state.max_instant) => match state {
+					Ok(_) => return Error::Expired,
+					Err(_) => return Error::Cancel,
+				},
+				changed = self.delivery.changed() => match changed {
+					Some(delivery) => max_latency = delivery.max_latency,
+					None => return Error::Cancel,
+				},
+			}
+		}
+	}
+
+	pub fn is_expired(&self, group: u64, timestamp: Time) -> bool {
+		let max_latency = self.delivery.current().max_latency;
+		let state = self.state.borrow();
+		group < state.max_group && timestamp + max_latency <= state.max_instant
+	}
+}
diff --git a/rs/moq-lite/src/model/frame.rs b/rs/moq-lite/src/model/frame.rs
index 74cce6fe8..c99f13564 100644
--- a/rs/moq-lite/src/model/frame.rs
+++ b/rs/moq-lite/src/model/frame.rs
@@ -1,18 +1,41 @@
-use std::future::Future;
+use std::ops::Deref;
 
 use bytes::{Bytes, BytesMut};
-use tokio::sync::watch;
 
-use crate::{Error, Produce, Result};
+use super::{Consumer, Produce, Producer};
+use crate::{Error, Result, Time};
 
-/// A chunk of data with an upfront size.
+/// A unit of data, representing a point in time.
+///
+/// This is often a video frame or a packet of audio samples.
+/// The instant is when the frame was captured and should be rendered, scoped to the *track*.
+///
+/// The size must be known upfront. If you don't know the size, write a Frame for each chunk.
 #[derive(Clone, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Frame {
-	pub size: u64,
+	/// A timestamp (in milliseconds) when the frame was originally created, scoped to the *track*.
+	///
+	/// This *should* be set as early as possible in the pipeline and proxied through all relays.
+	/// There is no clock synchronization or "zero" value; everything is relative to the track.
+	///
+	/// This may be used by the application as a replacement for "presentation timestamp", even across tracks.
+	/// However, the lack of granularity and inability to go backwards limits its usefulness.
+	pub instant: Time,
+
+	/// The size of the frame in bytes.
+	pub size: usize,
 }
 
 impl Frame {
+	/// A helper to create a frame with the current time.
+	pub fn new(size: usize) -> Self {
+		Self {
+			instant: Time::now(),
+			size,
+		}
+	}
+
 	/// Create a new producer and consumer for the frame.
 	pub fn produce(self) -> Produce<FrameProducer, FrameConsumer> {
 		let producer = FrameProducer::new(self);
@@ -23,95 +46,108 @@ impl Frame {
 
 impl From<usize> for Frame {
 	fn from(size: usize) -> Self {
-		Self { size: size as u64 }
+		Self {
+			instant: Time::now(),
+			size,
+		}
 	}
 }
 
 impl From<u64> for Frame {
 	fn from(size: u64) -> Self {
-		Self { size }
+		Self {
+			instant: Time::now(),
+			size: size as usize,
+		}
 	}
 }
 
 impl From<u32> for Frame {
 	fn from(size: u32) -> Self {
-		Self { size: size as u64 }
+		Self {
+			instant: Time::now(),
+			size: size as usize,
+		}
 	}
 }
 
 impl From<u16> for Frame {
 	fn from(size: u16) -> Self {
-		Self { size: size as u64 }
+		Self {
+			instant: Time::now(),
+			size: size as usize,
+		}
 	}
 }
 
-#[derive(Default)]
+#[derive(Default, Debug)]
 struct FrameState {
 	// The chunks that has been written thus far
 	chunks: Vec<Bytes>,
 
-	// Set when the writer or all readers are dropped.
-	closed: Option<Result<()>>,
+	// Sanity check to ensure we don't write more than the frame size.
+	remaining: usize,
+}
+
+impl FrameState {
+	fn new(size: usize) -> Self {
+		Self {
+			chunks: Vec::new(),
+			remaining: size,
+		}
+	}
+
+	fn write_chunk(&mut self, chunk: Bytes) -> Result<()> {
+		self.remaining = self.remaining.checked_sub(chunk.len()).ok_or(Error::WrongSize)?;
+		self.chunks.push(chunk);
+		Ok(())
+	}
 }
 
 /// Used to write a frame's worth of data in chunks.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct FrameProducer {
-	// Immutable stream state.
-	pub info: Frame,
+	info: Frame,
 
 	// Mutable stream state.
-	state: watch::Sender<FrameState>,
-
-	// Sanity check to ensure we don't write more than the frame size.
-	written: usize,
+	state: Producer<FrameState>,
 }
 
 impl FrameProducer {
-	fn new(info: Frame) -> Self {
+	pub fn new(info: Frame) -> Self {
 		Self {
+			state: Producer::new(FrameState::new(info.size)),
 			info,
-			state: Default::default(),
-			written: 0,
 		}
 	}
 
-	pub fn write_chunk<B: Into<Bytes>>(&mut self, chunk: B) {
-		let chunk = chunk.into();
-		self.written += chunk.len();
-		assert!(self.written <= self.info.size as usize);
+	pub fn info(&self) -> &Frame {
+		&self.info
+	}
 
-		self.state.send_modify(|state| {
-			assert!(state.closed.is_none());
-			state.chunks.push(chunk);
-		});
+	pub fn write_chunk<B: Into<Bytes>>(&mut self, chunk: B) -> Result<()> {
+		self.state.modify(|state| state.write_chunk(chunk.into()))?
 	}
 
-	pub fn close(self) {
-		assert!(self.written == self.info.size as usize);
-		self.state.send_modify(|state| state.closed = Some(Ok(())));
+	pub fn close(&mut self) -> Result<()> {
+		if self.state.borrow().remaining != 0 {
+			return Err(Error::WrongSize);
+		}
+		self.state.close()
 	}
 
-	pub fn abort(self, err: Error) {
-		self.state.send_modify(|state| state.closed = Some(Err(err)));
+	pub fn abort(&mut self, err: Error) -> Result<()> {
+		self.state.abort(err)
 	}
 
 	/// Create a new consumer for the frame.
 	pub fn consume(&self) -> FrameConsumer {
 		FrameConsumer {
 			info: self.info.clone(),
-			state: self.state.subscribe(),
+			state: self.state.consume(),
 			index: 0,
 		}
 	}
-
-	// Returns a Future so &self is not borrowed during the future.
-	pub fn unused(&self) -> impl Future<Output = ()> {
-		let state = self.state.clone();
-		async move {
-			state.closed().await;
-		}
-	}
 }
 
 impl From<Frame> for FrameProducer {
@@ -120,14 +156,24 @@ impl From<Frame> for FrameProducer {
 	}
 }
 
+impl Deref for FrameProducer {
+	type Target = Frame;
+
+	fn deref(&self) -> &Self::Target {
+		&self.info
+	}
+}
+
 /// Used to consume a frame's worth of data in chunks.
-#[derive(Clone)]
+///
+/// If the consumer is cloned, it will receive a copy of all unread chunks.
+#[derive(Clone, Debug)]
 pub struct FrameConsumer {
 	// Immutable stream state.
-	pub info: Frame,
+	info: Frame,
 
 	// Modify the stream state.
-	state: watch::Receiver<FrameState>,
+	state: Consumer<FrameState>,
 
 	// The number of frames we've read.
 	// NOTE: Cloned readers inherit this offset, but then run in parallel.
@@ -135,27 +181,22 @@ pub struct FrameConsumer {
 }
 
 impl FrameConsumer {
+	pub fn info(&self) -> &Frame {
+		&self.info
+	}
+
 	/// Return the next chunk.
 	pub async fn read_chunk(&mut self) -> Result<Option<Bytes>> {
-		loop {
-			{
-				let state = self.state.borrow_and_update();
-
-				if let Some(chunk) = state.chunks.get(self.index).cloned() {
-					self.index += 1;
-					return Ok(Some(chunk));
-				}
-
-				match &state.closed {
-					Some(Ok(_)) => return Ok(None),
-					Some(Err(err)) => return Err(err.clone()),
-					_ => {}
-				}
-			}
-
-			if self.state.changed().await.is_err() {
-				return Err(Error::Cancel);
-			}
+		let state = self
+			.state
+			.wait_for(|state| state.chunks.get(self.index).is_some())
+			.await?;
+
+		if let Some(chunk) = state.chunks.get(self.index).cloned() {
+			self.index += 1;
+			Ok(Some(chunk))
+		} else {
+			Ok(None)
 		}
 	}
 
@@ -163,17 +204,10 @@ impl FrameConsumer {
 	pub async fn read_chunks(&mut self) -> Result<Vec<Bytes>> {
 		// Wait until the writer is done before even attempting to read.
 		// That way this function can be cancelled without consuming half of the frame.
-		let state = match self.state.wait_for(|state| state.closed.is_some()).await {
-			Ok(state) => {
-				if let Some(Err(err)) = &state.closed {
-					return Err(err.clone());
-				}
-				state
-			}
-			Err(_) => return Err(Error::Cancel),
-		};
+		self.state.closed().await?;
 
 		// Get all of the remaining chunks.
+		let state = self.state.borrow();
 		let chunks = state.chunks[self.index..].to_vec();
 		self.index = state.chunks.len();
 
@@ -184,17 +218,10 @@ impl FrameConsumer {
 	pub async fn read_all(&mut self) -> Result<Bytes> {
 		// Wait until the writer is done before even attempting to read.
 		// That way this function can be cancelled without consuming half of the frame.
-		let state = match self.state.wait_for(|state| state.closed.is_some()).await {
-			Ok(state) => {
-				if let Some(Err(err)) = &state.closed {
-					return Err(err.clone());
-				}
-				state
-			}
-			Err(_) => return Err(Error::Cancel),
-		};
+		self.state.closed().await?;
 
 		// Get all of the remaining chunks.
+		let state = self.state.borrow();
 		let chunks = &state.chunks[self.index..];
 		self.index = state.chunks.len();
 
@@ -212,3 +239,198 @@ impl FrameConsumer {
 		Ok(buf.freeze())
 	}
 }
+
+impl Deref for FrameConsumer {
+	type Target = Frame;
+
+	fn deref(&self) -> &Self::Target {
+		&self.info
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn test_frame_new() {
+		let frame = Frame::new(100);
+		assert_eq!(frame.size, 100);
+		assert!(frame.instant > Time::ZERO);
+	}
+
+	#[test]
+	fn test_frame_from_usize() {
+		let frame: Frame = 100usize.into();
+		assert_eq!(frame.size, 100);
+	}
+
+	#[test]
+	fn test_frame_from_u64() {
+		let frame: Frame = 100u64.into();
+		assert_eq!(frame.size, 100);
+	}
+
+	#[test]
+	fn test_frame_from_u32() {
+		let frame: Frame = 100u32.into();
+		assert_eq!(frame.size, 100);
+	}
+
+	#[test]
+	fn test_frame_from_u16() {
+		let frame: Frame = 100u16.into();
+		assert_eq!(frame.size, 100);
+	}
+
+	#[tokio::test]
+	async fn test_frame_write_read_single_chunk() {
+		let frame = Frame {
+			instant: Time::from_millis(100).unwrap(),
+			size: 10,
+		};
+
+		let mut producer = FrameProducer::new(frame.clone());
+		let mut consumer = producer.consume();
+
+		// Write data
+		producer.write_chunk(Bytes::from("hello world")).unwrap_err(); // Too big
+		producer.write_chunk(Bytes::from("hello")).unwrap();
+		producer.write_chunk(Bytes::from("world")).unwrap();
+		producer.close().unwrap();
+
+		// Read data
+		let chunk1 = consumer.read_chunk().await.unwrap().unwrap();
+		assert_eq!(chunk1, Bytes::from("hello"));
+
+		let chunk2 = consumer.read_chunk().await.unwrap().unwrap();
+		assert_eq!(chunk2, Bytes::from("world"));
+
+		// No more chunks
+		let chunk3 = consumer.read_chunk().await.unwrap();
+		assert!(chunk3.is_none());
+	}
+
+	#[tokio::test]
+	async fn test_frame_read_all() {
+		let frame = Frame {
+			instant: Time::from_millis(100).unwrap(),
+			size: 10,
+		};
+
+		let mut producer = FrameProducer::new(frame);
+		let mut consumer = producer.consume();
+
+		producer.write_chunk(Bytes::from("hello")).unwrap();
+		producer.write_chunk(Bytes::from("world")).unwrap();
+		producer.close().unwrap();
+
+		let all = consumer.read_all().await.unwrap();
+		assert_eq!(all, Bytes::from("helloworld"));
+	}
+
+	#[tokio::test]
+	async fn test_frame_read_chunks() {
+		let frame = Frame {
+			instant: Time::from_millis(100).unwrap(),
+			size: 10,
+		};
+
+		let mut producer = FrameProducer::new(frame);
+		let mut consumer = producer.consume();
+
+		producer.write_chunk(Bytes::from("hello")).unwrap();
+		producer.write_chunk(Bytes::from("world")).unwrap();
+		producer.close().unwrap();
+
+		let chunks = consumer.read_chunks().await.unwrap();
+		assert_eq!(chunks.len(), 2);
+		assert_eq!(chunks[0], Bytes::from("hello"));
+		assert_eq!(chunks[1], Bytes::from("world"));
+	}
+
+	#[tokio::test]
+	async fn test_frame_wrong_size_too_large() {
+		let frame = Frame {
+			instant: Time::from_millis(100).unwrap(),
+			size: 5,
+		};
+
+		let mut producer = FrameProducer::new(frame);
+		producer.write_chunk(Bytes::from("hello")).unwrap();
+
+		// Try to write more than the size
+		let result = producer.write_chunk(Bytes::from("x"));
+		assert!(result.is_err());
+	}
+
+	#[tokio::test]
+	async fn test_frame_wrong_size_too_small() {
+		let frame = Frame {
+			instant: Time::from_millis(100).unwrap(),
+			size: 10,
+		};
+
+		let mut producer = FrameProducer::new(frame);
+		producer.write_chunk(Bytes::from("hello")).unwrap();
+
+		// Try to close before writing all data
+		let result = producer.close();
+		assert!(result.is_err());
+	}
+
+	#[tokio::test]
+	async fn test_frame_multiple_consumers() {
+		let frame = Frame {
+			instant: Time::from_millis(100).unwrap(),
+			size: 10,
+		};
+
+		let mut producer = FrameProducer::new(frame);
+		let mut consumer1 = producer.consume();
+		let mut consumer2 = producer.consume();
+
+		producer.write_chunk(Bytes::from("hello")).unwrap();
+		producer.write_chunk(Bytes::from("world")).unwrap();
+		producer.close().unwrap();
+
+		// Both consumers should get all data
+		let data1 = consumer1.read_all().await.unwrap();
+		let data2 = consumer2.read_all().await.unwrap();
+		assert_eq!(data1, Bytes::from("helloworld"));
+		assert_eq!(data2, Bytes::from("helloworld"));
+	}
+
+	#[tokio::test]
+	async fn test_frame_abort() {
+		let frame = Frame {
+			instant: Time::from_millis(100).unwrap(),
+			size: 10,
+		};
+
+		let mut producer = FrameProducer::new(frame);
+		let mut consumer = producer.consume();
+
+		producer.write_chunk(Bytes::from("hello")).unwrap();
+		producer.abort(Error::Cancel).unwrap();
+
+		// Consumer should get an error
+		let result = consumer.read_all().await;
+		assert!(result.is_err());
+	}
+
+	#[tokio::test]
+	async fn test_frame_produce_helper() {
+		let frame = Frame {
+			instant: Time::from_millis(100).unwrap(),
+			size: 5,
+		};
+
+		let mut pair = frame.produce();
+		pair.producer.write_chunk(Bytes::from("hello")).unwrap();
+		pair.producer.close().unwrap();
+
+		let data = pair.consumer.read_all().await.unwrap();
+		assert_eq!(data, Bytes::from("hello"));
+	}
+}
diff --git a/rs/moq-lite/src/model/group.rs b/rs/moq-lite/src/model/group.rs
index 835cffcc9..e78c784df 100644
--- a/rs/moq-lite/src/model/group.rs
+++ b/rs/moq-lite/src/model/group.rs
@@ -7,14 +7,12 @@
 //! The reader can be cloned, in which case each reader receives a copy of each frame. (fanout)
 //!
 //! The stream is closed with [ServeError::MoqError] when all writers or readers are dropped.
-use std::future::Future;
+use std::ops::Deref;
 
 use bytes::Bytes;
-use tokio::sync::watch;
 
-use crate::{Error, Produce, Result};
-
-use super::{Frame, FrameConsumer, FrameProducer};
+use super::{Consumer, Frame, FrameConsumer, FrameProducer, Producer};
+use crate::{Error, ExpiresConsumer, ExpiresProducer, Time};
 
 /// A group contains a sequence number because they can arrive out of order.
 ///
@@ -25,141 +23,128 @@ pub struct Group {
 	pub sequence: u64,
 }
 
-impl Group {
-	pub fn produce(self) -> Produce<GroupProducer, GroupConsumer> {
-		let producer = GroupProducer::new(self);
-		let consumer = producer.consume();
-		Produce { producer, consumer }
-	}
-}
-
-impl From<usize> for Group {
-	fn from(sequence: usize) -> Self {
+impl<T: Into<u64>> From<T> for Group {
+	fn from(sequence: T) -> Self {
 		Self {
-			sequence: sequence as u64,
+			sequence: sequence.into(),
 		}
 	}
 }
 
-impl From<u64> for Group {
-	fn from(sequence: u64) -> Self {
-		Self { sequence }
-	}
-}
+#[derive(Default, Debug)]
+struct GroupState {
+	// The frames that has been written thus far
+	frames: Vec<FrameProducer>,
 
-impl From<u32> for Group {
-	fn from(sequence: u32) -> Self {
-		Self {
-			sequence: sequence as u64,
-		}
-	}
+	// The maximum instant of the frames in the group.
+	// TODO prevent going backwards instead?
+	max_instant: Option<Time>,
 }
 
-impl From<u16> for Group {
-	fn from(sequence: u16) -> Self {
-		Self {
-			sequence: sequence as u64,
-		}
+impl GroupState {
+	fn append_frame(&mut self, frame: FrameProducer) {
+		self.max_instant = Some(self.max_instant.unwrap_or_default().max(frame.instant));
+		self.frames.push(frame);
 	}
 }
 
-#[derive(Default)]
-struct GroupState {
-	// The frames that has been written thus far
-	frames: Vec<FrameConsumer>,
-
-	// Whether the group is closed
-	closed: Option<Result<()>>,
-}
-
 /// Create a group, frame-by-frame.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct GroupProducer {
 	// Mutable stream state.
-	state: watch::Sender<GroupState>,
-
-	// Immutable stream state.
-	pub info: Group,
+	state: Producer<GroupState>,
+	info: Group,
+	expires: ExpiresProducer,
 }
 
 impl GroupProducer {
-	fn new(info: Group) -> Self {
+	pub fn new(info: Group, expires: ExpiresProducer) -> Self {
 		Self {
 			info,
 			state: Default::default(),
+			expires,
 		}
 	}
 
+	pub fn info(&self) -> &Group {
+		&self.info
+	}
+
 	/// A helper method to write a frame from a single byte buffer.
 	///
-	/// If you want to write multiple chunks, use [Self::create_frame] to get a frame producer.
-	/// But an upfront size is required.
-	pub fn write_frame<B: Into<Bytes>>(&mut self, frame: B) {
+	/// If you want to write multiple chunks, use [Self::create_frame] or [Self::append_frame].
+	pub fn write_frame<B: Into<Bytes>>(&mut self, frame: B, instant: Time) -> Result<(), Error> {
 		let data = frame.into();
 		let frame = Frame {
-			size: data.len() as u64,
+			size: data.len(),
+			instant,
 		};
-		let mut frame = self.create_frame(frame);
-		frame.write_chunk(data);
-		frame.close();
+		let mut frame = self.create_frame(frame)?;
+		frame.write_chunk(data)?;
+		frame.close()?;
+
+		Ok(())
 	}
 
 	/// Create a frame with an upfront size
-	pub fn create_frame(&mut self, info: Frame) -> FrameProducer {
-		let frame = Frame::produce(info);
-		self.append_frame(frame.consumer);
-		frame.producer
+	pub fn create_frame(&mut self, info: Frame) -> Result<FrameProducer, Error> {
+		let frame = FrameProducer::new(info);
+		self.append_frame(frame.clone())?;
+		Ok(frame)
 	}
 
 	/// Append a frame to the group.
-	pub fn append_frame(&mut self, consumer: FrameConsumer) {
-		self.state.send_modify(|state| {
-			assert!(state.closed.is_none());
-			state.frames.push(consumer)
-		});
+	pub fn append_frame(&mut self, frame: FrameProducer) -> Result<(), Error> {
+		// Add the current frame to the expiration tracker.
+		// NOTE: This might return an error if the current group is expired.
+		self.expires.create_frame(self.info.sequence, frame.instant)?;
+		self.state.modify(|state| state.append_frame(frame))
 	}
 
 	// Clean termination of the group.
-	pub fn close(self) {
-		self.state.send_modify(|state| state.closed = Some(Ok(())));
+	pub fn close(&mut self) -> Result<(), Error> {
+		self.state.close()
 	}
 
-	pub fn abort(self, err: Error) {
-		self.state.send_modify(|state| state.closed = Some(Err(err)));
+	pub fn abort(&mut self, err: Error) -> Result<(), Error> {
+		self.state.abort(err)
 	}
 
 	/// Create a new consumer for the group.
 	pub fn consume(&self) -> GroupConsumer {
 		GroupConsumer {
 			info: self.info.clone(),
-			state: self.state.subscribe(),
+			state: self.state.consume(),
 			index: 0,
 			active: None,
+			expires: self.expires.consume(),
 		}
 	}
 
-	pub fn unused(&self) -> impl Future<Output = ()> {
-		let state = self.state.clone();
-		async move {
-			state.closed().await;
-		}
+	// We don't use the `async` keyword so we don't borrow &self across the await.
+	pub async fn unused(&self) {
+		self.state.unused().await
 	}
 }
 
-impl From<Group> for GroupProducer {
-	fn from(info: Group) -> Self {
-		GroupProducer::new(info)
+impl Deref for GroupProducer {
+	type Target = Group;
+
+	fn deref(&self) -> &Self::Target {
+		&self.info
 	}
 }
 
 /// Consume a group, frame-by-frame.
-#[derive(Clone)]
+///
+/// If the consumer is cloned, it will receive a copy of all unread frames.
+#[derive(Clone, Debug)]
 pub struct GroupConsumer {
 	// Modify the stream state.
-	state: watch::Receiver<GroupState>,
+	state: Consumer<GroupState>,
 
 	// Immutable stream state.
-	pub info: Group,
+	info: Group,
 
 	// The number of frames we've read.
 	// NOTE: Cloned readers inherit this offset, but then run in parallel.
@@ -167,11 +152,18 @@ pub struct GroupConsumer {
 
 	// Used to make read_frame cancel safe.
 	active: Option<FrameConsumer>,
+
+	// Used to check if the group is expired early.
+	expires: ExpiresConsumer,
 }
 
 impl GroupConsumer {
+	pub fn info(&self) -> &Group {
+		&self.info
+	}
+
 	/// Read the next frame.
-	pub async fn read_frame(&mut self) -> Result<Option<Bytes>> {
+	pub async fn read_frame(&mut self) -> Result<Option<Bytes>, Error> {
 		// In order to be cancel safe, we need to save the active frame.
 		// That way if this method gets cancelled, we can resume where we left off.
 		if self.active.is_none() {
@@ -190,31 +182,262 @@ impl GroupConsumer {
 	}
 
 	/// Return a reader for the next frame.
-	pub async fn next_frame(&mut self) -> Result<Option<FrameConsumer>> {
+	pub async fn next_frame(&mut self) -> Result<Option<FrameConsumer>, Error> {
 		// Just in case someone called read_frame, cancelled it, then called next_frame.
 		if let Some(frame) = self.active.take() {
 			return Ok(Some(frame));
 		}
 
-		loop {
-			{
-				let state = self.state.borrow_and_update();
-
-				if let Some(frame) = state.frames.get(self.index).cloned() {
-					self.index += 1;
-					return Ok(Some(frame));
-				}
-
-				match &state.closed {
-					Some(Ok(_)) => return Ok(None),
-					Some(Err(err)) => return Err(err.clone()),
-					_ => {}
-				}
-			}
-
-			if self.state.changed().await.is_err() {
-				return Err(Error::Cancel);
-			}
+		let max_instant = self.state.borrow().max_instant;
+
+		let state = tokio::select! {
+			biased;
+			// Wait until a new frame.
+			state = self.state.wait_for(|state| self.index < state.frames.len()) => state?,
+			// Or wait until the maximum instant in the group is expired.
+			// We do this second because it's legal to return expired frames if we have them in cache already.
+			err = self.expires.wait_expired(self.info.sequence, max_instant.unwrap_or_default()), if max_instant.is_some() => return Err(err),
+			// NOTE: We don't have to wait for a new maximum, because it will satisfy the wait for the next frame.
+		};
+
+		if let Some(frame) = state.frames.get(self.index).cloned() {
+			self.index += 1;
+			return Ok(Some(frame.consume()));
 		}
+
+		Ok(None)
+	}
+
+	pub async fn closed(&self) -> Result<(), Error> {
+		self.state.closed().await
+	}
+}
+
+impl Deref for GroupConsumer {
+	type Target = Group;
+
+	fn deref(&self) -> &Self::Target {
+		&self.info
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{Delivery, DeliveryProducer, ExpiresProducer};
+
+	#[test]
+	fn test_group_from_u64() {
+		let group: Group = 42u64.into();
+		assert_eq!(group.sequence, 42);
+	}
+
+	#[tokio::test]
+	async fn test_group_write_read_frame() {
+		let group = Group { sequence: 0 };
+		let delivery = DeliveryProducer::new(Delivery::default());
+		let expires = ExpiresProducer::new(delivery.consume());
+
+		let mut producer = GroupProducer::new(group, expires);
+		let mut consumer = producer.consume();
+
+		// Write a frame
+		let instant = Time::from_millis(100).unwrap();
+		producer.write_frame(Bytes::from("hello"), instant).unwrap();
+		producer.close().unwrap();
+
+		// Read the frame
+		let data = consumer.read_frame().await.unwrap().unwrap();
+		assert_eq!(data, Bytes::from("hello"));
+
+		// No more frames
+		let data = consumer.read_frame().await.unwrap();
+		assert!(data.is_none());
+	}
+
+	#[tokio::test]
+	async fn test_group_multiple_frames() {
+		let group = Group { sequence: 5 };
+		let delivery = DeliveryProducer::new(Delivery::default());
+		let expires = ExpiresProducer::new(delivery.consume());
+
+		let mut producer = GroupProducer::new(group, expires);
+		let mut consumer = producer.consume();
+
+		// Write multiple frames
+		let t1 = Time::from_millis(100).unwrap();
+		let t2 = Time::from_millis(200).unwrap();
+		let t3 = Time::from_millis(300).unwrap();
+
+		producer.write_frame(Bytes::from("frame1"), t1).unwrap();
+		producer.write_frame(Bytes::from("frame2"), t2).unwrap();
+		producer.write_frame(Bytes::from("frame3"), t3).unwrap();
+		producer.close().unwrap();
+
+		// Read all frames
+		assert_eq!(consumer.read_frame().await.unwrap().unwrap(), Bytes::from("frame1"));
+		assert_eq!(consumer.read_frame().await.unwrap().unwrap(), Bytes::from("frame2"));
+		assert_eq!(consumer.read_frame().await.unwrap().unwrap(), Bytes::from("frame3"));
+		assert!(consumer.read_frame().await.unwrap().is_none());
+	}
+
+	#[tokio::test]
+	async fn test_group_create_frame_multi_chunk() {
+		let group = Group { sequence: 0 };
+		let delivery = DeliveryProducer::new(Delivery::default());
+		let expires = ExpiresProducer::new(delivery.consume());
+
+		let mut producer = GroupProducer::new(group, expires);
+		let mut consumer = producer.consume();
+
+		// Create a frame and write it in chunks
+		let instant = Time::from_millis(100).unwrap();
+		let frame = Frame { size: 10, instant };
+		let mut frame_producer = producer.create_frame(frame).unwrap();
+		frame_producer.write_chunk(Bytes::from("hello")).unwrap();
+		frame_producer.write_chunk(Bytes::from("world")).unwrap();
+		frame_producer.close().unwrap();
+
+		producer.close().unwrap();
+
+		// Read the frame
+		let data = consumer.read_frame().await.unwrap().unwrap();
+		assert_eq!(data, Bytes::from("helloworld"));
+	}
+
+	#[tokio::test]
+	async fn test_group_next_frame() {
+		let group = Group { sequence: 0 };
+		let delivery = DeliveryProducer::new(Delivery::default());
+		let expires = ExpiresProducer::new(delivery.consume());
+
+		let mut producer = GroupProducer::new(group, expires);
+		let mut consumer = producer.consume();
+
+		let instant = Time::from_millis(100).unwrap();
+		producer.write_frame(Bytes::from("test"), instant).unwrap();
+		producer.close().unwrap();
+
+		// Use next_frame to get the frame consumer
+		let mut frame_consumer = consumer.next_frame().await.unwrap().unwrap();
+		let data = frame_consumer.read_all().await.unwrap();
+		assert_eq!(data, Bytes::from("test"));
+
+		// No more frames
+		assert!(consumer.next_frame().await.unwrap().is_none());
+	}
+
+	#[tokio::test]
+	async fn test_group_multiple_consumers() {
+		let group = Group { sequence: 0 };
+		let delivery = DeliveryProducer::new(Delivery::default());
+		let expires = ExpiresProducer::new(delivery.consume());
+
+		let mut producer = GroupProducer::new(group, expires);
+		let mut consumer1 = producer.consume();
+		let mut consumer2 = producer.consume();
+
+		let instant = Time::from_millis(100).unwrap();
+		producer.write_frame(Bytes::from("data"), instant).unwrap();
+		producer.close().unwrap();
+
+		// Both consumers should get the frame
+		let data1 = consumer1.read_frame().await.unwrap().unwrap();
+		let data2 = consumer2.read_frame().await.unwrap().unwrap();
+		assert_eq!(data1, Bytes::from("data"));
+		assert_eq!(data2, Bytes::from("data"));
+	}
+
+	#[tokio::test]
+	async fn test_group_abort() {
+		let group = Group { sequence: 0 };
+		let delivery = DeliveryProducer::new(Delivery::default());
+		let expires = ExpiresProducer::new(delivery.consume());
+
+		let mut producer = GroupProducer::new(group, expires);
+		let mut consumer = producer.consume();
+
+		let instant = Time::from_millis(100).unwrap();
+		producer.write_frame(Bytes::from("data"), instant).unwrap();
+
+		// Abort before closing - this should propagate the error
+		producer.abort(Error::Cancel).unwrap();
+
+		// The first frame was already written and closed, so we can read it
+		let _result = consumer.read_frame().await;
+		// The frame itself will succeed but the group will be in error state
+		// So we check closed() instead
+		let closed_result = consumer.closed().await;
+		assert!(closed_result.is_err());
+	}
+
+	#[tokio::test]
+	async fn test_group_max_instant_increasing() {
+		let group = Group { sequence: 0 };
+		let delivery = DeliveryProducer::new(Delivery::default());
+		let expires = ExpiresProducer::new(delivery.consume());
+
+		let mut producer = GroupProducer::new(group, expires.clone());
+
+		let t1 = Time::from_millis(100).unwrap();
+		let t2 = Time::from_millis(200).unwrap();
+		let t3 = Time::from_millis(250).unwrap(); // Always increasing
+
+		producer.write_frame(Bytes::from("f1"), t1).unwrap();
+		producer.write_frame(Bytes::from("f2"), t2).unwrap();
+		producer.write_frame(Bytes::from("f3"), t3).unwrap();
+
+		// max_instant should be t3 (250ms), the highest timestamp
+		// This is indirectly tested through the internal state
+		// We can verify by checking the state was updated
+		producer.close().unwrap();
+	}
+
+	#[tokio::test]
+	async fn test_group_max_instant_out_of_order() {
+		// Test what happens when we write frames with out-of-order timestamps
+		let group = Group { sequence: 0 };
+		let delivery = DeliveryProducer::new(Delivery::default());
+		let expires = ExpiresProducer::new(delivery.consume());
+
+		let mut producer = GroupProducer::new(group, expires.clone());
+
+		let t1 = Time::from_millis(100).unwrap();
+		let t2 = Time::from_millis(200).unwrap();
+		let t3 = Time::from_millis(150).unwrap(); // Out of order - older than t2
+
+		producer.write_frame(Bytes::from("f1"), t1).unwrap();
+		producer.write_frame(Bytes::from("f2"), t2).unwrap();
+
+		// This should fail with Expired because t3 (150ms) is older than t2 (200ms)
+		// and max_latency is 0 by default
+		let result = producer.write_frame(Bytes::from("f3"), t3);
+		assert!(
+			result.is_err(),
+			"Writing a frame with an older timestamp should fail when max_latency is 0"
+		);
+	}
+
+	#[tokio::test]
+	async fn test_group_append_frame() {
+		let group = Group { sequence: 0 };
+		let delivery = DeliveryProducer::new(Delivery::default());
+		let expires = ExpiresProducer::new(delivery.consume());
+
+		let mut producer = GroupProducer::new(group, expires);
+		let mut consumer = producer.consume();
+
+		// Create a frame manually and append it
+		let instant = Time::from_millis(100).unwrap();
+		let frame = Frame { size: 5, instant };
+		let mut frame_producer = FrameProducer::new(frame);
+		frame_producer.write_chunk(Bytes::from("hello")).unwrap();
+		frame_producer.close().unwrap();
+
+		producer.append_frame(frame_producer).unwrap();
+		producer.close().unwrap();
+
+		let data = consumer.read_frame().await.unwrap().unwrap();
+		assert_eq!(data, Bytes::from("hello"));
 	}
 }
diff --git a/rs/moq-lite/src/model/mod.rs b/rs/moq-lite/src/model/mod.rs
index c3bd0f5fc..0f067b2b4 100644
--- a/rs/moq-lite/src/model/mod.rs
+++ b/rs/moq-lite/src/model/mod.rs
@@ -1,15 +1,24 @@
 mod broadcast;
+mod delivery;
+mod expires;
 mod frame;
 mod group;
 mod origin;
 mod produce;
+mod state;
+mod subscriber;
 mod time;
 mod track;
 
 pub use broadcast::*;
+pub use delivery::*;
+pub use expires::*;
 pub use frame::*;
 pub use group::*;
 pub use origin::*;
 pub use produce::*;
+pub use subscriber::*;
 pub use time::*;
 pub use track::*;
+
+use state::*;
diff --git a/rs/moq-lite/src/model/origin.rs b/rs/moq-lite/src/model/origin.rs
index 3e07e713e..4cdd0e373 100644
--- a/rs/moq-lite/src/model/origin.rs
+++ b/rs/moq-lite/src/model/origin.rs
@@ -19,6 +19,18 @@ impl ConsumerId {
 	}
 }
 
+pub struct Origin {}
+
+impl Origin {
+	pub fn produce() -> Produce<OriginProducer, OriginConsumer> {
+		let producer = OriginProducer::new();
+		Produce {
+			consumer: producer.consume(),
+			producer,
+		}
+	}
+}
+
 // If there are multiple broadcasts with the same path, we use the most recent one but keep the others around.
 struct OriginBroadcast {
 	path: PathOwned,
@@ -334,17 +346,6 @@ impl Default for OriginNodes {
 /// A broadcast path and its associated consumer, or None if closed.
 pub type OriginAnnounce = (PathOwned, Option<BroadcastConsumer>);
 
-/// A collection of broadcasts that can be published and subscribed to.
-pub struct Origin {}
-
-impl Origin {
-	pub fn produce() -> Produce<OriginProducer, OriginConsumer> {
-		let producer = OriginProducer::default();
-		let consumer = producer.consume();
-		Produce { producer, consumer }
-	}
-}
-
 /// Announces broadcasts to consumers over the network.
 #[derive(Clone, Default)]
 pub struct OriginProducer {
@@ -357,6 +358,10 @@ pub struct OriginProducer {
 }
 
 impl OriginProducer {
+	pub fn new() -> Self {
+		Self::default()
+	}
+
 	/// 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.
@@ -389,7 +394,7 @@ impl OriginProducer {
 		let root = root.clone();
 
 		web_async::spawn(async move {
-			broadcast.closed().await;
+			broadcast.closed().await.ok();
 			root.lock().remove(&full, broadcast, &rest);
 		});
 
diff --git a/rs/moq-lite/src/model/produce.rs b/rs/moq-lite/src/model/produce.rs
index 0c2520649..3492ee788 100644
--- a/rs/moq-lite/src/model/produce.rs
+++ b/rs/moq-lite/src/model/produce.rs
@@ -1,3 +1,5 @@
+use std::fmt;
+
 /// A named tuple of a producer and consumer for convenience.
 ///
 /// The producer and consumer may each be cloned as many times as you want.
@@ -8,3 +10,18 @@ pub struct Produce<P, C> {
 	pub producer: P,
 	pub consumer: C,
 }
+
+impl<P, C> Produce<P, C> {
+	pub fn new(producer: P, consumer: C) -> Self {
+		Self { producer, consumer }
+	}
+}
+
+impl<P: fmt::Debug, C: fmt::Debug> fmt::Debug for Produce<P, C> {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		f.debug_struct("Produce")
+			.field("producer", &self.producer)
+			.field("consumer", &self.consumer)
+			.finish()
+	}
+}
diff --git a/rs/moq-lite/src/model/state.rs b/rs/moq-lite/src/model/state.rs
new file mode 100644
index 000000000..fa0fd72a7
--- /dev/null
+++ b/rs/moq-lite/src/model/state.rs
@@ -0,0 +1,296 @@
+use std::{
+	fmt,
+	future::Future,
+	ops::Deref,
+	sync::{
+		atomic::{self, AtomicUsize},
+		Arc,
+	},
+};
+
+use tokio::sync::watch;
+
+use crate::Error;
+
+#[derive(Default)]
+struct State<T> {
+	value: T,
+	closed: Option<Result<(), Error>>,
+}
+
+pub struct Producer<T> {
+	state: watch::Sender<State<T>>,
+	active: Arc<AtomicUsize>,
+}
+
+impl<T> Producer<T> {
+	pub fn new(value: T) -> Self {
+		Self {
+			state: watch::Sender::new(State { value, closed: None }),
+			active: Arc::new(AtomicUsize::new(1)),
+		}
+	}
+
+	pub fn consume(&self) -> Consumer<T> {
+		Consumer::new(self.state.subscribe())
+	}
+
+	pub fn close(&mut self) -> Result<(), Error> {
+		let mut res = Ok(());
+
+		self.state.send_if_modified(|state| {
+			if let Some(Err(err)) = state.closed.clone() {
+				res = Err(err);
+				return false;
+			}
+
+			state.closed = Some(Ok(()));
+			true
+		});
+
+		res
+	}
+
+	pub fn abort(&mut self, err: Error) -> Result<(), Error> {
+		let mut res = Ok(());
+
+		self.state.send_if_modified(|state| {
+			if let Some(Err(closed)) = state.closed.clone() {
+				res = Err(closed);
+				return false;
+			}
+
+			state.closed = Some(Err(err));
+			true
+		});
+
+		res
+	}
+
+	pub fn modify<F, R>(&self, modify: F) -> Result<R, Error>
+	where
+		F: FnOnce(&mut T) -> R,
+	{
+		// Will be overwritten.
+		let mut result = Err(Error::Cancel);
+
+		self.state.send_if_modified(|state| {
+			if let Some(Err(err)) = state.closed.clone() {
+				result = Err(err);
+				false
+			} else {
+				result = Ok(modify(&mut state.value));
+				true
+			}
+		});
+
+		result
+	}
+
+	pub fn borrow(&self) -> Ref<'_, T> {
+		Ref {
+			inner: self.state.borrow(),
+		}
+	}
+
+	/// Block until there are no more consumers
+	pub fn unused(&self) -> impl Future<Output = ()> {
+		let state = self.state.clone();
+		async move { state.closed().await }
+	}
+
+	pub fn weak(&self) -> ProducerWeak<T> {
+		ProducerWeak {
+			state: self.state.clone(),
+			active: self.active.clone(),
+		}
+	}
+
+	pub fn is_clone(&self, other: &Self) -> bool {
+		self.state.same_channel(&other.state)
+	}
+}
+
+impl<T: Default> Default for Producer<T> {
+	fn default() -> Self {
+		Self::new(Default::default())
+	}
+}
+
+impl<T> Clone for Producer<T> {
+	fn clone(&self) -> Self {
+		self.active.fetch_add(1, atomic::Ordering::Relaxed);
+		Self {
+			state: self.state.clone(),
+			active: self.active.clone(),
+		}
+	}
+}
+
+impl<T> Drop for Producer<T> {
+	fn drop(&mut self) {
+		let active = self.active.fetch_sub(1, atomic::Ordering::Relaxed);
+		if active != 1 {
+			return;
+		}
+
+		self.state.send_if_modified(|state| {
+			if state.closed.is_some() {
+				return false;
+			}
+
+			state.closed = Some(Err(Error::Dropped));
+			true
+		});
+	}
+}
+
+impl<T: fmt::Debug> fmt::Debug for Producer<T> {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		let state = self.state.borrow();
+		f.debug_struct("Producer")
+			.field("state", &state.value)
+			.field("closed", &state.closed)
+			.finish()
+	}
+}
+
+pub struct ProducerWeak<T> {
+	state: watch::Sender<State<T>>,
+	active: Arc<AtomicUsize>,
+}
+
+impl<T> ProducerWeak<T> {
+	pub fn upgrade(&self) -> Result<Producer<T>, Error> {
+		if let Some(Err(err)) = self.state.borrow().closed.clone() {
+			return Err(err);
+		}
+
+		// Minor race; we could have been closed between the check and the fetch_add.
+		// It doesn't matter though, Producer needs to be responsible for other handles closing at random times.
+		self.active.fetch_add(1, atomic::Ordering::Relaxed);
+
+		let producer = Producer {
+			state: self.state.clone(),
+			active: self.active.clone(),
+		};
+
+		Ok(producer)
+	}
+
+	/*
+	pub fn closed(&self) -> impl Future<Output = Result<(), Error>> {
+		let mut state = self.state.subscribe();
+
+		async move {
+			match state.wait_for(|state| state.closed.is_some()).await {
+				Ok(state) => state.closed.clone().unwrap(),
+				Err(_) => Err(Error::Cancel),
+			}
+		}
+	}
+	*/
+}
+
+impl<T: fmt::Debug> fmt::Debug for ProducerWeak<T> {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		let state = self.state.borrow();
+		f.debug_struct("ProducerWeak")
+			.field("state", &state.value)
+			.field("closed", &state.closed)
+			.finish()
+	}
+}
+
+impl<T> Clone for ProducerWeak<T> {
+	fn clone(&self) -> Self {
+		Self {
+			state: self.state.clone(),
+			active: self.active.clone(),
+		}
+	}
+}
+
+pub struct Consumer<T> {
+	inner: watch::Receiver<State<T>>,
+}
+
+impl<T> Consumer<T> {
+	fn new(inner: watch::Receiver<State<T>>) -> Self {
+		Self { inner }
+	}
+
+	pub fn closed(&self) -> impl Future<Output = Result<(), Error>> {
+		// TODO Make a more efficient closed() that doesn't clone the inner.
+		let mut inner = self.inner.clone();
+		async move {
+			match inner.wait_for(|state| state.closed.is_some()).await {
+				Ok(state) => state.closed.clone().unwrap(),
+				Err(_) => unreachable!(),
+			}
+		}
+	}
+
+	// TODO Make a non-mut wait_for
+	// Returns when the function returns true or we're closed.
+	pub async fn wait_for(&mut self, mut f: impl FnMut(&T) -> bool) -> Result<Ref<'_, T>, Error> {
+		let mut matched = false;
+
+		let state = self
+			.inner
+			.wait_for(|state| {
+				// We always want to check the function first, only returning closed if false.
+				matched = f(&state.value);
+				matched || state.closed.is_some()
+			})
+			.await
+			.expect("not closed properly");
+
+		if !matched {
+			if let Some(Err(err)) = state.closed.clone() {
+				return Err(err);
+			}
+		}
+
+		Ok(Ref { inner: state })
+	}
+
+	pub fn borrow(&self) -> Ref<'_, T> {
+		Ref {
+			inner: self.inner.borrow(),
+		}
+	}
+
+	pub fn is_clone(&self, other: &Self) -> bool {
+		self.inner.same_channel(&other.inner)
+	}
+}
+
+impl<T: fmt::Debug> fmt::Debug for Consumer<T> {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		f.debug_struct("Consumer")
+			.field("state", &self.inner.borrow().value)
+			.field("closed", &self.inner.borrow().closed)
+			.finish()
+	}
+}
+
+impl<T> Clone for Consumer<T> {
+	fn clone(&self) -> Self {
+		Self {
+			inner: self.inner.clone(),
+		}
+	}
+}
+
+pub struct Ref<'a, T> {
+	inner: tokio::sync::watch::Ref<'a, State<T>>,
+}
+
+impl<'a, T> Deref for Ref<'a, T> {
+	type Target = T;
+
+	fn deref(&self) -> &Self::Target {
+		&self.inner.value
+	}
+}
diff --git a/rs/moq-lite/src/model/subscriber.rs b/rs/moq-lite/src/model/subscriber.rs
new file mode 100644
index 000000000..c8349cf04
--- /dev/null
+++ b/rs/moq-lite/src/model/subscriber.rs
@@ -0,0 +1,188 @@
+use std::cmp::Reverse;
+use std::ops::Deref;
+use std::{
+	fmt,
+	future::Future,
+	sync::{
+		atomic::{self, AtomicUsize},
+		LazyLock,
+	},
+};
+
+use priority_queue::PriorityQueue;
+use tokio::sync::watch;
+
+use crate::{Delivery, Time};
+
+/// Keeps track of the maximum priority and max latency of all consumers.
+#[derive(Default, Debug)]
+struct Max {
+	priority: PriorityQueue<usize, u8>,
+	max_latency: PriorityQueue<usize, Time>,
+
+	// We prefered `ordered: false`, because those subscribers are more latency sensitive.
+	ordered: PriorityQueue<usize, Reverse<bool>>,
+}
+
+static NEXT_ID: LazyLock<AtomicUsize> = LazyLock::new(|| AtomicUsize::new(0));
+
+pub struct Subscriber {
+	id: usize,
+	max: watch::Sender<Max>,
+	current: Delivery,
+}
+
+impl fmt::Debug for Subscriber {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		f.debug_struct("TrackMetaProducer")
+			.field("state", &self.max.borrow().deref())
+			.field("current", &self.current)
+			.finish()
+	}
+}
+
+impl Subscriber {
+	pub fn new(delivery: Delivery) -> Self {
+		let id = NEXT_ID.fetch_add(1, atomic::Ordering::Relaxed);
+		let max = watch::Sender::new(Max::default());
+
+		let mut this = Self {
+			id,
+			max: max.clone(),
+			current: Default::default(),
+		};
+		this.update(delivery);
+		this
+	}
+
+	pub fn current(&self) -> &Delivery {
+		&self.current
+	}
+
+	pub fn update(&mut self, delivery: Delivery) {
+		self.current = delivery;
+
+		self.max.send_if_modified(|state| {
+			let old_max_latency = state.max_latency.peek().map(|max| max.1).copied().unwrap_or_default();
+			let old_priority = state
+				.priority
+				.peek()
+				.map(|priority| priority.1)
+				.copied()
+				.unwrap_or_default();
+			let old_ordered = state
+				.ordered
+				.peek()
+				.map(|ordered| ordered.1)
+				.copied()
+				.unwrap_or_default();
+
+			state.priority.push(self.id, delivery.priority);
+			state.max_latency.push(self.id, delivery.max_latency);
+			state.ordered.push(self.id, Reverse(delivery.ordered));
+
+			delivery.max_latency > old_max_latency
+				|| delivery.priority > old_priority
+				|| delivery.ordered != old_ordered.0
+		});
+	}
+
+	// We don't use the `async` keyword so we don't borrow &self across the await.
+	pub fn unused(&self) -> impl Future<Output = ()> {
+		let state = self.max.clone();
+		async move {
+			state.closed().await;
+		}
+	}
+}
+
+impl Drop for Subscriber {
+	fn drop(&mut self) {
+		self.max.send_if_modified(|state| {
+			let old_max_latency = state.max_latency.peek().map(|max| max.1).copied().unwrap_or_default();
+			let old_priority = state
+				.priority
+				.peek()
+				.map(|priority| priority.1)
+				.copied()
+				.unwrap_or_default();
+			let old_ordered = state
+				.ordered
+				.peek()
+				.map(|ordered| ordered.1)
+				.copied()
+				.unwrap_or_default();
+
+			state.priority.remove(&self.id).expect("id not found");
+			state.max_latency.remove(&self.id).expect("id not found");
+			state.ordered.remove(&self.id).expect("id not found");
+
+			if let (Some((_, new_max_latency)), Some((_, new_priority)), Some((_, new_ordered))) =
+				(state.max_latency.peek(), state.priority.peek(), state.ordered.peek())
+			{
+				return old_max_latency > *new_max_latency
+					|| old_priority > *new_priority
+					|| old_ordered != *new_ordered;
+			}
+
+			// Always send if there are no more consumers.
+			true
+		});
+	}
+}
+
+#[derive(Clone)]
+pub struct Subscribers {
+	max: (watch::Sender<Max>, watch::Receiver<Max>),
+}
+
+impl fmt::Debug for Subscribers {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		f.debug_struct("TrackMetaConsumer")
+			.field("max", &self.max.1.borrow().deref())
+			.finish()
+	}
+}
+
+impl Subscribers {
+	pub fn new() -> Self {
+		Self {
+			max: watch::channel(Max::default()),
+		}
+	}
+
+	/// Return the latest delivery information, marking it as seen.
+	pub fn latest(&mut self) -> Option<Delivery> {
+		let state = self.max.1.borrow_and_update();
+		Some(Delivery {
+			priority: *state.priority.peek()?.1,
+			max_latency: *state.max_latency.peek()?.1,
+			ordered: state.ordered.peek()?.1 .0,
+		})
+	}
+
+	// Wait until the delivery information changes.
+	pub async fn changed(&mut self) -> Option<Delivery> {
+		self.max.1.changed().await.ok()?;
+		self.latest()
+	}
+
+	pub fn subscribe(&self, delivery: Delivery) -> Subscriber {
+		let id = NEXT_ID.fetch_add(1, atomic::Ordering::Relaxed);
+		let max = self.max.0.clone();
+
+		let mut this = Subscriber {
+			id,
+			max,
+			current: Default::default(),
+		};
+		this.update(delivery);
+		this
+	}
+}
+
+impl Default for Subscribers {
+	fn default() -> Self {
+		Self::new()
+	}
+}
diff --git a/rs/moq-lite/src/model/track.rs b/rs/moq-lite/src/model/track.rs
index 42e1866ec..ec069cb38 100644
--- a/rs/moq-lite/src/model/track.rs
+++ b/rs/moq-lite/src/model/track.rs
@@ -12,193 +12,376 @@
 //!
 //! The track is closed with [Error] when all writers or readers are dropped.
 
-use tokio::sync::watch;
+use web_async::FuturesExt;
+
+use super::{Consumer, Group, GroupConsumer, GroupProducer, Producer, ProducerWeak};
+use crate::{
+	Delivery, DeliveryConsumer, DeliveryProducer, Error, ExpiresConsumer, ExpiresProducer, Produce, Result, Subscriber,
+	Subscribers,
+};
+
+use std::{
+	borrow::Cow,
+	collections::VecDeque,
+	fmt,
+	future::Future,
+	ops::{Deref, DerefMut},
+	sync::Arc,
+};
+
+/// Static information about a track
+///
+/// Only used to make accessing the name easy/fast.
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(transparent))]
+pub struct Track {
+	pub name: Arc<String>,
+}
 
-use crate::{Error, Produce, Result};
+impl fmt::Display for Track {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		write!(f, "{}", self.name)
+	}
+}
 
-use super::{Group, GroupConsumer, GroupProducer};
+impl Track {
+	pub fn new<T: ToString>(name: T) -> Self {
+		Self {
+			name: Arc::new(name.to_string()),
+		}
+	}
 
-use std::{cmp::Ordering, future::Future};
+	pub fn as_str(&self) -> &str {
+		&self.name
+	}
+}
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct Track {
-	pub name: String,
-	pub priority: u8,
+impl From<&str> for Track {
+	fn from(name: &str) -> Self {
+		Self {
+			name: Arc::new(name.to_string()),
+		}
+	}
 }
 
-impl Track {
-	pub fn new<T: Into<String>>(name: T) -> Self {
+impl From<String> for Track {
+	fn from(name: String) -> Self {
+		Self { name: Arc::new(name) }
+	}
+}
+
+impl From<&String> for Track {
+	fn from(name: &String) -> Self {
+		Self {
+			name: Arc::new(name.clone()),
+		}
+	}
+}
+
+impl From<&Track> for Track {
+	fn from(track: &Track) -> Self {
+		track.clone()
+	}
+}
+
+impl From<Cow<'_, str>> for Track {
+	fn from(name: Cow<'_, str>) -> Self {
 		Self {
-			name: name.into(),
-			priority: 0,
+			name: Arc::new(name.into_owned()),
 		}
 	}
+}
 
-	pub fn produce(self) -> Produce<TrackProducer, TrackConsumer> {
-		let producer = TrackProducer::new(self);
-		let consumer = producer.consume();
-		Produce { producer, consumer }
+impl From<Arc<String>> for Track {
+	fn from(name: Arc<String>) -> Self {
+		Self { name }
 	}
 }
 
-#[derive(Default)]
-struct TrackState {
-	latest: Option<GroupConsumer>,
-	closed: Option<Result<()>>,
+impl AsRef<str> for Track {
+	fn as_ref(&self) -> &str {
+		&self.name
+	}
+}
+
+#[derive(Debug, Default)]
+struct State {
+	// Groups in order of arrival.
+	// If None, the group has expired but was not in the front of the queue.
+	groups: VecDeque<Option<Produce<GroupProducer, GroupConsumer>>>,
+
+	// +1 every time we remove a group from the front.
+	offset: usize,
+
+	// The highest sequence number received.
+	max: Option<u64>,
+}
+
+impl State {
+	fn create_group(&mut self, info: Group, expires: ExpiresProducer) -> Result<GroupProducer> {
+		let group = GroupProducer::new(info.clone(), expires);
+
+		// As a sanity check, make sure this is not a duplicate.
+		if self
+			.groups
+			.iter()
+			.filter_map(|g| g.as_ref())
+			.any(|g| g.producer.sequence == group.sequence)
+		{
+			return Err(Error::Duplicate);
+		}
+
+		self.max = Some(self.max.unwrap_or_default().max(group.sequence));
+
+		self.groups.push_back(Some(Produce {
+			consumer: group.consume(),
+			producer: group.clone(),
+		}));
+
+		Ok(group)
+	}
+
+	fn append_group(&mut self, expires: ExpiresProducer) -> GroupProducer {
+		let sequence = match self.max {
+			Some(sequence) => sequence + 1,
+			None => 0,
+		};
+		self.max = Some(sequence);
+
+		let group = GroupProducer::new(Group { sequence }, expires);
+
+		self.groups.push_back(Some(Produce {
+			consumer: group.consume(),
+			producer: group.clone(),
+		}));
+
+		group
+	}
 }
 
 /// A producer for a track, used to create new groups.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct TrackProducer {
-	pub info: Track,
-	state: watch::Sender<TrackState>,
+	info: Track,
+	state: Producer<State>,
+	subscribers: Subscribers,
+	delivery: DeliveryProducer,
+	expires: ExpiresProducer,
 }
 
 impl TrackProducer {
-	fn new(info: Track) -> Self {
+	pub fn new<T: Into<Track>>(info: T, delivery: Delivery) -> Self {
+		let info = info.into();
+
+		let delivery = DeliveryProducer::new(delivery);
+
 		Self {
+			state: Producer::default(),
+			expires: ExpiresProducer::new(delivery.consume()),
+			delivery,
+			subscribers: Default::default(),
 			info,
-			state: Default::default(),
 		}
 	}
 
-	/// Insert a group into the track, returning true if this is the latest group.
-	pub fn insert_group(&mut self, group: GroupConsumer) -> bool {
-		self.state.send_if_modified(|state| {
-			assert!(state.closed.is_none());
-
-			if let Some(latest) = &state.latest {
-				match group.info.cmp(&latest.info) {
-					Ordering::Less => return false,
-					Ordering::Equal => return false,
-					Ordering::Greater => (),
-				}
-			}
-
-			state.latest = Some(group.clone());
-			true
-		})
+	pub fn info(&self) -> Track {
+		self.info.clone()
 	}
 
-	/// Create a new group with the given sequence number.
-	///
-	/// If the sequence number is not the latest, this method will return None.
-	pub fn create_group(&mut self, info: Group) -> Option<GroupProducer> {
-		let group = info.produce();
-		self.insert_group(group.consumer).then_some(group.producer)
+	/// A handle to update the delivery information.
+	pub fn delivery(&mut self) -> &mut DeliveryProducer {
+		&mut self.delivery
 	}
 
-	/// Create a new group with the next sequence number.
-	pub fn append_group(&mut self) -> GroupProducer {
-		let mut producer = None;
-
-		self.state.send_if_modified(|state| {
-			assert!(state.closed.is_none());
-
-			let sequence = state.latest.as_ref().map_or(0, |group| group.info.sequence + 1);
-			let group = Group { sequence }.produce();
-			state.latest = Some(group.consumer);
-			producer = Some(group.producer);
+	/// Information about all of the subscribers of this track.
+	pub fn subscribers(&mut self) -> &mut Subscribers {
+		&mut self.subscribers
+	}
 
-			true
-		});
+	/// Return a handle controlling when groups are expired.
+	pub fn expires(&mut self) -> &mut ExpiresProducer {
+		&mut self.expires
+	}
 
-		producer.unwrap()
+	/// Create a new [GroupProducer] with the given info.
+	///
+	/// Returns an error if the track is closed.
+	pub fn create_group<T: Into<Group>>(&mut self, info: T) -> Result<GroupProducer> {
+		self.state
+			.modify(|state| state.create_group(info.into(), self.expires.clone()))?
 	}
 
-	/// Create a group with a single frame.
-	pub fn write_frame<B: Into<bytes::Bytes>>(&mut self, frame: B) {
-		let mut group = self.append_group();
-		group.write_frame(frame.into());
-		group.close();
+	/// Create a new group with the next sequence number.
+	pub fn append_group(&mut self) -> Result<GroupProducer> {
+		self.state.modify(|state| state.append_group(self.expires.clone()))
 	}
 
-	pub fn close(self) {
-		self.state.send_modify(|state| state.closed = Some(Ok(())));
+	pub fn close(&mut self) -> Result<()> {
+		self.state.close()
 	}
 
-	pub fn abort(self, err: Error) {
-		self.state.send_modify(|state| state.closed = Some(Err(err)));
+	pub fn abort(&mut self, err: Error) -> Result<()> {
+		self.state.abort(err)
 	}
 
 	/// Create a new consumer for the track.
-	pub fn consume(&self) -> TrackConsumer {
+	pub fn subscribe(&self, delivery: Delivery) -> TrackConsumer {
 		TrackConsumer {
 			info: self.info.clone(),
-			state: self.state.subscribe(),
-			prev: None,
+			state: self.state.consume(),
+			subscriber: self.subscribers.subscribe(delivery),
+			index: 0,
+			expires: self.expires.consume(),
+			delivery: self.delivery.consume(),
 		}
 	}
 
 	/// Block until there are no active consumers.
+	// We don't use the `async` keyword so we don't borrow &self across the await.
 	pub fn unused(&self) -> impl Future<Output = ()> {
 		let state = self.state.clone();
-		async move {
-			state.closed().await;
-		}
+		async move { state.unused().await }
 	}
 
 	/// Return true if this is the same track.
 	pub fn is_clone(&self, other: &Self) -> bool {
-		self.state.same_channel(&other.state)
+		self.state.is_clone(&other.state)
+	}
+
+	pub(super) fn weak(&self) -> TrackProducerWeak {
+		TrackProducerWeak {
+			info: self.info.clone(),
+			state: self.state.weak(),
+			subscribers: self.subscribers.clone(),
+			delivery: self.delivery.clone(),
+			expires: self.expires.clone(),
+		}
 	}
 }
 
-impl From<Track> for TrackProducer {
-	fn from(info: Track) -> Self {
-		TrackProducer::new(info)
+impl Deref for TrackProducer {
+	type Target = Track;
+
+	fn deref(&self) -> &Self::Target {
+		&self.info
 	}
 }
 
-/// A consumer for a track, used to read groups.
 #[derive(Clone)]
+pub(super) struct TrackProducerWeak {
+	info: Track,
+	state: ProducerWeak<State>,
+	subscribers: Subscribers,
+	delivery: DeliveryProducer,
+	expires: ExpiresProducer,
+}
+
+impl TrackProducerWeak {
+	pub fn upgrade(self) -> Result<TrackProducer> {
+		Ok(TrackProducer {
+			info: self.info,
+			state: self.state.upgrade()?,
+			subscribers: self.subscribers,
+			delivery: self.delivery,
+			expires: self.expires,
+		})
+	}
+}
+
+/// A consumer for a track, used to read groups.
+///
+/// If the consumer is cloned, it will receive a copy of all unread groups.
+#[derive(Debug)]
 pub struct TrackConsumer {
-	pub info: Track,
-	state: watch::Receiver<TrackState>,
-	prev: Option<u64>, // The previous sequence number
+	info: Track,
+
+	state: Consumer<State>,
+
+	subscriber: Subscriber,
+
+	expires: ExpiresConsumer,
+
+	// We last returned this group, factoring in offset
+	index: usize,
+
+	delivery: DeliveryConsumer,
 }
 
 impl TrackConsumer {
-	/// Return the next group in order.
+	pub fn info(&self) -> Track {
+		self.info.clone()
+	}
+
+	/// Return the next group received over the network, in any order.
+	///
+	/// See [TrackConsumerOrdered] if you're willing to buffer groups in order.
 	///
-	/// NOTE: This can have gaps if the reader is too slow or there were network slowdowns.
+	/// NOTE: This can have gaps due to congestion.
 	pub async fn next_group(&mut self) -> Result<Option<GroupConsumer>> {
-		// Wait until there's a new latest group or the track is closed.
-		let state = match self
-			.state
-			.wait_for(|state| {
-				state.latest.as_ref().map(|group| group.info.sequence) > self.prev || state.closed.is_some()
-			})
-			.await
-		{
-			Ok(state) => state,
-			Err(_) => return Err(Error::Cancel),
-		};
-
-		match &state.closed {
-			Some(Ok(_)) => return Ok(None),
-			Some(Err(err)) => return Err(err.clone()),
-			_ => {}
-		}
+		loop {
+			// Wait until there's a new latest group or the track is closed.
+			let state = self
+				.state
+				.wait_for(|state| self.index < state.offset + state.groups.len())
+				.await?;
+
+			let range = self.index.saturating_sub(state.offset)..state.groups.len();
+			if range.is_empty() {
+				// Closed
+				return Ok(None);
+			}
 
-		// If there's a new latest group, return it.
-		let group = state.latest.clone().unwrap();
-		self.prev = Some(group.info.sequence);
+			for i in range {
+				self.index = state.offset + i + 1;
 
-		Ok(Some(group))
+				// If None, the group has expired out of order.
+				if let Some(group) = &state.groups[i] {
+					// NOTE: This group might be expired from the consumer's perspective.
+					// Return than skip it, we return expires groups because it's still useful information.
+					return Ok(Some(group.consumer.clone()));
+				}
+			}
+		}
 	}
 
 	/// Block until the track is closed.
 	pub async fn closed(&self) -> Result<()> {
-		match self.state.clone().wait_for(|state| state.closed.is_some()).await {
-			Ok(state) => state.closed.clone().unwrap(),
-			Err(_) => Err(Error::Cancel),
-		}
+		self.state.closed().await
 	}
 
 	pub fn is_clone(&self, other: &Self) -> bool {
-		self.state.same_channel(&other.state)
+		self.state.is_clone(&other.state)
+	}
+
+	/// Return a handle allowing you to update the subscriber's priority/max_latency.
+	pub fn subscriber(&mut self) -> &mut Subscriber {
+		&mut self.subscriber
+	}
+
+	/// Return a handle to detect when groups are expired.
+	///
+	/// This is used internally, but worth exporting I guess.
+	pub fn expires(&mut self) -> &mut ExpiresConsumer {
+		&mut self.expires
+	}
+
+	/// Return a handle to update the delivery information.
+	pub fn delivery(&mut self) -> &mut DeliveryConsumer {
+		&mut self.delivery
+	}
+
+	/// Convert to a helper that returns groups in order, if possible.
+	pub fn ordered(self) -> TrackConsumerOrdered {
+		TrackConsumerOrdered::new(self)
+	}
+}
+
+impl Deref for TrackConsumer {
+	type Target = Track;
+
+	fn deref(&self) -> &Self::Target {
+		&self.info
 	}
 }
 
@@ -246,3 +429,392 @@ impl TrackConsumer {
 		assert!(!self.is_clone(other), "should not be clone");
 	}
 }
+
+/// A [TrackConsumer] that returns groups in creation order, if possible.
+///
+/// It's recommended to set [Delivery::ordered] too if you REALLY want head-of-line blocking.
+/// The user experience would be to buffer rather than skip any groups, except in severe congestion.
+///
+/// With [Delivery::ordered] not set, we will try our best to return groups in order up to `max_latency`.
+/// This produces a hybrid experience where we'll buffer up until a point then skip ahead to newer groups.
+//
+// TODO: There's no group dropped message (yet), so we guess based on min/max timestamps.
+pub struct TrackConsumerOrdered {
+	track: TrackConsumer,
+	expected: u64,
+	pending: VecDeque<GroupConsumer>,
+}
+
+impl TrackConsumerOrdered {
+	pub fn new(track: TrackConsumer) -> Self {
+		Self {
+			track,
+			expected: 0,
+			pending: VecDeque::new(),
+		}
+	}
+
+	pub async fn next_group(&mut self) -> Result<Option<GroupConsumer>> {
+		let mut expires = self.track.expires().clone();
+
+		loop {
+			tokio::select! {
+				biased;
+				// Get the next group from the track.
+				Some(group) = self.track.next_group().transpose() => {
+					let group = group?;
+
+					// If we're looking for this sequence number, return it.
+					if group.sequence == self.expected {
+						self.expected += 1;
+						return Ok(Some(group));
+					}
+
+					// If it's old, skip it.
+					if group.sequence < self.expected {
+						continue;
+					}
+
+					// If it's new, insert it into the buffered queue based on the sequence number ascending.
+					let index = self.pending.partition_point(|g| g.sequence < group.sequence);
+					self.pending.insert(index, group);
+				}
+				Some(next) = async {
+					loop {
+						// Get the oldest group in the buffered queue.
+						let first = self.pending.front()?;
+
+						// If the minimum sequence is not what we're looking for, wait until it would be expired.
+						if first.sequence != self.expected {
+							// Wait until the first frame of the group has been received.
+							let Ok(Some(frame)) = first.clone().next_frame().await else {
+								// The group has no frames, just skip it.
+								self.pending.pop_front();
+								continue;
+							};
+
+							// Wait until the first frame of the group would have been expired.
+							// This doesn't mean the entire group is expired, because that uses the max_timestamp.
+							// But even if the group has one frame this will still unstuck the consumer.
+							expires.wait_expired(first.sequence, frame.instant).await;
+						}
+
+						// Return the minimum group and skip over any gap.
+						let first = self.pending.pop_front().unwrap();
+						self.expected = first.sequence + 1;
+
+						return Some(first);
+					}
+				} => {
+					// We found the next group in order, so update the expected sequence number.
+					self.expected = next.sequence + 1;
+					return Ok(Some(next));
+				}
+			}
+		}
+	}
+}
+
+impl Deref for TrackConsumerOrdered {
+	type Target = TrackConsumer;
+
+	fn deref(&self) -> &Self::Target {
+		&self.track
+	}
+}
+
+impl DerefMut for TrackConsumerOrdered {
+	fn deref_mut(&mut self) -> &mut Self::Target {
+		&mut self.track
+	}
+}
+
+#[cfg(test)]
+impl TrackConsumerOrdered {
+	pub fn assert_next_group(&mut self) -> GroupConsumer {
+		use futures::FutureExt;
+		self.next_group()
+			.now_or_never()
+			.expect("next_group blocked")
+			.expect("next_group error")
+			.expect("next_group returned None")
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::Time;
+	use bytes::Bytes;
+
+	#[test]
+	fn test_track_new() {
+		let track = Track::new("test");
+		assert_eq!(track.as_str(), "test");
+	}
+
+	#[test]
+	fn test_track_from_str() {
+		let track: Track = "test".into();
+		assert_eq!(track.as_str(), "test");
+	}
+
+	#[test]
+	fn test_track_from_string() {
+		let track: Track = String::from("test").into();
+		assert_eq!(track.as_str(), "test");
+	}
+
+	#[tokio::test]
+	async fn test_track_append_group() {
+		let mut producer = TrackProducer::new("test", Delivery::default());
+		let mut consumer = producer.subscribe(Delivery::default());
+
+		// Append first group
+		let mut group1 = producer.append_group().unwrap();
+		assert_eq!(group1.sequence, 0);
+
+		// Write a frame to the group
+		let instant = Time::from_millis(100).unwrap();
+		group1.write_frame(Bytes::from("data1"), instant).unwrap();
+		group1.close().unwrap();
+
+		// Consumer should receive the group
+		let mut group1_consumer = consumer.assert_group();
+		assert_eq!(group1_consumer.sequence, 0);
+		let data = group1_consumer.read_frame().await.unwrap().unwrap();
+		assert_eq!(data, Bytes::from("data1"));
+
+		// Append second group
+		let mut group2 = producer.append_group().unwrap();
+		assert_eq!(group2.sequence, 1);
+		group2.write_frame(Bytes::from("data2"), instant).unwrap();
+		group2.close().unwrap();
+
+		let mut group2_consumer = consumer.assert_group();
+		assert_eq!(group2_consumer.sequence, 1);
+		let data = group2_consumer.read_frame().await.unwrap().unwrap();
+		assert_eq!(data, Bytes::from("data2"));
+	}
+
+	#[tokio::test]
+	async fn test_track_create_group() {
+		let mut producer = TrackProducer::new("test", Delivery::default());
+		let mut consumer = producer.subscribe(Delivery::default());
+
+		// Create a group with specific sequence
+		let mut group = producer.create_group(Group { sequence: 42 }).unwrap();
+		assert_eq!(group.sequence, 42);
+
+		let instant = Time::from_millis(100).unwrap();
+		group.write_frame(Bytes::from("hello"), instant).unwrap();
+		group.close().unwrap();
+
+		let group_consumer = consumer.assert_group();
+		assert_eq!(group_consumer.sequence, 42);
+	}
+
+	#[tokio::test]
+	async fn test_track_duplicate_group() {
+		let mut producer = TrackProducer::new("test", Delivery::default());
+
+		// Create first group with sequence 5
+		let _group1 = producer.create_group(Group { sequence: 5 }).unwrap();
+
+		// Try to create another group with the same sequence
+		let result = producer.create_group(Group { sequence: 5 });
+		assert!(result.is_err());
+	}
+
+	#[tokio::test]
+	async fn test_track_multiple_consumers() {
+		let mut producer = TrackProducer::new("test", Delivery::default());
+		let mut consumer1 = producer.subscribe(Delivery::default());
+		let mut consumer2 = producer.subscribe(Delivery::default());
+
+		let mut group = producer.append_group().unwrap();
+		let instant = Time::from_millis(100).unwrap();
+		group.write_frame(Bytes::from("shared"), instant).unwrap();
+		group.close().unwrap();
+
+		// Both consumers should receive the group
+		let mut g1 = consumer1.assert_group();
+		let mut g2 = consumer2.assert_group();
+
+		assert_eq!(g1.read_frame().await.unwrap().unwrap(), Bytes::from("shared"));
+		assert_eq!(g2.read_frame().await.unwrap().unwrap(), Bytes::from("shared"));
+	}
+
+	#[tokio::test]
+	async fn test_track_close() {
+		let mut producer = TrackProducer::new("test", Delivery::default());
+		let consumer = producer.subscribe(Delivery::default());
+
+		producer.close().unwrap();
+
+		// Consumer should detect the track is closed
+		consumer.assert_closed();
+	}
+
+	#[tokio::test]
+	async fn test_track_abort() {
+		let mut producer = TrackProducer::new("test", Delivery::default());
+		let consumer = producer.subscribe(Delivery::default());
+
+		producer.abort(Error::Cancel).unwrap();
+
+		// Consumer should detect the error
+		consumer.assert_error();
+	}
+
+	#[tokio::test]
+	async fn test_track_info() {
+		let track_info = Track::new("my_track");
+		let producer = TrackProducer::new(track_info.clone(), Delivery::default());
+		let consumer = producer.subscribe(Delivery::default());
+
+		assert_eq!(producer.info().as_str(), "my_track");
+		assert_eq!(consumer.info().as_str(), "my_track");
+	}
+
+	#[tokio::test]
+	async fn test_track_is_clone() {
+		let producer1 = TrackProducer::new("test", Delivery::default());
+		let producer2 = producer1.clone();
+		let producer3 = TrackProducer::new("test", Delivery::default());
+
+		assert!(producer1.is_clone(&producer2));
+		assert!(!producer1.is_clone(&producer3));
+
+		let consumer1 = producer1.subscribe(Delivery::default());
+		let consumer2 = producer1.subscribe(Delivery::default());
+		let consumer3 = producer3.subscribe(Delivery::default());
+
+		consumer1.assert_is_clone(&consumer2);
+		consumer1.assert_not_clone(&consumer3);
+	}
+
+	#[tokio::test]
+	async fn test_track_delivery_updates() {
+		let mut producer = TrackProducer::new("test", Delivery::default());
+		let mut consumer = producer.subscribe(Delivery::default());
+
+		// Update delivery info
+		let new_delivery = Delivery {
+			priority: 10,
+			max_latency: Time::from_millis(500).unwrap(),
+			ordered: true,
+		};
+		producer.delivery().update(new_delivery);
+
+		// Consumer should see the update
+		let updated = consumer.delivery().changed().await.unwrap();
+		assert_eq!(updated.priority, 10);
+		assert_eq!(updated.max_latency, Time::from_millis(500).unwrap());
+		assert!(updated.ordered);
+	}
+
+	#[tokio::test]
+	async fn test_track_ordered_consumer() {
+		// Set max_latency to allow buffering out-of-order groups
+		let delivery = Delivery {
+			max_latency: Time::from_millis(500).unwrap(),
+			..Default::default()
+		};
+		let mut producer = TrackProducer::new("test", delivery);
+		let consumer = producer.subscribe(delivery);
+		let mut ordered = consumer.ordered();
+
+		// Create groups out of order
+		let mut group2 = producer.create_group(Group { sequence: 1 }).unwrap();
+		let mut group3 = producer.create_group(Group { sequence: 2 }).unwrap();
+		let mut group1 = producer.create_group(Group { sequence: 0 }).unwrap();
+
+		// Use timestamps that correspond to when each group was created
+		// Group 0 has timestamp 0ms, group 1 has 100ms, group 2 has 200ms
+		let t0 = Time::from_millis(0).unwrap();
+		let t1 = Time::from_millis(100).unwrap();
+		let t2 = Time::from_millis(200).unwrap();
+
+		// Write and close in reverse order (groups arrive out of order)
+		group3.write_frame(Bytes::from("g3"), t2).unwrap();
+		group3.close().unwrap();
+
+		group1.write_frame(Bytes::from("g1"), t0).unwrap();
+		group1.close().unwrap();
+
+		group2.write_frame(Bytes::from("g2"), t1).unwrap();
+		group2.close().unwrap();
+
+		// Ordered consumer should return them in order despite arriving out of order
+		let g = ordered.assert_next_group();
+		assert_eq!(g.sequence, 0);
+
+		let g = ordered.assert_next_group();
+		assert_eq!(g.sequence, 1);
+
+		let g = ordered.assert_next_group();
+		assert_eq!(g.sequence, 2);
+	}
+
+	#[tokio::test]
+	async fn test_track_ordered_consumer_skip_expired() {
+		// Set max_latency to allow some buffering but not infinite
+		let delivery = Delivery {
+			max_latency: Time::from_millis(150).unwrap(),
+			..Default::default()
+		};
+		let mut producer = TrackProducer::new("test", delivery);
+		let consumer = producer.subscribe(delivery);
+		let mut ordered = consumer.ordered();
+
+		// Create groups where we'll skip group 1
+		let mut group0 = producer.create_group(Group { sequence: 0 }).unwrap();
+		let mut group2 = producer.create_group(Group { sequence: 2 }).unwrap();
+		let mut group3 = producer.create_group(Group { sequence: 3 }).unwrap();
+
+		// Timestamps need to satisfy: group2_instant + max_latency <= max_instant
+		// So: 100ms + 150ms <= 300ms ✓ (250 <= 300)
+		let t0 = Time::from_millis(0).unwrap();
+		let t2 = Time::from_millis(100).unwrap();
+		let t3 = Time::from_millis(300).unwrap();
+
+		// Write groups 0, 2, 3 (skip group 1)
+		group0.write_frame(Bytes::from("g0"), t0).unwrap();
+		group0.close().unwrap();
+
+		group2.write_frame(Bytes::from("g2"), t2).unwrap();
+		group2.close().unwrap();
+
+		group3.write_frame(Bytes::from("g3"), t3).unwrap();
+		group3.close().unwrap();
+
+		// Should get group 0 immediately
+		let g = ordered.assert_next_group();
+		assert_eq!(g.sequence, 0);
+
+		// Should skip group 1 (missing) and get group 2
+		// The ordered consumer waits for the first buffered group (group 2) to expire:
+		// - group 2 sequence (2) < max_group (3) ✓
+		// - group 2 instant (100ms) + max_latency (150ms) = 250ms <= max_instant (300ms) ✓
+		// So group 2 should be expired and returned immediately, skipping group 1
+		let g = ordered.assert_next_group();
+		assert_eq!(g.sequence, 2);
+
+		// Then get group 3
+		let g = ordered.assert_next_group();
+		assert_eq!(g.sequence, 3);
+	}
+
+	#[tokio::test]
+	async fn test_track_unused() {
+		let producer = TrackProducer::new("test", Delivery::default());
+
+		// Create and drop a consumer
+		let consumer = producer.subscribe(Delivery::default());
+		drop(consumer);
+
+		// Producer should eventually become unused
+		producer.unused().await;
+	}
+}
diff --git a/rs/moq-lite/src/session.rs b/rs/moq-lite/src/session.rs
index f236230ce..7a9a1ef0e 100644
--- a/rs/moq-lite/src/session.rs
+++ b/rs/moq-lite/src/session.rs
@@ -17,7 +17,8 @@ pub struct Session {
 /// The versions of MoQ that are supported by this implementation.
 ///
 /// Ordered by preference, with the client's preference taking priority.
-pub const VERSIONS: [coding::Version; 3] = [
+pub const VERSIONS: [coding::Version; 4] = [
+	lite::Version::Draft03.coding(),
 	lite::Version::Draft02.coding(),
 	lite::Version::Draft01.coding(),
 	ietf::Version::Draft14.coding(),
@@ -45,8 +46,8 @@ impl Session {
 		let mut stream = Stream::open(&session, setup::ServerKind::Ietf14).await?;
 
 		let mut parameters = ietf::Parameters::default();
-		parameters.set_varint(ietf::ParameterVarInt::MaxRequestId, u32::MAX as u64);
-		parameters.set_bytes(ietf::ParameterBytes::Implementation, b"moq-lite-rs".to_vec());
+		parameters.set_int(ietf::SetupParameter::MaxRequestId.into(), u32::MAX as u64);
+		parameters.set_bytes(ietf::SetupParameter::Implementation.into(), b"moq-lite-rs".to_vec());
 		let parameters = parameters.encode_bytes(());
 
 		let client = setup::Client {
@@ -67,11 +68,15 @@ impl Session {
 		if let Ok(version) = lite::Version::try_from(server.version) {
 			let stream = stream.with_version(version);
 			lite::start(session.clone(), stream, publish.into(), subscribe.into(), version).await?;
+
+			tracing::debug!(version = ?server.version, "connected");
 		} else if let Ok(version) = ietf::Version::try_from(server.version) {
 			// Decode the parameters to get the initial request ID.
 			let parameters = ietf::Parameters::decode(&mut server.parameters, version)?;
-			let request_id_max =
-				ietf::RequestId(parameters.get_varint(ietf::ParameterVarInt::MaxRequestId).unwrap_or(0));
+			let request_id_max = parameters
+				.get_int(ietf::SetupParameter::MaxRequestId.into())
+				.map(ietf::RequestId)
+				.unwrap_or_default();
 
 			let stream = stream.with_version(version);
 			ietf::start(
@@ -84,13 +89,13 @@ impl Session {
 				version,
 			)
 			.await?;
+
+			tracing::debug!(version = ?server.version, "connected");
 		} else {
 			// unreachable, but just in case
 			return Err(Error::Version(client.versions, [server.version].into()));
 		}
 
-		tracing::debug!(version = ?server.version, "connected");
-
 		Ok(Self::new(session))
 	}
 
@@ -105,7 +110,7 @@ impl Session {
 	) -> Result<Self, Error> {
 		// Accept with an initial version; we'll switch to the negotiated version later
 		let mut stream = Stream::accept(&session, ()).await?;
-		let client: setup::Client = stream.reader.decode().await?;
+		let mut client: setup::Client = stream.reader.decode().await?;
 		tracing::trace!(?client, "received client setup");
 
 		// Choose the version to use
@@ -119,14 +124,14 @@ impl Session {
 		// Only encode parameters if we're using the IETF draft because it has max_request_id
 		let parameters = if ietf::Version::try_from(version).is_ok() && client.kind == setup::ClientKind::Ietf14 {
 			let mut parameters = ietf::Parameters::default();
-			parameters.set_varint(ietf::ParameterVarInt::MaxRequestId, u32::MAX as u64);
-			parameters.set_bytes(ietf::ParameterBytes::Implementation, b"moq-lite-rs".to_vec());
+			parameters.set_int(ietf::SetupParameter::MaxRequestId.into(), u32::MAX as u64);
+			parameters.set_bytes(ietf::SetupParameter::Implementation.into(), b"moq-lite-rs".to_vec());
 			parameters.encode_bytes(())
 		} else {
 			lite::Parameters::default().encode_bytes(())
 		};
 
-		let mut server = setup::Server { version, parameters };
+		let server = setup::Server { version, parameters };
 		tracing::trace!(?server, "sending server setup");
 
 		let mut stream = stream.with_version(client.kind.reply());
@@ -135,11 +140,15 @@ impl Session {
 		if let Ok(version) = lite::Version::try_from(version) {
 			let stream = stream.with_version(version);
 			lite::start(session.clone(), stream, publish.into(), subscribe.into(), version).await?;
+
+			tracing::debug!(?version, "connected");
 		} else if let Ok(version) = ietf::Version::try_from(version) {
 			// Decode the parameters to get the initial request ID.
-			let parameters = ietf::Parameters::decode(&mut server.parameters, version)?;
-			let request_id_max =
-				ietf::RequestId(parameters.get_varint(ietf::ParameterVarInt::MaxRequestId).unwrap_or(0));
+			let parameters = ietf::Parameters::decode(&mut client.parameters, version)?;
+			let request_id_max = parameters
+				.get_int(ietf::SetupParameter::MaxRequestId.into())
+				.map(ietf::RequestId)
+				.unwrap_or_default();
 
 			let stream = stream.with_version(version);
 			ietf::start(
@@ -152,13 +161,13 @@ impl Session {
 				version,
 			)
 			.await?;
+
+			tracing::debug!(?version, "connected");
 		} else {
 			// unreachable, but just in case
 			return Err(Error::Version(client.versions, VERSIONS.into()));
 		}
 
-		tracing::debug!(?version, "connected");
-
 		Ok(Self::new(session))
 	}
 
diff --git a/rs/moq-native/examples/chat.rs b/rs/moq-native/examples/chat.rs
index c53da3e43..0c99477df 100644
--- a/rs/moq-native/examples/chat.rs
+++ b/rs/moq-native/examples/chat.rs
@@ -1,5 +1,7 @@
 // cargo run --example chat
 
+use anyhow::Context;
+
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
 	// Optional: Use moq_native to configure a logger.
@@ -9,14 +11,14 @@ async fn main() -> anyhow::Result<()> {
 	.init();
 
 	// Create an origin that we can publish to and the session can consume from.
-	let origin = moq_lite::Origin::produce();
+	let origin = moq_lite::OriginProducer::new();
 
 	// Run the broadcast production and the session in parallel.
 	// This is a simple example of how you can concurrently run multiple tasks.
 	// tokio::spawn works too.
 	tokio::select! {
-		res = run_broadcast(origin.producer) => res,
-		res = run_session(origin.consumer) => res,
+		res = run_session(origin.consume()) => res,
+		res = run_broadcast(origin) => res,
 	}
 }
 
@@ -40,43 +42,34 @@ async fn run_session(origin: moq_lite::OriginConsumer) -> anyhow::Result<()> {
 
 // 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..
-	// A broadcast is a collection of tracks, but in this example we'll only create one.
-	let mut broadcast = moq_lite::Broadcast::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.producer.create_track(moq_lite::Track {
-		name: "chat".to_string(),
-		priority: 0,
-	});
-
 	// 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".
-	// OPTIONAL: We publish after inserting the track just to avoid a nearly impossible race condition.
-	origin.publish_broadcast("", broadcast.consumer);
+	let mut broadcast = origin.create_broadcast("").context("not allowed to publish")?;
+
+	// A track is a series of groups representing a live stream.
+	let mut track = broadcast.create_track(
+		"chat",
+		moq_lite::Delivery {
+			priority: 0,
+			max_latency: moq_lite::Time::from_secs(10)?,
+			ordered: true,
+		},
+	)?;
 
 	// Create a group.
 	// Each group is independent and the newest group(s) will be prioritized.
-	let mut group = track.append_group();
+	let mut group = track.append_group()?;
 
 	// Write frames to the group.
 	// Each frame is dependent on the previous frame, so older frames are prioritized.
-	group.write_frame(bytes::Bytes::from_static(b"Hello"));
-	group.write_frame(bytes::Bytes::from_static(b"World"));
-	group.close();
+	group.write_frame(bytes::Bytes::from_static(b"Hello"), moq_lite::Time::from_secs(1)?)?;
+	group.write_frame(bytes::Bytes::from_static(b"World"), moq_lite::Time::from_secs(2)?)?;
+	group.close()?;
 
 	tracing::info!("wrote hello + world");
 
 	// Sleep before sending our next message.
 	tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;
 
-	// There's also a helper method to create a group with a single frame.
-	track.write_frame(bytes::Bytes::from_static(b"foobarbaz"));
-	tracing::info!("wrote foobarbaz");
-
-	// Sleep before exiting and closing the broadcast.
-	tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;
-
 	Ok(())
 }
diff --git a/rs/moq-relay/src/cluster.rs b/rs/moq-relay/src/cluster.rs
index 4f35fffb4..7d18cd533 100644
--- a/rs/moq-relay/src/cluster.rs
+++ b/rs/moq-relay/src/cluster.rs
@@ -1,7 +1,7 @@
-use std::{collections::HashMap, path::PathBuf, sync::Arc};
+use std::{collections::HashMap, path::PathBuf};
 
 use anyhow::Context;
-use moq_lite::{Broadcast, BroadcastConsumer, BroadcastProducer, Origin, OriginConsumer, OriginProducer};
+use moq_lite::{BroadcastConsumer, BroadcastProducer, OriginConsumer, OriginProducer};
 use tracing::Instrument;
 use url::Url;
 
@@ -57,16 +57,16 @@ pub struct Cluster {
 	client: moq_native::Client,
 
 	// Advertises ourselves as an origin to other nodes.
-	noop: moq_lite::Produce<BroadcastProducer, BroadcastConsumer>,
+	noop: BroadcastProducer,
 
 	// Broadcasts announced by local clients (users).
-	pub primary: Arc<moq_lite::Produce<OriginProducer, OriginConsumer>>,
+	pub primary: OriginProducer,
 
 	// Broadcasts announced by remote servers (cluster).
-	pub secondary: Arc<moq_lite::Produce<OriginProducer, OriginConsumer>>,
+	pub secondary: OriginProducer,
 
 	// Broadcasts announced by local clients and remote servers.
-	pub combined: Arc<moq_lite::Produce<OriginProducer, OriginConsumer>>,
+	pub combined: OriginProducer,
 }
 
 impl Cluster {
@@ -74,10 +74,10 @@ impl Cluster {
 		Cluster {
 			config,
 			client,
-			noop: Broadcast::produce(),
-			primary: Arc::new(Origin::produce()),
-			secondary: Arc::new(Origin::produce()),
-			combined: Arc::new(Origin::produce()),
+			noop: BroadcastProducer::new(),
+			primary: OriginProducer::new(),
+			secondary: OriginProducer::new(),
+			combined: OriginProducer::new(),
 		}
 	}
 
@@ -92,7 +92,7 @@ impl Cluster {
 		};
 
 		// Scope the origin to our root.
-		let subscribe_origin = subscribe_origin.producer.with_root(&token.root)?;
+		let subscribe_origin = subscribe_origin.with_root(&token.root)?;
 		subscribe_origin.consume_only(&token.subscribe)
 	}
 
@@ -104,15 +104,15 @@ impl Cluster {
 			false => &self.primary,
 		};
 
-		let publish_origin = publish_origin.producer.with_root(&token.root)?;
+		let publish_origin = publish_origin.with_root(&token.root)?;
 		publish_origin.publish_only(&token.publish)
 	}
 
 	pub fn get(&self, broadcast: &str) -> Option<BroadcastConsumer> {
 		self.primary
-			.consumer
+			.consume()
 			.consume_broadcast(broadcast)
-			.or_else(|| self.secondary.consumer.consume_broadcast(broadcast))
+			.or_else(|| self.secondary.consume().consume_broadcast(broadcast))
 	}
 
 	pub async fn run(self) -> anyhow::Result<()> {
@@ -131,14 +131,13 @@ impl Cluster {
 		// Use with_root to automatically strip the prefix from announced paths.
 		let origins = self
 			.secondary
-			.producer
 			.with_root(&self.config.prefix)
 			.context("no authorized origins")?;
 
 		// Announce ourselves as an origin to the root node.
 		if let Some(myself) = self.config.node.as_ref() {
 			tracing::info!(%myself, "announcing as leaf");
-			origins.publish_broadcast(myself, self.noop.consumer.clone());
+			origins.publish_broadcast(myself, self.noop.consume());
 		}
 
 		// If the token is provided, read it from the disk and use it in the query parameter.
@@ -148,7 +147,7 @@ impl Cluster {
 			None => "".to_string(),
 		};
 
-		let noop = self.noop.consumer.clone();
+		let noop = self.noop.consume();
 
 		// Despite returning a Result, we should NEVER return an Ok
 		tokio::select! {
@@ -169,8 +168,8 @@ impl Cluster {
 
 	// Shovel broadcasts from the primary and secondary origins into the combined origin.
 	async fn run_combined(self) -> anyhow::Result<()> {
-		let mut primary = self.primary.consumer.consume();
-		let mut secondary = self.secondary.consumer.consume();
+		let mut primary = self.primary.consume();
+		let mut secondary = self.secondary.consume();
 
 		loop {
 			let (name, broadcast) = tokio::select! {
@@ -181,7 +180,7 @@ impl Cluster {
 			};
 
 			if let Some(broadcast) = broadcast {
-				self.combined.producer.publish_broadcast(&name, broadcast);
+				self.combined.publish_broadcast(&name, broadcast);
 			}
 		}
 	}
@@ -264,8 +263,8 @@ impl Cluster {
 		tracing::info!(%url, "connecting to remote");
 
 		// Connect to the remote node.
-		let publish = Some(self.primary.consumer.consume());
-		let subscribe = Some(self.secondary.producer.clone());
+		let publish = Some(self.primary.consume());
+		let subscribe = Some(self.secondary.clone());
 
 		let session = self
 			.client
diff --git a/rs/moq-relay/src/main.rs b/rs/moq-relay/src/main.rs
index 0411ea82f..983c5d5bf 100644
--- a/rs/moq-relay/src/main.rs
+++ b/rs/moq-relay/src/main.rs
@@ -20,6 +20,8 @@ pub use config::*;
 pub use connection::*;
 pub use web::*;
 
+use futures::FutureExt;
+
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
 	// TODO: It would be nice to remove this and rely on feature flags only.
@@ -46,8 +48,7 @@ async fn main() -> anyhow::Result<()> {
 	let auth = config.auth.init()?;
 
 	let cluster = Cluster::new(config.cluster, client);
-	let cloned = cluster.clone();
-	tokio::spawn(async move { cloned.run().await.expect("cluster failed") });
+	tokio::spawn(cluster.clone().run().boxed());
 
 	// Create a web server too.
 	let web = Web::new(
@@ -60,9 +61,7 @@ async fn main() -> anyhow::Result<()> {
 		config.web,
 	);
 
-	tokio::spawn(async move {
-		web.run().await.expect("failed to run web server");
-	});
+	tokio::spawn(web.run().boxed());
 
 	tracing::info!(%addr, "listening");
 
@@ -81,6 +80,7 @@ async fn main() -> anyhow::Result<()> {
 		};
 
 		conn_id += 1;
+
 		tokio::spawn(async move {
 			let err = conn.run().await;
 			if let Err(err) = err {
diff --git a/rs/moq-relay/src/web.rs b/rs/moq-relay/src/web.rs
index 7c62cd92e..323afa350 100644
--- a/rs/moq-relay/src/web.rs
+++ b/rs/moq-relay/src/web.rs
@@ -273,19 +273,16 @@ async fn serve_fetch(
 
 	tracing::info!(%broadcast, %track, "fetching track");
 
-	let track = moq_lite::Track {
-		name: track,
-		priority: 0,
-	};
-
 	// 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);
+
+	let mut track = broadcast
+		.subscribe_track(track, moq_lite::Delivery::default())
+		.map_err(|_| StatusCode::NOT_FOUND)?;
 
 	let group = match track.next_group().await {
 		Ok(Some(group)) => group,
-		Ok(None) => return Err(StatusCode::NOT_FOUND.into()),
-		Err(_) => return Err(StatusCode::INTERNAL_SERVER_ERROR.into()),
+		_ => return Err(StatusCode::NOT_FOUND.into()),
 	};
 
 	Ok(ServeGroup::new(group))