@norskvideo/moq-net 0.1.2 → 0.1.4

package/lite/publisher.js

@@ -1,17 +1,39 @@
 /* @ts-self-types="./publisher.d.ts" */
 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 { Announce, AnnounceInit } from "./announce.js";
+import { Timescale } from "../time.js";
+import { AnnounceInit, AnnounceOk, encodeAnnounceBroadcast } from "./announce.js";
+import { Datagram as DatagramMessage } from "./datagram.js";
+import * as DatagramStream from "./datagram_stream.js";
 import { Group as GroupMessage } from "./group.js";
+import { Priority, sendOrder } from "./priority.js";
 import { Probe } from "./probe.js";
-import { encodeSubscribeResponse, SubscribeEnd, SubscribeOk, SubscribeUpdate } from "./subscribe.js";
-import { TrackInfo } from "./track.js";
-import { hasTrackStream, Version } from "./version.js";
+import { encodeSubscribeResponse, SubscribeEnd, SubscribeOk, SubscribeStart, SubscribeUpdate, } from "./subscribe.js";
+import { TrackInfo as TrackInfoMessage } from "./track.js";
+import { hasAnnounceId, hasAnnounceOk, hasDatagrams, hasProbeRtt, Version } from "./version.js";
 const PROBE_INTERVAL = 100; // ms
 const PROBE_MAX_AGE = 10_000; // ms
 const PROBE_MAX_DELTA = 0.25;
