@norskvideo/moq-net 0.1.8 → 0.2.0

package/track.d.ts

@@ -6,10 +6,10 @@
 import { type GetPromise, type Getter } from "@norskvideo/moq-signals";
 import type { Datagram } from "./datagram";
 import { type Frame, type Consumer as GroupConsumer, Producer as GroupProducer } from "./group";
-import { Timescale, type Timestamp } from "./time";
+import { Milli, Timescale, type Timestamp } from "./time";
 export type { Datagram } from "./datagram";
-/** Default {@link Info.latencyMax} window (milliseconds) when the publisher does not set one. */
-export declare const DEFAULT_LATENCY_MAX_MS = 5000;
+/** Default {@link Info.maxAge} window (milliseconds) when the publisher does not set one. */
+export declare const DEFAULT_MAX_AGE_MS: Milli;
 /** A position within a track: a group's sequence and a frame's index inside it. */
 export interface Location {
     /** The group's sequence number within the track. */
@@ -32,39 +32,59 @@ export interface Info {
      */
     timescale: Timescale;
     /**
-     * Publisher Max Latency: the maximum age (milliseconds) of a non-latest group before
+     * Publisher Max Age: the maximum age (milliseconds) of a non-latest group before
      * the publisher evicts it. Reported in TRACK_INFO (Lite05+) so relays re-serve with the
      * same bound. The publisher-side half of the budget a subscriber sets for itself.
+     * Rounded up to a whole millisecond by {@link infoDefaults}, which refuses a negative
+     * or non-finite value and a result past `Number.MAX_SAFE_INTEGER`.
      */
-    latencyMax: number;
-    /** Tie-break priority between subscriptions of equal subscriber priority. */
+    maxAge: Milli;
+    /** Tie-break priority between subscriptions of equal subscriber priority (`0..=255`, higher first). Defaults to `127`. */
     priority: number;
-    /**
-     * Whether groups are prioritized in sequence order. Groups may always arrive
-     * out-of-order (or not at all) over the network. Defaults to `false` (newest-first).
-     */
-    ordered: boolean;
 }
 /** Fill in any unset {@link Info} fields with their defaults. */
 export declare function infoDefaults(info?: Partial<Info>): Info;
+/** An explicitly included or excluded group sequence. */
+export type Bound = {
+    included: number;
+    excluded?: never;
+} | {
+    excluded: number;
+    included?: never;
+};
+/** Group limits; an omitted endpoint is unbounded. */
+export interface Groups {
+    /** The first group boundary. */
+    start?: Bound;
+    /** The last group boundary. */
+    end?: Bound;
+}
 /**
  * Per-subscription options, requested when a subscription opens and adjustable later via
  * {@link Subscriber.update}. Mirrors the Rust `Subscription`.
  */
 export interface Subscription {
-    /** Delivery priority relative to this session's other subscriptions. Defaults to `0`. */
+    /** Delivery priority relative to this session's other subscriptions (`0..=255`). Defaults to `0`. */
     priority?: number;
-    /** Whether groups are prioritized in sequence order. Defaults to `false` (newest-first). */
-    ordered?: boolean;
-    /** Maximum age (milliseconds) of a non-latest group before it is skipped. Defaults to `0`. */
-    latencyMax?: number;
-    /** First group the publisher should deliver, or omit to start at the latest group. */
-    startGroup?: number;
-    /** Last group the publisher should deliver (inclusive), or omit for no end. */
-    endGroup?: number;
+    /**
+     * Maximum age (milliseconds) of a non-latest group before it is skipped. Defaults to `0`.
+     * Rounded up to a whole millisecond, so a value derived from a measurement is never
+     * shortened. A negative or non-finite value, or one past `Number.MAX_SAFE_INTEGER`
+     * after rounding, is refused.
+     */
+    maxAge?: Milli;
+    /**
+     * The lowest group the publisher may deliver (a floor), or omit for none.
+     *
+     * A floor, not a request: only {@link maxAge} asks for data, and the floor bounds how
+     * far back it may reach. Omitting it and a floor of 0 mean the same thing, and a floor
+     * above the live edge simply waits there (a resumed subscription naming where it left
+     * off).
+     */
+    groups?: Groups;
 }
 /**
- * A request for a track the peer wants, yielded by `Broadcast.Producer.requested`.
+ * A request for a track the peer wants, delivered to the publishing wire layer.
  *
  * Created internally by the broadcast when a subscription (or info lookup) needs a track
  * served; answer it with {@link accept} or {@link reject}.
@@ -89,21 +109,13 @@ export declare class Request {
 export interface FetchGroupOptions {
     /** Delivery priority for the fetch stream. Defaults to `0`. */
     priority?: number;
-}
-/**
- * The per-track operations a lazy {@link Consumer} delegates to the broadcast it came from.
- *
- * Implemented by `broadcast.Producer` / `broadcast.Consumer` (and the wire-layer subclasses
- * that resolve them over the network), so a track handle holds a reference to its broadcast
- * and calls methods on it rather than capturing a bag of callbacks.
- */
-export interface Broadcast {
-    /** Open a live subscription to the named track. */
-    subscribe(name: string, options?: Subscription): Subscriber;
-    /** Resolve the named track's immutable info. */
-    resolveTrackInfo(name: string): Promise<Info>;
-    /** Fetch a single group of the named track by sequence. */
-    fetchGroup(name: string, sequence: number, options?: FetchGroupOptions): Promise<GroupConsumer>;
+    /**
+     * Abandons this fetch, rejecting with the signal's reason. Concurrent fetches of the same
+     * group share one stream, cancelled only once every caller has left. An already-aborted
+     * signal rejects before anything is sent, and aborting after the group resolves has no
+     * effect; close the group instead.
+     */
+    signal?: AbortSignal;
 }
 /**
  * A lazy handle to a track on a consumed broadcast.
@@ -114,8 +126,15 @@ export declare class Consumer {
     #private;
     /** The track name. */
     readonly name: string;
