diff --git a/quest/m0/README.md b/quest/m0/README.md index 6d1af5d8a8f..262170b8584 100644 --- a/quest/m0/README.md +++ b/quest/m0/README.md @@ -33,6 +33,7 @@ since cutting segments from first-frame pts waits on nothing in m1. - [Backport audio groupDuration](/quest/m0/backport-audio-group-duration.md) - `@moq/publish` 0.5.4 on `release` can pack several Opus frames per group, making Cloudflare's relay drop audio less often - [Backport the SETUP-path and iroh-key fixes](/quest/m0/backport-security-fixes.md) - `release` refuses a conflicting SETUP Path and keeps persisted iroh keys private, in one patch release - [Backport the joined-head FETCH race fix](/quest/m0/backport-fill-head-race.md) - a `release` relay stops FETCHing a group head its own SUBSCRIBE is bringing, which left live readers hanging +- [Release resumes owed groups or proves it doesn't need to](/quest/m0/backport-resume-owed-groups.md) - after main's resume fix, reproduce its cases on `release`, then backport or delete - [CI cost and latency](/quest/m0/ci/README.md) - cloud CI runs only in a batched merge gate as one `just ci` pass per batch, expensive checks run nightly and gate `release`, caches move to R2, and runners are chosen last - [More tests under load](/quest/m0/test-flakes-2/README.md) - load-only and queue failures, one quest per flake, fixed at the cause, since each one fails a whole batch - [A waiter's record limit changes no behavior](/quest/m0/kio-waiter-records.md) - two moq-net tests stop failing when kio's waiters remember 16 lists, and the limit becomes a tuning knob worth 3.9% per delivered group diff --git a/quest/m0/backport-resume-owed-groups.md b/quest/m0/backport-resume-owed-groups.md new file mode 100644 index 00000000000..41b2aa16757 --- /dev/null +++ b/quest/m0/backport-resume-owed-groups.md @@ -0,0 +1,35 @@ +# [S] Release resumes owed groups or proves it doesn't need to + +## Goal + +A `release` relay's resumed read gets every owed group or a drop for it, +never a hang, if `release` has the hang. Otherwise, this quest records the +evidence that `release` isn't exposed and is deleted. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7708](https://github.com/moq-dev/moq/pull/7708)): milestone m0, +beside the other backports. It started once #7708, the resume fix on main +that this ports, merged. + +- Exposure is unproven. `origin/release` (moq-net 0.3.19 at `acf91a00b9`) + has no `live_floor`, `judge`, or `Misses`. The shared live floor that + #7708 fixes arrived with + [moq-dev/moq#4741](https://github.com/moq-dev/moq/pull/4741), which is not + on `release`. `release` does have `resume.rs`, so + the symptom may still come through another path. + `release` also speaks draft 22 (`rs/moq-net/src/ietf/version.rs`), so + check drafts 14 to 22. +- Reproduce first. Port #7708's regression tests (the cache-loss case and + the bounded resumes) onto `release`'s older cache model and run them + there. If none fails, delete this quest and record the run in the PR. +- If one fails, fix it on `release` with the smallest change that matches + main's contract. Expect a hand-port, not a cherry-pick, since the cache + models differ. Then cut a patch release under the release line's usual + rules. Bump the version by hand at the semver level the change needs. +- Keep it separate from [the joined-head FETCH backport](/quest/m0/backport-fill-head-race.md). + #7708 says the PUBLISH_DONE grace correction tracked there is a separate + fix. + +Public API: none expected. Wire: none. diff --git a/quest/m0/ci/README.md b/quest/m0/ci/README.md index 139cb5e08d1..061a768aab2 100644 --- a/quest/m0/ci/README.md +++ b/quest/m0/ci/README.md @@ -166,3 +166,5 @@ The historical samples locate candidates; they are not controlled benchmarks. - [moq-audio's default-feature test build is clippy-clean and gated](/quest/m0/ci/default-feature-test-lint.md) - the dead `retains`/`fail` under default-feature `--tests` clippy is fixed, and the gate catches it next time - [A release merge opens no stale release PR](/quest/m0/ci/release-pr-after-release.md) - `just rs release` publishes before it proposes, so a merged release isn't re-proposed - [Dependabot leaves the workspace-hack to hakari](/quest/m0/ci/dependabot-workspace-hack.md) - cargo group PRs stop hand-editing `rs/workspace-hack/Cargo.toml` +- [mbx's free-space GC never removes a live target](/quest/m0/ci/mbx-gc.md) - the cargo shim stops deleting targets other sessions use when the host disk runs low +- [Bun runs only the test files we name](/quest/m0/ci/bun-test-paths.md) - scripted `bun test` calls pass exact paths, so generated copies never run diff --git a/quest/m0/ci/bun-test-paths.md b/quest/m0/ci/bun-test-paths.md new file mode 100644 index 00000000000..60afffd0baf --- /dev/null +++ b/quest/m0/ci/bun-test-paths.md @@ -0,0 +1,31 @@ +# [XS] Bun runs only the test files we name + +## Goal + +Every scripted `bun test ` passes an exact path. Bun then never runs a +same-named copy elsewhere in the checkout, such as a generated release tree +under `target/` or a scratch directory. A check keeps new bare filters +from coming back. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7680](https://github.com/moq-dev/moq/pull/7680), first seen in +[moq-dev/moq#7669](https://github.com/moq-dev/moq/pull/7669)): milestone m0, +in the CI epic. + +- Cause: bun treats a bare argument as a substring filter over discovered + files. Only arguments that start with `./` or `/` are exact. The API + checker's generated release tree under the build cache held copies of + `sh/gh/*.test.ts`, and those old tests ran against main's workflows. +- Bare filters on main: `.github/justfile:30,54,59` + (`sh/gh/alert|setup|ffi|cpp|publish.test.ts`), + `test/json-properties.sh:12`, `test/resume-model.sh:12`, + `test/justfile:52,54,277` (check what the harness lists expand to), and + `test/smoke/justfile:122`. Prefix each with `./`. +- Guard: have the test inventory (`sh/gh/test-inventory.py`) or a small + lint refuse a scripted `bun test` argument that ends in `.test.ts` and + lacks `./` or `/`. If no root `bunfig.toml` exists, also consider one + that limits discovery to the source roots. + +Public API: none. Wire: none. diff --git a/quest/m0/ci/mbx-gc.md b/quest/m0/ci/mbx-gc.md new file mode 100644 index 00000000000..098f75cd4bb --- /dev/null +++ b/quest/m0/ci/mbx-gc.md @@ -0,0 +1,47 @@ +# [S] mbx's free-space GC never removes a live target + +## Goal + +On agent hosts, a cargo call through the mbx shim never deletes a Cargo +target another session is still using. A run that loses disk headroom gets +a clear failure instead of silently evicting the shared cache. The host +settings that keep it so live in `kixelated/dotfiles`. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7742](https://github.com/moq-dev/moq/pull/7742)): milestone m0, +in the CI epic. +[moq-dev/moq#7715](https://github.com/moq-dev/moq/pull/7715) only worked +around the same GC for long interop runs. + +- Incident + ([comment](https://github.com/moq-dev/moq/pull/7742#issuecomment-6605544835)): + `mbx[gc]: 11.2 GiB free … under the 50.0 GiB minimum`, then "removed 7 + target directories (… 6 abandoned and 1 live)". It also evicted about + 30 GiB of shared cache objects below `gc.max_size`, because the disk was + under `gc.min_free_size`. +- This is documented mbx behaviour (`mbx gc --help`): below + `gc.min_free_size`, it collects past its budgets, managed targets first. + `~/work/dotfiles/mbx/config.toml` sets no `[gc]` options, so the + defaults apply. On 2026-11-03, `/` on `desktop` was 98% full with 49 GB + free, still under the threshold, so any cargo call can trigger it again. +- Work out why the disk is that full first: other worktrees' targets, `.tmp/` + scratch, Nix store. `quest worktree` reclaims finished checkouts. +- Then protect live targets in dotfiles. Lowering `min_free_size` only + changes when collection runs: below it, mbx still removes unprotected + managed targets. mbx's docs + ([managed targets](https://mr-boxington.jdx.dev/managed-targets)) describe + a running command's lease and a `target.keep` setting. Check which of them + failed for the target logged as live: a binary run straight from + `target/` holds no lease. Then set `target.keep` or the fitting `[gc]` + option. If mbx can't spare live targets at all, report that upstream and + record the issue link here. +- Edit dotfiles in place (`~/work/dotfiles` is live config), and link its + commit here when done. + +Public API: none. Wire: none. + +## Related + +- The queue host keeps the queue's disk - disk policy for the queue host, configured in kixelated/nixos diff --git a/quest/m0/interop-green/README.md b/quest/m0/interop-green/README.md index e444fe54a90..3f8ba886edc 100644 --- a/quest/m0/interop-green/README.md +++ b/quest/m0/interop-green/README.md @@ -1,4 +1,4 @@ -# [XS] Interop and Video pass on main +# Interop and Video pass on main ## Goal @@ -65,3 +65,7 @@ The P2P data-channel test timed out once, in 41668668824, and passes locally; triage it if it recurs. Public API: none. Wire: none. + +## Required + +- [The open-GOP recovery fixture provides the broadcast name](/quest/m0/interop-green/open-gop-fixture.md) - the open-GOP browser fixture stubs `in.name`, and an exception in an effect fails the test at once instead of timing out diff --git a/quest/m0/interop-green/open-gop-fixture.md b/quest/m0/interop-green/open-gop-fixture.md new file mode 100644 index 00000000000..e13138384ab --- /dev/null +++ b/quest/m0/interop-green/open-gop-fixture.md @@ -0,0 +1,36 @@ +# [XS] The open-GOP recovery fixture provides the broadcast name + +## Goal + +The scheduled Interop run's "Harness regressions" step passes the +`open-gop.browser.ts` case "software video recovery trims orphan pictures +after join and later gap". The fixture's fake broadcast provides everything +`@moq/watch`'s decoder reads. From now on, an exception thrown inside a +fixture's effect fails the test immediately with that error, instead of +surfacing as a 60-second timeout. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7715](https://github.com/moq-dev/moq/pull/7715) and +[moq-dev/moq#7716](https://github.com/moq-dev/moq/pull/7716)): milestone m0, +a child of the Interop epic, since it breaks the scheduled run. + +- Cause: [moq-dev/moq#7222](https://github.com/moq-dev/moq/pull/7222) + (`2738588cfc`) made `js/watch/src/video/decoder.ts` read + `broadcast.in.name.peek()` for stats. The fake broadcast in + `test/interop/clients/js/open-gop/main.ts` provides only `out: { catalog, + active }` and `relativeBroadcast`, so the read throws inside an effect. + The scheduled run + [41668668824](https://github.com/moq-dev/moq/actions/runs/41668668824) + fails with `TypeError: Cannot read properties of undefined (reading + 'name')` at `window.runRecovery`. +- Add `in: { name }` to the stub, typed against the real broadcast's shape + where the fixture allows it, so the next field the decoder reads fails + type-checking instead of at run time. +- Fail fast: route page errors and effect exceptions to a test failure. + [moq-dev/moq#7716](https://github.com/moq-dev/moq/pull/7716) adds + page-error collection to `harness.browser.ts`. Reuse it if it has landed, + or add the same collection here and let #7716 merge onto it. + +Public API: none. Wire: none. diff --git a/quest/m0/nightly/README.md b/quest/m0/nightly/README.md index 720f0a44712..593f9d3d918 100644 --- a/quest/m0/nightly/README.md +++ b/quest/m0/nightly/README.md @@ -1,4 +1,4 @@ -# [S] Nightly passes on main +# Nightly passes on main ## Goal @@ -32,3 +32,10 @@ This README's own work, after the children: threshold to [bench CI](/quest/m1/bench-ci.md). Public API: none. Wire: none. + +## Required + +- [Nightly's Rust and JS audits pass](/quest/m0/nightly/audits.md) - RUSTSEC-2026-0173 and the root `bun.lock` glob and minimatch advisories are upgraded away or ignored with a reason +- [moq-net's ingest fuzz target finds no stall](/quest/m0/nightly/ingest-fuzz.md) - the 13-byte stream that stalls ingest is fixed at its cause and kept as a regression test +- [Nightly's shipping-size check passes](/quest/m0/nightly/shipping-size.md) - js/net, js/watch, and moq-relay growth over 5% is traced to its commits, then shrunk or accepted +- [Nightly's Miri job stays inside its time budget](/quest/m0/nightly/miri.md) - Miri gets `rust-src`, then finishes inside its 60-minute job and 15-minute-per-test budgets diff --git a/quest/m0/nightly/audits.md b/quest/m0/nightly/audits.md new file mode 100644 index 00000000000..bed5132ef67 --- /dev/null +++ b/quest/m0/nightly/audits.md @@ -0,0 +1,39 @@ +# [XS] Nightly's Rust and JS audits pass + +## Goal + +Nightly's Rust and JS audit jobs pass on `main`. Each current advisory is +fixed by an upgrade, or by an override or an ignore that names the advisory +and its reason, so a new advisory shows up as the only red. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7667](https://github.com/moq-dev/moq/pull/7667)): milestone m0, +a child of the Nightly epic. + +Both fail in the scheduled run of 2026-11-03 +([run 41656613559](https://github.com/moq-dev/moq/actions/runs/41656613559)): + +- **Rust** + ([job](https://github.com/moq-dev/moq/actions/runs/41656613559/job/125988511066)): + RUSTSEC-2026-0173, `proc-macro-error2` unmaintained, reached through + `hax-lib-macros`. Find which of our crates pulls `hax-lib` in. Upgrade it + if a release drops the edge. Otherwise ignore the advisory in the audit + config with a comment naming the parent crate, since an unmaintained + proc-macro crate runs only at build time. +- **JS** + ([job](https://github.com/moq-dev/moq/actions/runs/41656613559/job/125988512588)): + the root `bun.lock` resolves `glob` (GHSA-3g3m-2fjr-6pw4) and `minimatch` + (GHSA-g3hv-75wg-m249) to vulnerable versions. Raise them through the parent + that pins them, or with a root `overrides` entry. + +Keep [the dependency audit](/quest/m2/audit-deps.md) in sync. It already +records that the root lock is not clean, so update its notes once this +lands. + +Public API: none. Wire: none. + +## Related + +- [Dependency audit](/quest/m2/audit-deps.md) - the recurring audit that owns advisory policy diff --git a/quest/m0/nightly/ingest-fuzz.md b/quest/m0/nightly/ingest-fuzz.md new file mode 100644 index 00000000000..a4171c6ef3c --- /dev/null +++ b/quest/m0/nightly/ingest-fuzz.md @@ -0,0 +1,35 @@ +# [S] moq-net's ingest fuzz target finds no stall + +## Goal + +Nightly's moq-net `ingest` fuzz target runs its budget without a finding. +The stall it found on a complete 13-byte stream is fixed at its cause, and +that input is kept as a regression test. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7667](https://github.com/moq-dev/moq/pull/7667)): milestone m0, +a child of the Nightly epic. + +- The scheduled run of 2026-11-03 + ([job](https://github.com/moq-dev/moq/actions/runs/41656613559/job/125988510475)) + panicked at `rs/moq-net/src/fuzz/ingest.rs:298` with "the ingest stalled + on a complete 13-byte stream". Its crash artifact is `crash-106ef498…`. + The 2026-11-01 E0391 build failure noted in + [the CI audit](/quest/m2/audit-ci.md) no longer occurs. +- Download the artifact before it expires, then replay it with + `cargo fuzz run ingest `. Decide whether the ingest really + stalls on that input or the harness's stall check is wrong, and fix + whichever it is. +- Add the input as a fixed regression test next to the target, so `just + check` covers it without fuzzing. +- The same run's `Fuzz (ts)` and `Fuzz (annexb)` failures are media + targets. They belong to [fuzz findings](/quest/m1/fuzz-findings/README.md), + or else to the Nightly epic's own triage, not to this quest. + +Public API: none expected. Wire: none expected. + +## Related + +- [Fuzz findings](/quest/m1/fuzz-findings/README.md) - the media fuzz targets' findings diff --git a/quest/m2/miri-nightly-budget.md b/quest/m0/nightly/miri.md similarity index 81% rename from quest/m2/miri-nightly-budget.md rename to quest/m0/nightly/miri.md index 2a8937c0338..c4c5cfc991c 100644 --- a/quest/m2/miri-nightly-budget.md +++ b/quest/m0/nightly/miri.md @@ -13,6 +13,12 @@ Decided 2026-10-31 (user, /quest-plan of the follow-ups from the 2026-10-31 /que (merged), which finished the Miri for in-memory unsafe quest. Milestone m2 (user: "use recommended for any CI/flakes"). +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from [moq-dev/moq#7667](https://github.com/moq-dev/moq/pull/7667)): +moved from m2 under [Nightly passes on main](/quest/m0/nightly/README.md), +since the missing `rust-src` keeps the m0 Nightly red. The scheduled run of +2026-11-03 ([run 41656613559](https://github.com/moq-dev/moq/actions/runs/41656613559/job/125988511062)) +still fails the same way. + Act on the first Nightly runs' timings, not ahead of them. Locally (24 cores) `just rs miri` took 11.5 min wall: strict pass 118 tests in 109 s, epoch pass 94 in 307 s. diff --git a/quest/m0/nightly/shipping-size.md b/quest/m0/nightly/shipping-size.md new file mode 100644 index 00000000000..41469845a53 --- /dev/null +++ b/quest/m0/nightly/shipping-size.md @@ -0,0 +1,39 @@ +# [S] Nightly's shipping-size check passes + +## Goal + +Nightly's shipping-size check passes on `main`. Every growth over its 5% +threshold is traced to the commits that caused it. Each is then shrunk back, +or accepted as a new baseline with the reason recorded. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7667](https://github.com/moq-dev/moq/pull/7667)): milestone m0, +a child of the Nightly epic. + +The scheduled run of 2026-11-03 +([job](https://github.com/moq-dev/moq/actions/runs/41656613559/job/126039954216)) +failed on growth since the previous run: + +- `js/net` raw went from 444,692 to 467,348 bytes. +- `js/watch` also grew past the threshold. +- All four moq-relay archives grew to about 10.2–11.3 MB, from about + 9.5–10.3 MB. + +Bisect each artifact between the two runs' commits. Likely suspects are the +recent bigint group IDs ([moq-dev/moq#7681](https://github.com/moq-dev/moq/pull/7681)) +for js/net, and any new default feature or dependency for moq-relay. +`cargo bloat` and the bundle's metafile name the code that grew. + +If the threshold compares only against the previous run, one intended jump +fails every night until the baseline moves. Check how the job sets its +baseline, and give it a documented way to accept a reviewed growth. +[Size audit](/quest/m2/audit-size.md) owns the release-time view of these +sizes. + +Public API: none. Wire: none. + +## Related + +- [Size audit](/quest/m2/audit-size.md) - pre-cut size investigation and the post-release refresh diff --git a/quest/m0/test-flakes-2/README.md b/quest/m0/test-flakes-2/README.md index ad89b9e4b6f..a3062473da5 100644 --- a/quest/m0/test-flakes-2/README.md +++ b/quest/m0/test-flakes-2/README.md @@ -95,3 +95,7 @@ Public API: none. Wire: none. - [The JS worklet library-build test survives load](/quest/m0/test-flakes-2/js-worklet-build.md) - the lazy-blob worklet build test stops timing out at bun's 5 seconds - [moq-archive's cross-backend recording test survives load](/quest/m0/test-flakes-2/archive-backends-identical.md) - `recordings_are_byte_identical_on_every_backend` stops splitting S3's video objects differently - [moq-ffi's panicked-origin supervision test survives load](/quest/m0/test-flakes-2/ffi-origin-panic.md) - a read the origin driver's panic ends always reports `MoqError::Task` +- [The scheduled macOS WebSocket version test completes reliably](/quest/m0/test-flakes-2/macos-websocket.md) - fix the scheduled timeout while preserving newest-version negotiation assertions +- [@moq/net's lite subscribe tests wait for the whole request](/quest/m0/test-flakes-2/js-subscribe-fixture.md) - the three lite subscribe-with-track cases pass under forced yields +- [Concurrent PulseAudio harness runs don't share a D-Bus name](/quest/m0/test-flakes-2/pulse-dbus.md) - parallel media runs no longer collide on `org.PulseAudio1` +- [@moq/net's uni-stream flood test survives reruns](/quest/m0/test-flakes-2/js-stream-flood.md) - "a flood of uni streams yields" passes under `--rerun-each` and load diff --git a/quest/m0/test-flakes-2/ietf22-fallback.md b/quest/m0/test-flakes-2/ietf22-fallback.md index 343654e621c..b7c7643087d 100644 --- a/quest/m0/test-flakes-2/ietf22-fallback.md +++ b/quest/m0/test-flakes-2/ietf22-fallback.md @@ -3,8 +3,8 @@ ## Goal When the newest of two live publishers withdraws, a browser `@moq/watch` -viewer on moq-transport-22 plays the still-live older run within the media -lane's derived 1039 ms bound. It keeps its session, and its audio resumes +viewer on moq-transport-22, or on moq-lite in Firefox, plays the still-live +older run within the media lane's derived 1039 ms bound. It keeps its session, and its audio resumes with its video. Both failures are fixed at their cause once one recurs with enough evidence to reproduce it deterministically. @@ -21,6 +21,20 @@ enough evidence to reproduce it deterministically. Neither failure has a known cause or a reproduction yet, so no production or test change is justified until one recurs. +Recurrence, added 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7667](https://github.com/moq-dev/moq/pull/7667)): Nightly's +Firefox media job failed `live incumbent fallback plays` on two consecutive +nights with the audio-stall symptom (`audioStalled:true, audioTimestamp:0` +after the fallback), on `old-moq-lite-07-wip`: +[2026-11-02](https://github.com/moq-dev/moq/actions/runs/41483654426/job/125408204778) +and +[2026-11-03](https://github.com/moq-dev/moq/actions/runs/41656613559/job/125988510133). +[moq-dev/moq#7716](https://github.com/moq-dev/moq/pull/7716) found it +separate from the Firefox tone problem. Read those jobs' artifacts first. If +they isolate the cause, the Waiting item clears. If they don't, rerun the +Waiting section's command with `--media-engines firefox` and the same +`RUST_LOG` filter. + Two failures were seen while landing [moq-dev/moq#6548](https://github.com/moq-dev/moq/pull/6548), on a host at load average 30 to 70: diff --git a/quest/m0/test-flakes-2/js-stream-flood.md b/quest/m0/test-flakes-2/js-stream-flood.md new file mode 100644 index 00000000000..62b9c6a53d3 --- /dev/null +++ b/quest/m0/test-flakes-2/js-stream-flood.md @@ -0,0 +1,29 @@ +# [S] @moq/net's uni-stream flood test survives reruns + +## Goal + +`js/net/src/stream.test.ts`'s "a flood of uni streams yields to the host's +other tasks" passes under `bun test --rerun-each` and under load. If it fails, +the cause is fixed: either the test's own state leaking between reruns, or +the accept loop failing to yield. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7658](https://github.com/moq-dev/moq/pull/7658)): milestone m0, +a child of the test-flakes epic. + +- #7658's exploratory stress run (`--rerun-each 5`) failed this test once. + It passes in normal suites and CI, and that run left no log. +- The test is at `js/net/src/stream.test.ts:1001`, unchanged since + [moq-dev/moq#7386](https://github.com/moq-dev/moq/pull/7386). It stubs + `performance.now` to add 5 per call to a module-level `fakeNow`. It then + expects a `yieldNow()` sibling to run before 1024 accepts finish. Suspect + first that `fakeNow` and the stub carry over between reruns, or are + restored late. +- Reproduce first: `bun test --rerun-each 50` on the file, both alone and + next to the rest of `js/net`. Then use the epic's load harness. Fix the + cause, whether in the test or in `stream.ts`'s budget, and keep the + test's claim that the flood yields. + +Public API: none. Wire: none. diff --git a/quest/m0/test-flakes-2/js-subscribe-fixture.md b/quest/m0/test-flakes-2/js-subscribe-fixture.md new file mode 100644 index 00000000000..15a883993d5 --- /dev/null +++ b/quest/m0/test-flakes-2/js-subscribe-fixture.md @@ -0,0 +1,31 @@ +# [XS] @moq/net's lite subscribe tests wait for the whole request + +## Goal + +The three `lite %s: a subscribe goes out with its track` cases (lite-05, +06, and 07) in `js/net/src/lite/subscriber.test.ts` pass when every budget +poll is forced to yield. They decode the SUBSCRIBE only after the request +has been fully written. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7663](https://github.com/moq-dev/moq/pull/7663)): milestone m0, +a child of the test-flakes epic. #7663 fixes the announce harness only and +leaves these tests alone. + +- The test (`subscriber.test.ts:1289`) waits on `(await + opened(1)).writing`, which resolves on the first written chunk. It then + decodes `streams[1].written`. The `fakeSession` fixture (`:1015`) copies + the bytes after one host turn, so under forced yields the SUBSCRIBE can + still be partial. +- Wait on a signal that the request is complete, such as a full-message + promise from the fixture, then decode. Don't wait on the subscriber reading + its response, as #7663 does for the announce harness: on lite-05 and later + the subscriber reads it only after TRACK_INFO, which the test sends after + decoding SUBSCRIBE. +- Verify under forced yields (#7663 shows how to force them) and at normal + speed. Check `fakeSession`'s other users for the same partial-write + wait. + +Public API: none. Wire: none. diff --git a/quest/m0/test-flakes-2/macos-websocket.md b/quest/m0/test-flakes-2/macos-websocket.md new file mode 100644 index 00000000000..8f813b6ba84 --- /dev/null +++ b/quest/m0/test-flakes-2/macos-websocket.md @@ -0,0 +1,44 @@ +# [S] The scheduled macOS WebSocket version test completes reliably + +## Goal + +`moq-tokio`'s `broadcast::broadcast_websocket_uses_newest_version` completes +reliably in the scheduled macOS job, with its client and server assertions +that WebSocket negotiates the newest lite version intact. Fix the timeout at +its cause and cover the failing lifecycle deterministically. + +## Plan + +Confirmed 2026-11-03 (maintainer, foreground follow-up planning from +[moq-dev/moq#7653](https://github.com/moq-dev/moq/pull/7653)). The maintainer +delegated milestone selection; this belongs in m0 because it blocks reliable +scheduled CI. Cache tuning and unrelated Nightly failures stay outside scope. + +- The [November 2 macOS job](https://github.com/moq-dev/moq/actions/runs/41483654426/job/125408628726) + timed out this test after 120 seconds. Reproduce against current `main` + before changing it, and find which operation stopped progressing. +- The fixture is in `rs/moq-tokio/tests/integration/broadcast.rs`. Its + connection attempt has a timeout, while its final server-task join waits + for session closure. That is a place to investigate, not an established + diagnosis. Distinguish negotiation, transport progress, and teardown. +- Keep the WebSocket transport and both version assertions. Follow the + [flake epic's test rules](/quest/m0/test-flakes-2/README.md); no larger + timeout, retry, or weakened assertion substitutes for fixing the cause. +- Validate the affected lifecycle locally and retain the macOS scheduled + evidence. Do not claim the scheduled failure fixed from Linux-only runs; + keep any unavailable platform proof explicit. + +The job's retained excerpt (timestamps omitted): + +```text +TIMEOUT [ 120.015s] (739/739) moq-tokio::integration broadcast::broadcast_websocket_uses_newest_version +running 1 test +test broadcast::broadcast_websocket_uses_newest_version has been running for over 60 seconds +(test timed out) +Summary [ 130.849s] 739 tests run: 738 passed, 1 timed out, 11 skipped +``` + +The captured test output had no negotiation or teardown diagnostics, so this +evidence does not identify the blocked operation. + +Public API: none expected. Wire: none. diff --git a/quest/m0/test-flakes-2/pulse-dbus.md b/quest/m0/test-flakes-2/pulse-dbus.md new file mode 100644 index 00000000000..3b9db6d1777 --- /dev/null +++ b/quest/m0/test-flakes-2/pulse-dbus.md @@ -0,0 +1,27 @@ +# [XS] Concurrent PulseAudio harness runs don't share a D-Bus name + +## Goal + +Two media harness runs on one host each start a private PulseAudio without +`D-Bus name org.PulseAudio1 already taken`, so a concurrent run never fails +before its browser launches. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7716](https://github.com/moq-dev/moq/pull/7716)): milestone m0, +a child of the test-flakes epic, since parallel agent runs hit it. + +- `test/lib/pulse.py` (lines 44–53) isolates `XDG_RUNTIME_DIR`, `PULSE_*`, + `ALSA_CONFIG_PATH`, and `DISPLAY`. It passes `DBUS_SESSION_BUS_ADDRESS` + through, so every private daemon tries to claim the same session-bus name. + Callers: `test/interop/interop.sh:2118`, `test/audio-quality/run.sh:349`, + and native-play. +- Give each daemon no session bus. Unset the address or disable PulseAudio's + D-Bus module in the private config, after checking that the daemon starts + cleanly with no bus. If it doesn't, run it under its own + `dbus-run-session`. +- Add a test that starts two `pulse.py` instances at once and plays through + each. + +Public API: none. Wire: none. diff --git a/quest/m1/README.md b/quest/m1/README.md index 7de63409ff6..d9b1d057e8f 100644 --- a/quest/m1/README.md +++ b/quest/m1/README.md @@ -175,6 +175,9 @@ per-frame CPU growth since #5926. - [HLS export lists a same-codec reconfigure's first group under the new init](/quest/m1/hls-reinit-same-codec.md) - the hand-over pick, whichever of the catalog and the records arrives first, after the catalog `hls` removal is planned - [Ordered reads can skip owed holes, and snapshot latest() does](/quest/m1/ordered-owed-holes.md) - moq-net's `Ordered` gains a read that skips past an owed hole to the newest buffered group, while keeping the reader's bounds - [A Rust relay never replays from group 0 to a lite-03/04 subscriber](/quest/m1/relay-inflight-replay.md) - A Rust relay or publisher serving a lite-03 or lite-04 SUBSCRIBE from a track copy that is still resolving starts at the newest group once the copy resolves +- [The resume model ends #7739's clean-end seed](/quest/m1/resume-seed-17893651.md) - replay seed 17893651 after #7705's wake fix, and fix it if a long-budget reader still never gets the end +- [Every moq-mux consumer gets the catalog warmup from one entry point](/quest/m1/mux-warmup.md) - one moq-mux call widens the subscription and configures the consumer, adopted by moq-audio, moq-c, moq-ffi's raw consumer, and moqsrc +- [Codex shells never load another checkout's dev environment](/quest/m1/codex-env-snapshot.md) - the Codex dev-shell snapshot is skipped when stale or inside `nix develop` - [Rename moq-rtc to moq-webrtc](/quest/m1/webrtc-rename.md) - one published `moq-webrtc` crate holds the gateway, the ICE driver, and the data-channel transport - [Vendor and trim the WebRTC stack](/quest/m1/webrtc-vendor.md) - str0m, dimpl, `is`, and sctp-proto live in moq-webrtc with unused code removed, so moq-rtc can take rind - [MoQ on rind](/quest/m1/rind/README.md) - every MoQ crate takes its crypto from rind, a pure-Rust graviola fork, so no build compiles C crypto diff --git a/quest/m1/codex-env-snapshot.md b/quest/m1/codex-env-snapshot.md new file mode 100644 index 00000000000..09d6b973c7d --- /dev/null +++ b/quest/m1/codex-env-snapshot.md @@ -0,0 +1,37 @@ +# [S] Codex shells never load another checkout's dev environment + +## Goal + +A Codex shell command always runs with the toolchain of the checkout it runs +in. A dev-shell snapshot captured for one flake is never sourced after the +checkout moves to another one, such as `main` to `release`. Inside +`nix develop`, the shell that `nix develop` built wins. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7680](https://github.com/moq-dev/moq/pull/7680)): milestone m1. + +- Mechanism: `.codex/hooks.json` runs `.codex/hooks/direnv.sh` once per + session start or resume. It writes `.direnv/codex-env.sh` from + `nix print-dev-env`. `.codex/config.toml` sets `BASH_ENV` to + `~/.codex/bash-env.sh`, a symlink to `~/work/dotfiles/codex/bash-env.sh`, + which sources that snapshot in every bash process. +- Failure: after #7680 switched its checkout to `release`, the stale main + snapshot overrode release's pinned toolchain (no WASM target), even inside + `nix develop --command bash -c …`, because bash re-sources `BASH_ENV`. + #7680 worked around it by unsetting `BASH_ENV`. +- Fix both halves: + - `direnv.sh` stamps the snapshot with a hash of `flake.nix` and + `flake.lock`. + - `bash-env.sh` (in dotfiles) skips the snapshot when `IN_NIX_SHELL` is + set, or when the stamp doesn't match the checkout's current files. A + mismatch says so once on stderr, so the session knows to re-run the hook. +- Test: a snapshot from one flake is not sourced after `flake.lock` changes, + and `nix develop --command` keeps its own toolchain. + +Public API: none. Wire: none. + +## Related + +- [Agents use quest's worktree hooks](/quest/m0/quest-worktree-hooks.md) - the Claude-side worktree hooks diff --git a/quest/m1/mux-warmup.md b/quest/m1/mux-warmup.md new file mode 100644 index 00000000000..500c5b98a8e --- /dev/null +++ b/quest/m1/mux-warmup.md @@ -0,0 +1,46 @@ +# [M] Every moq-mux consumer gets the catalog warmup from one entry point + +## Goal + +A moq-mux container consumer is built from a subscription delay and the +catalog rendition's `warmup` in one call. That call widens the subscription +and configures the consumer, so a caller can't forget the warmup or apply it +in the wrong order. Every raw consumer uses it: moq-audio, moq-c, moq-ffi's +`MoqMediaTrackConsumer`, and moq-gst's `moqsrc`. moq-ffi's raw consumer and +`moqsrc` then start early enough for a warmed-up decoder, as moq-c's +`moq_consume_audio`/`video` already do. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7723](https://github.com/moq-dev/moq/pull/7723)): milestone m1. +#7723's two follow-ups are one quest, since the simpler entry point is how +the two missing consumers get the warmup. + +- Today (`rs/moq-mux/src/container/consumer.rs:340-371`, and + `rs/moq-mux/MIGRATE.md:18`) the caller must add the warmup to the + subscription's `delay.max` before subscribing. It must then call + `with_warmup`, which carves the warmup back out, and call it before + `with_delay`. moq-audio (`decode/consumer.rs:245`) and moq-c + (`consume.rs:540-550`) do this by hand. +- Missing today: `rs/moq-ffi/src/media.rs:1717-1748` + (`MoqMediaTrackConsumer::subscribe`) and + `rs/moq-gst/src/source/imp.rs:1649-1673` subscribe with the caller's delay + and never call `with_warmup`. The deleted moq-c quest + (`quest/m1/c/raw-consume-warmup.md`, removed in `cd7f9a9a38`) wrongly + assumed moq-ffi already matched. +- Shape: one moq-mux constructor or builder takes the track or subscription + request, the `Delay`, and the warmup. It returns the widened subscription + and a consumer configured to match, or subscribes itself. Remove the + order-sensitive `with_warmup` + `with_delay` pair from the public API, + and record the break in `MIGRATE.md`. +- moq-video has its own two-decoder scheme (`decode/consumer.rs:176-185`). + Move it onto the new entry point if it fits. If not, record why here. +- Test each consumer: a test that starts a track with a nonzero catalog + warmup fails without that consumer's adoption. +- Builds on [moq-dev/moq#7697](https://github.com/moq-dev/moq/pull/7697) + (merged), which replaced the bindings' `max_delay` with + `Delay { min, max }` and edited `rs/moq-ffi/src/media.rs`. + +Public API: moq-mux's container consumer setup changes (breaking). The +bindings' subscribe surface is unchanged. Wire: none. diff --git a/quest/m1/resume-seed-17893651.md b/quest/m1/resume-seed-17893651.md new file mode 100644 index 00000000000..98e9a1d1902 --- /dev/null +++ b/quest/m1/resume-seed-17893651.md @@ -0,0 +1,33 @@ +# [XS] The resume model ends #7739's clean-end seed + +## Goal + +`moq-net`'s route-switching resume model +(`model::resume_model::readers_match_the_logical_track`) passes on seed +17893651, the clean-end stall that +[moq-dev/moq#7739](https://github.com/moq-dev/moq/pull/7739) found: a +long-budget reader whose only route ends gets the end, not a stall after +group 11. + +## Plan + +Noted 2026-11-03 (maintainer, /quest-plan of #7739's follow-ups) on the +resume-model quest that +[moq-dev/moq#7705](https://github.com/moq-dev/moq/pull/7705) finished. +#7705 fixed the fill-answer wake bug #7739 blamed for this stall, but its +checks ran seeds 1 to 16, 777, 4242, 12345 and the default, not this one. +Moved here on 2026-11-03 when merging `main` into +[moq-dev/moq#7747](https://github.com/moq-dev/moq/pull/7747) deleted that +quest. + +- Repro: `MOQ_RESUME_SEED=17893651 MOQ_RESUME_CASES=4096 cargo test -p moq-net + --all-features --release --lib model::resume_model::readers_match_the_logical_track`. +- Shrunk case: Up instance 1/slot 2, Write group 11, Join arrival reader + (Hour, default ranges, drop polling), End that route, finish=true. It + handed out group 11 and dropped 0..10, then never reported the end. +- If it passes on `main`, delete this quest. If it still fails, fix it at its + cause and add the shrunk case to `resume_model::regressions`: seed 1's + regression (`Up i1s0, Join, Write g11, End i1s0`) is similar but differs in + slot and order. + +Public API: none. Wire: none. diff --git a/quest/m1/rind/README.md b/quest/m1/rind/README.md index b9013cd7f91..da4633e70b2 100644 --- a/quest/m1/rind/README.md +++ b/quest/m1/rind/README.md @@ -68,3 +68,4 @@ The epic's own work, once every child has merged: - [Transport on rind](/quest/m1/rind/transport.md) - moq-quic, moq-tokio, moq-uring, moq-rtmp, and qmux take rind, and the `aws-lc-rs`/`ring` features go - [moq-rtc on rind](/quest/m1/rind/rtc.md) - str0m and dimpl run DTLS, SRTP, and STUN on rind - [moq-relay drops ACME for now](/quest/m1/rind/acme-remove.md) - the `acme` feature and rustls-acme go until ACME returns on rind +- [moq-crypto's signing runs on rind](/quest/m1/rind/crypto-sign.md) - Ed25519 signing and keygen leave aws-lc-rs, after moq-crypto lands diff --git a/quest/m1/rind/crypto-sign.md b/quest/m1/rind/crypto-sign.md new file mode 100644 index 00000000000..d74438e2256 --- /dev/null +++ b/quest/m1/rind/crypto-sign.md @@ -0,0 +1,32 @@ +# [S] moq-crypto's signing runs on rind + +## Goal + +moq-crypto's `sign` half signs, verifies, and generates Ed25519 keys and +randomness through rind instead of aws-lc-rs, so moq-crypto depends on no +aws-lc-rs at all. Keys and signatures already written stay byte-identical. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7702](https://github.com/moq-dev/moq/pull/7702)): milestone m1, +a child of the rind epic. The epic had no child for signing, and its final +step (removing aws-lc-rs) can't land until this one does. + +- Today `rs/moq-crypto/src/sign/key.rs`, moved from `rs/moq-sign` by #7702, + uses `aws_lc_rs::signature::{ED25519, Ed25519KeyPair, …}` and + `aws_lc_rs::rand`, and `rs/moq-crypto/Cargo.toml` holds both aws-lc-rs + and rind. +- Follow [moq-dev/moq#7570](https://github.com/moq-dev/moq/pull/7570) + (merged), whose `mesh::Signer` uses rind's `Ed25519KeyPair`. No binary + links moq-crypto's signing yet, so under the epic's rule it can switch on + rind 0.1.2 now. +- Test that keys and signatures from the aws-lc-rs build round-trip through + the rind build (fixed vectors), so stored keys keep working. +- Overlap: [the mesh key codec](https://github.com/moq-dev/moq/pull/7733) + ([moq-dev/moq#7733](https://github.com/moq-dev/moq/pull/7733)) makes + moq-auth use moq-sign's key type, which pulls aws-lc-rs into auth. This + quest removes that blocker. Whichever lands second rebases onto the + other's crate layout. + +Public API: none expected. Wire: none. diff --git a/quest/m1/subscribe-ranges/README.md b/quest/m1/subscribe-ranges/README.md index 787f43f74e3..ef0383ff8d7 100644 --- a/quest/m1/subscribe-ranges/README.md +++ b/quest/m1/subscribe-ranges/README.md @@ -101,6 +101,7 @@ every sequence delivered or dropped. - [Lite-07 ranges](/quest/m1/subscribe-ranges/lite.md) - the lite-07 wire, Rust publisher and subscriber, and the draft - [Lite-07 FETCH is single-group only](/quest/m1/subscribe-ranges/lite07-fetch.md) - lite-07 FETCH reads one group or a slice of one, and SUBSCRIBE ranges of whole groups, in Rust, JS, and the draft - [Delete the old start bookkeeping](/quest/m1/subscribe-ranges/start-bookkeeping.md) - what each lite cursor is owed and dropped lives in the model, and `TrackRun` only translates it per version +- [A bounded read that ended keeps returning None](/quest/m1/subscribe-ranges/repeated-eof.md) - a repeated read after a bounded range's end returns `Ok(None)` instead of parking ## Related diff --git a/quest/m1/subscribe-ranges/repeated-eof.md b/quest/m1/subscribe-ranges/repeated-eof.md new file mode 100644 index 00000000000..63ea1e5c629 --- /dev/null +++ b/quest/m1/subscribe-ranges/repeated-eof.md @@ -0,0 +1,44 @@ +# [S] A bounded read that ended keeps returning None + +## Goal + +Once a `moq_net::track::Subscriber` with a bounded range has returned +`Ok(None)` from `recv_group`/`next_group`, every later call returns +`Ok(None)` at once instead of parking, until an update widens its bounds. +The contract is documented on both +methods and tested on the Plain and Resume cursors. A wire publisher's +deliberate park past its bounded end (`parks`) is left as it is. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7708](https://github.com/moq-dev/moq/pull/7708)): milestone m1, +in the ranges epic, since it is the bounded-range read contract. + +- Decision prompt (maintainer, 2026-11-03): what a second read after a + bounded range's `Ok(None)` does: + - ✅ Fused: `None` again, as with Rust's `FusedStream`. + - Park until new data. + - Leave the choice to this quest. +- Refinement made while planning: the model's doc says a group outside the + bounds is held rather than skipped past, so widening the bounds later makes + it available again. Keep that. The read stays fused only until the + subscription's bounds widen. After that, reads resume over the new range. + If that reopening turns out not to be reachable through the public API, + plain fused is enough. +- Today a later read can park. The first completion returns `Ok(None)` + through `cursor.is_exhausted` (`rs/moq-net/src/model/track.rs`, Plain + arm of `poll_peek_group`). A later read goes back through + `TrackState::readable()`, which is false while the copy is idle, and parks + without reaching that check. Find the Resume arm's equivalent and make both + report exhaustion before parking. +- Tests: a bounded read that ends, then two more reads, on Plain and Resume + cursors and with `parks` off. If bounds widening is reachable, a widened + update after the end delivers the new groups. + +Public API: documented behaviour of `recv_group`/`next_group` (no +signature change). Wire: none. + +## Related + +- [Delete the old start bookkeeping](/quest/m1/subscribe-ranges/start-bookkeeping.md) - lite end semantics per cursor diff --git a/quest/m2/README.md b/quest/m2/README.md index 670e42f5e72..51c007af2ba 100644 --- a/quest/m2/README.md +++ b/quest/m2/README.md @@ -191,6 +191,10 @@ lite-07; bitrate enforcement is not part of this release. - [Drop moq-auth's iroh transport](/quest/m2/auth-drop-iroh.md) - the next breaking moq-auth release drops `Transport::Iroh` and the JS `"iroh"` value - [moq-transport finish interop](/quest/m2/ietf-finish.md) - the interop `finish` case runs on every even moq-transport draft instead of being skipped - [JS joining FETCH](/quest/m2/ietf-js-joining-fetch.md) - the JS publisher answers a joining FETCH that arrives after a quick finish, mirroring the Rust bound +- [An Absolute join never races an older-history FETCH](/quest/m2/ietf-absolute-join-race.md) - reproduce #7680's suspected collision on main, then fix it or keep the test and delete +- [Relays and moq-tokio offer versioned qmux-02 first](/quest/m2/qmux-02-subprotocols.md) - one shared qmux version list prefers 02, so JS clients negotiate it +- [A passing interop run stops publishers cleanly](/quest/m2/interop-shutdown-warnings.md) - no lingering publisher or unfinished-producer warning in a green interop run +- [Smoke tests make their certificates without a system OpenSSL config](/quest/m2/smoke-libressl.md) - moxygen and Cloudflare smoke pass `-config`, as the conformance runner does - [ashpd uses maintained D-Bus crates](/quest/m2/ashpd-maintained.md) - wait for a stable zbus 6 port, then remove the portal dependency exceptions - [Askama uses a maintained TOML parser](/quest/m2/askama-maintained.md) - wait for a stable parser migration, then remove the generator dependency exception - [Dependency and alternatives audit](/quest/m2/audit-deps.md) - every dependency earns its weight, preferring fewer, and the rest are current, deduplicated, and the best maintained option @@ -248,7 +252,6 @@ lite-07; bitrate enforcement is not part of this release. - [A kept draft-18 join pins its head group](/quest/m2/ietf-join-pin-head.md) - on draft 18, a joining FETCH that our publisher keeps open after a quick finish is answered even if the publisher drops its `track::Producer` right after `finish()` - [The JS player keeps a track's start when decoding from its first packet](/quest/m2/js-warmup-trim.md) - `@moq/watch` trims an audio track's catalog `warmup` only on a mid-stream join, as moq-audio does - [kio::Tasks tolerates a removed task's waker firing into its reused slot](/quest/m2/kio-tasks-waker-test.md) - A unit test in `rs/kio/src/task.rs` shows that when a task taken out with `Tasks::remove` wakes after another task was `insert`ed into its slot, the new occupant is polled at most once spuriously, still finishes on its own wake (handed back through `poll_each`), and its `TaskKey` still removes it -- [Nightly's Miri job stays inside its time budget](/quest/m2/miri-nightly-budget.md) - Nightly's Miri job stays inside its 60-minute job and 15-minute-per-test budgets - [moqsrc reconnects correctly whatever order events arrive in](/quest/m2/moqsrc-reconnect-order.md) - A moq-gst test reconnects `moqsrc` while a rendition pad is blocked downstream, delivering the reconnect's events - [A library recorder gets the takeover cut](/quest/m2/mux-source-cut.md) - A recorder built directly with `moq_hls::export::Broadcaster::new` ends a replaced instance's recording at what it listed when another publisher takes the broadcast over, exactly as one built through `Server::broadcaster` does - [The relay NixOS module's peer list is tested](/quest/m2/nix-relay-peers-test.md) - `nix flake check` evaluates the moq-relay NixOS module with no, one, and several `cluster.rootUrl` peers and refuses an empty list, asserting the `MOQ_CLUSTER_CONNECT` value each produces diff --git a/quest/m2/ietf-absolute-join-race.md b/quest/m2/ietf-absolute-join-race.md new file mode 100644 index 00000000000..b8377aa941b --- /dev/null +++ b/quest/m2/ietf-absolute-join-race.md @@ -0,0 +1,33 @@ +# [S] An Absolute join never races an older-history FETCH + +## Goal + +A moq-transport subscriber whose joining fill starts at an Absolute group, +while an older-history FETCH for the same track is in flight, gets every +group of both. A later join is never degraded. Otherwise, a reproduction +shows that main can't reach the collision, and this quest is deleted. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7680](https://github.com/moq-dev/moq/pull/7680)): milestone m2, +reproduce first. + +- #7680's local review, while backporting the joined-head FETCH fix, + flagged a possible pre-existing collision on main. An Absolute joining + fill and an older-history FETCH share state, and the collision degrades a + later join. It is unverified, and #7680 didn't chase it. +- Main's model differs from `release`: range fills and `Filter::Absolute` + live in `rs/moq-net/src/ietf/subscriber.rs`. Write a deterministic test + that interleaves an older-history FETCH with an Absolute join on drafts + 18, 20, and 22. If the test passes, delete the quest with the test kept as + coverage. +- Check [the fill redesign](/quest/m2/ietf-fill-refill.md) first. It deletes + the `Fill` handoff and may make this moot. If it lands first, rerun the + test against it. + +Public API: none expected. Wire: none. + +## Related + +- [A moq-transport group head fills its hole in place](/quest/m2/ietf-fill-refill.md) - the fill redesign that may remove the race diff --git a/quest/m2/ietf-hole-marker.md b/quest/m2/ietf-hole-marker.md index 32267578599..8a81a710bee 100644 --- a/quest/m2/ietf-hole-marker.md +++ b/quest/m2/ietf-hole-marker.md @@ -57,15 +57,15 @@ to the working group. Open, for this quest's interview: -- The carrier: a message on the SUBSCRIBE's request stream (drafts 18 and 22 - give each request its own stream), or a status on a group stream. +- The carrier: a message on the SUBSCRIBE's request stream (drafts 18, 20, + and 22 give each request its own stream), or a status on a group stream. - Whether the drop names its budget, as lite-07's SUBSCRIBE_DROP `Max Age` does in [Drop set](/quest/m1/drop-set.md), so a stale drop doesn't settle a wider reader. - How a publisher answering a range walks the drop set's runs in group order, and where FETCH_OK's End Location falls. -Test across Rust and JS on drafts 18 and 22, with and without the extension. +Test across Rust and JS on drafts 18, 20, and 22, with and without the extension. Draft 20 added 2026-11-03 (maintainer, /quest-plan of the follow-ups from [moq-dev/moq#7704](https://github.com/moq-dev/moq/pull/7704)), since draft 20 joined the covered drafts in [interop coverage](/quest/m1/interop-coverage/README.md). A range over a copy whose holes are all proven is answered with `0x8C` runs. A range with an unknown hole is still refused. Regression: an upstream reports G stale for a narrow subscriber while still holding G; a wider diff --git a/quest/m2/interop-shutdown-warnings.md b/quest/m2/interop-shutdown-warnings.md new file mode 100644 index 00000000000..c19b84c3ea5 --- /dev/null +++ b/quest/m2/interop-shutdown-warnings.md @@ -0,0 +1,36 @@ +# [S] A passing interop run stops publishers cleanly + +## Goal + +A passing `just test interop --all` prints neither of the +two warnings it prints today. No publisher is still running 10 s after it +was stopped, and no `track::Producer` is dropped without `finish()` or +`abort()` during the CLI FETCH round. Each warning is either fixed at its +cause or shown to be expected, in which case the harness stops printing it. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7701](https://github.com/moq-dev/moq/pull/7701)): milestone m2. + +- Publisher linger: `stop_publisher` in `test/interop/interop.sh` + (around lines 1138–1152) warns "publisher '$lang' was still running 10 s + after it was stopped; killing it". #7701 saw it for Rust. The comment near + `interop.sh:1077` says a finished import stays up for its linger + (max-age), so a longer default max-age, such as + [the 30 s default](/quest/m1/max-age-defaults.md), may outlast the 10 s. + Decide whether a stop should end the linger, or the harness should wait + for it. +- Unfinished producer: `track::Producer dropped without finish() or + abort()` (`rs/moq-net/src/model/track.rs`) during the CLI FETCH round. + Find which producer the CLI or the relay drops without finishing it, and + finish or abort it. +- Reproduce both from a passing local run with the producer warning set to + log a backtrace. Then add an assertion that a passing run logs neither + warning, so they can't return unnoticed. + +Public API: none expected. Wire: none. + +## Related + +- [Interop and Video pass on main](/quest/m0/interop-green/README.md) - red runs; this quest covers warnings in green ones diff --git a/quest/m2/perf/README.md b/quest/m2/perf/README.md index 7213f806aef..a432fb77dd4 100644 --- a/quest/m2/perf/README.md +++ b/quest/m2/perf/README.md @@ -89,7 +89,8 @@ revisions on the same host and worker count, and profiles with - [kio waiter costs](/quest/m2/perf/kio-waiter-costs.md) - long-lived waiters stop being rebuilt every poll, IETF fetch keeps one close watch per stream, and a short `kio::log` costs less - [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 - [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 -- [Cluster route memory](/quest/m2/perf/cluster-route-memory.md) - a full-mesh cluster's ~3.7 KB per route per broadcast shrinks, the in-memory hop is profiled, and `bench-profile lock` tolerates lost records +- [Cluster route memory](/quest/m2/perf/cluster-route-memory.md) - a full-mesh cluster's ~3.7 KB per route per broadcast shrinks, and the in-memory hop is profiled +- [Lock profiles find why switch records stop alternating](/quest/m2/perf/profile-lock-switches.md) - refusals stay strict and get a root cause, and lost records are sized and counted - [Small hot-path waste](/quest/m2/perf/hot-path-waste.md) - one track-name copy per lite subscription, no full-history `#drift` walk, and one header buffer per JS object - [Track-state reads skip when nothing changed](/quest/m2/perf/cursor-version-skip.md) - `Cursor::sync`, `probe` and `GroupExpiry` skip unchanged reads, then group reads move onto a Watch - [An idle TS export with a delay costs what one without does](/quest/m2/perf/ts-idle-jitter.md) - the jitter scan and memcmp stop leading the idle poll diff --git a/quest/m2/perf/cluster-route-memory.md b/quest/m2/perf/cluster-route-memory.md index f45ee0c3f26..83338f68e1b 100644 --- a/quest/m2/perf/cluster-route-memory.md +++ b/quest/m2/perf/cluster-route-memory.md @@ -2,21 +2,20 @@ ## Goal -Three follow-ups of the kio channel-contention spikes, each measured: +Two follow-ups of the kio channel-contention spikes, each measured: - The announce state a relay holds per route per broadcast in a full-mesh cluster shrinks from about 3.7 KB, so a mesh of W peers stops paying W squared times that for every broadcast, or the quest records why that state is needed. - The in-memory moq-lite hop's cost of about 140 thousand user instructions for a one-frame group is profiled (`cpu`), with the avoidable parts fixed or handed to the quest that owns them. -- `just bench-profile lock` tolerates a few lost perf records and nonalternating switch records, reporting how many it lost, instead of failing the run. ## Plan From [moq-dev/moq#7534](https://github.com/moq-dev/moq/pull/7534) (the relay-per-thread cluster spike) and [moq-dev/moq#7533](https://github.com/moq-dev/moq/pull/7533) (the replica spike). -Decided 2026-11-01 (maintainer, follow-up planning after the 2026-11-01 /quest-afk run): m2, in the perf epic, one quest for the spikes' three measurement follow-ups. +Decided 2026-11-01 (maintainer, follow-up planning after the 2026-11-01 /quest-afk run): m2, in the perf epic, one quest for the spikes' measurement follow-ups. - **Route memory.** #7534 meshed W origins over moq-lite-06 `memory` sessions, as dialed cluster peers do. Announce heap per broadcast went from 4.9 KB with one origin to 45 KB at 4 workers and 886 KB at 16 (240 routes, about 3.7 KB each), and allocations from 64 to 14,600; 10,000 broadcasts at 16 would hold about 9 GB. Real full-mesh relay clusters pay the same per route. Measure it on a relay cluster with the counting allocator (#7534's `rs/moq-relay/examples/spike_announce.rs` is in its prototype commit [`ddd8b04`](https://github.com/moq-dev/moq/commit/ddd8b042ab82c7a4d53957e31fe35942957b7dfb), not on `main`), break the 3.7 KB down by structure (origin route entry, per-session announce state, hop lists, cursors), and shrink what's duplicated per route. Check against [cluster routing](/quest/m1/cluster-routing/README.md)'s per-origin routes first, since they change what a route holds. - **Hop cost.** About 140 thousand user instructions per one-frame group across one in-memory hop; fanout's 64 subscribers spread over 15 hops raised user instructions 19%, while chat amortized it. Take a `cpu` profile of one hop and attribute it before fixing; a per-reader part belongs to [mesh session cost](/quest/m2/perf/mesh-session-cost.md), which owns the per-reader group cost. -- **`bench-profile lock`** (`bench/profile.py`): both spikes lost runs to it. #7533 could not record base chat at 16 workers on that host (every attempt lost a perf record or was refused for nonalternating switch records), and #7534 raised the perf buffer by hand (`SPIKE_PERF_BUFFER`). Raise the buffer for high-switch shapes, skip or pair up nonalternating switch records, and report the lost-record count beside the result so a reader can judge it. Cover it in `bench/profile.test.py`. +- **`bench-profile lock`**: moved to [its own quest](/quest/m2/perf/profile-lock-switches.md) on 2026-11-03 (maintainer, /quest-plan of the follow-ups from [moq-dev/moq#7742](https://github.com/moq-dev/moq/pull/7742)), which keeps refusing nonalternating switch records and finds their cause instead of tolerating them. Public API: none expected. Wire: none. diff --git a/quest/m2/perf/profile-lock-switches.md b/quest/m2/perf/profile-lock-switches.md new file mode 100644 index 00000000000..a3e1c3ee5c8 --- /dev/null +++ b/quest/m2/perf/profile-lock-switches.md @@ -0,0 +1,44 @@ +# [S] Lock profiles find why switch records stop alternating + +## Goal + +`just bench-profile lock` (`bench/profile.py`) keeps refusing a capture +whose switch records stop alternating, and the cause of those records is +found and fixed, so 16-worker captures on a quiet host complete. Lost perf +records are reduced by a larger buffer for high-switch shapes, and the +number lost is reported beside the result. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7742](https://github.com/moq-dev/moq/pull/7742)): milestone m2, +in the perf epic. The `bench-profile lock` bullet moves here from +[cluster route memory](/quest/m2/perf/cluster-route-memory.md), since it has +nothing to do with route memory. + +- Decision prompt (maintainer, 2026-11-03): cluster-route-memory said to + tolerate and count nonalternating switch records, while #7742 said to keep + refusing them: + - ✅ Strict: keep refusing, find the root cause, and drop the + tolerate-and-count bullet. + - Tolerate and count. +- Occurrences: + - #7742's second current-source capture at 16 workers was refused with + `worker moq-quic-0 (1448077) has nonalternating switch records`. No + other agent was running, so outside load is not an established cause. + - [moq-dev/moq#7533](https://github.com/moq-dev/moq/pull/7533) could not + record base chat at 16 workers. + - The [kio channel contention](/quest/m2/perf/kio-channel-contention/README.md) + notes, and the log lock profile quest #7742 deleted, also record + refusals. +- Check: the refusal is at `bench/profile.py:131`, with its test at + `bench/profile.test.py:279`. Capture the raw records of a refused run and + see whether they come from perf losing records, from records out of order + across CPUs, or from a parse error. Fix the cause in the capture or the + parser. +- Lost records: [moq-dev/moq#7534](https://github.com/moq-dev/moq/pull/7534) + raised the perf buffer by hand (`SPIKE_PERF_BUFFER`). Size the buffer for + high-switch shapes, report the lost count, and cover both in + `bench/profile.test.py`. + +Public API: none. Wire: none. diff --git a/quest/m2/performance-survey/README.md b/quest/m2/performance-survey/README.md index af36e1c973f..76fac586cb5 100644 --- a/quest/m2/performance-survey/README.md +++ b/quest/m2/performance-survey/README.md @@ -207,6 +207,7 @@ The `js/replay` nightly series and the browser smoke's `replay.json` protect it. ## Required - [Task capacity after bursts](/quest/m2/performance-survey/task-capacity.md) - memory a task set keeps after peak occupancy subsides +- [QUIC send-group capacity](/quest/m2/performance-survey/send-groups.md) - memory the scheduler's send-group slab keeps after subscription churn - [Cache metadata](/quest/m2/performance-survey/cache-metadata.md) - bookkeeping capacity after cached groups expire - [HLS request fan-out](/quest/m2/performance-survey/hls-serving.md) - repeated fetch, remux and playlist construction per viewer - [Announcement snapshots](/quest/m2/performance-survey/announced-snapshots.md) - HTTP polling cost versus result size and unrelated routes diff --git a/quest/m2/performance-survey/send-groups.md b/quest/m2/performance-survey/send-groups.md new file mode 100644 index 00000000000..906b3c529c8 --- /dev/null +++ b/quest/m2/performance-survey/send-groups.md @@ -0,0 +1,31 @@ +# [S] QUIC send-group capacity after subscription churn + +## Goal + +A measured verdict on the memory that moq-quic's scheduler keeps in its +send-group `Slab` after a connection's concurrent subscriptions peak and +fall. Either the slab gives the memory back, or the quest records why the +retained bytes per peak subscription are acceptable. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7740](https://github.com/moq-dev/moq/pull/7740)): milestone m2, +in the performance survey, with the same "measure before reclaiming" policy +as [task capacity](/quest/m2/performance-survey/task-capacity.md). + +- `rs/moq-quic/src/connection/streams/schedule.rs`: `groups: + Slab>` (around line 177) grows in `open_group`, and + `free_group` only removes the entry. Each `Group` holds a `Queue` of + BTreeMaps, priority, deficit, ring, and members. Explicit send groups are + opened per subscription (`rs/moq-net/src/lite/publisher.rs` + `session.send_group(...)`, and the same in `ietf/publisher.rs`), so a + relay connection keeps slots for its peak concurrent subscriptions. +- Measure with #7740's heap-delta approach (its `receive_bursts` + benchmark): open N subscriptions on one connection, close them, and record + retained bytes per peak subscription and how long they are held. +- If it matters at relay scale, shrink on a low-water mark, or reuse freed + slots across groups so idle entries hold no queue allocation. Otherwise + record the numbers and close. + +Public API: none. Wire: none. diff --git a/quest/m2/publish-done-codes.md b/quest/m2/publish-done-codes.md index 270574e4d1c..9b20315ae71 100644 --- a/quest/m2/publish-done-codes.md +++ b/quest/m2/publish-done-codes.md @@ -8,6 +8,6 @@ A moq-transport PUBLISH_DONE carries GOING_AWAY (0x4), TOO_FAR_BEHIND (0x5), and Follow-up of [moq-dev/moq#7396](https://github.com/moq-dev/moq/pull/7396), which did this for MALFORMED_TRACK (0x12). The stream-reset codes already map both ways in `rs/moq-net/src/ietf/error.rs:30-75`; only PUBLISH_DONE doesn't use them. -Decided 2026-10-30 (maintainer, follow-up planning after the /quest-afk run). Reuse #7396's path: the publisher picks the PUBLISH_DONE code from the same error-to-code mapping that resets the track's streams, and the subscriber reads it back as the peer's stream code. Cover drafts 18 and 22, both bindings, and JS, each test failing without its fix. +Decided 2026-10-30 (maintainer, follow-up planning after the /quest-afk run). Reuse #7396's path: the publisher picks the PUBLISH_DONE code from the same error-to-code mapping that resets the track's streams, and the subscriber reads it back as the peer's stream code. Cover drafts 18, 20, and 22, both bindings, and JS, each test failing without its fix. Draft 20 added 2026-11-03 (maintainer, /quest-plan of the follow-ups from [moq-dev/moq#7704](https://github.com/moq-dev/moq/pull/7704)), since draft 20 joined the covered drafts in [interop coverage](/quest/m1/interop-coverage/README.md). Public API: none. Wire: existing registered codes only. diff --git a/quest/m2/qmux-02-subprotocols.md b/quest/m2/qmux-02-subprotocols.md new file mode 100644 index 00000000000..297ca86d5ca --- /dev/null +++ b/quest/m2/qmux-02-subprotocols.md @@ -0,0 +1,39 @@ +# [S] Relays and moq-tokio offer versioned qmux-02 first + +## Goal + +The relay's WebSocket listener and moq-tokio's WebSocket, TCP, and Unix +clients and servers advertise versioned `qmux-02.{alpn}` subprotocol pairs +ahead of qmux-01, from one shared list. A JS client, which already offers +qmux-02 first, then negotiates qmux-02 against our relay. Older peers still +fall back to 01 or 00 as today. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7664](https://github.com/moq-dev/moq/pull/7664)): milestone m2. + +- Decision prompt (maintainer, 2026-11-03): what this quest does about + qmux-02: + - ✅ Advertise 02 first, in the relay and moq-tokio, from one shared list. + - Advertise 02 after 01. + - Leave the choice to this quest. +- Today `rs/moq-relay/src/websocket.rs:230` lists + `QMUX_VERSIONS = [QMux01, QMux00]`, and qmux-02 is accepted only as a bare + fallback. moq-tokio pins `QMux01` in `websocket.rs:548`, `tcp.rs`, + `unix.rs:16`, `server.rs`, `connection.rs`, and `webrtc.rs`. + `js/qmux/src/session.ts` already offers `qmux-02.` pairs first. + `Version::QMux02` exists in Rust (`rs/moq-quic/src/connection/mux/tests.rs`). +- Keep the per-ALPN floor (`QMUX01_ONLY_ALPNS`: moq-transport-18 and newer + need qmux-01 or later), and extend it to allow 02. +- Move the version list into one place that the relay and moq-tokio share, + as the comment beside `QMUX01_ONLY_ALPNS` asks. +- Test: a JS and a Rust client each negotiate qmux-02 against the relay and + a moq-tokio server. A client that offers only qmux-01 still connects. + +Public API: none expected. Wire: newer qmux preferred where both sides +support it. + +## Related + +- [Retire the web-transport JS qmux](/quest/m2/release/qmux-js-retire.md) - the old JS qmux publisher diff --git a/quest/m2/release/README.md b/quest/m2/release/README.md index 16198e433e0..eb86d124fd8 100644 --- a/quest/m2/release/README.md +++ b/quest/m2/release/README.md @@ -39,6 +39,7 @@ production stability proven merely because upstream artifacts published. - [Dart publication](/quest/m2/release/dart-publish.md) - the wrapper and native artifacts install from the registry - [Final libmoq stub](/quest/m2/release/libmoq-final-release.md) - publish the migration notice before removing its source - [Retire libmoq](/quest/m2/release/libmoq-retire.md) - cleanup only after that publication +- [Retire the moq-e2ee stub](/quest/m2/release/e2ee-retire.md) - delete `rs/moq-e2ee` once the cut publishes it as the final release - [Retire hand-written C](/quest/m2/release/c-retire.md) - delete the hand-written crate once generated C publishes - [Retire the web-transport JS qmux](/quest/m2/release/qmux-js-retire.md) - once `@moq/qmux` publishes from `js/qmux`, deprecate `@moq/web-socket-stream` and stop the second publisher - [moq.sh deployment](/quest/m2/release/moq-sh-deploy.md) - verify its release-triggered publication diff --git a/quest/m2/release/e2ee-retire.md b/quest/m2/release/e2ee-retire.md new file mode 100644 index 00000000000..8feba672937 --- /dev/null +++ b/quest/m2/release/e2ee-retire.md @@ -0,0 +1,26 @@ +# [XS] Retire the moq-e2ee stub + +## Goal + +`rs/moq-e2ee` is gone and the `moq-e2ee` crate is no longer published. Its +last release, a code-free crate whose README points at moq-crypto, stays on +crates.io for anyone still resolving the old name. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7702](https://github.com/moq-dev/moq/pull/7702)): milestone m2, +mirroring [Retire libmoq](/quest/m2/release/libmoq-retire.md). + +- #7702 leaves `rs/moq-e2ee` as a code-free stub, and + [the cut](/quest/m2/release/cut.md) publishes it at a version above + crates.io's 0.0.20. Check with `curl -s + https://crates.io/api/v1/crates/moq-e2ee` that the stub's version is the + newest. +- Then delete `rs/moq-e2ee` and its workspace member, so release-plz never + publishes it again, and grep for any remaining `moq-e2ee` or `moq_e2ee`. +- moq-sign was never published, so it needs no stub. + +## Required + +- [Cut and publish](/quest/m2/release/cut.md) - publishes the stub as moq-e2ee's final release diff --git a/quest/m2/release/npm-first-publish.md b/quest/m2/release/npm-first-publish.md index 48eb8261aaf..20f0c252dbc 100644 --- a/quest/m2/release/npm-first-publish.md +++ b/quest/m2/release/npm-first-publish.md @@ -32,7 +32,12 @@ real version is published by hand. `release.ts` compares against the Until the cut publishes `@moq/libav` 0.1.0, Windows `bun install` keeps failing, since `js/libav/build.ts` there unpacks the published tarball of -the workspace version. The placeholder does not change that. +the workspace version. The placeholder does not change that. Pullfrog's +review setup, which has no Nix, hits the same `@moq/libav@0.1.0 is not +published to npm yet` install failure on every run (noted 2026-11-03 from +[moq-dev/moq#7714](https://github.com/moq-dev/moq/pull/7714), e.g. +[run 41591680387](https://github.com/moq-dev/moq/actions/runs/41591680387)); +it clears with the same publication. `@moq/p2p` is out of scope: it is private with no release script, so the cut does not publish it. [Watch opts in](/quest/m2/p2p/watch.md) owns its first diff --git a/quest/m2/smoke-libressl.md b/quest/m2/smoke-libressl.md new file mode 100644 index 00000000000..dda1ed7057c --- /dev/null +++ b/quest/m2/smoke-libressl.md @@ -0,0 +1,23 @@ +# [XS] Smoke tests make their certificates without a system OpenSSL config + +## Goal + +`just test smoke moxygen` and the Cloudflare smoke test create their +self-signed certificates under LibreSSL or OpenSSL without `OPENSSL_CONF` +or a system `openssl.cnf`. + +## Plan + +Decided 2026-11-03 (maintainer, /quest-plan of the follow-ups from +[moq-dev/moq#7700](https://github.com/moq-dev/moq/pull/7700)): milestone m2. + +- #7700's moxygen smoke passed only with an explicit `OPENSSL_CONF`, because + the dev shell's LibreSSL has no system `openssl.cnf`. + `test/smoke/moxygen.sh:94` and `test/smoke/cloudflare.sh:129` run + `openssl req -x509 … -subj … -addext …` with no `-config`. +- `test/ietf-conformance/run.sh:25-40` already writes its own minimal + `openssl.cnf` and passes `-config`. Share that helper with both smoke + scripts instead of copying it. +- Verify with LibreSSL first on `PATH` and with `OPENSSL_CONF` unset. + +Public API: none. Wire: none.