@norskvideo/moq-net 0.1.8 → 0.2.1

package/lite/subscriber.js

@@ -1,35 +1,36 @@
 /* @ts-self-types="./subscriber.d.ts" */
-import { Signal } from "@norskvideo/moq-signals";
+import { race, Signal } from "@norskvideo/moq-signals";
 import * as announce from "../announced.js";
 import * as broadcast from "../broadcast.js";
 import { BroadcastCache } from "../consume.js";
-import { error, ProtocolViolation, reason } from "../error.js";
+import { controlTimeout, error, ProtocolViolation, reason, StreamCode, StreamError, sessionCause } from "../error.js";
 import * as netGroup from "../group.js";
-import { UNKNOWN_ORIGIN } from "../origin.js";
+import { Cost, MAX_HOPS, randomHop, routesEqual, stampHops, UNKNOWN_HOP } from "../hop.js";
+import { groupBounds, hiddenBelow, scopeCaptures, scopeHead, scopeOverlaps } from "../internal.js";
 import * as Path from "../path.js";
 import { Stream } from "../stream.js";
+import { TAIL_GRACE_MS, Tail } from "../tail.js";
 import * as Time from "../time.js";
-import { withTimeout } from "../util/timeout.js";
-import { AnnounceInit, AnnounceOk, AnnounceRequest, decodeAnnounceBroadcastMaybe } from "./announce.js";
+import { untilAborted } from "../util/abort.js";
+import { TimeoutError, withTimeout } from "../util/timeout.js";
+import { overrideBroadcastWire, wireOf } from "../wire.js";
+import { AnnounceHistory, AnnounceInit, AnnounceOk, AnnounceRequest, decodeAnnounceBroadcastMaybe, } from "./announce.js";
 import { Datagram as DatagramMessage } from "./datagram.js";
 import * as DatagramStream from "./datagram_stream.js";
 import { Fetch as FetchMessage } from "./fetch.js";
+import { frameDecoder, readFrames } from "./group.js";
 import { sendOrder } from "./priority.js";
 import { Probe } from "./probe.js";
 import { ProbeLevel } from "./setup.js";
 import { StreamId } from "./stream.js";
-import { decodeSubscribeResponse, decodeSubscribeResponseMaybe, Subscribe, SubscribeUpdate } from "./subscribe.js";
+import { decodeSubscribeResponse, decodeSubscribeResponseMaybe, EMPTY_RANGE, emptyRange, exclusiveGroupEnd, inclusiveGroupEnd, Subscribe, SubscribeUpdate, } from "./subscribe.js";
 import { TrackInfo, Track as TrackMessage } from "./track.js";
-import { hasAnnounceId, hasAnnounceOk, hasDatagrams, hasExcludeHop, hasProbeRtt, restartSupported, Version, } from "./version.js";
+import { hasAnnounceId, hasAnnounceOk, hasDatagrams, hasProbeRtt, hasStreamCount, restartSupported, Version, } from "./version.js";
 // Bound on how long stream-open plus the first response (SUBSCRIBE_OK on older
 // drafts, or TRACK_INFO on lite-05+) may take. Browsers cap concurrent QUIC streams
 // (Chrome ~100) and we open with waitUntilAvailable, so past the cap the open blocks
 // until the peer frees a slot. The timeout turns a stall into a clear error.
 const SUBSCRIBE_SETUP_TIMEOUT_MS = 10_000;