+const PROBE_RTT_DELTA = 0.25;
+/** Map a signed delta to an unsigned zigzag varint value (mirrors Rust `VarInt::from_zigzag`). */
+function zigzag(delta) {
+    return delta >= 0n ? delta << 1n : (-delta << 1n) - 1n;
+}
+// The TRACK stream, implicit SUBSCRIBE acceptance, and SUBSCRIBE_START/END are
+// all lite-05+.
+function supportsTrackStream(version) {
+    switch (version) {
+        case Version.DRAFT_01:
+        case Version.DRAFT_02:
+        case Version.DRAFT_03:
+        case Version.DRAFT_04:
+            return false;
+        default:
+            return true;
+    }
+}
 /**
  * Handles publishing broadcasts and managing their lifecycle.
  *
@@ -26,9 +48,19 @@ export class Publisher {
     // own announcements.
     origin;
     #quic;
+    // The one writer for the outbound datagram stream (getWriter locks it), acquired once at
+    // construction when this version + transport carry datagrams, released in close(). Its
+    // presence is the gate: undefined means datagrams aren't served on this connection. All
+    // subscriptions share it, since a second getWriter on the same stream would throw.
+    #datagramWriter;
     // Our published broadcasts.
     // It's a signal so we can live update any announce streams.
     #broadcasts = new Signal(new Map());
+    // TRACK_INFO is immutable per track, so resolve it from the application once
+    // (via a throwaway subscribe whose info() resolves when the app calls accept)
+    // and reuse it for every later TRACK request of the same track. Keyed by
+    // `broadcast\0track`. A rejected lookup is evicted so a retry can re-probe.
+    #trackInfo = new Map();
     /**
      * Creates a new Publisher instance.
      * @param quic - The WebTransport session to use
@@ -41,6 +73,11 @@ export class Publisher {
         this.#quic = quic;
         this.version = version;
         this.origin = origin;
+        // Grab the datagram writer up front when the transport carries datagrams (no group
+        // fallback, so it stays undefined otherwise). One writer for all subscriptions.
+        if (hasDatagrams(version)) {
+            this.#datagramWriter = DatagramStream.datagramWriter(quic);
+        }
     }
     /**
      * Publishes a broadcast with any associated tracks.
@@ -52,10 +89,12 @@ export class Publisher {
                 throw new Error("closed");
             broadcasts.set(path, broadcast);
         });
-        // Remove the broadcast from the lookup when it's closed.
-        void broadcast.closed.finally(() => {
+        // Remove the broadcast from the lookup when it's closed, unless the path was republished.
+        void broadcast.closed.then(() => {
             this.#broadcasts.mutate((broadcasts) => {
-                broadcasts?.delete(path);
+                if (broadcasts?.get(path) === broadcast) {
+                    broadcasts.delete(path);
+                }
             });
         });
     }
@@ -80,6 +119,10 @@ export class Publisher {
             console.debug(`announce: broadcast=${name} active=true`);
             active.add(suffix);
         }
+        // Lite06+: announce ids. Every active we send implicitly assigns the next
+        // per-stream ordinal; ended references the id instead of repeating the path.
+        let nextAnnounceId = 0n;
+        const announceIds = new Map();
         switch (this.version) {
             case Version.DRAFT_01:
             case Version.DRAFT_02: {
@@ -87,13 +130,26 @@ export class Publisher {
                 await init.encode(stream.writer, this.version);
                 break;
             }
-            default:
-                // Draft03+: send individual Announce messages for initial state.
+            default: {
+                if (!hasAnnounceOk(this.version)) {
+                    // Draft03/04: send individual Announce messages, stamping our origin as a hop.
+                    for (const suffix of active) {
+                        await encodeAnnounceBroadcast(stream.writer, { status: "active", suffix, hops: [this.origin] }, this.version);
+                    }
+                    break;
+                }
+                // Report our origin id once via AnnounceOk and the count of initial announces
+                // that follow; the subscriber stamps our origin onto each hop chain, so we omit it.
+                const ok = new AnnounceOk(this.origin, active.size);
+                await ok.encode(stream.writer, this.version);
                 for (const suffix of active) {
-                    const wire = new Announce({ suffix, active: true, hops: [this.origin] });
-                    await wire.encode(stream.writer, this.version);
+                    if (hasAnnounceId(this.version)) {
+                        announceIds.set(suffix, nextAnnounceId++);
+                    }
+                    await encodeAnnounceBroadcast(stream.writer, { status: "active", suffix, hops: [] }, this.version);
                 }
                 break;
+            }
         }
         // Wait for updates to the broadcasts.
         for (;;) {
@@ -116,18 +172,30 @@ export class Publisher {
                     continue; // Not our prefix.
                 newActive.add(suffix);
             }
-            // Announce any new broadcasts.
+            // Announce any new broadcasts. Lite05+ reports our origin once via AnnounceOk, so
+            // the subscriber stamps it onto each hop chain; older versions stamp it here.
             for (const added of newActive.difference(active)) {
                 console.debug(`announce: broadcast=${added} active=true`);
-                const wire = new Announce({ suffix: added, active: true, hops: [this.origin] });
-                await wire.encode(stream.writer, this.version);
+                const hops = hasAnnounceOk(this.version) ? [] : [this.origin];
+                if (hasAnnounceId(this.version)) {
+                    announceIds.set(added, nextAnnounceId++);
+                }
+                await encodeAnnounceBroadcast(stream.writer, { status: "active", suffix: added, hops }, this.version);
             }
-            // Announce any removed broadcasts.
-            // Ended announces don't need hops — the peer matches on path only.
+            // Announce any removed broadcasts. Lite06+ retracts by announce id;
+            // older versions repeat the path (ended announces don't need hops).
             for (const removed of active.difference(newActive)) {
                 console.debug(`announce: broadcast=${removed} active=false`);
-                const wire = new Announce({ suffix: removed, active: false });
-                await wire.encode(stream.writer, this.version);
+                if (hasAnnounceId(this.version)) {
+                    const id = announceIds.get(removed);
+                    announceIds.delete(removed);
+                    if (id === undefined)
+                        continue; // never announced
+                    await encodeAnnounceBroadcast(stream.writer, { status: "endedId", id }, this.version);
+                }
+                else {
+                    await encodeAnnounceBroadcast(stream.writer, { status: "ended", suffix: removed }, this.version);
+                }
             }
             // NOTE: This is kind of a hack that won't work with a rapid UNANNOUNCE/ANNOUNCE cycle.
             // However, our client doesn't do that anyway.
@@ -148,51 +216,122 @@ export class Publisher {
             stream.writer.reset(new Error("not found"));
             return;
         }
-        const track = broadcast.subscribe(msg.track, msg.priority);
+        const track = broadcast.subscribe(msg.track, {
+            priority: msg.priority,
+            ordered: msg.ordered,
+            latencyMax: msg.maxLatency,
+            startGroup: msg.startGroup,
+            endGroup: msg.endGroup,
+        });
+        const startGroup = msg.startGroup ?? track.latest();
+        if (startGroup !== undefined)
+            track.startAt(startGroup);
+        track.endAt(msg.endGroup);
+        // The best-effort datagram loop, started once serving begins. It parks when the
+        // track finishes (recvDatagram returns undefined), so #runTrack alone ends the
+        // subscription; awaited during teardown so it doesn't outlive the subscription.
+        let datagrams = Promise.resolve();
         try {
-            // moq-lite-05+ trims SUBSCRIBE_OK to the resolved start group; the publisher
-            // properties move to TRACK_INFO. Earlier versions echo the priority inline.
-            const info = hasTrackStream(this.version)
-                ? new SubscribeOk({ startGroup: msg.startGroup ?? 0 })
-                : new SubscribeOk({ priority: msg.priority });
-            await encodeSubscribeResponse(stream.writer, { ok: info }, this.version);
+            let timescale = Timescale.MILLI;
+            if (supportsTrackStream(this.version)) {
+                // Lite-05+ accepts implicitly: no SUBSCRIBE_OK (the immutable
+                // properties live in TRACK_INFO), and the resolved range arrives as
+                // SUBSCRIBE_START / SUBSCRIBE_END emitted from #runTrack.
+                //
+                // The timescale is an immutable property, so serving MUST use exactly
+                // what TRACK_INFO advertised. It comes from the producer's accept(), so
+                // they always agree. Awaiting info() also surfaces a rejected track
+                // (accept never called, track closed) as an error here, which resets the
+                // stream.
+                const info = await track.info();
+                timescale = info.timescale;
+            }
+            else {
+                // Older drafts acknowledge with SUBSCRIBE_OK and stream frames verbatim.
+                const ok = new SubscribeOk({
+                    priority: msg.priority,
+                    ordered: msg.ordered,
+                    maxLatency: msg.maxLatency,
+                    startGroup: msg.startGroup,
+                    endGroup: msg.endGroup,
+                });
+                await encodeSubscribeResponse(stream.writer, { ok }, this.version);
+            }
             console.debug(`publish ok: broadcast=${msg.broadcast} track=${track.name}`);
-            const serving = this.#runTrack(msg.id, msg.broadcast, track, stream.writer);
+            const serving = this.#runTrack(msg.id, msg.broadcast, track, stream.writer, timescale);
+            // Serve datagrams concurrently with groups whenever the transport carries them
+            // (the writer exists iff so). No group fallback: otherwise they simply aren't sent.
+            if (this.#datagramWriter) {
+                datagrams = this.#runDatagrams(msg.id, track, timescale);
+            }
             for (;;) {
                 const decode = SubscribeUpdate.decodeMaybe(stream.reader, this.version);
                 const result = await Promise.any([serving, decode]);
                 if (!result)
                     break;
                 if (result instanceof SubscribeUpdate) {
-                    console.debug(`subscribe update: broadcast=${msg.broadcast} track=${track.name} priority=${result.priority}`);
-                    track.updatePriority(result.priority);
+                    console.debug(`subscribe update: broadcast=${msg.broadcast} track=${track.name}`);
+                    track.update({
+                        priority: result.priority,
+                        ordered: result.ordered,
+                        latencyMax: result.maxLatency,
+                        startGroup: result.startGroup,
+                        endGroup: result.endGroup,
+                    });
+                    if (result.startGroup !== undefined)
+                        track.startAt(result.startGroup);
+                    track.endAt(result.endGroup);
                 }
             }
             console.debug(`publish done: broadcast=${msg.broadcast} track=${track.name}`);
             stream.close();
             track.close();
+            // track.close ends the datagram loop; wait so it doesn't leak past teardown.
+            await datagrams;
         }
         catch (err) {
             const e = error(err);
-            console.warn(`publish error: broadcast=${msg.broadcast} track=${track.name} error=${e.message}`);
+            console.warn(`publish error: broadcast=${msg.broadcast} track=${track.name} error=${reason(e)}`);
             track.close(e);
             stream.abort(e);
+            await datagrams;
         }
     }
     /**
-     * Serves a Track stream (moq-lite-05+): replies with the track's immutable TRACK_INFO.
+     * Handles a FETCH stream by serving one group as bare frame records (lite-05+).
      *
      * @internal
      */
