moqtail 0.7.0 → 0.8.0

package/dist/index.js

@@ -577,27 +577,37 @@ var ObjectDatagramStatusType, ObjectDatagramType, FetchHeaderType, SubgroupHeade
 var init_constant = __esm({
   "src/model/data/constant.ts"() {
     ObjectDatagramStatusType = /* @__PURE__ */ ((ObjectDatagramStatusType2) => {
-      ObjectDatagramStatusType2[ObjectDatagramStatusType2["WithoutExtensions"] = 2] = "WithoutExtensions";
-      ObjectDatagramStatusType2[ObjectDatagramStatusType2["WithExtensions"] = 3] = "WithExtensions";
+      ObjectDatagramStatusType2[ObjectDatagramStatusType2["WithoutExtensions"] = 32] = "WithoutExtensions";
+      ObjectDatagramStatusType2[ObjectDatagramStatusType2["WithExtensions"] = 33] = "WithExtensions";
       return ObjectDatagramStatusType2;
     })(ObjectDatagramStatusType || {});
     ((ObjectDatagramStatusType2) => {
       function tryFrom(value) {
         const v = typeof value === "bigint" ? Number(value) : value;
         switch (v) {
-          case 2:
-            return 2 /* WithoutExtensions */;
-          case 3:
-            return 3 /* WithExtensions */;
+          case 32:
+            return 32 /* WithoutExtensions */;
+          case 33:
+            return 33 /* WithExtensions */;
           default:
             throw new Error(`Invalid ObjectDatagramStatusType: ${value}`);
         }
       }
       ObjectDatagramStatusType2.tryFrom = tryFrom;
+      function hasExtensions(t) {
+        return t === 33 /* WithExtensions */;
+      }
+      ObjectDatagramStatusType2.hasExtensions = hasExtensions;
     })(ObjectDatagramStatusType || (ObjectDatagramStatusType = {}));
     ObjectDatagramType = /* @__PURE__ */ ((ObjectDatagramType2) => {
-      ObjectDatagramType2[ObjectDatagramType2["WithoutExtensions"] = 0] = "WithoutExtensions";
-      ObjectDatagramType2[ObjectDatagramType2["WithExtensions"] = 1] = "WithExtensions";
+      ObjectDatagramType2[ObjectDatagramType2["Type0x00"] = 0] = "Type0x00";
+      ObjectDatagramType2[ObjectDatagramType2["Type0x01"] = 1] = "Type0x01";
+      ObjectDatagramType2[ObjectDatagramType2["Type0x02"] = 2] = "Type0x02";
+      ObjectDatagramType2[ObjectDatagramType2["Type0x03"] = 3] = "Type0x03";
+      ObjectDatagramType2[ObjectDatagramType2["Type0x04"] = 4] = "Type0x04";
+      ObjectDatagramType2[ObjectDatagramType2["Type0x05"] = 5] = "Type0x05";
+      ObjectDatagramType2[ObjectDatagramType2["Type0x06"] = 6] = "Type0x06";
+      ObjectDatagramType2[ObjectDatagramType2["Type0x07"] = 7] = "Type0x07";
       return ObjectDatagramType2;
     })(ObjectDatagramType || {});
     ((ObjectDatagramType2) => {
@@ -605,14 +615,46 @@ var init_constant = __esm({
         const v = typeof value === "bigint" ? Number(value) : value;
         switch (v) {
           case 0:
-            return 0 /* WithoutExtensions */;
+            return 0 /* Type0x00 */;
           case 1:
-            return 1 /* WithExtensions */;
+            return 1 /* Type0x01 */;
+          case 2:
+            return 2 /* Type0x02 */;
+          case 3:
+            return 3 /* Type0x03 */;
+          case 4:
+            return 4 /* Type0x04 */;
+          case 5:
+            return 5 /* Type0x05 */;
+          case 6:
+            return 6 /* Type0x06 */;
+          case 7:
+            return 7 /* Type0x07 */;
           default:
             throw new Error(`Invalid ObjectDatagramType: ${value}`);
         }
       }
       ObjectDatagramType2.tryFrom = tryFrom;
+      function hasExtensions(t) {
+        return (t & 1) !== 0;
+      }
+      ObjectDatagramType2.hasExtensions = hasExtensions;
+      function isEndOfGroup(t) {
+        return (t & 2) !== 0;
+      }
+      ObjectDatagramType2.isEndOfGroup = isEndOfGroup;
+      function hasObjectId(t) {
+        return (t & 4) === 0;
+      }
+      ObjectDatagramType2.hasObjectId = hasObjectId;
+      function fromProperties(hasExtensions2, endOfGroup, objectIdIsZero) {
+        let type = 0;
+        if (hasExtensions2) type |= 1;
+        if (endOfGroup) type |= 2;
+        if (objectIdIsZero) type |= 4;
+        return type;
+      }
+      ObjectDatagramType2.fromProperties = fromProperties;
     })(ObjectDatagramType || (ObjectDatagramType = {}));
     FetchHeaderType = /* @__PURE__ */ ((FetchHeaderType3) => {
       FetchHeaderType3[FetchHeaderType3["Type0x05"] = 5] = "Type0x05";
@@ -767,11 +809,12 @@ var init_datagram_object = __esm({
     init_constant();
     init_location();
     DatagramObject = class _DatagramObject {
-      constructor(type, trackAlias, location, publisherPriority, extensionHeaders, payload) {
+      constructor(type, trackAlias, location, publisherPriority, extensionHeaders, payload, endOfGroup) {
         this.type = type;
         this.publisherPriority = publisherPriority;
         this.extensionHeaders = extensionHeaders;
         this.payload = payload;
+        this.endOfGroup = endOfGroup;
         this.trackAlias = BigInt(trackAlias);
         this.location = location;
       }
@@ -783,34 +826,48 @@ var init_datagram_object = __esm({
       get objectId() {
         return this.location.object;
       }
-      static newWithExtensions(trackAlias, groupId, objectId, publisherPriority, extensionHeaders, payload) {
+      /**
+       * Create a new DatagramObject with all properties specified.
+       * The type is automatically determined based on extensions, endOfGroup, and objectId.
+       */
+      static new(trackAlias, groupId, objectId, publisherPriority, extensionHeaders, payload, endOfGroup = false) {
+        const hasExtensions = extensionHeaders !== null && extensionHeaders.length > 0;
+        const objectIdIsZero = objectId === 0n;
+        const type = ObjectDatagramType.fromProperties(hasExtensions, endOfGroup, objectIdIsZero);
         return new _DatagramObject(
-          1 /* WithExtensions */,
+          type,
           trackAlias,
           new Location(groupId, objectId),
           publisherPriority,
-          extensionHeaders,
-          payload
+          hasExtensions ? extensionHeaders : null,
+          payload,
+          endOfGroup
         );
       }
-      static newWithoutExtensions(trackAlias, groupId, objectId, publisherPriority, payload) {
-        return new _DatagramObject(
-          0 /* WithoutExtensions */,
-          trackAlias,
-          new Location(groupId, objectId),
-          publisherPriority,
-          null,
-          payload
-        );
+      /**
+       * Create a DatagramObject with extensions.
+       * @deprecated Use DatagramObject.new() instead for Draft-14 compliance.
+       */
+      static newWithExtensions(trackAlias, groupId, objectId, publisherPriority, extensionHeaders, payload, endOfGroup = false) {
+        return _DatagramObject.new(trackAlias, groupId, objectId, publisherPriority, extensionHeaders, payload, endOfGroup);
+      }
+      /**
+       * Create a DatagramObject without extensions.
+       * @deprecated Use DatagramObject.new() instead for Draft-14 compliance.
+       */
+      static newWithoutExtensions(trackAlias, groupId, objectId, publisherPriority, payload, endOfGroup = false) {
+        return _DatagramObject.new(trackAlias, groupId, objectId, publisherPriority, null, payload, endOfGroup);
       }
       serialize() {
         const buf = new ByteBuffer();
         buf.putVI(this.type);
         buf.putVI(this.trackAlias);
         buf.putVI(this.location.group);
-        buf.putVI(this.location.object);
+        if (ObjectDatagramType.hasObjectId(this.type)) {
+          buf.putVI(this.location.object);
+        }
         buf.putU8(this.publisherPriority);
-        if (this.type === 1 /* WithExtensions */) {
+        if (ObjectDatagramType.hasExtensions(this.type)) {
           const extBuf = new ByteBuffer();
           if (this.extensionHeaders) {
             for (const header of this.extensionHeaders) {
@@ -828,28 +885,32 @@ var init_datagram_object = __esm({
         const msgType = ObjectDatagramType.tryFrom(msgTypeRaw);
         const trackAlias = buf.getVI();
         const groupId = buf.getVI();
-        const objectId = buf.getVI();
+        let objectId;
+        if (ObjectDatagramType.hasObjectId(msgType)) {
+          objectId = buf.getVI();
+        } else {
+          objectId = 0n;
+        }
         const publisherPriority = buf.getU8();
         let extensionHeaders = null;
-        switch (msgType) {
-          case 1 /* WithExtensions */: {
-            const extBytes = buf.getLengthPrefixedBytes();
-            const headerBytes = new FrozenByteBuffer5(extBytes);
-            extensionHeaders = [];
-            while (headerBytes.remaining > 0) {
-              extensionHeaders.push(headerBytes.getKeyValuePair());
-            }
-            break;
+        if (ObjectDatagramType.hasExtensions(msgType)) {
+          const extBytes = buf.getLengthPrefixedBytes();
+          const headerBytes = new FrozenByteBuffer5(extBytes);
+          extensionHeaders = [];
+          while (headerBytes.remaining > 0) {
+            extensionHeaders.push(headerBytes.getKeyValuePair());
           }
         }
         const payload = buf.getBytes(buf.remaining);
+        const endOfGroup = ObjectDatagramType.isEndOfGroup(msgType);
         return new _DatagramObject(
           msgType,
           trackAlias,
           new Location(groupId, objectId),
           publisherPriority,
           extensionHeaders,
-          payload
+          payload,
+          endOfGroup
         );
       }
     };
@@ -881,25 +942,35 @@ var init_datagram_status = __esm({
       get objectId() {
         return this.location.object;
       }
-      static withExtensions(trackAlias, location, publisherPriority, extensionHeaders, objectStatus) {
+      /**
+       * Create a new DatagramStatus with all properties specified.
+       * The type is automatically determined based on whether extensions are present.
+       */
+      static new(trackAlias, location, publisherPriority, extensionHeaders, objectStatus) {
+        const hasExtensions = extensionHeaders !== null && extensionHeaders.length > 0;
+        const type = hasExtensions ? 33 /* WithExtensions */ : 32 /* WithoutExtensions */;
         return new _DatagramStatus(
-          3 /* WithExtensions */,
+          type,
           trackAlias,
           location,
           publisherPriority,
-          extensionHeaders,
+          hasExtensions ? extensionHeaders : null,
           objectStatus
         );
       }
+      /**
+       * Create a DatagramStatus with extensions.
+       * @deprecated Use DatagramStatus.new() instead for Draft-14 compliance.
+       */
+      static withExtensions(trackAlias, location, publisherPriority, extensionHeaders, objectStatus) {
+        return _DatagramStatus.new(trackAlias, location, publisherPriority, extensionHeaders, objectStatus);
+      }
+      /**
+       * Create a DatagramStatus without extensions.
+       * @deprecated Use DatagramStatus.new() instead for Draft-14 compliance.
+       */
       static newWithoutExtensions(trackAlias, location, publisherPriority, objectStatus) {
-        return new _DatagramStatus(
-          2 /* WithoutExtensions */,
-          trackAlias,
-          location,
-          publisherPriority,
-          null,
-          objectStatus
-        );
+        return _DatagramStatus.new(trackAlias, location, publisherPriority, null, objectStatus);
       }
       serialize() {
         const buf = new ByteBuffer();
@@ -908,7 +979,7 @@ var init_datagram_status = __esm({
         buf.putVI(this.location.group);
         buf.putVI(this.location.object);
         buf.putU8(this.publisherPriority);
-        if (this.type === 3 /* WithExtensions */) {
+        if (ObjectDatagramStatusType.hasExtensions(this.type)) {
           const extBuf = new ByteBuffer();
           if (this.extensionHeaders) {
             for (const header of this.extensionHeaders) {
@@ -929,18 +1000,14 @@ var init_datagram_status = __esm({
         const objectId = buf.getVI();
         const publisherPriority = buf.getU8();
         let extensionHeaders = null;
-        switch (msgType) {
-          case 3 /* WithExtensions */: {
-            const extBytes = buf.getLengthPrefixedBytes();
-            const headerBytes = new FrozenByteBuffer5(extBytes);
-            extensionHeaders = [];
-            while (headerBytes.remaining > 0) {
-              extensionHeaders.push(headerBytes.getKeyValuePair());
-            }
-            break;
+        if (ObjectDatagramStatusType.hasExtensions(msgType)) {
+          const extBytes = buf.getLengthPrefixedBytes();
+          const headerBytes = new FrozenByteBuffer5(extBytes);
+          extensionHeaders = [];
+          while (headerBytes.remaining > 0) {
+            extensionHeaders.push(headerBytes.getKeyValuePair());
           }
         }
-        console.log("Came here for trying tryFrom with object status");
         const objectStatus = ObjectStatus.tryFrom(buf.getVI());
         return new _DatagramStatus(
           msgType,
@@ -1656,6 +1723,14 @@ var init_object = __esm({
           datagramObject.payload
         );
       }
+      /**
+       * Returns the endOfGroup flag from the source DatagramObject.
+       * This is separate from ObjectStatus.EndOfGroup - the flag indicates
+       * this is the last object in the group even with Normal status.
+       */
+      static isDatagramEndOfGroup(datagramObject) {
+        return datagramObject.endOfGroup;
+      }
       static fromDatagramStatus(datagramStatus, fullTrackName) {
         return new _MoqtObject(
           fullTrackName,
@@ -1692,7 +1767,12 @@ var init_object = __esm({
           subgroupObject.payload
         );
       }
-      tryIntoDatagramObject(trackAlias) {
+      /**
+       * Convert to DatagramObject for wire transmission.
+       * @param trackAlias - The track alias to use
+       * @param endOfGroup - Draft-14: Whether this is the last object in the group
+       */
+      tryIntoDatagramObject(trackAlias, endOfGroup = false) {
         if (this.objectForwardingPreference !== "Datagram" /* Datagram */) {
           throw new CastingError(
             "MoqtObject.tryIntoDatagramObject",
@@ -1708,24 +1788,15 @@ var init_object = __esm({
           );
         }
         const alias = BigInt(trackAlias);
-        if (this.extensionHeaders && this.extensionHeaders.length > 0) {
-          return DatagramObject.newWithExtensions(
-            alias,
-            this.groupId,
-            this.objectId,
-            this.publisherPriority,
-            this.extensionHeaders,
-            this.payload
-          );
-        } else {
-          return DatagramObject.newWithoutExtensions(
-            alias,
-            this.groupId,
-            this.objectId,
-            this.publisherPriority,
-            this.payload
-          );
-        }
+        return DatagramObject.new(
+          alias,
+          this.groupId,
+          this.objectId,
+          this.publisherPriority,
+          this.extensionHeaders,
+          this.payload,
+          endOfGroup
+        );
       }
       tryIntoDatagramStatus(trackAlias) {
         if (this.objectForwardingPreference !== "Datagram" /* Datagram */) {
@@ -2528,11 +2599,11 @@ function fetchTypeFromBigInt(v) {
       throw new CastingError("fetchTypeFromBigInt", "bigint", "FetchType", `Invalid FetchType:${v}`);
   }
 }
-var GroupOrder = /* @__PURE__ */ ((GroupOrder7) => {
-  GroupOrder7[GroupOrder7["Original"] = 0] = "Original";
-  GroupOrder7[GroupOrder7["Ascending"] = 1] = "Ascending";
-  GroupOrder7[GroupOrder7["Descending"] = 2] = "Descending";
-  return GroupOrder7;
+var GroupOrder = /* @__PURE__ */ ((GroupOrder6) => {
+  GroupOrder6[GroupOrder6["Original"] = 0] = "Original";
+  GroupOrder6[GroupOrder6["Ascending"] = 1] = "Ascending";
+  GroupOrder6[GroupOrder6["Descending"] = 2] = "Descending";
+  return GroupOrder6;
 })(GroupOrder || {});
 function groupOrderFromNumber(v) {
   switch (v) {
@@ -3538,15 +3609,14 @@ var PublishDone = class _PublishDone {
 
 // src/model/control/publish.ts
 init_byte_buffer();
-init_tuple();
 init_location();
 init_pair();
 init_error();
+init_data();
 var Publish = class _Publish {
-  constructor(requestId, trackNamespace, trackName, trackAlias, groupOrder, contentExists, largestLocation, forward, parameters) {
+  constructor(requestId, fullTrackName, trackAlias, groupOrder, contentExists, largestLocation, forward, parameters) {
     this.requestId = requestId;
-    this.trackNamespace = trackNamespace;
-    this.trackName = trackName;
+    this.fullTrackName = fullTrackName;
     this.trackAlias = trackAlias;
     this.groupOrder = groupOrder;
     this.contentExists = contentExists;
@@ -3554,11 +3624,10 @@ var Publish = class _Publish {
     this.forward = forward;
     this.parameters = parameters;
   }
-  static new(requestId, trackNamespace, trackName, trackAlias, groupOrder, contentExists, largestLocation, forward, parameters) {
+  static new(requestId, fullTrackName, trackAlias, groupOrder, contentExists, largestLocation, forward, parameters) {
     return new _Publish(
       BigInt(requestId),
-      trackNamespace,
-      trackName,
+      fullTrackName,
       BigInt(trackAlias),
       groupOrder,
       contentExists,
@@ -3575,9 +3644,7 @@ var Publish = class _Publish {
     buf.putVI(29 /* Publish */);
     const payload = new ByteBuffer();
     payload.putVI(this.requestId);
-    payload.putTuple(this.trackNamespace);
-    payload.putVI(this.trackName.length);
-    payload.putBytes(new TextEncoder().encode(this.trackName));
+    payload.putBytes(this.fullTrackName.serialize().toUint8Array());
     payload.putVI(this.trackAlias);
     payload.putU8(this.groupOrder);
     payload.putU8(this.contentExists);
@@ -3599,10 +3666,7 @@ var Publish = class _Publish {
   }
   static parsePayload(buf) {
     const requestId = buf.getVI();
-    const trackNamespace = buf.getTuple();
-    const trackNameLength = buf.getVI();
-    const trackNameBytes = buf.getBytes(Number(trackNameLength));
-    const trackName = new TextDecoder().decode(trackNameBytes);
+    const fullTrackName = buf.getFullTrackName();
     const trackAlias = buf.getVI();
     const groupOrder = buf.getU8();
     const contentExists = buf.getU8();
@@ -3618,8 +3682,7 @@ var Publish = class _Publish {
     }
     return new _Publish(
       requestId,
-      trackNamespace,
-      trackName,
+      fullTrackName,
       trackAlias,
       groupOrder,
       contentExists,
@@ -5491,6 +5554,70 @@ var SubscribeRequest = class {
   }
 };
 
+// src/client/request/subscribe_namespace.ts
+var SubscribeNamespaceRequest = class {
+  requestId;
+  message;
+  _resolve;
+  _reject;
+  promise;
+  constructor(msg) {
+    this.requestId = msg.requestId;
+    this.message = msg;
+    this.promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  resolve(value) {
+    this._resolve(value);
+  }
+  reject(reason) {
+    this._reject(reason);
+  }
+  then(onfulfilled, onrejected) {
+    return this.promise.then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.promise.catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.promise.finally(onfinally);
+  }
+};
+
+// src/client/request/publish.ts
+var PublishRequest = class {
+  requestId;
+  message;
+  _resolve;
+  _reject;
+  promise;
+  constructor(msg) {
+    this.requestId = msg.requestId;
+    this.message = msg;
+    this.promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  resolve(value) {
+    this._resolve(value);
+  }
+  reject(reason) {
+    this._reject(reason);
+  }
+  then(onfulfilled, onrejected) {
+    return this.promise.then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.promise.catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.promise.finally(onfinally);
+  }
+};
+
 // src/client/handler/publish_namespace.ts
 var handlerPublishNamespace = async (client, msg) => {
   if (client.onNamespacePublished) {
@@ -6027,7 +6154,12 @@ var handlerSubscribe = async (client, msg) => {
 };
 
 // src/client/handler/subscribe_namespace.ts
-var handlerSubscribeNamespace = async (_client, _msg) => {
+var handlerSubscribeNamespace = async (client, msg) => {
+  if (client.onPeerSubscribeNamespace) {
+    client.onPeerSubscribeNamespace(msg);
+  }
+  const okMsg = new SubscribeNamespaceOk(msg.requestId);
+  await client.controlStream.send(okMsg);
 };
 
 // src/client/handler/subscribe_namespace_error.ts
@@ -6113,8 +6245,229 @@ var handlerUnsubscribe = async (client, msg) => {
 var handlerUnsubscribeNamespace = async (_client, _msg) => {
 };
 
+// src/client/handler/publish.ts
+var handlerPublish = async (client, msg) => {
+  let streamController;
+  const stream = new ReadableStream({
+    start(c) {
+      streamController = c;
+    }
+  });
+  const localPseudoRequestId = client.allocatePseudoRequestId();
+  client.requestIdMap.addMapping(localPseudoRequestId, msg.fullTrackName);
+  client.subscriptionAliasMap.set(localPseudoRequestId, msg.trackAlias);
+  client.aliasFullTrackNameMap.set(msg.trackAlias, msg.fullTrackName);
+  const receiver = {
+    requestId: localPseudoRequestId,
+    streamsAccepted: 0,
+    largestLocation: void 0,
+    controller: streamController
+  };
+  client.subscriptions.set(msg.trackAlias, receiver);
+  if (client.onPeerPublish) {
+    client.onPeerPublish(msg, stream);
+  }
+  const publishOk = new PublishOk(
+    msg.requestId,
+    1,
+    255,
+    1 /* Ascending */,
+    2 /* LatestObject */,
+    void 0,
+    void 0,
+    []
+  );
+  await client.controlStream.send(publishOk);
+};
+
+// src/client/publication/publish.ts
+init_subgroup_header();
+var PublishPublication = class {
+  /**
+   * Creates a new PublishPublication instance.
+   * @param client - The MOQT client managing the connection.
+   * @param track - The track being proactively published.
+   * @param publishMsg - The publish message that initiated this session.
+   */
+  constructor(client, track, publishMsg) {
+    this.client = client;
+    this.track = track;
+    this.publishMsg = publishMsg;
+    this.#trackAlias = track.trackAlias;
+    this.#publisherPriority = track.publisherPriority;
+    this.publishToRelay();
+  }
+  /**
+   * The latest location that was published to the relay.
+   */
+  latestLocation;
+  /**
+   * The alias for the track being published.
+   */
+  #trackAlias;
+  /**
+   * The priority of the publisher.
+   */
+  #publisherPriority;
+  /**
+   * The number of streams opened for this publication.
+   */
+  #streamsOpened = 0n;
+  /**
+   * Function to cancel publishing, if set.
+   */
+  #cancelPublishing;
+  /**
+   * Whether publishing is completed/cancelled.
+   */
+  #isCompleted = false;
+  /**
+   * Lock for synchronizing stream operations.
+   */
+  #lock = new SimpleLock();
+  /**
+   * Map of group IDs to their corresponding send streams.
+   */
+  #streams = /* @__PURE__ */ new Map();
+  /**
+   * Unique identifier for this publication instance.
+   */
+  #id = Math.floor(Math.random() * 1e6);
+  /**
+   * Calculates the stream priority based on publisher priority.
+   * (Since this is a proactive push, there is no subscriber priority to average with).
+   */
+  get #streamPriority() {
+    return getTransportPriority(this.#publisherPriority);
+  }
+  /**
+   * Cancels the publication and cleans up resources.
+   * Removes the publication from the client's publication map.
+   */
+  cancel() {
+    if (this.#cancelPublishing) {
+      this.#cancelPublishing();
+      this.client.publications.delete(this.publishMsg.requestId);
+    }
+    this.#isCompleted = true;
+    this.#lock.acquire().then(() => {
+      for (const [groupId, stream] of this.#streams.entries()) {
+        stream.close().catch((e) => console.warn(`Failed to close stream for group ${groupId}:`, e));
+      }
+      this.#streams.clear();
+      this.#lock.release();
+    });
+  }
+  /**
+   * Publishes MOQT objects to the relay as they become available.
+   * Handles stream creation, object writing, and stream closure.
+   * @throws :{@link InternalError} If the track does not support live content.
+   */
+  async publishToRelay() {
+    if (!this.track.trackSource.live)
+      throw new InternalError("PublishPublication.publishToRelay", "Track does not support live content");
+    this.track.trackSource.live.onDone(() => {
+      this.cancel();
+    });
+    this.#cancelPublishing = this.track.trackSource.live.onNewObject(async (obj) => {
+      if (this.#isCompleted) return;
+      try {
+        if (!this.#streams.has(obj.location.group)) {
+          await this.#lock.acquire();
+          if (!this.#streams.has(obj.location.group)) {
+            const writeStream = await this.client.webTransport.createUnidirectionalStream({
+              sendOrder: this.#streamPriority
+            });
+            let subgroupId;
+            if (SubgroupHeaderType.hasExplicitSubgroupId(obj.getSubgroupHeaderType(true))) subgroupId = obj.subgroupId;
+            const header = new SubgroupHeader(
+              obj.getSubgroupHeaderType(true),
+              this.#trackAlias,
+              obj.location.group,
+              subgroupId,
+              this.#publisherPriority
+            );
+            const sendStream2 = await SendStream.new(writeStream, header);
+            this.#streams.set(obj.location.group, sendStream2);
+            this.#streamsOpened++;
+          }
+          await this.#lock.release();
+        }
+        const sendStream = this.#streams.get(obj.location.group);
+        await this.#lock.acquire();
+        await sendStream.write(obj.tryIntoSubgroupObject());
+        await this.#lock.release();
+        if (this.latestLocation && this.latestLocation.group !== obj.location.group) {
+          const prevGroup = this.latestLocation.group;
+          try {
+            await this.#lock.acquire();
+            const prevStream = this.#streams.get(prevGroup);
+            if (prevStream) {
+              try {
+                await prevStream.close();
+              } catch (err) {
+                console.warn("error in closing stream", prevGroup, err);
+              }
+              this.#streams.delete(prevGroup);
+            }
+            await this.#lock.release();
+          } catch (err) {
+            console.warn(
+              "error in closing stream: id, latestLocation.group, err",
+              this.#id,
+              this.latestLocation.group,
+              err
+            );
+          }
+        }
+        await this.#lock.acquire();
+        this.latestLocation = obj.location;
+        await this.#lock.release();
+      } catch (err) {
+        this.cancel();
+        throw err;
+      }
+    });
+  }
+};
+
+// src/client/handler/publish_ok.ts
+var handlerPublishOk = async (client, msg) => {
+  const request = client.requests.get(msg.requestId);
+  if (request instanceof PublishRequest) {
+    request.resolve(msg);
+    const fullTrackName = client.requestIdMap.getNameByRequestId(msg.requestId);
+    if (!fullTrackName) {
+      console.warn(`[MOQtail] No track mapped for PublishOk requestId: ${msg.requestId}`);
+      return;
+    }
+    const track = client.trackSources.get(fullTrackName.toString());
+    if (!track || !track.trackSource.live) {
+      console.warn(`[MOQtail] Live track source not found for ${fullTrackName.toString()}`);
+      return;
+    }
+    const publication = new PublishPublication(client, track, request.message);
+    client.publications.set(msg.requestId, publication);
+  } else {
+    throw new ProtocolViolationError("handlerPublishOk", "No publish request was found with the given request id");
+  }
+};
+
+// src/client/handler/publish_error.ts
+var handlerPublishError = async (client, msg) => {
+  const request = client.requests.get(msg.requestId);
+  if (request instanceof PublishRequest) {
+    request.resolve(msg);
+  } else {
+    throw new ProtocolViolationError("handlerPublishError", "No publish request was found with the given request id");
+  }
+};
+
 // src/client/handler/handler.ts
 function getHandlerForControlMessage(msg) {
+  if (msg instanceof Publish) return handlerPublish;
+  if (msg instanceof PublishOk) return handlerPublishOk;
+  if (msg instanceof PublishError) return handlerPublishError;
   if (msg instanceof PublishDone) return handlerPublishDone;
   if (msg instanceof PublishNamespace) return handlerPublishNamespace;
   if (msg instanceof PublishNamespaceCancel) return handlerPublishNamespaceCancel;
@@ -6268,7 +6621,7 @@ var RecvDatagramStream = class _RecvDatagramStream {
         }
         try {
           const firstByte = datagramBytes[0];
-          const isStatus = firstByte === 2 || firstByte === 3;
+          const isStatus = firstByte === 32 || firstByte === 33;
           let moqtObject;
           if (isStatus) {
             const datagramStatus = DatagramStatus.deserialize(
@@ -6444,6 +6797,10 @@ var MOQtailClient = class _MOQtailClient {
   onDatagramReceived;
   /** Invoked after enqueuing each outbound datagram object/status. */
   onDatagramSent;
+  /** Fired when an inbound PUBLISH control message is received. */
+  onPeerPublish;
+  /** Fired when an inbound SUBSCRIBE_NAMESPACE control message is received. */
+  onPeerSubscribeNamespace;
   /** Datagram writer for sending datagrams. */
   #datagramWriter;
   /** Datagram reader for receiving datagrams. */
@@ -6471,6 +6828,12 @@ var MOQtailClient = class _MOQtailClient {
     this.#dontUseRequestId += 2n;
     return id;
   }
+  /**
+   * Generates a safe, sequential local request ID for tracking pushed/incoming tracks.
+   */
+  allocatePseudoRequestId() {
+    return this.#nextClientRequestId;
+  }
   /**
    * Gets the current server setup configuration.
    *
@@ -6750,7 +7113,7 @@ var MOQtailClient = class _MOQtailClient {
         }
         const firstByte = datagramBytes[0];
         try {
-          const isStatus = firstByte === 2 || firstByte === 3;
+          const isStatus = firstByte === 32 || firstByte === 33;
           let moqtObject;
           let trackAlias;
           if (isStatus) {
@@ -7476,6 +7839,73 @@ var MOQtailClient = class _MOQtailClient {
       throw error;
     }
   }
+  /**
+   * Proactively push a track to the relay/peer.
+   */
+  async publish(fullTrackName, forward, trackAlias, parameters) {
+    this.#ensureActive();
+    try {
+      const params = parameters ? parameters.build() : new VersionSpecificParameters().build();
+      const requestId = this.#nextClientRequestId;
+      const msg = new Publish(
+        requestId,
+        fullTrackName,
+        trackAlias,
+        1 /* Ascending */,
+        0,
+        // ContentExists (0 = Unknown/No)
+        void 0,
+        // Largest Location
+        forward ? 1 : 0,
+        params
+      );
+      const request = new PublishRequest(msg);
+      this.requests.set(msg.requestId, request);
+      this.requestIdMap.addMapping(msg.requestId, fullTrackName);
+      this.subscriptionAliasMap.set(msg.requestId, trackAlias);
+      await this.controlStream.send(msg);
+      const response = await request;
+      if (response instanceof PublishError) {
+        this.requests.delete(msg.requestId);
+        this.requestIdMap.removeMappingByRequestId(msg.requestId);
+        this.subscriptionAliasMap.delete(msg.requestId);
+        return response;
+      } else {
+        return { requestId: msg.requestId, trackAlias };
+      }
+    } catch (error) {
+      await this.disconnect(
+        new InternalError("MOQtailClient.publish", error instanceof Error ? error.message : String(error))
+      );
+      throw error;
+    }
+  }
+  /**
+   * Registers an incoming PUBLISH announcement as a valid data receiver.
+   * This prepares the client to ingest pushed data streams matching the published alias.
+   * * @param msg - The incoming Publish control message
+   * @returns - A stream of MoqtObjects being pushed by the publisher
+   */
+  acceptPushedTrack(msg) {
+    this.#ensureActive();
+    let streamController;
+    const stream = new ReadableStream({
+      start(c) {
+        streamController = c;
+      }
+    });
+    this.requestIdMap.addMapping(msg.requestId, msg.fullTrackName);
+    this.subscriptionAliasMap.set(msg.requestId, msg.trackAlias);
+    this.aliasFullTrackNameMap.set(msg.trackAlias, msg.fullTrackName);
+    const receiver = {
+      requestId: msg.requestId,
+      streamsAccepted: 0,
+      largestLocation: void 0,
+      controller: streamController
+    };
+    this.subscriptions.set(msg.trackAlias, receiver);
+    return stream;
+  }
   // TODO: Each announced track should checked against ongoing subscribe_namespace
   // If matches it should send an announce to that peer automatically
   /**
@@ -7624,10 +8054,20 @@ var MOQtailClient = class _MOQtailClient {
     }
   }
   // INFO: Subscriber calls this the get matching announce messages with this prefix
-  async subscribeNamespace(msg) {
+  async subscribeNamespace(trackNamespacePrefix, parameters) {
     this.#ensureActive();
     try {
-      await this.controlStream.send(msg);
+      const params = parameters ? parameters.build() : new VersionSpecificParameters().build();
+      const msg = new SubscribeNamespace(this.#nextClientRequestId, trackNamespacePrefix, params);
+      const request = new SubscribeNamespaceRequest(msg);
+      this.requests.set(msg.requestId, request);
+      this.controlStream.send(msg);
+      const response = await request;
+      if (response instanceof SubscribeNamespaceOk) {
+        this.subscribedAnnounces.add(msg.trackNamespacePrefix);
+      }
+      this.requests.delete(msg.requestId);
+      return response;
     } catch (error) {
       await this.disconnect(
         new InternalError("MOQtailClient.subscribeNamespace", error instanceof Error ? error.message : String(error))
@@ -7780,8 +8220,9 @@ var MOQtailClient = class _MOQtailClient {
                     subgroupId = header.subgroupId;
                 }
                 const fullTrackName = this.aliasFullTrackNameMap.get(header.trackAlias);
-                if (!fullTrackName)
+                if (!fullTrackName) {
                   throw new ProtocolViolationError("MOQtailClient", "No full track name for received track alias");
+                }
                 const moqtObject = MoqtObject.fromSubgroupObject(
                   nextObject,
                   header.groupId,
@@ -7996,38 +8437,6 @@ var RingBufferObjectCache = class {
   }
 };
 
-// src/client/request/subscribe_namespace.ts
-var SubscribeNamespaceRequest = class {
-  requestId;
-  message;
-  _resolve;
-  _reject;
-  promise;
-  constructor(requestId, message) {
-    this.requestId = requestId;
-    this.message = message;
-    this.promise = new Promise((resolve, reject) => {
-      this._resolve = resolve;
-      this._reject = reject;
-    });
-  }
-  resolve(value) {
-    this._resolve(value);
-  }
-  reject(reason) {
-    this._reject(reason);
-  }
-  then(onfulfilled, onrejected) {
-    return this.promise.then(onfulfilled, onrejected);
-  }
-  catch(onrejected) {
-    return this.promise.catch(onrejected);
-  }
-  finally(onfinally) {
-    return this.promise.finally(onfinally);
-  }
-};
-
 // src/util/telemetry.ts
 var NetworkTelemetry = class {
   events = [];
@@ -8420,40 +8829,4 @@ var ClockNormalizer = class _ClockNormalizer {
   }
 };
 
-// src/util/get_akamai_offset.ts
-var AkamaiOffset = class _AkamaiOffset {
-  static _offset = null;
-  static _promise = null;
-  static async getClockSkew() {
-    if (_AkamaiOffset._offset !== null) {
-      return _AkamaiOffset._offset;
-    }
-    if (_AkamaiOffset._promise) {
-      return _AkamaiOffset._promise;
-    }
-    _AkamaiOffset._promise = _AkamaiOffset.ClockSkew().then((offset2) => {
-      _AkamaiOffset._offset = offset2;
-      return offset2;
-    });
-    const offset = await _AkamaiOffset._promise;
-    return Math.round(offset);
-  }
-  static async ClockSkew() {
-    const akamaiUrl = "https://time.akamai.com?ms";
-    performance.clearResourceTimings();
-    const response = await fetch(akamaiUrl);
-    const text = await response.text();
-    const TR = parseFloat(text.trim()) * 1e3;
-    const entry = performance.getEntriesByType("resource").find((e) => e.name.includes("time.akamai.com"));
-    if (!entry) {
-      console.warn("No resource entry found for Akamai time request");
-      return 0;
-    }
-    const T0 = entry.fetchStart + performance.timeOrigin;
-    const T1 = entry.responseStart + performance.timeOrigin;
-    const offset = (T0 + T1) / 2 - TR;
-    return offset;
-  }
-};
-
-export { AkamaiOffset, AudioLevel, AuthorizationToken, BaseByteBuffer12 as BaseByteBuffer, ByteBuffer, CaptureTimestamp, CastingError, ClientSetup, ClockNormalizer, CommonType, ControlMessage, ControlMessageType, ControlStream, DRAFT_14, DatagramObject, DatagramStatus, DeliveryTimeout, ExtensionHeader, ExtensionHeaders, Fetch, FetchCancel, FetchError, FetchErrorCode, FetchHeader, FetchHeaderType, FetchObject, FetchOk, FetchPublication, FetchRequest, FetchType, FilterType, FrozenByteBuffer5 as FrozenByteBuffer, FullTrackName, GoAway, GroupOrder, Header, HybridTrackSource, InternalError, InvalidTypeError, InvalidUTF8Error, KeyValueFormattingError, KeyValuePair, LOCHeaderExtensionId, LengthExceedsMaxError, LiveTrackSource, Location, MAX_FULL_TRACK_NAME_LENGTH, MAX_NAMESPACE_TUPLE_COUNT, MAX_REASON_PHRASE_LEN, MOQtailClient, MOQtailError, MaxAuthTokenCacheSize, MaxCacheDuration, MaxRequestId, MaxRequestId2 as MaxRequestIdParameter, MemoryObjectCache, MoqtObject, NetworkTelemetry, NotEnoughBytesError, ObjectDatagramStatusType, ObjectDatagramType, ObjectForwardingPreference, ObjectStatus, Path, PlayoutBuffer, ProtocolViolationError, Publish, PublishDone, PublishDoneStatusCode, PublishError, PublishErrorCode, PublishNamespace, PublishNamespaceCancel, PublishNamespaceDone, PublishNamespaceError, PublishNamespaceErrorCode, PublishNamespaceOk, PublishNamespaceRequest, PublishOk, PullPlayoutBuffer, ReasonPhrase, RecvDatagramStream, RecvStream, RequestIdError, RequestIdMap, RequestsBlocked, RingBufferObjectCache, SendDatagramStream, SendStream, ServerSetup, SetupParameter, SetupParameterType, SetupParameters, StaticTrackSource, SubgroupHeader, SubgroupHeaderType, SubgroupObject, Subscribe, SubscribeError, SubscribeErrorCode, SubscribeNamespace, SubscribeNamespaceError, SubscribeNamespaceErrorCode, SubscribeNamespaceOk, SubscribeNamespaceRequest, SubscribeOk, SubscribePublication, SubscribeRequest, SubscribeUpdate, Switch, TerminationCode, TerminationError, TimeoutError, TokenAliasType, TrackNameError, TrackStatus, TrackStatusCode, TrackStatusError, TrackStatusOk, Tuple, TupleField, Unsubscribe, UnsubscribeNamespace, VarIntOverflowError, VersionSpecificParameter, VersionSpecificParameterType, VersionSpecificParameters, VideoConfig, VideoFrameMarking, commonTypeFromNumber, controlMessageTypeFromBigInt, fetchErrorCodeFromBigInt, fetchTypeFromBigInt, filterTypeFromBigInt, groupOrderFromNumber, isBytes, isVarInt, locHeaderExtensionIdFromNumber, publishDoneStatusCodeFromBigInt, publishErrorCodeFromBigInt, publishNamespaceErrorCodeFromBigInt, setupParameterTypeFromNumber, subscribeErrorCodeFromBigInt, subscribeNamespaceErrorCodeFromBigInt, tokenAliasTypeFromNumber, trackStatusCodeFromBigInt, versionSpecificParameterTypeFromNumber };
+export { AudioLevel, AuthorizationToken, BaseByteBuffer12 as BaseByteBuffer, ByteBuffer, CaptureTimestamp, CastingError, ClientSetup, ClockNormalizer, CommonType, ControlMessage, ControlMessageType, ControlStream, DRAFT_14, DatagramObject, DatagramStatus, DeliveryTimeout, ExtensionHeader, ExtensionHeaders, Fetch, FetchCancel, FetchError, FetchErrorCode, FetchHeader, FetchHeaderType, FetchObject, FetchOk, FetchPublication, FetchRequest, FetchType, FilterType, FrozenByteBuffer5 as FrozenByteBuffer, FullTrackName, GoAway, GroupOrder, Header, HybridTrackSource, InternalError, InvalidTypeError, InvalidUTF8Error, KeyValueFormattingError, KeyValuePair, LOCHeaderExtensionId, LengthExceedsMaxError, LiveTrackSource, Location, MAX_FULL_TRACK_NAME_LENGTH, MAX_NAMESPACE_TUPLE_COUNT, MAX_REASON_PHRASE_LEN, MOQtailClient, MOQtailError, MaxAuthTokenCacheSize, MaxCacheDuration, MaxRequestId, MaxRequestId2 as MaxRequestIdParameter, MemoryObjectCache, MoqtObject, NetworkTelemetry, NotEnoughBytesError, ObjectDatagramStatusType, ObjectDatagramType, ObjectForwardingPreference, ObjectStatus, Path, PlayoutBuffer, ProtocolViolationError, Publish, PublishDone, PublishDoneStatusCode, PublishError, PublishErrorCode, PublishNamespace, PublishNamespaceCancel, PublishNamespaceDone, PublishNamespaceError, PublishNamespaceErrorCode, PublishNamespaceOk, PublishNamespaceRequest, PublishOk, PublishPublication, PublishRequest, PullPlayoutBuffer, ReasonPhrase, RecvDatagramStream, RecvStream, RequestIdError, RequestIdMap, RequestsBlocked, RingBufferObjectCache, SendDatagramStream, SendStream, ServerSetup, SetupParameter, SetupParameterType, SetupParameters, StaticTrackSource, SubgroupHeader, SubgroupHeaderType, SubgroupObject, Subscribe, SubscribeError, SubscribeErrorCode, SubscribeNamespace, SubscribeNamespaceError, SubscribeNamespaceErrorCode, SubscribeNamespaceOk, SubscribeNamespaceRequest, SubscribeOk, SubscribePublication, SubscribeRequest, SubscribeUpdate, Switch, TerminationCode, TerminationError, TimeoutError, TokenAliasType, TrackNameError, TrackStatus, TrackStatusCode, TrackStatusError, TrackStatusOk, Tuple, TupleField, Unsubscribe, UnsubscribeNamespace, VarIntOverflowError, VersionSpecificParameter, VersionSpecificParameterType, VersionSpecificParameters, VideoConfig, VideoFrameMarking, commonTypeFromNumber, controlMessageTypeFromBigInt, fetchErrorCodeFromBigInt, fetchTypeFromBigInt, filterTypeFromBigInt, groupOrderFromNumber, isBytes, isVarInt, locHeaderExtensionIdFromNumber, publishDoneStatusCodeFromBigInt, publishErrorCodeFromBigInt, publishNamespaceErrorCodeFromBigInt, setupParameterTypeFromNumber, subscribeErrorCodeFromBigInt, subscribeNamespaceErrorCodeFromBigInt, tokenAliasTypeFromNumber, trackStatusCodeFromBigInt, versionSpecificParameterTypeFromNumber };