@norskvideo/moq-net 0.1.8 → 0.2.1

package/connection/reload.d.ts

@@ -1,104 +1,25 @@
-import { type Getter, Signal } from "@norskvideo/moq-signals";
-import * as Announce from "../announced";
-import type * as Path from "../path";
-import { type ConnectProps, type WebSocketOptions, type WebTransportProps } from "./connect";
-import type { Established } from "./established";
-import type { Probe, Stats } from "./stats";
+import * as Time from "../time";
 /**
- * Exponential backoff settings for {@link Reload}'s reconnect loop.
+ * Exponential backoff settings for the reconnect loop.
  *
  * The delays carry jitter, so a fleet of tabs knocked offline together doesn't reconnect in
- * lockstep. Every failure is retried; {@link ReloadDelay.timeout} is what stops the loop.
+ * lockstep. Every failure is retried; {@link ReloadDelay.timeout} is what stops the current
+ * URL. A new URL or a disable/re-enable starts another sequence.
  */
 export type ReloadDelay = {
-    /** The delay in milliseconds before reconnecting (default: 1000). */
-    initial: DOMHighResTimeStamp;
+    /** The delay before reconnecting (default: 1000ms). */
+    initial?: Time.Milli;
     /** The multiplier for the delay (default: 2). */
-    multiplier: number;
-    /** The maximum delay in milliseconds (default: 5000). */
-    max: DOMHighResTimeStamp;
+    multiplier?: number;
+    /** The maximum delay (default: 5000ms). */
+    max?: Time.Milli;
     /**
-     * Maximum total time in milliseconds to spend retrying before giving up (default:
-     * 10000). Resets after each successful connection. Set to 0 for unlimited retries.
+     * Maximum total time to spend retrying the current URL before giving up
+     * (default: 10000ms). Resets after each successful connection, a URL change, or a
+     * disable/re-enable. Set to 0 for unlimited retries.
      */
-    timeout?: DOMHighResTimeStamp;
+    timeout?: Time.Milli;
 };
-/** Connection and retry options for {@link Reload}. */
-export type ReloadProps = Omit<ConnectProps, "signal"> & {
-    /** Whether to reload the connection when it disconnects (default: true). */
-    enabled?: boolean | Signal<boolean>;
-    /** The URL of the relay server. */
-    url?: URL | Signal<URL | undefined>;
-    /** Backoff settings for the reconnect loop. */
-    delay?: ReloadDelay;
-};
-/** Current state of a {@link Reload} connection. */
+/** Current state of a reconnecting connection. */
 export type ReloadStatus = "connecting" | "connected" | "disconnected";
