fix(net): pass lite-05/06 timestamps through

doc/concept/moq-lite.md

@@ -349,13 +349,13 @@ frames go out stamped with their send time; the work-in-progress 07 carries it
 untimed.
 
 A publisher refuses a group that starts before a lower one, and so does a
-moq-lite 07 receiver. Since moq-lite 05 and 06 send times look like media time,
-a receiver drops every timestamp it gets over them and the track arrives
-untimed.
-Timestamps received over moq-transport, whose peers may stamp arrival times,
-are not checked. Rust relays preserve them across moq-lite 07 when both peers
-negotiate the [ietf extension](/draft/moq-ietf), which carries their origin and
-keeps them unchecked. A moq-lite peer without it receives that track untimed.
+moq-lite 07 receiver. A receiver passes on the timestamps it gets over moq-lite
+05 and 06 without checking them, since their send times look like media time and
+an older group fetched later would look like a rewind. Timestamps received over
+moq-transport, whose peers may stamp arrival times, are not checked either. A
+relay serves both on over every version. Over moq-lite 07 the
+[ietf extension](/draft/moq-ietf) keeps moq-transport ones unchecked; without
+it, the receiver checks them and may refuse a group that rewinds.
 
 A publisher may [compress](/concept/compression) a track, which pays off for
 repetitive data such as JSON and not for media. Each group's frames become one

doc/setup/upgrade.md

@@ -83,10 +83,8 @@ These land with the next breaking release.
   receive.** Tracks from moq-lite before 05, and moq-transport tracks without
   `TIMESCALE` arrive untimed instead of
   stamped with their arrival time. moq-lite 05 and 06 can't encode absence and
