From e6a297ba5ed9093c4ed52d4ec7339e61e2db6c46 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 21 Oct 2026 22:35:27 -0700 Subject: [PATCH 1/6] quest: claim m1/interop-coverage/runner-cases Co-Authored-By: Claude Opus 5.5 From 6e38fa3f5da6222d4e0d86500cb770183a706e23 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 21 Oct 2026 23:15:43 -0700 Subject: [PATCH 2/6] quest(runner-cases): land the runner cases upstream and classify the relay failures The moq-dev-rs and moq-dev-js runner clients now implement data-subgroup-basic and subscribe-namespace-lifecycle, in englishm/moq-interop-runner#172 and #173. What remains waits on those merging and the client images being rebuilt. Co-Authored-By: Claude Opus 5.5 --- quest/m1/interop-coverage/README.md | 2 +- quest/m1/interop-coverage/runner-cases.md | 70 +++++++++++++++++------ 2 files changed, 53 insertions(+), 19 deletions(-) diff --git a/quest/m1/interop-coverage/README.md b/quest/m1/interop-coverage/README.md index 8045013a6df..6a2ae07d8e1 100644 --- a/quest/m1/interop-coverage/README.md +++ b/quest/m1/interop-coverage/README.md @@ -42,7 +42,7 @@ coverage on `main` at `3ab6cbf81d`. ## Required - [IETF matrix](/quest/m1/interop-coverage/ietf-matrix.md) - every interop client pair exchanges hang media over moq-transport through moq-relay -- [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 - [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/runner-cases.md b/quest/m1/interop-coverage/runner-cases.md index b4df1e8cbaa..eabe7b1ecc3 100644 --- a/quest/m1/interop-coverage/runner-cases.md +++ b/quest/m1/interop-coverage/runner-cases.md @@ -1,26 +1,60 @@ -# [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, and when the refusal + lands first, so is all of group 0. +- 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. + +Reporting the last two upstream needs maintainer approval, which this run +did not have. + +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. + +Still to investigate, from the runs for #173: + +- moq-dev-js `subscribe-namespace-lifecycle` against Cloudflare draft-18 + and aiomoqt never sees NAMESPACE_DONE, but only when the JS publisher and + subscriber share one process. Each half passes with a Rust counterpart, + and two separate Bun processes pass. +- moq-dev-js `data-subgroup-basic` against imquic (draft-22, + WebTransport) receives no objects. moq-dev-rs passes there on the same + draft. Public API: none. Wire: none. From 4cd91244d889242c168839b1ccd6d03c862894d2 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 21 Oct 2026 23:24:37 -0700 Subject: [PATCH 3/6] quest: plan headless moq-transport groups and record the runner-cases decisions Co-Authored-By: Claude Opus 5.5 --- quest/m1/interop-coverage/runner-cases.md | 8 ++- quest/m2/README.md | 1 + quest/m2/ietf-headless-group.md | 62 +++++++++++++++++++++++ 3 files changed, 69 insertions(+), 2 deletions(-) create mode 100644 quest/m2/ietf-headless-group.md diff --git a/quest/m1/interop-coverage/runner-cases.md b/quest/m1/interop-coverage/runner-cases.md index eabe7b1ecc3..662721a4655 100644 --- a/quest/m1/interop-coverage/runner-cases.md +++ b/quest/m1/interop-coverage/runner-cases.md @@ -39,8 +39,12 @@ Cloudflare's moq-test-client (draft-18): allows (§11.2.1.1). The runner's data-plane conventions leave status objects out of verification. -Reporting the last two upstream needs maintainer approval, which this run -did not have. +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 diff --git a/quest/m2/README.md b/quest/m2/README.md index 946d057fd7e..00403ff0198 100644 --- a/quest/m2/README.md +++ b/quest/m2/README.md @@ -58,6 +58,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..f7df17c0ed5 --- /dev/null +++ b/quest/m2/ietf-headless-group.md @@ -0,0 +1,62 @@ +# [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 it drops 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: `claim_fill` in `rs/moq-net/src/ietf/subscriber.rs` +returns no head, and the mid-group stream fails with "no fill to stitch a +mid-group stream onto", which drops it. The outcome is a race. If the +stream arrives while the fill is still pending, the tail is kept. If the +refusal lands first, the whole group is lost. 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 model already holds such a group: `group::Producer::start_at` trims a +group's front, and a reader positioned below it gets `Error::Lagged`. The +ingest fix is to open the group with `start_at(start)` once the fill has +settled with no head, instead of failing the stream. + +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 where the fill is refused before the +mid-group stream arrives, and another where it is refused after. 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 From fbd282d6d0d7839504a730200a2cfaa188804b08 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 21 Oct 2026 23:32:09 -0700 Subject: [PATCH 4/6] quest(headless-group): state the race in the order the code runs it Co-Authored-By: Claude Opus 5.5 --- quest/m1/interop-coverage/runner-cases.md | 4 +-- quest/m2/ietf-headless-group.md | 31 ++++++++++++++--------- 2 files changed, 21 insertions(+), 14 deletions(-) diff --git a/quest/m1/interop-coverage/runner-cases.md b/quest/m1/interop-coverage/runner-cases.md index 662721a4655..64631430e4a 100644 --- a/quest/m1/interop-coverage/runner-cases.md +++ b/quest/m1/interop-coverage/runner-cases.md @@ -32,8 +32,8 @@ Cloudflare's moq-test-client (draft-18): 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, and when the refusal - lands first, so is all of group 0. + 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 diff --git a/quest/m2/ietf-headless-group.md b/quest/m2/ietf-headless-group.md index f7df17c0ed5..1019f9b6c9a 100644 --- a/quest/m2/ietf-headless-group.md +++ b/quest/m2/ietf-headless-group.md @@ -18,19 +18,26 @@ 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: `claim_fill` in `rs/moq-net/src/ietf/subscriber.rs` -returns no head, and the mid-group stream fails with "no fill to stitch a -mid-group stream onto", which drops it. The outcome is a race. If the -stream arrives while the fill is still pending, the tail is kept. If the -refusal lands first, the whole group is lost. Cloudflare's moq-test-client -reproduces both: it writes object 0 before SUBSCRIBE_OK and refuses the -joining FETCH +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, which keeps the tail with its first + Object ID. +- 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 model already holds such a group: `group::Producer::start_at` trims a group's front, and a reader positioned below it gets `Error::Lagged`. The -ingest fix is to open the group with `start_at(start)` once the fill has -settled with no head, instead of failing the stream. +ingest fix is to give a stream that waited on a fill that settled with no +head the same unfilled path, instead of failing it. Open design points, with recommendations: @@ -47,9 +54,9 @@ Open design points, with recommendations: (`a_joining_fetch_refuses_a_missing_prefix_before_fetch_ok`), rather than ask upstream again. -Tests: a subscriber unit test where the fill is refused before the -mid-group stream arrives, and another where it is refused after. The two -orders must end the same way. Add a relay-level test that a moq-transport +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. From dd56844b11b80fdf1e18d8d55caeb3ccaa3782af Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 22 Oct 2026 12:23:20 -0700 Subject: [PATCH 5/6] quest(ietf-headless-group): trim the headless group in both race orders The unfilled path records the first Object ID only in the wire metadata, so the model group looks complete and moq-lite subscribers get the tail as a whole group. Plan a front-trimmed group in both orders instead. Co-Authored-By: Claude Opus 5.5 --- quest/m2/ietf-headless-group.md | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/quest/m2/ietf-headless-group.md b/quest/m2/ietf-headless-group.md index 1019f9b6c9a..07b4b9ec268 100644 --- a/quest/m2/ietf-headless-group.md +++ b/quest/m2/ietf-headless-group.md @@ -5,7 +5,8 @@ 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 it drops the whole group. A relay then forwards the tail to its +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"). @@ -23,8 +24,10 @@ 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, which keeps the tail with its first - Object ID. + 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", @@ -36,8 +39,10 @@ SUBSCRIBE_OK and refuses the joining FETCH The model already holds such a group: `group::Producer::start_at` trims a group's front, and a reader positioned below it gets `Error::Lagged`. The -ingest fix is to give a stream that waited on a fill that settled with no -head the same unfilled path, instead of failing it. +ingest fix is to open a headless group trimmed to its first Object ID in +both orders, rather than reuse today's unfilled path. Check that the +moq-transport egress forwards a front-trimmed group as a subgroup stream +starting at that Object ID. Open design points, with recommendations: From 83f60a13629948bb05be21b1fdc5b7b4fbf6d9c9 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 22 Oct 2026 12:29:22 -0700 Subject: [PATCH 6/6] quest(ietf-headless-group): keep Object IDs out of start_at Relayed Object IDs need not match frame ordinals, so the plan marks the missing head without trimming the model group to an Object ID. Co-Authored-By: Claude Opus 5.5 --- quest/m2/ietf-headless-group.md | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/quest/m2/ietf-headless-group.md b/quest/m2/ietf-headless-group.md index 07b4b9ec268..9d3a97ace83 100644 --- a/quest/m2/ietf-headless-group.md +++ b/quest/m2/ietf-headless-group.md @@ -37,12 +37,14 @@ 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 model already holds such a group: `group::Producer::start_at` trims a -group's front, and a reader positioned below it gets `Error::Lagged`. The -ingest fix is to open a headless group trimmed to its first Object ID in -both orders, rather than reuse today's unfilled path. Check that the -moq-transport egress forwards a front-trimmed group as a subgroup stream -starting at that Object ID. +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: