diff --git a/quest/m0/ci/README.md b/quest/m0/ci/README.md index 6f38961cc80..700b5b7d160 100644 --- a/quest/m0/ci/README.md +++ b/quest/m0/ci/README.md @@ -134,3 +134,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..9548d429ddd --- /dev/null +++ b/quest/m0/ci/recovery-clips.md @@ -0,0 +1,20 @@ +# [S] Recovery test clips encode once per run + +## Goal + +`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. 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/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 9624de38752..24217fdbd4e 100644 --- a/quest/m0/nightly/README.md +++ b/quest/m0/nightly/README.md @@ -34,3 +34,4 @@ 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 - [Gate stops hanging](/quest/m0/nightly/gate-hang.md) - `just gate` finishes instead of hanging to the timeout, and a hang names its 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/quic-rustdoc.md b/quest/m0/nightly/quic-rustdoc.md new file mode 100644 index 00000000000..837ceba890f --- /dev/null +++ b/quest/m0/nightly/quic-rustdoc.md @@ -0,0 +1,16 @@ +# [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. 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/README.md b/quest/m0/test-flakes-2/README.md index c76d5928ec6..095b1197167 100644 --- a/quest/m0/test-flakes-2/README.md +++ b/quest/m0/test-flakes-2/README.md @@ -52,3 +52,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 - [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 +- [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..7e146bad187 --- /dev/null +++ b/quest/m0/test-flakes-2/fake-timers.md @@ -0,0 +1,20 @@ +# [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. 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 e441562ba78..3f93058e5c5 100644 --- a/quest/m1/README.md +++ b/quest/m1/README.md @@ -119,6 +119,9 @@ removed). ## 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 @@ -132,9 +135,11 @@ removed). - [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 a per-rendition `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 - [Upgrade notes match the code](/quest/m1/upgrade-guide-facts.md) - the upgrade and CLI migration guides stop promising drafts 19-21, capped grants, and an ignored `MOQ_EPOCH` @@ -144,6 +149,9 @@ removed). - [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) - 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 - [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 @@ -171,6 +179,7 @@ removed). - [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 - [JS SETUP rejection ownership](/quest/m1/js-setup-rejection.md) - reproduce an unhandled version-refusal rejection without weakening the refusal - [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 f59cb24b1ae..aed589209c5 100644 --- a/quest/m2/perf/README.md +++ b/quest/m2/perf/README.md @@ -90,4 +90,8 @@ 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 - [io_uring demux churn](/quest/m2/perf/uring-demux-churn.md) - the demux snapshots stats and builds its fed list once per completion, not per datagram diff --git a/quest/m2/perf/covered-before-start.md b/quest/m2/perf/covered-before-start.md new file mode 100644 index 00000000000..d7348da88eb --- /dev/null +++ b/quest/m2/perf/covered-before-start.md @@ -0,0 +1,20 @@ +# [S] Lite coverage checks before START are cheap + +## Goal + +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. `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. 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.