diff --git a/quest/m1/interop-coverage/README.md b/quest/m1/interop-coverage/README.md index 4cda43b181f..e14329cece8 100644 --- a/quest/m1/interop-coverage/README.md +++ b/quest/m1/interop-coverage/README.md @@ -40,7 +40,9 @@ coverage on `main` at `3ab6cbf81d`. ## Required -- [Runner cases](/quest/m1/interop-coverage/runner-cases.md) - our runner clients run data-subgroup-basic and subscribe-namespace-lifecycle +- [Runner cases](/quest/m1/interop-coverage/runner-cases.md) - our runner clients' data-subgroup-basic and subscribe-namespace-lifecycle land upstream and go green on the report +- [JS namespace lifecycle](/quest/m1/interop-coverage/js-namespace-done.md) - moq-dev-js subscribe-namespace-lifecycle sees NAMESPACE_DONE with publisher and subscriber in one process +- [JS subgroup data through imquic](/quest/m1/interop-coverage/js-imquic-objects.md) - moq-dev-js data-subgroup-basic receives objects from imquic over WebTransport - [Late join and FETCH](/quest/m1/interop-coverage/late-join.md) - a late subscriber gets the current group from object 0, and a standalone FETCH returns a past group exactly - [Control cases](/quest/m1/interop-coverage/control.md) - GOAWAY redirect, TRACK_STATUS, datagrams, and request-ID limits pass across implementations diff --git a/quest/m1/interop-coverage/js-imquic-objects.md b/quest/m1/interop-coverage/js-imquic-objects.md new file mode 100644 index 00000000000..9c497d24dbf --- /dev/null +++ b/quest/m1/interop-coverage/js-imquic-objects.md @@ -0,0 +1,23 @@ +# [S] JS subgroup data reaches the subscriber through imquic + +## Goal + +The runner's moq-dev-js `data-subgroup-basic` case passes against imquic +(draft-22, WebTransport), where today the subscriber receives no objects. +If the cause is in imquic, it is reported upstream and the cell is +classified instead. + +## Plan + +Found in the runs for +[englishm/moq-interop-runner#173](https://github.com/englishm/moq-interop-runner/pull/173) +on 2026-10-22. moq-dev-rs passes against imquic on the same draft, so +compare what the two clients put on the wire (transport, SUBSCRIBE +fields, stream types) before suspecting imquic. + +Public API: unknown until the cause is found. Wire: none expected. + +## Related + +- [Runner cases](/quest/m1/interop-coverage/runner-cases.md) - lands the + client case this cell runs diff --git a/quest/m1/interop-coverage/js-namespace-done.md b/quest/m1/interop-coverage/js-namespace-done.md new file mode 100644 index 00000000000..7d45234b377 --- /dev/null +++ b/quest/m1/interop-coverage/js-namespace-done.md @@ -0,0 +1,24 @@ +# [S] JS namespace lifecycle passes with both halves in one process + +## Goal + +The runner's moq-dev-js `subscribe-namespace-lifecycle` case passes against +Cloudflare draft-18 and aiomoqt, where today the subscriber never sees +NAMESPACE_DONE. If the cause is in the relay under test, it is reported +upstream and the cell is classified instead. + +## Plan + +Found in the runs for +[englishm/moq-interop-runner#173](https://github.com/englishm/moq-interop-runner/pull/173) +on 2026-10-22. It fails only when the JS publisher and subscriber share one +process. Each half passes with a Rust counterpart, and two separate Bun +processes pass, so suspect state the two `js/net` sessions share in one +process before suspecting the relays. A fix in `js/net` gets a test there. + +Public API: unknown until the cause is found. Wire: none expected. + +## Related + +- [Runner cases](/quest/m1/interop-coverage/runner-cases.md) - lands the + client case this cell runs diff --git a/quest/m1/interop-coverage/runner-cases.md b/quest/m1/interop-coverage/runner-cases.md index b4df1e8cbaa..886c15fbbdd 100644 --- a/quest/m1/interop-coverage/runner-cases.md +++ b/quest/m1/interop-coverage/runner-cases.md @@ -1,26 +1,59 @@ -# [M] Our runner clients run the subgroup and namespace cases +# [XS] Our runner cases land upstream ## Goal -The moq-dev-rs and moq-dev-js clients in -[englishm/moq-interop-runner](https://github.com/englishm/moq-interop-runner) -implement `data-subgroup-basic` and `subscribe-namespace-lifecycle` -(moq-dev-js lacks both, moq-dev-rs lacks the first), and both pass against -moq-relay. +[englishm/moq-interop-runner#172](https://github.com/englishm/moq-interop-runner/pull/172) +(moq-dev-rs `data-subgroup-basic`) and +[englishm/moq-interop-runner#173](https://github.com/englishm/moq-interop-runner/pull/173) +(moq-dev-js `subscribe-namespace-lifecycle` and `data-subgroup-basic`) +are merged, the moq-dev client images are rebuilt, and the runner's report +shows both clients passing those cases against moq-relay. Check the PRs +with `gh pr view -R englishm/moq-interop-runner` and the cells on the +nightly report. Then delete this quest. ## Plan -Decided with the maintainer on 2026-10-21. These cases exist in the -runner's `docs/TEST-SPECIFICATIONS.md`, so implement them in our clients -there rather than in-tree; the [interop audit](/quest/m0/audit-interop.md)'s -standing approval covers PRs touching the `moq-dev-*` builds. - -As of the runner report of 2026-10-19, moq-relay fails -`data-subgroup-basic` from third-party clients: objects carry one extension -where zero were sent, group 0 is missing, and END_OF_TRACK arrives where -END_OF_GROUP was expected. moq-relay passing that case is part of this -quest. `subscribe-namespace-lifecycle` from our Rust client times out -against moxygen, quic-zig, and Cloudflare draft-14, likely the draft-14 -empty-prefix bug the interop audit owns. +Both PRs were tested on 2026-10-22 against moq-relay from `main` and from +the 0.17.7 release, on drafts 14 through 22 and on moq-lite, and both pass. +The report runs the published packages and images, so it turns green +only after the PRs merge and the client images are rebuilt. The rebuild is +already requested in +[englishm/moq-interop-runner#170](https://github.com/englishm/moq-interop-runner/pull/170). + +Why the report showed moq-relay failing `data-subgroup-basic` against +Cloudflare's moq-test-client (draft-18): + +- Ours: every forwarded object carried an extra property, the Timestamp + that released relays stamp on every object, even on a track that + declared no timescale. Fixed on `main` by + [moq-dev/moq#5083](https://github.com/moq-dev/moq/pull/5083), and it + turns green once a relay release ships it. +- Theirs: the publisher writes its first object while it answers the + relay's SUBSCRIBE, so SUBSCRIBE_OK's Largest Location is (0, 0), and it + refuses the relay's joining FETCH (REQUEST_ERROR 3). moq-relay joins the + live edge with Largest Object plus a joining FETCH (draft-18 §5.1.3), + which is the draft's own join, so object 0 is lost. When the group's + stream arrives before the refusal, all of group 0 is lost. +- Disputed: the client fails on any status object other than End of Group. + moq-relay ends the track with END_OF_TRACK at (3, 0), which draft-18 + allows (§11.2.1.1). The runner's data-plane conventions leave status + objects out of verification. + +Both are reported upstream, in +[cloudflare/moq-rs#281](https://github.com/cloudflare/moq-rs/issues/281) +and [cloudflare/moq-rs#282](https://github.com/cloudflare/moq-rs/issues/282). +moq-relay keeps its END_OF_TRACK (decided 2026-10-22). The group that +moq-relay drops when the joining FETCH is refused is +[headless moq-transport groups](/quest/m2/ietf-headless-group.md). + +The moq-dev-rs `subscribe-namespace-lifecycle` timeouts in the report come +from the stale client image. Rebuilt from the runner's current source, it +passes against moxygen and Cloudflare draft-18. Cloudflare draft-14 has no +SUBSCRIBE_NAMESPACE, so that cell is unsupported. + +Two moq-dev-js cells from the runs for #173 still fail, with causes not +yet found: +[JS namespace lifecycle in one process](/quest/m1/interop-coverage/js-namespace-done.md) +and [JS subgroup data through imquic](/quest/m1/interop-coverage/js-imquic-objects.md). Public API: none. Wire: none. diff --git a/quest/m2/README.md b/quest/m2/README.md index 79fe6fff086..d373ef27419 100644 --- a/quest/m2/README.md +++ b/quest/m2/README.md @@ -64,6 +64,7 @@ ranked just below deterministic TS legs, which it requires. - [V4L2 virtual camera](/quest/m2/v4l2-virtual-camera.md) - V4L2 capture runs nightly against the `vivid` virtual driver instead of only on a developer's camera - [Probe](/quest/m2/probe/README.md) - a session probes up to the bitrate it wants to send or receive, so a stopped simulcast rendition resumes and a viewer up-switches; the browser pads where native sessions retransmit - [Failed groups reach the publisher](/quest/m2/group-failed.md) - Rust and both JS publishers surface a group whose delivery a subscriber's stream gave up on, with one shape +- [Headless moq-transport groups](/quest/m2/ietf-headless-group.md) - a group whose head no fill or joining FETCH supplies keeps its tail instead of being dropped, and a relay forwards it to moq-transport subscribers - [A finished PROBE stops reporting](/quest/m2/probe-end-stale.md) - the Rust receive estimate reads unknown once its PROBE stream ends - [Wire stats](/quest/m2/wire-stats/README.md) - `Presence` counts each root's transport bytes on the wire, `wire_tx` and `wire_rx`, from QUIC, WebSocket, and embedder gateway sources - [Media stats](/quest/m2/stats/README.md) - publishers announce a stats track in the catalog, viewers answer a soliciting catalog through a per-catalog `.echo` broadcast, and one model turns both into a health verdict and a preflight report diff --git a/quest/m2/ietf-headless-group.md b/quest/m2/ietf-headless-group.md new file mode 100644 index 00000000000..9d3a97ace83 --- /dev/null +++ b/quest/m2/ietf-headless-group.md @@ -0,0 +1,76 @@ +# [M] Keep a moq-transport group whose head never arrives + +## Goal + +When a moq-transport subscription delivers a group starting partway through +and the fill or joining FETCH that should supply its head is refused or +ends empty, moq-net keeps the tail as a group that starts at that object. +Today, depending on a race, it either drops the whole group or keeps the +tail as if it were the whole group. A relay then forwards the tail to its +moq-transport subscribers instead of losing objects it received, which +draft-18 §9.4 forbids ("A relay MUST NOT reorder or drop objects received +on a multi-object stream"). + +## Plan + +Decided with the maintainer on 2026-10-22, from the runner cases work +([moq-dev/moq#6275](https://github.com/moq-dev/moq/pull/6275)): keep the +tail, don't drop the group. This was ranked m2 because it blocks no m1 +interop goal: a publisher that answers SUBSCRIBE_OK before writing, or that +serves the joining FETCH, never triggers it. + +Where it happens: `open_group` in `rs/moq-net/src/ietf/subscriber.rs`. +The outcome is a race between the mid-group stream and the joining FETCH's +refusal: + +- If the refusal lands first, the fill is no longer outstanding, and the + stream takes the unfilled path. That keeps the tail, but only the wire + metadata (`group::Wire.first_id`) records where it starts: the model + group begins at frame 0, so it looks complete, and `position_group` + serves the tail to moq-lite subscribers as a whole group. +- If the stream arrives while the fill is still pending, it waits in + `claim_fill`. Once the refusal settles the fill, `claim` returns no head, + and the stream fails with "no fill to stitch a mid-group stream onto", + which drops the whole group. + +Cloudflare's moq-test-client reproduces both: it writes object 0 before +SUBSCRIBE_OK and refuses the joining FETCH +([cloudflare/moq-rs#281](https://github.com/cloudflare/moq-rs/issues/281)). + +The ingest fix opens the same headless group in both orders, and the model +must know its head is missing so `position_group` refuses it to moq-lite +subscribers. `group::Producer::start_at` marks a missing front, but in +frame ordinals: relayed Object IDs need not match them (`group::Wire`), so +trimming to the first Object ID would invent frames and break FETCH and +partial-reader positioning. Mark the missing head without equating the +two, and check that the moq-transport egress forwards the group as a +subgroup stream starting at its first Object ID. + +Open design points, with recommendations: + +1. **Serving the tail to moq-transport subscribers.** Recommended: forward + it as a subgroup stream that starts at its first object, since §9.4 + applies. The alternative is to skip it, as moq-lite does. +2. **Serving the tail to moq-lite subscribers.** Recommended: keep the + current DROP (`position_group` in `rs/moq-net/src/lite/publisher.rs`) + for any subscriber that did not ask for a partial group. On moq-lite a + group is the unit of decodability, and only the subscriber knows whether + a partial one is any use. +3. **A later FETCH or joining FETCH for the missing head.** Recommended: + refuse the missing prefix, as the publisher already does + (`a_joining_fetch_refuses_a_missing_prefix_before_fetch_ok`), rather + than ask upstream again. + +Tests: a subscriber unit test for each order, with the fill refused before +the mid-group stream arrives and after it. The two orders must end the same +way. Add a relay-level test that a moq-transport +subscriber receives the tail while a moq-lite subscriber gets the DROP. + +Public API: none expected. Wire: none. + +## Related + +- [Runner cases](/quest/m1/interop-coverage/runner-cases.md) - where the + dropped group showed up, against Cloudflare's client +- [Late join and FETCH](/quest/m1/interop-coverage/late-join.md) - the + joining FETCH that normally supplies the head