-    async runTrackInfo(msg, stream) {
+    async runFetch(msg, stream) {
+        if (!supportsTrackStream(this.version)) {
+            stream.writer.reset(new Error("fetch requires moq-lite-05 or newer"));
+            return;
+        }
         const broadcast = this.#broadcasts.peek()?.get(msg.broadcast);
         if (!broadcast) {
-            throw new Error("not found");
+            console.debug(`fetch unknown: broadcast=${msg.broadcast}`);
+            stream.writer.reset(new Error("not found"));
+            return;
+        }
+        // The subscriber opened this stream, so its send order only ranked the request. Rank the
+        // response here, on the same scale as the group streams it competes with.
+        stream.writer.setPriority(sendOrder({ priority: msg.priority }));
+        let group;
+        try {
+            // The timescale is immutable, so serve exactly what TRACK_INFO advertised.
+            const info = await this.#resolveTrackInfo(msg.broadcast, msg.track);
+            group = await broadcast.track(msg.track).fetchGroup(msg.group, { priority: msg.priority });
+            await this.#runFetchGroup(group, stream.writer, Timescale(info.timescale));
+            console.debug(`fetch done: broadcast=${msg.broadcast} track=${msg.track} group=${msg.group}`);
+            stream.close();
+            group.close();
+        }
+        catch (err) {
+            const e = error(err);
+            console.warn(`fetch error: broadcast=${msg.broadcast} track=${msg.track} group=${msg.group} error=${reason(e)}`);
+            group?.close(e);
+            stream.abort(e);
         }
-        // The publisher properties aren't tracked in the browser model yet; report
-        // defaults with a millisecond timescale matching the wall-clock frame timestamps.
-        const info = new TrackInfo({ timescale: 1000 });
-        await info.encode(stream.writer, this.version);
     }
     /**
      * Runs a track and sends its data to the stream.
@@ -203,72 +342,220 @@ export class Publisher {
      *
      * @internal
      */
-    async #runTrack(sub, broadcast, track, stream) {
+    async #runTrack(sub, broadcast, track, stream, timescale) {
+        // Lite-05+ resolves the range on the subscribe stream: SUBSCRIBE_START once the
+        // first group is known, SUBSCRIBE_END when the track finishes.
+        const emitRange = supportsTrackStream(this.version);
+        let startSent = false;
+        // The exclusive end of the delivered range. recvGroup is arrival-ordered rather than
+        // sequence-ordered, so this tracks the max and not the last group seen. 0 is already
+        // the encoding for a track that produced no groups.
+        let end = 0;
+        // One ranking for the whole subscription, shared by every group it serves.
+        const priority = new Priority(track);
+        // 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
+        // FIN the subscribe stream ourselves below to say so.
+        let finished = false;
+        let unsubscribe;
+        const unsubscribed = new Promise((resolve) => {
+            unsubscribe = resolve;
+        });
+        void stream.closed.then(() => {
+            if (!finished)
+                unsubscribe();
+        }, 
+        // A reset is always the peer.
+        () => unsubscribe());
         try {
-            let lastSequence;
-            let trackEnded = false;
             for (;;) {
+                // Exactly-once serving, not the sequence cursor: on a relay, a burst can be
+                // ingested micro-reordered by the upstream leg, and a sequence cursor would
+                // permanently skip the older group even though it is cached and in demand.
+                // Staleness is the latency window's job (cache expiry), not arrival order's.
                 const next = track.recvGroup();
-                const res = await Promise.race([
-                    next.then((group) => ({ group })),
-                    stream.closed.then(() => "closed"),
-                ]);
-                if (res === "closed") {
+                const group = await Promise.race([next, stream.closed]);
+                if (!group) {
                     next.then((group) => group?.close()).catch(() => { });
                     break;
                 }
-                if (!res.group) {
-                    trackEnded = true;
-                    break;
+                if (emitRange && !startSent) {
+                    startSent = true;
+                    // SUBSCRIBE_START promises nothing below this sequence will be delivered.
+                    // Arrival-order serving could later surface a straggler below the first
+                    // group, so pin the floor to what was announced.
+                    track.startAt(group.sequence);
+                    await encodeSubscribeResponse(stream, { start: new SubscribeStart(group.sequence) }, this.version);
                 }
-                lastSequence = res.group.sequence;
-                void this.#runGroup(sub, res.group);
+                end = Math.max(end, group.sequence + 1);
+                void this.#runGroup({ sub, group, timescale, priority, unsubscribed });
             }
-            // moq-lite-05+: signal end-of-track before the subscribe stream FINs.
-            if (trackEnded && hasTrackStream(this.version)) {
-                const end = new SubscribeEnd({ group: lastSequence ?? 0 });
-                await encodeSubscribeResponse(stream, { end }, this.version);
+            if (emitRange) {
+                await encodeSubscribeResponse(stream, { end: new SubscribeEnd(end) }, this.version);
             }
             console.debug(`publish close: broadcast=${broadcast} track=${track.name}`);
+            finished = true;
             track.close();
             stream.close();
         }
         catch (err) {
             const e = error(err);
-            console.warn(`publish error: broadcast=${broadcast} track=${track.name} error=${e.message}`);
+            console.warn(`publish error: broadcast=${broadcast} track=${track.name} error=${reason(e)}`);
+            unsubscribe();
             track.close(e);
             stream.reset(e);
         }
+        finally {
+            priority.close();
+        }
     }
     /**
-     * Runs a group and sends its frames to the stream.
-     * @param sub - The subscription ID
-     * @param group - The group to run
+     * Answers a TRACK stream (0x6) with a single TRACK_INFO, then FINs.
+     *
+     * @internal
+     */
+    async runTrackInfo(msg, stream) {
+        try {
+            const info = await this.#resolveTrackInfo(msg.broadcast, msg.track);
+            await info.encode(stream.writer, this.version);
+            console.debug(`track info: broadcast=${msg.broadcast} track=${msg.track}`);
+            stream.close();
+        }
+        catch (err) {
+            console.debug(`track unknown: broadcast=${msg.broadcast} track=${msg.track}`);
+            stream.writer.reset(error(err));
+        }
+    }
+    // Resolve (and cache) a track's immutable TRACK_INFO by asking the application.
+    // `broadcast.track(name).info()` triggers a TrackRequest the app answers with
+    // accept(TrackInfo); only the immutable properties are needed (not the groups).
+    // Cached because they're fixed for the track's lifetime. Rejects if the broadcast
+    // or track is unavailable.
+    #resolveTrackInfo(broadcast, track) {
+        const key = `${broadcast}\0${track}`;
+        const cached = this.#trackInfo.get(key);
+        if (cached)
+            return cached;
+        const pending = (async () => {
+            const published = this.#broadcasts.peek()?.get(broadcast);
+            if (!published)
+                throw new Error("not found");
+            const info = await published.track(track).info();
+            return new TrackInfoMessage({
+                priority: info.priority,
+                ordered: info.ordered,
+                // Publisher Max Latency: the publisher's retention bound, advertised so
+                // relays re-serve with the same window.
+                latencyMax: info.latencyMax,
+                // Lite05 mandates per-frame timestamps. Advertise the track's timescale;
+                // `#runGroup` emits each frame converted to it.
+                timescale: info.timescale,
+            });
+        })();
+        // Don't poison the cache on failure: a later request may succeed.
+        pending.catch(() => this.#trackInfo.delete(key));
+        this.#trackInfo.set(key, pending);
+        return pending;
+    }
+    /**
+     * Forwards a track's datagrams best-effort over QUIC datagrams (lite-05 §6.4), parallel to
+     * its groups. Each datagram is dropped (there is no group fallback) if the encoded body
+     * doesn't fit the transport's datagram limit or the send fails. Returns once the track
+     * finishes; a failure never tears down the subscription.
      *
      * @internal
      */
-    async #runGroup(sub, group) {
+    async #runDatagrams(sub, track, timescale) {
+        const writer = this.#datagramWriter;
+        if (!writer)
+            return; // Only reached with a writer (see the #datagramWriter gate).
+        const maxSize = DatagramStream.maxDatagramSize(this.#quic);
+        try {
+            for (;;) {
+                const datagram = await track.recvDatagram();
+                if (!datagram)
+                    return; // Track finished; #runTrack tears the subscription down.
+                // Convert the timestamp to the track's advertised timescale, matching #runGroup.
+                const ts = Math.round(datagram.timestamp.as(timescale));
+                const body = new DatagramMessage(sub, datagram.sequence, ts, datagram.payload).encode();
+                // No group fallback: drop anything that doesn't fit a single datagram.
+                if (body.byteLength > maxSize) {
+                    console.debug(`dropping oversize datagram: sub=${sub} size=${body.byteLength} max=${maxSize}`);
+                    continue;
+                }
+                await writer.ready;
+                await writer.write(body);
+            }
+        }
+        catch (err) {
+            // Best-effort: a datagram send failure stops sending but never fails the subscription.
+            console.debug(`datagram send stopped: sub=${sub} error=${reason(err)}`);
+        }
+    }
+    // Serialize a fetched group's frames onto the FETCH stream as bare records: each a
+    // zigzag-delta timestamp (at the track's advertised timescale) followed by size + bytes.
+    async #runFetchGroup(group, stream, timescale) {
+        let prevTs = 0n;
+        for (;;) {
+            const frame = await Promise.race([group.readFrame(), stream.closed]);
+            if (!frame)
+                break;
+            const ts = BigInt(Math.round(frame.timestamp.as(timescale)));
+            await stream.u62(zigzag(ts - prevTs));
+            prevTs = ts;
+            await stream.u53(frame.payload.byteLength);
+            await stream.write(frame.payload);
+        }
+    }
+    /**
+     * Serves one group on its own unidirectional stream.
+     *
+     * @internal
+     */
+    async #runGroup(options) {
+        const { sub, group, timescale, priority, unsubscribed } = options;
         const msg = new GroupMessage(sub, group.sequence);
         try {
-            const stream = await Writer.open(this.#quic);
-            await stream.u8(0); // stream type
-            await msg.encode(stream);
+            // The transport drains streams by send order, so this is what makes a high-priority
+            // track (and a newer group within it) win the link when there isn't room for both.
+            //
+            // 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, {
+                sendOrder: priority.rank(group.sequence),
+                cancel: unsubscribed,
+                waitUntilAvailable: false,
+            });
+            if (!stream) {
+                group.close(new Error("no stream slot"));
+                return;
+            }
+            // Everything past this point runs inside the cleanup scope, so a failure never leaves
+            // a finished group's stream being ranked.
             try {
-                // moq-lite-05+ stamps each frame with a wall-clock millisecond timestamp, sent
-                // as a zigzag delta from the previous frame (the first frame is a delta from 0).
-                let prevTimestamp = 0n;
+                // A SUBSCRIBE_UPDATE re-ranks the subscription, so a group already on the wire
+                // follows it too rather than keeping a stale rank until it finishes.
+                priority.add(stream, group.sequence);
+                await stream.u53(0); // stream type
+                await msg.encode(stream);
+                // Lite05+ prefixes every frame with a zigzag-delta timestamp at the track's
+                // advertised timescale; older drafts omit it.
+                const timestamps = supportsTrackStream(this.version);
+                let prevTs = 0n;
                 for (;;) {
                     const frame = await Promise.race([group.readFrame(), stream.closed]);
                     if (!frame)
                         break;
-                    if (hasTrackStream(this.version)) {
-                        const now = BigInt(Date.now());
-                        const delta = now - prevTimestamp;
-                        prevTimestamp = now;
-                        await stream.u62((delta << 1n) ^ (delta >> 63n));
+                    if (timestamps) {
+                        // Convert each frame to the track's advertised timescale.
+                        const ts = BigInt(Math.round(frame.timestamp.as(timescale)));
+                        await stream.u62(zigzag(ts - prevTs));
+                        prevTs = ts;
                     }
-                    await stream.u53(frame.byteLength);
-                    await stream.write(frame);
+                    await stream.u53(frame.payload.byteLength);
+                    await stream.write(frame.payload);
                 }
                 stream.close();
                 group.close();
@@ -278,6 +565,9 @@ export class Publisher {
                 stream.reset(e);
                 group.close(e);
             }
+            finally {
+                priority.remove(stream);
+            }
         }
         catch (err) {
             const e = error(err);
@@ -299,36 +589,65 @@ export class Publisher {
             stream.close();
             return;
         }
-        let lastSentBitrate;
+        let lastSent;
         let lastSentTime;
+        // Whether a metric moved enough to be worth another report. Gaining or
+        // losing a value always counts; both unknown never does.
+        const moved = (prev, next, threshold = 0) => {
+            if (prev === undefined && next === undefined)
+                return false;
+            if (prev === undefined || next === undefined)
+                return true;
+            if (prev === 0)
+                return next !== 0;
+            return Math.abs(next - prev) / prev >= threshold;
+        };
         try {
             for (;;) {
                 const timeout = new Promise((resolve) => setTimeout(() => resolve("timeout"), PROBE_INTERVAL));
                 const result = await Promise.race([timeout, stream.reader.closed]);
                 if (result !== "timeout")
                     break;
+                // The two fields are independent on the wire, each using 0 for
+                // unknown, so a transport exposing only one still has something to
+                // report. Anything this version can't carry is dropped here rather
+                // than by the encoder, so it reads as unknown to every check below.
                 const stats = await quic.getStats();
-                const bitrate = stats.estimatedSendRate;
-                if (bitrate == null)
-                    continue;
+                // `smoothedRtt` is a DOMHighResTimeStamp, i.e. a double, but the wire
+                // carries whole milliseconds and the varint encoder throws on a
+                // fractional value. Round before it ever reaches `Probe`.
+                const rtt = stats.smoothedRtt != null ? Math.round(stats.smoothedRtt) : undefined;
+                const report = new Probe({
+                    bitrate: stats.estimatedSendRate ?? undefined,
+                    rtt: hasProbeRtt(this.version) ? rtt : undefined,
+                });
+                // Nothing left to report. Say so once if it retracts a value the peer
+                // is still holding, then stay quiet rather than repeating "unknown"
+                // every time the max age comes around.
+                if (report.bitrate === undefined && report.rtt === undefined) {
+                    const retracts = lastSent !== undefined && (lastSent.bitrate !== undefined || lastSent.rtt !== undefined);
+                    if (!retracts)
+                        continue;
+                }
                 let shouldSend;
-                if (lastSentBitrate === undefined || lastSentTime === undefined) {
+                if (lastSent === undefined || lastSentTime === undefined) {
                     shouldSend = true;
                 }
-                else if (lastSentBitrate === 0) {
-                    shouldSend = bitrate > 0;
-                }
                 else {
                     const elapsed = performance.now() - lastSentTime;
+                    // The bitrate threshold decays to zero as the last report ages: a
+                    // stale estimate is worth refreshing for a smaller move.
                     const t = Math.max(PROBE_INTERVAL, Math.min(PROBE_MAX_AGE, elapsed));
                     const range = PROBE_MAX_AGE - PROBE_INTERVAL;
                     const threshold = (PROBE_MAX_DELTA * (PROBE_MAX_AGE - t)) / range;
-                    const change = Math.abs(bitrate - lastSentBitrate) / lastSentBitrate;
-                    shouldSend = change >= threshold;
+                    shouldSend =
+                        elapsed >= PROBE_MAX_AGE ||
+                            moved(lastSent.bitrate, report.bitrate, threshold) ||
+                            moved(lastSent.rtt, report.rtt, PROBE_RTT_DELTA);
                 }
                 if (shouldSend) {
-                    await new Probe(bitrate).encode(stream.writer, this.version);
-                    lastSentBitrate = bitrate;
+                    await report.encode(stream.writer, this.version);
+                    lastSent = report;
                     lastSentTime = performance.now();
                 }
             }
@@ -345,6 +664,9 @@ export class Publisher {
             }
             return undefined;
         });
+        // Release the datagram writer's lock so the stream can be torn down.
+        this.#datagramWriter?.releaseLock();
+        this.#datagramWriter = undefined;
     }
 }
 //# sourceMappingURL=publisher.js.map