From 0775240422cd49ac9a24371dec94910e54b9201e Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 31 Oct 2026 22:45:04 -0700 Subject: [PATCH 01/16] chore(quest): claim quest/m1/api-audit/route/serve.md Quest-Claim: 9a8a03852b363c67 From da3fea23d110d8e861681a7838d1ab95f4683eee Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 31 Oct 2026 22:53:34 -0700 Subject: [PATCH 02/16] feat(net): serve held broadcasts through prefix routes Co-Authored-By: GPT-6.1 Sol --- dart/moq_ffi/lib/src/moq.dart | 30 ++- dart/moq_ffi/lib/src/uniffi_runtime.dart | 2 + doc/concept/identity.md | 17 +- doc/lib/layers.md | 6 + go/wrapper/origin.go | 6 + go/wrapper/publish.go | 2 +- js/net/MIGRATE.md | 3 +- js/net/api/index.api.md | 1 + js/net/bench/broadcasts.ts | 3 +- js/net/bench/requests.ts | 5 +- js/net/src/connection/forward.ts | 4 +- js/net/src/ietf/publisher.test.ts | 8 +- js/net/src/integration.test.ts | 103 +++++++---- js/net/src/internal.ts | 9 - js/net/src/lite/publisher.test.ts | 8 +- js/net/src/lite/tracks.test.ts | 7 +- js/net/src/origin-demand.test.ts | 41 ++-- js/net/src/origin-request.test.ts | 59 ++++-- js/net/src/origin.test.ts | 71 ++++--- js/net/src/origin.ts | 37 ++-- js/net/src/resume.model.test.ts | 5 +- js/net/src/resume.test.ts | 4 +- js/net/src/untimed.test.ts | 3 +- py/moq-rs/README.md | 2 +- py/moq-rs/moq/origin.py | 4 + py/moq-rs/tests/test_local.py | 21 +++ quest/m1/announce-takeover.md | 2 +- quest/m1/api-audit/route/README.md | 3 +- quest/m1/api-audit/route/handle.md | 3 +- quest/m1/api-audit/route/serve.md | 54 ------ rs/moq-c/src/api.rs | 21 +++ rs/moq-c/src/consume.rs | 9 + rs/moq-c/src/test.rs | 33 ++++ rs/moq-ffi/src/origin.rs | 33 +++- rs/moq-net-tests/tests/integration/main.rs | 1 + rs/moq-net-tests/tests/integration/serve.rs | 89 +++++++++ rs/moq-net/MIGRATE.md | 3 +- rs/moq-net/src/fuzz.rs | 2 +- rs/moq-net/src/ietf/publisher.rs | 2 +- rs/moq-net/src/ietf/subscriber.rs | 2 +- rs/moq-net/src/lite/subscriber.rs | 2 +- rs/moq-net/src/model/follow.rs | 2 +- rs/moq-net/src/model/origin.rs | 195 ++++++++++++-------- rs/moq-net/src/model/resume_model.rs | 2 +- swift/Sources/Moq/Origin.swift | 5 + 45 files changed, 611 insertions(+), 313 deletions(-) delete mode 100644 quest/m1/api-audit/route/serve.md create mode 100644 rs/moq-net-tests/tests/integration/serve.rs diff --git a/dart/moq_ffi/lib/src/moq.dart b/dart/moq_ffi/lib/src/moq.dart index 535337e1521..155c68be6c7 100644 --- a/dart/moq_ffi/lib/src/moq.dart +++ b/dart/moq_ffi/lib/src/moq.dart @@ -8,7 +8,9 @@ import "dart:ffi"; import "dart:io" show Platform, File, Directory; import "dart:isolate"; import "dart:typed_data"; + import "package:ffi/ffi.dart"; + import "uniffi_runtime.dart"; export "uniffi_runtime.dart"; @@ -11876,6 +11878,7 @@ abstract class MoqBroadcastRequestInterface { String path(); MoqBroadcastPrepared prepare({required String epoch}); void reject({required int errorCode}); + void serve({required MoqBroadcastConsumer broadcast}); } final _MoqBroadcastRequestFinalizer = Finalizer>((ptr) { @@ -11943,6 +11946,16 @@ class MoqBroadcastRequest implements MoqBroadcastRequestInterface { ); }, moqExceptionErrorHandler); } + + void serve({required MoqBroadcastConsumer broadcast}) { + return rustCall((status) { + uniffi_moq_ffi_fn_method_moqbroadcastrequest_serve( + uniffiClonePointer(), + FfiConverterMoqBroadcastConsumer.lower(broadcast), + status, + ); + }, moqExceptionErrorHandler); + } } class FfiConverterMoqBroadcastRequest { @@ -18636,6 +18649,15 @@ external void uniffi_moq_ffi_fn_method_moqbroadcastrequest_reject( Pointer uniffiStatus, ); +@Native, Pointer, Pointer)>( + assetId: _uniffiAssetId, +) +external void uniffi_moq_ffi_fn_method_moqbroadcastrequest_serve( + Pointer ptr, + Pointer broadcast, + Pointer uniffiStatus, +); + @Native Function(Pointer, Pointer)>( assetId: _uniffiAssetId, ) @@ -20507,6 +20529,9 @@ external int uniffi_moq_ffi_checksum_method_moqbroadcastrequest_prepare(); @Native(assetId: _uniffiAssetId) external int uniffi_moq_ffi_checksum_method_moqbroadcastrequest_reject(); +@Native(assetId: _uniffiAssetId) +external int uniffi_moq_ffi_checksum_method_moqbroadcastrequest_serve(); + @Native(assetId: _uniffiAssetId) external int uniffi_moq_ffi_checksum_method_moqfollowing_available(); @@ -21224,6 +21249,9 @@ void _checkApiChecksums() { if (uniffi_moq_ffi_checksum_method_moqbroadcastrequest_reject() != 9727) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } + if (uniffi_moq_ffi_checksum_method_moqbroadcastrequest_serve() != 16802) { + throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); + } if (uniffi_moq_ffi_checksum_method_moqfollowing_available() != 39867) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } @@ -21253,7 +21281,7 @@ void _checkApiChecksums() { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } if (uniffi_moq_ffi_checksum_method_moqoriginrequests_requested_broadcast() != - 31253) { + 47029) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } if (uniffi_moq_ffi_checksum_method_moqpublication_announce() != 60624) { diff --git a/dart/moq_ffi/lib/src/uniffi_runtime.dart b/dart/moq_ffi/lib/src/uniffi_runtime.dart index c61178325f7..9018eb4e97e 100644 --- a/dart/moq_ffi/lib/src/uniffi_runtime.dart +++ b/dart/moq_ffi/lib/src/uniffi_runtime.dart @@ -8,6 +8,7 @@ import "dart:ffi"; import "dart:io" show Platform, File, Directory; import "dart:isolate"; import "dart:typed_data"; + import "package:ffi/ffi.dart"; class UniffiInternalError implements Exception { @@ -250,6 +251,7 @@ mixin FfiConverterPrimitive on FfiConverter { @override T lower(T value) => value; } + Uint8List createUint8ListFromInt(int value) { int length = value.bitLength ~/ 8 + 1; if (length != 4 && length != 8) { diff --git a/doc/concept/identity.md b/doc/concept/identity.md index 0e707c6be72..37de5eceb73 100644 --- a/doc/concept/identity.md +++ b/doc/concept/identity.md @@ -118,10 +118,19 @@ demand, which has none until a worker answers. ## Work on demand -A worker can advertise a prefix it serves on demand, such as a transcoder -claiming `transcode`. A claim promises capability, not content, so it carries -no epoch. Each requested path is a separate job, announced at its exact path -under its own fresh epoch. +A worker can advertise a prefix it serves on demand. When answering with a +broadcast it already holds, Rust uses `request.serve(consumer)` and JavaScript +`request.serve(broadcast)`. This announces no exact route: the answer belongs +to the prefix route's instance at that path. Every answer there must continue +one sequence space with the same bytes. To serve different content at a path +already served, start a new prefix route. Its first subscription succeeds +without a restart on moq-transport 18 and 22 and moq-lite 06 and 07. + +A job that may restart independently, such as a transcoder claiming +`transcode`, instead prepares and publishes each requested path under a +fresh epoch. The claim promises capability, not content, and carries no +epoch. Each job announces an exact route; the cold-start subscription resets +on versions without takeover, as described below. ```rust let claim = origin.requests("transcode")?; diff --git a/doc/lib/layers.md b/doc/lib/layers.md index d6be6df64f7..d2d694949c3 100644 --- a/doc/lib/layers.md +++ b/doc/lib/layers.md @@ -42,6 +42,12 @@ Sessions, origins, broadcasts, tracks, and groups: `Client`, `Server`, | C++ | `moq::` | `moq::BroadcastProducer` | | C | `moq_session_*`, `moq_origin_*`, `moq_publish_track_*`, `moq_consume_track_*` | `moq_publish_track` | +An on-demand broadcast request can `serve` a held consumer without announcing +an exact route in every binding (`Serve` in Go and +`moq_broadcast_request_serve` in C). It answers under the prefix route's +continuous sequence space at that path. Use prepare and publish for a job +that may restart independently; see [work on demand](/concept/identity#work-on-demand). + ## media The catalog, encoded-media imports, and container-decoded reads, merging diff --git a/go/wrapper/origin.go b/go/wrapper/origin.go index bac6f59a75f..1e8fd023fd4 100644 --- a/go/wrapper/origin.go +++ b/go/wrapper/origin.go @@ -142,6 +142,12 @@ func (r *BroadcastRequest) Prepare(epoch string) (*BroadcastPrepared, error) { return &BroadcastPrepared{inner: inner}, nil } +// Serve answers with held content under the prefix route's continuous sequence space, +// without announcing an exact route. The broadcast remains the caller's to release. +func (r *BroadcastRequest) Serve(broadcast *BroadcastConsumer) error { + return r.inner.Serve(broadcast.inner) +} + // Reject fails the request with an application error code. func (r *BroadcastRequest) Reject(errorCode uint16) error { return r.inner.Reject(errorCode) diff --git a/go/wrapper/publish.go b/go/wrapper/publish.go index a179024d830..2f79805a7ce 100644 --- a/go/wrapper/publish.go +++ b/go/wrapper/publish.go @@ -17,7 +17,7 @@ type BroadcastProducer struct { } // NewBroadcastProducer creates a standalone broadcast, not attached to any -// origin: use it to serve a dynamic request ([BroadcastRequest.Accept]) or for +// origin: use it to serve a dynamic request ([BroadcastRequest.Serve]) or for // local pub/sub. To publish at a path, use [OriginProducer.CreateBroadcast]. func NewBroadcastProducer() (*BroadcastProducer, error) { inner, err := ffi.NewMoqBroadcastProducer() diff --git a/js/net/MIGRATE.md b/js/net/MIGRATE.md index 5f5894f0bc0..79c37ef65da 100644 --- a/js/net/MIGRATE.md +++ b/js/net/MIGRATE.md @@ -106,7 +106,8 @@ Only `publish` announces it: `prepared.broadcast` has no announcement methods. `Prepared.reject(err)` is replaced by idempotent `close()` and `[Symbol.dispose]()`; either refuses the unpublished answer as `Unroutable` and closes its broadcast. Closing that broadcast also refuses the request. `using` handles normal scope exit and exceptions; after `publish()`, disposal leaves the returned publication and its fill producer live. Use `request.reject(err)` to refuse before preparing. A retained, unclosed `Prepared` keeps its request pending; garbage collection provides no prompt cleanup guarantee. Construct a `Prepared` only with `request.prepare()`. Its constructor and the `Request.publisher`, `publishPrepared`, and `rejectPrepared` completion hooks are no longer public. -`Dynamic.update` is no longer part of the public API, and `Request` has no `accept` (#6496): only the built-in sessions answer with a broadcast they already hold. +`Dynamic.update` is no longer part of the public API (#6496). +`Request.serve(broadcast)` additively exposes the former private answer path: serve held content without announcing an exact route. The prefix route promises the same bytes and continuous sequences at each served path; start a new prefix route for different content, or prepare and publish an independent job. Close the claim and claim again to change it, and close an answer's producer to end that output. ### `largest()` reports within a reader's `setGroups` bounds diff --git a/js/net/api/index.api.md b/js/net/api/index.api.md index 841422bf7bc..1b872423533 100644 --- a/js/net/api/index.api.md +++ b/js/net/api/index.api.md @@ -403,6 +403,7 @@ export namespace Origin { readonly path: Path.Valid; prepare(epoch: Epoch.Valid): Origin.Prepared; reject(err: Error): void; + serve(source: Broadcast.Producer | Broadcast.Consumer): void; } export interface RequestOptions { epoch?: Epoch.Valid; diff --git a/js/net/bench/broadcasts.ts b/js/net/bench/broadcasts.ts index a43a1bc297b..2e262650c4a 100644 --- a/js/net/bench/broadcasts.ts +++ b/js/net/bench/broadcasts.ts @@ -6,7 +6,6 @@ import { Producer as BroadcastProducer } from "../src/broadcast.ts"; import { BroadcastCache } from "../src/consume.ts"; import * as Epoch from "../src/epoch.ts"; import { HopSchema, Route } from "../src/hop.ts"; -import { hooks } from "../src/internal.ts"; import { AnnounceRequest } from "../src/lite/announce.ts"; import { Publisher } from "../src/lite/publisher.ts"; import { Subscriber } from "../src/lite/subscriber.ts"; @@ -243,7 +242,7 @@ for (const pathCount of routeCounts) { const broadcasts = Array.from({ length: pathCount }, () => new BroadcastProducer()); for (const broadcast of broadcasts) { const request = (await pending.next()).value; - if (request) hooks.acceptRequest(request, broadcast); + if (request) request.serve(broadcast); } await Promise.resolve(); const before = requests.map((request) => request.active.peek()); diff --git a/js/net/bench/requests.ts b/js/net/bench/requests.ts index 937a747f7dd..20925a0cb8c 100644 --- a/js/net/bench/requests.ts +++ b/js/net/bench/requests.ts @@ -10,7 +10,6 @@ import { SubscribeNamespaceEntryDone, } from "../src/ietf/subscribe_namespace"; import { ALPN, Version } from "../src/ietf/version"; -import { hooks } from "../src/internal"; import { createMockTransportPair } from "../src/mock"; import { Producer } from "../src/origin"; import * as Path from "../src/path"; @@ -149,7 +148,7 @@ for (const failovers of [0, 1, 16, 128]) const source = new Broadcast(); sources.push(source); const answer = (await ar.next()).value; - if (answer) hooks.acceptRequest(answer, source); + if (answer) answer.serve(source); await settle(); entries.push({ primary, ar, br, held }); } @@ -186,7 +185,7 @@ for (const failovers of [0, 1, 16, 128]) for (let i = 0; i < entries.length; i++) { const source = new Broadcast(); sources.push(source); - hooks.acceptRequest(pending[i], source); + pending[i].serve(source); await settle(); if (!readsFrom(entries[i].held.active.peek(), source)) throw new Error("lost failover"); } diff --git a/js/net/src/connection/forward.ts b/js/net/src/connection/forward.ts index 0ca6982e222..bd4b3dc521c 100644 --- a/js/net/src/connection/forward.ts +++ b/js/net/src/connection/forward.ts @@ -8,7 +8,7 @@ import { Milli, Nano } from "@moq/clock"; import { type Dispose, race } from "@moq/signals"; import type * as Announce from "../announced.ts"; import { type Route, routesEqual } from "../hop.ts"; -import { coveringPrefixes, hooks } from "../internal.ts"; +import { coveringPrefixes } from "../internal.ts"; import type { Producer as OriginProducer, RequestSlot, Requests } from "../origin.ts"; import * as Path from "../path.ts"; import { after } from "../util/timer.ts"; @@ -294,7 +294,7 @@ async function drive(handle: Requests, conn: Established): Promise { const session = wireOf(conn); try { for await (const request of handle.requested()) { - hooks.acceptRequest(request, session.consume(request.path)); + request.serve(session.consume(request.path)); } } catch { handle.close(); diff --git a/js/net/src/ietf/publisher.test.ts b/js/net/src/ietf/publisher.test.ts index 54580b32068..6454a17aa38 100644 --- a/js/net/src/ietf/publisher.test.ts +++ b/js/net/src/ietf/publisher.test.ts @@ -405,7 +405,7 @@ test("a cancelled TRACK_STATUS releases its demand on every draft", async () => expect(early.written).toEqual([]); // Withdrawn, so a late answer is closed rather than served. const answer = new SessionBroadcast(); - hooks.acceptRequest(pending, answer); + pending.serve(answer); expect(answer.closed.peek()).toBeNull(); // The broadcast resolves, but its track is never answered. @@ -415,7 +415,7 @@ test("a cancelled TRACK_STATUS releases its demand on every draft", async () => if (!request) throw new Error("no request for room/late"); const served = new BroadcastProducer(); const trackRequest = wireOf(served).requested(); - hooks.acceptRequest(request, served); + request.serve(served); const track = await trackRequest; expect(track?.name).toBe("video"); late.cancel(); @@ -457,7 +457,7 @@ test("a SUBSCRIBE withdrawn during setup releases its demand on every draft", as expect(early.written).toEqual([]); // Withdrawn, so a late answer is closed rather than served. const answer = new SessionBroadcast(); - if (pending) hooks.acceptRequest(pending, answer); + if (pending) pending.serve(answer); expect(answer.closed.peek()).toBeNull(); // The broadcast resolves, but its track is never answered. @@ -467,7 +467,7 @@ test("a SUBSCRIBE withdrawn during setup releases its demand on every draft", as if (!request) throw new Error("no request for room/late"); const served = new BroadcastProducer(); const trackRequest = wireOf(served).requested(); - hooks.acceptRequest(request, served); + request.serve(served); const track = await trackRequest; if (!track) throw new Error("no request for video"); expect(track.name).toBe("video"); diff --git a/js/net/src/integration.test.ts b/js/net/src/integration.test.ts index f0c4df272b4..706e2122b35 100644 --- a/js/net/src/integration.test.ts +++ b/js/net/src/integration.test.ts @@ -2607,42 +2607,75 @@ test("create then announce is discoverable on the wire", async () => { origin.close(); }); -test("a handle serves a request under live/** over the wire", async () => { - const pair = createMockTransportPair(Lite.ALPN_06); - const origin = new OriginProducer(); - const handle = origin.requestsRoute(Path.from("live")); - - const serving = (async () => { - for await (const request of handle.requested()) { - const produced = new BroadcastProducer(); - produced.createTrack("chat", { timescale: Timescale.MILLI }).writeFrame(textFrame("hello")); - hooks.acceptRequest(request, produced); - } - })(); - - const [client, server] = await Promise.all([ - connect(url, { transport: pair.client }), - accept(pair.server, url, { publish: origin.consume() }), - ]); - - const announced = client.announced(); - const entry = await announced.next(); - expect(entry?.prefix).toBe("live" as Path.Valid); - expect(entry?.kind).toBe("start"); - - const remote = wireOf(client).consume(Path.from("live/cam")); - const track = remote.track("chat").subscribe().ordered(); - expect(await track.readString()).toBe("hello"); +test.each([Lite.ALPN_06, Lite.ALPN_07_WIP, Ietf.ALPN.DRAFT_18, Ietf.ALPN.DRAFT_22])( + "a held answer's first subscribe succeeds on %s without an exact route", + async (protocol) => { + const pair = createMockTransportPair(protocol); + const origin = new OriginProducer(); + const consumer = new OriginProducer(); + const handle = origin.requests(Path.empty()); + const held = new BroadcastProducer(); + held.createTrack("chat", { timescale: Timescale.MILLI }).writeFrame(textFrame("hello")); + const serving = (async () => { + for await (const request of handle.requested()) request.serve(held.consume()); + })(); + const [client, server] = await Promise.all([ + connect(url, { transport: pair.client, consume: consumer }), + accept(pair.server, url, { publish: origin.consume() }), + ]); + const requested = consumer.request(Path.from("live/cam")); + const remote = await waitFor(requested.active, (broadcast) => broadcast !== undefined); + if (!remote) throw new Error("request did not resolve"); + const track = remote.track("chat").subscribe().ordered(); + expect(await track.readString()).toBe("hello"); + expect(wireOf(origin.consume()).advertised.peek()?.has(Path.from("live/cam"))).toBe(false); + track.close(); + requested.close(); + handle.close(); + await serving; + held.close(); + client.abort(); + server.abort(); + origin.close(); + consumer.close(); + }, +); - track.close(); - remote.close(); - announced.close(); - handle.close(); - await serving; - client.abort(); - server.abort(); - origin.close(); -}); +test.each([Lite.ALPN_06, Lite.ALPN_07_WIP, Ietf.ALPN.DRAFT_18, Ietf.ALPN.DRAFT_22])( + "publishing a job still resets its first subscribe on %s", + async (protocol) => { + const pair = createMockTransportPair(protocol); + const origin = new OriginProducer(); + const consumer = new OriginProducer(); + const handle = origin.requests(Path.empty()); + const serving = (async () => { + const requests = handle.requested(); + const request = (await requests.next()).value; + if (!request) throw new Error("missing job request"); + const prepared = request.prepare(Epoch.mint()); + prepared.broadcast.createTrack("chat", { timescale: Timescale.MILLI }).writeFrame(textFrame("job")); + return prepared.publish(); + })(); + const [client, server] = await Promise.all([ + connect(url, { transport: pair.client, consume: consumer }), + accept(pair.server, url, { publish: origin.consume() }), + ]); + const requested = consumer.request(Path.from("live/cam")); + const remote = await waitFor(requested.active, (broadcast) => broadcast !== undefined); + if (!remote) throw new Error("request did not resolve"); + const track = remote.track("chat").subscribe().ordered(); + await expect(track.readString()).rejects.toBeInstanceOf(Error); + const publication = await serving; + track.close(); + requested.close(); + handle.close(); + publication.broadcast.close(); + client.abort(); + server.abort(); + origin.close(); + consumer.close(); + }, +); // The peer's close code a killed session carries. const DEATH = SessionCode(71); diff --git a/js/net/src/internal.ts b/js/net/src/internal.ts index 0d4fcadaaf1..1a6c38db46b 100644 --- a/js/net/src/internal.ts +++ b/js/net/src/internal.ts @@ -14,7 +14,6 @@ import type * as Epoch from "./epoch.ts"; import { toStreamCode } from "./error.ts"; import type { Frame, Consumer as GroupConsumer, Producer as GroupProducer } from "./group.ts"; import { isAnonymous, type Route } from "./hop.ts"; -import type { Request as OriginRequest } from "./origin.ts"; import * as Path from "./path.ts"; import type { Timestamp } from "./time.ts"; import type { Demand, Groups, Info, Position, Producer, Request, Subscriber, Subscription } from "./track.ts"; @@ -607,11 +606,6 @@ export const hooks: { stampEpoch: (target: BroadcastConsumer, epoch: Epoch.Valid | undefined) => void; /** Mark a broadcast handle served through a route claiming a shorter prefix: it lists nothing. */ stampUnlisted: (target: BroadcastConsumer) => void; - /** - * Resolve a session-forwarded request with its peer's routed broadcast. An application - * claim answers through `prepare` and `publish` instead. Assigned by `origin.ts`. - */ - acceptRequest: (request: OriginRequest, source: BroadcastProducer | BroadcastConsumer) => void; } = { endTrack: () => { throw new Error("track.ts not loaded"); @@ -842,9 +836,6 @@ export const hooks: { stampUnlisted: () => { throw new Error("broadcast.ts not loaded"); }, - acceptRequest: () => { - throw new Error("origin.ts not loaded"); - }, }; /** diff --git a/js/net/src/lite/publisher.test.ts b/js/net/src/lite/publisher.test.ts index 37225012fb7..787e8f38d67 100644 --- a/js/net/src/lite/publisher.test.ts +++ b/js/net/src/lite/publisher.test.ts @@ -719,7 +719,7 @@ async function servedSubscription( front.serve(broadcast.consume()); const dynamic = origin.requestsRoute(Path.from("test")); void (async () => { - for await (const request of dynamic.requested()) hooks.acceptRequest(request, front.consumer); + for await (const request of dynamic.requested()) request.serve(front.consumer); })(); routed = { front, dynamic }; } else { @@ -2720,7 +2720,7 @@ test("lite draft-06: a grant that shrinks while a TRACK resolves refuses it", as const request = await requests.next(); if (request.done) throw new Error("the handler never saw the request"); grant.set(grantOf("other")); - hooks.acceptRequest(request.value, produced); + request.value.serve(produced); await serving; expect(unauthorizedResets(resets)).toContain("unauthorized: live/cam"); @@ -2776,7 +2776,7 @@ test("lite draft-06: a grant that shrinks while TRACK_INFO is blocked resets it" const serving = publisher.runTrackInfo(new TrackMessage(Path.from("live/cam"), "video"), stream); const request = await requests.next(); if (request.done) throw new Error("the handler never saw the request"); - hooks.acceptRequest(request.value, produced); + request.value.serve(produced); await writing; grant.set(grantOf("other")); @@ -2825,7 +2825,7 @@ test("lite draft-06: a grant that shrinks while the broadcast resolves resets th if (request.done) throw new Error("the handler never saw the request"); grant.set(grantOf("other")); await Promise.resolve(); - hooks.acceptRequest(request.value, produced); + request.value.serve(produced); await serving; expect(unauthorizedResets(resets)).toContain("unauthorized: live/cam"); diff --git a/js/net/src/lite/tracks.test.ts b/js/net/src/lite/tracks.test.ts index a483f434ea8..14361128988 100644 --- a/js/net/src/lite/tracks.test.ts +++ b/js/net/src/lite/tracks.test.ts @@ -7,7 +7,6 @@ import { accept, connect } from "../connection/index.ts"; import * as Epoch from "../epoch.ts"; import { fromTransport, NotFound, SessionCode, StreamCode, StreamError } from "../error.ts"; import { randomHop } from "../hop.ts"; -import { hooks } from "../internal.ts"; import { createMockTransportPair } from "../mock.ts"; import { Producer as OriginProducer } from "../origin.ts"; import * as Path from "../path.ts"; @@ -414,7 +413,7 @@ test("a path served through a covering prefix route is NOT_FOUND", async () => { for await (const request of dynamic.requested()) { const served = new BroadcastProducer(); served.createTrack("video"); - hooks.acceptRequest(request, served); + request.serve(served); } })(); const { list } = publisher(origin); @@ -431,7 +430,7 @@ test("a local read through a covering prefix route is NOT_FOUND, and through its for await (const request of dynamic.requested()) { const served = new BroadcastProducer(); served.createTrack("video"); - hooks.acceptRequest(request, served); + request.serve(served); } })(); } @@ -533,7 +532,7 @@ test("an epoch-pinned front served through a covering prefix route is NOT_FOUND" for await (const request of dynamic.requested()) { const served = new BroadcastProducer(); served.createTrack("video"); - hooks.acceptRequest(request, served); + request.serve(served); } })(); const request = origin.consume().request(Path.from("room/alice")); diff --git a/js/net/src/origin-demand.test.ts b/js/net/src/origin-demand.test.ts index b9caea824d9..303614b5d48 100644 --- a/js/net/src/origin-demand.test.ts +++ b/js/net/src/origin-demand.test.ts @@ -6,7 +6,6 @@ import { Publisher as IetfPublisher } from "./ietf/publisher.ts"; import { NativeSession } from "./ietf/session.ts"; import { Subscribe as IetfSubscribe } from "./ietf/subscribe.ts"; import { Version as IetfVersion } from "./ietf/version.ts"; -import { hooks } from "./internal.ts"; import { Fetch } from "./lite/fetch.ts"; import { Publisher as LitePublisher } from "./lite/publisher.ts"; import { Subscribe as LiteSubscribe } from "./lite/subscribe.ts"; @@ -129,11 +128,11 @@ test("last cancellation finishes the internal wait and discards a late consumer" const keeper = source.consume(); const late = source.consume(); const close = spyOn(late, "close"); - hooks.acceptRequest(old, late); + old.serve(late); expect(close).toHaveBeenCalledTimes(1); close.mockRestore(); expect(source.closed.peek()).toBeUndefined(); - hooks.acceptRequest(fresh, source); + fresh.serve(source); await settle(); expect(next.active.peek()?.closed).toBe(source.closed); next.close(); @@ -171,7 +170,7 @@ test.each([true, false])( } await settle(); const late = new SessionBroadcast(); - hooks.acceptRequest(old, late); + old.serve(late); expect(late.closed.peek()).toBeNull(); const next = origin.request(path); const fresh = (await requests.next()).value; @@ -210,7 +209,7 @@ test.each([ try { hold.abort(); await first; - hooks.acceptRequest(request, source); + request.serve(source); await settle(); expect(other === "peer" ? (await second)?.closed : local?.active.peek()?.closed).toBe(source.closed); } finally { @@ -257,7 +256,7 @@ test.each(["accept", "reject", "cancel"] as const)( const request = (await requests.next()).value; if (!request) throw new Error("expected a pending request"); try { - if (action === "accept") hooks.acceptRequest(request, source); + if (action === "accept") request.serve(source); if (action === "reject") request.reject(new Error("denied")); if (action === "cancel") hold.abort(); const result = await wait; @@ -265,9 +264,9 @@ test.each(["accept", "reject", "cancel"] as const)( hold.abort(); if (action === "accept") { expect(result?.closed).toBe(source.closed); - hooks.acceptRequest(request, source); + request.serve(source); request.reject(new Error("late")); - } else hooks.acceptRequest(request, source); + } else request.serve(source); expect(source.closed.peek()).toBeUndefined(); } finally { remove.mockRestore(); @@ -295,9 +294,9 @@ test("a pending local request changing routes withdraws the old route's work", a const late = source.consume(); const close = spyOn(late, "close"); try { - hooks.acceptRequest(old, late); + old.serve(late); expect(close).toHaveBeenCalledTimes(1); - hooks.acceptRequest(fresh, source); + fresh.serve(source); await settle(); expect(local.active.peek()?.closed).toBe(source.closed); } finally { @@ -331,7 +330,7 @@ test("cancelling an old epoch waiter does not decrement a new epoch's demand", a const source = new Broadcast(); try { old.reject(new Error("obsolete")); - hooks.acceptRequest(fresh, source); + fresh.serve(source); expect((await after)?.closed).toBe(source.closed); } finally { origin.close(); @@ -352,7 +351,7 @@ test.each(["answer", "release"] as const)( const br = b.requested(); const held = origin.request(path); const source = new Broadcast(); - hooks.acceptRequest((await ar.next()).value, source); + (await ar.next()).value.serve(source); await settle(); // Another instance wins new requests. The old handle stays on its own epoch. const c = origin.requestsRoute(prefix, { epoch: Epoch.mint(), cost: 0n }); @@ -377,7 +376,7 @@ test.each(["answer", "release"] as const)( const front = late.consume(); const close = spyOn(front, "close"); try { - hooks.acceptRequest(pending, front); + pending.serve(front); await settle(); if (action === "release") expect(close).toHaveBeenCalledTimes(1); else { @@ -412,7 +411,7 @@ test.each([0, 1])( const held = origin.request(path); const source = new Broadcast(); sources.push(source); - hooks.acceptRequest((await ar.next()).value, source); + (await ar.next()).value.serve(source); await settle(); entries.push({ primary, ar, br, held }); } @@ -436,9 +435,9 @@ test.each([0, 1])( // The slot is still detached until its microtask runs, but no longer owns demand. entries[released].held.close(); hold.abort(); - hooks.acceptRequest(pending[released], front); + pending[released].serve(front); expect(close).toHaveBeenCalledTimes(1); - hooks.acceptRequest(pending[1 - released], replacement); + pending[1 - released].serve(replacement); await wait; expect(readsFrom(entries[1 - released].held.active.peek(), replacement)).toBe(true); } finally { @@ -511,7 +510,7 @@ test.each(["accept", "reject"] as const)( const denied = new Error("denied"); try { hold.abort(cancelled); - if (answer === "accept") hooks.acceptRequest(request, source); + if (answer === "accept") request.serve(source); else request.reject(denied); expect(await first).toBe(cancelled); const result = await second; @@ -541,7 +540,7 @@ test.each([true, false])("last waiter cancellation and accept in one turn (cance const close = spyOn(front, "close"); try { if (cancelFirst) hold.abort(cancelled); - hooks.acceptRequest(request, front); + request.serve(front); if (!cancelFirst) hold.abort(cancelled); expect(await wait).toBe(cancelled); expect(close).toHaveBeenCalledTimes(cancelFirst ? 1 : 0); @@ -551,7 +550,7 @@ test.each([true, false])("last waiter cancellation and accept in one turn (cance const fresh = (await requests.next()).value; expect(fresh).not.toBe(request); if (!fresh) throw new Error("expected fresh request"); - hooks.acceptRequest(fresh, source); + fresh.serve(source); } const answer = await next; expect(answer?.closed).toBe(source.closed); @@ -586,7 +585,7 @@ test.each([true, false])("local demand survives same-turn cancellation only when const replacement = rejoin ? origin.request(path) : undefined; try { await settle(); - hooks.acceptRequest(request, front); + request.serve(front); expect(close).toHaveBeenCalledTimes(rejoin ? 0 : 1); if (replacement) { await settle(); @@ -596,7 +595,7 @@ test.each([true, false])("local demand survives same-turn cancellation only when const next = (await requests.next()).value; expect(next).not.toBe(request); if (!next) throw new Error("expected fresh request"); - hooks.acceptRequest(next, source); + next.serve(source); await settle(); expect(fresh.active.peek()?.closed).toBe(source.closed); fresh.close(); diff --git a/js/net/src/origin-request.test.ts b/js/net/src/origin-request.test.ts index 48c05665c65..3383d2a904e 100644 --- a/js/net/src/origin-request.test.ts +++ b/js/net/src/origin-request.test.ts @@ -3,8 +3,7 @@ import { Producer as BroadcastProducer } from "./broadcast"; import * as Epoch from "./epoch"; import { StreamCode, StreamError } from "./error"; import { Route } from "./hop"; -import { hooks } from "./internal.ts"; -import { Producer, type Publication, type Request } from "./origin"; +import { Producer, type Publication } from "./origin"; import * as Path from "./path"; import { wireOf } from "./wire"; @@ -170,7 +169,7 @@ test("followers track the serving prefix, ignoring descendants and re-prices", a const keeper = source.consume(); const prefix = origin.requestsRoute(Path.from("pool")); const serving = (async () => { - for await (const request of prefix.requested()) hooks.acceptRequest(request, source.consume()); + for await (const request of prefix.requested()) request.serve(source.consume()); })(); const request = origin.follow(Path.from("pool/job")); await settle(); @@ -226,7 +225,7 @@ test("a follower tracks an epochless route replaced by an identical one", async const serve = (source: BroadcastProducer) => { const route = origin.requestsRoute(path); void (async () => { - for await (const request of route.requested()) hooks.acceptRequest(request, source.consume()); + for await (const request of route.requested()) request.serve(source.consume()); })(); return route; }; @@ -257,7 +256,7 @@ test("an origin closing settles a follower a served route resolved", async () => const source = new BroadcastProducer(); const route = origin.requestsRoute(path); void (async () => { - for await (const request of route.requested()) hooks.acceptRequest(request, source.consume()); + for await (const request of route.requested()) request.serve(source.consume()); })(); const request = origin.follow(path); await settle(); @@ -307,7 +306,7 @@ for (const received of [false, true]) { const source = new BroadcastProducer(); const route = received ? wireOf(origin).receive(path, Route.default) : origin.requestsRoute(path); void (async () => { - for await (const request of route.requested()) hooks.acceptRequest(request, source.consume()); + for await (const request of route.requested()) request.serve(source.consume()); })(); const request = origin.request(path); @@ -372,20 +371,56 @@ test("a prepared answer cannot announce itself before publish", async () => { origin.close(); }); -test("an application claim cannot accept an arbitrary broadcast", async () => { +test("an application serves held content without an exact route", async () => { const origin = new Producer(); const claim = origin.requests(Path.from("room")); const requests = claim.requested(); const request = origin.request(Path.from("room/alice")); - const pending: Request | undefined = (await requests.next()).value; + const pending = (await requests.next()).value; if (!pending) throw new Error("expected a request"); - // @ts-expect-error Only sessions accept a request; an application prepares and publishes. - expect(pending.accept).toBeUndefined(); + const source = new BroadcastProducer(); + source.createTrack("data").writeFrame({ payload: new TextEncoder().encode("held") }); + pending.serve(source.consume()); + await settle(); + const reader = request.active.peek()?.track("data").subscribe().ordered(); + expect(await reader?.readString()).toBe("held"); + expect(wireOf(origin.consume()).advertised.peek()?.has(Path.from("room/alice"))).toBe(false); + reader?.close(); request.close(); claim.close(); + source.close(); origin.close(); }); +for (const withdraw of ["unannounce", "replace"] as const) { + test(`a published answer is not cached after ${withdraw}`, async () => { + const origin = new Producer(); + const claim = origin.requests(Path.from("room")); + const requests = claim.requested(); + const path = Path.from("room/alice"); + const first = origin.request(path); + const pending = (await requests.next()).value; + if (!pending) throw new Error("expected a request"); + const publication = pending.prepare(Epoch.mint()).publish(); + await settle(); + const held = first.active.peek()?.clone(); + if (withdraw === "unannounce") publication.unannounce(); + else origin.createBroadcast(path).broadcast.close(); + const next = origin.request(path); + await settle(); + expect(next.active.peek()).toBeUndefined(); + const fresh = (await requests.next()).value; + if (!fresh) throw new Error("expected another request"); + fresh.reject(new Error("no replacement")); + held?.close(); + next.close(); + first.close(); + publication.broadcast.close(); + claim.close(); + origin.close(); + }); +} + test("closing a prepared answer refuses the request and closes its broadcast", async () => { const origin = new Producer(); const claim = origin.requests(Path.from("room")); @@ -578,7 +613,7 @@ test("an epoch-pinned follower resumes when its instance returns after a gap", a const serve = (instance: Epoch.Valid, broadcast: BroadcastProducer) => { const route = origin.requestsRoute(path, { epoch: instance }); void (async () => { - for await (const request of route.requested()) hooks.acceptRequest(request, broadcast.consume()); + for await (const request of route.requested()) request.serve(broadcast.consume()); })(); return route; }; @@ -731,7 +766,7 @@ test("a pending request retries a route gap and never retargets after resolving" if (!pending) throw new Error("replacement route was not requested"); const source = new BroadcastProducer(); const keeper = source.consume(); - hooks.acceptRequest(pending, source.consume()); + pending.serve(source.consume()); await settle(); expect(requested.active.peek()?.closed).toBe(source.closed); const replacement = origin.createBroadcast(path); diff --git a/js/net/src/origin.test.ts b/js/net/src/origin.test.ts index 4fd0b169a1e..4a951c08dfa 100644 --- a/js/net/src/origin.test.ts +++ b/js/net/src/origin.test.ts @@ -6,7 +6,7 @@ import { type Consumer as BroadcastConsumer, Producer as BroadcastProducer } fro import * as Epoch from "./epoch.ts"; import { StreamCode, StreamError } from "./error.ts"; import { HopSchema, Route } from "./hop.ts"; -import { hooks, spreadHash } from "./internal.ts"; +import { spreadHash } from "./internal.ts"; import { SessionBroadcast, textFrame } from "./mock.ts"; import type { Consumer, Table } from "./origin.ts"; import { Producer } from "./origin.ts"; @@ -33,7 +33,7 @@ function serve(origin: Producer, prefix: Path.Valid, consume: () => BroadcastCon void (async () => { try { for await (const request of handle.requested()) { - hooks.acceptRequest(request, consume()); + request.serve(consume()); } } catch { handle.close(); @@ -1108,7 +1108,7 @@ test("a handle serves a request under live", async () => { const produced = new BroadcastProducer(); produced.createTrack("video", { timescale: Timescale.MILLI }); - hooks.acceptRequest(req, produced); + req.serve(produced); await settle(); expect(request.active.peek()).toBeDefined(); @@ -1122,7 +1122,7 @@ test("a handle serves a request under live", async () => { origin.close(); }); -test("an originated route refuses a broadcast a session delivered", async () => { +test("an originated route serves held content a session delivered", async () => { const origin = new Producer(); const handle = origin.requestsRoute(Path.from("live")); const it = handle.requested(); @@ -1133,15 +1133,10 @@ test("an originated route refuses a broadcast a session delivered", async () => // What lite and IETF do when a session hands back a consumed broadcast. const foreign = new BroadcastProducer().consume(); overrideBroadcastWire(foreign, {}); - expect(() => hooks.acceptRequest(req, foreign)).toThrow("origin cannot serve a broadcast it did not produce"); - - const produced = new BroadcastProducer(); - produced.createTrack("video"); - hooks.acceptRequest(req, produced.consume()); + req.serve(foreign); expect(await pending).toBeDefined(); handle.close(); - produced.close(); foreign.close(); origin.close(); }); @@ -1188,7 +1183,7 @@ test("an accepted dynamic broadcast is retired when it closes", async () => { const first = await it.next(); const produced = new BroadcastProducer(); produced.createTrack("video", { timescale: Timescale.MILLI }); - hooks.acceptRequest(first.value, produced); + first.value.serve(produced); await settle(); expect(request.active.peek()?.track("video").subscribe()).toBeDefined(); @@ -1200,7 +1195,7 @@ test("an accepted dynamic broadcast is retired when it closes", async () => { expect(second.value?.path).toBe(path); const replacement = new BroadcastProducer(); replacement.createTrack("video", { timescale: Timescale.MILLI }); - hooks.acceptRequest(second.value, replacement); + second.value.serve(replacement); await settle(); expect(request.active.peek()?.track("video").subscribe()).toBeDefined(); @@ -1238,7 +1233,7 @@ test("a peer is offered and served the cheapest originated route", async () => { const pending = wireOf(consumer).demand(Path.from("live/cam")); const { value: req } = await cheap.requested().next(); const upstream = new BroadcastProducer(); - hooks.acceptRequest(req, upstream.consume()); + req.serve(upstream.consume()); expect(await pending).toBeDefined(); // An exact-path local broadcast competes with them on cost too. @@ -1298,7 +1293,7 @@ test("a request refusal does not keep demand from asking again", async () => { const { value: second } = await it.next(); expect(second?.path).toBe(Path.from("live/cam")); const produced = new BroadcastProducer(); - hooks.acceptRequest(second, produced); + second.serve(produced); await expect(pending).resolves.toBeDefined(); handle.close(); @@ -1322,7 +1317,7 @@ test("advancing requested without settling rejects the previous request", async await expect(firstDemand).rejects.toMatchObject({ code: StreamCode.Unroutable }); const produced = new BroadcastProducer(); - hooks.acceptRequest(second.value, produced); + second.value.serve(produced); await expect(secondDemand).resolves.toBeDefined(); handle.close(); @@ -1388,7 +1383,7 @@ test("an outranked route keeps serving until its replacement answers", async () // Once it answers, the request's tracks read it, under the same broadcast. const replacement = new BroadcastProducer(); const { value: req } = await asked; - hooks.acceptRequest(req, replacement.consume()); + req.serve(replacement.consume()); await settle(); expect(request.active.peek()).toBe(first); expect(readsFrom(first, replacement)).toBe(true); @@ -1724,7 +1719,7 @@ test("a refusal from a superseded route does not end the request", async () => { expect(request.closed.peek()).toBeUndefined(); const produced = new BroadcastProducer(); - hooks.acceptRequest(req, produced); + req.serve(produced); await settle(); expect(request.active.peek()).toBeDefined(); @@ -1776,7 +1771,7 @@ test("close rejects queued requests as unroutable", async () => { expect((await handle.requested().next()).done).toBe(true); expect(request.active.peek()).toBeUndefined(); - hooks.acceptRequest(req, new BroadcastProducer()); + req.serve(new BroadcastProducer()); await settle(); expect(request.active.peek()).toBeUndefined(); @@ -1846,7 +1841,7 @@ test("announced filters before rooting and retains lifecycle, routing and watch const request = reader.request(Path.from("cam")); const incoming = await broad.requested().next(); if (!incoming.value) throw new Error("missing served request"); - hooks.acceptRequest(incoming.value, source.consume()); + incoming.value.serve(source.consume()); await new Promise((resolve) => setImmediate(resolve)); expect(request.active.peek()).toBeDefined(); request.close(); @@ -1892,7 +1887,7 @@ test("an equal-cost pool spreads its paths the same way on every node", async () void (async () => { for await (const request of handle.requested()) { served.set(request.path, hop); - hooks.acceptRequest(request, new BroadcastProducer()); + request.serve(new BroadcastProducer()); } })(); return handle; @@ -1931,7 +1926,7 @@ test("an equal-cost replacement at its own path wins whatever its hop", async () void (async () => { for await (const request of handle.requested()) { served.push(hop); - hooks.acceptRequest(request, new BroadcastProducer()); + request.serve(new BroadcastProducer()); } })(); return handle; @@ -2153,7 +2148,7 @@ test("a scoped dynamic only serves allowed paths and presents relative requests" await new Promise((resolve) => setImmediate(resolve)); expect(pending.value?.path).toBe(Path.from("room/alice/chat")); const broadcast = new BroadcastProducer(); - hooks.acceptRequest(pending.value, broadcast); + pending.value.serve(broadcast); await new Promise((resolve) => setImmediate(resolve)); expect(request.active.peek()).toBeDefined(); dynamic.updateRoute({ cost: 2n }); @@ -2291,7 +2286,7 @@ test("broadcast handles carry the path they were created or requested at", async const request = origin.request(Path.from("live/bob")); const pending = await dynamic.requested().next(); const served = new BroadcastProducer(); - hooks.acceptRequest(pending.value, served); + pending.value.serve(served); expect(request.active.peek()?.path).toBe(Path.from("live/bob")); clone?.close(); @@ -2339,12 +2334,12 @@ test("demand held across an epoch change asks again, unless it named the old epo // Another instance now serves the route: the old handler's answer is for the old one. handle.updateRoute({ ...handle.route, epoch: NEWER }); - hooks.acceptRequest(req, new BroadcastProducer().consume()); + req.serve(new BroadcastProducer().consume()); await expect(pinned).rejects.toThrow("unroutable"); const next = new BroadcastProducer(); const track = next.createTrack("video"); - hooks.acceptRequest((await it.next()).value, next); + (await it.next()).value.serve(next); const subscription = (await unpinned)?.track("video").subscribe(); track.createGroup(7); expect((await subscription?.recvGroup())?.sequence).toBe(7); @@ -2388,11 +2383,11 @@ test("demand held across an epoch round trip still asks again", async () => { // Released by the first change; the epoch coming back does not undo that. handle.updateRoute({ ...handle.route, epoch: NEWER }); handle.updateRoute({ ...handle.route, epoch: EPOCH }); - hooks.acceptRequest(req, new BroadcastProducer().consume()); + req.serve(new BroadcastProducer().consume()); const next = new BroadcastProducer(); const track = next.createTrack("video"); - hooks.acceptRequest((await it.next()).value, next); + (await it.next()).value.serve(next); const subscription = (await demanded)?.track("video").subscribe(); track.createGroup(7); expect((await subscription?.recvGroup())?.sequence).toBe(7); @@ -2482,13 +2477,13 @@ test("a request held across an epoch change asks again and never takes the old h const old = (await requests.next()).value; dynamic.updateRoute({ ...dynamic.route, epoch: NEWER }); const current = origin.consume().request(path, { epoch: NEWER }); - hooks.acceptRequest(old, new BroadcastProducer().consume()); + old.serve(new BroadcastProducer().consume()); await settle(); expect(pinned.active.peek()).toBeUndefined(); expect(unpinned.active.peek()).toBeUndefined(); expect(current.active.peek()).toBeUndefined(); const next = (await requests.next()).value; - hooks.acceptRequest(next, new BroadcastProducer().consume()); + next.serve(new BroadcastProducer().consume()); await settle(); expect(unpinned.active.peek()?.epoch).toBe(NEWER); expect(current.active.peek()?.epoch).toBe(NEWER); @@ -2517,7 +2512,7 @@ test.each([ const held = origin.consume().request(path); const old = new BroadcastProducer(); const oldTrack = old.createTrack("video"); - hooks.acceptRequest((await requests.next()).value, old); + (await requests.next()).value.serve(old); await settle(); const resolved = held.active.peek(); expect(resolved?.epoch).toBe(from); @@ -2554,7 +2549,7 @@ test.each([ const demanded = wireOf(origin.consume()).demand(path); const next = new BroadcastProducer(); const nextTrack = next.createTrack("video"); - hooks.acceptRequest((await requests.next()).value, next); + (await requests.next()).value.serve(next); await settle(); expect(fresh.active.peek()?.epoch).toBe(to); const subscription = fresh.active.peek()?.track("video").subscribe(); @@ -2595,7 +2590,7 @@ test("an epoch update does not retain an answer that already closed", async () = const requests = dynamic.requested(); const held = origin.consume().request(path); const old = new BroadcastProducer(); - hooks.acceptRequest((await requests.next()).value, old); + (await requests.next()).value.serve(old); old.close(); // The server's closure callback has not removed the answer yet. dynamic.updateRoute({ epoch: NEWER }); @@ -2604,7 +2599,7 @@ test("an epoch update does not retain an answer that already closed", async () = expect(held.active.peek()).toBeUndefined(); const fresh = origin.consume().request(path); const next = new BroadcastProducer(); - hooks.acceptRequest((await requests.next()).value, next); + (await requests.next()).value.serve(next); expect(fresh.active.peek()?.epoch).toBe(NEWER); fresh.close(); next.close(); @@ -2623,7 +2618,7 @@ test("an unread resolved request retains its broadcast until its last handle clo const requests = dynamic.requested(); const held = origin.consume().request(path); const old = new SessionBroadcast(); - hooks.acceptRequest((await requests.next()).value, old); + (await requests.next()).value.serve(old); // Change epochs before the active getter or its subscription can clone the answer. dynamic.updateRoute({ epoch: NEWER }); expect(old.closed.peek()).toBeUndefined(); @@ -2645,14 +2640,14 @@ test("a session's re-request after an epoch update asks the handler again", asyn const before = wire.demand(path); const old = new BroadcastProducer(); - hooks.acceptRequest((await requests.next()).value, old); + (await requests.next()).value.serve(old); expect(await before).toBeDefined(); dynamic.updateRoute({ ...dynamic.route, epoch: NEWER }); const after = wire.demand(path); const next = new BroadcastProducer(); const track = next.createTrack("video"); - hooks.acceptRequest((await requests.next()).value, next); + (await requests.next()).value.serve(next); const subscription = (await after)?.track("video").subscribe(); track.createGroup(7); expect((await subscription?.recvGroup())?.sequence).toBe(7); @@ -2676,7 +2671,7 @@ test("an update does not override route selection: another claim at the epoch ke const held = origin.consume().request(path); const answer = new BroadcastProducer(); - hooks.acceptRequest((await firstRequests.next()).value, answer); + (await firstRequests.next()).value.serve(answer); await settle(); expect(held.active.peek()?.epoch).toBe(EPOCH); @@ -2686,7 +2681,7 @@ test("an update does not override route selection: another claim at the epoch ke const fresh = origin.consume().request(path); const replacement = new BroadcastProducer(); const track = replacement.createTrack("video"); - hooks.acceptRequest((await secondRequests.next()).value, replacement); + (await secondRequests.next()).value.serve(replacement); await settle(); expect(held.active.peek()?.epoch).toBe(EPOCH); expect(fresh.active.peek()?.epoch).toBe(EPOCH); diff --git a/js/net/src/origin.ts b/js/net/src/origin.ts index 772b34f40a4..f32c932d205 100644 --- a/js/net/src/origin.ts +++ b/js/net/src/origin.ts @@ -343,13 +343,10 @@ class ServeState { readonly root: Path.Valid; /** The prefix the route claims; every served path is at or beneath it. */ readonly prefix: Path.Valid; - /** False when a session announced the route: it may serve that session's broadcast. */ - readonly originated: boolean; - constructor(root: Path.Valid, prefix: Path.Valid, originated: boolean) { + constructor(root: Path.Valid, prefix: Path.Valid) { this.root = root; this.prefix = prefix; - this.originated = originated; } queue = new Signal(new Set()); @@ -1334,7 +1331,7 @@ export class Producer implements Table { return this.#insertRoute(prefix, Route.default, true, true); } - /** Insert an originated claim with route metadata that answers through `hooks.acceptRequest`, for tests and benches. @internal */ + /** Insert an originated claim with route metadata that answers through `Request.serve`, for tests and benches. @internal */ requestsRoute( prefix: Path.Valid, route: @@ -1372,7 +1369,7 @@ export class Producer implements Table { #insertRoute(prefix: Path.Valid, route: Route, originated: boolean, publishes: boolean): Requests { prefix = this.#scope.prefix(prefix); publishPath(prefix); - const server = new ServeState(this.#scope.root, prefix, originated); + const server = new ServeState(this.#scope.root, prefix); server.onChange = (path) => this.#state.refresh(path); const entry: RouteEntry = { identity: {}, @@ -2389,7 +2386,8 @@ export class Requests { * A pending request for a broadcast to be served on demand. * * Yielded by {@link Requests.requested}. {@link prepare} then {@link Prepared.publish} - * resolves it with a new exact-path broadcast; {@link reject} resolves it with an error. + * resolves it with a new exact-path broadcast; {@link serve} answers with a held broadcast; + * {@link reject} resolves it with an error. * Advancing the iterator or closing it without either rejects the request. * * @public @@ -2418,7 +2416,10 @@ export class Request { // The exact route usually settles the request on its own, resolving its waiters // through the new epoch; answer it directly if it is still pending. publication.announce({ epoch }); - if (request.#server.has(request)) request.#server.accept(request, publication.broadcast.consume()); + // Its exact route owns availability: never cache a published job under the + // prefix, which would keep serving it after that exact route is withdrawn. + request.#server.forget(Path.join(request.#server.root, request.path), request); + request.#server.settled.update((n) => n + 1); return publication; }; rejectPrepared = (request, err) => request.#server.reject(request, err); @@ -2427,7 +2428,6 @@ export class Request { request.#withdrawn = true; void err; }; - hooks.acceptRequest = (request, source) => request.#accept(source); } /** Start answering as a new publisher instance, hidden until published. */ @@ -2441,22 +2441,21 @@ export class Request { return makePrepared(this, publication, epoch); } - // Resolve a session-forwarded request with its peer's routed broadcast, through - // `hooks.acceptRequest`. The caller keeps producing into `source`; repeat requests for - // the path share it for as long as it stays live. Throws when handed a broadcast a - // session delivered to an originated claim, leaving the request open: it would go out - // labeled with this origin's hop. - #accept(source: broadcast.Producer | broadcast.Consumer): void { + /** + * Serve a held broadcast under this prefix route without announcing an exact route. + * + * Takes ownership of a consumer; a producer stays the caller's. Every answer at this + * path belongs to the prefix route's instance and must continue the same sequences and + * bytes. Start a new prefix route for different content, or use {@link prepare} and + * {@link Prepared.publish} for a job that can restart independently. + */ + serve(source: broadcast.Producer | broadcast.Consumer): void { if (this.#done) { // A withdrawn request takes no answer. Only the handed-off consumer is ours; // the application still owns its producer and any other consumers. if (this.#withdrawn && source instanceof broadcast.Consumer) source.close(); return; } - if (this.#publisher) throw new Error("claim answers must be prepared and published"); - if (this.#server.originated && !(source instanceof broadcast.Producer) && wireOf(source).fromSession) { - throw new Error("origin cannot serve a broadcast it did not produce"); - } this.#done = true; const front = source instanceof broadcast.Producer ? source.consume() : source; this.#server.accept(this, front); diff --git a/js/net/src/resume.model.test.ts b/js/net/src/resume.model.test.ts index 74ec1f0c953..7b62ed578cb 100644 --- a/js/net/src/resume.model.test.ts +++ b/js/net/src/resume.model.test.ts @@ -445,10 +445,7 @@ class Model { const producer = broadcast.createTrack("video", { timescale: Timescale.MILLI }); void (async () => { for await (const request of serving.requested()) { - hooks.acceptRequest( - request, - Upstream.of(broadcast, (sequence, local) => this.fill(epoch, slot, sequence, local)), - ); + request.serve(Upstream.of(broadcast, (sequence, local) => this.fill(epoch, slot, sequence, local))); } })(); instance.routes[slot] = { track: producer, serving, broadcast, groups: new Map(), givenUp: new Set() }; diff --git a/js/net/src/resume.test.ts b/js/net/src/resume.test.ts index ff64b7ca39e..97bc3c33e07 100644 --- a/js/net/src/resume.test.ts +++ b/js/net/src/resume.test.ts @@ -40,7 +40,7 @@ async function isPending(promise: Promise): Promise { function serve(origin: Producer, source: BroadcastProducer, cost: bigint) { const handle = wireOf(origin).receive(path, Route.normalize({ epoch: EPOCH, cost })); void (async () => { - for await (const request of handle.requested()) hooks.acceptRequest(request, source.consume()); + for await (const request of handle.requested()) request.serve(source.consume()); })(); return () => handle.close(); } @@ -901,7 +901,7 @@ test("between routes a reader keeps reading the copy it has", async () => { expect(drain(sub)).toEqual([1]); const { value: pending } = await asked.next(); - hooks.acceptRequest(pending, b.consume()); + pending.serve(b.consume()); await settle(); await settle(); tb.write(1); diff --git a/js/net/src/untimed.test.ts b/js/net/src/untimed.test.ts index 3579fbf1b8d..bd28ce9b074 100644 --- a/js/net/src/untimed.test.ts +++ b/js/net/src/untimed.test.ts @@ -4,7 +4,6 @@ import { expect, test } from "bun:test"; import { type Consumer as BroadcastConsumer, Producer as BroadcastProducer } from "./broadcast.ts"; import { accept, connect } from "./connection/index.ts"; import * as Ietf from "./ietf/index.ts"; -import { hooks } from "./internal.ts"; import * as Lite from "./lite/index.ts"; import { createMockTransportPair } from "./mock.ts"; import { Producer as OriginProducer } from "./origin.ts"; @@ -134,7 +133,7 @@ test("a forwarded untimed track stays untimed", async () => { for await (const request of dynamic.requested()) { const input = wireOf(ingest).consume(request.path); inputs.push(input); - hooks.acceptRequest(request, await republish(input)); + request.serve(await republish(input)); } })(); diff --git a/py/moq-rs/README.md b/py/moq-rs/README.md index 372b7c006bb..6807295c7db 100644 --- a/py/moq-rs/README.md +++ b/py/moq-rs/README.md @@ -260,7 +260,7 @@ Every handle whose cleanup is `cancel()` is an async context manager, so exiting - `.broadcast → BroadcastProducer`. The broadcast to fill. - `.announce(route=None)`, `.unannounce()`. Advertise or retract its exact path; both raise `Closed` once the broadcast closed. - **`OriginRequests`**. Async source of broadcasts requested by consumers. - - `await .requested_broadcast() → BroadcastRequest`. Call `.prepare(mint_epoch())`, fill its `.broadcast`, then `.publish() → Publication` to serve it under a new epoch, or `.reject(code)` to fail the requester. + - `await .requested_broadcast() → BroadcastRequest`. Call `.serve(consumer)` to answer with held content under the prefix route's continuous sequence space, `.prepare(mint_epoch())` then `.publish() → Publication` for an independently restarting job, or `.reject(code)` to fail the requester. - Async iterator yielding `BroadcastRequest` - **`OriginConsumer`**. Discover broadcasts. - `.announced(prefix, filter=None) → AnnounceConsumer` (async iterator of `AnnounceEvent`: `AnnounceEventStart`, `AnnounceEventUpdate`, `AnnounceEventEnd`, `AnnounceEventRestart`, or `AnnounceEventTakeover`, each carrying an `Announce` whose `.route.epoch` names the publisher run; on a restart, request the path again; a takeover continues what the route at `.predecessor` served); `filter` is a pattern relative to the literal prefix, while each `Announce.prefix` stays origin-relative and `.captures` reports wildcard matches diff --git a/py/moq-rs/moq/origin.py b/py/moq-rs/moq/origin.py index 4d7dc876a36..d977279b45d 100644 --- a/py/moq-rs/moq/origin.py +++ b/py/moq-rs/moq/origin.py @@ -123,6 +123,10 @@ def prepare(self, epoch: str) -> BroadcastPrepared: """Start an answer under a new epoch, hidden until published.""" return BroadcastPrepared(self._inner.prepare(epoch)) + def serve(self, broadcast: BroadcastConsumer) -> None: + """Serve held content under the prefix route's continuous sequence space, without an exact route.""" + self._inner.serve(broadcast._inner) + def reject(self, error_code: int) -> None: """Reject the request with an application error code.""" self._inner.reject(error_code) diff --git a/py/moq-rs/tests/test_local.py b/py/moq-rs/tests/test_local.py index 3efedb002bc..2706021f022 100644 --- a/py/moq-rs/tests/test_local.py +++ b/py/moq-rs/tests/test_local.py @@ -796,6 +796,27 @@ async def test_dynamic_broadcast_request(): served.broadcast.close() +async def test_dynamic_serves_held_content_without_an_exact_route(): + origin = moq.OriginProducer() + dynamic = origin.requests("live") + held = moq.BroadcastProducer() + track = held.publish_track("status", moq.TrackInfo(timescale=1_000_000)) + source = held.consume() + requesting = asyncio.create_task(origin.consume().request("live/cam")) + request = await dynamic.requested_broadcast() + request.serve(source) + with pytest.raises(Exception): + request.serve(source) + broadcast = await requesting + reader = await broadcast.subscribe_track("status") + track.write_frame(b"held", timedelta(microseconds=1)) + frame = await reader.read_frame() + assert frame is not None and frame.payload == b"held" + track.finish() + held.close() + dynamic.cancel() + + async def test_dynamic_broadcast_request_can_reject(): origin = moq.OriginProducer() dynamic = origin.requests("") diff --git a/quest/m1/announce-takeover.md b/quest/m1/announce-takeover.md index fcee6f58a0c..b6ccf2dfe9d 100644 --- a/quest/m1/announce-takeover.md +++ b/quest/m1/announce-takeover.md @@ -61,7 +61,7 @@ this quest removes the predecessor machinery and grows to [XL]. [One Route handle](/quest/m1/api-audit/route/handle.md) creates the path's exact route under the prefix route's identity by default, and the answer it gives the waiting request is that route's broadcast. A job - that serves a held broadcast through [serve](/quest/m1/api-audit/route/serve.md) + that serves a held broadcast through `Request::serve` never announces an exact route, so it needs none of this. - **One stream per path and identity.** A claim may answer a path under its identity only while that stream is live. Once the job's route ends, diff --git a/quest/m1/api-audit/route/README.md b/quest/m1/api-audit/route/README.md index 926c5b7d9a1..dd7b3a3c53e 100644 --- a/quest/m1/api-audit/route/README.md +++ b/quest/m1/api-audit/route/README.md @@ -36,7 +36,7 @@ resets is serving a held broadcast with no separate exact route. The user's "it worked before #6496" did not reproduce on any older tree, including one before [moq-dev/moq#5678](https://github.com/moq-dev/moq/pull/5678). Their proposed `accept_published(&Publication)` would not avoid the reset, -so it was dropped. Their relay instead gets [serve](/quest/m1/api-audit/route/serve.md). +so it was dropped. Their relay instead uses `Request::serve` for its held broadcast. The maintainer then asked for an audit of the origin, claim and epoch API. Four read-only audits covered the Rust surface, JS and the bindings, the @@ -151,7 +151,6 @@ stale, including `doc/concept/identity.md`. ## Required -- [Serve a held broadcast](/quest/m1/api-audit/route/serve.md) - a prefix route's request can be answered with a broadcast the app already holds, and the first subscribe succeeds on every wire - [Identity and epoch](/quest/m1/api-audit/route/identity.md) - every route carries an `identity` (one continuous stream) and a private per-identity epoch, ranked newest within an identity and hashed across identities, with no epochless routes left in the origin - [One Route handle](/quest/m1/api-audit/route/handle.md) - `Publication`, `Prepared`, `Announcer` and `Requests` become one `Route` that owns its broadcast, with app options separate from transit facts - [Identities are percent-encoded in paths](/quest/m1/api-audit/route/identity-encoding.md) - HLS URLs and archive keys round-trip any stable identity diff --git a/quest/m1/api-audit/route/handle.md b/quest/m1/api-audit/route/handle.md index 8f3fc272d48..da9aced9df2 100644 --- a/quest/m1/api-audit/route/handle.md +++ b/quest/m1/api-audit/route/handle.md @@ -62,7 +62,7 @@ JS and the bindings identical. prefix route's `serve`, as today, where a standalone broadcast cannot be announced. - **Prefix routes.** A prefix route yields requests, and each one is - answered by `serve(consumer)` (from [serve](/quest/m1/api-audit/route/serve.md)), + answered by `serve(consumer)`, by `route(options)`, or by `reject`. `route(options)` creates the path's exact `Route`, which inherits the prefix route's identity by default so that the reader continues (see [announce takeover](/quest/m1/announce-takeover.md)). @@ -109,7 +109,6 @@ wrappers. Wire: none. ## Required - [Identity and epoch](/quest/m1/api-audit/route/identity.md) - the identity a route mints and keeps -- [Serve a held broadcast](/quest/m1/api-audit/route/serve.md) - the served answer this handle carries over ## Related diff --git a/quest/m1/api-audit/route/serve.md b/quest/m1/api-audit/route/serve.md deleted file mode 100644 index 2f00e95cce1..00000000000 --- a/quest/m1/api-audit/route/serve.md +++ /dev/null @@ -1,54 +0,0 @@ -# [M] Serve a held broadcast - -## Goal - -An application answering a prefix route's request can hand over a broadcast -it already holds: `request.serve(consumer)` in Rust and -`request.serve(broadcast)` in JS, mirrored in moq-ffi, moq-c and the -wrappers. The answer is served under the prefix route's own identity and -announces no exact route. A client's first subscribe through it succeeds -over moq-transport-18, moq-transport-22, moq-lite-06 and moq-lite-07-wip. - -Non-goals: the route handle rename ([One Route handle](/quest/m1/api-audit/route/handle.md) -carries `serve` over), and removing the reset for answers that announce a -per-path route ([announce takeover](/quest/m1/announce-takeover.md)). - -## Plan - -Decided 2026-10-30 (maintainer); see the [epic](/quest/m1/api-audit/route/README.md). -This lands first, on today's `origin::Requests`/`Request`, so moq.pro's -sync-ingest mirror (`rs/edge/src/sync/ingest.rs`, which calls -`request.accept`) and the external relay operator have a supported answer -before the larger rework. - -- Make the crate-private `Request::accept` (`rs/moq-net/src/model/origin.rs`) - public as `serve`, for application claims as well as sessions. Replace the - `compile_fail,E0624` doctest with usage docs. In JS, expose `#accept` as - `serve` and drop `hooks.acceptRequest` if nothing else needs it. -- Contract, in rustdoc and `doc/concept/identity.md`: a served answer is - part of the prefix route's stream at that path. Today that means its - instance; after [Identity and epoch](/quest/m1/api-audit/route/identity.md), - its identity, which promises one continuous sequence space per path. To - serve different bytes at a path that was already served, start a new - prefix route rather than serving new bytes under the old one. A job that - may restart per path answers with `prepare`/`publish`, and takes the - cold-start reset until [announce takeover](/quest/m1/announce-takeover.md). -- Served-answer cache: an answer that `prepare`/`publish` stored in the - prefix route's served cache must not serve a later request once its - exact route is withdrawn. Check `ServeState`'s cache on withdrawal, fix - it if the answer survives, and test it. -- Tests: turn the reproduction from planning into an integration test in - `rs/moq-net-tests/tests/integration/`. A server origin `requests("")` - linked over `transport::memory`; the handler serves a held broadcast; the - client's first `request` plus `subscribe` reads a frame on every version - above. Keep the prepare/publish case asserting today's reset, so - takeover's change to it is visible. Mirror it in `js/net`. -- `MIGRATE.md` (rs/moq-net, js/net): mention `serve` beside the existing - #6496 entry. It is additive. - -Public API: additive `Request::serve` in Rust, JS and the bindings. Wire: -none. - -## Related - -- [moq-dev/moq#6496](https://github.com/moq-dev/moq/pull/6496) - made `accept` crate-private; this reopens it under a stated contract diff --git a/rs/moq-c/src/api.rs b/rs/moq-c/src/api.rs index 167aa555d7e..1ebfa08a698 100644 --- a/rs/moq-c/src/api.rs +++ b/rs/moq-c/src/api.rs @@ -2074,6 +2074,27 @@ pub unsafe extern "C" fn moq_broadcast_request_path(request: u32, dst: *mut moq_ }) } +/// Serve a held consumer under the prefix route's instance without announcing an exact route. +/// +/// Every answer at this path must continue the same sequences and bytes. Start a new +/// prefix route for different content, or prepare and publish a job with its own instance. +/// Consumes the request handle; the consumer remains owned by the caller. +/// Returns zero on success, or a negative error. +#[unsafe(no_mangle)] +pub extern "C" fn moq_broadcast_request_serve(request: u32, broadcast: u32) -> i32 { + ffi::enter(move || { + let request = ffi::parse_id(request)?; + let broadcast = ffi::parse_id(broadcast)?; + let mut state = State::lock(); + let broadcast = state.consume.broadcast(broadcast)?; + let (request, driver) = state.origin.broadcast_request_take(request)?; + driver.check()?; + request.serve(broadcast); + driver.check()?; + Ok(()) + }) +} + /// Start a broadcast request answer under `epoch`, hidden until published. /// /// Consumes the request handle, writes the new broadcast handle to `broadcast` diff --git a/rs/moq-c/src/consume.rs b/rs/moq-c/src/consume.rs index 703a9020896..ba12cf5f725 100644 --- a/rs/moq-c/src/consume.rs +++ b/rs/moq-c/src/consume.rs @@ -242,6 +242,15 @@ pub struct Consume { } impl Consume { + /// Borrow held content for an on-demand answer without consuming the caller's handle. + pub fn broadcast(&self, id: Id) -> Result { + let context = self.broadcast.get(id).ok_or(Error::BroadcastNotFound)?; + if let Some(origin) = &context.origin { + origin.driver.check()?; + } + Ok(context.broadcast.clone()) + } + /// Buffer a broadcast the origin handed out, keeping the cursor that named it so a catalog /// rendition referencing a sibling broadcast resolves through the same origin. pub fn start( diff --git a/rs/moq-c/src/test.rs b/rs/moq-c/src/test.rs index ac4be83b61b..d79c5556b8b 100644 --- a/rs/moq-c/src/test.rs +++ b/rs/moq-c/src/test.rs @@ -3259,6 +3259,39 @@ fn dynamic_serves_a_request_under_a_prefix() { assert_eq!(moq_origin_close(origin), 0); } +#[test] +fn dynamic_serves_a_held_consumer_without_taking_its_handle() { + let origin = id(moq_origin_create()); + let broadcast = publish_broadcast(origin, b"source"); + let held = consume_local(broadcast); + let cb = Callback::new(); + let dynamic = + id(unsafe { moq_origin_requests(origin, b"live".as_ptr().cast(), 4, Some(channel_callback), cb.ptr) }); + let result = Callback::new(); + let _task = id(unsafe { + moq_origin_request( + origin, + b"live/cam".as_ptr().cast(), + 8, + std::ptr::null(), + 0, + Some(channel_callback), + result.ptr, + ) + }); + let request = id(cb.recv()); + assert_eq!(moq_broadcast_request_serve(request, held), 0); + let served = id(result.recv()); + assert!(moq_broadcast_request_serve(request, held) < 0, "request is consumed"); + assert_eq!(moq_consume_close(held), 0, "source handle remains caller-owned"); + result.recv_terminal(); + assert_eq!(moq_consume_close(served), 0); + assert_eq!(moq_origin_requests_cancel(dynamic), 0); + cb.recv_terminal(); + assert_eq!(moq_publish_close(broadcast), 0); + assert_eq!(moq_origin_close(origin), 0); +} + #[test] fn dynamic_refuses_a_missing_callback() { let origin = id(moq_origin_create()); diff --git a/rs/moq-ffi/src/origin.rs b/rs/moq-ffi/src/origin.rs index 590e3172b8f..7fda9a2012a 100644 --- a/rs/moq-ffi/src/origin.rs +++ b/rs/moq-ffi/src/origin.rs @@ -523,7 +523,7 @@ impl MoqOriginConsumer { impl MoqOriginRequests { /// Wait for the next broadcast requested through this handle's prefix. /// - /// Returns a [`MoqBroadcastRequest`]: accept it with a broadcast producer or reject + /// Returns a [`MoqBroadcastRequest`]: serve a held broadcast, prepare a new one, or reject /// it with an application error code. The requesting consumer stays pending until then. pub async fn requested_broadcast(&self) -> Result, MoqError> { let task = self.task.lock().unwrap().clone().ok_or(MoqError::Closed)?; @@ -587,6 +587,19 @@ impl MoqBroadcastRequest { })) } + /// Serve a held broadcast under the prefix route's instance without announcing an exact route. + /// + /// Every answer at this path must continue the same sequences and bytes. Start a new + /// prefix route for different content, or prepare and publish a job with its own instance. + pub fn serve(&self, broadcast: &Arc) -> Result<(), MoqError> { + let _guard = crate::ffi::enter(); + self.driver.check()?; + broadcast.driver.check()?; + self.take()?.serve(&broadcast.inner); + self.driver.check()?; + Ok(()) + } + /// Reject the request with an application error code. pub fn reject(&self, error_code: u16) -> Result<(), MoqError> { let _guard = crate::ffi::enter(); @@ -693,6 +706,24 @@ impl MoqFollowing { mod supervision_tests { use super::*; + #[tokio::test] + async fn serving_held_content_consumes_only_the_request() { + let origin = MoqOriginProducer::new(Default::default()); + let requests = origin.requests("room".into()).unwrap(); + let source = origin.create_broadcast("source".into()).unwrap().broadcast(); + let held = source.consume().unwrap(); + let consumer = origin.consume(); + let (resolved, ()) = tokio::join!(consumer.request("room/camera".into(), None), async { + let request = requests.requested_broadcast().await.unwrap(); + request.serve(&held).unwrap(); + assert!(matches!(request.serve(&held), Err(MoqError::Closed))); + }); + assert!(resolved.is_ok()); + assert!(!held.inner.is_closed(), "serving leaves the caller's consumer usable"); + requests.cancel(); + source.close().unwrap(); + } + #[tokio::test] async fn a_panicked_origin_task_reaches_the_host_while_another_origin_keeps_working() { let (inner, driver, trigger) = crate::ffi::panicking_origin(); diff --git a/rs/moq-net-tests/tests/integration/main.rs b/rs/moq-net-tests/tests/integration/main.rs index c8a31acfb55..ea8f634857e 100644 --- a/rs/moq-net-tests/tests/integration/main.rs +++ b/rs/moq-net-tests/tests/integration/main.rs @@ -3,6 +3,7 @@ mod ietf_conformance; mod refresh; mod restart; +mod serve; #[path = "../../../moq-net/tests/integration/support/mod.rs"] mod support; diff --git a/rs/moq-net-tests/tests/integration/serve.rs b/rs/moq-net-tests/tests/integration/serve.rs new file mode 100644 index 00000000000..7223cb6f407 --- /dev/null +++ b/rs/moq-net-tests/tests/integration/serve.rs @@ -0,0 +1,89 @@ +//! A held answer belongs to its prefix route; a published job has its own route. + +use std::time::Duration; + +use moq_net::{Epoch, Hop, Timestamp, Version, broadcast, origin, track}; + +use crate::support::harness::{MockConnectOptions, connect_mock, spawn}; + +fn origin(hop: u64) -> origin::Producer { + let (origin, driver) = origin::Producer::new(origin::Config::new(Hop::new(hop).unwrap())); + spawn(driver); + origin +} + +async fn first_subscribe(version: &str, publish: bool) { + let version: Version = version.parse().unwrap(); + let server = origin(1); + let client = origin(2); + let requests = server.requests("").unwrap(); + let mut options = MockConnectOptions::new(version); + options.server_publish = Some(server.consume()); + options.client_subscribe = Some(client.clone()); + let _pair = connect_mock(options).await; + + let remote = client.consume().request("camera", None).await.unwrap(); + let read = async { + let mut reader = remote.track("video")?.subscribe(None).await?; + let mut group = reader.recv_group().await?.ok_or(moq_net::Error::Unroutable)?; + let frame = group.read_frame().await?.ok_or(moq_net::Error::Unroutable)?; + Ok::<_, moq_net::Error>(frame.payload) + }; + // A held broadcast needs no origin or announcement of its own. + let held = broadcast::Info::new().produce(); + let held_track = held.create_track("video", track::Info::default().with_timescale(moq_net::Timescale::MILLI)).unwrap(); + let mut group = held_track.append_group().unwrap(); + group.write_frame(Timestamp::ZERO, b"held".as_slice()).unwrap(); + group.finish().unwrap(); + let handler = async { + if publish { + let prepared = requests + .requested_broadcast() + .await + .unwrap() + .prepare(Epoch::mint()) + .unwrap(); + let track = prepared + .broadcast() + .create_track("video", track::Info::default().with_timescale(moq_net::Timescale::MILLI)) + .unwrap(); + let mut group = track.append_group().unwrap(); + group.write_frame(Timestamp::ZERO, b"held".as_slice()).unwrap(); + group.finish().unwrap(); + Some(prepared.publish().unwrap()) + } else { + requests.requested_broadcast().await.unwrap().serve(&held); + None + } + }; + let (result, _publication) = futures::join!(read, handler); + if publish && version != "moq-lite-07-wip".parse().unwrap() { + assert!( + result.is_err(), + "{version}: publishing an exact route still resets the first subscribe" + ); + } else { + assert_eq!(result.unwrap().as_ref(), b"held", "{version}"); + } +} + +macro_rules! cases { + ($($name:ident: $version:literal, $publish:literal;)*) => {$( + #[moq_clock::test] + async fn $name() { + moq_clock::timeout(Duration::from_secs(10), first_subscribe($version, $publish)) + .await.expect("first subscribe stalled"); + } + )*}; +} + +cases! { + serve_ietf18: "moq-transport-18", false; + serve_ietf22: "moq-transport-22", false; + serve_lite06: "moq-lite-06", false; + serve_lite07: "moq-lite-07-wip", false; + publish_ietf18: "moq-transport-18", true; + publish_ietf22: "moq-transport-22", true; + publish_lite06: "moq-lite-06", true; + publish_lite07: "moq-lite-07-wip", true; +} diff --git a/rs/moq-net/MIGRATE.md b/rs/moq-net/MIGRATE.md index eede46d4122..dcbfc3c4c88 100644 --- a/rs/moq-net/MIGRATE.md +++ b/rs/moq-net/MIGRATE.md @@ -265,7 +265,8 @@ Treat a failed group read as the loss of that group and keep reading the track, Answer each `origin::Request` with `request.prepare(epoch)?` (a fresh `Epoch::mint()` per output run), fill `prepared.broadcast()`, then `prepared.publish()?`, which announces the broadcast at the exact path under that epoch and returns its producer. Only `publish` announces it: `prepared.broadcast().announce(..)` fails with `Error::Closed`. `Dynamic::update` is gone: drop the claim and claim again to change it, and close an answer's producer to end that output. -`Request::accept`, `Producer::dynamic_route`, and `Dynamic::update_route` are crate-private (#6496): only the built-in sessions answer with a broadcast they already hold. +`Producer::dynamic_route` and `Dynamic::update_route` remain crate-private (#6496). +`Request::serve(consumer)` additively exposes the former private `accept`: answer with a held broadcast without announcing an exact route. The prefix route promises the same bytes and continuous sequences at each served path; start a new prefix route for different content, or prepare and publish an independent job. Dropping a `Prepared` unpublished refuses the request, as dropping a `Request` does, and `publish` fails with `Error::Unroutable` once the claim went away. ### Anchors can name a time (#6074) diff --git a/rs/moq-net/src/fuzz.rs b/rs/moq-net/src/fuzz.rs index 052d2d938ce..1bc4d3e6dca 100644 --- a/rs/moq-net/src/fuzz.rs +++ b/rs/moq-net/src/fuzz.rs @@ -409,7 +409,7 @@ pub fn update_route(dynamic: &crate::origin::Requests, route: crate::origin::Rou /// Answer a peer claim's request with the broadcast its session already holds. pub fn accept(request: crate::origin::Request, broadcast: impl crate::Consume) { - request.accept(broadcast) + request.serve(broadcast) } /// A session's snapshot of its peer's initial announcements, for the synced bench. diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index f1da9ff01ea..b9959d6ed17 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -8782,7 +8782,7 @@ mod serve_tests { auth.handle().authorize(¬hing()); let output = crate::broadcast::Info::new().produce(); let _track = output.create_track("video", None).unwrap(); - request.accept(&output); + request.serve(&output); answer.await; let code = refusal_code(&h.log.writes.lock().unwrap()[mark..], version); diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index d8d635e8e8b..0a5efb2e9be 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -2720,7 +2720,7 @@ impl Subscriber { // The handler exists before the requester sees the source, so a track it asks // for before `run_broadcast` first polls queues instead of failing `NotFound`. let dynamic = source.requests(); - request.accept(&*source); + request.serve(&*source); // The namespace's token closes the source as it is retracted. If it was // retracted since the accept, close it here as that retraction would have, diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index 0ce4ed44bb7..8ed0482c597 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -6849,7 +6849,7 @@ impl Announced { // `NotFound`. Accepted before the push, so the requester holds the source // before its serve machine can see it unheld. let dynamic = source.requests(); - request.accept(&source); + request.serve(&source); let _ = subscriber.sources.try_push(MintedSource { path, epoch: entry.route.epoch.clone(), diff --git a/rs/moq-net/src/model/follow.rs b/rs/moq-net/src/model/follow.rs index 687e5f7c6fa..bcf608f4940 100644 --- a/rs/moq-net/src/model/follow.rs +++ b/rs/moq-net/src/model/follow.rs @@ -572,7 +572,7 @@ mod tests { exact.unannounce(); let served = broadcast::Info::new().produce(); let (again, ()) = futures::join!(available(&mut announced), async { - requested(&dynamic).await.accept(&served); + requested(&dynamic).await.serve(&served); }); assert!(again.is_clone(&first), "the route above did not carry the instance on"); } diff --git a/rs/moq-net/src/model/origin.rs b/rs/moq-net/src/model/origin.rs index ce60949c0e9..e263282ac6b 100644 --- a/rs/moq-net/src/model/origin.rs +++ b/rs/moq-net/src/model/origin.rs @@ -5780,7 +5780,7 @@ impl OriginState { /// One-shot result of a dynamic broadcast request. /// -/// Stays `None` until a handler [`accept`](Request::accept)s (yielding the served +/// Stays `None` until a handler [`serve`](Request::serve)s (yielding the served /// broadcast) or [`reject`](Request::reject)s (yielding an error). The producer is /// dropped right after writing, closing the channel; kio checks the value before the closed /// flag, so an awaiting requester still observes the final result. @@ -6093,12 +6093,7 @@ impl ServeState { producer: &kio::Producer, result: Result, ) -> Option> { - if self.closed { - return None; - } - // Released already (the route changed instance): the answer was for the old one, - // so nothing resolves or caches it. - self.requests.remove_if(path, |p| p.same_channel(producer))?; + self.take(path, producer)?; let state = self; let resolved = match result { Ok(broadcast) => { @@ -6124,6 +6119,15 @@ impl ServeState { Some(resolved) } + /// Admit an answer only while its request still belongs to this route instance. + fn take(&mut self, path: &Path, producer: &kio::Producer) -> Option<()> { + if self.closed { + return None; + } + self.requests.remove_if(path, |p| p.same_channel(producer))?; + Some(()) + } + /// Release every request, queued or handed to a handler, and forget the answers served, /// because the route now names another publisher instance. Returns the released /// requests for the caller to refuse once it holds no lock, since the refusal wakes @@ -6147,14 +6151,14 @@ impl ServeState { /// /// Yielded by [`Requests::poll_requested_broadcast`]. The requester is awaiting inside /// [`Consumer::request`]; [`prepare`](Self::prepare) then [`Prepared::publish`] -/// resolves it with a new exact-path broadcast, and [`reject`](Self::reject) resolves it -/// with an error. Dropping the request without either rejects it. +/// resolves it with a new exact-path broadcast, [`serve`](Self::serve) answers with a held +/// broadcast, and [`reject`](Self::reject) resolves it with an error. Dropping it rejects it. /// -/// Only the built-in sessions answer with a broadcast they already hold: +/// Serve a held broadcast without announcing an exact route: /// -/// ```compile_fail,E0624 +/// ``` /// fn answer(request: moq_net::origin::Request, broadcast: moq_net::broadcast::Consumer) { -/// request.accept(broadcast); +/// request.serve(broadcast); /// } /// ``` pub struct Request { @@ -6165,7 +6169,7 @@ pub struct Request { // this wakes them with the outcome. producer: kio::Producer, - // The queue this request came from, so `accept` can cache the served + // The queue this request came from, so `serve` can cache the served // broadcast for repeat requests. home: kio::Shared, @@ -6192,9 +6196,13 @@ impl Request { }) } - /// Resolve a session-forwarded claim with its peer's already-routed broadcast. - #[cfg(feature = "async")] - pub(crate) fn accept(self, broadcast: impl Consume) { + /// Serve a held broadcast under this prefix route without announcing an exact route. + /// + /// The answer belongs to the prefix route's instance at this path: every answer for + /// that path must continue the same sequence space and bytes. Start a new prefix + /// route to serve different content there. For a job that may restart independently, + /// use [`Self::prepare`] and [`Prepared::publish`] to announce its own instance. + pub fn serve(self, broadcast: impl Consume) { let broadcast = broadcast.consume(); let _ = ServeState::resolve(&self.home, &self.path, &self.producer, Ok(broadcast)); // `self.producer` drops here, closing the channel; the value is still observable. @@ -6245,7 +6253,13 @@ impl Prepared { // and whatever resolved through the claim's current instance beneath it. Answered // and taken over under one lock, so nothing resolves in between. let admitted = broadcast.announce_withheld(announcer, route, Some(&request.home), || { - resolved = request.home.lock().answer(&request.path, &request.producer, Ok(answer)); + // The exact route owns this answer's availability. Caching it under the + // prefix would keep serving it after that route is withdrawn. + resolved = request + .home + .lock() + .take(&request.path, &request.producer) + .map(|()| Ok(answer)); resolved.is_some() })?; let Some(resolved) = resolved.filter(|_| admitted) else { @@ -6265,7 +6279,7 @@ impl Drop for Request { // producer clone (plus this one) closes the channel, resolving coalesced requesters to // `Unroutable` rather than hanging. // - // The identity guard matters: `accept`/`reject` already removed our entry and released + // The identity guard matters: `serve`/`reject` already removed our entry and released // the lock before we run, so a concurrent request for the same path may have registered // a *new* one here. Removing unconditionally would clobber it, stranding its requesters. ServeState::forget(&self.home, &self.path, &self.producer); @@ -8344,7 +8358,7 @@ mod tests { assert_eq!(request.path().as_str(), ".svc/p1/foo"); assert!(server.poll_requested_broadcast(&kio::Waiter::noop()).is_pending()); let source = broadcast::Info::new().produce(); - request.accept(&source); + request.serve(&source); let through = through.await.expect("resolves"); let direct = direct.await.expect("resolves"); @@ -8939,7 +8953,7 @@ mod tests { let pending = consumer.request("pool/job-0", None); let request = queued(&old).await; let first = broadcast::Info::new().produce(); - request.accept(&first); + request.serve(&first); let resolved = pending.await.expect("the old route resolves"); assert!(new.poll_requested_broadcast(&kio::Waiter::noop()).is_pending()); @@ -8949,7 +8963,7 @@ mod tests { let pending = consumer.request("pool/job-0", None); let request = queued(&new).await; let second = broadcast::Info::new().produce(); - request.accept(&second); + request.serve(&second); let replaced = pending.await.expect("the replacement resolves"); assert!(!replaced.is_clone(&resolved)); } @@ -8982,7 +8996,7 @@ mod tests { ); let pending = consumer.request("pool/job-0", None); - queued(&new).await.accept(broadcast::Info::new().produce()); + queued(&new).await.serve(broadcast::Info::new().produce()); pending.await.expect("the replacement resolves"); } } @@ -9013,7 +9027,7 @@ mod tests { async fn hold(consumer: &Consumer, path: &str, server: &Requests) -> (broadcast::Producer, broadcast::Consumer) { let pending = consumer.request(path, None); let answer = broadcast::Info::new().produce(); - queued(server).await.accept(&answer); + queued(server).await.serve(&answer); (answer, pending.await.expect("the request resolves")) } @@ -9443,7 +9457,7 @@ mod tests { let pending = consumer.request("room/alice", None); let request = queued(&server).await; let upstream = broadcast::Info::new().produce(); - request.accept(&upstream); + request.serve(&upstream); pending.await.expect("resolves through the cheaper route"); } @@ -9488,7 +9502,7 @@ mod tests { .unwrap(); let request = queued(&server).await; let upstream = broadcast::Info::new().produce(); - request.accept(&upstream); + request.serve(&upstream); let second = consumer.request("room/alice", None).await.expect("resolves"); assert!(first.is_clone(&second), "the newcomer joins the front"); @@ -9607,7 +9621,7 @@ mod tests { let upstream = broadcast::Info::new().produce(); let _b = upstream.create_track("b", None).unwrap(); let _c = upstream.create_track("c", None).unwrap(); - queued(&server).await.accept(&upstream); + queued(&server).await.serve(&upstream); assert_eq!(listed(&mut tracks).await, "+c"); assert_eq!(listed(&mut tracks).await, "-a"); @@ -9626,7 +9640,7 @@ mod tests { let pending = consumer.request("room/alice", None); let upstream = broadcast::Info::new().produce(); let _a = upstream.create_track("a", None).unwrap(); - queued(&first).await.accept(&upstream); + queued(&first).await.serve(&upstream); let front = pending.await.unwrap(); let mut tracks = front.tracks().unwrap(); assert_eq!(listed(&mut tracks).await, "+a"); @@ -9644,7 +9658,7 @@ mod tests { moq_clock::timeout(Duration::from_secs(1), queued(&second)) .await .expect("the front asked the successor") - .accept(&successor); + .serve(&successor); assert_eq!(listed(&mut tracks).await, "+b"); assert!(!front.is_closed()); } @@ -9676,7 +9690,7 @@ mod tests { let pending = consumer.request("room/alice", None); let upstream = broadcast::Info::new().produce(); let _a = upstream.create_track("a", None).unwrap(); - queued(&first).await.accept(&upstream); + queued(&first).await.serve(&upstream); let front = pending.await.unwrap(); let mut tracks = front.tracks().unwrap(); assert_eq!(listed(&mut tracks).await, "+a"); @@ -9695,7 +9709,7 @@ mod tests { moq_clock::timeout(Duration::from_secs(1), queued(&last)) .await .expect("the front asked the chain's last route") - .accept(&successor); + .serve(&successor); assert_eq!(listed(&mut tracks).await, "+b", "{links} links, epochs: {epochs}"); assert!(!front.is_closed()); // The front carries the last instance, so a request now joins it. @@ -9718,7 +9732,7 @@ mod tests { let first = producer.requests_route("room/alice", route(0), None).unwrap(); let pending = consumer.request("room/alice", None); let upstream = broadcast::Info::new().produce(); - queued(&first).await.accept(&upstream); + queued(&first).await.serve(&upstream); let resolved = pending.await.unwrap(); // Taken over, then renewed, with no yield between. @@ -9731,7 +9745,7 @@ mod tests { moq_clock::timeout(Duration::from_secs(1), queued(&second)) .await .expect("a fresh front asked the renewed route") - .accept(&renewed); + .serve(&renewed); let again = pending.await.unwrap(); assert_eq!(again.info().epoch, route(2).epoch); assert!( @@ -9751,7 +9765,7 @@ mod tests { let pending = consumer.request("room/alice", None); let upstream = broadcast::Info::new().produce(); let _video = upstream.create_track("video", None).unwrap(); - queued(&server).await.accept(&upstream); + queued(&server).await.serve(&upstream); let front = pending.await.unwrap(); let mut tracks = front.tracks().unwrap(); @@ -9914,7 +9928,7 @@ mod tests { let pending = consumer.request("room/alice", None); let upstream = broadcast::Info::new().produce(); let dynamic = upstream.requests(); - queued(&server).await.accept(&upstream); + queued(&server).await.serve(&upstream); let resolved = pending.await.expect("resolves"); (server, upstream, dynamic, resolved) } @@ -10015,7 +10029,7 @@ mod tests { let session = producer.consume().excluding(Hop::random()); let pending = session.request("room/alice", None); if viewer == 0 { - queued(&server).await.accept(&upstream); + queued(&server).await.serve(&upstream); } let resolved = pending.await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); @@ -10078,7 +10092,7 @@ mod tests { let fronts = || producer.shared.lock().fronts.len(); let pending = consumer.request("room/alice", None); - queued(&server).await.accept(&upstream); + queued(&server).await.serve(&upstream); let resolved = pending.await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); next_group(&mut subscription).await.unwrap().expect("the live group"); @@ -10137,7 +10151,7 @@ mod tests { let fronts = || producer.shared.lock().fronts.len(); let pending = consumer.request("room/alice", None); - queued(&server).await.accept(&upstream); + queued(&server).await.serve(&upstream); let resolved = pending.await.expect("resolves"); let reader = resolved.track("video").unwrap().subscribe(None); settle(|| source.demand().is_wanted()).await; @@ -10212,7 +10226,7 @@ mod tests { let fronts = || producer.shared.lock().fronts.len(); let pending = producer.consume().request("room/alice", None); - queued(&server).await.accept(&upstream); + queued(&server).await.serve(&upstream); let _viewer = pending.await.expect("the plain front resolves"); let peer = producer.consume().excluding(origin(7)); @@ -10249,7 +10263,7 @@ mod tests { let pending = peer.request("room/alice", None); let source = broadcast::Info::new().produce(); - queued(&incumbent).await.accept(&source); + queued(&incumbent).await.serve(&source); let resolved = pending.await.expect("resolves through the incumbent"); // The same publisher, now also reached through the peer, outlives the incumbent. @@ -10264,7 +10278,7 @@ mod tests { drop(source); let replacement = broadcast::Info::new().produce(); - queued(&echo).await.accept(&replacement); + queued(&echo).await.serve(&replacement); resolved.assert_not_closed(); view.expect_next_ended("room").await; } @@ -10296,7 +10310,7 @@ mod tests { let pending = producer.consume().request("room/alice", None); let upstream = broadcast::Info::new().produce(); let mut dynamic = upstream.requests(); - queued(&first_server).await.accept(&upstream); + queued(&first_server).await.serve(&upstream); let resolved = pending.await.unwrap(); #[cfg(feature = "async")] @@ -10354,7 +10368,7 @@ mod tests { .unwrap(); let replacement = broadcast::Info::new().produce(); let mut replacement_dynamic = replacement.requests(); - queued(&replacement_server).await.accept(&replacement); + queued(&replacement_server).await.serve(&replacement); let request = moq_clock::timeout(Duration::from_secs(1), replacement_dynamic.requested_track()) .await .expect("the front asked the replacement") @@ -10852,14 +10866,14 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.requests_route("room", Route::default(), None).unwrap(); + let server = producer.requests("room").unwrap(); let pending = consumer.request("room/alice", None); let request = queued(&server).await; assert_eq!(request.path().as_str(), "room/alice"); let source = broadcast::Info::new().produce(); - request.accept(&source); + request.serve(&source); let resolved = pending.await.expect("resolves"); // The handle is named by what the requester asked for. @@ -10885,7 +10899,7 @@ mod tests { assert!(server.poll_requested_broadcast(&kio::Waiter::noop()).is_pending()); let source = broadcast::Info::new().produce(); - request.accept(&source); + request.serve(&source); let first = first.await.expect("resolves"); let second = second.await.expect("resolves"); @@ -10943,7 +10957,7 @@ mod tests { let request = queued(&standby_server).await; let source = broadcast::Info::new().produce(); - request.accept(&source); + request.serve(&source); let resolved = resolving.await.expect("resolves via the standby"); assert_eq!(resolved.info().path.as_str(), "room/alice"); @@ -11472,7 +11486,7 @@ mod tests { let request = queued(&server).await; assert_eq!(request.path().as_str(), "room/bob"); let served = broadcast::Info::new().produce(); - request.accept(&served); + request.serve(&served); pending.await.expect("resolves"); } @@ -11630,6 +11644,33 @@ mod tests { announced.assert_next_wait(); } + /// A published job must stop answering through its claim when its exact route leaves, + /// even while its fill handle and readers keep the broadcast alive. + #[moq_clock::test] + async fn a_withdrawn_publication_is_not_a_cached_claim_answer() { + let producer = origin(1).produce(); + let claim = producer.requests("room").unwrap(); + let path = Path::from_static("room/alice"); + let pending = producer.consume().request(path.clone(), None); + let publication = queued(&claim) + .await + .prepare(crate::Epoch::mint()) + .unwrap() + .publish() + .unwrap(); + let held = pending.await.unwrap(); + publication.unannounce(); + assert!( + claim.state.lock().served.get(&path).is_none(), + "withdrawn job still cached" + ); + let next = producer.consume().request(path, None); + let request = queued(&claim).await; + request.reject(Error::App(42)); + assert!(next.await.is_err()); + drop(held); + } + /// A takeover withdrawn before the cursor delivers it may have continued what its /// reader resolved through the claim, so the claim continues nothing more for that /// reader: the next answer is a start. @@ -11767,7 +11808,7 @@ mod tests { let winner = producer.requests_route("room/alice", Route::default(), None).unwrap(); request.reject(Error::NotFound); let source = broadcast::Info::new().produce(); - queued(&winner).await.accept(&source); + queued(&winner).await.serve(&source); let mut result = None; settle(|| { @@ -11821,7 +11862,7 @@ mod tests { } let pending = consumer.request("room/alice", None); - queued(&server).await.accept(&source); + queued(&server).await.serve(&source); let resolved = pending.await.expect("resolves"); let budget = track::Subscription::default().with_max_delay(Duration::from_secs(3600)); @@ -11882,7 +11923,7 @@ mod tests { assert_eq!(request.path().as_str(), "anything/at/all"); let source = broadcast::Info::new().produce(); - request.accept(&source); + request.serve(&source); let resolved = pending.await.expect("resolves"); assert_eq!(resolved.info().path.as_str(), "anything/at/all"); @@ -12143,7 +12184,7 @@ mod tests { let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"before".as_ref()).unwrap(); group.finish().unwrap(); - request.accept(&source); + request.serve(&source); let resolved = pending.await.expect("resolves"); let mut subscription = resolved @@ -12199,7 +12240,7 @@ mod tests { let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"before".as_ref()).unwrap(); group.finish().unwrap(); - request.accept(&replacement); + request.serve(&replacement); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"resumed".as_ref()).unwrap(); @@ -12239,7 +12280,7 @@ mod tests { let pending = consumer.request("room/alice", None); let source = broadcast::Info::new().produce(); let track = source.create_track("video", crate::track::Info::timed()).unwrap(); - queued(&first).await.accept(&source); + queued(&first).await.serve(&source); let resolved = pending.await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); deliver(&track, &mut subscription, b"first").await; @@ -12371,7 +12412,7 @@ mod tests { let new_track = new.create_track("video", crate::track::Info::timed()).unwrap(); let stale = broadcast::Info::new().produce(); let _stale_track = stale.create_track("video", crate::track::Info::timed()).unwrap(); - request.accept(&stale); + request.serve(&stale); let resolved = pending.await.expect("resolves the winner"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); @@ -12399,17 +12440,17 @@ mod tests { let _stale_track = stale.create_track("video", crate::track::Info::timed()).unwrap(); let epoch = crate::Epoch::mint(); if answer_first { - request.accept(&stale); + request.serve(&stale); dynamic.update_route(dynamic.route().with_epoch(epoch.clone())).unwrap(); } else { dynamic.update_route(dynamic.route().with_epoch(epoch.clone())).unwrap(); - request.accept(&stale); + request.serve(&stale); } let request = queued(&dynamic).await; let fresh = broadcast::Info::new().produce(); let fresh_track = fresh.create_track("video", crate::track::Info::timed()).unwrap(); - request.accept(&fresh); + request.serve(&fresh); let resolved = pending.await.expect("the request carries over to the new instance"); assert_eq!(resolved.info().epoch.as_ref(), Some(&epoch)); assert!( @@ -12454,7 +12495,7 @@ mod tests { let fresh = broadcast::Info::new().produce(); let fresh_track = fresh.create_track("video", crate::track::Info::timed()).unwrap(); - queued(&dynamic).await.accept(&fresh); + queued(&dynamic).await.serve(&fresh); let resolved = pending.await.expect("the request carries over"); assert_eq!(resolved.info().epoch.as_ref(), Some(&epoch)); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); @@ -12481,11 +12522,11 @@ mod tests { dynamic.update_route(dynamic.route().with_epoch(old.clone())).unwrap(); let stale = broadcast::Info::new().produce(); let _stale_track = stale.create_track("video", crate::track::Info::timed()).unwrap(); - request.accept(&stale); + request.serve(&stale); let fresh = broadcast::Info::new().produce(); let fresh_track = fresh.create_track("video", crate::track::Info::timed()).unwrap(); - queued(&dynamic).await.accept(&fresh); + queued(&dynamic).await.serve(&fresh); let resolved = pending.await.expect("the request carries over"); assert_eq!(resolved.info().epoch.as_ref(), Some(&old)); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); @@ -12504,7 +12545,7 @@ mod tests { let pending = consumer.request("room/alice", None); let old = broadcast::Info::new().produce(); let _old_track = old.create_track("video", crate::track::Info::timed()).unwrap(); - queued(&dynamic).await.accept(&old); + queued(&dynamic).await.serve(&old); let resolved = pending.await.expect("resolves"); dynamic @@ -12517,7 +12558,7 @@ mod tests { let retry = consumer.request("room/alice", None); let fresh = broadcast::Info::new().produce(); let _fresh_track = fresh.create_track("video", crate::track::Info::timed()).unwrap(); - queued(&dynamic).await.accept(&fresh); + queued(&dynamic).await.serve(&fresh); let replaced = retry.await.expect("the new instance resolves"); assert!(!replaced.is_clone(&resolved), "rejoined the first instance's front"); } @@ -12629,7 +12670,7 @@ mod tests { let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"before".as_ref()).unwrap(); group.finish().unwrap(); - request.accept(&successor); + request.serve(&successor); rig.incumbent_track.clone().abort(Error::Dropped).unwrap(); assert!( @@ -12685,7 +12726,7 @@ mod tests { rig.incumbent_track.clone().abort(Error::Dropped).unwrap(); let replacement = broadcast::Info::new().produce(); let mut handler = replacement.requests(); - queued(&standby).await.accept(&replacement); + queued(&standby).await.serve(&replacement); let request = handler.requested_track().await.unwrap(); assert_eq!(request.subscription().unwrap().start(), Some(5)); let track = request.accept(crate::track::Info::timed()); @@ -12760,7 +12801,7 @@ mod tests { let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"before".as_ref()).unwrap(); group.finish().unwrap(); - request.accept(&source); + request.serve(&source); let resolved = pending.await.expect("resolves through the incumbent"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); @@ -12788,7 +12829,7 @@ mod tests { let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"before".as_ref()).unwrap(); group.finish().unwrap(); - request.accept(&replacement); + request.serve(&replacement); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"resumed".as_ref()).unwrap(); group.finish().unwrap(); @@ -12826,7 +12867,7 @@ mod tests { let mut group = track_a.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"from-a".as_ref()).unwrap(); group.finish().unwrap(); - request.accept(&source_a); + request.serve(&source_a); let resolved_a = pending.await.expect("resolves"); let mut sub_a = resolved_a @@ -12878,7 +12919,7 @@ mod tests { let mut group = track_b.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"from-b".as_ref()).unwrap(); group.finish().unwrap(); - request.accept(&source_b); + request.serve(&source_b); let resolved_b = pending.await.expect("B's front is served immediately"); assert!( @@ -13030,7 +13071,7 @@ mod tests { let again = consumer.request("room/alice", None); let upstream = broadcast::Info::new().produce(); - request.accept(&upstream); + request.serve(&upstream); let first = pending.await.expect("resolves"); let again = again.await.expect("resolves"); assert!( @@ -13102,7 +13143,7 @@ mod tests { let request = queued(&server).await; let source = broadcast::Info::new().produce(); let track = source.create_track("video", crate::track::Info::timed()).unwrap(); - request.accept(&source); + request.serve(&source); let resolved = pending.await.expect("resolves"); let mut subscription = resolved @@ -13147,7 +13188,7 @@ mod tests { .unwrap(); let pending = producer.consume().request("room/alice", None); let source = broadcast::Info::new().produce(); - queued(&server).await.accept(&source); + queued(&server).await.serve(&source); let resolved = pending.await.unwrap(); source.close(); @@ -13235,7 +13276,7 @@ mod tests { let pending = producer.consume().request("live", None); let source = broadcast::Info::new().produce(); let track = source.create_track("video", crate::track::Info::timed()).unwrap(); - queued(&server).await.accept(&source); + queued(&server).await.serve(&source); let resolved = pending.await.unwrap(); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); @@ -13319,7 +13360,7 @@ mod tests { .requests_route("room", Route::default().with_hops(hops(&[10])), None) .unwrap(); let mid_pending = mid.consume().request("room/alice", None); - queued(&mid_server).await.accept(&leaf_front); + queued(&mid_server).await.serve(&leaf_front); let mid_resolved = mid_pending.await.expect("mid resolves"); let edge = origin(3).produce(); @@ -13327,7 +13368,7 @@ mod tests { .requests_route("room", Route::default().with_hops(hops(&[20])), None) .unwrap(); let edge_pending = edge.consume().request("room/alice", None); - queued(&edge_server).await.accept(&mid_resolved); + queued(&edge_server).await.serve(&mid_resolved); let edge_resolved = edge_pending.await.expect("edge resolves"); let mut subscription = edge_resolved @@ -13463,7 +13504,7 @@ mod tests { let pending = producer.consume().request("room/alice", None); let upstream = broadcast::Info::new().produce(); let old = upstream.create_track("video", crate::track::Info::timed()).unwrap(); - queued(&server).await.accept(&upstream); + queued(&server).await.serve(&upstream); let resolved = pending.await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = old.append_group().unwrap(); @@ -13879,7 +13920,7 @@ mod tests { let pending = consumer.request("room/alice", None); let request = queued(&server).await; let source = broadcast::Info::new().produce(); - request.accept(&source); + request.serve(&source); let resolved = pending.await.expect("the dynamic still serves"); drop(resolved); @@ -14412,7 +14453,7 @@ mod tests { let source = producer.requests("project/room").unwrap(); let pending = consumer.request("room/lobby.chat", None); let request = source.requested_broadcast().await.unwrap(); - request.accept(local.consume()); + request.serve(local.consume()); pending.await.unwrap(); } diff --git a/rs/moq-net/src/model/resume_model.rs b/rs/moq-net/src/model/resume_model.rs index e4b65e7c409..bd496ba0326 100644 --- a/rs/moq-net/src/model/resume_model.rs +++ b/rs/moq-net/src/model/resume_model.rs @@ -459,7 +459,7 @@ impl Model { let upstream = broadcast.consume(); let serving = moq_clock::sim::spawn(async move { while let Ok(request) = kio::wait(|waiter| requests.poll_requested_broadcast(waiter)).await { - request.accept(&upstream); + request.serve(&upstream); } }); self.instances[epoch].routes[slot] = Some(Copy { diff --git a/swift/Sources/Moq/Origin.swift b/swift/Sources/Moq/Origin.swift index 8dfe72169d6..280e7b94dff 100644 --- a/swift/Sources/Moq/Origin.swift +++ b/swift/Sources/Moq/Origin.swift @@ -59,6 +59,11 @@ public final class BroadcastRequest: Sendable { BroadcastPrepared(try ffi.prepare(epoch: epoch)) } + /// Serve held content under the prefix route's continuous sequence space, without an exact route. + public func serve(broadcast: BroadcastConsumer) throws { + try ffi.serve(broadcast: broadcast.ffi) + } + /// Reject the request with an application error code. public func reject(errorCode: UInt16) throws { try ffi.reject(errorCode: errorCode) From 3558352261815b5726cdd234ea6d09f13b5247da Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 31 Oct 2026 22:54:12 -0700 Subject: [PATCH 03/16] style(net): format cross-version serve tests Co-Authored-By: GPT-6.1 Sol --- rs/moq-net-tests/tests/integration/serve.rs | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/rs/moq-net-tests/tests/integration/serve.rs b/rs/moq-net-tests/tests/integration/serve.rs index 7223cb6f407..b0b66bbf2fb 100644 --- a/rs/moq-net-tests/tests/integration/serve.rs +++ b/rs/moq-net-tests/tests/integration/serve.rs @@ -31,7 +31,12 @@ async fn first_subscribe(version: &str, publish: bool) { }; // A held broadcast needs no origin or announcement of its own. let held = broadcast::Info::new().produce(); - let held_track = held.create_track("video", track::Info::default().with_timescale(moq_net::Timescale::MILLI)).unwrap(); + let held_track = held + .create_track( + "video", + track::Info::default().with_timescale(moq_net::Timescale::MILLI), + ) + .unwrap(); let mut group = held_track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"held".as_slice()).unwrap(); group.finish().unwrap(); @@ -45,7 +50,10 @@ async fn first_subscribe(version: &str, publish: bool) { .unwrap(); let track = prepared .broadcast() - .create_track("video", track::Info::default().with_timescale(moq_net::Timescale::MILLI)) + .create_track( + "video", + track::Info::default().with_timescale(moq_net::Timescale::MILLI), + ) .unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"held".as_slice()).unwrap(); From 2dcf502609fa00dd829dceff3f4d68fa9d16b254 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 31 Oct 2026 22:56:21 -0700 Subject: [PATCH 04/16] test(net): retain the published track through first subscribe Co-Authored-By: GPT-6.1 Sol --- rs/moq-net-tests/tests/integration/serve.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rs/moq-net-tests/tests/integration/serve.rs b/rs/moq-net-tests/tests/integration/serve.rs index b0b66bbf2fb..e54d3723840 100644 --- a/rs/moq-net-tests/tests/integration/serve.rs +++ b/rs/moq-net-tests/tests/integration/serve.rs @@ -58,7 +58,7 @@ async fn first_subscribe(version: &str, publish: bool) { let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"held".as_slice()).unwrap(); group.finish().unwrap(); - Some(prepared.publish().unwrap()) + Some((prepared.publish().unwrap(), track)) } else { requests.requested_broadcast().await.unwrap().serve(&held); None From 346446cddcfb1312ea133c5234c9276331b7da7d Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 31 Oct 2026 22:57:00 -0700 Subject: [PATCH 05/16] docs(net): describe all prefix request answers Co-Authored-By: GPT-6.1 Sol --- js/net/src/origin.ts | 2 +- rs/moq-net/src/model/origin.rs | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/js/net/src/origin.ts b/js/net/src/origin.ts index f32c932d205..659079dbadd 100644 --- a/js/net/src/origin.ts +++ b/js/net/src/origin.ts @@ -2388,7 +2388,7 @@ export class Requests { * Yielded by {@link Requests.requested}. {@link prepare} then {@link Prepared.publish} * resolves it with a new exact-path broadcast; {@link serve} answers with a held broadcast; * {@link reject} resolves it with an error. - * Advancing the iterator or closing it without either rejects the request. + * Advancing the iterator or closing it without answering rejects the request. * * @public */ diff --git a/rs/moq-net/src/model/origin.rs b/rs/moq-net/src/model/origin.rs index e263282ac6b..2dd4397371e 100644 --- a/rs/moq-net/src/model/origin.rs +++ b/rs/moq-net/src/model/origin.rs @@ -6173,8 +6173,8 @@ pub struct Request { // broadcast for repeat requests. home: kio::Shared, - // Applications publish answers into this origin; session-forwarded claims accept - // their peer's already-routed broadcast directly instead. + // Applications can prepare answers in this origin; a session-forwarded request + // can only serve its peer's already-routed broadcast. publisher: Option, } From 13457e45b766bc1219cf8c7b56150e264a1ba47b Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 31 Oct 2026 22:57:41 -0700 Subject: [PATCH 06/16] docs(net): remove the retired direct-publish comment Co-Authored-By: GPT-6.1 Sol --- js/net/src/origin.ts | 2 -- 1 file changed, 2 deletions(-) diff --git a/js/net/src/origin.ts b/js/net/src/origin.ts index 659079dbadd..f424323e38b 100644 --- a/js/net/src/origin.ts +++ b/js/net/src/origin.ts @@ -2413,8 +2413,6 @@ export class Request { }; publishPrepared = (request, publication, epoch) => { if (!request.#server.has(request)) throw new Error("request is closed"); - // The exact route usually settles the request on its own, resolving its waiters - // through the new epoch; answer it directly if it is still pending. publication.announce({ epoch }); // Its exact route owns availability: never cache a published job under the // prefix, which would keep serving it after that exact route is withdrawn. From f7fce9c64079089444c8b806823c0ffd48f25300 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 31 Oct 2026 22:58:34 -0700 Subject: [PATCH 07/16] refactor(net): use public serve in test and benchmark consumers Co-Authored-By: GPT-6.1 Sol --- rs/moq-net-tests/tests/integration/ietf_conformance.rs | 2 +- rs/moq-net-tests/tests/integration/restart.rs | 4 ++-- rs/moq-net/benches/origin.rs | 2 +- rs/moq-net/src/fuzz.rs | 5 ----- 4 files changed, 4 insertions(+), 9 deletions(-) diff --git a/rs/moq-net-tests/tests/integration/ietf_conformance.rs b/rs/moq-net-tests/tests/integration/ietf_conformance.rs index 7b7c8c27f2c..a41409a08ae 100644 --- a/rs/moq-net-tests/tests/integration/ietf_conformance.rs +++ b/rs/moq-net-tests/tests/integration/ietf_conformance.rs @@ -32,7 +32,7 @@ async fn routing(version: &str, cluster: bool) { moq_clock::sim::spawn(async move { let request = serving.requested_broadcast().await.unwrap(); assert_eq!(request.path().as_str(), NAMESPACE); - moq_net::fuzz::accept(request, answer); + request.serve(answer); }); let mut options = MockConnectOptions::new(version); diff --git a/rs/moq-net-tests/tests/integration/restart.rs b/rs/moq-net-tests/tests/integration/restart.rs index 175830ec888..0e48e9ff38c 100644 --- a/rs/moq-net-tests/tests/integration/restart.rs +++ b/rs/moq-net-tests/tests/integration/restart.rs @@ -192,7 +192,7 @@ impl Worker { let output = broadcast::Info::new().produce(); let track = output.create_track("video", timed()).unwrap(); write(&track, &format!("{hop}")); - moq_net::fuzz::accept(request, &output); + request.serve(&output); served.borrow_mut().push((output, track)); } })); @@ -277,7 +277,7 @@ impl Claim { while let Ok(request) = handler.requested_broadcast().await { let output = broadcast::Info::new().produce(); let track = output.create_track("video", timed()).unwrap(); - moq_net::fuzz::accept(request, &output); + request.serve(&output); served.borrow_mut().push((output, track)); } })); diff --git a/rs/moq-net/benches/origin.rs b/rs/moq-net/benches/origin.rs index f1319c13a18..96c341bd49a 100644 --- a/rs/moq-net/benches/origin.rs +++ b/rs/moq-net/benches/origin.rs @@ -876,7 +876,7 @@ fn pool(members: usize, paths: usize, cursors: usize) -> Pool { for member in &members { while let Poll::Ready(request) = member.poll_requested_broadcast(&waiter) { let broadcast = broadcast::Info::new().produce(); - moq_net::fuzz::accept(request.unwrap(), &broadcast); + request.unwrap().serve(&broadcast); producers.push(broadcast); } } diff --git a/rs/moq-net/src/fuzz.rs b/rs/moq-net/src/fuzz.rs index 1bc4d3e6dca..decc9aae77a 100644 --- a/rs/moq-net/src/fuzz.rs +++ b/rs/moq-net/src/fuzz.rs @@ -407,11 +407,6 @@ pub fn update_route(dynamic: &crate::origin::Requests, route: crate::origin::Rou dynamic.update_route(route) } -/// Answer a peer claim's request with the broadcast its session already holds. -pub fn accept(request: crate::origin::Request, broadcast: impl crate::Consume) { - request.serve(broadcast) -} - /// A session's snapshot of its peer's initial announcements, for the synced bench. /// Drop it to land the snapshot. pub struct Snapshot(#[allow(dead_code, reason = "held for its drop, which lands the snapshot")] crate::model::Snapshot); From f5a92b33f103d4ee3f1d1a69d7e23840fdf0a54b Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sun, 1 Nov 2026 09:38:58 -0800 Subject: [PATCH 08/16] refactor(net): drop the session-delivered mark serve no longer reads Request.serve accepts a held session consumer, so nothing reads the fromSession flag the old refusal needed. Remove it from the wire view, the front, and its test, and the comments that described the refusal. Co-Authored-By: Claude Opus 5.5 --- js/net/src/order.test.ts | 2 +- js/net/src/resume.test.ts | 13 ------------- js/net/src/resume.ts | 17 ----------------- js/net/src/untimed.test.ts | 4 ++-- js/net/src/wire.ts | 14 ++------------ 5 files changed, 5 insertions(+), 45 deletions(-) diff --git a/js/net/src/order.test.ts b/js/net/src/order.test.ts index 8d31bac0e6e..0f60c79554c 100644 --- a/js/net/src/order.test.ts +++ b/js/net/src/order.test.ts @@ -271,7 +271,7 @@ test("ietf keeps a closing group stream ranked until it settles", async () => { }); // One track fanned out to an ascending and a descending subscriber, the shape a relay serves -// from one upstream request (a JS app does not proxy, so the track is local here). The +// from one upstream request (the track is local here). The // aggregate a wire would request upstream turns descending once the descending subscriber // joins, so it is never held behind the other's backlog, and each session still serves its // own subscriber in its own order. diff --git a/js/net/src/resume.test.ts b/js/net/src/resume.test.ts index c81604b4dfd..848a272d91b 100644 --- a/js/net/src/resume.test.ts +++ b/js/net/src/resume.test.ts @@ -1359,19 +1359,6 @@ test("a datagram reader lets go of the copies a swap replaced", async () => { b.close(); }); -test("a front remembers it served a session's broadcast between routes", () => { - const front = new Front(); - const a = new BroadcastProducer(); - const session = a.consume(); - overrideBroadcastWire(session, {}); - front.serve(session); - expect(front.fromSession).toBe(true); - front.park(); - expect(front.fromSession).toBe(true); - front.consumer.close(); - a.close(); -}); - test("a failed group on a route whose replacement was refused ends with the refusal", async () => { const front = new Front(); const a = new BroadcastProducer(); diff --git a/js/net/src/resume.ts b/js/net/src/resume.ts index b7450b95376..200fff0e6b8 100644 --- a/js/net/src/resume.ts +++ b/js/net/src/resume.ts @@ -143,14 +143,11 @@ class Source { readonly wire: BroadcastWire; /** The table's handle this was served from, so serving it again is a no-op. */ readonly from: broadcast.Consumer; - /** Whether a session delivered it, read from the handle served rather than the clone. */ - readonly fromSession: boolean; #consumer: broadcast.Consumer; #holds = 0; constructor(from: broadcast.Consumer) { this.from = from; - this.fromSession = wireOf(from).fromSession === true; this.#consumer = from.clone(); this.wire = wireOf(this.#consumer); } @@ -1525,8 +1522,6 @@ export class Front { #concluded = false; /** The tracks each source was checked against the recorded properties for; see #verify. */ #verified = new WeakMap>(); - /** Whether any source it served came from a session, kept between routes. */ - #fromSession = false; constructor() { this.consumer = makeFrontConsumer(this); @@ -1672,7 +1667,6 @@ export class Front { if (this.#concluded || this.#source?.from === from) return; const source = new Source(from); source.retain(); - this.#fromSession ||= source.fromSession; const previous = this.#source; this.#source = source; this.#retired(); @@ -1707,14 +1701,6 @@ export class Front { this.#retire = new AbortController(); } - /** - * Whether a broadcast it served came from a session; see {@link BroadcastWire.fromSession}. - * Sticky, since the front can move back onto a session's route at any time. - */ - get fromSession(): boolean { - return this.#fromSession; - } - // Splice `source`'s copy of a track in, once it claims the same content as the copies before. #splice(route: Route, source: Source): void { const recorded = this.#info.get(route.name); @@ -1995,9 +1981,6 @@ class FrontConsumer extends broadcast.Consumer { resolveTrackInfo: (name, hold) => front.resolveTrackInfo(name, hold), largest: (name) => front.largest(name), fetchGroup: (name, sequence, options) => front.fetchGroup(name, sequence, options), - get fromSession() { - return front.fromSession; - }, }); } diff --git a/js/net/src/untimed.test.ts b/js/net/src/untimed.test.ts index 9a5d5f14a77..2ec52a88be1 100644 --- a/js/net/src/untimed.test.ts +++ b/js/net/src/untimed.test.ts @@ -128,8 +128,8 @@ test("a forwarded untimed track stays untimed", async () => { } })(); - // Serve the downstream session from the upstream one. A JS origin refuses to serve a - // broadcast a session delivered, so the forwarding node republishes a copy it produced. + // Serve the downstream session from the upstream one through a copy the forwarding + // node produces. const dynamic = relay.requestsRoute(Path.from("test")); const inputs: BroadcastConsumer[] = []; const forwarding = (async () => { diff --git a/js/net/src/wire.ts b/js/net/src/wire.ts index 9d16631d831..268d84341b6 100644 --- a/js/net/src/wire.ts +++ b/js/net/src/wire.ts @@ -33,11 +33,6 @@ export interface Broadcast { tracks(owner?: object): Tracks; /** Answer the broadcast's listings, as a session does with its peer's; throws while another answers. */ lister(): Lister; - /** - * A session delivered this broadcast. An originated route refuses to serve it: - * publishing it would name this origin's hop for upstream content. - */ - fromSession?: boolean; } /** Receives one change to the watched prefixes: `prefix` is now (or no longer) wanted. */ @@ -142,19 +137,14 @@ export function registerWire(handle: object, view: View): void { views.set(handle, view); } -/** - * Replace selected operations on a broadcast's package-private view. - * - * Only a session-delivered broadcast does this, so the replacement is marked. - * An origin refuses to serve that broadcast on a route it originated. - */ +/** Replace selected operations on a broadcast's package-private view. */ export function overrideBroadcastWire( handle: broadcast.Consumer, overrides: Partial>, ): void { const view = views.get(handle); if (!view) throw new Error("broadcast has no wire view"); - views.set(handle, { ...(view as Broadcast), ...overrides, fromSession: true }); + views.set(handle, { ...(view as Broadcast), ...overrides }); } export function wireOf(handle: broadcast.Producer): Produced; From 520b701aa7a5f70d52da1aadd89a139d619010de Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sun, 1 Nov 2026 09:39:01 -0800 Subject: [PATCH 09/16] docs(bindings): point held-broadcast answers at serve The binding migration guides replaced accept(broadcast) with prepare and publish only. serve is the direct replacement for a held broadcast, so name it beside prepare, and list it in the C request path's borrow rule. Co-Authored-By: Claude Opus 5.5 --- c/moq/MIGRATE.md | 1 + dart/moq/MIGRATE.md | 1 + go/wrapper/MIGRATE.md | 1 + kt/moq/MIGRATE.md | 1 + py/moq-rs/MIGRATE.md | 1 + rs/moq-c/MIGRATE.md | 1 + rs/moq-c/src/api.rs | 5 +++-- swift/MIGRATE.md | 1 + 8 files changed, 10 insertions(+), 2 deletions(-) diff --git a/c/moq/MIGRATE.md b/c/moq/MIGRATE.md index f63c8185d98..168a22fec1a 100644 --- a/c/moq/MIGRATE.md +++ b/c/moq/MIGRATE.md @@ -83,6 +83,7 @@ Publish a replacement under a new name, and expect a finished track's demand ter `moq_origin_dynamic` takes no route, and `moq_origin_dynamic_update` is gone. `moq_broadcast_request_accept` is replaced by `moq_broadcast_request_prepare`, which returns a prepared answer under the epoch you pass: fill its broadcast, then `moq_broadcast_prepared_publish` announces it at the exact path under that epoch. +To answer with a broadcast you already hold, `moq_broadcast_request_serve(request, consumer)` serves it under the prefix route without announcing an exact route; the consumer stays yours to free. `moq_broadcast_prepared_free` refuses an answer you will not publish. ### `moq_track_info` gains `compress` (#5928) diff --git a/dart/moq/MIGRATE.md b/dart/moq/MIGRATE.md index 10ec0483f9c..0f1bb047377 100644 --- a/dart/moq/MIGRATE.md +++ b/dart/moq/MIGRATE.md @@ -134,6 +134,7 @@ Publish a replacement under a new name, and expect a finished track's demand wat `origin.dynamic_(prefix:)` takes no route, and `update` is gone. Replace `request.accept(broadcast:)` with `request.prepare(epoch: mintEpoch())`, which returns a `BroadcastPrepared`: fill its `broadcast()`, then `publish()` announces it at the exact path under that epoch and returns its producer. +To answer with a broadcast you already hold, `request.serve(broadcast: producer.consume())` serves it under the prefix route without announcing an exact route. ### Anchors can name a time (#6074) diff --git a/go/wrapper/MIGRATE.md b/go/wrapper/MIGRATE.md index 1ac64f9a9a2..af085ee310c 100644 --- a/go/wrapper/MIGRATE.md +++ b/go/wrapper/MIGRATE.md @@ -126,6 +126,7 @@ Publish a replacement under a new name, and expect a finished track's demand wat `OriginProducer.Dynamic(prefix)` takes no route, and `OriginDynamic.Update` is gone. Replace `request.Accept(broadcast)` with `request.Prepare(epoch)`, which returns a `*BroadcastPrepared`: fill its `Broadcast()`, then `Publish()` announces it at the exact path under that epoch and returns its producer. +To answer with a broadcast you already hold, `request.Serve(consumer)` serves it under the prefix route without announcing an exact route; the consumer stays yours to close. Where you rejected a request after a failed setup, `Close()` the prepared answer instead. ### `TrackInfo` gains `Compress` (#5928) diff --git a/kt/moq/MIGRATE.md b/kt/moq/MIGRATE.md index c5e09fe8227..cb67026a42d 100644 --- a/kt/moq/MIGRATE.md +++ b/kt/moq/MIGRATE.md @@ -129,6 +129,7 @@ Publish a replacement under a new name, and expect a finished track's demand wat `OriginProducer.dynamic(prefix)` takes no route, and `OriginDynamic.update` is gone. Replace `request.accept(broadcast)` with `request.prepare(mintEpoch())`, which returns a `BroadcastPrepared`: fill its `broadcast()`, then `publish()` announces it at the exact path under that epoch and returns its producer. +To answer with a broadcast you already hold, `request.serve(producer.consume())` serves it under the prefix route without announcing an exact route. ### Anchors can name a time (#6074) diff --git a/py/moq-rs/MIGRATE.md b/py/moq-rs/MIGRATE.md index 4072adde08b..9a974bfd854 100644 --- a/py/moq-rs/MIGRATE.md +++ b/py/moq-rs/MIGRATE.md @@ -125,6 +125,7 @@ Publish a replacement under a new name, and expect a finished track's demand wat `OriginProducer.dynamic(prefix)` takes no route, and `OriginDynamic.update` is gone. Replace `request.accept(broadcast)` with `prepared = request.prepare(moq.mint_epoch())`, fill `prepared.broadcast`, then `prepared.publish()`, which announces it at the exact path under that epoch and returns its producer. +To answer with a broadcast you already hold, `request.serve(producer.consume())` serves it under the prefix route without announcing an exact route. ### Anchors can name a time (#6074) diff --git a/rs/moq-c/MIGRATE.md b/rs/moq-c/MIGRATE.md index 29f031fc42e..ce4c3910d31 100644 --- a/rs/moq-c/MIGRATE.md +++ b/rs/moq-c/MIGRATE.md @@ -117,6 +117,7 @@ Publish a replacement under a new name, and expect a finished track's demand ter `moq_origin_dynamic` takes no route, and `moq_origin_dynamic_update` is gone. `moq_broadcast_request_accept` is replaced by `moq_broadcast_request_prepare`, which returns a prepared answer under the epoch you pass: fill its broadcast, then `moq_broadcast_prepared_publish` announces it at the exact path under that epoch. +To answer with a broadcast you already hold, `moq_broadcast_request_serve(request, consumer)` serves it under the prefix route without announcing an exact route; the consumer stays yours to free. `moq_broadcast_prepared_free` refuses an answer you will not publish. ### `moq_track_info` gains `compress` (#5928) diff --git a/rs/moq-c/src/api.rs b/rs/moq-c/src/api.rs index 9e2ed574fb1..cfd95c6e6cd 100644 --- a/rs/moq-c/src/api.rs +++ b/rs/moq-c/src/api.rs @@ -2095,8 +2095,9 @@ pub extern "C" fn moq_origin_requests_cancel(dynamic: u32) -> i32 { /// The path of a broadcast request delivered to a [moq_origin_requests] callback. /// -/// The destination borrows the request's storage: copy it out before accept, -/// reject, or [moq_broadcast_request_free]. +/// The destination borrows the request's storage: copy it out before +/// [moq_broadcast_request_serve], [moq_broadcast_request_prepare], +/// [moq_broadcast_request_reject], or [moq_broadcast_request_free]. /// /// Returns a zero on success, or a negative code on failure. /// diff --git a/swift/MIGRATE.md b/swift/MIGRATE.md index 39478780f17..9ff6cbe3f4a 100644 --- a/swift/MIGRATE.md +++ b/swift/MIGRATE.md @@ -121,6 +121,7 @@ Publish a replacement under a new name, and expect a finished track's demand wat `OriginProducer.dynamic(prefix:)` takes no route, and `OriginDynamic.update(route:)` is gone. Replace `request.accept(broadcast:)` with `let prepared = try request.prepare(epoch: mintEpoch())`, fill `prepared.broadcast`, then `try prepared.publish()`, which announces it at the exact path under that epoch and returns its producer. +To answer with a broadcast you already hold, `try request.serve(broadcast: producer.consume())` serves it under the prefix route without announcing an exact route. ### Anchors can name a time (#6074) From 7903f5af95aefc02b5d64a11b178d039aa26feb3 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 2 Nov 2026 07:48:26 -0800 Subject: [PATCH 10/16] test(py): use Timestamp for held broadcast content Co-Authored-By: GPT-6.1 Sol --- py/moq-rs/tests/test_local.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/py/moq-rs/tests/test_local.py b/py/moq-rs/tests/test_local.py index e86305435d3..2745f1870ab 100644 --- a/py/moq-rs/tests/test_local.py +++ b/py/moq-rs/tests/test_local.py @@ -809,7 +809,7 @@ async def test_dynamic_serves_held_content_without_an_exact_route(): request.serve(source) broadcast = await requesting reader = await broadcast.subscribe_track("status") - track.write_frame(b"held", timedelta(microseconds=1)) + track.write_frame(b"held", moq.Timestamp(1, 1_000_000)) frame = await reader.read_frame() assert frame is not None and frame.payload == b"held" track.finish() From 04ef02182035caf13690409a67bbdc53bb00b63b Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 2 Nov 2026 07:50:36 -0800 Subject: [PATCH 11/16] test(net): serve the merged track status request through the public API Co-Authored-By: GPT-6.1 Sol --- js/net/src/ietf/publisher.test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/js/net/src/ietf/publisher.test.ts b/js/net/src/ietf/publisher.test.ts index 4c8314baaae..bb9c20bd794 100644 --- a/js/net/src/ietf/publisher.test.ts +++ b/js/net/src/ietf/publisher.test.ts @@ -306,7 +306,7 @@ test("TRACK_STATUS finished at once is answered on every draft", async () => { finish(); const served = new BroadcastProducer(); served.createTrack("video"); - hooks.acceptRequest(pending, served); + pending.serve(served); await task; expect(await wire().u53()).toBe(TrackStatusOk.id); From 8693cfb8a38d813f57c644bf579f08735eceda63 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 2 Nov 2026 08:05:19 -0800 Subject: [PATCH 12/16] docs(go): name the consumer passed to a held broadcast request Co-Authored-By: GPT-6.1 Sol --- go/wrapper/publish.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/go/wrapper/publish.go b/go/wrapper/publish.go index 23a12e9707c..5519d001dbb 100644 --- a/go/wrapper/publish.go +++ b/go/wrapper/publish.go @@ -17,8 +17,9 @@ type BroadcastProducer struct { } // NewBroadcastProducer creates a standalone broadcast, not attached to any -// origin: use it to serve a dynamic request ([BroadcastRequest.Serve]) or for -// local pub/sub. To publish at a path, use [OriginProducer.CreateBroadcast]. +// origin: pass its [BroadcastProducer.Consume] result to [BroadcastRequest.Serve] +// for a dynamic request, or use it for local pub/sub. To publish at a path, use +// [OriginProducer.CreateBroadcast]. func NewBroadcastProducer() (*BroadcastProducer, error) { inner, err := ffi.NewMoqBroadcastProducer() if err != nil { From 7e7d6f9abcec2be05b696b8675b43a2865111d29 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 2 Nov 2026 08:27:41 -0800 Subject: [PATCH 13/16] fix(net): gate held-answer test and clarify routing docs Co-Authored-By: GPT-6.1 Sol --- doc/concept/identity.md | 14 +++++++------- doc/lib/layers.md | 10 +++++----- rs/moq-net/src/model/origin.rs | 1 + 3 files changed, 13 insertions(+), 12 deletions(-) diff --git a/doc/concept/identity.md b/doc/concept/identity.md index 75eb664f495..56a7c335989 100644 --- a/doc/concept/identity.md +++ b/doc/concept/identity.md @@ -116,19 +116,19 @@ demand, which has none until a worker answers. ## Work on demand -A worker can advertise a prefix it serves on demand. When answering with a -broadcast it already holds, Rust uses `request.serve(consumer)` and JavaScript -`request.serve(broadcast)`. This announces no exact route: the answer belongs +A worker can advertise a prefix it serves on demand and answer with a +broadcast it already holds. This announces no exact route: the answer belongs to the prefix route's instance at that path. Every answer there must continue one sequence space with the same bytes. To serve different content at a path -already served, start a new prefix route. Its first subscription succeeds -without a restart on moq-transport 18 and 22 and moq-lite 06 and 07. +already served, start a new prefix route. Its first subscription stays on +the prefix route without a restart. A job that may restart independently, such as a transcoder claiming `transcode`, instead prepares and publishes each requested path under a fresh epoch. The claim promises capability, not content, and carries no -epoch. Each job announces an exact route; the cold-start subscription resets -on versions without takeover, as described below. +epoch. Each job announces an exact route; without takeover support, the +cold-start subscription ends and the subscriber follows the new announcement, +as described below. ```rust let claim = origin.requests("transcode")?; diff --git a/doc/lib/layers.md b/doc/lib/layers.md index d2d694949c3..a9ec70893c3 100644 --- a/doc/lib/layers.md +++ b/doc/lib/layers.md @@ -42,11 +42,11 @@ Sessions, origins, broadcasts, tracks, and groups: `Client`, `Server`, | C++ | `moq::` | `moq::BroadcastProducer` | | C | `moq_session_*`, `moq_origin_*`, `moq_publish_track_*`, `moq_consume_track_*` | `moq_publish_track` | -An on-demand broadcast request can `serve` a held consumer without announcing -an exact route in every binding (`Serve` in Go and -`moq_broadcast_request_serve` in C). It answers under the prefix route's -continuous sequence space at that path. Use prepare and publish for a job -that may restart independently; see [work on demand](/concept/identity#work-on-demand). +On-demand broadcast requests in every binding can answer with held content +without announcing an exact route. The answer uses the prefix route's +continuous sequence space at that path. Use a fresh publication for a job +that may restart independently; see [work on demand](/concept/identity#work-on-demand) +and the [Go](/lib/go/) and [C](/lib/c/) binding references. ## media diff --git a/rs/moq-net/src/model/origin.rs b/rs/moq-net/src/model/origin.rs index 0a560361c38..d13afb0cb77 100644 --- a/rs/moq-net/src/model/origin.rs +++ b/rs/moq-net/src/model/origin.rs @@ -11654,6 +11654,7 @@ mod tests { /// A published job must stop answering through its claim when its exact route leaves, /// even while its fill handle and readers keep the broadcast alive. #[kio::test] + #[cfg(feature = "async")] async fn a_withdrawn_publication_is_not_a_cached_claim_answer() { let producer = origin(1).produce(); let claim = producer.requests("room").unwrap(); From 1a1a65d228b952d1a88c7768ffae522ce1f53a98 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 3 Nov 2026 09:16:40 -0800 Subject: [PATCH 14/16] test(net): adapt held-answer tests to fresh-instance prepare Co-Authored-By: Claude Opus 5.5 --- js/net/src/integration.test.ts | 2 +- js/net/src/origin-request.test.ts | 4 ++-- rs/moq-net-tests/tests/integration/serve.rs | 7 +------ rs/moq-net/src/model/origin.rs | 7 +------ 4 files changed, 5 insertions(+), 15 deletions(-) diff --git a/js/net/src/integration.test.ts b/js/net/src/integration.test.ts index e2db7afb2ff..8182f0cd577 100644 --- a/js/net/src/integration.test.ts +++ b/js/net/src/integration.test.ts @@ -2815,7 +2815,7 @@ test.each([Lite.ALPN_06, Lite.ALPN_07_WIP, Ietf.ALPN.DRAFT_18, Ietf.ALPN.DRAFT_2 const requests = handle.requested(); const request = (await requests.next()).value; if (!request) throw new Error("missing job request"); - const prepared = request.prepare(Epoch.mint()); + const prepared = request.prepare(); prepared.broadcast.createTrack("chat", { timescale: Timescale.MILLI }).writeFrame(textFrame("job")); return prepared.publish(); })(); diff --git a/js/net/src/origin-request.test.ts b/js/net/src/origin-request.test.ts index c21403842a9..9d9af2064a1 100644 --- a/js/net/src/origin-request.test.ts +++ b/js/net/src/origin-request.test.ts @@ -3,7 +3,7 @@ import { Producer as BroadcastProducer } from "./broadcast"; import { StreamCode, StreamError } from "./error"; import { Route } from "./hop"; import * as Instance from "./instance.ts"; -import { type Following, Producer, type Publication, type Request, type Requesting } from "./origin"; +import { type Following, Producer, type Publication, type Requesting } from "./origin"; import * as Path from "./path"; import { wireOf } from "./wire"; @@ -401,7 +401,7 @@ for (const withdraw of ["unannounce", "replace"] as const) { const first = origin.request(path); const pending = (await requests.next()).value; if (!pending) throw new Error("expected a request"); - const publication = pending.prepare(Epoch.mint()).publish(); + const publication = pending.prepare().publish(); await settle(); const held = first.active.peek()?.clone(); if (withdraw === "unannounce") publication.unannounce(); diff --git a/rs/moq-net-tests/tests/integration/serve.rs b/rs/moq-net-tests/tests/integration/serve.rs index a84e38a8aad..3783678f6ff 100644 --- a/rs/moq-net-tests/tests/integration/serve.rs +++ b/rs/moq-net-tests/tests/integration/serve.rs @@ -42,12 +42,7 @@ async fn first_subscribe(version: &str, publish: bool) { group.finish().unwrap(); let handler = async { if publish { - let prepared = requests - .requested_broadcast() - .await - .unwrap() - .prepare() - .unwrap(); + let prepared = requests.requested_broadcast().await.unwrap().prepare().unwrap(); let track = prepared .broadcast() .create_track( diff --git a/rs/moq-net/src/model/origin.rs b/rs/moq-net/src/model/origin.rs index e5ae24a5077..616e4691a4a 100644 --- a/rs/moq-net/src/model/origin.rs +++ b/rs/moq-net/src/model/origin.rs @@ -11531,12 +11531,7 @@ mod tests { let claim = producer.requests("room").unwrap(); let path = Path::from_static("room/alice"); let pending = producer.consume().request(path.clone(), None); - let publication = queued(&claim) - .await - .prepare() - .unwrap() - .publish() - .unwrap(); + let publication = queued(&claim).await.prepare().unwrap().publish().unwrap(); let held = pending.await.unwrap(); publication.unannounce(); assert!( From c5df12416c5b579bb50e68f898e7ecc189e3753e Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 3 Nov 2026 09:24:44 -0800 Subject: [PATCH 15/16] test(net): serve the group ID request through the public API Co-Authored-By: Claude Opus 5.5 --- js/net/src/group-id.test.ts | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/js/net/src/group-id.test.ts b/js/net/src/group-id.test.ts index b59474e114d..812c4aba7ef 100644 --- a/js/net/src/group-id.test.ts +++ b/js/net/src/group-id.test.ts @@ -4,7 +4,6 @@ import { expect, test } from "bun:test"; import { type Consumer as BroadcastConsumer, Producer as BroadcastProducer } from "./broadcast.ts"; import { accept, connect } from "./connection/index.ts"; import * as Ietf from "./ietf/index.ts"; -import { hooks } from "./internal.ts"; import * as Lite from "./lite/index.ts"; import { createMockTransportPair } from "./mock.ts"; import { Producer as OriginProducer } from "./origin.ts"; @@ -87,7 +86,7 @@ for (const wire of WIRES) { for await (const request of dynamic.requested()) { const input = wireOf(ingest).consume(request.path); inputs.push(input); - hooks.acceptRequest(request, await forward(input)); + request.serve(await forward(input)); } })(); From fe44ac0bdb91265a45c4cc729816849585e96b24 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 3 Nov 2026 11:30:56 -0800 Subject: [PATCH 16/16] docs(net): name the current crate-private route functions in MIGRATE Co-Authored-By: Claude Opus 5.5 --- rs/moq-net/MIGRATE.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rs/moq-net/MIGRATE.md b/rs/moq-net/MIGRATE.md index 5ac45a49931..47b9bfd5760 100644 --- a/rs/moq-net/MIGRATE.md +++ b/rs/moq-net/MIGRATE.md @@ -308,7 +308,7 @@ Treat a failed group read as the loss of that group and keep reading the track, Answer each `origin::Request` with `request.prepare()?`, fill `prepared.broadcast()`, then `prepared.publish()?`, which announces the broadcast at the exact path under a fresh instance of its own and returns its producer. Only `publish` announces it: `prepared.broadcast().announce(..)` fails with `Error::Closed`. `Dynamic::update` is gone: drop the claim and claim again to change it, and close an answer's producer to end that output. -`Producer::dynamic_route` and `Dynamic::update_route` remain crate-private (#6496). +`Producer::requests_route` and `Requests::update_route` remain crate-private (#6496). `Request::serve(consumer)` additively exposes the former private `accept`: answer with a held broadcast without announcing an exact route. The prefix route promises the same bytes and continuous sequences at each served path; start a new prefix route for different content, or prepare and publish an independent job. Dropping a `Prepared` unpublished refuses the request, as dropping a `Request` does, and `publish` fails with `Error::Unroutable` once the claim went away.