@norskvideo/moq-net 0.1.8 → 0.2.1

package/origin.js

@@ -1,59 +1,1449 @@
 /* @ts-self-types="./origin.d.ts" */
 /**
- * Endpoint identity within a hop chain, shared by both wire protocols.
+ * A broadcast routing table, independent of any connection.
  *
- * moq-lite carries these natively on every announcement; moq-transport carries them
- * via the MoQ Cluster extension (see `ietf/cluster.ts`). Mirrors `Origin` in
+ * Publish broadcasts into an origin and hand the origin to one or more connections to
+ * serve them; the broadcasts outlive any single session. Hand the same (or another)
+ * origin to a connection's `consume` option and the peer's announced routes appear
+ * in the table too: each route covers a path prefix, and a request for a path under
+ * it resolves through the session that announced it. Mirrors the `origin` module in
  * `rs/moq-net`.
  *
  * @module
  */
-import * as z from "zod/mini";
+import { Derived, getter, Once, Signal } from "@norskvideo/moq-signals";
+import * as announce from "./announced.js";
+import * as broadcast from "./broadcast.js";
+import { StreamCode, StreamError } from "./error.js";
+import { isAnonymous, Route, routesEqual } from "./hop.js";
+import { hiddenBelow, hooks, scopeCaptures, scopeHead, scopeOverlaps } from "./internal.js";
+import * as Path from "./path.js";
+import { registerWire, wireOf } from "./wire.js";
+export { isAnonymous } from "./hop.js";
+/** The rooted permissions shared by a handle and every route it inserts. */
+class Scope {
+    static all = new Scope(Path.empty());
+    root;
+    allowed;
+    constructor(root, allowed) {
+        this.root = root;
+        this.allowed = allowed;
+    }
+    narrow(root, patterns) {
+        const joined = Path.encode(Path.join(this.root, root));
+        const rooted = patterns.rooted(joined);
+        const allowed = this.allowed?.intersect(rooted) ?? rooted;
+        if (allowed.size === 0)
+            throw new Error("origin scopes do not overlap");
+        return new Scope(joined, allowed);
+    }
+    matches(path) {
+        return this.allowed?.matches(path) ?? true;
+    }
+    path(path) {
+        const joined = Path.encode(Path.join(this.root, path));
+        if (!this.matches(joined))
+            throw new Error("path is outside the origin scope");
+        return joined;
+    }
+    prefix(prefix) {
+        const joined = Path.encode(Path.join(this.root, prefix));
+        if (this.allowed && !this.allowed.overlaps(Path.Pattern.subtree(joined))) {
+            throw new Error("prefix is outside the origin scope");
+        }
+        return joined;
+    }
+    patterns(pattern = Path.Pattern.all()) {
+        const rooted = new Path.Patterns([pattern.rooted(this.root)]);
+        return this.allowed?.intersect(rooted) ?? rooted;
+    }
+    /** Omit nested heads because the outer subscription already carries their routes. */
+    heads() {
+        if (!this.allowed)
+            return [Path.empty()];
+        const heads = [...new Set([...this.allowed.rebase(this.root)].map(scopeHead))].sort();
+        return heads.filter((head) => !heads.some((other) => other !== head && Path.hasPrefix(other, head)));
+    }
+    /** The exact paths within this scope, relative to its root. */
+    projectPaths(values) {
+        if (!values || this === Scope.all)
+            return values;
+        const out = new Map();
+        for (const [path, value] of values) {
+            if (!this.matches(path))
+                continue;
+            const relative = Path.stripPrefix(this.root, path);
+            if (relative !== null)
+                out.set(relative, value);
+        }
+        return out;
+    }
+    /**
+     * The advertisements that may serve this scope, relative to its root. Every prefix at or
+     * above the root presents as the empty path, most specific first, since that is the order
+     * a request beneath the root resolves in.
+     */
+    projectRoutes(values) {
+        if (!values || this === Scope.all)
+            return values;
+        const out = new Map();
+        const covering = [];
+        const allowed = this.allowed && [...this.allowed];
+        for (const [path, candidates] of values) {
+            const relative = Path.stripPrefix(this.root, path);
+            const above = relative === null || relative === Path.empty();
+            if (above && !Path.hasPrefix(path, this.root))
+                continue;
+            const visible = candidates
+                .filter((value) => !allowed || allowed.some((pattern) => advertOverlaps(value, path, pattern)))
+                // The claim moves with the key, so it compares against root-relative requests.
+                .map((value) => (value.claim ? { ...value, claim: value.claim.rebase(this.root) } : value));
+            if (visible.length === 0)
+                continue;
+            if (!above) {
+                out.set(relative, visible);
+                continue;
+            }
+            // Hold the empty path's place in the order until every covering prefix is known.
+            if (covering.length === 0)
+                out.set(Path.empty(), []);
+            covering.push([path, visible]);
+        }
+        if (covering.length > 0) {
+            covering.sort(([a], [b]) => b.length - a.length);
+            out.set(Path.empty(), covering.flatMap(([, visible]) => visible));
+        }
+        return out;
+    }
+}
+/** Whether the route advertised at `prefix` may serve any path `pattern` admits. */
+function advertOverlaps(advert, prefix, pattern) {
+    return advert.claim ? advert.claim.overlaps(pattern) : scopeOverlaps(pattern, prefix);
+}
+/**
+ * Presents advertised prefixes relative to a root. Every prefix at or above the root
+ * collapses to the empty path, where the most specific one wins, since that is the route
+ * a request beneath the root resolves through.
+ */
+class CoveringRoot {
+    #root;
+    #covering;
+    constructor(root) {
+        this.#root = root;
+    }
+    /** The presented path for `path`, or undefined when it is outside the root or a broader cover. */
+    relative(path) {
+        const relative = Path.stripPrefix(this.#root, path);
+        if (relative !== null && relative !== Path.empty())
+            return relative;
+        if (relative === null && !Path.hasPrefix(path, this.#root))
+            return undefined;
+        if (this.#covering !== undefined && !Path.hasPrefix(this.#covering, path))
+            return undefined;
+        this.#covering = path;
+        return Path.empty();
+    }
+}
+/** Orders advertisements at one prefix: the better route, then a local broadcast on a tie, then fewer hops. */
+function compareCandidates(a, b) {
+    return (compareRoutes(a.route, b.route) ||
+        Number(b.exact) - Number(a.exact) ||
+        a.route.hops.length - b.route.hops.length);
+}
+/** Orders two routes by preference: identified before anonymous, then lower warm cost, then lower cold cost. */
+function compareRoutes(a, b) {
+    const anonymous = Number(isAnonymous(a)) - Number(isAnonymous(b));
+    if (anonymous !== 0)
+        return anonymous;
+    if (a.cost.warm !== b.cost.warm)
+        return a.cost.warm < b.cost.warm ? -1 : 1;
+    if (a.cost.cold !== b.cost.cold)
+        return a.cost.cold < b.cost.cold ? -1 : 1;
+    return 0;
+}
+/** The preferred of `entries` (newest first) not skipped: the best route, then fewest hops, then newest. */
+function preferredEntry(entries, skip) {
+    let best;
+    for (const entry of entries) {
+        if (skip?.(entry))
+            continue;
+        if (!best) {
+            best = entry;
+            continue;
+        }
+        const a = entry.route.peek();
+        const b = best.route.peek();
+        const order = compareRoutes(a, b) || a.hops.length - b.hops.length;
+        if (order < 0)
+            best = entry;
+    }
+    return best;
+}
+/** Whether a session received `entry`, so it is never forwarded to a peer. */
+function received(entry) {
+    return !entry.originated;
+}
+function noCapacity() {
+    return new StreamError(StreamCode.NoCapacity, { message: "no capacity" });
+}
+/** A served route from {@link Producer.dynamic}: the queue a handler drains. */
+class ServeState {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    queue = new Signal([]);
+    pending = new Map();
+    served = new Map();
+    rejected = new Map();
+    // demand() is the only reader of `rejected`. A Consumer.request refusal never
+    // re-enqueues, so storing the error without a waiter would pin every unique
+    // path until the route dies.
+    demanding = new Map();
+    closed = new Once();
+    settled = new Signal(0);
+    onChange = () => { };
+    onReject = () => { };
+    enqueue(path) {
+        if (this.closed.peek() !== undefined)
+            return;
+        this.rejected.delete(path);
+        if (this.pending.has(path))
+            return;
+        const live = this.served.get(path);
+        if (live && live.closed.peek() === undefined)
+            return;
+        const request = makeRequest(Path.stripPrefix(this.root, path) ?? Path.empty(), this);
+        this.pending.set(path, request);
+        this.queue.mutate((queue) => {
+            queue.push(request);
+        });
+    }
+    accept(request, front) {
+        const path = Path.join(this.root, request.path);
+        if (this.closed.peek() !== undefined || this.pending.get(path) !== request) {
+            front.close();
+            return;
+        }
+        this.pending.delete(path);
+        const existing = this.served.get(path);
+        if (existing && existing.closed.peek() === undefined) {
+            front.close();
+            this.onChange(path);
+            this.settled.update((n) => n + 1);
+            return;
+        }
+        this.served.set(path, front);
+        void front.closed.then(() => {
+            if (this.served.get(path) !== front)
+                return;
+            this.served.delete(path);
+            this.onChange(path);
+        });
+        this.onChange(path);
+        this.settled.update((n) => n + 1);
+    }
+    reject(request, err) {
+        const path = Path.join(this.root, request.path);
+        if (this.pending.get(path) !== request)
+            return;
+        this.pending.delete(path);
+        if (this.demanding.has(path))
+            this.rejected.set(path, err);
+        this.onReject(path, err);
+        this.settled.update((n) => n + 1);
+    }
+    close(abort) {
+        if (this.closed.peek() !== undefined)
+            return;
+        const err = abort ?? noCapacity();
+        this.closed.set(err);
+        const queued = [...this.pending.values()];
+        this.pending.clear();
+        this.queue.mutate((queue) => {
+            queue.length = 0;
+        });
+        for (const request of queued) {
+            finishRequest(request, err);
+        }
+        for (const [path, front] of this.served) {
+            front.close();
+            this.onChange(path);
+        }
+        this.served.clear();
+        this.rejected.clear();
+        this.demanding.clear();
+        this.settled.update((n) => n + 1);
+    }
+}
+/** A table mutation invalidates the shared route snapshot before its async notification. */
+class VersionedSignal extends Signal {
+    version = 0;
+    set(value, notify) {
+        this.version++;
+        super.set(value, notify);
+    }
+}
+/** Reactive backing state shared by origin producers and consumers. */
+class OriginState {
+    // Both tables decouple the application producing into the origin from the
+    // connections serving or feeding it. Undefined once the origin closes, so late
+    // writes fail loudly.
+    //
+    // Created is what this endpoint publishes, keyed by exact path, announced or not.
+    // Local is the announced subset, with its route in advertisedLocal: a broadcast
+    // exists for nobody, here or at a peer, until it announces. Routes is the
+    // advertisement table: prefixes a dynamic handle or a received session covers,
+    // newest first. Local and routes stay separate so a session can never announce a
+    // received entry back to a peer, which is what makes an origin shared by both
+    // directions echo-free.
+    created = new Map();
+    local = new VersionedSignal(new Map());
+    advertisedLocal = new VersionedSignal(new Map());
+    routes = new VersionedSignal(new Map());
+    #snapshotVersion = "";
+    #snapshot = { candidates: new Map(), routes: new Map(), visible: new Map() };
+    /** The full route table is built once per mutation, regardless of observer count. */
+    available = new Derived([this.local, this.advertisedLocal, this.routes], () => this.snapshot().routes);
+    /** {@link available} without hidden routes, for unscoped readers that did not opt in. */
+    visible = new Derived([this.local, this.advertisedLocal, this.routes], () => this.snapshot().visible);
+    snapshot() {
+        const version = `${this.local.version}/${this.advertisedLocal.version}/${this.routes.version}`;
+        if (version === this.#snapshotVersion)
+            return this.#snapshot;
+        const candidates = this.candidates();
+        const available = new Map();
+        const visible = new Map();
+        for (const [path, [best]] of candidates) {
+            available.set(path, best.route);
+            if (!hiddenBelow(Path.empty(), path))
+                visible.set(path, best.route);
+        }
+        this.#snapshot = { candidates, routes: available, visible };
+        this.#snapshotVersion = version;
+        return this.#snapshot;
+    }
+    /**
+     * Every advertisement per prefix, most preferred first, without the `skip`ped entries.
+     * Readers select after filtering by their scope, so a cheaper route they cannot see
+     * never hides one they can.
+     */
+    candidates(skip) {
+        const out = new Map();
+        for (const [path, entries] of this.routes.peek() ?? []) {
+            const list = [];
+            for (const entry of entries) {
+                if (skip?.(entry))
+                    continue;
+                list.push({ identity: entry.identity, route: entry.route.peek(), claim: entry.claim, exact: false });
+            }
+            if (list.length > 0)
+                out.set(path, list);
+        }
+        const advertised = this.advertisedLocal.peek();
+        for (const [path, front] of this.local.peek() ?? []) {
+            const local = { identity: front, route: advertised?.get(path) ?? Route.default, exact: true };
+            const list = out.get(path);
+            if (list)
+                list.push(local);
+            else
+                out.set(path, [local]);
+        }
+        for (const list of out.values()) {
+            // Stable, so equal routes keep the table's newest-first order.
+            if (list.length > 1)
+                list.sort(compareCandidates);
+        }
+        return out;
+    }
+    // Originated advertisements sessions should forward: exact-path announces plus
+    // originated dynamics. Identity is the local front or the route entry, so a
+    // republish diffs as retract-then-announce and a re-price as another active.
+    originated = new Signal(new Map());
+    // Broadcasts materialized from a served route, keyed by exact path. Shared by every
+    // request for the path so repeats reuse one accept; dropped (and closed) when the
+    // providing route goes away or the last request releases it.
+    materialized = new Map();
+    // Paths consumers asked for without waiting for an announcement; attached sessions
+    // answer them with blind subscriptions. Never announced: an answered request is assumed
+    // present, not known live, so it must not read as an availability claim.
+    requests = new Signal(new Map());
+    // How many sessions are attached, and how many of those support broadcast discovery.
+    // What backs the public `discovery` getter.
+    sessions = new Signal({ total: 0, discovery: 0 });
+    // How many things are prepared to answer a request: attached sessions, plus reconnecting
+    // connections that have no session right now but will. Zero means an unrouted path is
+    // unroutable rather than merely unanswered, which is the whole difference between "wait,
+    // this is coming" and "nothing here can ever serve you".
+    answerers = new Signal(0);
+    closed = new Once();
+    /**
+     * Recompute what `path` resolves to, waking only the requests watching that path.
+     *
+     * A no-op for a path nobody requested, so the common case (publishing into a table
+     * nobody is asking about) costs a map lookup. Call after any write that could change
+     * the answer for a single path.
+     */
+    refresh(path) {
+        const slot = this.requests.peek()?.get(path);
+        if (!slot)
+            return;
+        slot.route.set(this.route(path, slot));
+    }
+    /**
+     * `entry` refused `path` with `err`. A request still serving another source skips the
+     * refuser; one with nothing serving ends with `err`.
+     */
+    refuse(path, entry, err) {
+        const slot = this.requests.peek()?.get(path);
+        if (!slot)
+            return;
+        // Only the route the request is waiting on speaks for it; a superseded one's answer is moot.
+        if (this.bestEntry(path, (candidate) => slot.refused.has(candidate)) !== entry)
+            return;
+        const serving = slot.route.peek();
+        if (serving && serving.closed.peek() === undefined) {
+            slot.refused.add(entry);
+            slot.route.set(this.route(path, slot));
+            return;
+        }
+        this.requests.mutate((map) => {
+            if (map?.get(path) === slot)
+                map.delete(path);
+        });
+        slot.answer?.close();
+        slot.answer = undefined;
+        slot.route.set(undefined);
+        this.releaseMaterialized(path);
+        for (const closed of slot.handles)
+            closed.set(err);
+        slot.handles.clear();
+    }
+    /**
+     * Recompute every open request covered by `prefix`, after a route was inserted or
+     * removed there: a route covers many paths, so a single-path refresh is not enough.
+     * Every materialized broadcast belongs to an open request, so rerouting them also
+     * releases a retracted route's session subscription even when nothing reads it again.
+     */
+    refreshPrefix(prefix) {
+        for (const [path, slot] of this.requests.peek() ?? []) {
+            if (Path.hasPrefix(prefix, path))
+                slot.route.set(this.route(path, slot));
+        }
+    }
+    /** Rebuild the publisher-facing originated table after an advertisement write. */
+    rebuildOriginated() {
+        if (!this.local.peek() && !this.advertisedLocal.peek() && !this.routes.peek()) {
+            this.originated.set(undefined);
+            return;
+        }
+        // A local broadcast and an originated dynamic at one path compete on cost, as they do for requests.
+        this.originated.set(this.candidates(received));
+    }
+    /**
+     * Release the materialized broadcast for `path`, once its last request is gone: the
+     * cache exists to share one session subscription between requests, not to outlive
+     * them.
+     */
+    releaseMaterialized(path) {
+        const cached = this.materialized.get(path);
+        if (!cached)
+            return;
+        this.materialized.delete(path);
+        cached.front.close();
+    }
+    /** The preferred entry on the most specific route covering `path`, ignoring skipped entries, if any. */
+    bestEntry(path, skip) {
+        let bestPrefix;
+        let best;
+        for (const [prefix, entries] of this.routes.peek() ?? []) {
+            if (!Path.hasPrefix(prefix, path))
+                continue;
+            const entry = preferredEntry(entries, (candidate) => !candidate.scope.matches(path) || (skip?.(candidate) ?? false));
+            if (!entry)
+                continue;
+            if (bestPrefix === undefined || prefix.length > bestPrefix.length) {
+                bestPrefix = prefix;
+                best = entry;
+            }
+        }
+        return best;
+    }
+    /**
+     * Whether the announced local broadcast at `path` wins over `entry`, the best route a
+     * session or dynamic handle announced there. Cost decides, as for any two routes: an
+     * identified route strictly cheaper than the local one wins, and the local broadcast
+     * wins a tie. A route at a shorter prefix never competes, since the most specific
+     * prefix wins outright. False when nothing is announced locally at `path`.
+     */
+    localWins(path, entry) {
+        const local = this.advertisedLocal.peek()?.get(path);
+        if (!local || !this.local.peek()?.has(path))
+            return false;
+        if (!entry || !this.routes.peek()?.get(path)?.includes(entry))
+            return true;
+        return compareRoutes(local, entry.route.peek()) <= 0;
+    }
+    /**
+     * What `path` resolves to: an announced local publish, a broadcast materialized from
+     * the best covering route, or the blind answer.
+     *
+     * Materialization is lazy and cached per path: the first request under a route opens
+     * the providing session's subscription and repeats share it. A better route is made
+     * before the old one breaks: the current front keeps serving until the new route
+     * answers (then swaps) or refuses (then is skipped). A retracted route swaps at once.
+     */
+    route(path, slot) {
+        const entry = this.bestEntry(path, (candidate) => slot.refused.has(candidate));
+        const local = this.local.peek()?.get(path);
+        if (local && this.localWins(path, entry)) {
+            // Nothing reads a remote front the local broadcast replaced, so close its session subscription.
+            this.releaseMaterialized(path);
+            return local;
+        }
+        let cached = this.materialized.get(path);
+        if (cached && cached.front.closed.peek() !== undefined) {
+            this.materialized.delete(path);
+            cached = undefined;
+        }
+        if (cached && cached.entry === entry)
+            return cached.front;
+        if (!entry?.server) {
+            this.releaseMaterialized(path);
+            return slot.answer;
+        }
+        const served = entry.server.served.get(path);
+        if (served && served.closed.peek() === undefined) {
+            cached?.front.close();
+            this.materialized.set(path, { entry, front: served });
+            return served;
+        }
+        entry.server.enqueue(path);
+        return cached?.front;
+    }
+}
+/**
+ * The write side of an origin: create broadcasts by path and advertise them.
+ *
+ * Independent of any connection. A connection given this origin (via its `publish` option)
+ * announces and serves the table's originated advertisements for as long as the session
+ * lasts; the broadcasts themselves live until their producer closes or {@link close} tears
+ * the origin down. A reconnecting session re-announces the table on each attach, so
+ * advertisements made while offline surface on the next connection.
+ *
+ * Create, attach {@link dynamic} for tracks served on demand, populate, then
+ * {@link broadcast.Producer.announce}: an exact-path subscribe before the tracks exist is
+ * refused, and nobody can see or reach a broadcast until it announces.
+ *
+ * @public
+ */
+export class Producer {
+    #state = new OriginState();
+    #scope = Scope.all;
+    #requests;
+    // The reader backing the passthroughs, so holding a Producer never requires the
+    // consume().x() stutter for everyday reads. One instance, so `discovery` keeps its
+    // identity across reads.
+    #reader = makeConsumer(this.#state, this.#scope);
+    constructor() {
+        const thisProducer = this;
+        registerWire(this, {
+            receive: (prefix, route) => this.#receive(prefix, route),
+            interests: () => this.#scope.heads(),
+            accepts: (prefix) => !this.#scope.allowed ||
+                this.#scope.allowed.overlaps(Path.Pattern.subtree(Path.join(this.#scope.root, prefix))),
+            attach: (discovery) => this.#attach(discovery),
+            expect: () => this.#expect(),
+            get requests() {
+                if (thisProducer.#scope === Scope.all)
+                    return thisProducer.#state.requests;
+                thisProducer.#requests ??= new Derived([thisProducer.#state.requests], (requests) => thisProducer.#scope.projectPaths(requests));
+                return thisProducer.#requests;
+            },
+            changed: () => this.#changed(),
+            answer: (path, front) => this.#answer(this.#scope.path(path), front),
+            routes: (path) => wireOf(this.#reader).routes(path),
+        });
+    }
+    /** Narrow this handle to patterns beneath root, presenting paths relative to that root. */
+    scope(root, patterns) {
+        const scope = this.#scope.narrow(root, patterns);
+        const producer = new Producer();
+        producer.#state = this.#state;
+        producer.#scope = scope;
+        producer.#reader = makeConsumer(this.#state, scope);
+        return producer;
+    }
+    /**
+     * Settles once the origin closes: `null` on a clean close, or the abort {@link Error}.
+     * Peek it synchronously (`undefined` while open), observe it reactively, or `await` it.
+     */
+    get closed() {
+        return this.#state.closed;
+    }
+    /**
+     * Create a broadcast at `path`, returning its producer.
+     *
+     * The broadcast exists for nobody until {@link broadcast.Producer.announce}: announce
+     * streams skip it and requests for its path find nothing, on this origin exactly as at
+     * a peer. Announce once its tracks exist; {@link broadcast.Producer.unannounce}
+     * withdraws it from everyone again.
+     *
+     * Close the producer to drop it. Creating a path again supersedes the previous
+     * broadcast: the origin drops its handle on the old one, which closes it unless the
+     * application still holds a consumer clone. An announced local broadcast competes with
+     * a remote route at the same path on cost, winning ties.
+     */
+    createBroadcast(path) {
+        path = this.#scope.path(path);
+        const created = this.#state.created;
+        if (!created)
+            throw new Error("origin is closed");
+        const producer = new broadcast.Producer();
+        hooks.stampPath(producer, path);
+        const front = producer.consume();
+        hooks.attachAnnouncer(producer, {
+            announce: (route) => this.#advertiseExact(path, front, route),
+            unannounce: () => this.#retractExact(path, front),
+        });
+        const previous = created.get(path);
+        created.set(path, front);
+        if (previous) {
+            this.#retractExact(path, previous);
+            previous.close();
+        }
+        // Drop it when the broadcast closes, unless a recreate already replaced it: a
+        // stale broadcast closing must not unpublish the live one.
+        void front.closed.then(() => {
+            this.#retractExact(path, front);
+            if (this.#state.created?.get(path) === front)
+                this.#state.created.delete(path);
+        });
+        return producer;
+    }
+    #advertiseExact(path, front, route) {
+        if (!this.#state.local.peek())
+            throw new Error("origin is closed");
+        if (this.#state.created?.get(path) !== front)
+            throw new Error("broadcast is closed");
+        // Both maps move together, so every reader sees the broadcast and its route at once.
+        this.#state.local.mutate((broadcasts) => {
+            broadcasts?.set(path, front);
+        });
+        this.#state.advertisedLocal.mutate((advertised) => {
+            advertised?.set(path, route);
+        });
+        this.#state.rebuildOriginated();
+        this.#state.refresh(path);
+    }
+    #retractExact(path, front) {
+        if (this.#state.local.peek()?.get(path) !== front)
+            return;
+        this.#state.local.mutate((broadcasts) => {
+            broadcasts?.delete(path);
+        });
+        this.#state.advertisedLocal.mutate((advertised) => {
+            advertised?.delete(path);
+        });
+        this.#state.rebuildOriginated();
+        this.#state.refresh(path);
+    }
+    /**
+     * Advertise `prefix` and serve the requests beneath it.
+     *
+     * A route is always a prefix: it claims `prefix` and every path beneath it (the
+     * empty prefix claims every path). A service that only serves some of them
+     * advertises the covering prefix and rejects the rest as they are requested;
+     * consumers narrow with a {@link Path.Pattern} locally. The advertisement is
+     * visible to {@link Consumer.announced} and forwarded by sessions for as long as
+     * the returned {@link Dynamic} lives. A consumer resolving a path under it that
+     * no announced local broadcast wins is handed to the handle as a {@link Request}.
+     */
+    dynamic(prefix, route = Route.default) {
+        return this.#insertRoute(prefix, Route.normalize(route), true);
+    }
+    /**
+     * Land a route a peer announced, served through the returned handle. Same as
+     * {@link dynamic} but not originated, so a session never announces it back.
+     *
+     * @internal
+     */
+    #receive(prefix, route = Route.default) {
+        return this.#insertRoute(prefix, Route.normalize(route), false);
+    }
+    #insertRoute(prefix, route, originated) {
+        prefix = this.#scope.prefix(prefix);
+        const server = new ServeState(this.#scope.root);
+        server.onChange = (path) => this.#state.refresh(path);
+        const entry = {
+            identity: {},
+            scope: this.#scope,
+            claim: this.#scope.allowed?.intersect(new Path.Patterns([Path.Pattern.subtree(prefix)])),
+            route: new Signal(route),
+            originated,
+            server,
+        };
+        server.onReject = (path, err) => this.#state.refuse(path, entry, err);
+        let closed = false;
+        this.#state.routes.mutate((routes) => {
+            if (!routes) {
+                closed = true;
+                return;
+            }
+            const entries = routes.get(prefix);
+            if (entries)
+                entries.unshift(entry);
+            else
+                routes.set(prefix, [entry]);
+        });
+        if (closed) {
+            server.close();
+            return makeDynamic(prefix, entry, this.#state, () => { });
+        }
+        this.#state.rebuildOriginated();
+        this.#state.refreshPrefix(prefix);
+        const retract = () => {
+            this.#state.routes.mutate((routes) => {
+                const entries = routes?.get(prefix);
+                if (!entries)
+                    return;
+                const index = entries.indexOf(entry);
+                if (index < 0)
+                    return;
+                entries.splice(index, 1);
+                if (entries.length === 0)
+                    routes?.delete(prefix);
+            });
+            // A retracted entry can never be picked again, so the refusals pinned to it are dead weight.
+            for (const slot of this.#state.requests.peek()?.values() ?? [])
+                slot.refused.delete(entry);
+            server.close();
+            this.#state.rebuildOriginated();
+            this.#state.refreshPrefix(prefix);
+        };
+        return makeDynamic(prefix, entry, this.#state, retract);
+    }
+    /**
+     * Register an attached session, counting it toward the `discovery` state. Returns the
+     * detach; call it exactly once when the session dies.
+     *
+     * @internal
+     */
+    #attach(discovery) {
+        this.#sessions(1, discovery);
+        const release = this.#expect();
+        let detached = false;
+        return () => {
+            if (detached)
+                return;
+            detached = true;
+            this.#sessions(-1, discovery);
+            release();
+        };
+    }
+    #sessions(delta, discovery) {
+        this.#state.sessions.update(({ total, discovery: d }) => ({
+            total: total + delta,
+            discovery: d + (discovery ? delta : 0),
+        }));
+    }
+    /**
+     * Declare that something will answer requests on this origin, even with no session
+     * attached right now.
+     *
+     * A reconnecting connection holds one for its whole life, so a request made during a
+     * reconnect (or before the first session establishes) stays pending instead of reading as
+     * unroutable. Without it, {@link Request.unroutable} would fire on every page load, in the
+     * window between wiring the origin up and the handshake completing. Call the returned
+     * dispose when the connection is done for good.
+     *
+     * @internal
+     */
+    #expect() {
+        this.#state.answerers.update((count) => count + 1);
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            // Clamped because closing the origin zeroes the count, and the sessions attached at
+            // the time still release afterwards.
+            this.#state.answerers.update((count) => Math.max(0, count - 1));
+        };
+    }
+    /**
+     * Resolves once anything a serving session scans changes: the open requests, or either
+     * side of the routing table.
+     *
+     * @internal
+     */
+    #changed() {
+        return Signal.race(this.#state.requests, this.#state.local, this.#state.routes, this.#state.advertisedLocal);
+    }
+    /**
+     * Provide `front` as the answer for the open request on `path`, taking ownership of it.
+     *
+     * Returns undefined (releasing the front) when the request is gone or already answered;
+     * first session in wins, and a loser must stay eligible to answer later. The returned
+     * withdraw releases the front and, if it was the standing answer, vacates the slot and
+     * wakes the other serving loops so a standby session answers immediately; call it when
+     * the session dies.
+     *
+     * @internal
+     */
+    #answer(path, front) {
+        const slot = this.#state.requests.peek()?.get(path);
+        if (!slot || slot.answer !== undefined) {
+            front.close();
+            return undefined;
+        }
+        slot.answer = front;
+        this.#state.refresh(path);
+        return () => {
+            if (slot.answer === front) {
+                slot.answer = undefined;
+                this.#state.refresh(path);
+                // The route signal only reaches this path's requesters; poke the map so every
+                // serving loop re-scans and one of them re-answers.
+                this.#state.requests.mutate(() => { });
+            }
+            front.close();
+        };
+    }
+    /** A read handle for this origin, the side a connection's `publish` option borrows. */
+    consume() {
+        return makeConsumer(this.#state, this.#scope);
+    }
+    /** Whether every attached session announces into the table; see {@link Consumer.discovery}. */
+    get discovery() {
+        return this.#reader.discovery;
+    }
+    /** Resolve `path`, optionally waiting for an announcement; see {@link Consumer.request}. */
+    request(path, options) {
+        return this.#reader.request(path, options);
+    }
+    /** The available announcements under `scope`, as a live map; see {@link Consumer.broadcasts}. */
+    broadcasts(scope, options) {
+        return this.#reader.broadcasts(scope, options);
+    }
+    /** The available broadcasts under `scope`, as a live stream; see {@link Consumer.announced}. */
+    announced(scope, options) {
+        return this.#reader.announced(scope, options);
+    }
+    /** Close the origin, every broadcast it still routes, and its announcement streams. Idempotent. */
+    close(abort) {
+        if (this.#state.closed.peek() !== undefined)
+            return;
+        this.#state.closed.set(abort ?? null);
+        for (const front of this.#state.created?.values() ?? []) {
+            front.close();
+        }
+        this.#state.created = undefined;
+        this.#state.local.update(() => undefined);
+        this.#state.advertisedLocal.update(() => undefined);
+        this.#state.routes.update((routes) => {
+            for (const entries of routes?.values() ?? []) {
+                for (const entry of entries)
+                    entry.server?.close(abort);
+            }
+            return undefined;
+        });
+        this.#state.originated.update(() => undefined);
+        // Materialized broadcasts are handles we opened; release them.
+        for (const cached of this.#state.materialized.values()) {
+            cached.front.close();
+        }
+        this.#state.materialized.clear();
+        // Nothing will answer a request on a closed origin, whatever is still attached, so
+        // existing requests report unroutable rather than waiting on a corpse.
+        this.#state.answerers.set(0);
+        this.#state.requests.update((requests) => {
+            for (const slot of requests?.values() ?? []) {
+                slot.answer?.close();
+                slot.answer = undefined;
+                slot.route.set(undefined);
+            }
+            return undefined;
+        });
+    }
+}
+// Constructs a Consumer from within this module without exposing a public constructor
+// that would leak the unexported OriginState. Assigned in the class's static block.
+let makeConsumer;
+// Same for Requesting: a public constructor would let a caller forge a handle that no origin
+// ever registered, whose lifecycle guarantees are then false. `@internal` alone would not
+// stop it, since the declaration emit keeps the constructor.
+let makeRequesting;
+let makeDynamic;
+let makeRequest;
+let finishRequest;
 /**
- * A relay origin id, encoded as a 62-bit varint on the wire.
+ * An open request for a path nothing announced; see {@link Consumer.request}.
  *
- * The {@link OriginSchema} validates any incoming value and brands it so the
- * type system enforces "only validated origins flow into hop lists." Internal
- * code that synthesizes an id (e.g. {@link randomOrigin}) uses
- * `OriginSchema.parse(...)` to produce a branded value from the raw bigint.
+ * @public
  */
