From 53f48ce03ac068dd12ea92c03ed9c08d0a6c8cf4 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 27 Oct 2026 22:53:31 -0700 Subject: [PATCH 1/2] chore(quest): plan follow-ups from the 2026-10-27 spawn Co-Authored-By: Claude Opus 5.5 --- quest/m0/ci/README.md | 4 ++++ quest/m0/ci/quic-padding.md | 16 ++++++++++++++++ quest/m0/ci/recovery-clips.md | 17 +++++++++++++++++ quest/m0/ci/stats-oversize.md | 14 ++++++++++++++ quest/m0/ci/tracing-filter.md | 16 ++++++++++++++++ quest/m0/nightly/README.md | 2 ++ quest/m0/nightly/gate-hang.md | 18 ++++++++++++++++++ quest/m0/nightly/quic-rustdoc.md | 14 ++++++++++++++ quest/m0/test-flakes-2/README.md | 1 + quest/m0/test-flakes-2/fake-timers.md | 18 ++++++++++++++++++ quest/m1/README.md | 9 +++++++++ quest/m1/bench-ci.md | 4 ++++ quest/m1/c/README.md | 1 + quest/m1/c/json-window.md | 16 ++++++++++++++++ quest/m1/cluster-routing/routes.md | 10 ++++++++++ quest/m1/gst-max-delay.md | 18 ++++++++++++++++++ quest/m1/hls-record-target.md | 17 +++++++++++++++++ quest/m1/js-fetch-timeout-test.md | 15 +++++++++++++++ quest/m1/mock-reset-codes.md | 23 +++++++++++++++++++++++ quest/m1/recover-reader-budget.md | 17 +++++++++++++++++ quest/m1/resume-release-rust.md | 16 ++++++++++++++++ quest/m1/slow-joiner-test.md | 17 +++++++++++++++++ quest/m1/smoke-token-subject.md | 17 +++++++++++++++++ quest/m1/subscribe-timestamps.md | 25 +++++++++++++++++++++++++ quest/m2/perf/README.md | 4 ++++ quest/m2/perf/covered-before-start.md | 16 ++++++++++++++++ quest/m2/perf/export-idle-poll.md | 15 +++++++++++++++ quest/m2/perf/lite-request-allocs.md | 20 ++++++++++++++++++++ quest/m2/perf/mesh-session-cost.md | 17 +++++++++++++++++ 29 files changed, 397 insertions(+) create mode 100644 quest/m0/ci/quic-padding.md create mode 100644 quest/m0/ci/recovery-clips.md create mode 100644 quest/m0/ci/stats-oversize.md create mode 100644 quest/m0/ci/tracing-filter.md create mode 100644 quest/m0/nightly/gate-hang.md create mode 100644 quest/m0/nightly/quic-rustdoc.md create mode 100644 quest/m0/test-flakes-2/fake-timers.md create mode 100644 quest/m1/c/json-window.md create mode 100644 quest/m1/gst-max-delay.md create mode 100644 quest/m1/hls-record-target.md create mode 100644 quest/m1/js-fetch-timeout-test.md create mode 100644 quest/m1/mock-reset-codes.md create mode 100644 quest/m1/recover-reader-budget.md create mode 100644 quest/m1/resume-release-rust.md create mode 100644 quest/m1/slow-joiner-test.md create mode 100644 quest/m1/smoke-token-subject.md create mode 100644 quest/m1/subscribe-timestamps.md create mode 100644 quest/m2/perf/covered-before-start.md create mode 100644 quest/m2/perf/export-idle-poll.md create mode 100644 quest/m2/perf/lite-request-allocs.md create mode 100644 quest/m2/perf/mesh-session-cost.md diff --git a/quest/m0/ci/README.md b/quest/m0/ci/README.md index 46ae5afef89..d4e7705a5bc 100644 --- a/quest/m0/ci/README.md +++ b/quest/m0/ci/README.md @@ -135,3 +135,7 @@ The historical samples locate candidates; they are not controlled benchmarks. - [First shared FFI release](/quest/m0/ci/nightly-ffi-reuse.md) - condition: the backport merges and the next `moq-ffi-v*` tag runs `Release FFI`; verify the wrappers - [Fewer BTreeMap instantiations](/quest/m0/ci/btree-keys.md) - moq-net shares BTreeMap key and value types, kept only if its CPU time drops - [Halve the slowest tests' CPU](/quest/m0/ci/slow-tests.md) - the slowest 1% of tests take under half their 289 CPU-seconds, with coverage kept +- [Recovery clips once](/quest/m0/ci/recovery-clips.md) - `recovery_test`'s FFmpeg clips encode once per run, not once per process +- [Padding runs](/quest/m0/ci/quic-padding.md) - moq-quic parses a PADDING run as one frame, keeping the padding stats' meaning +- [tracing-test filter](/quest/m0/ci/tracing-filter.md) - moq-tokio's tests stop forcing every crate to format at TRACE +- [Stats oversize](/quest/m0/ci/stats-oversize.md) - moq-stats refuses an oversized plain snapshot before parsing it back diff --git a/quest/m0/ci/quic-padding.md b/quest/m0/ci/quic-padding.md new file mode 100644 index 00000000000..139bd33fd2d --- /dev/null +++ b/quest/m0/ci/quic-padding.md @@ -0,0 +1,16 @@ +# [S] moq-quic collapses padding runs + +## Goal + +moq-quic's frame iterator yields one frame for a run of PADDING bytes instead +of one per byte, cutting the roughly 30% of debug-build handshake CPU it +costs today, and the padding stats still count what they mean to count. + +## Plan + +Found by [moq-dev/moq#6987](https://github.com/moq-dev/moq/pull/6987)'s +profile of the slowest tests. First check what the padding stats should +count (bytes or frames) and keep that meaning. The iterator parses +peer-sent packets, so a run is consumed in one step with no per-byte work. + +Public API: none expected; report any change to the stats. diff --git a/quest/m0/ci/recovery-clips.md b/quest/m0/ci/recovery-clips.md new file mode 100644 index 00000000000..d77d51fe2ed --- /dev/null +++ b/quest/m0/ci/recovery-clips.md @@ -0,0 +1,17 @@ +# [S] Recovery test clips encode once per run + +## Goal + +`recovery_test`'s FFmpeg clips are encoded once per test run instead of once +per test process, cutting the 35 to 40% of its CPU that FFmpeg encode and +decode take today, with every case and its coverage kept. + +## Plan + +Found by [moq-dev/moq#6987](https://github.com/moq-dev/moq/pull/6987)'s +profile of the slowest tests. Pick one of: committing the clips (about 320 KB +each), generating them in a nextest setup script, or caching them under a +lock keyed by the FFmpeg version. Measure it the way that PR measured its cohort, on the same machine before +and after. + +Public API: none. diff --git a/quest/m0/ci/stats-oversize.md b/quest/m0/ci/stats-oversize.md new file mode 100644 index 00000000000..10501a0cd4c --- /dev/null +++ b/quest/m0/ci/stats-oversize.md @@ -0,0 +1,14 @@ +# [XS] moq-stats refuses an oversized plain snapshot early + +## Goal + +moq-stats' snapshot encoder refuses an oversized plain snapshot before +parsing it back, as it already does for deflate, so the oversize tests stop +spending about 4.5 s of CPU building and re-reading a snapshot they refuse. + +## Plan + +Found by [moq-dev/moq#6987](https://github.com/moq-dev/moq/pull/6987)'s +profile. Keep the refusal error the same. + +Public API: none. diff --git a/quest/m0/ci/tracing-filter.md b/quest/m0/ci/tracing-filter.md new file mode 100644 index 00000000000..876c1778c7e --- /dev/null +++ b/quest/m0/ci/tracing-filter.md @@ -0,0 +1,16 @@ +# [XS] tracing-test stops forcing TRACE everywhere + +## Goal + +moq-tokio's tests no longer turn on `tracing-test`'s `no-env-filter` feature +for the whole build, so other crates' tests stop formatting every event at +TRACE, which costs 11 to 17% of the moq-tokio integration tests' CPU. + +## Plan + +Found by [moq-dev/moq#6987](https://github.com/moq-dev/moq/pull/6987)'s +profile. Cargo feature unification enables the feature for every crate that +shares the build. Narrow it to the tests that need it, or filter per test, +and measure the integration tests before and after. + +Public API: none. diff --git a/quest/m0/nightly/README.md b/quest/m0/nightly/README.md index a153222320e..b397af5bb21 100644 --- a/quest/m0/nightly/README.md +++ b/quest/m0/nightly/README.md @@ -34,3 +34,5 @@ Public API: none. Wire: none. - [moq-net compiles in Fuzz and send-depth](/quest/m0/nightly/send-overflow.md) - the ietf publisher future stops overflowing the Send check - [Probing beside Cubic](/quest/m0/nightly/competing-cubic.md) - the `competing_cubic` probe test stays within its deadline budget - [cargo deny passes](/quest/m0/nightly/cargo-deny.md) - Audit stops failing on the yanked crypto-bigint and moq-studio's egui licenses +- [Gate hang](/quest/m0/nightly/gate-hang.md) - the 2026-10-27 gate hang is fixed at its cause and the gate's output names a hung module +- [moq-quic rustdoc](/quest/m0/nightly/quic-rustdoc.md) - `--all-features` rustdoc for moq-quic builds and a lane checks it diff --git a/quest/m0/nightly/gate-hang.md b/quest/m0/nightly/gate-hang.md new file mode 100644 index 00000000000..afa65e89806 --- /dev/null +++ b/quest/m0/nightly/gate-hang.md @@ -0,0 +1,18 @@ +# [S] Nightly's gate names a hung module + +## Goal + +The test that hung the 2026-10-27 scheduled Nightly gate +([job](https://github.com/moq-dev/moq/actions/runs/40506938673/job/122198526371), +36 minutes with no output before the timeout) is found and fixed at its +cause, and the gate prints per-module progress with timestamps, so a future +hang names its module. + +## Plan + +Found by [moq-dev/moq#6991](https://github.com/moq-dev/moq/pull/6991)'s +replay. The gate buffers output per module, so the log cannot say which one +hung. Reproduce with `just gate`, then add the timestamps. Never a retry or +a longer timeout. + +Public API: none. diff --git a/quest/m0/nightly/quic-rustdoc.md b/quest/m0/nightly/quic-rustdoc.md new file mode 100644 index 00000000000..82546f2d50c --- /dev/null +++ b/quest/m0/nightly/quic-rustdoc.md @@ -0,0 +1,14 @@ +# [XS] moq-quic's all-features rustdoc builds + +## Goal + +`cargo doc -p moq-quic --all-features` succeeds; today it fails on +`SentPackets`, already broken on `main` before +[moq-dev/moq#6950](https://github.com/moq-dev/moq/pull/6950). + +## Plan + +Fix the doc build, and add the all-features rustdoc build to whichever lane +should have caught it. + +Public API: none. diff --git a/quest/m0/test-flakes-2/README.md b/quest/m0/test-flakes-2/README.md index 9df1c1b33da..cbd39033350 100644 --- a/quest/m0/test-flakes-2/README.md +++ b/quest/m0/test-flakes-2/README.md @@ -53,3 +53,4 @@ Public API: none. Wire: none. - [Swapped Rust to JS Opus](/quest/m0/test-flakes-2/swapped-js-opus.md) - the `rust-swapped -> js` interop cell stops timing out under load - [JS host-task yields follow the clock](/quest/m0/test-flakes-2/js-host-yields.md) - `Budget` and `nextTask` yield through the injected clock, so `Manual` tests stop racing them - [Runner VM test under load](/quest/m0/test-flakes-2/runner-vm.md) - the runner VM check passes when it rebuilds in a merge group, and a failed flake check prints its full log +- [Fake timers to Manual](/quest/m0/test-flakes-2/fake-timers.md) - the remaining bun fake-timer tests run on the `Manual` clock diff --git a/quest/m0/test-flakes-2/fake-timers.md b/quest/m0/test-flakes-2/fake-timers.md new file mode 100644 index 00000000000..308c83f8d4d --- /dev/null +++ b/quest/m0/test-flakes-2/fake-timers.md @@ -0,0 +1,18 @@ +# [M] JS tests drive time through Manual + +## Goal + +The remaining `@moq/net` and `@moq/hang` tests that use bun's fake timers run +on the `Manual` clock instead, so host-task yields cannot race them: forward, +the ietf and lite publisher and subscriber tests, integration, connect, and +hang's consumer startup. + +## Plan + +Follows [moq-dev/moq#6988](https://github.com/moq-dev/moq/pull/6988), which +made `Budget` yield through the clock and moved three tests. Bun's fake +timers cannot see a yield, so these pass today only because nothing yields +at the wrong moment. Prove each converted test still fails when its behavior +breaks, and that it passes with `Budget` forced to yield on every call. + +Public API: none. diff --git a/quest/m1/README.md b/quest/m1/README.md index f0c572d128b..ac73181689f 100644 --- a/quest/m1/README.md +++ b/quest/m1/README.md @@ -113,6 +113,9 @@ surface and zero-copy texture import, land before the cut. ## Required - [Resume checked against a model](/quest/m1/resume-model-test.md) - a randomized test checks every resumed reader against a one-track reference model in Rust and JS, and passes before the cut +- [Recover by the reader's budget](/quest/m1/recover-reader-budget.md) - resume judges a missing group by each reader's own budget, not the copy's +- [Rust resume release path](/quest/m1/resume-release-rust.md) - letting go of a replaced Rust copy never releases a group already moved to another +- [Slow joiner test](/quest/m1/slow-joiner-test.md) - a reader stalled before its first read loses no groups within its budget, under real stream backpressure - [Address groups by timestamp](/quest/m1/time-addressing/README.md) - group start timestamps replace sequence numbers in the moq-net API and lite-07 wire, while old subscribers, old publishers, and published JS clients keep working - [Release audit findings](/quest/m1/release-audit/README.md) - resolve newly identified resource, parser, playback, and interoperability risks before the cut - [Pre-cut audit findings](/quest/m1/cut-audit/README.md) - fix the crashes, hostile-input costs, and correctness bugs the 2026-10-24 audit of main found @@ -126,9 +129,11 @@ surface and zero-copy texture import, land before the cut. - [Subscribe ranges](/quest/m1/subscribe-ranges/README.md) - a lite-07 SUBSCRIBE asks for past and live ranges with absolute or relative ends, in either order, and replaces FETCH; merged ranges never starve a subscriber; relays fill misses by range, including over moq-transport - [Drop set](/quest/m1/drop-set.md) - each cursor judges missing groups against its own budget, so a narrow reader drops promptly and a widening re-offers groups already reported dropped on lite-07 - [Broadcast archives](/quest/m1/archive/README.md) - ANNOUNCE, TRACKS, and a SUBSCRIBE per track record every track under a prefix to any object_store, a host serves a stored broadcast back, and the catalog drops its archive pointer for an opt-in `hls` field +- [HLS recorder target](/quest/m1/hls-record-target.md) - the moq-cli HLS recorder takes its target duration from the declared `hls` duration - [Compressed tracks](/quest/m1/compress/README.md) - a track flagged `compress` is DEFLATEd per group by moq-net, forwarded compressed, and inflated once on the relay for peers that cannot signal it; `catalog.json.z` and moq-flate go away - [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 - [Moxygen minimal interop](/quest/m1/smoke-moxygen.md) - waiting on Moxygen to send a registered filter type, then the smoke lane stops hiding its failure +- [Smoke token subject](/quest/m1/smoke-token-subject.md) - condition: grant subject ships; then the release smoke test signs with `--subject` - [Moxygen pin bump](/quest/m1/moxygen-pin-bump.md) - waiting on moxygen#264, then the TRACK_STATUS patch is dropped - [Broadcast lifecycle](/quest/m1/broadcast-lifecycle/README.md) - broadcasts are online or offline with no finished state in moq-net, finished-broadcast retention is a fixed moq-mux policy, and each linger timer has one meaning - [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 @@ -137,6 +142,9 @@ surface and zero-copy texture import, land before the cut. - [Drop web-transport-trait](/quest/m1/drop-web-transport-trait.md) - iroh, wasm, and ffi implement moq-net's `transport::poll` traits, and the remaining `web_transport_trait` adapters are deleted - [On-demand JavaScript FETCH](/quest/m1/js-fetch-on-demand.md) - browser publishers answer IETF FETCH for evicted or uncached groups through the JS ranges request surface - [Rust FETCH parity](/quest/m1/ietf-fetch-parity.md) - Rust finishes an answered joining FETCH's head, refuses a lost head with DOES_NOT_EXIST, and sends no timestamps without TIMESCALE, as the JS publisher does +- [SUBSCRIBE honors the properties opt-out](/quest/m1/subscribe-timestamps.md) - Rust's SUBSCRIBE sends untimed objects when Track Properties are declined, and the Rust subscriber asks for them when it needs timestamps +- [JS FETCH timeout test](/quest/m1/js-fetch-timeout-test.md) - a JS joining FETCH still waiting on its SUBSCRIBE at the deadline is refused with TIMEOUT +- [Mock reset codes](/quest/m1/mock-reset-codes.md) - `js/net`'s mock transport carries only reset codes, and any reset found sending the wrong code is fixed - [IETF fill timeout](/quest/m1/ietf-fill-timeout.md) - Rust honors native FILL_TIMEOUT to bound upstream waiting on drafts 18 and 22, alongside local content-age enforcement - [JS FETCH fill timeout](/quest/m1/ietf-fill-timeout-js.md) - the JS FETCH responder honors FILL_TIMEOUT as Rust does - [Rust identity enforcement](/quest/m1/catalog-identity-rs.md) - `moq-mux` refuses a redefined rendition, and every Rust publisher mints a new rendition name for a decoder identity change and updates everything else in place @@ -165,6 +173,7 @@ surface and zero-copy texture import, land before the cut. - [Settled copies versus whole groups](/quest/m1/settled-copies.md) - every model check of whether a group is done means either a settled copy or the whole group, as it needs - [An HLS viewer starts capture](/quest/m1/hls-record-demand.md) - a record-track subscriber counts as demand for its rendition's media - [One moq-ffi build definition](/quest/m1/ffi-build-flags.md) - every binding takes moq-ffi's default features from one place +- [moqsrc max-delay](/quest/m1/gst-max-delay.md) - GStreamer's `moqsrc` takes a `max-delay` property instead of a hard-coded 1 s budget - [moq-clock moves into kio::clock](/quest/m1/kio-clock.md) - moq-clock and its test macro become `kio::clock` and `#[kio::test]` before the cut publishes them - [Poll-first async](/quest/m1/poll-first/README.md) - library crates compile no coroutines by default: async wrappers are generated from `poll_*` and gated behind an `async` feature diff --git a/quest/m1/bench-ci.md b/quest/m1/bench-ci.md index 5ab81546a52..9ffea2695bb 100644 --- a/quest/m1/bench-ci.md +++ b/quest/m1/bench-ci.md @@ -58,6 +58,10 @@ the hosted runners, so its noise is near zero, and it is free for open source. It does not measure syscalls, I/O, or contention, so the relay load, uring, transport, and session sweeps stay on the paired hosted comparison. +The A/A calibration includes moq-quic's windowed `benches/streams.rs` cases: +on a shared host the unchanged base alone varied 17 to 43% between +back-to-back runs ([moq-dev/moq#6950](https://github.com/moq-dev/moq/pull/6950)). + ## Related - [Benchmark reporting](/bench/README.md) - the paired comparison and the trend table diff --git a/quest/m1/c/README.md b/quest/m1/c/README.md index 979651893c3..af4cbf2d370 100644 --- a/quest/m1/c/README.md +++ b/quest/m1/c/README.md @@ -30,3 +30,4 @@ Public API: moq-c gains each m1 binding feature. Wire: none. ## Required - [moq-c decode start](/quest/m1/c/decode-start.md) - a moq-c decoder can read a finished track from its start +- [JSON windows](/quest/m1/c/json-window.md) - moq-c publishes and reads moq-json windows, as moq-ffi does diff --git a/quest/m1/c/json-window.md b/quest/m1/c/json-window.md new file mode 100644 index 00000000000..8ba8be2e680 --- /dev/null +++ b/quest/m1/c/json-window.md @@ -0,0 +1,16 @@ +# [M] moq-c JSON window producer and consumer + +## Goal + +moq-c publishes and reads moq-json windows, as moq-ffi does, with tests and +`doc/lib/c`. + +## Plan + +Found by [moq-dev/moq#6946](https://github.com/moq-dev/moq/pull/6946). The +maintainer decided on 2026-10-25 that the hand-written moq-c ships at this +cut with parity with moq-ffi for every m1 binding feature, and windows are +the gap left. Mirror moq-ffi's window API and its timestamp handling +(nullable `const moq_timestamp *`). + +Public API: new moq-c functions. Wire: none. diff --git a/quest/m1/cluster-routing/routes.md b/quest/m1/cluster-routing/routes.md index 196cb21d5f0..ed53de17a42 100644 --- a/quest/m1/cluster-routing/routes.md +++ b/quest/m1/cluster-routing/routes.md @@ -666,6 +666,16 @@ mints at its own time, so mint order outranks cost, preference, and the local-broadcast tie and relays disagree on a pool path's winner, while ranking a minted epoch last keeps the renewal it was meant to delete. +Decided 2026-10-27 (maintainer), from +[grant subject](https://github.com/moq-dev/moq/pull/6992): decide what key +identities are filed under for sessions allowed to publish part of the tree +with no subject (public rules, mTLS certificates, or a third-party auth +server), and whether the relay refuses such a grant when the client +presented a token. Also from +[moq-dev/moq#6947](https://github.com/moq-dev/moq/pull/6947): in `js/net`'s +`origin.ts` a detached request stays on its own route instead of following +the cheapest one; fix it with the route-selection rework here. + ## Required - [Grant subject](/quest/m1/cluster-routing/grant-subject.md) - the issuer-qualified subject scoped identities are filed under diff --git a/quest/m1/gst-max-delay.md b/quest/m1/gst-max-delay.md new file mode 100644 index 00000000000..c283c24cd71 --- /dev/null +++ b/quest/m1/gst-max-delay.md @@ -0,0 +1,18 @@ +# [S] moqsrc takes a max-delay + +## Goal + +GStreamer's `moqsrc` has a `max-delay` element property (default 1 s, today's +hard-coded value) that sets every track's delay budget, and `interop.sh` +sets it to 5 s as the other interop readers allow. + +## Plan + +Decided 2026-10-27 (maintainer): a property, not a budget derived from the +track's max-age, since the budget is a latency tradeoff the viewer chooses +and publishers keep 30 s of max-age. Found by +[moq-dev/moq#6990](https://github.com/moq-dev/moq/pull/6990): a starved +GStreamer subscriber fails the gap check with no way to widen it +(`rs/moq-gst/src/source/imp.rs`). Update `doc/bin/gstreamer.md`. + +Public API: a new `moqsrc` property. Wire: none. diff --git a/quest/m1/hls-record-target.md b/quest/m1/hls-record-target.md new file mode 100644 index 00000000000..5fa1a91e562 --- /dev/null +++ b/quest/m1/hls-record-target.md @@ -0,0 +1,17 @@ +# [XS] The moq-cli HLS recorder uses the declared target + +## Goal + +The `moq-cli` HLS recorder sets `EXT-X-TARGETDURATION` from the declared `hls` +duration, as the exporter does since +[moq-dev/moq#7018](https://github.com/moq-dev/moq/pull/7018), so a recording +written live keeps one target instead of rewriting its header as segments +grow. + +## Plan + +Today `Playlist::push` in `rs/moq-cli/src/hls/record.rs` takes the longest +segment seen so far, rounded up. Follow that PR's overrun rule: list the +segment anyway and warn. + +Public API: none. diff --git a/quest/m1/js-fetch-timeout-test.md b/quest/m1/js-fetch-timeout-test.md new file mode 100644 index 00000000000..7075207d966 --- /dev/null +++ b/quest/m1/js-fetch-timeout-test.md @@ -0,0 +1,15 @@ +# [XS] JS joining FETCH times out a pending SUBSCRIBE + +## Goal + +A test shows that a JS joining FETCH whose SUBSCRIBE is still being set up +at the 10 s request deadline is refused with TIMEOUT. + +## Plan + +[moq-dev/moq#6945](https://github.com/moq-dev/moq/pull/6945) added the wait +but left this path untested, for lack of a way to hold a subscription +pending in a test. Hold the SUBSCRIBE in setup with a publisher-side hook that never answers, +and drive the deadline on the `Manual` clock. + +Public API: none. diff --git a/quest/m1/mock-reset-codes.md b/quest/m1/mock-reset-codes.md new file mode 100644 index 00000000000..e3d7f65675f --- /dev/null +++ b/quest/m1/mock-reset-codes.md @@ -0,0 +1,23 @@ +# [M] The JS mock transport carries only reset codes + +## Goal + +`js/net`'s mock transport delivers a stream reset to the peer as a code, as +real WebTransport does (0 for a plain `Error`), instead of the local reason +object. Every test that relied on a reason a real wire cannot carry is +fixed, and so is any reset that would go out with the wrong code. + +## Plan + +Found by [moq-dev/moq#6988](https://github.com/moq-dev/moq/pull/6988). A +cancel hook on the mock's TransformStream works in bun and node but makes +`abort()` reject; wrapping the read side does not. Either breaks 9 tests: + +- 4 ietf publisher draft-22 tests expect "unsubscribed" or "range update", + which suggests those resets go out as INTERNAL_ERROR on a real wire and + should be CANCELLED. Reproduce against a real peer and fix the code at the + publisher. +- 2 lite publisher tests and 3 reload/connect setup tests check reasons a + real wire cannot carry; assert on what the peer can observe. + +Public API: none. Wire: any reset found sending the wrong code is corrected. diff --git a/quest/m1/recover-reader-budget.md b/quest/m1/recover-reader-budget.md new file mode 100644 index 00000000000..ed105b26eb5 --- /dev/null +++ b/quest/m1/recover-reader-budget.md @@ -0,0 +1,17 @@ +# [S] Recover judges a miss by the reader's own budget + +## Goal + +When resume decides whether a missing group is still coming, it judges by +the reader's own budget, not the copy's combined one, in Rust and `@moq/net`. +Right after a failover, a short-budget reader no longer settles a group for +an hour-budget reader sharing the copy. + +## Plan + +Found by [moq-dev/moq#6947](https://github.com/moq-dev/moq/pull/6947)'s model +test, which never triggered it once routes answered fetches. Reproduce it +with a fixed case first, then extend the model test so a random sweep can +hit it. + +Public API: none. Wire: none. diff --git a/quest/m1/resume-release-rust.md b/quest/m1/resume-release-rust.md new file mode 100644 index 00000000000..0cb835b83c5 --- /dev/null +++ b/quest/m1/resume-release-rust.md @@ -0,0 +1,16 @@ +# [S] Rust resume never releases a moved group + +## Goal + +Letting go of a replaced copy in Rust resume never releases a group already +moved to another copy, so that group never ends cleanly with frames missing. +A test proves it either way. + +## Plan + +[moq-dev/moq#6947](https://github.com/moq-dev/moq/pull/6947) fixed this in +`@moq/net`, found by its model test. Rust's sweeps pass, but nobody checked +whether Rust has the same release path. Write the fixed case from that JS +fix against Rust; if it fails, fix it at the cause. + +Public API: none. diff --git a/quest/m1/slow-joiner-test.md b/quest/m1/slow-joiner-test.md new file mode 100644 index 00000000000..f7b1f940868 --- /dev/null +++ b/quest/m1/slow-joiner-test.md @@ -0,0 +1,17 @@ +# [S] A slow joiner loses no groups within its budget + +## Goal + +A test drives a reader that stalls before its first read, over a transport +with real stream-credit backpressure, and shows the relay drops none of the +groups its budget covers. + +## Plan + +Found by [moq-dev/moq#6990](https://github.com/moq-dev/moq/pull/6990): a +live-edge audio join subscribed with only its decoder warmup as its budget, +so a C reader starved before its first read lost its queued groups at the +relay. That PR's unit test checks the subscribe budget, not the relay path. +Use moq-net's mock harness with a capped stream count and mock time. + +Public API: none. diff --git a/quest/m1/smoke-token-subject.md b/quest/m1/smoke-token-subject.md new file mode 100644 index 00000000000..1837a8ad5ae --- /dev/null +++ b/quest/m1/smoke-token-subject.md @@ -0,0 +1,17 @@ +# [XS] The release smoke test signs with a subject + +## Goal + +Condition: the first release carrying +[grant subject](https://github.com/moq-dev/moq/pull/6992) is published. +Check that the published CLI's `auth sign --help` lists `--subject`. Then +`test/smoke/token.sh` passes `--subject` when signing its scoped publish +token, and this quest is deleted. + +## Plan + +The published CLIs reject unknown flags, so the smoke test cannot take +`--subject` before the release, and a scoped publish token without a subject +is refused once the release ships. + +Public API: none. diff --git a/quest/m1/subscribe-timestamps.md b/quest/m1/subscribe-timestamps.md new file mode 100644 index 00000000000..eebabb9d138 --- /dev/null +++ b/quest/m1/subscribe-timestamps.md @@ -0,0 +1,25 @@ +# [S] Rust SUBSCRIBE honors the Track Properties opt-out + +## Goal + +A moq-transport SUBSCRIBE that opts out of Track Properties +(INCLUDE_PROPERTIES `0`) gets no TIMESCALE and untimed objects from the Rust +publisher, as from the JS publisher and as Rust FETCH already does +([moq-dev/moq#6999](https://github.com/moq-dev/moq/pull/6999)). The Rust +subscriber asks for properties whenever it needs timestamps, so it reads a +timed track timed from either publisher. + +## Plan + +Decided 2026-10-27 (maintainer): one rule for both publishers and both +request kinds. Today the Rust subscriber opts out on some SUBSCRIBEs +(`properties_wanted: matches!(target, Target::Request(_))` in +`rs/moq-net/src/ietf/subscriber.rs`) and still expects timestamps, so a JS +publisher would hand it untimed objects on a timed track. Fix the subscriber +first, then the publisher. Land after +[lite-05/06 timestamps](https://github.com/moq-dev/moq/pull/6996), which +changes how moq-transport tracks are stamped. + +Test both directions against JS in `just test interop --all`. + +Public API: none. Wire: the Rust publisher omits timestamps when asked to. diff --git a/quest/m2/perf/README.md b/quest/m2/perf/README.md index 67fe89ec339..84841de7ae9 100644 --- a/quest/m2/perf/README.md +++ b/quest/m2/perf/README.md @@ -89,3 +89,7 @@ revisions on the same host and worker count, and profiles with - [Shard by default](/quest/m2/perf/shard-default.md) - a saturating shard sweep decides whether an unset `runtime.workers` runs one worker per core on Linux - [Profile the io_uring clock read](/quest/m2/perf/uring-clock-profile.md) - a `perf` profile shows whether #5926's per-turn clock read cut the io_uring relay's `[vdso]` share and CPU - [io_uring buffer pool memory](/quest/m2/perf/uring-pool-memory.md) - measure reserved versus resident pool memory before any shrink policy +- [An idle export poll is cheap](/quest/m2/perf/export-idle-poll.md) - an export poll nothing woke skips the track fill and catalog work it repeats today +- [Mesh session cost](/quest/m2/perf/mesh-session-cost.md) - moq-net's per-session announce, route sync, and scope work drops, swept over sessions and announces +- [Lite request allocations](/quest/m2/perf/lite-request-allocs.md) - `Path::concat` allocates once and the lite request handler keeps one track-name copy +- [Coverage before START](/quest/m2/perf/covered-before-start.md) - the lite-07 publisher's coverage check costs O(1) per wake before SUBSCRIBE_START diff --git a/quest/m2/perf/covered-before-start.md b/quest/m2/perf/covered-before-start.md new file mode 100644 index 00000000000..fe6e6c8339d --- /dev/null +++ b/quest/m2/perf/covered-before-start.md @@ -0,0 +1,16 @@ +# [S] Lite coverage checks before START are cheap + +## Goal + +Before SUBSCRIBE_START, the lite-07 publisher's `track::Subscriber::covered` +check stops rebuilding a set from everything skipped on every wake, so a wake +costs O(1) instead of O(skipped). + +## Plan + +Found by [moq-dev/moq#6995](https://github.com/moq-dev/moq/pull/6995), which +made `covered` incremental after the start resolves. Keep the skipped record +incremental from the first wake too, and cover it in the +`track_range_filling` benchmark. + +Public API: none. diff --git a/quest/m2/perf/export-idle-poll.md b/quest/m2/perf/export-idle-poll.md new file mode 100644 index 00000000000..08f46d9152a --- /dev/null +++ b/quest/m2/perf/export-idle-poll.md @@ -0,0 +1,15 @@ +# [M] An export poll nothing woke is cheap + +## Goal + +A container export poll that no new data woke costs little: today about 24% +of each poll is moq-net track fill and 11 to 19% is catalog polling. A +benchmark shows the idle poll's cost, before and after. + +## Plan + +Found by [moq-dev/moq#6987](https://github.com/moq-dev/moq/pull/6987)'s +profile of the moq-mux TS export tests. It helps those tests and production +exports alike. Profile first, then cut the work an idle poll repeats. + +Public API: none expected. diff --git a/quest/m2/perf/lite-request-allocs.md b/quest/m2/perf/lite-request-allocs.md new file mode 100644 index 00000000000..387fb2da476 --- /dev/null +++ b/quest/m2/perf/lite-request-allocs.md @@ -0,0 +1,20 @@ +# [S] Fewer allocations on the lite request path + +## Goal + +`Path::concat`, and so `Path::join`, allocates once for a result over 22 +bytes instead of twice, and the lite request handler keeps one copy of the +track name instead of two. Allocation-counting tests show the drop. + +## Plan + +Found by [moq-dev/moq#6952](https://github.com/moq-dev/moq/pull/6952): + +- `Path::concat` builds a `String`, then copies it into the `Arc`. + Build it on the stack the way `from_tuple` does. +- The lite request serve copies the track name into the owned message and + again into its log context in `RequestServe::track`. + +Extend `rs/moq-net-tests/tests/announce_allocs.rs`. + +Public API: none. diff --git a/quest/m2/perf/mesh-session-cost.md b/quest/m2/perf/mesh-session-cost.md new file mode 100644 index 00000000000..c0242e697e5 --- /dev/null +++ b/quest/m2/perf/mesh-session-cost.md @@ -0,0 +1,17 @@ +# [M] Mesh session cost + +## Goal + +moq-net's per-session cost in the random-mesh tests drops, measured by a +benchmark swept over sessions and announces: announce handling, +`sync_route`/`requests_route`, `OriginScope::relative` rebuilding its +patterns on every call, and per-session setup (about 25%). + +## Plan + +Found by [moq-dev/moq#6987](https://github.com/moq-dev/moq/pull/6987)'s +profile of the moq-net mesh tests (8.4 s, barely changed there because the +cost is production code). Cache `OriginScope::relative`'s patterns first; +benchmark before changing the rest. + +Public API: none expected. From 58bd95db55d07a8db48c6cb2360e56e3e306f22d Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 27 Oct 2026 23:06:20 -0700 Subject: [PATCH 2/2] chore(quest): sharpen follow-up quests per review Co-Authored-By: Claude Opus 5.5 --- quest/m0/ci/recovery-clips.md | 11 +++++++---- quest/m0/nightly/quic-rustdoc.md | 6 ++++-- quest/m0/test-flakes-2/fake-timers.md | 6 ++++-- quest/m1/README.md | 2 +- quest/m2/perf/covered-before-start.md | 16 ++++++++++------ 5 files changed, 26 insertions(+), 15 deletions(-) diff --git a/quest/m0/ci/recovery-clips.md b/quest/m0/ci/recovery-clips.md index d77d51fe2ed..9548d429ddd 100644 --- a/quest/m0/ci/recovery-clips.md +++ b/quest/m0/ci/recovery-clips.md @@ -2,16 +2,19 @@ ## Goal -`recovery_test`'s FFmpeg clips are encoded once per test run instead of once -per test process, cutting the 35 to 40% of its CPU that FFmpeg encode and -decode take today, with every case and its coverage kept. +`recovery_test`'s FFmpeg clips, and the reference frames decoded from them, +are produced once per test run instead of once per test process, with every +case and its coverage kept. FFmpeg encode and decode together take 35 to 40% +of its CPU today; the PR reports how much of that each part saved. ## Plan Found by [moq-dev/moq#6987](https://github.com/moq-dev/moq/pull/6987)'s profile of the slowest tests. Pick one of: committing the clips (about 320 KB each), generating them in a nextest setup script, or caching them under a -lock keyed by the FFmpeg version. Measure it the way that PR measured its cohort, on the same machine before +lock keyed by the FFmpeg version. Reusing the encoded clip alone leaves the +per-process reference decode, so share the decoded reference data the same +way or report the encode-only saving. Measure it the way that PR measured its cohort, on the same machine before and after. Public API: none. diff --git a/quest/m0/nightly/quic-rustdoc.md b/quest/m0/nightly/quic-rustdoc.md index 82546f2d50c..837ceba890f 100644 --- a/quest/m0/nightly/quic-rustdoc.md +++ b/quest/m0/nightly/quic-rustdoc.md @@ -8,7 +8,9 @@ ## Plan -Fix the doc build, and add the all-features rustdoc build to whichever lane -should have caught it. +Fix the doc build. The gate's Rust lint builds workspace rustdoc without +`--all-features`, and `rs doctest` runs `cargo test --doc`, so nothing builds +this. Add `cargo doc -p moq-quic --all-features` to Nightly's feature lane +(`just rs features`), and name the lane in the PR. Public API: none. diff --git a/quest/m0/test-flakes-2/fake-timers.md b/quest/m0/test-flakes-2/fake-timers.md index 308c83f8d4d..7e146bad187 100644 --- a/quest/m0/test-flakes-2/fake-timers.md +++ b/quest/m0/test-flakes-2/fake-timers.md @@ -12,7 +12,9 @@ hang's consumer startup. Follows [moq-dev/moq#6988](https://github.com/moq-dev/moq/pull/6988), which made `Budget` yield through the clock and moved three tests. Bun's fake timers cannot see a yield, so these pass today only because nothing yields -at the wrong moment. Prove each converted test still fails when its behavior -breaks, and that it passes with `Budget` forced to yield on every call. +at the wrong moment. Each converted test installs its `Manual` clock and +restores the ambient clock when it finishes, as the existing `Manual` tests +do, so no fake clock leaks into the next test. Prove each converted test +still fails when its behavior breaks, and that it passes with `Budget` forced to yield on every call. Public API: none. diff --git a/quest/m1/README.md b/quest/m1/README.md index ac73181689f..53092bac347 100644 --- a/quest/m1/README.md +++ b/quest/m1/README.md @@ -142,7 +142,7 @@ surface and zero-copy texture import, land before the cut. - [Drop web-transport-trait](/quest/m1/drop-web-transport-trait.md) - iroh, wasm, and ffi implement moq-net's `transport::poll` traits, and the remaining `web_transport_trait` adapters are deleted - [On-demand JavaScript FETCH](/quest/m1/js-fetch-on-demand.md) - browser publishers answer IETF FETCH for evicted or uncached groups through the JS ranges request surface - [Rust FETCH parity](/quest/m1/ietf-fetch-parity.md) - Rust finishes an answered joining FETCH's head, refuses a lost head with DOES_NOT_EXIST, and sends no timestamps without TIMESCALE, as the JS publisher does -- [SUBSCRIBE honors the properties opt-out](/quest/m1/subscribe-timestamps.md) - Rust's SUBSCRIBE sends untimed objects when Track Properties are declined, and the Rust subscriber asks for them when it needs timestamps +- [SUBSCRIBE honors the properties opt-out](/quest/m1/subscribe-timestamps.md) - the Rust publisher sends untimed objects to a SUBSCRIBE that declines Track Properties, and the Rust subscriber asks for them when it needs timestamps - [JS FETCH timeout test](/quest/m1/js-fetch-timeout-test.md) - a JS joining FETCH still waiting on its SUBSCRIBE at the deadline is refused with TIMEOUT - [Mock reset codes](/quest/m1/mock-reset-codes.md) - `js/net`'s mock transport carries only reset codes, and any reset found sending the wrong code is fixed - [IETF fill timeout](/quest/m1/ietf-fill-timeout.md) - Rust honors native FILL_TIMEOUT to bound upstream waiting on drafts 18 and 22, alongside local content-age enforcement diff --git a/quest/m2/perf/covered-before-start.md b/quest/m2/perf/covered-before-start.md index fe6e6c8339d..d7348da88eb 100644 --- a/quest/m2/perf/covered-before-start.md +++ b/quest/m2/perf/covered-before-start.md @@ -2,15 +2,19 @@ ## Goal -Before SUBSCRIBE_START, the lite-07 publisher's `track::Subscriber::covered` -check stops rebuilding a set from everything skipped on every wake, so a wake -costs O(1) instead of O(skipped). +Before SUBSCRIBE_START, the lite-07 publisher's coverage check stops +rebuilding a `RangeSet` from every skipped range and rescanning the covered +runs on each wake. A wake costs work proportional to what changed since the +last one, not to the skipped record's size. ## Plan Found by [moq-dev/moq#6995](https://github.com/moq-dev/moq/pull/6995), which -made `covered` incremental after the start resolves. Keep the skipped record -incremental from the first wake too, and cover it in the -`track_range_filling` benchmark. +made `covered` incremental after the start resolves. `self.skipped` is already +updated incrementally; the cost is the set rebuilt from it and the scan in +`track::Subscriber::covered`. Keep an incremental coverage summary or cursor +across wakes instead. `track_range_filling` never builds a `TrackRun` or +reaches this branch, so add a benchmark that drives the lite publisher with +no start resolved, swept over skipped ranges. Public API: none.