-    constructor(name: string, broadcast: Broadcast);
-    /** Open a live subscription to the track. */
+    private constructor();
+    /**
+     * Open a live subscription to the track.
+     *
+     * The cursor starts at the group the subscription named (its floor), or 0.
+     * {@link Subscription.maxAge} is what asks for data: delivery skips everything above
+     * the floor that the budget convicts, so the default budget of zero delivers only the
+     * latest group and a larger one reaches back over what it can still use.
+     */
     subscribe(options?: Subscription): Subscriber;
     /** Fetch the track's immutable publisher properties without subscribing. */
     info(): Promise<Info>;
@@ -129,7 +148,7 @@ export declare class Consumer {
  * subscription the publisher serves from it) gets an independent
  * {@link Subscriber} that receives a full copy of the groups, each with its own
  * read cursor. Groups are mirrored into every live subscriber and retained for the
- * track's `latencyMax` window so a late subscriber replays the recent groups.
+ * track's `maxAge` window so a late subscriber replays the recent groups.
  *
  * Obtained from {@link Request.accept} (the wire asks the application for a track to
  * serve) or constructed directly for an in-process track.
@@ -144,6 +163,13 @@ export declare class Producer {
      * Rejects if the track is closed before the properties are known.
      */
     info(): Promise<Info>;
+    /**
+     * Publisher priority from the committed {@link Info}, or the default before {@link accept}.
+     *
+     * Higher is served first. Hang publishers set this from `Catalog.PRIORITY` so
+     * audio outranks video on the wire and in the bandwidth allocator.
+     */
+    get priority(): number;
     /**
      * Settles once the track closes: `null` on a clean close, or the abort {@link Error}.
      * Peek it synchronously (`undefined` while open), observe it reactively, or `await` it.
@@ -156,7 +182,14 @@ export declare class Producer {
     get subscription(): Getter<Subscription | undefined>;
     /** Commit the immutable publisher properties, resolving {@link info}. Returns `this`. */
     accept(info?: Partial<Info>): this;
-    /** An independent {@link Subscriber} receiving a full copy of this track's groups. */
+    /**
+     * An independent {@link Subscriber} reading this track's groups.
+     *
+     * Its cursor starts at the group the subscription named (its floor), or 0.
+     * {@link Subscription.maxAge} is what asks for data: delivery skips everything above
+     * the floor that the budget convicts, so the default budget of zero delivers only the
+     * latest group and a larger one reaches back over what it can still use.
+     */
     subscribe(options?: Subscription): Subscriber;
     /**
      * Whether the track currently has any subscribers.
@@ -189,18 +222,38 @@ export declare class Producer {
      * keep datagram payloads small (e.g. a single audio frame). Datagrams are never delivered
      * over IETF moq-transport or stream-only transports (the WebSocket fallback). A payload over
      * 65535 bytes (the QUIC datagram frame ceiling) throws. An origin publisher uses this; a
-     * relay preserving upstream numbering uses {@link writeDatagram}.
+     * relay preserving upstream numbering uses {@link insertDatagram}.
      */
     appendDatagram(timestamp: Timestamp, payload: Uint8Array): number;
     /**
-     * Write a datagram with an explicit sequence number.
+     * Insert a datagram with an explicit sequence number.
      *
      * Preserves the supplied sequence (advancing the shared counter if needed) so a relay can
      * forward a datagram without renumbering it. The size limits of {@link appendDatagram}
      * apply. Most origin publishers want {@link appendDatagram} instead.
      */
-    writeDatagram(datagram: Datagram): void;
-    /** Close the track and every subscriber, mirroring the abort to their groups. Idempotent. */
+    insertDatagram(sequence: number, timestamp: Timestamp, payload: Uint8Array): void;
+    /**
+     * Declare the track's exclusive end, possibly ahead of the live edge, mirroring the Rust
+     * `finish_at`.
+     *
+     * `final` is the first sequence that will never be produced, so a track whose last group
+     * is 89 finishes at 90. Groups and datagrams below it are still accepted; anything at or
+     * above it is refused. Unlike {@link close} it is not terminal: call `close()` once the
+     * remaining groups are written. Throws if the track is closed, already has an end, or
+     * `final` is at or below a sequence already produced.
+     */
+    finishAt(final: number): void;
+    /**
+     * Close the track and every subscriber, mirroring the abort to their groups. Idempotent.
+     *
+     * A clean close keeps the end {@link finishAt} declared, or declares one past the highest
+     * sequence produced; an abort ends without one. Subscribers still draining get the
+     * finished groups first, then the end or the abort. An abort after the declared end
+     * settled (reached, with every group below it finished) is a clean close. The groups
+     * left behind still age out after the track's `maxAge`, so a stale subscriber can't pin
+     * them.
+     */
     close(abort?: Error): void;
     /** Append a frame as its own single-frame group. */
     writeFrame(frame: Frame): void;
@@ -237,6 +290,23 @@ export declare class Subscriber {
     get subscription(): Getter<Subscription | undefined>;
     /** Return the latest group sequence observed on this track, if any. */
     latest(): number | undefined;
+    /**
+     * The track's exclusive final boundary: the end {@link Producer.finishAt} declared, which
+     * can be ahead of the live edge, or one past the highest sequence produced once the
+     * producer closes cleanly (0 for a track that produced none). Groups and datagrams share
+     * the sequence namespace, so this can exceed `latest() + 1`. Undefined until declared,
+     * and after an abort that declared none.
+     */
+    final(): number | undefined;
+    /**
+     * Resolve with the track's exclusive final boundary once it is known, mirroring the Rust
+     * `finished`.
+     *
+     * Resolves as soon as the end is declared, which may be ahead of the live edge, so it
+     * says nothing about every group having arrived: read until the cursor returns
+     * `undefined` for that. Rejects with the abort, or if the track closes without an end.
+     */
+    finished(): Promise<number>;
     /**
      * The newest frame this track has produced, or `undefined` while it has none.
      *
@@ -246,39 +316,33 @@ export declare class Subscriber {
      * left can no longer say where the edge is.
      */
     largest(): Location | undefined;
+    /** Limit subsequent reads to these groups and return this reader for chaining. */
+    withGroups(groups: Groups): this;
     /**
-     * An independent subscriber to the same track, with its own cursor and its own replay of
-     * the retained window.
-     *
-     * Reads here do not consume anything this one would deliver, which is what lets a
-     * publisher read the cache alongside the cursor it is serving from. Resolving the track
-     * again through the broadcast would not do: a dynamic serve is one request per peer
-     * subscription, so that mints a second producer the application has to answer separately.
-     *
-     * @internal Wire layers only.
-     */
-    fork(options?: Subscription): Subscriber;
-    /** Start this subscriber's local read cursor at `sequence`, without changing its wire request. */
-    startAt(sequence: number): void;
-    /**
-     * Cap {@link nextGroup} and {@link recvGroup} at `sequence` inclusively, or omit it to
-     * remove the cap. Groups above the cap remain buffered and become readable if the cap
-     * is raised. This local cursor does not change the subscription's wire request.
+     * Limit subsequent reads without rewinding read progress or changing the wire request.
+     * An omitted start preserves the current floor; an omitted end removes the cap.
+     * Raising the end makes unread buffered groups available again.
      */
-    endAt(sequence?: number): void;
+    setGroups(groups: Groups): void;
     /** Close the track (optionally with an error), closing any pending groups. Idempotent. */
     close(abort?: Error): void;
     /**
      * Receive every group on this track exactly once, as it becomes available.
      *
      * Groups may arrive out of order or with gaps due to network conditions; unlike
-     * {@link nextGroup}, one that arrives after a newer group was already returned is
-     * still delivered. When several groups are buffered, the lowest sequence is
+     * {@link Ordered.nextGroup}, one that arrives after a newer group was already returned
+     * is still delivered. When several groups are buffered, the lowest sequence is
      * returned first.
      *
-     * Honors the floor set by {@link startAt} and the cap set by {@link endAt}: a group
+     * Honors the range set by {@link setGroups}: a group
      * beyond the cap stays buffered (not dropped) and is offered once the cap rises, even
      * after a clean close, without blocking in-range groups that arrive behind it.
+     * A group whose presentation time is further behind the live edge than this
+     * subscriber's `maxAge` is skipped. The default of zero takes the live edge.
+     * The budget remains attached after return, so a pending frame read rejects if a stalled
+     * group becomes stale while newer data advances.
+     *
+     * The first call commits this track to arrival order: {@link ordered} throws afterwards.
      */
     recvGroup(): Promise<GroupConsumer | undefined>;
     /**
@@ -287,7 +351,7 @@ export declare class Subscriber {
      *
      * Returns `undefined` when nothing is deliverable right now, which is not by itself the
      * end of the track: a group may still arrive, or one may be parked beyond the
-     * {@link endAt} cap. Use it to drain what the retained window already holds, where
+     * {@link setGroups} cap. Use it to drain what the retained window already holds, where
      * waiting for a sequence nothing will republish would park forever.
      */
     tryRecvGroup(): GroupConsumer | undefined;
@@ -297,40 +361,104 @@ export declare class Subscriber {
      * Datagrams are a separate best-effort channel from groups (see
      * {@link Producer.appendDatagram}); they share only the sequence namespace. A consumer
      * that falls too far behind silently loses the oldest datagrams. Read this alongside
-     * {@link recvGroup} (e.g. in a separate loop) to receive both channels concurrently. Returning
-     * a datagram advances {@link nextGroup} past that sequence.
+     * {@link recvGroup} (e.g. in a separate loop) to receive both channels concurrently.
+     * The two cursors are independent: a datagram never moves the group cursor.
      */
     recvDatagram(): Promise<Datagram | undefined>;
     /**
-     * Return the next group with a strictly-greater sequence number than the last returned.
+     * Read this track's groups in sequence order instead of arrival order.
+     *
+     * Both cursors draw from the same buffer, so a track is read one way or the other: this
+     * hands the subscription to the returned {@link Ordered} and leaves this handle inert.
+     * {@link recvGroup} and {@link recvDatagram} throw afterwards. Throws once a
+     * {@link recvGroup} call has already committed the track to arrival order.
      *
-     * Late arrivals (sequence at or below the last returned) are silently skipped.
-     * Use {@link recvGroup} to see every group in arrival order instead.
+     * Datagrams come along: they are a separate cursor either way, so the choice of group
+     * order says nothing about them, and reading them commits nothing.
      */
-    nextGroup(): Promise<GroupConsumer | undefined>;
+    ordered(): Ordered;
     /**
-     * Reads the next frame across all groups, discarding older groups.
-     * Treat the returned frame bytes as read-only; they are shared with other consumers.
+     * Update this subscription's options (e.g. priority), triggering a SUBSCRIBE_UPDATE to the
+     * publisher. Mirrors the Rust `Subscriber::update`.
      */
-    readFrame(): Promise<Frame | undefined>;
+    update(options: Subscription): void;
+}
+/**
+ * A {@link Subscriber} that reads groups in sequence order.
+ *
+ * Created by {@link Subscriber.ordered}, which takes the subscription over: the two
+ * cursors draw from one buffer, so a track is read one way or the other and never both.
+ * Every group this returns has a higher sequence than the last, so a late arrival is
+ * skipped rather than delivered out of turn.
+ *
+ * `maxAge` applies as this cursor reads, exactly as it does on the arrival cursor: a
+ * group is skipped once its reach, where its immediate successor begins, is that far
+ * behind the newest frame on the track. Nothing weaker convicts it, since the reach is
+ * the only proof that every frame it could still hold is past the budget, so a backlog
+ * inside the budget is still delivered whole, as a burst in order. The budget follows a
+ * group already handed out too: a stalled group's pending frame read rejects once newer
+ * content has pulled that far ahead.
+ */
+export declare class Ordered {
+    #private;
+    /** The track name. */
+    readonly name: string;
+    private constructor();
+    /** Resolve this track's immutable publisher properties; see {@link Subscriber.info}. */
+    info(): Promise<Info>;
+    /** Settles once the track closes; see {@link Producer.closed}. */
+    get closed(): GetPromise<Error | null>;
+    /** This subscriber's current options, including defaults and the last {@link update}. */
+    get subscription(): Getter<Subscription | undefined>;
+    /** The latest group sequence observed on this track, if any. */
+    latest(): number | undefined;
+    /** The track's exclusive final boundary; see {@link Subscriber.final}. */
+    final(): number | undefined;
+    /** Resolve with the track's exclusive final boundary once known; see {@link Subscriber.finished}. */
+    finished(): Promise<number>;
+    /** Limit subsequent reads to these groups and return this reader for chaining. */
+    withGroups(groups: Groups): this;
+    /** Limit subsequent reads to these groups; see {@link Subscriber.setGroups}. */
+    setGroups(groups: Groups): void;
+    /** Update this subscription's options; see {@link Subscriber.update}. */
+    update(options: Subscription): void;
+    /** Close the track (optionally with an error), closing any pending groups. Idempotent. */
+    close(abort?: Error): void;
     /**
-     * Reads the next frame along with its group and frame sequence numbers.
+     * Return the next group with a strictly-greater sequence number than the last returned.
+     *
+     * Late arrivals (sequence at or below the last returned) are silently skipped, as is a
+     * group whose every frame is further behind the live edge than `maxAge` (the default of
+     * zero keeps only what nothing newer has superseded). Honors the bounds set by
+     * {@link setGroups}.
+     */
+    nextGroup(): Promise<GroupConsumer | undefined>;
+    /**
+     * Read the next frame across groups, in sequence order, with its group and frame numbers.
+     *
+     * Rides the same cursor as {@link nextGroup} and shares this handle's contract: a
+     * buffered backlog is drained in full up to the point `maxAge` proves it useless.
      * Treat the returned frame bytes as read-only; they are shared with other consumers.
      */
-    readFrameSequence(): Promise<({
+    readFrame(): Promise<({
         group: number;
         frame: number;
     } & Frame) | undefined>;
-    /** Reads the next frame and decodes it as a UTF-8 string. */
+    /** Read the next frame and decode it as a UTF-8 string. */
     readString(): Promise<string | undefined>;
-    /** Reads the next frame and parses it as JSON. */
+    /** Read the next frame and parse it as JSON. */
     readJson(): Promise<unknown | undefined>;
-    /** Reads the next frame and decodes it as a one-byte boolean, throwing on a malformed frame. */
+    /** Read the next frame and decode it as a one-byte boolean, throwing on a malformed frame. */
     readBool(): Promise<boolean | undefined>;
     /**
-     * Update this subscription's options (e.g. priority), triggering a SUBSCRIBE_UPDATE to the
-     * publisher. Mirrors the Rust `Subscriber::update`.
+     * Receive the next datagram in arrival order.
+     *
+     * Datagrams are a separate best-effort channel from groups (see
+     * {@link Producer.appendDatagram}); they share only the sequence namespace, and
+     * neither cursor moves the other. Unordered by construction, so this behaves
+     * identically on either handle; it is here so a track carrying both channels needs
+     * one subscription rather than two.
      */
-    update(options: Subscription): void;
+    recvDatagram(): Promise<Datagram | undefined>;
 }
 //# sourceMappingURL=track.d.ts.map

package/track.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"track.d.ts","sourceRoot":"","sources":["../src/track.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"track.d.ts","sourceRoot":"","sources":["../src/track.ts"],"names":[],"mappings":"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"}