-  carry a send time instead, so their receivers drop every timestamp and those
-  tracks arrive untimed too: read media time from the payload. moq-transport
-  timestamps are served to moq-lite untimed; see
-  [untimed tracks](/concept/moq-lite#subscriptions). A new subscriber with no
+  carry a send time instead, which their receivers pass through as the track's
+  time; see [untimed tracks](/concept/moq-lite#subscriptions). A new subscriber with no
   start on an untimed track starts at the latest group.
 - **Max age and max delay count wall-clock time too.** A superseded group is
   stale once its successor arrived a full budget ago, as well as by media

drafts/draft-lcurley-moq-ietf.md

@@ -143,10 +143,10 @@ The Version also gives each property its meaning: drafts 18 and 19 serialize a b
 Other properties are opaque to this extension.
 
 ## Timestamps {#timestamps}
-A relay MUST preserve a relayed track's Timescale and timestamps across a negotiated hop, except in a listing ({{track}}).
+A relay MUST preserve a relayed track's Timescale and timestamps across a negotiated hop.
 A nonzero Version identifies timestamps from MoQ Transport, which may be arrival times and need not rise with Group Sequence.
 The receiver MUST NOT apply moq-lite's group-start rewind check to such a track; a Version of zero retains that check.
-Without this extension, a relay MUST serve a MoQ Transport track untimed as {{moql}} requires.
+Without this extension, or in a listing ({{track}}), the receiver may check them like native moq-lite timestamps and refuse a Group that rewinds.
 
 On a timed track, the FRAME's Timestamp, or the datagram's for a datagram, is the object's time, and nothing else carries it.
 The Property Block MUST NOT contain a mutable Timestamp (0x10) there; a receiver MUST treat one as malformed.
@@ -199,7 +199,7 @@ The receiver parses the keys inside the Immutable Properties from its value, whi
 It SHOULD read them from the value when needed rather than hold them beside it, as a list of IDs can cost several times the value.
 
 A TRACKS_ADD ({{moql}} Tracks Stream) embeds TRACK_INFO without TRACK_PROPERTIES, so when the extension is negotiated a subscriber MUST NOT skip the Track Stream for a track it learned from a listing.
-Lacking the Version, a TRACKS_ADD cannot mark a {{moqt}} track's timestamps as unchecked ({{timestamps}}), so it lists that track untimed even when the extension is negotiated.
+Lacking the Version, a TRACKS_ADD cannot mark a {{moqt}} track's timestamps as unchecked ({{timestamps}}).
 
 
 # Datagrams {#datagrams}
@@ -264,7 +264,7 @@ A high, distinctive value is used to avoid collisions with the low values {{moql
 
 ## Since draft-lcurley-moq-ietf-00 (in progress)
 
-- Preserve relayed track timestamps and their unchecked MoQ Transport provenance across negotiated hops.
+- Preserve relayed track timestamps and their unchecked MoQ Transport provenance across negotiated hops. Without the extension a relay serves them as native moq-lite timestamps rather than untimed.
 - Initial version.
 
 # Acknowledgments

drafts/draft-lcurley-moq-lite.md

@@ -190,7 +190,7 @@ A Track without a `Timescale` is untimed: its frames and datagrams carry no time
 A timestamp MUST be less than 2^61, so every version can carry it; a receiver treats a larger one as a malformed Track.
 Unless a negotiated extension specifies otherwise, a publisher MUST NOT start a timed Group's frame 0 earlier than that of any lower-sequence Group it publishes.
 A receiver MAY check a received Group against this rule, refusing a violating Group's stream (STOP_SENDING) with TIMESTAMP_MISMATCH.
-A relay that cannot vouch for a Track's timestamps, such as ones received over another protocol, MUST serve the Track untimed unless a negotiated extension identifies their unchecked provenance.
+A relay serves a Track's timestamps on as it received them, including ones it did not check, unless a negotiated extension specifies otherwise.
 
 ## Positions {#positions}
 A Position is a (Group Sequence, Frame Index) pair identifying one frame within a Track.
@@ -1832,7 +1832,7 @@ The `Message Length` describes the payload size on the wire.
 
 - Replaced ANNOUNCE_OK Active Count with an ordered, empty SYNCED event (0x4), marking the initial set without retaining routes that end before delivery.
 
-- A publisher must not start a timed Group's frame 0 earlier than a lower-sequence Group's, and a receiver may refuse a Group that does. A relay serves a Track whose timestamps it cannot vouch for untimed unless a negotiated extension identifies their unchecked provenance.
+- A publisher must not start a timed Group's frame 0 earlier than a lower-sequence Group's, and a receiver may refuse a Group that does. A relay serves every Track's timestamps on as received.
 
 - Bounded every timestamp below 2^61. A larger one is a malformed Track.
 

js/e2ee/src/transport.test.ts

@@ -48,10 +48,10 @@ async function active(origin: Origin.Producer, path: Path.Valid): Promise<Broadc
 }
 
 // Whether the wire carries the route's epoch, and the track's timestamps. Neither is
-// authenticated, so the frames open either way. A lite-05 receiver drops timestamps.
+// authenticated, so the frames open either way.
 const transports = [
 	["moq-lite-07", "moq-lite-07-wip", true, true],
-	["moq-lite-05", "moq-lite-05", false, false],
+	["moq-lite-05", "moq-lite-05", false, true],
 	["moq-transport-18", "moqt-18", true, true],
 ] as const;
 

js/net/MIGRATE.md

@@ -152,8 +152,8 @@ A new group or datagram raises it at frame 0 before any frame lands, and it can
 
 A local write whose first frame starts before a lower-sequence group's, or after a higher one's, throws `TimestampMismatch`.
 A group received over moq-lite-07 is checked the same way.
-A track received over moq-lite-05/06 arrives untimed, since its timestamps may be send times: read times from the payload, such as the hang container's, instead of the frame's `timestamp`.
-One received over moq-transport keeps its timestamps unchecked, and a relay serves it to moq-lite untimed.
+A track received over moq-lite-05/06 keeps its timestamps unchecked, since they may be an untimed origin's send times, and so does one received over moq-transport.
+A relay serves both on over every version, where a moq-lite-07 receiver checks them and may refuse a group that rewinds.
 A publisher whose timeline restarts publishes a new broadcast instead.
 
 ### `Auth.Auth` is `Auth.Handle`, and `Auth.Token` is `Auth.Auth` (#5695)

js/net/src/lite/group.ts

@@ -81,14 +81,12 @@ export interface WireFrame extends netGroup.Frame {
 export interface FrameFormat {
 	/** The wire timescale; non-zero means every frame carries a zigzag-delta timestamp. */
 	scale: number;
-	/** Whether a carried timestamp is kept; false drops it where it may be a send time. */
-	timed?: boolean;
 	/** Whether every frame declares its plain size ahead of a stored slice. */
 	compress?: boolean;
 }
 
 /** Decode one frame, with timestamp deltas when scaled and declared plain sizes when compressed. */
-export function frameDecoder({ scale, timed = true, compress = false }: FrameFormat): (c: Cursor) => WireFrame {
+export function frameDecoder({ scale, compress = false }: FrameFormat): (c: Cursor) => WireFrame {
 	const timescale = scale === 0 ? undefined : Time.Timescale(scale);
 	let prevTs = 0n;
 	return (c) => {
@@ -100,8 +98,7 @@ export function frameDecoder({ scale, timed = true, compress = false }: FrameFor
 		const payload = c.read(size);
 		// Commit the delta only after the last read: an incomplete decode gets retried.
 		prevTs += delta;
-		// Read to stay in step, but dropped where it may be a send time.
-		const timestamp = timescale === undefined || !timed ? undefined : new Time.Timestamp(Number(prevTs), timescale);
+		const timestamp = timescale === undefined ? undefined : new Time.Timestamp(Number(prevTs), timescale);
 		return { payload, inflated, timestamp };
 	};
 }

js/net/src/lite/publisher.test.ts

@@ -6,7 +6,6 @@ import { Producer as BroadcastProducer } from "../broadcast.ts";
 import { fromTransport, SessionCode, StreamCode, StreamError, toStreamCode } from "../error.ts";
 import type { Producer as GroupProducer } from "../group.ts";
 import { randomHop } from "../hop.ts";
-import { Version as IetfVersion } from "../ietf/version.ts";
 import { hooks } from "../internal.ts";
 import { createMockTransportPair, textFrame } from "../mock.ts";
 import { Producer as OriginProducer } from "../origin.ts";
@@ -599,15 +598,15 @@ test.each([0, 5, 6, 7])("a fetched cached tail keeps absolute indices from %s",
 	}
 });
 
-// An unchecked track goes out untimed, so lite-06 carries its send time, never the frame's own
-// timestamp, which may be a moq-transport arrival time.
-test("lite draft-06: an unchecked track's fetched frames carry their send time", async () => {
+// An unchecked track's frames go out with their own timestamps, which may be moq-transport
+// arrival times, rather than their send time.
+test("lite draft-06: an unchecked track's fetched frames carry their own timestamp", async () => {
 	const pair = createMockTransportPair(ALPN_06);
 	const origin = new OriginProducer();
 	const publisher = new Publisher(pair.server, Version.DRAFT_06, randomHop(), origin.consume());
 
 	const broadcast = publish(origin, Path.from("test"));
-	const track = broadcast.createTrack("video", { timescale: Timescale.MICRO, ietf: IetfVersion.DRAFT_22 });
+	const track = broadcast.createTrack("video", { timescale: Timescale.MICRO, unchecked: true });
 
 	const group = track.createGroup(0);
 	group.writeFrame(textFrame("hello", Timestamp.fromMillis(36_000_000)));
@@ -619,14 +618,10 @@ test("lite draft-06: an unchecked track's fetched frames carry their send time",
 
 	const msg = new Fetch({ broadcast: Path.from("test"), track: "video", priority: 0, group: 0 });
 	try {
-		const before = Math.floor(Timestamp.now().value);
 		await publisher.runFetch(msg, server);
-		const after = Math.ceil(Timestamp.now().value);
 
-		// The first frame's zigzag delta is against 0, in the milliseconds TRACK_INFO declares.
-		const sent = Number((await client.reader.u62()) >> 1n);
-		expect(sent).toBeGreaterThanOrEqual(before);
-		expect(sent).toBeLessThanOrEqual(after);
+		// The first frame's zigzag delta is against 0, in the microseconds TRACK_INFO declares.
+		expect(await client.reader.u62()).toBe(36_000_000_000n << 1n);
 	} finally {
 		publisher.close();
 		client.close();

js/net/src/lite/publisher.ts

@@ -97,17 +97,12 @@ interface Stamp {
 	timescale: Timescale;
 	/**
 	 * Whether each frame's own timestamp goes out. Lite-05/06 cannot encode an untimed track, so
-	 * one served untimed carries its send time instead, unchecked ones included.
+	 * an untimed one carries its send time instead.
 	 */
 	timed: boolean;
 }
 
-/** The timescale a moq-lite hop serves a track at: none for an {@link track.Info.ietf} one. */
-function liteTimescale(info: track.Info): Timescale | undefined {
-	return info.ietf === undefined ? (info.timescale ?? undefined) : undefined;
-}
-
-/** How `version` stamps a track served at `timescale` (see `liteTimescale`), or undefined when it carries none. */
+/** How `version` stamps a track with `timescale`, or undefined when it carries none. */
 function stamping(version: Version, timescale: Timescale | undefined): Stamp | undefined {
 	const wire = wireTimescale(version, timescale);
 	return wire === undefined ? undefined : { timescale: wire, timed: timescale !== undefined };
@@ -134,9 +129,8 @@ function trackInfoMessage(info: track.Info, version: Version): TrackInfoMessage
 		// Publisher Max Age: the publisher's retention bound, advertised so relays re-serve
 		// with the same window.
 		maxAge: info.maxAge,
-		// `#serveGroup` emits each frame converted to it. Unchecked timestamps never enter
-		// moq-lite, whose receivers check them.
-		timescale: liteTimescale(info),
+		// `#serveGroup` emits each frame converted to it.
+		timescale: info.timescale ?? undefined,
 		// An older peer is served the frames inflated.
 		compress: hasCompression(version) && !!info.compress,
 	});
@@ -943,7 +937,7 @@ export class Publisher {
 				// The timescale is an immutable property, so serving MUST use exactly
 				// what TRACK_INFO advertised. It comes from the producer's accept(), so
 				// they always agree.
-				stamp = stamping(this.version, liteTimescale(info));
+				stamp = stamping(this.version, info.timescale ?? undefined);
 				compress = hasCompression(this.version) && !!info.compress;
 			} else {
 				// Older drafts acknowledge with SUBSCRIBE_OK and stream frames verbatim.

js/net/src/lite/subscriber.test.ts

@@ -22,6 +22,7 @@ import { hooks } from "../internal.ts";
 import { GRACE } from "../ledger.ts";
 import * as Path from "../path.ts";
 import { Reader, Writer } from "../stream.ts";
+import { Timescale } from "../time.ts";
 import type { Producer } from "../track.ts";
 import { type AnnounceBroadcast, AnnounceInit, AnnounceOk, encodeAnnounceBroadcast } from "./announce.ts";
 import { Datagram as DatagramMessage } from "./datagram.ts";
@@ -2259,9 +2260,9 @@ async function groupStream(timestamp: number, version: Version = Version.DRAFT_0
 }
 
 // Lite-05/06 stamp an untimed track's frames with their send time, which a receiver cannot tell
-// from media time, so it drops every timestamp there: a group that rewinds or lands out of order is
-// accepted untimed.
-test.each([Version.DRAFT_05, Version.DRAFT_06])("version %p drops received timestamps", async (version) => {
+// from media time, so it keeps every timestamp there unchecked: a group that rewinds or lands out
+// of order is accepted with its timestamp.
+test.each([Version.DRAFT_05, Version.DRAFT_06])("version %p passes received timestamps through", async (version) => {
 	const { quic, streams, opened } = fakeSession();
 	const subscriber = new Subscriber(quic, version, HopSchema.parse(1n));
 	const broadcast = subscriber.consume(Path.from("room"));
@@ -2280,14 +2281,14 @@ test.each([Version.DRAFT_05, Version.DRAFT_06])("version %p drops received times
 		for (let i = 0; i < 3; i++) {
 			const group = await track.recvGroup();
 			const frame = await group?.readFrame();
-			got.push([group?.sequence, frame?.payload.length, frame?.timestamp]);
+			got.push([group?.sequence, frame?.payload.length, frame?.timestamp?.value]);
 		}
 		expect(got).toEqual([
-			[3, 1, undefined],
-			[4, 1, undefined],
-			[5, 1, undefined],
+			[3, 1, 2000],
+			[4, 1, 1000],
+			[5, 1, 500],
 		]);
-		expect((await track.info()).timescale).toBeUndefined();
+		expect((await track.info()).timescale).toBe(Timescale.MILLI);
 		expect(track.closed.peek()).toBeUndefined();
 	} finally {
 		track.close();

js/net/src/lite/subscriber.ts

@@ -1212,14 +1212,15 @@ export class Subscriber {
 	// Map the wire TRACK_INFO onto the model track.Info a producer/consumer holds.
 	#toModelInfo(info: TrackInfo): track.Info {
 		return {
-			// Lite-05/06 timestamps may be send times, so the copy is untimed and the ingest drops them.
-			timescale: hasMediaTime(this.version) ? info.timescale : undefined,
+			timescale: info.timescale,
 			// Publisher Max Age rides on the wire, so the local media-time budget
 			// matches what the upstream advertises (relays re-serve with the same bound).
 			maxAge: info.maxAge === undefined ? undefined : Milli(info.maxAge),
 			priority: info.priority,
 			refresh: info.refresh,
 			compress: info.compress,
+			// Lite-05/06 timestamps may be send times, so the copy's groups skip the rewind check.
+			...(hasMediaTime(this.version) ? {} : { unchecked: true }),
 		};
 	}
 
@@ -1426,7 +1427,6 @@ export class Subscriber {
 		try {
 			const decode = frameDecoder({
 				scale: info.timescale ?? 0,
-				timed: hasMediaTime(this.version),
 				compress: info.compress,
 			});
 
@@ -1738,7 +1738,6 @@ export class Subscriber {
 
 			await readFrames(stream, producer, {
 				scale: timescale,
-				timed: hasMediaTime(this.version),
 				compress: entry.compress,
 			});
 
@@ -1820,11 +1819,8 @@ export class Subscriber {
 
 		const scale = entry.timescale;
 
-		// Dropped where it may be a send time, like a frame's.
 		const timestamp =
-			dg.timestamp === undefined || !hasMediaTime(this.version)
-				? undefined
-				: new Time.Timestamp(dg.timestamp, Time.Timescale(scale));
+			dg.timestamp === undefined ? undefined : new Time.Timestamp(dg.timestamp, Time.Timescale(scale));
 		// A datagram's sequence is never owed a stream, so it never holds the tail open.
 		entry.tail.account(dg.sequence, dg.sequence + 1);
 		hooks.writeDatagram(entry.track, { sequence: dg.sequence, timestamp, payload: dg.payload }, dg.inflated);

js/net/src/lite/track_stream.test.ts

@@ -4,7 +4,6 @@
 import { describe, expect, test } from "bun:test";
 import { Elapsed, Milli, Nano, timeout } from "@moq/clock";
 import { randomHop } from "../hop.ts";
-import { Version as IetfVersion } from "../ietf/version.ts";
 import { createMockTransportPair } from "../mock.ts";
 import { Producer as OriginProducer } from "../origin.ts";
 import * as Path from "../path.ts";
@@ -382,10 +381,8 @@ describe.each([Version.DRAFT_05, Version.DRAFT_06, Version.DRAFT_07])("%s", (ver
 		origin.close();
 	});
 
-	// Timestamps received over moq-transport may be arrival times, so they never enter moq-lite,
-	// whose receivers check every timestamp: the track is served untimed (milliseconds of send
-	// time before lite-07).
-	test("an unchecked track is served untimed", async () => {
+	// An unchecked track's timestamps go out as received, so TRACK_INFO declares its own scale.
+	test("an unchecked track is served with its timescale", async () => {
 		const pair = createMockTransportPair(ALPN_05);
 		const origin = new OriginProducer();
 		const publisher = new Publisher(pair.server, version, randomHop(), origin.consume());
@@ -396,7 +393,7 @@ describe.each([Version.DRAFT_05, Version.DRAFT_06, Version.DRAFT_07])("%s", (ver
 			for (;;) {
 				const request = await wireOf(broadcast).requested();
 				if (!request) return;
-				request.accept({ timescale: Timescale.MICRO, ietf: IetfVersion.DRAFT_22 });
+				request.accept({ timescale: Timescale.MICRO, unchecked: true });
 			}
 		})();
 
@@ -406,7 +403,7 @@ describe.each([Version.DRAFT_05, Version.DRAFT_06, Version.DRAFT_07])("%s", (ver
 		void publisher.runTrackInfo(new TrackMessage(Path.from("room"), "video"), server);
 
 		const info = await TrackInfo.decode(client.reader, version);
-		expect(info.timescale).toBe(version === Version.DRAFT_07 ? undefined : Timescale.MILLI);
+		expect(info.timescale).toBe(Timescale.MICRO);
 
 		client.writer.close();
 		publisher.close();