From 6c82a8a0b6b1262219dba256e0d84411fa6caa18 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 00:02:04 -0700 Subject: [PATCH 1/2] chore(quest): claim quest/m1/settled-copies.md Quest-Claim: 4161d7a8908df5cc From 6d0aaebfe07d034eadbb3a996b74e6cc2167e2d2 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 01:23:27 -0700 Subject: [PATCH 2/2] fix(net): a finished bounded copy leaves the largest group open A copy a transport bound cut short finished only its own range, so it no longer marks the track's largest group final. Audits every whole-group versus settled-copy check in the model; the rest already use the meaning they need. Co-Authored-By: Claude Opus 5.5 --- quest/m1/README.md | 1 - quest/m1/settled-copies.md | 26 ----------------------- rs/moq-net/src/model/cache.rs | 8 +++---- rs/moq-net/src/model/group.rs | 5 ++++- rs/moq-net/src/model/track.rs | 40 +++++++++++++++++++++++++++++++++++ 5 files changed, 48 insertions(+), 32 deletions(-) delete mode 100644 quest/m1/settled-copies.md diff --git a/quest/m1/README.md b/quest/m1/README.md index c8fd34f95eb..e68bf9e7b76 100644 --- a/quest/m1/README.md +++ b/quest/m1/README.md @@ -168,7 +168,6 @@ removed). - [Segment cuts hold bounded state](/quest/m1/segmenter-cuts.md) - the HLS segmenter keeps one pending cut, so `styp` input without sync samples cannot grow it - [Next Object on a cold Rust copy](/quest/m1/next-object-cold-copy.md) - a join after an upstream group report starts at the first frame received, never skipping - [Container consumers buffer by backpressure](/quest/m1/container-backpressure.md) - Rust and JS container consumers decode ahead only a byte budget, so a hostile publisher cannot grow them -- [Settled copies versus whole groups](/quest/m1/settled-copies.md) - every model check of whether a group is done means either a settled copy or the whole group, as it needs - [An HLS viewer starts capture](/quest/m1/hls-record-demand.md) - a record-track subscriber counts as demand for its rendition's media - [One moq-ffi build definition](/quest/m1/ffi-build-flags.md) - every binding takes moq-ffi's default features from one place - [moq-clock moves into kio::clock](/quest/m1/kio-clock.md) - moq-clock and its test macro become `kio::clock` and `#[kio::test]` before the cut publishes them diff --git a/quest/m1/settled-copies.md b/quest/m1/settled-copies.md deleted file mode 100644 index f9ba2d0c07e..00000000000 --- a/quest/m1/settled-copies.md +++ /dev/null @@ -1,26 +0,0 @@ -# [S] Settled copies versus whole groups - -## Goal - -Every check in moq-net's model that asks whether a group is done uses the -meaning it needs: a copy whose writer finished (`Handle::is_settled`) or the -whole group reaching its end (`is_finished`). A finished bounded copy is -never mistaken for the whole group, and never kept open as unfinished. - -## Plan - -Decided 2026-10-28 (maintainer), from -[moq-dev/moq#6922](https://github.com/moq-dev/moq/pull/6922): audit every -caller at once instead of fixing them as reviews find them. Three review -rounds on #6922 each fixed one site (track teardown, the track's clean end, -and uncached copies). - -- List every `is_finished`, `is_settled`, `serves_end`, and `cut` caller in - `rs/moq-net/src/model/` and state which meaning each needs. -- `tear_down`'s `open` and `lookup.retain` still use whole-group - `is_finished`. That looks deliberate, since a bounded copy does not serve - the group's end, but confirm it. -- Each wrong caller gets a test that fails before its fix. Callers that are - right need no test. - -Public API: none. Wire: none. diff --git a/rs/moq-net/src/model/cache.rs b/rs/moq-net/src/model/cache.rs index 6de5651f370..cda8203f98c 100644 --- a/rs/moq-net/src/model/cache.rs +++ b/rs/moq-net/src/model/cache.rs @@ -721,8 +721,8 @@ pub(super) struct Track { #[derive(Default)] struct Largest { position: Option, - // The largest group's content may still grow: no copy of it finished, and it is not a - // datagram. An aborted one stays open, since it can be recreated or fetched. + // The largest group's content may still grow: no copy of the whole group finished, and it + // is not a datagram. An aborted one stays open, since it can be recreated or fetched. open: bool, // The track ended, so no newer position can follow. ended: bool, @@ -738,8 +738,8 @@ impl Track { } } - /// Group `sequence` holds every frame it will have: a copy finished, or it is a datagram. - /// A group name fixes its content, so no legal write raises the largest past it. + /// Group `sequence` holds every frame it will have: a whole copy finished, or it is a + /// datagram. A group name fixes its content, so no legal write raises the largest past it. pub(super) fn finish_largest(&self, sequence: u64) { let mut largest = self.largest.lock(); if largest.position.is_some_and(|position| position.group == sequence) { diff --git a/rs/moq-net/src/model/group.rs b/rs/moq-net/src/model/group.rs index aaaa927dec5..ee7a8fa035d 100644 --- a/rs/moq-net/src/model/group.rs +++ b/rs/moq-net/src/model/group.rs @@ -1865,7 +1865,10 @@ impl Producer { // An empty group counts as content once it ends. self.handle.start(None); // A finished group can no longer raise the track's largest, which may end its stream. - self.handle.cache.finish_largest(self.sequence); + // A copy a transport bound cut short finished only its own range. + if original_fin.is_some() { + self.handle.cache.finish_largest(self.sequence); + } Ok(()) } diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index 740a498034d..2072e2268e7 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -1797,6 +1797,9 @@ impl TrackState { .chain(self.detached.drain(..).filter_map(|copy| copy.writing())) .collect(); let dropped = StreamError::from(&err); + // A slot survives only on a copy holding the whole group. A finished bounded copy + // serves no group reader, so it leaves the cache like an open one; a reader already + // holding it keeps it, since its writer settled and it is not aborted above. let open: Vec<_> = self .lookup .iter() @@ -8488,6 +8491,43 @@ mod test { assert_eq!(reader.poll_largest(&noop), Poll::Ready(None)); } + /// A copy a transport bound cut short finishes only its own range, so the largest group + /// may still grow and the stream stays open past the end. + #[moq_clock::test] + #[cfg(feature = "async")] + async fn a_finished_bounded_copy_keeps_the_largest_open() { + let mut producer = track_producer("test", Info::timed()); + let dynamic = producer.requests(); + let noop = kio::Waiter::noop(); + let mut first = producer.create_group(group::Info { sequence: 0 }).unwrap(); + first.write_frame(Timestamp::ZERO, &b"a"[..]).unwrap(); + first.abort(Error::Cancel).unwrap(); + producer.finish_at(Position::group(1)).unwrap(); + + let mut reader = producer.consume(); + assert_eq!(reader.poll_largest(&noop), Poll::Ready(Some(Position::group(0)))); + let fetch = reader.fetch_range( + 0, + FetchOptions { + options: group::Fetch::default(), + end: Some(1), + }, + ); + let mut bounded = dynamic + .requested_fill_group() + .await + .unwrap() + .accept(Info::timed()) + .unwrap(); + bounded.write_frame(Timestamp::ZERO, &b"a"[..]).unwrap(); + bounded.finish().unwrap(); + fetch.await.unwrap(); + assert!( + reader.poll_largest(&noop).is_pending(), + "the bounded copy does not hold the whole group" + ); + } + /// A datagram raises the largest like a group, at its only object. #[test] fn a_datagram_raises_the_largest() {