moqtail 0.8.1 → 0.10.0

package/dist/{client/index.d.ts → client.d.ts}

@@ -1,5 +1,5 @@
-import { n as MoqtObject, L as Location, m as FullTrackName, f as ObjectForwardingPreference, K as KeyValuePair, D as DatagramObject, h as DatagramStatus, c as Tuple, o as SubgroupObject, j as FetchObject } from '../byte_buffer-BM4uNj4n.js';
-import { w as ControlMessage, S as Subscribe, q as PublishDoneStatusCode, V as SubscribeUpdate, x as Fetch, L as Publish, b as PublishNamespaceOk, a as PublishNamespaceError, P as PublishNamespace, A as FetchOk, z as FetchError, U as SubscribeOk, Q as SubscribeError, J as SubscribeNamespaceOk, I as SubscribeNamespaceError, H as SubscribeNamespace, O as PublishOk, N as PublishError, a5 as SetupParameters, G as GroupOrder, F as FilterType, a7 as VersionSpecificParameters, h as FetchType, a2 as RequestIdMap, Z as PublishNamespaceDone, B as GoAway, a1 as SubgroupHeader, a0 as FetchHeader, E as ServerSetup, c as PublishNamespaceCancel, $ as UnsubscribeNamespace, a3 as Header } from '../version_parameter-f75NkWiO.js';
+import { c as ControlMessage, U as MoqtObject, y as Location, u as FullTrackName, _ as ObjectForwardingPreference, au as TrackExtension, ao as Subscribe, a4 as PublishDoneStatusCode, ae as RequestUpdate, F as Fetch, a2 as Publish, ad as RequestOk, aa as RequestError, a5 as PublishNamespace, p as FetchOk, aq as SubscribeOk, R as MessageParameter, ap as SubscribeNamespace, a8 as PublishOk, v as GroupOrder, q as FetchType, ak as SetupParameters, D as Datagram, r as FilterType, ay as Tuple, ac as RequestIdMap, a7 as PublishNamespaceDone, G as GoAway, an as SubgroupObject, al as SubgroupHeader, n as FetchObject, l as FetchHeader, a3 as PublishDone, ah as ServerSetup, a6 as PublishNamespaceCancel, X as NamespaceSubscribeOptions, aC as UnsubscribeNamespace, aw as TrackStatus, H as Header } from './setup_parameter-BOeGq6Mv.js';
+import { L as LogLevel } from './logger-C6QS408Z.js';
 
 /**
  * Copyright 2025 The MOQtail Authors
@@ -171,7 +171,7 @@ declare class LiveTrackSource implements LiveObjectSource {
     readonly stream: ReadableStream<MoqtObject>;
     constructor(stream: ReadableStream<MoqtObject>);
     get largestLocation(): Location | undefined;
-    onNewObject(listener: (obj: MoqtObject) => void): () => void;
+    onNewObject(listener: (obj: MoqtObject) => Promise<void> | void): () => void;
     onDone(listener: () => void): () => void;
     stop(): void;
 }
@@ -261,6 +261,12 @@ type Track = {
      * Optional compact numeric alias assigned during protocol negotiation.
      */
     trackAlias?: bigint;
+    /**
+     * Track extensions advertised by the publisher.
+     * Set before calling `publish()` to include extensions in the PUBLISH message.
+     * Populated automatically on the subscriber side when SUBSCRIBE_OK or FETCH_OK is received.
+     */
+    trackExtensions?: TrackExtension[];
 };
 
 /**
@@ -313,10 +319,10 @@ declare class SubscribePublication {
      */
     done(statusCode: PublishDoneStatusCode): Promise<void>;
     /**
-     * Updates the subscription parameters and locations based on a SubscribeUpdate message.
-     * @param msg - The update message containing new subscription details.
+     * Updates the subscription parameters and locations based on a RequestUpdate message.
+     * @param msg - The update message containing new request details.
      */
-    update(msg: SubscribeUpdate): void;
+    update(msg: RequestUpdate): void;
     /**
      * Publishes MOQT objects to the subscriber as they become available.
      * Handles stream creation, object writing, and stream closure based on subscription parameters.
@@ -399,7 +405,7 @@ declare class PublishPublication {
 }
 
 /**
- * Copyright 2025 The MOQtail Authors
+ * Copyright 2026 The MOQtail Authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -414,18 +420,18 @@ declare class PublishPublication {
  * limitations under the License.
  */
 