-/** Decode an unsigned zigzag varint back to a signed delta (mirrors Rust `VarInt::to_zigzag`). */
-function unzigzag(v) {
-    return (v >> 1n) ^ -(v & 1n);
-}
 // The TRACK stream and implicit SUBSCRIBE acceptance are lite-05+.
 function supportsTrackStream(version) {
     switch (version) {
@@ -69,9 +70,8 @@ export class Subscriber {
     #quic;
     // The version of the connection.
     version;
-    // Shared with the Publisher so callers can optionally filter out their
-    // own announcements on a per-call basis (see {@link AnnouncedOptions}).
-    origin;
+    // Shared with the Publisher so reflected announces can be dropped on receipt.
+    hop;
     // Our subscribed tracks. `timescale` resolves once known (from TRACK_INFO on
     // lite-05+, or implicit defaults on older drafts); group streams block on it
     // before decoding any frame, since a group's QUIC stream can race ahead.
@@ -79,6 +79,9 @@ export class Subscriber {
     #subscribeNext = 0n;
     // Dedup consumed broadcasts per path: repeat consume() calls share one subscription.
     #consumes = new BroadcastCache();
+    // A random Hop ID of this connection's own, written as the first hop of any chain that
+    // names no publisher, so a publisher that reconnects reads as a new one.
+    #stamp;
     // Dedup in-flight one-shot fetches, keyed by [broadcast, track, sequence]. Concurrent (or
     // repeat, while still open) fetchGroup() calls for the same group share one FETCH stream and
     // each get an independent mirror; the entry is evicted once the group closes.
@@ -94,48 +97,51 @@ export class Subscriber {
      * Creates a new Subscriber instance.
      * @param quic - The WebTransport session to use
      * @param version - The protocol version
-     * @param origin - Origin id shared with the Publisher
+     * @param origin - Hop id shared with the Publisher
      * @param probe - Optional sink for the peer's PROBE estimates
      * @param peerSetup - Optional peer SETUP slot for capability gating (lite-05+)
      *
      * @internal
      */
-    constructor(quic, version, origin, probe, peerSetup) {
+    constructor(quic, version, hop, probe, peerSetup) {
         this.#quic = quic;
         this.version = version;
-        this.origin = origin;
+        this.hop = hop;
+        this.#stamp = randomHop();
         this.#probe = probe;
         this.#peerSetup = peerSetup;
     }
     /**
-     * Subscribe to broadcast announcements under `prefix`.
+     * Subscribe to broadcast announcements matching `scope`. Paths are relative
+     * to the session, not the scope.
+     *
+     * Reflected announces (those whose hop chain already includes this
+     * connection) are always dropped: moq-lite-06 has none to keep, and older
+     * versions stay consistent with that.
      *
-     * Pass `{ ignoreSelf: true }` to skip announces that have already traversed
-     * this connection's {@link origin}.
+     * Hidden routes (a `.`-prefixed segment below the scope's head) are left out unless
+     * `options.hidden` opts in. The opt-in rides the request on lite-07+; an older peer
+     * never hides anything, so the rule is also applied here.
      */
-    announced(prefix = Path.empty(), options = {}) {
-        const announced = new announce.Producer(prefix);
-        void this.#runAnnounced(announced, prefix, options);
+    announced(scope = Path.Pattern.all(), options) {
+        const announced = new announce.Producer();
+        // The wire speaks announce interest by prefix, and echoes suffixes beneath it.
+        void this.#runAnnounced(announced, scopeHead(scope), scope, options?.hidden ?? false);
         return announced.consume();
     }
-    async #runAnnounced(announced, prefix, options) {
+    async #runAnnounced(announced, prefix, scope, hidden) {
         console.debug(`announced: prefix=${prefix}`);
-        // Lite04/05: send our own session-level origin id so the peer can skip announces
+        // Lite04/05: send our own session-level Hop ID so the peer can skip announces
         // whose hop chain already passed through us. Encoding drops it on every other
         // version, where we drop the reflected announce on receipt instead. Matches the
         // Rust subscriber's `exclude_hop: self.self_origin.id` in `run_announce_prefix`.
-        const msg = new AnnounceRequest(prefix, this.origin);
-        // Drop reflected announces so callers asking for "someone else's broadcasts"
-        // don't re-see their own publishes. A caller can always ask for this, and it is
-        // required on versions that don't carry excludeHop above: there the peer isn't
-        // filtering them out for us, so filtering here keeps what the app sees the same
-        // as lite-05. Lite01-03 carry no real hop ids, so the check never matches there.
-        const dropReflected = options.ignoreSelf || !hasExcludeHop(this.version);
+        const msg = new AnnounceRequest(prefix, this.hop, hidden);
+        const visible = (path) => scopeOverlaps(scope, path) && (hidden || !hiddenBelow(prefix, path));
         // Opened outside the try so the catch can reach it: a protocol violation below has
         // to reset the stream, not just close our side of it.
         let stream;
         try {
-            stream = await Stream.open(this.#quic);
+            stream = await Stream.open(this.#quic, { version: this.version });
         }
         catch (err) {
             announced.close(error(err));
@@ -145,17 +151,16 @@ export class Subscriber {
             // Send the announce interest.
             await stream.writer.u53(StreamId.Announce);
             await msg.encode(stream.writer, this.version);
-            // Lite05+: the publisher reports its own origin id before any announces.
+            // Lite05+: the publisher reports its own Hop ID before any announces.
             // It no longer stamps itself onto each hop chain, so we append it here to
-            // keep the ignoreSelf loop check seeing the full chain.
+            // keep the reflected-announce loop check seeing the full chain.
             let responderOrigin;
             if (hasAnnounceOk(this.version)) {
                 const ok = await AnnounceOk.decode(stream.reader, this.version);
-                // A responder that withholds its identity sends the reserved 0. It names
-                // nobody, so folding it into a chain would stamp a placeholder that cannot
-                // close a loop or tell two publishers apart. Treat it as absent instead,
-                // which is the loop-blind route the draft describes.
-                responderOrigin = ok.origin === UNKNOWN_ORIGIN ? undefined : ok.origin;
+                // Keep a withheld 0: it names nobody for loop detection, but it is the
+                // anonymous mark and must travel the reconstructed chain. Assigned identities
+                // stay off this hop and are never forwarded.
+                responderOrigin = ok.hop;
             }
             const advertised = new Map();
             switch (this.version) {
@@ -167,15 +172,20 @@ export class Subscriber {
                     // they go on record and obey the same one-per-path rule: the initial set
                     // naming a path twice is the same violation as two ANNOUNCE_STARTs for it,
                     // and the record is what catches either. Draft01/02 carry no hop ids and no
-                    // ANNOUNCE_OK, so nothing names the publisher.
+                    // ANNOUNCE_OK, so this connection's stamp names the publisher.
                     for (const suffix of init.suffixes) {
                         const path = Path.join(prefix, suffix);
-                        if (advertised.has(suffix)) {
+                        if (advertised.has(path)) {
                             throw new ProtocolViolation(`duplicate announce for ${path}`);
                         }
-                        advertised.set(suffix, { publisher: undefined, live: true });
+                        const route = { hops: [this.#stamp, UNKNOWN_HOP], cost: Cost.zero };
+                        const live = visible(path);
+                        const captures = scopeCaptures(scope, path);
+                        advertised.set(path, { publisher: this.#stamp, live, route, captures });
+                        if (!live)
+                            continue;
                         console.debug(`announced: broadcast=${path} active=true`);
-                        announced.append({ path: suffix, active: true });
+                        announced.append({ prefix: path, captures, kind: "announced", route });
                     }
                     break;
                 }
@@ -184,13 +194,13 @@ export class Subscriber {
                     break;
             }
             // Lite06+: announce ids. Each received `active` implicitly assigns the next
-            // per-stream ordinal; `endedId`/`restart` reference it. Tracked even for
-            // announces we skip via ignoreSelf, since the sender doesn't know we skipped.
-            let nextAnnounceId = 0n;
-            const announcedById = new Map();
+            // per-stream ordinal; `endedId`/`restart` reference it, and lite-07 bases copy
+            // from it. Tracked even for announces we skip as reflected, since the sender
+            // doesn't know we skipped.
+            const history = new AnnounceHistory();
             // Receive announce updates (for Draft03, this includes initial state)
             for (;;) {
-                const announce = await Promise.race([
+                const announce = await race([
                     decodeAnnounceBroadcastMaybe(stream.reader, this.version),
                     announced.closed,
                 ]);
@@ -199,45 +209,43 @@ export class Subscriber {
                     break;
                 if (announce instanceof Error)
                     throw announce;
-                let suffix;
+                let path;
                 let active;
                 // Present on active/restart; ended messages never carry hops worth checking.
                 let hops;
+                let cost;
                 switch (announce.status) {
-                    case "active":
-                        suffix = announce.suffix;
+                    case "active": {
+                        const resolved = hasAnnounceId(this.version) ? history.start(announce) : announce;
+                        // The wire names the suffix beneath the interest prefix; the consumer
+                        // sees the covered path from the session root.
+                        path = Path.join(prefix, resolved.suffix);
                         active = true;
-                        hops = announce.hops;
-                        if (hasAnnounceId(this.version)) {
-                            announcedById.set(nextAnnounceId++, announce.suffix);
-                        }
+                        hops = resolved.hops;
+                        cost = announce.cost;
                         break;
+                    }
                     case "ended":
-                        suffix = announce.suffix;
+                        path = Path.join(prefix, announce.suffix);
                         active = false;
                         break;
-                    case "endedId": {
+                    case "endedId":
                         // Resolve and retire the id; an unknown or retired id is a protocol violation.
-                        const path = announcedById.get(announce.id);
-                        if (path === undefined)
-                            throw new ProtocolViolation(`unknown announce id: ${announce.id}`);
-                        announcedById.delete(announce.id);
-                        suffix = path;
+                        path = Path.join(prefix, history.end(announce.id));
                         active = false;
                         break;
-                    }
                     case "restart": {
                         // Resolve the id; it stays live (the replacement reuses it).
-                        const path = announcedById.get(announce.id);
-                        if (path === undefined)
-                            throw new ProtocolViolation(`unknown announce id: ${announce.id}`);
-                        suffix = path;
+                        const resolved = history.update(announce);
+                        path = Path.join(prefix, resolved.suffix);
                         active = true;
-                        hops = announce.hops;
+                        hops = resolved.hops;
+                        cost = announce.cost;
                         break;
                     }
+                    case "skipped":
+                        continue;
                 }
-                const path = Path.join(prefix, suffix);
                 // One current advertisement per path per stream, decided before anything below
                 // can skip this announcement. A second ANNOUNCE_START for a path the peer
                 // already advertised is a violation whether or not its route would be usable
@@ -250,7 +258,7 @@ export class Subscriber {
                 // a duplicate means the same thing on both sides of it. Mirrors the branch the
                 // Rust announce loop takes before `start_announce`.
                 const duplicateIsRestart = restartSupported(this.version) && !hasAnnounceId(this.version);
-                if (announce.status === "active" && !duplicateIsRestart && advertised.has(suffix)) {
+                if (announce.status === "active" && !duplicateIsRestart && advertised.has(path)) {
                     throw new ProtocolViolation(`duplicate announce for ${path}`);
                 }
                 // Retract the path: forget the advertisement, drop the shared consume entry so a
@@ -258,63 +266,87 @@ export class Subscriber {
                 // and tell the consumer. A no-op for an advertisement never surfaced, which is
                 // what an id retiring a skipped announce resolves to.
                 const retract = () => {
-                    const previous = advertised.get(suffix);
-                    advertised.delete(suffix);
+                    const previous = advertised.get(path);
+                    advertised.delete(path);
                     if (!previous?.live)
                         return;
                     this.#consumes.evict(path);
                     console.debug(`announced: broadcast=${path} active=false`);
-                    announced.append({ path: suffix, active: false });
+                    announced.append({
+                        prefix: path,
+                        captures: previous.captures,
+                        kind: "retracted",
+                        route: previous.route,
+                    });
                 };
                 // In Lite05+ the sender's origin arrives via AnnounceOk, not in each hop
                 // list, so fold it back in before checking.
-                if (hops !== undefined && dropReflected) {
+                if (hops !== undefined) {
                     const full = responderOrigin !== undefined ? [...hops, responderOrigin] : hops;
-                    if (full.includes(this.origin)) {
+                    if (full.includes(this.hop)) {
                         // A reflected restart means the peer's remaining route loops back through
                         // us, so the route is gone even though the message says active. The
                         // advertisement stays live: the peer still holds the path and its id still
                         // resolves here.
                         retract();
-                        advertised.set(suffix, { publisher: undefined, live: false });
+                        advertised.set(path, {
+                            publisher: undefined,
+                            live: false,
+                            route: { hops: full, cost: Cost.zero },
+                            captures: undefined,
+                        });
                         continue;
                     }
                 }
-                if (active) {
-                    // The first hop identifies the original publisher; an empty chain means the
-                    // peer itself originated it. See `restart_announce` in the Rust subscriber.
-                    const publisher = hops?.[0] ?? responderOrigin;
-                    // A publisher with no identity (an empty chain from a peer that withheld its
-                    // own id, or a lite-03 UNKNOWN placeholder) never proves continuity: two such
-                    // advertisements can be unrelated publishers. Mirrors the
-                    // `publisher == Origin::UNKNOWN` arm of the Rust `restart_announce`.
-                    const identified = publisher !== undefined && publisher !== UNKNOWN_ORIGIN;
-                    // A second advertisement for a path we already carry is a restart: either an
-                    // explicit ANNOUNCE_UPDATE, or (lite-05) a duplicate ANNOUNCE.
-                    const previous = advertised.get(suffix);
-                    if (previous?.live) {
-                        if (identified && previous.publisher === publisher) {
-                            // Same publisher, new route. In-flight subscriptions resume across it,
-                            // so there is nothing for a consumer to react to. An unidentified
-                            // publisher falls through to the replacement path below instead.
-                            console.debug(`announced: broadcast=${path} rerouted`);
-                            continue;
-                        }
-                        // A different publisher took the path, so cached track info and existing
-                        // subscriptions must not carry over. Surface a real end before the start.
-                        retract();
-                    }
-                    // After `retract()`, which clears the entry: the path is advertised again, by
-                    // whoever just took it over. Recording it before would leave nothing behind, so
-                    // the *next* takeover would read as a first announcement and skip its own end.
-                    advertised.set(suffix, { publisher, live: true });
-                }
-                else {
+                if (!active) {
                     retract();
                     continue;
                 }
+                // The first hop identifies the original publisher; an empty chain means the
+                // peer itself originated it. One that names nobody (lite-01..03, or a peer
+                // reporting 0) gets this connection's stamp in front of its 0.
+                const fullHops = stampHops(hops !== undefined && responderOrigin !== undefined
+                    ? [...hops, responderOrigin]
+                    : [...(hops ?? [])], this.#stamp);
+                // Appending a withheld AnnounceOk(0) onto a 32-entry list is the same
+                // drop Rust's Hops::push makes: do not expose an overlong chain.
+                if (fullHops === undefined || fullHops.length > MAX_HOPS) {
+                    console.debug(`announced: broadcast=${path} dropped (hop chain at MAX_HOPS)`);
+                    advertised.set(path, {
+                        publisher: undefined,
+                        live: false,
+                        route: { hops: [], cost: Cost.zero },
+                        captures: undefined,
+                    });
+                    continue;
+                }
+                const publisher = fullHops[0];
+                const route = { hops: fullHops, cost: cost ?? Cost.zero };
+                const captures = scopeCaptures(scope, path);
+                if (!visible(path)) {
+                    advertised.set(path, { publisher, live: false, route, captures });
+                    continue;
+                }
+                // A second advertisement for a path we already carry is a restart: either an
+                // explicit ANNOUNCE_UPDATE, or (lite-05) a duplicate ANNOUNCE. It updates the
+                // route in place, so a forwarder re-prices without retracting.
+                const previous = advertised.get(path);
+                if (previous?.live) {
+                    // A different publisher took the path. Subscriptions already open drain
+                    // the old copy, but the next consume starts fresh rather than reusing the
+                    // old publisher's cached track info.
+                    if (previous.publisher !== publisher)
+                        this.#consumes.evict(path);
+                    advertised.set(path, { publisher, live: true, route, captures });
+                    console.debug(`announced: broadcast=${path} rerouted`);
+                    if (!routesEqual(previous.route, route)) {
+                        announced.append({ prefix: path, captures, kind: "updated", route });
+                    }
+                    continue;
+                }
+                advertised.set(path, { publisher, live: true, route, captures });
                 console.debug(`announced: broadcast=${path} active=true`);
-                announced.append({ path: suffix, active: true });
+                announced.append({ prefix: path, captures, kind: "announced", route });
             }
             announced.close();
         }
@@ -354,7 +386,7 @@ export class Subscriber {
         const consumer = new ConsumeBroadcast(this, path);
         void (async () => {
             for (;;) {
-                const request = await consumer.requested();
+                const request = await wireOf(consumer).requested();
                 if (!request)
                     break;
                 void this.#runSubscribe(path, request);
@@ -365,19 +397,24 @@ export class Subscriber {
     async #runSubscribe(broadcast, request) {
         const id = this.#subscribeNext++;
         const subscription = request.subscription;
+        const initialBounds = groupBounds(subscription.groups);
+        if (emptyRange({ startGroup: initialBounds.start, endGroup: initialBounds.end })) {
+            request.reject(new Error(EMPTY_RANGE));
+            return;
+        }
         // `timescale` stays undefined until TRACK_INFO (or, on older drafts,
         // implicit defaults) resolves it; runGroup blocks on it before decoding.
         const timescale = new Signal(undefined);
         console.debug(`subscribe start: id=${id} broadcast=${broadcast} track=${request.name}`);
+        const bounds = groupBounds(subscription.groups);
         const msg = new Subscribe({
             id,
             broadcast,
             track: request.name,
             priority: subscription.priority ?? 0,
-            ordered: subscription.ordered,
-            maxLatency: subscription.latencyMax,
-            startGroup: subscription.startGroup,
-            endGroup: subscription.endGroup,
+            maxAge: subscription.maxAge,
+            startGroup: subscription.groups?.start === undefined ? undefined : bounds.start,
+            endGroup: inclusiveGroupEnd(bounds.end),
         });
         // Open the stream under a timeout. The stream handle flows back via `state`
         // so the timeout path can abort it if it finishes opening after the deadline.
@@ -389,7 +426,9 @@ export class Subscriber {
             console.debug(`subscribe ok: id=${id} broadcast=${broadcast} track=${request.name}`);
         }
         catch (err) {
-            const e = error(err);
+            // The setup outlived its deadline waiting for the first response: a control
+            // timeout, not content that arrived late.
+            const e = err instanceof TimeoutError ? controlTimeout(err) : await sessionCause(this.#quic, err);
             request.reject(e);
             this.#subscribes.delete(id);
             console.warn(`subscribe error: id=${id} broadcast=${broadcast} track=${request.name} error=${reason(e)}`);
@@ -399,31 +438,40 @@ export class Subscriber {
             setup.then(() => state.stream?.abort(e), () => state.stream?.abort(e));
             return;
         }
-        const { stream, producer } = opened;
+        const { stream, entry } = opened;
+        const producer = entry.track;
         try {
             // Watch for subscription changes and send SUBSCRIBE_UPDATE. Lite01/Lite02
             // don't carry SUBSCRIBE_UPDATE on the wire, so skip the watcher there
             // and just wait on the stream/track like before.
             //
-            // On lite-05+ the publisher sends SUBSCRIBE_START/END/DROP on this stream;
-            // drain them (we don't drive delivery off the resolved range) so the FIN is
-            // observed. Older drafts just wait for the stream to close.
-            const closed = supportsTrackStream(this.version) ? this.#drainResponses(stream) : stream.reader.closed;
+            // On lite-05+ the publisher sends SUBSCRIBE_START/END/DROP on this stream until
+            // its FIN; older drafts just close it. Either way group streams can still be in
+            // flight, so the track ends only once the tail is accounted for. A reset rejects
+            // instead, so the track ends with that error rather than a clean tail.
+            const responses = supportsTrackStream(this.version)
+                ? this.#runResponses(stream, entry)
+                : stream.reader.closed;
+            const closed = responses.then(() => this.#settleTail(entry));
+            // A reset that lands after the race below settled is moot; the race observes one before.
+            closed.catch(() => { });
             const subscriptionUpdates = this.version === Version.DRAFT_01 || this.version === Version.DRAFT_02
                 ? undefined
-                : this.#runSubscriptionUpdates(id, broadcast, producer, msg, stream);
+                : this.#runSubscriptionUpdates(id, broadcast, entry, msg, stream);
             // Terminal conditions (stream end, track close, a failed subscription update) settle at most
             // once; race them into one stable promise so the demand loop doesn't re-subscribe each pass.
+            // Updates stop quietly at the FIN, which can land before the responses ahead of it are
+            // decoded, so only their failure is terminal on its own.
             const terminal = [closed, producer.closed];
             if (subscriptionUpdates !== undefined)
-                terminal.push(subscriptionUpdates);
-            const done = Promise.race(terminal);
+                terminal.push(subscriptionUpdates.then(() => closed));
+            const done = race(terminal);
             // Serve until a terminal condition fires or the last local subscriber leaves. The unused
             // wake is level-triggered: re-check demand so a subscriber that returns before we tear
             // down (e.g. a quickly unmuted tile) resumes on the same subscription.
             const idle = Symbol("idle");
             for (;;) {
-                const reason = await Promise.race([done, producer.unused().then(() => idle)]);
+                const reason = await race([done, producer.unused().then(() => idle)]);
                 if (reason === idle && producer.closed.peek() === undefined && producer.used.peek())
                     continue;
                 break;
@@ -433,7 +481,7 @@ export class Subscriber {
             console.debug(`subscribe close: id=${id} broadcast=${broadcast} track=${request.name}`);
         }
         catch (err) {
-            const e = error(err);
+            const e = await sessionCause(this.#quic, err);
             producer.close(e);
             console.warn(`subscribe error: id=${id} broadcast=${broadcast} track=${request.name} error=${reason(e)}`);
             stream.abort(e);
@@ -467,8 +515,22 @@ export class Subscriber {
             drainOk = true;
         }
         // Register before opening SUBSCRIBE so a racing GROUP stream finds the entry.
-        this.#subscribes.set(id, { track: producer, timescale });
-        state.stream = await Stream.open(this.#quic);
+        const entry = {
+            track: producer,
+            timescale,
+            // The effective max age is the stopgap grace: the wrong clock (it bounds
+            // presentation-time drift), but it is how long the subscriber was willing to wait
+            // for a late group anyway. Already the smaller of the subscriber's and the track's.
+            tail: new Tail({
+                grace: () => {
+                    const maxAge = producer.subscription.peek()?.maxAge ?? Time.Milli.zero;
+                    return maxAge > 0 ? maxAge : TAIL_GRACE_MS;
+                },
+            }),
+            requested: msg.startGroup,
+        };
+        this.#subscribes.set(id, entry);
+        state.stream = await Stream.open(this.#quic, { version: this.version });
         await state.stream.writer.u53(StreamId.Subscribe);
         await msg.encode(state.stream.writer, this.version);
         if (drainOk) {
@@ -478,37 +540,52 @@ export class Subscriber {
                 throw new Error("first subscribe response must be SUBSCRIBE_OK");
             }
         }
-        return { stream: state.stream, producer };
+        return { stream: state.stream, entry };
     }
     // Opens a TRACK stream, reads the single TRACK_INFO, and FINs. Lite-05+ only.
     async #trackInfo(broadcast, track) {
-        const stream = await Stream.open(this.#quic);
-        try {
+        return this.#exchange({ version: this.version }, async (stream) => {
             await stream.writer.u53(StreamId.Track);
             await new TrackMessage(broadcast, track).encode(stream.writer, this.version);
             const info = await TrackInfo.decode(stream.reader, this.version);
             // The publisher FINs after TRACK_INFO; FIN our side too.
             stream.close();
             return info;
+        });
+    }
+    // Opens a stream and runs a request/response exchange on it, resetting the stream if `run`
+    // fails. Subscriber.close() also resets it while `run` is pending, so a peer that never
+    // answers cannot hold it open, and a stream that opens after the close is reset at once.
+    async #exchange(options, run) {
+        const closed = this.#closed.signal;
+        closed.throwIfAborted();
+        const stream = await Stream.open(this.#quic, options);
+        const abort = () => stream.abort(error(closed.reason));
+        closed.addEventListener("abort", abort);
+        try {
+            closed.throwIfAborted();
+            return await run(stream);
         }
         catch (err) {
             stream.abort(error(err));
             throw err;
         }
+        finally {
+            closed.removeEventListener("abort", abort);
+        }
     }
     // Map the wire TRACK_INFO onto the model track.Info a producer/consumer holds.
     #toModelInfo(info) {
         return {
             timescale: Time.Timescale(info.timescale),
-            // Publisher Max Latency rides on the wire, so the local retention window
+            // Publisher Max Age rides on the wire, so the local retention window
             // matches what the upstream advertises (relays re-serve with the same bound).
-            latencyMax: info.latencyMax,
+            maxAge: Time.Milli(info.maxAge),
             priority: info.priority,
-            ordered: info.ordered,
         };
     }
     // Resolve a track's immutable model info via a TRACK stream (lite-05+), for the
-    // ConsumeBroadcast backing track.Consumer.info(). On older drafts there's no TRACK
+    // ConsumeBroadcast backing track.Consumer.query(). On older drafts there's no TRACK
     // stream, so this rejects rather than fabricating defaults.
     async resolveTrackInfo(broadcast, track) {
         if (!supportsTrackStream(this.version)) {
@@ -518,83 +595,115 @@ export class Subscriber {
     }
     // Open a FETCH stream for one group and stream its bare frames into a group, for the
     // ConsumeBroadcast backing track.Consumer.fetchGroup() (lite-05+).
-    fetchGroup(broadcast, track, sequence, options = {}) {
+    async fetchGroup(broadcast, track, sequence, options = {}) {
+        options.signal?.throwIfAborted();
         // Coalesce onto a still-open fetch of the same group so we don't open a second FETCH
         // stream (and re-download it); each caller reads an independent mirror.
+        //
+        // Reserve each caller's mirror before the fetch starts or is awaited: the fetch watches
+        // demand from the start, and a fast FIN cannot discard frames before these callers
+        // receive their handles. An abort closes only this caller's mirror, so the stream is
+        // cancelled once the last one leaves.
         const key = JSON.stringify([broadcast, track, sequence]);
-        const existing = this.#fetches.get(key);
-        if (existing && !existing.isClosed)
-            return Promise.resolve(existing.mirror());
-        // Create and cache the group synchronously (before any await) so a concurrent fetch for
-        // the same group finds it and coalesces rather than racing to open its own stream.
-        const group = new netGroup.Producer(sequence);
-        this.#fetches.set(key, group);
-        void group.closed.then(() => {
-            if (this.#fetches.get(key) === group)
-                this.#fetches.delete(key);
-        });
-        return this.#runFetch(broadcast, track, sequence, options, group);
+        let entry = this.#fetches.get(key);
+        let consumer;
+        if (entry && !entry.group.isClosed) {
+            consumer = entry.group.mirror();
+        }
+        else {
+            const group = new netGroup.Producer(sequence);
+            consumer = group.mirror();
+            entry = { group, accepted: this.#runFetch(broadcast, track, sequence, options.priority ?? 0, group) };
+            this.#fetches.set(key, entry);
+            void group.closed.then(() => {
+                if (this.#fetches.get(key)?.group === group)
+                    this.#fetches.delete(key);
+            });
+        }
+        try {
+            await untilAborted(entry.accepted, options.signal);
+            return consumer;
+        }
+        catch (err) {
+            consumer.close();
+            throw err;
+        }
     }
     // Open the FETCH stream and pump the response into the shared group. Setup errors close the
-    // group (so coalesced mirrors observe them and the entry evicts) and reject this caller.
-    async #runFetch(broadcast, track, sequence, options, group) {
+    // group, evict the entry, and reject every caller waiting for acceptance. A setup every caller
+    // has abandoned is cancelled the same way.
+    async #runFetch(broadcast, track, sequence, priority, group) {
         try {
             if (!supportsTrackStream(this.version)) {
                 throw new Error("fetch group requires moq-lite-05 or newer");
             }
-            const info = await this.#trackInfo(broadcast, track);
-            const priority = options.priority ?? 0;
-            const stream = await Stream.open(this.#quic, { sendOrder: sendOrder({ priority }) });
+            // Lite has no FETCH_OK, so a publisher that never answers would hold the setup forever.
+            // Subscriber.close() closing the group releases every caller at any stage, and resets
+            // the streams the setup opened.
+            const setup = this.#fetchSetup(broadcast, track, sequence, priority, group);
+            let accepted;
             try {
-                await stream.writer.u53(StreamId.Fetch);
-                await new FetchMessage(broadcast, track, priority, sequence).encode(stream.writer, this.version);
+                accepted = await untilAbandoned(group, setup);
             }
             catch (err) {
-                stream.abort(error(err));
+                // A setup that finishes just after the close hands back a stream nobody will read.
+                void setup.then(({ stream }) => stream.abort(error(err)), () => void 0);
                 throw err;
             }
-            // Mint this caller's reader before starting the pump, so the group has demand when the
-            // pump begins watching it (an abandoned fetch cancels once every reader has left).
-            const consumer = group.mirror();
-            void this.#runFetchResponse(stream, group, Time.Timescale(info.timescale));
-            return consumer;
+            void this.#runFetchResponse(accepted.stream, group, Time.Timescale(accepted.info.timescale));
         }
         catch (err) {
             group.close(error(err));
             throw err;
         }
     }
+    // Resolve the track's timescale, then open the FETCH stream and wait for it to be accepted.
+    // Closing the group during that wait resets the stream.
+    async #fetchSetup(broadcast, track, sequence, priority, group) {
+        const info = await untilClosed(group, this.#trackInfo(broadcast, track));
+        return this.#exchange({ sendOrder: sendOrder({ priority }), version: this.version }, async (stream) => {
+            await stream.writer.u53(StreamId.Fetch);
+            await new FetchMessage({ broadcast, track, priority, group: sequence }).encode(stream.writer, this.version);
+            // A byte or an empty-group FIN accepts the fetch; a reset rejects it.
+            // done() buffers that byte so the response pump can decode it normally.
+            await untilClosed(group, stream.reader.done());
+            return { stream, info };
+        });
+    }
     // Read the FETCH response (bare zigzag-delta-timestamped frames) into the group, then
     // FIN. A stream-level failure aborts the group so its reader observes the gap.
     async #runFetchResponse(stream, group, timescale) {
         try {
-            let prevTs = 0n;
+            const decode = frameDecoder(timescale);
             // Serve until the stream FINs, the group closes, or every reader leaves. A group can
             // stay open indefinitely (a catalog or JSON stream), so an abandoned fetch is stopped by
-            // demand, not by the stream ending. `closed` and `unused` are watched across frames as
-            // stable promises (not re-subscribed to the signals each frame); the unused check is
-            // level-triggered, so a coalesced fetch that arrives before we cancel re-arms and resumes.
+            // demand, not by the stream ending. `unused` is watched across frames as one stable
+            // promise; the check is level-triggered, so a coalesced fetch that arrives before we
+            // cancel re-arms and resumes.
             const idle = Symbol("idle");
-            const closed = Promise.resolve(group.closed);
             let unused = group.unused().then(() => idle);
+            // A decode consumes its frame whenever it lands, so one outstanding across a re-arm is
+            // kept and awaited again rather than abandoned with its frame.
+            let pending;
             for (;;) {
-                const done = await Promise.race([stream.reader.done(), closed, unused]);
-                if (done === idle) {
-                    if (!group.isClosed && group.used.peek()) {
-                        unused = group.unused().then(() => idle);
-                        continue;
+                // Buffered frames are written without an await, as in a group stream.
+                let frame = pending === undefined ? stream.reader.tryDecode(decode) : undefined;
+                if (!frame) {
+                    pending ??= stream.reader.decodeMaybe(decode);
+                    const next = await race([pending, group.closed, unused]);
+                    if (next === idle) {
+                        if (!group.isClosed && group.used.peek()) {
+                            unused = group.unused().then(() => idle);
+                            continue;
+                        }
+                        break;
                     }
-                    break;
+                    pending = undefined;
+                    if (!next || next instanceof Error)
+                        break;
+                    frame = next;
                 }
-                if (done !== false)
-                    break;
-                prevTs += unzigzag(await stream.reader.u62());
-                const timestamp = new Time.Timestamp(Number(prevTs), timescale);
-                const size = await stream.reader.u53();
-                const payload = await stream.reader.read(size);
-                if (!payload)
-                    break;
-                group.writeFrame({ payload, timestamp });
+                group.writeFrame(frame);
             }
             group.close();
             stream.close();
@@ -605,57 +714,128 @@ export class Subscriber {
             stream.abort(e);
         }
     }
-    // Drains SUBSCRIBE_START/END/DROP on the subscribe stream until FIN (lite-05+).
-    // The resolved range is informational here; the producer already orders groups.
-    // Resolves (never rejects) on FIN or on the stream being reset out from under it,
-    // so it's safe to drop from a Promise.race without an unhandled rejection.
-    async #drainResponses(stream) {
-        try {
-            for (;;) {
-                const resp = await decodeSubscribeResponseMaybe(stream.reader, this.version);
-                if (!resp)
-                    return;
+    // Reads SUBSCRIBE_START/END/DROP on the subscribe stream until FIN (lite-05+), recording
+    // the range the tail is accounted against. SUBSCRIBE_END declares the track's end right
+    // away, so a consumer learns it before the last groups arrive. The publisher must declare
+    // the end before FIN; resets and malformed responses reject with their failure.
+    async #runResponses(stream, entry) {
+        for (;;) {
+            const resp = await decodeSubscribeResponseMaybe(stream.reader, this.version);
+            if (!resp) {
+                if (entry.end === undefined)
+                    throw new ProtocolViolation("subscribe stream ended without SUBSCRIBE_END");
+                return;
+            }
+            if ("start" in resp) {
+                entry.start = resp.start.group;
+                // The groups the SUBSCRIBE asked for below it are unavailable, whatever the
+                // demand asks later.
+                if (entry.requested !== undefined)
+                    entry.tail.account(entry.requested, entry.start);
+            }
+            else if ("end" in resp) {
+                if (entry.end !== undefined)
+                    throw new ProtocolViolation("duplicate SUBSCRIBE_END");
+                entry.end = resp.end.group;
+                if (hasStreamCount(this.version))
+                    entry.streams = resp.end.streams;
+                // A local close can win the race with the response; there is nothing left to end.
+                if (entry.track.closed.peek() !== undefined)
+                    continue;
+                try {
+                    entry.track.finishAt(entry.end);
+                }
+                catch (err) {
+                    // lite-05 specified an inclusive end, and @moq/net 0.1.3 to 0.1.9 sent one, so
+                    // there an end below a received group only costs the early boundary: the FIN
+                    // still finishes the track. Later drafts made it exclusive.
+                    if (this.version !== Version.DRAFT_05) {
+                        throw new ProtocolViolation(`invalid SUBSCRIBE_END: ${reason(error(err))}`);
+                    }
+                    console.warn(`invalid SUBSCRIBE_END: ${reason(error(err))}`);
+                }
+            }
+            else if ("drop" in resp) {
+                entry.tail.account(resp.drop.start, resp.drop.end + 1);
             }
-        }
-        catch {
-            // Stream closed or reset; nothing more to drain.
         }
     }
+    // Wait for the group streams the publisher still owes once it has ended the subscription.
+    //
+    // lite-07 counts streams, so skipped sequences owe nothing. Older drafts account for
+    // the range using received headers and SUBSCRIBE_DROP. A counted stream reset before
+    // its header leaves no trace, so the grace still bounds that wait. Streams whose
+    // headers arrived keep reading until their own FIN or reset.
+    #settleTail(entry) {
+        const { tail, track } = entry;
+        const complete = () => {
+            if (entry.streams !== undefined)
+                return tail.streams >= entry.streams;
+            // Without SUBSCRIBE_END (older drafts) nothing says which groups are owed.
+            if (entry.end === undefined)
+                return false;
+            // Without SUBSCRIBE_START the publisher served no group at all.
+            if (entry.start === undefined)
+                return true;
+            // Owed from the floor the demand last asked for, which an update can move either
+            // way, or where SUBSCRIBE_START resolved a live-edge one. The groups the SUBSCRIBE
+            // asked for below its SUBSCRIBE_START were accounted for when it arrived.
+            const groups = track.subscription.peek()?.groups;
+            const bounds = groupBounds(groups ?? {});
+            const start = groups?.start === undefined ? entry.start : bounds.start;
+            const end = bounds.end === undefined ? entry.end : Math.min(entry.end, bounds.end);
+            return tail.covers(start, end);
+        };
+        return tail.settle(complete, track.closed);
+    }
     /**
      * Send SUBSCRIBE_UPDATE messages whenever the track's aggregate subscription changes.
      *
      * Resolves cleanly when the stream or track closes, so the caller can include
-     * this in Promise.race without leaving a dangling pending write that would
+     * this in a race without leaving a dangling pending write that would
      * become an unhandled rejection if the user calls update after close.
      *
      * Peeks the signal at the top of every iteration so that updates which landed
      * before SubscribeOk arrived (or between iterations, before .next() registered
      * its listener) aren't lost.
      */
-    async #runSubscriptionUpdates(id, broadcast, track, msg, stream) {
-        const stopped = Promise.race([track.closed, stream.reader.closed]).then(() => null);
+    async #runSubscriptionUpdates(id, broadcast, entry, msg, stream) {
+        const track = entry.track;
+        const stopped = race([track.closed, stream.reader.closed]).then(() => null);
         let lastSent = {
             priority: msg.priority,
-            ordered: msg.ordered,
-            latencyMax: msg.maxLatency,
-            startGroup: msg.startGroup,
-            endGroup: msg.endGroup,
+            maxAge: Time.Milli(msg.maxAge),
+            groups: {
+                start: msg.startGroup === undefined ? undefined : { included: msg.startGroup },
+                end: msg.endGroup === undefined ? undefined : { excluded: exclusiveGroupEnd(msg.endGroup) ?? 0 },
+            },
         };
         for (;;) {
             const current = track.subscription.peek();
             if (current === undefined || this.#sameSubscription(current, lastSent)) {
                 // Nothing new to send; wait for a change or termination.
-                const next = await Promise.race([track.subscription.changed(), stopped]);
+                const next = await race([track.subscription.changed(), stopped]);
                 if (next === null)
                     return;
                 continue;
             }
+            // Demand collapsing to nothing is refused the same way an initial empty
+            // request is: the error closes the track, so every local subscriber sees it.
+            const bounds = groupBounds(current.groups);
+            if (emptyRange({ startGroup: bounds.start, endGroup: bounds.end }))
+                throw new Error(EMPTY_RANGE);
+            // A lowered floor owes groups nobody asked for until now.
+            if (current.groups?.start !== undefined) {
+                const floor = lastSent.groups?.start === undefined ? entry.start : groupBounds(lastSent.groups).start;
+                entry.tail.demand(bounds.start, floor ?? Number.POSITIVE_INFINITY);
+            }
+            // Round-trip the other Subscribe parameters so the publisher doesn't
+            // interpret SUBSCRIBE_UPDATE as a reset of ordered/maxAge/etc.
             const update = new SubscribeUpdate({
                 priority: current.priority ?? 0,
-                ordered: current.ordered,
-                maxLatency: current.latencyMax,
-                startGroup: current.startGroup,
-                endGroup: current.endGroup,
+                maxAge: current.maxAge,
+                startGroup: current.groups?.start === undefined ? undefined : bounds.start,
+                endGroup: inclusiveGroupEnd(bounds.end),
             });
             await update.encode(stream.writer, this.version);
             lastSent = { ...current };
@@ -663,11 +843,12 @@ export class Subscriber {
         }
     }
     #sameSubscription(a, b) {
+        const ag = groupBounds(a.groups);
+        const bg = groupBounds(b.groups);
         return ((a.priority ?? 0) === (b.priority ?? 0) &&
-            (a.ordered ?? false) === (b.ordered ?? false) &&
-            (a.latencyMax ?? 0) === (b.latencyMax ?? 0) &&
-            a.startGroup === b.startGroup &&
-            a.endGroup === b.endGroup);
+            (a.maxAge ?? 0) === (b.maxAge ?? 0) &&
+            ag.start === bg.start &&
+            ag.end === bg.end);
     }
     /**
      * Handles a group message.
@@ -684,10 +865,19 @@ export class Subscriber {
             }
             return;
         }
-        const { track, timescale } = entry;
+        const { track, timescale, tail } = entry;
         const producer = new netGroup.Producer(group.sequence);
-        track.writeGroup(producer);
+        const read = tail.open(group.sequence);
         try {
+            // The publisher contradicted its own end, which no later group can repair. lite-05
+            // specified an inclusive end, so its last group lands on it: the write below drops
+            // only that group there.
+            if (entry.end !== undefined && group.sequence >= entry.end && this.version !== Version.DRAFT_05) {
+                const violation = new ProtocolViolation(`group ${group.sequence} is at or past the declared end ${entry.end}`);
+                track.close(violation);
+                throw violation;
+            }
+            track.writeGroup(producer);
             // Block until the timescale is known; the group's stream can arrive before
             // TRACK_INFO (or implicit defaults) resolves it on the subscribe stream.
             let scale = timescale.peek();
@@ -695,42 +885,24 @@ export class Subscriber {
                 if (track.closed.peek() !== undefined) {
                     // Subscription ended before the scale resolved; nothing to decode.
                     producer.close();
-                    stream.stop(new Error("cancel"));
+                    stream.stop(new StreamError(StreamCode.Cancel, { message: "cancel" }));
                     return;
                 }
                 await Signal.race(timescale, track.closed);
                 scale = timescale.peek();
             }
-            // A non-zero scale means every frame is prefixed with a zigzag-delta timestamp
-            // (the lite-05 FRAME format), which we decode into a Timestamp at that scale.
-            // Scale 0 (pre-lite-05) carries no timestamp, so we wall-clock-stamp.
-            let prevTs = 0n;
-            for (;;) {
-                const done = await Promise.race([stream.done(), track.closed, producer.closed]);
-                if (done !== false)
-                    break;
-                let timestamp;
-                if (scale !== 0) {
-                    prevTs += unzigzag(await stream.u62());
-                    timestamp = new Time.Timestamp(Number(prevTs), Time.Timescale(scale));
-                }
-                else {
-                    timestamp = Time.Timestamp.now();
-                }
-                const size = await stream.u53();
-                const payload = await stream.read(size);
-                if (!payload)
-                    break;
-                producer.writeFrame({ payload, timestamp });
-            }
+            await readFrames(stream, producer, scale);
             producer.close();
-            stream.stop(new Error("cancel"));
+            stream.stop(new StreamError(StreamCode.Cancel, { message: "cancel" }));
         }
         catch (err) {
             const e = error(err);
             producer.close(e);
             stream.stop(e);
         }
+        finally {
+            read();
+        }
     }
     /**
      * Receives QUIC datagrams and routes each to its subscription's track producer (lite-05 §6.4).
@@ -783,7 +955,7 @@ export class Subscriber {
     // Decode one datagram body and hand it to the matching subscription's producer. Drops the
     // datagram (best-effort) if the subscription is unknown/closed or its timescale isn't resolved.
     async #routeDatagram(payload) {
-        const dg = await DatagramMessage.decode(payload);
+        const dg = await DatagramMessage.decode(payload, this.version);
         const entry = this.#subscribes.get(dg.subscribe);
         if (!entry)
             return; // Unknown or already-closed subscription.
@@ -793,7 +965,9 @@ export class Subscriber {
         if (!scale)
             return;
         const timestamp = new Time.Timestamp(dg.timestamp, Time.Timescale(scale));
-        entry.track.writeDatagram({ sequence: dg.sequence, timestamp, payload: dg.payload });
+        // A datagram's sequence is never owed a stream, so it never holds the tail open.
+        entry.tail.account(dg.sequence, dg.sequence + 1);
+        entry.track.insertDatagram(dg.sequence, timestamp, dg.payload);
     }
     /**
      * Opens a PROBE bidi stream to receive bandwidth estimates from the publisher.
@@ -832,7 +1006,7 @@ export class Subscriber {
         // transport hiccup) MUST NOT tear down the connection. On error, drop the
         // estimates so consumers know they're stale.
         try {
-            const stream = await Stream.open(this.#quic);
+            const stream = await Stream.open(this.#quic, { version: this.version });
             await stream.writer.u53(StreamId.Probe);
             for (;;) {
                 const probe = await Probe.decodeMaybe(stream.reader, this.version);
@@ -861,16 +1035,48 @@ export class Subscriber {
             this.#probe.set({});
         }
     }
-    close() {
-        this.#closed.abort();
+    /**
+     * Ends every subscribed track: cleanly for a deliberate close, or with `err` when the
+     * session died, since those tracks were cut off rather than ended.
+     */
+    close(err) {
+        // A fetch or setup exchange cut off by the session is incomplete even on a deliberate
+        // close, so it always ends with an error.
+        const cut = err ?? new StreamError(StreamCode.SessionClosed, { message: "session closed" });
+        this.#closed.abort(cut);
         for (const { track } of this.#subscribes.values()) {
-            track.close();
+            track.close(err);
         }
         this.#subscribes.clear();
+        // This also releases callers still awaiting acceptance.
+        for (const { group } of this.#fetches.values()) {
+            group.close(cut);
+        }
+    }
+}
+// Settles with `step`, or rejects with the group's error once it closes first. A publisher
+// may never answer a FETCH, so Subscriber.close() closing the group is what releases it.
+async function untilClosed(group, step) {
+    const value = await race([step, group.closed]);
+    const closed = group.closed.peek();
+    if (closed !== undefined)
+        throw closed ?? new Error("fetch closed before it was accepted");
+    return value;
+}
+// Like untilClosed, but also cancels once every reader has left. Demand is level-triggered, so a
+// caller that coalesces onto the group before the check re-arms it.
+async function untilAbandoned(group, step) {
+    const idle = Symbol("idle");
+    for (;;) {
+        const value = await untilClosed(group, race([step, group.unused().then(() => idle)]));
+        if (value !== idle)
+            return value;
+        if (!group.used.peek())
+            throw new StreamError(StreamCode.Cancel, { message: "cancel" });
     }
 }
 /**
- * A broadcast consumed from a lite session. It resolves `track.Consumer.info()` and
+ * A broadcast consumed from a lite session. It resolves `track.Consumer.query()` and
  * `.fetchGroup()` over the wire (lite-05+ TRACK / FETCH streams) by reaching into the
  * {@link Subscriber} it was opened from, the way the Rust `BroadcastConsumer` holds its
  * session. Live subscribes still flow through the inherited requested() queue.
@@ -880,6 +1086,10 @@ class ConsumeBroadcast extends broadcast.Consumer {
     #path;
     constructor(subscriber, path, state) {
         super(state);
+        overrideBroadcastWire(this, {
+            resolveTrackInfo: (name) => subscriber.resolveTrackInfo(path, name),
+            fetchGroup: (name, sequence, options) => subscriber.fetchGroup(path, name, sequence, options),
+        });
         this.#subscriber = subscriber;
         this.#path = path;
     }
@@ -888,11 +1098,5 @@ class ConsumeBroadcast extends broadcast.Consumer {
     clone() {
         return new ConsumeBroadcast(this.#subscriber, this.#path, this.shareState());
     }
-    resolveTrackInfo(name) {
-        return this.#subscriber.resolveTrackInfo(this.#path, name);
-    }
-    fetchGroup(name, sequence, options) {
-        return this.#subscriber.fetchGroup(this.#path, name, sequence, options);
-    }
 }
 //# sourceMappingURL=subscriber.js.map