diff --git a/js/net/src/lite/subscriber.test.ts b/js/net/src/lite/subscriber.test.ts index ba87eb6818b..eb241960df2 100644 --- a/js/net/src/lite/subscriber.test.ts +++ b/js/net/src/lite/subscriber.test.ts @@ -1283,6 +1283,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/js/net/src/lite/subscriber.ts b/js/net/src/lite/subscriber.ts index d9d62af4f43..4b32996cf9e 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; } @@ -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 (isUnrequested(request)) { 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/quest/m1/stream-credit/README.md b/quest/m1/stream-credit/README.md index 25e9db3ed00..2b86a275ed4 100644 --- a/quest/m1/stream-credit/README.md +++ b/quest/m1/stream-credit/README.md @@ -42,6 +42,5 @@ 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 - [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/quest/m2/recut-held.md b/quest/m2/recut-held.md index 5dee6ce812c..3984d2fb6fe 100644 --- a/quest/m2/recut-held.md +++ b/quest/m2/recut-held.md @@ -29,6 +29,5 @@ padding probes already moved to m3 on 2026-11-06. ## Required -- [Release on leave](/quest/m1/stream-credit/release-on-leave.md) - claim held stream-credit - [Browser send estimate](/quest/m2/probe/browser-send-estimate.md) - claim held probe - [One page-wide getStats sampling ticker](/quest/m2/probe/stats-ticker.md) - claim held probe diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index b096de03077..862dc8b3c7c 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -6369,7 +6369,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() { @@ -6405,6 +6405,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()), @@ -6433,6 +6434,270 @@ 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(std::num::NonZeroU64::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; + } + 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, + 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)) + ); + + // 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()); + + 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"); + 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); + } + } + + /// 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(std::num::NonZeroU64::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 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_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(std::num::NonZeroU64::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 requester = request.consume().info(); + let mut serving = ServeLoop::new(&serve, request, Default::default()); + 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 { + 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, + }; + + // 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); + 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. struct Harness { serve: TrackServe, @@ -9339,6 +9604,7 @@ impl TrackServe { demand: Some(subscription.clone()), demand_ranges: ranges.clone(), fill_groups: Default::default(), + fills_changed: false, subscription, ranges, tail, @@ -9470,6 +9736,8 @@ struct Establish { demand: Option, /// The demand's ranges, which come first on the wire. demand_ranges: Vec, + /// Fill preferences changed while opening and need an update once active. + fills_changed: bool, /// The groups it asks for fills. fill_groups: rangemap::RangeSet, /// The ranges the SUBSCRIBE carries: the demand's, then the fills'. @@ -10010,6 +10278,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(active) = serve_loop.sub { let applied = match finished { true => self.serve.subscriber.finish_subscribe(active.id), @@ -10579,13 +10851,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( @@ -10596,6 +10878,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); @@ -10856,11 +11139,38 @@ impl ServeLoop { loop { match &mut self.mode { 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) + { + Ok(changed) => est.fills_changed |= changed, + Err(err) => return Poll::Ready(ServeEnd::GiveBack(err)), + } + // 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() + && !read + { + self.abandon_setup(); + continue; + } let res = ready!(est.poll(waiter)); let id = est.id; + let fills_changed = est.fills_changed; 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. diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index f56a0428f25..f264bb61646 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 diff --git a/rs/moq-net/tests/integration/stream_credit.rs b/rs/moq-net/tests/integration/stream_credit.rs index c175f374cc7..845d6bd47be 100644 --- a/rs/moq-net/tests/integration/stream_credit.rs +++ b/rs/moq-net/tests/integration/stream_credit.rs @@ -146,3 +146,80 @@ async fn a_subscription_past_the_credit_is_served_once_credit_returns() { assert_eq!(group.sequence, 0, "{version}"); } } + +/// 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. + 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 + .route("live", moq_net::origin::RouteOptions::hidden()) + .unwrap(); + let info = track::Info::default() + .with_timescale(moq_net::Timescale::MILLI) + .with_max_age(None); + 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); + 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}"); + 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); + } +}