@norskvideo/moq-net 0.1.2 → 0.1.4

package/ietf/publisher.js

@@ -1,9 +1,15 @@
 /* @ts-self-types="./publisher.d.ts" */
-import { Announced } from "../announced.js";
+import { Signal } from "@norskvideo/moq-signals";
+import { error, reason } from "../error.js";
 import * as Path from "../path.js";
 import { Writer } from "../stream.js";
-import { error } from "../util/error.js";
-import { Frame, Group as GroupMessage } from "./object.js";
+import { withTimeout } from "../util/timeout.js";
+import * as Cluster from "./cluster.js";
+import { FetchHeader } from "./fetch.js";
+import * as Filter from "./filter.js";
+import { FetchFrame, Frame, Group as GroupMessage } from "./object.js";
+import { fromWire } from "./priority.js";
+import * as Properties from "./properties.js";
 import { PublishDone } from "./publish.js";
 import { PublishNamespace, PublishNamespaceDone, PublishNamespaceOk } from "./publish_namespace.js";
 import { RequestError, RequestOk } from "./request.js";
@@ -11,6 +17,25 @@ import { SubscribeError, SubscribeOk } from "./subscribe.js";
 import { SubscribeNamespaceEntry, SubscribeNamespaceEntryDone, SubscribeNamespaceOk, } from "./subscribe_namespace.js";
 import { TrackStatus } from "./track.js";
 import { Version } from "./version.js";
+/** First wait before re-offering a namespace the peer refused or we couldn't open for. */
+const RETRY_BASE = 100;
+/** Ceiling on that wait. The loop retries for the life of the session, so it must not spin. */
+const RETRY_MAX = 5000;
+/** PUBLISH_DONE statuses this implementation emits. Stable across drafts 14 through 19. */
+const PUBLISH_DONE_STATUS = {
+    INTERNAL_ERROR: 0x0,
+    TRACK_ENDED: 0x2,
+};
+/**
+ * How long one advertisement may take to be answered. Matches the Rust publisher, and the
+ * peer accepting the stream is only half the exchange: one it never answers on holds the
+ * loop just as effectively as one it never grants.
+ */
+const ADVERTISE_TIMEOUT_MS = 5000;
+/** Sleep `delay`, jittered, so a relay's namespaces don't all retry on the same tick. */
+function retryAfter(delay) {
+    return new Promise((resolve) => setTimeout(resolve, delay * (0.5 + Math.random() / 2)));
+}
 /**
  * Handles publishing broadcasts using moq-transport protocol.
  * Uses the stream-per-request pattern (real bidi streams for v17, virtual for v14-v16).
@@ -20,86 +45,44 @@ import { Version } from "./version.js";
 export class Publisher {
     #quic;
     #session;
+    #requiresSolicitation;
+    // What every advertisement carries on a session that negotiated the MoQ Cluster
+    // extension: a hop path holding our own id, so the peer can tell that what it hears
+    // back came from us. `undefined` when nothing negotiated it.
+    #advert;
     // Our published broadcasts.
-    #broadcasts = new Map();
-    // Any consumers that want each new announcement.
-    #announcedConsumers = new Set();
+    // It's a signal so we can live update any subscribe_namespace streams.
+    #broadcasts = new Signal(new Map());
     /**
      * Creates a new Publisher instance.
-     * @param quic - The WebTransport session (for uni streams)
-     * @param session - The session abstraction for bidi streams and request IDs
      *
      * @internal
      */
