From f08b8bb839818380163335ca4d661a564c503888 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 22:36:19 -0800 Subject: [PATCH 1/5] chore(quest): claim quest/m2/time-addressing/time-end-gap.md Quest-Claim: fdcadee622242c75 From 558d43c133e3653b1f61e682bcc4e4d7e21c35e7 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 23:09:20 -0800 Subject: [PATCH 2/5] fix(net): a time end between two groups ends an ordered read at the next An ordered read of a locally produced track passes a key below a group its producer created, so a time end falling between two groups ends the read once a group past it exists instead of waiting out delay.max. A received copy still ends only on what its feed proves, such as a GROUP's Previous Start. js/net's arrival reads stop ending on a local track's received edge, matching Rust, and count the misses they gave up. Co-Authored-By: Claude Opus 5.5 --- js/net/src/internal.ts | 10 +- js/net/src/ordered.test.ts | 56 +++++++- js/net/src/resume.test.ts | 27 ++++ js/net/src/resume.ts | 4 +- js/net/src/track.ts | 33 +++-- quest/m2/time-addressing/time-end-gap.md | 15 -- rs/moq-net/src/model/resume.rs | 10 +- rs/moq-net/src/model/track.rs | 131 +++++++++++++++++- rs/moq-net/tests/integration/range_anchors.rs | 89 +++++++++++- 9 files changed, 323 insertions(+), 52 deletions(-) delete mode 100644 quest/m2/time-addressing/time-end-gap.md diff --git a/js/net/src/internal.ts b/js/net/src/internal.ts index bbde94521e..318a37720f 100644 --- a/js/net/src/internal.ts +++ b/js/net/src/internal.ts @@ -498,9 +498,10 @@ export interface ResumeSource { /** * Whether the reader's bounded `window` has nothing left to deliver, judged by the serving * copy against what it and the logical reader (`delivered`) handed out. A copy that may still - * deliver keeps it open. Mirrors the Rust `Reader::exhausted`. + * deliver keeps it open, and an `ordered` reader passes what the copy's own publisher + * created past. Mirrors the Rust `Reader::exhausted`. */ - exhausted(delivered: Delivered, window: Window): boolean; + exhausted(delivered: Delivered, window: Window, ordered: boolean): boolean; /** Wake once a read may go differently; fires at most once. */ changed(fn: () => void): Dispose; /** Forget the gaps in `delivered` below each group past the budget, judged on the newest copy. */ @@ -875,9 +876,10 @@ export const hooks: { parked: (subscriber: Subscriber) => Subscriber; /** * Whether a route copy's bounded window has nothing left for the logical reader that handed - * out `delivered`, counting what the copy handed out itself. Mirrors the Rust `exhausted_for`. + * out `delivered`, counting what the copy handed out itself, read in key order when + * `ordered`. Mirrors the Rust `exhausted_for`. */ - exhaustedFor: (subscriber: Subscriber, delivered: Delivered) => boolean; + exhaustedFor: (subscriber: Subscriber, delivered: Delivered, ordered: boolean) => boolean; /** How many runs of handed-out groups a subscriber remembers: one per gap, plus the floor. Tests only. */ deliveredRuns: (subscriber: Subscriber) => number; /** How many runs a subscriber's record of what it reported holds. Tests only. */ diff --git a/js/net/src/ordered.test.ts b/js/net/src/ordered.test.ts index b29bdcf5b2..cd1457e605 100644 --- a/js/net/src/ordered.test.ts +++ b/js/net/src/ordered.test.ts @@ -5,7 +5,7 @@ import { Duration, sleep } from "@moq/clock"; import { Manual } from "@moq/clock/test"; import { StreamCode, StreamError } from "./error.ts"; import { hooks, staleHole } from "./internal.ts"; -import { textFrame } from "./mock.ts"; +import { manual, settlesWithin, textFrame } from "./mock.ts"; import { Timestamp } from "./time.ts"; import { type Ordered, Producer as TrackProducer } from "./track.ts"; @@ -405,3 +405,57 @@ test("a read returning only gaps keeps its handed-out record compact", () => { } expect(hooks.deliveredRuns(sub)).toBe(1); }); + +// Mirrors the Rust `a_time_end_between_*` tests in `track.rs`. +const between = { ranges: [{ start: { time: 1500n }, end: { time: 1999n } }], delay: { max: Duration.millis(30_000) } }; + +test("a time end between two groups ends an ordered read once the publisher created one past it", async () => { + using clock = manual(); + const producer = new TrackProducer("test"); + const ordered = producer.subscribe(between).ordered(); + const arrival = producer.subscribe(between); + put(producer, 1000n, false); + expect((await ordered.nextGroup())?.start).toBe(1000n); + expect((await arrival.recvGroup())?.start).toBe(1000n); + const end = ordered.nextGroup(); + expect(await settlesWithin(end, clock)).toBe(false); + // Handing out 2000 would pass every start below it; an arrival read waits, since 1500 may still come. + put(producer, 2000n, false); + expect(await end).toBeUndefined(); + expect(await settlesWithin(arrival.recvGroup(), clock)).toBe(false); + + // A group created between before a read reaches the end is still read. + const later = producer.subscribe(between).ordered(); + expect((await later.nextGroup())?.start).toBe(1000n); + put(producer, 1600n, false); + expect((await later.nextGroup())?.start).toBe(1600n); + expect(await later.nextGroup()).toBeUndefined(); +}); + +test("a time end between appended groups ends either read at once", async () => { + const producer = new TrackProducer("test"); + for (const key of [1000n, 2000n]) { + const group = producer.appendGroup(Timestamp.unscaled(key)); + group.writeFrame(textFrame("x", Timestamp.unscaled(key))); + group.finish(); + } + const arrival = producer.subscribe(between); + expect((await arrival.recvGroup())?.start).toBe(1000n); + expect(await arrival.recvGroup()).toBeUndefined(); + const ordered = producer.subscribe(between).ordered(); + expect((await ordered.nextGroup())?.start).toBe(1000n); + expect(await ordered.nextGroup()).toBeUndefined(); +}); + +test("a time end between received groups ends an ordered read only once the skip is proven", async () => { + using clock = manual(); + const producer = receivedTrack(); + put(producer, 1000n, false); + put(producer, 2000n, false); + const ordered = producer.subscribe(between).ordered(); + expect((await ordered.nextGroup())?.start).toBe(1000n); + const end = ordered.nextGroup(); + expect(await settlesWithin(end, clock)).toBe(false); + producer.skipGroups(1001n, 2000n); + expect(await end).toBeUndefined(); +}); diff --git a/js/net/src/resume.test.ts b/js/net/src/resume.test.ts index 85c11e2537..e9ff36126b 100644 --- a/js/net/src/resume.test.ts +++ b/js/net/src/resume.test.ts @@ -4831,3 +4831,30 @@ test("failed copies holding groups back are each subscribed afresh", async () => sub.close(); close(); }); + +// Mirrors the Rust `a_time_end_between_groups_ends_an_ordered_read_at_the_next` integration test, +// through a front serving the publisher's own track: its copy passes on what that publisher created. +test("a time end between two groups ends an ordered read through a front at the next", async () => { + const front = new Front(); + const source = new BroadcastProducer(); + const handle = source.consume(); + front.serve(handle); + const track = copy(source); + for (const key of [1000n, 2000n, 3000n]) track.write(key); + const between = { + ranges: [{ start: { time: 1500n }, end: { time: 1999n } }], + delay: { max: Duration.millis(3_600_000) }, + }; + const ordered = front.consumer.track("seq").subscribe(between).ordered(); + expect((await ordered.nextGroup())?.start).toBe(1000n); + expect(await ordered.nextGroup()).toBeUndefined(); + // An arrival read waits: the publisher may still create 1500. + const arrival = front.consumer.track("seq").subscribe(between); + expect((await arrival.recvGroup())?.start).toBe(1000n); + expect(await isPending(arrival.recvGroup())).toBe(true); + ordered.close(); + arrival.close(); + front.consumer.close(); + handle.close(); + source.close(); +}); diff --git a/js/net/src/resume.ts b/js/net/src/resume.ts index d2310a9c78..47cab308ed 100644 --- a/js/net/src/resume.ts +++ b/js/net/src/resume.ts @@ -1084,7 +1084,7 @@ class Reader implements ResumeSource { * cursor. A backfill still to ask is not judged yet, and a route between copies has nothing to * judge. Mirrors the Rust `Reader::exhausted`. */ - exhausted(delivered: Delivered, window: Window): boolean { + exhausted(delivered: Delivered, window: Window, ordered: boolean): boolean { this.sync(); if (this.#closed || this.#ended || this.#resumed) return false; const serving = this.#copies.at(-1); @@ -1102,7 +1102,7 @@ class Reader implements ResumeSource { } } } - return hooks.exhaustedFor(serving.sub, delivered); + return hooks.exhaustedFor(serving.sub, delivered, ordered); } tryDrop(delivered: Delivered, passing?: bigint): (Recv & { kind: "drop" }) | undefined { diff --git a/js/net/src/track.ts b/js/net/src/track.ts index a3af08b498..d22a7c22ba 100644 --- a/js/net/src/track.ts +++ b/js/net/src/track.ts @@ -4204,16 +4204,19 @@ export class Subscriber { // {@link #drained}. A wire publisher's reader never ends there. #exhausted(): boolean { if (this.#parks) return false; - if (this.#resume) return this.#resume.exhausted(this.#delivered, this.#window); - return this.#drained([this.#delivered]); + const ordered = this.#mode === "ordered"; + if (this.#resume) return this.#resume.exhausted(this.#delivered, this.#window, ordered); + return this.#drained([this.#delivered], ordered); } // Whether a bounded window has nothing left to deliver: every group in its ranges was handed // out (in any of `taken`), dropped, or never will be, as one skipped as stale, one below where // the feed started, or a hole the feed no longer owes. An open window always has more, and so - // does one the cap keeps a group out of, since the reader may raise it again. Mirrors the - // Rust `Cursor::is_exhausted`. - #drained(taken: readonly Delivered[]): boolean { + // does one the cap keeps a group out of, since the reader may raise it again. A local + // producer may still create any group it did not skip, so only an `ordered` read, which hands + // out the group it created above a hole before any created later below, passes that hole. + // Mirrors the Rust `Cursor::is_exhausted`. + #drained(taken: readonly Delivered[], ordered: boolean): boolean { const end = this.#window.end(); if (end === undefined) return false; // A fill still owes a group it reads. @@ -4221,6 +4224,7 @@ export class Subscriber { const held = this.#state.groups.peek(); const producer = this.#state.producer; const received = max(this.#state.received.peek(), ((producer && fillEdge(producer)) ?? -1n) + 1n); + const local = producer !== undefined && !wireFed(producer); // A received stale run that does not settle this reader is unknown to it (see `settles`): // the reader still wants those groups, however the feed accounted for them. const budget = this.#drift().budget; @@ -4240,10 +4244,14 @@ export class Subscriber { })); const drops = overlapping.filter((run) => settles(run, budget, coverage)); const unknown = overlapping.filter((run) => !settles(run, budget, coverage)); - for (const open of runGaps(drops, gap.start, gap.end)) { + // A miss this reader gave up on is never wanted again. + const opens = runGaps(drops, gap.start, gap.end).flatMap((run) => + runGaps(this.#givenUp, run.start, run.end), + ); + for (const open of opens) { if (unknown.some((run) => run.start < open.end && open.start < run.end)) return false; - // Not received yet, so it may still arrive. - if (open.end > received) return false; + // Not received yet, so it may still arrive; a local producer may still create it. + if (open.end > received || (local && !ordered)) return false; // Held, so a read still hands it out, skips it, or waits for the cap to rise. const index = timelineIndex(held, open.start); if (held[index] && held[index].start < open.end) return false; @@ -4293,10 +4301,10 @@ export class Subscriber { }; // A route copy judged for the logical reader that handed out `delivered`: what the copy // handed out itself counts too. A copy that is itself a front judges across its own copies. - hooks.exhaustedFor = (subscriber, delivered) => + hooks.exhaustedFor = (subscriber, delivered, ordered) => subscriber.#resume - ? subscriber.#resume.exhausted(subscriber.#delivered.union(delivered), subscriber.#window) - : subscriber.#drained([subscriber.#delivered, delivered]); + ? subscriber.#resume.exhausted(subscriber.#delivered.union(delivered), subscriber.#window, ordered) + : subscriber.#drained([subscriber.#delivered, delivered], ordered); hooks.tryDrop = (subscriber) => subscriber.#tryDrop(); // A reader following route copies leaves its ranges to the serving copy, which resolves // their anchors against the groups it holds, then narrows them to its own local bounds. @@ -5828,7 +5836,8 @@ export class Ordered { * group whose every frame is further behind the live edge than `delay.max` (the default * subscription's zero keeps only what nothing newer has superseded). Honors the bounds set by * {@link withRange}. Like {@link Subscriber.recvGroup}, a read whose ranges all end - * finishes once nothing in them is left to deliver. Later reads return `undefined` + * finishes once nothing in them is left to deliver; on a local track that includes a key + * below a group the producer created, which this read hands out first. Later reads return `undefined` * immediately too; widening the ranges with {@link update} reads on above the last key returned. */ nextGroup(): Promise { diff --git a/quest/m2/time-addressing/time-end-gap.md b/quest/m2/time-addressing/time-end-gap.md deleted file mode 100644 index 75d69d624e..0000000000 --- a/quest/m2/time-addressing/time-end-gap.md +++ /dev/null @@ -1,15 +0,0 @@ -# [M] A time end between two groups ends the read at the next group - -## Goal - -A bounded read whose time end falls between two held groups ends as soon as the next held group starts past that end. It does not wait out `delay.max` for a straggler. This is the migration form of a former exclusive end, `Time(t - 1)`, so binding users who migrated hit it. The behavior matches between Rust and `@moq/net`, for start-order and arrival-order reads. - -## Plan - -Found by [moq-dev/moq#9190](https://github.com/moq-dev/moq/pull/9190). On a live, locally produced track with groups at 1000, 2000 and 3000, an ordered read of `Time(1500)..=Time(1999)` hands out 1000 and then parks until `delay.max` ages out keys 1001..=1999, or forever with no max. `Time(1500)..=Time(2000)` ends at once: handing out 2000 passes every key below it. The same read in arrival order waits the budget out even with the end at 2000. The old exclusive `Absolute` end in the bindings lowered to the same `Time(t - 1)`, so this is not a regression. - -The wait comes from `Cursor::is_exhausted` in `rs/moq-net/src/model/track.rs`. It requires every key in the window up to the end to be delivered, written off, given up, dropped, or skipped. A local producer that creates group 2000 after 1000 records no skip of 1001..=1999. A lite-07 copy does learn that skip from the GROUP's Previous Start. - -Recommendation: an ordered read ends once the next held group lies past every range, since it would have handed that group out and passed the keys below it anyway. An arrival-order read keeps waiting for a straggler that a local producer may still create below the end, unless the producer records the skip. Weigh that against having `create_group` above the highest key record the keys between as skipped, which gives a local track the same knowledge a lite-07 copy has. Check JS for the same behavior and fix both together. - -Repro, as a test beside `a_range_reads_only_its_groups`: cache groups 1000, 2000, and 3000 with one frame each, subscribe with `replay().with_order(Order::Ascending).with_ranges([Time(1_500)..=Time(1_999)])`, call `.ordered()`, and poll `poll_next_group`. It returns 1000 and then stays pending instead of ending. diff --git a/rs/moq-net/src/model/resume.rs b/rs/moq-net/src/model/resume.rs index 7858b13fff..93c5026e57 100644 --- a/rs/moq-net/src/model/resume.rs +++ b/rs/moq-net/src/model/resume.rs @@ -1161,9 +1161,9 @@ impl Subscriber { /// Whether this reader's bounded window has nothing left for the readers that handed out /// `taken`, the first of which is its own; see [`Reader::exhausted`]. - pub(super) fn exhausted(&mut self, taken: &[&Delivered], waiter: &kio::Waiter) -> bool { + pub(super) fn exhausted(&mut self, taken: &[&Delivered], ordered: bool, waiter: &kio::Waiter) -> bool { let mut reader = self.reader(); - !reader.let_go(taken[0], waiter) && reader.exhausted(taken, waiter) + !reader.let_go(taken[0], waiter) && reader.exhausted(taken, ordered, waiter) } /// Hand out the group a [`Self::poll_peek_group`] reserved. @@ -2522,7 +2522,7 @@ impl Reader { } let drained = self.bound_at_end(); let waits = self.let_go(delivered, waiter); - if !parks && !waits && self.exhausted(&[delivered], waiter) { + if !parks && !waits && self.exhausted(&[delivered], ordered, waiter) { return Some(Poll::Ready(Ok(None))); } match self.poll_end(waiter, |copy| copy.done.clone().map(|done| done.map(|_| ()))) { @@ -2540,7 +2540,7 @@ impl Reader { /// resume point was the copies' it replaced, each let go once it had nothing more, and a /// backfill still out is not judged yet. A route between copies has nothing to judge. /// `taken` holds the logical readers' records, the reader's own first. - fn exhausted(&mut self, taken: &[&Delivered], waiter: &kio::Waiter) -> bool { + fn exhausted(&mut self, taken: &[&Delivered], ordered: bool, waiter: &kio::Waiter) -> bool { if self.resumed.is_some() { return false; } @@ -2575,7 +2575,7 @@ impl Reader { sub: Sub::Ready(sub), floor, .. - }) if Some(*generation) == self.generation => sub.exhausted_for(taken, *floor, waiter), + }) if Some(*generation) == self.generation => sub.exhausted_for(taken, *floor, ordered, waiter), _ => false, } } diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index 1916410c2b..07f5addf28 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -9272,7 +9272,11 @@ impl Cursor { /// cap keeps a group out of, since a reader may raise a cap again. Groups under `from` are /// not judged: a time start resolves to the group containing it, which may lie under a /// copy's resume point. - fn is_exhausted(&self, logical: &[&Delivered], from: u64) -> bool { + /// + /// An `ordered` read of the track's own publisher also passes a key below a group that + /// publisher created (see [`Self::passes`]). A received copy never does: only what its + /// feed proved, such as a GROUP's Previous Start, accounts for a key there. + fn is_exhausted(&self, logical: &[&Delivered], from: u64, ordered: bool) -> bool { let taken: Vec<&Delivered> = std::iter::once(&self.record.delivered) .chain(logical.iter().copied()) .collect(); @@ -9286,6 +9290,7 @@ impl Cursor { let coverage = self.coverage(); let state = self.state.read(); let budget = clamp_max_delay(self.subscription.read().budget(), state.max_age_bound()); + let passes = ordered && !state.anchors.received(); let accounted = |gap: ops::Range| { let mut left = RangeSet::new(); left.insert(gap.clone()); @@ -9309,7 +9314,7 @@ impl Cursor { for key in self.seek_pending.range(gap).map(|(key, _)| *key) { left.remove(key..key + 1); } - left.is_empty() + left.iter().all(|open| passes && Self::passes(&state, open)) }; self.filter .window @@ -9321,6 +9326,15 @@ impl Cursor { }) } + /// Whether an ordered read of its track's own publisher passes `gap` without a group: that + /// publisher created one at its last key or past it, which the read hands out (or would, + /// were it in range and still held) before any created later below it, and no group the + /// read may still hand out, or wait on a cap for, lies in it. + fn passes(state: &TrackState, gap: &ops::Range) -> bool { + state.max_key.is_some_and(|max| max >= gap.end - 1) + && !state.lookup.range(gap.clone()).any(|(_, slot)| slot.visible) + } + /// Whether group `key`, at or above [`Self::floor`], is one this cursor reads now: /// in its window and below its cap. One that isn't may be later. fn admits(&self, key: u64) -> bool { @@ -10714,7 +10728,7 @@ impl Subscriber { Poll::Pending => { // A read that only skipped since its last hand-out settles its write-offs too. cursor.retire_written_off(); - break match !self.parks && cursor.is_exhausted(&[], 0) { + break match !self.parks && cursor.is_exhausted(&[], 0, ordered) { true => Poll::Ready(Ok(None)), false => Poll::Pending, }; @@ -10741,15 +10755,22 @@ impl Subscriber { /// Whether this route copy's bounded window has nothing left for the logical readers that /// handed out `logical`: what this copy took itself, wrote off, or gave up counts too. /// It judges from its resume point `from`: the logical reader judges what lies under it. - pub(super) fn exhausted_for(&mut self, logical: &[&Delivered], from: Option, waiter: &kio::Waiter) -> bool { + /// An `ordered` read also ends where [`Cursor::is_exhausted`] says one does. + pub(super) fn exhausted_for( + &mut self, + logical: &[&Delivered], + from: Option, + ordered: bool, + waiter: &kio::Waiter, + ) -> bool { match &mut self.inner { - Inner::Plain(cursor) => cursor.is_exhausted(logical, from.unwrap_or(0)), + Inner::Plain(cursor) => cursor.is_exhausted(logical, from.unwrap_or(0), ordered), // A copy that is another front's logical track judges across its own copies. Inner::Resume(resume, own) => { let mut taken = Vec::with_capacity(logical.len() + 1); taken.push(&own.record.delivered); taken.extend_from_slice(logical); - resume.exhausted(&taken, waiter) + resume.exhausted(&taken, ordered, waiter) } } } @@ -11924,7 +11945,8 @@ impl Ordered { /// Honors the group range set by [`Subscriber::with_range`] before [`Subscriber::ordered`]: /// a group past the cap stays in the producer's cache and becomes eligible again if /// the cap rises or is removed. Ranges that all end end the read once they are - /// accounted for, as for [`Subscriber::poll_recv_group`]. + /// accounted for, as for [`Subscriber::poll_recv_group`]. On a locally produced track that + /// includes a key below a group the producer created, which this read hands out first. /// Later reads return `Ok(None)` immediately too; widening the ranges with /// [`Self::update`] resumes reading above the last key returned. /// @@ -13306,6 +13328,101 @@ mod test { assert_eq!(read_groups(|waiter| ordered.poll_next_group(waiter)), want); } + /// A time end between two groups ends an ordered read once the track's own publisher + /// created a group past it, waking the read parked there: handing that group out would have + /// passed the starts between. An arrival read keeps waiting, since the publisher may still + /// create a group between, until it says it won't (see the next test). + #[test] + fn a_time_end_between_groups_ends_an_ordered_read_at_the_next() { + let producer = track_producer("test", None); + let range = Range { + start: Anchor::Time(1_500), + end: Some(Anchor::Time(1_999)), + }; + let bounded = || producer.subscribe(replay().with_ranges([range])); + let mut ordered = bounded().ordered(); + let mut arrival = bounded(); + let _first = framed(&producer, 1_000, 1).finish().unwrap(); + let noop = kio::Waiter::noop(); + assert!(matches!(ordered.poll_next_group(&noop), Poll::Ready(Ok(Some(group))) if group.start == 1_000)); + assert!(matches!(arrival.poll_recv_group(&noop), Poll::Ready(Ok(Some(group))) if group.start == 1_000)); + + let woken = Arc::new(AtomicBool::new(false)); + let waiter = kio::Waiter::new(futures::task::waker(Arc::new(FlagWake(woken.clone())))); + assert!( + ordered.poll_next_group(&waiter).is_pending(), + "a group may still come below the end" + ); + let _past = framed(&producer, 2_000, 1).finish().unwrap(); + assert!(woken.load(Ordering::SeqCst), "the group past the end wakes the read"); + assert!(matches!(ordered.poll_next_group(&noop), Poll::Ready(Ok(None)))); + assert!(arrival.poll_recv_group(&noop).is_pending(), "1500 may still be created"); + + // A group created between before a read reaches the end is still read. + let mut later = bounded().ordered(); + assert!(matches!(later.poll_next_group(&noop), Poll::Ready(Ok(Some(group))) if group.start == 1_000)); + let _between = framed(&producer, 1_600, 1).finish().unwrap(); + assert!(matches!(later.poll_next_group(&noop), Poll::Ready(Ok(Some(group))) if group.start == 1_600)); + assert!(matches!(later.poll_next_group(&noop), Poll::Ready(Ok(None)))); + } + + /// An appending publisher says it will not go back, so the starts between its groups are + /// skipped and a time end between two of them ends a read in either order at once. + #[test] + fn a_time_end_between_appended_groups_ends_either_read() { + let producer = track_producer("test", None); + for key in [1_000, 2_000] { + let mut group = producer.append_group(crate::Timestamp::unscaled(key)).unwrap(); + group.write_frame(crate::Timestamp::unscaled(key), &b"x"[..]).unwrap(); + group.finish().unwrap(); + } + let range = Range { + start: Anchor::Time(1_500), + end: Some(Anchor::Time(1_999)), + }; + let bounded = || producer.subscribe(replay().with_ranges([range])); + let want = vec![(1_000, vec![0])]; + let mut arrival = bounded(); + assert_eq!(read_groups(|waiter| arrival.poll_recv_group(waiter)), want); + assert!(matches!( + arrival.poll_recv_group(&kio::Waiter::noop()), + Poll::Ready(Ok(None)) + )); + let mut ordered = bounded().ordered(); + assert_eq!(read_groups(|waiter| ordered.poll_next_group(waiter)), want); + assert!(matches!( + ordered.poll_next_group(&kio::Waiter::noop()), + Poll::Ready(Ok(None)) + )); + } + + /// A received copy ends an ordered read between two groups only on what its feed proves: + /// a hole it may still land waits, and the starts between skipped, as a GROUP's Previous + /// Start says, end it. + #[cfg(feature = "async")] + #[test] + fn a_time_end_between_received_groups_ends_only_once_proven() { + let producer = received_producer(None); + producer.anchored(); + let _groups: Vec<_> = [1_000, 2_000] + .into_iter() + .map(|key| framed(&producer, key, 1).finish().unwrap()) + .collect(); + let range = Range { + start: Anchor::Time(1_500), + end: Some(Anchor::Time(1_999)), + }; + let mut ordered = producer.subscribe(replay().with_ranges([range])).ordered(); + let noop = kio::Waiter::noop(); + assert!(matches!(ordered.poll_next_group(&noop), Poll::Ready(Ok(Some(group))) if group.start == 1_000)); + assert!( + ordered.poll_next_group(&noop).is_pending(), + "the feed may still land 1500" + ); + producer.skip_groups(1_001..2_000); + assert!(matches!(ordered.poll_next_group(&noop), Poll::Ready(Ok(None)))); + } + /// A drop outside a reader's ranges is reported once a group arriving places a time start /// below it, widening its range over the drop, as a scan of the whole window would. #[test] diff --git a/rs/moq-net/tests/integration/range_anchors.rs b/rs/moq-net/tests/integration/range_anchors.rs index fda4f0e699..071da1cba0 100644 --- a/rs/moq-net/tests/integration/range_anchors.rs +++ b/rs/moq-net/tests/integration/range_anchors.rs @@ -48,6 +48,28 @@ fn millis(ms: u64) -> Timestamp { /// to `range` reads oldest first: through the publisher's own origin with no `version`, /// otherwise over one session on it. async fn read(version: Option<&str>, range: Range) -> Result, Error> { + read_as(version, range, Read::default()).await.map(|read| read.groups) +} + +/// How [`read_as`] publishes and reads. +#[derive(Clone, Copy, Default)] +struct Read { + /// The publisher appends each group, saying it will not go back below it. + append: bool, + /// The subscriber reads in key order. + ordered: bool, +} + +/// What [`read_as`] read. +#[derive(Debug, PartialEq)] +struct Groups { + groups: Vec, + /// The read ended, rather than waited out [`TIMEOUT`]. + ended: bool, +} + +/// [`read`], published and read as `how` says. +async fn read_as(version: Option<&str>, range: Range, how: Read) -> Result { let publisher = produce_origin(1); let broadcast = publisher .route("room", moq_net::origin::RouteOptions::hidden()) @@ -61,7 +83,10 @@ async fn read(version: Option<&str>, range: Range) -> Result, Error> { .unwrap(); broadcast.announce().unwrap(); for key in (0..5).map(|second| second * 1000) { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = match how.append { + true => track.append_group(millis(key)).unwrap(), + false => track.create_group(moq_net::group::Info { start: key }).unwrap(), + }; group.write_frame(millis(key), &b"x"[..]).unwrap(); group.finish().unwrap(); } @@ -89,15 +114,33 @@ async fn read(version: Option<&str>, range: Range) -> Result, Error> { .with_delay(Delay::default().with_max(FOREVER)) .with_order(Order::Ascending) .with_ranges([range]); - let mut reader = kio::clock::timeout(TIMEOUT, remote.track("data").unwrap().subscribe(subscription)) + let reader = kio::clock::timeout(TIMEOUT, remote.track("data").unwrap().subscribe(subscription)) .await .expect("subscribe timeout")?; - let mut read = Vec::new(); - while let Ok(group) = kio::clock::timeout(TIMEOUT, reader.recv_group()).await { + let mut read = Groups { + groups: Vec::new(), + ended: false, + }; + let mut ordered = None; + let mut arrival = None; + match how.ordered { + true => ordered = Some(reader.ordered()), + false => arrival = Some(reader), + } + loop { + let next = match (&mut ordered, &mut arrival) { + (Some(ordered), _) => kio::clock::timeout(TIMEOUT, ordered.next_group()).await, + (_, Some(arrival)) => kio::clock::timeout(TIMEOUT, arrival.recv_group()).await, + _ => unreachable!(), + }; + let Ok(group) = next else { break }; match group? { - Some(group) => read.push(group.start), - None => break, + Some(group) => read.groups.push(group.start), + None => { + read.ended = true; + break; + } } } let _track = track.finish().unwrap(); @@ -301,3 +344,37 @@ async fn a_sparse_request_counts_its_relative_start_back_as_the_publisher_did() assert_eq!(end.map(|group| group.start), None, "the ranges are covered"); let _track = track.finish().unwrap(); } + +/// A time end between two groups ends an ordered read once the publisher created a group past +/// it: handing that group out would have passed the starts between. Through the publisher's own +/// origin that is its own state. A lite-07 copy ends there only on what its wire proves, the +/// starts between skipped, which a GROUP's Previous Start says of an appending publisher. A +/// publisher creating groups out of order says nothing, so the copy, and any arrival read of a +/// track created that way, waits for a group that may still come. +#[kio::test] +async fn a_time_end_between_groups_ends_an_ordered_read_at_the_next() { + let between = range(Anchor::Time(1500), Some(Anchor::Time(1999))); + let ordered = |append| Read { append, ordered: true }; + let arrival = |append| Read { append, ordered: false }; + let lite07 = Some("moq-lite-07-wip"); + for (version, how, ended) in [ + (None, ordered(false), true), + (None, ordered(true), true), + (None, arrival(false), false), + (None, arrival(true), true), + (lite07, ordered(true), true), + (lite07, arrival(true), true), + (lite07, ordered(false), false), + ] { + let read = read_as(version, between, how).await.unwrap(); + let label = (version, how.append, how.ordered); + assert_eq!( + read, + Groups { + groups: vec![1000], + ended + }, + "{label:?}" + ); + } +} From 85efea73760aac681e49359d757286e015f1c387 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 23:28:02 -0800 Subject: [PATCH 3/5] fix(net): an ordered read that ran out of its range passes it for good An ordered read ending at a bounded window's end now moves past it, in a plain cursor and a front's reader, so a group created below the end afterward is late rather than handed out on the next read. Co-Authored-By: Claude Opus 5.5 --- js/net/src/ordered.test.ts | 12 ++++-- js/net/src/resume.test.ts | 7 +++- js/net/src/track.ts | 26 +++++++++++- rs/moq-net/src/model/resume.rs | 7 ++++ rs/moq-net/src/model/track.rs | 40 ++++++++++++++++--- rs/moq-net/tests/integration/range_anchors.rs | 17 +++++++- 6 files changed, 96 insertions(+), 13 deletions(-) diff --git a/js/net/src/ordered.test.ts b/js/net/src/ordered.test.ts index cd1457e605..55717a51f7 100644 --- a/js/net/src/ordered.test.ts +++ b/js/net/src/ordered.test.ts @@ -422,11 +422,17 @@ test("a time end between two groups ends an ordered read once the publisher crea // Handing out 2000 would pass every start below it; an arrival read waits, since 1500 may still come. put(producer, 2000n, false); expect(await end).toBeUndefined(); - expect(await settlesWithin(arrival.recvGroup(), clock)).toBe(false); + const waiting = arrival.recvGroup(); + expect(await settlesWithin(waiting, clock)).toBe(false); + // The ended read passed every key below its end: a group created there now is late. + put(producer, 1500n, false); + expect(await ordered.nextGroup()).toBeUndefined(); + expect((await waiting)?.start).toBe(1500n); - // A group created between before a read reaches the end is still read. + // A group created between before a read reaches the end is still read. The time start now + // resolves to 1500, which contains it. const later = producer.subscribe(between).ordered(); - expect((await later.nextGroup())?.start).toBe(1000n); + expect((await later.nextGroup())?.start).toBe(1500n); put(producer, 1600n, false); expect((await later.nextGroup())?.start).toBe(1600n); expect(await later.nextGroup()).toBeUndefined(); diff --git a/js/net/src/resume.test.ts b/js/net/src/resume.test.ts index e9ff36126b..2a05361976 100644 --- a/js/net/src/resume.test.ts +++ b/js/net/src/resume.test.ts @@ -4851,7 +4851,12 @@ test("a time end between two groups ends an ordered read through a front at the // An arrival read waits: the publisher may still create 1500. const arrival = front.consumer.track("seq").subscribe(between); expect((await arrival.recvGroup())?.start).toBe(1000n); - expect(await isPending(arrival.recvGroup())).toBe(true); + const waiting = arrival.recvGroup(); + expect(await isPending(waiting)).toBe(true); + // The ended ordered read passed its range: a group created there now is late. + track.write(1500n); + expect(await ordered.nextGroup()).toBeUndefined(); + expect((await waiting)?.start).toBe(1500n); ordered.close(); arrival.close(); front.consumer.close(); diff --git a/js/net/src/track.ts b/js/net/src/track.ts index d22a7c22ba..f8425f6bcb 100644 --- a/js/net/src/track.ts +++ b/js/net/src/track.ts @@ -5108,7 +5108,11 @@ export class Subscriber { } } this.#handOut(recv.group.start, ordered); - } else if (recv.kind === "idle" && this.#exhausted()) return { kind: "done" }; + } else if (recv.kind === "done" || (recv.kind === "idle" && this.#exhausted())) { + // As the Rust front's reader: whatever ended it, an ordered read passed its range. + if (ordered) this.#passEnd(); + return { kind: "done" }; + } return recv; } } @@ -5345,6 +5349,21 @@ export class Subscriber { return undefined; } + // Pass every key below the bounded window's end for good, as an ordered read that ran out of it: + // a group created there later is late, so later reads end at once too. Mirrors the Rust + // `Cursor::pass_end`. + #passEnd(): void { + // A resumed reader's ranges resolve on the copy serving it. + const end = this.#resume ? this.#resume.servingEnd() : this.#window.end(); + if (end === undefined) return; + const floor = this.#delivered.runEnd(0n) ?? 0n; + this.#delivered.forgetBelow(end); + const forgot = this.#delivered.runEnd(0n) ?? 0n; + if (forgot > floor) this.#stoppedReading(floor, forgot); + if (!this.#resume) this.#nextKey = max(this.#nextKey, end); + this.#fold(forgot); + } + // Take `given` from the gap at `index` as an item, which the read has now moved past. What lies // below `given`, which the bounds leave out, and from `resume` on stay gaps. #takeGap(items: Items, index: number, given: Run, resume: bigint): Item { @@ -5568,7 +5587,10 @@ export class Subscriber { const end = this.#state.end.peek()?.at; // A time start still looked up may yet take in a group held already. if (this.#window.lookups().length > 0) return { kind: "idle" }; - if (this.#exhausted()) return { kind: "done" }; + if (this.#exhausted()) { + this.#passEnd(); + return { kind: "done" }; + } if ( !this.#parked(groups) && !this.#starting(groups, start) && diff --git a/rs/moq-net/src/model/resume.rs b/rs/moq-net/src/model/resume.rs index 93c5026e57..fd48069b60 100644 --- a/rs/moq-net/src/model/resume.rs +++ b/rs/moq-net/src/model/resume.rs @@ -1390,6 +1390,13 @@ impl Subscriber { reader.declared_error.clone() } + /// The exclusive end of the reader's ranges, once they all end and resolved. + pub(super) fn window_end(&self) -> Option { + let mut reader = self.reader(); + let window = reader.window(); + window.end().filter(|_| !window.is_pending()) + } + /// The local group filter, as [`track::Subscriber::poll_largest`] reports within it. pub(super) fn bounds(&self) -> track::Bounds { let mut reader = self.reader(); diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index 07f5addf28..e853d3c249 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -10224,6 +10224,13 @@ impl Cursor { self.forget_heads_below(floor); } + /// Pass every key below `end` for good, as an ordered read whose bounded window ran out + /// at `end`: a group created there later is late, so later reads end at once too. + fn pass_end(&mut self, end: u64) { + self.skip_ordered(end); + self.record.delivered.forget_below(end); + } + /// Let go of the heads asked below `next`, which an ordered read never goes back for: /// one still out would keep the read waiting on a fill it no longer polls. fn forget_heads_below(&mut self, next: u64) { @@ -10729,7 +10736,12 @@ impl Subscriber { // A read that only skipped since its last hand-out settles its write-offs too. cursor.retire_written_off(); break match !self.parks && cursor.is_exhausted(&[], 0, ordered) { - true => Poll::Ready(Ok(None)), + true => { + if ordered && let Some(end) = cursor.filter.window.end() { + cursor.pass_end(end); + } + Poll::Ready(Ok(None)) + } false => Poll::Pending, }; } @@ -10746,9 +10758,20 @@ impl Subscriber { idle.finish(&mut cursor.idle, walk, polled.is_pending()); polled } - Inner::Resume(resume, logical) => resume - .poll_peek_group(ordered, self.parks, &logical.record.delivered, waiter) - .map(|res| res.map(|candidate| candidate.map(|candidate| Reserved::Resume(Box::new(candidate))))), + Inner::Resume(resume, logical) => { + let polled = resume.poll_peek_group(ordered, self.parks, &logical.record.delivered, waiter); + if ordered + && matches!(polled, Poll::Ready(Ok(None))) + && let Some(end) = resume.window_end() + && !logical.record.delivered.covers(0..end) + { + // As a plain cursor's [`Cursor::pass_end`]: what it handed out moved, which + // nothing it parked on notifies. + resume.disarm(); + logical.record.delivered.forget_below(end); + } + polled.map(|res| res.map(|candidate| candidate.map(|candidate| Reserved::Resume(Box::new(candidate))))) + } } } @@ -13357,10 +13380,15 @@ mod test { assert!(woken.load(Ordering::SeqCst), "the group past the end wakes the read"); assert!(matches!(ordered.poll_next_group(&noop), Poll::Ready(Ok(None)))); assert!(arrival.poll_recv_group(&noop).is_pending(), "1500 may still be created"); + // The ended read passed every key below its end: a group created there now is late. + let _late = framed(&producer, 1_500, 1).finish().unwrap(); + assert!(matches!(ordered.poll_next_group(&noop), Poll::Ready(Ok(None)))); + assert!(matches!(arrival.poll_recv_group(&noop), Poll::Ready(Ok(Some(group))) if group.start == 1_500)); - // A group created between before a read reaches the end is still read. + // A group created between before a read reaches the end is still read. The time start + // now resolves to 1500, which contains it. let mut later = bounded().ordered(); - assert!(matches!(later.poll_next_group(&noop), Poll::Ready(Ok(Some(group))) if group.start == 1_000)); + assert!(matches!(later.poll_next_group(&noop), Poll::Ready(Ok(Some(group))) if group.start == 1_500)); let _between = framed(&producer, 1_600, 1).finish().unwrap(); assert!(matches!(later.poll_next_group(&noop), Poll::Ready(Ok(Some(group))) if group.start == 1_600)); assert!(matches!(later.poll_next_group(&noop), Poll::Ready(Ok(None)))); diff --git a/rs/moq-net/tests/integration/range_anchors.rs b/rs/moq-net/tests/integration/range_anchors.rs index 071da1cba0..9be6886e5e 100644 --- a/rs/moq-net/tests/integration/range_anchors.rs +++ b/rs/moq-net/tests/integration/range_anchors.rs @@ -143,6 +143,20 @@ async fn read_as(version: Option<&str>, range: Range, how: Read) -> Result kio::clock::timeout(TIMEOUT, ordered.next_group()).await, + (_, Some(arrival)) => kio::clock::timeout(TIMEOUT, arrival.recv_group()).await, + _ => unreachable!(), + }; + if let Ok(Ok(Some(group))) = next { + read.groups.push(group.start); + } + } let _track = track.finish().unwrap(); Ok(read) } @@ -350,7 +364,8 @@ async fn a_sparse_request_counts_its_relative_start_back_as_the_publisher_did() /// origin that is its own state. A lite-07 copy ends there only on what its wire proves, the /// starts between skipped, which a GROUP's Previous Start says of an appending publisher. A /// publisher creating groups out of order says nothing, so the copy, and any arrival read of a -/// track created that way, waits for a group that may still come. +/// track created that way, waits for a group that may still come. A group created below the +/// end after an ordered read ended is late, as for any key the read passed. #[kio::test] async fn a_time_end_between_groups_ends_an_ordered_read_at_the_next() { let between = range(Anchor::Time(1500), Some(Anchor::Time(1999))); From d788e0b6e94341cff21f4f52851fc4c192b44840 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 23:42:42 -0800 Subject: [PATCH 4/5] fix(net): an ended ordered read passes only what lies below its cap A front's reader also ends when its copy runs out under a lowered cap, so it commits only up to the cap; raising it reads the rest. Co-Authored-By: Claude Opus 5.5 --- js/net/src/track.ts | 9 +++++--- rs/moq-net/src/model/resume.rs | 41 ++++++++++++++++++++++++++++++++++ rs/moq-net/src/model/track.rs | 18 +++++++++------ 3 files changed, 58 insertions(+), 10 deletions(-) diff --git a/js/net/src/track.ts b/js/net/src/track.ts index f8425f6bcb..e3acecda1a 100644 --- a/js/net/src/track.ts +++ b/js/net/src/track.ts @@ -5350,12 +5350,15 @@ export class Subscriber { } // Pass every key below the bounded window's end for good, as an ordered read that ran out of it: - // a group created there later is late, so later reads end at once too. Mirrors the Rust + // a group created there later is late, so later reads end at once too. Only below the cap: a read + // that ran out under a lowered cap still owes what lies above it. Mirrors the Rust // `Cursor::pass_end`. #passEnd(): void { // A resumed reader's ranges resolve on the copy serving it. - const end = this.#resume ? this.#resume.servingEnd() : this.#window.end(); - if (end === undefined) return; + const window = this.#resume ? this.#resume.servingEnd() : this.#window.end(); + if (window === undefined) return; + const cap = this.#cursor.peek().end; + const end = cap === undefined ? window : min(cap, window); const floor = this.#delivered.runEnd(0n) ?? 0n; this.#delivered.forgetBelow(end); const forgot = this.#delivered.runEnd(0n) ?? 0n; diff --git a/rs/moq-net/src/model/resume.rs b/rs/moq-net/src/model/resume.rs index fd48069b60..4ca5dacea3 100644 --- a/rs/moq-net/src/model/resume.rs +++ b/rs/moq-net/src/model/resume.rs @@ -4737,6 +4737,47 @@ mod test { } } + /// An ordered read that ran out under a lowered cap passes only what lies below it, on a + /// front's reader as on a plain one: raising the cap reads the rest of a finished track. + #[test] + #[cfg(feature = "async")] + fn an_ordered_read_ended_under_a_cap_reads_on_once_it_rises() { + let subscription = Subscription::default() + .with_delay(Delay::default().with_max(HOUR)) + .with_ranges([track::Range::groups(0..3)]); + for routed in [false, true] { + let routes = Producer::new(); + let logical = logical(&routes); + let a = copy(); + routes.serve(a.consume()); + for sequence in 0..3 { + write(&a, sequence); + } + let _finished = a.clone().finish().unwrap(); + let track = if routed { &logical } else { &a }; + let sub = track + .consume() + .subscribe(subscription.clone()) + .now_or_never() + .unwrap() + .unwrap(); + let mut ordered = sub.ordered().with_range(..1); + let noop = kio::Waiter::noop(); + let next = |ordered: &mut track::Ordered| match ordered.poll_next_group(&noop) { + Poll::Ready(Ok(group)) => Some(group.map(|group| group.start)), + _ => None, + }; + assert_eq!(next(&mut ordered), Some(Some(0)), "routed={routed}"); + assert_eq!(next(&mut ordered), Some(None), "routed={routed}: nothing below the cap"); + let mut ordered = ordered.with_range(..); + let mut rest = Vec::new(); + while let Poll::Ready(Ok(Some(group))) = ordered.poll_next_group(&noop) { + rest.push(group.start); + } + assert_eq!(rest, [1, 2], "routed={routed}"); + } + } + /// A front's reader counts the groups its budget skips, as a plain reader does. #[test] fn a_front_reader_counts_the_groups_its_budget_skips() { diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index e853d3c249..483be99994 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -10225,7 +10225,8 @@ impl Cursor { } /// Pass every key below `end` for good, as an ordered read whose bounded window ran out - /// at `end`: a group created there later is late, so later reads end at once too. + /// at `end`, or at its cap below that: a group created there later is late, so later reads + /// end at once too. fn pass_end(&mut self, end: u64) { self.skip_ordered(end); self.record.delivered.forget_below(end); @@ -10738,7 +10739,7 @@ impl Subscriber { break match !self.parks && cursor.is_exhausted(&[], 0, ordered) { true => { if ordered && let Some(end) = cursor.filter.window.end() { - cursor.pass_end(end); + cursor.pass_end(cursor.end_key.map_or(end, |cap| cap.min(end))); } Poll::Ready(Ok(None)) } @@ -10760,15 +10761,18 @@ impl Subscriber { } Inner::Resume(resume, logical) => { let polled = resume.poll_peek_group(ordered, self.parks, &logical.record.delivered, waiter); + // As a plain cursor's [`Cursor::pass_end`], below the cap: a read that ran out under + // a lowered cap, its window or the track having ended, still owes what lies above it. if ordered && matches!(polled, Poll::Ready(Ok(None))) && let Some(end) = resume.window_end() - && !logical.record.delivered.covers(0..end) { - // As a plain cursor's [`Cursor::pass_end`]: what it handed out moved, which - // nothing it parked on notifies. - resume.disarm(); - logical.record.delivered.forget_below(end); + let end = resume.bounds().end.map_or(end, |cap| cap.min(end)); + if !logical.record.delivered.covers(0..end) { + // What it handed out moved, which nothing it parked on notifies. + resume.disarm(); + logical.record.delivered.forget_below(end); + } } polled.map(|res| res.map(|candidate| candidate.map(|candidate| Reserved::Resume(Box::new(candidate))))) } From aeb71f26307ea39392bb5f031f62090ba9de59a4 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 20 Nov 2026 01:18:00 -0800 Subject: [PATCH 5/5] fix(net): an ended ordered read reports what it passed before passing it - Rust `Cursor::pass_end` commits the stale convictions below the end, so a group stepped over as stale is a gap before the read ends. - Rust front reader takes its window end and cap under the same lock that decided the end, so a range widened meanwhile is still read. - JS `#passEnd` takes the copies' dispositions below the end first, so a front's gap (a group missing its head) goes out before the end. - `Ordered` docs: a widened range reads on above the end the read passed. - range_anchors: the late-group check fails on an error or a wait. Co-Authored-By: Claude Opus 5.5 --- js/net/src/ordered.test.ts | 19 ++++- js/net/src/resume.test.ts | 27 ++++++ js/net/src/track.ts | 15 +++- rs/moq-net/src/model/resume.rs | 82 ++++++++++++++++--- rs/moq-net/src/model/track.rs | 44 ++++++---- rs/moq-net/tests/integration/range_anchors.rs | 3 +- 6 files changed, 158 insertions(+), 32 deletions(-) diff --git a/js/net/src/ordered.test.ts b/js/net/src/ordered.test.ts index 55717a51f7..24bc6dc51b 100644 --- a/js/net/src/ordered.test.ts +++ b/js/net/src/ordered.test.ts @@ -6,7 +6,7 @@ import { Manual } from "@moq/clock/test"; import { StreamCode, StreamError } from "./error.ts"; import { hooks, staleHole } from "./internal.ts"; import { manual, settlesWithin, textFrame } from "./mock.ts"; -import { Timestamp } from "./time.ts"; +import { Timescale, Timestamp } from "./time.ts"; import { type Ordered, Producer as TrackProducer } from "./track.ts"; // A session-fed copy owes holes; an in-process producer does not. @@ -465,3 +465,20 @@ test("a time end between received groups ends an ordered read only once the skip producer.skipGroups(1001n, 2000n); expect(await end).toBeUndefined(); }); + +// Mirrors the Rust `an_ordered_read_ended_past_a_stale_group_reports_it_first`. +test("an ordered read whose window ends past a group it passed as stale reports it first", () => + withClock((clock) => { + const producer = new TrackProducer("test").accept({ timescale: Timescale.MILLI }); + const first = producer.createGroup(0n); + first.writeFrame(textFrame("x", Timestamp.fromMillis(0))); + first.finishAt(10n); + clock.jump(Duration.millis(100)); + put(producer, 100n); + const ordered = producer + .subscribe({ delay: { max: Duration.millis(50) }, ranges: [{ start: { time: 0n }, end: { time: 49n } }] }) + .ordered(); + expect(items(ordered)).toEqual(["gap 0..1 (old)"]); + expect(ordered.tryNextItem()).toBeUndefined(); + expect(ordered.tryNextGroup()).toBeUndefined(); + })); diff --git a/js/net/src/resume.test.ts b/js/net/src/resume.test.ts index 2a05361976..d872d71a15 100644 --- a/js/net/src/resume.test.ts +++ b/js/net/src/resume.test.ts @@ -4863,3 +4863,30 @@ test("a time end between two groups ends an ordered read through a front at the handle.close(); source.close(); }); + +// An ordered read through a front that ends past a group its copy gave up, as one missing its head +// with no fill to ask, returns that gap before the end. +test("an ordered read through a front returns the gap its copy gave up before ending", async () => { + const front = new Front(); + const a = new BroadcastProducer(); + const ta = defined(a.createTrack("seq", { maxAge: null })); + const tail = hooks.receiveGroup(ta, { start: 0n, offset: 1 }); + tail.writeFrame({ payload: enc.encode("0.1"), timestamp: Timestamp.unscaled(0n) }); + tail.finish(); + const past = ta.createGroup(2n); + past.writeFrame({ payload: enc.encode("2.0"), timestamp: Timestamp.unscaled(2n) }); + past.finish(); + front.serve(a.consume()); + const ordered = front.consumer + .track("seq") + .subscribe({ delay: { max: null }, ranges: [{ start: { time: 0n }, end: { time: 1n } }] }) + .ordered(); + try { + expect(await ordered.nextItem()).toMatchObject({ kind: "gap", start: 0n, end: 1n }); + expect(await ordered.nextItem()).toBeUndefined(); + } finally { + ordered.close(); + front.consumer.close(); + a.close(); + } +}); diff --git a/js/net/src/track.ts b/js/net/src/track.ts index e3acecda1a..f7e6a76606 100644 --- a/js/net/src/track.ts +++ b/js/net/src/track.ts @@ -5359,6 +5359,17 @@ export class Subscriber { if (window === undefined) return; const cap = this.#cursor.peek().end; const end = cap === undefined ? window : min(cap, window); + // Passing the keys hands them out as far as #delivered knows, so first take what the copies + // gave up there, as a group handed out does. + if (this.#resume) { + for ( + let drop = this.#resume.tryDrop(this.#delivered, end); + drop; + drop = this.#resume.tryDrop(this.#delivered, end) + ) { + this.#queueResumedDrop(drop); + } + } const floor = this.#delivered.runEnd(0n) ?? 0n; this.#delivered.forgetBelow(end); const forgot = this.#delivered.runEnd(0n) ?? 0n; @@ -5863,7 +5874,9 @@ export class Ordered { * {@link withRange}. Like {@link Subscriber.recvGroup}, a read whose ranges all end * finishes once nothing in them is left to deliver; on a local track that includes a key * below a group the producer created, which this read hands out first. Later reads return `undefined` - * immediately too; widening the ranges with {@link update} reads on above the last key returned. + * immediately too; widening the ranges with {@link update} reads on above the end the read + * passed (or the cap, when that was lower), so a group created below that end afterward is + * never handed out. */ nextGroup(): Promise { return ordered_.nextGroup(this.#subscriber); diff --git a/rs/moq-net/src/model/resume.rs b/rs/moq-net/src/model/resume.rs index 4ca5dacea3..16cabc817c 100644 --- a/rs/moq-net/src/model/resume.rs +++ b/rs/moq-net/src/model/resume.rs @@ -1119,11 +1119,16 @@ impl Subscriber { /// deadline. What the reader changes itself (its range, what it handed out) disarms it. /// Another handle's read that follows the route or the preferences first only applies /// a change that already woke this one. + /// + /// An `ordered` read that ends passes every key below its window's end, or its cap below + /// that, in `delivered` for good, as [`track::Cursor::pass_end`] does: a group created + /// there later is late. The end is the one the read ended at, taken under the same lock, + /// so a range widened meanwhile is still read. pub(super) fn poll_peek_group( &mut self, ordered: bool, parks: bool, - delivered: &Delivered, + delivered: &mut Delivered, waiter: &kio::Waiter, ) -> Poll>> { let walk = Walk::new(ordered); @@ -1131,19 +1136,38 @@ impl Subscriber { return Poll::Pending; } let mut idle = Idle::start(&mut self.idle, waiter); - let polled = { + let (polled, passed) = { let waiter = idle.waiter(); let mut reader = self.reader(); // Registered before looking, so a route change from here on wakes the read, // even on a path that parks without looking at the route. reader.route.register(waiter); - loop { + let polled = loop { if let Some(result) = reader.poll_lowest(ordered, parks, delivered, waiter) { break result; } - } + }; + // Below the cap: a read that ran out under a lowered cap, its window or the track + // having ended, still owes what lies above it. + let cap = reader.groups.1; + let window = reader.window(); + let end = window.end().filter(|_| !window.is_pending()); + let passed = match (ordered, &polled, end) { + (true, Poll::Ready(Ok(None)), Some(end)) => { + let end = cap.map_or(end, |cap| cap.min(end)); + let moved = !delivered.covers(0..end); + delivered.forget_below(end); + moved + } + _ => false, + }; + (polled, passed) }; idle.finish(&mut self.idle, walk, polled.is_pending()); + // What it handed out moved, which nothing it parked on notifies. + if passed { + Idle::disarm(&mut self.idle); + } polled } @@ -1390,13 +1414,6 @@ impl Subscriber { reader.declared_error.clone() } - /// The exclusive end of the reader's ranges, once they all end and resolved. - pub(super) fn window_end(&self) -> Option { - let mut reader = self.reader(); - let window = reader.window(); - window.end().filter(|_| !window.is_pending()) - } - /// The local group filter, as [`track::Subscriber::poll_largest`] reports within it. pub(super) fn bounds(&self) -> track::Bounds { let mut reader = self.reader(); @@ -6628,6 +6645,45 @@ mod test { assert_eq!(read(&mut sub), ["group 6"]); } + /// A front's ordered read that ends past a group its copy gave up, as one missing its head + /// with no fill to ask, returns that gap before the end. + #[test] + #[cfg(feature = "async")] + fn a_front_returns_the_gap_its_copy_gave_up_before_ending() { + let routes = Producer::new(); + let logical = logical(&routes); + let a = copy(); + let track::Received::Group(mut rest) = a.create_group_at(group::Info { start: 0 }, 1).unwrap() else { + panic!("nothing else holds the group"); + }; + rest.write_frame(ts(0), b"x".as_ref()).unwrap(); + rest.finish().unwrap(); + write(&a, 2); + routes.serve(a.consume()); + let mut sub = logical + .consume() + .subscribe( + Subscription::default() + .with_delay(Delay::default().with_max(HOUR)) + .with_ranges([track::Range::groups(0..2)]), + ) + .now_or_never() + .unwrap() + .unwrap() + .ordered(); + let waiter = kio::Waiter::noop(); + let mut items = Vec::new(); + let end = loop { + match sub.poll_next_item(&waiter) { + Poll::Ready(Ok(Some(track::Item::Group(group)))) => items.push(format!("group {}", group.start)), + Poll::Ready(Ok(Some(track::Item::Gap { range, .. }))) => items.push(format!("gap {range:?}")), + end => break end, + } + }; + assert_eq!(items, ["gap 0..1"]); + assert!(matches!(end, Poll::Ready(Ok(None))), "the read ends"); + } + /// A front served by another front reports a late arrival on the inner copy too. #[test] fn a_nested_front_reports_a_late_arrival_as_a_gap() { @@ -9397,8 +9453,8 @@ mod test { }; let preferences = track::Preferences::from(ranges(5)); let mut sub = routes.consume().subscribe(preferences.clone()); - let delivered = Delivered::default(); - let Poll::Ready(Ok(Some(candidate))) = sub.poll_peek_group(false, false, &delivered, &kio::Waiter::noop()) + let mut delivered = Delivered::default(); + let Poll::Ready(Ok(Some(candidate))) = sub.poll_peek_group(false, false, &mut delivered, &kio::Waiter::noop()) else { panic!("a group to reserve") }; diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index 483be99994..7fae09d2da 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -10226,8 +10226,9 @@ impl Cursor { /// Pass every key below `end` for good, as an ordered read whose bounded window ran out /// at `end`, or at its cap below that: a group created there later is late, so later reads - /// end at once too. + /// end at once too. The groups it stepped over as stale are given up for good with them. fn pass_end(&mut self, end: u64) { + self.commit_seek_stale(end); self.skip_ordered(end); self.record.delivered.forget_below(end); } @@ -10760,20 +10761,7 @@ impl Subscriber { polled } Inner::Resume(resume, logical) => { - let polled = resume.poll_peek_group(ordered, self.parks, &logical.record.delivered, waiter); - // As a plain cursor's [`Cursor::pass_end`], below the cap: a read that ran out under - // a lowered cap, its window or the track having ended, still owes what lies above it. - if ordered - && matches!(polled, Poll::Ready(Ok(None))) - && let Some(end) = resume.window_end() - { - let end = resume.bounds().end.map_or(end, |cap| cap.min(end)); - if !logical.record.delivered.covers(0..end) { - // What it handed out moved, which nothing it parked on notifies. - resume.disarm(); - logical.record.delivered.forget_below(end); - } - } + let polled = resume.poll_peek_group(ordered, self.parks, &mut logical.record.delivered, waiter); polled.map(|res| res.map(|candidate| candidate.map(|candidate| Reserved::Resume(Box::new(candidate))))) } } @@ -11975,7 +11963,8 @@ impl Ordered { /// accounted for, as for [`Subscriber::poll_recv_group`]. On a locally produced track that /// includes a key below a group the producer created, which this read hands out first. /// Later reads return `Ok(None)` immediately too; widening the ranges with - /// [`Self::update`] resumes reading above the last key returned. + /// [`Self::update`] resumes reading above the end the read passed (or the cap, when that + /// was lower), so a group created below that end afterward is never handed out. /// /// Returns `Ok(Some(item))` when a group or gap is available, `Ok(None)` when the track is /// finished (including an abort after its declared end settled, see [`Producer::abort`]) @@ -21082,6 +21071,29 @@ mod test { assert_eq!(items(&mut ordered), ["gap 0..1 (old)", "group 1", "group 2", "pending"]); } + /// An ordered read whose bounded window runs out past a group it stepped over as stale + /// reports that gap before its end, and counts it: passing the end gives the group up. + #[test] + #[cfg(feature = "async")] + fn an_ordered_read_ended_past_a_stale_group_reports_it_first() { + let producer = track_producer("test", Info::timed()); + elapse(&producer, Duration::ZERO); + let mut group = producer.create_group(group::Info { start: 0 }).unwrap(); + group.write_frame(Timestamp::ZERO, &b"x"[..]).unwrap(); + group.finish_at(10).unwrap(); + elapse(&producer, Duration::from_millis(100)); + put(&producer, 100, Some(100)); + let mut ordered = producer + .subscribe( + Subscription::default() + .with_delay(Delay::default().with_max(Duration::from_millis(50))) + .with_ranges([Range::groups(0..50)]), + ) + .ordered(); + assert_eq!(items(&mut ordered), ["gap 0..1 (old)"]); + assert!(matches!(ordered.next_item().now_or_never(), Some(Ok(None)))); + } + /// A final drop replaces the part of a stale gap it covers while that gap still waits, so /// the buffered gaps never overlap: the stale run keeps what lies either side of it. #[test] diff --git a/rs/moq-net/tests/integration/range_anchors.rs b/rs/moq-net/tests/integration/range_anchors.rs index 9be6886e5e..f09acd7f88 100644 --- a/rs/moq-net/tests/integration/range_anchors.rs +++ b/rs/moq-net/tests/integration/range_anchors.rs @@ -153,7 +153,8 @@ async fn read_as(version: Option<&str>, range: Range, how: Read) -> Result kio::clock::timeout(TIMEOUT, arrival.recv_group()).await, _ => unreachable!(), }; - if let Ok(Ok(Some(group))) = next { + // An error or a wait fails the test; a group handed out shows in the groups read. + if let Some(group) = next.expect("an ended read answers at once")? { read.groups.push(group.start); } }