-/** Maintains a MoQ connection, reconnecting with exponential backoff when it drops. */
-export declare class Reload {
-    #private;
-    /** Relay URL to connect to; updating it triggers a reconnect. */
-    url: Signal<URL | undefined>;
-    /** Whether reconnecting is active. */
-    enabled: Signal<boolean>;
-    /** Current connection status. */
-    status: Signal<ReloadStatus>;
-    /** The currently established session, or undefined while disconnected. */
-    established: Signal<Established | undefined>;
-    /**
-     * The current connection's PROBE estimates, spanning reconnects.
-     *
-     * Undefined while disconnected: the estimates belong to a single connection.
-     * See {@link Established.probe}.
-     */
-    readonly probe: Getter<Probe | undefined>;
-    /** WebTransport options applied to each connection attempt (not reactive). */
-    webtransport?: WebTransportProps;
-    /** WebSocket fallback options applied to each connection attempt (not reactive). */
-    websocket: WebSocketOptions | undefined;
-    /**
-     * Whether the relay supports broadcast discovery, applied to each connection attempt (not
-     * reactive). Undefined defers to the default for the URL. See {@link Established.discovery}.
-     */
-    discovery?: boolean;
-    /** Backoff settings for the reconnect loop. */
-    delay: ReloadDelay;
-    /**
-     * Resolves when the reconnect loop stops via {@link Reload.close}.
-     *
-     * Rejects when the loop gives up instead, carrying the failure that was in flight when the
-     * retry window expired.
-     */
-    closed: Promise<void>;
-    constructor(props?: ReloadProps);
-    /**
-     * Subscribe to broadcast announcements under an optional prefix, spanning reconnects.
-     *
-     * The same {@link Announce.Consumer} stream as {@link Established.announced}, but everything active
-     * is retracted (an `active: false` update) whenever the connection drops and re-announced on
-     * reconnect, so a consumer draining `next()` never clings to a dead route across a reconnect.
-     *
-     * Stays empty while the relay lacks {@link Established.discovery}.
-     */
-    announced(prefix?: Path.Valid): Announce.Consumer;
-    /**
-     * A reactive handle to one broadcast, spanning reconnects.
-     *
-     * The same {@link Announce.Broadcast} as {@link Established.announcedBroadcast}, but it
-     * follows the reconnect loop: the broadcast drops to `undefined` when the connection dies
-     * and resolves again once the new connection announces the path. Use it instead of
-     * consuming off {@link Reload.established} whenever the broadcast may come online after you
-     * do, which is exactly the case a blind `consume` loses.
-     *
-     * Close the handle when done; {@link Reload.close} only drops it to `undefined`.
-     */
-    announcedBroadcast(path: Path.Valid): Announce.Broadcast;
-    /**
-     * Snapshot the live connection's transport counters, or undefined while disconnected.
-     * See {@link Established.stats}.
-     */
-    stats(): Promise<Stats | undefined>;
-    /** Stop reconnecting, close the current connection, and resolve {@link Reload.closed}. */
-    close(): void;
-}
 //# sourceMappingURL=reload.d.ts.map

