From 1a554d2c1f53621255cd09af29e8b861310a99b6 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 21 Oct 2026 09:30:43 -0700 Subject: [PATCH] quest: plan follow-ups from the m0/m1 spawn run Twenty-five new quests (sixteen m1, nine m2) and Plan edits to pmt-lifecycle, resume-datagrams, and subscribe-ranges/dynamic, as settled in the 2026-10-21 /quest-plan interview. Co-Authored-By: Claude Opus 5.5 --- quest/m1/README.md | 12 ++++++ quest/m1/audio-devices-arm.md | 22 ++++++++++ quest/m1/auth/README.md | 1 + quest/m1/auth/bindings-polish.md | 37 +++++++++++++++++ quest/m1/binding-check-cost.md | 29 ++++++++++++++ quest/m1/ci-housekeeping.md | 33 +++++++++++++++ quest/m1/goaway-deadline.md | 24 +++++++++++ quest/m1/ietf-extension/README.md | 1 + quest/m1/ietf-extension/serve-timed.md | 31 ++++++++++++++ quest/m1/interop-finish.md | 27 +++++++++++++ quest/m1/js-parked-expiry.md | 28 +++++++++++++ quest/m1/js-reload-userinfo.md | 20 ++++++++++ quest/m1/js-start-parity.md | 21 ++++++++++ quest/m1/net-internals.md | 31 ++++++++++++++ quest/m1/quic-silent-peer-drain.md | 33 +++++++++++++++ quest/m1/resume-datagrams.md | 8 ++++ quest/m1/resume-rust-end.md | 40 +++++++++++++++++++ quest/m1/smoke-dependabot.md | 27 +++++++++++++ quest/m1/subscribe-ranges/dynamic.md | 3 ++ quest/m1/test-flakes-2/README.md | 5 +++ quest/m1/test-flakes-2/three-flakes.md | 34 ++++++++++++++++ quest/m1/ts-reliability/README.md | 1 + quest/m1/ts-reliability/pmt-lifecycle.md | 3 ++ .../release-clock-false-alarms.md | 34 ++++++++++++++++ quest/m2/README.md | 9 +++++ quest/m2/bench-transport-sweep.md | 25 ++++++++++++ quest/m2/drop-dead-items.md | 24 +++++++++++ quest/m2/from-str-trait.md | 20 ++++++++++ quest/m2/go-first-dial-failure.md | 26 ++++++++++++ quest/m2/ietf-lazy-discovery.md | 32 +++++++++++++++ quest/m2/ietf-request-order.md | 33 +++++++++++++++ quest/m2/js-request-stream.md | 25 ++++++++++++ quest/m2/keyed-prefix-polling.md | 28 +++++++++++++ quest/m2/lite-legacy-gap.md | 25 ++++++++++++ 34 files changed, 752 insertions(+) create mode 100644 quest/m1/audio-devices-arm.md create mode 100644 quest/m1/auth/bindings-polish.md create mode 100644 quest/m1/binding-check-cost.md create mode 100644 quest/m1/ci-housekeeping.md create mode 100644 quest/m1/goaway-deadline.md create mode 100644 quest/m1/ietf-extension/serve-timed.md create mode 100644 quest/m1/interop-finish.md create mode 100644 quest/m1/js-parked-expiry.md create mode 100644 quest/m1/js-reload-userinfo.md create mode 100644 quest/m1/js-start-parity.md create mode 100644 quest/m1/net-internals.md create mode 100644 quest/m1/quic-silent-peer-drain.md create mode 100644 quest/m1/resume-rust-end.md create mode 100644 quest/m1/smoke-dependabot.md create mode 100644 quest/m1/test-flakes-2/three-flakes.md create mode 100644 quest/m1/ts-reliability/release-clock-false-alarms.md create mode 100644 quest/m2/bench-transport-sweep.md create mode 100644 quest/m2/drop-dead-items.md create mode 100644 quest/m2/from-str-trait.md create mode 100644 quest/m2/go-first-dial-failure.md create mode 100644 quest/m2/ietf-lazy-discovery.md create mode 100644 quest/m2/ietf-request-order.md create mode 100644 quest/m2/js-request-stream.md create mode 100644 quest/m2/keyed-prefix-polling.md create mode 100644 quest/m2/lite-legacy-gap.md diff --git a/quest/m1/README.md b/quest/m1/README.md index 8e3a843bafe..725825dfcdf 100644 --- a/quest/m1/README.md +++ b/quest/m1/README.md @@ -86,9 +86,11 @@ lands before the cut. - [Publish channel count](/quest/m1/publish-audio-channel-count.md) - forcing a channel count on an Audio.Capture stops costing the subscriber gaps of silence, and the media fixture's cold-start audio-tone flake is fixed at its cause - [Relay signal install](/quest/m1/relay-signal-install.md) - a shutdown signal after the relay starts serving drains it, without leaking handlers into an embedder whose startup failed - [Rust redirect loops](/quest/m1/tokio-redirect-loop.md) - moq-tokio escalates its backoff when GOAWAY redirects bounce between peers, as JS does +- [JS redirect keys strip userinfo](/quest/m1/js-reload-userinfo.md) - js/net keys a reconnect endpoint without URL userinfo, matching Rust - [Container reads drop backfill](/quest/m1/read-backfill.md) - the JS container consumer drops groups below its read cursor like Rust - [Rust request credit](/quest/m1/rs-request-credit.md) - a moq-net request fails at once without stream credit instead of waiting - [A stalled subscriber holds bounded state](/quest/m1/egress-held-state.md) - group machines and bytes a credit-withholding downstream makes a publisher hold plateau at what its credit and the latency budget allow, on lite and moq-transport +- [A parked JS stream open gives up](/quest/m1/js-parked-expiry.md) - a js/net publisher's pending stream open ends when its group expires or is evicted - [qmux no-wait opens](/quest/m1/qmux-no-wait.md) - the in-tree @moq/qmux rejects an over-limit create when waitUntilAvailable is false, like Chrome - [TS fidelity and recovery](/quest/m1/ts-reliability/README.md) - both modes have explicit profiles, automated validation, loss tests, and a dedicated guide - [A widened max age re-offers cached groups](/quest/m1/resolved-demand.md) - a warm relay serves a reader with a wider max age the cached groups a cold relay would, with no wire change @@ -96,23 +98,33 @@ lands before the cut. - [Resumed close](/quest/m1/resume-closed.md) - a resumed JS track keeps its declared end across copies, and its `closed` and `largest()` settle on a clean end - [Resume through an outage](/quest/m1/resume-outage.md) - a same-epoch resume after an unclosed route dies delivers the backlog its max age still holds, pinned by a regression test - [Resumed datagrams](/quest/m1/resume-datagrams.md) - a resumed track skips only datagrams it already delivered, not every lower sequence +- [Rust resume holds a declared end](/quest/m1/resume-rust-end.md) - a resumed Rust track keeps a declared end across copies, dedupes flapping copies, and judges retention inside the reader's window +- [JS answers SUBSCRIBE_START like Rust](/quest/m1/js-start-parity.md) - a JS publisher's START names where its backlog starts, not its newest group - [Received timestamps are media time](/quest/m1/lite-time-provenance.md) - a received timed track's timestamps are media time, so the rewind check can run across hops - [WebGPU on Safari](/quest/m1/webgpu-safari.md) - the WebGPU renderer is verified on Safari 26 for macOS and iOS - [A failed HLS export answers with an error](/quest/m1/hls-failure-signal.md) - playlists answer a no-store 5xx once their timeline fails, and so does the DASH manifest for a shared reference failure, so a truncated recording never looks complete - [Close tail drain](/quest/m1/close-tail-drain.md) - after a peer close, subscribers read the group streams their transport already delivered instead of aborting them, so a finished tail arrives on every version +- [GOAWAY deadline](/quest/m1/goaway-deadline.md) - the drain deadline counts from the trigger in moq-net and js/net, so a peer that stops reading cannot stall it +- [Silent-peer close](/quest/m1/quic-silent-peer-drain.md) - moq-quic closes a connection that never heard its peer without the 3 s drain - [Binding linger](/quest/m1/linger-ffi.md) - `moq-ffi` and every binding finish a broadcast cleanly, so subscribers drain it until its media is stale - [JS linger](/quest/m1/linger-js.md) - `js/net` finishes a broadcast cleanly like Rust, and `@moq/publish` uses it when a source stops - [GStreamer linger](/quest/m1/linger-gst.md) - `moq-gst` sinks finish their broadcast at end of stream instead of closing it - [Gateway linger](/quest/m1/linger-gateways.md) - HLS, RTMP, SRT and RTC imports linger at a clean end, cut short by a newer epoch at the same path +- [Interop finish](/quest/m1/interop-finish.md) - the interop matrix proves a clean broadcast finish across implementations - [Exporters follow a rendition to a new track](/quest/m1/export-rendition-rebind.md) - the fMP4, TS, MKV and FLV exporters rebuild a rendition whose resolved `track` or `broadcast` changes under the same ID - [lite-06 max sequence](/quest/m1/lite06-max-sequence.md) - group sequence 2^62-1 reaches a lite-06 subscriber or is refused loudly, instead of vanishing - [Track live signal](/quest/m1/track-live.md) - a reader can wait for its track's feed to be live, so a player skips old cached groups while a fresh upstream subscription starts - [Binding docs](/quest/m1/docs-bindings.md) - every public moq-ffi and moq-c item has rustdoc, carried into the generated bindings and `moq.h` - [C++ and OBS package proof](/quest/m1/cpp-package-check.md) - the installed artifacts pass before their first release +- [Binding check cost](/quest/m1/binding-check-cost.md) - `moq.cpp` compiles once per C++ standard and Gradle stays warm, measured before and after +- [Audio devices on ARM](/quest/m1/audio-devices-arm.md) - `just rs audio-devices` passes on the hosted ARM runner +- [CI housekeeping](/quest/m1/ci-housekeeping.md) - queue nextest at 24 threads, stale Pages artifacts cleared, the actionlint ignore dropped +- [Smoke flake bumps](/quest/m1/smoke-dependabot.md) - `test/smoke/flake.lock` bumps with its Playwright pin, automated or documented - [moq-net compiles once](/quest/m1/net-erase-transport.md) - the session drivers stop monomorphizing per transport and per crate, saving several MiB of the relay, FFI library, `libmoq` and CLI +- [moq-net internals](/quest/m1/net-internals.md) - no per-group session clones, no transport type parameter in lite and IETF internals, and the `Local` check measured - [Dead code and API surface audit](/quest/m1/audit-dead-code.md) - repeat the removal audit before the next major release - [Dependency and alternatives audit](/quest/m1/audit-deps.md) - dependencies are current, deduplicated, needed, and the best maintained option diff --git a/quest/m1/audio-devices-arm.md b/quest/m1/audio-devices-arm.md new file mode 100644 index 00000000000..a3a12067609 --- /dev/null +++ b/quest/m1/audio-devices-arm.md @@ -0,0 +1,22 @@ +# [S] Audio device tests pass on ARM + +## Goal + +`just rs audio-devices` passes on the hosted ARM runner, as it does on +x86_64 Linux, so its nightly lane is a signal rather than a known red. + +## Plan + +The recipe first ran nightly on 2026-10-20 and failed all five playback +tests on ARM; nothing owned it +([moq-dev/moq#6155](https://github.com/moq-dev/moq/pull/6155)). +[moq-dev/moq#6175](https://github.com/moq-dev/moq/pull/6175) then fixed +PulseAudio's 20 ms playback period for these tests. Check a nightly after +#6175 first: if ARM passes, delete this quest. Otherwise reproduce on ARM +and fix the cause, not the timing. + +Public API: none. Wire: none. + +## Related + +- [PulseAudio capture periods](/quest/m2/pulseaudio-capture-period.md) - the capture half of the same period fix diff --git a/quest/m1/auth/README.md b/quest/m1/auth/README.md index 17f6a6024d9..85f385fff1d 100644 --- a/quest/m1/auth/README.md +++ b/quest/m1/auth/README.md @@ -150,6 +150,7 @@ because `main` assigned 0x3A to NOT_FETCHABLE first. - [Token in band](/quest/m1/auth/token-in-band.md) - extra credentials ride AUTH streams: a session starts on the token its SETUP or URL carried and its AUTH streams add the rest +- [Binding auth polish](/quest/m1/auth/bindings-polish.md) - OBS reconnects with the presented token, one FFI auth handle, Swift grant sequences ## Related diff --git a/quest/m1/auth/bindings-polish.md b/quest/m1/auth/bindings-polish.md new file mode 100644 index 00000000000..b5444a6c3d0 --- /dev/null +++ b/quest/m1/auth/bindings-polish.md @@ -0,0 +1,37 @@ +# [S] Binding auth polish + +## Goal + +Three gaps left by [moq-dev/moq#6137](https://github.com/moq-dev/moq/pull/6137) +close: OBS reconnects with the token the user last presented, moq-ffi wraps +one auth handle type instead of two, and Swift exposes grants as an +`AsyncSequence`. + +## Plan + +Decided 2026-10-21 with the maintainer: one m1 quest after the bindings land. + +- **OBS reconnect.** A reconnect dials the URL's original token, not the one + presented mid-stream through `MoQOutput::PresentToken`. Once tokens can + ride SETUP, the presented token replaces it on reconnect. +- **FFI dispatch.** `rs/moq-ffi/src/auth.rs` wraps both + `moq_net::auth::Handle` (server sessions) and moq-tokio's + `connection::auth::Handle` (client sessions). With one handle spanning a + connection, collapse the enum. #6137 decided whichever of it and + [moq-dev/moq#6109](https://github.com/moq-dev/moq/pull/6109) lands second + does this; skip it if that already happened. +- **Swift.** Grants arrive as an `AsyncSequence`, once the generated types + are `Sendable`. If they still are not, say why in the PR rather than + forcing it. + +Public API: Swift additive. Wire: none. + +## Required + +- [Bindings](/quest/m1/auth/bindings.md) - lands the binding auth surface this polishes +- [Auth outlives its session](/quest/m1/auth/issuer.md) - one handle per connection, which the enum collapse needs +- [Token in band](/quest/m1/auth/token-in-band.md) - tokens that ride SETUP, which the OBS reconnect needs + +## Related + +- [First dial failures in Go](/quest/m2/go-first-dial-failure.md) - the m2 half of this binding cleanup diff --git a/quest/m1/binding-check-cost.md b/quest/m1/binding-check-cost.md new file mode 100644 index 00000000000..3974fe48476 --- /dev/null +++ b/quest/m1/binding-check-cost.md @@ -0,0 +1,29 @@ +# [M] Binding checks cost less + +## Goal + +An `rs/moq-ffi` change's binding checks finish markedly faster, with the +same coverage. `moq.cpp` compiles once per C++ standard instead of once per +consumer build, and Kotlin reuses a warm Gradle daemon. The PR reports the +before and after. + +## Plan + +From the CI audit in [moq-dev/moq#6155](https://github.com/moq-dev/moq/pull/6155), +decided 2026-10-21 with the maintainer as an m1 quest. Measured there: C++ +plus the OBS plugin take about 4.5 min because the generated `moq.cpp` +compiles six times at `-O0`, and Kotlin spends about 65 s of its 30 to 110 s +starting a cold Gradle daemon. Those two are most of the binding time. + +- Build `moq.cpp` into one library per C++ standard and link every consumer + against it. +- Keep a Gradle daemon warm where the checks run, without letting it leak + state between builds. +- Measure locally and on the queue runner, before and after. + +Public API: none. Wire: none. + +## Related + +- [CI workflow audit](/quest/m1/audit-ci.md) - judges every job's cost against its signal +- [CI cost and latency](/quest/m0/ci/README.md) - runner and cache infrastructure diff --git a/quest/m1/ci-housekeeping.md b/quest/m1/ci-housekeeping.md new file mode 100644 index 00000000000..48232393edf --- /dev/null +++ b/quest/m1/ci-housekeeping.md @@ -0,0 +1,33 @@ +# [XS] CI housekeeping + +## Goal + +Three small CI changes land together: + +- The merge queue's nextest runs with `NEXTEST_TEST_THREADS=24`. +- Nightly `benchmark-site` and smoke `relays-report` delete an earlier + attempt's stale `github-pages` artifact before uploading, as interop's + report job does. +- `.github/actionlint.yaml` drops its ignore for the `queue` key once an + actionlint release after 1.7.12 is in the dev shell. + +## Plan + +- **Threads.** Recommended in + [moq-dev/moq#6174](https://github.com/moq-dev/moq/pull/6174): the suite + needs about 200 CPU-seconds, and most slots wait on sockets, subprocesses, + and timeouts. Pinned to 8 CPUs it took 105 to 113 s at 8 threads and 47 s + at 24. Set it for the queue job only, after a few loaded + `just check --all` runs at 24; a flake there points at a test to fix. +- **Pages artifact** and **actionlint** both come from + [moq-dev/moq#6180](https://github.com/moq-dev/moq/pull/6180). A re-run of + either nightly job fails on the stale artifact today. The actionlint fix, + [rhysd/actionlint#661](https://github.com/rhysd/actionlint/pull/661), is + merged but unreleased; if no release reaches nixpkgs by the time the rest + is ready, land the rest and leave this bullet. + +Public API: none. Wire: none. + +## Related + +- [CI workflow audit](/quest/m1/audit-ci.md) - the broader per-job review diff --git a/quest/m1/goaway-deadline.md b/quest/m1/goaway-deadline.md new file mode 100644 index 00000000000..5b087514951 --- /dev/null +++ b/quest/m1/goaway-deadline.md @@ -0,0 +1,24 @@ +# [S] The GOAWAY drain deadline starts at the trigger + +## Goal + +A session's GOAWAY drain deadline counts from when the drain was triggered, +not from when the GOAWAY reached the wire, in moq-net (lite and IETF) and +js/net. A peer that stops reading can no longer stall the GOAWAY write and +hold the session open past its deadline. + +## Plan + +[moq-dev/moq#6144](https://github.com/moq-dev/moq/pull/6144) found that +moq-net arms its GOAWAY timer only after the message is written. A peer that +keeps the transport open but stops reading stalls that write forever, on lite +(open, flush, FIN ack) and IETF (`encode_message(..).await`). #6144 fixed the +relay only: its drain observer closes each session at the absolute deadline. +Library users of moq-net and js/net still hang. + +- Arm the deadline at the trigger and race the write against it, so the + relay's own deadline close becomes a backstop rather than the only bound. +- Port #6144's `a_stalled_goaway_write_is_still_closed_at_the_deadline` to + moq-net and js/net, on a mocked clock, for lite and IETF. + +Public API: behavior only. Wire: none. diff --git a/quest/m1/ietf-extension/README.md b/quest/m1/ietf-extension/README.md index d31d0303840..cf8b1f2971f 100644 --- a/quest/m1/ietf-extension/README.md +++ b/quest/m1/ietf-extension/README.md @@ -84,6 +84,7 @@ Work owned by this README, after the children land: ## Required - [Ingress-version provenance](/quest/m1/ietf-extension/lite.md) - a track crossing a lite-07 hop carries its moq-transport ingress version once, replacing per-block Encoding codes +- [Timed tracks cross lite-07](/quest/m1/ietf-extension/serve-timed.md) - moq-transport timestamps reach `ietf` extension peers over lite-07, with `unchecked` derived from `Info::ietf()` ## Related diff --git a/quest/m1/ietf-extension/serve-timed.md b/quest/m1/ietf-extension/serve-timed.md new file mode 100644 index 00000000000..a131316a5ff --- /dev/null +++ b/quest/m1/ietf-extension/serve-timed.md @@ -0,0 +1,31 @@ +# [S] Timed moq-transport tracks cross a lite-07 mesh + +## Goal + +A timed track ingested over moq-transport keeps its timestamps across a +lite-07 hop to a peer that negotiated the `ietf` extension, so a relay mesh +carries them end to end. A peer without the extension still gets the track +untimed. + +## Plan + +Decided 2026-10-21 with the maintainer: m1, under moq-transport passthrough. + +[moq-dev/moq#6150](https://github.com/moq-dev/moq/pull/6150) marks a timed +track received over moq-transport with the crate-private +`track::Info::unchecked` and serves it untimed to moq-lite, so its +timestamps stop at the first lite hop. +[moq-dev/moq#6107](https://github.com/moq-dev/moq/pull/6107) gives every +moq-transport track `track::Info::ietf()`, its ingress version. Derive +`unchecked` from `ietf()` instead of keeping a second flag, and let the lite +publisher serve such a track timed to an `ietf` extension peer, which knows +the timestamps came from moq-transport and are unchecked. + +Mirror it in js/net, where `Info.unchecked` is `@internal`. If the timed +encoding on that hop needs a wire change, update +`drafts/draft-lcurley-moq-lite.md` (or the extension's draft) in the same PR. + +## Required + +- [Received timestamps are media time](/quest/m1/lite-time-provenance.md) - adds `unchecked` and the untimed serving this changes +- [Ingress-version provenance](/quest/m1/ietf-extension/lite.md) - adds `Info::ietf()`, which `unchecked` derives from diff --git a/quest/m1/interop-finish.md b/quest/m1/interop-finish.md new file mode 100644 index 00000000000..c22fb704d6e --- /dev/null +++ b/quest/m1/interop-finish.md @@ -0,0 +1,27 @@ +# [S] Interop covers a clean broadcast finish + +## Goal + +The interop matrix has a media "finish" case: a publisher in each +implementation finishes its broadcast cleanly, and every subscriber drains +the tail and then sees the broadcast end, rather than an abort. A regression +in any implementation's linger shows up as a red cell. + +## Plan + +From [moq-dev/moq#6151](https://github.com/moq-dev/moq/pull/6151), which +gave js/net `Broadcast.Producer.finish()`. Rust, JS, and the bindings each +have a finish once their linger quests land. Drive it from the existing +interop clients rather than adding a new harness, and assert both halves: +the late tail arrives and the end is clean. + +Public API: none. Wire: none. + +## Required + +- [Binding linger](/quest/m1/linger-ffi.md) - bindings finish a broadcast, so the binding interop clients can +- [JS linger](/quest/m1/linger-js.md) - js/net finishes a broadcast, so the JS interop client can + +## Related + +- [Interop report](/quest/m1/interop-report.md) - where the new case's cells show up diff --git a/quest/m1/js-parked-expiry.md b/quest/m1/js-parked-expiry.md new file mode 100644 index 00000000000..42d035d81ce --- /dev/null +++ b/quest/m1/js-parked-expiry.md @@ -0,0 +1,28 @@ +# [S] A parked JS stream open gives up when its group expires + +## Goal + +A js/net publisher's pending stream open ends as soon as its group expires +or is evicted, as Rust's parked machines do with +[moq-dev/moq#6140](https://github.com/moq-dev/moq/pull/6140). A stalled +downstream no longer makes a JS publisher hold one pending open per group. + +## Plan + +Decided 2026-10-21 with the maintainer: m1. JS lite and IETF open each +group's stream with `waitUntilAvailable: false`, so an over-limit open fails +at once on a transport that rejects it. A WebTransport implementation that +parks it instead leaves one pending open per group, bounded only by the 10 s +`OPEN_TIMEOUT_MS` or the subscriber leaving. + +- Cancel the pending open when its group expires or is evicted, mirroring + Rust's `poll_abandoned`. Then decide whether `OPEN_TIMEOUT_MS` still earns + its place, and delete it if not. +- Mocked-time test: a transport that parks opens, a group that expires while + its open is parked, and the open released at expiry. + +Public API: none. Wire: none. + +## Related + +- [A stalled subscriber holds bounded state](/quest/m1/egress-held-state.md) - the Rust side of bounded egress diff --git a/quest/m1/js-reload-userinfo.md b/quest/m1/js-reload-userinfo.md new file mode 100644 index 00000000000..266be1810ce --- /dev/null +++ b/quest/m1/js-reload-userinfo.md @@ -0,0 +1,20 @@ +# [XS] JS redirect keys strip URL userinfo + +## Goal + +js/net's reconnect (`js/net/src/connection/reload.ts`) keys an endpoint +without its URL userinfo, as Rust does, so a redirect loop is detected +whatever credentials the URL carries and none of them end up in the key. + +## Plan + +`endpoint()` clears only `search` and `hash` today. Rust's redirect-key rule +from [moq-dev/moq#6162](https://github.com/moq-dev/moq/pull/6162) also drops +userinfo; match it exactly, and test both a userinfo URL and a redirect loop +that differs only in userinfo. + +Public API: none. Wire: none. + +## Required + +- [Rust redirect loops](/quest/m1/tokio-redirect-loop.md) - lands the Rust rule this mirrors diff --git a/quest/m1/js-start-parity.md b/quest/m1/js-start-parity.md new file mode 100644 index 00000000000..72659b6a1f4 --- /dev/null +++ b/quest/m1/js-start-parity.md @@ -0,0 +1,21 @@ +# [XS] JS answers SUBSCRIBE_START like Rust + +## Goal + +The js/net lite publisher (`js/net/src/lite/publisher.ts`) answers +SUBSCRIBE_START with the lower of the first group it serves and where its +source starts, as Rust does. A JS publisher sending a descending backlog no +longer names its newest group, which a resumed idle copy misjudges as a gap. + +## Plan + +Found in [moq-dev/moq#6183](https://github.com/moq-dev/moq/pull/6183). +Decided 2026-10-21: match Rust in m1. A test publishes a descending backlog +from JS and checks the START names the oldest group. + +Public API: none. Wire: none, only the value JS sends. + +## Related + +- [lite-05/06 gap judgement](/quest/m2/lite-legacy-gap.md) - the same misjudgement on versions whose START cannot say it +- [Resume through an outage](/quest/m1/resume-outage.md) - the resume work that found it diff --git a/quest/m1/net-internals.md b/quest/m1/net-internals.md new file mode 100644 index 00000000000..60f8e866413 --- /dev/null +++ b/quest/m1/net-internals.md @@ -0,0 +1,31 @@ +# [M] moq-net internals after transport erasure + +## Goal + +With the transport boxed, the lite publisher stops cloning the session and +group per group, and the lite and IETF internals lose the transport type +parameter they keep only for test mocks. A `just bench-runtime` run on +io_uring measures the cost of the `Local` thread check. + +## Plan + +Follow-ups from [moq-dev/moq#6176](https://github.com/moq-dev/moq/pull/6176), +decided 2026-10-21 with the maintainer. + +- **Per-group clones.** The lite publisher clones its session and group for + each group it serves. Borrow or share them instead, and show the win on the + session delivery benches. +- **Type parameter.** Lite and IETF internals stay generic over the + transport only so tests can inject mocks. Mock behind the boxed transport + instead, and drop the parameter. +- **`Local` check.** Run `just bench-runtime` on io_uring and report what the + `Local` thread check costs; act on it only if it shows. + +Dropped: renaming the over-long `session_delivery_*` bench IDs, since it +loses their history for a cosmetic gain. + +Public API: none. Wire: none. + +## Required + +- [moq-net compiles once](/quest/m1/net-erase-transport.md) - boxes the transport these cleanups build on diff --git a/quest/m1/quic-silent-peer-drain.md b/quest/m1/quic-silent-peer-drain.md new file mode 100644 index 00000000000..9aae84717ae --- /dev/null +++ b/quest/m1/quic-silent-peer-drain.md @@ -0,0 +1,33 @@ +# [S] A connection that never heard its peer closes at once + +## Goal + +moq-quic skips the close drain for a connection that never received a packet +from its peer, so closing a dial to an unreachable host returns at once +instead of waiting three PTOs (3 s at the default 333 ms initial RTT). +Stopping a `moqsink` whose relay is down stops promptly. + +## Plan + +Seen as moqsink's 3 s stop against an unreachable relay in +[moq-dev/moq#6152](https://github.com/moq-dev/moq/pull/6152), and as about ten +moq-gst tests paying 3 s each in +[moq-dev/moq#6174](https://github.com/moq-dev/moq/pull/6174). With no packet +from the peer, nothing on the other side needs the drain's CONNECTION_CLOSE +retransmits; a peer heard even once keeps the normal drain. + +Open decision, public API, settled in this quest's PR with options and a +recommendation: should the configured idle timeout also bound the handshake? +Today moq-quic's handshake idle timeout is a fixed 10 s that neither +`--quic-idle-timeout` nor moq-uring's `Transport` sets, so three moq-uring +endpoint tests wait it out (#6174). + +Regression tests: close a client whose dial never got an answer and assert +it returns without the drain, on a mocked clock. + +Wire: none. + +## Related + +- [Socket close](/quest/m2/quic-socket-close.md) - releasing the endpoint's socket on close +- [Keep-alive from the idle timeout](/quest/m2/quic-keep-alive.md) - the other timer derived from the idle timeout diff --git a/quest/m1/resume-datagrams.md b/quest/m1/resume-datagrams.md index 13c930a37cb..c9dc0aca4df 100644 --- a/quest/m1/resume-datagrams.md +++ b/quest/m1/resume-datagrams.md @@ -24,5 +24,13 @@ it. - Apply the same rule in both languages, so the JS and Rust readers agree. - Regression test in both: route A delivers datagram 10, route B takes over and delivers a replay of 10 and a new 5. The reader gets 5 once, and 10 only once. +- Clamp the front's new-copy subscription to the readers' floor, so the resume + floor reaches the wire. `origin.rs` subscribes with the readers' unclamped + demand (`io.weak.subscription()`), so a cold relay pulls its whole max-age + window on resume. Readers dedupe, so nothing is lost, but the resume costs + bandwidth ([moq-dev/moq#6183](https://github.com/moq-dev/moq/pull/6183)). + Folded here (decided 2026-10-21) because both touch the resume path in + `rs/moq-net/src/model/resume.rs`; test that a resume asks upstream from the + floor. Public API: behavior only. Wire: none. diff --git a/quest/m1/resume-rust-end.md b/quest/m1/resume-rust-end.md new file mode 100644 index 00000000000..0d2c5cc9cfa --- /dev/null +++ b/quest/m1/resume-rust-end.md @@ -0,0 +1,40 @@ +# [S] Rust resume holds a declared end across copies + +## Goal + +A resumed Rust track (`resume::Reader` in `rs/moq-net/src/model/resume.rs`) +keeps a declared end once any copy reported it, as JS does with +[moq-dev/moq#6136](https://github.com/moq-dev/moq/pull/6136). A route that +flaps holds no more replaced copies than the distinct routes it needs, and a +replaced copy is kept only for groups inside the reader's window. + +## Plan + +Decided 2026-10-21 with the maintainer: one quest for three Rust resume gaps. + +- **Declared end.** `poll_finished` reads only the serving copy, so an end + declared on a replaced copy is lost after a swap. Answer from the first + declared end, and refuse a copy declaring a different one, matching JS. +- **Flapping routes.** Swapping between the same two routes adds one replaced + copy per swap, redundant as backups + ([moq-dev/moq#6141](https://github.com/moq-dev/moq/pull/6141)). Dedupe them + per swap. +- **Window.** The "may still land" check ignores the reader's `Window`, so a + sparse-range reader keeps a replaced copy up to its budget for a gap outside + its ranges (#6141). Judge it inside the window. +- **Route failures.** Rust `route_failed` is narrower than JS + `ROUTE_FAILURES` (`js/net/src/resume.ts`), and adding the JS guard in Rust + hangs `partial_group` + ([moq-dev/moq#6143](https://github.com/moq-dev/moq/pull/6143)). This belongs + to the recovery-verdicts quest planned in + [moq-dev/moq#6102](https://github.com/moq-dev/moq/pull/6102); fold it there + if that lands first, otherwise align the two here. + +Regression test per gap, on a mocked clock, mirrored in JS where JS lacks one. + +Public API: behavior only. Wire: none. + +## Related + +- [Resumed close](/quest/m1/resume-closed.md) - the JS half of a declared end across copies +- [Resumed datagrams](/quest/m1/resume-datagrams.md) - the other resume reader fix in the same file diff --git a/quest/m1/smoke-dependabot.md b/quest/m1/smoke-dependabot.md new file mode 100644 index 00000000000..a47162e60a7 --- /dev/null +++ b/quest/m1/smoke-dependabot.md @@ -0,0 +1,27 @@ +# [S] Smoke's flake bumps with its Playwright pin + +## Goal + +`test/smoke/flake.lock` stays current without a hand-made bump, and every +bump moves the npm `playwright` pin to the flake's `PLAYWRIGHT_VERSION` in +the same PR, so `just freshness` passes. If automating the pin costs more +than it saves, the coupled bump is documented where a maintainer will find +it when the update is due. + +## Plan + +From [moq-dev/moq#6169](https://github.com/moq-dev/moq/pull/6169). +Dependabot's nix ecosystem on main covers only `/`. #6169 gives the smoke +flake its own entry, but Dependabot updates only the lock: `freshness.sh` +then fails because the npm pin did not move. `test/smoke/README.md` already +says to bump both together by hand. + +- Prefer automation: a workflow that follows a Dependabot smoke-flake PR + and pushes the matching pin, or one scheduled job that bumps both. +- Whichever lands, a stale smoke flake must be visible, not silent. + +Public API: none. Wire: none. + +## Related + +- [Playwright from nix](https://github.com/moq-dev/moq/pull/6116) - plans the Playwright pin this bump must follow diff --git a/quest/m1/subscribe-ranges/dynamic.md b/quest/m1/subscribe-ranges/dynamic.md index 2a96fd1bb92..fff00273ff5 100644 --- a/quest/m1/subscribe-ranges/dynamic.md +++ b/quest/m1/subscribe-ranges/dynamic.md @@ -89,6 +89,9 @@ Decided by the maintainer on 2026-10-20, when the quest was first started splits each fill into its per-group requests internally, keeping its ABI unchanged, and maps `moq_subscription.max_delay_us` to `Some`: a frozen C subscriber cannot ask for max-age alone, as today. Not a blocker. +- **Bench.** Fills fan out, so add a fill bench swept over both axes, + subscribers x misses, so a cost that grows with either shows up as a slope + (decided 2026-10-21). ## Related diff --git a/quest/m1/test-flakes-2/README.md b/quest/m1/test-flakes-2/README.md index 5e069ff9b67..f1af539358c 100644 --- a/quest/m1/test-flakes-2/README.md +++ b/quest/m1/test-flakes-2/README.md @@ -46,12 +46,17 @@ which #6032 had already finished, so it reuses #6032's reserved-port fix as its own child. moq-uring's `host_tracks_moq_clock` was seen the same day but #6056 had already fixed it by measuring the calibration gap. +Added 2026-10-21 (maintainer): three small flakes and a fresh-worktree +interop failure from the m0/m1 merge run, kept in one child since each is +small. + Public API: none. Wire: none. ## Required - [Redundant failover drift](/quest/m1/test-flakes-2/redundant-failover-drift.md) - a stitching TS export switches back to the surviving importer behind bufferbloat instead of failing on a stalled clock - [Relay bench holder](/quest/m1/test-flakes-2/relay-bench-holder.md) - the foreign-listener bench test fails fast when its holder cannot bind, instead of hanging on a fifo +- [Three flakes and fresh-worktree interop](/quest/m1/test-flakes-2/three-flakes.md) - OBS stop drain, the js/net RSS test, the audio harness RTT sample, and interop's bun install ## Related diff --git a/quest/m1/test-flakes-2/three-flakes.md b/quest/m1/test-flakes-2/three-flakes.md new file mode 100644 index 00000000000..72bc5c27b32 --- /dev/null +++ b/quest/m1/test-flakes-2/three-flakes.md @@ -0,0 +1,34 @@ +# [XS] Three flakes and a fresh-worktree interop + +## Goal + +Each of these passes reliably under a loaded `just check`, fixed at its +cause: + +- OBS "stop drains the session" (`moq-output-test.cpp`, a 16 MiB frame under + TSan), seen in [moq-dev/moq#6131](https://github.com/moq-dev/moq/pull/6131) + and [moq-dev/moq#6137](https://github.com/moq-dev/moq/pull/6137). +- The js/net RSS memory test, which flakes under load + ([moq-dev/moq#6128](https://github.com/moq-dev/moq/pull/6128)). +- The audio-quality harness's RTT sample: since + [moq-dev/moq#5534](https://github.com/moq-dev/moq/pull/5534), `probe.ts` + peeks a probe an audio-only page never observes, so samples lack `rtt` + (#6128). + +And `just test interop` runs in a fresh worktree instead of failing on +missing bun dependencies (#6137). + +## Plan + +Decided 2026-10-21 with the maintainer: one quest for the four, since each +is small. Reproduce each before fixing, and follow the epic's rules: no +retries, sleeps, or raised timeouts. + +- The RSS test should measure the allocation in a way that does not depend + on process RSS. +- The RTT probe should subscribe while sampling, as + `js/watch/src/ui/stats.ts` does. +- Interop should install what it needs, as the other `just` recipes do, + rather than assume an earlier `bun install`. + +Public API: none. Wire: none. diff --git a/quest/m1/ts-reliability/README.md b/quest/m1/ts-reliability/README.md index 3203d12869a..44a9c9c8742 100644 --- a/quest/m1/ts-reliability/README.md +++ b/quest/m1/ts-reliability/README.md @@ -128,6 +128,7 @@ remain with their current quests. - [Stream routes](/quest/m1/ts-reliability/stream-routes.md) - every PID gets a declared route, and what is not carried is counted - [Clockless export](/quest/m1/ts-reliability/clockless-export.md) - TS import and export carry audio-only and data-only programs - [Arrival stamps](/quest/m1/ts-reliability/arrival-stamps.md) - frames carry their local arrival time, so a stalled path never lets late frames out +- [Release clock false alarms](/quest/m1/ts-reliability/release-clock-false-alarms.md) - no false jitter leap at a 500 ms delay and no false drift alarm ## Related diff --git a/quest/m1/ts-reliability/pmt-lifecycle.md b/quest/m1/ts-reliability/pmt-lifecycle.md index 82ff4fe47cc..56eb20cf8e8 100644 --- a/quest/m1/ts-reliability/pmt-lifecycle.md +++ b/quest/m1/ts-reliability/pmt-lifecycle.md @@ -63,6 +63,9 @@ Decided 2026-10-20 by the maintainer: change in place with fresh names. If the program returns, it publishes a new epoch of its broadcast, never the retired instance's names for new content. A single-program import whose selected program leaves the PAT ends, as today. +- Open: a PAT that names a program whose PMT never arrives. Decide whether + the import refuses it or waits, and which clock bounds the wait (found in + [moq-dev/moq#6122](https://github.com/moq-dev/moq/pull/6122)). Why: it matches the 2026-10-15 identity decision (changed content gets a new name; a new epoch stays reserved for a whole-broadcast restart). Rejected: diff --git a/quest/m1/ts-reliability/release-clock-false-alarms.md b/quest/m1/ts-reliability/release-clock-false-alarms.md new file mode 100644 index 00000000000..9a0f34efa28 --- /dev/null +++ b/quest/m1/ts-reliability/release-clock-false-alarms.md @@ -0,0 +1,34 @@ +# [S] The TS export release clock raises no false alarms + +## Goal + +The TS export's jitter buffer reports a jitter leap or an `out_of_tolerance` +drift only when the source clock actually misbehaves. The recovery arms of +[moq-dev/moq#6139](https://github.com/moq-dev/moq/pull/6139) run clean at a +500 ms export delay and across the long arm, and assert it. + +## Plan + +Decided 2026-10-21 with the maintainer: m1, under TS reliability. Both seen +in #6139, whose arms stayed at 1 s (`export ts --delay`'s default) to land: + +- **Jitter leap at 500 ms.** A declared PCR discontinuity rewinding 475 ms + after a skipped group reads as a jitter leap. A declared discontinuity is + a new timeline, not jitter. +- **Drift estimate.** In the long arm the rate estimate read 5,551 ppm once, + at about 95 s, counting one `out_of_tolerance` against an exact source + clock. The final estimate was 0.00015 ppm and output was unaffected, but + anyone monitoring the counter sees a false alarm. Find which sample + produced it before changing the estimator. + +Reproduce each first, then make the arms assert both counters stay zero. + +Public API: none. Wire: none. + +## Required + +- [Loss and recovery tests](/quest/m1/ts-reliability/recovery.md) - lands the arms these alarms fire in + +## Related + +- [Arrival stamps](/quest/m1/ts-reliability/arrival-stamps.md) - also changes when the export releases a frame diff --git a/quest/m2/README.md b/quest/m2/README.md index b8a5e496769..7f161f908cd 100644 --- a/quest/m2/README.md +++ b/quest/m2/README.md @@ -63,12 +63,16 @@ ranked just below deterministic TS legs, which it requires. - [Perf](/quest/m2/perf/README.md) - eliminate measured hot-path costs across moq-uring, kio, and the moq-net model - [Benchmark regressions in CI](/quest/m2/bench-ci.md) - PRs get a non-blocking comparison of the Criterion benches they affect, and a nightly trend on main alerts on regressions - [Relay session bench](/quest/m2/bench-relay.md) - the same scenario through moq-relay's own connection handling +- [Transport x version benches](/quest/m2/bench-transport-sweep.md) - the session benches sweep transports as well as versions - [Read-only lookup](/quest/m2/read-only-lookup.md) - a live track lookup stops waking the front and every demand watcher - [Ordered owed wait](/quest/m2/ordered-owed-wait.md) - an ordered reader waits within max_delay for a missing group only while the track still owes it +- [lite-05/06 gap judgement](/quest/m2/lite-legacy-gap.md) - a resumed copy on lite-05/06 never reads a descending track's newest group as its start - [Unbounded groups](/quest/m2/unbounded-groups/README.md) - groups and frames lose their size caps; the cache sheds parts of a group under pressure and refills the holes in place - [Rust-backed @moq/net](/quest/m2/rs2ts/README.md) - measure browser baselines, complete WASM bindings, and adopt Rust behind @moq/net before the later JS-only stage - [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 +- [IETF lazy discovery](/quest/m2/ietf-lazy-discovery.md) - moq-transport sessions ask for announcements only under watched prefixes, starting with UNSUBSCRIBE_NAMESPACE on d14/15 +- [Keyed prefix polling](/quest/m2/keyed-prefix-polling.md) - `SubscriberDriver` polls only the prefixes a wake concerns, if a bench shows the slope - [Route health](/quest/m2/route-health/README.md) - epoch-only active/passive track recovery over metadata-only subscriptions - [E2EE](/quest/m2/e2ee/README.md) - TypeScript and Rust peers interoperate over encrypted broadcasts no relay can decrypt - [Wrapper seam over moq-net](/quest/m2/net-wrap-trait.md) - a reviewed decision on how e2ee, json, and future wrappers sit between any moq-net writer or reader and the network, trait versus bridge @@ -83,6 +87,7 @@ ranked just below deterministic TS legs, which it requires. - [Namespaced external types](/quest/m2/uniffi-namespaces.md) - the UniFFI fork lets two crates export the same type name, reopening the per-layer crate split - [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 +- [Go first dial failure](/quest/m2/go-first-dial-failure.md) - Go reports why a first dial fails, and the Kotlin and Dart docs name `client.failure()` correctly - [Dart on iOS](/quest/m2/dart-ios.md) - prove the shipped iOS native asset actually loads on a device, which no CI can - [Mobile completion](/quest/m2/mobile-completion.md) - verify the Swift and Kotlin bindings over Rust-owned capture - [Bindings in the interop matrix](/quest/m2/interop-bindings.md) - Kotlin, Swift, and Dart publish and subscribe against every other interop client @@ -176,5 +181,9 @@ ranked just below deterministic TS legs, which it requires. - [avcC and hvcC through mp4-atom](/quest/m2/mp4-atom-config.md) - moq-mux stops hand-writing the decoder config records its mp4-atom dependency already parses - [Relay metrics through prometheus-client](/quest/m2/relay-prometheus-client.md) - `/metrics` renders through the maintained client with the same series - [Dead routes on IETF name their cause](/quest/m2/js-ietf-dead-route-error.md) - a JS subscription on a dead moq-transport session ends with the session error, not `unauthorized` +- [IETF request order](/quest/m2/ietf-request-order.md) - d14/15 requests take their ID after opening, legacy `control.sending()` races are gone, and SUBSCRIBE_NAMESPACE never closes over its own close +- [JS IETF request streams](/quest/m2/js-request-stream.md) - `RequestStream` owns deadlines and cancellation, and TRACK trailing bytes close the session like Rust - [Error cleanups](/quest/m2/error-cleanups.md) - delete the unused `Error::SessionClosed`; raw transport failures already map to `Unroutable` +- [FromStr parsers](/quest/m2/from-str-trait.md) - hang, moq-auth, and moq-msf implement `FromStr` instead of inherent `from_str` +- [Drop dead items](/quest/m2/drop-dead-items.md) - the audit's uncalled public items and test helpers are removed - [Test coverage audit](/quest/m2/audit-test-coverage.md) - repeat the coverage audit against the m1 baselines after the next release ships diff --git a/quest/m2/bench-transport-sweep.md b/quest/m2/bench-transport-sweep.md new file mode 100644 index 00000000000..7a531f93ea0 --- /dev/null +++ b/quest/m2/bench-transport-sweep.md @@ -0,0 +1,25 @@ +# [M] Session benches sweep transport and version + +## Goal + +The moq-net session benches run each scenario over transport x version, not +only the in-memory mock, so a cost that one transport adds (stream opens, +framing, flow control) shows up as its own series in the regression table. + +## Plan + +Decided 2026-10-21 with the maintainer: m2. `rs/moq-net/benches/session.rs` +sweeps `VERSIONS` (lite-06, lite-07-wip, moq-transport-22) over the +in-memory transport only. Add the transports a production session uses, +moq-quic and qmux at least, keeping each run deterministic: drive QUIC over +an in-memory datagram link rather than real sockets if the noise demands it. +Keep existing bench IDs stable so their history carries over; new +transports add series rather than renaming old ones. + +Public API: none. Wire: none. + +## Related + +- [Benchmark sources](/quest/m2/bench-sources.md) - feeds these series into the regression table +- [Relay session bench](/quest/m2/bench-relay.md) - the same scenario through moq-relay +- [QUIC on the sim](/quest/m2/quic-sim.md) - an in-memory QUIC link the sweep could reuse diff --git a/quest/m2/drop-dead-items.md b/quest/m2/drop-dead-items.md new file mode 100644 index 00000000000..e3f15952f12 --- /dev/null +++ b/quest/m2/drop-dead-items.md @@ -0,0 +1,24 @@ +# [S] Remove uncalled public items + +## Goal + +The uncalled items the dead-code audit found are gone: moq-cli's `nvenc` and +`nvdec` Cargo feature aliases, `moq_net::Version::uses_setup_negotiation`, +and moq-net's test helpers `track::Subscriber::assert_error`, +`AnnounceConsumer::assert_next_restarted`, and +`AnnounceConsumer::assert_next_ended`. + +## Plan + +From [moq-dev/moq#6166](https://github.com/moq-dev/moq/pull/6166). Decided +2026-10-21 with the maintainer: m2. Verify each still has no caller across +the repo, bindings included, before removing it; keep any that gained one. +The test helpers live in `model/track.rs` and `model/origin.rs`, which many +open PRs churn, so expect merge conflicts there. + +Public API: breaking for moq-cli (features) and moq-net (`Version`), with a +`MIGRATE.md` entry in each. Wire: none. + +## Related + +- [Dead code and API surface audit](/quest/m1/audit-dead-code.md) - the audit that found them diff --git a/quest/m2/from-str-trait.md b/quest/m2/from-str-trait.md new file mode 100644 index 00000000000..379ce8264ee --- /dev/null +++ b/quest/m2/from-str-trait.md @@ -0,0 +1,20 @@ +# [S] Parsers implement FromStr + +## Goal + +`hang`, `moq-auth`, and `moq-msf` parse through `impl FromStr` instead of an +inherent `pub fn from_str`, so `str::parse` works and the +`clippy::should_implement_trait` expectations go away. + +## Plan + +From the lint audit in +[moq-dev/moq#6159](https://github.com/moq-dev/moq/pull/6159), which kept the +inherent methods because the switch breaks callers. Decided 2026-10-21 with +the maintainer: do it in m2. Today's inherent methods are in +`rs/hang/src/catalog/root.rs`, `rs/moq-auth/src/key.rs`, +`rs/moq-auth/src/set.rs`, and `rs/moq-msf/src/lib.rs`; check for more. +Remove the inherent method rather than keeping it beside the trait. + +Public API: breaking for each crate, with a `MIGRATE.md` entry in each. Wire: +none. diff --git a/quest/m2/go-first-dial-failure.md b/quest/m2/go-first-dial-failure.md new file mode 100644 index 00000000000..f8cf1942e40 --- /dev/null +++ b/quest/m2/go-first-dial-failure.md @@ -0,0 +1,26 @@ +# [XS] Go reports why a first dial fails + +## Goal + +The Go wrapper reports why a client's first dial is failing, as Python, +Swift, Kotlin, and Dart do since +[moq-dev/moq#6131](https://github.com/moq-dev/moq/pull/6131), and the Kotlin +and Dart docs describe `client.failure()` on the object that actually has it. + +## Plan + +Decided 2026-10-21 with the maintainer: m2. #6131 left Go without a `Client` +failure accessor; add it the way the other wrappers expose it. + +[moq-dev/moq#6170](https://github.com/moq-dev/moq/pull/6170) found that +`doc/lib/kt/index.md` and `doc/lib/dart/index.md` say `client.failure()` +while their examples only use `Moq.connect`, which never hands back a +`Client` before connecting. Align that wording once the linger and auth +binding PRs that also touch those pages have landed. + +Public API: Go additive. Wire: none. + +## Required + +- [Binding linger](/quest/m1/linger-ffi.md) - touches the same binding docs +- [Bindings](/quest/m1/auth/bindings.md) - touches the same binding docs diff --git a/quest/m2/ietf-lazy-discovery.md b/quest/m2/ietf-lazy-discovery.md new file mode 100644 index 00000000000..1d11d192fcc --- /dev/null +++ b/quest/m2/ietf-lazy-discovery.md @@ -0,0 +1,32 @@ +# [L] IETF lazy discovery + +## Goal + +A moq-transport session, like a lite one, asks for announcements only under +the prefixes its origin is watching, and withdraws the ask when nobody +watches any more, on every draft we support. + +## Plan + +[moq-dev/moq#6165](https://github.com/moq-dev/moq/pull/6165) made lite +discovery lazy and kept IETF eager: lazy SUBSCRIBE_NAMESPACE needs an +UNSUBSCRIBE_NAMESPACE path on drafts 14 and 15, and peers still push +unsolicited PUBLISH_NAMESPACE. + +- First step: Rust sends UNSUBSCRIBE_NAMESPACE on d14/15. It never does + today ([moq-dev/moq#6133](https://github.com/moq-dev/moq/pull/6133)). +- Then drive SUBSCRIBE_NAMESPACE from the origin's watched prefixes, as the + lite path does, in Rust and JS. +- Decide what an unsolicited PUBLISH_NAMESPACE outside any watched prefix + costs the receiver, and bound it. + +Public API: none expected. Wire: no new messages. + +## Required + +- [Lazy discovery in Rust](/quest/m1/lazy-discovery/rust.md) - the lite path this mirrors + +## Related + +- [Lazy discovery](/quest/m1/lazy-discovery/README.md) - the moq-lite epic +- [Keyed prefix polling](/quest/m2/keyed-prefix-polling.md) - the per-wake cost of many open prefixes diff --git a/quest/m2/ietf-request-order.md b/quest/m2/ietf-request-order.md new file mode 100644 index 00000000000..da3e86352e3 --- /dev/null +++ b/quest/m2/ietf-request-order.md @@ -0,0 +1,33 @@ +# [S] IETF requests take their ID in send order + +## Goal + +On moq-transport drafts 14 and 15, a request never spends an ID it cannot +send, legacy request paths have no `control.sending()` races, and an outbound +SUBSCRIBE_NAMESPACE never closes the session over its own local close. + +## Plan + +Decided 2026-10-21 with the maintainer: m2, since legacy IETF drafts are low +priority. + +- **ID order.** Rust `advertise_namespace` takes its request ID before + opening the stream. On a d14/15 timeout that leaves a gap, and a peer that + requires the next ID refuses every later request. Open first, then take + the ID. +- **`control.sending()` races.** Audit the other legacy paths for the same + shape ([moq-dev/moq#6126](https://github.com/moq-dev/moq/pull/6126)). +- **SUBSCRIBE_NAMESPACE self-close.** A local close during the counted + initial set may make the read loop see an end and throw "namespace stream + ended inside the initial set", closing the session over our own close + ([moq-dev/moq#6130](https://github.com/moq-dev/moq/pull/6130)). + Unverified: reproduce it before fixing, and drop the bullet if it does not + reproduce. + +Each fix lands with a mocked-time regression test on the affected drafts. + +Public API: none. Wire: none. + +## Related + +- [JS IETF request streams](/quest/m2/js-request-stream.md) - the JS side of the legacy request cleanup diff --git a/quest/m2/js-request-stream.md b/quest/m2/js-request-stream.md new file mode 100644 index 00000000000..b1a39614598 --- /dev/null +++ b/quest/m2/js-request-stream.md @@ -0,0 +1,25 @@ +# [S] JS IETF requests own their stream + +## Goal + +js/net's IETF request cleanup lives in one place: `RequestStream` owns the +request's deadline and its cancellation, and a malformed TRACK stream ends +the session as it does in Rust. + +## Plan + +- **One owner.** `Deadline` and SUBSCRIBE's `#cancelSubscribe` each clean up + part of a request. + [moq-dev/moq#6133](https://github.com/moq-dev/moq/pull/6133) kept them + apart because routing only SUBSCRIBE's timeout through `Deadline` would + send UNSUBSCRIBE twice. Fold both into `RequestStream`, so each request + sends its withdrawal once on timeout, abandonment, or error. +- **TRACK trailing bytes.** JS resets a TRACK (0x6) stream that carries + bytes after its request, while Rust closes the session + ([moq-dev/moq#6158](https://github.com/moq-dev/moq/pull/6158)). Match Rust. + +Public API: none (`Deadline` and `RequestStream` are internal). Wire: none. + +## Related + +- [IETF request order](/quest/m2/ietf-request-order.md) - the Rust side of the legacy request cleanup diff --git a/quest/m2/keyed-prefix-polling.md b/quest/m2/keyed-prefix-polling.md new file mode 100644 index 00000000000..b9cea725a43 --- /dev/null +++ b/quest/m2/keyed-prefix-polling.md @@ -0,0 +1,28 @@ +# [S] Keyed prefix polling + +## Goal + +A session's `SubscriberDriver` polls only the prefix machines a wake +concerns, so its per-wake cost does not grow with the number of open +prefixes. Or a benchmark shows the cost is flat and this quest is deleted. + +## Plan + +From [moq-dev/moq#6165](https://github.com/moq-dev/moq/pull/6165). +Decided 2026-10-21 with the maintainer: gated on a measurement. + +- First add or extend a bench (`rs/moq-net/benches/interests.rs` is the + nearest) that sweeps open prefixes per session against wakes. If the + per-wake cost does not grow with the prefix table, close the quest with + the numbers. +- Otherwise key polling by prefix and show the slope flatten. + +Public API: none. Wire: none. + +## Required + +- [Lazy discovery in Rust](/quest/m1/lazy-discovery/rust.md) - lands the per-prefix requests this polls + +## Related + +- [IETF lazy discovery](/quest/m2/ietf-lazy-discovery.md) - more prefixes per session once IETF is lazy too diff --git a/quest/m2/lite-legacy-gap.md b/quest/m2/lite-legacy-gap.md new file mode 100644 index 00000000000..e06bfac683b --- /dev/null +++ b/quest/m2/lite-legacy-gap.md @@ -0,0 +1,25 @@ +# [S] Resumed copies judge the gap on lite-05/06 + +## Goal + +On moq-lite-05 and 06, an idle resumed copy never misreads a descending +track's newest group as where its feed starts, so readers keep the cached +groups their max age still allows, as they do on lite-07. + +## Plan + +From [moq-dev/moq#6183](https://github.com/moq-dev/moq/pull/6183), which +fixed lite-07 by judging the gap from SUBSCRIBE_START's first group. On +05/06 the copy still judges it by the first group header, and on a +descending track the first header to land can be the newest group. Their +START has no `largest`, so this needs its own small design within those +versions' wire, which is published and must not change. Propose it in the +PR with options and a recommendation; leaving 05/06 as is, documented, is +one option. + +Public API: none. Wire: none. + +## Related + +- [JS answers SUBSCRIBE_START like Rust](/quest/m1/js-start-parity.md) - the lite-07 publisher half +- [Resume through an outage](/quest/m1/resume-outage.md) - the lite-07 fix