moqtail 0.7.0

package/dist/util/index.js

@@ -0,0 +1,1789 @@
+import Heap from 'heap-js';
+
+// src/util/telemetry.ts
+var NetworkTelemetry = class {
+  events = [];
+  windowMs;
+  constructor(windowMs = 1e3) {
+    this.windowMs = windowMs;
+  }
+  push({ latency, size }) {
+    const now = Date.now();
+    this.events.push({ timestamp: now, latency, size });
+  }
+  clean() {
+    const cutoff = Date.now() - this.windowMs;
+    while (this.events.length && this.events[0] && this.events[0].timestamp < cutoff) {
+      this.events.shift();
+    }
+  }
+  get throughput() {
+    this.clean();
+    const totalBytes = this.events.reduce((sum, e) => sum + e.size, 0);
+    return totalBytes / (this.windowMs / 1e3);
+  }
+  get latency() {
+    this.clean();
+    if (!this.events.length) return 0;
+    return this.events.reduce((sum, e) => sum + e.latency, 0) / this.events.length;
+  }
+};
+
+// 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;
+  }
+};
+
+// src/model/error/constant.ts
+var 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;
+})(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;
+})(TerminationCode || (TerminationCode = {}));
+
+// 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
+var ObjectDatagramStatusType = /* @__PURE__ */ ((ObjectDatagramStatusType2) => {
+  ObjectDatagramStatusType2[ObjectDatagramStatusType2["WithoutExtensions"] = 2] = "WithoutExtensions";
+  ObjectDatagramStatusType2[ObjectDatagramStatusType2["WithExtensions"] = 3] = "WithExtensions";
+  return ObjectDatagramStatusType2;
+})(ObjectDatagramStatusType || {});
+((ObjectDatagramStatusType2) => {
+  function tryFrom(value) {
+    const v = typeof value === "bigint" ? Number(value) : value;
+    switch (v) {
+      case 2:
+        return 2 /* WithoutExtensions */;
+      case 3:
+        return 3 /* WithExtensions */;
+      default:
+        throw new Error(`Invalid ObjectDatagramStatusType: ${value}`);
+    }
+  }
+  ObjectDatagramStatusType2.tryFrom = tryFrom;
+})(ObjectDatagramStatusType || (ObjectDatagramStatusType = {}));
+var ObjectDatagramType = /* @__PURE__ */ ((ObjectDatagramType2) => {
+  ObjectDatagramType2[ObjectDatagramType2["WithoutExtensions"] = 0] = "WithoutExtensions";
+  ObjectDatagramType2[ObjectDatagramType2["WithExtensions"] = 1] = "WithExtensions";
+  return ObjectDatagramType2;
+})(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;
+})(ObjectDatagramType || (ObjectDatagramType = {}));
+var FetchHeaderType = /* @__PURE__ */ ((FetchHeaderType2) => {
+  FetchHeaderType2[FetchHeaderType2["Type0x05"] = 5] = "Type0x05";
+  return FetchHeaderType2;
+})(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;
+})(FetchHeaderType || (FetchHeaderType = {}));
+var 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;
+})(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;
+})(SubgroupHeaderType || (SubgroupHeaderType = {}));
+var ObjectForwardingPreference = /* @__PURE__ */ ((ObjectForwardingPreference2) => {
+  ObjectForwardingPreference2["Subgroup"] = "Subgroup";
+  ObjectForwardingPreference2["Datagram"] = "Datagram";
+  return ObjectForwardingPreference2;
+})(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;
+})(ObjectForwardingPreference || (ObjectForwardingPreference = {}));
+var 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;
+})(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;
+})(ObjectStatus || (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 = FetchHeaderType.tryFrom(typeRaw);
+    const requestId = buf.getVI();
+    return new _FetchHeader(type, requestId);
+  }
+};
+
+// 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/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 (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 = SubgroupHeaderType.tryFrom(buf.getNumberVI());
+    const trackAlias = buf.getVI();
+    const groupId = buf.getVI();
+    let subgroupId;
+    if (SubgroupHeaderType.hasExplicitSubgroupId(headerType)) {
+      subgroupId = buf.getVI();
+    } else if (SubgroupHeaderType.isSubgroupIdZero(headerType)) {
+      subgroupId = 0n;
+    }
+    const publisherPriority = buf.getU8();
+    return new _SubgroupHeader(headerType, trackAlias, groupId, subgroupId, publisherPriority);
+  }
+};
+
+// src/model/data/header.ts
+var Header;
+((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;
+})(Header || (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 BaseByteBuffer11 = 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 KeyValuePair5.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 BaseByteBuffer11 {
+  _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 FrozenByteBuffer4(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 FrozenByteBuffer4 = class extends BaseByteBuffer11 {
+  constructor(buf) {
+    super(buf);
+  }
+  get length() {
+    return this.buf.length;
+  }
+};
+
+// src/model/common/pair.ts
+var MAX_VALUE_LENGTH = 2 ** 16 - 1;
+var KeyValuePair5 = 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/extension_header/capture_time_stamp.ts
+var CaptureTimestamp = class _CaptureTimestamp {
+  constructor(timestamp) {
+    this.timestamp = timestamp;
+  }
+  static TYPE = 2 /* CaptureTimestamp */;
+  toKeyValuePair() {
+    return KeyValuePair5.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 KeyValuePair5.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 KeyValuePair5.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 KeyValuePair5.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
+var ExtensionHeader;
+((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;
+})(ExtensionHeader || (ExtensionHeader = {}));
+var ExtensionHeaders2 = 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 = ExtensionHeader.fromKeyValuePair(kvp);
+      if (parsed) result.push(parsed);
+    }
+    return result;
+  }
+};
+
+// src/util/playout_buffer.ts
+var DEFAULT_TARGET_LATENCY_MS = 100;
+var DEFAULT_MAX_LATENCY_MS = 1e3;
+var PlayoutBuffer = class {
+  constructor(objectStream, options) {
+    this.options = options;
+    this.#targetLatencyMs = this.options?.targetLatencyMs ?? DEFAULT_TARGET_LATENCY_MS;
+    this.#maxLatencyMs = this.options?.maxLatencyMs ?? DEFAULT_MAX_LATENCY_MS;
+    this.#clock = this.options?.clock;
+    this.#reader = objectStream.getReader();
+    this.#fillBuffer();
+    this.#serveBuffer();
+  }
+  #reader;
+  #buffer = new Heap((a, b) => {
+    return a.object.location.compare(b.object.location);
+  });
+  #isRunning = true;
+  #targetLatencyMs;
+  #moqObjectCountInBuffer = 0;
+  #moqObjectCountExitingBuffer = 0;
+  #maxLatencyMs;
+  #clock;
+  onObject = null;
+  async hasObjectReady() {
+    const now = this.#getNormalizedTime();
+    const oldest = this.#buffer.peek();
+    return oldest ? now - oldest.createdAt >= this.#targetLatencyMs : false;
+  }
+  getStatus() {
+    const oldest = this.#buffer.peek();
+    const result = {
+      bufferSize: this.#buffer.length,
+      isRunning: this.#isRunning
+    };
+    if (oldest) {
+      result.oldestTimestamp = oldest.createdAt;
+    }
+    return result;
+  }
+  cleanup() {
+    this.#isRunning = false;
+    this.onObject?.(null);
+  }
+  #getNormalizedTime() {
+    if (this.#clock) {
+      return this.#clock.now();
+    }
+    return Date.now();
+  }
+  async #serveBuffer() {
+    while (this.#isRunning) {
+      const now = this.#getNormalizedTime();
+      const oldest = this.#buffer.peek();
+      if (oldest && this.onObject) {
+        const timeUntilReady = this.#targetLatencyMs - (now - oldest.createdAt);
+        if (timeUntilReady <= 0) {
+          const bufferedObj = this.#buffer.pop();
+          this.#moqObjectCountExitingBuffer++;
+          if (this.#moqObjectCountExitingBuffer % 50 === 0) ;
+          this.onObject(bufferedObj.object);
+          if (this.#moqObjectCountExitingBuffer % 50 === 0) ;
+        } else {
+          const sleepTime = Math.min(timeUntilReady, 50);
+          await new Promise((resolve) => setTimeout(resolve, sleepTime));
+        }
+      } else {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      }
+    }
+  }
+  async #fillBuffer() {
+    while (this.#isRunning) {
+      try {
+        const { value, done } = await this.#reader.read();
+        if (done) {
+          this.cleanup();
+          return;
+        }
+        this.#evictOnMaxLatency();
+        const bufferedObject = {
+          object: value,
+          createdAt: this.#extractCreatedAt(value)
+        };
+        this.#moqObjectCountInBuffer++;
+        if (this.#moqObjectCountInBuffer % 50 === 0) {
+        }
+        this.#buffer.push(bufferedObject);
+      } catch (error) {
+        this.cleanup();
+      }
+    }
+  }
+  #extractCreatedAt(object) {
+    if (object.extensionHeaders) {
+      const extensionHeaders = ExtensionHeaders2.fromKeyValuePairs(object.extensionHeaders);
+      for (const header of extensionHeaders) {
+        if (ExtensionHeader.isCaptureTimestamp(header)) {
+          return Number(header.timestamp);
+        }
+      }
+    }
+    return this.#getNormalizedTime();
+  }
+  #evictOnMaxLatency() {
+    const now = this.#getNormalizedTime();
+    const oldest = this.#buffer.peek();
+    if (oldest && now - oldest.createdAt > this.#maxLatencyMs) {
+      if (oldest.object.location.object === 0n) {
+        const groupToDrop = oldest.object.location.group;
+        this.#dropGop(groupToDrop);
+      } else {
+        this.#buffer.pop();
+      }
+      this.#evictOnMaxLatency();
+    }
+  }
+  #dropGop(groupId) {
+    while (this.#buffer.length > 0) {
+      const oldest = this.#buffer.peek();
+      if (oldest && oldest.object.location.group === groupId) {
+        this.#buffer.pop();
+      } else {
+        break;
+      }
+    }
+  }
+};
+var DEFAULT_BUFFER_CAPACITY = 50;
+var DEFAULT_TARGET_LATENCY_MS2 = 500;
+var DEFAULT_MAX_LATENCY_MS2 = 2e3;
+var PullPlayoutBuffer = class {
+  constructor(writeStream, options) {
+    this.options = options;
+    this.#bucketCapacity = this.options.bucketCapacity ?? DEFAULT_BUFFER_CAPACITY;
+    this.#targetLatencyMs = this.options.targetLatencyMs ?? DEFAULT_TARGET_LATENCY_MS2;
+    this.#maxLatencyMs = this.options.maxLatencyMs ?? DEFAULT_MAX_LATENCY_MS2;
+    this.#reader = writeStream.getReader();
+    this.#fillBuffer();
+  }
+  #reader;
+  #buffer = new Heap((a, b) => {
+    if (a.location.compare(b.location) <= 0) {
+      if (b.location.compare(a.location) <= 0) {
+        return 0;
+      }
+      return -1;
+    }
+    return 1;
+  });
+  #isRunning = true;
+  #bucketCapacity;
+  #targetLatencyMs;
+  #maxLatencyMs;
+  #lastIncomingTimestamp = 0;
+  #pendingCallback = null;
+  // Pull-based API: Consumer calls this when ready for next object
+  nextObject(callback) {
+    if (this.#buffer.length > 0) {
+      const obj = this.#buffer.pop();
+      callback(obj || null);
+      return;
+    }
+    this.#pendingCallback = callback;
+  }
+  // Check if there's an object ready immediately (non-blocking)
+  hasObjectReady() {
+    return this.#buffer.length > 0;
+  }
+  // Get current buffer status for debugging
+  getStatus() {
+    return {
+      bufferSize: this.#buffer.length,
+      isRunning: this.#isRunning
+    };
+  }
+  // Cleanup method - called when buffer is destroyed
+  cleanup() {
+    this.#isRunning = false;
+  }
+  // Simple background filling - just fills the buffer as objects arrive
+  async #fillBuffer() {
+    while (this.#isRunning) {
+      try {
+        const { value, done } = await this.#reader.read();
+        if (done) {
+          this.#isRunning = false;
+          if (this.#pendingCallback) {
+            const callback = this.#pendingCallback;
+            this.#pendingCallback = null;
+            callback(null);
+          }
+          return;
+        }
+        this.#lastIncomingTimestamp = performance.now();
+        if (this.#buffer.length >= this.#bucketCapacity) {
+          this.#manageBufferOverflow();
+        }
+        this.#buffer.push(value);
+        if (this.#pendingCallback) {
+          const callback = this.#pendingCallback;
+          this.#pendingCallback = null;
+          const obj = this.#buffer.pop();
+          callback(obj || null);
+        }
+      } catch (error) {
+        console.error("Error in fillBuffer:", error);
+        this.#isRunning = false;
+        if (this.#pendingCallback) {
+          const callback = this.#pendingCallback;
+          this.#pendingCallback = null;
+          callback(null);
+        }
+      }
+    }
+  }
+  // Manage buffer overflow by dropping oldest GOPs
+  #manageBufferOverflow() {
+    const droppedGops = this.#dropMultipleGopsToTarget();
+    if (droppedGops === 0) {
+      const dropCount = Math.floor(this.#bucketCapacity * 0.2);
+      for (let i = 0; i < dropCount; i++) {
+        this.#buffer.pop();
+      }
+      console.log(`\u{1F5D1}\uFE0F [PULL BUFFER] Buffer overflow: dropped ${dropCount} oldest objects (fallback)`);
+    }
+  }
+  // Find GOP boundaries based on group IDs
+  #findGopBoundaries(objects) {
+    const gops = [];
+    if (objects.length === 0) return gops;
+    const groupMap = /* @__PURE__ */ new Map();
+    objects.forEach((obj, index) => {
+      const groupId = obj.location.group;
+      if (!groupMap.has(groupId)) {
+        groupMap.set(groupId, []);
+      }
+      groupMap.get(groupId).push(index);
+    });
+    const sortedGroups = Array.from(groupMap.entries()).sort(([a], [b]) => {
+      if (a < b) return -1;
+      if (a > b) return 1;
+      return 0;
+    });
+    sortedGroups.forEach(([, indices]) => {
+      if (indices.length > 0) {
+        gops.push({
+          start: Math.min(...indices),
+          end: Math.max(...indices)
+        });
+      }
+    });
+    console.log(`\u{1F3AC} [PULL BUFFER] Found ${gops.length} GOPs (groups) in buffer`);
+    return gops;
+  }
+  // Drop oldest GOP (complete group)
+  #dropOldestGop() {
+    const allObjects = this.#buffer.toArray();
+    const gops = this.#findGopBoundaries(allObjects);
+    if (gops.length > 0) {
+      const oldestGop = gops[0];
+      if (oldestGop) {
+        const firstObj = allObjects[oldestGop.start];
+        const groupId = firstObj?.location.group;
+        for (let i = oldestGop.start; i <= oldestGop.end; i++) {
+          this.#buffer.pop();
+        }
+        console.log(`\u{1F5D1}\uFE0F [PULL BUFFER] Dropped GOP (Group ${groupId}): ${oldestGop.end - oldestGop.start + 1} objects`);
+        return true;
+      }
+    }
+    return false;
+  }
+  // Drop multiple GOPs to reach target buffer size
+  #dropMultipleGopsToTarget() {
+    const targetBufferSize = Math.floor(this.#bucketCapacity * 0.7);
+    let droppedGops = 0;
+    while (this.#buffer.length > targetBufferSize && droppedGops < 3) {
+      if (this.#dropOldestGop()) {
+        droppedGops++;
+      } else {
+        break;
+      }
+    }
+    if (droppedGops > 0) {
+      console.log(
+        `\u{1F5D1}\uFE0F [PULL BUFFER] Dropped ${droppedGops} GOPs to reduce buffer size. New buffer size: ${this.#buffer.length}`
+      );
+    }
+    return droppedGops;
+  }
+};
+
+// src/util/clock_normalizer.ts
+var DEFAULT_SAMPLE_SIZE = 5;
+var DEFAULT_TIME_SERVER = "https://time.akamai.com/?ms";
+var ClockNormalizer = class _ClockNormalizer {
+  offset;
+  timeServerUrl;
+  numSamples;
+  constructor(timeServerUrl, offset, numSamples) {
+    this.timeServerUrl = timeServerUrl;
+    this.offset = offset;
+    this.numSamples = numSamples;
+  }
+  static async create(timeServerUrl, numberOfSamples) {
+    const url = timeServerUrl ? timeServerUrl : DEFAULT_TIME_SERVER;
+    const numSamples = numberOfSamples ? numberOfSamples : DEFAULT_SAMPLE_SIZE;
+    const offset = await _ClockNormalizer.calculateSkew(url, numSamples);
+    return new _ClockNormalizer(url, offset, numSamples);
+  }
+  getSkew() {
+    return this.offset;
+  }
+  now() {
+    return Date.now() - this.offset;
+  }
+  async recalibrate() {
+    this.offset = await _ClockNormalizer.calculateSkew(this.timeServerUrl, this.numSamples);
+    return this.offset;
+  }
+  static async calculateSkew(timeServerUrl, numSamples) {
+    const samples = [];
+    for (let i = 0; i < numSamples; i++) {
+      const sample = await _ClockNormalizer.takeSingleSample(timeServerUrl);
+      if (sample !== null) {
+        samples.push(sample);
+      }
+      if (i < numSamples - 1) {
+        await new Promise((resolve) => setTimeout(resolve, 20));
+      }
+    }
+    if (samples.length === 0) {
+      throw new Error("Failed to get any valid samples");
+    }
+    const offsets = samples.map((s) => s.offset);
+    const average = offsets.reduce((sum, offset) => sum + offset, 0) / offsets.length;
+    return Math.round(average);
+  }
+  static async takeSingleSample(timeServerUrl) {
+    const separator = timeServerUrl.includes("?") ? "&" : "?";
+    const url = `${timeServerUrl}${separator}_=${Date.now()}`;
+    const t0 = performance.now();
+    const localTimeBeforeRequest = Date.now();
+    const response = await fetch(url, { cache: "no-store" });
+    const serverTimeText = await response.text();
+    const t1 = performance.now();
+    const localTimeAfterRequest = Date.now();
+    const serverTime = parseFloat(serverTimeText);
+    if (isNaN(serverTime)) {
+      return null;
+    }
+    const serverTimeMs = serverTime * 1e3;
+    const rtt = t1 - t0;
+    const oneWayDelay = rtt / 2;
+    const avgLocalTime = (localTimeBeforeRequest + localTimeAfterRequest) / 2;
+    const localTimeAtServer = avgLocalTime - oneWayDelay;
+    const offset = localTimeAtServer - serverTimeMs;
+    return { offset, rtt };
+  }
+};
+
+// src/util/get_akamai_offset.ts
+var AkamaiOffset = class _AkamaiOffset {
+  static _offset = null;
+  static _promise = null;
+  static async getClockSkew() {
+    if (_AkamaiOffset._offset !== null) {
+      return _AkamaiOffset._offset;
+    }
+    if (_AkamaiOffset._promise) {
+      return _AkamaiOffset._promise;
+    }
+    _AkamaiOffset._promise = _AkamaiOffset.ClockSkew().then((offset2) => {
+      _AkamaiOffset._offset = offset2;
+      return offset2;
+    });
+    const offset = await _AkamaiOffset._promise;
+    return Math.round(offset);
+  }
+  static async ClockSkew() {
+    const akamaiUrl = "https://time.akamai.com?ms";
+    performance.clearResourceTimings();
+    const response = await fetch(akamaiUrl);
+    const text = await response.text();
+    const TR = parseFloat(text.trim()) * 1e3;
+    const entry = performance.getEntriesByType("resource").find((e) => e.name.includes("time.akamai.com"));
+    if (!entry) {
+      console.warn("No resource entry found for Akamai time request");
+      return 0;
+    }
+    const T0 = entry.fetchStart + performance.timeOrigin;
+    const T1 = entry.responseStart + performance.timeOrigin;
+    const offset = (T0 + T1) / 2 - TR;
+    return offset;
+  }
+};
+
+export { AkamaiOffset, ClockNormalizer, NetworkTelemetry, PlayoutBuffer, PullPlayoutBuffer };