-declare class PublishNamespaceRequest implements PromiseLike<PublishNamespaceOk | PublishNamespaceError> {
+declare class PublishNamespaceRequest implements PromiseLike<RequestOk | RequestError> {
     readonly requestId: bigint;
     readonly message: PublishNamespace;
     private _resolve;
     private _reject;
     private promise;
     constructor(requestId: bigint, message: PublishNamespace);
-    resolve(value: PublishNamespaceOk | PublishNamespaceError | PromiseLike<PublishNamespaceOk | PublishNamespaceError>): void;
+    resolve(value: RequestOk | RequestError | PromiseLike<RequestOk | RequestError>): void;
     reject(reason?: any): void;
-    then<TResult1 = PublishNamespaceOk | PublishNamespaceError, TResult2 = never>(onfulfilled?: ((value: PublishNamespaceOk | PublishNamespaceError) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<PublishNamespaceOk | PublishNamespaceError | TResult>;
-    finally(onfinally?: (() => void) | undefined | null): Promise<PublishNamespaceOk | PublishNamespaceError>;
+    then<TResult1 = RequestOk | RequestError, TResult2 = never>(onfulfilled?: ((value: RequestOk | RequestError) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<RequestOk | RequestError | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<RequestOk | RequestError>;
 }
 
 /**
@@ -444,7 +450,7 @@ declare class PublishNamespaceRequest implements PromiseLike<PublishNamespaceOk
  * limitations under the License.
  */
 
-declare class FetchRequest implements PromiseLike<FetchOk | FetchError> {
+declare class FetchRequest implements PromiseLike<FetchOk | RequestError> {
     readonly requestId: bigint;
     readonly message: Fetch;
     private _resolve;
@@ -455,11 +461,11 @@ declare class FetchRequest implements PromiseLike<FetchOk | FetchError> {
     isActive: boolean;
     isResolved: boolean;
     constructor(message: Fetch);
-    resolve(value: FetchOk | FetchError | PromiseLike<FetchOk | FetchError>): void;
+    resolve(value: FetchOk | RequestError | PromiseLike<FetchOk | RequestError>): void;
     reject(reason?: any): void;
-    then<TResult1 = FetchOk | FetchError, TResult2 = never>(onfulfilled?: ((value: FetchOk | FetchError) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<FetchOk | FetchError | TResult>;
-    finally(onfinally?: (() => void) | undefined | null): Promise<FetchOk | FetchError>;
+    then<TResult1 = FetchOk | RequestError, TResult2 = never>(onfulfilled?: ((value: FetchOk | RequestError) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<FetchOk | RequestError | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<FetchOk | RequestError>;
 }
 
 /**
@@ -478,7 +484,7 @@ declare class FetchRequest implements PromiseLike<FetchOk | FetchError> {
  * limitations under the License.
  */
 
-declare class SubscribeRequest implements PromiseLike<SubscribeOk | SubscribeError> {
+declare class SubscribeRequest implements PromiseLike<SubscribeOk | RequestError> {
     #private;
     requestId: bigint;
     fullTrackName: FullTrackName;
@@ -487,25 +493,25 @@ declare class SubscribeRequest implements PromiseLike<SubscribeOk | SubscribeErr
     endGroup: bigint | undefined;
     priority: number;
     forward: boolean;
-    subscribeParameters: KeyValuePair[];
+    subscribeParameters: MessageParameter[];
     largestLocation: Location | undefined;
     streamsAccepted: bigint;
     expectedStreams: bigint | undefined;
     readonly controller: ReadableStreamDefaultController<MoqtObject>;
     readonly stream: ReadableStream<MoqtObject>;
     constructor(msg: Subscribe);
-    update(msg: SubscribeUpdate): void;
-    switch(newTrackName: FullTrackName, newParameters: KeyValuePair[]): void;
+    update(msg: RequestUpdate): void;
+    switch(newTrackName: FullTrackName, newParameters: MessageParameter[]): void;
     unsubscribe(): void;
-    resolve(value: SubscribeOk | SubscribeError | PromiseLike<SubscribeOk | SubscribeError>): void;
+    resolve(value: SubscribeOk | RequestError | PromiseLike<SubscribeOk | RequestError>): void;
     reject(reason?: any): void;
-    then<TResult1 = SubscribeOk | SubscribeError, TResult2 = never>(onfulfilled?: ((value: SubscribeOk | SubscribeError) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<SubscribeOk | SubscribeError | TResult>;
-    finally(onfinally?: (() => void) | undefined | null): Promise<SubscribeOk | SubscribeError>;
+    then<TResult1 = SubscribeOk | RequestError, TResult2 = never>(onfulfilled?: ((value: SubscribeOk | RequestError) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<SubscribeOk | RequestError | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<SubscribeOk | RequestError>;
 }
 
 /**
- * Copyright 2025 The MOQtail Authors
+ * Copyright 2026 The MOQtail Authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -520,18 +526,18 @@ declare class SubscribeRequest implements PromiseLike<SubscribeOk | SubscribeErr
  * limitations under the License.
  */
 
-declare class SubscribeNamespaceRequest implements PromiseLike<SubscribeNamespaceOk | SubscribeNamespaceError> {
+declare class SubscribeNamespaceRequest implements PromiseLike<RequestOk | RequestError> {
     readonly requestId: bigint;
     readonly message: SubscribeNamespace;
     private _resolve;
     private _reject;
     private promise;
     constructor(msg: SubscribeNamespace);
-    resolve(value: SubscribeNamespaceOk | SubscribeNamespaceError | PromiseLike<SubscribeNamespaceOk | SubscribeNamespaceError>): void;
+    resolve(value: RequestOk | RequestError | PromiseLike<RequestOk | RequestError>): void;
     reject(reason?: any): void;
-    then<TResult1 = SubscribeNamespaceOk | SubscribeNamespaceError, TResult2 = never>(onfulfilled?: ((value: SubscribeNamespaceOk | SubscribeNamespaceError) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<SubscribeNamespaceOk | SubscribeNamespaceError | TResult>;
-    finally(onfinally?: (() => void) | undefined | null): Promise<SubscribeNamespaceOk | SubscribeNamespaceError>;
+    then<TResult1 = RequestOk | RequestError, TResult2 = never>(onfulfilled?: ((value: RequestOk | RequestError) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<RequestOk | RequestError | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<RequestOk | RequestError>;
 }
 
 /**
@@ -550,18 +556,18 @@ declare class SubscribeNamespaceRequest implements PromiseLike<SubscribeNamespac
  * limitations under the License.
  */
 
-declare class PublishRequest implements PromiseLike<PublishOk | PublishError> {
+declare class PublishRequest implements PromiseLike<PublishOk | RequestError> {
     readonly requestId: bigint;
     readonly message: Publish;
     private _resolve;
     private _reject;
     private promise;
     constructor(msg: Publish);
-    resolve(value: PublishOk | PublishError | PromiseLike<PublishOk | PublishError>): void;
+    resolve(value: PublishOk | RequestError | PromiseLike<PublishOk | RequestError>): void;
     reject(reason?: any): void;
-    then<TResult1 = PublishOk | PublishError, TResult2 = never>(onfulfilled?: ((value: PublishOk | PublishError) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<PublishOk | PublishError | TResult>;
-    finally(onfinally?: (() => void) | undefined | null): Promise<PublishOk | PublishError>;
+    then<TResult1 = PublishOk | RequestError, TResult2 = never>(onfulfilled?: ((value: PublishOk | RequestError) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<PublishOk | RequestError | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<PublishOk | RequestError>;
 }
 
 /**
@@ -641,12 +647,12 @@ type MOQtailRequest = PublishRequest | PublishNamespaceRequest | SubscribeNamesp
 type MOQtailClientOptions = {
     /** Relay / server endpoint for the underlying {@link https://developer.mozilla.org/docs/Web/API/WebTransport | WebTransport} session (can be absolute {@link https://developer.mozilla.org/en-US/docs/Web/API/URL | URL} or string).*/
     url: string | URL;
-    /** Ordered preference list of MOQT protocol version numbers (e.g. `0xff00000b`).   */
-    supportedVersions: number[];
     /**  {@link SetupParameters} customizations; if omitted a default instance is built.*/
     setupParameters?: SetupParameters;
     /**  Passed directly to the browser's {@link https://developer.mozilla.org/docs/Web/API/WebTransport | WebTransport} constructor for {@link https://developer.mozilla.org/docs/Web/API/WebTransportOptions | WebTransportOptions}. */
-    transportOptions?: WebTransportOptions;
+    transportOptions?: WebTransportOptions & {
+        protocols?: string[];
+    };
     /** Per *data* uni-stream idle timeout in milliseconds. */
     dataStreamTimeoutMs?: number;
     /** Control stream read timeout in milliseconds. */
@@ -662,9 +668,9 @@ type MOQtailClientOptions = {
         /** Fired once when the session ends (normal or error). Receives the reason passed to {@link MOQtailClient.disconnect | disconnect}. */
         onSessionTerminated?: (reason?: unknown) => void;
         /** Invoked for each decoded datagram object/status arriving. */
-        onDatagramReceived?: (data: DatagramObject | DatagramStatus) => void;
+        onDatagramReceived?: (data: Datagram) => void;
         /** Invoked after enqueuing each outbound datagram object/status. */
-        onDatagramSent?: (data: DatagramObject | DatagramStatus) => void;
+        onDatagramSent?: (data: Datagram) => void;
     };
 };
 /**
@@ -704,8 +710,8 @@ type SubscribeOptions = {
     forward: boolean;
     /** {@link FilterType} variant controlling starting subset (e.g. {@link FilterType.LatestObject}). */
     filterType: FilterType;
-    /** Optional extension {@link VersionSpecificParameters} appended to the SUBSCRIBE control message. */
-    parameters?: VersionSpecificParameters;
+    /** Optional extension parameters appended to the SUBSCRIBE control message. */
+    parameters?: MessageParameter[];
     /** Required for {@link FilterType.AbsoluteStart} / {@link FilterType.AbsoluteRange}; earliest {@link Location} to include. */
     startLocation?: Location;
     /** Required for {@link FilterType.AbsoluteRange}; exclusive upper group boundary (coerced to bigint if number provided). */
@@ -738,8 +744,8 @@ type SubscribeUpdateOptions = {
     priority: number;
     /** Updated direction flag. */
     forward: boolean;
-    /** Optional additional {@link VersionSpecificParameters}; existing parameters persist if omitted. */
-    parameters?: VersionSpecificParameters;
+    /** Optional additional parameters; existing parameters persist if omitted. */
+    parameters?: MessageParameter[];
 };
 /**
  * Parameters for {@link MOQtailClient.switch | switching} an existing SUBSCRIBE to a new track.
@@ -757,8 +763,8 @@ type SwitchOptions = {
     fullTrackName: FullTrackName;
     /** The original SUBSCRIBE request id (bigint) being updated. */
     subscriptionRequestId: bigint;
-    /** Optional additional {@link VersionSpecificParameters}; existing parameters persist if omitted. */
-    parameters?: VersionSpecificParameters;
+    /** Optional additional parameters; existing parameters persist if omitted. */
+    parameters?: MessageParameter[];
 };
 /**
  * Options for {@link MOQtailClient.fetch | performing a FETCH} operation for historical or relative object ranges.
@@ -769,7 +775,7 @@ type SwitchOptions = {
  *   priority: 64,
  *   groupOrder: GroupOrder.Original,
  *   typeAndProps: {
- *     type: FetchType.StandAlone,
+ *     type: FetchType.Standalone,
  *     props: { fullTrackName, startLocation, endLocation }
  *   }
  * })
@@ -800,12 +806,12 @@ type FetchOptions = {
     groupOrder: GroupOrder;
     /**
      * Discriminated union selecting the {@link FetchType} mode and its specific properties:
-     * - StandAlone: full explicit range on a {@link FullTrackName} with start/end {@link Location}s.
+     * - Standalone: full explicit range on a {@link FullTrackName} with start/end {@link Location}s.
      * - Relative / Absolute: join an existing {@link SubscribeRequest} (identified by `joiningRequestId`) with starting position `joiningStart`.
      */
     typeAndProps: {
         /** Standalone historical/segment fetch for a specific {@link FullTrackName}. */
-        type: FetchType.StandAlone;
+        type: FetchType.Standalone;
         /** Properties for standalone fetch: explicit track and range. */
         props: {
             fullTrackName: FullTrackName;
@@ -829,8 +835,8 @@ type FetchOptions = {
             joiningStart: bigint;
         };
     };
-    /** Optional {@link VersionSpecificParameters} block. */
-    parameters?: VersionSpecificParameters;
+    /** Optional parameters block. */
+    parameters?: MessageParameter[];
 };
 
 /**
@@ -861,8 +867,8 @@ type FetchOptions = {
  */
 declare class SendDatagramStream {
     #private;
-    readonly onDataSent?: (data: DatagramObject | DatagramStatus) => void;
-    constructor(writer: WritableStreamDefaultWriter<Uint8Array>, trackAlias: bigint, onDataSent?: (data: DatagramObject | DatagramStatus) => void);
+    readonly onDataSent?: (data: Datagram) => void;
+    constructor(writer: WritableStreamDefaultWriter<Uint8Array>, trackAlias: bigint, onDataSent?: (data: Datagram) => void);
     /**
      * Create a new datagram sender for a specific track.
      *
@@ -871,7 +877,7 @@ declare class SendDatagramStream {
      * @param onDataSent - Optional callback fired when datagram is sent
      * @returns SendDatagramStream instance
      */
-    static new(writeStream: WritableStream<Uint8Array>, trackAlias: bigint, onDataSent?: (data: DatagramObject | DatagramStatus) => void): Promise<SendDatagramStream>;
+    static new(writeStream: WritableStream<Uint8Array>, trackAlias: bigint, onDataSent?: (data: Datagram) => void): Promise<SendDatagramStream>;
     /**
      * Create a datagram sender using an existing shared writer.
      * Use this when multiple senders need to share a single writer.
@@ -881,13 +887,12 @@ declare class SendDatagramStream {
      * @param onDataSent - Optional callback fired when datagram is sent
      * @returns SendDatagramStream instance
      */
-    static fromWriter(writer: WritableStreamDefaultWriter<Uint8Array>, trackAlias: bigint, onDataSent?: (data: DatagramObject | DatagramStatus) => void): SendDatagramStream;
+    static fromWriter(writer: WritableStreamDefaultWriter<Uint8Array>, trackAlias: bigint, onDataSent?: (data: Datagram) => void): SendDatagramStream;
     /**
      * Write a MoqtObject as a datagram.
-     * Converts to DatagramObject or DatagramStatus automatically.
+     * Converts to Datagram automatically based on object state.
      *
      * @param object - MoqtObject to send (must have Datagram forwarding preference)
-     * @throws ProtocolViolationError if object is not datagram-compatible
      */
     write(object: MoqtObject): Promise<void>;
     /**
@@ -904,8 +909,7 @@ declare class SendDatagramStream {
  * Parallel to RecvStream but for datagram-based delivery.
  *
  * Automatically handles:
- * - DatagramObject parsing (objects with payloads)
- * - DatagramStatus parsing (status-only objects)
+ * - Datagram parsing (both payload and status datagrams)
  * - Track alias to full track name resolution
  *
  * @example
@@ -923,7 +927,7 @@ declare class SendDatagramStream {
 declare class RecvDatagramStream {
     #private;
     readonly stream: ReadableStream<MoqtObject>;
-    readonly onDataReceived?: (data: DatagramObject | DatagramStatus) => void;
+    readonly onDataReceived?: (data: Datagram) => void;
     private constructor();
     /**
      * Create a new datagram receiver.
@@ -933,7 +937,7 @@ declare class RecvDatagramStream {
      * @param onDataReceived - Optional callback fired when datagram is received
      * @returns RecvDatagramStream instance
      */
-    static new(readStream: ReadableStream<Uint8Array>, trackAliasResolver: (trackAlias: bigint) => FullTrackName, onDataReceived?: (data: DatagramObject | DatagramStatus) => void): Promise<RecvDatagramStream>;
+    static new(readStream: ReadableStream<Uint8Array>, trackAliasResolver: (trackAlias: bigint) => FullTrackName, onDataReceived?: (data: Datagram) => void): Promise<RecvDatagramStream>;
     /**
      * Cancel the datagram reader.
      */
@@ -944,6 +948,22 @@ declare class RecvDatagramStream {
     releaseLock(): void;
 }
 
+/**
+ * Copyright 2025 The MOQtail Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 /**
  * @public
  * Represents a Media Over QUIC Transport (MOQT) client session.
@@ -958,7 +978,7 @@ declare class RecvDatagramStream {
  *
  * ### Connect and Subscribe to a Track
  * ```ts
- * const client = await MOQtailClient.new({ url, supportedVersions: [0xff00000b] });
+ * const client = await MOQtailClient.new({ url });
  * const result = await client.subscribe({
  *   fullTrackName,
  *   filterType: FilterType.LatestObject,
@@ -966,7 +986,7 @@ declare class RecvDatagramStream {
  *   groupOrder: GroupOrder.Original,
  *   priority: 0
  * });
- * if (!(result instanceof SubscribeError)) {
+ * if (!(result instanceof RequestError)) {
  *   for await (const object of result.stream) {
  *     // Consume MOQT objects
  *   }
@@ -975,9 +995,9 @@ declare class RecvDatagramStream {
  *
  * ### Publish a namespace for Publishing
  * ```ts
- * const client = await MOQtailClient.new({ url, supportedVersions: [0xff00000b] });
+ * const client = await MOQtailClient.new({ url });
  * const publishNamespaceResult = await client.publishNamespace(["camera", "main"]);
- * if (!(publishNamespaceResult instanceof PublishNamespaceError)) {
+ * if (!(publishNamespaceResult instanceof RequestError)) {
  *   // Ready to publish objects under this namespace
  * }
  * ```
@@ -1071,7 +1091,7 @@ declare class MOQtailClient {
      */
     onGoaway?: (msg: GoAway) => void;
     /**
-     * Fired if the underlying WebTransport session fails (ready → closed prematurely).
+     * Fired if the underlying WebTransport session fails (ready -\> closed prematurely).
      * Use to log or alert on transport errors.
      * Lifecycle/error handler.
      */
@@ -1113,13 +1133,19 @@ declare class MOQtailClient {
      */
     onError?: (er: unknown) => void;
     /** Invoked for each decoded datagram object/status arriving. */
-    onDatagramReceived?: (data: DatagramObject | DatagramStatus) => void;
+    onDatagramReceived?: (data: Datagram) => void;
     /** Invoked after enqueuing each outbound datagram object/status. */
-    onDatagramSent?: (data: DatagramObject | DatagramStatus) => void;
+    onDatagramSent?: (data: Datagram) => void;
     /** Fired when an inbound PUBLISH control message is received. */
     onPeerPublish?: (msg: Publish, stream: ReadableStream<MoqtObject>) => void;
+    /** Fired when an inbound PUBLISH_DONE control message is received. */
+    onPeerPublishDone?: (msg: PublishDone) => void;
     /** Fired when an inbound SUBSCRIBE_NAMESPACE control message is received. */
     onPeerSubscribeNamespace?: (msg: SubscribeNamespace) => void;
+    /** Fired when a NAMESPACE message arrives on a SUBSCRIBE_NAMESPACE bi-stream (prefix + suffix). */
+    onPeerNamespace?: (prefix: Tuple, suffix: Tuple) => void;
+    /** Fired when a NAMESPACE_DONE message arrives on a SUBSCRIBE_NAMESPACE bi-stream (prefix + suffix). */
+    onPeerNamespaceDone?: (prefix: Tuple, suffix: Tuple) => void;
     /**
      * Stream of all received MoqtObjects from datagrams across all tracks
      * Consumer should filter by fullTrackName as needed
@@ -1142,6 +1168,16 @@ declare class MOQtailClient {
      * Returns true if datagram support is currently active
      */
     get isDatagramsEnabled(): boolean;
+    /**
+     * Sets the global log level for all moqtail-ts loggers.
+     * @param level - The minimum {@link LogLevel} to output. Use `LogLevel.NONE` to silence all logs.
+     */
+    static setLogLevel(level: LogLevel): void;
+    /**
+     * Restricts log output to the specified module names. Pass `null` to allow all modules.
+     * @param modules - Array of module name strings, or `null` to enable all modules.
+     */
+    static setLogEnabledModules(modules: string[] | null): void;
     private constructor();
     /**
      * Establishes a new {@link MOQtailClient} session over WebTransport and performs the MOQT setup handshake.
@@ -1155,8 +1191,7 @@ declare class MOQtailClient {
      * @example Minimal connection
      * ```ts
      * const client = await MOQtailClient.new({
-     *   url: 'https://relay.example.com/transport',
-     *   supportedVersions: [0xff00000b]
+     *   url: 'https://relay.example.com/transport'
      * });
      * ```
      *
@@ -1164,7 +1199,6 @@ declare class MOQtailClient {
      * ```ts
      * const client = await MOQtailClient.new({
      *   url,
-     *   supportedVersions: [0xff00000b],
      *   setupParameters: new SetupParameters().addMaxRequestId(1000),
      *   transportOptions: { congestionControl: 'default' },
      *   dataStreamTimeoutMs: 5000,
@@ -1353,11 +1387,11 @@ declare class MOQtailClient {
      * - `filterType: AbsoluteRange` lets you specify a start and end group, both of should be in the future; the stream waits for those objects. If the start location is \< the latest object
      * observed at the publisher then it behaves as `filterType: LatestObject`.
      *
-     * The method returns either a {@link SubscribeError} (on refusal) or an object with the subscription `requestId` and a `ReadableStream` of {@link MoqtObject}s.
+     * The method returns either a {@link RequestError} (on refusal) or an object with the subscription `requestId` and a `ReadableStream` of {@link MoqtObject}s.
      * Use the `requestId` for {@link MOQtailClient.unsubscribe} or {@link MOQtailClient.subscribeUpdate}. Use the `stream` to decode and display objects.
      *
      * @param args - {@link SubscribeOptions} describing the subscription window and relay forwarding behavior.
-     * @returns Either a {@link SubscribeError} or `{ requestId, stream }` for consuming objects.
+     * @returns Either a {@link RequestError} or `{ requestId, stream }` for consuming objects.
      * @throws : {@link MOQtailError} If the client is destroyed.
      * @throws : {@link ProtocolViolationError} If required fields are missing or inconsistent.
      * @throws : {@link InternalError} On transport/protocol failure (disconnect is triggered before rethrow).
@@ -1371,7 +1405,7 @@ declare class MOQtailClient {
      *   groupOrder: GroupOrder.Original,
      *   priority: 32
      * });
-     * if (!(result instanceof SubscribeError)) {
+     * if (!(result instanceof RequestError)) {
      *   for await (const obj of result.stream) {
      *     // decode and display obj
      *   }
@@ -1391,7 +1425,7 @@ declare class MOQtailClient {
      * });
      * ```
      */
-    subscribe(args: SubscribeOptions): Promise<SubscribeError | {
+    subscribe(args: SubscribeOptions): Promise<RequestError | {
         requestId: bigint;
         stream: ReadableStream<MoqtObject>;
     }>;
@@ -1416,7 +1450,7 @@ declare class MOQtailClient {
      * @example Subscribe and later unsubscribe
      * ```ts
      * const sub = await client.subscribe({ fullTrackName, filterType: FilterType.LatestObject, forward: true, groupOrder: GroupOrder.Original, priority: 0 });
-     * if (!(sub instanceof SubscribeError)) {
+     * if (!(sub instanceof RequestError)) {
      *   // ...consume objects...
      *   await client.unsubscribe(sub.requestId);
      * }
@@ -1488,7 +1522,7 @@ declare class MOQtailClient {
      * await client.switch({ subscriptionRequestId, fullTrackName: newTrackName });
      * ```
      */
-    switch(args: SwitchOptions): Promise<SubscribeError | {
+    switch(args: SwitchOptions): Promise<RequestError | {
         requestId: bigint;
         stream: ReadableStream<MoqtObject>;
     }>;
@@ -1496,7 +1530,7 @@ declare class MOQtailClient {
      * One-shot retrieval of a bounded object span, optionally anchored to an existing subscription, returning a stream of {@link MoqtObject}s.
      *
      * Choose a fetch type via `typeAndProps.type`:
-     * - StandAlone: Historical slice of a specific {@link FullTrackName} independent of active subscriptions.
+     * - Standalone: Historical slice of a specific {@link FullTrackName} independent of active subscriptions.
      * - Relative: Range relative to the JOINING subscription's current (largest) location; use when you want "N groups back" from live.
      * - Absolute: Absolute group/object offsets tied to an existing subscription (stable anchor) even if that subscription keeps forwarding.
      *
@@ -1506,7 +1540,7 @@ declare class MOQtailClient {
      * - typeAndProps: Discriminated union carrying parameters specific to each fetch mode (see examples).
      * - parameters: Optional version-specific extension block.
      *
-     * Returns either a {@link FetchError} (refusal / invalid request at protocol level) or `{ requestId, stream }` whose `stream`
+     * Returns either a {@link RequestError} (refusal / invalid request at protocol level) or `{ requestId, stream }` whose `stream`
      * ends naturally after the bounded range completes (no explicit cancel needed for normal completion).
      *
      * Use cases:
@@ -1529,11 +1563,11 @@ declare class MOQtailClient {
      *   priority: 64,
      *   groupOrder: GroupOrder.Original,
      *   typeAndProps: {
-     *     type: FetchType.StandAlone,
+     *     type: FetchType.Standalone,
      *     props: { fullTrackName, startLocation, endLocation }
      *   }
      * })
-     * if (!(r instanceof FetchError)) {
+     * if (!(r instanceof RequestError)) {
      *   for await (const obj of r.stream as any) {
      *     // consume objects then stream ends automatically
      *   }
@@ -1543,7 +1577,7 @@ declare class MOQtailClient {
      * @example Relative to live subscription (e.g. last 5 groups)
      * ```ts
      * const sub = await client.subscribe({ fullTrackName, filterType: FilterType.LatestObject, forward: true, groupOrder: GroupOrder.Original, priority: 0 })
-     * if (!(sub instanceof SubscribeError)) {
+     * if (!(sub instanceof RequestError)) {
      *   const slice = await client.fetch({
      *     priority: 32,
      *     groupOrder: GroupOrder.Original,
@@ -1552,7 +1586,7 @@ declare class MOQtailClient {
      * }
      * ```
      */
-    fetch(args: FetchOptions): Promise<FetchError | {
+    fetch(args: FetchOptions): Promise<RequestError | {
         requestId: bigint;
         stream: ReadableStream<MoqtObject>;
     }>;
@@ -1578,8 +1612,8 @@ declare class MOQtailClient {
      *
      * @example Cancel shortly after starting
      * ```ts
-     * const r = await client.fetch({ priority: 32, groupOrder: GroupOrder.Original, typeAndProps: { type: FetchType.StandAlone, props: { fullTrackName, startLocation, endLocation } } })
-     * if (!(r instanceof FetchError)) {
+     * const r = await client.fetch({ priority: 32, groupOrder: GroupOrder.Original, typeAndProps: { type: FetchType.Standalone, props: { fullTrackName, startLocation, endLocation } } })
+     * if (!(r instanceof RequestError)) {
      *   // user navigated away
      *   await client.fetchCancel(r.requestId)
      * }
@@ -1595,10 +1629,15 @@ declare class MOQtailClient {
     /**
      * Proactively push a track to the relay/peer.
      */
-    publish(fullTrackName: FullTrackName, forward: boolean, trackAlias: bigint, parameters?: VersionSpecificParameters): Promise<PublishError | {
+    publish(fullTrackName: FullTrackName, forward: boolean, trackAlias: bigint, parameters?: MessageParameter[], trackExtensions?: TrackExtension[]): Promise<RequestError | {
         requestId: bigint;
         trackAlias: bigint;
     }>;
+    /**
+     * Signals the end of a published track to the peer/relay.
+     * * @param publishRequestId - The original requestId used when `publish()` was called.
+     */
+    publishDone(publishRequestId: bigint | number, statusCode?: number, reasonPhrase?: string): Promise<void>;
     /**
      * Registers an incoming PUBLISH announcement as a valid data receiver.
      * This prepares the client to ingest pushed data streams matching the published alias.
@@ -1617,9 +1656,9 @@ declare class MOQtailClient {
      *
      * Parameter semantics:
      * - trackNamespace: Tuple representing the namespace prefix (e.g. ["camera","main"]). All tracks whose full names start with this tuple are considered within the announce scope.
-     * - parameters: Optional {@link VersionSpecificParameters}; omitted =\> default instance.
+     * - parameters: Optional {@link MessageParameters}; omitted =\> default instance.
      *
-     * Returns: {@link PublishNamespaceOk} on success (namespace added to `announcedNamespaces`) or {@link PublishNamespaceError} explaining refusal.
+     * Returns: {@link RequestOk} on success (namespace added to `announcedNamespaces`) or {@link RequestError} explaining refusal.
      *
      * Use cases:
      * - Make a camera or sensor namespace available before any objects are pushed.
@@ -1637,18 +1676,18 @@ declare class MOQtailClient {
      * @example Minimal announce
      * ```ts
      * const res = await client.publishNamespace(["camera","main"])
-     * if (res instanceof PublishNamespaceOk) {
+     * if (res instanceof RequestOk) {
      *   // ready to publish objects under tracks with this namespace prefix
      * }
      * ```
      *
      * @example PublishNamespace with parameters block
      * ```ts
-     * const params = new VersionSpecificParameters().setSomeExtensionFlag(true)
+     * const params = new MessageParameters().setSomeExtensionFlag(true)
      * const resp = await client.publishNamespace(["room","1234"], params)
      * ```
      */
-    publishNamespace(trackNamespace: Tuple, parameters?: VersionSpecificParameters): Promise<PublishNamespaceError | PublishNamespaceOk>;
+    publishNamespace(trackNamespace: Tuple, parameters?: MessageParameter[]): Promise<RequestOk | RequestError>;
     /**
      * Withdraw a previously announced namespace so new subscribers no longer discover its tracks.
      *
@@ -1710,10 +1749,43 @@ declare class MOQtailClient {
      * ```
      */
     publishNamespaceCancel(msg: PublishNamespaceCancel): Promise<void>;
-    subscribeNamespace(trackNamespacePrefix: Tuple, parameters?: VersionSpecificParameters): Promise<SubscribeNamespaceError | SubscribeNamespaceOk>;
+    subscribeNamespace(trackNamespacePrefix: Tuple, subscribeOptions?: NamespaceSubscribeOptions, parameters?: MessageParameter[]): Promise<{
+        response: RequestOk | RequestError;
+        cancel: () => Promise<void>;
+    }>;
     unsubscribeNamespace(msg: UnsubscribeNamespace): Promise<void>;
 }
 
+/**
+ * Copyright 2026 The MOQtail Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+declare class TrackStatusRequest implements PromiseLike<RequestOk | RequestError> {
+    readonly requestId: bigint;
+    readonly message: TrackStatus;
+    private _resolve;
+    private _reject;
+    private promise;
+    constructor(msg: TrackStatus);
+    resolve(value: RequestOk | RequestError | PromiseLike<RequestOk | RequestError>): void;
+    reject(reason?: any): void;
+    then<TResult1 = RequestOk | RequestError, TResult2 = never>(onfulfilled?: ((value: RequestOk | RequestError) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<RequestOk | RequestError | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<RequestOk | RequestError>;
+}
+
 /**
  * Copyright 2025 The MOQtail Authors
  *
@@ -1748,4 +1820,4 @@ declare class RecvStream {
     static new(readStream: ReadableStream<Uint8Array>, partialDataTimeout?: number, onDataReceived?: (data: SubgroupObject | SubgroupHeader | FetchObject | FetchHeader) => void): Promise<RecvStream>;
 }
 
-export { ControlStream, type FetchOptions, FetchPublication, FetchRequest, HybridTrackSource, type LiveObjectSource, LiveTrackSource, MOQtailClient, type MOQtailClientOptions, type MOQtailRequest, MemoryObjectCache, type ObjectCache, type PastObjectSource, PublishNamespaceRequest, PublishPublication, PublishRequest, RecvDatagramStream, RecvStream, RingBufferObjectCache, SendDatagramStream, SendStream, StaticTrackSource, SubscribeNamespaceRequest, type SubscribeOptions, SubscribePublication, SubscribeRequest, type SubscribeUpdateOptions, type SwitchOptions, type Track, type TrackSource };
+export { ControlStream, type FetchOptions, FetchPublication, FetchRequest, HybridTrackSource, type LiveObjectSource, LiveTrackSource, MOQtailClient, type MOQtailClientOptions, type MOQtailRequest, MemoryObjectCache, type ObjectCache, type PastObjectSource, PublishNamespaceRequest, PublishPublication, PublishRequest, RecvDatagramStream, RecvStream, RingBufferObjectCache, SendDatagramStream, SendStream, StaticTrackSource, SubscribeNamespaceRequest, type SubscribeOptions, SubscribePublication, SubscribeRequest, type SubscribeUpdateOptions, type SwitchOptions, type Track, type TrackSource, TrackStatusRequest };