diff --git a/quest/m0/ci/README.md b/quest/m0/ci/README.md index ea8bb6ce159..139cb5e08d1 100644 --- a/quest/m0/ci/README.md +++ b/quest/m0/ci/README.md @@ -163,3 +163,6 @@ The historical samples locate candidates; they are not controlled benchmarks. - [Binary release publishers run on their tag](/quest/m0/ci/release-tag-publishers.md) - brew, Go and Swift releases stop running through `workflow_run` on main - [The bench comparison builds moq-gst's catalog bench on its base](/quest/m0/ci/bench-base-build.md) - A paired bench comparison that selects `rust/gst/moq-gst/catalog` against `origin/main` builds the base side and reports a comparison, instead of marking it unavailable with "base build failed" - [The workspace-hack refuses trybuild edges and spares non-media builds](/quest/m0/ci/hakari-followups.md) - `hakari.py` refuses trybuild dev-dependency edges, and non-media Linux test builds stop needing libpipewire and libclang +- [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` diff --git a/quest/m0/ci/default-feature-test-lint.md b/quest/m0/ci/default-feature-test-lint.md new file mode 100644 index 00000000000..107eed7d21b --- /dev/null +++ b/quest/m0/ci/default-feature-test-lint.md @@ -0,0 +1,54 @@ +# [S] moq-audio's default-feature test build is clippy-clean and gated + +## Goal + +`cargo clippy --locked -p moq-audio --tests -- -D warnings` (default +features, test cfg) passes on main, and the PR gate fails a change that +breaks that configuration again. Done when that configuration is clippy-clean +and the gate covers it. + +## Plan + +Planned 2026-11-03 (maintainer, `/quest-plan`), from the +[moq-dev/moq#7652](https://github.com/moq-dev/moq/pull/7652) iterate, which +saw the same finding on its branch and on main. + +Verified on `origin/main` at `3c9facb322` (2026-11-03): + +```text +$ cargo clippy --locked -p moq-audio --tests -- -D warnings +error: methods `retains` and `fail` are never used + --> rs/moq-audio/src/encode/producer.rs:517:16 +error: could not compile `moq-audio` (lib test) due to 1 previous error +``` + +Both methods are `#[cfg(any(feature = "capture", test))]`, but their only +callers are in `rs/moq-audio/src/encode/capture.rs`, which compiles only +with `capture`. A test build without `capture` compiles them with no caller. + +Why the gate misses it: the land gate lints Rust only through the one +`just rs test` build that `sh/rs/select.sh test` runs, and that build turns on +`moq-audio/capture` and `moq-audio/playback` whenever moq-audio is selected. +So moq-audio's default-feature test build is never compiled in the gate. +[moq-dev/moq#7786](https://github.com/moq-dev/moq/pull/7786), queued on 2026-11-03, +adds `--benches --examples` and each target's `required-features` to the same +build. It keeps the capture picks, so it doesn't catch this either. + +- Fix the cfgs: gate `retains` and `fail` on `feature = "capture"` alone, or + give them a caller outside `capture`. Audit the other + `cfg(any(feature = "...", test))` items the gate's feature picks hide, in + moq-audio and moq-video. +- Cover it in the gate without a second full compile, since the gate already + has only one Rust build (see `rs/justfile`'s `test` recipe comments). One + way is a lint, for example in `just rs lint`, that refuses + `cfg(any(feature = "X", test))` on an item whose callers are all behind + `X`, if that can be checked cheaply. Otherwise, measure the cost of + linting moq-audio's and moq-video's default-feature `--tests` build when + they are selected, and bring the numbers to the maintainer if it is not + small. + +Public API: none. Wire: none. + +## Related + +- [Gate each diff in under five minutes](/quest/m0/ci/five-minutes.md) - the gate's time budget any extra build must fit diff --git a/quest/m0/ci/dependabot-workspace-hack.md b/quest/m0/ci/dependabot-workspace-hack.md new file mode 100644 index 00000000000..4da3d978ca8 --- /dev/null +++ b/quest/m0/ci/dependabot-workspace-hack.md @@ -0,0 +1,45 @@ +# [S] Dependabot leaves the workspace-hack to hakari + +## Goal + +A Dependabot cargo group PR arrives with `rs/workspace-hack/Cargo.toml` +matching `cargo hakari generate`, so nobody regenerates it by hand. Dependabot +no longer bumps the hack's transitive pins and pulls in duplicate majors. +Dependabot still updates every other cargo manifest and `Cargo.lock`. Done +when a Dependabot cargo group PR passes `cargo hakari generate --diff` (in +`just rs lint`) without a manual commit. + +## Plan + +Planned 2026-11-03 (maintainer, `/quest-plan`), from +[moq-dev/moq#7782](https://github.com/moq-dev/moq/pull/7782). Dependabot +edited the hakari-generated `rs/workspace-hack/Cargo.toml` by hand, bumping +transitive pins (rustc-hash 1→2, num-bigint, rand_chacha, spin, const-oid, +itertools, quick-xml, tower-http, windows-core). Those bumps only added +duplicate majors, and a maintainer commit had to regenerate the file back to +main's contents. Every cargo group PR does the same, since the cargo entry in +`.github/dependabot.yml` groups `"*"` from `/`. + +Options to evaluate, in this order: + +1. **Exclude the file.** Dependabot's `exclude-paths` for the cargo + ecosystem, pointing at `rs/workspace-hack/`. Risk: excluding a workspace + member may break Dependabot's workspace resolution, so it updates nothing + or fails. Test it on a fork or a scratch branch before relying on it. +2. **Ignore rules.** `ignore` entries for the hack's pins don't scale: the + pins are every unified transitive dependency, and an ignore also stops the + same crate's legitimate direct bumps. +3. **Regenerate in CI.** A workflow that runs `cargo hakari generate` on + `dependabot/cargo/*` branches and pushes the result. It needs a write + token on a pushed branch, which conflicts with + [Read-only pull-request CI](/quest/m0/ci/read-only-secrets.md); bring it + to the maintainer before building it. + +Pick the first one that works, and record the test that proved it. If none +works without a write credential, report the options to the maintainer. + +Public API: none. Wire: none. + +## Related + +- [Unify dependency features with cargo-hakari](/quest/m0/ci/hakari.md) - the workspace-hack this keeps generated diff --git a/quest/m0/ci/release-pr-after-release.md b/quest/m0/ci/release-pr-after-release.md new file mode 100644 index 00000000000..7f8a4899608 --- /dev/null +++ b/quest/m0/ci/release-pr-after-release.md @@ -0,0 +1,39 @@ +# [XS] A release merge opens no stale release PR + +## Goal + +Merging a release-plz release PR into `release` publishes that release and +opens no new release PR for the versions it just shipped. A new release PR +appears only when `release` holds unreleased changes. Done when a release +merge doesn't produce a stale release PR. + +## Plan + +Planned 2026-11-03 (maintainer, `/quest-plan`). + +[moq-dev/moq#7651](https://github.com/moq-dev/moq/pull/7651) merged at +19:33Z, and release-plz opened +[moq-dev/moq#7750](https://github.com/moq-dev/moq/pull/7750) at 19:57Z, +before 0.19.33 was published. The only change in #7750 was a second `## [0.19.33]` heading in +`rs/moq-tokio/CHANGELOG.md`, so it was closed. Release PRs routinely open +within half an hour of the previous merge +([moq-dev/moq#7009](https://github.com/moq-dev/moq/pull/7009), opened after +[moq-dev/moq#6508](https://github.com/moq-dev/moq/pull/6508) merged, was +also closed unmerged). + +The likely cause: `release-rs.yml` runs `just rs release` on every push to +`release`, and that recipe (`rs/justfile`, `release:`) runs +`release-plz release-pr` before `release-plz release`. The PR step then sees +the merged versions as unpublished and untagged, and re-proposes them. + +- Confirm the cause from the workflow run that #7651's merge started, or + from a dry run (`release-plz release-pr --dry-run` or similar) against the + merged state. +- If confirmed, run `release-plz release` first, then `release-pr`, in the + same recipe. Check how release-plz's own action orders the two commands, and + copy that order. +- Keep the change compatible with + [Rust releases publish through OIDC](/quest/m1/release-rs-oidc.md), which + edits the same workflow. + +Public API: none. Wire: none. diff --git a/quest/m0/test-flakes-2/README.md b/quest/m0/test-flakes-2/README.md index d71a34d322f..ad89b9e4b6f 100644 --- a/quest/m0/test-flakes-2/README.md +++ b/quest/m0/test-flakes-2/README.md @@ -71,7 +71,17 @@ yields covering lite-03 and lite-04, fixed by [moq-dev/moq#7663](https://github. The JS close-drain fixture advanced after the setup group's first payload, so a zero-delay subscription could expire its sender while the write budget yielded. It now reads that group through FIN before starting the next one, fixed by -[moq-dev/moq#7658](https://github.com/moq-dev/moq/pull/7658). +[moq-dev/moq#7658](https://github.com/moq-dev/moq/pull/7658). The lite-04 case +of the same test failed once more in the batch for +[moq-dev/moq#7431](https://github.com/moq-dev/moq/pull/7431) +([run 41573678257](https://github.com/moq-dev/moq/actions/runs/41573678257), +2026-11-03 03:45Z) with `Session: remote error: 0`, the cancellation that PR +explains. That batch predates #7658's merge at 15:56Z, and no queue run since +has failed it, so it needs no child of its own (noted 2026-11-03, +`/quest-plan`). + +Added 2026-11-03 (maintainer, `/quest-plan`): five more merge-queue failures +from 2026-11-03 and early 2026-11-04 UTC, one child each. Public API: none. Wire: none. @@ -80,3 +90,8 @@ Public API: none. Wire: none. - [IETF22 fallback](/quest/m0/test-flakes-2/ietf22-fallback.md) - an IETF22 browser viewer follows a fallback within the media lane's bound, keeping its session and its audio - [Browser buffering and Firefox audio-tone tests pass under load](/quest/m0/test-flakes-2/browser-media-flakes.md) - the two `harness.browser.ts` buffering tests and the Firefox player's audio-tone checks pass reliably in Interop and Nightly, each fixed at its cause under the epic's rules - [moq-tokio's close-drain test survives load](/quest/m0/test-flakes-2/tokio-close-drain.md) - `quic_client_close_drains_finished_track` stops failing land batches with "Unroutable" +- [moq-transcode's live multi-rung test survives load](/quest/m0/test-flakes-2/transcode-multi-rung.md) - `live_multi_rung` stops failing queue batches with a cancelled rung group +- [moq-relay's embedded io_uring stop test survives load](/quest/m0/test-flakes-2/relay-embed-stop.md) - `uring_custom_route_and_quic` stops seeing HTTP accepted after its owner stopped +- [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` diff --git a/quest/m0/test-flakes-2/archive-backends-identical.md b/quest/m0/test-flakes-2/archive-backends-identical.md new file mode 100644 index 00000000000..fca5b8f64fc --- /dev/null +++ b/quest/m0/test-flakes-2/archive-backends-identical.md @@ -0,0 +1,43 @@ +# [S] moq-archive's cross-backend recording test survives load + +## Goal + +`moq-archive producer::backends::recordings_are_byte_identical_on_every_backend` +(`rs/moq-archive/src/producer/backends.rs`) passes reliably in a loaded +merge-queue `just ci`, fixed at its cause, never by raising a timeout or +adding a retry. Done when the test no longer fails the queue and a loaded +local repeat of it passes. + +## Plan + +Planned 2026-11-03 (maintainer, `/quest-plan`). It failed the merge-queue +batch for [moq-dev/moq#7754](https://github.com/moq-dev/moq/pull/7754) +([run 41760215336](https://github.com/moq-dev/moq/actions/runs/41760215336), +2026-11-04 02:21Z) after 2.05 s, on the S3 backend: + +```text +FAIL [ 2.053s] ( 819/10037) moq-archive producer::backends::recordings_are_byte_identical_on_every_backend +thread 'producer::backends::recordings_are_byte_identical_on_every_backend' (1814852) panicked at rs/moq-archive/src/producer/backends.rs:198:5: +assertion `left == right` failed: S3 +``` + +Comparing the two maps in the assertion shows only the video objects +differed. The in-memory recording stored groups 2–3 in object `…02-…-…2000` +and groups 4–5 in `…04-…-…4000`. The S3 recording stored group 2 alone in +`…02`, then groups 3–4 in `…03`, then group 5 alone in `…05`. + +A likely cause is in the test's wait rather than the producer. `record` +aborts the first run once the `…02` object exists (`stored` only `head`s the +path). With a 200 ms flush, a slow S3 put can leave that object holding only +group 2 when the abort lands. The second run then correctly resumes after the +last stored group (2), so the split differs from the backends that stored +groups 2 and 3 together. + +- Confirm it, for example by delaying the S3 mock's puts. +- If confirmed, make `record` wait for the stored object to hold both groups + (decode it) before aborting, not just for it to exist. If the producer is + wrong to flush a partial object there, fix the producer instead. +- [moq-dev/moq#7752](https://github.com/moq-dev/moq/pull/7752) edits this + file. Start from whichever version is on main. + +Follow the rules in [More tests under load](/quest/m0/test-flakes-2/README.md). diff --git a/quest/m0/test-flakes-2/ffi-origin-panic.md b/quest/m0/test-flakes-2/ffi-origin-panic.md new file mode 100644 index 00000000000..a275e840879 --- /dev/null +++ b/quest/m0/test-flakes-2/ffi-origin-panic.md @@ -0,0 +1,40 @@ +# [S] moq-ffi's panicked-origin supervision test survives load + +## Goal + +`moq-ffi origin::supervision_tests::a_panicked_origin_task_reaches_the_host_while_another_origin_keeps_working` +(`rs/moq-ffi/src/origin.rs`) passes reliably in a loaded merge-queue +`just ci`, fixed at its cause, never by raising a timeout or adding a retry. +Done when the test no longer fails the queue and a loaded local repeat of it +passes. + +## Plan + +Planned 2026-11-03 (maintainer, `/quest-plan`). It failed the merge-queue +batch for [moq-dev/moq#7771](https://github.com/moq-dev/moq/pull/7771) +([run 41752982583](https://github.com/moq-dev/moq/actions/runs/41752982583), +2026-11-04 01:17Z) after 0.070 s: + +```text +FAIL [ 0.070s] ( 2086/11649) moq-ffi origin::supervision_tests::a_panicked_origin_task_reaches_the_host_while_another_origin_keeps_working +thread 'moq-ffi-worker' (1035695) panicked at rs/moq-ffi/src/ffi.rs:558:17: +injected origin driver panic +thread 'origin::supervision_tests::a_panicked_origin_task_reaches_the_host_while_another_origin_keeps_working' (1035639) panicked at rs/moq-ffi/src/origin.rs:688:9: +assertion failed: matches!(failed.next().await, Err(MoqError::Task { .. })) +``` + +The injected panic fired on the worker (`panicking_origin` in +`rs/moq-ffi/src/ffi.rs`), but the pending `announced().next()` returned +something other than `MoqError::Task`. That matters beyond the test: a host +waiting on announcements can miss the origin task's failure, which is the +behavior the test exists to prove. + +- Find what `next()` returned instead: most likely the origin closing (an end + or `Closed`) reached the read before the driver's panic was recorded as the + task's failure. +- If so, fix the order in the driver supervision, so a read the panic ends + always reports `Task`. Don't loosen the assertion. +- [moq-dev/moq#7752](https://github.com/moq-dev/moq/pull/7752) edits + `rs/moq-ffi/src/ffi.rs`. Start from whichever version is on main. + +Follow the rules in [More tests under load](/quest/m0/test-flakes-2/README.md). diff --git a/quest/m0/test-flakes-2/js-worklet-build.md b/quest/m0/test-flakes-2/js-worklet-build.md new file mode 100644 index 00000000000..d34ea2fd5b8 --- /dev/null +++ b/quest/m0/test-flakes-2/js-worklet-build.md @@ -0,0 +1,37 @@ +# [S] The JS worklet library-build test survives load + +## Goal + +"library builds load worklets from a lazy blob or a hosted base, leaving no +child process" (`js/common/worklet.test.ts`) passes reliably in a loaded +merge-queue `just ci`, fixed at its cause, never by raising a timeout or +adding a retry. Done when the test no longer fails the queue and a loaded +local repeat of it passes. + +## Plan + +Planned 2026-11-03 (maintainer, `/quest-plan`). It timed out in the +merge-queue batch for [moq-dev/moq#7536](https://github.com/moq-dev/moq/pull/7536) +([run 41700523666](https://github.com/moq-dev/moq/actions/runs/41700523666), +2026-11-03 19:13Z): + +```text +#[group]js/common/worklet.test.ts: +(fail) library builds load worklets from a lazy blob or a hosted base, leaving no child process [5004.51ms] + ^ this test timed out after 5000ms. +(pass) the dev server serves hosted worklets where builds emit them [803.45ms] +``` + +This test already failed the queue once and was counted fixed in the epic's +2026-10-26 entry. It runs a real `vite build` of a one-line worklet, so a +loaded host can push one build past bun's default 5-second test timeout. + +- Measure where the time goes under load: Vite's startup, the plugin's + in-process worklet bundle, or a wait on a child process. +- If the build is slow because the plugin does needless work, make it cheaper. + If it is a whole Vite build that no smaller unit can replace, move the check + to a cheaper level, for example by testing the plugin's transform without + a full build, and keep one build where it is cheap enough to stay reliable. +- A longer per-test timeout is not a fix under the epic's rules. + +Follow the rules in [More tests under load](/quest/m0/test-flakes-2/README.md). diff --git a/quest/m0/test-flakes-2/relay-embed-stop.md b/quest/m0/test-flakes-2/relay-embed-stop.md new file mode 100644 index 00000000000..b7b0c9a22f8 --- /dev/null +++ b/quest/m0/test-flakes-2/relay-embed-stop.md @@ -0,0 +1,36 @@ +# [S] moq-relay's embedded io_uring stop test survives load + +## Goal + +`moq-relay::integration embed::uring_custom_route_and_quic` +(`rs/moq-relay/tests/integration/embed.rs`) passes reliably in a loaded +merge-queue `just ci`, fixed at its cause, never by raising a timeout or +adding a retry. Done when the test no longer fails the queue and a loaded +local repeat of it passes. + +## Plan + +Planned 2026-11-03 (maintainer, `/quest-plan`). It failed the merge-queue +batch for [moq-dev/moq#7753](https://github.com/moq-dev/moq/pull/7753) +([run 41736459964](https://github.com/moq-dev/moq/actions/runs/41736459964), +2026-11-03 23:06Z) after 0.371 s, while its `shared_tokio` and `worker_tokio` +siblings passed: + +```text +FAIL [ 0.371s] (7970/9724) moq-relay::integration embed::uring_custom_route_and_quic +thread 'embed::uring_custom_route_and_quic' (3744147) panicked at rs/moq-relay/tests/integration/embed.rs:51:5: +HTTP still accepted after the owner stopped +``` + +`assert_owner_stopped` connects to the HTTP port after the owner stops and +expects a refusal. + +- Find out whether the io_uring listener was still open (the stop returned + before its accept socket closed) or another test bound the freed ephemeral + port in between. The relay's auth-trust flake was a reused port + ([moq-dev/moq#7550](https://github.com/moq-dev/moq/pull/7550)). +- If the listener outlives the stop, fix the stop so it returns only after + the socket closes. If the port was reused, prove the close another way, for + example with the socket-inode check the QUIC half already uses on Linux. + +Follow the rules in [More tests under load](/quest/m0/test-flakes-2/README.md). diff --git a/quest/m0/test-flakes-2/transcode-multi-rung.md b/quest/m0/test-flakes-2/transcode-multi-rung.md new file mode 100644 index 00000000000..230fc09383c --- /dev/null +++ b/quest/m0/test-flakes-2/transcode-multi-rung.md @@ -0,0 +1,42 @@ +# [S] moq-transcode's live multi-rung test survives load + +## Goal + +`moq-transcode tests::live_multi_rung` (`rs/moq-transcode/src/lib.rs`) passes +reliably in a loaded merge-queue `just ci`, fixed at its cause, never by +raising a timeout or adding a retry. Done when the test no longer fails the +queue and a loaded local repeat of it passes. + +## Plan + +Planned 2026-11-03 (maintainer, `/quest-plan`). It failed two merge-queue +batches on 2026-11-03, both with the same panic: + +- [Run 41599906715](https://github.com/moq-dev/moq/actions/runs/41599906715), + the batch for [moq-dev/moq#7544](https://github.com/moq-dev/moq/pull/7544), + at 08:03Z after 0.909 s. +- [Run 41666527065](https://github.com/moq-dev/moq/actions/runs/41666527065), + the batch for [moq-dev/moq#7692](https://github.com/moq-dev/moq/pull/7692), + at 15:44Z after 1.566 s. + +```text +FAIL [ 1.566s] (9500/9597) moq-transcode tests::live_multi_rung +thread 'tests::live_multi_rung' (26884) panicked at rs/moq-transcode/src/lib.rs:550:52: +called `Result::unwrap()` on an `Err` value: Cancel +``` + +Line 550 is the `group.read_frame().await.unwrap()` that drains each rung's +first group, so a rung's output group was cancelled before it held all five +source frames. + +- The test runs in real time on purpose: its comment says a paused clock let + the source outrun the feed's bounded broadcast while the rungs encoded on + their own threads. Under load, real time can do the same thing. Find what + cancels the rung's group: the feed's lag, a superseding group, or the rung + restarting its encoder. +- Follow the epic's rules: drive the source from an event the rungs report, + or from a `kio::clock::Manual` clock, rather than a wall-clock pace. If the + code under test drops a group it should finish, fix the code. +- Reproduce it under load first, for example beside a full `cargo nextest`. + +Follow the rules in [More tests under load](/quest/m0/test-flakes-2/README.md). diff --git a/quest/m1/README.md b/quest/m1/README.md index f64f2da4201..7de63409ff6 100644 --- a/quest/m1/README.md +++ b/quest/m1/README.md @@ -178,6 +178,9 @@ per-frame CPU growth since #5926. - [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 +- [A hardware decoder's capability refusal is an unsupported config](/quest/m1/hw-decoder-refusal.md) - a GPU that can't decode a stream reports `UnsupportedConfig`, so callers fall back to another rendition +- [A JS audio capture gap keeps the audio before it](/quest/m1/js-audio-gap-flush.md) - every capture gap flushes the `AudioEncoder` before restarting it, like a disable +- [A draft-18 resume of a cached group under a finite max-age settles](/quest/m1/ietf18-resume-cached-start.md) - the read delivers the group or refuses at once, never hangs ## Related diff --git a/quest/m1/hw-decoder-refusal.md b/quest/m1/hw-decoder-refusal.md new file mode 100644 index 00000000000..589e95dc852 --- /dev/null +++ b/quest/m1/hw-decoder-refusal.md @@ -0,0 +1,49 @@ +# [M] A hardware decoder's capability refusal is an unsupported config + +## Goal + +When every decoder that would take a codec refuses it because the device +can't decode that stream (for example an HEVC profile, a bit depth, or AV1 on +a GPU that lacks it), video subscribe reports `UnsupportedConfig`, not a +backend fault. A caller such as OBS can then fall back to another rendition, +as it can for codecs this build can't decode at all. OBS's audio already +falls back on `UnsupportedConfig` (`cpp/obs/src/moq-source.cpp`). Its video +still decodes with FFmpeg until [OBS native codecs](/quest/m2/obs-moq-video/README.md) +lands. Missing drivers, no device, and library faults stay faults. Done when +a capability refusal from each hardware backend that can detect one surfaces +as `MoqError::UnsupportedConfig` through moq-ffi and moq-c, and a probe-backed +test shows a mixed refusal and fault still reports a fault. + +## Plan + +Planned 2026-11-03 (maintainer, `/quest-plan`), from the follow-ups of +[moq-dev/moq#7730](https://github.com/moq-dev/moq/pull/7730), which typed +decoder setup refusals. That PR settled (✅, maintainer) that +`UnsupportedConfig` covers only a known-unsupported codec, layout, or +description, and that typed backend faults are never folded into it. This +quest keeps that rule: it makes a hardware backend know when it can't decode +a stream. + +Today `select` in `rs/moq-video/src/decode/backend/mod.rs` returns +`Error::NoDecoder` (a fault) when every candidate that takes the codec fails +to open, whatever the reason. The consumer maps only `UnsupportedCodec` to +`UnsupportedConfig` (`rs/moq-video/src/decode/consumer.rs`). + +- Give the backend open path a typed refusal, distinct from a fault, for a + stream the device reports it can't decode. Each backend needs its own + capability query or error code: VideoToolbox, VA-API (profile and + entrypoint lists), NVDEC (decode caps), Media Foundation, MediaCodec, and + V4L2. A backend that can't tell the two apart keeps reporting a fault. +- `select` reports `UnsupportedCodec` only when every tried candidate refused + by capability. If any candidate faulted, the result stays `NoDecoder`. + `Auto` with a working software fallback is unaffected. +- Test it with the probe decoders (`backend/probe.rs`), so it doesn't depend + on the host GPU. Run the real-backend checks on whichever hosts have one, + such as kixtop for VideoToolbox. + +Public API: no new variants. More setups reach `UnsupportedConfig` instead of +`Video`. Note that in each binding's MIGRATE.md. Wire: none. + +## Related + +- [OBS native codecs](/quest/m2/obs-moq-video/README.md) - the OBS source whose rendition fallback this feeds diff --git a/quest/m1/ietf18-resume-cached-start.md b/quest/m1/ietf18-resume-cached-start.md new file mode 100644 index 00000000000..93418a654bc --- /dev/null +++ b/quest/m1/ietf18-resume-cached-start.md @@ -0,0 +1,44 @@ +# [M] A draft-18 resume of a cached group under a finite max-age settles + +## Goal + +On moq-transport draft-18, a track copy that went idle holding a group +resumes a bounded subscription of that group after the upstream moved on. +When the publisher's max-age is finite, the read either delivers the group, +as moq-lite and drafts 20 and 22 do, or ends at once with a refusal the +reader can see. It never waits forever for a group that won't come. Done when +`a_resumed_bounded_subscription_keeps_its_cached_start` runs every version +with an explicit finite max-age (30 s) and asserts each version's outcome, +with no draft-18-specific fallback added. + +## Plan + +Planned 2026-11-03 (maintainer, `/quest-plan`), from the follow-ups of +[moq-dev/moq#7729](https://github.com/moq-dev/moq/pull/7729). The problem +predates that PR, since media tracks were already 30 s. It surfaced when +raw tracks became finite. + +The read asks for group 0 below the copy's live floor. A finite budget can't +judge a group below that floor (`TrackState::cache_floor` in +`rs/moq-net/src/model/track.rs`), so the copy must fill it from upstream. +moq-lite and drafts 20 and 22 do that. Draft-18 doesn't, and the read never +gets group 0. + +- Reproduce it with `a_resumed_bounded_subscription_keeps_its_cached_start` + (`rs/moq-net/tests/integration/fetch_only.rs`). Give its track an explicit + finite max-age, such as 30 s, rather than relying on a default. #7729 is + changing the authored default to 0 s unless the publisher asks for more + (maintainer, 2026-11-03), so a default would test a different case. +- Follow the standing rule for moq-transport FETCH versus SUBSCRIBE: pick the + simplest path and accept a refusal on the awkward draft rather than add a + draft-specific fallback. If draft-18 can fill the group through the path + the other drafts already use, use it. Otherwise end the read with a + refusal, and have the test assert that for draft-18, as the multi-group + FETCH test beside it already does. +- moq-lite's behavior keeps full correctness. Don't change it to match. + +Public API: none. Wire: none. + +## Related + +- [A kept draft-18 join pins its head group](/quest/m2/ietf-join-pin-head.md) - another draft-18 read that the publisher's lifecycle cuts short diff --git a/quest/m1/js-audio-gap-flush.md b/quest/m1/js-audio-gap-flush.md new file mode 100644 index 00000000000..ec2b1d658e0 --- /dev/null +++ b/quest/m1/js-audio-gap-flush.md @@ -0,0 +1,38 @@ +# [S] A JS audio capture gap keeps the audio before it + +## Goal + +In `@moq/publish`, a gap in audio capture (a lost track or a capture +discontinuity, not a disable) publishes every chunk the `AudioEncoder` still +holds for the audio before the gap, then restarts the codec for the audio +after it. This includes a gap inside replayed history, where today most of +the frames one backlog drain submits are lost. Done when every gap goes +through the same flush-then-restart path as a disable, and a test with a gap +in the middle of a replayed backlog publishes every frame on both sides of +it. + +## Plan + +Planned 2026-11-03 (maintainer, `/quest-plan`), from the follow-ups of +[moq-dev/moq#7725](https://github.com/moq-dev/moq/pull/7725). That PR made a +disable flush the codec before placing its break marker and restarting it +(`cutAfterFlush` in `js/publish/src/audio/encoder.ts`). It deliberately left +capture gaps on their old path: `submit` calls `encoder.reset()` and +`configure()` as soon as a frame's timestamp isn't contiguous, which throws +away the chunks still in flight. Its comment says those chunks predate the gap, +and they do, so they are audio the publisher had and drops. + +- Route a non-contiguous frame through the flush-then-restart path: flush, + publish what the codec emits, place the gap's marker, restart, then encode + the frame after the gap. Frames that arrive during the flush must wait + rather than reach the old codec; the disable path resumes its drain only + once the flush ends. +- Keep Chrome's output-clock re-base, which is why the restart exists. +- Cover a live gap and a gap inside a replayed backlog, and check that the + marker sits after every pre-gap chunk. + +Public API: none. Wire: none. + +## Related + +- [Push-to-talk loses no speech](/quest/m1/push-to-talk/README.md) - the same encoder kept alive across a mute diff --git a/quest/m2/README.md b/quest/m2/README.md index a0364c7a4d3..670e42f5e72 100644 --- a/quest/m2/README.md +++ b/quest/m2/README.md @@ -278,3 +278,7 @@ lite-07; bitrate enforcement is not part of this release. - [fMP4 import at 1-byte chunks is no slower than before](/quest/m2/fmp4-byte-chunk-perf.md) - bisect and fix or accept the ~19% slowdown at 1-byte chunks - [The relay bench reports io_uring pool size and RSS](/quest/m2/bench-uring-pool.md) - pool growth regressions show up in normal bench runs - [MKV imports ffmpeg's multichannel FLAC](/quest/m2/mkv-flac-channel-mask.md) - a channel-mask-only Vorbis comment is accepted, so default ffmpeg multichannel FLAC needs no remux +- [The bindings' TrackInfo docs list its real fields](/quest/m2/track-info-docs.md) - Swift, Kotlin and Dart stop naming ordering and latency budget on `TrackInfo` +- [Kotlin dependencies live in a Gradle version catalog](/quest/m2/kt-version-catalog.md) - one catalog entry per library, so a Dependabot bump can't drag another along +- [The dev shell builds Kotlin with Gradle 9](/quest/m2/kt-gradle-9.md) - `gradle_9` in the dev shell, so the Android target builds there +- [The publish support panel lists only codecs publishing accepts](/quest/m2/publish-support-probe.md) - the settings panel runs the publisher's Annex B encoder probe diff --git a/quest/m2/kt-gradle-9.md b/quest/m2/kt-gradle-9.md new file mode 100644 index 00000000000..8eca80c751e --- /dev/null +++ b/quest/m2/kt-gradle-9.md @@ -0,0 +1,34 @@ +# [S] The dev shell builds Kotlin with Gradle 9 + +## Goal + +The dev shell's Kotlin toolchain (`ktDeps` in `flake.nix`) ships `gradle_9` +instead of `gradle_8`, so the Android target can be built from the dev shell. +Done when `just kt check` passes on the dev shell's Gradle 9, and +`gradle -Pandroid.enabled=true :moq-ffi:assembleRelease :moq:assembleRelease` +builds both AARs from the dev shell on a host with an Android SDK. + +## Plan + +Planned 2026-11-03 (maintainer, `/quest-plan`), from the follow-ups of +[moq-dev/moq#7562](https://github.com/moq-dev/moq/pull/7562). Gradle 8 +can't configure the Android target on any AGP 9.x, including the 9.4.1 that +main had before #7562. AGP 9.5.0 needs Gradle 9.6.0 or later. #7562 built +the AARs with Gradle 9.8.0 outside the dev shell. The release runner's +Gradle 9.8.2 already publishes them. + +The `flake.nix` comment pins Gradle 8 because "Kotlin 2.0.21's Gradle plugin +predates Gradle 9", but `kt/build.gradle.kts` is on Kotlin 2.4.21, so that +reason no longer holds. The pinned nixpkgs has `gradle_9` at 9.8.0. + +- Swap `gradle_8` for `gradle_9` in `ktDeps` and rewrite the comment with the + current constraint (AGP 9.x needs Gradle 9). +- Run `just kt check` on Linux and macOS (kixtop). Fix any Gradle 9 + deprecation that is now an error. +- The dev shell has no Android SDK, so the Android build still needs + `ANDROID_HOME`. Adding an SDK to the default shell is out of scope. Ask + the maintainer before adding one. +- Check that `.github/workflows/android.yml` and the release workflows still + agree with the dev shell's Gradle major. + +Public API: none. Wire: none. diff --git a/quest/m2/kt-version-catalog.md b/quest/m2/kt-version-catalog.md new file mode 100644 index 00000000000..c4186e1f5f2 --- /dev/null +++ b/quest/m2/kt-version-catalog.md @@ -0,0 +1,32 @@ +# [XS] Kotlin dependencies live in a Gradle version catalog + +## Goal + +`kt/` declares its library and plugin versions once, in a Gradle version +catalog (`kt/gradle/libs.versions.toml`), with one entry per library. A +Dependabot bump of one `org.jetbrains.kotlinx` library then can't rewrite +another that happens to share its version string. Done when no +`kt/**/*.gradle.kts` file spells a dependency version inline, and +`just kt check` passes. + +## Plan + +Planned 2026-11-03 (maintainer, `/quest-plan`), from the follow-ups of +[moq-dev/moq#7562](https://github.com/moq-dev/moq/pull/7562). Dependabot's +Gradle updater rewrites every `org.jetbrains.kotlinx` line in a build script +that shares the old version string, so a serialization bump can drag +coroutines along once both sit on the same version. +`kt/moq/build.gradle.kts` and `kt/moq-ffi/build.gradle.kts` spell +`kotlinx-coroutines-*` and `kotlinx-serialization-json` versions inline. + +- Move the libraries into `[versions]` and `[libraries]`, with a separate + version key per library family (coroutines, serialization). Move the + plugin versions into `[plugins]` too, requested with `alias(...)`: Kotlin, + maven-publish and Dokka in `kt/build.gradle.kts`, and the Android plugin + pinned in `kt/settings.gradle.kts`'s `pluginManagement`. +- Keep `kt/`'s Dependabot entry (`directory: "/kt"`, group `gradle`). + Dependabot reads `gradle/libs.versions.toml` under that directory. +- Leave `moqffi.version` and `moq.version` in `gradle.properties`: they are + this repository's own published versions, not dependencies. + +Public API: none. Wire: none. diff --git a/quest/m2/publish-support-probe.md b/quest/m2/publish-support-probe.md new file mode 100644 index 00000000000..898fb0df79e --- /dev/null +++ b/quest/m2/publish-support-probe.md @@ -0,0 +1,30 @@ +# [S] The publish support panel lists only codecs publishing accepts + +## Goal + +The `` settings panel (`js/publish/src/support/`) +decides video encode support with the same encoder setup probe the publisher +uses, including the Annex B output check. On Safari it stops listing HEVC as +supported when publishing would skip it. Done when the panel and the +publisher share one probe, and a test with an encoder that emits +length-prefixed output shows the panel reporting that codec unsupported. + +## Plan + +Planned 2026-11-03 (maintainer, `/quest-plan`), from the follow-ups of +[moq-dev/moq#7765](https://github.com/moq-dev/moq/pull/7765), which makes +the publisher refuse an encoder whose output ignores the requested Annex B +format (`probeEncoder` in `js/publish/src/video/encoder.ts`). Safari's HEVC +encoder does that. The panel's `probe` (`js/publish/src/support/video.ts`) +still trusts `VideoEncoder.isConfigSupported` alone. + +- Start once #7765 has merged, since its probe is what this reuses. +- Share one probe rather than copy it. Move it somewhere both modules + import, and keep the panel's software/hardware split, which runs a probe + per acceleration preference. +- The output check encodes a real frame, which costs more than + `isConfigSupported`. Cache the result per codec and preference if the + panel probes repeatedly. + +Public API: none. The panel's output changes on browsers whose encoder +ignores Annex B. Wire: none. diff --git a/quest/m2/track-info-docs.md b/quest/m2/track-info-docs.md new file mode 100644 index 00000000000..d1039bff7ef --- /dev/null +++ b/quest/m2/track-info-docs.md @@ -0,0 +1,28 @@ +# [XS] The bindings' TrackInfo docs list its real fields + +## Goal + +The `TrackInfo` alias docs in Swift (`swift/Sources/Moq/Aliases.swift`), +Kotlin (`kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/Aliases.kt`) and Dart +(`dart/moq/lib/src/aliases.dart`) name only fields `MoqTrackInfo` has. Done +when each alias doc matches the record's fields, and no other binding's +`TrackInfo` doc names a field the record lacks. + +## Plan + +Planned 2026-11-03 (maintainer, `/quest-plan`), from the follow-ups of +[moq-dev/moq#7729](https://github.com/moq-dev/moq/pull/7729). + +The docs say "priority, ordering, latency budget, and timescale" (Kotlin, +Dart) and "priority, group ordering, max age, and timescale" (Swift). +`MoqTrackInfo` (`rs/moq-ffi/src/producer.rs`) has `priority`, `max_age`, +`refresh`, `timescale` and `compress`. Ordering and delay are subscriber-side +(`MoqSubscription`). #7729 adds `max_age_unlimited`, so describe the record +as it stands when this lands. + +- Name the fields, or describe the record's purpose without a list that can + drift. Prefer the one-line purpose plus a pointer to the record, so a new + field doesn't make the alias wrong again. +- Check the Python, Go, C and C++ wrappers' equivalents the same way. + +Public API: docs only. Wire: none.