fix(net)!: ranges refuse what the wire drops

dart/moq/lib/src/durations.dart

@@ -35,8 +35,9 @@ extension BackoffDuration on MoqBackoff {
 
 /// Duration views over the subscription knobs.
 extension SubscriptionDuration on MoqSubscription {
-  /// Upper bound on buffering before a stalled group is skipped.
-  Duration get maxDelay => Duration(microseconds: maxDelayUs);
+  /// Upper bound on buffering before a stalled group is skipped, or null for the default.
+  Duration? get maxDelay =>
+      maxDelayUs == null ? null : Duration(microseconds: maxDelayUs!);
 }
 
 /// Duration views over the publisher-side track settings.

dart/moq_ffi/lib/src/moq.dart

@@ -767,12 +767,12 @@ class FfiConverterMoqRange {
 
 class MoqSubscription {
   final int priority;
-  final int maxDelayUs;
+  final int? maxDelayUs;
   final List<MoqRange>? ranges;
   final MoqOrder? order;
   MoqSubscription({
     this.priority = 0,
-    this.maxDelayUs = 0,
+    this.maxDelayUs = null,
     this.ranges = null,
     this.order = null,
   });
@@ -790,7 +790,7 @@ class FfiConverterMoqSubscription {
     );
     final priority = priority_lifted.value;
     new_offset += priority_lifted.bytesRead;
-    final maxDelayUs_lifted = FfiConverterUInt64.read(
+    final maxDelayUs_lifted = FfiConverterOptionalUInt64.read(
       Uint8List.view(buf.buffer, new_offset),
     );
     final maxDelayUs = maxDelayUs_lifted.value;
@@ -819,7 +819,7 @@ class FfiConverterMoqSubscription {
   static RustBuffer lower(MoqSubscription value) {
     final total_length =
         FfiConverterInt8.allocationSize(value.priority) +
-        FfiConverterUInt64.allocationSize(value.maxDelayUs) +
+        FfiConverterOptionalUInt64.allocationSize(value.maxDelayUs) +
         FfiConverterOptionalSequenceMoqRange.allocationSize(value.ranges) +
         FfiConverterOptionalMoqOrder.allocationSize(value.order) +
         0;
@@ -834,7 +834,7 @@ class FfiConverterMoqSubscription {
       value.priority,
       Uint8List.view(buf.buffer, new_offset),
     );
-    new_offset += FfiConverterUInt64.write(
+    new_offset += FfiConverterOptionalUInt64.write(
       value.maxDelayUs,
       Uint8List.view(buf.buffer, new_offset),
     );
@@ -851,7 +851,7 @@ class FfiConverterMoqSubscription {
 
   static int allocationSize(MoqSubscription value) {
     return FfiConverterInt8.allocationSize(value.priority) +
-        FfiConverterUInt64.allocationSize(value.maxDelayUs) +
+        FfiConverterOptionalUInt64.allocationSize(value.maxDelayUs) +
         FfiConverterOptionalSequenceMoqRange.allocationSize(value.ranges) +
         FfiConverterOptionalMoqOrder.allocationSize(value.order) +
         0;

doc/concept/moq-lite.md

@@ -256,9 +256,12 @@ own ranges cover, resolved again whenever it replaces them, even when another
 subscriber of the same track asked for more. Widening them, including lowering
 the start, also serves the cached groups they newly cover, never one already
 served. A relay merges its subscribers' ranges into one upstream request, which
-today's wire versions carry as the single span covering them. A time anchor is
-resolved from the groups the serving hop holds; upstream it asks for everything
-max delay allows, and an untimed track refuses it. At the live edge, a time end
+today's wire versions carry as the single span covering them. A relative or time
+anchor resolves on the hop that publishes the track, and over moq-lite-07, which
+reports the live edge and media time and asks upstream for every group the budget
+allows. Over an older lite or any moq-transport version, a subscriber gets every
+anchor but the live and default starts refused as unsupported, and an untimed
+track refuses a time anchor. At the live edge, a time end
 may let one group through before its first frame shows it starts past the end:
 the first group that has yet to start is handed out without waiting for that
 frame, and the next one waits on it. A datagram is judged by its own timestamp.

go/wrapper/moq_test.go

@@ -830,8 +830,9 @@ func TestAscendingSubscriptionReadsCachedBacklogOldestFirst(t *testing.T) {
 	}
 
 	order := moq.OrderAscending
+	maxDelay := 10 * time.Second
 	consumer, err := track.Consume(&moq.Subscription{
-		MaxDelay: 10 * time.Second,
+		MaxDelay: &maxDelay,
 		Ranges:   []moq.Range{{Start: moq.AnchorRelative{Groups: 2}}},
 		Order:    &order,
 	})

go/wrapper/records.go

@@ -58,19 +58,19 @@ func datagramFromFFI(d *ffi.MoqDatagram) *Datagram {
 }
 
 // Subscription holds subscriber-side delivery preferences: priority, the max delay
-// a non-latest group may fall behind before it is skipped (zero skips at once, and it
-// caps every range), the ranges of the track to deliver (nil for everything MaxDelay
+// a non-latest group may fall behind before it is skipped (nil for moq-net's default of
+// zero, which skips at once; it caps every range), the ranges of the track to deliver (nil for everything MaxDelay
 // still allows, while an empty non-nil slice asks for nothing), and the order the
 // publisher sends pending groups in (nil for newest first).
 type Subscription struct {
 	Priority int8
-	MaxDelay time.Duration
+	MaxDelay *time.Duration
 	Ranges   []Range
 	Order    *Order
 }
 
 func (s Subscription) ffi() (ffi.MoqSubscription, error) {
-	maxDelay, err := bridge.Duration(s.MaxDelay, "max delay")
+	maxDelay, err := bridge.OptionalDuration(s.MaxDelay, "max delay")
 	var ranges *[]ffi.MoqRange
 	if s.Ranges != nil {
 		ranges = &s.Ranges

kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/Durations.kt

@@ -53,9 +53,9 @@ val QuicConfig.idleTimeout: Duration?
 val QuicConfig.keepAlive: Duration?
     get() = keepAliveUs?.toLong()?.microseconds
 
-/** Upper bound on buffering before a stalled group is skipped. */
-val Subscription.maxDelay: Duration
-    get() = maxDelayUs.toLong().microseconds
+/** Upper bound on buffering before a stalled group is skipped, or null for the default. */
+val Subscription.maxDelay: Duration?
+    get() = maxDelayUs?.toLong()?.microseconds
 
 /** Maximum age of a non-latest group before the publisher evicts it, or null for the default. */
 val TrackInfo.maxAge: Duration?

py/moq-rs/moq/_records.py

@@ -94,21 +94,22 @@ class Subscription:
     """Subscriber-side delivery preferences, mirroring moq-net's ``track::Subscription``.
 
     ``priority`` is in ``-128..=127``, higher first, and defaults to 0, the midpoint.
-    ``max_delay`` is how far a non-latest group may fall behind before it is skipped;
-    zero skips at once, and it caps every range. ``ranges`` are the spans of the track to
-    deliver, ``None`` for everything ``max_delay`` still allows. ``order`` is which pending
-    group the publisher sends first, ``None`` for newest first.
+    ``max_delay`` is how far a non-latest group may fall behind before it is skipped,
+    ``None`` for moq-net's default of zero, which skips at once; it caps every range.
+    ``ranges`` are the spans of the track to deliver, ``None`` for everything ``max_delay``
+    still allows. ``order`` is which pending group the publisher sends first, ``None`` for
+    newest first.
     """
 
     priority: int = 0
-    max_delay: timedelta = timedelta(0)
+    max_delay: timedelta | None = None
     ranges: Sequence[MoqRange] | None = None
     order: MoqOrder | None = None
 
     def _ffi(self) -> MoqSubscription:
         return MoqSubscription(
             priority=self.priority,
-            max_delay_us=_to_us(self.max_delay, "max_delay"),
+            max_delay_us=_opt_us(self.max_delay, "max_delay"),
             ranges=None if self.ranges is None else list(self.ranges),
             order=self.order,
         )

quest/m1/api-audit/README.md

@@ -73,7 +73,6 @@ Rejected in planning:
 - [Container formats name inputs](/quest/m1/api-audit/container-format.md) - `ContainerFormat` names what is parsed, never how it is packaged; `ContainerStream` and TS passthrough internals are gone
 - [moq-net exports with a consumer](/quest/m1/api-audit/net-exports.md) - Rust and JS model exports without a consumer go private, wrong ones are deleted, and JS names mirror Rust
 - [One clean close](/quest/m1/api-audit/clean-close.md) - a clean session close has one spelling and failures are recorded inside moq-net
-- [Ranges refuse what the wire drops](/quest/m1/api-audit/ranges-wire.md) - relative and time anchors fail loud where a wire cannot carry them, `floor()` honors the subscription, and bindings take an optional max delay
 - [Derived origins borrow](/quest/m1/api-audit/derived-origin-close.md) - closing a JS `scope()` or `withPreference()` handle releases only that handle
 - [Wrapper config names](/quest/m1/api-audit/wrapper-config.md) - Python, Go, and Dart client options use the FFI's names and nesting
 - [Bindings read gaps and ends](/quest/m1/api-audit/decode-read-bindings.md) - moq-ffi and every wrapper surface `Gap` and `End` instead of discarding them

quest/m1/subscribe-ranges/lite.md

@@ -35,6 +35,14 @@ that is the Largest Object's group, so a newest group with no objects yet is
 not counted until its first object arrives; the relay reports what it has
 rather than waiting for the peer.
 
+Today a track copy received over lite-06 or earlier, or any moq-transport
+draft, refuses relative and time anchors with `Unsupported`, while a lite-07
+copy resolves them locally (it learns the largest and media time and asks for
+everything the budget allows; `lite::Version::resolves_anchors`). Each mapping
+above that makes an older wire carry an anchor lifts that wire's refusal for
+that anchor only, and extends the per-wire table in
+`rs/moq-net/tests/integration/range_anchors.rs`.
+
 Test the lite-05 relay case #5000 left out, on mock time beside
 `rs/moq-net/tests/integration/late_lower_group.rs`: a live subscriber already reading
 group 1, then one from `Absolute(0)`, and a fresh group 0 reaches only the

rs/moq-c/src/api.rs

@@ -591,6 +591,8 @@ pub struct moq_subscription {
 	/// Zero skips immediately. Enforced by the publisher's cache and by any local buffering.
 	/// It caps every range.
 	pub max_delay_us: u64,
+	/// Whether `max_delay_us` is set. When false, moq-net's default applies: zero.
+	pub max_delay_present: bool,
 
 	/// The spans of the track to deliver, or NULL for everything `max_delay_us` still
 	/// considers fresh. A non-NULL pointer with `ranges_len` 0 asks for nothing.
@@ -687,8 +689,10 @@ pub(crate) unsafe fn parse_subscription(
 	};
 	let mut out = moq_net::track::Subscription::default()
 		.with_priority(subscription.priority)
-		.with_max_delay(std::time::Duration::from_micros(subscription.max_delay_us))
 		.with_order(order);
+	if subscription.max_delay_present {
+		out = out.with_max_delay(std::time::Duration::from_micros(subscription.max_delay_us));
+	}
 	if !subscription.ranges.is_null() {
 		let ranges = unsafe { std::slice::from_raw_parts(subscription.ranges, subscription.ranges_len) };
 		let ranges = ranges

rs/moq-c/src/test.rs

@@ -1486,6 +1486,7 @@ fn publish_track_invalid_broadcast() {
 	let subscription = moq_subscription {
 		priority: 1,
 		max_delay_us: 0,
+		max_delay_present: false,
 		ranges: std::ptr::null(),
 		ranges_len: 0,
 		order: 0,
@@ -1595,6 +1596,7 @@ fn raw_track_publish_consume() {
 	let subscription = moq_subscription {
 		priority: 0,
 		max_delay_us: 1_000_000,
+		max_delay_present: true,
 		ranges: std::ptr::null(),
 		ranges_len: 0,
 		order: 0,
@@ -1817,6 +1819,7 @@ fn raw_track_subscription_options_and_update() {
 	let subscription = moq_subscription {
 		priority: 5,
 		max_delay_us: 25_000,
+		max_delay_present: true,
 		ranges: ranges.as_ptr(),
 		ranges_len: ranges.len(),
 		order: 0,
@@ -1931,6 +1934,7 @@ fn raw_track_time_anchor() {
 	let subscription = moq_subscription {
 		priority: 5,
 		max_delay_us: 1_000_000,
+		max_delay_present: true,
 		ranges: ranges.as_ptr(),
 		ranges_len: ranges.len(),
 		order: 0,
@@ -2031,6 +2035,7 @@ fn raw_track_update_refuses_time_on_untimed() {
 	let update = moq_subscription {
 		priority: 3,
 		max_delay_us: 1_000_000,
+		max_delay_present: true,
 		ranges: ranges.as_ptr(),
 		ranges_len: ranges.len(),
 		order: 0,
@@ -2089,6 +2094,7 @@ fn raw_track_relative_update_counts_from_the_track_edge() {
 	let subscribe = |ranges: &[moq_range]| moq_subscription {
 		priority: 0,
 		max_delay_us: 60_000_000,
+		max_delay_present: true,
 		ranges: ranges.as_ptr(),
 		ranges_len: ranges.len(),
 		order: 0,
@@ -2359,6 +2365,7 @@ fn publish_finish_serves_finished_tracks_until_closed() {
 	let subscription = moq_subscription {
 		priority: 0,
 		max_delay_us: 0,
+		max_delay_present: false,
 		ranges: std::ptr::null(),
 		ranges_len: 0,
 		order: 0,
@@ -5875,6 +5882,7 @@ fn read_raw_frames(consume: u32, name: &[u8], count: usize) -> Vec<Vec<u8>> {
 	let subscription = moq_subscription {
 		priority: 0,
 		max_delay_us: 1_000_000,
+		max_delay_present: true,
 		ranges: std::ptr::null(),
 		ranges_len: 0,
 		order: 0,

rs/moq-ffi/src/consumer.rs

@@ -31,13 +31,14 @@ pub struct MoqSubscription {
 	/// The default 0 is the midpoint.
 	#[uniffi(default = 0)]
 	pub priority: i8,
-	/// Maximum age of a non-latest group before it is skipped, in microseconds.
-	/// `0` skips immediately; a larger value tolerates that much reordering.
+	/// Maximum age of a non-latest group before it is skipped, in microseconds, or null
+	/// for moq-net's default: `0`, which skips immediately. A larger value tolerates that
+	/// much reordering.
 	///
 	/// Enforced both by the publisher's cache (sent on the wire) and by any local
 	/// buffering, such as [`MoqMediaTrackConsumer`]'s jitter buffer. It caps every range.
-	#[uniffi(default = 0)]
-	pub max_delay_us: u64,
+	#[uniffi(default = None)]
+	pub max_delay_us: Option<u64>,
 	/// The spans of the track to deliver, or null for everything `max_delay_us` still
 	/// considers fresh. An empty list asks for nothing.
 	///
@@ -155,9 +156,10 @@ impl TryFrom<MoqSubscription> for moq_net::track::Subscription {
 	type Error = MoqError;
 
 	fn try_from(s: MoqSubscription) -> Result<Self, MoqError> {
-		let mut subscription = moq_net::track::Subscription::default()
-			.with_priority(s.priority)
-			.with_max_delay(std::time::Duration::from_micros(s.max_delay_us));
+		let mut subscription = moq_net::track::Subscription::default().with_priority(s.priority);
+		if let Some(max_delay) = s.max_delay_us {
+			subscription = subscription.with_max_delay(std::time::Duration::from_micros(max_delay));
+		}
 		if let Some(ranges) = s.ranges {
 			subscription = subscription.with_ranges(
 				ranges

rs/moq-ffi/src/test.rs

@@ -1098,7 +1098,7 @@ async fn raw_track_update_does_not_wait_for_pending_read() {
 	consumer
 		.update(MoqSubscription {
 			priority: 10,
-			max_delay_us: 25_000,
+			max_delay_us: Some(25_000),
 			ranges: Some(vec![MoqRange {
 				start: MoqAnchor::Absolute { group: 0, frame: 0 },
 				end: None,
@@ -4648,7 +4648,7 @@ async fn raw_track_update_during_pending_group_still_reads_datagram() {
 	consumer
 		.update(MoqSubscription {
 			priority: 10,
-			max_delay_us: 25_000,
+			max_delay_us: Some(25_000),
 			ranges: Some(vec![MoqRange {
 				start: MoqAnchor::Absolute { group: 0, frame: 0 },
 				end: None,
@@ -7543,7 +7543,7 @@ async fn ascending_subscription_reads_a_cached_backlog_oldest_first() {
 
 	let subscription = MoqSubscription {
 		priority: 0,
-		max_delay_us: 10_000_000,
+		max_delay_us: Some(10_000_000),
 		ranges: Some(vec![MoqRange {
 			start: MoqAnchor::Relative { groups: 2 },
 			end: None,
@@ -7782,7 +7782,7 @@ async fn time_anchors_start_at_the_containing_group() {
 
 	let since = |timestamp_us| MoqSubscription {
 		priority: 0,
-		max_delay_us: 10_000_000,
+		max_delay_us: Some(10_000_000),
 		ranges: Some(vec![MoqRange {
 			start: MoqAnchor::Time { timestamp_us },
 			end: None,

rs/moq-net/src/error.rs

@@ -439,7 +439,7 @@ pub enum Error {
 	#[error("unexpected message")]
 	UnexpectedMessage,
 
-	/// The peer asked for a feature this endpoint does not implement.
+	/// A feature was asked for that this endpoint, or the wire to the peer, does not implement.
 	#[error("unsupported")]
 	Unsupported,
 

rs/moq-net/src/ietf/subscriber.rs

@@ -4215,8 +4215,10 @@ impl Subscriber {
 		let dynamic = request.dynamic();
 		// Nothing feeds this copy live: what it caches is fetched, never the live edge. Idle
 		// from the accept, so no reader takes it as live in between.
-		let track = request.idle().accept(accepted_info(&ok.properties, self.version));
+		let track = request.idle().stage(accepted_info(&ok.properties, self.version));
+		// Marked received before any reader sees it, so none resolves an anchor this wire dropped.
 		track.received();
+		let track = track.commit();
 		Some(Idle {
 			demand: track.demand(),
 			track,

rs/moq-net/src/lite/subscriber.rs

@@ -7178,8 +7178,13 @@ impl ServeLoop {
 			true => request.request_start(None),
 			false => request,
 		};
-		let serving = request.accept(info);
+		// Marked received before any reader sees it, so none resolves an anchor this wire dropped.
+		let serving = request.stage(info);
 		serving.received();
+		if serve.subscriber.version.resolves_anchors() {
+			serving.anchored();
+		}
+		let serving = serving.commit();
 		Self {
 			edge: serving.consume(),
 			largest: None,