-export const OriginSchema = z
-    .bigint()
-    .check(z.refine((value) => value >= 0n && value < 1n << 62n, "Origin must be a non-negative 62-bit integer"))
-    .brand("Origin");
+export class Requesting {
+    /** The requested path. */
+    path;
+    /**
+     * The resolved broadcast, or undefined while nothing provides the path.
+     *
+     * The table's route when it has one: a local publish (no round trip) or an announced
+     * broadcast, swapping when a republish takes the path. Otherwise a session's blind
+     * answer, which is assumed present rather than known live: a missing broadcast
+     * surfaces as a reset on the first track subscription, not here. Drops back to
+     * undefined when the providing route dies and resolves again when another appears.
+     *
+     * Yours for as long as the request is open: it is a handle of this request's own, so
+     * closing it ends your view of the path rather than the route everyone else reads.
+     * {@link close} releases whatever is current.
+     */
+    active;
+    /**
+     * Whether nothing can serve this path, as opposed to not having served it yet.
+     *
+     * True when the origin routes nothing here and nothing is prepared to answer: no session
+     * attached and no connection reconnecting toward one. False whenever {@link active} is
+     * set, and false while a connection is still coming up, so the ordinary page-load window
+     * before the first handshake reads as pending rather than as a missing broadcast. Waiting
+     * on this is futile by definition; wait for an announcement instead, via the origin's
+     * `announced`. True once the request is refused.
+     */
+    unroutable;
+    /**
+     * Settles with the error a route's handler refused the path with, or `null` once you
+     * {@link close} the request. A refusal is final: no other route is asked, and a fresh
+     * request is needed to try again.
+     */
+    closed;
+    #dispose;
+    #disposed = false;
+    constructor(path, active, unroutable, closed, dispose) {
+        this.path = path;
+        this.active = active;
+        this.unroutable = unroutable;
+        this.closed = closed;
+        this.#dispose = dispose;
+    }
+    static {
+        makeRequesting = (path, active, unroutable, closed, dispose) => new Requesting(path, active, unroutable, closed, dispose);
+    }
+    /** Withdraw the request. The path stays routed for any other open request. Idempotent. */
+    close() {
+        if (this.#disposed)
+            return;
+        this.#disposed = true;
+        this.#dispose();
+    }
+}
 /**
- * The reserved id 0, meaning "no identity".
+ * The read side of an origin: resolve broadcasts by path and watch what is available.
+ *
+ * Obtain one from {@link Producer.consume}. Pass it to a connection's `publish` option to
+ * serve the origin's local broadcasts to that peer; read it directly to consume anything
+ * the origin routes, locally published or discovered by a session.
  *
- * It stands in for an endpoint that never declared one, and any number of endpoints can
- * be 0, so it identifies nothing: it is never a loop, never a publisher two chains have
- * in common, and never excluded from an advertisement.
+ * @public
  */
-export const UNKNOWN_ORIGIN = OriginSchema.parse(0n);
+export class Consumer {
+    #state;
+    #scope;
+    constructor(state, scope) {
+        this.#state = state;
+        this.#scope = scope;
+        // True only when every attached session announces. One session that cannot means the
+        // table is an incomplete picture, so a consumer gated on it has to keep its blind
+        // fallback: the paths only that session carries never reach the table at all.
+        this.#discovery = new Derived([state.sessions], ({ total, discovery }) => total === 0 ? undefined : discovery === total);
+        registerWire(this, {
+            routes: (path) => this.#routes(scope.path(path)),
+            broadcasts: scope === Scope.all ? state.local : new Derived([state.local], (local) => scope.projectPaths(local)),
+            advertised: scope === Scope.all
+                ? state.originated
+                : new Derived([state.originated], (routes) => scope.projectRoutes(routes)),
+            local: (path) => this.#local(scope.path(path)),
+            demand: (path) => this.#demand(scope.path(path)),
+        });
+    }
+    static {
+        makeConsumer = (state, scope) => new Consumer(state, scope);
+    }
+    /** Settles once the origin closes; see {@link Producer.closed}. */
+    get closed() {
+        return this.#state.closed;
+    }
+    /**
+     * Whether the announcement table sees everything the attached sessions can serve.
+     *
+     * Undefined while no session is attached (nothing is known yet), true when every attached
+     * session announces into the table, and false as soon as one does not, where
+     * {@link announced} cannot be complete and consumers should {@link request} paths instead
+     * of waiting. One blind session among several is still false: the paths only it carries
+     * never reach the table, so a consumer that trusted the gate would never see them.
+     */
+    get discovery() {
+        return this.#discovery;
+    }
+    // Derived per access rather than cached: a lightweight mapped view over the session
+    // counts, avoiding a Computed's lifecycle.
+    #discovery;
+    /**
+     * Whether the table routes `path`, by an announced local publish or an announced
+     * route covering it.
+     *
+     * Availability, not a handle: {@link request} is the only way to consume by path. A
+     * request on a routed path resolves to that route and never to a blind answer, which is
+     * why a serving session leaves it alone.
+     *
+     * @internal
+     */
+    #routes(path) {
+        if (this.#state.local.peek()?.has(path))
+            return true;
+        return this.#state.bestEntry(path) !== undefined;
+    }
+    /**
+     * Resolve `path`, optionally waiting for an announcement.
+     *
+     * The one way to consume by path. {@link Requesting.active} follows whatever the table
+     * routes (an announced local publish, or any feeding session's announcement, swapping
+     * on a republish or a retraction); when nothing does, the request stands and whichever
+     * attached session answers first provides a blind subscription instead, re-answered
+     * across reconnects.
+     * With `announced: true`, an unrouted request waits while discovery is supported and
+     * falls back to that blind behavior only when discovery is unavailable. Close the request
+     * when done. On a closed origin it never resolves.
+     *
+     * With several sessions on one origin the first to answer wins, and it may be one that
+     * does not carry the path. Nothing corrects that: a missing broadcast surfaces as a reset
+     * on the first track and deliberately leaves the handle open, since the wire cannot tell
+     * "not here" from "not yet" and a blind handle is expected to survive until a publisher
+     * arrives. It matters only on an origin mixing sessions that announce with sessions that
+     * cannot, where a path only the silent session carries may sit behind another session's
+     * answer. Prefer {@link unroutable} and announcements over blind requests when the origin
+     * feeds from more than one connection.
+     */
+    request(path, options = {}) {
+        const relative = path;
+        path = this.#scope.path(path);
+        const requests = this.#state.requests.peek();
+        if (!requests) {
+            // Closed origin: a request that can never resolve, and says so.
+            const closed = new Once();
+            return makeRequesting(relative, new Signal(undefined), getter(true), closed, () => closed.set(null));
+        }
+        let slot = requests.get(path);
+        if (!slot) {
+            // Seeded through the constructor, so a path the table already routes resolves on the
+            // first read. It must not go through a silent set: that still captures the pre-seed
+            // value as the baseline the next change is compared against, and never flushes to
+            // clear it, so a seeded route retracting to undefined would look like no change and
+            // notify nobody.
+            const refused = new Set();
+            const created = {
+                blind: 0,
+                handles: new Set(),
+                refused,
+                route: new Signal(this.#state.route(path, { refused })),
+            };
+            slot = created;
+            this.#state.requests.mutate((map) => {
+                map?.set(path, created);
+            });
+        }
+        const closed = new Once();
+        slot.handles.add(closed);
+        let blind = !options.announced || this.#discovery.peek() === false;
+        if (blind)
+            slot.blind += 1;
+        this.#state.requests.mutate(() => { });
+        // An announcement-gated request falls back to a blind subscription only while at
+        // least one attached session cannot announce. It returns to the gate if discovery
+        // becomes complete again, and remains gated with no session attached.
+        const unsubscribeDiscovery = options.announced
+            ? this.#discovery.subscribe((discovery) => {
+                const next = discovery === false;
+                if (next === blind)
+                    return;
+                blind = next;
+                slot.blind += next ? 1 : -1;
+                this.#state.requests.mutate(() => { });
+            })
+            : () => { };
+        // Hand out a handle of the request's own rather than the table's. Closing a consumer
+        // closes the broadcast once it was the last one, and the table often holds the only
+        // other handle, so lending its front out means an ordinary close() by one requester
+        // can unpublish the path for everybody else.
+        const taken = slot;
+        // Memoized on the route's identity: the same front resolving again returns the handle
+        // we already made, and only a real swap clones a new one (cloning before closing the
+        // old, so a broadcast that both routes share never briefly loses its last handle).
+        let released = false;
+        let source;
+        let handle;
+        const own = (front) => {
+            if (released)
+                return undefined;
+            if (front !== source) {
+                const previous = handle;
+                source = front;
+                handle = front?.clone();
+                if (handle)
+                    hooks.stampPath(handle, relative);
+                previous?.close();
+            }
+            return handle;
+        };
+        const route = taken.route;
+        const active = new Derived([route], own);
+        // Swapping on the read is what keeps a routed path resolving synchronously, but a
+        // holder that only ever peeked would then pin a route that has already been retracted
+        // until it happened to read again. Following the route as well retires it promptly,
+        // and the memo makes the two paths agree: whichever runs first does the swap.
+        const unsubscribe = route.subscribe(own);
+        // Only meaningful while nothing is routed, so it reads the route rather than `active`:
+        // the two cannot disagree, since a routed path always has an answerer-independent
+        // answer.
+        const unroutable = new Derived([route, this.#state.answerers, closed], (front, answerers, ended) => ended !== undefined || (!front && answerers === 0));
+        return makeRequesting(relative, active, unroutable, closed, () => {
+            // Releases this request's handle; the route itself belongs to the table.
+            released = true;
+            unsubscribeDiscovery();
+            unsubscribe();
+            handle?.close();
+            handle = undefined;
+            source = undefined;
+            taken.handles.delete(closed);
+            if (closed.peek() === undefined)
+                closed.set(null);
+            if (blind)
+                taken.blind -= 1;
+            this.#state.requests.mutate(() => { });
+            if (taken.handles.size > 0)
+                return;
+            // Defer the teardown a microtask: an effect whose rerun was triggered by the
+            // answer resolving closes its old request and takes a new one in the same tick,
+            // and tearing down in between would drop the answer it is about to read.
+            queueMicrotask(() => {
+                if (taken.handles.size > 0)
+                    return;
+                // A refused slot already tore itself down, and the path may hold a newer one.
+                if (this.#state.requests.peek()?.get(path) !== taken)
+                    return;
+                this.#state.requests.mutate((map) => {
+                    map?.delete(path);
+                });
+                taken.answer?.close();
+                taken.answer = undefined;
+                taken.route.set(undefined);
+                this.#state.releaseMaterialized(path);
+            });
+        });
+    }
+    /**
+     * The announced routes matching `scope`, as a live map from covered prefix to route.
+     * Local broadcasts appear once announced; received and dynamic routes retain their
+     * advertised prefixes. Reads are synchronous, and the getter needs no teardown.
+     * Hidden routes are left out unless `options.hidden` opts in (see {@link announce.Options}).
+     * Unscoped readers share one snapshot; each distinct scope filters the table on changes.
+     */
+    broadcasts(scope, options) {
+        const hidden = options?.hidden ?? false;
+        if (!scope && this.#scope === Scope.all)
+            return hidden ? this.#state.available : this.#state.visible;
+        const patterns = this.#scope.patterns(scope);
+        return new Derived([this.#state.available], () => {
+            const routes = new Map();
+            for (const [path, entry] of this.#listed(patterns, hidden))
+                routes.set(path, entry.route);
+            return routes;
+        });
+    }
+    /**
+     * The announced routes matching `scope`, as a live stream: every currently advertised
+     * route arrives first as active, then additions and retractions as they happen.
+     * Any pattern is accepted. A local broadcast appears once it announces, exactly as a
+     * peer sees it. A dynamic or received route announces the prefix it covers when its
+     * subtree overlaps the scope. The stream ends when the origin closes or the consumer is
+     * closed. Hidden routes are left out unless `options.hidden` opts in (see {@link announce.Options}).
+     */
+    announced(scope = Path.Pattern.all(), options) {
+        const producer = new announce.Producer();
+        void this.#runAnnounced(producer, this.#scope.patterns(scope), options?.hidden ?? false);
+        return producer.consume();
+    }
+    /** One snapshot shared by map readers and announcement-stream diffing. */
+    #listed(patterns, hidden) {
+        const next = new Map();
+        const covering = new CoveringRoot(this.#scope.root);
+        const scopes = [...patterns]
+            .sort((a, b) => Path.compareSpecificity(b.specificity(), a.specificity()))
+            .map((pattern) => ({ pattern, head: scopeHead(pattern) }));
+        for (const [path, candidates] of this.#state.snapshot().candidates) {
+            // The first candidate this reader can see wins, since the preferred one overall may not be.
+            let entry;
+            let scope;
+            for (const candidate of candidates) {
+                scope = scopes.find(({ pattern, head }) => (candidate.exact ? pattern.matches(path) : advertOverlaps(candidate, path, pattern)) &&
+                    (hidden || !hiddenBelow(head, path)));
+                if (scope) {
+                    entry = candidate;
+                    break;
+                }
+            }
+            if (!entry || !scope)
+                continue;
+            const relative = covering.relative(path);
+            if (relative === undefined)
+                continue;
+            next.set(relative, {
+                identity: entry.identity,
+                route: entry.route,
+                captures: scopeCaptures(scope.pattern, path),
+            });
+        }
+        return next;
+    }
+    async #runAnnounced(producer, patterns, hidden) {
+        // Keyed by the presented path (from the origin, not the scope), valued by identity
+        // plus route. Diffing identity rather than mere presence means a republish emits a
+        // retraction then a fresh announcement; a re-price of the same identity emits an
+        // update.
+        let active = new Map();
+        try {
+            for (;;) {
+                const local = this.#state.local.peek();
+                const advertisedLocal = this.#state.advertisedLocal.peek();
+                const routes = this.#state.routes.peek();
+                if (local === undefined && advertisedLocal === undefined && routes === undefined)
+                    break;
+                const next = this.#listed(patterns, hidden);
+                for (const [path, snap] of active) {
+                    const cur = next.get(path);
+                    if (!cur || cur.identity !== snap.identity)
+                        producer.append({
+                            prefix: path,
+                            captures: snap.captures,
+                            kind: "retracted",
+                            route: snap.route,
+                        });
+                }
+                for (const [path, snap] of next) {
+                    const prev = active.get(path);
+                    if (!prev || prev.identity !== snap.identity) {
+                        producer.append({
+                            prefix: path,
+                            captures: snap.captures,
+                            kind: "announced",
+                            route: snap.route,
+                        });
+                    }
+                    else if (!routesEqual(prev.route, snap.route)) {
+                        producer.append({ prefix: path, captures: snap.captures, kind: "updated", route: snap.route });
+                    }
+                }
+                active = next;
+                await Signal.race(this.#state.local, this.#state.advertisedLocal, this.#state.routes, producer.closed);
+                if (producer.closed.peek() !== undefined)
+                    return;
+            }
+        }
+        catch {
+            // The reader closed between the check and an append; nothing left to do.
+        }
+        producer.close();
+    }
+    /**
+     * The local table, borrowed by the wire publishers to answer subscribes.
+     *
+     * Deliberately excludes received routes: a session never re-announces what a peer
+     * told it, so an origin wired to both directions of a connection cannot echo.
+     * Borrowed, not owned: do not close the fronts. Undefined once the origin closes.
+     *
+     * @internal
+     */
+    /**
+     * Originated advertisements a session should forward: exact-path announces plus
+     * originated dynamics. Undefined once the origin closes.
+     *
+     * @internal
+     */
+    /**
+     * The announced local broadcast at `path`, when it beats the originated routes there.
+     * Resolves through what rebuildOriginated advertised: a peer never sees received routes.
+     */
+    #local(path) {
+        const local = this.#state.local.peek()?.get(path);
+        if (local && this.#state.localWins(path, this.#state.bestEntry(path, received)))
+            return local;
+        return undefined;
+    }
+    /**
+     * Resolve `path` for serving: an announced local broadcast, or wait for an originated
+     * dynamic to accept it. Undefined when nothing here can serve the path.
+     *
+     * @internal
+     */
+    async #demand(path) {
+        const local = this.#local(path);
+        if (local)
+            return local;
+        const entry = this.#state.bestEntry(path, received);
+        if (!entry?.server)
+            return undefined;
+        const server = entry.server;
+        const live = server.served.get(path);
+        if (live && live.closed.peek() === undefined)
+            return live;
+        server.enqueue(path);
+        server.demanding.set(path, (server.demanding.get(path) ?? 0) + 1);
+        try {
+            for (;;) {
+                const served = server.served.get(path);
+                if (served && served.closed.peek() === undefined)
+                    return served;
+                const rejected = server.rejected.get(path);
+                if (rejected) {
+                    server.rejected.delete(path);
+                    throw rejected;
+                }
+                const closed = server.closed.peek();
+                if (closed !== undefined) {
+                    if (closed)
+                        throw closed;
+                    return undefined;
+                }
+                if (!server.pending.has(path))
+                    return undefined;
+                await Signal.race(server.settled, server.closed);
+            }
+        }
+        finally {
+            const n = (server.demanding.get(path) ?? 1) - 1;
+            if (n <= 0)
+                server.demanding.delete(path);
+            else
+                server.demanding.set(path, n);
+        }
+    }
+}
 /**
- * Maximum length of a hop chain. Must match `MAX_HOPS` in Rust's `model/origin.rs`.
+ * A served route from {@link Producer.dynamic}: advertises a prefix and answers the
+ * requests beneath it.
+ *
+ * Drop it (or {@link close}) to retract the route and reject anything still waiting
+ * with {@link StreamCode.NoCapacity}. {@link update} re-prices it in place.
  *
- * Broadcasts with longer chains are rejected, which bounds loop detection and rejects
- * pathological announcements across clusters with unbounded forwarding.
+ * @public
  */
