moqtail 0.7.0 → 0.8.0

package/dist/index.cjs

@@ -583,27 +583,37 @@ exports.ObjectDatagramStatusType = void 0; exports.ObjectDatagramType = void 0;
 var init_constant = __esm({
   "src/model/data/constant.ts"() {
     exports.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;
     })(exports.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;
     })(exports.ObjectDatagramStatusType || (exports.ObjectDatagramStatusType = {}));
     exports.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;
     })(exports.ObjectDatagramType || {});
     ((ObjectDatagramType2) => {
@@ -611,14 +621,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;
     })(exports.ObjectDatagramType || (exports.ObjectDatagramType = {}));
     exports.FetchHeaderType = /* @__PURE__ */ ((FetchHeaderType3) => {
       FetchHeaderType3[FetchHeaderType3["Type0x05"] = 5] = "Type0x05";
@@ -773,11 +815,12 @@ var init_datagram_object = __esm({
     init_constant();
     init_location();
     exports.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;
       }
@@ -789,34 +832,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 = exports.ObjectDatagramType.fromProperties(hasExtensions, endOfGroup, objectIdIsZero);
         return new _DatagramObject(
-          1 /* WithExtensions */,
+          type,
           trackAlias,
           new exports.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 exports.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 exports.ByteBuffer();
         buf.putVI(this.type);
         buf.putVI(this.trackAlias);
         buf.putVI(this.location.group);
-        buf.putVI(this.location.object);
+        if (exports.ObjectDatagramType.hasObjectId(this.type)) {
+          buf.putVI(this.location.object);
+        }
         buf.putU8(this.publisherPriority);
-        if (this.type === 1 /* WithExtensions */) {
+        if (exports.ObjectDatagramType.hasExtensions(this.type)) {
           const extBuf = new exports.ByteBuffer();
           if (this.extensionHeaders) {
             for (const header of this.extensionHeaders) {
@@ -834,28 +891,32 @@ var init_datagram_object = __esm({
         const msgType = exports.ObjectDatagramType.tryFrom(msgTypeRaw);
         const trackAlias = buf.getVI();
         const groupId = buf.getVI();
-        const objectId = buf.getVI();
+        let objectId;
+        if (exports.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 exports.FrozenByteBuffer(extBytes);
-            extensionHeaders = [];
-            while (headerBytes.remaining > 0) {
-              extensionHeaders.push(headerBytes.getKeyValuePair());
-            }
-            break;
+        if (exports.ObjectDatagramType.hasExtensions(msgType)) {
+          const extBytes = buf.getLengthPrefixedBytes();
+          const headerBytes = new exports.FrozenByteBuffer(extBytes);
+          extensionHeaders = [];
+          while (headerBytes.remaining > 0) {
+            extensionHeaders.push(headerBytes.getKeyValuePair());
           }
         }
         const payload = buf.getBytes(buf.remaining);
+        const endOfGroup = exports.ObjectDatagramType.isEndOfGroup(msgType);
         return new _DatagramObject(
           msgType,
           trackAlias,
           new exports.Location(groupId, objectId),
           publisherPriority,
           extensionHeaders,
-          payload
+          payload,
+          endOfGroup
         );
       }
     };
@@ -887,25 +948,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 exports.ByteBuffer();
@@ -914,7 +985,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 (exports.ObjectDatagramStatusType.hasExtensions(this.type)) {
           const extBuf = new exports.ByteBuffer();
           if (this.extensionHeaders) {
             for (const header of this.extensionHeaders) {
@@ -935,18 +1006,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 exports.FrozenByteBuffer(extBytes);
-            extensionHeaders = [];
-            while (headerBytes.remaining > 0) {
-              extensionHeaders.push(headerBytes.getKeyValuePair());
-            }
-            break;
+        if (exports.ObjectDatagramStatusType.hasExtensions(msgType)) {
+          const extBytes = buf.getLengthPrefixedBytes();
+          const headerBytes = new exports.FrozenByteBuffer(extBytes);
+          extensionHeaders = [];
+          while (headerBytes.remaining > 0) {
+            extensionHeaders.push(headerBytes.getKeyValuePair());
           }
         }
-        console.log("Came here for trying tryFrom with object status");
         const objectStatus = exports.ObjectStatus.tryFrom(buf.getVI());
         return new _DatagramStatus(
           msgType,
@@ -1662,6 +1729,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,
@@ -1698,7 +1773,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 exports.CastingError(
             "MoqtObject.tryIntoDatagramObject",
@@ -1714,24 +1794,15 @@ var init_object = __esm({
           );
         }
         const alias = BigInt(trackAlias);
-        if (this.extensionHeaders && this.extensionHeaders.length > 0) {
-          return exports.DatagramObject.newWithExtensions(
-            alias,
-            this.groupId,
-            this.objectId,
-            this.publisherPriority,
-            this.extensionHeaders,
-            this.payload
-          );
-        } else {
-          return exports.DatagramObject.newWithoutExtensions(
-            alias,
-            this.groupId,
-            this.objectId,
-            this.publisherPriority,
-            this.payload
-          );
-        }
+        return exports.DatagramObject.new(
+          alias,
+          this.groupId,
+          this.objectId,
+          this.publisherPriority,
+          this.extensionHeaders,
+          this.payload,
+          endOfGroup
+        );
       }
       tryIntoDatagramStatus(trackAlias) {
         if (this.objectForwardingPreference !== "Datagram" /* Datagram */) {
@@ -2534,11 +2605,11 @@ function fetchTypeFromBigInt(v) {
       throw new exports.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) {
@@ -3544,15 +3615,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;
@@ -3560,11 +3630,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,
@@ -3581,9 +3650,7 @@ var Publish = class _Publish {
     buf.putVI(29 /* Publish */);
     const payload = new exports.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);
@@ -3605,10 +3672,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();
@@ -3624,8 +3688,7 @@ var Publish = class _Publish {
     }
     return new _Publish(
       requestId,
-      trackNamespace,
-      trackName,
+      fullTrackName,
       trackAlias,
       groupOrder,
       contentExists,
@@ -5497,6 +5560,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) {
@@ -6033,7 +6160,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
@@ -6119,8 +6251,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 exports.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 (exports.SubgroupHeaderType.hasExplicitSubgroupId(obj.getSubgroupHeaderType(true))) subgroupId = obj.subgroupId;
+            const header = new exports.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 exports.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 exports.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;
@@ -6274,7 +6627,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 = exports.DatagramStatus.deserialize(
@@ -6450,6 +6803,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. */
@@ -6477,6 +6834,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.
    *
@@ -6756,7 +7119,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) {
@@ -7482,6 +7845,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 exports.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
   /**
@@ -7630,10 +8060,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 exports.InternalError("MOQtailClient.subscribeNamespace", error instanceof Error ? error.message : String(error))
@@ -7786,8 +8226,9 @@ var MOQtailClient = class _MOQtailClient {
                     subgroupId = header.subgroupId;
                 }
                 const fullTrackName = this.aliasFullTrackNameMap.get(header.trackAlias);
-                if (!fullTrackName)
+                if (!fullTrackName) {
                   throw new exports.ProtocolViolationError("MOQtailClient", "No full track name for received track alias");
+                }
                 const moqtObject = exports.MoqtObject.fromSubgroupObject(
                   nextObject,
                   header.groupId,
@@ -8002,38 +8443,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 = [];
@@ -8426,43 +8835,6 @@ 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;
-  }
-};
-
-exports.AkamaiOffset = AkamaiOffset;
 exports.AuthorizationToken = AuthorizationToken;
 exports.ClientSetup = ClientSetup;
 exports.ClockNormalizer = ClockNormalizer;
@@ -8506,6 +8878,8 @@ exports.PublishNamespaceErrorCode = PublishNamespaceErrorCode;
 exports.PublishNamespaceOk = PublishNamespaceOk;
 exports.PublishNamespaceRequest = PublishNamespaceRequest;
 exports.PublishOk = PublishOk;
+exports.PublishPublication = PublishPublication;
+exports.PublishRequest = PublishRequest;
 exports.PullPlayoutBuffer = PullPlayoutBuffer;
 exports.RecvDatagramStream = RecvDatagramStream;
 exports.RecvStream = RecvStream;