package/connection/reload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reload.d.ts","sourceRoot":"","sources":["../../src/connection/reload.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,MAAM,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAE5C,OAAO,KAAK,KAAK,IAAI,MAAM,YAAY,CAAC;AAExC,OAAO,EAAE,KAAK,YAAY,EAAW,KAAK,gBAAgB,EAAE,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACzG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG;IACzB,qEAAqE;IACrE,OAAO,EAAE,mBAAmB,CAAC;IAE7B,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAC;IAEnB,yDAAyD;IACzD,GAAG,EAAE,mBAAmB,CAAC;IAEzB;;;OAGG;IACH,OAAO,CAAC,EAAE,mBAAmB,CAAC;CAC9B,CAAC;AAEF,uDAAuD;AACvD,MAAM,MAAM,WAAW,GAAG,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,GAAG;IACxD,4EAA4E;IAC5E,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;IAEpC,mCAAmC;IACnC,GAAG,CAAC,EAAE,GAAG,GAAG,MAAM,CAAC,GAAG,GAAG,SAAS,CAAC,CAAC;IAEpC,+CAA+C;IAC/C,KAAK,CAAC,EAAE,WAAW,CAAC;CACpB,CAAC;AAUF,oDAAoD;AACpD,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,WAAW,GAAG,cAAc,CAAC;AAEvE,uFAAuF;AACvF,qBAAa,MAAM;;IAClB,iEAAiE;IACjE,GAAG,EAAE,MAAM,CAAC,GAAG,GAAG,SAAS,CAAC,CAAC;IAE7B,sCAAsC;IACtC,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;IAEzB,iCAAiC;IACjC,MAAM,uBAA4C;IAElD,0EAA0E;IAC1E,WAAW,kCAAkD;IAE7D;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,GAAG,SAAS,CAAC,CAAC;IAE1C,8EAA8E;IAC9E,YAAY,CAAC,EAAE,iBAAiB,CAAC;IAEjC,oFAAoF;IACpF,SAAS,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAExC;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB,+CAA+C;IAC/C,KAAK,EAAE,WAAW,CAAC;IAKnB;;;;;OAKG;IACH,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAkBtB,YAAY,KAAK,CAAC,EAAE,WAAW,EAmC9B;IAmGD;;;;;;;;OAQG;IACH,SAAS,CAAC,MAAM,GAAE,IAAI,CAAC,KAAmB,GAAG,QAAQ,CAAC,QAAQ,CAoD7D;IAED;;;;;;;;;;OAUG;IACH,kBAAkB,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC,SAAS,CAEvD;IAED;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAExC;IAED,0FAA0F;IAC1F,KAAK,SAGJ;CACD"}
+{"version":3,"file":"reload.d.ts","sourceRoot":"","sources":["../../src/connection/reload.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,IAAI,MAAM,YAAY,CAAC;AAMnC;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG;IACzB,uDAAuD;IACvD,OAAO,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC;IAErB,iDAAiD;IACjD,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,2CAA2C;IAC3C,GAAG,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC;IAEjB;;;;OAIG;IACH,OAAO,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC;CACrB,CAAC;AA+CF,kDAAkD;AAClD,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,WAAW,GAAG,cAAc,CAAC"}

package/connection/reload.js

@@ -1,17 +1,35 @@
 /* @ts-self-types="./reload.d.ts" */
-import { Effect, Signal } from "@norskvideo/moq-signals";
+import { Effect, Once, Signal } from "@norskvideo/moq-signals";
 import * as Announce from "../announced.js";
-import { error } from "../error.js";
-import { empty as emptyPath } from "../path.js";
+import { Allocator } from "../bandwidth.js";
+import { error, SessionCode, SessionError } from "../error.js";
+import * as Path from "../path.js";
+import * as Time from "../time.js";
+import { wireOf } from "../wire.js";
 import { connect } from "./connect.js";
 /**
- * How long to keep retrying before giving up, when {@link ReloadDelay.timeout} is unset.
+ * The backoff applied to whichever {@link ReloadDelay} fields a caller leaves out.
  *
- * Short on purpose: a failure that clears within it was transient, and one that doesn't should
- * surface as an error rather than leave the page silently reconnecting for minutes.
+ * The timeout is short on purpose: a failure that clears within it was transient, and one that
+ * doesn't should surface on {@link Reload.error} rather than leave the page silently
+ * reconnecting for minutes. A loop nobody watches wants `timeout: 0` instead, since there is
+ * no one to react. Giving up does not dispose the loop: a new URL or a disable/re-enable
+ * starts another sequence.
+ */
+const DEFAULT_DELAY = {
+    initial: Time.Milli(1000),
+    multiplier: 2,
+    max: Time.Milli(5000),
+    timeout: Time.Milli(10000),
+};
+/** How often the send-rate estimate is sampled from the live transport. */
+const BANDWIDTH_POLL = 100;
+/**
+ * The reconnect loop behind a Connection handle: connects, waits for the session to end, then
+ * redials with exponential backoff.
+ *
+ * @internal
  */
-const DEFAULT_TIMEOUT = 10000;
-/** Maintains a MoQ connection, reconnecting with exponential backoff when it drops. */
 export class Reload {
     /** Relay URL to connect to; updating it triggers a reconnect. */
     url;
@@ -19,6 +37,14 @@ export class Reload {
     enabled;
     /** Current connection status. */
     status = new Signal("disconnected");
+    /**
+     * The failure that stopped retrying the current URL, or undefined while the loop is live.
+     *
+     * Set on an auth rejection or when the retry window expires. Cleared when a new URL or a
+     * disable/re-enable starts another sequence, not on a page hide/show. Transient drops
+     * that are still being retried leave this empty.
+     */
+    error;
     /** The currently established session, or undefined while disconnected. */
     established = new Signal(undefined);
     /**
@@ -28,6 +54,14 @@ export class Reload {
      * See {@link Established.probe}.
      */
     probe;
+    /**
+     * Divides this connection's send-rate estimate among the tracks sharing it.
+     *
+     * The same instance across reconnects, so reservations survive a drop. The
+     * estimate is `undefined` while disconnected, which tells a sender to hold
+     * its rate rather than encode at zero.
+     */
+    bandwidth;
     /** WebTransport options applied to each connection attempt (not reactive). */
     webtransport;
     /** WebSocket fallback options applied to each connection attempt (not reactive). */
@@ -37,23 +71,50 @@ export class Reload {
      * reactive). Undefined defers to the default for the URL. See {@link Established.discovery}.
      */
     discovery;
-    /** Backoff settings for the reconnect loop. */
+    /**
+     * The origin whose broadcasts are served, spanning reconnects (not reactive).
+     *
+     * Each session announces the origin's table when it attaches, so a broadcast published
+     * while offline surfaces on the next connection and a reconnect re-announces everything
+     * still published. See the `publish` connect option.
+     */
+    publish;
+    /**
+     * The origin fed with the peer's announced broadcasts, spanning reconnects (not
+     * reactive).
+     *
+     * The entries a session fed retract when it dies, and the next session re-populates the
+     * table, so a consumer watching the origin sees offline/online transitions across a
+     * reconnect. See the `consume` connect option.
+     */
+    consume;
+    /** Backoff settings for the reconnect loop; an unset field uses its default. */
     delay;
     /** The reactive effect scope driving the connect loop; closed by {@link Reload.close}. */
     #signals = new Effect();
+    // Sampled from the live session; undefined while disconnected or the transport has none.
+    #estimate = new Signal(undefined);
     /**
-     * Resolves when the reconnect loop stops via {@link Reload.close}.
-     *
-     * Rejects when the loop gives up instead, carrying the failure that was in flight when the
-     * retry window expired.
+     * Settles once this loop is disposed via {@link Reload.close}: `null` on a clean close,
+     * or the abort {@link Error}. Peek it synchronously (`undefined` while open), observe it
+     * reactively, or `await` it. Attempt failures live on {@link Reload.error} instead.
      */
-    closed;
-    #closedResolve;
-    #closedReject;
+    get closed() {
+        return this.#closed;
+    }
+    #closed = new Once();
+    #error = new Signal(undefined);
     // The current wait between attempts, doubling per failure, and when the retry window expires.
     // Both are undefined between sequences, so a later edit to `delay` applies to the next one.
     #delay;
     #deadline;
+    // The URL the current retry sequence is for. Cleared when disabled, URL-less, or given
+    // up, so the next attempt starts a fresh backoff window.
+    #sequenceHref;
+    // The href that exhausted its retry sequence. Survives a page hide/show so resume does
+    // not redial credentials the peer already refused. Cleared when the URL changes or the
+    // loop is disabled.
+    #givenUpHref;
     // Increased by 1 each time to trigger a reload.
     #tick = new Signal(0);
     // True after the browser freezes or hides the page until it visibly resumes.
@@ -63,25 +124,30 @@ export class Reload {
     #url;
     constructor(props) {
         this.url = Signal.from(props?.url);
-        this.enabled = Signal.from(props?.enabled ?? false);
-        this.delay = props?.delay ?? { initial: 1000, multiplier: 2, max: 5000 };
+        this.enabled = Signal.from(props?.enabled ?? true);
+        this.delay = props?.delay ?? {};
         this.webtransport = props?.webtransport;
         this.websocket = props?.websocket;
         this.discovery = props?.discovery;
-        this.closed = new Promise((resolve, reject) => {
-            this.#closedResolve = resolve;
-            this.#closedReject = reject;
-        });
-        // A caller is free to never await `closed`, and giving up rejects it unprompted. Marking the
-        // rejection handled here keeps that from surfacing as an `unhandledrejection`; a consumer
-        // awaiting the same promise still receives it.
-        this.closed.catch(() => { });
-        if (typeof window !== "undefined" && typeof document !== "undefined") {
-            this.#signals.event(window, "pagehide", () => this.#suspended.set(true));
-            this.#signals.event(window, "pageshow", () => this.#suspended.set(false));
-            this.#signals.event(window, "unload", () => this.#suspended.set(true));
-            this.#signals.event(document, "visibilitychange", () => {
-                if (!document.hidden)
+        this.publish = props?.publish;
+        this.consume = props?.consume;
+        // Requests on the consume origin stay pending across a reconnect, and before the
+        // first session establishes, rather than reading as unroutable the moment no session
+        // is attached. Released only when this loop is disposed: giving up the current URL
+        // is recoverable (a new URL or a disable/re-enable starts another sequence), so a
+        // request must keep waiting rather than go unroutable in the gap.
+        if (this.consume) {
+            this.#signals.cleanup(wireOf(this.consume).expect());
+        }
+        this.error = this.#error;
+        const win = globalThis.window;
+        const doc = globalThis.document;
+        if (typeof win !== "undefined" && typeof doc !== "undefined") {
+            this.#signals.event(win, "pagehide", () => this.#suspended.set(true));
+            this.#signals.event(win, "pageshow", () => this.#suspended.set(false));
+            this.#signals.event(win, "unload", () => this.#suspended.set(true));
+            this.#signals.event(doc, "visibilitychange", () => {
+                if (!doc.hidden)
                     this.#suspended.set(false);
             });
         }
@@ -89,6 +155,32 @@ export class Reload {
             const connection = effect.get(this.established);
             return connection && effect.get(connection.probe);
         });
+        this.bandwidth = new Allocator(this.#estimate);
+        this.#signals.cleanup(() => this.bandwidth.close());
+        // The transport has no event for the send-rate estimate, so sample on our
+        // own schedule and skip a tick while the previous snapshot is outstanding.
+        this.#signals.run((effect) => {
+            effect.set(this.#estimate, undefined);
+            const connection = effect.get(this.established);
+            if (!connection)
+                return;
+            let pending = false;
+            const sample = async () => {
+                if (pending)
+                    return;
+                pending = true;
+                try {
+                    const stats = await effect.race(connection.stats());
+                    if (stats)
+                        this.#estimate.set(stats.estimatedSendRate);
+                }
+                finally {
+                    pending = false;
+                }
+            };
+            void sample();
+            effect.interval(() => void sample(), BANDWIDTH_POLL);
+        });
         this.#url = this.#signals.computed((effect) => effect.get(this.url)?.href);
         // Create a reactive root so cleanup is easier.
         this.#signals.run(this.#connect.bind(this));
@@ -96,14 +188,34 @@ export class Reload {
     #connect(effect) {
         // Will retry when the tick changes.
         effect.get(this.#tick);
-        const suspended = effect.get(this.#suspended);
         const enabled = effect.get(this.enabled);
-        if (!enabled || suspended)
+        if (!enabled) {
+            this.#givenUpHref = undefined;
+            this.#resetSequence();
+            return;
+        }
+        // Hide/freeze pauses an in-flight sequence without recovering from give-up.
+        const suspended = effect.get(this.#suspended);
+        if (suspended) {
+            this.#resetSequence();
             return;
+        }
         const href = effect.get(this.#url);
-        if (!href)
+        if (!href) {
+            this.#givenUpHref = undefined;
+            this.#resetSequence();
             return;
+        }
         const url = new URL(href);
+        if (this.#givenUpHref === href) {
+            return;
+        }
+        if (this.#sequenceHref !== href) {
+            this.#resetSequence();
+            this.#sequenceHref = href;
+            this.#error.set(undefined);
+            this.#givenUpHref = undefined;
+        }
         effect.set(this.status, "connecting", "disconnected");
         // This run's teardown, handed to connect() so a rerun cancels the attempt in flight.
         const signal = effect.abort;
@@ -112,10 +224,13 @@ export class Reload {
             // later dropped from a connect failure or a peer that flaps immediately.
             let connected;
             try {
-                const connection = await connect(url, {
+                const connection = await connect({
+                    url,
                     websocket: this.websocket,
                     webtransport: this.webtransport,
                     discovery: this.discovery,
+                    publish: this.publish,
+                    consume: this.consume,
                     signal,
                 });
                 // Hand the connection to the effect, which closes it now if this run is already over.
@@ -126,12 +241,13 @@ export class Reload {
                 effect.set(this.status, "connected", "disconnected");
                 connected = performance.now();
                 // A cancelled effect resolves undefined, so the sentinel tells the session
-                // closing apart from this run being torn down.
-                const closed = await Promise.race([effect.cancel, connection.closed.then(() => true)]);
-                if (!closed)
+                // closing (null for clean, an Error otherwise) apart from this run being
+                // torn down.
+                const closed = await effect.race(connection.closed);
+                if (closed === undefined)
                     return;
                 console.warn("connection closed, reconnecting");
-                this.#retry(effect, connected);
+                this.#retry(effect, connected, closed ?? undefined);
             }
             catch (err) {
                 // Treat teardown as cancellation, not a connection failure.
@@ -148,6 +264,16 @@ export class Reload {
      * `cause` the error that killed it, if it died with one.
      */
     #retry(effect, connected, cause) {
+        // Resolved per sequence rather than at construction, so an edit to `delay` (including
+        // one that drops a field back to its default) applies to the next retry. Field by
+        // field rather than by spread: a caller building `{ initial: maybeInitial }` from an
+        // optional value passes an explicit undefined, which a spread would take as the
+        // answer, turning the backoff into NaN or the window into forever.
+        const delay = this.delay ?? {};
+        const initial = delay.initial ?? DEFAULT_DELAY.initial;
+        const multiplier = delay.multiplier ?? DEFAULT_DELAY.multiplier;
+        const max = delay.max ?? DEFAULT_DELAY.max;
+        const timeout = delay.timeout ?? DEFAULT_DELAY.timeout;
         // Any session is dead now: report disconnected during the backoff rather than
         // when the retry reruns the effect.
         this.established.set(undefined);
@@ -156,44 +282,66 @@ export class Reload {
         // start a fresh retry window: a one-off drop should reconnect promptly. Anything
         // shorter is a peer that accepts and immediately severs, which has to keep
         // escalating or we hammer it forever at the initial delay.
-        if (connected !== undefined && performance.now() - connected >= this.delay.initial) {
+        if (connected !== undefined && performance.now() - connected >= initial) {
             this.#delay = undefined;
             this.#deadline = undefined;
         }
+        // An auth rejection stops this URL however long the session lived. UNAUTHORIZED is a
+        // specified code rather than one we guessed at, so this is the peer saying these
+        // credentials will never work; retrying them just burns the window. Matches
+        // moq-tokio's reconnect loop, which stops on the same close. A new URL or a
+        // disable/re-enable starts another sequence; the handle itself is not disposed.
+        //
+        // Only a session close says that. The stream registry gives 2 to DELIVERY_TIMEOUT,
+        // so a stream reset during the SETUP exchange would otherwise suppress reconnect
+        // for good.
+        if (cause instanceof SessionError && cause.code === SessionCode.Unauthorized) {
+            console.warn("session rejected as unauthorized, not retrying");
+            this.#giveUp(cause);
+            return;
+        }
         const now = performance.now();
-        const timeout = this.delay.timeout ?? DEFAULT_TIMEOUT;
-        this.#delay ??= this.delay.initial;
+        this.#delay ??= initial;
         this.#deadline ??= timeout > 0 ? now + timeout : Number.POSITIVE_INFINITY;
         if (now >= this.#deadline) {
             console.warn("reconnect timed out");
             // A graceful close has no error, so report the timeout itself.
-            this.#closedReject(cause === undefined ? new Error("reconnect timed out") : error(cause));
+            this.#giveUp(cause === undefined ? new Error("reconnect timed out") : error(cause));
             return;
         }
         // Equal jitter, so a fleet of tabs knocked offline together doesn't reconnect on the same
         // tick, and never past the deadline the retry window promised.
         const wait = Math.min(this.#delay * (0.5 + Math.random() / 2), this.#deadline - now);
-        this.#delay = Math.min(this.#delay * this.delay.multiplier, this.delay.max);
+        this.#delay = Math.min(this.#delay * multiplier, max);
         const tick = this.#tick.peek() + 1;
         effect.timer(() => this.#tick.update((prev) => Math.max(prev, tick)), wait);
     }
+    #giveUp(cause) {
+        this.#error.set(cause);
+        this.#givenUpHref = this.#sequenceHref;
+        this.#resetSequence();
+    }
+    #resetSequence() {
+        this.#delay = undefined;
+        this.#deadline = undefined;
+        this.#sequenceHref = undefined;
+    }
     /**
-     * Subscribe to broadcast announcements under an optional prefix, spanning reconnects.
+     * Subscribe to broadcast announcements matching `scope`, spanning reconnects.
      *
      * The same {@link Announce.Consumer} stream as {@link Established.announced}, but everything active
-     * is retracted (an `active: false` update) whenever the connection drops and re-announced on
+     * is retracted (a `retracted` update) whenever the connection drops and re-announced on
      * reconnect, so a consumer draining `next()` never clings to a dead route across a reconnect.
      *
      * Stays empty while the relay lacks {@link Established.discovery}.
      */
-    announced(prefix = emptyPath()) {
-        const producer = new Announce.Producer(prefix);
+    announced(scope = Path.Pattern.all(), options) {
+        // With a consume origin the table already spans reconnects (the forwarder retracts
+        // a dead session's entries), so its stream is the same thing with less machinery.
+        if (this.consume)
+            return this.consume.announced(scope, options);
+        const producer = new Announce.Producer();
         const consumer = producer.consume();
-        // Closing the consumer closes the shared state, so stop appending after that.
-        let closed = false;
-        void consumer.closed.then(() => {
-            closed = true;
-        });
         const pump = new Effect();
         pump.run((effect) => {
             const conn = effect.get(this.established);
@@ -203,20 +351,21 @@ export class Reload {
             // consumer empty rather than opening a subscription that can't be answered.
             if (!conn.discovery)
                 return;
-            const upstream = conn.announced(prefix);
+            const upstream = conn.announced(scope, options);
             effect.cleanup(() => upstream.close());
-            // Track what this connection announced so we can retract it if the connection drops.
-            const active = new Set();
+            // Track what this connection announced so we can retract it if the connection
+            // drops; the last event rides along for the retraction.
+            const active = new Map();
             effect.spawn(async () => {
                 try {
                     for (;;) {
-                        const entry = await Promise.race([effect.cancel, upstream.next()]);
+                        const entry = await effect.race(upstream.next());
                         if (!entry)
                             break;
-                        if (entry.active)
-                            active.add(entry.path);
+                        if (Announce.isActive(entry.kind))
+                            active.set(entry.prefix, entry);
                         else
-                            active.delete(entry.path);
+                            active.delete(entry.prefix);
                         producer.append(entry);
                     }
                 }
@@ -226,9 +375,9 @@ export class Reload {
                 finally {
                     // Retract everything from the connection that just went away, so a per-broadcast
                     // watcher tears down instead of clinging to the dead route.
-                    if (!closed) {
-                        for (const path of active) {
-                            producer.append({ path, active: false });
+                    if (consumer.closed.peek() === undefined) {
+                        for (const entry of active.values()) {
+                            producer.append({ ...entry, kind: "retracted" });
                         }
                     }
                 }
@@ -238,20 +387,6 @@ export class Reload {
         void consumer.closed.then(() => pump.close());
         return consumer;
     }
-    /**
-     * A reactive handle to one broadcast, spanning reconnects.
-     *
-     * The same {@link Announce.Broadcast} as {@link Established.announcedBroadcast}, but it
-     * follows the reconnect loop: the broadcast drops to `undefined` when the connection dies
-     * and resolves again once the new connection announces the path. Use it instead of
-     * consuming off {@link Reload.established} whenever the broadcast may come online after you
-     * do, which is exactly the case a blind `consume` loses.
-     *
-     * Close the handle when done; {@link Reload.close} only drops it to `undefined`.
-     */
-    announcedBroadcast(path) {
-        return new Announce.Broadcast({ connection: this.established, path });
-    }
     /**
      * Snapshot the live connection's transport counters, or undefined while disconnected.
      * See {@link Established.stats}.
@@ -259,10 +394,11 @@ export class Reload {
     async stats() {
         return this.established.peek()?.stats();
     }
-    /** Stop reconnecting, close the current connection, and resolve {@link Reload.closed}. */
-    close() {
+    /** Stop reconnecting, close the current connection, and settle {@link Reload.closed}. Idempotent. */
+    close(abort) {
         this.#signals.close();
-        this.#closedResolve();
+        if (this.#closed.peek() === undefined)
+            this.#closed.set(abort ?? null);
     }
 }
 //# sourceMappingURL=reload.js.map