-export const MAX_HOPS = 32;
+export class Dynamic {
+    /** The prefix this handle advertises. */
+    prefix;
+    #entry;
+    #state;
+    #retract;
+    #closed = false;
+    constructor(prefix, entry, state, retract) {
+        this.prefix = Path.stripPrefix(entry.scope.root, prefix) ?? Path.empty();
+        this.#entry = entry;
+        this.#state = state;
+        this.#retract = retract;
+    }
+    static {
+        makeDynamic = (prefix, entry, state, retract) => new Dynamic(prefix, entry, state, retract);
+    }
+    /** Re-price the route in place. The prefix is fixed at announce time. */
+    update(route) {
+        if (this.#closed)
+            throw new Error("dynamic is closed");
+        this.#entry.route.set(Route.normalize(route));
+        this.#state.rebuildOriginated();
+        this.#state.refreshPrefix(Path.join(this.#entry.scope.root, this.prefix));
+        this.#state.routes.mutate(() => { });
+    }
+    /** Retract the route and reject anything still waiting. Idempotent. */
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.#retract();
+    }
+    /** Requests under this prefix, as they arrive, each to {@link Request.accept} or reject. */
+    async *requested() {
+        const server = this.#entry.server;
+        if (!server)
+            return;
+        let current;
+        const drop = () => {
+            current?.reject(noCapacity());
+            current = undefined;
+        };
+        try {
+            for (;;) {
+                const next = server.queue.peek()[0];
+                if (next) {
+                    drop();
+                    server.queue.mutate((queue) => {
+                        queue.shift();
+                    });
+                    current = next;
+                    yield next;
+                    continue;
+                }
+                if (server.closed.peek() !== undefined)
+                    return;
+                await Signal.race(server.queue, server.closed);
+            }
+        }
+        finally {
+            drop();
+        }
+    }
+}
 /**
- * Generate a fresh origin with a random non-zero id.
+ * A pending request for a broadcast to be served on demand.
  *
- * `crypto.getRandomValues` is overkill for best-effort loop detection, but
- * used for slightly better distribution than `Math.random` at negligible cost.
+ * Yielded by {@link Dynamic.requested}. {@link accept} resolves it with a live
+ * broadcast; {@link reject} resolves it with an error. Advancing the iterator or
+ * closing it without either rejects the request.
  *
- * TEMPORARY: the wire format allows 62 bits, but older `@moq/lite` JS clients
- * decode `AnnounceInterest.exclude_hop` as a u53 (number) and throw on anything
- * > 2^53-1. To keep those clients alive against fresh peers, we cap the random
- * id at 53 bits. Restore to 62 bits once the u62 fix has propagated to deployed
- * bundles. Mirrors `Origin::random` in rs/moq-net.
+ * @public
  */
