From f6a3c022130839829e636c15fcb7ef99b4c14015 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 3 Nov 2026 11:07:24 -0800 Subject: [PATCH 01/13] quest: plan the 2026-11-03 follow-ups Add 23 quests the maintainer settled in the 2026-11-03 follow-up planning interview, edit ten existing quests with the follow-ups they absorb, and delete m0/test-flakes-2/tokio-close-drain.md, fixed by moq-dev/moq#7634. Co-Authored-By: Claude Opus 5.5 --- quest/m0/README.md | 2 + quest/m0/ci/README.md | 1 + quest/m0/ci/no-fail-fast.md | 24 ++++++++++ quest/m0/cmaf-receive-bounds.md | 45 +++++++++++++++++++ quest/m0/nightly/README.md | 9 +++- quest/m0/nightly/bindings-bench-evicted.md | 27 +++++++++++ quest/m0/nightly/miri-frame.md | 30 +++++++++++++ quest/m0/nightly/receive-windows-evicted.md | 34 ++++++++++++++ quest/m0/nightly/relay-stack.md | 26 +++++++++++ quest/m0/test-flakes-2/README.md | 1 - quest/m0/test-flakes-2/tokio-close-drain.md | 25 ----------- quest/m0/video-sps-walk.md | 40 +++++++++++++++++ quest/m1/README.md | 5 +++ .../m1/audio-jitter-target/capped-budgets.md | 19 +++++++- quest/m1/c/api-gaps.md | 17 +++---- quest/m1/cluster-routing/routes.md | 2 +- quest/m1/js-bigint-audit.md | 34 ++++++++++++++ quest/m1/js-follow-abort-wake.md | 38 ++++++++++++++++ quest/m1/js-resume-model-12345.md | 34 ++++++++++++++ quest/m1/msf-ext-proto.md | 25 +++++++++++ quest/m1/socket/README.md | 1 + quest/m1/socket/carla.md | 6 +++ quest/m1/socket/old-hop-dial.md | 34 ++++++++++++++ quest/m1/subscribe-ranges/README.md | 1 + quest/m1/subscribe-ranges/js-fills.md | 45 +++++++++++++++++++ quest/m1/subscribe-ranges/js.md | 15 +++---- quest/m1/tokio-client-fresh-port.md | 34 ++++++++++++++ quest/m1/vendor-sync/uniffi.md | 3 +- quest/m2/README.md | 8 ++++ quest/m2/announce-credit.md | 7 +++ quest/m2/auth-http-request-kind.md | 34 ++++++++++++++ quest/m2/bench-hygiene.md | 30 +++++++++++++ quest/m2/bench-latency-resolution.md | 29 ++++++++++++ quest/m2/catalog-republish-cost.md | 29 ++++++++++++ quest/m2/ffi-exporter.md | 10 ++++- quest/m2/miri-nightly-budget.md | 12 +++-- .../m2/perf/kio-channel-contention/README.md | 1 + .../kio-channel-contention/log-adoption.md | 5 ++- .../relay-per-thread.md | 45 +++++++++++++++++++ quest/m2/perf/mesh-session-cost.md | 11 +++++ quest/m2/probe/README.md | 1 + quest/m2/probe/stats-ticker.md | 32 +++++++++++++ quest/m2/publish-done-codes.md | 8 +++- quest/m2/quic-emsgsize-classify.md | 30 +++++++++++++ quest/m2/quic-realtime/README.md | 15 +++++++ quest/m2/release/README.md | 1 + quest/m2/release/moq-e2ee-retire.md | 37 +++++++++++++++ quest/m2/rind/README.md | 1 + quest/m2/rind/crypto.md | 33 ++++++++++++++ quest/m2/route-interest-prefixes.md | 36 +++++++++++++++ quest/m2/scuffle-sps-bump.md | 44 ++++++++++++++++++ quest/m2/track-test-eviction-asserts.md | 28 ++++++++++++ 52 files changed, 1007 insertions(+), 57 deletions(-) create mode 100644 quest/m0/ci/no-fail-fast.md create mode 100644 quest/m0/cmaf-receive-bounds.md create mode 100644 quest/m0/nightly/bindings-bench-evicted.md create mode 100644 quest/m0/nightly/miri-frame.md create mode 100644 quest/m0/nightly/receive-windows-evicted.md create mode 100644 quest/m0/nightly/relay-stack.md delete mode 100644 quest/m0/test-flakes-2/tokio-close-drain.md create mode 100644 quest/m0/video-sps-walk.md create mode 100644 quest/m1/js-bigint-audit.md create mode 100644 quest/m1/js-follow-abort-wake.md create mode 100644 quest/m1/js-resume-model-12345.md create mode 100644 quest/m1/msf-ext-proto.md create mode 100644 quest/m1/socket/old-hop-dial.md create mode 100644 quest/m1/subscribe-ranges/js-fills.md create mode 100644 quest/m1/tokio-client-fresh-port.md create mode 100644 quest/m2/auth-http-request-kind.md create mode 100644 quest/m2/bench-hygiene.md create mode 100644 quest/m2/bench-latency-resolution.md create mode 100644 quest/m2/catalog-republish-cost.md create mode 100644 quest/m2/perf/kio-channel-contention/relay-per-thread.md create mode 100644 quest/m2/probe/stats-ticker.md create mode 100644 quest/m2/quic-emsgsize-classify.md create mode 100644 quest/m2/release/moq-e2ee-retire.md create mode 100644 quest/m2/rind/crypto.md create mode 100644 quest/m2/route-interest-prefixes.md create mode 100644 quest/m2/scuffle-sps-bump.md create mode 100644 quest/m2/track-test-eviction-asserts.md diff --git a/quest/m0/README.md b/quest/m0/README.md index 55bddeb5c1f..1128dfdaab1 100644 --- a/quest/m0/README.md +++ b/quest/m0/README.md @@ -29,6 +29,8 @@ since cutting segments from first-frame pts waits on nothing in m1. - [Nightly passes on main](/quest/m0/nightly/README.md) - the scheduled Nightly passes end to end, so red means a new break - [Interop and Video pass on main](/quest/m0/interop-green/README.md) - the scheduled Interop and Video workflows pass, so red means a new break +- [moq-video shares moq-mux's bounded H.265 SPS walk](/quest/m0/video-sps-walk.md) - a hostile publisher's H.265 SPS can't panic a subscriber's decoder +- [Subscriber-side CMAF parsing is bounded](/quest/m0/cmaf-receive-bounds.md) - a received `moof` or init over `MAX_METADATA_BYTES` is refused before mp4-atom parses it, so one frame can't cost a subscriber hundreds of megabytes - [Publish the release line's drain() wrappers](/quest/m0/ffi-shutdown-backport.md) - Python `moq-rs` 0.5.2 and Dart `moq` 0.1.1 reach PyPI and pub.dev from `release` - [Backport audio groupDuration](/quest/m0/backport-audio-group-duration.md) - `@moq/publish` 0.5.4 on `release` can pack several Opus frames per group, making Cloudflare's relay drop audio less often - [Backport the SETUP-path and iroh-key fixes](/quest/m0/backport-security-fixes.md) - `release` refuses a conflicting SETUP Path and keeps persisted iroh keys private, in one patch release diff --git a/quest/m0/ci/README.md b/quest/m0/ci/README.md index be6e8b849aa..76316797511 100644 --- a/quest/m0/ci/README.md +++ b/quest/m0/ci/README.md @@ -169,4 +169,5 @@ The historical samples locate candidates; they are not controlled benchmarks. - [Pullfrog reviews finish inside their time limit](/quest/m0/ci/pullfrog-timeout.md) - A Pullfrog review of a large PR finishes instead of failing on the action's run limit - [Long test runs keep their built binaries](/quest/m0/ci/shared-target.md) - A long `just test interop` or wire-compat run never fails because the binaries it built were removed from the shared Cargo target mid-run, such as by mbx pruning its managed build storage - [One nextest pin](/quest/m0/ci/nextest-pin.md) - cargo-nextest's version lives in one place +- [Local test runs honor NEXTEST_NO_FAIL_FAST](/quest/m0/ci/no-fail-fast.md) - `just check` and `sh/rs/nextest.sh` pass `--no-fail-fast` through, so one host failure doesn't hide the rest - [The flake lane skips hosts that can't map user namespaces](/quest/m0/ci/userns-uid-map.md) - `check flake` skips instead of failing where `/proc/self/uid_map` is unwritable diff --git a/quest/m0/ci/no-fail-fast.md b/quest/m0/ci/no-fail-fast.md new file mode 100644 index 00000000000..681c47f0a64 --- /dev/null +++ b/quest/m0/ci/no-fail-fast.md @@ -0,0 +1,24 @@ +# [XS] Local test runs honor NEXTEST_NO_FAIL_FAST + +## Goal + +`just check` and `sh/rs/nextest.sh` pass `--no-fail-fast` to nextest when +`NEXTEST_NO_FAIL_FAST` is set, so one host-specific failure doesn't hide the +rest of the suite's results. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- ✅ m0, as a child of [CI cost and latency](/quest/m0/ci/README.md) +- m1 +- m2 + +- Trace how `just check` reaches nextest (`sh/rs/nextest.sh` execs + `sh/local.sh`) and pass the flag through there, so every entry point gets + it. +- Check first whether the pinned cargo-nextest already reads the variable + itself; if so, make sure nothing in between overrides it. +- Default behavior stays fail-fast. + +Public API: none. Wire: none. diff --git a/quest/m0/cmaf-receive-bounds.md b/quest/m0/cmaf-receive-bounds.md new file mode 100644 index 00000000000..3ca6bc93f4c --- /dev/null +++ b/quest/m0/cmaf-receive-bounds.md @@ -0,0 +1,45 @@ +# [M] Subscriber-side CMAF parsing is bounded + +## Goal + +A hostile publisher can't make a subscriber allocate hundreds of megabytes +from one frame. Every place a subscriber parses received CMAF with mp4-atom +refuses a `moof` (or init `moov`) larger than `MAX_METADATA_BYTES` before +parsing it, and a peak-memory test like +[moq-dev/moq#7687](https://github.com/moq-dev/moq/pull/7687)'s shows the +bound holding on each path. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- ✅ m0 (security: one hostile frame costs about 320 MB per subscriber) +- m1 +- m2 + +#7687 bounds the importer (publisher side). Received frames, up to 32 MiB +each, still reach mp4-atom unchecked: + +- `fmp4::Wire::decode` and its `decode` helper + (`rs/moq-mux/src/container/fmp4/mod.rs`, around line 556). +- `Wire::from_init` (same file, around line 440). +- MSF's init parse, `cmaf_moov` + (`rs/moq-mux/src/catalog/msf/consumer.rs`, around line 416). +- `rs/moq-mux/src/container/mp4.rs` (the `Moof::decode` around line 162 and + the init's `Moov::decode`). + +Reuse #7687's `MAX_METADATA_BYTES`: read each box header's size and refuse +an oversized `moof`/`moov` before decoding it, so the limit stays one +constant shared with the importer. Measure each path's peak with #7687's +counting allocator (`allocation::Usage::peak`), as its +`fragment_plans_within_the_held_bound` does, failing without the fix. + +Public API: none expected (a new error variant at most). Wire: none. + +## Required + +- [fMP4 sample plans, trun counts, and trak counts are bounded](/quest/m1/fmp4-metadata-limits.md) - lands `MAX_METADATA_BYTES` (moq-dev/moq#7687) + +## Related + +- [One policy for oversized container metadata](/quest/m2/import-metadata-policy.md) - the importer-side rule this mirrors diff --git a/quest/m0/nightly/README.md b/quest/m0/nightly/README.md index 720f0a44712..fb213aadacf 100644 --- a/quest/m0/nightly/README.md +++ b/quest/m0/nightly/README.md @@ -1,4 +1,4 @@ -# [S] Nightly passes on main +# Nightly passes on main ## Goal @@ -32,3 +32,10 @@ This README's own work, after the children: threshold to [bench CI](/quest/m1/bench-ci.md). Public API: none. Wire: none. + +## Required + +- [The receive-windows benchmark runs to the end](/quest/m0/nightly/receive-windows-evicted.md) - `benchmark_receive_windows` stops failing `frame: Evicted`, so the Rust benchmark-tests job publishes its report +- [The relay's startup fits its stack under all features](/quest/m0/nightly/relay-stack.md) - `debug_relay_load_and_run_fit_windows_stack` passes under `--all-features`, fixed at the feature that grew the future +- [The binding benchmark's 64 KiB case measures](/quest/m0/nightly/bindings-bench-evicted.md) - the 64 KiB case completes instead of failing `evicted` +- [Nightly Miri installs rust-src and covers the lock-free frame path](/quest/m0/nightly/miri-frame.md) - the Miri job gets past setup and runs `model::frame::tests` diff --git a/quest/m0/nightly/bindings-bench-evicted.md b/quest/m0/nightly/bindings-bench-evicted.md new file mode 100644 index 00000000000..0208a02c573 --- /dev/null +++ b/quest/m0/nightly/bindings-bench-evicted.md @@ -0,0 +1,27 @@ +# [S] The binding benchmark's 64 KiB case measures + +## Goal + +Nightly's `Binding benchmark runners` job passes: the 64 KiB case of the +moq-ffi throughput benchmark (`rs/moq-ffi/src/bench.rs`, run by each +binding's runner such as `py/moq-rs/benches/ffi.py`) completes and reports +a number instead of failing `evicted` on `main`. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- ✅ m0, as a child of [Nightly passes on main](/quest/m0/nightly/README.md) +- m1 +- m2 + +- Confirm the cause first. The likely one: each case's origin cache is + `CACHE_BYTES` (64 MiB), and a 64 KiB case writes 64-frame groups + (`frames()` caps at 64), so a round can outgrow the cache before a slow + binding reads it. +- Then size the case or its cache so it measures throughput rather than + eviction, and keep the other sizes' numbers comparable with past nights. +- Run every binding's runner locally (`just gh nightly bindings`) before + pushing. + +Public API: none. Wire: none. diff --git a/quest/m0/nightly/miri-frame.md b/quest/m0/nightly/miri-frame.md new file mode 100644 index 00000000000..3b1046f50ef --- /dev/null +++ b/quest/m0/nightly/miri-frame.md @@ -0,0 +1,30 @@ +# [XS] Nightly Miri installs rust-src and covers the lock-free frame path + +## Goal + +Nightly's `Tests (rs miri)` job gets past cargo-miri's setup, and +`model::frame::tests` runs under Miri there, covering the lock-free unsafe +delivery path [moq-dev/moq#7508](https://github.com/moq-dev/moq/pull/7508) +added. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- ✅ m0, as a child of [Nightly passes on main](/quest/m0/nightly/README.md) +- m1 +- m2 + +- The job's first run + ([41483654426](https://github.com/moq-dev/moq/actions/runs/41483654426)) + failed before any test, as cargo-miri found no `rust-src`. Install it + with the toolchain: `components: miri` in `.github/workflows/nightly.yml` + becomes `miri, rust-src`. +- `sh/rs/miri.sh`'s strict pass already selects moq-net's `model::frame::` + (line 85). Confirm #7508's tests are among them and pass under Miri + locally, extend the selection if any are missed, and check the Nightly log + shows them run. +- The rest of the job's time budget stays with + [Miri nightly budget](/quest/m2/miri-nightly-budget.md) in m2. + +Public API: none. Wire: none. diff --git a/quest/m0/nightly/receive-windows-evicted.md b/quest/m0/nightly/receive-windows-evicted.md new file mode 100644 index 00000000000..23a8f17f928 --- /dev/null +++ b/quest/m0/nightly/receive-windows-evicted.md @@ -0,0 +1,34 @@ +# [S] The receive-windows benchmark runs to the end + +## Goal + +`moq-tokio`'s `benchmark_receive_windows` +(`rs/moq-tokio/tests/integration/receive_credit.rs:1056`) passes on `main` +instead of failing with `frame: Evicted`, so Nightly's `Rust benchmark +tests` job (`gh nightly rust-test`) passes and that night's report is +published. Fixed at the cause, never by loosening what the benchmark +measures. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- ✅ m0, as a child of [Nightly passes on main](/quest/m0/nightly/README.md) +- m1 +- m2 + +It failed in 3 of 3 local runs on `main`, and the job's failure skips the +rest of the night's report. Likely since +[moq-dev/moq#7597](https://github.com/moq-dev/moq/pull/7597) changed its +subscription to a track `Delay { min, max }`: confirm by running the +benchmark at #7597's parent and at #7597. + +- Repro: `cargo nextest run -p moq-tokio --release -E + 'test(benchmark_receive_windows)' --run-ignored only`. +- Decide whether the benchmark's subscription now asks for less than it + reads (a zero `delay.max` evicting groups the reader still wants), or + whether eviction changed under it, and fix that side. +- [Receive pool](/quest/m2/receive-pool.md) sweeps this harness later; keep + its cases runnable. + +Public API: none. Wire: none. diff --git a/quest/m0/nightly/relay-stack.md b/quest/m0/nightly/relay-stack.md new file mode 100644 index 00000000000..55345f71a71 --- /dev/null +++ b/quest/m0/nightly/relay-stack.md @@ -0,0 +1,26 @@ +# [S] The relay's startup fits its stack under all features + +## Goal + +`moq-relay`'s `stack::debug_relay_load_and_run_fit_windows_stack` +(`rs/moq-relay/tests/integration/stack.rs`) passes under `--all-features` +on `main` instead of overflowing its 1 MiB thread. Fixed at the cause, by +shrinking the future that grew, never by raising the stack size the test +models. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- ✅ m0, as a child of [Nightly passes on main](/quest/m0/nightly/README.md) +- m1 +- m2 + +- Find which feature grows `Relay::load`/`Relay::run`'s future: run the + test with each feature added to the defaults, then measure the futures' + sizes (`-Zprint-type-sizes`, or `size_of_val` on the futures in a test). +- Box or split the large state that feature adds, the way the default build + already fits. +- Keep the test's 1 MiB stack, which stands for a Windows main thread. + +Public API: none expected. Wire: none. diff --git a/quest/m0/test-flakes-2/README.md b/quest/m0/test-flakes-2/README.md index ab11c124d2c..267ac444b20 100644 --- a/quest/m0/test-flakes-2/README.md +++ b/quest/m0/test-flakes-2/README.md @@ -75,5 +75,4 @@ Public API: none. Wire: none. - [IETF22 fallback](/quest/m0/test-flakes-2/ietf22-fallback.md) - an IETF22 browser viewer follows a fallback within the media lane's bound, keeping its session and its audio - [Browser buffering and Firefox audio-tone tests pass under load](/quest/m0/test-flakes-2/browser-media-flakes.md) - the two `harness.browser.ts` buffering tests and the Firefox player's audio-tone checks pass reliably in Interop and Nightly, each fixed at its cause under the epic's rules -- [moq-tokio's close-drain test survives load](/quest/m0/test-flakes-2/tokio-close-drain.md) - `quic_client_close_drains_finished_track` stops failing land batches with "Unroutable" - [@moq/net's boundary-sync test survives load](/quest/m0/test-flakes-2/js-boundary-sync.md) - "a version without a boundary syncs" passes under load diff --git a/quest/m0/test-flakes-2/tokio-close-drain.md b/quest/m0/test-flakes-2/tokio-close-drain.md deleted file mode 100644 index bafbd08cca4..00000000000 --- a/quest/m0/test-flakes-2/tokio-close-drain.md +++ /dev/null @@ -1,25 +0,0 @@ -# [S] moq-tokio's close-drain test survives load - -## Goal - -`moq-tokio::integration backend::quic_client_close_drains_finished_track` -(`rs/moq-tokio/tests/integration/backend.rs`) passes reliably under a loaded -`just ci`. It's fixed at its cause, never by raising a timeout or adding a -retry. - -## Plan - -Planned 2026-11-01 (maintainer, follow-up planning after the 2026-11-01 /quest-complete run). The test failed with "subscribe failed: Unroutable" and passed on rerun. -On 2026-11-01 it ejected two land batches, at 20:24Z and 20:44Z (see -[moq-dev/moq#7258](https://github.com/moq-dev/moq/pull/7258) and -[moq-dev/moq#7439](https://github.com/moq-dev/moq/pull/7439)), and it failed -once in [moq-dev/moq#7490](https://github.com/moq-dev/moq/pull/7490)'s full -run. - -- It runs on moq-lite (`moq-lite-07-wip`, around line 801). Find the race that - lets the subscribe reach the publisher before its route exists, or after the - route has gone. -- Reproduce it under load first, for example by running it beside a full - `cargo nextest`. - -Follow the rules in [More tests under load](/quest/m0/test-flakes-2/README.md). diff --git a/quest/m0/video-sps-walk.md b/quest/m0/video-sps-walk.md new file mode 100644 index 00000000000..f653dadf626 --- /dev/null +++ b/quest/m0/video-sps-walk.md @@ -0,0 +1,40 @@ +# [S] moq-video shares moq-mux's bounded H.265 SPS walk + +## Goal + +A hostile publisher's H.265 SPS can't panic a subscriber's decoder. +moq-video's VUI reads (`rs/moq-video/src/decode/vui.rs:102` and `:263`) stop +calling `scuffle_h265::SpsNALUnit::parse` directly and go through moq-mux's +bounded walk, `sps::parse_full` from +[moq-dev/moq#7685](https://github.com/moq-dev/moq/pull/7685), which refuses an +SPS that would reach scuffle-h265's overflowing lines. The regression inputs +from #7685 pass through moq-video's decode path too. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- ✅ m0 (security: a remote input crashes a subscriber) +- m1 +- m2 + +From #7685's follow-ups: it bounds moq-mux's import path, but moq-video still +parses the same SPS unchecked, and `:263` unwraps the result. + +- Expose the walk from moq-mux (`codec/h265/sps.rs`) as a small public + function rather than copying it into moq-video, so both crates refuse the + same inputs. +- Replace both call sites; `:263`'s `unwrap()` becomes an error the decoder + reports. +- Feed #7685's minimized inputs through moq-video's VUI read in a test that + panics without the fix. + +Public API: additive in moq-mux (the shared SPS walk). Wire: none. + +## Required + +- [SPS fields cannot overflow](/quest/m1/fuzz-findings/sps-overflow.md) - lands `sps::parse_full` in moq-mux (moq-dev/moq#7685) + +## Related + +- [Drop the H.265 SPS pre-walk](/quest/m2/scuffle-sps-bump.md) - removes this walk once scuffle ships fixed releases diff --git a/quest/m1/README.md b/quest/m1/README.md index 16fa5523e38..e292ebcd720 100644 --- a/quest/m1/README.md +++ b/quest/m1/README.md @@ -141,6 +141,7 @@ per-frame CPU growth since #5926. - [Media fuzz findings](/quest/m1/fuzz-findings/README.md) - the nightly media fuzz targets run clean: mp4-atom, MKV block, TS step, SPS overflow, and catalog encoder bugs they found are fixed - [fMP4 sample plans, trun counts, and trak counts are bounded](/quest/m1/fmp4-metadata-limits.md) - a `moof` or `moov` within the importer's bounds cannot plan hundreds of megabytes or take quadratic time; 116 bytes cost 584 MB today - [Mesh dials recover from a stuck flow](/quest/m1/mesh-fresh-port.md) - a relay redials a failing cluster peer from a fresh UDP port, so one dropped 5-tuple can't strand a link +- [moq-tokio clients redial from a fresh source port](/quest/m1/tokio-client-fresh-port.md) - after N failed dials a client on an ephemeral port rebinds, so one dropped 5-tuple can't strand it - [Cluster routing](/quest/m1/cluster-routing/README.md) - prove shared routing contracts, implement per-origin routes, and connect outbound local clusters - [Routing guide](/quest/m1/routing-guide.md) - concepts and practical outbound federation setup - [moq-c at parity](/quest/m1/c/README.md) - the hand-written `moq-c` ships at the cut with every m1 binding feature moq-ffi gains @@ -154,11 +155,13 @@ per-frame CPU growth since #5926. - [Datagram tracks](/quest/m1/datagram-tracks/README.md) - a track is datagrams or streams; datagram tracks have their own request and sequence, no ranges, no cache, and map to object ID 0 on moq-transport - [A step back smaller than the delay keeps the TS export](/quest/m1/ts-small-step-back.md) - audio restarts instead of regressing; video stays within its declared depth - [moq-boy's status loop stops on an errored track](/quest/m1/moq-boy-status-loop.md) - only schema errors are caught +- [A routed JS read wakes when its track aborts](/quest/m1/js-follow-abort-wake.md) - a pending `readFrame()` on a group found through `request()`/`follow()` rejects on `track.abort()` - [release carries the fanout-threads bench](/quest/m1/release-fanout-bench.md) - a bench-only port of session_fanout_threads for the pre-cut pairing - [Finalize moq-lite-07](/quest/m1/lite07-finalize.md) - when the maintainer cuts it, lite-07 negotiates as `moq-lite-07` and the next release ships it - [Sockets](/quest/m1/socket/README.md) - a generic dial/accept `Socket` in moq-net, Rust, JS, and Python, with tracks as streams; moq-boy and CARLA move onto it - [Moxygen pin bump](/quest/m1/moxygen-pin-bump.md) - waiting on moxygen#264, then the TRACK_STATUS patch is dropped - [A smaller, safer API than release](/quest/m1/api-audit/README.md) - every surface added since release has a consumer or is gone, overlapping operations are collapsed, names mirror across Rust, JS, and the bindings, and every break says how to migrate +- [@moq/net holds every unbounded u62 as bigint](/quest/m1/js-bigint-audit.md) - u62 wire values a peer can push past 2^53 move to `bigint`, with round-trip tests - [moq-crypto replaces moq-sign and moq-e2ee](/quest/m1/moq-crypto.md) - one Rust crate and one JS package hold signing and end-to-end encryption, sharing moq-net's timestamp check - [Register moq-dev draft 20 in the interop runner](/quest/m1/ietf-drop/README.md) - land the external registry, notes, and README correction for drafts 18, 20, and 22 - [A lapsed request token resets with EXPIRED_AUTH_TOKEN](/quest/m1/auth-expiry-reset.md) - group streams of a lapsed grant reset with the expiry code, so a client knows to renew @@ -196,6 +199,8 @@ per-frame CPU growth since #5926. - [Ordered reads can skip owed holes, and snapshot latest() does](/quest/m1/ordered-owed-holes.md) - moq-net's `Ordered` gains a read that skips past an owed hole to the newest buffered group, while keeping the reader's bounds - [A Rust relay never replays from group 0 to a lite-03/04 subscriber](/quest/m1/relay-inflight-replay.md) - A Rust relay or publisher serving a lite-03 or lite-04 SUBSCRIBE from a track copy that is still resolving starts at the newest group once the copy resolves - [The resume model passes its long run again](/quest/m1/resume-model-7542.md) - fix #7542's regression that drops groups a long-budget reader can still get +- [The JS resume model passes seed 12345](/quest/m1/js-resume-model-12345.md) - a reader updated to no ranges keeps reading instead of ending cleanly +- [The MSF catalog keeps a prototype-named extension](/quest/m1/msf-ext-proto.md) - `js/msf`'s `ext` map keeps a `__proto__` key, like Rust - [A resume more than one group behind never hangs](/quest/m1/ietf-resume-behind.md) - a resumed read gets every group or a drop on every wire version - [Stats name the route instance's epoch with a type](/quest/m1/stats-epoch-type.md) - `GroupFrame::epoch` gets a dedicated type and tests stop mislabelling the instance diff --git a/quest/m1/audio-jitter-target/capped-budgets.md b/quest/m1/audio-jitter-target/capped-budgets.md index 67402e58e40..a42edf0ea51 100644 --- a/quest/m1/audio-jitter-target/capped-budgets.md +++ b/quest/m1/audio-jitter-target/capped-budgets.md @@ -1,4 +1,4 @@ -# [XS] Re-measure the browser budgets after the estimator capped one observation's weight +# [S] Re-measure the browser budgets after the estimator capped one observation's weight, and group AAC bursts ## Goal @@ -7,7 +7,9 @@ began capping how much weight one observation takes, the player changes that followed, and the relay history-fill fix, show the AAC `bursty` browser rows discarding about as much audio a minute as the Opus `bursty` rows, and the Opus `near-zero` row holding a 60 ms target with no underrun episodes. `test/audio-quality/budgets.json` -carries every browser row's ceilings re-measured from them. +carries every browser row's ceilings re-measured from them. The AAC +publisher stops sending each seven-frame flush as seven groups newest +first, so AAC `wide` stops running dry. ## Waiting @@ -19,6 +21,19 @@ carries every browser row's ceilings re-measured from them. ## Plan +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs): plan the AAC publisher fix here. On +[moq-dev/moq#7679](https://github.com/moq-dev/moq/pull/7679)'s runs AAC +`wide` ran dry 1 to 4 times a minute at a 323 ms target. The publisher sends +each seven-frame PES flush as seven one-frame groups, delivered newest first, +so the oldest frame waits behind every newer group (the cause predicted +below). Send a flush so its oldest frame goes first, for example as one +group or in ascending order, and re-measure the AAC rows after it. Options +shown: + +- m0 +- ✅ m1, in this quest +- m2 + Decided 2026-10-30 (maintainer): the count restarts at the 2026-10-29 nightly, the first after [moq-dev/moq#7168](https://github.com/moq-dev/moq/pull/7168), because the diff --git a/quest/m1/c/api-gaps.md b/quest/m1/c/api-gaps.md index 772bd9c1a27..840349d9fbe 100644 --- a/quest/m1/c/api-gaps.md +++ b/quest/m1/c/api-gaps.md @@ -7,14 +7,15 @@ rendition's priority and a rate control driven by the reservation. ## Plan -- Add C ABI support for disabling simulcast rungs on pre-encoded media after - [moq-dev/moq#7029](https://github.com/moq-dev/moq/pull/7029) lands its shared - importer support. It is still open as of 2026-11-02: main lacks - `moq_mux::import::Track::set_enabled`, `import::VideoInit.priority`, and the - AV1/VP8/VP9 importer setters. That PR owns those changes and the moq-ffi - `MoqRateControl`, `MoqVideoInit.lower`, and media producer `set_enabled` - interfaces. Do not duplicate or import its unmerged source changes here. -- After it merges, expose media `set_enabled`, lower-rendition ordering, and +- Add C ABI support for disabling simulcast rungs on pre-encoded media on + [moq-dev/moq#7029](https://github.com/moq-dev/moq/pull/7029)'s shared + importer support. It merged as + [61cb70456d](https://github.com/moq-dev/moq/commit/61cb70456dd0d70909bc2a1c18916331e90b51ea), + so this work is unblocked: main has `moq_mux::import::Track::set_enabled`, + `import::VideoInit.priority`, the AV1/VP8/VP9 importer setters, and the + moq-ffi `MoqRateControl`, `MoqVideoInit.lower`, and media producer + `set_enabled` interfaces. +- Expose media `set_enabled`, lower-rendition ordering, and a rate control over the C reservation. Inspect the final shared interfaces first. Decided 2026-10-30 (maintainer, /quest-plan of the 2026-10-30 /quest-complete follow-ups): the C epic's rule (every m1 binding feature diff --git a/quest/m1/cluster-routing/routes.md b/quest/m1/cluster-routing/routes.md index b7192ab4c77..d1b3376f835 100644 --- a/quest/m1/cluster-routing/routes.md +++ b/quest/m1/cluster-routing/routes.md @@ -690,4 +690,4 @@ the cheapest one; fix it with the route-selection rework here. - [Route wakes](/quest/m2/route-wakes.md) - index work follows the settled source-selection model - [Route health](/quest/m2/route-health/README.md) - epoch-only progress observation and local delivery failover - +- [A route stream's interest is a set of prefixes](/quest/m2/route-interest-prefixes.md) - m2: one stream's interest covers several prefixes diff --git a/quest/m1/js-bigint-audit.md b/quest/m1/js-bigint-audit.md new file mode 100644 index 00000000000..be461c9dcdd --- /dev/null +++ b/quest/m1/js-bigint-audit.md @@ -0,0 +1,34 @@ +# [S] @moq/net holds every unbounded u62 as bigint + +## Goal + +Every u62 wire value `@moq/net` reads that a peer can push past 2^53 is held +as `bigint`, as group IDs are since +[moq-dev/moq#7681](https://github.com/moq-dev/moq/pull/7681), so a large value +round-trips exactly or is refused instead of losing precision. Each one +moved has a round-trip test past 2^53. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- ✅ m1 (the maintainer asked for this audit) +- m2 + +- Audit the u62 values still held as `number` in `js/net` (lite and IETF + coding): request IDs, track aliases, object and frame IDs, subgroups, and + timestamps, among others. +- For each, decide whether a peer can send a value past 2^53. Move those to + `bigint`; for the rest, refuse a value past `Number.MAX_SAFE_INTEGER` at + decode and record why `number` is enough. +- Test each moved value with an encode/decode round trip past 2^53, and each + refused one with a decode that fails. +- Rust already holds them as `u64`; keep names and semantics mirrored. + +Public API: a breaking type change in `@moq/net` for each value moved to +`bigint`, noted in the package's MIGRATE. Wire: none. + +## Related + +- [Address groups by timestamp](/quest/m1/time-addressing/js.md) - starts become `bigint` there too diff --git a/quest/m1/js-follow-abort-wake.md b/quest/m1/js-follow-abort-wake.md new file mode 100644 index 00000000000..3c6f5c5c0c8 --- /dev/null +++ b/quest/m1/js-follow-abort-wake.md @@ -0,0 +1,38 @@ +# [S] A routed JS read wakes when its track aborts + +## Goal + +In `@moq/net`, a pending `group.readFrame()` on a group of a broadcast found +through `Origin.Consumer.request()` or `follow()` rejects as soon as the +publisher calls `track.abort(err)`, as it already does through +`broadcast.consume()`. A regression test covers both paths, and Rust is +checked for the same gap. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- ✅ m1 +- m2 + +Found by [moq-dev/moq#7693](https://github.com/moq-dev/moq/pull/7693): the +pending read stays parked until the next read throws the error, while a +pending `nextGroup()` wakes on both paths. + +- Likely in `js/net/src/resume.ts`: a group handed out from a route's copy + isn't aborted when the source copy fails. Abort every handed-out group with + the copy's error. +- Check Rust's resume reader for the same case (a frame read pending on a + handed-out group when the serving track aborts) and fix it there too if it + hangs. +- The test fails without the fix: publish, route a read through + `request()`/`follow()`, park a `readFrame()`, abort the track, and expect + the rejection without another read. + +Public API: none. Wire: none. + +## Related + +- [moq-boy's status loop stops on an errored track](/quest/m1/moq-boy-status-loop.md) - #7693, where this surfaced +- [Resume redesign](/quest/m2/resume-redesign.md) - would replace this code later diff --git a/quest/m1/js-resume-model-12345.md b/quest/m1/js-resume-model-12345.md new file mode 100644 index 00000000000..7bb04421c6a --- /dev/null +++ b/quest/m1/js-resume-model-12345.md @@ -0,0 +1,34 @@ +# [S] The JS resume model passes seed 12345 + +## Goal + +`@moq/net`'s resume model passes +`MOQ_RESUME_SEED=12345 MOQ_RESUME_CASES=400 bun test src/resume.model.test.ts` +(in `js/net`), fixed at the cause: a reader whose range was fully read and +then updated to no ranges keeps reading instead of reporting the track ended +cleanly. The minimal case is a fixed regression test. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- ✅ m1 +- m2 + +Found by [moq-dev/moq#7681](https://github.com/moq-dev/moq/pull/7681), which +reproduced it at its merge base `8121cf68`: "the track ended cleanly though no +route declared an end". A reader whose `[0,1)` range was read, then updated +to `ranges: undefined`, reports done. + +- An update to no ranges means "follow live" again, not "every range is + covered"; find where the reader's completion check reads the emptied range + list as exhausted. +- Sibling of [moq-dev/moq#7705](https://github.com/moq-dev/moq/pull/7705) on + the Rust side; compare the two fixes so the languages agree. + +Public API: none. Wire: none. + +## Related + +- [The resume model passes its long run again](/quest/m1/resume-model-7542.md) - the Rust model's own seed 12345 failure diff --git a/quest/m1/msf-ext-proto.md b/quest/m1/msf-ext-proto.md new file mode 100644 index 00000000000..5d9112cabb6 --- /dev/null +++ b/quest/m1/msf-ext-proto.md @@ -0,0 +1,25 @@ +# [XS] The MSF catalog keeps a prototype-named extension + +## Goal + +`js/msf/src/catalog.ts`'s `ext` map keeps a `__proto__` key as an own +property, as Rust's `moq-msf` `Catalog::ext` does. The shared parity +corpus covers it. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- ✅ m1 +- m2 + +`ext` parses with `z.record` (around line 76), which drops a `__proto__` +key. Use the same parser and test corpus as hang's catalog maps from +[moq-dev/moq#7498](https://github.com/moq-dev/moq/pull/7498). + +Public API: none. Wire: none. + +## Required + +- [Text and data sections keep a prototype-named ID](/quest/m1/cut-audit/catalog-proto-ids.md) - the parser and corpus this reuses (moq-dev/moq#7498) diff --git a/quest/m1/socket/README.md b/quest/m1/socket/README.md index 06829fa33d7..06ca125747b 100644 --- a/quest/m1/socket/README.md +++ b/quest/m1/socket/README.md @@ -83,6 +83,7 @@ announce-watch-request pairing remains in `rs/moq-boy`, `js/moq-boy`, or - [Rust sockets](/quest/m1/socket/rust.md) - `moq_net::socket` with `Listener`, `dial`, and `Socket`, plus the concept page - [JS sockets](/quest/m1/socket/js.md) - the same surface in `@moq/net`, interoperating with Rust +- [A socket dial over an older hop fails instead of waiting](/quest/m1/socket/old-hop-dial.md) - a dial through a pre-lite-07 hop fails `Unsupported` - [Python sockets](/quest/m1/socket/py.md) - moq-ffi and `py/moq-rs` bindings, interoperating with Rust - [moq-boy on sockets](/quest/m1/socket/boy.md) - the emulator accepts viewers through a listener and echoes latency per socket - [CARLA on sockets](/quest/m1/socket/carla.md) - trucks accept drivers through a listener and ack them per socket diff --git a/quest/m1/socket/carla.md b/quest/m1/socket/carla.md index 085acb3b869..8a8a84d97df 100644 --- a/quest/m1/socket/carla.md +++ b/quest/m1/socket/carla.md @@ -29,6 +29,12 @@ See the [epic](/quest/m1/socket/README.md) for the layout and the reply split. because publish and subscribe are granted separately; say so in `demo/carla/README.md`. - Update `demo/carla/README.md` (paths, lease) and `doc/bin/demo.md`. +- Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs): [moq-dev/moq#7678](https://github.com/moq-dev/moq/pull/7678) keys carla's + Python driver lease on a local run counter, because moq-ffi's + `MoqBroadcastConsumer` exposes no instance. If the move to sockets doesn't + make that counter moot, add a `MoqBroadcastConsumer::instance()` accessor + (and its Python wrapper) and key the lease on the real instance. Options + shown: m0; ✅ m1, in this quest; m2. ## Required diff --git a/quest/m1/socket/old-hop-dial.md b/quest/m1/socket/old-hop-dial.md new file mode 100644 index 00000000000..df58d3d1866 --- /dev/null +++ b/quest/m1/socket/old-hop-dial.md @@ -0,0 +1,34 @@ +# [S] A socket dial over an older hop fails instead of waiting + +## Goal + +A socket dial through a hop older than lite-07 fails with `Unsupported` +instead of waiting forever. Today the older hop re-mints the answer's +instance, so the dialer never sees an answer it recognizes. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- ✅ m1, in this epic +- m2 + +From [moq-dev/moq#7677](https://github.com/moq-dev/moq/pull/7677), which +lands Rust sockets and documents the hang (accept already fails +`Unsupported` over an older hop). + +- One option from #7677: the dialer also watches `path/.accept/` and + fails `Unsupported` on an answer whose instance `is_minted()`. Weigh the + cost of a second announce interest per pending dial against alternatives, + and record the choice. +- Python inherits it through moq-ffi. If [JS sockets](/quest/m1/socket/js.md) + has landed, its dial gets the same check. +- Test through a pre-lite-07 hop: the dial fails promptly with + `Unsupported`. + +Public API: none (an existing error). Wire: none. + +## Required + +- [Rust sockets](/quest/m1/socket/rust.md) - the dial this bounds diff --git a/quest/m1/subscribe-ranges/README.md b/quest/m1/subscribe-ranges/README.md index b8bd2fcc77d..0375415bcc8 100644 --- a/quest/m1/subscribe-ranges/README.md +++ b/quest/m1/subscribe-ranges/README.md @@ -98,6 +98,7 @@ every sequence delivered or dropped. - [Lite-07 ranges](/quest/m1/subscribe-ranges/lite.md) - the lite-07 wire, Rust publisher and subscriber, and the draft - [JS ranges](/quest/m1/subscribe-ranges/js.md) - `@moq/net`'s on-demand request surface and `fetchGroup` as a range +- [JS received copies fill what they missed](/quest/m1/subscribe-ranges/js-fills.md) - a JS subscriber session asks upstream for its copy's misses, with Rust's below-start and head-fill rules - [Remove FETCH from lite-07](/quest/m1/subscribe-ranges/lite07-fetch.md) - FETCH removed from lite-07 in Rust, JS, and the draft - [Delete the old start bookkeeping](/quest/m1/subscribe-ranges/start-bookkeeping.md) - what each lite cursor is owed and dropped lives in the model, and `TrackRun` only translates it per version diff --git a/quest/m1/subscribe-ranges/js-fills.md b/quest/m1/subscribe-ranges/js-fills.md new file mode 100644 index 00000000000..0b4e220e447 --- /dev/null +++ b/quest/m1/subscribe-ranges/js-fills.md @@ -0,0 +1,45 @@ +# [M] JS received copies fill what they missed + +## Goal + +A JS subscriber session asks upstream for the groups its received copy +missed, as Rust's lite subscriber `requested_fill` loop does, so a JS reader +behind a JS or Rust publisher, or a JS relay, gets history its copy never +held. It carries Rust's below-start rule and head fill, and `Fill.time` +resolves a time start that no held group resolves. Verified JS-to-JS and +through a JS relay to Rust. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- ✅ m1, in this epic +- m2 + +The maintainer chose to plan these separately from +[moq-dev/moq#7696](https://github.com/moq-dev/moq/pull/7696), which lands +JS's on-demand request surface (`Track.Requests`, `Track.Fill`) and deletes +[JS ranges](/quest/m1/subscribe-ranges/js.md). There, received copies never +fill: no handle can reach one. + +- The session acts as its received copy's `Requests` handler and asks + upstream with lite FETCH, or a ranged lite-07 SUBSCRIBE. +- Below-start rule from [moq-dev/moq#7168](https://github.com/moq-dev/moq/pull/7168) + (decided 2026-10-29, maintainer): give up a run below a start already + resolved under a budget at least as loose as the reader's, and on a pre-06 + wire fill below the start only when the reader names a floor. +- Head fill from [moq-dev/moq#7625](https://github.com/moq-dev/moq/pull/7625): + hand out a cached group missing its first frames only once a fill answers + from frame 0, and give up one whose fill is refused. +- `Fill.time` for a time start no held group resolves, matching Rust's + `Fill::time`. +- Tests: JS publisher to JS subscriber, and a JS relay between a Rust + publisher and a Rust subscriber, each missing groups below and inside the + copy. + +Public API: none expected beyond #7696's surface. Wire: none. + +## Required + +- [JS ranges](/quest/m1/subscribe-ranges/js.md) - the request surface this answers through diff --git a/quest/m1/subscribe-ranges/js.md b/quest/m1/subscribe-ranges/js.md index 1ed038aeeff..67301515e85 100644 --- a/quest/m1/subscribe-ranges/js.md +++ b/quest/m1/subscribe-ranges/js.md @@ -79,16 +79,11 @@ What remains: concurrent requests, and cancellation while awaiting a reply. - **`fetchGroup`.** Becomes a one-range subscription on the request surface above, or is removed. -- **Fills.** Mirror Rust's rule from [#7168](https://github.com/moq-dev/moq/pull/7168) - (decided 2026-10-29, maintainer): give up a run below a start already - resolved under a budget at least as loose as the reader's, and on a pre-06 - wire fill below the start only when the reader names a floor. `js/net` - requests no fills today, so nothing over-fetches yet; this keeps it that way - once it does. With fills, a bounded read also mirrors Rust's head fill - ([moq-dev/moq#7625](https://github.com/moq-dev/moq/pull/7625)): it hands out - a cached group missing its first frames only once a fill answers from frame - 0, and gives one whose fill is refused up as a miss. Until then a JS reader - counts a hole the feed no longer owes as given up, with no fill asked. +- **Fills.** Received copies asking upstream for their misses, with Rust's + below-start rule and head fill, moved to + [JS received copies fill what they missed](/quest/m1/subscribe-ranges/js-fills.md) + (maintainer, 2026-11-03). Until it lands, a JS reader counts a hole the + feed no longer owes as given up, with no fill asked. Ranges stay whole groups ([moq-dev/moq#6465](https://github.com/moq-dev/moq/pull/6465)), so the group model keeps refusing a nonzero lite `frameStart` as a protocol diff --git a/quest/m1/tokio-client-fresh-port.md b/quest/m1/tokio-client-fresh-port.md new file mode 100644 index 00000000000..c2f2630b145 --- /dev/null +++ b/quest/m1/tokio-client-fresh-port.md @@ -0,0 +1,34 @@ +# [S] moq-tokio clients redial from a fresh source port + +## Goal + +A moq-tokio client whose reconnects keep failing rebinds to a fresh ephemeral +UDP port after N consecutive failed dials when its bind port is 0, so a +network fault that drops one 5-tuple can't strand it. Today every reconnect +reuses one socket, so with `--connect-backoff-timeout 0` a dropped flow +retries forever. A proxy test that drops one source port's packets shows the +client reconnecting on another. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- ✅ m1 +- m2 + +[moq-dev/moq#7688](https://github.com/moq-dev/moq/pull/7688) fixes this for +the relay's cluster dials only +([Mesh dials recover from a stuck flow](/quest/m1/mesh-fresh-port.md)). + +- Reuse #7688's rebinding where it fits; choose N and record why. +- An explicit nonzero bind port is never changed. +- Model the test on #7688's proxy test, on controlled time. +- Every binding that takes `connect` settings gets the behavior through + moq-tokio, with nothing new to configure unless the PR finds a reason. + +Public API: none expected. Wire: none. + +## Related + +- [Mesh dials recover from a stuck flow](/quest/m1/mesh-fresh-port.md) - the cluster-dial half diff --git a/quest/m1/vendor-sync/uniffi.md b/quest/m1/vendor-sync/uniffi.md index 7ee8889fd8c..944d138a3df 100644 --- a/quest/m1/vendor-sync/uniffi.md +++ b/quest/m1/vendor-sync/uniffi.md @@ -21,7 +21,8 @@ Recurring child of the [vendor sync](/quest/m1/vendor-sync/README.md), which says how each run works and recurs. Decided 2026-10-30 (maintainer): covered only until [the switch to rust2's exporter](/quest/m2/ffi-exporter.md) lands. After that, rust2 owns the generators, and the next run drops this child. Until then, a fix -landed here goes upstream into rust2's fork too, or rust2's import loses it. +landed here joins the exporter quest's carried-over list, so the exporter's +generators get it too; rust2's fork is maintenance-only since 2026-11-02. A port means a commit on the fork and a pin bump in moq (`flake.nix` and the places its "five places" comments name), with regenerated bindings diffed and diff --git a/quest/m2/README.md b/quest/m2/README.md index 4c04ff593e6..edf2a51203c 100644 --- a/quest/m2/README.md +++ b/quest/m2/README.md @@ -79,6 +79,7 @@ lite-07; bitrate enforcement is not part of this release. - [Receive pool](/quest/m2/receive-pool.md) - one byte budget per worker covers every connection's receive credit and the cache, billing each frame once - [Front parking](/quest/m2/origin-front-parks.md) - an unroutable request waits on a front instead of re-asking on every route-table move - [Route wakes](/quest/m2/route-wakes.md) - a route change wakes only the fronts it can move, so pool churn stops scaling with served paths +- [A route stream's interest is a set of prefixes](/quest/m2/route-interest-prefixes.md) - one Announce Stream covers several subtrees, with floors and certification proved over the set - [Fewer allocations in announce fan-out](/quest/m2/announce-fanout-allocs.md) - a deep path costs no more allocations per subscriber than a shallow one - [moq-room scales to large rooms](/quest/m2/room-bench.md) - a benchmark measures `Room` with large participant counts, and polling narrows only if it shows a slope - [Route health](/quest/m2/route-health/README.md) - epoch-only active/passive track recovery over metadata-only subscriptions @@ -93,6 +94,7 @@ lite-07; bitrate enforcement is not part of this release. - [PulseAudio capture periods](/quest/m2/pulseaudio-capture-period.md) - capture on cpal's PulseAudio host arrives in short periods, not the server's 2 s default fragment, proven on the null sink's monitor - [Bindings size profile](/quest/m2/ffi-size-profile.md) - a benchmark decides whether the moq-ffi builds ship at opt-level "s", which halves the dylib - [Value merge-patch diff](/quest/m2/json-value-diff.md) - benchmarks decide between moq-json's generic serializer diff, a ported `Value` diff, and compression alone +- [Measure what a catalog republish costs per rendition edit](/quest/m2/catalog-republish-cost.md) - bench whole-catalog re-serialization across track counts, then decide deltas or a bound - [Go module proxy](/quest/m2/go-module-proxy.md) - `moq.dev/moq-ffi` ships from a static GOPROXY we host, so its staticlibs stop growing git history by ~61 MiB per release - [Go per-platform lib modules](/quest/m2/go-ffi-platform-modules.md) - a Go build downloads only the host's staticlib, and `go mod vendor` works - [Dart on iOS](/quest/m2/dart-ios.md) - prove the shipped iOS native asset actually loads on a device, which no CI can @@ -213,16 +215,20 @@ lite-07; bitrate enforcement is not part of this release. - [Interop audit](/quest/m2/audit-interop.md) - our interop runner entries match what we ship, and every red interop cell with a moq.dev side is fixed, reported, or noted as down or unsupported - [The HLS server follows each path once](/quest/m2/hls-follow-once.md) - `Following` reports synced absence, so moq-hls resolves with one follow - [moq-bench pins the instances it measures](/quest/m2/bench-epoch-pin.md) - pooled requests pin their announced epoch, so a takeover is not counted as the same broadcast +- [moq-bench reports sub-millisecond latency](/quest/m2/bench-latency-resolution.md) - steady-window latency resolves finer than 1 ms +- [Benchmark series stay meaningful](/quest/m2/bench-hygiene.md) - a warm `burst` variant, stale series pruned, and slow-group `bytes` kept out of series names - [The memory bench finishes at 1 MiB frames](/quest/m2/memory-bench-hang.md) - the allocation mode's park at `size=1048576` is root-caused and fixed - [Audio's Latest start reaches back](/quest/m2/audio-latest-reach-back.md) - moq_audio's start covers min plus warmup like other consumers - [moq-lite tails count drops](/quest/m2/lite-tail-drop-count.md) - SUBSCRIBE_DROP accounting replaces the session-tail grace from lite-05 - [Re-run the SPS fuzzer on h264-reader](/quest/m2/sps-fuzz-h264-reader.md) - the H.264 SPS overflow is rechecked on the new parser +- [Drop the H.265 SPS pre-walk once scuffle is fixed](/quest/m2/scuffle-sps-bump.md) - waiting on ScuffleCloud/scuffle#653 and #654 releases, then bump and drop the walk - [Audio track changes are gapless](/quest/m2/gapless-audio-switch.md) - no silence beyond a frame on audio format or rendition changes, enforced by media QA - [PCM encodes in one pass](/quest/m2/pcm-bulk-encode.md) - the PCM encoder converts a frame in bulk instead of one sample at a time - [We own our WebRTC stack](/quest/m2/webrtc/README.md) - moq-rtc becomes moq-webrtc with moq-ice, the data-channel transport, and a vendored, trimmed str0m/dimpl/is/sctp-proto - [PUBLISH_DONE says why](/quest/m2/publish-done-codes.md) - GOING_AWAY, TOO_FAR_BEHIND, and EXPIRED round-trip as stream codes - [moq repair refuses a live recording](/quest/m2/mp4-repair-lock.md) - the recorder's advisory lock keeps `moq repair mp4` off a file still being written - [The error-queue reader decodes truncated control data](/quest/m2/errqueue-truncation.md) - `MSG_ERRQUEUE` keeps what fit on `MSG_CTRUNC`, like the receive paths +- [The QUIC driver tells an MTU probe from an oversized send](/quest/m2/quic-emsgsize-classify.md) - a non-probe `EMSGSIZE` is logged and counted instead of dropped silently - [moq-quic's internal dev-dependencies are path-only](/quest/m2/quic-dev-dep-path.md) - moq-congestion is a path dev-dependency - [moq-mux's AAC config reports SBR](/quest/m2/aac-sbr-config.md) - moq-audio reads backward-compatible SBR from the config - [fMP4 decode times from the declared reorder depth](/quest/m2/fmp4-declared-clock.md) - `DeclaredClock` replaces the sub-GOP cadence cap, as in TS, FLV, and MKV @@ -258,8 +264,10 @@ lite-07; bitrate enforcement is not part of this release. - [The test inventory follows every branch selection](/quest/m2/test-inventory-followups.md) - `sh/gh/test-inventory.py` judges every check by the dispatcher branch its caller actually selects, including the cargo-fuzz caller check, the recipe-runs-tests check - [tls:// sessions report their negotiated ALPN](/quest/m2/tls-link-alpn.md) - A session accepted on a `tls://` listener reports the negotiated moq ALPN in `Link::alpn`, as raw QUIC, WebTransport, and WebSocket sessions already do, so admission and logs see the protocol on every transport - [PUBLISH token renewal is consistent across pause and forward, and the multi-token cost is profiled](/quest/m2/token-auth-followups.md) - on a moq-transport session, a REQUEST_UPDATE carrying an AUTHORIZATION TOKEN on a PUBLISH gets the same answer whether the PUBLISH is paused or forwarding +- [HTTP auth servers see which request named a token](/quest/m2/auth-http-request-kind.md) - the HTTP auth contract forwards `auth::Request`'s `kind()` and `path()` - [moq-uring's handle lifecycle tests cover the newly spawned queue and a woken close watcher](/quest/m2/uring-lifecycle-tests.md) - two regressions cover the shutdown paths moq-dev/moq#7309 added - [Watch tests wait for the change they expect](/quest/m2/watch-test-waits.md) - `js/watch` tests wait for the signal or state they assert on instead of a fixed number of event-loop yields, so they neither flake under load nor pass before the change happens +- [JS eviction tests prove the eviction happened](/quest/m2/track-test-eviction-asserts.md) - `track.test.ts`'s eviction tests fail with eviction off - [Nightly runs zizmor's online workflow audits](/quest/m2/workflow-audit-followups.md) - nightly runs zizmor's online audits - [moq auth sign mints capped tokens](/quest/m2/auth-sign-caps.md) - CLI flags for the bitrate caps - [QUIC-LB forwarding reads the cluster's peers and reports its counts](/quest/m2/quic-lb-forward-extras.md) - a cluster-API peer map and forward counters diff --git a/quest/m2/announce-credit.md b/quest/m2/announce-credit.md index 7ba0159a040..180afc0e7bb 100644 --- a/quest/m2/announce-credit.md +++ b/quest/m2/announce-credit.md @@ -42,6 +42,13 @@ Decided 2026-11-01 with the maintainer (the follow-up to the the session advertises, and the session never closes for count. moq-transport and older lite versions have no credit and keep today's close at the cap. +- Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs): weigh per-socket stream credit here, + like QUIC's MAX_STREAMS. With + [moq-dev/moq#7677](https://github.com/moq-dev/moq/pull/7677)'s sockets, a peer can keep + as many live socket streams listed as the session's announce cap allows, + with no per-socket bound. Decide whether the route credit covers it or a + socket needs its own, for byte streams and the mesh. Options shown: m0; + m1; ✅ m2, in this quest. - Settle and record here how SYNCED behaves when the initial set exceeds the credit. For example, SYNCED could follow the credited part, and the rest arrives as live updates. diff --git a/quest/m2/auth-http-request-kind.md b/quest/m2/auth-http-request-kind.md new file mode 100644 index 00000000000..ebc27df77e2 --- /dev/null +++ b/quest/m2/auth-http-request-kind.md @@ -0,0 +1,34 @@ +# [M] HTTP auth servers see which request named a token + +## Goal + +An external auth server authorizes per request: the HTTP auth contract +forwards `auth::Request`'s `kind()` and `path()` from +[moq-dev/moq#7211](https://github.com/moq-dev/moq/pull/7211), so the server can +decide a token's grant knowing which request (and path) first named it. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- m1 +- ✅ m2 + +#7211 made `moq_net::auth::RequestKind` public and gave `auth::Request` +`kind()` and `path()`, naming the request that first named the token +(`None` for an AUTH-stream token). moq-auth's HTTP client doesn't send them +yet. + +- Add both to the HTTP auth request body as optional fields, absent for an + AUTH-stream token, so existing servers keep working. +- Document the fields in the HTTP auth contract docs and `moq auth serve`, + and have the reference server read them. +- Test that a server can refuse a token for one request kind and accept it + for another. + +Public API: additive (HTTP auth contract fields). Wire: none. + +## Related + +- [Token auth follow-ups](/quest/m2/token-auth-followups.md) - the rest of #7211's follow-ups diff --git a/quest/m2/bench-hygiene.md b/quest/m2/bench-hygiene.md new file mode 100644 index 00000000000..211d2e0af7c --- /dev/null +++ b/quest/m2/bench-hygiene.md @@ -0,0 +1,30 @@ +# [S] Benchmark series stay meaningful + +## Goal + +Three gaps in the nightly benchmarks are closed: hang's buffered bench has a +`burst` variant with a nonzero warmup, the benchmark report prunes series +that haven't been measured in N days, and the JS slow-group bench's `bytes` +column stays out of series names. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- m1 +- ✅ m2 + +- **Warm burst.** `js/hang/bench/buffered.ts`'s `burst` scenario runs with + zero warmup, so it never reaches the warming path + [moq-dev/moq#7523](https://github.com/moq-dev/moq/pull/7523) kept linear. + Add a variant with a nonzero warmup (and min delay) that would go quadratic + without #7523's fix. +- **Prune stale series.** Series nothing measures any more, such as the + retired `bench-ffi` ones, linger in the report (`sh/gh/bench-report.py`). + Drop series not measured in N days, choosing N and recording why. +- **Slow-group names.** `js/hang/bench/slow-group.ts`'s `bytes` column ends + up in its series names; report it as a value instead, so a change in + bytes doesn't start a new series. + +Public API: none. Wire: none. diff --git a/quest/m2/bench-latency-resolution.md b/quest/m2/bench-latency-resolution.md new file mode 100644 index 00000000000..ed357573fcb --- /dev/null +++ b/quest/m2/bench-latency-resolution.md @@ -0,0 +1,29 @@ +# [S] moq-bench reports sub-millisecond latency + +## Goal + +moq-bench's delivery latency over the steady window resolves finer than +1 ms, so relay changes that move latency by microseconds show up in its +percentiles instead of rounding to the same whole millisecond. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- m1 +- ✅ m2 + +`rs/moq-bench/src/stats.rs` records latency with `as_millis()` into +one-millisecond buckets (`LATENCY_BUCKETS`, 60,001 buckets through 60 s). +The relay-per-thread spike +([moq-dev/moq#7534](https://github.com/moq-dev/moq/pull/7534)) found its +glass-to-glass p50 "within the generator's millisecond resolution" while the +in-process hop measured 75 to 175 us. + +- Record microseconds (or finer) over the steady window with a bounded + histogram (for example log-linear buckets), keeping memory flat. +- Keep the report's existing millisecond fields for the nightly series, and + add finer ones, or migrate the series names deliberately. + +Public API: none. Wire: none. diff --git a/quest/m2/catalog-republish-cost.md b/quest/m2/catalog-republish-cost.md new file mode 100644 index 00000000000..8bbf9a3e013 --- /dev/null +++ b/quest/m2/catalog-republish-cost.md @@ -0,0 +1,29 @@ +# [S] Measure what a catalog republish costs per rendition edit + +## Goal + +A benchmark measures whole-catalog re-serialization per rendition edit +across track counts, and its numbers decide between catalog deltas, a bound +on catalog size, or leaving it as is, recorded in the PR. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- m1 +- ✅ m2 + +Every rendition edit re-serializes and republishes the whole catalog, so +the cost grows with the track count. + +- Bench serialize plus publish per edit at, for example, 1, 16, 256, and + 4,096 tracks, in Rust and JS. +- Then bring the choice back: deltas (see the JSON diff quest), a documented + bound on tracks per catalog, or no change. + +Public API: none for the measurement. Wire: none. + +## Related + +- [Benchmark a Value merge-patch diff for moq-json](/quest/m2/json-value-diff.md) - the delta machinery a catalog diff would reuse diff --git a/quest/m2/ffi-exporter.md b/quest/m2/ffi-exporter.md index f135664d885..3c4270dc857 100644 --- a/quest/m2/ffi-exporter.md +++ b/quest/m2/ffi-exporter.md @@ -81,6 +81,14 @@ which publishes `rust2-uniffi`, `rust2-uniffi-core`, `rust2-uniffi-macros`, and Delete `rs/uniffi-bindgen`, the "five places" comments in `flake.nix`, and the `nix/uniffi-dart-*` lockfile and patch. The `sh/{kt,swift,dart,cpp}` packaging scripts stay: they package moq. +- Zero-default durations (Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), from + [moq-dev/moq#7697](https://github.com/moq-dev/moq/pull/7697)): the + exporter gives generated duration fields a zero default, so a bare C++ + `moq::Subscription{}` or generated C `moq_subscription_default()` means a + max delay of 0, as every hand-written binding's does. Until then those + two leave both bounds unset, and their docs say to start from + `subscription_defaults()` (accepted docs-only on #7697). Options shown: + m0; m1; ✅ m2, in this quest. - Negative durations (2026-10-25, maintainer): the Dart negative-duration patch moq carries goes upstream into the fork's Dart generator, and the Go generator stops panicking on a negative `time.Duration` (the Go wrapper @@ -116,7 +124,7 @@ none. ## Related -- [UniFFI generator forks are current](/quest/m1/vendor-sync/uniffi.md) - keeps the forks this replaces synced with upstream until the switch; its fixes must reach rust2's fork +- [UniFFI generator forks are current](/quest/m1/vendor-sync/uniffi.md) - keeps the forks this replaces synced with upstream until the switch; its fixes join the carried-over list above, since rust2's fork is maintenance-only since 2026-11-02 - [Payload bytes](https://github.com/moq-dev/rust2/blob/main/quest/m1/ffi-bytes.md) - the first patch the fork carries - [Kotlin calls](https://github.com/moq-dev/rust2/blob/main/quest/m1/kt-ffi-calls.md) - a Kotlin generator patch the fork carries - [Foreign poll for hot reads](https://github.com/moq-dev/rust2/blob/main/quest/m1/ffi-poll-protocol.md) - a generated poll protocol the fork carries; dropping a future at cancel is optional here, since no moq quest waits on it diff --git a/quest/m2/miri-nightly-budget.md b/quest/m2/miri-nightly-budget.md index 2a8937c0338..44542697194 100644 --- a/quest/m2/miri-nightly-budget.md +++ b/quest/m2/miri-nightly-budget.md @@ -19,10 +19,10 @@ epoch pass 94 in 307 s. - No Nightly timing exists yet: the first run with the job ([run 41483654426](https://github.com/moq-dev/moq/actions/runs/41483654426), - 2026-11-02) failed in 2 minutes before any test, as cargo-miri found no - `rust-src` ("given Rust source directory ... does not exist"). Install it - with the toolchain (`components: miri` in `.github/workflows/nightly.yml` - becomes `miri, rust-src`), then read the timings from the next run. + 2026-11-02) failed before any test, as cargo-miri found no `rust-src`. + Installing it moved to m0 (maintainer, 2026-11-03) with + [Nightly Miri installs rust-src](/quest/m0/nightly/miri-frame.md); read + the timings from the first run after it. - `a_group_has_no_frame_cap` (`rs/moq-net/src/model/group.rs:5228` as of be39188000) took 307 s alone, writing 10,000 one-byte frames. Under `cfg(miri)` write fewer, still more than any former per-group frame cap, so the test @@ -35,3 +35,7 @@ epoch pass 94 in 307 s. `timeout-minutes: 60` at line 328) rather than raising the timeout. Public API: none. Wire: none. + +## Required + +- [Nightly Miri installs rust-src and covers the lock-free frame path](/quest/m0/nightly/miri-frame.md) - the job reaches its tests, so it has timings to act on diff --git a/quest/m2/perf/kio-channel-contention/README.md b/quest/m2/perf/kio-channel-contention/README.md index 0a004871759..ea6793cde18 100644 --- a/quest/m2/perf/kio-channel-contention/README.md +++ b/quest/m2/perf/kio-channel-contention/README.md @@ -470,4 +470,5 @@ Decided (maintainer, 2026-11-01, cluster spike): ## Required +- [Plan relay-per-thread on a worker mesh that never re-announces](/quest/m2/perf/kio-channel-contention/relay-per-thread.md) - measure no-re-announce, weigh it against per-track replicas, and decide whether log adoption waits on it - [Log adoption](/quest/m2/perf/kio-channel-contention/log-adoption.md) - the rest of moq-net's log-shaped state moves onto the log where it measures as a win diff --git a/quest/m2/perf/kio-channel-contention/log-adoption.md b/quest/m2/perf/kio-channel-contention/log-adoption.md index 81d6ce1f1c7..365dd10817c 100644 --- a/quest/m2/perf/kio-channel-contention/log-adoption.md +++ b/quest/m2/perf/kio-channel-contention/log-adoption.md @@ -24,8 +24,9 @@ stays on its mutex. shared track it keeps is still the most contended channel, with one reader per worker. Nor does the cluster spike (2026-11-01, same epic): a relay per thread took every channel's lock wait to zero, but its win is - conditional on a worker mesh that never re-announces peer routes, which is - not planned yet. If relay-per-thread lands, adoption is likely abandoned; + conditional on a worker mesh that never re-announces peer routes, which + [its plan](/quest/m2/perf/kio-channel-contention/relay-per-thread.md) + weighs, deciding whether adoption waits on it. If relay-per-thread lands, adoption is likely abandoned; until then the shared model stays. - Audit moq-net (and moq-relay's `critical.rs`) for other state that is appended at the back, read by cursor, and evicted from the front, beyond diff --git a/quest/m2/perf/kio-channel-contention/relay-per-thread.md b/quest/m2/perf/kio-channel-contention/relay-per-thread.md new file mode 100644 index 00000000000..bf40f27a0a7 --- /dev/null +++ b/quest/m2/perf/kio-channel-contention/relay-per-thread.md @@ -0,0 +1,45 @@ +# [M] Plan relay-per-thread on a worker mesh that never re-announces + +## Goal + +A recorded plan, with the maintainer's decisions, for running the relay as +one cluster per worker thread linked by a mesh that never re-announces peer +routes to peers. It weighs that design against the replica spike's +per-track replicas, sets how routes from outside the relay reach every +worker, measures announce state and propagation with no-re-announce, and +decides whether [Log adoption](/quest/m2/perf/kio-channel-contention/log-adoption.md) +waits on it. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- m1 +- ✅ m2, in this epic + +From the epic's 2026-11-01 cluster-spike verdict +([moq-dev/moq#7534](https://github.com/moq-dev/moq/pull/7534)): a conditional +win, planned on the condition that the worker mesh never re-announces peer +routes. The epic README holds both spikes' numbers. + +- Measure the no-re-announce mesh: heap and allocations per broadcast and + announce delay at 1 to 16 workers (the cluster spike's `spike_announce` + table), plus the data-plane shapes (chat, fanout, video-heavy). +- Settle how other relays' routes reach every worker without re-announce, + for example through [Routes and announces](/quest/m1/cluster-routing/routes.md)' + per-connection `proxy` preference turned off on worker links. +- Compare against the replica spike + ([moq-dev/moq#7533](https://github.com/moq-dev/moq/pull/7533)): replicate + per track on demand above a fan-out threshold, with one shared announce + table. +- Bring the choice, and whether Log adoption waits on it, back to the + maintainer; the result becomes implementation quests through + `/quest-plan`. + +Public API: none (a plan). Wire: none. + +## Related + +- [Cluster route memory](/quest/m2/perf/cluster-route-memory.md) - shrinks the per-route state a full mesh multiplies +- [Shard by default](/quest/m2/perf/shard-default.md) - the thread-per-core workers this runs on diff --git a/quest/m2/perf/mesh-session-cost.md b/quest/m2/perf/mesh-session-cost.md index 7d505c1e621..207c864368e 100644 --- a/quest/m2/perf/mesh-session-cost.md +++ b/quest/m2/perf/mesh-session-cost.md @@ -24,3 +24,14 @@ instructions per reader per group (1 to 16 readers per track). Part of it is copying the large `group::Consumer` value, inside `Poll>>`, through each layer that returns it; consider boxing parts of `group::Consumer`, and measure it on the same read. + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs): the route layer's floor-only batches belong here too. In +[moq-dev/moq#7676](https://github.com/moq-dev/moq/pull/7676)'s route layer, +any floor change sends a batch on each route stream, even when no announce +changed. +Measure that floor-only batch cost against session count, and batch or +coalesce floor changes if it grows with sessions. Options shown: + +- m0 +- m1 +- ✅ m2, in this quest diff --git a/quest/m2/probe/README.md b/quest/m2/probe/README.md index 6ca5266317a..41feb7d5c7e 100644 --- a/quest/m2/probe/README.md +++ b/quest/m2/probe/README.md @@ -85,6 +85,7 @@ This README's own work, once the children land: - [Native rung disable proof](/quest/m1/simulcast-rung-disable.md) - a shaped uplink through moq-ffi proves the top rendition stops and resumes over real BBR3 probing - [Browser send estimate](/quest/m2/probe/browser-send-estimate.md) - shipping Chrome and Safari publishers adapt to the relay's PROBE estimate, since they have no `getStats()` +- [One page-wide getStats sampling ticker](/quest/m2/probe/stats-ticker.md) - a page's connections share one sampling ticker - [Padding probes](/quest/m2/probe/padding.md) - a browser probes with a lowest-priority padding stream on an ALR schedule - [JS rung disable](/quest/m2/probe/rung-disable-js.md) - `@moq/publish` applies the native rung rule, recovering through padding - [Viewer targets](/quest/m2/probe/viewer-target.md) - a session sends its viewer handles as its PROBE target, probes to the peer's, splits the receive estimate into viewer grants, and advertises `Increase` where a sender exists diff --git a/quest/m2/probe/stats-ticker.md b/quest/m2/probe/stats-ticker.md new file mode 100644 index 00000000000..4b3ecf8dbc2 --- /dev/null +++ b/quest/m2/probe/stats-ticker.md @@ -0,0 +1,32 @@ +# [XS] One page-wide getStats sampling ticker + +## Goal + +A page's `@moq/net` connections sample their send-rate estimate from one +shared ticker instead of one loop each, so many publishing connections on a +page cost one tick's work per interval. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- m1 +- ✅ m2, in this epic + +From [moq-dev/moq#7524](https://github.com/moq-dev/moq/pull/7524), which +sampled `getStats()` only while a reservation reads it: loops ticking in +phase cost about a third of the main-thread time for 4 to 16 publishing +connections. Observed there, not implemented. + +- One module-level ticker that runs only while some connection has a + reservation reading its estimate, and samples each such connection per + tick. +- Measure main-thread time before and after with #7524's harness at 4 and + 16 connections. + +Public API: none. Wire: none. + +## Related + +- [Browser send estimate](/quest/m2/probe/browser-send-estimate.md) - where a browser without `getStats()` gets its estimate diff --git a/quest/m2/publish-done-codes.md b/quest/m2/publish-done-codes.md index 270574e4d1c..c902d3edd05 100644 --- a/quest/m2/publish-done-codes.md +++ b/quest/m2/publish-done-codes.md @@ -2,7 +2,7 @@ ## Goal -A moq-transport PUBLISH_DONE carries GOING_AWAY (0x4), TOO_FAR_BEHIND (0x5), and EXPIRED (0x6) when those are the reason, and a subscriber reads each back as its stream code, in Rust and JS, so the bindings report why instead of an unspecified remote error. +A moq-transport PUBLISH_DONE carries GOING_AWAY (0x4), TOO_FAR_BEHIND (0x5), and EXPIRED (0x6) when those are the reason, and a subscriber reads each back as its stream code, in Rust and JS, so the bindings report why instead of an unspecified remote error. A relay that ends a relayed track because its upstream ended (a malformed track it aborted, say) forwards that reason instead of INTERNAL_ERROR. ## Plan @@ -10,4 +10,10 @@ Follow-up of [moq-dev/moq#7396](https://github.com/moq-dev/moq/pull/7396), which Decided 2026-10-30 (maintainer, follow-up planning after the /quest-afk run). Reuse #7396's path: the publisher picks the PUBLISH_DONE code from the same error-to-code mapping that resets the track's streams, and the subscriber reads it back as the peer's stream code. Cover drafts 18 and 22, both bindings, and JS, each test failing without its fix. +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs): add the relayed case here, from [moq-dev/moq#7135](https://github.com/moq-dev/moq/pull/7135)'s follow-ups. When the relay aborts a malformed upstream track it still ends the downstream subscription with PUBLISH_DONE `INTERNAL_ERROR`, so bindings show `Internal`. Map the upstream end's reason through the same path, after checking whether draft-22's PUBLISH_DONE registry has a code that fits each case. Options shown: + +- m0 +- m1 +- ✅ m2, in this quest + Public API: none. Wire: existing registered codes only. diff --git a/quest/m2/quic-emsgsize-classify.md b/quest/m2/quic-emsgsize-classify.md new file mode 100644 index 00000000000..0755eb38e13 --- /dev/null +++ b/quest/m2/quic-emsgsize-classify.md @@ -0,0 +1,30 @@ +# [S] The QUIC driver tells an MTU probe from an oversized send + +## Goal + +moq-tokio's QUIC driver (`send_failed` in +`rs/moq-tokio/src/quic/driver/runtime/mod.rs`) still drops an `EMSGSIZE` from +an MTU probe quietly, but a real oversized send that fails with `EMSGSIZE` is +logged and counted, so it can't be dropped silently again. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- m1 +- ✅ m2 + +From [moq-dev/moq#7649](https://github.com/moq-dev/moq/pull/7649), which +capped a GSO train at what one UDP send carries after full trains above a +~6.5 KB MTU failed with `EMSGSIZE` and were dropped unlogged: `send_failed` +treats every Unix `EMSGSIZE` as an expected MTU-probe loss. + +- Tell the two apart from the transmit itself (a probe's size against the + path's confirmed MTU, or a probe flag the transmit carries). +- Log a non-probe `EMSGSIZE` (rate-limited, like the driver's other send + errors) and count it where the driver's metrics live. +- Apply the same rule in moq-uring's driver if it has the same blanket case. +- Test both cases with a socket that fails with `EMSGSIZE`. + +Public API: none expected. Wire: none. diff --git a/quest/m2/quic-realtime/README.md b/quest/m2/quic-realtime/README.md index 2f2f2b43078..e4b1bae884c 100644 --- a/quest/m2/quic-realtime/README.md +++ b/quest/m2/quic-realtime/README.md @@ -131,6 +131,21 @@ Remaining work once the candidates finish (this README's own job): turns them on instead, so only `Realtime` sessions pay the ACK bytes. - Wire the winner's moq-shaper run into the nightly so a regression in queuing delay shows up. +- SCReAMv2's frame latency under main's corrected pacer: recover it, through + the draft's media-queue terms (section 4.4) or headroom for keyframe + pacing ([moq-dev/moq#7547](https://github.com/moq-dev/moq/pull/7547)'s + rerun on [moq-dev/moq#7606](https://github.com/moq-dev/moq/pull/7606)). +- Only if BBR3's delay bound wins the bake-off: cut ProbeBW_UP's short + transient queues, and explain why utilization after a drop fell to 80% + on `cellular-step` and `cellular-deep` where BBR3 gets 98% + ([moq-dev/moq#7544](https://github.com/moq-dev/moq/pull/7544)). + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs): both items above join this README's remaining work. Options +shown: + +- m0 +- m1 +- ✅ m2, in this epic The winner's target rate already reaches moq-cli and moq-ffi encoders through `bandwidth_estimate` → `estimated_send_rate` → `set_bitrate`. diff --git a/quest/m2/release/README.md b/quest/m2/release/README.md index 16198e433e0..6ff82c52a7b 100644 --- a/quest/m2/release/README.md +++ b/quest/m2/release/README.md @@ -39,6 +39,7 @@ production stability proven merely because upstream artifacts published. - [Dart publication](/quest/m2/release/dart-publish.md) - the wrapper and native artifacts install from the registry - [Final libmoq stub](/quest/m2/release/libmoq-final-release.md) - publish the migration notice before removing its source - [Retire libmoq](/quest/m2/release/libmoq-retire.md) - cleanup only after that publication +- [Retire the moq-e2ee stub](/quest/m2/release/moq-e2ee-retire.md) - waiting on the stub's release above 0.0.20, then delete `rs/moq-e2ee` - [Retire hand-written C](/quest/m2/release/c-retire.md) - delete the hand-written crate once generated C publishes - [Retire the web-transport JS qmux](/quest/m2/release/qmux-js-retire.md) - once `@moq/qmux` publishes from `js/qmux`, deprecate `@moq/web-socket-stream` and stop the second publisher - [moq.sh deployment](/quest/m2/release/moq-sh-deploy.md) - verify its release-triggered publication diff --git a/quest/m2/release/moq-e2ee-retire.md b/quest/m2/release/moq-e2ee-retire.md new file mode 100644 index 00000000000..17ae79779be --- /dev/null +++ b/quest/m2/release/moq-e2ee-retire.md @@ -0,0 +1,37 @@ +# [XS] Retire the moq-e2ee stub + +## Goal + +`rs/moq-e2ee` is gone and the `moq-e2ee` crate is no longer published. Its +last release, a code-free crate whose README points at moq-crypto, stays on +crates.io for anyone still resolving the old name. + +## Waiting + +- moq-dev/moq: the next cut publishes the `moq-e2ee` stub to crates.io, + above 0.0.20. Check with + `curl -s https://crates.io/api/v1/crates/moq-e2ee | jq -r .crate.max_version`. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- m1 +- ✅ m2, in the release epic beside the libmoq stub + +[moq-dev/moq#7702](https://github.com/moq-dev/moq/pull/7702) turns +`rs/moq-e2ee` into a code-free stub that the cut's `just version` lifts +above 0.0.20, so release-plz publishes it. + +- Once that release is on crates.io, delete `rs/moq-e2ee` and its workspace + member, so release-plz never publishes it again. +- Grep for any remaining `moq-e2ee` that names the crate rather than the + draft or profile (`draft-lcurley-moq-e2ee`, "moq-e2ee epoch"). + +Public API: none. Wire: none. + +## Related + +- [moq-crypto replaces moq-sign and moq-e2ee](/quest/m1/moq-crypto.md) - makes the stub +- [Retire libmoq](/quest/m2/release/libmoq-retire.md) - the same retirement for libmoq diff --git a/quest/m2/rind/README.md b/quest/m2/rind/README.md index cf6435cb00a..5899eeca7f2 100644 --- a/quest/m2/rind/README.md +++ b/quest/m2/rind/README.md @@ -67,4 +67,5 @@ The epic's own work, once every child has merged: - [rind-instant-acme is on crates.io](/quest/m2/rind/instant-acme.md) - waiting on the adapter relay ACME needs - [Transport on rind](/quest/m2/rind/transport.md) - moq-quic, moq-tokio, moq-uring, moq-rtmp, and qmux take rind, and the `aws-lc-rs`/`ring` features go - [moq-rtc on rind](/quest/m2/rind/rtc.md) - str0m and dimpl run DTLS, SRTP, and STUN on rind +- [moq-crypto signs on rind](/quest/m2/rind/crypto.md) - moq-crypto's Ed25519 keygen, sign, and verify move off aws-lc-rs - [Relay ACME on instant-acme](/quest/m2/rind/acme.md) - moq-relay replaces rustls-acme with instant-acme on rind and owns renewal diff --git a/quest/m2/rind/crypto.md b/quest/m2/rind/crypto.md new file mode 100644 index 00000000000..23977e99256 --- /dev/null +++ b/quest/m2/rind/crypto.md @@ -0,0 +1,33 @@ +# [S] moq-crypto signs on rind + +## Goal + +moq-crypto generates, signs, and verifies its Ed25519 keys with rind instead +of aws-lc-rs, so its build compiles no C crypto. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- m1 +- ✅ m2, in this epic + +Model it on [moq-dev/moq#7570](https://github.com/moq-dev/moq/pull/7570), +which moved moq-auth to rind and implements `mesh::Signer` for +`rind::signature::Ed25519KeyPair`. + +- Keygen, sign, and verify move to rind; key, signature, and wire formats + stay byte-identical, checked against keys and signatures made before the + switch. +- Map rind's errors by hand, as #7570 did, so its types stay out of + moq-crypto's API. +- `cargo tree -p moq-crypto -e normal,build` holds no aws-lc or ring. +- Compare `cargo bench -p moq-crypto --bench sign` before and after. + +Public API: none expected, unless a ready-made key type is exposed (as +`mesh::Signer` names rind's). Wire: none. + +## Required + +- [moq-crypto replaces moq-sign and moq-e2ee](/quest/m1/moq-crypto.md) - creates the crate (moq-dev/moq#7702) diff --git a/quest/m2/route-interest-prefixes.md b/quest/m2/route-interest-prefixes.md new file mode 100644 index 00000000000..1b95f259af8 --- /dev/null +++ b/quest/m2/route-interest-prefixes.md @@ -0,0 +1,36 @@ +# [M] A route stream's interest is a set of prefixes + +## Goal + +A route-layer Announce Stream's interest is a set of prefixes instead of +one, so a subscriber that wants several disjoint subtrees opens one stream +rather than one per prefix. ANNOUNCE_FLOOR regions and certification hold +across the set, and the proof's floor and certification sweeps pass over +multi-prefix interests. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- m1 +- ✅ m2 + +Split out of [Routes and announces](/quest/m1/cluster-routing/routes.md) by +[moq-dev/moq#7676](https://github.com/moq-dev/moq/pull/7676), which lands +the route layer's core with a single interest prefix per stream (its +regions are suffixes of that prefix) and leaves this as a separate m2 quest. + +- Define how ANNOUNCE_FLOOR names a region under a set (which prefix it + extends), and what a count of zero means when no prefix meets the sender's + regions. +- Redo the proof's floor and certification sweeps with multi-prefix + interests, including overlapping prefixes and a set that changes. +- Update the lite draft and both implementations together. + +Public API: the route layer's interest type. Wire: an Announce Stream's +interest and ANNOUNCE_FLOOR regions on the next unpublished lite version. + +## Related + +- [Routes and announces](/quest/m1/cluster-routing/routes.md) - the single-prefix route layer this extends diff --git a/quest/m2/scuffle-sps-bump.md b/quest/m2/scuffle-sps-bump.md new file mode 100644 index 00000000000..8a5a38f397d --- /dev/null +++ b/quest/m2/scuffle-sps-bump.md @@ -0,0 +1,44 @@ +# [XS] Drop the H.265 SPS pre-walk once scuffle is fixed + +## Goal + +moq-mux (and moq-video, once it shares the walk) parse H.265 SPS with +fixed scuffle-h265 and scuffle-expgolomb releases and no longer pre-walk the +SPS to refuse inputs that overflowed the old ones. The committed regression +inputs still pass. + +## Waiting + +- ScuffleCloud/scuffle: fixed releases for + [ScuffleCloud/scuffle#653](https://github.com/ScuffleCloud/scuffle/issues/653) + (scuffle-h265) and + [ScuffleCloud/scuffle#654](https://github.com/ScuffleCloud/scuffle/issues/654) + (scuffle-expgolomb) on crates.io. Check the issues + and `curl -s https://crates.io/api/v1/crates/scuffle-h265` (and + `scuffle-expgolomb`) for a version newer than 0.2.2 and 0.1.5. Posting + on those repos still needs the maintainer's approval. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- m1 +- ✅ m2 + +[moq-dev/moq#7685](https://github.com/moq-dev/moq/pull/7685) added the walk +(`sps::parse_full`) because scuffle-h265 0.2.2 and scuffle-expgolomb 0.1.5 +overflow on hostile SPS fields. + +- Bump both crates, run the `fmp4`, `annexb`, and `ts` fuzz regressions and + moq-video's SPS regression test against the bare parser, and delete the + walk only if they pass without it. +- Keep every regression input. + +Public API: removes the shared walk if moq-video no longer needs it. +Wire: none. + +## Related + +- [SPS fields cannot overflow](/quest/m1/fuzz-findings/sps-overflow.md) - added the walk +- [moq-video shares moq-mux's bounded H.265 SPS walk](/quest/m0/video-sps-walk.md) - the second user of the walk diff --git a/quest/m2/track-test-eviction-asserts.md b/quest/m2/track-test-eviction-asserts.md new file mode 100644 index 00000000000..10061103684 --- /dev/null +++ b/quest/m2/track-test-eviction-asserts.md @@ -0,0 +1,28 @@ +# [XS] JS eviction tests prove the eviction happened + +## Goal + +Every `js/net/src/track.test.ts` test that checks behavior surviving a cache +eviction first asserts the eviction happened, so each one fails with +eviction turned off instead of passing. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- m1 +- ✅ m2 + +Today they pass with eviction off, so they don't guard what they name. +Candidates include "an evicted successor with unread frames still starts the +wall clock" (around line 1902), "a failed successor hands the wall clock on +after the cache evicts it" (around 1944), and "retention eviction surfaces as +a gap for a handed-out group" (around 2040); check the rest of the file the +same way. + +- Assert the evicted group is gone from the cache (or the eviction counter + moved) before the assertion the test is named for. +- Confirm each fails with eviction disabled, then passes as written. + +Public API: none. Wire: none. From a1888e43f52253d12770546452f46bff4901859f Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 3 Nov 2026 11:37:08 -0800 Subject: [PATCH 02/13] quest: add SUBSCRIBE_STARTED, the widening bench, and revoked announce resets Record the maintainer's SUBSCRIBE_STARTED decision in Lite-07 ranges, and plan two more 2026-11-03 follow-ups: the stale track_range_widening bench assertion (Nightly) and resetting an announce revoked after its OK (m2). Co-Authored-By: Claude Opus 5.5 --- quest/m0/nightly/README.md | 1 + quest/m0/nightly/track-range-widening.md | 33 ++++++++++++++++++++++ quest/m1/subscribe-ranges/lite.md | 10 +++++++ quest/m2/README.md | 1 + quest/m2/announce-revoke-reset.md | 35 ++++++++++++++++++++++++ 5 files changed, 80 insertions(+) create mode 100644 quest/m0/nightly/track-range-widening.md create mode 100644 quest/m2/announce-revoke-reset.md diff --git a/quest/m0/nightly/README.md b/quest/m0/nightly/README.md index fb213aadacf..727a56ed449 100644 --- a/quest/m0/nightly/README.md +++ b/quest/m0/nightly/README.md @@ -38,4 +38,5 @@ Public API: none. Wire: none. - [The receive-windows benchmark runs to the end](/quest/m0/nightly/receive-windows-evicted.md) - `benchmark_receive_windows` stops failing `frame: Evicted`, so the Rust benchmark-tests job publishes its report - [The relay's startup fits its stack under all features](/quest/m0/nightly/relay-stack.md) - `debug_relay_load_and_run_fit_windows_stack` passes under `--all-features`, fixed at the feature that grew the future - [The binding benchmark's 64 KiB case measures](/quest/m0/nightly/bindings-bench-evicted.md) - the 64 KiB case completes instead of failing `evicted` +- [The range-widening bench expects a narrowed read to end](/quest/m0/nightly/track-range-widening.md) - `track_range_widening/1r/64` stops asserting a pending read that #7545 made end - [Nightly Miri installs rust-src and covers the lock-free frame path](/quest/m0/nightly/miri-frame.md) - the Miri job gets past setup and runs `model::frame::tests` diff --git a/quest/m0/nightly/track-range-widening.md b/quest/m0/nightly/track-range-widening.md new file mode 100644 index 00000000000..40964f13173 --- /dev/null +++ b/quest/m0/nightly/track-range-widening.md @@ -0,0 +1,33 @@ +# [S] The range-widening bench expects a narrowed read to end + +## Goal + +`rs/moq-net/benches/track.rs`'s `track_range_widening/1r/64` passes on +`main`, under `cargo test -p moq-net --all-targets` and Nightly's `cargo +bench -p moq-net --bench '*'`, with an assertion that matches bounded reads +as [moq-dev/moq#7545](https://github.com/moq-dev/moq/pull/7545) defined them. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- ✅ m0, as a child of [Nightly passes on main](/quest/m0/nightly/README.md) +- m1 +- m2 + +Found by [moq-dev/moq#7536](https://github.com/moq-dev/moq/pull/7536), which +bisected it to #7545 ("end bounded reads", +[64cba13](https://github.com/moq-dev/moq/commit/64cba1337136c67ce77aaf6ae337f355c97a895e)). +After widening, the bench narrows its reader back to the already-delivered +`0..1` and asserts the next `poll_recv_group` is pending +(`bench_range_widening`, around line 1730). Since #7545 the bounded read +ends instead, returning `Ready(Ok(None))`. CI's `cargo test` skips bench +targets, so it went unnoticed. + +- Either assert the end, or narrow to a range that isn't finished yet so the + read stays pending. Pick the one that keeps the bench measuring the widening + it names, and say why in the PR. +- Confirm with `cargo test -p moq-net --all-targets` and a short `cargo + bench -p moq-net --bench track -- track_range_widening`. + +Public API: none. Wire: none. diff --git a/quest/m1/subscribe-ranges/lite.md b/quest/m1/subscribe-ranges/lite.md index fcce6cb6211..bbf26804f74 100644 --- a/quest/m1/subscribe-ranges/lite.md +++ b/quest/m1/subscribe-ranges/lite.md @@ -124,6 +124,16 @@ Open questions the attempt raised, each with the attempt's recommendation: message can report a start. SUBSCRIBE_UPDATE keeps restating the whole list either way: each range is a few bytes, and restating stays stateless. If IDs are adopted, #7207 is the reference encoding. + Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 + /quest-afk and /quest-complete runs), for the implicit Range IDs that are + this quest's next step after + [moq-dev/moq#7675](https://github.com/moq-dev/moq/pull/7675): a range a + SUBSCRIBE_UPDATE adds learns where it started through a new + **SUBSCRIBE_STARTED** message (type 0x3) carrying Range ID and Range Start, + which the publisher sends when the added range's start resolves. Options: + ✅ a new SUBSCRIBE_STARTED; repeat SUBSCRIBE_OK. (Recorded in this item + because #7675, which rewrites this text and moves the question to a + `## Waiting` item, had not merged.) - `auth::lite_07_narrowing_resets_a_fetch_in_flight` read `Stream(Cancel)` instead of `Unauthorized`/`Unroutable` when the grant narrowed mid-group; the refusal must carry the grant's error. diff --git a/quest/m2/README.md b/quest/m2/README.md index edf2a51203c..78b01e7f4b2 100644 --- a/quest/m2/README.md +++ b/quest/m2/README.md @@ -226,6 +226,7 @@ lite-07; bitrate enforcement is not part of this release. - [PCM encodes in one pass](/quest/m2/pcm-bulk-encode.md) - the PCM encoder converts a frame in bulk instead of one sample at a time - [We own our WebRTC stack](/quest/m2/webrtc/README.md) - moq-rtc becomes moq-webrtc with moq-ice, the data-channel transport, and a vendored, trimmed str0m/dimpl/is/sctp-proto - [PUBLISH_DONE says why](/quest/m2/publish-done-codes.md) - GOING_AWAY, TOO_FAR_BEHIND, and EXPIRED round-trip as stream codes +- [A revoked announce resets instead of FINning](/quest/m2/announce-revoke-reset.md) - a PUBLISH_NAMESPACE revoked after its OK resets with INTERNAL_ERROR, per draft-22 §6.4.2.3 - [moq repair refuses a live recording](/quest/m2/mp4-repair-lock.md) - the recorder's advisory lock keeps `moq repair mp4` off a file still being written - [The error-queue reader decodes truncated control data](/quest/m2/errqueue-truncation.md) - `MSG_ERRQUEUE` keeps what fit on `MSG_CTRUNC`, like the receive paths - [The QUIC driver tells an MTU probe from an oversized send](/quest/m2/quic-emsgsize-classify.md) - a non-probe `EMSGSIZE` is logged and counted instead of dropped silently diff --git a/quest/m2/announce-revoke-reset.md b/quest/m2/announce-revoke-reset.md new file mode 100644 index 00000000000..dd0f19a4d88 --- /dev/null +++ b/quest/m2/announce-revoke-reset.md @@ -0,0 +1,35 @@ +# [S] A revoked announce resets instead of FINning + +## Goal + +A moq-transport PUBLISH_NAMESPACE we accepted whose token is revoked after +its OK is withdrawn by resetting the request, RESET_STREAM and STOP_SENDING +with INTERNAL_ERROR, as draft-22 §6.4.2.3 withdraws a request, instead of +ending with a FIN. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- m1 +- ✅ m2 + +From [moq-dev/moq#7703](https://github.com/moq-dev/moq/pull/7703)'s +follow-ups. That PR resets a lapsed announce with EXPIRED_AUTH_TOKEN (0x7) +but leaves a revoked or narrowed one ending with a FIN, as before. + +- Use INTERNAL_ERROR, since the stream registry has no "unauthorized" code. +- This changes behavior for revocations: a peer that read the FIN as the end + now sees a reset, and the reset takes an unflushed OK with it, as #7703's + expiry reset does. Note it in moq-net's MIGRATE. +- Reuse #7703's `Reader::stop` and `Writer::reset`. +- Rewrite #7703's FIN-and-wait revoke test + (`a_revoked_token_retracts_an_announce_whose_ok_is_blocked`) to expect the + reset, on mocked time for drafts 18, 20, and 22. + +Public API: none. Wire: existing codes only; a revoked announce now resets. + +## Required + +- [A lapsed request token resets its groups with EXPIRED_AUTH_TOKEN](/quest/m1/auth-expiry-reset.md) - adds the announce reset path this reuses (moq-dev/moq#7703) From 2bcd5fe07cb535e23febf189cbaef5fe44a93a71 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 3 Nov 2026 11:45:00 -0800 Subject: [PATCH 03/13] quest: drop the announce reset's Required link to the finished expiry quest #7703 merged and deleted quest/m1/auth-expiry-reset.md, so the revoked-announce quest is unblocked; #7703 stays cited as its source. Co-Authored-By: Claude Opus 5.5 --- quest/m2/announce-revoke-reset.md | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/quest/m2/announce-revoke-reset.md b/quest/m2/announce-revoke-reset.md index dd0f19a4d88..afe79144f54 100644 --- a/quest/m2/announce-revoke-reset.md +++ b/quest/m2/announce-revoke-reset.md @@ -16,7 +16,7 @@ Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-a - ✅ m2 From [moq-dev/moq#7703](https://github.com/moq-dev/moq/pull/7703)'s -follow-ups. That PR resets a lapsed announce with EXPIRED_AUTH_TOKEN (0x7) +follow-ups. That PR (merged) resets a lapsed announce with EXPIRED_AUTH_TOKEN (0x7) but leaves a revoked or narrowed one ending with a FIN, as before. - Use INTERNAL_ERROR, since the stream registry has no "unauthorized" code. @@ -29,7 +29,3 @@ but leaves a revoked or narrowed one ending with a FIN, as before. reset, on mocked time for drafts 18, 20, and 22. Public API: none. Wire: existing codes only; a revoked announce now resets. - -## Required - -- [A lapsed request token resets its groups with EXPIRED_AUTH_TOKEN](/quest/m1/auth-expiry-reset.md) - adds the announce reset path this reuses (moq-dev/moq#7703) From 4e8cc3e1c285df0fe51d5c3769f77a95e7ce6a56 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 3 Nov 2026 12:03:31 -0800 Subject: [PATCH 04/13] quest: plan a host lock so benchmark sessions can't overlap Maintainer, 2026-11-03: m0 (options m2, m0, drop). The quest's PR decides whether the lock lives in moq's bench recipes or in quest gate. Co-Authored-By: Claude Opus 5.5 --- quest/m0/README.md | 1 + quest/m0/bench-host-lock.md | 55 +++++++++++++++++++++++++++++++++++++ 2 files changed, 56 insertions(+) create mode 100644 quest/m0/bench-host-lock.md diff --git a/quest/m0/README.md b/quest/m0/README.md index 1128dfdaab1..79f286b630c 100644 --- a/quest/m0/README.md +++ b/quest/m0/README.md @@ -37,6 +37,7 @@ since cutting segments from first-frame pts waits on nothing in m1. - [Backport the joined-head FETCH race fix](/quest/m0/backport-fill-head-race.md) - a `release` relay stops FETCHing a group head its own SUBSCRIBE is bringing, which left live readers hanging - [CI cost and latency](/quest/m0/ci/README.md) - cloud CI runs only in a batched merge gate as one `just ci` pass per batch, expensive checks run nightly and gate `release`, caches move to R2, and runners are chosen last - [More tests under load](/quest/m0/test-flakes-2/README.md) - load-only and queue failures, one quest per flake, fixed at the cause, since each one fails a whole batch +- [Benchmark sessions can't overlap on a host](/quest/m0/bench-host-lock.md) - a host-level lock keeps a second benchmark or profile session from measuring under the first's load - [Backport the relay and auth hardening to release](/quest/m0/backport-release-hardening.md) - `release`'s relay refuses dot-segment paths, serves its HTTP routes with main's response hardening, and withdraws advertisements a peer starves of send credit; its auth client refuses redirects - [Release's MKV importer bounds what it buffers](/quest/m0/backport-mkv-buffer.md) - on `release`, an MKV input that declares a huge element and trickles its bytes no longer grows the importer's memory without limit - [HLS export on a declared grid](/quest/m0/hls-media-grid.md) - the catalog's `hls` field and record tracks go away, and the export numbers segments on `media.join.interval` from media tracks diff --git a/quest/m0/bench-host-lock.md b/quest/m0/bench-host-lock.md new file mode 100644 index 00000000000..e3e98899723 --- /dev/null +++ b/quest/m0/bench-host-lock.md @@ -0,0 +1,55 @@ +# [S] Benchmark sessions can't overlap on a host + +## Goal + +Two benchmark or profile sessions never run at once on one host. A +host-level lock, taken by `quest gate` or by moq's bench recipes (for example +`just bench-profile`, the relay CPU bisect driver, and `bench/run.sh`), makes +a second session wait, or refuse with a message naming the holder, instead of +measuring under the first one's load. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 +/quest-afk and /quest-complete runs), milestone: + +- m2 +- ✅ m0 +- drop + +Evidence: on 2026-11-03 `nixos2` had three rind agents and +[moq-dev/moq#7605](https://github.com/moq-dev/moq/pull/7605)'s relay-CPU +bisect running while [moq-dev/moq#7742](https://github.com/moq-dev/moq/pull/7742)'s +lock profile ran, which voided two of its three runs. Instruction counts are +load-sensitive too, so overlapping sessions skew even the metrics that avoid +wall-clock time. + +Decide in this quest's PR whether the lock lives in moq or needs a +moq-dev/quest change, and record the choice and why here: + +- **In moq.** The bench recipes take one host-wide lock, for example + `flock` on a fixed path outside the checkout, so every worktree and agent + shares it. That serializes benchmark sessions with each other, but builds + and tests that other agents run through `quest gate` still start, since + the gate only waits on load average and free memory. +- **In quest.** `quest gate` gains an exclusive admission that a bench + takes, holding back other gated commands while it runs. Today the gate + has no exclusive mode and no configuration (`quest gate --help`). That + change goes into moq-dev/quest first, then moq adopts it with a pin bump, + and this quest waits on the release. + +Either way: + +- Cover every entry point that measures: `bench/run.sh` (and the `just bench*` + recipes that call it), `just bench-profile`, and the relay CPU bisect + driver once #7605 lands it. +- The holder is visible (command, PID, start time), and a stale lock from a + dead process is released. +- Nightly's hosted runners run one job per machine, so they need no change. + +Public API: none. Wire: none. + +## Related + +- [Find and fix the relay's per-frame CPU growth since #5926](/quest/m1/release-perf/relay-cpu-bisect.md) - the bisect that overlapped +- [Log lock profile](/quest/m1/unbounded-groups/log-lock-profile.md) - the profile whose runs were voided From 7ef398466243431b3e6e0b133874cbf0b8481d77 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 3 Nov 2026 12:15:36 -0800 Subject: [PATCH 05/13] quest: drop the bench lock's link to the log lock profile moq-dev/moq#7742 deletes quest/m1/unbounded-groups/log-lock-profile.md, so the link would dangle once it lands; #7742 stays cited as the evidence. Co-Authored-By: Claude Opus 5.5 --- quest/m0/bench-host-lock.md | 1 - 1 file changed, 1 deletion(-) diff --git a/quest/m0/bench-host-lock.md b/quest/m0/bench-host-lock.md index e3e98899723..97ef54343cb 100644 --- a/quest/m0/bench-host-lock.md +++ b/quest/m0/bench-host-lock.md @@ -52,4 +52,3 @@ Public API: none. Wire: none. ## Related - [Find and fix the relay's per-frame CPU growth since #5926](/quest/m1/release-perf/relay-cpu-bisect.md) - the bisect that overlapped -- [Log lock profile](/quest/m1/unbounded-groups/log-lock-profile.md) - the profile whose runs were voided From 0740289cceb8e462b76af2fc71bcd418905e10b7 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 3 Nov 2026 12:30:59 -0800 Subject: [PATCH 06/13] quest: plan JSON snapshot resync and prototype-safe rendition names From moq-dev/moq#7693's iterate: a JSON snapshot consumer resyncs at the next group after a bad frame (m2), and the abort-wake quest gains its moq-boy repro. From moq-dev/moq#7498's iterate: the MSF ext quest widens to js/publish's rendition maps as one prototype-safe names quest (m1). Co-Authored-By: Claude Opus 5.5 --- quest/m1/README.md | 2 +- quest/m1/js-follow-abort-wake.md | 9 ++++--- quest/m1/msf-ext-proto.md | 25 ------------------ quest/m1/proto-safe-names.md | 45 ++++++++++++++++++++++++++++++++ quest/m2/README.md | 1 + quest/m2/json-snapshot-resync.md | 40 ++++++++++++++++++++++++++++ 6 files changed, 93 insertions(+), 29 deletions(-) delete mode 100644 quest/m1/msf-ext-proto.md create mode 100644 quest/m1/proto-safe-names.md create mode 100644 quest/m2/json-snapshot-resync.md diff --git a/quest/m1/README.md b/quest/m1/README.md index 68cd241c85f..889b2b00148 100644 --- a/quest/m1/README.md +++ b/quest/m1/README.md @@ -197,7 +197,7 @@ per-frame CPU growth since #5926. - [A Rust relay never replays from group 0 to a lite-03/04 subscriber](/quest/m1/relay-inflight-replay.md) - A Rust relay or publisher serving a lite-03 or lite-04 SUBSCRIBE from a track copy that is still resolving starts at the newest group once the copy resolves - [The resume model passes its long run again](/quest/m1/resume-model-7542.md) - fix #7542's regression that drops groups a long-budget reader can still get - [The JS resume model passes seed 12345](/quest/m1/js-resume-model-12345.md) - a reader updated to no ranges keeps reading instead of ending cleanly -- [The MSF catalog keeps a prototype-named extension](/quest/m1/msf-ext-proto.md) - `js/msf`'s `ext` map keeps a `__proto__` key, like Rust +- [Prototype-safe rendition names in JS](/quest/m1/proto-safe-names.md) - `js/msf`'s `ext` and `js/publish`'s rendition maps keep `__proto__` and `constructor` names, like Rust - [A resume more than one group behind never hangs](/quest/m1/ietf-resume-behind.md) - a resumed read gets every group or a drop on every wire version - [Stats name the route instance's epoch with a type](/quest/m1/stats-epoch-type.md) - `GroupFrame::epoch` gets a dedicated type and tests stop mislabelling the instance diff --git a/quest/m1/js-follow-abort-wake.md b/quest/m1/js-follow-abort-wake.md index 3c6f5c5c0c8..878fd7a69ab 100644 --- a/quest/m1/js-follow-abort-wake.md +++ b/quest/m1/js-follow-abort-wake.md @@ -4,9 +4,9 @@ In `@moq/net`, a pending `group.readFrame()` on a group of a broadcast found through `Origin.Consumer.request()` or `follow()` rejects as soon as the -publisher calls `track.abort(err)`, as it already does through -`broadcast.consume()`. A regression test covers both paths, and Rust is -checked for the same gap. +publisher calls `track.abort(err)`, with the track's error, as it already +does through `broadcast.consume()`, instead of staying parked until cleanup. +A regression test covers both paths, and Rust is checked for the same gap. ## Plan @@ -26,6 +26,9 @@ pending `nextGroup()` wakes on both paths. - Check Rust's resume reader for the same case (a frame read pending on a handed-out group when the serving track aborts) and fix it there too if it hangs. +- A repro: moq-boy's status loop reading through the origin, where the + abort leaves its read parked until cleanup (the maintainer approved this + quest again from #7693's iterate, 2026-11-03). - The test fails without the fix: publish, route a read through `request()`/`follow()`, park a `readFrame()`, abort the track, and expect the rejection without another read. diff --git a/quest/m1/msf-ext-proto.md b/quest/m1/msf-ext-proto.md deleted file mode 100644 index 5d9112cabb6..00000000000 --- a/quest/m1/msf-ext-proto.md +++ /dev/null @@ -1,25 +0,0 @@ -# [XS] The MSF catalog keeps a prototype-named extension - -## Goal - -`js/msf/src/catalog.ts`'s `ext` map keeps a `__proto__` key as an own -property, as Rust's `moq-msf` `Catalog::ext` does. The shared parity -corpus covers it. - -## Plan - -Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: - -- m0 -- ✅ m1 -- m2 - -`ext` parses with `z.record` (around line 76), which drops a `__proto__` -key. Use the same parser and test corpus as hang's catalog maps from -[moq-dev/moq#7498](https://github.com/moq-dev/moq/pull/7498). - -Public API: none. Wire: none. - -## Required - -- [Text and data sections keep a prototype-named ID](/quest/m1/cut-audit/catalog-proto-ids.md) - the parser and corpus this reuses (moq-dev/moq#7498) diff --git a/quest/m1/proto-safe-names.md b/quest/m1/proto-safe-names.md new file mode 100644 index 00000000000..822a71feaeb --- /dev/null +++ b/quest/m1/proto-safe-names.md @@ -0,0 +1,45 @@ +# [S] Prototype-safe rendition names in JS + +## Goal + +JS keeps names that collide with `Object.prototype` (`__proto__`, +`constructor`, `toString`) wherever it keys renditions or catalog members +by name, the way Rust does: + +- `js/msf/src/catalog.ts`'s `ext` map keeps a `__proto__` key as an own + property, like `moq-msf`'s `Catalog::ext`. +- `js/publish` registers a rendition named `__proto__` or `constructor` + instead of refusing it as "rendition already registered", and its catalog + and stats builders publish it. + +The shared parity corpus covers each. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- ✅ m1 +- m2 + +Both gaps are the same bug as hang's catalog maps, fixed by +[moq-dev/moq#7498](https://github.com/moq-dev/moq/pull/7498): a plain object +keyed by an untrusted name. Planned as one quest (maintainer, from #7498's +iterate, 2026-11-03). + +- **MSF `ext`.** It parses with `z.record` (around line 76), which drops a + `__proto__` key. Use the same parser and test corpus as hang's maps from + #7498. +- **js/publish.** `#renditions` and `#records` in + `js/publish/src/broadcast.ts` (around lines 147 and 163) are plain + objects, so `this.#renditions.peek()[name]` finds `Object.prototype`'s + member and throws "already registered". Key them with a `Map` (or + null-prototype objects) and carry that through the catalog and stats + builders that read them, so the published catalog keeps the name. +- Test `__proto__`, `constructor`, and `toString` in each place. + +Public API: none. Wire: none. + +## Required + +- [Text and data sections keep a prototype-named ID](/quest/m1/cut-audit/catalog-proto-ids.md) - the parser and corpus this reuses (moq-dev/moq#7498) diff --git a/quest/m2/README.md b/quest/m2/README.md index 78b01e7f4b2..1e1367ec333 100644 --- a/quest/m2/README.md +++ b/quest/m2/README.md @@ -95,6 +95,7 @@ lite-07; bitrate enforcement is not part of this release. - [Bindings size profile](/quest/m2/ffi-size-profile.md) - a benchmark decides whether the moq-ffi builds ship at opt-level "s", which halves the dylib - [Value merge-patch diff](/quest/m2/json-value-diff.md) - benchmarks decide between moq-json's generic serializer diff, a ported `Value` diff, and compression alone - [Measure what a catalog republish costs per rendition edit](/quest/m2/catalog-republish-cost.md) - bench whole-catalog re-serialization across track counts, then decide deltas or a bound +- [A JSON snapshot consumer resyncs after a bad frame](/quest/m2/json-snapshot-resync.md) - a decode failure drops the group with a typed error, so `@moq/room` and moq-boy resume at the next snapshot - [Go module proxy](/quest/m2/go-module-proxy.md) - `moq.dev/moq-ffi` ships from a static GOPROXY we host, so its staticlibs stop growing git history by ~61 MiB per release - [Go per-platform lib modules](/quest/m2/go-ffi-platform-modules.md) - a Go build downloads only the host's staticlib, and `go mod vendor` works - [Dart on iOS](/quest/m2/dart-ios.md) - prove the shipped iOS native asset actually loads on a device, which no CI can diff --git a/quest/m2/json-snapshot-resync.md b/quest/m2/json-snapshot-resync.md new file mode 100644 index 00000000000..9869ae3502c --- /dev/null +++ b/quest/m2/json-snapshot-resync.md @@ -0,0 +1,40 @@ +# [S] A JSON snapshot consumer resyncs after a bad frame + +## Goal + +When a frame fails to decode (a `SyntaxError` or `DuplicateKey`), `@moq/json`'s +`Snapshot.Consumer` drops the current group and throws a distinct decode +error, then resumes at the next group's snapshot. Callers such as +`@moq/room` and moq-boy can catch that error and keep reading instead of +ending. `rs/moq-json`'s snapshot consumer does the same. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: + +- m0 +- m1 +- ✅ m2 + +From [moq-dev/moq#7693](https://github.com/moq-dev/moq/pull/7693)'s +follow-ups, where both automated reviewers asked moq-boy to keep reading +after a malformed frame. That was refuted there, since the consumer can't +recover: after a parse error `#framesRead` and the delta base go stale +(`js/json/src/snapshot/consumer.ts`; `frames_read` in +`rs/moq-json/src/snapshot/consumer.rs`), so continuing would show wrong +state. The maintainer approved planning the fix from #7693's iterate. + +- On a decode failure, reset the frame count and delta base, skip the rest + of the group, and throw a new typed error (wrapping the cause) so callers + can tell it apart from a track end. +- Mirror it in Rust as a new `Error` variant, with the same skip. +- Move `@moq/room`'s metadata reader and moq-boy's status loop + (`js/room/src/metadata.ts`, `js/moq-boy/src/game.ts`) to skip the error + and resync, and test a malformed delta followed by a good group in both + languages. + +Public API: a new decode error in `@moq/json` and `moq-json`. Wire: none. + +## Related + +- [Benchmark a Value merge-patch diff for moq-json](/quest/m2/json-value-diff.md) - may replace the Rust diff this consumer applies From e81565d91c9715f82edecd22616897e4a333b8bb Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 3 Nov 2026 12:38:56 -0800 Subject: [PATCH 07/13] quest: plan native time-stretch in moq-audio, copying NetEq Maintainer on moq-dev/moq#7679, 2026-11-03: "m1 please copy what NetEQ does". A sibling of Watch in the audio jitter target epic, sharing one algorithm and its test vectors. Also drop proto-safe-names' Required link: #7498 merged and deleted catalog-proto-ids.md. Co-Authored-By: Claude Opus 5.5 --- quest/m1/audio-jitter-target/README.md | 1 + .../m1/audio-jitter-target/native-stretch.md | 74 +++++++++++++++++++ quest/m1/audio-jitter-target/watch.md | 1 + quest/m1/proto-safe-names.md | 15 ++-- 4 files changed, 83 insertions(+), 8 deletions(-) create mode 100644 quest/m1/audio-jitter-target/native-stretch.md diff --git a/quest/m1/audio-jitter-target/README.md b/quest/m1/audio-jitter-target/README.md index 5a3e3580667..6190f540839 100644 --- a/quest/m1/audio-jitter-target/README.md +++ b/quest/m1/audio-jitter-target/README.md @@ -37,6 +37,7 @@ native playback against its budgets. ## Required - [Watch](/quest/m1/audio-jitter-target/watch.md) - the browser's measured target, proven on Chrome and Safari against the public relay +- [Native stretch](/quest/m1/audio-jitter-target/native-stretch.md) - `moq play` copies NetEq's accelerate and preemptive expand, sharing the browser's algorithm and vectors, so its native rows reach zero steady-state underruns - [Capped budgets](/quest/m1/audio-jitter-target/capped-budgets.md) - post-cap nightlies confirm AAC bursty discards about as much audio as Opus bursty and the first row no longer stalls, and every browser row's budgets are re-measured from them ## Closes diff --git a/quest/m1/audio-jitter-target/native-stretch.md b/quest/m1/audio-jitter-target/native-stretch.md new file mode 100644 index 00000000000..1ea520fc050 --- /dev/null +++ b/quest/m1/audio-jitter-target/native-stretch.md @@ -0,0 +1,74 @@ +# [L] moq play reaches zero steady-state underruns by time-stretching + +## Goal + +`rs/moq-audio`'s playback converges on its playout target by time-stretching +received audio, as WebRTC NetEq does, instead of running its ring dry and +padding with silence or trimming buffered audio. `moq play`'s native rows in +`test/audio-quality` reach zero underruns once the target settles. The +stretch shares one algorithm and one set of test vectors with the browser's +in [Watch](/quest/m1/audio-jitter-target/watch.md). + +Boundaries: no packet loss concealment, so a frame that never arrives is +still missing audio; only received audio is stretched. The estimator +(`rs/moq-audio/src/jitter.rs`) stays as `doc/concept/audio-jitter.md` +specifies it. + +## Plan + +Decided 2026-11-03 (maintainer, on +[moq-dev/moq#7679](https://github.com/moq-dev/moq/pull/7679): "m1 please copy +what NetEQ does"), milestone: + +- m0 +- ✅ m1, in this epic +- m2 + +The browser half moved into m1 on #7679, which scopes native playback out of +[Watch](/quest/m1/audio-jitter-target/watch.md). This is the native half. +Today the native ring (`rs/moq-audio/src/ring.rs`) pads a dry ring with +silence back up to its latency and trims when the writer runs ahead, so +jitter and drift cost a glitch. + +**Copy NetEq.** Accelerate removes, and preemptive expand repeats, whole pitch +periods found by autocorrelation, overlap-adding at the seam. Start from +NetEq's thresholds and change one only with a measurement: + +- [`time_stretch.h`](https://webrtc.googlesource.com/src/+/refs/heads/main/modules/audio_coding/neteq/time_stretch.h) and + [`time_stretch.cc`](https://webrtc.googlesource.com/src/+/refs/heads/main/modules/audio_coding/neteq/time_stretch.cc): the shared search. It downsamples + to 4 kHz, autocorrelates over `kCorrelationLen` 50 samples for lags + `kMinLag` 10 to `kMaxLag` 60 (2.5 to 15 ms), runs a simple VAD, and + stretches only on `kCorrelationThreshold` 14746 (0.9 in Q14) or passive + speech. +- [`accelerate.cc`](https://webrtc.googlesource.com/src/+/refs/heads/main/modules/audio_coding/neteq/accelerate.cc): about 30 ms of input, and a 0.5 + threshold (8192 in Q14) in fast mode. +- [`preemptive_expand.cc`](https://webrtc.googlesource.com/src/+/refs/heads/main/modules/audio_coding/neteq/preemptive_expand.cc): the 0.9 threshold and + at least 15 ms of new data. +- [`decision_logic.cc`](https://webrtc.googlesource.com/src/+/refs/heads/main/modules/audio_coding/neteq/decision_logic.cc): when to accelerate or expand + against the target, at `kDelayAdjustmentGranularityMs` (20 ms). + +WebRTC is BSD-3-Clause; keep its notice with any code ported from it. + +**Share with JS.** Like the estimator, the stretch is specified once and +implemented in both languages. Whichever of this quest and Watch lands first +adds the stretch to `doc/concept/audio-jitter.md` (normative), with test +vectors beside the [conformance corpus](/doc/concept/audio-jitter.md): +input PCM, a requested accelerate or expand, and the expected output. The +second one conforms to them. Neither waits on the other, since the design +is NetEq's, not either implementation's. + +- Stretch on the PCM the ring hands to the device callback, driven by the + distance between buffered audio and the target. The callback stays + allocation-free and lock-free, as the ring is today. +- Padding with silence remains only for a ring the stretch couldn't keep fed, + and a trim only for a distance it can't close within a bound. +- Verification: the native rows reach 0 `underruns` per minute after the + target settles, and their provisional budgets are re-measured on the nightly + runner by the budgets note's rule. A listening check confirms that a 2 ms/s + drift and the measured expansions are inaudible or close to it. + +Public API: none expected. Wire: none. + +## Related + +- [Watch](/quest/m1/audio-jitter-target/watch.md) - the browser stretch sharing this algorithm and its vectors diff --git a/quest/m1/audio-jitter-target/watch.md b/quest/m1/audio-jitter-target/watch.md index 8b79046df75..307b76d4fef 100644 --- a/quest/m1/audio-jitter-target/watch.md +++ b/quest/m1/audio-jitter-target/watch.md @@ -72,3 +72,4 @@ defer validation of the current player. - [A/V clock](/quest/m1/av-clock.md) - reshapes `SyncInput` around the per-track target this line produces - [Capped budgets](/quest/m1/audio-jitter-target/capped-budgets.md) - confirms the build-flush fix on the nightlies, no gate on this proof +- [Native stretch](/quest/m1/audio-jitter-target/native-stretch.md) - the native time-stretch sharing one NetEq algorithm and its test vectors with this one diff --git a/quest/m1/proto-safe-names.md b/quest/m1/proto-safe-names.md index 822a71feaeb..6cfbd126fdb 100644 --- a/quest/m1/proto-safe-names.md +++ b/quest/m1/proto-safe-names.md @@ -23,13 +23,16 @@ Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-a - m2 Both gaps are the same bug as hang's catalog maps, fixed by -[moq-dev/moq#7498](https://github.com/moq-dev/moq/pull/7498): a plain object -keyed by an untrusted name. Planned as one quest (maintainer, from #7498's +[moq-dev/moq#7498](https://github.com/moq-dev/moq/pull/7498) (merged as +[7b4f53165](https://github.com/moq-dev/moq/commit/7b4f53165056d665378a09ec84465b6b033f5bf7)): +a plain object keyed by an untrusted name. Planned as one quest (maintainer, from #7498's iterate, 2026-11-03). - **MSF `ext`.** It parses with `z.record` (around line 76), which drops a - `__proto__` key. Use the same parser and test corpus as hang's maps from - #7498. + `__proto__` key; the encoder already writes one as an own property. Use the + parser hang's maps use since #7498 (`renditions()`/`section()` in + `js/hang/src/catalog/section.ts`, or its pattern if `js/msf` can't depend on + hang) and add the case to the parity corpus. - **js/publish.** `#renditions` and `#records` in `js/publish/src/broadcast.ts` (around lines 147 and 163) are plain objects, so `this.#renditions.peek()[name]` finds `Object.prototype`'s @@ -39,7 +42,3 @@ iterate, 2026-11-03). - Test `__proto__`, `constructor`, and `toString` in each place. Public API: none. Wire: none. - -## Required - -- [Text and data sections keep a prototype-named ID](/quest/m1/cut-audit/catalog-proto-ids.md) - the parser and corpus this reuses (moq-dev/moq#7498) From ecbb20212950ef9b82be1b3ba5fae90e39376170 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 3 Nov 2026 12:40:13 -0800 Subject: [PATCH 08/13] quest: name the browser stretch's current owner in Native stretch Main still keeps the browser stretch in m2 Time stretch; open moq-dev/moq#7679 moves it into Watch. Cross-link both, and record the native m1 decision in the epic's boundaries. Co-Authored-By: Claude Opus 5.5 --- quest/m1/audio-jitter-target/README.md | 7 ++++++- quest/m1/audio-jitter-target/native-stretch.md | 16 ++++++++++------ quest/m2/watch-audio-time-stretch.md | 4 ++++ 3 files changed, 20 insertions(+), 7 deletions(-) diff --git a/quest/m1/audio-jitter-target/README.md b/quest/m1/audio-jitter-target/README.md index 6190f540839..0ff46383adb 100644 --- a/quest/m1/audio-jitter-target/README.md +++ b/quest/m1/audio-jitter-target/README.md @@ -27,7 +27,12 @@ every viewer, so `"auto"` shipped ahead of the Chrome and Safari proof the Watch quest still owes; the maintainer accepted that, and the re-measured replay budgets, on 2026-10-04. Decided 2026-10-13: retain the remaining proof in m1 because the A/V clock and worker release contracts depend on it. Native quality expansion -remains separately scoped in m2. +remains separately scoped in m2, except native time-stretch: decided +2026-11-03 (maintainer, on +[moq-dev/moq#7679](https://github.com/moq-dev/moq/pull/7679)), `moq play` +copies NetEq's stretch in m1 as +[Native stretch](/quest/m1/audio-jitter-target/native-stretch.md), sharing +one algorithm and its vectors with the browser's. What the line still owes once Watch lands: its recorded trace replayed through the native decode path too, asserting the same target series the browser's diff --git a/quest/m1/audio-jitter-target/native-stretch.md b/quest/m1/audio-jitter-target/native-stretch.md index 1ea520fc050..c46b97140bf 100644 --- a/quest/m1/audio-jitter-target/native-stretch.md +++ b/quest/m1/audio-jitter-target/native-stretch.md @@ -6,8 +6,7 @@ received audio, as WebRTC NetEq does, instead of running its ring dry and padding with silence or trimming buffered audio. `moq play`'s native rows in `test/audio-quality` reach zero underruns once the target settles. The -stretch shares one algorithm and one set of test vectors with the browser's -in [Watch](/quest/m1/audio-jitter-target/watch.md). +stretch shares one algorithm and one set of test vectors with the browser's. Boundaries: no packet loss concealment, so a frame that never arrives is still missing audio; only received audio is stretched. The estimator @@ -24,8 +23,12 @@ what NetEQ does"), milestone: - ✅ m1, in this epic - m2 -The browser half moved into m1 on #7679, which scopes native playback out of -[Watch](/quest/m1/audio-jitter-target/watch.md). This is the native half. +This is the native half. The browser half is +[Time stretch](/quest/m2/watch-audio-time-stretch.md) on `main` today; +#7679, still open, folds it into +[Watch](/quest/m1/audio-jitter-target/watch.md) in m1 and scopes native +playback out of Watch. Wherever the browser stretch lives when this starts, +it shares the algorithm and vectors below. Today the native ring (`rs/moq-audio/src/ring.rs`) pads a dry ring with silence back up to its latency and trims when the writer runs ahead, so jitter and drift cost a glitch. @@ -50,7 +53,7 @@ NetEq's thresholds and change one only with a measurement: WebRTC is BSD-3-Clause; keep its notice with any code ported from it. **Share with JS.** Like the estimator, the stretch is specified once and -implemented in both languages. Whichever of this quest and Watch lands first +implemented in both languages. Whichever of this quest and the browser stretch lands first adds the stretch to `doc/concept/audio-jitter.md` (normative), with test vectors beside the [conformance corpus](/doc/concept/audio-jitter.md): input PCM, a requested accelerate or expand, and the expected output. The @@ -71,4 +74,5 @@ Public API: none expected. Wire: none. ## Related -- [Watch](/quest/m1/audio-jitter-target/watch.md) - the browser stretch sharing this algorithm and its vectors +- [Time stretch](/quest/m2/watch-audio-time-stretch.md) - the browser stretch sharing this algorithm and its vectors, which #7679 folds into Watch +- [Watch](/quest/m1/audio-jitter-target/watch.md) - the browser's measured target, and the browser stretch's home once #7679 lands diff --git a/quest/m2/watch-audio-time-stretch.md b/quest/m2/watch-audio-time-stretch.md index 50bd0bdd265..710ab117b2c 100644 --- a/quest/m2/watch-audio-time-stretch.md +++ b/quest/m2/watch-audio-time-stretch.md @@ -29,3 +29,7 @@ was closed in favor of it); the clock the stretch converges toward is - [Watch](/quest/m1/audio-jitter-target/watch.md) - the recorded traces this replays, and the JS target it converges toward - [A/V clock](/quest/m1/av-clock.md) - the clock the stretch converges toward + +## Related + +- [Native stretch](/quest/m1/audio-jitter-target/native-stretch.md) - the native half, sharing one NetEq algorithm and its test vectors with this one From 961da6886eae7db2f7e681ad1e898d3b42395625 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 3 Nov 2026 12:41:52 -0800 Subject: [PATCH 09/13] quest: fix two review threads and plan a self-contained Moxygen smoke cert CodeRabbit on moq-dev/moq#7748: vui.rs:263 is a test fixture, so the SPS walk replaces only the decoder's call at :102; and sub-millisecond bench latency needs a microsecond send time in the frame header. From moq-dev/moq#7700: the Moxygen smoke lane writes its own OpenSSL config, like ietf-conformance. Co-Authored-By: Claude Opus 5.5 --- quest/m0/video-sps-walk.md | 11 ++++++---- quest/m2/README.md | 1 + quest/m2/bench-latency-resolution.md | 7 ++++++ quest/m2/smoke-moxygen-cert.md | 33 ++++++++++++++++++++++++++++ 4 files changed, 48 insertions(+), 4 deletions(-) create mode 100644 quest/m2/smoke-moxygen-cert.md diff --git a/quest/m0/video-sps-walk.md b/quest/m0/video-sps-walk.md index f653dadf626..a26a1fb4374 100644 --- a/quest/m0/video-sps-walk.md +++ b/quest/m0/video-sps-walk.md @@ -3,7 +3,7 @@ ## Goal A hostile publisher's H.265 SPS can't panic a subscriber's decoder. -moq-video's VUI reads (`rs/moq-video/src/decode/vui.rs:102` and `:263`) stop +moq-video's VUI read (`rs/moq-video/src/decode/vui.rs:102`) stops calling `scuffle_h265::SpsNALUnit::parse` directly and go through moq-mux's bounded walk, `sps::parse_full` from [moq-dev/moq#7685](https://github.com/moq-dev/moq/pull/7685), which refuses an @@ -19,13 +19,16 @@ Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-a - m2 From #7685's follow-ups: it bounds moq-mux's import path, but moq-video still -parses the same SPS unchecked, and `:263` unwraps the result. +parses the same SPS unchecked: scuffle-h265 itself overflows inside +`SpsNALUnit::parse` before `:102` can map a failed parse to `Some(None)`. - Expose the walk from moq-mux (`codec/h265/sps.rs`) as a small public function rather than copying it into moq-video, so both crates refuse the same inputs. -- Replace both call sites; `:263`'s `unwrap()` becomes an error the decoder - reports. +- Replace the decoder's call at `:102`, mapping a refusal the way a failed + parse already maps (`Some(None)`, which clears the label). The other parse, + at `:263`, is in the test `a_window_past_the_picture_is_refused` on a fixed + valid fixture, so it can stay. - Feed #7685's minimized inputs through moq-video's VUI read in a test that panics without the fix. diff --git a/quest/m2/README.md b/quest/m2/README.md index 1e1367ec333..01a62e54f15 100644 --- a/quest/m2/README.md +++ b/quest/m2/README.md @@ -214,6 +214,7 @@ lite-07; bitrate enforcement is not part of this release. - [No MOQ_* knobs outside the binaries](/quest/m2/env-knobs.md) - test, bench, and library knobs leave the `MOQ_*` prefix - [Clean ALSA playback onset](/quest/m2/audio-alsa-onset.md) - no onset restarts or clicks over PulseAudio - [Interop audit](/quest/m2/audit-interop.md) - our interop runner entries match what we ship, and every red interop cell with a moq.dev side is fixed, reported, or noted as down or unsupported +- [The Moxygen smoke lane makes its own certificate config](/quest/m2/smoke-moxygen-cert.md) - `just test smoke moxygen` needs no `OPENSSL_CONF` from the caller, like the conformance lane - [The HLS server follows each path once](/quest/m2/hls-follow-once.md) - `Following` reports synced absence, so moq-hls resolves with one follow - [moq-bench pins the instances it measures](/quest/m2/bench-epoch-pin.md) - pooled requests pin their announced epoch, so a takeover is not counted as the same broadcast - [moq-bench reports sub-millisecond latency](/quest/m2/bench-latency-resolution.md) - steady-window latency resolves finer than 1 ms diff --git a/quest/m2/bench-latency-resolution.md b/quest/m2/bench-latency-resolution.md index ed357573fcb..1a561d1f34d 100644 --- a/quest/m2/bench-latency-resolution.md +++ b/quest/m2/bench-latency-resolution.md @@ -21,6 +21,13 @@ The relay-per-thread spike glass-to-glass p50 "within the generator's millisecond resolution" while the in-process hop measured 75 to 175 us. +- Send the keyframe's send time in microseconds: the frame header + (`rs/moq-bench/src/connection.rs`) carries only `timestamp_ms`, so a finer + receive clock against a millisecond send time would mostly measure that + truncation. Add a microsecond field beside `timestamp_ms`, optional in + `RecvHeader` so older publishers still parse, and pass it to + `Stats::latency`. It's a bench payload field, not a wire change; don't get + there by changing the track's timescale. - Record microseconds (or finer) over the steady window with a bounded histogram (for example log-linear buckets), keeping memory flat. - Keep the report's existing millisecond fields for the nightly series, and diff --git a/quest/m2/smoke-moxygen-cert.md b/quest/m2/smoke-moxygen-cert.md new file mode 100644 index 00000000000..839bf8c094f --- /dev/null +++ b/quest/m2/smoke-moxygen-cert.md @@ -0,0 +1,33 @@ +# [XS] The Moxygen smoke lane makes its own certificate config + +## Goal + +`just test smoke moxygen` generates its throwaway relay certificate in the +dev shell without the caller setting `OPENSSL_CONF`, the way +`just test ietf-conformance` already does. + +## Plan + +Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 +/quest-afk and /quest-complete runs), milestone: + +- m0 +- m1 +- ✅ m2 + +From [moq-dev/moq#7700](https://github.com/moq-dev/moq/pull/7700)'s +follow-ups: the published-package Moxygen smoke lane passed only with an +explicit `OPENSSL_CONF=`. The dev shell's LibreSSL (4.3.2) has +no system-wide `openssl.cnf`, so the bare `openssl req` in +`test/smoke/moxygen.sh` (around line 94) fails with "Unable to load config +info from etc/ssl/openssl.cnf". + +- Write a minimal config into the lane's scratch directory and pass it with + `-config`, as `test/ietf-conformance/run.sh` does (around line 25), or share + one helper between the two. +- `test/smoke/cloudflare.sh` (around line 129) calls `openssl req` the same + way; give it the same fix wherever it runs on the dev shell's LibreSSL. +- Run `just test smoke moxygen` from a fresh dev shell with `OPENSSL_CONF` + unset. + +Public API: none. Wire: none. From c8d8471b3f85dc8a7b70ab3af6449bdb9e45de26 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 3 Nov 2026 12:57:09 -0800 Subject: [PATCH 10/13] quest: bound every received box and count, and narrow the MSF half Merge main (#7687 and #7693 merged): drop the CMAF quest's Required edge and the abort-wake quest's link to the deleted moq-boy quest. Per the OpenAI review, the CMAF quest bounds every top-level box before mp4-atom's Any decoder and bounds counts too. Per Pullfrog, js/msf's decode already keeps a __proto__ extension, so only its exported schema remains. Co-Authored-By: Claude Opus 5.5 --- quest/m0/cmaf-receive-bounds.md | 29 +++++++++++++++++++---------- quest/m1/js-follow-abort-wake.md | 3 +-- quest/m1/proto-safe-names.md | 18 ++++++++++-------- 3 files changed, 30 insertions(+), 20 deletions(-) diff --git a/quest/m0/cmaf-receive-bounds.md b/quest/m0/cmaf-receive-bounds.md index 3ca6bc93f4c..6d9a8f7e5ce 100644 --- a/quest/m0/cmaf-receive-bounds.md +++ b/quest/m0/cmaf-receive-bounds.md @@ -17,7 +17,7 @@ Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-a - m1 - m2 -#7687 bounds the importer (publisher side). Received frames, up to 32 MiB +#7687 (merged) bounds the importer (publisher side). Received frames, up to 32 MiB each, still reach mp4-atom unchecked: - `fmp4::Wire::decode` and its `decode` helper @@ -28,18 +28,27 @@ each, still reach mp4-atom unchecked: - `rs/moq-mux/src/container/mp4.rs` (the `Moof::decode` around line 162 and the init's `Moov::decode`). -Reuse #7687's `MAX_METADATA_BYTES`: read each box header's size and refuse -an oversized `moof`/`moov` before decoding it, so the limit stays one -constant shared with the importer. Measure each path's peak with #7687's -counting allocator (`allocation::Usage::peak`), as its -`fragment_plans_within_the_held_bound` does, failing without the fix. +- **Every box, not only `moof` and `moov`.** These paths decode each + top-level box through `mp4_atom::Any::decode_maybe` before discarding the + ones they don't use, and mp4-atom expands any box it knows (a stray + top-level `trun`, say) wherever it appears. So read each top-level box's + header and refuse or skip any body over #7687's `MAX_METADATA_BYTES` before + `Any` sees it, keeping the limit one constant shared with the importer. +- **Counts, not only bytes.** A small box can still declare a large count. + Bound received sample counts as the importer does (`MAX_FRAGMENT_SAMPLES`), + including runs without per-sample fields. `sgpd`'s zero-byte entries are + fixed upstream and picked up by + [moq-mux on a fixed mp4-atom](/quest/m1/fuzz-findings/mp4-atom-bump.md), + which waits on a release. If that hasn't landed, refuse an `sgpd` entry + count the input can't hold here too. +- Measure each path's peak with #7687's counting allocator + (`allocation::Usage::peak`), as its `fragment_plans_within_the_held_bound` + does, with both a large-box and a small-box/large-count input per path, each + failing without the fix. Public API: none expected (a new error variant at most). Wire: none. -## Required - -- [fMP4 sample plans, trun counts, and trak counts are bounded](/quest/m1/fmp4-metadata-limits.md) - lands `MAX_METADATA_BYTES` (moq-dev/moq#7687) - ## Related - [One policy for oversized container metadata](/quest/m2/import-metadata-policy.md) - the importer-side rule this mirrors +- [moq-mux on a fixed mp4-atom](/quest/m1/fuzz-findings/mp4-atom-bump.md) - the upstream `sgpd` count fix diff --git a/quest/m1/js-follow-abort-wake.md b/quest/m1/js-follow-abort-wake.md index 878fd7a69ab..5b9f396a8a3 100644 --- a/quest/m1/js-follow-abort-wake.md +++ b/quest/m1/js-follow-abort-wake.md @@ -16,7 +16,7 @@ Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-a - ✅ m1 - m2 -Found by [moq-dev/moq#7693](https://github.com/moq-dev/moq/pull/7693): the +Found by [moq-dev/moq#7693](https://github.com/moq-dev/moq/pull/7693) (merged): the pending read stays parked until the next read throws the error, while a pending `nextGroup()` wakes on both paths. @@ -37,5 +37,4 @@ Public API: none. Wire: none. ## Related -- [moq-boy's status loop stops on an errored track](/quest/m1/moq-boy-status-loop.md) - #7693, where this surfaced - [Resume redesign](/quest/m2/resume-redesign.md) - would replace this code later diff --git a/quest/m1/proto-safe-names.md b/quest/m1/proto-safe-names.md index 6cfbd126fdb..6ee1feeff33 100644 --- a/quest/m1/proto-safe-names.md +++ b/quest/m1/proto-safe-names.md @@ -6,8 +6,9 @@ JS keeps names that collide with `Object.prototype` (`__proto__`, `constructor`, `toString`) wherever it keys renditions or catalog members by name, the way Rust does: -- `js/msf/src/catalog.ts`'s `ext` map keeps a `__proto__` key as an own - property, like `moq-msf`'s `Catalog::ext`. +- `js/msf/src/catalog.ts`'s exported `CatalogSchema` keeps a `__proto__` + `ext` key as an own property, as its `decode` already does, like + `moq-msf`'s `Catalog::ext`. - `js/publish` registers a rendition named `__proto__` or `constructor` instead of refusing it as "rendition already registered", and its catalog and stats builders publish it. @@ -28,17 +29,18 @@ Both gaps are the same bug as hang's catalog maps, fixed by a plain object keyed by an untrusted name. Planned as one quest (maintainer, from #7498's iterate, 2026-11-03). -- **MSF `ext`.** It parses with `z.record` (around line 76), which drops a - `__proto__` key; the encoder already writes one as an own property. Use the - parser hang's maps use since #7498 (`renditions()`/`section()` in - `js/hang/src/catalog/section.ts`, or its pattern if `js/msf` can't depend on - hang) and add the case to the parity corpus. +- **MSF `ext`.** `decode` and `encode` already keep a `__proto__` member + (null-prototype maps; `catalog.test.ts`'s "round-trips a __proto__ + extension member as data"). Only the exported `CatalogSchema` (around line + 69) still declares `ext` as a `z.record`, which drops it for a caller that + parses with the schema directly. Give it the same null-prototype parse, or + stop exporting it as a parser if nothing outside `js/msf` should use it. - **js/publish.** `#renditions` and `#records` in `js/publish/src/broadcast.ts` (around lines 147 and 163) are plain objects, so `this.#renditions.peek()[name]` finds `Object.prototype`'s member and throws "already registered". Key them with a `Map` (or null-prototype objects) and carry that through the catalog and stats builders that read them, so the published catalog keeps the name. -- Test `__proto__`, `constructor`, and `toString` in each place. +- Test `__proto__`, `constructor`, and `toString` in each place that changes. Public API: none. Wire: none. From d5070b58b26085c1260d9f28622f9b218512f8b0 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 3 Nov 2026 13:06:19 -0800 Subject: [PATCH 11/13] quest: state the CMAF Goal over every box and count Pullfrog's suggested patch on moq-dev/moq#7748, applied unchanged. Co-Authored-By: Claude Opus 5.5 --- quest/m0/cmaf-receive-bounds.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/quest/m0/cmaf-receive-bounds.md b/quest/m0/cmaf-receive-bounds.md index 6d9a8f7e5ce..9d888096ae5 100644 --- a/quest/m0/cmaf-receive-bounds.md +++ b/quest/m0/cmaf-receive-bounds.md @@ -4,10 +4,10 @@ A hostile publisher can't make a subscriber allocate hundreds of megabytes from one frame. Every place a subscriber parses received CMAF with mp4-atom -refuses a `moof` (or init `moov`) larger than `MAX_METADATA_BYTES` before -parsing it, and a peak-memory test like +refuses any top-level box whose body exceeds `MAX_METADATA_BYTES`, and any +count over the importer's cap, before parsing it. A peak-memory test like [moq-dev/moq#7687](https://github.com/moq-dev/moq/pull/7687)'s shows the -bound holding on each path. +bounds holding on each path. ## Plan From 46ea32cfe5df318680f654320ff79c58cd5121b4 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 3 Nov 2026 13:18:08 -0800 Subject: [PATCH 12/13] quest: native stretch vectors grade the accelerate/expand/hold choice CodeRabbit's suggested wording on moq-dev/moq#7748, applied unchanged. Co-Authored-By: Claude Opus 5.5 --- quest/m1/audio-jitter-target/native-stretch.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/quest/m1/audio-jitter-target/native-stretch.md b/quest/m1/audio-jitter-target/native-stretch.md index c46b97140bf..dd3ca6ee8c5 100644 --- a/quest/m1/audio-jitter-target/native-stretch.md +++ b/quest/m1/audio-jitter-target/native-stretch.md @@ -56,7 +56,7 @@ WebRTC is BSD-3-Clause; keep its notice with any code ported from it. implemented in both languages. Whichever of this quest and the browser stretch lands first adds the stretch to `doc/concept/audio-jitter.md` (normative), with test vectors beside the [conformance corpus](/doc/concept/audio-jitter.md): -input PCM, a requested accelerate or expand, and the expected output. The +input PCM, buffered distance, target, and hysteresis state, the expected accelerate, expand, or hold, and the expected output. The second one conforms to them. Neither waits on the other, since the design is NetEq's, not either implementation's. From 961dd6c28f505971355999e9d990c976b1a30f27 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 3 Nov 2026 22:52:59 -0800 Subject: [PATCH 13/13] quest: fold the e2ee stub and LibreSSL smoke duplicates into #7747's quests Pullfrog on moq-dev/moq#7748: moq-e2ee-retire.md duplicates main's release/e2ee-retire.md, and smoke-moxygen-cert.md duplicates main's smoke-libressl.md (both from #7747). Remove this PR's copies with quest rm and move their extra evidence into main's. A sweep against #7747, #7795, and #7807 found no other duplicates. Co-Authored-By: Claude Opus 5.5 --- quest/m2/README.md | 1 - quest/m2/release/README.md | 1 - quest/m2/release/e2ee-retire.md | 7 ++++-- quest/m2/release/moq-e2ee-retire.md | 37 ----------------------------- quest/m2/smoke-libressl.md | 6 ++++- quest/m2/smoke-moxygen-cert.md | 33 ------------------------- 6 files changed, 10 insertions(+), 75 deletions(-) delete mode 100644 quest/m2/release/moq-e2ee-retire.md delete mode 100644 quest/m2/smoke-moxygen-cert.md diff --git a/quest/m2/README.md b/quest/m2/README.md index a62a52ea5a0..1f2a8c18702 100644 --- a/quest/m2/README.md +++ b/quest/m2/README.md @@ -226,7 +226,6 @@ lite-07; bitrate enforcement is not part of this release. - [No MOQ_* knobs outside the binaries](/quest/m2/env-knobs.md) - test, bench, and library knobs leave the `MOQ_*` prefix - [Clean ALSA playback onset](/quest/m2/audio-alsa-onset.md) - no onset restarts or clicks over PulseAudio - [Interop audit](/quest/m2/audit-interop.md) - our interop runner entries match what we ship, and every red interop cell with a moq.dev side is fixed, reported, or noted as down or unsupported -- [The Moxygen smoke lane makes its own certificate config](/quest/m2/smoke-moxygen-cert.md) - `just test smoke moxygen` needs no `OPENSSL_CONF` from the caller, like the conformance lane - [moq-hls exposes each rendition's bound source](/quest/m2/hls-rendition-source.md) - playlists and segments report the source path and instance they read, so a cache can key on the source - [The HLS server follows each path once](/quest/m2/hls-follow-once.md) - `Following` reports synced absence, so moq-hls resolves with one follow - [moq-bench pins the instances it measures](/quest/m2/bench-epoch-pin.md) - pooled requests pin their announced epoch, so a takeover is not counted as the same broadcast diff --git a/quest/m2/release/README.md b/quest/m2/release/README.md index c6fdc10fbaf..eb86d124fd8 100644 --- a/quest/m2/release/README.md +++ b/quest/m2/release/README.md @@ -39,7 +39,6 @@ production stability proven merely because upstream artifacts published. - [Dart publication](/quest/m2/release/dart-publish.md) - the wrapper and native artifacts install from the registry - [Final libmoq stub](/quest/m2/release/libmoq-final-release.md) - publish the migration notice before removing its source - [Retire libmoq](/quest/m2/release/libmoq-retire.md) - cleanup only after that publication -- [Retire the moq-e2ee stub](/quest/m2/release/moq-e2ee-retire.md) - waiting on the stub's release above 0.0.20, then delete `rs/moq-e2ee` - [Retire the moq-e2ee stub](/quest/m2/release/e2ee-retire.md) - delete `rs/moq-e2ee` once the cut publishes it as the final release - [Retire hand-written C](/quest/m2/release/c-retire.md) - delete the hand-written crate once generated C publishes - [Retire the web-transport JS qmux](/quest/m2/release/qmux-js-retire.md) - once `@moq/qmux` publishes from `js/qmux`, deprecate `@moq/web-socket-stream` and stop the second publisher diff --git a/quest/m2/release/e2ee-retire.md b/quest/m2/release/e2ee-retire.md index 8feba672937..4e97bd34e83 100644 --- a/quest/m2/release/e2ee-retire.md +++ b/quest/m2/release/e2ee-retire.md @@ -15,10 +15,13 @@ mirroring [Retire libmoq](/quest/m2/release/libmoq-retire.md). - #7702 leaves `rs/moq-e2ee` as a code-free stub, and [the cut](/quest/m2/release/cut.md) publishes it at a version above crates.io's 0.0.20. Check with `curl -s - https://crates.io/api/v1/crates/moq-e2ee` that the stub's version is the - newest. + https://crates.io/api/v1/crates/moq-e2ee | jq -r .crate.max_version` that + the stub's version is the newest. - Then delete `rs/moq-e2ee` and its workspace member, so release-plz never publishes it again, and grep for any remaining `moq-e2ee` or `moq_e2ee`. + Keep the draft and profile names (`draft-lcurley-moq-e2ee`, "moq-e2ee + epoch"), which name the format, not the crate. (Folded in from + moq-dev/moq#7748's duplicate "Retire the moq-e2ee stub", 2026-11-04.) - moq-sign was never published, so it needs no stub. ## Required diff --git a/quest/m2/release/moq-e2ee-retire.md b/quest/m2/release/moq-e2ee-retire.md deleted file mode 100644 index a55af04a487..00000000000 --- a/quest/m2/release/moq-e2ee-retire.md +++ /dev/null @@ -1,37 +0,0 @@ -# [XS] Retire the moq-e2ee stub - -## Goal - -`rs/moq-e2ee` is gone and the `moq-e2ee` crate is no longer published. Its -last release, a code-free crate whose README points at moq-crypto, stays on -crates.io for anyone still resolving the old name. - -## Waiting - -- moq-dev/moq: the next cut publishes the `moq-e2ee` stub to crates.io, - above 0.0.20. Check with - `curl -s https://crates.io/api/v1/crates/moq-e2ee | jq -r .crate.max_version`. - -## Plan - -Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 /quest-afk and /quest-complete runs), milestone: - -- m0 -- m1 -- ✅ m2, in the release epic beside the libmoq stub - -[moq-dev/moq#7702](https://github.com/moq-dev/moq/pull/7702) (merged) turned -`rs/moq-e2ee` into a code-free stub that the cut's `just version` lifts -above 0.0.20, so release-plz publishes it. - -- Once that release is on crates.io, delete `rs/moq-e2ee` and its workspace - member, so release-plz never publishes it again. -- Grep for any remaining `moq-e2ee` that names the crate rather than the - draft or profile (`draft-lcurley-moq-e2ee`, "moq-e2ee epoch"). - -Public API: none. Wire: none. - -## Related - -- [moq-crypto replaces moq-sign and moq-e2ee](https://github.com/moq-dev/moq/pull/7702) - makes the stub -- [Retire libmoq](/quest/m2/release/libmoq-retire.md) - the same retirement for libmoq diff --git a/quest/m2/smoke-libressl.md b/quest/m2/smoke-libressl.md index dda1ed7057c..66fbe230870 100644 --- a/quest/m2/smoke-libressl.md +++ b/quest/m2/smoke-libressl.md @@ -14,7 +14,11 @@ Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from - #7700's moxygen smoke passed only with an explicit `OPENSSL_CONF`, because the dev shell's LibreSSL has no system `openssl.cnf`. `test/smoke/moxygen.sh:94` and `test/smoke/cloudflare.sh:129` run - `openssl req -x509 … -subj … -addext …` with no `-config`. + `openssl req -x509 … -subj … -addext …` with no `-config`. Reproduced + 2026-11-03 on the dev shell's LibreSSL 4.3.2: a bare `openssl req` with + `OPENSSL_CONF` unset fails with "Unable to load config info from + etc/ssl/openssl.cnf". (Folded in from moq-dev/moq#7748's duplicate "The + Moxygen smoke lane makes its own certificate config", 2026-11-04.) - `test/ietf-conformance/run.sh:25-40` already writes its own minimal `openssl.cnf` and passes `-config`. Share that helper with both smoke scripts instead of copying it. diff --git a/quest/m2/smoke-moxygen-cert.md b/quest/m2/smoke-moxygen-cert.md deleted file mode 100644 index 839bf8c094f..00000000000 --- a/quest/m2/smoke-moxygen-cert.md +++ /dev/null @@ -1,33 +0,0 @@ -# [XS] The Moxygen smoke lane makes its own certificate config - -## Goal - -`just test smoke moxygen` generates its throwaway relay certificate in the -dev shell without the caller setting `OPENSSL_CONF`, the way -`just test ietf-conformance` already does. - -## Plan - -Decided 2026-11-03 (maintainer, follow-up planning after the 2026-11-03 -/quest-afk and /quest-complete runs), milestone: - -- m0 -- m1 -- ✅ m2 - -From [moq-dev/moq#7700](https://github.com/moq-dev/moq/pull/7700)'s -follow-ups: the published-package Moxygen smoke lane passed only with an -explicit `OPENSSL_CONF=`. The dev shell's LibreSSL (4.3.2) has -no system-wide `openssl.cnf`, so the bare `openssl req` in -`test/smoke/moxygen.sh` (around line 94) fails with "Unable to load config -info from etc/ssl/openssl.cnf". - -- Write a minimal config into the lane's scratch directory and pass it with - `-config`, as `test/ietf-conformance/run.sh` does (around line 25), or share - one helper between the two. -- `test/smoke/cloudflare.sh` (around line 129) calls `openssl req` the same - way; give it the same fix wherever it runs on the dev shell's LibreSSL. -- Run `just test smoke moxygen` from a fresh dev shell with `OPENSSL_CONF` - unset. - -Public API: none. Wire: none.