From e8fb2e85049e276b369adad4029589547de6a4fa Mon Sep 17 00:00:00 2001 From: OneTooMany Date: Thu, 8 Oct 2026 14:41:53 +0200 Subject: [PATCH 1/5] quest: plan the FFI publisher stall and demand lost wake Follow-ups from #5053 and #5054. The browser interop quest moves to m0 and widens to the moq-ffi publisher going silent until the relay's idle timeout, a new m0 quest fixes demand polls that lose a reader's wake, and the JS ranges quest notes that a held TRACK request and its SUBSCRIBE are one request. Co-Authored-By: Claude Opus 5.5 --- quest/m0/README.md | 9 +++++ quest/m0/demand-lost-wake.md | 59 ++++++++++++++++++++++++++++ quest/m0/ffi-publisher-stall.md | 53 +++++++++++++++++++++++++ quest/m1/README.md | 1 - quest/m1/interop-browser-timeouts.md | 29 -------------- quest/m1/subscribe-ranges/js.md | 6 +++ 6 files changed, 127 insertions(+), 30 deletions(-) create mode 100644 quest/m0/demand-lost-wake.md create mode 100644 quest/m0/ffi-publisher-stall.md delete mode 100644 quest/m1/interop-browser-timeouts.md diff --git a/quest/m0/README.md b/quest/m0/README.md index 848bc443c19..b7b537c1cff 100644 --- a/quest/m0/README.md +++ b/quest/m0/README.md @@ -28,6 +28,13 @@ edge, which embeds moq-relay; it moved there on 2026-09-28. Pools of claim workers (transcoders) also need the relay to forget a front nobody reads, and demand that doesn't flap on a viewer's first subscribe (both found 2026-10-07). +A demand poll that loses a reader's wake keeps an unread front and its +upstream subscription alive, so it ships with them (found 2026-10-08). + +Interop coverage: Go and Python publishers fall silent until the relay's 10 s +idle timeout drops them, which fails the browser cells and hides as slow +passes elsewhere. It moved here from m1 on 2026-10-08 because it masks +interop on every wire PR. Interop: Fastly's moq-relay-interop report (run of 2026-09-23, build 7ee2b02) was triaged against `main` on 2026-10-07. Its SETUP, UNSUBSCRIBE @@ -62,6 +69,8 @@ a published `@moq/watch` break. - [TRACK stream demand](/quest/m0/track-stream-demand.md) - a lite-05+ subscribe shows the publisher one `used` edge, not a flap between TRACK and SUBSCRIBE - [Idle fronts](/quest/m0/idle-fronts.md) - a front nobody has read for the linger ends with its per-path state, so a standing claim stops accumulating fronts and sources - [Upstream position regression](/quest/m0/largest-regression.md) - a relay copy that sees upstream's largest group go backwards ends instead of serving the old instance's cache +- [Demand lost wake](/quest/m0/demand-lost-wake.md) - a reader that comes and goes between a demand poll and its re-read never leaves a front or `broadcast::Demand` without a wake +- [FFI publisher stall](/quest/m0/ffi-publisher-stall.md) - Go and Python publishers stay connected through every interop cell, and a cell fails when a connection idles out - [qmux credit](/quest/m0/qmux-credit.md) - qmux returns connection credit for dropped and stopped streams and delivers its close frame, on both lines - [web-transport releases the qmux fixes](/quest/m0/qmux-credit-upstream.md) - waiting on moq-dev/web-transport#412 and #413 to merge and ship, which qmux credit bumps to - [Broadcast epochs](/quest/m0/broadcast-epoch/README.md) - every first-party publisher that can restart mints a fresh route epoch, the newest wins a path, and only routes with the same epoch resume a subscription diff --git a/quest/m0/demand-lost-wake.md b/quest/m0/demand-lost-wake.md new file mode 100644 index 00000000000..9122d3e8196 --- /dev/null +++ b/quest/m0/demand-lost-wake.md @@ -0,0 +1,59 @@ +# [S] Demand polls never lose a wake + +## Goal + +A reader that arrives or leaves between a demand poll and its re-read never +leaves the waiter without a wake. Today a relay front's driver can miss a +track's `Unused` edge: the copy keeps its upstream subscription for nobody, +and the front never retires, with nothing to bound it on a quiet +single-track front. In the other direction a reader stalls on a parked track +until the linger expires. `broadcast::Demand::poll_demand` has the same shape +and is fixed with it. + +## Plan + +Facts from `main` at 7c6b6afc1 (line numbers at time of writing): + +- `serve_front`'s wait closure (`rs/moq-net/src/model/origin.rs:2728-2735`) + calls `io.weak.poll_unused` or `poll_used`, then steps only if + `io.weak.is_used() != io.used`. `TrackWeak::poll_used` and `poll_unused` + (`track.rs:2550-2558`) discard the result, and kio + (`rs/kio/src/weak.rs:168-188`) returns `Ready` without registering when + the edge is already met. With `used` true: no consumers, so `Ready` without + a registration; a reader arrives, so `is_used()` is true and the closure + returns `Pending`; the reader leaves and nothing wakes the driver. +- `Step::Demand` (`origin.rs:2841-2857`) re-reads `is_used()` and can emit a + duplicate `Used` or `Unused`. +- `broadcast::Demand::poll_demand` (`broadcast.rs:136-147`, `887-904`): + `register_demand` drops each track's `Ready`, then recomputes `is_used()`. + +Decided 2026-10-08: + +- m0: it undermines [Idle fronts](/quest/m0/idle-fronts.md)'s retire and + leaks an upstream subscription. +- Covers `broadcast::Demand` too: same pattern, and publishers rely on its + edges being clean. +- Reuse the pattern Idle fronts uses for the holder edge (`poll_held`, + `poll_unheld`): the wrappers return `Poll`, the closure steps on `Ready`, + and the handler polls again (registering) when nothing changed. A closed + track's `Ready(Err(Closed))` is not an edge, or an ended unused track spins. +- Distinct from kio's level-only demand, which + [Front deadline index](/quest/m1/front-deadline-index.md) scopes out: there + a reader that comes and goes between polls skips restarting the linger, but + no wake is lost. + +Verification: a loom model beside Idle fronts' +`a_request_never_joins_a_retiring_front` in `rs/moq-net/tests/loom.rs`, with +a reader thread taking and dropping a track around the driver's poll, failing +without the fix; the same for `Demand`. The simulated network can't hit a +window inside a single poll. + +Public API: none. Wire: none. + +## Required + +- [Idle fronts](/quest/m0/idle-fronts.md) - edits the same closure (#5054); build on it + +## Related + +- [Front deadline index](/quest/m1/front-deadline-index.md) - later replaces this closure with per-track wakes, which must keep the fix diff --git a/quest/m0/ffi-publisher-stall.md b/quest/m0/ffi-publisher-stall.md new file mode 100644 index 00000000000..7d0033a4240 --- /dev/null +++ b/quest/m0/ffi-publisher-stall.md @@ -0,0 +1,53 @@ +# [M] FFI publishers stay connected through interop + +## Goal + +Every cell of `just test interop --all` with a Go or Python publisher passes +reliably on `main` and in nightly CI, with the cause found and fixed. Today a +moq-ffi publisher goes silent, not even sending QUIC keep-alives, until the +relay's 10 s idle timeout closes its connection and it reconnects. The +browser cells (`go -> js`, `python -> js`) can't absorb that within their +30 s limit and fail at 32 to 33 s; the others (`-> rust`, `-> python`, +`-> gst`) pass slowly at 10 to 11 s or fail intermittently. The harness fails +any cell whose connection idles out, so a drop and reconnect can no longer +pass as a slow cell. + +## Plan + +Facts (2026-10-08, line numbers at time of writing): + +- Run 37511624075 (`main` at 29792f815): `python -> js` and `go -> js` + failed; `python -> rust` (11 s), `go -> rust` (10 s) and both `-> gst` + cells (10 to 11 s) passed slowly. The browser saw the Python broadcast go + offline, come back, and go offline again. On the auth line the browser's + tone subscription was reset with code 0. PR runs 37710920335 and + 37676389320 fail non-browser cells the same way; other runs pass, so it is + intermittent. +- A local run's `relay.log`: the relay subscribes upstream on the + publisher's connection, logs `connection closed err=transport: connection + error: timed out` 10 s later, and the publisher reconnects from the same + port. The publisher logs nothing. +- The 10 s is `DEFAULT_IDLE_TIMEOUT` (`rs/moq-tokio/src/quic.rs:98`, + keep-alive 3 s at `:104`). It predates the passing nightlies, so the + trigger is the publisher going silent, not the timeout. +- Go stalls too, so the cause is in moq-ffi or below, not `py/`. Unproven + lead: `rs/moq-ffi/src/ffi.rs:41` runs everything on one single-threaded + runtime thread, which may block once the first subscribes arrive. +- The nightlies up to 2026-10-05 (11b28de07) passed, with `python -> rust` + at 1 to 4 s. The regression is in 11b28de07..29792f815 (92 commits). + +Decided 2026-10-08: + +- Moved from m1 and widened from the browser cells: the stall masks interop + on every wire PR, and may disconnect real FFI publishers. +- Bisect the window on a cell that reproduces locally, then fix the cause. + Never raise a timeout or add a retry. +- The harness fails a cell when any connection in it idles out (the relay + logs `timed out`), so this class of regression fails every run instead of + passing slowly. Land a moq-ffi regression test too if the cause allows one. + +Public API: none expected. Wire: none. + +## Related + +- [CI runner stalls](/quest/m1/ci-runner-stalls.md) - shorter freezes of both interop tracks on CI runners, a different symptom diff --git a/quest/m1/README.md b/quest/m1/README.md index 0d07d744921..67e278a6987 100644 --- a/quest/m1/README.md +++ b/quest/m1/README.md @@ -69,7 +69,6 @@ blocks. The quests that gated m0 lines moved under them. - [Dropped uring session closes](/quest/m1/uring-drop-close.md) - a moq-uring session dropped without close() closes its connection - [Media audio-tone check](/quest/m1/media-audio-tone.md) - the media lane's audio-tone check passes under load, fixed at its cause - [CI runner stalls](/quest/m1/ci-runner-stalls.md) - the 0.4 to 0.8 s freezes of both interop tracks on CI are attributed from a week of nightlies and fixed or told apart from playback bugs -- [Browser interop cells](/quest/m1/interop-browser-timeouts.md) - `go -> js` and `python -> js` pass, fixed at the cause rather than by a longer timeout - [Wire compatibility](/quest/m1/wire-compat.md) - a nightly run tests this checkout against the last published release for tokens, session wire, and catalog/container - [Same-epoch importers](/quest/m1/hop-aligned-import.md) - importers sharing one `--epoch` and fed one stream publish identical groups and timestamps, so failover between a redundant pair survives - [cpal loads libasound at runtime](/quest/m1/cpal-alsa-runtime.md) - condition: a cpal release whose Linux build carries no load-time libasound requirement diff --git a/quest/m1/interop-browser-timeouts.md b/quest/m1/interop-browser-timeouts.md deleted file mode 100644 index 1dd84434af7..00000000000 --- a/quest/m1/interop-browser-timeouts.md +++ /dev/null @@ -1,29 +0,0 @@ -# [M] Browser interop cells pass with FFI publishers - -## Goal - -The `go -> js` and `python -> js` cells of `just test interop --all` pass -reliably on `main` and in nightly CI, with the cause found and fixed. They -time out today at 32 to 33 s against a 30 s limit, on `main` too (run -37511624075), and on the auth line the browser's tone subscription is reset -with code 0. - -## Plan - -Decided 2026-10-07: investigate now rather than wait for nightly results -after #5005 (expiry-wakes, since landed), which may have been the cause: an -FFI publisher's 2 s audio max age parked hundreds of group serves. - -- Reproduce locally with `just test interop --all`, under load and alone. - The js cell (`test/interop/interop.sh` js subscriber, `driver.ts`) waits for - rendered video, then audio, pause, and resume, each within the timeout; - `harness.ts` `waitForWatch` has its own hard-coded 30 s. -- Find which step stalls and why, from the player trace and the publisher - side. Check whether #5005 alone fixed it before changing anything else. -- Never raise the timeout or add a retry. - -Public API: none expected. Wire: none. - -## Related - -- [CI runner stalls](/quest/m1/ci-runner-stalls.md) - shorter freezes of both interop tracks on CI runners diff --git a/quest/m1/subscribe-ranges/js.md b/quest/m1/subscribe-ranges/js.md index e404e0a471c..b48a96ed094 100644 --- a/quest/m1/subscribe-ranges/js.md +++ b/quest/m1/subscribe-ranges/js.md @@ -24,6 +24,12 @@ IETF FETCH dispatch. Resized from [M] to [L] for it. Storage, retention, and media catalog interpretation stay outside `js/net`. - One logical dynamic track per broadcast and name: a cache-miss request never creates a duplicate live producer. +- A lite TRACK's info request and the SUBSCRIBE that follows it are one + request. The publisher holds the info request until the SUBSCRIBE's first + response (TRACK stream demand, #5053), so the SUBSCRIBE joins it; today + `resolveTrackInfo` and `subscribe` in `js/net/src/broadcast.ts` each queue + their own. Test one request per viewer. Decided 2026-10-08: no separate + quest, since no app can pull per-track requests until this surface exists. - Verify with an in-memory responder, without OPFS or an archive writer: a browser publisher serves a native subscriber after a group is evicted or was never cached, covering exact replay, empty and missing groups, From ee80c9f710dce4f93d710c2ca75d82efbc16caab Mon Sep 17 00:00:00 2001 From: OneTooMany Date: Thu, 8 Oct 2026 14:51:16 +0200 Subject: [PATCH 2/5] quest: correct the FFI stall cells and demand closure handling from review Co-Authored-By: Claude Opus 5.5 --- quest/m0/demand-lost-wake.md | 28 ++++++++++++++++------- quest/m0/ffi-publisher-stall.md | 39 ++++++++++++++++++++++----------- 2 files changed, 46 insertions(+), 21 deletions(-) diff --git a/quest/m0/demand-lost-wake.md b/quest/m0/demand-lost-wake.md index 9122d3e8196..e5a6e4d18ac 100644 --- a/quest/m0/demand-lost-wake.md +++ b/quest/m0/demand-lost-wake.md @@ -29,24 +29,36 @@ Facts from `main` at 7c6b6afc1 (line numbers at time of writing): Decided 2026-10-08: -- m0: it undermines [Idle fronts](/quest/m0/idle-fronts.md)'s retire and - leaks an upstream subscription. +- m0: it undermines the idle-front retire (#5054) and leaks an upstream + subscription. - Covers `broadcast::Demand` too: same pattern, and publishers rely on its edges being clean. -- Reuse the pattern Idle fronts uses for the holder edge (`poll_held`, - `poll_unheld`): the wrappers return `Poll`, the closure steps on `Ready`, - and the handler polls again (registering) when nothing changed. A closed - track's `Ready(Err(Closed))` is not an edge, or an ended unused track spins. +- Reuse the handler shape Idle fronts uses for the holder edge (`poll_held`, + `poll_unheld`): the closure steps on `Ready`, and the handler re-reads and + polls again (registering) when nothing changed. Not its wrappers, which + map a closed channel to `Ready` on every pass. - Distinct from kio's level-only demand, which [Front deadline index](/quest/m1/front-deadline-index.md) scopes out: there a reader that comes and goes between polls skips restarting the linger, but no wake is lost. +Pitfalls: + +- A track's `Ready(Err(Closed))` is an edge only while the track is recorded + used. Closing flips `is_used()` to false (an upstream refusing an active + track ends it this way), so it owes one final `Unused`, or it stays used + and its front never retires. After that it is no edge, or an ended unused + track spins. +- `broadcast::Demand` has no handler to poll again: publishers await + `poll_demand` directly, so the retry lives inside the poll, re-registering + while a track was `Ready` but the aggregate is unmet. + Verification: a loom model beside Idle fronts' `a_request_never_joins_a_retiring_front` in `rs/moq-net/tests/loom.rs`, with a reader thread taking and dropping a track around the driver's poll, failing -without the fix; the same for `Demand`. The simulated network can't hit a -window inside a single poll. +without the fix; the same for `Demand`. Also cover a track that closes while +used (one `Unused`) and one that closes already unused (no spin). The +simulated network can't hit a window inside a single poll. Public API: none. Wire: none. diff --git a/quest/m0/ffi-publisher-stall.md b/quest/m0/ffi-publisher-stall.md index 7d0033a4240..dd55ce4a508 100644 --- a/quest/m0/ffi-publisher-stall.md +++ b/quest/m0/ffi-publisher-stall.md @@ -7,22 +7,27 @@ reliably on `main` and in nightly CI, with the cause found and fixed. Today a moq-ffi publisher goes silent, not even sending QUIC keep-alives, until the relay's 10 s idle timeout closes its connection and it reconnects. The browser cells (`go -> js`, `python -> js`) can't absorb that within their -30 s limit and fail at 32 to 33 s; the others (`-> rust`, `-> python`, -`-> gst`) pass slowly at 10 to 11 s or fail intermittently. The harness fails -any cell whose connection idles out, so a drop and reconnect can no longer -pass as a slow cell. +30 s limit and fail at 32 to 33 s; `-> rust` and `-> gst` pass slowly at 10 +to 11 s, and in some runs most cells of one publisher fail at 11 s. The +harness fails any cell whose connection idles out, so a drop and reconnect +can no longer pass as a slow cell. ## Plan Facts (2026-10-08, line numbers at time of writing): - Run 37511624075 (`main` at 29792f815): `python -> js` and `go -> js` - failed; `python -> rust` (11 s), `go -> rust` (10 s) and both `-> gst` - cells (10 to 11 s) passed slowly. The browser saw the Python broadcast go - offline, come back, and go offline again. On the auth line the browser's - tone subscription was reset with code 0. PR runs 37710920335 and - 37676389320 fail non-browser cells the same way; other runs pass, so it is - intermittent. + failed; `-> rust` and `-> gst` (10 to 11 s) passed slowly; the rest passed + in 0 to 1 s. Those subscribers exit on their first byte, while `-> rust` + and `-> gst` exit only on their next write after `head` closes, so the + publisher delivers its first data and then stalls. A bisect therefore + judges by `-> rust`'s time or the browser cells; the one-byte cells pass + either way. The browser saw the Python broadcast go offline, come back, + and go offline again. On the auth line the browser's tone subscription was + reset with code 0. +- PR runs 37710920335 (Python) and 37676389320 (Go) fail most cells of that + publisher at 11 s, one-byte cells included, so it can stall before the + first byte too. Other runs pass, so it is intermittent. - A local run's `relay.log`: the relay subscribes upstream on the publisher's connection, logs `connection closed err=transport: connection error: timed out` 10 s later, and the publisher reconnects from the same @@ -42,9 +47,17 @@ Decided 2026-10-08: on every wire PR, and may disconnect real FFI publishers. - Bisect the window on a cell that reproduces locally, then fix the cause. Never raise a timeout or add a retry. -- The harness fails a cell when any connection in it idles out (the relay - logs `timed out`), so this class of regression fails every run instead of - passing slowly. Land a moq-ffi regression test too if the cause allows one. +- The harness fails a cell when any connection in it idles out, so this + class of regression fails every run instead of passing slowly. Land a + moq-ffi regression test too if the cause allows one. + +Harness pitfalls: one relay serves the whole run, and its `connection closed +err=... timed out` warning (`rs/moq-relay/src/relay.rs:792`) names no +connection and lands about 10 s after the peer went quiet, often in a later +cell. Tie each idle-out to its connection first, by logging the connection +there or having the client report its own drop. A client the harness kills +(`gst-launch` on SIGPIPE, `moq-cli` under `timeout -k`) may close without a +CONNECTION_CLOSE and idle out legitimately; that doesn't count. Public API: none expected. Wire: none. From 95ddc6c676f5fa2af8cde3dac99c87eee5d7ec17 Mon Sep 17 00:00:00 2001 From: OneTooMany Date: Thu, 8 Oct 2026 14:55:45 +0200 Subject: [PATCH 3/5] quest: decide aggregate demand from per-track polls without spinning Co-Authored-By: Claude Opus 5.5 --- quest/m0/demand-lost-wake.md | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/quest/m0/demand-lost-wake.md b/quest/m0/demand-lost-wake.md index e5a6e4d18ac..81ef306a959 100644 --- a/quest/m0/demand-lost-wake.md +++ b/quest/m0/demand-lost-wake.md @@ -50,15 +50,21 @@ Pitfalls: and its front never retires. After that it is no edge, or an ended unused track spins. - `broadcast::Demand` has no handler to poll again: publishers await - `poll_demand` directly, so the retry lives inside the poll, re-registering - while a track was `Ready` but the aggregate is unmet. + `poll_demand` directly, so the fix lives inside the poll. Prefer deciding + from the per-track poll results over re-reading `is_used()`: every track + `Ready` meets `unused`, any `Ready(Ok)` meets `used`, and otherwise the + tracks in the way hold registrations. Never retry just because a track was + `Ready`: with one track unused and another still read, that spins until + the last viewer leaves. Verification: a loom model beside Idle fronts' `a_request_never_joins_a_retiring_front` in `rs/moq-net/tests/loom.rs`, with a reader thread taking and dropping a track around the driver's poll, failing without the fix; the same for `Demand`. Also cover a track that closes while -used (one `Unused`) and one that closes already unused (no spin). The -simulated network can't hit a window inside a single poll. +used (one `Unused`) and one that closes already unused (no spin), and for +`Demand` two tracks: `Pending` while only one is read, done once its last +reader leaves. The simulated network can't hit a window inside a single +poll. Public API: none. Wire: none. From dae4cc3b73b3d56b99293137be1e5b390aa0eba7 Mon Sep 17 00:00:00 2001 From: OneTooMany Date: Thu, 8 Oct 2026 15:24:17 +0200 Subject: [PATCH 4/5] quest: close harness clients cleanly and harden the front's holder edge Co-Authored-By: Claude Opus 5.5 --- quest/m0/demand-lost-wake.md | 19 ++++++++++++++++--- quest/m0/ffi-publisher-stall.md | 11 +++++++---- 2 files changed, 23 insertions(+), 7 deletions(-) diff --git a/quest/m0/demand-lost-wake.md b/quest/m0/demand-lost-wake.md index 81ef306a959..d4b76b823df 100644 --- a/quest/m0/demand-lost-wake.md +++ b/quest/m0/demand-lost-wake.md @@ -8,7 +8,8 @@ track's `Unused` edge: the copy keeps its upstream subscription for nobody, and the front never retires, with nothing to bound it on a quiet single-track front. In the other direction a reader stalls on a parked track until the linger expires. `broadcast::Demand::poll_demand` has the same shape -and is fixed with it. +and is fixed with it, and a closed broadcast never spins the front's holder +edge. ## Plan @@ -26,6 +27,13 @@ Facts from `main` at 7c6b6afc1 (line numbers at time of writing): duplicate `Used` or `Unused`. - `broadcast::Demand::poll_demand` (`broadcast.rs:136-147`, `887-904`): `register_demand` drops each track's `Ready`, then recomputes `is_used()`. +- On #5054's head 3b6d36f67, `poll_held` and `poll_unheld` + (`broadcast.rs:386-393`) map kio's `Ready(Err(Closed))`, returned before + registering, to `Ready`, and `Step::Holders` `continue`s while + `is_held() == held`. A closed broadcast would livelock the driver in + `kio::wait`, which has no budget. Not reachable today: the only closers of + the front's broadcast, `Action::End` and `Retire` through `End`, end the + driver in the same pass, and `FrontTask` owns the producer. Decided 2026-10-08: @@ -37,6 +45,10 @@ Decided 2026-10-08: `poll_unheld`): the closure steps on `Ready`, and the handler re-reads and polls again (registering) when nothing changed. Not its wrappers, which map a closed channel to `Ready` on every pass. +- Fold the holder-edge hardening in, since this rewrites the same closure: a + closed broadcast ends the front (or skips the holder edge) instead of + polling it again, so safety is local rather than resting on who owns the + producer. - Distinct from kio's level-only demand, which [Front deadline index](/quest/m1/front-deadline-index.md) scopes out: there a reader that comes and goes between polls skips restarting the linger, but @@ -63,8 +75,9 @@ a reader thread taking and dropping a track around the driver's poll, failing without the fix; the same for `Demand`. Also cover a track that closes while used (one `Unused`) and one that closes already unused (no spin), and for `Demand` two tracks: `Pending` while only one is read, done once its last -reader leaves. The simulated network can't hit a window inside a single -poll. +reader leaves. A front whose broadcast closes while unheld must not spin; +close it from a test, since no production path does yet. The simulated +network can't hit a window inside a single poll. Public API: none. Wire: none. diff --git a/quest/m0/ffi-publisher-stall.md b/quest/m0/ffi-publisher-stall.md index dd55ce4a508..bf0bc3b5131 100644 --- a/quest/m0/ffi-publisher-stall.md +++ b/quest/m0/ffi-publisher-stall.md @@ -50,14 +50,17 @@ Decided 2026-10-08: - The harness fails a cell when any connection in it idles out, so this class of regression fails every run instead of passing slowly. Land a moq-ffi regression test too if the cause allows one. +- The harness shuts down every client it starts cleanly, so every idle-out + counts. Today `gst-launch` dies on SIGPIPE and `moq-cli` can be killed + under `timeout -k`, which may leave a QUIC connection to idle out. No + exception list for killed clients: it would hide a real idle-out behind a + harness kill. -Harness pitfalls: one relay serves the whole run, and its `connection closed +Harness pitfall: one relay serves the whole run, and its `connection closed err=... timed out` warning (`rs/moq-relay/src/relay.rs:792`) names no connection and lands about 10 s after the peer went quiet, often in a later cell. Tie each idle-out to its connection first, by logging the connection -there or having the client report its own drop. A client the harness kills -(`gst-launch` on SIGPIPE, `moq-cli` under `timeout -k`) may close without a -CONNECTION_CLOSE and idle out legitimately; that doesn't count. +there or having the client report its own drop. Public API: none expected. Wire: none. From d2acc9775275c19303e6da26c5f39149ce41dae4 Mon Sep 17 00:00:00 2001 From: OneTooMany Date: Thu, 8 Oct 2026 18:20:31 +0200 Subject: [PATCH 5/5] quest: drop the JS one-request note that #5053 now delivers With one producer per track name (#4929) merged into #5053, a viewer's SUBSCRIBE joins the request its held TRACK opened, and #5053 tests one request per viewer. Co-Authored-By: Claude Opus 5.5 --- quest/m1/subscribe-ranges/js.md | 6 ------ 1 file changed, 6 deletions(-) diff --git a/quest/m1/subscribe-ranges/js.md b/quest/m1/subscribe-ranges/js.md index b48a96ed094..e404e0a471c 100644 --- a/quest/m1/subscribe-ranges/js.md +++ b/quest/m1/subscribe-ranges/js.md @@ -24,12 +24,6 @@ IETF FETCH dispatch. Resized from [M] to [L] for it. Storage, retention, and media catalog interpretation stay outside `js/net`. - One logical dynamic track per broadcast and name: a cache-miss request never creates a duplicate live producer. -- A lite TRACK's info request and the SUBSCRIBE that follows it are one - request. The publisher holds the info request until the SUBSCRIBE's first - response (TRACK stream demand, #5053), so the SUBSCRIBE joins it; today - `resolveTrackInfo` and `subscribe` in `js/net/src/broadcast.ts` each queue - their own. Test one request per viewer. Decided 2026-10-08: no separate - quest, since no app can pull per-track requests until this surface exists. - Verify with an in-memory responder, without OPFS or an archive writer: a browser publisher serves a native subscriber after a group is evicted or was never cached, covering exact replay, empty and missing groups,