moqtail 0.7.0

package/dist/model/index.cjs

@@ -0,0 +1,4759 @@
+'use strict';
+
+// src/model/error/error.ts
+var MOQtailError = class extends Error {
+  constructor(cause) {
+    super(cause);
+    this.name = this.constructor.name;
+  }
+};
+var NotEnoughBytesError = class extends MOQtailError {
+  constructor(context, needed, available) {
+    super(`[${context}] not enough bytes: needed ${needed}, available ${available}`);
+    this.context = context;
+    this.needed = needed;
+    this.available = available;
+  }
+};
+var CastingError = class extends MOQtailError {
+  constructor(context, fromType, toType, details) {
+    super(`[${context}] cannot cast from ${fromType} to ${toType}, [${details}]`);
+    this.context = context;
+    this.fromType = fromType;
+    this.toType = toType;
+    this.details = details;
+  }
+};
+var VarIntOverflowError = class extends MOQtailError {
+  constructor(context, value) {
+    super(`[${context}] value ${value} too large to encode as varint`);
+    this.context = context;
+    this.value = value;
+  }
+};
+var LengthExceedsMaxError = class extends MOQtailError {
+  constructor(context, max, len) {
+    super(`[${context}] length ${len} exceeds maximum of ${max}, protocol violation`);
+    this.context = context;
+    this.max = max;
+    this.len = len;
+  }
+};
+var KeyValueFormattingError = class extends MOQtailError {
+  constructor(context) {
+    super(`[${context}] key value formatting error`);
+    this.context = context;
+  }
+};
+var InvalidTypeError = class extends MOQtailError {
+  constructor(context, details) {
+    super(`Invalid type: [${context}], [${details}]`);
+    this.context = context;
+    this.details = details;
+  }
+};
+var InvalidUTF8Error = class extends MOQtailError {
+  constructor(context, details) {
+    super(`Invalid UTF8: [${context}], [${details}]`);
+    this.context = context;
+    this.details = details;
+  }
+};
+var ProtocolViolationError = class extends MOQtailError {
+  constructor(context, details) {
+    super(`Protocol violation: [${context}], [${details}]`);
+    this.context = context;
+    this.details = details;
+  }
+};
+var TrackNameError = class extends MOQtailError {
+  constructor(context, details) {
+    super(`Track naming error: [${context}], [${details}]`);
+    this.context = context;
+    this.details = details;
+  }
+};
+var RequestIdError = class extends MOQtailError {
+  constructor(context, details) {
+    super(`Request ID error: [${context}], [${details}]`);
+    this.context = context;
+    this.details = details;
+  }
+};
+var TimeoutError = class extends MOQtailError {
+  constructor(context) {
+    super(`Timeout: [${context}]`);
+    this.context = context;
+  }
+};
+var InternalError = class extends MOQtailError {
+  constructor(context, details) {
+    super(`Internal error: [${context}], [${details}]`);
+    this.context = context;
+    this.details = details;
+  }
+};
+var TerminationError = class extends MOQtailError {
+  constructor(context, terminationCode) {
+    super(`Connection terminated with code ${terminationCode}: ${context}`);
+    this.context = context;
+    this.terminationCode = terminationCode;
+  }
+};
+
+// src/model/common/pair.ts
+var MAX_VALUE_LENGTH = 2 ** 16 - 1;
+var KeyValuePair = class _KeyValuePair {
+  /**
+   * The key/type identifier for this pair.
+   * - Even: value is a varint.
+   * - Odd: value is a blob.
+   */
+  typeValue;
+  /**
+   * The value for this pair.
+   * - If `typeValue` is even: a varint (`bigint`).
+   * - If `typeValue` is odd: a binary blob (`Uint8Array`).
+   */
+  value;
+  /**
+   * Constructs a new KeyValuePair.
+   * @param typeValue - The key/type identifier.
+   * @param value - The value (varint or blob).
+   * @internal Use static factory methods instead.
+   */
+  constructor(typeValue, value) {
+    this.typeValue = typeValue;
+    this.value = value;
+  }
+  /**
+   * Creates a new varint KeyValuePair.
+   * @param typeValue - Must be even.
+   * @param value - The varint value.
+   * @returns A KeyValuePair with varint value.
+   * @throws KeyValueFormattingError if typeValue is not even.
+   */
+  static tryNewVarInt(typeValue, value) {
+    const tv = typeof typeValue === "number" ? BigInt(typeValue) : typeValue;
+    if (tv % 2n !== 0n) {
+      throw new KeyValueFormattingError("KeyValuePair.tryNewVarInt");
+    }
+    const v = typeof value === "number" ? BigInt(value) : value;
+    return new _KeyValuePair(tv, v);
+  }
+  /**
+   * Creates a new blob KeyValuePair.
+   * @param typeValue - Must be odd.
+   * @param value - The binary blob value.
+   * @returns A KeyValuePair with blob value.
+   * @throws KeyValueFormattingError if typeValue is not odd.
+   * @throws LengthExceedsMaxError if value length exceeds 65535 bytes.
+   */
+  static tryNewBytes(typeValue, value) {
+    const tv = typeof typeValue === "number" ? BigInt(typeValue) : typeValue;
+    if (tv % 2n === 0n) {
+      throw new KeyValueFormattingError("KeyValuePair.tryNewBytes");
+    }
+    const len = value.length;
+    if (len > MAX_VALUE_LENGTH) {
+      throw new LengthExceedsMaxError("KeyValuePair.tryNewBytes", MAX_VALUE_LENGTH, len);
+    }
+    return new _KeyValuePair(tv, value);
+  }
+  /**
+   * Serializes this key-value pair to a frozen byte buffer.
+   * @returns The serialized buffer.
+   */
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(this.typeValue);
+    if (isVarInt(this)) {
+      buf.putVI(this.value);
+    } else if (isBytes(this)) {
+      buf.putLengthPrefixedBytes(this.value);
+    }
+    return buf.freeze();
+  }
+  /**
+   * Deserializes a KeyValuePair from a buffer.
+   * @param buf - The buffer to read from.
+   * @returns The deserialized KeyValuePair.
+   * @throws LengthExceedsMaxError if blob length exceeds 65535 bytes.
+   * @throws NotEnoughBytesError if buffer does not contain enough bytes.
+   */
+  static deserialize(buf) {
+    const typeValue = buf.getVI();
+    if (typeValue % 2n === 0n) {
+      const value = buf.getVI();
+      return new _KeyValuePair(typeValue, value);
+    } else {
+      const len = buf.getNumberVI();
+      if (len > MAX_VALUE_LENGTH) {
+        throw new LengthExceedsMaxError("KeyValuePair.deserialize", MAX_VALUE_LENGTH, len);
+      }
+      const value = buf.getBytes(len);
+      return new _KeyValuePair(typeValue, value);
+    }
+  }
+  /**
+   * Checks if this pair is equal to another.
+   * @param other - The other KeyValuePair.
+   * @returns True if both type and value are equal.
+   */
+  equals(other) {
+    if (this.typeValue !== other.typeValue) return false;
+    if (isVarInt(this) && isVarInt(other)) {
+      return this.value === other.value;
+    }
+    if (isBytes(this) && isBytes(other)) {
+      const a = this.value;
+      const b = other.value;
+      if (a.length !== b.length) return false;
+      for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) return false;
+      }
+      return true;
+    }
+    return false;
+  }
+};
+function isVarInt(pair) {
+  return pair.typeValue % 2n === 0n;
+}
+function isBytes(pair) {
+  return pair.typeValue % 2n !== 0n;
+}
+
+// src/model/common/location.ts
+var Location = class _Location {
+  /**
+   * The group index for this location.
+   */
+  group;
+  /**
+   * The object index within the group for this location.
+   */
+  object;
+  /**
+   * Constructs a new Location.
+   * @param group - The group index (number or bigint).
+   * @param object - The object index (number or bigint).
+   */
+  constructor(group, object) {
+    this.group = BigInt(group);
+    this.object = BigInt(object);
+  }
+  /**
+   * Serializes this Location to a FrozenByteBuffer.
+   * @returns The serialized buffer.
+   * @throws CastingError if group or object is negative.
+   * @throws VarIntOverflowError if group or object exceeds varint encoding limits.
+   */
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(this.group);
+    buf.putVI(this.object);
+    return buf.freeze();
+  }
+  /**
+   * Deserializes a Location from a buffer.
+   * @param buf - The buffer to read from.
+   * @returns The deserialized Location.
+   * @throws NotEnoughBytesError if buffer does not contain enough bytes.
+   */
+  static deserialize(buf) {
+    const group = buf.getVI();
+    const object = buf.getVI();
+    return new _Location(group, object);
+  }
+  /**
+   * Checks if this Location is equal to another.
+   * @param other - The other Location to compare.
+   * @returns True if both group and object are equal.
+   */
+  equals(other) {
+    return this.group === other.group && this.object === other.object;
+  }
+  /**
+   * Compares this Location to another for ordering.
+   * @param other - The other Location to compare.
+   * @returns -1 if this \< other, 1 if this \> other, 0 if equal.
+   */
+  compare(other) {
+    if (this.group < other.group) return -1;
+    if (this.group > other.group) return 1;
+    if (this.object < other.object) return -1;
+    if (this.object > other.object) return 1;
+    return 0;
+  }
+};
+
+// src/model/common/tuple.ts
+var PATH_SEPARATOR = "/";
+var TupleField = class _TupleField {
+  /**
+   * The raw value of the field as a byte array.
+   */
+  constructor(value) {
+    this.value = value;
+  }
+  /**
+   * Creates a TupleField from a UTF-8 string.
+   * @param str - The string to encode.
+   * @returns A new TupleField containing the encoded value.
+   */
+  static fromUtf8(str) {
+    return new _TupleField(new TextEncoder().encode(str));
+  }
+  /**
+   * Decodes the field value to a UTF-8 string.
+   * @returns The decoded string.
+   */
+  toUtf8() {
+    return new TextDecoder().decode(this.value);
+  }
+  /**
+   * Serializes this field to a length-prefixed byte array.
+   * @returns The serialized bytes.
+   */
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(this.value.length);
+    buf.putBytes(this.value);
+    return buf.toUint8Array();
+  }
+  /**
+   * Deserializes a TupleField from a buffer.
+   * @param buf - The buffer to read from.
+   * @returns The deserialized TupleField.
+   * @throws CastingError if the length cannot be safely cast to number.
+   * @throws NotEnoughBytesError if buffer does not contain enough bytes.
+   */
+  static deserialize(buf) {
+    const lenBig = buf.getVI();
+    const len = Number(lenBig);
+    if (BigInt(len) !== lenBig) {
+      throw new CastingError("TupleField.deserialize", "bigint", "number", `${lenBig}`);
+    }
+    const bytes = buf.getBytes(len);
+    return new _TupleField(bytes);
+  }
+};
+var Tuple = class _Tuple {
+  /**
+   * The ordered list of fields in this tuple.
+   */
+  constructor(fields = []) {
+    this.fields = fields;
+  }
+  /**
+   * Creates a Tuple from a path string, splitting on '/'.
+   * @param path - The path string (e.g. '/foo/bar').
+   * @returns A Tuple with each segment as a field.
+   */
+  static fromUtf8Path(path) {
+    const parts = path.split(PATH_SEPARATOR).filter(Boolean);
+    const fields = parts.map(TupleField.fromUtf8);
+    return new _Tuple(fields);
+  }
+  /**
+   * Converts the tuple to a path string, joining fields with '/'.
+   * @returns The path string (e.g. '/foo/bar').
+   */
+  toUtf8Path() {
+    return this.fields.map((f) => PATH_SEPARATOR + f.toUtf8()).join("");
+  }
+  /**
+   * Adds a field to the tuple.
+   * @param field - The TupleField to add.
+   */
+  add(field) {
+    this.fields.push(field);
+  }
+  /**
+   * Gets the field at the specified index.
+   * @param index - The field index.
+   * @returns The TupleField at the index.
+   * @throws Error if no field exists at the index.
+   */
+  get(index) {
+    const field = this.fields[index];
+    if (!field) throw new Error("Field not found at index");
+    return field;
+  }
+  /**
+   * Sets the field at the specified index.
+   * @param index - The field index.
+   * @param field - The TupleField to set.
+   */
+  set(index, field) {
+    this.fields[index] = field;
+  }
+  /**
+   * Clears all fields from the tuple.
+   */
+  clear() {
+    this.fields.length = 0;
+  }
+  /**
+   * Serializes the tuple to a FrozenByteBuffer.
+   * @returns The serialized buffer.
+   */
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(this.fields.length);
+    for (const field of this.fields) {
+      buf.putBytes(field.serialize());
+    }
+    return buf.freeze();
+  }
+  /**
+   * Deserializes a Tuple from a buffer.
+   * @param buf - The buffer to read from.
+   * @returns The deserialized Tuple.
+   * @throws CastingError if the count cannot be safely cast to number.
+   * @throws NotEnoughBytesError if buffer does not contain enough bytes.
+   */
+  static deserialize(buf) {
+    const countBig = buf.getVI();
+    const count = Number(countBig);
+    if (BigInt(count) !== countBig) {
+      throw new CastingError("Tuple.deserialize", "bigint", "number", `${countBig}`);
+    }
+    const fields = [];
+    for (let i = 0; i < count; i++) {
+      const field = TupleField.deserialize(buf);
+      fields.push(field);
+    }
+    return new _Tuple(fields);
+  }
+  /**
+   * Checks if this tuple is equal to another.
+   * @param other - The other Tuple to compare.
+   * @returns True if all fields are equal.
+   */
+  equals(other) {
+    if (this.fields.length !== other.fields.length) return false;
+    return this.fields.every((f, i) => f.value.toString() === other.fields[i].value.toString());
+  }
+};
+
+// src/model/common/reason_phrase.ts
+var MAX_REASON_PHRASE_LEN = 1024;
+var ReasonPhrase = class _ReasonPhrase {
+  /**
+   * The underlying phrase string.
+   * @public
+   */
+  #phrase;
+  /**
+   * Constructs a ReasonPhrase, validating UTF-8 encoding and length.
+   *
+   * @param phrase - The string to use as the reason phrase.
+   * @throws {@link InvalidUTF8Error} if encoding fails.
+   * @throws {@link LengthExceedsMaxError} if the encoded phrase exceeds {@link MAX_REASON_PHRASE_LEN} bytes.
+   * @public
+   */
+  constructor(phrase) {
+    let encodedPhrase;
+    try {
+      encodedPhrase = new TextEncoder().encode(phrase);
+    } catch (e) {
+      const errorMessage = e instanceof Error ? e.message : String(e);
+      throw new InvalidUTF8Error("ReasonPhrase.constructor (TextEncoder failed)", errorMessage);
+    }
+    if (encodedPhrase.length > MAX_REASON_PHRASE_LEN) {
+      throw new LengthExceedsMaxError("ReasonPhrase.constructor", MAX_REASON_PHRASE_LEN, encodedPhrase.length);
+    }
+    this.#phrase = phrase;
+  }
+  /**
+   * Returns the phrase string.
+   * @public
+   */
+  get phrase() {
+    return this.#phrase;
+  }
+  /**
+   * Serializes the ReasonPhrase into a {@link FrozenByteBuffer} containing:
+   * varint(length_of_phrase_bytes) || phrase_bytes
+   *
+   * @returns The serialized buffer.
+   * @public
+   */
+  serialize() {
+    const buf = new ByteBuffer();
+    const phraseBytes = new TextEncoder().encode(this.#phrase);
+    buf.putVI(phraseBytes.length);
+    buf.putBytes(phraseBytes);
+    return buf.freeze();
+  }
+  /**
+   * Deserializes a ReasonPhrase from the given buffer.
+   * Reads varint(length) || utf8‑bytes.
+   *
+   * @param buf - The buffer to read from.
+   * @returns The deserialized ReasonPhrase.
+   * @throws :{@link CastingError} if the length cannot be safely cast to a number.
+   * @throws :{@link LengthExceedsMaxError} if the length exceeds {@link MAX_REASON_PHRASE_LEN}.
+   * @throws :{@link NotEnoughBytesError} if the buffer does not contain enough bytes.
+   * @throws :{@link InvalidUTF8Error} if decoding fails.
+   * @public
+   */
+  static deserialize(buf) {
+    const lenBig = buf.getVI();
+    let len;
+    try {
+      len = Number(lenBig);
+      if (BigInt(len) !== lenBig) {
+        throw new Error(`Value ${lenBig.toString()} cannot be accurately represented as a number.`);
+      }
+    } catch (e) {
+      const errorDetails = e instanceof Error ? e.message : String(e);
+      throw new CastingError("ReasonPhrase.deserialize length", "bigint", "number", errorDetails);
+    }
+    if (len > MAX_REASON_PHRASE_LEN) {
+      throw new LengthExceedsMaxError("ReasonPhrase.deserialize", MAX_REASON_PHRASE_LEN, len);
+    }
+    if (buf.remaining < len) {
+      throw new NotEnoughBytesError("ReasonPhrase.deserialize value", len, buf.remaining);
+    }
+    const phraseBytes = buf.getBytes(len);
+    try {
+      const phraseStr = new TextDecoder("utf-8", { fatal: true }).decode(phraseBytes);
+      return new _ReasonPhrase(phraseStr);
+    } catch (e) {
+      const errorMessage = e instanceof Error ? e.message : String(e);
+      throw new InvalidUTF8Error("ReasonPhrase.deserialize (decode)", errorMessage);
+    }
+  }
+};
+
+// src/model/data/constant.ts
+exports.ObjectDatagramStatusType = /* @__PURE__ */ ((ObjectDatagramStatusType2) => {
+  ObjectDatagramStatusType2[ObjectDatagramStatusType2["WithoutExtensions"] = 2] = "WithoutExtensions";
+  ObjectDatagramStatusType2[ObjectDatagramStatusType2["WithExtensions"] = 3] = "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 */;
+      default:
+        throw new Error(`Invalid ObjectDatagramStatusType: ${value}`);
+    }
+  }
+  ObjectDatagramStatusType2.tryFrom = tryFrom;
+})(exports.ObjectDatagramStatusType || (exports.ObjectDatagramStatusType = {}));
+exports.ObjectDatagramType = /* @__PURE__ */ ((ObjectDatagramType2) => {
+  ObjectDatagramType2[ObjectDatagramType2["WithoutExtensions"] = 0] = "WithoutExtensions";
+  ObjectDatagramType2[ObjectDatagramType2["WithExtensions"] = 1] = "WithExtensions";
+  return ObjectDatagramType2;
+})(exports.ObjectDatagramType || {});
+((ObjectDatagramType2) => {
+  function tryFrom(value) {
+    const v = typeof value === "bigint" ? Number(value) : value;
+    switch (v) {
+      case 0:
+        return 0 /* WithoutExtensions */;
+      case 1:
+        return 1 /* WithExtensions */;
+      default:
+        throw new Error(`Invalid ObjectDatagramType: ${value}`);
+    }
+  }
+  ObjectDatagramType2.tryFrom = tryFrom;
+})(exports.ObjectDatagramType || (exports.ObjectDatagramType = {}));
+exports.FetchHeaderType = /* @__PURE__ */ ((FetchHeaderType2) => {
+  FetchHeaderType2[FetchHeaderType2["Type0x05"] = 5] = "Type0x05";
+  return FetchHeaderType2;
+})(exports.FetchHeaderType || {});
+((FetchHeaderType2) => {
+  function tryFrom(value) {
+    const v = typeof value === "bigint" ? Number(value) : value;
+    switch (v) {
+      case 5:
+        return 5 /* Type0x05 */;
+      default:
+        throw new Error(`Invalid FetchHeaderType: ${value}`);
+    }
+  }
+  FetchHeaderType2.tryFrom = tryFrom;
+})(exports.FetchHeaderType || (exports.FetchHeaderType = {}));
+exports.SubgroupHeaderType = /* @__PURE__ */ ((SubgroupHeaderType2) => {
+  SubgroupHeaderType2[SubgroupHeaderType2["Type0x10"] = 16] = "Type0x10";
+  SubgroupHeaderType2[SubgroupHeaderType2["Type0x11"] = 17] = "Type0x11";
+  SubgroupHeaderType2[SubgroupHeaderType2["Type0x12"] = 18] = "Type0x12";
+  SubgroupHeaderType2[SubgroupHeaderType2["Type0x13"] = 19] = "Type0x13";
+  SubgroupHeaderType2[SubgroupHeaderType2["Type0x14"] = 20] = "Type0x14";
+  SubgroupHeaderType2[SubgroupHeaderType2["Type0x15"] = 21] = "Type0x15";
+  SubgroupHeaderType2[SubgroupHeaderType2["Type0x18"] = 24] = "Type0x18";
+  SubgroupHeaderType2[SubgroupHeaderType2["Type0x19"] = 25] = "Type0x19";
+  SubgroupHeaderType2[SubgroupHeaderType2["Type0x1A"] = 26] = "Type0x1A";
+  SubgroupHeaderType2[SubgroupHeaderType2["Type0x1B"] = 27] = "Type0x1B";
+  SubgroupHeaderType2[SubgroupHeaderType2["Type0x1C"] = 28] = "Type0x1C";
+  SubgroupHeaderType2[SubgroupHeaderType2["Type0x1D"] = 29] = "Type0x1D";
+  return SubgroupHeaderType2;
+})(exports.SubgroupHeaderType || {});
+((SubgroupHeaderType2) => {
+  function hasExplicitSubgroupId(t) {
+    switch (t) {
+      case 20 /* Type0x14 */:
+      case 21 /* Type0x15 */:
+      case 28 /* Type0x1C */:
+      case 29 /* Type0x1D */:
+        return true;
+      default:
+        return false;
+    }
+  }
+  SubgroupHeaderType2.hasExplicitSubgroupId = hasExplicitSubgroupId;
+  function isSubgroupIdZero(t) {
+    switch (t) {
+      case 16 /* Type0x10 */:
+      case 17 /* Type0x11 */:
+      case 24 /* Type0x18 */:
+      case 25 /* Type0x19 */:
+        return true;
+      default:
+        return false;
+    }
+  }
+  SubgroupHeaderType2.isSubgroupIdZero = isSubgroupIdZero;
+  function hasExtensions(t) {
+    switch (t) {
+      case 17 /* Type0x11 */:
+      case 19 /* Type0x13 */:
+      case 21 /* Type0x15 */:
+      case 25 /* Type0x19 */:
+      case 27 /* Type0x1B */:
+      case 29 /* Type0x1D */:
+        return true;
+      default:
+        return false;
+    }
+  }
+  SubgroupHeaderType2.hasExtensions = hasExtensions;
+  function tryFrom(value) {
+    const v = typeof value === "bigint" ? Number(value) : value;
+    switch (v) {
+      case 16:
+        return 16 /* Type0x10 */;
+      case 17:
+        return 17 /* Type0x11 */;
+      case 18:
+        return 18 /* Type0x12 */;
+      case 19:
+        return 19 /* Type0x13 */;
+      case 20:
+        return 20 /* Type0x14 */;
+      case 21:
+        return 21 /* Type0x15 */;
+      case 24:
+        return 24 /* Type0x18 */;
+      case 25:
+        return 25 /* Type0x19 */;
+      case 26:
+        return 26 /* Type0x1A */;
+      case 27:
+        return 27 /* Type0x1B */;
+      case 28:
+        return 28 /* Type0x1C */;
+      case 29:
+        return 29 /* Type0x1D */;
+      default:
+        throw new Error(`Invalid SubgroupHeaderType: ${value}`);
+    }
+  }
+  SubgroupHeaderType2.tryFrom = tryFrom;
+})(exports.SubgroupHeaderType || (exports.SubgroupHeaderType = {}));
+exports.ObjectForwardingPreference = /* @__PURE__ */ ((ObjectForwardingPreference2) => {
+  ObjectForwardingPreference2["Subgroup"] = "Subgroup";
+  ObjectForwardingPreference2["Datagram"] = "Datagram";
+  return ObjectForwardingPreference2;
+})(exports.ObjectForwardingPreference || {});
+((ObjectForwardingPreference2) => {
+  function tryFrom(value) {
+    if (value === "Subgroup") return "Subgroup" /* Subgroup */;
+    if (value === "Datagram") return "Datagram" /* Datagram */;
+    throw new Error(`Invalid ObjectForwardingPreference: ${value}`);
+  }
+  ObjectForwardingPreference2.tryFrom = tryFrom;
+})(exports.ObjectForwardingPreference || (exports.ObjectForwardingPreference = {}));
+exports.ObjectStatus = /* @__PURE__ */ ((ObjectStatus2) => {
+  ObjectStatus2[ObjectStatus2["Normal"] = 0] = "Normal";
+  ObjectStatus2[ObjectStatus2["DoesNotExist"] = 1] = "DoesNotExist";
+  ObjectStatus2[ObjectStatus2["EndOfGroup"] = 3] = "EndOfGroup";
+  ObjectStatus2[ObjectStatus2["EndOfTrack"] = 4] = "EndOfTrack";
+  return ObjectStatus2;
+})(exports.ObjectStatus || {});
+((ObjectStatus2) => {
+  function tryFrom(value) {
+    const v = typeof value === "bigint" ? Number(value) : value;
+    switch (v) {
+      case 0:
+        return 0 /* Normal */;
+      case 1:
+        return 1 /* DoesNotExist */;
+      case 3:
+        return 3 /* EndOfGroup */;
+      case 4:
+        return 4 /* EndOfTrack */;
+      default:
+        throw new Error(`Invalid ObjectStatus: ${value}`);
+    }
+  }
+  ObjectStatus2.tryFrom = tryFrom;
+})(exports.ObjectStatus || (exports.ObjectStatus = {}));
+
+// src/model/data/datagram_object.ts
+var DatagramObject = class _DatagramObject {
+  constructor(type, trackAlias, location, publisherPriority, extensionHeaders, payload) {
+    this.type = type;
+    this.publisherPriority = publisherPriority;
+    this.extensionHeaders = extensionHeaders;
+    this.payload = payload;
+    this.trackAlias = BigInt(trackAlias);
+    this.location = location;
+  }
+  trackAlias;
+  location;
+  get groupId() {
+    return this.location.group;
+  }
+  get objectId() {
+    return this.location.object;
+  }
+  static newWithExtensions(trackAlias, groupId, objectId, publisherPriority, extensionHeaders, payload) {
+    return new _DatagramObject(
+      1 /* WithExtensions */,
+      trackAlias,
+      new Location(groupId, objectId),
+      publisherPriority,
+      extensionHeaders,
+      payload
+    );
+  }
+  static newWithoutExtensions(trackAlias, groupId, objectId, publisherPriority, payload) {
+    return new _DatagramObject(
+      0 /* WithoutExtensions */,
+      trackAlias,
+      new Location(groupId, objectId),
+      publisherPriority,
+      null,
+      payload
+    );
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(this.type);
+    buf.putVI(this.trackAlias);
+    buf.putVI(this.location.group);
+    buf.putVI(this.location.object);
+    buf.putU8(this.publisherPriority);
+    if (this.type === 1 /* WithExtensions */) {
+      const extBuf = new ByteBuffer();
+      if (this.extensionHeaders) {
+        for (const header of this.extensionHeaders) {
+          extBuf.putKeyValuePair(header);
+        }
+      }
+      const extBytes = extBuf.toUint8Array();
+      buf.putLengthPrefixedBytes(extBytes);
+    }
+    buf.putBytes(this.payload);
+    return buf.freeze();
+  }
+  static deserialize(buf) {
+    const msgTypeRaw = buf.getNumberVI();
+    const msgType = exports.ObjectDatagramType.tryFrom(msgTypeRaw);
+    const trackAlias = buf.getVI();
+    const groupId = buf.getVI();
+    const objectId = buf.getVI();
+    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;
+      }
+    }
+    const payload = buf.getBytes(buf.remaining);
+    return new _DatagramObject(
+      msgType,
+      trackAlias,
+      new Location(groupId, objectId),
+      publisherPriority,
+      extensionHeaders,
+      payload
+    );
+  }
+};
+
+// src/model/data/datagram_status.ts
+var DatagramStatus = class _DatagramStatus {
+  constructor(type, trackAlias, location, publisherPriority, extensionHeaders, objectStatus) {
+    this.type = type;
+    this.publisherPriority = publisherPriority;
+    this.extensionHeaders = extensionHeaders;
+    this.objectStatus = objectStatus;
+    this.trackAlias = BigInt(trackAlias);
+    this.location = location;
+  }
+  trackAlias;
+  location;
+  get groupId() {
+    return this.location.group;
+  }
+  get objectId() {
+    return this.location.object;
+  }
+  static withExtensions(trackAlias, location, publisherPriority, extensionHeaders, objectStatus) {
+    return new _DatagramStatus(
+      3 /* WithExtensions */,
+      trackAlias,
+      location,
+      publisherPriority,
+      extensionHeaders,
+      objectStatus
+    );
+  }
+  static newWithoutExtensions(trackAlias, location, publisherPriority, objectStatus) {
+    return new _DatagramStatus(
+      2 /* WithoutExtensions */,
+      trackAlias,
+      location,
+      publisherPriority,
+      null,
+      objectStatus
+    );
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(this.type);
+    buf.putVI(this.trackAlias);
+    buf.putVI(this.location.group);
+    buf.putVI(this.location.object);
+    buf.putU8(this.publisherPriority);
+    if (this.type === 3 /* WithExtensions */) {
+      const extBuf = new ByteBuffer();
+      if (this.extensionHeaders) {
+        for (const header of this.extensionHeaders) {
+          extBuf.putKeyValuePair(header);
+        }
+      }
+      const extBytes = extBuf.toUint8Array();
+      buf.putLengthPrefixedBytes(extBytes);
+    }
+    buf.putVI(this.objectStatus);
+    return buf.freeze();
+  }
+  static deserialize(buf) {
+    const msgTypeRaw = buf.getNumberVI();
+    const msgType = exports.ObjectDatagramStatusType.tryFrom(msgTypeRaw);
+    const trackAlias = buf.getVI();
+    const groupId = buf.getVI();
+    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;
+      }
+    }
+    console.log("Came here for trying tryFrom with object status");
+    const objectStatus = exports.ObjectStatus.tryFrom(buf.getVI());
+    return new _DatagramStatus(
+      msgType,
+      trackAlias,
+      new Location(groupId, objectId),
+      publisherPriority,
+      extensionHeaders,
+      objectStatus
+    );
+  }
+};
+
+// src/model/data/fetch_header.ts
+var FetchHeader = class _FetchHeader {
+  constructor(type, requestId) {
+    this.type = type;
+    this.requestId = BigInt(requestId);
+  }
+  requestId;
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(this.type);
+    buf.putVI(this.requestId);
+    return buf.freeze();
+  }
+  static deserialize(buf) {
+    const typeRaw = buf.getVI();
+    const type = exports.FetchHeaderType.tryFrom(typeRaw);
+    const requestId = buf.getVI();
+    return new _FetchHeader(type, requestId);
+  }
+};
+
+// src/model/data/fetch_object.ts
+var FetchObject = class _FetchObject {
+  constructor(location, subgroupId, publisherPriority, extensionHeaders, objectStatus, payload) {
+    this.publisherPriority = publisherPriority;
+    this.extensionHeaders = extensionHeaders;
+    this.objectStatus = objectStatus;
+    this.payload = payload;
+    this.location = location;
+    this.subgroupId = BigInt(subgroupId);
+  }
+  location;
+  subgroupId;
+  get groupId() {
+    return this.location.group;
+  }
+  get objectId() {
+    return this.location.object;
+  }
+  static newWithStatus(groupId, subgroupId, objectId, publisherPriority, extensionHeaders, objectStatus) {
+    return new _FetchObject(
+      new Location(groupId, objectId),
+      subgroupId,
+      publisherPriority,
+      extensionHeaders,
+      objectStatus,
+      null
+    );
+  }
+  static newWithPayload(groupId, subgroupId, objectId, publisherPriority, extensionHeaders, payload) {
+    return new _FetchObject(
+      new Location(groupId, objectId),
+      subgroupId,
+      publisherPriority,
+      extensionHeaders,
+      null,
+      payload
+    );
+  }
+  // to be compatible with subgroup_object serialize method
+  serialize(_previousObjectId) {
+    const buf = new ByteBuffer();
+    buf.putVI(this.location.group);
+    buf.putVI(this.subgroupId);
+    buf.putVI(this.location.object);
+    buf.putU8(this.publisherPriority);
+    const extensionHeaders = new ByteBuffer();
+    if (this.extensionHeaders) {
+      for (const header of this.extensionHeaders) {
+        extensionHeaders.putKeyValuePair(header);
+      }
+    }
+    const extBytes = extensionHeaders.toUint8Array();
+    buf.putLengthPrefixedBytes(extBytes);
+    if (this.payload) {
+      buf.putLengthPrefixedBytes(this.payload);
+    } else {
+      buf.putVI(0);
+      buf.putVI(this.objectStatus);
+    }
+    return buf.freeze();
+  }
+  static deserialize(buf) {
+    const groupId = buf.getVI();
+    const subgroupId = buf.getVI();
+    const objectId = buf.getVI();
+    const publisherPriority = buf.getU8();
+    const extLen = buf.getNumberVI();
+    let extensionHeaders = null;
+    if (extLen > 0) {
+      const headerBytes = new FrozenByteBuffer5(buf.getBytes(extLen));
+      extensionHeaders = [];
+      while (headerBytes.remaining > 0) {
+        extensionHeaders.push(headerBytes.getKeyValuePair());
+      }
+    }
+    const payloadLen = buf.getNumberVI();
+    let objectStatus = null;
+    let payload = null;
+    if (payloadLen === 0) {
+      objectStatus = exports.ObjectStatus.tryFrom(buf.getVI());
+    } else {
+      payload = buf.getBytes(payloadLen);
+    }
+    return new _FetchObject(
+      new Location(groupId, objectId),
+      subgroupId,
+      publisherPriority,
+      extensionHeaders,
+      objectStatus,
+      payload
+    );
+  }
+};
+
+// src/model/data/full_track_name.ts
+var MAX_NAMESPACE_TUPLE_COUNT = 32;
+var MAX_FULL_TRACK_NAME_LENGTH = 4096;
+var FullTrackName = class _FullTrackName {
+  constructor(namespace, name) {
+    this.namespace = namespace;
+    this.name = name;
+  }
+  /**
+   * Human-readable representation: `\<namespace path joined by '/'\>:\<name as lowercase hex\>`.
+   * If the underlying {@link Tuple} exposes `toUtf8Path`, it's used; otherwise the raw fields are joined.
+   * This is lossy only in the sense that name bytes are hex encoded; round-tripping requires serialization.
+   */
+  toString() {
+    const nsStr = this.namespace.toUtf8Path ? this.namespace.toUtf8Path() : Array.from(this.namespace.fields).join("/");
+    const nameStr = Array.from(this.name).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return `${nsStr}:${nameStr}`;
+  }
+  /**
+   * Construct a validated full track name.
+   *
+   * Validation steps:
+   * 1. Convert namespace string -\> {@link Tuple} (split on '/') if needed.
+   * 2. Reject if namespace tuple field count is 0 or \> {@link MAX_NAMESPACE_TUPLE_COUNT}.
+   * 3. Encode name string to UTF-8 if needed.
+   * 4. Reject if total serialized length (namespace tuple + name bytes) \> {@link MAX_FULL_TRACK_NAME_LENGTH}.
+   *
+   * @throws :{@link TrackNameError} on any constraint violation.
+   * @example
+   * ```ts
+   * const full = FullTrackName.tryNew('media/video', 'keyframe')
+   * console.log(full.toString()) // media/video:6b65796672616d65
+   * ```
+   */
+  static tryNew(namespace, name) {
+    const nsTuple = typeof namespace === "string" ? Tuple.fromUtf8Path(namespace) : namespace;
+    const nsCount = nsTuple.fields.length;
+    if (nsCount === 0 || nsCount > MAX_NAMESPACE_TUPLE_COUNT) {
+      throw new TrackNameError(
+        "FullTrackName::tryNew(nsCount)",
+        `Namespace cannot be empty or cannot exceed ${MAX_NAMESPACE_TUPLE_COUNT} fields`
+      );
+    }
+    const nameBytes = typeof name === "string" ? new TextEncoder().encode(name) : name;
+    const totalLen = nsTuple.serialize().toUint8Array().length + nameBytes.length;
+    if (totalLen > MAX_FULL_TRACK_NAME_LENGTH) {
+      throw new TrackNameError(
+        "FullTrackName::tryNew(totalLen)",
+        `Total length cannot exceed ${MAX_FULL_TRACK_NAME_LENGTH}`
+      );
+    }
+    return new _FullTrackName(nsTuple, nameBytes);
+  }
+  /**
+   * Serialize to a frozen buffer: tuple (namespace) followed by length‑prefixed name bytes.
+   * Consumers needing raw bytes should call `.toUint8Array()` on the returned {@link FrozenByteBuffer}.
+   */
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putTuple(this.namespace);
+    buf.putLengthPrefixedBytes(this.name);
+    return buf.freeze();
+  }
+  /**
+   * Parse a serialized full track name. Performs the same validations as {@link FullTrackName.tryNew}.
+   * The provided buffer's read cursor advances accordingly.
+   * @throws :{@link TrackNameError} if constraints are violated.
+   */
+  static deserialize(buf) {
+    const namespace = buf.getTuple();
+    const nsCount = namespace.fields.length;
+    if (nsCount === 0 || nsCount > MAX_NAMESPACE_TUPLE_COUNT) {
+      throw new TrackNameError(
+        "FullTrackName::deserialize(nsCount)",
+        `Namespace cannot be empty or cannot exceed ${MAX_NAMESPACE_TUPLE_COUNT} fields`
+      );
+    }
+    const name = buf.getLengthPrefixedBytes();
+    const totalLen = namespace.serialize().toUint8Array().length + name.length;
+    if (totalLen > MAX_FULL_TRACK_NAME_LENGTH) {
+      throw new TrackNameError(
+        "FullTrackName::deserialize(totalLen)",
+        `Total length cannot exceed ${MAX_FULL_TRACK_NAME_LENGTH}`
+      );
+    }
+    return new _FullTrackName(namespace, name);
+  }
+};
+
+// src/model/error/constant.ts
+exports.TerminationCode = /* @__PURE__ */ ((TerminationCode2) => {
+  TerminationCode2[TerminationCode2["NO_ERROR"] = 0] = "NO_ERROR";
+  TerminationCode2[TerminationCode2["INTERNAL_ERROR"] = 1] = "INTERNAL_ERROR";
+  TerminationCode2[TerminationCode2["UNAUTHORIZED"] = 2] = "UNAUTHORIZED";
+  TerminationCode2[TerminationCode2["PROTOCOL_VIOLATION"] = 3] = "PROTOCOL_VIOLATION";
+  TerminationCode2[TerminationCode2["INVALID_REQUEST_ID"] = 4] = "INVALID_REQUEST_ID";
+  TerminationCode2[TerminationCode2["DUPLICATE_TRACK_ALIAS"] = 5] = "DUPLICATE_TRACK_ALIAS";
+  TerminationCode2[TerminationCode2["KEY_VALUE_FORMATTING_ERROR"] = 6] = "KEY_VALUE_FORMATTING_ERROR";
+  TerminationCode2[TerminationCode2["TOO_MANY_REQUESTS"] = 7] = "TOO_MANY_REQUESTS";
+  TerminationCode2[TerminationCode2["INVALID_PATH"] = 8] = "INVALID_PATH";
+  TerminationCode2[TerminationCode2["MALFORMED_PATH"] = 9] = "MALFORMED_PATH";
+  TerminationCode2[TerminationCode2["GOAWAY_TIMEOUT"] = 16] = "GOAWAY_TIMEOUT";
+  TerminationCode2[TerminationCode2["CONTROL_MESSAGE_TIMEOUT"] = 17] = "CONTROL_MESSAGE_TIMEOUT";
+  TerminationCode2[TerminationCode2["DATA_STREAM_TIMEOUT"] = 18] = "DATA_STREAM_TIMEOUT";
+  TerminationCode2[TerminationCode2["AUTH_TOKEN_CACHE_OVERFLOW"] = 19] = "AUTH_TOKEN_CACHE_OVERFLOW";
+  TerminationCode2[TerminationCode2["DUPLICATE_AUTH_TOKEN_ALIAS"] = 20] = "DUPLICATE_AUTH_TOKEN_ALIAS";
+  TerminationCode2[TerminationCode2["VERSION_NEGOTIATION_FAILED"] = 21] = "VERSION_NEGOTIATION_FAILED";
+  TerminationCode2[TerminationCode2["MALFORMED_AUTH_TOKEN"] = 22] = "MALFORMED_AUTH_TOKEN";
+  TerminationCode2[TerminationCode2["UNKNOWN_AUTH_TOKEN_ALIAS"] = 23] = "UNKNOWN_AUTH_TOKEN_ALIAS";
+  TerminationCode2[TerminationCode2["EXPIRED_AUTH_TOKEN"] = 24] = "EXPIRED_AUTH_TOKEN";
+  TerminationCode2[TerminationCode2["INVALID_AUTHORITY"] = 25] = "INVALID_AUTHORITY";
+  TerminationCode2[TerminationCode2["MALFORMED_AUTHORITY"] = 26] = "MALFORMED_AUTHORITY";
+  return TerminationCode2;
+})(exports.TerminationCode || {});
+((TerminationCode2) => {
+  function tryFrom(code) {
+    switch (code) {
+      case 0 /* NO_ERROR */:
+        return 0 /* NO_ERROR */;
+      case 1 /* INTERNAL_ERROR */:
+        return 1 /* INTERNAL_ERROR */;
+      case 2 /* UNAUTHORIZED */:
+        return 2 /* UNAUTHORIZED */;
+      case 3 /* PROTOCOL_VIOLATION */:
+        return 3 /* PROTOCOL_VIOLATION */;
+      case 4 /* INVALID_REQUEST_ID */:
+        return 4 /* INVALID_REQUEST_ID */;
+      case 5 /* DUPLICATE_TRACK_ALIAS */:
+        return 5 /* DUPLICATE_TRACK_ALIAS */;
+      case 6 /* KEY_VALUE_FORMATTING_ERROR */:
+        return 6 /* KEY_VALUE_FORMATTING_ERROR */;
+      case 7 /* TOO_MANY_REQUESTS */:
+        return 7 /* TOO_MANY_REQUESTS */;
+      case 8 /* INVALID_PATH */:
+        return 8 /* INVALID_PATH */;
+      case 9 /* MALFORMED_PATH */:
+        return 9 /* MALFORMED_PATH */;
+      case 16 /* GOAWAY_TIMEOUT */:
+        return 16 /* GOAWAY_TIMEOUT */;
+      case 17 /* CONTROL_MESSAGE_TIMEOUT */:
+        return 17 /* CONTROL_MESSAGE_TIMEOUT */;
+      case 18 /* DATA_STREAM_TIMEOUT */:
+        return 18 /* DATA_STREAM_TIMEOUT */;
+      case 19 /* AUTH_TOKEN_CACHE_OVERFLOW */:
+        return 19 /* AUTH_TOKEN_CACHE_OVERFLOW */;
+      case 20 /* DUPLICATE_AUTH_TOKEN_ALIAS */:
+        return 20 /* DUPLICATE_AUTH_TOKEN_ALIAS */;
+      case 21 /* VERSION_NEGOTIATION_FAILED */:
+        return 21 /* VERSION_NEGOTIATION_FAILED */;
+      default:
+        throw new InvalidTypeError("TerminationCode.tryFrom", `Unknown termination code: ${code}`);
+    }
+  }
+  TerminationCode2.tryFrom = tryFrom;
+})(exports.TerminationCode || (exports.TerminationCode = {}));
+
+// src/model/extension_header/constant.ts
+var LOCHeaderExtensionId = /* @__PURE__ */ ((LOCHeaderExtensionId2) => {
+  LOCHeaderExtensionId2[LOCHeaderExtensionId2["CaptureTimestamp"] = 2] = "CaptureTimestamp";
+  LOCHeaderExtensionId2[LOCHeaderExtensionId2["VideoFrameMarking"] = 4] = "VideoFrameMarking";
+  LOCHeaderExtensionId2[LOCHeaderExtensionId2["AudioLevel"] = 6] = "AudioLevel";
+  LOCHeaderExtensionId2[LOCHeaderExtensionId2["VideoConfig"] = 13] = "VideoConfig";
+  return LOCHeaderExtensionId2;
+})(LOCHeaderExtensionId || {});
+function locHeaderExtensionIdFromNumber(value) {
+  switch (value) {
+    case 2:
+      return 2 /* CaptureTimestamp */;
+    case 4:
+      return 4 /* VideoFrameMarking */;
+    case 6:
+      return 6 /* AudioLevel */;
+    case 13:
+      return 13 /* VideoConfig */;
+    default:
+      throw new InvalidTypeError("locHeaderExtensionIdFromNumber", `Invalid LOC header extension id: ${value}`);
+  }
+}
+
+// src/model/extension_header/capture_time_stamp.ts
+var CaptureTimestamp = class _CaptureTimestamp {
+  constructor(timestamp) {
+    this.timestamp = timestamp;
+  }
+  static TYPE = 2 /* CaptureTimestamp */;
+  toKeyValuePair() {
+    return KeyValuePair.tryNewVarInt(_CaptureTimestamp.TYPE, this.timestamp);
+  }
+  static fromKeyValuePair(pair) {
+    const type = Number(pair.typeValue);
+    if (type === _CaptureTimestamp.TYPE && typeof pair.value === "bigint") {
+      return new _CaptureTimestamp(pair.value);
+    }
+    return void 0;
+  }
+};
+
+// src/model/extension_header/video_frame_marking.ts
+var VideoFrameMarking = class _VideoFrameMarking {
+  constructor(value) {
+    this.value = value;
+  }
+  static TYPE = 4 /* VideoFrameMarking */;
+  toKeyValuePair() {
+    return KeyValuePair.tryNewVarInt(_VideoFrameMarking.TYPE, this.value);
+  }
+  static fromKeyValuePair(pair) {
+    const type = Number(pair.typeValue);
+    if (type === _VideoFrameMarking.TYPE && typeof pair.value === "bigint") {
+      return new _VideoFrameMarking(pair.value);
+    }
+    return void 0;
+  }
+};
+
+// src/model/extension_header/audio_level.ts
+var AudioLevel = class _AudioLevel {
+  constructor(audioLevel) {
+    this.audioLevel = audioLevel;
+  }
+  static TYPE = 6 /* AudioLevel */;
+  toKeyValuePair() {
+    return KeyValuePair.tryNewVarInt(_AudioLevel.TYPE, this.audioLevel);
+  }
+  static fromKeyValuePair(pair) {
+    const type = Number(pair.typeValue);
+    if (type === _AudioLevel.TYPE && typeof pair.value === "bigint") {
+      return new _AudioLevel(pair.value);
+    }
+    return void 0;
+  }
+};
+
+// src/model/extension_header/video_config.ts
+var VideoConfig = class _VideoConfig {
+  constructor(config) {
+    this.config = config;
+  }
+  static TYPE = 13 /* VideoConfig */;
+  toKeyValuePair() {
+    return KeyValuePair.tryNewBytes(_VideoConfig.TYPE, this.config);
+  }
+  static fromKeyValuePair(pair) {
+    const type = Number(pair.typeValue);
+    if (type === _VideoConfig.TYPE && pair.value instanceof Uint8Array) {
+      return new _VideoConfig(pair.value);
+    }
+    return void 0;
+  }
+};
+
+// src/model/extension_header/extension_header.ts
+exports.ExtensionHeader = void 0;
+((ExtensionHeader2) => {
+  function fromKeyValuePair(pair) {
+    return CaptureTimestamp.fromKeyValuePair(pair) || VideoFrameMarking.fromKeyValuePair(pair) || AudioLevel.fromKeyValuePair(pair) || VideoConfig.fromKeyValuePair(pair);
+  }
+  ExtensionHeader2.fromKeyValuePair = fromKeyValuePair;
+  function toKeyValuePair(header) {
+    return header.toKeyValuePair();
+  }
+  ExtensionHeader2.toKeyValuePair = toKeyValuePair;
+  function isCaptureTimestamp(header) {
+    return header instanceof CaptureTimestamp;
+  }
+  ExtensionHeader2.isCaptureTimestamp = isCaptureTimestamp;
+  function isVideoFrameMarking(header) {
+    return header instanceof VideoFrameMarking;
+  }
+  ExtensionHeader2.isVideoFrameMarking = isVideoFrameMarking;
+  function isAudioLevel(header) {
+    return header instanceof AudioLevel;
+  }
+  ExtensionHeader2.isAudioLevel = isAudioLevel;
+  function isVideoConfig(header) {
+    return header instanceof VideoConfig;
+  }
+  ExtensionHeader2.isVideoConfig = isVideoConfig;
+})(exports.ExtensionHeader || (exports.ExtensionHeader = {}));
+var ExtensionHeaders = class {
+  kvps = [];
+  addCaptureTimestamp(timestamp) {
+    this.kvps.push(new CaptureTimestamp(BigInt(timestamp)).toKeyValuePair());
+    return this;
+  }
+  addVideoFrameMarking(marking) {
+    this.kvps.push(new VideoFrameMarking(BigInt(marking)).toKeyValuePair());
+    return this;
+  }
+  addAudioLevel(audioLevel) {
+    this.kvps.push(new AudioLevel(BigInt(audioLevel)).toKeyValuePair());
+    return this;
+  }
+  addVideoConfig(config) {
+    this.kvps.push(new VideoConfig(config).toKeyValuePair());
+    return this;
+  }
+  addRaw(pair) {
+    this.kvps.push(pair);
+    return this;
+  }
+  build() {
+    return this.kvps;
+  }
+  static fromKeyValuePairs(kvps) {
+    const result = [];
+    for (const kvp of kvps) {
+      const parsed = exports.ExtensionHeader.fromKeyValuePair(kvp);
+      if (parsed) result.push(parsed);
+    }
+    return result;
+  }
+};
+
+// src/model/data/subgroup_object.ts
+var SubgroupObject = class _SubgroupObject {
+  constructor(objectId, extensionHeaders, objectStatus, payload) {
+    this.extensionHeaders = extensionHeaders;
+    this.objectStatus = objectStatus;
+    this.payload = payload;
+    this.objectId = BigInt(objectId);
+  }
+  objectId;
+  static newWithStatus(objectId, extensionHeaders, objectStatus) {
+    return new _SubgroupObject(objectId, extensionHeaders, objectStatus, null);
+  }
+  static newWithPayload(objectId, extensionHeaders, payload) {
+    return new _SubgroupObject(objectId, extensionHeaders, null, payload);
+  }
+  // TODO: object delta encoding is missing here...
+  serialize(previousObjectId) {
+    let objectIdDelta = previousObjectId ? this.objectId - previousObjectId - BigInt(1) : this.objectId;
+    const buf = new ByteBuffer();
+    buf.putVI(objectIdDelta);
+    const extensionHeaders = new ByteBuffer();
+    if (this.extensionHeaders) {
+      for (const header of this.extensionHeaders) {
+        extensionHeaders.putKeyValuePair(header);
+      }
+      const headerBytes = extensionHeaders.toUint8Array();
+      buf.putLengthPrefixedBytes(headerBytes);
+    }
+    if (this.payload) {
+      buf.putLengthPrefixedBytes(this.payload);
+    } else {
+      buf.putVI(0);
+      buf.putVI(this.objectStatus);
+    }
+    return buf.freeze();
+  }
+  static deserialize(buf, hasExtensions, previousObjectId) {
+    const objectDelta = buf.getVI();
+    let objectId = previousObjectId !== void 0 ? previousObjectId + objectDelta + BigInt(1) : objectDelta;
+    let extensionHeaders = null;
+    if (hasExtensions) {
+      extensionHeaders = [];
+      const extLen = buf.getNumberVI();
+      const headerBytes = new FrozenByteBuffer5(buf.getBytes(extLen));
+      while (headerBytes.remaining > 0) {
+        extensionHeaders.push(headerBytes.getKeyValuePair());
+      }
+    }
+    const payloadLen = buf.getNumberVI();
+    let objectStatus = null;
+    let payload = null;
+    if (payloadLen === 0) {
+      objectStatus = exports.ObjectStatus.tryFrom(buf.getVI());
+    } else {
+      payload = buf.getBytes(payloadLen);
+    }
+    return new _SubgroupObject(objectId, extensionHeaders, objectStatus, payload);
+  }
+};
+
+// src/model/data/object.ts
+var MoqtObject = class _MoqtObject {
+  constructor(fullTrackName, location, publisherPriority, objectForwardingPreference, subgroupId, objectStatus, extensionHeaders, payload) {
+    this.fullTrackName = fullTrackName;
+    this.publisherPriority = publisherPriority;
+    this.objectForwardingPreference = objectForwardingPreference;
+    this.objectStatus = objectStatus;
+    this.extensionHeaders = extensionHeaders;
+    this.payload = payload;
+    this.location = location;
+    this.subgroupId = subgroupId !== null ? BigInt(subgroupId) : null;
+  }
+  location;
+  subgroupId;
+  get groupId() {
+    return this.location.group;
+  }
+  get objectId() {
+    return this.location.object;
+  }
+  getSubgroupHeaderType(containsEnd) {
+    const hasExtensions = !!this.extensionHeaders && this.extensionHeaders.length > 0;
+    const hasSubgroupId = this.subgroupId !== null;
+    const isSubgroupIdZero = this.subgroupId === 0n;
+    if (containsEnd) {
+      if (hasSubgroupId) {
+        return hasExtensions ? 29 /* Type0x1D */ : 28 /* Type0x1C */;
+      } else if (isSubgroupIdZero) {
+        return hasExtensions ? 25 /* Type0x19 */ : 24 /* Type0x18 */;
+      } else {
+        return hasExtensions ? 27 /* Type0x1B */ : 26 /* Type0x1A */;
+      }
+    } else {
+      if (hasSubgroupId) {
+        return hasExtensions ? 21 /* Type0x15 */ : 20 /* Type0x14 */;
+      } else if (isSubgroupIdZero) {
+        return hasExtensions ? 17 /* Type0x11 */ : 16 /* Type0x10 */;
+      } else {
+        return hasExtensions ? 19 /* Type0x13 */ : 18 /* Type0x12 */;
+      }
+    }
+  }
+  isDatagram() {
+    return this.objectForwardingPreference === "Datagram" /* Datagram */;
+  }
+  isSubgroup() {
+    return this.objectForwardingPreference === "Subgroup" /* Subgroup */;
+  }
+  isEndOfGroup() {
+    return this.objectStatus === 3 /* EndOfGroup */;
+  }
+  isEndOfTrack() {
+    return this.objectStatus === 4 /* EndOfTrack */;
+  }
+  doesNotExist() {
+    return this.objectStatus === 1 /* DoesNotExist */;
+  }
+  hasPayload() {
+    return this.payload !== null;
+  }
+  hasStatus() {
+    return this.objectStatus !== 0 /* Normal */;
+  }
+  static newWithPayload(fullTrackName, location, publisherPriority, objectForwardingPreference, subgroupId, extensionHeaders, payload) {
+    return new _MoqtObject(
+      fullTrackName,
+      location,
+      publisherPriority,
+      objectForwardingPreference,
+      subgroupId,
+      0 /* Normal */,
+      extensionHeaders,
+      payload
+    );
+  }
+  static newWithStatus(fullTrackName, location, publisherPriority, objectForwardingPreference, subgroupId, extensionHeaders, objectStatus) {
+    return new _MoqtObject(
+      fullTrackName,
+      location,
+      publisherPriority,
+      objectForwardingPreference,
+      subgroupId,
+      objectStatus,
+      extensionHeaders,
+      null
+    );
+  }
+  static fromDatagramObject(datagramObject, fullTrackName) {
+    return new _MoqtObject(
+      fullTrackName,
+      new Location(datagramObject.groupId, datagramObject.objectId),
+      datagramObject.publisherPriority,
+      "Datagram" /* Datagram */,
+      null,
+      0 /* Normal */,
+      datagramObject.extensionHeaders,
+      datagramObject.payload
+    );
+  }
+  static fromDatagramStatus(datagramStatus, fullTrackName) {
+    return new _MoqtObject(
+      fullTrackName,
+      datagramStatus.location,
+      datagramStatus.publisherPriority,
+      "Datagram" /* Datagram */,
+      null,
+      datagramStatus.objectStatus,
+      datagramStatus.extensionHeaders,
+      null
+    );
+  }
+  static fromFetchObject(fetchObject, fullTrackName) {
+    return new _MoqtObject(
+      fullTrackName,
+      fetchObject.location,
+      fetchObject.publisherPriority,
+      "Subgroup" /* Subgroup */,
+      fetchObject.subgroupId,
+      fetchObject.objectStatus || 0 /* Normal */,
+      fetchObject.extensionHeaders,
+      fetchObject.payload
+    );
+  }
+  static fromSubgroupObject(subgroupObject, groupId, publisherPriority, subgroupId, fullTrackName) {
+    return new _MoqtObject(
+      fullTrackName,
+      new Location(groupId, subgroupObject.objectId),
+      publisherPriority,
+      "Subgroup" /* Subgroup */,
+      subgroupId,
+      subgroupObject.objectStatus || 0 /* Normal */,
+      subgroupObject.extensionHeaders,
+      subgroupObject.payload
+    );
+  }
+  tryIntoDatagramObject(trackAlias) {
+    if (this.objectForwardingPreference !== "Datagram" /* Datagram */) {
+      throw new CastingError(
+        "MoqtObject.tryIntoDatagramObject",
+        "MoqtObject",
+        "DatagramObject",
+        "Object Forwarding Preference must be Datagram"
+      );
+    }
+    if (this.objectStatus !== 0 /* Normal */ || !this.payload) {
+      throw new ProtocolViolationError(
+        "MoqtObject.tryIntoDatagramObject",
+        "Object must have Normal status and payload for DatagramObject conversion"
+      );
+    }
+    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
+      );
+    }
+  }
+  tryIntoDatagramStatus(trackAlias) {
+    if (this.objectForwardingPreference !== "Datagram" /* Datagram */) {
+      throw new CastingError(
+        "MoqtObject.tryIntoDatagramStatus",
+        "MoqtObject",
+        "DatagramStatus",
+        "Object Forwarding Preference must be Datagram"
+      );
+    }
+    if (this.objectStatus === 0 /* Normal */) {
+      throw new ProtocolViolationError(
+        "MoqtObject.tryIntoDatagramStatus",
+        "Object Status must not be Normal for DatagramStatus conversion"
+      );
+    }
+    const alias = BigInt(trackAlias);
+    if (this.extensionHeaders && this.extensionHeaders.length > 0) {
+      return DatagramStatus.withExtensions(
+        alias,
+        this.location,
+        this.publisherPriority,
+        this.extensionHeaders,
+        this.objectStatus
+      );
+    } else {
+      return DatagramStatus.newWithoutExtensions(alias, this.location, this.publisherPriority, this.objectStatus);
+    }
+  }
+  tryIntoFetchObject() {
+    if (this.objectForwardingPreference !== "Subgroup" /* Subgroup */) {
+      throw new CastingError(
+        "MoqtObject.tryIntoFetchObject",
+        "MoqtObject",
+        "FetchObject",
+        "Object Forwarding Preference must be Subgroup"
+      );
+    }
+    if (this.subgroupId === null) {
+      throw new ProtocolViolationError(
+        "MoqtObject.tryIntoFetchObject",
+        "Subgroup ID is required for Subgroup forwarding preference"
+      );
+    }
+    if (this.objectStatus === 0 /* Normal */ && this.payload) {
+      return FetchObject.newWithPayload(
+        this.groupId,
+        this.subgroupId,
+        this.objectId,
+        this.publisherPriority,
+        this.extensionHeaders,
+        this.payload
+      );
+    } else {
+      return FetchObject.newWithStatus(
+        this.groupId,
+        this.subgroupId,
+        this.objectId,
+        this.publisherPriority,
+        this.extensionHeaders,
+        this.objectStatus
+      );
+    }
+  }
+  tryIntoSubgroupObject() {
+    if (this.objectForwardingPreference !== "Subgroup" /* Subgroup */) {
+      throw new CastingError(
+        "MoqtObject.tryIntoSubgroupObject",
+        "MoqtObject",
+        "SubgroupObject",
+        "Object Forwarding Preference must be Subgroup"
+      );
+    }
+    if (this.objectStatus === 0 /* Normal */ && this.payload) {
+      return SubgroupObject.newWithPayload(this.location.object, this.extensionHeaders, this.payload);
+    } else {
+      return SubgroupObject.newWithStatus(this.location.object, this.extensionHeaders, this.objectStatus);
+    }
+  }
+};
+
+// src/model/data/subgroup_header.ts
+var SubgroupHeader = class _SubgroupHeader {
+  constructor(type, trackAlias, groupId, subgroupId, publisherPriority) {
+    this.type = type;
+    this.publisherPriority = publisherPriority;
+    this.trackAlias = BigInt(trackAlias);
+    this.groupId = BigInt(groupId);
+    if (subgroupId !== void 0) {
+      this.subgroupId = BigInt(subgroupId);
+    } else {
+      this.subgroupId = subgroupId;
+    }
+  }
+  subgroupId;
+  trackAlias;
+  groupId;
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(this.type);
+    buf.putVI(this.trackAlias);
+    buf.putVI(this.groupId);
+    if (exports.SubgroupHeaderType.hasExplicitSubgroupId(this.type)) {
+      if (this.subgroupId === void 0) {
+        throw new ProtocolViolationError(
+          "SubgroupHeader.serialize",
+          "Subgroup_id field is required for this header type"
+        );
+      }
+      buf.putVI(this.subgroupId);
+    }
+    buf.putU8(this.publisherPriority);
+    return buf.freeze();
+  }
+  static deserialize(buf) {
+    const headerType = exports.SubgroupHeaderType.tryFrom(buf.getNumberVI());
+    const trackAlias = buf.getVI();
+    const groupId = buf.getVI();
+    let subgroupId;
+    if (exports.SubgroupHeaderType.hasExplicitSubgroupId(headerType)) {
+      subgroupId = buf.getVI();
+    } else if (exports.SubgroupHeaderType.isSubgroupIdZero(headerType)) {
+      subgroupId = 0n;
+    }
+    const publisherPriority = buf.getU8();
+    return new _SubgroupHeader(headerType, trackAlias, groupId, subgroupId, publisherPriority);
+  }
+};
+
+// src/model/data/request_id.ts
+var RequestIdMap = class {
+  requestIdToName = /* @__PURE__ */ new Map();
+  nameToRequestId = /* @__PURE__ */ new Map();
+  /**
+   * @public
+   * Adds a mapping between a requestId and a full track name.
+   *
+   * @param requestId - The requestId to associate.
+   * @param name - The full track name to associate.
+   * @throws :{@link RequestIdError} if the requestId or name is already mapped to a different value.
+   */
+  addMapping(requestId, name) {
+    if (this.requestIdToName.has(requestId)) {
+      const existingName = this.requestIdToName.get(requestId);
+      if (existingName === name) return;
+      throw new RequestIdError(
+        "RequestIdMap::addMapping(existingName)",
+        `Full track name already exists for requestId: ${requestId}`
+      );
+    }
+    if (this.nameToRequestId.has(name)) {
+      const existingRequestId = this.nameToRequestId.get(name);
+      if (existingRequestId === requestId) return;
+      throw new RequestIdError(
+        "RequestIdMap::addMapping(existingRequestId)",
+        `A requestId already exists for full track name: ${name}`
+      );
+    }
+    this.requestIdToName.set(requestId, name);
+    this.nameToRequestId.set(name, requestId);
+  }
+  /**
+   * @public
+   * Gets the full track name for a given requestId.
+   *
+   * @param requestId - The requestId to look up.
+   * @returns The associated full track name.
+   * @throws :{@link RequestIdError} if the requestId does not exist.
+   */
+  getNameByRequestId(requestId) {
+    const name = this.requestIdToName.get(requestId);
+    if (!name)
+      throw new RequestIdError("RequestIdMap::getNameByRequestId(name)", `RequestId: ${requestId} doesn't exist`);
+    return name;
+  }
+  /**
+   * @public
+   * Gets the requestId for a given full track name.
+   *
+   * @param name - The full track name to look up.
+   * @returns The associated requestId.
+   * @throws :{@link RequestIdError} if the name does not exist.
+   */
+  getRequestIdByName(name) {
+    const requestId = this.nameToRequestId.get(name);
+    if (requestId === void 0)
+      throw new RequestIdError("RequestIdMap::getRequestIdByName(requestId)", `Name does not exist`);
+    return requestId;
+  }
+  /**
+   * @public
+   * Removes a mapping by requestId.
+   *
+   * @param requestId - The requestId to remove.
+   * @returns The removed full track name, or undefined if not found.
+   */
+  removeMappingByRequestId(requestId) {
+    const name = this.requestIdToName.get(requestId);
+    if (name) {
+      this.requestIdToName.delete(requestId);
+      this.nameToRequestId.delete(name);
+      return name;
+    }
+    return void 0;
+  }
+  /**
+   * @public
+   * Removes a mapping by full track name.
+   *
+   * @param name - The full track name to remove.
+   * @returns The removed requestId, or undefined if not found.
+   */
+  removeMappingByName(name) {
+    const requestId = this.nameToRequestId.get(name);
+    if (requestId !== void 0) {
+      this.nameToRequestId.delete(name);
+      this.requestIdToName.delete(requestId);
+      return requestId;
+    }
+    return void 0;
+  }
+  /**
+   * @public
+   * Checks if the map contains a given requestId.
+   *
+   * @param requestId - The requestId to check.
+   * @returns True if the requestId exists, false otherwise.
+   */
+  containsRequestId(requestId) {
+    return this.requestIdToName.has(requestId);
+  }
+  /**
+   * @public
+   * Checks if the map contains a given full track name.
+   *
+   * @param name - The full track name to check.
+   * @returns True if the name exists, false otherwise.
+   */
+  containsName(name) {
+    return this.nameToRequestId.has(name);
+  }
+};
+
+// src/model/data/header.ts
+exports.Header = void 0;
+((Header2) => {
+  function newFetch(...args) {
+    return new FetchHeader(...args);
+  }
+  Header2.newFetch = newFetch;
+  function newSubgroup(...args) {
+    return new SubgroupHeader(...args);
+  }
+  Header2.newSubgroup = newSubgroup;
+  function isFetch(header) {
+    return header instanceof FetchHeader;
+  }
+  Header2.isFetch = isFetch;
+  function isSubgroup(header) {
+    return header instanceof SubgroupHeader;
+  }
+  Header2.isSubgroup = isSubgroup;
+  function serialize(header) {
+    return header.serialize();
+  }
+  Header2.serialize = serialize;
+  function deserialize(buf) {
+    buf.checkpoint();
+    const type = buf.getNumberVI();
+    buf.restore();
+    switch (type) {
+      case 5:
+        return FetchHeader.deserialize(buf);
+      case 16:
+      case 17:
+      case 18:
+      case 19:
+      case 20:
+      case 21:
+      case 24:
+      case 25:
+      case 26:
+      case 27:
+      case 28:
+      case 29:
+        return SubgroupHeader.deserialize(buf);
+      default:
+        throw new InvalidTypeError("Header::deserialize(type)", `Unknown header type: ${type}`);
+    }
+  }
+  Header2.deserialize = deserialize;
+})(exports.Header || (exports.Header = {}));
+
+// src/model/common/byte_buffer.ts
+var MAX_VARINT_1BYTE = 2n ** 6n - 1n;
+var MAX_VARINT_2BYTE = 2n ** 14n - 1n;
+var MAX_VARINT_4BYTE = 2n ** 30n - 1n;
+var MAX_VARINT_8BYTE = 2n ** 62n - 1n;
+var BaseByteBuffer12 = class {
+  buf;
+  view;
+  _offset = 0;
+  _checkpoint = 0;
+  constructor(buf) {
+    this.buf = buf;
+    this.view = new DataView(buf.buffer, buf.byteOffset, buf.length);
+  }
+  get offset() {
+    return this._offset;
+  }
+  get remaining() {
+    return this.length - this._offset;
+  }
+  /**
+   * Save current read position for potential rollback
+   */
+  checkpoint() {
+    this._checkpoint = this._offset;
+  }
+  /**
+   * Restore read position to last checkpoint
+   */
+  restore() {
+    this._offset = this._checkpoint;
+  }
+  toUint8Array() {
+    return this.buf.slice();
+  }
+  getU8() {
+    if (this.remaining < 1) throw new NotEnoughBytesError("getU8", 1, this.remaining);
+    return this.view.getUint8(this._offset++);
+  }
+  getU16() {
+    if (this.remaining < 2) throw new NotEnoughBytesError("getU16", 2, this.remaining);
+    const v = this.view.getUint16(this._offset, false);
+    this._offset += 2;
+    return v;
+  }
+  getVI() {
+    if (this.remaining < 1) throw new NotEnoughBytesError("getVI.first_byte", 1, this.remaining);
+    const first = this.getU8();
+    const prefix = first >> 6;
+    let numBytes;
+    switch (prefix) {
+      case 0:
+        numBytes = 1;
+        break;
+      case 1:
+        numBytes = 2;
+        break;
+      case 2:
+        numBytes = 4;
+        break;
+      case 3:
+        numBytes = 8;
+        break;
+      default:
+        throw new Error("Invalid varint prefix");
+    }
+    if (numBytes > 1 && this.remaining < numBytes - 1) {
+      this._offset--;
+      throw new NotEnoughBytesError("getVI.continuation", numBytes, this.remaining + 1);
+    }
+    let result = BigInt(first & 63);
+    if (numBytes > 1) {
+      result <<= BigInt((numBytes - 1) * 8);
+      for (let i = 1; i < numBytes; i++) {
+        const b = BigInt(this.getU8());
+        result |= b << BigInt((numBytes - 1 - i) * 8);
+      }
+    }
+    return result;
+  }
+  getNumberVI() {
+    let big = this.getVI();
+    if (big > Number.MAX_SAFE_INTEGER)
+      throw new CastingError(
+        "BaseByteBuffer.getNumberVI()",
+        "bigint",
+        "number",
+        "bigint exceeds Number.MAX_SAFE_INTEGER"
+      );
+    return Number(big);
+  }
+  getBytes(len) {
+    if (this.remaining < len) throw new NotEnoughBytesError("getBytes", len, this.remaining);
+    const slice = this.buf.slice(this._offset, this._offset + len);
+    this._offset += len;
+    return slice;
+  }
+  getLengthPrefixedBytes() {
+    const len = this.getNumberVI();
+    if (this.length < this.offset + len)
+      throw new NotEnoughBytesError("BaseByteBuffer.getLengthPrefixedBytes", len, this.length - this.offset);
+    return this.getBytes(len);
+  }
+  getKeyValuePair() {
+    return KeyValuePair.deserialize(this);
+  }
+  getReasonPhrase() {
+    return ReasonPhrase.deserialize(this);
+  }
+  getLocation() {
+    return Location.deserialize(this);
+  }
+  getTuple() {
+    return Tuple.deserialize(this);
+  }
+  getFullTrackName() {
+    return FullTrackName.deserialize(this);
+  }
+};
+var ByteBuffer = class extends BaseByteBuffer12 {
+  _length = 0;
+  constructor(initialSize = 128) {
+    super(new Uint8Array(initialSize));
+  }
+  get length() {
+    return this._length;
+  }
+  /**
+   * Clear all data and reset all positions
+   */
+  clear() {
+    this._length = 0;
+    this._offset = 0;
+    this._checkpoint = 0;
+    this.buf = new Uint8Array();
+    this.view = new DataView(this.buf.buffer, this.buf.byteOffset, this.buf.length);
+  }
+  /**
+   * Drop all data before current offset and reset positions
+   * This is the key method for memory management - removes processed data
+   */
+  commit() {
+    if (this._offset === 0) {
+      return;
+    }
+    if (this._offset >= this._length) {
+      this.clear();
+      return;
+    }
+    this.buf.set(this.buf.subarray(this._offset, this._length), 0);
+    this._length = this._length - this._offset;
+    this._offset = 0;
+    this._checkpoint = 0;
+    this.view = new DataView(this.buf.buffer, this.buf.byteOffset, this.buf.length);
+  }
+  ensureCapacity(add) {
+    const need = this._length + add;
+    if (need <= this.buf.length) return;
+    let newSize = this.buf.length * 2 + 1;
+    while (newSize < need) newSize *= 2;
+    const newBuf = new Uint8Array(newSize);
+    newBuf.set(this.buf.subarray(0, this._length));
+    this.buf = newBuf;
+    this.view = new DataView(this.buf.buffer);
+  }
+  // --------- WRITE OPERATIONS ---------
+  putU8(v) {
+    if (v < 0 || v > 255) {
+      throw new RangeError(`Value ${v} is out of range for a U8 (0-255).`);
+    }
+    this.ensureCapacity(1);
+    this.view.setUint8(this._length++, v);
+  }
+  putU16(v) {
+    if (v < 0 || v > 65535) {
+      throw new RangeError(`Value ${v} is out of range for a U16 (0-65535).`);
+    }
+    this.ensureCapacity(2);
+    this.view.setUint16(this._length, v, false);
+    this._length += 2;
+  }
+  /**
+   * Write a variable-length integer (QUIC-style varint)
+   * Encoding:
+   * - 2 MSB = 00: 1 byte (6 bits) for values 0-63
+   * - 2 MSB = 01: 2 bytes (14 bits) for values 0-16383
+   * - 2 MSB = 10: 4 bytes (30 bits) for values 0-1073741823
+   * - 2 MSB = 11: 8 bytes (62 bits) for values 0-4611686018427387903
+   */
+  putVI(v) {
+    const value = typeof v === "number" ? BigInt(v) : v;
+    if (value < 0) {
+      throw new CastingError("putVI", typeof v, "unsigned varint", "negative values are not supported");
+    }
+    if (value <= MAX_VARINT_1BYTE) {
+      this.putU8(Number(value));
+    } else if (value <= MAX_VARINT_2BYTE) {
+      this.ensureCapacity(2);
+      this.view.setUint8(this._length++, Number(value >> 8n | 0b01000000n));
+      this.view.setUint8(this._length++, Number(value & 0xffn));
+    } else if (value <= MAX_VARINT_4BYTE) {
+      this.ensureCapacity(4);
+      this.view.setUint8(this._length++, Number(value >> 24n | 0b10000000n));
+      this.view.setUint8(this._length++, Number(value >> 16n & 0xffn));
+      this.view.setUint8(this._length++, Number(value >> 8n & 0xffn));
+      this.view.setUint8(this._length++, Number(value & 0xffn));
+    } else if (value <= MAX_VARINT_8BYTE) {
+      this.ensureCapacity(8);
+      this.view.setUint8(this._length++, Number(value >> 56n | 0b11000000n));
+      this.view.setUint8(this._length++, Number(value >> 48n & 0xffn));
+      this.view.setUint8(this._length++, Number(value >> 40n & 0xffn));
+      this.view.setUint8(this._length++, Number(value >> 32n & 0xffn));
+      this.view.setUint8(this._length++, Number(value >> 24n & 0xffn));
+      this.view.setUint8(this._length++, Number(value >> 16n & 0xffn));
+      this.view.setUint8(this._length++, Number(value >> 8n & 0xffn));
+      this.view.setUint8(this._length++, Number(value & 0xffn));
+    } else {
+      throw new VarIntOverflowError("putVI", Number(value));
+    }
+  }
+  putBytes(src) {
+    this.ensureCapacity(src.length);
+    this.buf.set(src, this._length);
+    this._length += src.length;
+  }
+  putLengthPrefixedBytes(src) {
+    this.putVI(src.length);
+    this.putBytes(src);
+  }
+  putKeyValuePair(pair) {
+    const b = pair.serialize().toUint8Array();
+    this.putBytes(b);
+  }
+  putReasonPhrase(reason) {
+    const b = reason.serialize().toUint8Array();
+    this.putBytes(b);
+  }
+  toUint8Array() {
+    return this.buf.slice(0, this._length);
+  }
+  freeze() {
+    const snap = this.buf.slice(0, this._length);
+    return new FrozenByteBuffer5(snap);
+  }
+  putLocation(loc) {
+    this.putVI(loc.group);
+    this.putVI(loc.object);
+  }
+  putTuple(tuple) {
+    const serialized = tuple.serialize();
+    this.putBytes(serialized.toUint8Array());
+  }
+  putFullTrackName(fullTrackName) {
+    const serialized = fullTrackName.serialize();
+    this.putBytes(serialized.toUint8Array());
+  }
+};
+var FrozenByteBuffer5 = class extends BaseByteBuffer12 {
+  constructor(buf) {
+    super(buf);
+  }
+  get length() {
+    return this.buf.length;
+  }
+};
+
+// src/model/control/constant.ts
+var DRAFT_14 = 4278190094;
+var ControlMessageType = /* @__PURE__ */ ((ControlMessageType2) => {
+  ControlMessageType2[ControlMessageType2["ReservedSetupV00"] = 1] = "ReservedSetupV00";
+  ControlMessageType2[ControlMessageType2["ReservedClientSetupV10"] = 64] = "ReservedClientSetupV10";
+  ControlMessageType2[ControlMessageType2["ReservedServerSetupV10"] = 65] = "ReservedServerSetupV10";
+  ControlMessageType2[ControlMessageType2["ClientSetup"] = 32] = "ClientSetup";
+  ControlMessageType2[ControlMessageType2["ServerSetup"] = 33] = "ServerSetup";
+  ControlMessageType2[ControlMessageType2["GoAway"] = 16] = "GoAway";
+  ControlMessageType2[ControlMessageType2["MaxRequestId"] = 21] = "MaxRequestId";
+  ControlMessageType2[ControlMessageType2["RequestsBlocked"] = 26] = "RequestsBlocked";
+  ControlMessageType2[ControlMessageType2["Subscribe"] = 3] = "Subscribe";
+  ControlMessageType2[ControlMessageType2["SubscribeOk"] = 4] = "SubscribeOk";
+  ControlMessageType2[ControlMessageType2["SubscribeError"] = 5] = "SubscribeError";
+  ControlMessageType2[ControlMessageType2["Unsubscribe"] = 10] = "Unsubscribe";
+  ControlMessageType2[ControlMessageType2["SubscribeUpdate"] = 2] = "SubscribeUpdate";
+  ControlMessageType2[ControlMessageType2["PublishDone"] = 11] = "PublishDone";
+  ControlMessageType2[ControlMessageType2["Fetch"] = 22] = "Fetch";
+  ControlMessageType2[ControlMessageType2["FetchOk"] = 24] = "FetchOk";
+  ControlMessageType2[ControlMessageType2["FetchError"] = 25] = "FetchError";
+  ControlMessageType2[ControlMessageType2["FetchCancel"] = 23] = "FetchCancel";
+  ControlMessageType2[ControlMessageType2["TrackStatus"] = 13] = "TrackStatus";
+  ControlMessageType2[ControlMessageType2["TrackStatusOk"] = 14] = "TrackStatusOk";
+  ControlMessageType2[ControlMessageType2["TrackStatusError"] = 15] = "TrackStatusError";
+  ControlMessageType2[ControlMessageType2["PublishNamespace"] = 6] = "PublishNamespace";
+  ControlMessageType2[ControlMessageType2["PublishNamespaceOk"] = 7] = "PublishNamespaceOk";
+  ControlMessageType2[ControlMessageType2["PublishNamespaceError"] = 8] = "PublishNamespaceError";
+  ControlMessageType2[ControlMessageType2["PublishNamespaceDone"] = 9] = "PublishNamespaceDone";
+  ControlMessageType2[ControlMessageType2["PublishNamespaceCancel"] = 12] = "PublishNamespaceCancel";
+  ControlMessageType2[ControlMessageType2["SubscribeNamespace"] = 17] = "SubscribeNamespace";
+  ControlMessageType2[ControlMessageType2["SubscribeNamespaceOk"] = 18] = "SubscribeNamespaceOk";
+  ControlMessageType2[ControlMessageType2["SubscribeNamespaceError"] = 19] = "SubscribeNamespaceError";
+  ControlMessageType2[ControlMessageType2["UnsubscribeNamespace"] = 20] = "UnsubscribeNamespace";
+  ControlMessageType2[ControlMessageType2["Publish"] = 29] = "Publish";
+  ControlMessageType2[ControlMessageType2["PublishOk"] = 30] = "PublishOk";
+  ControlMessageType2[ControlMessageType2["PublishError"] = 31] = "PublishError";
+  ControlMessageType2[ControlMessageType2["Switch"] = 34] = "Switch";
+  return ControlMessageType2;
+})(ControlMessageType || {});
+function controlMessageTypeFromBigInt(v) {
+  switch (v) {
+    case 0x01n:
+      return 1 /* ReservedSetupV00 */;
+    case 0x40n:
+      return 64 /* ReservedClientSetupV10 */;
+    case 0x41n:
+      return 65 /* ReservedServerSetupV10 */;
+    case 0x20n:
+      return 32 /* ClientSetup */;
+    case 0x21n:
+      return 33 /* ServerSetup */;
+    case 0x10n:
+      return 16 /* GoAway */;
+    case 0x15n:
+      return 21 /* MaxRequestId */;
+    case 0x1an:
+      return 26 /* RequestsBlocked */;
+    case 0x03n:
+      return 3 /* Subscribe */;
+    case 0x04n:
+      return 4 /* SubscribeOk */;
+    case 0x05n:
+      return 5 /* SubscribeError */;
+    case 0x0an:
+      return 10 /* Unsubscribe */;
+    case 0x02n:
+      return 2 /* SubscribeUpdate */;
+    case 0x0bn:
+      return 11 /* PublishDone */;
+    case 0x16n:
+      return 22 /* Fetch */;
+    case 0x18n:
+      return 24 /* FetchOk */;
+    case 0x19n:
+      return 25 /* FetchError */;
+    case 0x17n:
+      return 23 /* FetchCancel */;
+    case 0x0dn:
+      return 13 /* TrackStatus */;
+    case 0x0en:
+      return 13 /* TrackStatus */;
+    case 0x06n:
+      return 6 /* PublishNamespace */;
+    case 0x07n:
+      return 7 /* PublishNamespaceOk */;
+    case 0x08n:
+      return 8 /* PublishNamespaceError */;
+    case 0x09n:
+      return 9 /* PublishNamespaceDone */;
+    case 0x0cn:
+      return 12 /* PublishNamespaceCancel */;
+    case 0x11n:
+      return 17 /* SubscribeNamespace */;
+    case 0x12n:
+      return 18 /* SubscribeNamespaceOk */;
+    case 0x13n:
+      return 19 /* SubscribeNamespaceError */;
+    case 0x14n:
+      return 20 /* UnsubscribeNamespace */;
+    case 0x1dn:
+      return 29 /* Publish */;
+    case 0x1en:
+      return 30 /* PublishOk */;
+    case 0x1fn:
+      return 31 /* PublishError */;
+    default:
+      throw new Error(`Invalid ControlMessageType: ${v}`);
+  }
+}
+var PublishNamespaceErrorCode = /* @__PURE__ */ ((PublishNamespaceErrorCode4) => {
+  PublishNamespaceErrorCode4[PublishNamespaceErrorCode4["InternalError"] = 0] = "InternalError";
+  PublishNamespaceErrorCode4[PublishNamespaceErrorCode4["Unauthorized"] = 1] = "Unauthorized";
+  PublishNamespaceErrorCode4[PublishNamespaceErrorCode4["Timeout"] = 2] = "Timeout";
+  PublishNamespaceErrorCode4[PublishNamespaceErrorCode4["NotSupported"] = 3] = "NotSupported";
+  PublishNamespaceErrorCode4[PublishNamespaceErrorCode4["Uninterested"] = 4] = "Uninterested";
+  PublishNamespaceErrorCode4[PublishNamespaceErrorCode4["MalformedAuthToken"] = 16] = "MalformedAuthToken";
+  PublishNamespaceErrorCode4[PublishNamespaceErrorCode4["UnknownAuthTokenAlias"] = 17] = "UnknownAuthTokenAlias";
+  PublishNamespaceErrorCode4[PublishNamespaceErrorCode4["ExpiredAuthToken"] = 18] = "ExpiredAuthToken";
+  return PublishNamespaceErrorCode4;
+})(PublishNamespaceErrorCode || {});
+function publishNamespaceErrorCodeFromBigInt(v) {
+  switch (v) {
+    case 0x0n:
+      return 0 /* InternalError */;
+    case 0x1n:
+      return 1 /* Unauthorized */;
+    case 0x2n:
+      return 2 /* Timeout */;
+    case 0x3n:
+      return 3 /* NotSupported */;
+    case 0x4n:
+      return 4 /* Uninterested */;
+    case 0x10n:
+      return 16 /* MalformedAuthToken */;
+    case 0x11n:
+      return 17 /* UnknownAuthTokenAlias */;
+    case 0x12n:
+      return 18 /* ExpiredAuthToken */;
+    default:
+      throw new Error(`Invalid PublishNamespaceErrorCode: ${v}`);
+  }
+}
+var FilterType = /* @__PURE__ */ ((FilterType2) => {
+  FilterType2[FilterType2["NextGroupStart"] = 1] = "NextGroupStart";
+  FilterType2[FilterType2["LatestObject"] = 2] = "LatestObject";
+  FilterType2[FilterType2["AbsoluteStart"] = 3] = "AbsoluteStart";
+  FilterType2[FilterType2["AbsoluteRange"] = 4] = "AbsoluteRange";
+  return FilterType2;
+})(FilterType || {});
+function filterTypeFromBigInt(v) {
+  switch (v) {
+    case 0x1n:
+      return 1 /* NextGroupStart */;
+    case 0x2n:
+      return 2 /* LatestObject */;
+    case 0x3n:
+      return 3 /* AbsoluteStart */;
+    case 0x4n:
+      return 4 /* AbsoluteRange */;
+    default:
+      throw new Error(`Invalid FilterType: ${v}`);
+  }
+}
+var FetchType = /* @__PURE__ */ ((FetchType3) => {
+  FetchType3[FetchType3["StandAlone"] = 1] = "StandAlone";
+  FetchType3[FetchType3["Relative"] = 2] = "Relative";
+  FetchType3[FetchType3["Absolute"] = 3] = "Absolute";
+  return FetchType3;
+})(FetchType || {});
+function fetchTypeFromBigInt(v) {
+  switch (v) {
+    case 0x1n:
+      return 1 /* StandAlone */;
+    case 0x2n:
+      return 2 /* Relative */;
+    case 0x3n:
+      return 3 /* Absolute */;
+    default:
+      throw new CastingError("fetchTypeFromBigInt", "bigint", "FetchType", `Invalid FetchType:${v}`);
+  }
+}
+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) {
+    case 0:
+      return 0 /* Original */;
+    case 1:
+      return 1 /* Ascending */;
+    case 2:
+      return 2 /* Descending */;
+    default:
+      throw new CastingError("groupOrderFromNumber", "number", "GroupOrder", `Invalid GroupOrder: ${v}`);
+  }
+}
+var SubscribeErrorCode = /* @__PURE__ */ ((SubscribeErrorCode4) => {
+  SubscribeErrorCode4[SubscribeErrorCode4["InternalError"] = 0] = "InternalError";
+  SubscribeErrorCode4[SubscribeErrorCode4["Unauthorized"] = 1] = "Unauthorized";
+  SubscribeErrorCode4[SubscribeErrorCode4["Timeout"] = 2] = "Timeout";
+  SubscribeErrorCode4[SubscribeErrorCode4["NotSupported"] = 3] = "NotSupported";
+  SubscribeErrorCode4[SubscribeErrorCode4["TrackDoesNotExist"] = 4] = "TrackDoesNotExist";
+  SubscribeErrorCode4[SubscribeErrorCode4["InvalidRange"] = 5] = "InvalidRange";
+  SubscribeErrorCode4[SubscribeErrorCode4["MalformedAuthToken"] = 16] = "MalformedAuthToken";
+  SubscribeErrorCode4[SubscribeErrorCode4["ExpiredAuthToken"] = 18] = "ExpiredAuthToken";
+  return SubscribeErrorCode4;
+})(SubscribeErrorCode || {});
+function subscribeErrorCodeFromBigInt(v) {
+  switch (v) {
+    case 0x0n:
+      return 0 /* InternalError */;
+    case 0x1n:
+      return 1 /* Unauthorized */;
+    case 0x2n:
+      return 2 /* Timeout */;
+    case 0x3n:
+      return 3 /* NotSupported */;
+    case 0x4n:
+      return 4 /* TrackDoesNotExist */;
+    case 0x5n:
+      return 5 /* InvalidRange */;
+    case 0x10n:
+      return 16 /* MalformedAuthToken */;
+    case 0x12n:
+      return 18 /* ExpiredAuthToken */;
+    default:
+      throw new Error(`Invalid SubscribeErrorCode: ${v}`);
+  }
+}
+var FetchErrorCode = /* @__PURE__ */ ((FetchErrorCode3) => {
+  FetchErrorCode3[FetchErrorCode3["InternalError"] = 0] = "InternalError";
+  FetchErrorCode3[FetchErrorCode3["Unauthorized"] = 1] = "Unauthorized";
+  FetchErrorCode3[FetchErrorCode3["Timeout"] = 2] = "Timeout";
+  FetchErrorCode3[FetchErrorCode3["NotSupported"] = 3] = "NotSupported";
+  FetchErrorCode3[FetchErrorCode3["TrackDoesNotExist"] = 4] = "TrackDoesNotExist";
+  FetchErrorCode3[FetchErrorCode3["InvalidRange"] = 5] = "InvalidRange";
+  FetchErrorCode3[FetchErrorCode3["NoObjects"] = 6] = "NoObjects";
+  FetchErrorCode3[FetchErrorCode3["InvalidJoiningRequestId"] = 7] = "InvalidJoiningRequestId";
+  FetchErrorCode3[FetchErrorCode3["UnknownStatusInRange"] = 8] = "UnknownStatusInRange";
+  FetchErrorCode3[FetchErrorCode3["MalformedTrack"] = 9] = "MalformedTrack";
+  FetchErrorCode3[FetchErrorCode3["MalformedAuthToken"] = 16] = "MalformedAuthToken";
+  FetchErrorCode3[FetchErrorCode3["ExpiredAuthToken"] = 18] = "ExpiredAuthToken";
+  return FetchErrorCode3;
+})(FetchErrorCode || {});
+function fetchErrorCodeFromBigInt(v) {
+  switch (v) {
+    case 0x0n:
+      return 0 /* InternalError */;
+    case 0x1n:
+      return 1 /* Unauthorized */;
+    case 0x2n:
+      return 2 /* Timeout */;
+    case 0x3n:
+      return 3 /* NotSupported */;
+    case 0x4n:
+      return 4 /* TrackDoesNotExist */;
+    case 0x5n:
+      return 5 /* InvalidRange */;
+    case 0x6n:
+      return 6 /* NoObjects */;
+    case 0x7n:
+      return 7 /* InvalidJoiningRequestId */;
+    case 0x8n:
+      return 8 /* UnknownStatusInRange */;
+    case 0x9n:
+      return 9 /* MalformedTrack */;
+    case 0x10n:
+      return 16 /* MalformedAuthToken */;
+    case 0x12n:
+      return 18 /* ExpiredAuthToken */;
+    default:
+      throw new CastingError("fetchErrorCodeFromBigInt", "number", "FetchErrorCode", "Invalid fetch error code");
+  }
+}
+var TrackStatusCode = /* @__PURE__ */ ((TrackStatusCode2) => {
+  TrackStatusCode2[TrackStatusCode2["InProgress"] = 0] = "InProgress";
+  TrackStatusCode2[TrackStatusCode2["DoesNotExist"] = 1] = "DoesNotExist";
+  TrackStatusCode2[TrackStatusCode2["NotYetBegun"] = 2] = "NotYetBegun";
+  TrackStatusCode2[TrackStatusCode2["Finished"] = 3] = "Finished";
+  TrackStatusCode2[TrackStatusCode2["RelayUnavailable"] = 4] = "RelayUnavailable";
+  return TrackStatusCode2;
+})(TrackStatusCode || {});
+function trackStatusCodeFromBigInt(v) {
+  switch (v) {
+    case 0x00n:
+      return 0 /* InProgress */;
+    case 0x01n:
+      return 1 /* DoesNotExist */;
+    case 0x02n:
+      return 2 /* NotYetBegun */;
+    case 0x03n:
+      return 3 /* Finished */;
+    case 0x04n:
+      return 4 /* RelayUnavailable */;
+    default:
+      throw new Error(`Invalid TrackStatusCode: ${v}`);
+  }
+}
+var SubscribeNamespaceErrorCode = /* @__PURE__ */ ((SubscribeNamespaceErrorCode3) => {
+  SubscribeNamespaceErrorCode3[SubscribeNamespaceErrorCode3["InternalError"] = 0] = "InternalError";
+  SubscribeNamespaceErrorCode3[SubscribeNamespaceErrorCode3["Unauthorized"] = 1] = "Unauthorized";
+  SubscribeNamespaceErrorCode3[SubscribeNamespaceErrorCode3["Timeout"] = 2] = "Timeout";
+  SubscribeNamespaceErrorCode3[SubscribeNamespaceErrorCode3["NotSupported"] = 3] = "NotSupported";
+  SubscribeNamespaceErrorCode3[SubscribeNamespaceErrorCode3["NamespacePrefixUnknown"] = 4] = "NamespacePrefixUnknown";
+  SubscribeNamespaceErrorCode3[SubscribeNamespaceErrorCode3["NamespacePrefixOverlap"] = 5] = "NamespacePrefixOverlap";
+  SubscribeNamespaceErrorCode3[SubscribeNamespaceErrorCode3["MalformedAuthToken"] = 16] = "MalformedAuthToken";
+  SubscribeNamespaceErrorCode3[SubscribeNamespaceErrorCode3["ExpiredAuthToken"] = 18] = "ExpiredAuthToken";
+  return SubscribeNamespaceErrorCode3;
+})(SubscribeNamespaceErrorCode || {});
+function subscribeNamespaceErrorCodeFromBigInt(v) {
+  switch (v) {
+    case 0x0n:
+      return 0 /* InternalError */;
+    case 0x1n:
+      return 1 /* Unauthorized */;
+    case 0x2n:
+      return 2 /* Timeout */;
+    case 0x3n:
+      return 3 /* NotSupported */;
+    case 0x4n:
+      return 4 /* NamespacePrefixUnknown */;
+    case 0x5n:
+      return 5 /* NamespacePrefixOverlap */;
+    case 0x10n:
+      return 16 /* MalformedAuthToken */;
+    case 0x12n:
+      return 18 /* ExpiredAuthToken */;
+    default:
+      throw new Error(`Invalid SubscribeNamespaceErrorCode: ${v}`);
+  }
+}
+var PublishDoneStatusCode = /* @__PURE__ */ ((PublishDoneStatusCode3) => {
+  PublishDoneStatusCode3[PublishDoneStatusCode3["InternalError"] = 0] = "InternalError";
+  PublishDoneStatusCode3[PublishDoneStatusCode3["Unauthorized"] = 1] = "Unauthorized";
+  PublishDoneStatusCode3[PublishDoneStatusCode3["TrackEnded"] = 2] = "TrackEnded";
+  PublishDoneStatusCode3[PublishDoneStatusCode3["SubscriptionEnded"] = 3] = "SubscriptionEnded";
+  PublishDoneStatusCode3[PublishDoneStatusCode3["GoingAway"] = 4] = "GoingAway";
+  PublishDoneStatusCode3[PublishDoneStatusCode3["Expired"] = 5] = "Expired";
+  PublishDoneStatusCode3[PublishDoneStatusCode3["TooFarBehind"] = 6] = "TooFarBehind";
+  return PublishDoneStatusCode3;
+})(PublishDoneStatusCode || {});
+function publishDoneStatusCodeFromBigInt(v) {
+  switch (v) {
+    case 0x0n:
+      return 0 /* InternalError */;
+    case 0x1n:
+      return 1 /* Unauthorized */;
+    case 0x2n:
+      return 2 /* TrackEnded */;
+    case 0x3n:
+      return 3 /* SubscriptionEnded */;
+    case 0x4n:
+      return 4 /* GoingAway */;
+    case 0x5n:
+      return 5 /* Expired */;
+    case 0x6n:
+      return 6 /* TooFarBehind */;
+    default:
+      throw new Error(`Invalid PublishDoneStatusCode: ${v}`);
+  }
+}
+var PublishErrorCode = /* @__PURE__ */ ((PublishErrorCode3) => {
+  PublishErrorCode3[PublishErrorCode3["InternalError"] = 0] = "InternalError";
+  PublishErrorCode3[PublishErrorCode3["Unauthorized"] = 1] = "Unauthorized";
+  PublishErrorCode3[PublishErrorCode3["Timeout"] = 2] = "Timeout";
+  PublishErrorCode3[PublishErrorCode3["NotSupported"] = 3] = "NotSupported";
+  PublishErrorCode3[PublishErrorCode3["InvalidNamespace"] = 4] = "InvalidNamespace";
+  PublishErrorCode3[PublishErrorCode3["InvalidTrackName"] = 5] = "InvalidTrackName";
+  PublishErrorCode3[PublishErrorCode3["MalformedAuthToken"] = 16] = "MalformedAuthToken";
+  PublishErrorCode3[PublishErrorCode3["UnknownAuthTokenAlias"] = 17] = "UnknownAuthTokenAlias";
+  PublishErrorCode3[PublishErrorCode3["ExpiredAuthToken"] = 18] = "ExpiredAuthToken";
+  return PublishErrorCode3;
+})(PublishErrorCode || {});
+function publishErrorCodeFromBigInt(v) {
+  switch (v) {
+    case 0x0n:
+      return 0 /* InternalError */;
+    case 0x1n:
+      return 1 /* Unauthorized */;
+    case 0x2n:
+      return 2 /* Timeout */;
+    case 0x3n:
+      return 3 /* NotSupported */;
+    case 0x4n:
+      return 4 /* InvalidNamespace */;
+    case 0x5n:
+      return 5 /* InvalidTrackName */;
+    case 0x10n:
+      return 16 /* MalformedAuthToken */;
+    case 0x11n:
+      return 17 /* UnknownAuthTokenAlias */;
+    case 0x12n:
+      return 18 /* ExpiredAuthToken */;
+    default:
+      throw new Error(`Invalid PublishErrorCode: ${v}`);
+  }
+}
+
+// src/model/control/publish_namespace.ts
+var PublishNamespace = class _PublishNamespace {
+  /**
+   * @public
+   * Constructs a PublishNamespace message.
+   *
+   * @param requestId - The request ID for this publish namespace message.
+   * @param trackNamespace - The track namespace as a Tuple.
+   * @param parameters - The list of key-value parameters for the track.
+   */
+  constructor(requestId, trackNamespace, parameters) {
+    this.requestId = requestId;
+    this.trackNamespace = trackNamespace;
+    this.parameters = parameters;
+  }
+  /**
+   * @public
+   * Gets the message type for this PublishNamespace message.
+   *
+   * @returns The ControlMessageType.Announce value.
+   */
+  getType() {
+    return 6 /* PublishNamespace */;
+  }
+  /**
+   * @public
+   * Serializes the PublishNamespace message into a {@link FrozenByteBuffer}.
+   *
+   * @returns The serialized buffer.
+   * @throws :{@link LengthExceedsMaxError} If the payload exceeds 65535 bytes.
+   */
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(6 /* PublishNamespace */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    payload.putTuple(this.trackNamespace);
+    payload.putVI(this.parameters.length);
+    for (const param of this.parameters) {
+      payload.putKeyValuePair(param);
+    }
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("PublishNamespace::serialize(payloadBytes.length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  /**
+   * @public
+   * Parses a PublishNamespace message from the given buffer.
+   *
+   * @param buf - The buffer to parse from.
+   * @returns The parsed PublishNamespace message.
+   * @throws :{@link NotEnoughBytesError} If the buffer does not contain enough bytes.
+   */
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    const trackNamespace = buf.getTuple();
+    const paramCount = buf.getNumberVI();
+    const parameters = new Array(paramCount);
+    for (let i = 0; i < paramCount; i++) {
+      parameters[i] = buf.getKeyValuePair();
+    }
+    return new _PublishNamespace(requestId, trackNamespace, parameters);
+  }
+};
+
+// src/model/control/subscribe.ts
+var Subscribe = class _Subscribe {
+  constructor(requestId, fullTrackName, subscriberPriority, groupOrder, forward, filterType, startLocation, endGroup, parameters) {
+    this.requestId = requestId;
+    this.fullTrackName = fullTrackName;
+    this.subscriberPriority = subscriberPriority;
+    this.groupOrder = groupOrder;
+    this.forward = forward;
+    this.filterType = filterType;
+    this.startLocation = startLocation;
+    this.endGroup = endGroup;
+    this.parameters = parameters;
+  }
+  static newNextGroupStart(requestId, fullTrackName, subscriberPriority, groupOrder, forward, parameters) {
+    return new _Subscribe(
+      requestId,
+      fullTrackName,
+      subscriberPriority,
+      groupOrder,
+      forward,
+      1 /* NextGroupStart */,
+      void 0,
+      void 0,
+      parameters
+    );
+  }
+  static newLatestObject(requestId, fullTrackName, subscriberPriority, groupOrder, forward, parameters) {
+    return new _Subscribe(
+      requestId,
+      fullTrackName,
+      subscriberPriority,
+      groupOrder,
+      forward,
+      2 /* LatestObject */,
+      void 0,
+      void 0,
+      parameters
+    );
+  }
+  static newAbsoluteStart(requestId, fullTrackName, subscriberPriority, groupOrder, forward, startLocation, parameters) {
+    return new _Subscribe(
+      requestId,
+      fullTrackName,
+      subscriberPriority,
+      groupOrder,
+      forward,
+      3 /* AbsoluteStart */,
+      startLocation,
+      void 0,
+      parameters
+    );
+  }
+  static newAbsoluteRange(requestId, fullTrackName, subscriberPriority, groupOrder, forward, startLocation, endGroup, parameters) {
+    if (endGroup < startLocation.group) {
+      throw new Error("End Group must be >= Start Group");
+    }
+    return new _Subscribe(
+      requestId,
+      fullTrackName,
+      subscriberPriority,
+      groupOrder,
+      forward,
+      4 /* AbsoluteRange */,
+      startLocation,
+      endGroup,
+      parameters
+    );
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(3 /* Subscribe */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    payload.putBytes(this.fullTrackName.serialize().toUint8Array());
+    payload.putU8(this.subscriberPriority);
+    payload.putU8(this.groupOrder);
+    payload.putU8(this.forward ? 1 : 0);
+    payload.putVI(this.filterType);
+    if (this.filterType === 3 /* AbsoluteStart */ || this.filterType === 4 /* AbsoluteRange */) {
+      if (!this.startLocation) {
+        throw new Error("StartLocation required for selected filterType");
+      }
+      payload.putLocation(this.startLocation);
+    }
+    if (this.filterType === 4 /* AbsoluteRange */) {
+      if (this.endGroup == null) {
+        throw new Error("EndGroup required for AbsoluteRange");
+      }
+      payload.putVI(this.endGroup);
+    }
+    payload.putVI(this.parameters.length);
+    for (const param of this.parameters) {
+      payload.putBytes(param.serialize().toUint8Array());
+    }
+    const payloadBytes = payload.toUint8Array();
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    const fullTrackName = buf.getFullTrackName();
+    const subscriberPriority = buf.getU8();
+    const groupOrder = buf.getU8();
+    const forward = buf.getU8() === 1;
+    const filterType = Number(buf.getVI());
+    let startLocation = void 0;
+    let endGroup = void 0;
+    if (filterType === 3 /* AbsoluteStart */ || filterType === 4 /* AbsoluteRange */) {
+      startLocation = buf.getLocation();
+    }
+    if (filterType === 4 /* AbsoluteRange */) {
+      endGroup = buf.getVI();
+    }
+    const paramCount = Number(buf.getVI());
+    const parameters = [];
+    for (let i = 0; i < paramCount; i++) {
+      parameters.push(KeyValuePair.deserialize(buf));
+    }
+    return new _Subscribe(
+      requestId,
+      fullTrackName,
+      subscriberPriority,
+      groupOrder,
+      forward,
+      filterType,
+      startLocation,
+      endGroup,
+      parameters
+    );
+  }
+};
+
+// src/model/control/switch.ts
+var Switch = class _Switch {
+  constructor(requestId, fullTrackName, subscriptionRequestId, parameters) {
+    this.requestId = requestId;
+    this.fullTrackName = fullTrackName;
+    this.subscriptionRequestId = subscriptionRequestId;
+    this.parameters = parameters;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(34 /* Switch */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    payload.putBytes(this.fullTrackName.serialize().toUint8Array());
+    payload.putVI(this.subscriptionRequestId);
+    payload.putVI(this.parameters.length);
+    for (const param of this.parameters) {
+      payload.putBytes(param.serialize().toUint8Array());
+    }
+    const payloadBytes = payload.toUint8Array();
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    const fullTrackName = buf.getFullTrackName();
+    const subscriptionRequestId = buf.getVI();
+    const paramCount = Number(buf.getVI());
+    const parameters = [];
+    for (let i = 0; i < paramCount; i++) {
+      parameters.push(KeyValuePair.deserialize(buf));
+    }
+    return new _Switch(requestId, fullTrackName, subscriptionRequestId, parameters);
+  }
+};
+
+// src/model/control/publish_namespace_error.ts
+var PublishNamespaceError = class _PublishNamespaceError {
+  constructor(requestId, errorCode, reasonPhrase) {
+    this.requestId = requestId;
+    this.errorCode = errorCode;
+    this.reasonPhrase = reasonPhrase;
+  }
+  getType() {
+    return 8 /* PublishNamespaceError */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(8 /* PublishNamespaceError */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    payload.putVI(this.errorCode);
+    payload.putReasonPhrase(this.reasonPhrase);
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError(
+        "PublishNamespaceError::serialize(payloadBytes.length)",
+        65535,
+        payloadBytes.length
+      );
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    const errorCodeRaw = buf.getVI();
+    const errorCode = publishNamespaceErrorCodeFromBigInt(errorCodeRaw);
+    const reasonPhrase = buf.getReasonPhrase();
+    return new _PublishNamespaceError(requestId, errorCode, reasonPhrase);
+  }
+};
+
+// src/model/control/publish_namespace_ok.ts
+var PublishNamespaceOk = class _PublishNamespaceOk {
+  requestId;
+  constructor(requestId) {
+    this.requestId = BigInt(requestId);
+  }
+  getType() {
+    return 7 /* PublishNamespaceOk */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    buf.putVI(7 /* PublishNamespaceOk */);
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("PublishNamespaceOk::serialize(payloadBytes.length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    return new _PublishNamespaceOk(requestId);
+  }
+};
+
+// src/model/control/publish_namespace_cancel.ts
+var PublishNamespaceCancel = class _PublishNamespaceCancel {
+  constructor(trackNamespace, errorCode, reasonPhrase) {
+    this.trackNamespace = trackNamespace;
+    this.errorCode = errorCode;
+    this.reasonPhrase = reasonPhrase;
+  }
+  getType() {
+    return 12 /* PublishNamespaceCancel */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(12 /* PublishNamespaceCancel */);
+    const payload = new ByteBuffer();
+    payload.putTuple(this.trackNamespace);
+    payload.putVI(this.errorCode);
+    payload.putReasonPhrase(this.reasonPhrase);
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError(
+        "PublishNamespaceCancel::serialize(payloadBytes.length)",
+        65535,
+        payloadBytes.length
+      );
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const trackNamespace = buf.getTuple();
+    const errorCodeRaw = buf.getVI();
+    const errorCode = publishNamespaceErrorCodeFromBigInt(errorCodeRaw);
+    const reasonPhrase = buf.getReasonPhrase();
+    return new _PublishNamespaceCancel(trackNamespace, errorCode, reasonPhrase);
+  }
+};
+
+// src/model/control/client_setup.ts
+var ClientSetup = class _ClientSetup {
+  constructor(supportedVersions, setupParameters) {
+    this.supportedVersions = supportedVersions;
+    this.setupParameters = setupParameters;
+  }
+  getType() {
+    return 32 /* ClientSetup */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(32 /* ClientSetup */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.supportedVersions.length);
+    for (const version of this.supportedVersions) {
+      payload.putVI(version);
+    }
+    payload.putVI(this.setupParameters.length);
+    for (const param of this.setupParameters) {
+      payload.putKeyValuePair(param);
+    }
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("ClientSetup::serialize(payload_length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const numberOfSupportedVersions = buf.getNumberVI();
+    const supportedVersions = new Array(numberOfSupportedVersions);
+    for (let i = 0; i < numberOfSupportedVersions; i++) {
+      supportedVersions[i] = buf.getNumberVI();
+    }
+    const paramCount = buf.getNumberVI();
+    const setupParameters = new Array(paramCount);
+    for (let i = 0; i < paramCount; i++) {
+      setupParameters[i] = buf.getKeyValuePair();
+    }
+    return new _ClientSetup(supportedVersions, setupParameters);
+  }
+};
+
+// src/model/control/fetch.ts
+var Fetch = class _Fetch {
+  constructor(requestId, subscriberPriority, groupOrder, typeAndProps, parameters) {
+    this.requestId = requestId;
+    this.subscriberPriority = subscriberPriority;
+    this.groupOrder = groupOrder;
+    this.typeAndProps = typeAndProps;
+    this.parameters = parameters;
+  }
+  getType() {
+    return 22 /* Fetch */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(22 /* Fetch */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    payload.putU8(this.subscriberPriority);
+    payload.putU8(this.groupOrder);
+    payload.putVI(this.typeAndProps.type);
+    switch (this.typeAndProps.type) {
+      case 3 /* Absolute */:
+      case 2 /* Relative */: {
+        payload.putVI(this.typeAndProps.props.joiningRequestId);
+        payload.putVI(this.typeAndProps.props.joiningStart);
+        break;
+      }
+      case 1 /* StandAlone */: {
+        payload.putFullTrackName(this.typeAndProps.props.fullTrackName);
+        payload.putLocation(this.typeAndProps.props.startLocation);
+        payload.putLocation(this.typeAndProps.props.endLocation);
+        break;
+      }
+    }
+    payload.putVI(this.parameters.length);
+    for (const param of this.parameters) {
+      payload.putKeyValuePair(param);
+    }
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("Fetch::serialize(payload_length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    if (buf.remaining < 1) throw new NotEnoughBytesError("Fetch::parse_payload(subscriber_priority)", 1, buf.remaining);
+    const subscriberPriority = buf.getU8();
+    if (buf.remaining < 1) throw new NotEnoughBytesError("Fetch::parse_payload(group_order)", 1, buf.remaining);
+    const groupOrderRaw = buf.getU8();
+    const groupOrder = groupOrderFromNumber(groupOrderRaw);
+    const fetchTypeRaw = buf.getVI();
+    const fetchType = fetchTypeFromBigInt(fetchTypeRaw);
+    let props;
+    switch (fetchType) {
+      case 3 /* Absolute */:
+      case 2 /* Relative */: {
+        const joiningRequestId = buf.getVI();
+        const joiningStart = buf.getVI();
+        props = {
+          type: fetchType,
+          props: { joiningRequestId, joiningStart }
+        };
+        break;
+      }
+      case 1 /* StandAlone */: {
+        const fullTrackName = buf.getFullTrackName();
+        const startLocation = buf.getLocation();
+        const endLocation = buf.getLocation();
+        props = {
+          type: 1 /* StandAlone */,
+          props: { fullTrackName, startLocation, endLocation }
+        };
+        break;
+      }
+      default:
+        throw new Error(`Unknown fetch type: ${fetchType}`);
+    }
+    const paramCount = buf.getNumberVI();
+    const parameters = new Array(paramCount);
+    for (let i = 0; i < paramCount; i++) {
+      parameters[i] = buf.getKeyValuePair();
+    }
+    return new _Fetch(requestId, subscriberPriority, groupOrder, props, parameters);
+  }
+};
+
+// src/model/control/fetch_cancel.ts
+var FetchCancel = class _FetchCancel {
+  requestId;
+  constructor(requestId) {
+    this.requestId = BigInt(requestId);
+  }
+  getType() {
+    return 23 /* FetchCancel */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(23 /* FetchCancel */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("FetchCancel::serialize(payloadBytes.length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    return new _FetchCancel(requestId);
+  }
+};
+
+// src/model/control/fetch_error.ts
+var FetchError = class _FetchError {
+  requestId;
+  errorCode;
+  reasonPhrase;
+  constructor(requestId, errorCode, reasonPhrase) {
+    this.requestId = requestId;
+    this.errorCode = errorCode;
+    this.reasonPhrase = reasonPhrase;
+  }
+  getType() {
+    return 25 /* FetchError */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(25 /* FetchError */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    payload.putVI(this.errorCode);
+    payload.putReasonPhrase(this.reasonPhrase);
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("FetchError::serialize(payloadBytes.length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    const errorCodeRaw = buf.getVI();
+    const errorCode = fetchErrorCodeFromBigInt(errorCodeRaw);
+    const reasonPhrase = buf.getReasonPhrase();
+    return new _FetchError(requestId, errorCode, reasonPhrase);
+  }
+};
+
+// src/model/control/fetch_ok.ts
+var FetchOk = class _FetchOk {
+  constructor(requestId, groupOrder, endOfTrack, endLocation, parameters) {
+    this.requestId = requestId;
+    this.groupOrder = groupOrder;
+    this.endOfTrack = endOfTrack;
+    this.endLocation = endLocation;
+    this.parameters = parameters;
+  }
+  static newAscending(requestId, endOfTrack, endLocation, parameters) {
+    return new _FetchOk(BigInt(requestId), 1 /* Ascending */, endOfTrack, endLocation, parameters);
+  }
+  static newDescending(requestId, endOfTrack, endLocation, parameters) {
+    return new _FetchOk(BigInt(requestId), 2 /* Descending */, endOfTrack, endLocation, parameters);
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(BigInt(24 /* FetchOk */));
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    payload.putU8(this.groupOrder);
+    payload.putU8(this.endOfTrack ? 1 : 0);
+    payload.putLocation(this.endLocation);
+    payload.putVI(this.parameters.length);
+    for (const param of this.parameters) {
+      payload.putKeyValuePair(param);
+    }
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("FetchOk::serialize(payloadBytes.length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    if (buf.remaining < 1) {
+      throw new NotEnoughBytesError("FetchOk::parsePayload(group_order)", 1, 0);
+    }
+    const groupOrderRaw = buf.getU8();
+    const groupOrder = groupOrderFromNumber(groupOrderRaw);
+    if (groupOrder === 0 /* Original */) {
+      throw new ProtocolViolationError(
+        "FetchOk::parsePayload(groupOrder)",
+        "Group order must be Ascending(0x01) or Descending(0x02)"
+      );
+    }
+    if (buf.remaining < 1) {
+      throw new NotEnoughBytesError("FetchOk::parsePayload(endOfTrack)", 1, 0);
+    }
+    const endOfTrackRaw = buf.getU8();
+    let endOfTrack;
+    if (endOfTrackRaw === 0) {
+      endOfTrack = false;
+    } else if (endOfTrackRaw === 1) {
+      endOfTrack = true;
+    } else {
+      throw new ProtocolViolationError(
+        "FetchOk::parsePayload(endOfTrack)",
+        "End of track must be true(0x01) or false(0x00)"
+      );
+    }
+    const endLocation = buf.getLocation();
+    const paramCount = buf.getNumberVI();
+    const parameters = new Array(paramCount);
+    for (let i = 0; i < paramCount; i++) {
+      parameters[i] = buf.getKeyValuePair();
+    }
+    return new _FetchOk(requestId, groupOrder, endOfTrack, endLocation, parameters);
+  }
+};
+
+// src/model/control/goaway.ts
+var GoAway = class _GoAway {
+  newSessionUri;
+  constructor(newSessionUri) {
+    if (newSessionUri && newSessionUri.length === 0) {
+      this.newSessionUri = void 0;
+    } else {
+      this.newSessionUri = newSessionUri;
+    }
+  }
+  static getType() {
+    return 16 /* GoAway */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(16 /* GoAway */);
+    const payload = new ByteBuffer();
+    if (this.newSessionUri) {
+      let uriBytes;
+      try {
+        const encoder = new TextEncoder();
+        uriBytes = encoder.encode(this.newSessionUri);
+      } catch (error) {
+        throw new InvalidUTF8Error(
+          "GoAway::serialize(newSessionUri)",
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+      payload.putLengthPrefixedBytes(uriBytes);
+    } else {
+      payload.putVI(0);
+    }
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("GoAway::serialize(payloadBytes.length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const uriLength = buf.getNumberVI();
+    if (uriLength === 0) {
+      return new _GoAway(void 0);
+    }
+    if (buf.remaining < uriLength) {
+      throw new NotEnoughBytesError("GoAway::parsePayload(uriLength)", uriLength, buf.remaining);
+    }
+    const uriBytes = buf.getBytes(uriLength);
+    let newSessionUri;
+    try {
+      const decoder = new TextDecoder();
+      newSessionUri = decoder.decode(uriBytes);
+    } catch (error) {
+      throw new InvalidUTF8Error(
+        "GoAway::parsePayload(newSessionUri)",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+    return new _GoAway(newSessionUri);
+  }
+};
+
+// src/model/control/max_request_id.ts
+var MaxRequestId = class _MaxRequestId {
+  requestId;
+  constructor(requestId) {
+    this.requestId = BigInt(requestId);
+  }
+  getType() {
+    return 21 /* MaxRequestId */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId + 1n);
+    buf.putVI(21 /* MaxRequestId */);
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("MaxRequestId::serialize(payload_length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    return new _MaxRequestId(requestId);
+  }
+};
+
+// src/model/control/server_setup.ts
+var ServerSetup = class _ServerSetup {
+  constructor(selectedVersion, setupParameters) {
+    this.selectedVersion = selectedVersion;
+    this.setupParameters = setupParameters;
+  }
+  getType() {
+    return 33 /* ServerSetup */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(33 /* ServerSetup */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.selectedVersion);
+    payload.putVI(this.setupParameters.length);
+    for (const param of this.setupParameters) {
+      payload.putKeyValuePair(param);
+    }
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("ServerSetup::serialize(payloadBytes.length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const selectedVersion = buf.getNumberVI();
+    const paramCount = buf.getNumberVI();
+    const setupParameters = new Array(paramCount);
+    for (let i = 0; i < paramCount; i++) {
+      setupParameters[i] = buf.getKeyValuePair();
+    }
+    return new _ServerSetup(selectedVersion, setupParameters);
+  }
+};
+
+// src/model/control/publish_done.ts
+var PublishDone = class _PublishDone {
+  constructor(requestId, statusCode, streamCount, errorReason) {
+    this.requestId = requestId;
+    this.statusCode = statusCode;
+    this.streamCount = streamCount;
+    this.errorReason = errorReason;
+  }
+  static new(requestId, statusCode, streamCount, errorReason) {
+    return new _PublishDone(BigInt(requestId), statusCode, streamCount, errorReason);
+  }
+  getType() {
+    return 11 /* PublishDone */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(11 /* PublishDone */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    payload.putVI(this.statusCode);
+    payload.putVI(this.streamCount);
+    payload.putReasonPhrase(this.errorReason);
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("PublishDone::serialize(payloadBytes.length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    const statusCodeRaw = buf.getVI();
+    const statusCode = publishDoneStatusCodeFromBigInt(statusCodeRaw);
+    const streamCount = buf.getVI();
+    const errorReason = buf.getReasonPhrase();
+    return new _PublishDone(requestId, statusCode, streamCount, errorReason);
+  }
+};
+
+// src/model/control/publish.ts
+var Publish = class _Publish {
+  constructor(requestId, trackNamespace, trackName, trackAlias, groupOrder, contentExists, largestLocation, forward, parameters) {
+    this.requestId = requestId;
+    this.trackNamespace = trackNamespace;
+    this.trackName = trackName;
+    this.trackAlias = trackAlias;
+    this.groupOrder = groupOrder;
+    this.contentExists = contentExists;
+    this.largestLocation = largestLocation;
+    this.forward = forward;
+    this.parameters = parameters;
+  }
+  static new(requestId, trackNamespace, trackName, trackAlias, groupOrder, contentExists, largestLocation, forward, parameters) {
+    return new _Publish(
+      BigInt(requestId),
+      trackNamespace,
+      trackName,
+      BigInt(trackAlias),
+      groupOrder,
+      contentExists,
+      largestLocation,
+      forward,
+      parameters
+    );
+  }
+  getType() {
+    return 29 /* Publish */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    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.putVI(this.trackAlias);
+    payload.putU8(this.groupOrder);
+    payload.putU8(this.contentExists);
+    if (this.largestLocation !== void 0) {
+      payload.putBytes(this.largestLocation.serialize().toUint8Array());
+    }
+    payload.putU8(this.forward);
+    payload.putVI(this.parameters.length);
+    for (const param of this.parameters) {
+      payload.putKeyValuePair(param);
+    }
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("Publish::serialize(payloadBytes.length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  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 trackAlias = buf.getVI();
+    const groupOrder = buf.getU8();
+    const contentExists = buf.getU8();
+    let largestLocation;
+    if (contentExists === 1) {
+      largestLocation = Location.deserialize(buf);
+    }
+    const forward = buf.getU8();
+    const paramCount = buf.getVI();
+    const parameters = new Array(Number(paramCount));
+    for (let i = 0; i < paramCount; i++) {
+      parameters[i] = buf.getKeyValuePair();
+    }
+    return new _Publish(
+      requestId,
+      trackNamespace,
+      trackName,
+      trackAlias,
+      groupOrder,
+      contentExists,
+      largestLocation,
+      forward,
+      parameters
+    );
+  }
+};
+
+// src/model/control/publish_ok.ts
+var PublishOk = class _PublishOk {
+  constructor(requestId, forward, subscriberPriority, groupOrder, filterType, startLocation, endGroup, parameters) {
+    this.requestId = requestId;
+    this.forward = forward;
+    this.subscriberPriority = subscriberPriority;
+    this.groupOrder = groupOrder;
+    this.filterType = filterType;
+    this.startLocation = startLocation;
+    this.endGroup = endGroup;
+    this.parameters = parameters;
+  }
+  static new(requestId, forward, subscriberPriority, groupOrder, filterType, startLocation, endGroup, parameters) {
+    return new _PublishOk(
+      BigInt(requestId),
+      forward,
+      subscriberPriority,
+      groupOrder,
+      filterType,
+      startLocation,
+      endGroup !== void 0 ? BigInt(endGroup) : void 0,
+      parameters
+    );
+  }
+  getType() {
+    return 30 /* PublishOk */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(30 /* PublishOk */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    payload.putU8(this.forward);
+    payload.putU8(this.subscriberPriority);
+    payload.putU8(this.groupOrder);
+    payload.putVI(this.filterType);
+    if (this.filterType === 3 /* AbsoluteStart */ || this.filterType === 4 /* AbsoluteRange */) {
+      if (this.startLocation !== void 0) {
+        payload.putBytes(this.startLocation.serialize().toUint8Array());
+      }
+    }
+    if (this.filterType === 4 /* AbsoluteRange */) {
+      if (this.endGroup !== void 0) {
+        payload.putVI(this.endGroup);
+      }
+    }
+    payload.putVI(this.parameters.length);
+    for (const param of this.parameters) {
+      payload.putKeyValuePair(param);
+    }
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("PublishOk::serialize(payloadBytes.length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    const forward = buf.getU8();
+    const subscriberPriority = buf.getU8();
+    const groupOrder = buf.getU8();
+    const filterTypeRaw = buf.getVI();
+    const filterType = filterTypeFromBigInt(filterTypeRaw);
+    let startLocation;
+    let endGroup;
+    if (filterType === 3 /* AbsoluteStart */ || filterType === 4 /* AbsoluteRange */) {
+      startLocation = Location.deserialize(buf);
+    }
+    if (filterType === 4 /* AbsoluteRange */) {
+      endGroup = buf.getVI();
+    }
+    const paramCount = buf.getVI();
+    const parameters = new Array(Number(paramCount));
+    for (let i = 0; i < paramCount; i++) {
+      parameters[i] = buf.getKeyValuePair();
+    }
+    return new _PublishOk(
+      requestId,
+      forward,
+      subscriberPriority,
+      groupOrder,
+      filterType,
+      startLocation,
+      endGroup,
+      parameters
+    );
+  }
+};
+
+// src/model/control/publish_error.ts
+var PublishError = class _PublishError {
+  constructor(requestId, errorCode, errorReason) {
+    this.requestId = requestId;
+    this.errorCode = errorCode;
+    this.errorReason = errorReason;
+  }
+  static new(requestId, errorCode, errorReason) {
+    return new _PublishError(BigInt(requestId), errorCode, errorReason);
+  }
+  getType() {
+    return 31 /* PublishError */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(31 /* PublishError */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    payload.putVI(this.errorCode);
+    payload.putReasonPhrase(this.errorReason);
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("PublishError::serialize(payloadBytes.length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    const errorCodeRaw = buf.getVI();
+    const errorCode = publishErrorCodeFromBigInt(errorCodeRaw);
+    const errorReason = buf.getReasonPhrase();
+    return new _PublishError(requestId, errorCode, errorReason);
+  }
+};
+
+// src/model/control/subscribe_error.ts
+var SubscribeError = class _SubscribeError {
+  constructor(requestId, errorCode, errorReason) {
+    this.requestId = requestId;
+    this.errorCode = errorCode;
+    this.errorReason = errorReason;
+  }
+  static new(requestId, errorCode, errorReason) {
+    return new _SubscribeError(BigInt(requestId), errorCode, errorReason);
+  }
+  getType() {
+    return 5 /* SubscribeError */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(5 /* SubscribeError */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    payload.putVI(this.errorCode);
+    payload.putReasonPhrase(this.errorReason);
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("SubscribeError::serialize(payloadBytes.length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    const errorCodeRaw = buf.getVI();
+    const errorCode = subscribeErrorCodeFromBigInt(errorCodeRaw);
+    const errorReason = buf.getReasonPhrase();
+    return new _SubscribeError(requestId, errorCode, errorReason);
+  }
+};
+
+// src/model/control/subscribe_ok.ts
+var SubscribeOk = class _SubscribeOk {
+  requestId;
+  trackAlias;
+  expires;
+  groupOrder;
+  contentExists;
+  largestLocation;
+  parameters;
+  constructor(requestId, trackAlias, expires, groupOrder, contentExists, largestLocation, parameters) {
+    this.requestId = requestId;
+    this.trackAlias = trackAlias;
+    this.expires = expires;
+    this.groupOrder = groupOrder;
+    this.contentExists = contentExists;
+    this.largestLocation = largestLocation;
+    this.parameters = parameters;
+  }
+  static newAscendingNoContent(requestId, trackAlias, expires, parameters) {
+    return new _SubscribeOk(requestId, trackAlias, expires, 1 /* Ascending */, false, void 0, parameters);
+  }
+  static newDescendingNoContent(requestId, trackAlias, expires, parameters) {
+    return new _SubscribeOk(requestId, trackAlias, expires, 2 /* Descending */, false, void 0, parameters);
+  }
+  static newAscendingWithContent(requestId, trackAlias, expires, largestLocation, parameters) {
+    return new _SubscribeOk(requestId, trackAlias, expires, 1 /* Ascending */, true, largestLocation, parameters);
+  }
+  static newDescendingWithContent(requestId, trackAlias, expires, largestLocation, parameters) {
+    return new _SubscribeOk(requestId, trackAlias, expires, 2 /* Descending */, true, largestLocation, parameters);
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(4 /* SubscribeOk */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    payload.putVI(this.trackAlias);
+    payload.putVI(this.expires);
+    payload.putU8(this.groupOrder);
+    if (this.contentExists) {
+      payload.putU8(1);
+      payload.putLocation(this.largestLocation);
+    } else {
+      payload.putU8(0);
+    }
+    payload.putVI(this.parameters.length);
+    for (const param of this.parameters) {
+      payload.putKeyValuePair(param);
+    }
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("SubscribeOk::serialize(payloadBytes.length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    const trackAlias = buf.getVI();
+    const expires = buf.getVI();
+    if (buf.remaining < 1) throw new NotEnoughBytesError("SubscribeOk::parsePayload(groupOrder)", 1, buf.remaining);
+    const groupOrderRaw = buf.getU8();
+    const groupOrder = groupOrderFromNumber(groupOrderRaw);
+    if (groupOrder === 0 /* Original */) {
+      throw new ProtocolViolationError(
+        "SubscribeOk::parsePayload(groupOrder)",
+        "Group order must be Ascending(0x01) or Descending(0x02)"
+      );
+    }
+    if (buf.remaining < 1) throw new NotEnoughBytesError("SubscribeOk::parsePayload(contentExists)", 1, buf.remaining);
+    const contentExistsRaw = buf.getU8();
+    let contentExists;
+    if (contentExistsRaw === 0) {
+      contentExists = false;
+    } else if (contentExistsRaw === 1) {
+      contentExists = true;
+    } else {
+      throw new ProtocolViolationError("SubscribeOk::parsePayload", `Invalid Content Exists value: ${contentExistsRaw}`);
+    }
+    let largestLocation = void 0;
+    if (contentExists) {
+      largestLocation = buf.getLocation();
+    }
+    const paramCount = buf.getNumberVI();
+    const parameters = new Array(paramCount);
+    for (let i = 0; i < paramCount; i++) {
+      parameters[i] = buf.getKeyValuePair();
+    }
+    return new _SubscribeOk(requestId, trackAlias, expires, groupOrder, contentExists, largestLocation, parameters);
+  }
+};
+
+// src/model/control/subscribe_update.ts
+var SubscribeUpdate = class _SubscribeUpdate {
+  constructor(requestId, subscriptionRequestId, startLocation, endGroup, subscriberPriority, forward, parameters) {
+    this.requestId = requestId;
+    this.subscriptionRequestId = subscriptionRequestId;
+    this.startLocation = startLocation;
+    this.endGroup = endGroup;
+    this.subscriberPriority = subscriberPriority;
+    this.forward = forward;
+    this.parameters = parameters;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(2 /* SubscribeUpdate */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    payload.putVI(this.subscriptionRequestId);
+    payload.putLocation(this.startLocation);
+    payload.putVI(this.endGroup);
+    payload.putU8(this.subscriberPriority);
+    payload.putU8(this.forward ? 1 : 0);
+    payload.putVI(this.parameters.length);
+    for (const param of this.parameters) {
+      payload.putBytes(param.serialize().toUint8Array());
+    }
+    const payloadBytes = payload.toUint8Array();
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    const subscriptionRequestId = buf.getVI();
+    const startLocation = buf.getLocation();
+    const endGroup = buf.getVI();
+    const subscriberPriority = buf.getU8();
+    const forward = buf.getU8();
+    const paramCountBig = buf.getVI();
+    const paramCount = Number(paramCountBig);
+    if (BigInt(paramCount) !== paramCountBig) {
+      throw new CastingError("SubscribeUpdate.deserialize paramCount", "bigint", "number", `${paramCountBig}`);
+    }
+    const parameters = [];
+    for (let i = 0; i < paramCount; i++) {
+      parameters.push(KeyValuePair.deserialize(buf));
+    }
+    return new _SubscribeUpdate(
+      requestId,
+      subscriptionRequestId,
+      startLocation,
+      endGroup,
+      subscriberPriority,
+      forward === 1,
+      parameters
+    );
+  }
+  equals(other) {
+    if (this.requestId !== other.requestId || this.subscriptionRequestId !== other.subscriptionRequestId || this.endGroup !== other.endGroup || this.subscriberPriority !== other.subscriberPriority || this.forward !== other.forward || this.startLocation === void 0 !== (other.startLocation === void 0) || this.startLocation && other.startLocation && !this.startLocation.equals(other.startLocation) || this.parameters.length !== other.parameters.length) {
+      return false;
+    }
+    for (let i = 0; i < this.parameters.length; i++) {
+      const a = this.parameters[i];
+      const b = other.parameters[i];
+      if (!a || !b || !a.equals(b)) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+// src/model/control/requests_blocked.ts
+var RequestsBlocked = class _RequestsBlocked {
+  maximumRequestId;
+  constructor(maximumRequestId) {
+    this.maximumRequestId = BigInt(maximumRequestId);
+  }
+  getType() {
+    return 26 /* RequestsBlocked */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(26 /* RequestsBlocked */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.maximumRequestId);
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("RequestsBlocked::serialize", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const maximumRequestId = buf.getVI();
+    return new _RequestsBlocked(maximumRequestId);
+  }
+};
+
+// src/model/control/track_status.ts
+var TrackStatus = class _TrackStatus {
+  constructor(requestId, trackAlias, fullTrackName, subscriberPriority, groupOrder, forward, filterType, startLocation, endGroup, subscribeParameters) {
+    this.requestId = requestId;
+    this.trackAlias = trackAlias;
+    this.fullTrackName = fullTrackName;
+    this.subscriberPriority = subscriberPriority;
+    this.groupOrder = groupOrder;
+    this.forward = forward;
+    this.filterType = filterType;
+    this.startLocation = startLocation;
+    this.endGroup = endGroup;
+    this.subscribeParameters = subscribeParameters;
+  }
+  static newNextGroupStart(requestId, trackAlias, fullTrackName, subscriberPriority, groupOrder, forward, subscribeParameters) {
+    return new _TrackStatus(
+      requestId,
+      trackAlias,
+      fullTrackName,
+      subscriberPriority,
+      groupOrder,
+      forward,
+      1 /* NextGroupStart */,
+      void 0,
+      void 0,
+      subscribeParameters
+    );
+  }
+  static newLatestObject(requestId, trackAlias, fullTrackName, subscriberPriority, groupOrder, forward, subscribeParameters) {
+    return new _TrackStatus(
+      requestId,
+      trackAlias,
+      fullTrackName,
+      subscriberPriority,
+      groupOrder,
+      forward,
+      2 /* LatestObject */,
+      void 0,
+      void 0,
+      subscribeParameters
+    );
+  }
+  static newAbsoluteStart(requestId, trackAlias, fullTrackName, subscriberPriority, groupOrder, forward, startLocation, subscribeParameters) {
+    return new _TrackStatus(
+      requestId,
+      trackAlias,
+      fullTrackName,
+      subscriberPriority,
+      groupOrder,
+      forward,
+      3 /* AbsoluteStart */,
+      startLocation,
+      void 0,
+      subscribeParameters
+    );
+  }
+  static newAbsoluteRange(requestId, trackAlias, fullTrackName, subscriberPriority, groupOrder, forward, startLocation, endGroup, subscribeParameters) {
+    if (endGroup < startLocation.group) {
+      throw new Error("End Group must be >= Start Group");
+    }
+    return new _TrackStatus(
+      requestId,
+      trackAlias,
+      fullTrackName,
+      subscriberPriority,
+      groupOrder,
+      forward,
+      4 /* AbsoluteRange */,
+      startLocation,
+      endGroup,
+      subscribeParameters
+    );
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(13 /* TrackStatus */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    payload.putVI(this.trackAlias);
+    payload.putBytes(this.fullTrackName.serialize().toUint8Array());
+    payload.putU8(this.subscriberPriority);
+    payload.putU8(this.groupOrder);
+    payload.putU8(this.forward ? 1 : 0);
+    payload.putVI(this.filterType);
+    if (this.filterType === 3 /* AbsoluteStart */ || this.filterType === 4 /* AbsoluteRange */) {
+      if (!this.startLocation) {
+        throw new Error("StartLocation required for selected filterType");
+      }
+      payload.putLocation(this.startLocation);
+    }
+    if (this.filterType === 4 /* AbsoluteRange */) {
+      if (this.endGroup == null) {
+        throw new Error("EndGroup required for AbsoluteRange");
+      }
+      payload.putVI(this.endGroup);
+    }
+    payload.putVI(this.subscribeParameters.length);
+    for (const param of this.subscribeParameters) {
+      payload.putBytes(param.serialize().toUint8Array());
+    }
+    const payloadBytes = payload.toUint8Array();
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    const trackAlias = buf.getVI();
+    const fullTrackName = buf.getFullTrackName();
+    const subscriberPriority = buf.getU8();
+    const groupOrder = buf.getU8();
+    const forward = buf.getU8() === 1;
+    const filterType = Number(buf.getVI());
+    let startLocation = void 0;
+    let endGroup = void 0;
+    if (filterType === 3 /* AbsoluteStart */ || filterType === 4 /* AbsoluteRange */) {
+      startLocation = buf.getLocation();
+    }
+    if (filterType === 4 /* AbsoluteRange */) {
+      endGroup = buf.getVI();
+    }
+    const paramCount = Number(buf.getVI());
+    const subscribeParameters = [];
+    for (let i = 0; i < paramCount; i++) {
+      subscribeParameters.push(KeyValuePair.deserialize(buf));
+    }
+    return new _TrackStatus(
+      requestId,
+      trackAlias,
+      fullTrackName,
+      subscriberPriority,
+      groupOrder,
+      forward,
+      filterType,
+      startLocation,
+      endGroup,
+      subscribeParameters
+    );
+  }
+};
+
+// src/model/control/publish_namespace_done.ts
+var PublishNamespaceDone = class _PublishNamespaceDone {
+  /**
+   * Constructs a PublishNamespaceDone message.
+   * @param trackNamespace - The track namespace to unpublish.
+   */
+  constructor(trackNamespace) {
+    this.trackNamespace = trackNamespace;
+  }
+  /**
+   * Gets the control message type for this PublishNamespaceDone message.
+   * @returns The ControlMessageType.PublishNamespaceDone enum value.
+   */
+  getType() {
+    return 9 /* PublishNamespaceDone */;
+  }
+  /**
+   * Serializes the PublishNamespaceDone message to a frozen byte buffer.
+   * @returns The serialized message as a FrozenByteBuffer.
+   * @throws :{@link LengthExceedsMaxError} If the payload exceeds 65535 bytes.
+   */
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(9 /* PublishNamespaceDone */);
+    const payload = new ByteBuffer();
+    payload.putTuple(this.trackNamespace);
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError(
+        "PublishNamespaceDone::serialize(payloadBytes.length)",
+        65535,
+        payloadBytes.length
+      );
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  /**
+   * Parses a PublishNamespaceDone message payload from a buffer.
+   * @param buf - The buffer containing the payload.
+   * @returns The parsed PublishNamespaceDone message.
+   */
+  static parsePayload(buf) {
+    const trackNamespace = buf.getTuple();
+    return new _PublishNamespaceDone(trackNamespace);
+  }
+};
+
+// src/model/control/unsubscribe.ts
+var Unsubscribe = class _Unsubscribe {
+  requestId;
+  constructor(requestId) {
+    this.requestId = BigInt(requestId);
+  }
+  getType() {
+    return 10 /* Unsubscribe */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(10 /* Unsubscribe */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("Unsubscribe::serialize(payloadBytes.length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    return new _Unsubscribe(requestId);
+  }
+};
+
+// src/model/control/subscribe_namespace.ts
+var SubscribeNamespace = class _SubscribeNamespace {
+  constructor(requestId, trackNamespacePrefix, parameters) {
+    this.requestId = requestId;
+    this.trackNamespacePrefix = trackNamespacePrefix;
+    this.parameters = parameters;
+  }
+  getType() {
+    return 17 /* SubscribeNamespace */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(17 /* SubscribeNamespace */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    payload.putTuple(this.trackNamespacePrefix);
+    payload.putVI(this.parameters.length);
+    for (const param of this.parameters) {
+      payload.putKeyValuePair(param);
+    }
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("SubscribeNamespace::serialize(payloadBytes.length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    const trackNamespacePrefix = buf.getTuple();
+    const paramCount = buf.getNumberVI();
+    const parameters = new Array(paramCount);
+    for (let i = 0; i < paramCount; i++) {
+      parameters[i] = buf.getKeyValuePair();
+    }
+    return new _SubscribeNamespace(requestId, trackNamespacePrefix, parameters);
+  }
+};
+
+// src/model/control/subscribe_namespace_ok.ts
+var SubscribeNamespaceOk = class _SubscribeNamespaceOk {
+  requestId;
+  constructor(requestId) {
+    this.requestId = BigInt(requestId);
+  }
+  getType() {
+    return 18 /* SubscribeNamespaceOk */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(18 /* SubscribeNamespaceOk */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("SubscribeNamespaceOk::serialize(payloadBytes)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    return new _SubscribeNamespaceOk(requestId);
+  }
+};
+
+// src/model/control/subscribe_namespace_error.ts
+var SubscribeNamespaceError = class _SubscribeNamespaceError {
+  constructor(requestId, errorCode, reasonPhrase) {
+    this.requestId = requestId;
+    this.errorCode = errorCode;
+    this.reasonPhrase = reasonPhrase;
+  }
+  getType() {
+    return 19 /* SubscribeNamespaceError */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(19 /* SubscribeNamespaceError */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    payload.putVI(this.errorCode);
+    payload.putReasonPhrase(this.reasonPhrase);
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("SubscribeNamespaceError::serialize(payload_length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    const errorCodeRaw = buf.getVI();
+    const errorCode = subscribeNamespaceErrorCodeFromBigInt(errorCodeRaw);
+    const reasonPhrase = buf.getReasonPhrase();
+    return new _SubscribeNamespaceError(requestId, errorCode, reasonPhrase);
+  }
+};
+
+// src/model/control/unsubscribe_namespace.ts
+var UnsubscribeNamespace = class _UnsubscribeNamespace {
+  constructor(trackNamespacePrefix) {
+    this.trackNamespacePrefix = trackNamespacePrefix;
+  }
+  getType() {
+    return 20 /* UnsubscribeNamespace */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(20 /* UnsubscribeNamespace */);
+    const payload = new ByteBuffer();
+    payload.putTuple(this.trackNamespacePrefix);
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("UnsubscribeNamespace::serialize(payload_length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const trackNamespacePrefix = buf.getTuple();
+    return new _UnsubscribeNamespace(trackNamespacePrefix);
+  }
+};
+
+// src/model/control/control_message.ts
+exports.ControlMessage = void 0;
+((ControlMessage2) => {
+  function deserialize(buf) {
+    const messageTypeRaw = buf.getVI();
+    const messageType = controlMessageTypeFromBigInt(messageTypeRaw);
+    const payloadLength = buf.getU16();
+    if (buf.remaining < payloadLength)
+      throw new NotEnoughBytesError("ControlMessage.deserialize(payload_bytes)", payloadLength, buf.remaining);
+    const payloadBytes = buf.getBytes(payloadLength);
+    const payload = new FrozenByteBuffer5(payloadBytes);
+    switch (messageType) {
+      case 29 /* Publish */:
+        return Publish.parsePayload(payload);
+      case 30 /* PublishOk */:
+        return PublishOk.parsePayload(payload);
+      case 31 /* PublishError */:
+        return PublishError.parsePayload(payload);
+      case 11 /* PublishDone */:
+        return PublishDone.parsePayload(payload);
+      case 6 /* PublishNamespace */:
+        return PublishNamespace.parsePayload(payload);
+      case 12 /* PublishNamespaceCancel */:
+        return PublishNamespaceCancel.parsePayload(payload);
+      case 8 /* PublishNamespaceError */:
+        return PublishNamespaceError.parsePayload(payload);
+      case 7 /* PublishNamespaceOk */:
+        return PublishNamespaceOk.parsePayload(payload);
+      case 32 /* ClientSetup */:
+        return ClientSetup.parsePayload(payload);
+      case 22 /* Fetch */:
+        return Fetch.parsePayload(payload);
+      case 23 /* FetchCancel */:
+        return FetchCancel.parsePayload(payload);
+      case 25 /* FetchError */:
+        return FetchError.parsePayload(payload);
+      case 24 /* FetchOk */:
+        return FetchOk.parsePayload(payload);
+      case 16 /* GoAway */:
+        return GoAway.parsePayload(payload);
+      case 21 /* MaxRequestId */:
+        return MaxRequestId.parsePayload(payload);
+      case 33 /* ServerSetup */:
+        return ServerSetup.parsePayload(payload);
+      case 3 /* Subscribe */:
+        return Subscribe.parsePayload(payload);
+      case 5 /* SubscribeError */:
+        return SubscribeError.parsePayload(payload);
+      case 4 /* SubscribeOk */:
+        return SubscribeOk.parsePayload(payload);
+      case 2 /* SubscribeUpdate */:
+        return SubscribeUpdate.parsePayload(payload);
+      case 26 /* RequestsBlocked */:
+        return RequestsBlocked.parsePayload(payload);
+      case 13 /* TrackStatus */:
+        return TrackStatus.parsePayload(payload);
+      case 13 /* TrackStatus */:
+        return TrackStatus.parsePayload(payload);
+      case 9 /* PublishNamespaceDone */:
+        return PublishNamespaceDone.parsePayload(payload);
+      case 10 /* Unsubscribe */:
+        return Unsubscribe.parsePayload(payload);
+      case 17 /* SubscribeNamespace */:
+        return SubscribeNamespace.parsePayload(payload);
+      case 18 /* SubscribeNamespaceOk */:
+        return SubscribeNamespaceOk.parsePayload(payload);
+      case 19 /* SubscribeNamespaceError */:
+        return SubscribeNamespaceError.parsePayload(payload);
+      case 20 /* UnsubscribeNamespace */:
+        return UnsubscribeNamespace.parsePayload(payload);
+      default:
+        throw new Error(`Unknown or unhandled ControlMessageType: ${messageType}`);
+    }
+  }
+  ControlMessage2.deserialize = deserialize;
+  function serialize(msg) {
+    return msg.serialize();
+  }
+  ControlMessage2.serialize = serialize;
+})(exports.ControlMessage || (exports.ControlMessage = {}));
+
+// src/model/control/track_status_error.ts
+var TrackStatusError = class _TrackStatusError {
+  constructor(requestId, errorCode, errorReason, trackAlias) {
+    this.requestId = requestId;
+    this.errorCode = errorCode;
+    this.errorReason = errorReason;
+    this.trackAlias = trackAlias;
+  }
+  static new(requestId, errorCode, errorReason, trackAlias) {
+    return new _TrackStatusError(BigInt(requestId), errorCode, errorReason, trackAlias);
+  }
+  getType() {
+    return 15 /* TrackStatusError */;
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(15 /* TrackStatusError */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    payload.putVI(this.errorCode);
+    payload.putReasonPhrase(this.errorReason);
+    payload.putVI(this.trackAlias);
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("TrackStatusError::serialize(payloadBytes.length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    const errorCodeRaw = buf.getVI();
+    const errorCode = subscribeErrorCodeFromBigInt(errorCodeRaw);
+    const errorReason = buf.getReasonPhrase();
+    const trackAlias = buf.getVI();
+    return new _TrackStatusError(requestId, errorCode, errorReason, trackAlias);
+  }
+};
+
+// src/model/control/track_status_ok.ts
+var TrackStatusOk = class _TrackStatusOk {
+  requestId;
+  expires;
+  groupOrder;
+  contentExists;
+  largestLocation;
+  subscribeParameters;
+  constructor(requestId, expires, groupOrder, contentExists, largestLocation, subscribeParameters) {
+    this.requestId = requestId;
+    this.expires = expires;
+    this.groupOrder = groupOrder;
+    this.contentExists = contentExists;
+    this.largestLocation = largestLocation;
+    this.subscribeParameters = subscribeParameters;
+  }
+  static newAscendingNoContent(requestId, expires, subscribeParameters) {
+    return new _TrackStatusOk(requestId, expires, 1 /* Ascending */, false, void 0, subscribeParameters);
+  }
+  static newDescendingNoContent(requestId, expires, subscribeParameters) {
+    return new _TrackStatusOk(requestId, expires, 2 /* Descending */, false, void 0, subscribeParameters);
+  }
+  static newAscendingWithContent(requestId, expires, largestLocation, subscribeParameters) {
+    return new _TrackStatusOk(requestId, expires, 1 /* Ascending */, true, largestLocation, subscribeParameters);
+  }
+  static newDescendingWithContent(requestId, expires, largestLocation, subscribeParameters) {
+    return new _TrackStatusOk(requestId, expires, 2 /* Descending */, true, largestLocation, subscribeParameters);
+  }
+  serialize() {
+    const buf = new ByteBuffer();
+    buf.putVI(14 /* TrackStatusOk */);
+    const payload = new ByteBuffer();
+    payload.putVI(this.requestId);
+    payload.putVI(this.expires);
+    payload.putU8(this.groupOrder);
+    if (this.contentExists) {
+      payload.putU8(1);
+      payload.putLocation(this.largestLocation);
+    } else {
+      payload.putU8(0);
+    }
+    payload.putVI(this.subscribeParameters.length);
+    for (const param of this.subscribeParameters) {
+      payload.putKeyValuePair(param);
+    }
+    const payloadBytes = payload.toUint8Array();
+    if (payloadBytes.length > 65535) {
+      throw new LengthExceedsMaxError("TrackStatusOk::serialize(payloadBytes.length)", 65535, payloadBytes.length);
+    }
+    buf.putU16(payloadBytes.length);
+    buf.putBytes(payloadBytes);
+    return buf.freeze();
+  }
+  static parsePayload(buf) {
+    const requestId = buf.getVI();
+    const expires = buf.getVI();
+    if (buf.remaining < 1) throw new NotEnoughBytesError("TrackStatusOk::parsePayload(groupOrder)", 1, buf.remaining);
+    const groupOrderRaw = buf.getU8();
+    const groupOrder = groupOrderFromNumber(groupOrderRaw);
+    if (groupOrder === 0 /* Original */) {
+      throw new ProtocolViolationError(
+        "TrackStatusOk::parsePayload(groupOrder)",
+        "Group order must be Ascending(0x01) or Descending(0x02)"
+      );
+    }
+    if (buf.remaining < 1) throw new NotEnoughBytesError("TrackStatusOk::parsePayload(contentExists)", 1, buf.remaining);
+    const contentExistsRaw = buf.getU8();
+    let contentExists;
+    if (contentExistsRaw === 0) {
+      contentExists = false;
+    } else if (contentExistsRaw === 1) {
+      contentExists = true;
+    } else {
+      throw new ProtocolViolationError(
+        "TrackStatusOk::parsePayload",
+        `Invalid Content Exists value: ${contentExistsRaw}`
+      );
+    }
+    let largestLocation = void 0;
+    if (contentExists) {
+      largestLocation = buf.getLocation();
+    }
+    const paramCount = buf.getNumberVI();
+    const subscribeParameters = new Array(paramCount);
+    for (let i = 0; i < paramCount; i++) {
+      subscribeParameters[i] = buf.getKeyValuePair();
+    }
+    return new _TrackStatusOk(requestId, expires, groupOrder, contentExists, largestLocation, subscribeParameters);
+  }
+};
+
+// src/model/parameter/constant.ts
+var CommonType = /* @__PURE__ */ ((CommonType2) => {
+  CommonType2[CommonType2["AuthorizationToken"] = 3] = "AuthorizationToken";
+  return CommonType2;
+})(CommonType || {});
+function commonTypeFromNumber(value) {
+  switch (value) {
+    case 3:
+      return 3 /* AuthorizationToken */;
+    default:
+      throw new InvalidTypeError("commonTypeFromNumber", `Invalid common type: ${value}`);
+  }
+}
+var SetupParameterType = /* @__PURE__ */ ((SetupParameterType2) => {
+  SetupParameterType2[SetupParameterType2["Path"] = 1] = "Path";
+  SetupParameterType2[SetupParameterType2["MaxRequestId"] = 2] = "MaxRequestId";
+  SetupParameterType2[SetupParameterType2["MaxAuthTokenCacheSize"] = 4] = "MaxAuthTokenCacheSize";
+  return SetupParameterType2;
+})(SetupParameterType || {});
+function setupParameterTypeFromNumber(value) {
+  switch (value) {
+    case 1:
+      return 1 /* Path */;
+    case 2:
+      return 2 /* MaxRequestId */;
+    case 4:
+      return 4 /* MaxAuthTokenCacheSize */;
+    default:
+      throw new InvalidTypeError("setupParameterTypeFromNumber", `Invalid setup parameter type: ${value}`);
+  }
+}
+var VersionSpecificParameterType = /* @__PURE__ */ ((VersionSpecificParameterType2) => {
+  VersionSpecificParameterType2[VersionSpecificParameterType2["AuthorizationToken"] = 1] = "AuthorizationToken";
+  VersionSpecificParameterType2[VersionSpecificParameterType2["DeliveryTimeout"] = 2] = "DeliveryTimeout";
+  VersionSpecificParameterType2[VersionSpecificParameterType2["MaxCacheDuration"] = 4] = "MaxCacheDuration";
+  return VersionSpecificParameterType2;
+})(VersionSpecificParameterType || {});
+function versionSpecificParameterTypeFromNumber(value) {
+  switch (value) {
+    case 1:
+      return 1 /* AuthorizationToken */;
+    case 2:
+      return 2 /* DeliveryTimeout */;
+    case 4:
+      return 4 /* MaxCacheDuration */;
+    default:
+      throw new InvalidTypeError("versionSpecificParameterTypeFromNumber", `Invalid version parameter type: ${value}`);
+  }
+}
+var TokenAliasType = /* @__PURE__ */ ((TokenAliasType3) => {
+  TokenAliasType3[TokenAliasType3["Delete"] = 0] = "Delete";
+  TokenAliasType3[TokenAliasType3["Register"] = 1] = "Register";
+  TokenAliasType3[TokenAliasType3["UseAlias"] = 2] = "UseAlias";
+  TokenAliasType3[TokenAliasType3["UseValue"] = 3] = "UseValue";
+  return TokenAliasType3;
+})(TokenAliasType || {});
+function tokenAliasTypeFromNumber(value) {
+  switch (value) {
+    case 0:
+      return 0 /* Delete */;
+    case 1:
+      return 1 /* Register */;
+    case 2:
+      return 2 /* UseAlias */;
+    case 3:
+      return 3 /* UseValue */;
+    default:
+      throw new InvalidTypeError("tokenAliasTypeFromNumber", `Invalid token alias type: ${value}`);
+  }
+}
+
+// src/model/parameter/setup/max_request_id.ts
+var MaxRequestId2 = class _MaxRequestId {
+  constructor(maxId) {
+    this.maxId = maxId;
+  }
+  static TYPE = 2 /* MaxRequestId */;
+  toKeyValuePair() {
+    return KeyValuePair.tryNewVarInt(_MaxRequestId.TYPE, this.maxId);
+  }
+  static fromKeyValuePair(pair) {
+    if (Number(pair.typeValue) !== _MaxRequestId.TYPE || typeof pair.value !== "bigint") return void 0;
+    return new _MaxRequestId(pair.value);
+  }
+};
+
+// src/model/parameter/setup/path.ts
+var Path = class _Path {
+  constructor(moqtPath) {
+    this.moqtPath = moqtPath;
+  }
+  static TYPE = 1 /* Path */;
+  toKeyValuePair() {
+    const encoder = new TextEncoder();
+    const bytes = encoder.encode(this.moqtPath);
+    return KeyValuePair.tryNewBytes(_Path.TYPE, bytes);
+  }
+  static fromKeyValuePair(pair) {
+    if (Number(pair.typeValue) !== _Path.TYPE || !(pair.value instanceof Uint8Array)) return void 0;
+    const moqtPath = new TextDecoder().decode(pair.value);
+    return new _Path(moqtPath);
+  }
+};
+
+// src/model/parameter/setup/max_auth_token_cache_size.ts
+var MaxAuthTokenCacheSize = class _MaxAuthTokenCacheSize {
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+  }
+  static TYPE = 4 /* MaxAuthTokenCacheSize */;
+  toKeyValuePair() {
+    return KeyValuePair.tryNewVarInt(_MaxAuthTokenCacheSize.TYPE, this.maxSize);
+  }
+  static fromKeyValuePair(pair) {
+    if (Number(pair.typeValue) !== _MaxAuthTokenCacheSize.TYPE || typeof pair.value !== "bigint") return void 0;
+    return new _MaxAuthTokenCacheSize(pair.value);
+  }
+};
+
+// src/model/parameter/common/authorization_token.ts
+var AuthorizationToken = class _AuthorizationToken {
+  constructor(variant) {
+    this.variant = variant;
+  }
+  static TYPE = 3 /* AuthorizationToken */;
+  static newDelete(tokenAlias) {
+    return new _AuthorizationToken({
+      aliasType: 0 /* Delete */,
+      tokenAlias: BigInt(tokenAlias)
+    });
+  }
+  static newRegister(tokenAlias, tokenType, tokenValue) {
+    return new _AuthorizationToken({
+      aliasType: 1 /* Register */,
+      tokenAlias: BigInt(tokenAlias),
+      tokenType: BigInt(tokenType),
+      tokenValue
+    });
+  }
+  static newUseAlias(tokenAlias) {
+    return new _AuthorizationToken({
+      aliasType: 2 /* UseAlias */,
+      tokenAlias: BigInt(tokenAlias)
+    });
+  }
+  static newUseValue(tokenType, tokenValue) {
+    return new _AuthorizationToken({
+      aliasType: 3 /* UseValue */,
+      tokenType: BigInt(tokenType),
+      tokenValue
+    });
+  }
+  toKeyValuePair() {
+    const payload = new ByteBuffer();
+    payload.putVI(this.variant.aliasType);
+    switch (this.variant.aliasType) {
+      case 0 /* Delete */:
+        payload.putVI(this.variant.tokenAlias);
+        break;
+      case 1 /* Register */:
+        payload.putVI(this.variant.tokenAlias);
+        payload.putVI(this.variant.tokenType);
+        payload.putBytes(this.variant.tokenValue);
+        break;
+      case 2 /* UseAlias */:
+        payload.putVI(this.variant.tokenAlias);
+        break;
+      case 3 /* UseValue */:
+        payload.putVI(this.variant.tokenType);
+        payload.putBytes(this.variant.tokenValue);
+        break;
+    }
+    return KeyValuePair.tryNewBytes(_AuthorizationToken.TYPE, payload.toUint8Array());
+  }
+  static fromKeyValuePair(pair) {
+    if (Number(pair.typeValue) !== _AuthorizationToken.TYPE || !(pair.value instanceof Uint8Array)) return void 0;
+    const frozen = new FrozenByteBuffer5(pair.value);
+    const aliasTypeRaw = frozen.getNumberVI();
+    const aliasType = tokenAliasTypeFromNumber(aliasTypeRaw);
+    switch (aliasType) {
+      case 0 /* Delete */: {
+        const tokenAlias = frozen.getVI();
+        return new _AuthorizationToken({ aliasType, tokenAlias });
+      }
+      case 1 /* Register */: {
+        const tokenAlias = frozen.getVI();
+        const tokenType = frozen.getVI();
+        const tokenValue = frozen.getBytes(frozen.remaining);
+        return new _AuthorizationToken({ aliasType, tokenAlias, tokenType, tokenValue });
+      }
+      case 2 /* UseAlias */: {
+        const tokenAlias = frozen.getVI();
+        return new _AuthorizationToken({ aliasType, tokenAlias });
+      }
+      case 3 /* UseValue */: {
+        const tokenType = frozen.getVI();
+        const tokenValue = frozen.getBytes(frozen.remaining);
+        return new _AuthorizationToken({ aliasType, tokenType, tokenValue });
+      }
+    }
+  }
+};
+
+// src/model/parameter/setup_parameter.ts
+exports.SetupParameter = void 0;
+((SetupParameter2) => {
+  function fromKeyValuePair(pair) {
+    return Path.fromKeyValuePair(pair) || MaxRequestId2.fromKeyValuePair(pair) || MaxAuthTokenCacheSize.fromKeyValuePair(pair) || AuthorizationToken.fromKeyValuePair(pair);
+  }
+  SetupParameter2.fromKeyValuePair = fromKeyValuePair;
+  function toKeyValuePair(param) {
+    return param.toKeyValuePair();
+  }
+  SetupParameter2.toKeyValuePair = toKeyValuePair;
+  function isPath(param) {
+    return param instanceof Path;
+  }
+  SetupParameter2.isPath = isPath;
+  function isMaxRequestId(param) {
+    return param instanceof MaxRequestId2;
+  }
+  SetupParameter2.isMaxRequestId = isMaxRequestId;
+  function isMaxAuthTokenCacheSize(param) {
+    return param instanceof MaxAuthTokenCacheSize;
+  }
+  SetupParameter2.isMaxAuthTokenCacheSize = isMaxAuthTokenCacheSize;
+  function isAuthorizationToken(param) {
+    return param instanceof AuthorizationToken;
+  }
+  SetupParameter2.isAuthorizationToken = isAuthorizationToken;
+})(exports.SetupParameter || (exports.SetupParameter = {}));
+var SetupParameters = class {
+  kvps = [];
+  addMaxAuthTokenCacheSize(maxSize) {
+    this.kvps.push(new MaxAuthTokenCacheSize(BigInt(maxSize)).toKeyValuePair());
+    return this;
+  }
+  addMaxRequestId(maxId) {
+    this.kvps.push(new MaxRequestId2(BigInt(maxId)).toKeyValuePair());
+    return this;
+  }
+  addPath(moqtPath) {
+    this.kvps.push(new Path(moqtPath).toKeyValuePair());
+    return this;
+  }
+  addAuthorizationToken(auth) {
+    this.kvps.push(auth.toKeyValuePair());
+    return this;
+  }
+  addRaw(pair) {
+    this.kvps.push(pair);
+    return this;
+  }
+  build() {
+    return this.kvps;
+  }
+  static fromKeyValuePairs(kvps) {
+    const result = [];
+    for (const kvp of kvps) {
+      const parsed = Path.fromKeyValuePair(kvp) || MaxRequestId2.fromKeyValuePair(kvp) || MaxAuthTokenCacheSize.fromKeyValuePair(kvp) || AuthorizationToken.fromKeyValuePair(kvp);
+      if (parsed) result.push(parsed);
+    }
+    return result;
+  }
+};
+
+// src/model/parameter/version/delivery_timeout.ts
+var DeliveryTimeout = class _DeliveryTimeout {
+  constructor(objectTimeout) {
+    this.objectTimeout = objectTimeout;
+  }
+  static TYPE = 2 /* DeliveryTimeout */;
+  toKeyValuePair() {
+    return KeyValuePair.tryNewVarInt(_DeliveryTimeout.TYPE, this.objectTimeout);
+  }
+  static fromKeyValuePair(pair) {
+    if (Number(pair.typeValue) !== _DeliveryTimeout.TYPE || typeof pair.value !== "bigint") return void 0;
+    return new _DeliveryTimeout(pair.value);
+  }
+};
+
+// src/model/parameter/version/max_cache_duration.ts
+var MaxCacheDuration = class _MaxCacheDuration {
+  constructor(duration) {
+    this.duration = duration;
+  }
+  static TYPE = 4 /* MaxCacheDuration */;
+  toKeyValuePair() {
+    return KeyValuePair.tryNewVarInt(_MaxCacheDuration.TYPE, this.duration);
+  }
+  static fromKeyValuePair(pair) {
+    if (Number(pair.typeValue) !== _MaxCacheDuration.TYPE || typeof pair.value !== "bigint") return void 0;
+    return new _MaxCacheDuration(pair.value);
+  }
+};
+
+// src/model/parameter/version_parameter.ts
+exports.VersionSpecificParameter = void 0;
+((VersionSpecificParameter2) => {
+  function fromKeyValuePair(pair) {
+    return MaxCacheDuration.fromKeyValuePair(pair) || DeliveryTimeout.fromKeyValuePair(pair) || AuthorizationToken.fromKeyValuePair(pair);
+  }
+  VersionSpecificParameter2.fromKeyValuePair = fromKeyValuePair;
+  function toKeyValuePair(param) {
+    return param.toKeyValuePair();
+  }
+  VersionSpecificParameter2.toKeyValuePair = toKeyValuePair;
+  function isMaxCacheDuration(param) {
+    return param instanceof MaxCacheDuration;
+  }
+  VersionSpecificParameter2.isMaxCacheDuration = isMaxCacheDuration;
+  function isDeliveryTimeout(param) {
+    return param instanceof DeliveryTimeout;
+  }
+  VersionSpecificParameter2.isDeliveryTimeout = isDeliveryTimeout;
+  function isAuthorizationToken(param) {
+    return param instanceof AuthorizationToken;
+  }
+  VersionSpecificParameter2.isAuthorizationToken = isAuthorizationToken;
+})(exports.VersionSpecificParameter || (exports.VersionSpecificParameter = {}));
+var VersionSpecificParameters = class {
+  kvps = [];
+  addMaxCacheDuration(duration) {
+    this.kvps.push(new MaxCacheDuration(BigInt(duration)).toKeyValuePair());
+    return this;
+  }
+  addDeliveryTimeout(timeout) {
+    this.kvps.push(new DeliveryTimeout(BigInt(timeout)).toKeyValuePair());
+    return this;
+  }
+  addAuthorizationToken(auth) {
+    this.kvps.push(auth.toKeyValuePair());
+    return this;
+  }
+  addRaw(pair) {
+    this.kvps.push(pair);
+    return this;
+  }
+  build() {
+    return this.kvps;
+  }
+  static fromKeyValuePairs(kvps) {
+    const result = [];
+    for (const kvp of kvps) {
+      const parsed = MaxCacheDuration.fromKeyValuePair(kvp) || DeliveryTimeout.fromKeyValuePair(kvp) || AuthorizationToken.fromKeyValuePair(kvp);
+      if (parsed) result.push(parsed);
+    }
+    return result;
+  }
+};
+
+exports.AudioLevel = AudioLevel;
+exports.AuthorizationToken = AuthorizationToken;
+exports.BaseByteBuffer = BaseByteBuffer12;
+exports.ByteBuffer = ByteBuffer;
+exports.CaptureTimestamp = CaptureTimestamp;
+exports.CastingError = CastingError;
+exports.ClientSetup = ClientSetup;
+exports.CommonType = CommonType;
+exports.ControlMessageType = ControlMessageType;
+exports.DRAFT_14 = DRAFT_14;
+exports.DatagramObject = DatagramObject;
+exports.DatagramStatus = DatagramStatus;
+exports.DeliveryTimeout = DeliveryTimeout;
+exports.ExtensionHeaders = ExtensionHeaders;
+exports.Fetch = Fetch;
+exports.FetchCancel = FetchCancel;
+exports.FetchError = FetchError;
+exports.FetchErrorCode = FetchErrorCode;
+exports.FetchHeader = FetchHeader;
+exports.FetchObject = FetchObject;
+exports.FetchOk = FetchOk;
+exports.FetchType = FetchType;
+exports.FilterType = FilterType;
+exports.FrozenByteBuffer = FrozenByteBuffer5;
+exports.FullTrackName = FullTrackName;
+exports.GoAway = GoAway;
+exports.GroupOrder = GroupOrder;
+exports.InternalError = InternalError;
+exports.InvalidTypeError = InvalidTypeError;
+exports.InvalidUTF8Error = InvalidUTF8Error;
+exports.KeyValueFormattingError = KeyValueFormattingError;
+exports.KeyValuePair = KeyValuePair;
+exports.LOCHeaderExtensionId = LOCHeaderExtensionId;
+exports.LengthExceedsMaxError = LengthExceedsMaxError;
+exports.Location = Location;
+exports.MAX_FULL_TRACK_NAME_LENGTH = MAX_FULL_TRACK_NAME_LENGTH;
+exports.MAX_NAMESPACE_TUPLE_COUNT = MAX_NAMESPACE_TUPLE_COUNT;
+exports.MAX_REASON_PHRASE_LEN = MAX_REASON_PHRASE_LEN;
+exports.MOQtailError = MOQtailError;
+exports.MaxAuthTokenCacheSize = MaxAuthTokenCacheSize;
+exports.MaxCacheDuration = MaxCacheDuration;
+exports.MaxRequestId = MaxRequestId;
+exports.MaxRequestIdParameter = MaxRequestId2;
+exports.MoqtObject = MoqtObject;
+exports.NotEnoughBytesError = NotEnoughBytesError;
+exports.Path = Path;
+exports.ProtocolViolationError = ProtocolViolationError;
+exports.Publish = Publish;
+exports.PublishDone = PublishDone;
+exports.PublishDoneStatusCode = PublishDoneStatusCode;
+exports.PublishError = PublishError;
+exports.PublishErrorCode = PublishErrorCode;
+exports.PublishNamespace = PublishNamespace;
+exports.PublishNamespaceCancel = PublishNamespaceCancel;
+exports.PublishNamespaceDone = PublishNamespaceDone;
+exports.PublishNamespaceError = PublishNamespaceError;
+exports.PublishNamespaceErrorCode = PublishNamespaceErrorCode;
+exports.PublishNamespaceOk = PublishNamespaceOk;
+exports.PublishOk = PublishOk;
+exports.ReasonPhrase = ReasonPhrase;
+exports.RequestIdError = RequestIdError;
+exports.RequestIdMap = RequestIdMap;
+exports.RequestsBlocked = RequestsBlocked;
+exports.ServerSetup = ServerSetup;
+exports.SetupParameterType = SetupParameterType;
+exports.SetupParameters = SetupParameters;
+exports.SubgroupHeader = SubgroupHeader;
+exports.SubgroupObject = SubgroupObject;
+exports.Subscribe = Subscribe;
+exports.SubscribeError = SubscribeError;
+exports.SubscribeErrorCode = SubscribeErrorCode;
+exports.SubscribeNamespace = SubscribeNamespace;
+exports.SubscribeNamespaceError = SubscribeNamespaceError;
+exports.SubscribeNamespaceErrorCode = SubscribeNamespaceErrorCode;
+exports.SubscribeNamespaceOk = SubscribeNamespaceOk;
+exports.SubscribeOk = SubscribeOk;
+exports.SubscribeUpdate = SubscribeUpdate;
+exports.Switch = Switch;
+exports.TerminationError = TerminationError;
+exports.TimeoutError = TimeoutError;
+exports.TokenAliasType = TokenAliasType;
+exports.TrackNameError = TrackNameError;
+exports.TrackStatus = TrackStatus;
+exports.TrackStatusCode = TrackStatusCode;
+exports.TrackStatusError = TrackStatusError;
+exports.TrackStatusOk = TrackStatusOk;
+exports.Tuple = Tuple;
+exports.TupleField = TupleField;
+exports.Unsubscribe = Unsubscribe;
+exports.UnsubscribeNamespace = UnsubscribeNamespace;
+exports.VarIntOverflowError = VarIntOverflowError;
+exports.VersionSpecificParameterType = VersionSpecificParameterType;
+exports.VersionSpecificParameters = VersionSpecificParameters;
+exports.VideoConfig = VideoConfig;
+exports.VideoFrameMarking = VideoFrameMarking;
+exports.commonTypeFromNumber = commonTypeFromNumber;
+exports.controlMessageTypeFromBigInt = controlMessageTypeFromBigInt;
+exports.fetchErrorCodeFromBigInt = fetchErrorCodeFromBigInt;
+exports.fetchTypeFromBigInt = fetchTypeFromBigInt;
+exports.filterTypeFromBigInt = filterTypeFromBigInt;
+exports.groupOrderFromNumber = groupOrderFromNumber;
+exports.isBytes = isBytes;
+exports.isVarInt = isVarInt;
+exports.locHeaderExtensionIdFromNumber = locHeaderExtensionIdFromNumber;
+exports.publishDoneStatusCodeFromBigInt = publishDoneStatusCodeFromBigInt;
+exports.publishErrorCodeFromBigInt = publishErrorCodeFromBigInt;
+exports.publishNamespaceErrorCodeFromBigInt = publishNamespaceErrorCodeFromBigInt;
+exports.setupParameterTypeFromNumber = setupParameterTypeFromNumber;
+exports.subscribeErrorCodeFromBigInt = subscribeErrorCodeFromBigInt;
+exports.subscribeNamespaceErrorCodeFromBigInt = subscribeNamespaceErrorCodeFromBigInt;
+exports.tokenAliasTypeFromNumber = tokenAliasTypeFromNumber;
+exports.trackStatusCodeFromBigInt = trackStatusCodeFromBigInt;
+exports.versionSpecificParameterTypeFromNumber = versionSpecificParameterTypeFromNumber;