Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
33 commits
Select commit Hold shift + click to select a range
c4aef1a
chore(quest): claim quest/m1/relay-inflight-replay.md
kixelated Nov 3, 2026
74909c8
fix(net): join unresolved legacy tracks at the live edge
kixelated Nov 3, 2026
0942320
fix(net): preserve lite01/02 joins and align live-edge expectations
kixelated Nov 3, 2026
6babd67
docs(net): clarify the legacy unresolved join floor
kixelated Nov 3, 2026
9d239c6
fix(net): floor a pending pre-06 join at the newest group as of its r…
kixelated Nov 3, 2026
e70f6b2
Merge remote-tracking branch 'origin/main' into HEAD
kixelated Nov 3, 2026
2cce053
fix(net): keep a subscription's request snapshot off Subscribing
kixelated Nov 3, 2026
3f2e01d
docs(quest): sequence relay-inflight-replay after the HLS grid
kixelated Nov 3, 2026
6e7c54d
Merge remote-tracking branch 'origin/main' into HEAD
kixelated Nov 4, 2026
796bbca
docs(quest): complete relay inflight replay after HLS grid
kixelated Nov 4, 2026
9ce32d3
docs(quest): retain replay quest for review decisions
kixelated Nov 4, 2026
6157752
Merge remote-tracking branch 'origin/main' into t3/relay-inflight-replay
kixelated Nov 4, 2026
f87d0ea
fix(net): defer copyless wire joins and align legacy floors
kixelated Nov 4, 2026
1394101
chore(quest): finish relay request-time joins
kixelated Nov 4, 2026
a05de1a
test(net): unwrap the provisional track write guard
kixelated Nov 4, 2026
e0f8f10
test(net): retain the provisional group handle
kixelated Nov 4, 2026
5122621
merge: update relay joins with main
kixelated Nov 5, 2026
fa492a3
fix(net): freeze pending front snapshots at their first answer
kixelated Nov 5, 2026
1e575c3
test(net): cover info snapshots across route replacements
kixelated Nov 5, 2026
8a321d1
test(net): initialize shared answers in preference fixtures
kixelated Nov 5, 2026
5e2ead5
chore(quest): checkpoint remaining snapshot review findings
kixelated Nov 5, 2026
a6bb43e
Merge remote-tracking branch 'origin/main' into t3/93c5a7f5
kixelated Nov 5, 2026
899160c
fix(net): settle legacy relay joins past the upstream answer
kixelated Nov 5, 2026
bbf2327
Merge remote-tracking branch 'origin/main' into t3/93c5a7f5
kixelated Nov 5, 2026
fbaa9f6
style(net): satisfy clippy and biome
kixelated Nov 5, 2026
1172db1
style(net): format the run helper's lint allowance
kixelated Nov 5, 2026
7175eef
test(net): drop explicit derefs in the settle test
kixelated Nov 5, 2026
a11a5e2
chore(quest): finish relay-inflight-replay
kixelated Nov 5, 2026
5f55182
fix(net): answer a settling legacy join at once
kixelated Nov 5, 2026
39589c1
Merge remote-tracking branch 'origin/main' into HEAD
kixelated Nov 5, 2026
e4136ec
fix(net): drop the legacy join settle; take the newest group at resol…
kixelated Nov 5, 2026
3f0a3cc
fix(net): a legacy join takes a reported largest even on a warm copy
kixelated Nov 5, 2026
2414c26
Merge remote-tracking branch 'origin/main' into HEAD
kixelated Nov 5, 2026
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
87 changes: 75 additions & 12 deletions js/net/src/lite/publisher.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -714,6 +714,8 @@ async function servedSubscription(
routed?: boolean;
// Groups the track holds before the SUBSCRIBE arrives, stamped by sequence.
prefill?: bigint[];
// A newer largest group the track's source reported before the SUBSCRIBE arrives.
reported?: bigint;
// Leave the track unresolved until `accept`, as an on-demand track the SUBSCRIBE beats.
pending?: boolean;
} = {},
Expand Down Expand Up @@ -749,6 +751,10 @@ async function servedSubscription(
for (const frame of frames) group.writeFrame(textFrame(frame, Timestamp.fromMillis(Number(sequence))));
group.finish();
}
if (options.reported !== undefined) {
if (!track) throw new Error("a pending track has no source to report");
hooks.reportedGroup(track, options.reported);
}
// Pulled before the SUBSCRIBE arrives: a broadcast nobody pulls refuses an unknown track.
const request = options.pending ? wireOf(broadcast).requested() : undefined;