-    constructor(quic, session) {
+    constructor({ quic, session, requiresSolicitation, cluster, }) {
         this.#quic = quic;
         this.#session = session;
+        this.#requiresSolicitation = requiresSolicitation;
+        this.#advert = Cluster.advertise(cluster);
     }
     /**
      * Publishes a broadcast with any associated tracks.
-     * Opens a bidi stream to send PublishNamespace and waits for response.
+     * The namespace is advertised with an unsolicited PUBLISH_NAMESPACE, or on request
+     * if the peer asked for that (see {@link runPublishNamespaces}).
      */
     publish(path, broadcast) {
-        this.#broadcasts.set(path, broadcast);
-        this.#notifyConsumers(path, true);
-        void this.#runPublish(path, broadcast);
-    }
-    async #runPublish(path, broadcast) {
-        try {
-            const requestId = await this.#session.nextRequestId();
-            if (requestId === undefined)
-                return;
-            const stream = await this.#session.openBi();
-            try {
-                // Write PublishNamespace
-                await stream.writer.u53(PublishNamespace.id);
-                const msg = new PublishNamespace({ requestId, trackNamespace: path });
-                await msg.encode(stream.writer, this.#session.version);
-                // Read response (RequestOk and PublishNamespaceOk share 0x07)
-                const respTypeId = await stream.reader.u53();
-                if (respTypeId === RequestOk.id) {
-                    // Draft-14 sends PublishNamespaceOk (requestId only, no parameters)
-                    if (this.#session.version === Version.DRAFT_14) {
-                        await PublishNamespaceOk.decode(stream.reader, this.#session.version);
-                    }
-                    else {
-                        await RequestOk.decode(stream.reader, this.#session.version);
-                    }
-                }
-                else {
-                    throw new Error(`PublishNamespace rejected: typeId=0x${respTypeId.toString(16)}`);
-                }
-                // Wait for broadcast to close or stream to close (peer cancelled)
-                await Promise.race([broadcast.closed, stream.reader.closed]);
-                // For v14-v16: send explicit PublishNamespaceDone (removed in v17+)
-                if (this.#session.version === Version.DRAFT_14 ||
-                    this.#session.version === Version.DRAFT_15 ||
-                    this.#session.version === Version.DRAFT_16) {
-                    try {
-                        await stream.writer.u53(PublishNamespaceDone.id);
-                        const done = new PublishNamespaceDone({ trackNamespace: path, requestId });
-                        await done.encode(stream.writer, this.#session.version);
-                    }
-                    catch {
-                        // Stream might already be closed
-                    }
+        this.#broadcasts.mutate((broadcasts) => {
+            if (!broadcasts)
+                throw new Error("closed");
+            broadcasts.set(path, broadcast);
+        });
+        // Remove the broadcast from the lookup when it's closed, unless the path was republished.
+        void broadcast.closed.then(() => {
+            this.#broadcasts.mutate((broadcasts) => {
+                if (broadcasts?.get(path) === broadcast) {
+                    broadcasts.delete(path);
                 }
-                stream.close();
-            }
-            catch (err) {
-                stream.abort(error(err));
-                throw err;
-            }
-        }
-        catch (err) {
-            const e = error(err);
-            console.warn(`announce failed: broadcast=${path} error=${e.message}`);
-        }
-        finally {
-            broadcast.close();
-            this.#broadcasts.delete(path);
-            this.#notifyConsumers(path, false);
-        }
+            });
+        });
     }
     /**
      * Handles an incoming SUBSCRIBE request on a bidi stream.
@@ -110,7 +93,7 @@ export class Publisher {
     async runSubscribe(msg, stream) {
         const version = this.#session.version;
         const name = msg.trackNamespace;
-        const broadcast = this.#broadcasts.get(name);
+        const broadcast = this.#broadcasts.peek()?.get(name);
         if (!broadcast) {
             // Write error response
             if (version === Version.DRAFT_14) {
@@ -134,8 +117,37 @@ export class Publisher {
             stream.close();
             return;
         }
-        const track = broadcast.subscribe(msg.trackName, msg.subscriberPriority);
+        const priority = fromWire(msg.subscriberPriority);
+        const track = broadcast.subscribe(msg.trackName, { priority });
+        // Hoisted so the cleanup below reaches it: the fork happens before SUBSCRIBE_OK is
+        // written, and a write that throws must not strand the sink it attached.
+        let cache;
         try {
+            const timescale = (await track.info()).timescale;
+            // The filter and any fill are relative to the live edge, so snapshot it once: the
+            // fill ends exactly where a Next Object subscription begins, which is what lets
+            // the draft's current-group join (Next Object plus a StartGroup=1 fill) cover the
+            // group with no gap and no overlap.
+            const edge = liveEdge(track);
+            const range = subscribeRange(msg, edge, version);
+            // The wire request tells an upstream what we need; the cursor is what actually
+            // trims this subscriber, since the producer fans every cached group out to every
+            // sink regardless. An absent start joins at the latest group, which is what
+            // moq-lite means by joining a live track.
+            track.update({
+                priority,
+                startGroup: range.start && Number(range.start.group),
+                endGroup: range.end && Number(range.end.group),
+            });
+            const startGroup = range.start ? Number(range.start.group) : track.latest();
+            if (startGroup !== undefined)
+                track.startAt(startGroup);
+            // A fill reads the group cache through its own consumer, independent of the
+            // subscription's cursor. Forked from this subscriber rather than resolved through
+            // the broadcast again: a dynamic serve is one request per peer subscription, so
+            // asking the broadcast would mint a second producer nobody has accepted.
+            const fill = msg.fill && Filter.isDraft20(version) ? fillRange(msg.fill, msg.filter, edge.largest) : undefined;
+            cache = fill && fill.kind !== "empty" ? track.fork({ priority }) : undefined;
             // Send SUBSCRIBE_OK
             await stream.writer.u53(SubscribeOk.id);
             const ok = new SubscribeOk({
@@ -143,73 +155,183 @@ export class Publisher {
                     ? msg.requestId
                     : undefined,
                 trackAlias: msg.requestId,
+                // Required once the track has content; a fill-requesting subscriber sizes its
+                // backfill against this.
+                largest: edge.largest && { groupId: edge.largest.group, objectId: edge.largest.object },
+                properties: msg.propertiesWanted
+                    ? // Declaring the timescale is what opts the track into timestamps; every
+                        // object Timestamp below is in these units. We serve the newest group
+                        // first, matching moq-lite.
+                        { timescale, groupOrder: Properties.DESCENDING }
+                    : // INCLUDE_PROPERTIES=0. The block stays present but empty, which also means
+                        // the track opts out of timestamps for this subscriber.
+                        {},
             });
             await ok.encode(stream.writer, version);
             console.debug(`publish ok: broadcast=${name} track=${track.name}`);
+            // Cancels groups still queued for a stream slot. Only the subscriber leaving counts:
+            // a track that ran out of groups still has to flush the ones already queued, and we
+            // close the stream ourselves below to say so.
+            let finished = false;
+            let unsubscribe;
+            const unsubscribed = new Promise((resolve) => {
+                unsubscribe = resolve;
+            });
+            void stream.reader.closed.then(() => {
+                if (!finished)
+                    unsubscribe();
+            }, 
+            // A reset is always the peer.
+            () => unsubscribe());
             // Serve track groups, racing with stream close (= Unsubscribe)
             const serving = (async () => {
                 for (;;) {
                     const group = await track.recvGroup();
                     if (!group)
                         return;
-                    void this.#runGroup(msg.requestId, group);
-                }
-            })();
-            await Promise.race([serving, stream.reader.closed]);
-            console.debug(`publish done: broadcast=${name} track=${track.name}`);
-            // v14-v16: send PublishDone before closing
-            if (version === Version.DRAFT_14 || version === Version.DRAFT_15 || version === Version.DRAFT_16) {
-                try {
-                    await stream.writer.u53(PublishDone.id);
-                    const done = new PublishDone({
+                    // Past the filter's end. Dropped here rather than through `endAt`, which
+                    // parks a capped group instead: this range is fixed for the life of the
+                    // subscription, so a group above it is never coming back in, and holding
+                    // one keeps the loop from ever ending. A producer that publishes beyond
+                    // the end and then closes would otherwise strand PUBLISH_DONE.
+                    if (range.end !== undefined && BigInt(group.sequence) > range.end.group) {
+                        group.close();
+                        continue;
+                    }
+                    void this.#runGroup({
                         requestId: msg.requestId,
-                        statusCode: 200,
-                        reasonPhrase: "OK",
+                        group,
+                        timescale,
+                        stamped: msg.propertiesWanted,
+                        slice: groupSlice(range, group.sequence),
+                        unsubscribed,
                     });
-                    await done.encode(stream.writer, version);
-                }
-                catch {
-                    // Stream might already be closed by peer
                 }
+            })();
+            // The fill (when one was requested) runs alongside on its own fetch stream; its
+            // failures reset that stream and never touch the subscription.
+            const filling = fill && cache
+                ? this.#runFill({
+                    requestId: msg.requestId,
+                    priority,
+                    fill,
+                    cache,
+                    timescale,
+                    stamped: msg.propertiesWanted,
+                    unsubscribed,
+                })
+                : Promise.resolve();
+            let publishError;
+            try {
+                await Promise.race([Promise.all([serving, filling]), stream.reader.closed]);
+            }
+            catch (err) {
+                publishError = error(err);
+            }
+            console.debug(`publish done: broadcast=${name} track=${track.name}`);
+            if (publishError) {
+                console.warn(`publish error: broadcast=${name} track=${track.name} error=${reason(publishError)}`);
+            }
+            // PUBLISH_DONE is required for every supported draft. The peer may have already
+            // closed its side to unsubscribe, in which case there is nowhere to send it.
+            try {
+                await stream.writer.u53(PublishDone.id);
+                const done = new PublishDone({
+                    requestId: version === Version.DRAFT_14 || version === Version.DRAFT_15 || version === Version.DRAFT_16
+                        ? msg.requestId
+                        : undefined,
+                    statusCode: publishError ? PUBLISH_DONE_STATUS.INTERNAL_ERROR : PUBLISH_DONE_STATUS.TRACK_ENDED,
+                    reasonPhrase: publishError ? "internal error" : "track ended",
+                });
+                await done.encode(stream.writer, version);
+            }
+            catch {
+                // Stream might already be closed by peer.
             }
+            // Only now is the close below ours. Claiming it any earlier would read a peer FIN
+            // that lands while PublishDone is still going out as our own completion, leaving
+            // queued groups to open for a subscriber that has already left.
+            finished = true;
             stream.close();
         }
         catch (err) {
             const e = error(err);
-            console.warn(`publish error: broadcast=${name} track=${track.name} error=${e.message}`);
+            console.warn(`publish error: broadcast=${name} track=${track.name} error=${reason(e)}`);
             stream.abort(e);
         }
         finally {
             track.close();
+            // Idempotent, and the backstop for a throw between the fork and the fill starting:
+            // #runFill closes it itself on every path it reaches.
+            cache?.close();
         }
     }
     /**
      * Runs a group and sends its frames using ObjectStream (Subgroup delivery mode).
      */
-    async #runGroup(requestId, group) {
+    async #runGroup(options) {
+        const { requestId, group, timescale, stamped, slice, unsubscribed } = options;
         try {
-            const stream = await Writer.open(this.#quic, this.#session.version);
+            // One stream per group is faster than a peer at its limit can retire them, so this
+            // is the one path that doesn't wait for a slot: the transport would serve the opens
+            // in the order we asked, which is oldest-first, exactly backwards for live media.
+            // Failing here drops the group and lets the next one compete for the next slot.
+            const stream = await Writer.tryOpen(this.#quic, {
+                cancel: unsubscribed,
+                version: this.#session.version,
+                waitUntilAvailable: false,
+            });
+            if (!stream) {
+                group.close(new Error("no stream slot"));
+                return;
+            }
             const header = new GroupMessage({
                 trackAlias: requestId,
                 groupId: group.sequence,
                 subGroupId: 0,
                 publisherPriority: 0,
                 flags: {
-                    hasExtensions: false,
+                    // The object properties carry the timestamp, so there is nothing to write
+                    // when the track declared no units to read one in.
+                    hasExtensions: stamped,
                     hasSubgroup: false,
                     hasSubgroupObject: false,
                     hasEnd: true,
                     hasPriority: true,
+                    // Only honest when the stream really starts at the group's first object;
+                    // a trimmed head starts partway through.
+                    firstObject: slice.skip === 0,
                 },
             });
             await header.encode(stream, this.#session.version);
             try {
+                // The first written object goes on the wire as its absolute id, so a trimmed
+                // head shows the true numbering rather than a silently renumbered group.
+                let first = true;
+                // The next object id that could be written, which starts at the filter rather
+                // than at zero. A backwards range (`startObject` above `endObject` in the same
+                // group) is empty, and starting here is what lets the check below see that
+                // before the read parks on an object the range already excludes.
+                let next = slice.skip;
                 for (;;) {
-                    const frame = await Promise.race([group.readFrame(), stream.closed]);
+                    // The filter ends inside this group: everything at `until` and beyond is
+                    // outside the requested range, so stop without waiting for the group's end.
+                    if (slice.until !== undefined && next >= slice.until)
+                        break;
+                    // Reading from the filter's start drops the objects below it, including any the
+                    // group's cache evicted: they are outside the requested range, so losing them is
+                    // not the gap that would otherwise reset this stream and forfeit the rest of the
+                    // group. An eviction at or above the start is a real gap and still throws.
+                    const frame = await Promise.race([group.readFrameSequence({ from: slice.skip }), stream.closed]);
                     if (!frame)
                         break;
-                    const obj = new Frame({ payload: frame });
-                    await obj.encode(stream, header.flags);
+                    next = frame.sequence + 1;
+                    if (slice.until !== undefined && frame.sequence >= slice.until)
+                        break;
+                    const obj = new Frame({ payload: frame.payload, timestamp: frame.timestamp });
+                    const delta = first ? frame.sequence : 0;
+                    first = false;
+                    await obj.encode(stream, header.flags, timescale, this.#session.version, delta);
                 }
                 stream.close();
             }
@@ -221,15 +343,112 @@ export class Publisher {
             group.close();
         }
     }
+    /**
+     * Serve a draft-20 fill on its own fetch stream: the requested range, read from the
+     * group cache, capped at the Largest Object snapshot.
+     *
+     * A fill is a promise once requested. An empty range opens no stream, but a range we
+     * cannot serve still opens one and resets it right after the FETCH_HEADER, the draft's
+     * fill-failure signal. Nothing here touches the subscription either way.
+     */
+    async #runFill(options) {
+        const { requestId, fill, cache, timescale, stamped, unsubscribed } = options;
+        const version = this.#session.version;
+        // Everything is inside the try so the cache fork is released on every path out,
+        // including a transport failure while opening the stream.
+        let stream;
+        try {
+            if (fill.kind === "empty")
+                return;
+            stream = await Writer.tryOpen(this.#quic, { cancel: unsubscribed, version });
+            if (!stream) {
+                console.debug(`fill stream failed to open: fill=${requestId}`);
+                return;
+            }
+            await stream.u53(FetchHeader.type);
+            await new FetchHeader({ requestId }).encode(stream, version);
+            if (fill.kind !== "group") {
+                throw new Error("a fill spanning several groups is not supported");
+            }
+            const group = takeGroup(cache, Number(fill.sequence));
+            try {
+                await this.#writeFillGroup(stream, group, fill, timescale, stamped, unsubscribed);
+            }
+            finally {
+                group.close();
+            }
+            stream.close();
+            console.debug(`fill complete: fill=${requestId}`);
+        }
+        catch (err) {
+            // A fill never fails the subscription; its own stream carries the failure.
+            const e = error(err);
+            console.debug(`fill failed, resetting its stream: fill=${requestId} error=${reason(e)}`);
+            stream?.reset(e);
+        }
+        finally {
+            cache.close();
+        }
+    }
+    /**
+     * Write one cached group's frames as draft-20 fetch objects.
+     *
+     * The cap is the Largest Object snapshot: the group may keep growing, but everything
+     * past the snapshot belongs to the subscription, not the fill.
+     */
+    async #writeFillGroup(stream, group, fill, timescale, stamped, unsubscribed) {
+        let first = true;
+        let next = 0n;
+        // The subscriber leaving has to end the fill too. An absolute filter ending below the
+        // edge with no end object leaves `until` unset, so this reads until the group closes,
+        // which a still-open past group may never do. Watching only the fetch stream would
+        // then pin the group and the cache subscription behind it for the life of the track.
+        let left = false;
+        const cancelled = unsubscribed.then(() => {
+            left = true;
+            return undefined;
+        });
+        for (;;) {
+            // The group may keep growing, but everything at `until` and beyond belongs to the
+            // subscription, so stop without waiting for the group's end.
+            if (fill.until !== undefined && next >= fill.until)
+                break;
+            // Reading from the fill's start drops everything below it, evicted objects included;
+            // see the same read in #runGroup.
+            const frame = await Promise.race([
+                group.readFrameSequence({ from: Number(fill.skip) }),
+                stream.closed,
+                cancelled,
+            ]);
+            if (left)
+                throw new Error("unsubscribed before the fill finished");
+            if (!frame)
+                break;
+            next = BigInt(frame.sequence) + 1n;
+            if (fill.until !== undefined && BigInt(frame.sequence) >= fill.until)
+                break;
+            const obj = new FetchFrame({ payload: frame.payload, timestamp: stamped ? frame.timestamp : undefined });
+            await obj.encode(stream, { group: Number(fill.sequence), object: frame.sequence, first }, timescale, this.#session.version);
+            first = false;
+        }
+    }
     /**
      * Handles an incoming SUBSCRIBE_NAMESPACE on a bidi stream.
-     * Sends RequestOk, then streams Namespace/NamespaceDone entries.
+     *
+     * This carries the advertisements only when the peer asked to be told on request
+     * (MoQ Solicit); otherwise {@link runPublishNamespaces} has already announced
+     * everything and repeating it here would leave the peer holding two sources for one
+     * broadcast. Draft-16+ streams Namespace entries inline; draft-14/15 predate those
+     * messages, so each advertisement is a PUBLISH_NAMESPACE request of its own.
      *
      * @internal
      */
     async runSubscribeNamespace(msg, stream) {
         const version = this.#session.version;
         const prefix = msg.namespace;
+        const legacy = version === Version.DRAFT_14 || version === Version.DRAFT_15;
+        // Draft-14/15: the open PUBLISH_NAMESPACE request per advertised suffix.
+        const requests = new Map();
         try {
             // Send OK response
             if (version === Version.DRAFT_14) {
@@ -244,45 +463,298 @@ export class Publisher {
                 });
                 await ok.encode(stream.writer, version);
             }
-            // Create an Announced consumer and seed it with current broadcasts
-            const announced = new Announced(prefix);
-            for (const name of this.#broadcasts.keys()) {
-                const suffix = Path.stripPrefix(prefix, name);
-                if (suffix === null)
-                    continue;
-                announced.append({ path: suffix, active: true });
+            if (!this.#requiresSolicitation) {
+                // Already announced, unasked. Hold the stream open until the peer is done.
+                await stream.reader.closed;
+                stream.close();
+                return;
             }
-            this.#announcedConsumers.add(announced);
-            // Close the consumer when the stream closes
-            stream.reader.closed.then(() => announced.close(), () => announced.close());
-            try {
-                for (;;) {
-                    const entry = await announced.next();
-                    if (!entry)
-                        break;
-                    if (entry.active) {
-                        await stream.writer.u53(SubscribeNamespaceEntry.id);
-                        const e = new SubscribeNamespaceEntry({ suffix: entry.path });
-                        await e.encode(stream.writer, version);
-                    }
-                    else {
-                        await stream.writer.u53(SubscribeNamespaceEntryDone.id);
-                        const e = new SubscribeNamespaceEntryDone({ suffix: entry.path });
-                        await e.encode(stream.writer, version);
+            // Reports whether the peer now holds the namespace: an inline entry always
+            // lands, but a PUBLISH_NAMESPACE request can be declined.
+            const advertise = async (suffix) => {
+                if (legacy) {
+                    return await this.#advertise(Path.join(prefix, suffix), requests, refused);
+                }
+                await stream.writer.u53(SubscribeNamespaceEntry.id);
+                await new SubscribeNamespaceEntry({ suffix, cluster: this.#advert }).encode(stream.writer, version);
+                return true;
+            };
+            const withdraw = async (suffix) => {
+                if (legacy) {
+                    await this.#withdraw(Path.join(prefix, suffix), requests);
+                }
+                else {
+                    await stream.writer.u53(SubscribeNamespaceEntryDone.id);
+                    await new SubscribeNamespaceEntryDone({ suffix }).encode(stream.writer, version);
+                }
+            };
+            let active = new Set();
+            let retry = 0;
+            // What the peer refused, and whether coming back is worth anything.
+            const refused = new Map();
+            for (;;) {
+                // Subscribe BEFORE reconciling, for the same reason as
+                // {@link runPublishNamespaces}: a publish landing while an advertisement
+                // waits for its reply only notifies listeners already registered.
+                // TODO Make a better helper within Signals.
+                let dispose;
+                const changed = new Promise((resolve) => {
+                    dispose = this.#broadcasts.changed(resolve);
+                });
+                const broadcasts = this.#broadcasts.peek();
+                if (!broadcasts) {
+                    dispose();
+                    break;
+                }
+                const updated = new Set();
+                for (const name of broadcasts.keys()) {
+                    const suffix = Path.stripPrefix(prefix, name);
+                    if (suffix === null)
+                        continue;
+                    updated.add(suffix);
+                }
+                // A namespace that is gone takes its refusal with it, so re-announcing the
+                // path offers it again.
+                const live = new Set([...updated].map((suffix) => Path.join(prefix, suffix)));
+                for (const path of [...refused.keys()]) {
+                    if (!live.has(path))
+                        refused.delete(path);
+                }
+                // Track what the peer holds rather than what we attempted: a declined
+                // advertisement stays out of `held`, so the next turn retries it instead of
+                // believing the namespace is already up.
+                const held = new Set(active);
+                for (const added of updated.difference(active)) {
+                    if (this.#offerable(Path.join(prefix, added), refused)) {
+                        if (await advertise(added))
+                            held.add(added);
                     }
                 }
-            }
-            finally {
-                announced.close();
-                this.#announcedConsumers.delete(announced);
+                for (const removed of active.difference(updated)) {
+                    await withdraw(removed);
+                    held.delete(removed);
+                }
+                active = held;
+                // Whatever we wanted up and could not get up, as {@link runPublishNamespaces}
+                // does: only a legacy request can be declined, and nothing about the peer
+                // starting to answer raises a signal this loop is watching.
+                const outstanding = [...updated.difference(active)].some((suffix) => this.#pending(Path.join(prefix, suffix), refused));
+                retry = outstanding ? Math.min(retry ? retry * 2 : RETRY_BASE, RETRY_MAX) : 0;
+                // Wait for the next change, or for the peer to unsubscribe.
+                const next = await (retry
+                    ? Promise.race([changed, stream.reader.closed, retryAfter(retry).then(() => broadcasts)])
+                    : Promise.race([changed, stream.reader.closed]));
+                dispose();
+                if (!next)
+                    break;
             }
             stream.close();
         }
         catch (err) {
             const e = error(err);
-            console.debug(`subscribe_namespace stream error: ${e.message}`);
+            console.debug(`subscribe_namespace stream error: ${reason(e)}`);
             stream.abort(e);
         }
+        finally {
+            // This subscription's advertisements die with it.
+            for (const path of [...requests.keys()]) {
+                await this.#withdraw(path, requests);
+            }
+        }
+    }
+    /**
+     * Advertise every published broadcast with an unsolicited PUBLISH_NAMESPACE, until
+     * the publisher is closed.
+     *
+     * The peers that never send SUBSCRIBE_NAMESPACE are exactly the ones expecting a
+     * publisher to announce itself, so announcing is the default. A peer that would
+     * rather ask says so in its SETUP (MoQ Solicit) and this does nothing, leaving
+     * {@link runSubscribeNamespace} to carry the advertisements instead. Exactly one of
+     * the two is live, so the peer never hears a namespace twice.
+     *
+     * @internal
+     */
+    async runPublishNamespaces() {
+        if (this.#requiresSolicitation) {
+            // The peer asked to be told on request; runSubscribeNamespace answers it.
+            return;
+        }
+        // The open PUBLISH_NAMESPACE request per advertised path.
+        const requests = new Map();
+        try {
+            let active = new Set();
+            let retry = 0;
+            // What the peer refused, and whether coming back is worth anything.
+            const refused = new Map();
+            for (;;) {
+                // Subscribe BEFORE reconciling. Each advertisement below waits a round trip
+                // for the peer's reply, and a publish that lands in that window notifies
+                // only the listeners already registered; one created afterwards would sleep
+                // through it and leave the namespace unadvertised until something unrelated
+                // changed.
+                // TODO Make a better helper within Signals.
+                let dispose;
+                const changed = new Promise((resolve) => {
+                    dispose = this.#broadcasts.changed(resolve);
+                });
+                const broadcasts = this.#broadcasts.peek();
+                if (!broadcasts) {
+                    dispose();
+                    break;
+                }
+                const updated = new Set(broadcasts.keys());
+                // A namespace that is gone takes its refusal with it, so re-announcing the
+                // path offers it again. Rust gets this by rebuilding the watched entry.
+                for (const path of [...refused.keys()]) {
+                    if (!updated.has(path))
+                        refused.delete(path);
+                }
+                for (const added of updated.difference(active)) {
+                    if (this.#offerable(added, refused)) {
+                        await this.#advertise(added, requests, refused);
+                    }
+                }
+                for (const removed of active.difference(updated)) {
+                    await this.#withdraw(removed, requests);
+                }
+                // What the peer holds, not what we attempted: a declined PUBLISH_NAMESPACE
+                // leaves no request behind, so it stays outstanding below.
+                active = new Set(requests.keys());
+                // Whatever we wanted up and could not get up. Stream credit freeing, a
+                // transient failure clearing, or the peer starting to answer raises no
+                // signal of its own, so the only way back is to ask again on a timer.
+                const outstanding = [...updated.difference(active)].some((path) => this.#pending(path, refused));
+                retry = outstanding ? Math.min(retry ? retry * 2 : RETRY_BASE, RETRY_MAX) : 0;
+                // Wait for the next change, which has already fired if one landed above.
+                const next = await (retry
+                    ? Promise.race([changed, retryAfter(retry).then(() => broadcasts)])
+                    : changed);
+                dispose();
+                if (!next)
+                    break;
+            }
+        }
+        catch (err) {
+            // Nothing restarts this loop, so whatever got us here cost the session its
+            // discovery. Not a debug-level event.
+            console.warn(`publish_namespace loop failed: ${reason(error(err))}`);
+        }
+        finally {
+            // Close out every open PUBLISH_NAMESPACE request.
+            for (const path of [...requests.keys()]) {
+                await this.#withdraw(path, requests);
+            }
+        }
+    }
+    /**
+     * Whether a namespace may be offered to the peer right now.
+     *
+     * A peer that asked never to be offered it again means it, whatever brought us back;
+     * one that named a minimum wait gets it, even when our own backoff comes round sooner.
+     */
+    #offerable(path, refused) {
+        const entry = refused.get(path);
+        if (entry === undefined)
+            return true;
+        return entry !== "never" && Date.now() >= entry;
+    }
+    /**
+     * Whether the loop should keep coming back to a namespace the peer does not hold.
+     *
+     * Distinct from {@link offerable}, and the difference is what arms the retry: a
+     * namespace waiting out a minimum is not offerable yet but is still pending, and
+     * gating the timer on offerable instead would disarm it for exactly the wait it is
+     * supposed to be counting. Only a refusal that forbids retrying ends it.
+     */
+    #pending(path, refused) {
+        return refused.get(path) !== "never";
+    }
+    /**
+     * Advertise one namespace on its own PUBLISH_NAMESPACE request. A declined request
+     * is logged and skipped: a peer that wants none of this rejects each one and stays
+     * connected.
+     *
+     * `refused` records what a refusal said about coming back, so a peer that asked not to
+     * be offered a namespace again is not re-offered it by the retry above.
+     */
+    async #advertise(path, requests, refused) {
+        const requestId = await this.#session.nextRequestId();
+        if (requestId === undefined)
+            return false;
+        // Opening is inside the try because it fails like any other advertisement does:
+        // a peer out of stream credit rejects here, and letting that escape would unwind
+        // the announce loop and take discovery down for the whole session, rather than
+        // costing this one namespace a turn.
+        let request;
+        try {
+            request = await this.#session.openBi();
+            const stream = request;
+            // Bounded, like the subscriber's own request: the loop is single-threaded over
+            // advertisements, so a peer that takes the stream and answers nothing strands
+            // every publish and withdrawal behind it. Timing out costs this namespace a
+            // turn and leaves it outstanding, which the retry above re-offers.
+            await withTimeout((async () => {
+                await stream.writer.u53(PublishNamespace.id);
+                const msg = new PublishNamespace({ requestId, trackNamespace: path, cluster: this.#advert });
+                await msg.encode(stream.writer, this.#session.version);
+                // Read response (RequestOk and PublishNamespaceOk share 0x07)
+                const respTypeId = await stream.reader.u53();
+                if (respTypeId === RequestError.id) {
+                    // The peer named how long to stay away, in milliseconds. Draft-14/15
+                    // carry no such field, so a 0 there says nothing and our own backoff
+                    // stands; everywhere else 0 means it does not want this again.
+                    const err = await RequestError.decode(stream.reader, this.#session.version);
+                    const legacy = this.#session.version === Version.DRAFT_14 || this.#session.version === Version.DRAFT_15;
+                    if (!legacy) {
+                        refused.set(path, err.retryInterval === 0n ? "never" : Date.now() + Number(err.retryInterval));
+                    }
+                    throw new Error(`PublishNamespace rejected: ${err.errorCode} ${err.reasonPhrase}`);
+                }
+                if (respTypeId !== RequestOk.id) {
+                    throw new Error(`PublishNamespace rejected: typeId=0x${respTypeId.toString(16)}`);
+                }
+                // Draft-14 sends PublishNamespaceOk (requestId only, no parameters)
+                if (this.#session.version === Version.DRAFT_14) {
+                    await PublishNamespaceOk.decode(stream.reader, this.#session.version);
+                }
+                else {
+                    await RequestOk.decode(stream.reader, this.#session.version);
+                }
+            })(), ADVERTISE_TIMEOUT_MS, `advertisement timed out after ${ADVERTISE_TIMEOUT_MS}ms waiting for the peer's answer`);
+            requests.set(path, { path, requestId, stream: request });
+            return true;
+        }
+        catch (err) {
+            const e = error(err);
+            console.warn(`announce failed: broadcast=${path} error=${reason(e)}`);
+            request?.abort(e);
+            return false;
+        }
+    }
+    /**
+     * Close out a namespace's PUBLISH_NAMESPACE request with PUBLISH_NAMESPACE_DONE.
+     */
+    async #withdraw(path, requests) {
+        const request = requests.get(path);
+        if (!request)
+            return;
+        requests.delete(path);
+        // Draft-17+ removed PUBLISH_NAMESPACE_DONE: the close below is the whole
+        // withdrawal. Sending it anyway puts the type on the wire before the body throws,
+        // and a receiver reading 0x09 there has no choice but to treat it as a protocol
+        // violation.
+        const version = this.#session.version;
+        if (version === Version.DRAFT_14 || version === Version.DRAFT_15 || version === Version.DRAFT_16) {
+            try {
+                await request.stream.writer.u53(PublishNamespaceDone.id);
+                const done = new PublishNamespaceDone({ trackNamespace: request.path, requestId: request.requestId });
+                await done.encode(request.stream.writer, version);
+            }
+            catch {
+                // Stream might already be closed
+            }
+        }
+        request.stream.close();
     }
     /**
      * Handles an incoming TRACK_STATUS_REQUEST on a bidi stream.
@@ -313,18 +785,163 @@ export class Publisher {
         }
         stream.close();
     }
-    #notifyConsumers(path, active) {
-        for (const consumer of this.#announcedConsumers) {
-            const suffix = Path.stripPrefix(consumer.prefix, path);
-            if (suffix === null)
-                continue;
-            try {
-                consumer.append({ path: suffix, active });
-            }
-            catch {
-                // Consumer already closed, will be cleaned up
+    /**
+     * Closes every published broadcast and stops accepting new ones.
+     *
+     * @internal
+     */
+    close() {
+        this.#broadcasts.update((broadcasts) => {
+            for (const broadcast of broadcasts?.values() ?? []) {
+                broadcast.close();
             }
+            return undefined;
+        });
+    }
+}
+/**
+ * Take one group out of a cache view, without waiting.
+ *
+ * A fill's group is at or below the Largest Object snapshot, so it is either still in the
+ * retained window or gone for good: nothing republishes an old sequence, and waiting for one
+ * would park for the life of the track. Scanning past it, or running dry, is a cache miss,
+ * which the caller turns into the draft's fill-failure reset.
+ */
+function takeGroup(cache, sequence) {
+    for (;;) {
+        const group = cache.tryRecvGroup();
+        if (!group)
+            throw new Error(`group not found: ${sequence}`);
+        if (group.sequence === sequence)
+            return group;
+        group.close();
+        if (group.sequence > sequence)
+            throw new Error(`group not found: ${sequence}`);
+    }
+}
+/** `a - b`, saturating at zero the way the draft's unsigned arithmetic does. */
+function saturatingSub(a, b) {
+    return a > b ? a - b : 0n;
+}
+/** Snapshot the live edge of a track. */
+function liveEdge(track) {
+    const latest = track.latest();
+    if (latest === undefined)
+        return {};
+    const largest = track.largest();
+    if (!largest)
+        return { latest: BigInt(latest), next: { group: BigInt(latest), object: 0n } };
+    const group = BigInt(largest.group);
+    const object = BigInt(largest.frame);
+    return { latest: BigInt(latest), largest: { group, object }, next: { group, object: object + 1n } };
+}
+/**
+ * Resolve a SUBSCRIBE's Location Filter into the range to serve.
+ *
+ * Only draft-20 is honored. Earlier drafts have a Filter Type tag whose absolute forms we
+ * never served, and starting to interpret them now would change what an existing peer
+ * receives; draft-20 is also the first version whose relative forms can name a past group
+ * without the subscriber knowing Largest Object.
+ */
+function subscribeRange(msg, edge, version) {
+    if (!Filter.isDraft20(version)) {
+        if (msg.filter.kind !== "nextObject" && msg.filter.kind !== "unfiltered") {
+            console.warn(`filter not supported before draft-20, ignoring: ${msg.filter.kind}`);
         }
+        return {};
+    }
+    return filterRange(msg.filter, edge);
+}
+/** The Locations a single Location Filter selects, resolved against the live edge. */
+function filterRange(filter, edge) {
+    switch (filter.kind) {
+        // No restriction. moq-lite starts at the beginning of the latest group, which is the
+        // join point it is built around; a subscription passes objects as they are published,
+        // so an absent filter is not a request to replay history.
+        case "unfiltered":
+            return {};
+        // `{Largest.Group, Largest.Object + 1}`. Everything below it, including the already
+        // published head of the current group, is outside the requested range, so the join is
+        // mid-group by construction. The draft pairs this with a fill when the subscriber
+        // wants the head; see {@link Publisher.runFill}.
+        case "nextObject":
+            return { start: edge.next };
+        // `{Largest.Group + 1 - groups, 0}`: 0 is the next group and 1 is the current one.
+        // Counted from `Largest.Group`, which sits below the newest group while that group has
+        // no objects yet; only with no largest at all does the newest group stand in for it.
+        case "relative": {
+            const base = edge.largest?.group ?? edge.latest;
+            if (base === undefined)
+                return {};
+            return { start: { group: saturatingSub(base + 1n, filter.groups), object: 0n } };
+        }
+        case "absolute":
+            return {
+                start: { group: filter.startGroup, object: filter.startObject },
+                end: filter.endGroup === undefined ? undefined : { group: filter.endGroup, object: filter.endObject },
+            };
+    }
+}
+/**
+ * Trim a group to the filter's object bounds, so nothing outside the requested range is
+ * sent. Interior groups are served whole.
+ */
+function groupSlice(range, sequence) {
+    const at = BigInt(sequence);
+    return {
+        skip: range.start?.group === at ? Number(range.start.object) : 0,
+        until: range.end?.group === at && range.end.object !== undefined ? Number(range.end.object) + 1 : undefined,
+    };
+}
+/**
+ * Resolve a fill request using the Fetch rules: relative to Largest Object and never
+ * extending beyond it. An omitted Location Filter inherits the subscription's.
+ */
+function fillRange(fill, subscription, largest) {
+    // A Range Filter narrows which objects pass, which we do not implement; serving the
+    // unfiltered range instead would deliver objects the peer excluded, so refuse it.
+    if (fill.rangeFilters)
+        return { kind: "unsupported" };
+    const filter = fill.filter ?? subscription;
+    // Nothing published (or no precise edge to cap at) means no fill is servable; an empty
+    // range opens no stream.
+    if (!largest)
+        return { kind: "empty" };
+    let start;
+    switch (filter.kind) {
+        // A Fetch without a filter is the whole track up to Largest Object.
+        case "unfiltered":
+            start = { group: 0n, object: 0n };
+            break;
+        // One past the edge, which for a Fetch is always empty.
+        case "nextObject":
+            return { kind: "empty" };
+        case "relative":
+            start = { group: saturatingSub(largest.group + 1n, filter.groups), object: 0n };
+            break;
+        case "absolute":
+            start = { group: filter.startGroup, object: filter.startObject };
+            break;
+    }
+    // Cap the requested end at Largest Object.
+    let end = { group: largest.group, object: largest.object };
+    if (filter.kind === "absolute" && filter.endGroup !== undefined) {
+        const below = filter.endGroup < largest.group ||
+            (filter.endGroup === largest.group && filter.endObject !== undefined && filter.endObject < largest.object);
+        if (below)
+            end = { group: filter.endGroup, object: filter.endObject };
+    }
+    if (start.group > end.group ||
+        (start.group === end.group && end.object !== undefined && end.object < start.object)) {
+        return { kind: "empty" };
     }
+    if (start.group !== end.group)
+        return { kind: "unsupported" };
+    return {
+        kind: "group",
+        sequence: start.group,
+        skip: start.object,
+        until: end.object === undefined ? undefined : end.object + 1n,
+    };
 }
 //# sourceMappingURL=publisher.js.map