-export function randomOrigin() {
-    const buf = new BigUint64Array(1);
-    crypto.getRandomValues(buf);
-    // Mask to 53 bits.
-    const raw = buf[0] & 0x1fffffffffffffn;
-    // Guard against the (astronomically unlikely) zero draw.
-    return OriginSchema.parse(raw === 0n ? 1n : raw);
+export class Request {
+    /** The path that was requested. */
+    path;
+    #server;
+    #done = false;
+    constructor(path, server) {
+        this.path = path;
+        this.#server = server;
+    }
+    static {
+        makeRequest = (path, server) => new Request(path, server);
+        finishRequest = (request, err) => {
+            request.#done = true;
+            void err;
+        };
+    }
+    /**
+     * Accept the request, resolving every awaiting requester with `broadcast`.
+     *
+     * The caller keeps producing into `broadcast`; repeat requests for the path share
+     * it for as long as it stays live.
+     */
+    accept(source) {
+        if (this.#done)
+            return;
+        this.#done = true;
+        const front = source instanceof broadcast.Producer ? source.consume() : source;
+        this.#server.accept(this, front);
+    }
+    /** Reject the request, resolving every awaiting requester with `err`. */
+    reject(err) {
+        if (this.#done)
+            return;
+        this.#done = true;
+        this.#server.reject(this, err);
+    }
 }
 //# sourceMappingURL=origin.js.map