Expand Down Expand Up @@ -796,11 +802,19 @@ async function servedSubscription(
serving,
parked: gate.parked,
release: gate.release,
// Resolve a pending track with the publisher's request for it.
async accept() {
// Resolve a pending track with the publisher's request for it, answering with `held`
// and, when `reported`, an upstream's report of a newer largest group.
async accept(held: bigint[] = [], reported?: bigint) {
const pulled = await request;
if (!pulled) throw new Error("the publisher never requested the track");
track = pulled.accept(info);
const staged = hooks.stageRequest(pulled, info);
if (reported !== undefined) hooks.reportedGroup(staged.producer, reported);
for (const sequence of held) {
const group = staged.producer.createGroup(sequence);
for (const frame of frames) group.writeFrame(textFrame(frame, Timestamp.fromMillis(Number(sequence))));
group.finish();
}
track = staged.commit();
},
// Stamped by sequence, so a group served out of order still starts in order.
serve(sequence: bigint) {
Expand Down Expand Up @@ -1465,24 +1479,73 @@ test("lite draft-05: an update dropping the floor re-pins to the latest group",

// A SUBSCRIBE can beat its track resolving, as one a relay serves from a copy still fetching
// upstream. Groups the track holds once it does are older than the join, so an absent Group
// Start is still the latest group.
test.each([Version.DRAFT_01, Version.DRAFT_03, Version.DRAFT_05])(
"lite %s: a subscribe that beats its track resolving joins at the latest group",
// Start is still the latest group known then, including one the upstream reported.
// Routed, the join reads the front's serving copy.
test.each([
[Version.DRAFT_03, undefined, false],
[Version.DRAFT_04, undefined, false],
[Version.DRAFT_04, 9n, false],
[Version.DRAFT_04, 9n, true],
[Version.DRAFT_05, undefined, false],
[Version.DRAFT_05, undefined, true],
])(
Comment thread
kixelated marked this conversation as resolved.
Resolved
"lite %s (reported %s, routed %s): a subscribe that beats its track resolving joins at its newest group",
async (version, reported, routed) => {
const sub = await servedSubscription({ version, pending: true, routed });
try {
await sub.accept([0n, 3n, 7n], reported);
if (reported !== undefined) {
// The SUBSCRIBE_OK follows the floor, so these arrive after the join took it.
expect("ok" in (await decodeSubscribeResponse(sub.client.reader, version))).toBe(true);
sub.serve(8n);
sub.serve(9n);
}
expect(await sub.servedHeader()).toBe(reported ?? 7n);
expect(await sub.servedSequence()).toBeUndefined();
} finally {
await sub.close();
}
},
);

// A track that already holds groups when the SUBSCRIBE arrives still joins at a newer largest
// its source reported, as a cold one would.
test.each([Version.DRAFT_04, Version.DRAFT_05])(
"lite %s: a join on a track already holding groups starts at a reported newer group",
async (version) => {
const sub = await servedSubscription({ version, pending: true });
const sub = await servedSubscription({ version, prefill: [0n, 3n], reported: 9n });
try {
await sub.accept();
sub.serve(0n);
sub.serve(1n);
sub.serve(2n);
expect(await sub.servedHeader()).toBe(2n);
if (version === Version.DRAFT_04) {
expect("ok" in (await decodeSubscribeResponse(sub.client.reader, version))).toBe(true);
} else {
await flush();
}
sub.serve(7n);
sub.serve(9n);
expect(await sub.servedHeader()).toBe(9n);
expect(await sub.servedSequence()).toBeUndefined();
} finally {
await sub.close();
}
},
);

// Lite-01/02 retain the arrival-only floor even when the answer contains history.
test.each([Version.DRAFT_01, Version.DRAFT_02])(
"lite %s: a pending join retains its arrival-only floor",
async (version) => {
const sub = await servedSubscription({ version, pending: true });
try {
await sub.accept([0n, 3n, 7n]);
expect(await sub.servedHeader()).toBe(0n);
expect(await sub.servedHeader()).toBe(3n);
expect(await sub.servedHeader()).toBe(7n);
} finally {
await sub.close();
}
},
);

// On an empty track the re-pin has no latest group to name, so the first group the
// track produces is served, even below the dropped floor.
test("lite draft-05: an update dropping the floor on an empty track serves the next group", async () => {
Expand Down
21 changes: 14 additions & 7 deletions js/net/src/lite/publisher.ts
Original file line number Diff line number Diff line change
Expand Up @@ -1040,13 +1040,20 @@ export class Publisher {
}
const publisher = info.priority;
// A SUBSCRIBE can arrive before its track resolves, such as one a relay serves from a
// copy still fetching upstream, or on lite-05 one sent alongside its TRACK, when no
// group is known yet: the newest once it resolves stands in, as it would for one
// sent after.
const resolved = cursorFloor(this.version, msg.startGroup, hooks.latestSequence(track));
if (latest === undefined && resolved !== floor) {
floor = resolved;
track.withRange({ start: { included: floor } });
// copy still fetching upstream, or on lite-05 one sent alongside its TRACK: the newest
// group known once it resolves stands in, including a largest the upstream's answer
// reported, whether or not the copy already held a group. A newer group the answer
// brings later is not waited for. Lite-01/02 keep their arrival floor, as Rust does.
if (this.version !== Version.DRAFT_01 && this.version !== Version.DRAFT_02) {
let newest = latest;
for (const known of [hooks.latestSequence(track), hooks.peekLargest(track).largest?.group]) {
if (known !== undefined) newest = newest === undefined ? known : max(newest, known);
}
const resolved = cursorFloor(this.version, msg.startGroup, newest);
if (resolved !== floor) {
floor = resolved;
track.withRange({ start: { included: floor } });
}
}
// Older drafts carry no timestamps.
let stamp: Stamp | undefined;
Expand Down
1 change: 0 additions & 1 deletion quest/m1/README.md
Original file line number Diff line number Diff line change
Expand Up @@ -181,7 +181,6 @@ their end report, so an embedder's drain alert pages on real cuts.
- [Session policy lives in moq-net](/quest/m1/session-policy/README.md) - accept and connect deadlines, admission, window widening and reconnect live once in moq-net; moq-tokio and moq-relay's io_uring path call them
- [moq auth serve scopes each client certificate by its chain](/quest/m1/auth-cert-rules.md) - per-certificate and per-intermediate rules in a reloaded TOML config, keyed by the chain hashes the relay sends
- [A replacement that fails before delivering never ends a live track](/quest/m1/route-swap-keeps-incumbent.md) - a route change whose replacement aborts before its first group leaves readers on the source that was serving
- [A Rust relay never replays from group 0 to a lite-03/04 subscriber](/quest/m1/relay-inflight-replay.md) - A Rust relay or publisher serving a lite-03 or lite-04 SUBSCRIBE from a track copy that is still resolving starts at the newest group once the copy resolves
- [Rename moq-rtc to moq-webrtc](/quest/m1/webrtc-rename.md) - one published `moq-webrtc` crate holds the gateway, the ICE driver, and the data-channel transport
- [Vendor and trim the WebRTC stack](/quest/m1/webrtc-vendor.md) - str0m, dimpl, `is`, and sctp-proto live in moq-webrtc with unused code removed, so moq-rtc can take rind
- [MoQ on rind](/quest/m1/rind/README.md) - every MoQ crate takes its crypto from rind, a pure-Rust graviola fork, so no build compiles C crypto
Expand Down
33 changes: 0 additions & 33 deletions quest/m1/relay-inflight-replay.md

This file was deleted.

Loading
Loading