From 50fa247d0f4a1f9689272c75bcec4779bf9f6442 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 4 Nov 2026 14:22:14 -0800 Subject: [PATCH 1/8] quest: plan seven follow-ups from 2026-11-04 - m0: moq-gst's interleaved restart test flakes under load (test-flakes-2 child) - m1: one typed unsupported-CPU error in moq-auth, moq-hls and moq-crypto e2ee - m1: move the overcommitted receive-window cells out of m0 Nightly, behind group-drops - m1: JS undefined IETF datagram status is a protocol violation (datagram-tracks/ietf) - m1: JS group demand counts only readers that will read - m2: a socket dial learns its peer is behind an older moq-lite hop - m2: a refused follower asks a replacement handler Co-Authored-By: Claude Opus 5.5 --- quest/m0/nightly/README.md | 4 +- quest/m0/test-flakes-2/README.md | 4 + .../test-flakes-2/gst-reconnect-interleave.md | 59 +++++++++++++ quest/m1/README.md | 2 + quest/m1/datagram-tracks/ietf.md | 14 ++++ quest/m1/group-drops.md | 2 +- quest/m1/js-group-demand.md | 50 +++++++++++ .../nightly => m1}/receive-windows-evicted.md | 19 +++-- quest/m1/rind/README.md | 1 + quest/m1/rind/cpu-error.md | 50 +++++++++++ quest/m2/README.md | 2 + quest/m2/follow-refused-retry.md | 57 +++++++++++++ quest/m2/socket-old-hop-signal.md | 84 +++++++++++++++++++ 13 files changed, 338 insertions(+), 10 deletions(-) create mode 100644 quest/m0/test-flakes-2/gst-reconnect-interleave.md create mode 100644 quest/m1/js-group-demand.md rename quest/{m0/nightly => m1}/receive-windows-evicted.md (86%) create mode 100644 quest/m1/rind/cpu-error.md create mode 100644 quest/m2/follow-refused-retry.md create mode 100644 quest/m2/socket-old-hop-signal.md diff --git a/quest/m0/nightly/README.md b/quest/m0/nightly/README.md index bddd0482811..05f149e50d4 100644 --- a/quest/m0/nightly/README.md +++ b/quest/m0/nightly/README.md @@ -33,12 +33,14 @@ This README's own work, after the children: threshold to [bench CI](/quest/m1/bench-ci.md), and the moq-net bench panics in "Rust bench targets" to [moq-net's benches run to completion](/quest/m1/bench-test-mode.md). + The receive-windows benchmark's overcommitted cells, skipped since + [moq-dev/moq#7838](https://github.com/moq-dev/moq/pull/7838), moved to + [m1](/quest/m1/receive-windows-evicted.md) on 2026-11-04 (maintainer). Public API: none. Wire: none. ## Required -- [The receive-windows benchmark runs to the end](/quest/m0/nightly/receive-windows-evicted.md) - `benchmark_receive_windows` stops failing `frame: Evicted`, so the Rust benchmark-tests job publishes its report - [moq-net's ingest fuzz target finds no stall](/quest/m0/nightly/ingest-fuzz.md) - the 13-byte stream that stalls ingest is fixed at its cause and kept as a regression test - [Nightly's shipping-size check passes](/quest/m0/nightly/shipping-size.md) - js/net, js/watch, and moq-relay growth over 5% is traced to its commits, then shrunk or accepted - [Nightly's Miri job stays inside its time budget](/quest/m0/nightly/miri.md) - Miri gets `rust-src`, then finishes inside its 60-minute job and 15-minute-per-test budgets diff --git a/quest/m0/test-flakes-2/README.md b/quest/m0/test-flakes-2/README.md index bc2c05c9f72..31833ee99da 100644 --- a/quest/m0/test-flakes-2/README.md +++ b/quest/m0/test-flakes-2/README.md @@ -88,10 +88,14 @@ has failed it, so it needs no child of its own (noted 2026-11-03, 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. +Added 2026-11-04 (maintainer, `/quest-plan`): moq-gst's interleaved restart +test, which failed two merge-queue batches and two loaded local runs. + Public API: none. Wire: none. ## Required - [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-gst's interleaved restart test passes under load](/quest/m0/test-flakes-2/gst-reconnect-interleave.md) - `restarts_under_reconnects_interleave_on_one_pad` passes in loaded runs and the merge queue, its missed delivery and its stray `Eos` each fixed at the cause - [reload.test.ts's close-drain tests pass under load](/quest/m0/test-flakes-2/reload-close-drain.md) - the drain cases in `js/net`'s reload tests pass in loaded multi-file runs diff --git a/quest/m0/test-flakes-2/gst-reconnect-interleave.md b/quest/m0/test-flakes-2/gst-reconnect-interleave.md new file mode 100644 index 00000000000..5f27c79f328 --- /dev/null +++ b/quest/m0/test-flakes-2/gst-reconnect-interleave.md @@ -0,0 +1,59 @@ +# [S] moq-gst's interleaved restart test passes under load + +## Goal + +`restarts_under_reconnects_interleave_on_one_pad` in +`rs/moq-gst/src/source/imp.rs` passes reliably in a loaded `just check` and +in the merge queue, fixed at its cause under the +[epic](/quest/m0/test-flakes-2/README.md)'s rules. Done when the PR explains +each failure below and shows the loaded run that reproduced it now passing. + +## Plan + +Planned 2026-11-04 with the maintainer, from +[moq-dev/moq#7888](https://github.com/moq-dev/moq/pull/7888)'s suggested +follow-ups. No quest or open PR tracked it. + +Failures seen so far, each passing when run alone: + +- [moq-dev/moq#7888](https://github.com/moq-dev/moq/pull/7888) (2026-11-04, + full `just check`): `5 never reached a pad`, the panic in + `Recorder::wait` after its 10 s wall-clock `wait_timeout_while`. Tag 5 is + round 1's restart: the new publisher's first write never reached a pad. +- [moq-dev/moq#7761](https://github.com/moq-dev/moq/pull/7761) (full + `just check` with seven repositories' checks on one host): failed, then + passed 5 of 5 isolated runs. Its output wasn't kept. +- [moq-dev/moq#7606](https://github.com/moq-dev/moq/pull/7606) (merge queue, + 2026-11-02, the land fixer's requeue comment): failed in 0.1 s, so not on + a timeout. `assert_one_pad_held` found an `Eos`. The recorded events show + every restart starting the pad again and replaying the previous round's + buffers (2 and 3, then 5, 6 and 7 twice), and a last segment at 2809000 + before the `Eos`. +- [moq-dev/moq#7296](https://github.com/moq-dev/moq/pull/7296) (merge queue, + 2026-11-01, the land fixer's handback comment): panicked unwrapping + `Err(unroutable)` at `imp.rs:3822:48` of that head's numbering. + +So at least two causes may be at work: a delivery that misses its wait +under load, and an ordering race (an `Eos` or `Unroutable`) that shows up +in a fast run. Find each from the code under test before changing the test. + +- The `Recorder` waits on a wall clock while the session runs on + `super::RUNTIME`. Prefer driving the session's timers with a mocked clock + or waiting on an event, as the epic's rules say. If the session itself is + slow under load, fix that. +- The `Eos` breaks the test's own claim that no round ends the pad. Check + whether the pad's actor can retire the pad when a restart, the catalog + relist, and the unannounce and re-announce interleave, as moqsrc's + rendition actor ([moq-dev/moq#7368](https://github.com/moq-dev/moq/pull/7368)) + promises it can't. A real retirement is a moqsrc bug, fixed in moqsrc. +- Find which call returned `Unroutable` in #7296's run, and whether + `publication.announce` or a follow can meet an unroutable path in the + window after `unannounce`. + +Reproduce first: run moq-gst's tests together with the rest of the +workspace under CPU contention, repeating this test in a loop beside a +loaded `just check`. If it doesn't reproduce in a reasonable number +of runs, report that and the runs tried rather than changing the test +blind. + +Public API: none. Wire: none. diff --git a/quest/m1/README.md b/quest/m1/README.md index 24e54e04076..482d92c8aa1 100644 --- a/quest/m1/README.md +++ b/quest/m1/README.md @@ -151,6 +151,8 @@ their end report, so an embedder's drain alert pages on real cuts. - [Subscribe ranges](/quest/m1/subscribe-ranges/README.md) - a lite-07 SUBSCRIBE asks for past and live ranges with absolute or relative ends, in either order, and replaces FETCH; merged ranges never starve a subscriber; relays fill misses by range, including over moq-transport - [Drop set](/quest/m1/drop-set.md) - each cursor judges missing groups against its own budget, so a narrow reader drops promptly and a widening re-offers groups already reported dropped on lite-07 - [A group a subscriber gives up on is always reported](/quest/m1/group-drops.md) - the wire names every abandoned group and the drop signal is public, so readers count losses instead of stalling +- [The overcommitted receive-window cells run again](/quest/m1/receive-windows-evicted.md) - `benchmark_receive_windows` measures its 256-stream and 4 MiB-frame cells again, reporting delivered frames and evictions instead of stalling +- [JS group demand counts only readers that will read](/quest/m1/js-group-demand.md) - a buffered copy whose reader already passed it no longer keeps a group wanted, so JS fills stop where Rust's do - [Datagram tracks](/quest/m1/datagram-tracks/README.md) - a track is datagrams or streams; datagram tracks have their own request and sequence, no ranges, no cache, and map to object ID 0 on moq-transport - [Stream credit by priority](/quest/m1/stream-credit/README.md) - every stream opens through one priority entry point, and a higher-priority group takes over or resets a lower one when credit runs out - [Finalize moq-lite-07](/quest/m1/lite07-finalize.md) - when the maintainer cuts it, lite-07 negotiates as `moq-lite-07` and the next release ships it diff --git a/quest/m1/datagram-tracks/ietf.md b/quest/m1/datagram-tracks/ietf.md index c0a7c874677..37b3a70b460 100644 --- a/quest/m1/datagram-tracks/ietf.md +++ b/quest/m1/datagram-tracks/ietf.md @@ -36,6 +36,20 @@ NOT_FOUND, and a stream track never sends one. Restore what it removed: moq-net's `session_delivery_datagram`; - the OBJECT_DATAGRAM sentence in `doc/concept/standard.md`. +An OBJECT_DATAGRAM whose Object Status is undefined is a protocol violation +in JS too, as it is in Rust, on every subscription kind. Planned 2026-11-04 +with the maintainer, from +[moq-dev/moq#7846](https://github.com/moq-dev/moq/pull/7846). Rust's +`recv_datagram` (`rs/moq-net/src/ietf/subscriber.rs`, about line 4839) +closes the session with `ProtocolViolation` when `status_defined` +(`rs/moq-net/src/ietf/object.rs`, about line 21: Normal, END_OF_GROUP and +END_OF_TRACK) rejects the status, even while it drops the datagram. JS's +`#recvDatagram` (`js/net/src/ietf/subscriber.ts`) decodes and drops it +silently, on main and after #7846. Check the shared status set once for +both datagram paths, so a datagram-track subscription keeps the check +when it starts accepting datagrams, and add a JS test that an undefined +status closes the session. + Public API: none beyond the model. Wire: no format change. ## Required diff --git a/quest/m1/group-drops.md b/quest/m1/group-drops.md index 786670d8a4b..3ae504de173 100644 --- a/quest/m1/group-drops.md +++ b/quest/m1/group-drops.md @@ -72,4 +72,4 @@ Wire: possibly lite-07 (SUBSCRIBE_DROP for a stopped group), decided here. ## Related - [Drop set](/quest/m1/drop-set.md) - owns the per-cursor drop runs this reports -- [The receive-windows benchmark](/quest/m0/nightly/receive-windows-evicted.md) - its overcommitted cells wait on this (skipped by [moq-dev/moq#7838](https://github.com/moq-dev/moq/pull/7838) until it lands) +- [The receive-windows benchmark](/quest/m1/receive-windows-evicted.md) - its overcommitted cells wait on this (skipped by [moq-dev/moq#7838](https://github.com/moq-dev/moq/pull/7838) until it lands) diff --git a/quest/m1/js-group-demand.md b/quest/m1/js-group-demand.md new file mode 100644 index 00000000000..67f1c423b6c --- /dev/null +++ b/quest/m1/js-group-demand.md @@ -0,0 +1,50 @@ +# [M] JS group demand counts only readers that will read + +## Goal + +In `@moq/net`, a group is wanted only while some reader will still read it, +as in Rust. A copy another reader's sink holds but that reader has passed, +or will never reach, no longer keeps the group wanted. So a received copy's +fill FETCH, and the IETF range fetch, stop downloading a group as soon as no +reader will read it, as Rust's do. + +## Plan + +Planned 2026-11-04 with the maintainer, from the follow-ups of +[moq-dev/moq#7845](https://github.com/moq-dev/moq/pull/7845), whose fill +ingest stops once nobody holds the group (`untilAbandoned`). Milestone m1 +(maintainer). + +The gap: a cached group is mirrored into every subscribed sink +(`#mirror` in `js/net/src/track.ts`), and a mirror counts as holding the +group. So a reader reading in arrival order that already passed the group, +or one whose range or budget will skip it, still keeps it wanted, and the +fill keeps downloading. IETF's `RangeFetch.unwanted` +(`js/net/src/ietf/range.ts`) reads the same group demand. Rust judges a fill +by the runs its joins still read (`Fill::wanted` in +`rs/moq-net/src/model/track/fill.rs`: "a reader still reads it, and it was +neither answered nor delivered live since it was asked"). + +- Match Rust's rule, not a new one: first confirm what Rust counts (a + join's unread runs, and whether a queued, not-yet-received group counts), + and write it down in the PR. +- A buffered mirror the reader will still reach keeps counting. Only one + behind its cursor, or outside what it will read, stops counting. +- Fix it where demand is computed, so the lite fill ingest, IETF range + fetches and any other consumer of group demand follow the same rule. + Don't special-case the fill. +- Keep the order with the [drop set](/quest/m1/drop-set.md), which changes + how a cursor judges a missing group and asks `js/net` to mirror each case. + Whether a reader "will read" a group depends on that judgment, so build on + whichever has landed and leave the other a note. +- Tests: a fill FETCH stops once the only remaining mirror belongs to a + reader that passed the group, and keeps going while a mirror's reader + still has to reach it. + +Public API: none. Wire: none. + +## Related + +- [Subscribe ranges](/quest/m1/subscribe-ranges/README.md) - the JS received-copy fills this stops sooner +- [Drop set](/quest/m1/drop-set.md) - each cursor's judgment of what it will still read +- [JS fastest-reader pacing](/quest/m2/js-fastest-reader.md) - also paces by which readers still read a group diff --git a/quest/m0/nightly/receive-windows-evicted.md b/quest/m1/receive-windows-evicted.md similarity index 86% rename from quest/m0/nightly/receive-windows-evicted.md rename to quest/m1/receive-windows-evicted.md index 69cc9ef5463..95702b3a105 100644 --- a/quest/m0/nightly/receive-windows-evicted.md +++ b/quest/m1/receive-windows-evicted.md @@ -17,8 +17,15 @@ alongside throughput and latency, instead of failing. ## Plan -Decided 2026-11-03 (maintainer): m0, as a child of -[Nightly passes on main](/quest/m0/nightly/README.md). +Moved to m1 2026-11-04 with the maintainer, after +[moq-dev/moq#7838](https://github.com/moq-dev/moq/pull/7838) landed the +fitting cells: what remains waits on +[group-drops](/quest/m1/group-drops.md), an m1 quest, and with the +overcommitted cells skipped the benchmark no longer fails Nightly, so this +no longer holds the m0 +[Nightly passes on main](/quest/m0/nightly/README.md) epic open. It replaces +the 2026-11-03 decision (maintainer) that placed it in m0 as that epic's +child. Overload policy, decided 2026-11-04 (maintainer): @@ -90,10 +97,6 @@ connection-wide admission semaphore are recorded in Public API: none. Wire: none. -## Waiting +## Required -- Outside condition: `quest/m1/group-drops.md`, planned in - [moq-dev/moq#7890](https://github.com/moq-dev/moq/pull/7890), finishes, - making `track::Subscriber`'s drop signal public on `main`. Check that - [moq-dev/moq#7890](https://github.com/moq-dev/moq/pull/7890) has - merged and that the quest file has since been deleted from `main`. +- [A group a subscriber gives up on is always reported](/quest/m1/group-drops.md) - the public drop signal the reader needs to return a dropped group's permit diff --git a/quest/m1/rind/README.md b/quest/m1/rind/README.md index cd55ca0c004..7d2167751d2 100644 --- a/quest/m1/rind/README.md +++ b/quest/m1/rind/README.md @@ -66,4 +66,5 @@ The epic's own work, once every child has merged: ## Required - [Transport on rind](/quest/m1/rind/transport.md) - moq-quic, moq-tokio, moq-uring, moq-rtmp, and qmux take rind, and the `aws-lc-rs`/`ring` features go +- [One typed unsupported-CPU error](/quest/m1/rind/cpu-error.md) - moq-auth, moq-hls and moq-crypto e2ee carry `moq_crypto::provider::UnsupportedCpu` and drop their own CPU-check helpers - [moq-rtc on rind](/quest/m1/rind/rtc.md) - str0m and dimpl run DTLS, SRTP, and STUN on rind diff --git a/quest/m1/rind/cpu-error.md b/quest/m1/rind/cpu-error.md new file mode 100644 index 00000000000..e852b809117 --- /dev/null +++ b/quest/m1/rind/cpu-error.md @@ -0,0 +1,50 @@ +# [S] One typed unsupported-CPU error + +## Goal + +moq-auth's and moq-hls's `Error::UnsupportedCpu` and moq-crypto e2ee's +`Error::Unsupported` carry the shared +`moq_crypto::provider::UnsupportedCpu` instead of a `String`, converted with +`?`, and each crate's own `rind::cpu::check()` wrapper is gone +(`unsupported_cpu` in `rs/moq-auth/src/error.rs` and +`rs/moq-hls/src/error.rs`, and the `map_err` in +`rs/moq-crypto/src/e2ee/credential.rs`). A caller tells a CPU refusal from +any other failure by its type, the same way in every crate. + +## Plan + +Planned 2026-11-04 with the maintainer, from the suggested follow-up of +[moq-dev/moq#7873](https://github.com/moq-dev/moq/pull/7873) +([Transport on rind](/quest/m1/rind/transport.md)). That PR adds the +`provider` feature to moq-crypto, holding `provider::UnsupportedCpu` +(`Clone + Copy + Eq`, wrapping rind's `MissingFeature` privately), and moves +moq-quic, moq-tokio, qmux and moq-uring onto it as +`UnsupportedCpu(#[from] ...)` with `#[error(transparent)]`. This quest does +the same for the three crates it left, so it starts once that PR lands. + +- **The type must not need rustls.** In #7873, `provider` pulls in rustls, + since it also holds `provider()` and `install_default()`. moq-auth's core + build has no rustls (only its `client` feature does), and the e2ee feature + doesn't either. Recommended: put `UnsupportedCpu` and `check()` where they + need only rind, such as a moq-crypto feature that `provider` and `e2ee` + both enable, and keep `provider` for the rustls half. The type's path + may then move out of `provider`, which nothing released uses yet. Check with + `cargo tree` that moq-auth's and moq-crypto's default and + `--no-default-features` graphs gain no rustls. +- moq-hls doesn't depend on moq-crypto today and gains it for this type. +- moq-rtmp kept `rind::cpu::check()` behind `io::Error` in #7873 only + because `provider` needs rustls. If the split above lands, move it onto + the typed error too, or record why not. +- Keep each variant's name: `UnsupportedCpu` in moq-auth and moq-hls. Rename + e2ee's `Unsupported` to `UnsupportedCpu` too, since it only ever means a + CPU refusal, so all three read alike. +- Docs naming these variants (`rs/moq-hls/src/lib.rs`, the moq-hls export + and server rustdoc) follow the change. + +Public API: breaking for moq-auth, moq-hls and moq-crypto (the variants' +payload type, and e2ee's variant name). Each gets a `## Unreleased` note in +its `MIGRATE.md`. Wire: none. + +## Required + +- [Transport on rind](/quest/m1/rind/transport.md) - adds `moq_crypto::provider::UnsupportedCpu`, which this wraps diff --git a/quest/m2/README.md b/quest/m2/README.md index fe50c4f2054..2c98e7fb11e 100644 --- a/quest/m2/README.md +++ b/quest/m2/README.md @@ -86,8 +86,10 @@ lite-07; bitrate enforcement is not part of this release. - [Paired bench BASE](/quest/m2/bench-base-paired.md) - `just bench ` uses the nightly's paired comparison and the old one is deleted - [Receive pool](/quest/m2/receive-pool.md) - one byte budget per worker covers every connection's receive credit and the cache, billing each frame once - [Front parking](/quest/m2/origin-front-parks.md) - an unroutable request waits on a front instead of re-asking on every route-table move +- [A refused follower asks a replacement handler](/quest/m2/follow-refused-retry.md) - a same-instance handler swap with identical route details re-asks a refused `Following`, while listeners still see no change - [Route wakes](/quest/m2/route-wakes.md) - a route change wakes only the fronts it can move, so pool churn stops scaling with served paths - [A route stream's interest is a set of prefixes](/quest/m2/route-interest-prefixes.md) - one Announce Stream covers several subtrees, with floors and certification proved over the set +- [A socket dial learns its peer is behind an older hop](/quest/m2/socket-old-hop-signal.md) - a relay marks what its older moq-lite sessions withhold, so a dial fails `Unsupported` instead of waiting like one to an absent peer - [Fewer allocations in announce fan-out](/quest/m2/announce-fanout-allocs.md) - a deep path costs no more allocations per subscriber than a shallow one - [moq-room scales to large rooms](/quest/m2/room-bench.md) - a benchmark measures `Room` with large participant counts, and polling narrows only if it shows a slope - [Route health](/quest/m2/route-health/README.md) - epoch-only active/passive track recovery over metadata-only subscriptions diff --git a/quest/m2/follow-refused-retry.md b/quest/m2/follow-refused-retry.md new file mode 100644 index 00000000000..3bfcb360bfd --- /dev/null +++ b/quest/m2/follow-refused-retry.md @@ -0,0 +1,57 @@ +# [S] A refused follower asks a replacement handler + +## Goal + +A `Following` whose last resolution was refused asks again once the +handler that refused it is replaced, even when the replacement registers +the same instance with identical route details. Announcement listeners +still see no change for such a swap. + +## Plan + +Planned 2026-11-04 with the maintainer, from a review thread declined on +[moq-dev/moq#7836](https://github.com/moq-dev/moq/pull/7836) +([`follow.rs`](https://github.com/moq-dev/moq/pull/7836#discussion_r4471135777)). +Milestone m2 (maintainer). + +The gap: since #7836, a refused `Following` (its `refused` flag in +`rs/moq-net/src/model/follow.rs`) waits for an announcement change before +asking again: another instance, the path going and coming back, or the +same instance over another route. `TableCursor::update` +(`rs/moq-net/src/model/origin.rs`, the `previous.meta == meta && +previous.served == served` arm) deliberately delivers nothing when the +winning route keeps its instance, prefix, servability and metadata. So a +handler dropped and re-registered with an identical route stays refused +until something else changes. Making that swap an announcement event was +declined: it would change announcement semantics for every listener, not +just refused followers. + +Recommended: after a refusal, the follower also waits on the route table's +path-scoped `Watch` (crate-private, in `origin.rs`), the generation +`routed_broadcast` already waits on after an `Unroutable`. It moves on any +change to the routes covering the path, including a handler swap, and +wakes only what watches that path, so listeners see nothing new. Check that +re-registering an identical route does bump it; if it doesn't, bump it +there, not in the announcement. Not chosen: a timed retry, which #7836's +decision 2 (maintainer, 2026-11-04) ruled out. + +Fold this into whatever `follow` becomes under +[Listing and follow](/quest/m1/api-audit/route/events.md), which moves +instance changes inside `follow`. If the path watch changes under +[front parking](/quest/m2/origin-front-parks.md), use its replacement. + +Tests: a refused follower asks the replacement after an identical-route +handler swap; an announcement listener sees no event for that swap; and a +follower that nothing replaced still doesn't ask the refusing handler again. + +Public API: none. Wire: none. + +## Required + +- [HLS lists a broadcast's contributions without starting their media](/quest/m0/hls-contributions.md) - its PR, [moq-dev/moq#7836](https://github.com/moq-dev/moq/pull/7836), adds the refused follower this extends + +## Related + +- [Listing and follow](/quest/m1/api-audit/route/events.md) - `follow` takes over instance changes from announce events +- [Front parking](/quest/m2/origin-front-parks.md) - the same refusal wait for `routed_broadcast` +- [The HLS server follows each path once](/quest/m2/hls-follow-once.md) - another `Following` addition diff --git a/quest/m2/socket-old-hop-signal.md b/quest/m2/socket-old-hop-signal.md new file mode 100644 index 00000000000..b9fad75468a --- /dev/null +++ b/quest/m2/socket-old-hop-signal.md @@ -0,0 +1,84 @@ +# [L] A socket dial learns its peer is behind an older hop + +## Goal + +A socket dial to a peer whose endpoint an older moq-lite hop withholds fails +with `Unsupported` instead of waiting, while a dial to a peer that isn't +online yet keeps waiting. The relay holding the older session tells the +dialer on the wire. Dialers and relays on versions without that signal keep +today's wait. + +## Plan + +Planned 2026-11-04 with the maintainer, from the limit +[moq-dev/moq#7888](https://github.com/moq-dev/moq/pull/7888) documented. +Milestone m2 (maintainer). + +Where it gets lost: an endpoint's `.socket/` broadcast is hidden, and +before lite-07 ANNOUNCE_REQUEST has no hidden opt-in. When a peer `P` +reaches its relay `R` over a moq-lite-06 (or older) client session whose +publish half isn't opted into hidden routes, `R` never learns `P`'s +endpoint. Since #7888, `P` sees this from its own session version +(crate-private `HiddenWithheld` in `rs/moq-net/src/model/origin.rs`) and +fails its own dials and accepts. A lite-07 dialer `D` gets nothing: it waits +for `P`'s announcement as for a peer not online yet. `R` can't tell the two +apart either, since it never sees `P`'s hidden path. What `R` does know is +which of its sessions are older moq-lite with a publish half not opted into +hidden, and each one's publish scope from its grants. + +Recommended design, to settle in this quest: + +- **What tells the dialer.** `R` sends a "hidden routes withheld" marker on + its announce stream for each such session, covering that session's + publish scope where it meets the request's prefix, and withdraws it when + the session ends. Relays forward markers like routes, so they cross + cluster links. `D`'s endpoint fails a dial with `Unsupported` while a + marker covers the peer's `.socket/` path and no route serves it. An + announced route always wins over a marker. +- **Scope by publish grant.** A session that may publish nothing (a viewer) + marks nothing, so one old viewer can't fail every dial on a relay. That + is why the signal can't reuse #7888's coarse, origin-wide count, which is + safe only for an endpoint's own hop. A session with an unrestricted + publish scope marks everything it may publish; the PR records that cost. +- **When to judge.** The dial judges only once the dialer's announce sync + has settled, so it never misses a marker that arrives with the snapshot. +- **Where it rides.** As its own announce-stream message, or as a flag on + the [route layer](/quest/m1/cluster-routing/routes/README.md)'s messages + if that layer has landed. Choose whichever leaves the draft simpler, and + say how markers merge across relays. + +Weigh this alternative before choosing: `R` forwards a dialer's narrow +interest to its older sessions, since a lite-06 ANNOUNCE_REQUEST naming the +`.socket/` segment does list the hidden route (#7888's round-1 review +response, `rs/moq-net/src/lite/publisher.rs`). The dial would then connect +with no wire change, but `P` can't tell that its relay forwards interest, +so `P`'s own refusal from #7888 would stay. Pick it only if that one-sided +result is acceptable. + +Versions and compatibility: + +- The signal goes in whichever moq-lite wip is current when this lands + (lite-07-wip before its cut, per the + [freeze policy](/quest/m1/lite07-finalize.md), otherwise the next wip), + with its draft text in the same PR. +- A dialer whose relay doesn't send it, or whose own session predates it, + waits as it does today. Published versions are unchanged. +- moq-transport hops carry no marker, so a dial across one waits as today. + No IETF-only surface is added. +- Rust, `@moq/net`'s socket and moq-ffi behave alike. `doc/concept/socket.md` + and the `Endpoint` rustdoc replace the "waits as for an absent peer" + limit. + +Tests, in the relay harness (`rs/moq-net/tests/integration/socket.rs`): a +lite-07 dial to a peer behind a lite-06 hop fails `Unsupported`, including +across a cluster hop. A dial to an absent peer still waits. A viewer-only +lite-06 session marks nothing. A peer opted into hidden routes over lite-06 +(`an_older_hop_opted_into_hidden_connects`) still connects. + +Public API: none expected; dials return the existing `Error::Unsupported`. +Wire: a new marker on the current moq-lite wip. + +## Related + +- [Sockets](/quest/m1/socket/README.md) - the dial and accept this reports on, and #7888's first-hop check +- [Routes and announces](/quest/m1/cluster-routing/routes/README.md) - the route layer a marker may ride From 33113f986d2d7e05745b68c1ca00bd655f258890 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 4 Nov 2026 14:32:36 -0800 Subject: [PATCH 2/8] test(gst): ignore the flaky interleaved restart test The maintainer decided on 2026-11-04 to ignore restarts_under_reconnects_interleave_on_one_pad until quest/m0/test-flakes-2/gst-reconnect-interleave.md fixes it, and to let moq-dev/moq#7873 land as is, with the cpu-error quest moving the type later. Co-Authored-By: Claude Opus 5.5 --- quest/m0/test-flakes-2/gst-reconnect-interleave.md | 10 +++++++++- quest/m1/rind/cpu-error.md | 3 +++ rs/moq-gst/src/source/imp.rs | 1 + 3 files changed, 13 insertions(+), 1 deletion(-) diff --git a/quest/m0/test-flakes-2/gst-reconnect-interleave.md b/quest/m0/test-flakes-2/gst-reconnect-interleave.md index 5f27c79f328..9983863bb4f 100644 --- a/quest/m0/test-flakes-2/gst-reconnect-interleave.md +++ b/quest/m0/test-flakes-2/gst-reconnect-interleave.md @@ -5,7 +5,8 @@ `restarts_under_reconnects_interleave_on_one_pad` in `rs/moq-gst/src/source/imp.rs` passes reliably in a loaded `just check` and in the merge queue, fixed at its cause under the -[epic](/quest/m0/test-flakes-2/README.md)'s rules. Done when the PR explains +[epic](/quest/m0/test-flakes-2/README.md)'s rules, and runs again with its +`#[ignore]` removed. Done when the PR explains each failure below and shows the loaded run that reproduced it now passing. ## Plan @@ -14,6 +15,13 @@ Planned 2026-11-04 with the maintainer, from [moq-dev/moq#7888](https://github.com/moq-dev/moq/pull/7888)'s suggested follow-ups. No quest or open PR tracked it. +Ignored, decided 2026-11-04 (maintainer, on +[moq-dev/moq#7917](https://github.com/moq-dev/moq/pull/7917)): the test is +`#[ignore]`d with a reason naming this quest, so it stops failing +merge-queue batches. The PR that fixes it removes the +`#[ignore]`, re-enabling the test, and shows it passing in the loaded runs +below. + Failures seen so far, each passing when run alone: - [moq-dev/moq#7888](https://github.com/moq-dev/moq/pull/7888) (2026-11-04, diff --git a/quest/m1/rind/cpu-error.md b/quest/m1/rind/cpu-error.md index e852b809117..eb346d78695 100644 --- a/quest/m1/rind/cpu-error.md +++ b/quest/m1/rind/cpu-error.md @@ -22,6 +22,9 @@ moq-quic, moq-tokio, qmux and moq-uring onto it as `UnsupportedCpu(#[from] ...)` with `#[error(transparent)]`. This quest does the same for the three crates it left, so it starts once that PR lands. +- ✅ #7873 lands as is, with the type in `provider`; this quest moves it + later (maintainer, 2026-11-04, on + [moq-dev/moq#7917](https://github.com/moq-dev/moq/pull/7917)). - **The type must not need rustls.** In #7873, `provider` pulls in rustls, since it also holds `provider()` and `install_default()`. moq-auth's core build has no rustls (only its `client` feature does), and the e2ee feature diff --git a/rs/moq-gst/src/source/imp.rs b/rs/moq-gst/src/source/imp.rs index a05d8a9676f..838a92acb20 100644 --- a/rs/moq-gst/src/source/imp.rs +++ b/rs/moq-gst/src/source/imp.rs @@ -4936,6 +4936,7 @@ mod session_tests { /// route drops and returns as across a reconnect. The pad's actor takes each play, idle, and /// retirement in turn, so every round lands on the first pad and none ends it. #[test] + #[ignore = "flaky under load; see quest/m0/test-flakes-2/gst-reconnect-interleave.md"] fn restarts_under_reconnects_interleave_on_one_pad() { let _pad_ids = pad_ids(); let element = element(); From b5404a89a32f1a5c413bcb6c5e3167b3e80d197e Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 4 Nov 2026 14:33:52 -0800 Subject: [PATCH 3/8] quest: base the old-hop dial marker on the dialed endpoint A grant-scoped marker would fail a dial to an absent peer under an older publisher's grant. The relay now probes its older sessions for the dialed path and marks only an endpoint that exists. Co-Authored-By: Claude Opus 5.5 --- quest/m2/README.md | 2 +- quest/m2/socket-old-hop-signal.md | 66 +++++++++++++++++-------------- 2 files changed, 37 insertions(+), 31 deletions(-) diff --git a/quest/m2/README.md b/quest/m2/README.md index 2c98e7fb11e..a8aff7c8165 100644 --- a/quest/m2/README.md +++ b/quest/m2/README.md @@ -89,7 +89,7 @@ lite-07; bitrate enforcement is not part of this release. - [A refused follower asks a replacement handler](/quest/m2/follow-refused-retry.md) - a same-instance handler swap with identical route details re-asks a refused `Following`, while listeners still see no change - [Route wakes](/quest/m2/route-wakes.md) - a route change wakes only the fronts it can move, so pool churn stops scaling with served paths - [A route stream's interest is a set of prefixes](/quest/m2/route-interest-prefixes.md) - one Announce Stream covers several subtrees, with floors and certification proved over the set -- [A socket dial learns its peer is behind an older hop](/quest/m2/socket-old-hop-signal.md) - a relay marks what its older moq-lite sessions withhold, so a dial fails `Unsupported` instead of waiting like one to an absent peer +- [A socket dial learns its peer is behind an older hop](/quest/m2/socket-old-hop-signal.md) - a relay finds the dialed endpoint behind its older moq-lite session and marks that path, so the dial fails `Unsupported` while one to an absent peer still waits - [Fewer allocations in announce fan-out](/quest/m2/announce-fanout-allocs.md) - a deep path costs no more allocations per subscriber than a shallow one - [moq-room scales to large rooms](/quest/m2/room-bench.md) - a benchmark measures `Room` with large participant counts, and polling narrows only if it shows a slope - [Route health](/quest/m2/route-health/README.md) - epoch-only active/passive track recovery over metadata-only subscriptions diff --git a/quest/m2/socket-old-hop-signal.md b/quest/m2/socket-old-hop-signal.md index b9fad75468a..0d0a0651068 100644 --- a/quest/m2/socket-old-hop-signal.md +++ b/quest/m2/socket-old-hop-signal.md @@ -26,34 +26,39 @@ apart either, since it never sees `P`'s hidden path. What `R` does know is which of its sessions are older moq-lite with a publish half not opted into hidden, and each one's publish scope from its grants. -Recommended design, to settle in this quest: +The signal must be about the peer, not the grant. A session's publish +grant says only that it *may* publish under a prefix, not that the dialed +endpoint exists behind it. A marker covering an older session's grant would +also fail a dial to a peer that isn't online yet under that grant, which is +exactly the case that must keep waiting. So the grant only narrows where to +look, and the evidence has to name the endpoint. -- **What tells the dialer.** `R` sends a "hidden routes withheld" marker on - its announce stream for each such session, covering that session's - publish scope where it meets the request's prefix, and withdraws it when - the session ends. Relays forward markers like routes, so they cross - cluster links. `D`'s endpoint fails a dial with `Unsupported` while a - marker covers the peer's `.socket/` path and no route serves it. An - announced route always wins over a marker. -- **Scope by publish grant.** A session that may publish nothing (a viewer) - marks nothing, so one old viewer can't fail every dial on a relay. That - is why the signal can't reuse #7888's coarse, origin-wide count, which is - safe only for an endpoint's own hop. A session with an unrestricted - publish scope marks everything it may publish; the PR records that cost. -- **When to judge.** The dial judges only once the dialer's announce sync - has settled, so it never misses a marker that arrives with the snapshot. -- **Where it rides.** As its own announce-stream message, or as a flag on - the [route layer](/quest/m1/cluster-routing/routes/README.md)'s messages - if that layer has landed. Choose whichever leaves the draft simpler, and - say how markers merge across relays. +Recommended design, to settle in this quest: -Weigh this alternative before choosing: `R` forwards a dialer's narrow -interest to its older sessions, since a lite-06 ANNOUNCE_REQUEST naming the -`.socket/` segment does list the hidden route (#7888's round-1 review -response, `rs/moq-net/src/lite/publisher.rs`). The dial would then connect -with no wire change, but `P` can't tell that its relay forwards interest, -so `P`'s own refusal from #7888 would stay. Pick it only if that one-sided -result is acceptable. +- **Find the endpoint.** When a dial's interest in `/.socket/` + reaches a relay, the relay asks each of its older sessions whose publish + grant covers that path, with an ANNOUNCE_REQUEST naming the path, held + open while the dial waits so a peer that comes online later is seen. Such a + request names the hidden segment, so a lite-06 peer does announce its + endpoint (#7888's round-1 review response, + `rs/moq-net/src/lite/publisher.rs`). A session that may publish nothing + (a viewer) is never asked. +- **Tell the dialer.** If an older session announces the endpoint, the relay + sends a marker for that exact path on the wire: the endpoint exists behind + an older hop. `D`'s endpoint fails the dial with `Unsupported`, and only + for that path. With no answer, nothing is marked, and the dial waits as + for an absent peer. The marker is withdrawn when that session ends. +- **Across a cluster.** Relay-to-relay links ask for everything, not for a + dialer's narrow interest, so the relay holding the older session may never + see the dial. Settle how the interest or the probe reaches it (for example, + the holding relay probes on a dial's SUBSCRIBE to the path, which it does + receive), and how markers cross cluster links. +- **Where the marker rides.** Its own announce-stream message, or a flag on + the [route layer](/quest/m1/cluster-routing/routes/README.md)'s messages if + that layer has landed. Choose whichever leaves the draft simpler. +- **Not chosen:** routing the dial once the probe finds the endpoint. The + peer can't tell that its relay probes, so it keeps failing its own dials + and accepts (#7888), and the session would connect from one side only. Versions and compatibility: @@ -71,14 +76,15 @@ Versions and compatibility: Tests, in the relay harness (`rs/moq-net/tests/integration/socket.rs`): a lite-07 dial to a peer behind a lite-06 hop fails `Unsupported`, including -across a cluster hop. A dial to an absent peer still waits. A viewer-only -lite-06 session marks nothing. A peer opted into hidden routes over lite-06 +across a cluster hop. A dial to an absent peer still waits, including one +whose path lies under another lite-06 session's publish grant. A viewer-only +lite-06 session is never asked. A peer opted into hidden routes over lite-06 (`an_older_hop_opted_into_hidden_connects`) still connects. Public API: none expected; dials return the existing `Error::Unsupported`. -Wire: a new marker on the current moq-lite wip. +Wire: a new per-path marker on the current moq-lite wip. ## Related - [Sockets](/quest/m1/socket/README.md) - the dial and accept this reports on, and #7888's first-hop check -- [Routes and announces](/quest/m1/cluster-routing/routes/README.md) - the route layer a marker may ride +- [Routes and announces](/quest/m1/cluster-routing/routes/README.md) - the route layer a marker may ride, and how interest crosses cluster links From b92b75e3b97c555228abc064acdb51088f5f7038 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 4 Nov 2026 14:36:00 -0800 Subject: [PATCH 4/8] quest: name request's refusal wait, not the removed routed_broadcast Co-Authored-By: Claude Opus 5.5 --- quest/m2/follow-refused-retry.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/quest/m2/follow-refused-retry.md b/quest/m2/follow-refused-retry.md index 3bfcb360bfd..edb83a99aa1 100644 --- a/quest/m2/follow-refused-retry.md +++ b/quest/m2/follow-refused-retry.md @@ -28,7 +28,8 @@ just refused followers. Recommended: after a refusal, the follower also waits on the route table's path-scoped `Watch` (crate-private, in `origin.rs`), the generation -`routed_broadcast` already waits on after an `Unroutable`. It moves on any +`origin::Consumer::request` (its `Requesting` future) already waits on +after an `Unroutable`. It moves on any change to the routes covering the path, including a handler swap, and wakes only what watches that path, so listeners see nothing new. Check that re-registering an identical route does bump it; if it doesn't, bump it @@ -53,5 +54,5 @@ Public API: none. Wire: none. ## Related - [Listing and follow](/quest/m1/api-audit/route/events.md) - `follow` takes over instance changes from announce events -- [Front parking](/quest/m2/origin-front-parks.md) - the same refusal wait for `routed_broadcast` +- [Front parking](/quest/m2/origin-front-parks.md) - the same refusal wait for `request` - [The HLS server follows each path once](/quest/m2/hls-follow-once.md) - another `Following` addition From 34d9d30faa046887b0b0d9e5294e5ba8af3e9fca Mon Sep 17 00:00:00 2001 From: "pullfrog[bot]" <226033991+pullfrog[bot]@users.noreply.github.com> Date: Wed, 4 Nov 2026 22:50:08 +0000 Subject: [PATCH 5/8] test-inventory: allow the ignored gst flake, owned by its quest --- sh/gh/test-inventory.allow | 3 +++ 1 file changed, 3 insertions(+) diff --git a/sh/gh/test-inventory.allow b/sh/gh/test-inventory.allow index 29342f1414c..6f44c275b3f 100644 --- a/sh/gh/test-inventory.allow +++ b/sh/gh/test-inventory.allow @@ -2,6 +2,9 @@ # one: ` `. sh/gh/test-inventory.py prints the name of any # orphan missing here, and fails on an entry that has a caller. +# Flaky under load; the quest makes it reliable, then removes its `#[ignore]`. +ignore moq-gst::source::imp::session_tests::restarts_under_reconnects_interleave_on_one_pad /quest/m0/test-flakes-2/gst-reconnect-interleave.md + # Need a GPU, a desktop, or a device that no CI runner has. ignore moq-carla-bridge::gpu_video_reaches_the_worker /quest/m2/carla-bridge.md recipe carla::bridge-gpu /quest/m2/carla-bridge.md From 424d3f69da1b97b977b756151f11ad3aa9715978 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 4 Nov 2026 14:51:57 -0800 Subject: [PATCH 6/8] quest: cache group errors by kind, retryable ones for a bounded time Planned with the maintainer while settling moq-dev/moq#7872. Co-Authored-By: Claude Opus 5.5 --- quest/m1/README.md | 1 + quest/m1/group-error-cache.md | 87 +++++++++++++++++++++++++++++++++++ 2 files changed, 88 insertions(+) create mode 100644 quest/m1/group-error-cache.md diff --git a/quest/m1/README.md b/quest/m1/README.md index 482d92c8aa1..b546c114eff 100644 --- a/quest/m1/README.md +++ b/quest/m1/README.md @@ -150,6 +150,7 @@ their end report, so an embedder's drain alert pages on real cuts. - [A job's exact route continues its claim's readers](/quest/m1/announce-takeover.md) - a job's route inherits its claim's instance, replacing the ANNOUNCE_TAKEOVER predecessor design - [Subscribe ranges](/quest/m1/subscribe-ranges/README.md) - a lite-07 SUBSCRIBE asks for past and live ranges with absolute or relative ends, in either order, and replaces FETCH; merged ranges never starve a subscriber; relays fill misses by range, including over moq-transport - [Drop set](/quest/m1/drop-set.md) - each cursor judges missing groups against its own budget, so a narrow reader drops promptly and a widening re-offers groups already reported dropped on lite-07 +- [Group errors are cached by kind](/quest/m1/group-error-cache.md) - permanent group errors bind every reader, retryable ones are kept only for a bounded time, and a live SUBSCRIBE_DROP or FETCH answered `Old` no longer caches it for good - [A group a subscriber gives up on is always reported](/quest/m1/group-drops.md) - the wire names every abandoned group and the drop signal is public, so readers count losses instead of stalling - [The overcommitted receive-window cells run again](/quest/m1/receive-windows-evicted.md) - `benchmark_receive_windows` measures its 256-stream and 4 MiB-frame cells again, reporting delivered frames and evictions instead of stalling - [JS group demand counts only readers that will read](/quest/m1/js-group-demand.md) - a buffered copy whose reader already passed it no longer keeps a group wanted, so JS fills stop where Rust's do diff --git a/quest/m1/group-error-cache.md b/quest/m1/group-error-cache.md new file mode 100644 index 00000000000..b51a73d9077 --- /dev/null +++ b/quest/m1/group-error-cache.md @@ -0,0 +1,87 @@ +# [M] Group errors are cached by kind, retryable ones for a bounded time + +## Goal + +Every place moq-net records that a group won't be delivered, in Rust and +JS, follows one rule. A permanent error, where the group can never be +served, is recorded and binds every later reader. A retryable error is kept +only for a bounded time, so a later reader or a widened one asks again once +it lapses, while a burst of readers doesn't re-ask the source for each one. +Both paths that cache `Old` permanently on main follow the rule. + +## Plan + +Planned 2026-11-04 with the maintainer, while settling +[moq-dev/moq#7872](https://github.com/moq-dev/moq/pull/7872). In the +maintainer's words: "we should cache errors for some amount of time. I +really hate classifying them though, but I think we kind of have to know +the difference between permanent and retryable errors." Milestone m1 +(maintainer). + +Where this starts: #7872 (decision 2, 2026-11-04) made a range's own start +skip, a second stale drop, and history recovered once non-permanent. +`Fill::refuse_groups` records nothing, while `Fill::drop_groups` records +the groups as lost for good (`rs/moq-net/src/model/track/fill.rs`). The +only permanent losses it kept are a SUBSCRIBE_DROP NotFound and groups past +the track's end. Two paths on main still cache `Old` permanently, listed as +#7872's follow-ups: + +- A live SUBSCRIBE_DROP records every error on the track, `Old` included: + `self.serving.drop_groups(...)` in `rs/moq-net/src/lite/subscriber.rs` + (the `SubscribeResponse::Drop` arm), into `track::Producer::drop_groups` + (`rs/moq-net/src/model/track.rs`). +- `Fill::reject` for lite and IETF FETCH (`reject` in + `rs/moq-net/src/model/track/fill.rs`) records `Old` as dropped when + `old_binds_everyone`, that is when the publisher's max age applies to + every reader. + +The work: + +- **Inventory** every place a group error is recorded or refused, in Rust + (`TrackState::drop_groups`, `drop_unfed`, `Fill::drop_groups`, + `refuse_groups`, `reject_groups`, `reject`, the IETF subscriber's fetch + and range drops in `rs/moq-net/src/ietf/subscriber.rs`) and JS (`#drop` + in `js/net/src/track.ts`, `Fill.dropGroups` and `refuseGroups` in + `js/net/src/fill.ts`, and `js/net/src/ietf/range.ts`). For each, note + which errors reach it and whether it caches them. Put the inventory in the + PR. +- **The smallest classification that works.** Recommended starting point: + permanent for not found, past the track's end, and unauthorized; + retryable for old, lagged, evicted, cancelled, and unroutable. Keep it a + property of the error kind, decided in one place, rather than a per-call + choice. Prefer fewer classes if the inventory shows one is never needed. + Don't match on error variants at the call sites (AGENTS.md); classify + once where the error is defined. +- **Bounded caching for retryable errors.** Decide whether a retryable + error is cached at all, and for how long. Prefer a bound the track + already has over a new constant: for `Old`, the budget it was judged + under (a widening already re-asks), or the publisher's max age. The + bound must also hold up against a hostile peer: what the cache holds is + sized by the pool, as the [drop set](/quest/m1/drop-set.md) bills its + runs. +- **Fix both main paths** under the rule: a live SUBSCRIBE_DROP records + only a permanent error, and `Fill::reject` stops recording `Old` as lost + for good. Mirror both in JS. +- **To settle in this quest, with the maintainer:** the drop set keeps a + received stale run with the budget it was judged under, reversed only by a + widening ("Only a widening reverses a stale verdict"). That is a + retryable error held without a time bound. Either the bounded-time rule + covers those runs too, or the drop set's budget scoping already counts as + the bound for `Old`. Recommended: the latter, so `Old` has one bound (its + budget) and the time bound covers the other retryable kinds. +- Tests: a retryable refusal is asked again after its bound lapses and not + before; a permanent one never is; a live SUBSCRIBE_DROP with `Old` no + longer binds a wider reader; a FETCH answered `Old` under the publisher's + max age is asked again once the bound lapses. + +Public API: possibly a classification query on `Error` (Rust) and its JS +mirror, if a caller outside moq-net needs it; otherwise none. Wire: none. + +## Required + +- [Drop set](/quest/m1/drop-set.md) - its per-cursor runs and their reasons are what this bounds; its PR, [moq-dev/moq#7670](https://github.com/moq-dev/moq/pull/7670), rewrites the same recording paths +- [Lite-07 ranges](/quest/m1/subscribe-ranges/lite.md) - its PR, [moq-dev/moq#7872](https://github.com/moq-dev/moq/pull/7872), makes the start skip and recovery non-permanent, the rule this generalizes + +## Related + +- [A group a subscriber gives up on is always reported](/quest/m1/group-drops.md) - reports what a subscriber gives up; this decides how long the track remembers it From 6f2163c192935dd9322a9386abd5f122f215f0c5 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 4 Nov 2026 14:53:59 -0800 Subject: [PATCH 7/8] quest: an announced route wins over the old-hop marker, which follows the endpoint Co-Authored-By: Claude Opus 5.5 --- quest/m2/socket-old-hop-signal.md | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/quest/m2/socket-old-hop-signal.md b/quest/m2/socket-old-hop-signal.md index 0d0a0651068..ad2672ea363 100644 --- a/quest/m2/socket-old-hop-signal.md +++ b/quest/m2/socket-old-hop-signal.md @@ -47,12 +47,17 @@ Recommended design, to settle in this quest: sends a marker for that exact path on the wire: the endpoint exists behind an older hop. `D`'s endpoint fails the dial with `Unsupported`, and only for that path. With no answer, nothing is marked, and the dial waits as - for an absent peer. The marker is withdrawn when that session ends. + for an absent peer. The marker tracks that announcement: it goes when the + older session unannounces the endpoint or ends, whichever comes first. +- **An announced route wins.** While any route announces the endpoint (for + example, a current session overlapping an older one during a reconnect), + the dial uses it and ignores the marker. - **Across a cluster.** Relay-to-relay links ask for everything, not for a dialer's narrow interest, so the relay holding the older session may never - see the dial. Settle how the interest or the probe reaches it (for example, - the holding relay probes on a dial's SUBSCRIBE to the path, which it does - receive), and how markers cross cluster links. + see the dial, and a dial sends no SUBSCRIBE until the endpoint is + announced. Settle how the dialer's narrow interest reaches the holding + relay (for example, cluster links forwarding narrow interest under + `.socket`), and how markers cross cluster links. - **Where the marker rides.** Its own announce-stream message, or a flag on the [route layer](/quest/m1/cluster-routing/routes/README.md)'s messages if that layer has landed. Choose whichever leaves the draft simpler. @@ -78,7 +83,9 @@ Tests, in the relay harness (`rs/moq-net/tests/integration/socket.rs`): a lite-07 dial to a peer behind a lite-06 hop fails `Unsupported`, including across a cluster hop. A dial to an absent peer still waits, including one whose path lies under another lite-06 session's publish grant. A viewer-only -lite-06 session is never asked. A peer opted into hidden routes over lite-06 +lite-06 session is never asked. A marker goes when the older session +unannounces the endpoint, and a current route announcing the same endpoint +wins over it. A peer opted into hidden routes over lite-06 (`an_older_hop_opted_into_hidden_connects`) still connects. Public API: none expected; dials return the existing `Error::Unsupported`. From 1e17a307d94be594c633e91740c43b4e46a29291 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 4 Nov 2026 14:55:42 -0800 Subject: [PATCH 8/8] quest: address CodeRabbit's planning findings on #7917 Co-Authored-By: Claude Opus 5.5 --- .../test-flakes-2/gst-reconnect-interleave.md | 15 ++++++++++----- quest/m1/js-group-demand.md | 3 ++- quest/m2/follow-refused-retry.md | 19 +++++++++++++------ quest/m2/socket-old-hop-signal.md | 3 ++- 4 files changed, 27 insertions(+), 13 deletions(-) diff --git a/quest/m0/test-flakes-2/gst-reconnect-interleave.md b/quest/m0/test-flakes-2/gst-reconnect-interleave.md index 9983863bb4f..ee5b8b42e36 100644 --- a/quest/m0/test-flakes-2/gst-reconnect-interleave.md +++ b/quest/m0/test-flakes-2/gst-reconnect-interleave.md @@ -49,11 +49,16 @@ in a fast run. Find each from the code under test before changing the test. `super::RUNTIME`. Prefer driving the session's timers with a mocked clock or waiting on an event, as the epic's rules say. If the session itself is slow under load, fix that. -- The `Eos` breaks the test's own claim that no round ends the pad. Check - whether the pad's actor can retire the pad when a restart, the catalog - relist, and the unannounce and re-announce interleave, as moqsrc's - rendition actor ([moq-dev/moq#7368](https://github.com/moq-dev/moq/pull/7368)) - promises it can't. A real retirement is a moqsrc bug, fixed in moqsrc. +- The `Eos` breaks the test's own claim that no round ends the pad. The + pad actor retires a pad whose rendition is still delisted at its turn + (`retired()` checks the pad table's `listed`), and the test doesn't wait + for the catalog relist to apply before it unannounces. First lead: the + retirement is intended and the test is missing that wait (a relist of an + existing rendition adds no pad, so the sibling test's `await_pad` doesn't + apply). If the retirement happens even after the relist applied, it's a + moqsrc bug, fixed in moqsrc + ([moq-dev/moq#7368](https://github.com/moq-dev/moq/pull/7368) made the + actor own the pad). - Find which call returned `Unroutable` in #7296's run, and whether `publication.announce` or a follow can meet an unroutable path in the window after `unannounce`. diff --git a/quest/m1/js-group-demand.md b/quest/m1/js-group-demand.md index 67f1c423b6c..36393bd4a64 100644 --- a/quest/m1/js-group-demand.md +++ b/quest/m1/js-group-demand.md @@ -39,7 +39,8 @@ neither answered nor delivered live since it was asked"). whichever has landed and leave the other a note. - Tests: a fill FETCH stops once the only remaining mirror belongs to a reader that passed the group, and keeps going while a mirror's reader - still has to reach it. + still has to reach it. An IETF range fetch stops once its last reader + passes the requested group. Public API: none. Wire: none. diff --git a/quest/m2/follow-refused-retry.md b/quest/m2/follow-refused-retry.md index edb83a99aa1..c867c37b705 100644 --- a/quest/m2/follow-refused-retry.md +++ b/quest/m2/follow-refused-retry.md @@ -4,8 +4,10 @@ A `Following` whose last resolution was refused asks again once the handler that refused it is replaced, even when the replacement registers -the same instance with identical route details. Announcement listeners -still see no change for such a swap. +the same instance with identical route details while the old one is still +up, so the path stays covered. Announcement listeners still see no change +for such an overlapping swap. A swap that drops the old route first already +ends and restarts the path, which a refused follower re-asks today. ## Plan @@ -33,7 +35,10 @@ after an `Unroutable`. It moves on any change to the routes covering the path, including a handler swap, and wakes only what watches that path, so listeners see nothing new. Check that re-registering an identical route does bump it; if it doesn't, bump it -there, not in the announcement. Not chosen: a timed retry, which #7836's +there, not in the announcement. The watch wakes on any change to a +covering route, including a lower-ranked one that leaves the refusing +handler selected, so after each wake ask again only if the selected route +entry is no longer the one that refused. Not chosen: a timed retry, which #7836's decision 2 (maintainer, 2026-11-04) ruled out. Fold this into whatever `follow` becomes under @@ -41,9 +46,11 @@ Fold this into whatever `follow` becomes under instance changes inside `follow`. If the path watch changes under [front parking](/quest/m2/origin-front-parks.md), use its replacement. -Tests: a refused follower asks the replacement after an identical-route -handler swap; an announcement listener sees no event for that swap; and a -follower that nothing replaced still doesn't ask the refusing handler again. +Tests: a refused follower asks the replacement after an overlapping +identical-route handler swap; an announcement listener sees no event for +that swap; a change to a lower-ranked covering route doesn't re-ask the +refusing handler; and a follower that nothing replaced doesn't ask it +again. Public API: none. Wire: none. diff --git a/quest/m2/socket-old-hop-signal.md b/quest/m2/socket-old-hop-signal.md index ad2672ea363..21504ceb311 100644 --- a/quest/m2/socket-old-hop-signal.md +++ b/quest/m2/socket-old-hop-signal.md @@ -83,7 +83,8 @@ Tests, in the relay harness (`rs/moq-net/tests/integration/socket.rs`): a lite-07 dial to a peer behind a lite-06 hop fails `Unsupported`, including across a cluster hop. A dial to an absent peer still waits, including one whose path lies under another lite-06 session's publish grant. A viewer-only -lite-06 session is never asked. A marker goes when the older session +lite-06 session is never asked. A dial that starts before the older +session announces the endpoint fails `Unsupported` once it does. A marker goes when the older session unannounces the endpoint, and a current route announcing the same endpoint wins over it. A peer opted into hidden routes over lite-06 (`an_older_hop_opted_into_hidden_connects`) still connects.