From 0826108a707d6f9a12b1654861ad1b1d11d199ea Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 4 Nov 2026 23:20:42 -0800 Subject: [PATCH 01/21] chore(quest): claim quest/m1/stream-credit/release-on-leave.md Quest-Claim: 6b7d2ce6d5b0e858 From 83cb9d70ba2c1f23e05c6f1259f40f4a2ceb304c Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 4 Nov 2026 23:43:16 -0800 Subject: [PATCH 02/21] docs(quest): record lite-07 three-slot setup blocker Co-Authored-By: GPT-6.1 Sol --- quest/m1/stream-credit/release-on-leave.md | 45 ++++++++++++++++++++++ 1 file changed, 45 insertions(+) diff --git a/quest/m1/stream-credit/release-on-leave.md b/quest/m1/stream-credit/release-on-leave.md index 7cd4de438f0..2780af4fbe4 100644 --- a/quest/m1/stream-credit/release-on-leave.md +++ b/quest/m1/stream-credit/release-on-leave.md @@ -21,3 +21,48 @@ relay test first, find which stream stays open and on which side, fix it, and set that relay test's credits back to the tight case. With opens now waiting for credit instead of failing, a leaked stream stalls later subscriptions silently, and low-credit peers such as browsers hit it first. + + +### Investigation + +2026-11-04: reproduced before any fix with the existing relay regression, changing +only lite-07's credit from 4 to exactly 3. The command +`just rs test -p moq-net --test integration -E 'test(a_subscription_past_the_credit_is_served_once_credit_returns)'` +failed: "moq-lite-07-wip: the waiting subscription never got credit". +The client stream types before departure were `[7, 1, 6]`: AUTH, ANNOUNCE, TRACK. +The first SUBSCRIBE had not reached the publisher. The initial diagnosis of a +leak after an established subscription was therefore incomplete. + +`ServeLoop::poll` waits in `ServeMode::Establish` without checking whether demand +left, keeping the answered `HeldTrack` open. An experimental abandonment check +and explicit cancellation of the opening registration released that TRACK and let +the second TRACK resolve. With the first publisher track kept alive, the same +regression then failed later: "no group after credit returned". The second +SUBSCRIBE was now blocked behind its own TRACK. This confirms that departure +cleanup alone does not achieve the Goal. The incomplete implementation and test +edits were removed pending the contract decision above. + +Before claiming, checked the current patches of +[moq-dev/moq#7670](https://github.com/moq-dev/moq/pull/7670) and +[moq-dev/moq#7737](https://github.com/moq-dev/moq/pull/7737). Their stale-group and +pending-join changes touch the files but do not implement this cleanup or remove +the TRACK/SUBSCRIBE credit dependency. + + +## Waiting + +- Maintainer: choose the stream-budget contract before implementation. Investigation + on main `0834a1eab0` found that three slots cannot establish even the first media + subscription: AUTH and ANNOUNCE hold two, TRACK holds the third until SUBSCRIBE + answers, and SUBSCRIBE needs a fourth. Options: + 1. **(Recommended)** Make lite-07 subscription setup fit three slots by returning + immutable track metadata on SUBSCRIBE, removing the companion TRACK from this + path. This revises the unpublished wire and needs Rust/JS and draft updates; + retain standalone TRACK for info-only queries. + 2. Keep the separate TRACK/SUBSCRIBE handshake and scope this quest to departure + cleanup with four slots, documenting its minimum credit requirement. This + abandons the present three-slot Goal. + 3. Release TRACK before SUBSCRIBE opens when credit is exhausted. This creates a + demand gap for on-demand producers and needs an explicit decision about their + lifetime; do not silently weaken the current hold guarantee. + Check: record the chosen contract in Plan, then resume implementation. From f7fdfddd34907de0027883b239d02a6962fdd167 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 5 Nov 2026 12:50:00 -0800 Subject: [PATCH 03/21] chore(quest): claim quest/m1/stream-credit/release-on-leave.md Quest-Claim: f14c95768e229ca8 From ad77cfed0e58d0aa3f44c8d6d0c59341476f1bd0 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 5 Nov 2026 12:57:44 -0800 Subject: [PATCH 04/21] fix(net): release abandoned subscription setup streams Co-Authored-By: GPT-6.1 Sol --- js/net/src/lite/subscriber.test.ts | 32 ++++++ quest/m1/stream-credit/README.md | 1 - quest/m1/stream-credit/release-on-leave.md | 28 ----- rs/moq-net/src/lite/subscriber.rs | 100 +++++++++++++++++- rs/moq-net/tests/integration/stream_credit.rs | 66 ++++++++++++ 5 files changed, 197 insertions(+), 30 deletions(-) delete mode 100644 quest/m1/stream-credit/release-on-leave.md diff --git a/js/net/src/lite/subscriber.test.ts b/js/net/src/lite/subscriber.test.ts index a9004ee48f2..64b730c0dbc 100644 --- a/js/net/src/lite/subscriber.test.ts +++ b/js/net/src/lite/subscriber.test.ts @@ -1284,6 +1284,38 @@ test("a lite SUBSCRIBE open given up leaves its stream to the next open", async } }); +// Leaving during SUBSCRIBE setup releases its TRACK bridge while the broadcast stays live. +test.each(["credit", "answer"] as const)("abandoning SUBSCRIBE during %s releases TRACK", async (stage) => { + const { quic, streams, opened } = fakeSession(stage === "credit" ? [1] : []); + const subscriber = new Subscriber(quic, Version.DRAFT_07, HopSchema.parse(1n)); + const warn = spyOn(console, "warn").mockImplementation(() => {}); + const room = subscriber.consume(Path.from("room")); + try { + const video = room.track("video").subscribe(); + await opened(0); + await streams[0].reading; + await answerTrackInfo(streams[0], Version.DRAFT_07); + await opened(1); + if (stage === "answer") await streams[1].reading; + video.close(); + await drainReactions(); + if (stage === "credit") await streams[0].aborted; + else await streams[0].finished; + if (stage === "credit") { + streams[1].release(); + await drainReactions(); + expect(streams[1].written).toEqual([]); + } + const audio = room.track("audio").subscribe(); + await (await opened(stage === "credit" ? 1 : 2)).writing; + audio.close(); + } finally { + room.close(); + subscriber.close(); + warn.mockRestore(); + } +}); + // The last reader leaving gives the setup up while its TRACK stream still waits for a slot, so // the stream admitted for it goes unused to the next open. test("a lite subscribe whose readers leave while it waits for a stream gives up the wait", async () => { diff --git a/quest/m1/stream-credit/README.md b/quest/m1/stream-credit/README.md index 8b4eb210783..a76e52b8af5 100644 --- a/quest/m1/stream-credit/README.md +++ b/quest/m1/stream-credit/README.md @@ -42,7 +42,6 @@ receiving every group, and nothing hanging. ## Required -- [An abandoned subscription setup releases its streams](/quest/m1/stream-credit/release-on-leave.md) - release TRACK and pending SUBSCRIBE when demand leaves during setup - [Open streams](/quest/m1/stream-credit/open-streams.md) - each session lists its open streams and, where the transport can tell, which are fully acknowledged - [Reset fallback](/quest/m1/stream-credit/reset-fallback.md) - a waiting higher-priority open resets the lowest-priority stream, one reset in flight per waiting open - [Takeover](/quest/m1/stream-credit/takeover.md) - on lite-07 a higher-priority group takes over an acknowledged stream, and a group that lost its stream resumes diff --git a/quest/m1/stream-credit/release-on-leave.md b/quest/m1/stream-credit/release-on-leave.md deleted file mode 100644 index 69b95024cb1..00000000000 --- a/quest/m1/stream-credit/release-on-leave.md +++ /dev/null @@ -1,28 +0,0 @@ -# [S] An abandoned subscription setup releases its streams - -## Goal - -On lite-07, a subscription whose last reader leaves while SUBSCRIBE is still -opening or awaiting its answer releases its upstream TRACK and pending -SUBSCRIBE, so their credit can serve later requests. - -## Plan - -Decided 2026-11-05 (maintainer, /quest-plan): ✅ Keep the TRACK/SUBSCRIBE -handshake and document the minimum of four concurrent bidirectional streams. -AUTH and ANNOUNCE hold two slots for the session lifetime; TRACK is briefly -held alongside SUBSCRIBE. Three slots cannot establish the first subscription. -Rejected: metadata on SUBSCRIBE (overlaps other lite-07 work and saves no round -trip), and releasing TRACK early during a live setup. - -The established-subscription regression -`a_subscription_past_the_credit_is_served_once_credit_returns` already passes -with four slots. Keep that budget. The three-slot reproduction did not show a -departure leak. - -Local review identified remaining pending-setup cleanup: `ServeLoop::poll` in -`ServeMode::Establish` waits on establishment without observing lost demand, -while holding `HeldTrack`. Reproduce abandonment with at least four slots, -keeping the publisher and route live, then ensure both the TRACK hold and the -pending SUBSCRIBE registration are released when demand leaves. Preserve the -hold while demand remains. Cover Rust and its JS counterpart where applicable. diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index a54e95cd82e..bdbc4cae7ae 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -6058,7 +6058,7 @@ mod tests { assert!(wire.is_empty(), "a second SUBSCRIBE trailed the first"); } - /// A narrower limit landing while the SUBSCRIBE is still opening resets it with + /// A narrower limit landing while SUBSCRIBE is still opening resets it with /// UNAUTHORIZED, like a live one, and releases its id. #[kio::test] async fn a_narrower_limit_resets_a_subscribe_still_opening() { @@ -6094,6 +6094,7 @@ mod tests { let broadcast = crate::broadcast::Info::new().produce(); let request = broadcast.reserve_track("audio").unwrap(); let mut serving = ServeLoop::new(&serve, request, Default::default()); + let _reader = serving.serving.subscribe(None); let wire = Wire { subscription: Subscription::default(), demand: Some(Subscription::default()), @@ -6122,6 +6123,91 @@ mod tests { drop(gate); } + /// Losing demand releases setup even when credit, writes, or the answer never arrive. + #[kio::test] + async fn an_abandoned_setup_releases_its_track_and_registration() { + for stage in ["credit", "write", "answer"] { + let gate = kio::Producer::new(stage != "write"); + let opening = kio::Producer::new(true); + let session = SinkSession::gated_bi(gate.consume()).with_open_bi_gate(opening.consume()); + + let origin = origin::Config::new(crate::Hop::new(1).unwrap()).produce(); + let subscriber = Subscriber::new(SubscriberConfig { + runtime: crate::time::sim(), + session: crate::driver::Transport::new(session.clone()), + origin, + recv_bandwidth: None, + version: Version::Lite07, + peer_setup: crate::lite::PeerSetup::new(false, crate::transport::Address::Setup), + peer_hop: None, + cost: None, + going_away: Default::default(), + auth: crate::auth::Link::new(false), + }); + let subscribes = subscriber.subscribes.clone(); + let serve = TrackServe { + validity: Default::default(), + route: None, + source: None, + subscriber, + path: Path::from_static("room/host"), + instance: None, + name: "audio".to_string(), + }; + + let broadcast = crate::broadcast::Info::new().produce(); + let request = broadcast.reserve_track("audio").unwrap(); + let mut serving = ServeLoop::new(&serve, request, Default::default()); + let reader = serving.serving.subscribe(None); + let held = Stream::open(&serve.subscriber.session, Version::Lite07).await.unwrap(); + serving.held = Some(HeldTrack(held)); + if stage == "credit" { + *opening.write().ok().expect("gate live") = false; + } + let wire = Wire { + subscription: Subscription::default(), + demand: Some(Subscription::default()), + demand_ranges: vec![lite::Range::OLDEST], + ranges: vec![lite::Range::OLDEST], + }; + let establish = serve.prepare_establish(&mut serving.serving, wire, &Default::default()); + serving.mode = ServeMode::Establish(establish); + let gate_run = serve.gate(); + let mut running = TrackServeRun { + serve, + state: TrackRunState::Serve(serving), + gate: gate_run, + datagrams: None, + }; + + assert!(kio::Task::poll(&mut running, &kio::Waiter::noop()).is_pending()); + assert_eq!(session.log.bi_opens(), if stage == "credit" { 1 } else { 2 }); + assert!(!subscribes.lock().is_empty()); + assert!( + !session + .log + .trail() + .iter() + .any(|(_, sent)| matches!(sent, crate::lite::test_transport::Sent::Finish)) + ); + + drop(reader); + let _ = kio::Task::poll(&mut running, &kio::Waiter::noop()); + + assert!( + session + .log + .trail() + .iter() + .any(|(id, sent)| *id == 0 && matches!(sent, crate::lite::test_transport::Sent::Finish)), + "TRACK hold released" + ); + assert!(session.log.closes().is_empty(), "session stays live"); + assert!(subscribes.lock().is_empty(), "the id outlived its subscription"); + drop(gate); + } + } + /// Everything a `handle_subscription` test needs to stay alive for the call. struct Harness { serve: TrackServe, @@ -9596,6 +9682,10 @@ impl kio::Task for TrackServeRun { datagrams.end(Err(Error::Cancel)); } + if let ServeMode::Establish(establish) = serve_loop.mode { + establish.abort(&Error::Cancel); + } + if let Sub::Active(mut active) = serve_loop.sub { self.serve.subscriber.remove_subscribe(active.id); if active.stream.writer.finish().is_ok() @@ -10428,6 +10518,14 @@ impl ServeLoop { loop { match &mut self.mode { ServeMode::Establish(est) => { + // Credit or flow control may never return. Observe lost demand before + // waiting, retaining the TRACK bridge only while somebody needs it. + if self.fetches.is_empty() + && self.range_fills.is_empty() + && crate::util::poll_unwanted(&mut self.demand, waiter).is_ready() + { + return Poll::Ready(ServeEnd::Idle); + } let res = ready!(est.poll(waiter)); let id = est.id; self.mode = ServeMode::Select; diff --git a/rs/moq-net/tests/integration/stream_credit.rs b/rs/moq-net/tests/integration/stream_credit.rs index 963b555f7d0..39c4a8a6463 100644 --- a/rs/moq-net/tests/integration/stream_credit.rs +++ b/rs/moq-net/tests/integration/stream_credit.rs @@ -137,3 +137,69 @@ async fn a_subscription_past_the_credit_is_served_once_credit_returns() { assert_eq!(group.sequence, 0, "{version}"); } } + +/// A relay's upstream session out of request credit waits for it rather than refusing: a +/// subscription past the publisher's credit is served once an earlier one leaves. +#[kio::test] +async fn an_abandoned_setup_returns_credit_with_the_publisher_still_live() { + // lite-07 needs 4: session-long AUTH and ANNOUNCE plus TRACK held until SUBSCRIBE answers. + // Three is below the setup minimum; the second subscription waits for the first's credit. + for (version, credit) in [("moq-lite-07-wip", 4)] { + let version: Version = version.parse().unwrap(); + let publisher = origin(1); + let viewer = origin(2); + let broadcast = publisher.create_broadcast("live").unwrap(); + let info = track::Info::default() + .with_timescale(moq_net::Timescale::MILLI) + .with_max_age(None); + let first = broadcast.create_track("first", info.clone()).unwrap(); + let second = broadcast.create_track("second", info.clone()).unwrap(); + let third = broadcast.create_track("third", info).unwrap(); + broadcast.announce(Default::default()).unwrap(); + + let mut options = MockConnectOptions::new(version); + options.transport.max_concurrent_bi_streams = Some(credit); + options.server_publish = Some(publisher.consume()); + options.client_subscribe = Some(viewer.clone()); + let _pair = connect_mock(options).await; + + let remote = viewer + .consume() + .follow("live", None) + .unwrap() + .available() + .await + .unwrap() + .unwrap(); + let prefs = + track::Subscription::default().with_delay(track::Delay::default().with_max(Duration::from_secs(30))); + let held = remote.track("first").unwrap().subscribe(prefs.clone()).await.unwrap(); + let mut waiting = Box::pin(remote.track("second").unwrap().subscribe(prefs.clone())); + assert!( + kio::clock::timeout(Duration::from_secs(5), waiting.as_mut()) + .await + .is_err(), + "{version}: the second subscription had no credit to wait for" + ); + + drop(waiting); + drop(held); + let waiting = remote.track("third").unwrap().subscribe(prefs); + let mut subscriber = kio::clock::timeout(Duration::from_secs(60), waiting) + .await + .unwrap_or_else(|_| panic!("{version}: the waiting subscription never got credit")) + .unwrap_or_else(|err| panic!("{version}: the waiting subscription failed: {err}")); + let mut group = third.append_group().unwrap(); + group.write_frame(Timestamp::ZERO, b"x".as_slice()).unwrap(); + group.finish().unwrap(); + let group = kio::clock::timeout(Duration::from_secs(5), subscriber.recv_group()) + .await + .unwrap_or_else(|_| panic!("{version}: no group after credit returned")) + .unwrap() + .unwrap(); + assert_eq!(group.sequence, 0, "{version}"); + // Both earlier publishers and their route survive abandonment. + first.append_group().unwrap().finish().unwrap(); + second.append_group().unwrap().finish().unwrap(); + } +} From c102d0dfa70836bf8eb03df7142400cfdf30c189 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 5 Nov 2026 13:06:36 -0800 Subject: [PATCH 05/21] fix(net): preserve pre-TRACK subscription bootstrap Co-Authored-By: GPT-6.1 Sol --- rs/moq-net/src/lite/subscriber.rs | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index da9426e8ed5..08a04c8e703 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -10520,9 +10520,11 @@ impl ServeLoop { loop { match &mut self.mode { ServeMode::Establish(est) => { - // Credit or flow control may never return. Observe lost demand before - // waiting, retaining the TRACK bridge only while somebody needs it. - if self.fetches.is_empty() + // Before TRACK existed, SUBSCRIBE itself obtained the metadata that + // attaches downstream readers. Its initial lack of demand is expected. + // With TRACK, credit or flow control must not retain an abandoned setup. + if serve.subscriber.version.has_track_stream() + && self.fetches.is_empty() && self.range_fills.is_empty() && crate::util::poll_unwanted(&mut self.demand, waiter).is_ready() { From a4881cb6524fd1be29979066457cf3997e2b23e9 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 5 Nov 2026 13:16:56 -0800 Subject: [PATCH 06/21] fix(net): preserve linger and drive fetches during setup Co-Authored-By: GPT-6.1 Sol --- rs/moq-net/src/lite/subscriber.rs | 36 +++++++++++++++++-- rs/moq-net/tests/integration/stream_credit.rs | 21 +++++++---- 2 files changed, 49 insertions(+), 8 deletions(-) diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index 08a04c8e703..37cf3c91a0b 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -6193,6 +6193,17 @@ mod tests { .any(|(_, sent)| matches!(sent, crate::lite::test_transport::Sent::Finish)) ); + // A canceled fetch must retire even while establishment is blocked. + let (_track, fetching, fill) = feed_fetch(50); + let TrackRunState::Serve(serving) = &mut running.state else { + unreachable!() + }; + serving.fetches.push(FillServeRun::new( + running.serve.clone(), + fill, + FetchInfo::Known(Default::default()), + )); + drop(fetching); drop(reader); let _ = kio::Task::poll(&mut running, &kio::Waiter::noop()); @@ -6206,6 +6217,12 @@ mod tests { ); assert!(session.log.closes().is_empty(), "session stays live"); assert!(subscribes.lock().is_empty(), "the id outlived its subscription"); + let TrackRunState::Serve(serving) = &running.state else { + panic!("copy should linger") + }; + assert!(matches!(serving.mode, ServeMode::Select)); + assert!(serving.linger.deadline().is_some()); + assert!(serving.fetches.is_empty()); drop(gate); } } @@ -10520,15 +10537,30 @@ impl ServeLoop { loop { match &mut self.mode { ServeMode::Establish(est) => { + let _ = self.fetches.poll(waiter); + self.feed_fetches + .poll(&self.sub, serve.subscriber.runtime.now(), waiter); + let read = crate::util::poll_unwanted(&mut self.demand, waiter).is_pending(); + if let Err(err) = self + .range_fills + .poll(serve, &self.serving, Some(&est.tail), read, waiter) + { + return Poll::Ready(ServeEnd::GiveBack(err)); + } // Before TRACK existed, SUBSCRIBE itself obtained the metadata that // attaches downstream readers. Its initial lack of demand is expected. // With TRACK, credit or flow control must not retain an abandoned setup. if serve.subscriber.version.has_track_stream() && self.fetches.is_empty() && self.range_fills.is_empty() - && crate::util::poll_unwanted(&mut self.demand, waiter).is_ready() + && !read { - return Poll::Ready(ServeEnd::Idle); + let ServeMode::Establish(est) = std::mem::replace(&mut self.mode, ServeMode::Select) else { + unreachable!() + }; + est.abort(&Error::Cancel); + self.held = None; + continue; } let res = ready!(est.poll(waiter)); let id = est.id; diff --git a/rs/moq-net/tests/integration/stream_credit.rs b/rs/moq-net/tests/integration/stream_credit.rs index 39c4a8a6463..64a9dfd18f2 100644 --- a/rs/moq-net/tests/integration/stream_credit.rs +++ b/rs/moq-net/tests/integration/stream_credit.rs @@ -138,12 +138,10 @@ async fn a_subscription_past_the_credit_is_served_once_credit_returns() { } } -/// A relay's upstream session out of request credit waits for it rather than refusing: a -/// subscription past the publisher's credit is served once an earlier one leaves. +/// Abandoning setup returns credit without ending earlier publishers or their route. #[kio::test] async fn an_abandoned_setup_returns_credit_with_the_publisher_still_live() { // lite-07 needs 4: session-long AUTH and ANNOUNCE plus TRACK held until SUBSCRIBE answers. - // Three is below the setup minimum; the second subscription waits for the first's credit. for (version, credit) in [("moq-lite-07-wip", 4)] { let version: Version = version.parse().unwrap(); let publisher = origin(1); @@ -198,8 +196,19 @@ async fn an_abandoned_setup_returns_credit_with_the_publisher_still_live() { .unwrap() .unwrap(); assert_eq!(group.sequence, 0, "{version}"); - // Both earlier publishers and their route survive abandonment. - first.append_group().unwrap().finish().unwrap(); - second.append_group().unwrap().finish().unwrap(); + drop(group); + drop(subscriber); + let mut resumed = remote.track("second").unwrap().subscribe(None).await.unwrap(); + let mut group = second.append_group().unwrap(); + group.write_frame(Timestamp::ZERO, b"still live".as_slice()).unwrap(); + group.finish().unwrap(); + let group = kio::clock::timeout(Duration::from_secs(5), resumed.recv_group()) + .await + .unwrap() + .unwrap() + .unwrap(); + assert_eq!(group.sequence, 0); + // Keep the first publisher alive through the resumed wire request too. + drop(first); } } From 623b9f8e77b05ca8ac3d1c2642ce1d086040cafe Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 5 Nov 2026 13:18:31 -0800 Subject: [PATCH 07/21] fix(net): apply fill demand changes after setup completes Co-Authored-By: GPT-6.1 Sol --- rs/moq-net/src/lite/subscriber.rs | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index 37cf3c91a0b..2c4bb59e6d6 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -10564,9 +10564,15 @@ impl ServeLoop { } let res = ready!(est.poll(waiter)); let id = est.id; + let fills_changed = est.fill_groups != self.range_fills.ask.groups; self.mode = ServeMode::Select; match res { - Ok(active) => self.sub = Sub::Active(active), + Ok(active) => { + self.sub = Sub::Active(active); + if fills_changed && let Err(err) = self.begin(serve, self.serving.subscription()) { + return Poll::Ready(ServeEnd::GiveBack(err)); + } + } Err(err) => { // Opening the upstream failed (usually the session dying): hand // the track back for another route to resume. From 188fc53761125d62bdb28bd38ffc0dc2f1845966 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 5 Nov 2026 13:19:03 -0800 Subject: [PATCH 08/21] fix(net): keep legacy feed fills parked until establishment Co-Authored-By: GPT-6.1 Sol --- rs/moq-net/src/lite/subscriber.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index 2c4bb59e6d6..8e0ba6e2ab3 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -10538,8 +10538,6 @@ impl ServeLoop { match &mut self.mode { ServeMode::Establish(est) => { let _ = self.fetches.poll(waiter); - self.feed_fetches - .poll(&self.sub, serve.subscriber.runtime.now(), waiter); let read = crate::util::poll_unwanted(&mut self.demand, waiter).is_pending(); if let Err(err) = self .range_fills From 359f9becbfe98e3738435bb4a99aa60d1671c40e Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 5 Nov 2026 22:43:07 -0800 Subject: [PATCH 09/21] fix(net): finish setup state and quest merge cleanup --- quest/m2/recut-held.md | 1 - rs/moq-net/src/lite/subscriber.rs | 10 ++++------ 2 files changed, 4 insertions(+), 7 deletions(-) diff --git a/quest/m2/recut-held.md b/quest/m2/recut-held.md index 59b0ee3575d..3ff34eb9645 100644 --- a/quest/m2/recut-held.md +++ b/quest/m2/recut-held.md @@ -33,5 +33,4 @@ padding probes in [lite07-finalize](/quest/m2/lite07-finalize.md). - [IETF datagram tracks](/quest/m1/datagram-tracks/ietf.md) - claim held datagram-tracks - [rind CPU error](/quest/m1/rind/cpu-error.md) - claim held rind - [Connect policy](/quest/m1/session-policy/connect.md) - claim held session-policy -- [Release on leave](/quest/m1/stream-credit/release-on-leave.md) - claim held stream-credit - [Probe padding](/quest/m2/probe/padding.md) - claim held probe diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index 17f678c532d..cc563652e86 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -3105,7 +3105,6 @@ mod tests { demand: Some(Subscription::default()), fill_ids: Default::default(), fill_groups: Default::default(), - fills_changed: false, tail: tail.clone(), served: None, started: false, @@ -3260,7 +3259,6 @@ mod tests { demand: Some(Subscription::default()), fill_ids: Default::default(), fill_groups: Default::default(), - fills_changed: false, tail: Default::default(), served: None, started: false, @@ -3726,7 +3724,6 @@ mod tests { demand: Some(Subscription::default()), fill_ids: Default::default(), fill_groups: Default::default(), - fills_changed: false, tail: Default::default(), served: None, started: false, @@ -3840,7 +3837,6 @@ mod tests { demand: Some(Subscription::default()), fill_ids: Default::default(), fill_groups: Default::default(), - fills_changed: false, tail: Default::default(), served: Some(4), started: true, @@ -3906,7 +3902,6 @@ mod tests { demand: Some(Subscription::default()), fill_ids: Default::default(), fill_groups: Default::default(), - fills_changed: false, tail: Default::default(), served: Some(4), started: true, @@ -10902,7 +10897,10 @@ impl ServeLoop { ServeMode::Establish(est) => { let _ = self.fetches.poll(waiter); let read = crate::util::poll_unwanted(&mut self.demand, waiter).is_pending(); - match self.range_fills.poll(serve, &self.serving, Some(&est.tail), read, waiter) { + match self + .range_fills + .poll(serve, &self.serving, Some(&est.tail), read, waiter) + { Ok(changed) => est.fills_changed |= changed, Err(err) => return Poll::Ready(ServeEnd::GiveBack(err)), } From 28fd7fa5b5f7dc2644e31f32bf5b5104c567affa Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 5 Nov 2026 23:23:40 -0800 Subject: [PATCH 10/21] test(net): adapt stream credit coverage to broadcast handles --- rs/moq-net/tests/integration/stream_credit.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/rs/moq-net/tests/integration/stream_credit.rs b/rs/moq-net/tests/integration/stream_credit.rs index 3cfadf51a9f..9cef237e5a0 100644 --- a/rs/moq-net/tests/integration/stream_credit.rs +++ b/rs/moq-net/tests/integration/stream_credit.rs @@ -155,14 +155,14 @@ async fn an_abandoned_setup_returns_credit_with_the_publisher_still_live() { let version: Version = version.parse().unwrap(); let publisher = origin(1); let viewer = origin(2); - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.publish("live", moq_net::broadcast::Info::default()).unwrap(); let info = track::Info::default() .with_timescale(moq_net::Timescale::MILLI) .with_max_age(None); - let first = broadcast.create_track("first", info.clone()).unwrap(); - let second = broadcast.create_track("second", info.clone()).unwrap(); - let third = broadcast.create_track("third", info).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let first = broadcast.broadcast().create_track("first", info.clone()).unwrap(); + let second = broadcast.broadcast().create_track("second", info.clone()).unwrap(); + let third = broadcast.broadcast().create_track("third", info).unwrap(); + broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version); options.transport.max_concurrent_bi_streams = Some(credit); From 3e0085a9e8b9cf18de7a6adc059dc8130b0e9813 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 5 Nov 2026 23:24:55 -0800 Subject: [PATCH 11/21] test(net): use hidden origin route for credit coverage --- rs/moq-net/tests/integration/stream_credit.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rs/moq-net/tests/integration/stream_credit.rs b/rs/moq-net/tests/integration/stream_credit.rs index 9cef237e5a0..a26064c9761 100644 --- a/rs/moq-net/tests/integration/stream_credit.rs +++ b/rs/moq-net/tests/integration/stream_credit.rs @@ -155,7 +155,7 @@ async fn an_abandoned_setup_returns_credit_with_the_publisher_still_live() { let version: Version = version.parse().unwrap(); let publisher = origin(1); let viewer = origin(2); - let broadcast = publisher.publish("live", moq_net::broadcast::Info::default()).unwrap(); + let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); let info = track::Info::default() .with_timescale(moq_net::Timescale::MILLI) .with_max_age(None); From 48e09527102227a1aeab1f8a1b038d9338a2e1b6 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 5 Nov 2026 23:41:19 -0800 Subject: [PATCH 12/21] style(net): format migrated credit test --- rs/moq-net/tests/integration/stream_credit.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/rs/moq-net/tests/integration/stream_credit.rs b/rs/moq-net/tests/integration/stream_credit.rs index a26064c9761..ee95d2497ff 100644 --- a/rs/moq-net/tests/integration/stream_credit.rs +++ b/rs/moq-net/tests/integration/stream_credit.rs @@ -155,7 +155,9 @@ async fn an_abandoned_setup_returns_credit_with_the_publisher_still_live() { let version: Version = version.parse().unwrap(); let publisher = origin(1); let viewer = origin(2); - let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("live", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let info = track::Info::default() .with_timescale(moq_net::Timescale::MILLI) .with_max_age(None); From 3869692d0b82747344df471ec3be72b3ce6b7951 Mon Sep 17 00:00:00 2001 From: "pullfrog[bot]" <226033991+pullfrog[bot]@users.noreply.github.com> Date: Fri, 6 Nov 2026 10:50:33 +0000 Subject: [PATCH 13/21] fix(net): keep a fresh setup until its demand arrives Release-on-leave treated an establishment that had not seen a reader yet as abandoned, resetting a live SUBSCRIBE before its consumer attached. A relay forwarding a fresh request then stalled: the downstream subscriber got no groups and its recv_group timed out. Only release once demand arrived and then left, matching the JavaScript subscriber. A request that never had a reader still ends through the existing request-validity and idle paths. --- rs/moq-net/src/lite/subscriber.rs | 97 ++++++++++++++++++++++++++++++- 1 file changed, 95 insertions(+), 2 deletions(-) diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index cc563652e86..28da0581170 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -6537,6 +6537,92 @@ mod tests { } } + /// A setup no reader has reached yet is not abandoned: it may attach after the + /// SUBSCRIBE starts, as a relay forwarding a fresh request does. + #[kio::test] + async fn a_setup_waits_for_demand_that_never_arrived() { + let gate = kio::Producer::new(false); + let opening = kio::Producer::new(true); + let session = SinkSession::gated_bi(gate.consume()).with_open_bi_gate(opening.consume()); + + let origin = origin::Config::new(crate::Hop::new(1).unwrap()).produce(); + let subscriber = Subscriber::new(SubscriberConfig { + runtime: crate::time::sim(), + session: crate::driver::Transport::new(session.clone()), + origin, + recv_bandwidth: None, + version: Version::Lite07, + peer_setup: crate::lite::PeerSetup::new(false, crate::transport::Address::Setup), + peer_hop: None, + cost: None, + going_away: Default::default(), + auth: crate::auth::Link::new(false), + }); + let subscribes = subscriber.subscribes.clone(); + let serve = TrackServe { + validity: Default::default(), + route: None, + source: None, + subscriber, + path: Path::from_static("room/host"), + instance: None, + name: "audio".to_string(), + }; + + let broadcast = crate::broadcast::Info::new().produce(); + let request = broadcast.reserve_track("audio").unwrap(); + let mut serving = ServeLoop::new(&serve, request, Default::default()); + let held = Stream::open(&serve.subscriber.session, Version::Lite07).await.unwrap(); + serving.held = Some(HeldTrack(held)); + let wire = Wire { + subscription: Subscription::default(), + demand: Some(Subscription::default()), + demand_ranges: vec![lite::Range::OLDEST], + ranges: vec![lite::Range::OLDEST], + }; + let establish = serve.prepare_establish(&mut serving.serving, wire, &Default::default()); + serving.mode = ServeMode::Establish(establish); + let gate_run = serve.gate(); + let mut running = TrackServeRun { + serve, + state: TrackRunState::Serve(serving), + gate: gate_run, + datagrams: None, + }; + + // Nothing reads the track yet, so the fresh setup waits rather than giving up. + assert!(kio::Task::poll(&mut running, &kio::Waiter::noop()).is_pending()); + let TrackRunState::Serve(serving) = &mut running.state else { + unreachable!() + }; + assert!(matches!(serving.mode, ServeMode::Establish(_))); + assert!(!subscribes.lock().is_empty(), "the fresh setup keeps its registration"); + assert!( + !session + .log + .trail() + .iter() + .any(|(_, sent)| matches!(sent, crate::lite::test_transport::Sent::Finish)), + "a fresh setup keeps its TRACK hold" + ); + + // A reader arriving keeps it, and its leaving is what releases the setup. + let reader = serving.serving.subscribe(None); + assert!(kio::Task::poll(&mut running, &kio::Waiter::noop()).is_pending()); + drop(reader); + let _ = kio::Task::poll(&mut running, &kio::Waiter::noop()); + assert!( + session + .log + .trail() + .iter() + .any(|(id, sent)| *id == 0 && matches!(sent, crate::lite::test_transport::Sent::Finish)), + "TRACK hold released once demand left" + ); + assert!(subscribes.lock().is_empty(), "the id outlived its subscription"); + drop(gate); + } + /// Everything a `handle_subscription` test needs to stay alive for the call. struct Harness { serve: TrackServe, @@ -9372,6 +9458,7 @@ impl TrackServe { demand_ranges: ranges.clone(), fill_groups: Default::default(), fills_changed: false, + arrived: false, subscription, ranges, tail, @@ -9505,6 +9592,9 @@ struct Establish { demand_ranges: Vec, /// Fill preferences changed while opening and need an update once active. fills_changed: bool, + /// A reader wanted the track while opening, so a later lull is an abandonment + /// rather than a request that never had one. + arrived: bool, /// The groups it asks for fills. fill_groups: rangemap::RangeSet, /// The ranges the SUBSCRIBE carries: the demand's, then the fills'. @@ -10897,6 +10987,7 @@ impl ServeLoop { ServeMode::Establish(est) => { let _ = self.fetches.poll(waiter); let read = crate::util::poll_unwanted(&mut self.demand, waiter).is_pending(); + est.arrived |= read; match self .range_fills .poll(serve, &self.serving, Some(&est.tail), read, waiter) @@ -10906,11 +10997,13 @@ impl ServeLoop { } // Before TRACK existed, SUBSCRIBE itself obtained the metadata that // attaches downstream readers. Its initial lack of demand is expected. - // With TRACK, credit or flow control must not retain an abandoned setup. + // With TRACK, credit or flow control must not retain an abandoned setup, + // but demand that never arrived yet is not abandonment: a fresh request + // may not have attached its reader. if serve.subscriber.version.has_track_stream() && self.fetches.is_empty() && self.range_fills.is_empty() - && !read + && est.arrived && !read { let ServeMode::Establish(est) = std::mem::replace(&mut self.mode, ServeMode::Select) else { unreachable!() From 477a18f9bb462e35e11b164aa3da8328d9bdfea2 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 6 Nov 2026 08:09:39 -0800 Subject: [PATCH 14/21] fix(net): reset canceled setup demand and idle linger Co-Authored-By: GPT-6.1 Sol --- rs/moq-net/src/lite/subscriber.rs | 91 ++++++++++++++++++++++++++----- rs/moq-net/src/model/track.rs | 7 ++- 2 files changed, 81 insertions(+), 17 deletions(-) diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index 28da0581170..5165bebdde0 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -6476,14 +6476,10 @@ mod tests { if stage == "credit" { *opening.write().ok().expect("gate live") = false; } - let wire = Wire { - subscription: Subscription::default(), - demand: Some(Subscription::default()), - demand_ranges: vec![lite::Range::OLDEST], - ranges: vec![lite::Range::OLDEST], - }; - let establish = serve.prepare_establish(&mut serving.serving, wire, &Default::default()); - serving.mode = ServeMode::Establish(establish); + serving.linger.set(Some(serve.subscriber.runtime.now())); + let pref = serving.serving.subscription(); + serving.begin(&serve, pref).unwrap(); + assert!(serving.linger.deadline().is_none(), "new demand ends the old linger"); let gate_run = serve.gate(); let mut running = TrackServeRun { serve, @@ -6537,6 +6533,66 @@ mod tests { } } + /// Equal demand returning between cancellation and Select must open a new setup. + #[kio::test] + async fn identical_demand_after_setup_cancellation_is_not_already_served() { + let gate = kio::Producer::new(false); + let opening = kio::Producer::new(true); + let session = SinkSession::gated_bi(gate.consume()).with_open_bi_gate(opening.consume()); + + let origin = origin::Config::new(crate::Hop::new(1).unwrap()).produce(); + let subscriber = Subscriber::new(SubscriberConfig { + runtime: crate::time::sim(), + session: crate::driver::Transport::new(session.clone()), + origin, + recv_bandwidth: None, + version: Version::Lite07, + peer_setup: crate::lite::PeerSetup::new(false, crate::transport::Address::Setup), + peer_hop: None, + cost: None, + going_away: Default::default(), + auth: crate::auth::Link::new(false), + }); + let subscribes = subscriber.subscribes.clone(); + let serve = TrackServe { + validity: Default::default(), + route: None, + source: None, + subscriber, + path: Path::from_static("room/host"), + instance: None, + name: "audio".to_string(), + }; + + let broadcast = crate::broadcast::Info::new().produce(); + let request = broadcast.reserve_track("audio").unwrap(); + let mut serving = ServeLoop::new(&serve, request, Default::default()); + let held = Stream::open(&serve.subscriber.session, Version::Lite07).await.unwrap(); + serving.held = Some(HeldTrack(held)); + let wire = Wire { + subscription: Subscription::default(), + demand: Some(Subscription::default()), + demand_ranges: vec![lite::Range::OLDEST], + ranges: vec![lite::Range::OLDEST], + }; + let reader = serving.serving.subscribe(None); + serving.serving.seen_subscription(Some(Subscription::default())); + let establish = serve.prepare_establish(&mut serving.serving, wire, &Default::default()); + serving.mode = ServeMode::Establish(establish); + + drop(reader); + serving.abandon_setup(); + let _returning = serving.serving.subscribe(None); + assert!(matches!( + serving.serving.poll_subscription_changed(&kio::Waiter::noop()), + Poll::Ready(Ok(Some(_))) + )); + let pref = serving.serving.subscription(); + serving.begin(&serve, pref).unwrap(); + assert!(matches!(serving.mode, ServeMode::Establish(_))); + assert_eq!(subscribes.lock().len(), 1); + } + /// A setup no reader has reached yet is not abandoned: it may attach after the /// SUBSCRIBE starts, as a relay forwarding a fresh request does. #[kio::test] @@ -10708,13 +10764,23 @@ impl ServeLoop { tail.set_grace(self.serving.tail_grace(pipelined.pref.budget())); } self.parked = Some(pipelined.id()); - self.serving.seen_subscription(pipelined.pref); + self.serving.seen_subscription(Some(pipelined.pref)); match pipelined.state { PipelinedState::Opening(establish) => self.mode = ServeMode::Establish(establish), PipelinedState::Open(active) => self.sub = Sub::Active(active), } } + /// Release a setup that no longer has demand, including the demand it acted on. + fn abandon_setup(&mut self) { + let ServeMode::Establish(est) = std::mem::replace(&mut self.mode, ServeMode::Select) else { + unreachable!() + }; + est.abort(&Error::Cancel); + self.held = None; + self.serving.seen_subscription(None); + } + /// Apply a demand change: open, update, or cancel the upstream subscription. fn begin(&mut self, serve: &TrackServe, pref: Option) -> Result<(), Error> { match serve.begin_subscription( @@ -10725,6 +10791,7 @@ impl ServeLoop { self.supports_update, )? { Begin::Establish(est) => { + self.linger.set(None); // A fresh subscription may deliver what the last one would not. self.range_fills.forget_refused(); self.mode = ServeMode::Establish(est); @@ -11005,11 +11072,7 @@ impl ServeLoop { && self.range_fills.is_empty() && est.arrived && !read { - let ServeMode::Establish(est) = std::mem::replace(&mut self.mode, ServeMode::Select) else { - unreachable!() - }; - est.abort(&Error::Cancel); - self.held = None; + self.abandon_setup(); continue; } let res = ready!(est.poll(waiter)); diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index 3a3c31c8c04..96f736a56f8 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -4111,10 +4111,11 @@ impl Producer { /// Count `seen` as the aggregate already acted on, so /// [`Self::poll_subscription_changed`] reports only a change from it: the demand a - /// subscriber session asked upstream for before accepting the track. + /// subscriber session asked upstream for before accepting the track, or `None` + /// after abandoning that setup. #[cfg_attr(not(feature = "async"), allow(dead_code, reason = "async-only"))] - pub(crate) fn seen_subscription(&mut self, seen: Subscription) { - self.prev_subscription = Some(seen); + pub(crate) fn seen_subscription(&mut self, seen: Option) { + self.prev_subscription = seen; } /// How long a subscriber session's tail waits for a late group: `budget`, bounded by how From 508957595e206a17f8933e554925ab0fba43cf46 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 6 Nov 2026 09:08:23 -0800 Subject: [PATCH 15/21] docs(quest): record explicit requester ownership decision --- quest/m1/stream-credit/release-on-leave.md | 39 ++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 quest/m1/stream-credit/release-on-leave.md diff --git a/quest/m1/stream-credit/release-on-leave.md b/quest/m1/stream-credit/release-on-leave.md new file mode 100644 index 00000000000..3c48700bce3 --- /dev/null +++ b/quest/m1/stream-credit/release-on-leave.md @@ -0,0 +1,39 @@ +# [S] An abandoned subscription setup releases its streams + +## Goal + +On lite-07, a subscription whose last reader leaves while SUBSCRIBE is still +opening or awaiting its answer releases its upstream TRACK and pending +SUBSCRIBE, so their credit can serve later requests. + +## Plan + +Decided 2026-11-05 (maintainer, /quest-plan): ✅ Keep the TRACK/SUBSCRIBE +handshake and document the minimum of four concurrent bidirectional streams. +AUTH and ANNOUNCE hold two slots for the session lifetime; TRACK is briefly +held alongside SUBSCRIBE. Three slots cannot establish the first subscription. +Rejected: metadata on SUBSCRIBE (overlaps other lite-07 work and saves no round +trip), and releasing TRACK early during a live setup. + +The established-subscription regression +`a_subscription_past_the_credit_is_served_once_credit_returns` already passes +with four slots. Keep that budget. The three-slot reproduction did not show a +departure leak. + +Local review identified remaining pending-setup cleanup: `ServeLoop::poll` in +`ServeMode::Establish` waits on establishment without observing lost demand, +while holding `HeldTrack`. Reproduce abandonment with at least four slots, +keeping the publisher and route live, then ensure both the TRACK hold and the +pending SUBSCRIBE registration are released when demand leaves. Preserve the +hold while demand remains. Cover Rust and its JS counterpart where applicable. + +Decided 2026-11-06 (maintainer, /quest-unblock): ✅ Rethink the handoff +around explicit requester ownership until the first reader attaches. Replace +the demand-arrived heuristic so a requester disappearing after metadata +acceptance releases a blocked SUBSCRIBE and its TRACK hold. Rejected: another +heuristic patch, landing with the known gap, and dropping the PR. + +Use the existing `track::Resolving` requester handle as ownership across +metadata acceptance. It already contributes demand until dropped; subscribe +before releasing it to transfer ownership without a gap. Setup cancellation +therefore observes current owners rather than remembering demand history. From aca6db892a1abb8ecbd36b9a321d685336097efd Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 6 Nov 2026 09:10:37 -0800 Subject: [PATCH 16/21] docs(quest): link the resumed setup ownership work --- quest/m1/stream-credit/README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/quest/m1/stream-credit/README.md b/quest/m1/stream-credit/README.md index a76e52b8af5..300d75dc0d9 100644 --- a/quest/m1/stream-credit/README.md +++ b/quest/m1/stream-credit/README.md @@ -42,6 +42,8 @@ receiving every group, and nothing hanging. ## Required +- [Release abandoned setup](/quest/m1/stream-credit/release-on-leave.md) - requester ownership releases blocked setup before a reader attaches + - [Open streams](/quest/m1/stream-credit/open-streams.md) - each session lists its open streams and, where the transport can tell, which are fully acknowledged - [Reset fallback](/quest/m1/stream-credit/reset-fallback.md) - a waiting higher-priority open resets the lowest-priority stream, one reset in flight per waiting open - [Takeover](/quest/m1/stream-credit/takeover.md) - on lite-07 a higher-priority group takes over an acknowledged stream, and a group that lost its stream resumes From 0a079f957947c5046aedb7b010ed00d82ba12d2c Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 6 Nov 2026 09:13:04 -0800 Subject: [PATCH 17/21] fix(net): use requester ownership during subscription setup --- js/net/src/lite/subscriber.ts | 11 +- rs/moq-net/src/lite/subscriber.rs | 194 ++++++++++++++++-------------- 2 files changed, 109 insertions(+), 96 deletions(-) diff --git a/js/net/src/lite/subscriber.ts b/js/net/src/lite/subscriber.ts index 5a2eb95690b..ad96ae2dafb 100644 --- a/js/net/src/lite/subscriber.ts +++ b/js/net/src/lite/subscriber.ts @@ -1215,21 +1215,20 @@ export class Subscriber { const deadline = new Deadline(); const setup = this.#openSubscribe(state, msg, ranges, request, id, deadline); - // The readers leaving gives the setup up, even while its streams wait for credit. An - // info-only lookup attaches no reader, so only demand that arrived and left counts. + // Subscribers and info lookups explicitly own setup, including the handoff from + // metadata acceptance to reader attachment. Release it when the last owner leaves. const left = new AbortController(); const demand = request.demand(); - let arrived = false; + const wanted = hooks.requestWanted(request); let unwatch: Dispose | undefined; const watch = () => { - if (demand.wanted.peek() !== undefined) arrived = true; - if (hooks.demandReleased(demand).peek() !== undefined || (arrived && demand.wanted.peek() === undefined)) { + if (hooks.demandReleased(demand).peek() !== undefined || !wanted.peek()) { left.abort( new StreamError(StreamCode.Cancel, { message: "subscribe abandoned before it was accepted" }), ); state.cancel.abort(left.signal.reason); } else { - unwatch = Signal.race(demand.wanted, hooks.demandReleased(demand)).changed(watch); + unwatch = Signal.race(wanted, hooks.demandReleased(demand)).changed(watch); } }; watch(); diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index 5165bebdde0..47e9a553d03 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -6593,90 +6593,110 @@ mod tests { assert_eq!(subscribes.lock().len(), 1); } - /// A setup no reader has reached yet is not abandoned: it may attach after the - /// SUBSCRIBE starts, as a relay forwarding a fresh request does. + /// A requester owns setup through metadata acceptance until a reader attaches or + /// the requester disappears, including when no poll ever observed its demand. #[kio::test] - async fn a_setup_waits_for_demand_that_never_arrived() { - let gate = kio::Producer::new(false); - let opening = kio::Producer::new(true); - let session = SinkSession::gated_bi(gate.consume()).with_open_bi_gate(opening.consume()); + async fn a_requester_owns_setup_until_attachment_or_cancellation() { + for attach in [false, true] { + let gate = kio::Producer::new(false); + let opening = kio::Producer::new(true); + let session = SinkSession::gated_bi(gate.consume()).with_open_bi_gate(opening.consume()); - let origin = origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let subscriber = Subscriber::new(SubscriberConfig { - runtime: crate::time::sim(), - session: crate::driver::Transport::new(session.clone()), - origin, - recv_bandwidth: None, - version: Version::Lite07, - peer_setup: crate::lite::PeerSetup::new(false, crate::transport::Address::Setup), - peer_hop: None, - cost: None, - going_away: Default::default(), - auth: crate::auth::Link::new(false), - }); - let subscribes = subscriber.subscribes.clone(); - let serve = TrackServe { - validity: Default::default(), - route: None, - source: None, - subscriber, - path: Path::from_static("room/host"), - instance: None, - name: "audio".to_string(), - }; + let origin = origin::Config::new(crate::Hop::new(1).unwrap()).produce(); + let subscriber = Subscriber::new(SubscriberConfig { + runtime: crate::time::sim(), + session: crate::driver::Transport::new(session.clone()), + origin, + recv_bandwidth: None, + version: Version::Lite07, + peer_setup: crate::lite::PeerSetup::new(false, crate::transport::Address::Setup), + peer_hop: None, + cost: None, + going_away: Default::default(), + auth: crate::auth::Link::new(false), + }); + let subscribes = subscriber.subscribes.clone(); + let serve = TrackServe { + validity: Default::default(), + route: None, + source: None, + subscriber, + path: Path::from_static("room/host"), + instance: None, + name: "audio".to_string(), + }; - let broadcast = crate::broadcast::Info::new().produce(); - let request = broadcast.reserve_track("audio").unwrap(); - let mut serving = ServeLoop::new(&serve, request, Default::default()); - let held = Stream::open(&serve.subscriber.session, Version::Lite07).await.unwrap(); - serving.held = Some(HeldTrack(held)); - let wire = Wire { - subscription: Subscription::default(), - demand: Some(Subscription::default()), - demand_ranges: vec![lite::Range::OLDEST], - ranges: vec![lite::Range::OLDEST], - }; - let establish = serve.prepare_establish(&mut serving.serving, wire, &Default::default()); - serving.mode = ServeMode::Establish(establish); - let gate_run = serve.gate(); - let mut running = TrackServeRun { - serve, - state: TrackRunState::Serve(serving), - gate: gate_run, - datagrams: None, - }; + let broadcast = crate::broadcast::Info::new().produce(); + let request = broadcast.reserve_track("audio").unwrap(); + let mut requester = request.consume().info(); + let mut serving = ServeLoop::new(&serve, request, Default::default()); + assert!(kio::Task::poll(&mut requester, &kio::Waiter::noop()).is_ready()); + let held = Stream::open(&serve.subscriber.session, Version::Lite07).await.unwrap(); + serving.held = Some(HeldTrack(held)); + let wire = Wire { + subscription: Subscription::default(), + demand: Some(Subscription::default()), + demand_ranges: vec![lite::Range::OLDEST], + ranges: vec![lite::Range::OLDEST], + }; + let establish = serve.prepare_establish(&mut serving.serving, wire, &Default::default()); + serving.mode = ServeMode::Establish(establish); + let gate_run = serve.gate(); + let mut running = TrackServeRun { + serve, + state: TrackRunState::Serve(serving), + gate: gate_run, + datagrams: None, + }; - // Nothing reads the track yet, so the fresh setup waits rather than giving up. - assert!(kio::Task::poll(&mut running, &kio::Waiter::noop()).is_pending()); - let TrackRunState::Serve(serving) = &mut running.state else { - unreachable!() - }; - assert!(matches!(serving.mode, ServeMode::Establish(_))); - assert!(!subscribes.lock().is_empty(), "the fresh setup keeps its registration"); - assert!( - !session - .log - .trail() - .iter() - .any(|(_, sent)| matches!(sent, crate::lite::test_transport::Sent::Finish)), - "a fresh setup keeps its TRACK hold" - ); + // Cancellation can happen before the first serving poll after metadata acceptance. + if !attach { + drop(requester); + let _ = kio::Task::poll(&mut running, &kio::Waiter::noop()); + assert!(subscribes.lock().is_empty(), "a vanished requester releases setup"); + assert!( + session + .log + .trail() + .iter() + .any(|(id, sent)| *id == 0 && matches!(sent, crate::lite::test_transport::Sent::Finish)), + "a vanished requester releases TRACK" + ); + continue; + } + // The requester still owns setup while no group reader has attached. + assert!(kio::Task::poll(&mut running, &kio::Waiter::noop()).is_pending()); + let TrackRunState::Serve(serving) = &mut running.state else { + unreachable!() + }; + assert!(matches!(serving.mode, ServeMode::Establish(_))); + assert!(!subscribes.lock().is_empty(), "the fresh setup keeps its registration"); + assert!( + !session + .log + .trail() + .iter() + .any(|(_, sent)| matches!(sent, crate::lite::test_transport::Sent::Finish)), + "a fresh setup keeps its TRACK hold" + ); - // A reader arriving keeps it, and its leaving is what releases the setup. - let reader = serving.serving.subscribe(None); - assert!(kio::Task::poll(&mut running, &kio::Waiter::noop()).is_pending()); - drop(reader); - let _ = kio::Task::poll(&mut running, &kio::Waiter::noop()); - assert!( - session - .log - .trail() - .iter() - .any(|(id, sent)| *id == 0 && matches!(sent, crate::lite::test_transport::Sent::Finish)), - "TRACK hold released once demand left" - ); - assert!(subscribes.lock().is_empty(), "the id outlived its subscription"); - drop(gate); + // A reader arriving keeps it, and its leaving is what releases the setup. + let reader = serving.serving.subscribe(None); + drop(requester); + assert!(kio::Task::poll(&mut running, &kio::Waiter::noop()).is_pending()); + drop(reader); + let _ = kio::Task::poll(&mut running, &kio::Waiter::noop()); + assert!( + session + .log + .trail() + .iter() + .any(|(id, sent)| *id == 0 && matches!(sent, crate::lite::test_transport::Sent::Finish)), + "TRACK hold released once demand left" + ); + assert!(subscribes.lock().is_empty(), "the id outlived its subscription"); + drop(gate); + } } /// Everything a `handle_subscription` test needs to stay alive for the call. @@ -9514,7 +9534,6 @@ impl TrackServe { demand_ranges: ranges.clone(), fill_groups: Default::default(), fills_changed: false, - arrived: false, subscription, ranges, tail, @@ -9648,9 +9667,6 @@ struct Establish { demand_ranges: Vec, /// Fill preferences changed while opening and need an update once active. fills_changed: bool, - /// A reader wanted the track while opening, so a later lull is an abandonment - /// rather than a request that never had one. - arrived: bool, /// The groups it asks for fills. fill_groups: rangemap::RangeSet, /// The ranges the SUBSCRIBE carries: the demand's, then the fills'. @@ -11054,7 +11070,6 @@ impl ServeLoop { ServeMode::Establish(est) => { let _ = self.fetches.poll(waiter); let read = crate::util::poll_unwanted(&mut self.demand, waiter).is_pending(); - est.arrived |= read; match self .range_fills .poll(serve, &self.serving, Some(&est.tail), read, waiter) @@ -11062,15 +11077,14 @@ impl ServeLoop { Ok(changed) => est.fills_changed |= changed, Err(err) => return Poll::Ready(ServeEnd::GiveBack(err)), } - // Before TRACK existed, SUBSCRIBE itself obtained the metadata that - // attaches downstream readers. Its initial lack of demand is expected. - // With TRACK, credit or flow control must not retain an abandoned setup, - // but demand that never arrived yet is not abandonment: a fresh request - // may not have attached its reader. + // TRACK requesters own a Resolving handle through metadata acceptance + // until they attach a reader or cancel. That ownership is demand too, + // so no observed-arrival history is needed to bridge the handoff. + // Older wires obtain metadata on SUBSCRIBE itself. if serve.subscriber.version.has_track_stream() && self.fetches.is_empty() && self.range_fills.is_empty() - && est.arrived && !read + && !read { self.abandon_setup(); continue; From 3296c40ad7bdf6edf3745268edcfd712c1130f30 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 6 Nov 2026 09:15:14 -0800 Subject: [PATCH 18/21] test(net): poll the retained requester handle directly --- rs/moq-net/src/lite/subscriber.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index 47e9a553d03..de97bcfd553 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -6628,9 +6628,9 @@ mod tests { let broadcast = crate::broadcast::Info::new().produce(); let request = broadcast.reserve_track("audio").unwrap(); - let mut requester = request.consume().info(); + let requester = request.consume().info(); let mut serving = ServeLoop::new(&serve, request, Default::default()); - assert!(kio::Task::poll(&mut requester, &kio::Waiter::noop()).is_ready()); + assert!(requester.poll_ok(&kio::Waiter::noop()).is_ready()); let held = Stream::open(&serve.subscriber.session, Version::Lite07).await.unwrap(); serving.held = Some(HeldTrack(held)); let wire = Wire { From d6acf79ada559a5202f1a45d8d9bb53ef5861cc4 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 6 Nov 2026 09:18:55 -0800 Subject: [PATCH 19/21] docs(quest): finish requester ownership cleanup --- quest/m1/stream-credit/README.md | 2 -- quest/m1/stream-credit/release-on-leave.md | 39 ---------------------- 2 files changed, 41 deletions(-) delete mode 100644 quest/m1/stream-credit/release-on-leave.md diff --git a/quest/m1/stream-credit/README.md b/quest/m1/stream-credit/README.md index 300d75dc0d9..a76e52b8af5 100644 --- a/quest/m1/stream-credit/README.md +++ b/quest/m1/stream-credit/README.md @@ -42,8 +42,6 @@ receiving every group, and nothing hanging. ## Required -- [Release abandoned setup](/quest/m1/stream-credit/release-on-leave.md) - requester ownership releases blocked setup before a reader attaches - - [Open streams](/quest/m1/stream-credit/open-streams.md) - each session lists its open streams and, where the transport can tell, which are fully acknowledged - [Reset fallback](/quest/m1/stream-credit/reset-fallback.md) - a waiting higher-priority open resets the lowest-priority stream, one reset in flight per waiting open - [Takeover](/quest/m1/stream-credit/takeover.md) - on lite-07 a higher-priority group takes over an acknowledged stream, and a group that lost its stream resumes diff --git a/quest/m1/stream-credit/release-on-leave.md b/quest/m1/stream-credit/release-on-leave.md deleted file mode 100644 index 3c48700bce3..00000000000 --- a/quest/m1/stream-credit/release-on-leave.md +++ /dev/null @@ -1,39 +0,0 @@ -# [S] An abandoned subscription setup releases its streams - -## Goal - -On lite-07, a subscription whose last reader leaves while SUBSCRIBE is still -opening or awaiting its answer releases its upstream TRACK and pending -SUBSCRIBE, so their credit can serve later requests. - -## Plan - -Decided 2026-11-05 (maintainer, /quest-plan): ✅ Keep the TRACK/SUBSCRIBE -handshake and document the minimum of four concurrent bidirectional streams. -AUTH and ANNOUNCE hold two slots for the session lifetime; TRACK is briefly -held alongside SUBSCRIBE. Three slots cannot establish the first subscription. -Rejected: metadata on SUBSCRIBE (overlaps other lite-07 work and saves no round -trip), and releasing TRACK early during a live setup. - -The established-subscription regression -`a_subscription_past_the_credit_is_served_once_credit_returns` already passes -with four slots. Keep that budget. The three-slot reproduction did not show a -departure leak. - -Local review identified remaining pending-setup cleanup: `ServeLoop::poll` in -`ServeMode::Establish` waits on establishment without observing lost demand, -while holding `HeldTrack`. Reproduce abandonment with at least four slots, -keeping the publisher and route live, then ensure both the TRACK hold and the -pending SUBSCRIBE registration are released when demand leaves. Preserve the -hold while demand remains. Cover Rust and its JS counterpart where applicable. - -Decided 2026-11-06 (maintainer, /quest-unblock): ✅ Rethink the handoff -around explicit requester ownership until the first reader attaches. Replace -the demand-arrived heuristic so a requester disappearing after metadata -acceptance releases a blocked SUBSCRIBE and its TRACK hold. Rejected: another -heuristic patch, landing with the known gap, and dropping the PR. - -Use the existing `track::Resolving` requester handle as ownership across -metadata acceptance. It already contributes demand until dropped; subscribe -before releasing it to transfer ownership without a gap. Setup cancellation -therefore observes current owners rather than remembering demand history. From dec1cc29a3195264de33b2a27f21bc7f63d9d8f3 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 6 Nov 2026 09:30:56 -0800 Subject: [PATCH 20/21] fix(net): use requester ownership while waiting for authorization --- js/net/src/lite/subscriber.ts | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/js/net/src/lite/subscriber.ts b/js/net/src/lite/subscriber.ts index ad96ae2dafb..4a1cfbe9b01 100644 --- a/js/net/src/lite/subscriber.ts +++ b/js/net/src/lite/subscriber.ts @@ -34,7 +34,7 @@ import type * as track from "../track.ts"; import { untilAborted } from "../util/abort.ts"; import { closeUnwanted } from "../util/announce.ts"; import { Deadline } from "../util/deadline.ts"; -import { abandoned, isAbandoned, unwanted } from "../util/demand.ts"; +import { isUnrequested, unrequested, unwanted } from "../util/demand.ts"; import { LIMITS, type Limits, SlotMap, Slots } from "../util/limits.ts"; import { min, UNBOUNDED } from "../util/sequence.ts"; import { Budget } from "../util/yield.ts"; @@ -1154,11 +1154,11 @@ export class Subscriber { for (;;) { const ready = await this.#auth?.ready(broadcast, "subscribe", { signal: consumed.valid, - until: () => abandoned(request.demand()), + until: () => unrequested(request), }); if (ready !== false) break; // Demand returning before we commit is not abandonment, matching the serving loop. - if (!isAbandoned(request.demand())) continue; + if (!isUnrequested(request)) continue; request.reject(new Error("subscribe abandoned before it was authorized")); return; } @@ -1222,7 +1222,7 @@ export class Subscriber { const wanted = hooks.requestWanted(request); let unwatch: Dispose | undefined; const watch = () => { - if (hooks.demandReleased(demand).peek() !== undefined || !wanted.peek()) { + if (isUnrequested(request)) { left.abort( new StreamError(StreamCode.Cancel, { message: "subscribe abandoned before it was accepted" }), ); From 4025c4ab3519f5fdca65ec2b7abcfb4b6334f900 Mon Sep 17 00:00:00 2001 From: quest fixer Date: Fri, 6 Nov 2026 13:35:38 -0800 Subject: [PATCH 21/21] test(net): follow base origin hop constructor type --- rs/moq-net/src/lite/subscriber.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index 21b7dc1d774..bd45eb5c0c6 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -6443,7 +6443,7 @@ mod tests { let opening = kio::Producer::new(true); let session = SinkSession::gated_bi(gate.consume()).with_open_bi_gate(opening.consume()); - let origin = origin::Config::new(crate::Hop::new(1).unwrap()).produce(); + let origin = origin::Config::new(std::num::NonZeroU64::new(1).unwrap()).produce(); let subscriber = Subscriber::new(SubscriberConfig { runtime: crate::time::sim(), session: crate::driver::Transport::new(session.clone()), @@ -6540,7 +6540,7 @@ mod tests { let opening = kio::Producer::new(true); let session = SinkSession::gated_bi(gate.consume()).with_open_bi_gate(opening.consume()); - let origin = origin::Config::new(crate::Hop::new(1).unwrap()).produce(); + let origin = origin::Config::new(std::num::NonZeroU64::new(1).unwrap()).produce(); let subscriber = Subscriber::new(SubscriberConfig { runtime: crate::time::sim(), session: crate::driver::Transport::new(session.clone()), @@ -6602,7 +6602,7 @@ mod tests { let opening = kio::Producer::new(true); let session = SinkSession::gated_bi(gate.consume()).with_open_bi_gate(opening.consume()); - let origin = origin::Config::new(crate::Hop::new(1).unwrap()).produce(); + let origin = origin::Config::new(std::num::NonZeroU64::new(1).unwrap()).produce(); let subscriber = Subscriber::new(SubscriberConfig { runtime: crate::time::sim(), session: crate::driver::Transport::new(session.clone()),