@moqtap/codec 0.1.0

package/dist/chunk-23YG7F46.js

@@ -0,0 +1,764 @@
+import {
+  BufferReader,
+  BufferWriter,
+  DecodeError
+} from "./chunk-YBSEOSSP.js";
+
+// src/drafts/draft07/messages.ts
+var MESSAGE_TYPE_IDS = {
+  // Control messages (on control stream)
+  subscribe_update: 0x02n,
+  subscribe: 0x03n,
+  subscribe_ok: 0x04n,
+  subscribe_error: 0x05n,
+  announce: 0x06n,
+  announce_ok: 0x07n,
+  announce_error: 0x08n,
+  unannounce: 0x09n,
+  unsubscribe: 0x0an,
+  subscribe_done: 0x0bn,
+  announce_cancel: 0x0cn,
+  track_status_request: 0x0dn,
+  track_status: 0x0en,
+  goaway: 0x10n,
+  subscribe_announces: 0x11n,
+  subscribe_announces_ok: 0x12n,
+  subscribe_announces_error: 0x13n,
+  unsubscribe_announces: 0x14n,
+  max_subscribe_id: 0x15n,
+  fetch: 0x16n,
+  fetch_cancel: 0x17n,
+  fetch_ok: 0x18n,
+  fetch_error: 0x19n,
+  client_setup: 0x40n,
+  server_setup: 0x41n,
+  // Data stream messages
+  object_stream: 0x00n,
+  object_datagram: 0x01n,
+  stream_header_track: 0x50n,
+  stream_header_group: 0x51n,
+  stream_header_subgroup: 0x04n
+  // Note: same ID as subscribe_ok but used on data streams, context disambiguates
+};
+var MESSAGE_ID_TO_TYPE = /* @__PURE__ */ new Map();
+for (const [name, id] of Object.entries(MESSAGE_TYPE_IDS)) {
+  if (!MESSAGE_ID_TO_TYPE.has(id) || name !== "stream_header_subgroup") {
+    MESSAGE_ID_TO_TYPE.set(id, name);
+  }
+}
+
+// src/drafts/draft07/varint.ts
+function encodeVarInt(value) {
+  const writer = new BufferWriter(8);
+  writer.writeVarInt(value);
+  return writer.finish();
+}
+function decodeVarInt(bytes, offset = 0) {
+  try {
+    const reader = new BufferReader(bytes, offset);
+    const value = reader.readVarInt();
+    return { ok: true, value, bytesRead: reader.offset - offset };
+  } catch (e) {
+    if (e instanceof DecodeError) {
+      return { ok: false, error: e };
+    }
+    throw e;
+  }
+}
+
+// src/drafts/draft07/codec.ts
+var FILTER_TYPE_TO_WIRE = {
+  latest_group: 1n,
+  latest_object: 2n,
+  absolute_start: 3n,
+  absolute_range: 4n
+};
+var WIRE_TO_FILTER_TYPE = /* @__PURE__ */ new Map([
+  [1n, "latest_group"],
+  [2n, "latest_object"],
+  [3n, "absolute_start"],
+  [4n, "absolute_range"]
+]);
+var GROUP_ORDER_TO_WIRE = {
+  original: 0,
+  ascending: 1,
+  descending: 2
+};
+var WIRE_TO_GROUP_ORDER = /* @__PURE__ */ new Map([
+  [0, "original"],
+  [1, "ascending"],
+  [2, "descending"]
+]);
+function writeGroupOrder(writer, value) {
+  const wire = GROUP_ORDER_TO_WIRE[value];
+  writer.writeUint8(wire);
+}
+function readGroupOrder(reader) {
+  const wire = reader.readUint8();
+  const value = WIRE_TO_GROUP_ORDER.get(wire);
+  if (value === void 0) {
+    throw new DecodeError("CONSTRAINT_VIOLATION", `Invalid group order value: ${wire}`, reader.offset - 1);
+  }
+  return value;
+}
+var DATA_STREAM_TYPE_IDS = /* @__PURE__ */ new Set([
+  MESSAGE_TYPE_IDS.object_stream,
+  MESSAGE_TYPE_IDS.object_datagram,
+  MESSAGE_TYPE_IDS.stream_header_track,
+  MESSAGE_TYPE_IDS.stream_header_group
+]);
+function encodeClientSetup(msg, writer) {
+  writer.writeVarInt(msg.supportedVersions.length);
+  for (const version of msg.supportedVersions) {
+    writer.writeVarInt(version);
+  }
+  writer.writeParameters(msg.parameters);
+}
+function encodeServerSetup(msg, writer) {
+  writer.writeVarInt(msg.selectedVersion);
+  writer.writeParameters(msg.parameters);
+}
+function encodeSubscribe(msg, writer) {
+  writer.writeVarInt(msg.subscribeId);
+  writer.writeVarInt(msg.trackAlias);
+  writer.writeTuple(msg.trackNamespace);
+  writer.writeString(msg.trackName);
+  writer.writeUint8(msg.subscriberPriority);
+  writeGroupOrder(writer, msg.groupOrder);
+  writer.writeVarInt(FILTER_TYPE_TO_WIRE[msg.filterType]);
+  if (msg.filterType === "absolute_start" || msg.filterType === "absolute_range") {
+    writer.writeVarInt(msg.startGroup);
+    writer.writeVarInt(msg.startObject);
+  }
+  if (msg.filterType === "absolute_range") {
+    writer.writeVarInt(msg.endGroup);
+    writer.writeVarInt(msg.endObject);
+  }
+  writer.writeParameters(msg.parameters);
+}
+function encodeSubscribeOk(msg, writer) {
+  writer.writeVarInt(msg.subscribeId);
+  writer.writeVarInt(msg.expires);
+  writeGroupOrder(writer, msg.groupOrder);
+  writer.writeUint8(msg.contentExists ? 1 : 0);
+  if (msg.contentExists) {
+    writer.writeVarInt(msg.largestGroupId);
+    writer.writeVarInt(msg.largestObjectId);
+  }
+  writer.writeParameters(msg.parameters);
+}
+function encodeSubscribeError(msg, writer) {
+  writer.writeVarInt(msg.subscribeId);
+  writer.writeVarInt(msg.errorCode);
+  writer.writeString(msg.reasonPhrase);
+  writer.writeVarInt(msg.trackAlias);
+}
+function encodeSubscribeDone(msg, writer) {
+  writer.writeVarInt(msg.subscribeId);
+  writer.writeVarInt(msg.statusCode);
+  writer.writeString(msg.reasonPhrase);
+  writer.writeUint8(msg.contentExists ? 1 : 0);
+  if (msg.contentExists) {
+    writer.writeVarInt(msg.finalGroupId);
+    writer.writeVarInt(msg.finalObjectId);
+  }
+}
+function encodeSubscribeUpdate(msg, writer) {
+  writer.writeVarInt(msg.subscribeId);
+  writer.writeVarInt(msg.startGroup);
+  writer.writeVarInt(msg.startObject);
+  writer.writeVarInt(msg.endGroup);
+  writer.writeVarInt(msg.endObject);
+  writer.writeUint8(msg.subscriberPriority);
+  writer.writeParameters(msg.parameters);
+}
+function encodeUnsubscribe(msg, writer) {
+  writer.writeVarInt(msg.subscribeId);
+}
+function encodeAnnounce(msg, writer) {
+  writer.writeTuple(msg.trackNamespace);
+  writer.writeParameters(msg.parameters);
+}
+function encodeAnnounceOk(msg, writer) {
+  writer.writeTuple(msg.trackNamespace);
+}
+function encodeAnnounceError(msg, writer) {
+  writer.writeTuple(msg.trackNamespace);
+  writer.writeVarInt(msg.errorCode);
+  writer.writeString(msg.reasonPhrase);
+}
+function encodeAnnounceCancel(msg, writer) {
+  writer.writeTuple(msg.trackNamespace);
+  writer.writeVarInt(msg.errorCode);
+  writer.writeString(msg.reasonPhrase);
+}
+function encodeUnannounce(msg, writer) {
+  writer.writeTuple(msg.trackNamespace);
+}
+function encodeTrackStatusRequest(msg, writer) {
+  writer.writeTuple(msg.trackNamespace);
+  writer.writeString(msg.trackName);
+}
+function encodeTrackStatus(msg, writer) {
+  writer.writeTuple(msg.trackNamespace);
+  writer.writeString(msg.trackName);
+  writer.writeVarInt(msg.statusCode);
+  writer.writeVarInt(msg.lastGroupId);
+  writer.writeVarInt(msg.lastObjectId);
+}
+function encodeGoAway(msg, writer) {
+  writer.writeString(msg.newSessionUri);
+}
+function encodeSubscribeAnnounces(msg, writer) {
+  writer.writeTuple(msg.trackNamespace);
+  writer.writeParameters(msg.parameters);
+}
+function encodeSubscribeAnnouncesOk(msg, writer) {
+  writer.writeTuple(msg.trackNamespace);
+}
+function encodeSubscribeAnnouncesError(msg, writer) {
+  writer.writeTuple(msg.trackNamespace);
+  writer.writeVarInt(msg.errorCode);
+  writer.writeString(msg.reasonPhrase);
+}
+function encodeUnsubscribeAnnounces(msg, writer) {
+  writer.writeTuple(msg.trackNamespace);
+}
+function encodeMaxSubscribeId(msg, writer) {
+  writer.writeVarInt(msg.subscribeId);
+}
+function encodeFetch(msg, writer) {
+  writer.writeVarInt(msg.subscribeId);
+  writer.writeTuple(msg.trackNamespace);
+  writer.writeString(msg.trackName);
+  writer.writeUint8(msg.subscriberPriority);
+  writeGroupOrder(writer, msg.groupOrder);
+  writer.writeVarInt(msg.startGroup);
+  writer.writeVarInt(msg.startObject);
+  writer.writeVarInt(msg.endGroup);
+  writer.writeVarInt(msg.endObject);
+  writer.writeParameters(msg.parameters);
+}
+function encodeFetchOk(msg, writer) {
+  writer.writeVarInt(msg.subscribeId);
+  writeGroupOrder(writer, msg.groupOrder);
+  writer.writeUint8(msg.endOfTrack ? 1 : 0);
+  writer.writeVarInt(msg.largestGroupId);
+  writer.writeVarInt(msg.largestObjectId);
+  writer.writeParameters(msg.parameters);
+}
+function encodeFetchError(msg, writer) {
+  writer.writeVarInt(msg.subscribeId);
+  writer.writeVarInt(msg.errorCode);
+  writer.writeString(msg.reasonPhrase);
+}
+function encodeFetchCancel(msg, writer) {
+  writer.writeVarInt(msg.subscribeId);
+}
+function encodeObjectStream(msg, writer) {
+  writer.writeVarInt(MESSAGE_TYPE_IDS.object_stream);
+  writer.writeVarInt(msg.subscribeId);
+  writer.writeVarInt(msg.trackAlias);
+  writer.writeVarInt(msg.groupId);
+  writer.writeVarInt(msg.objectId);
+  writer.writeUint8(msg.publisherPriority);
+  if (msg.objectStatus !== void 0) {
+    writer.writeVarInt(msg.objectStatus);
+  } else {
+    writer.writeVarInt(0);
+  }
+  writer.writeBytes(msg.payload);
+}
+function encodeObjectDatagram(msg, writer) {
+  writer.writeVarInt(MESSAGE_TYPE_IDS.object_datagram);
+  writer.writeVarInt(msg.subscribeId);
+  writer.writeVarInt(msg.trackAlias);
+  writer.writeVarInt(msg.groupId);
+  writer.writeVarInt(msg.objectId);
+  writer.writeUint8(msg.publisherPriority);
+  if (msg.objectStatus !== void 0) {
+    writer.writeVarInt(msg.objectStatus);
+  } else {
+    writer.writeVarInt(0);
+  }
+  writer.writeBytes(msg.payload);
+}
+function encodeStreamHeaderTrack(msg, writer) {
+  writer.writeVarInt(MESSAGE_TYPE_IDS.stream_header_track);
+  writer.writeVarInt(msg.subscribeId);
+  writer.writeVarInt(msg.trackAlias);
+  writer.writeUint8(msg.publisherPriority);
+}
+function encodeStreamHeaderGroup(msg, writer) {
+  writer.writeVarInt(MESSAGE_TYPE_IDS.stream_header_group);
+  writer.writeVarInt(msg.subscribeId);
+  writer.writeVarInt(msg.trackAlias);
+  writer.writeVarInt(msg.groupId);
+  writer.writeUint8(msg.publisherPriority);
+}
+function encodeStreamHeaderSubgroup(msg, writer) {
+  writer.writeVarInt(MESSAGE_TYPE_IDS.stream_header_subgroup);
+  writer.writeVarInt(msg.subscribeId);
+  writer.writeVarInt(msg.trackAlias);
+  writer.writeVarInt(msg.groupId);
+  writer.writeVarInt(msg.subgroupId);
+  writer.writeUint8(msg.publisherPriority);
+}
+var controlEncoders = {
+  client_setup: encodeClientSetup,
+  server_setup: encodeServerSetup,
+  subscribe: encodeSubscribe,
+  subscribe_ok: encodeSubscribeOk,
+  subscribe_error: encodeSubscribeError,
+  subscribe_done: encodeSubscribeDone,
+  subscribe_update: encodeSubscribeUpdate,
+  unsubscribe: encodeUnsubscribe,
+  announce: encodeAnnounce,
+  announce_ok: encodeAnnounceOk,
+  announce_error: encodeAnnounceError,
+  announce_cancel: encodeAnnounceCancel,
+  unannounce: encodeUnannounce,
+  track_status_request: encodeTrackStatusRequest,
+  track_status: encodeTrackStatus,
+  goaway: encodeGoAway,
+  subscribe_announces: encodeSubscribeAnnounces,
+  subscribe_announces_ok: encodeSubscribeAnnouncesOk,
+  subscribe_announces_error: encodeSubscribeAnnouncesError,
+  unsubscribe_announces: encodeUnsubscribeAnnounces,
+  max_subscribe_id: encodeMaxSubscribeId,
+  fetch: encodeFetch,
+  fetch_ok: encodeFetchOk,
+  fetch_error: encodeFetchError,
+  fetch_cancel: encodeFetchCancel
+};
+var dataStreamEncoders = {
+  object_stream: encodeObjectStream,
+  object_datagram: encodeObjectDatagram,
+  stream_header_track: encodeStreamHeaderTrack,
+  stream_header_group: encodeStreamHeaderGroup,
+  stream_header_subgroup: encodeStreamHeaderSubgroup
+};
+function decodeClientSetup(reader) {
+  const numVersions = reader.readVarInt();
+  if (numVersions === 0n) {
+    throw new DecodeError("CONSTRAINT_VIOLATION", "supported_versions must not be empty", reader.offset);
+  }
+  const supportedVersions = [];
+  for (let i = 0n; i < numVersions; i++) {
+    supportedVersions.push(reader.readVarInt());
+  }
+  const parameters = reader.readParameters();
+  return { type: "client_setup", supportedVersions, parameters };
+}
+function decodeServerSetup(reader) {
+  const selectedVersion = reader.readVarInt();
+  const parameters = reader.readParameters();
+  return { type: "server_setup", selectedVersion, parameters };
+}
+function decodeSubscribe(reader) {
+  const subscribeId = reader.readVarInt();
+  const trackAlias = reader.readVarInt();
+  const trackNamespace = reader.readTuple();
+  const trackName = reader.readString();
+  const subscriberPriority = reader.readUint8();
+  const groupOrder = readGroupOrder(reader);
+  const filterTypeWire = reader.readVarInt();
+  const filterType = WIRE_TO_FILTER_TYPE.get(filterTypeWire);
+  if (filterType === void 0) {
+    throw new DecodeError("CONSTRAINT_VIOLATION", `Invalid filter type: ${filterTypeWire}`, reader.offset);
+  }
+  const base = {
+    type: "subscribe",
+    subscribeId,
+    trackAlias,
+    trackNamespace,
+    trackName,
+    subscriberPriority,
+    groupOrder,
+    filterType,
+    parameters: void 0
+  };
+  if (filterType === "absolute_start") {
+    const startGroup = reader.readVarInt();
+    const startObject = reader.readVarInt();
+    base.parameters = reader.readParameters();
+    return { ...base, startGroup, startObject };
+  }
+  if (filterType === "absolute_range") {
+    const startGroup = reader.readVarInt();
+    const startObject = reader.readVarInt();
+    const endGroup = reader.readVarInt();
+    const endObject = reader.readVarInt();
+    base.parameters = reader.readParameters();
+    return { ...base, startGroup, startObject, endGroup, endObject };
+  }
+  base.parameters = reader.readParameters();
+  return base;
+}
+function decodeSubscribeOk(reader) {
+  const subscribeId = reader.readVarInt();
+  const expires = reader.readVarInt();
+  const groupOrder = readGroupOrder(reader);
+  const contentExistsWire = reader.readUint8();
+  const contentExists = contentExistsWire !== 0;
+  if (contentExists) {
+    const largestGroupId = reader.readVarInt();
+    const largestObjectId = reader.readVarInt();
+    const parameters2 = reader.readParameters();
+    return { type: "subscribe_ok", subscribeId, expires, groupOrder, contentExists, largestGroupId, largestObjectId, parameters: parameters2 };
+  }
+  const parameters = reader.readParameters();
+  return { type: "subscribe_ok", subscribeId, expires, groupOrder, contentExists, parameters };
+}
+function decodeSubscribeError(reader) {
+  const subscribeId = reader.readVarInt();
+  const errorCode = reader.readVarInt();
+  const reasonPhrase = reader.readString();
+  const trackAlias = reader.readVarInt();
+  return { type: "subscribe_error", subscribeId, errorCode, reasonPhrase, trackAlias };
+}
+function decodeSubscribeDone(reader) {
+  const subscribeId = reader.readVarInt();
+  const statusCode = reader.readVarInt();
+  const reasonPhrase = reader.readString();
+  const contentExistsWire = reader.readUint8();
+  const contentExists = contentExistsWire !== 0;
+  if (contentExists) {
+    const finalGroupId = reader.readVarInt();
+    const finalObjectId = reader.readVarInt();
+    return { type: "subscribe_done", subscribeId, statusCode, reasonPhrase, contentExists, finalGroupId, finalObjectId };
+  }
+  return { type: "subscribe_done", subscribeId, statusCode, reasonPhrase, contentExists };
+}
+function decodeSubscribeUpdate(reader) {
+  const subscribeId = reader.readVarInt();
+  const startGroup = reader.readVarInt();
+  const startObject = reader.readVarInt();
+  const endGroup = reader.readVarInt();
+  const endObject = reader.readVarInt();
+  const subscriberPriority = reader.readUint8();
+  const parameters = reader.readParameters();
+  return { type: "subscribe_update", subscribeId, startGroup, startObject, endGroup, endObject, subscriberPriority, parameters };
+}
+function decodeUnsubscribe(reader) {
+  const subscribeId = reader.readVarInt();
+  return { type: "unsubscribe", subscribeId };
+}
+function decodeAnnounce(reader) {
+  const trackNamespace = reader.readTuple();
+  const parameters = reader.readParameters();
+  return { type: "announce", trackNamespace, parameters };
+}
+function decodeAnnounceOk(reader) {
+  const trackNamespace = reader.readTuple();
+  return { type: "announce_ok", trackNamespace };
+}
+function decodeAnnounceError(reader) {
+  const trackNamespace = reader.readTuple();
+  const errorCode = reader.readVarInt();
+  const reasonPhrase = reader.readString();
+  return { type: "announce_error", trackNamespace, errorCode, reasonPhrase };
+}
+function decodeAnnounceCancel(reader) {
+  const trackNamespace = reader.readTuple();
+  const errorCode = reader.readVarInt();
+  const reasonPhrase = reader.readString();
+  return { type: "announce_cancel", trackNamespace, errorCode, reasonPhrase };
+}
+function decodeUnannounce(reader) {
+  const trackNamespace = reader.readTuple();
+  return { type: "unannounce", trackNamespace };
+}
+function decodeTrackStatusRequest(reader) {
+  const trackNamespace = reader.readTuple();
+  const trackName = reader.readString();
+  return { type: "track_status_request", trackNamespace, trackName };
+}
+function decodeTrackStatus(reader) {
+  const trackNamespace = reader.readTuple();
+  const trackName = reader.readString();
+  const statusCode = reader.readVarInt();
+  const lastGroupId = reader.readVarInt();
+  const lastObjectId = reader.readVarInt();
+  return { type: "track_status", trackNamespace, trackName, statusCode, lastGroupId, lastObjectId };
+}
+function decodeGoAway(reader) {
+  const newSessionUri = reader.readString();
+  return { type: "goaway", newSessionUri };
+}
+function decodeSubscribeAnnounces(reader) {
+  const trackNamespace = reader.readTuple();
+  const parameters = reader.readParameters();
+  return { type: "subscribe_announces", trackNamespace, parameters };
+}
+function decodeSubscribeAnnouncesOk(reader) {
+  const trackNamespace = reader.readTuple();
+  return { type: "subscribe_announces_ok", trackNamespace };
+}
+function decodeSubscribeAnnouncesError(reader) {
+  const trackNamespace = reader.readTuple();
+  const errorCode = reader.readVarInt();
+  const reasonPhrase = reader.readString();
+  return { type: "subscribe_announces_error", trackNamespace, errorCode, reasonPhrase };
+}
+function decodeUnsubscribeAnnounces(reader) {
+  const trackNamespace = reader.readTuple();
+  return { type: "unsubscribe_announces", trackNamespace };
+}
+function decodeMaxSubscribeId(reader) {
+  const subscribeId = reader.readVarInt();
+  return { type: "max_subscribe_id", subscribeId };
+}
+function decodeFetch(reader) {
+  const subscribeId = reader.readVarInt();
+  const trackNamespace = reader.readTuple();
+  const trackName = reader.readString();
+  const subscriberPriority = reader.readUint8();
+  const groupOrder = readGroupOrder(reader);
+  const startGroup = reader.readVarInt();
+  const startObject = reader.readVarInt();
+  const endGroup = reader.readVarInt();
+  const endObject = reader.readVarInt();
+  const parameters = reader.readParameters();
+  return { type: "fetch", subscribeId, trackNamespace, trackName, subscriberPriority, groupOrder, startGroup, startObject, endGroup, endObject, parameters };
+}
+function decodeFetchOk(reader) {
+  const subscribeId = reader.readVarInt();
+  const groupOrder = readGroupOrder(reader);
+  const endOfTrackWire = reader.readUint8();
+  const endOfTrack = endOfTrackWire !== 0;
+  const largestGroupId = reader.readVarInt();
+  const largestObjectId = reader.readVarInt();
+  const parameters = reader.readParameters();
+  return { type: "fetch_ok", subscribeId, groupOrder, endOfTrack, largestGroupId, largestObjectId, parameters };
+}
+function decodeFetchError(reader) {
+  const subscribeId = reader.readVarInt();
+  const errorCode = reader.readVarInt();
+  const reasonPhrase = reader.readString();
+  return { type: "fetch_error", subscribeId, errorCode, reasonPhrase };
+}
+function decodeFetchCancel(reader) {
+  const subscribeId = reader.readVarInt();
+  return { type: "fetch_cancel", subscribeId };
+}
+function decodeObjectStream(reader) {
+  const subscribeId = reader.readVarInt();
+  const trackAlias = reader.readVarInt();
+  const groupId = reader.readVarInt();
+  const objectId = reader.readVarInt();
+  const publisherPriority = reader.readUint8();
+  const objectStatusRaw = Number(reader.readVarInt());
+  const payload = reader.readBytes(reader.remaining);
+  const base = { type: "object_stream", subscribeId, trackAlias, groupId, objectId, publisherPriority, payload };
+  if (objectStatusRaw !== 0) {
+    return { ...base, objectStatus: objectStatusRaw };
+  }
+  return base;
+}
+function decodeObjectDatagram(reader) {
+  const subscribeId = reader.readVarInt();
+  const trackAlias = reader.readVarInt();
+  const groupId = reader.readVarInt();
+  const objectId = reader.readVarInt();
+  const publisherPriority = reader.readUint8();
+  const objectStatusRaw = Number(reader.readVarInt());
+  const payload = reader.readBytes(reader.remaining);
+  const base = { type: "object_datagram", subscribeId, trackAlias, groupId, objectId, publisherPriority, payload };
+  if (objectStatusRaw !== 0) {
+    return { ...base, objectStatus: objectStatusRaw };
+  }
+  return base;
+}
+function decodeStreamHeaderTrack(reader) {
+  const subscribeId = reader.readVarInt();
+  const trackAlias = reader.readVarInt();
+  const publisherPriority = reader.readUint8();
+  return { type: "stream_header_track", subscribeId, trackAlias, publisherPriority };
+}
+function decodeStreamHeaderGroup(reader) {
+  const subscribeId = reader.readVarInt();
+  const trackAlias = reader.readVarInt();
+  const groupId = reader.readVarInt();
+  const publisherPriority = reader.readUint8();
+  return { type: "stream_header_group", subscribeId, trackAlias, groupId, publisherPriority };
+}
+function decodeStreamHeaderSubgroup(reader) {
+  const subscribeId = reader.readVarInt();
+  const trackAlias = reader.readVarInt();
+  const groupId = reader.readVarInt();
+  const subgroupId = reader.readVarInt();
+  const publisherPriority = reader.readUint8();
+  return { type: "stream_header_subgroup", subscribeId, trackAlias, groupId, subgroupId, publisherPriority };
+}
+var controlDecoders = /* @__PURE__ */ new Map([
+  [MESSAGE_TYPE_IDS.client_setup, decodeClientSetup],
+  [MESSAGE_TYPE_IDS.server_setup, decodeServerSetup],
+  [MESSAGE_TYPE_IDS.subscribe, decodeSubscribe],
+  [MESSAGE_TYPE_IDS.subscribe_ok, decodeSubscribeOk],
+  [MESSAGE_TYPE_IDS.subscribe_error, decodeSubscribeError],
+  [MESSAGE_TYPE_IDS.subscribe_done, decodeSubscribeDone],
+  [MESSAGE_TYPE_IDS.subscribe_update, decodeSubscribeUpdate],
+  [MESSAGE_TYPE_IDS.unsubscribe, decodeUnsubscribe],
+  [MESSAGE_TYPE_IDS.announce, decodeAnnounce],
+  [MESSAGE_TYPE_IDS.announce_ok, decodeAnnounceOk],
+  [MESSAGE_TYPE_IDS.announce_error, decodeAnnounceError],
+  [MESSAGE_TYPE_IDS.announce_cancel, decodeAnnounceCancel],
+  [MESSAGE_TYPE_IDS.unannounce, decodeUnannounce],
+  [MESSAGE_TYPE_IDS.track_status_request, decodeTrackStatusRequest],
+  [MESSAGE_TYPE_IDS.track_status, decodeTrackStatus],
+  [MESSAGE_TYPE_IDS.goaway, decodeGoAway],
+  [MESSAGE_TYPE_IDS.subscribe_announces, decodeSubscribeAnnounces],
+  [MESSAGE_TYPE_IDS.subscribe_announces_ok, decodeSubscribeAnnouncesOk],
+  [MESSAGE_TYPE_IDS.subscribe_announces_error, decodeSubscribeAnnouncesError],
+  [MESSAGE_TYPE_IDS.unsubscribe_announces, decodeUnsubscribeAnnounces],
+  [MESSAGE_TYPE_IDS.max_subscribe_id, decodeMaxSubscribeId],
+  [MESSAGE_TYPE_IDS.fetch, decodeFetch],
+  [MESSAGE_TYPE_IDS.fetch_ok, decodeFetchOk],
+  [MESSAGE_TYPE_IDS.fetch_error, decodeFetchError],
+  [MESSAGE_TYPE_IDS.fetch_cancel, decodeFetchCancel]
+]);
+var dataStreamDecoders = /* @__PURE__ */ new Map([
+  [MESSAGE_TYPE_IDS.object_stream, decodeObjectStream],
+  [MESSAGE_TYPE_IDS.object_datagram, decodeObjectDatagram],
+  [MESSAGE_TYPE_IDS.stream_header_track, decodeStreamHeaderTrack],
+  [MESSAGE_TYPE_IDS.stream_header_group, decodeStreamHeaderGroup],
+  [MESSAGE_TYPE_IDS.stream_header_subgroup, decodeStreamHeaderSubgroup]
+]);
+var MESSAGE_TYPE_TO_WIRE = {
+  client_setup: MESSAGE_TYPE_IDS.client_setup,
+  server_setup: MESSAGE_TYPE_IDS.server_setup,
+  subscribe: MESSAGE_TYPE_IDS.subscribe,
+  subscribe_ok: MESSAGE_TYPE_IDS.subscribe_ok,
+  subscribe_error: MESSAGE_TYPE_IDS.subscribe_error,
+  subscribe_done: MESSAGE_TYPE_IDS.subscribe_done,
+  subscribe_update: MESSAGE_TYPE_IDS.subscribe_update,
+  unsubscribe: MESSAGE_TYPE_IDS.unsubscribe,
+  announce: MESSAGE_TYPE_IDS.announce,
+  announce_ok: MESSAGE_TYPE_IDS.announce_ok,
+  announce_error: MESSAGE_TYPE_IDS.announce_error,
+  announce_cancel: MESSAGE_TYPE_IDS.announce_cancel,
+  unannounce: MESSAGE_TYPE_IDS.unannounce,
+  track_status_request: MESSAGE_TYPE_IDS.track_status_request,
+  track_status: MESSAGE_TYPE_IDS.track_status,
+  goaway: MESSAGE_TYPE_IDS.goaway,
+  subscribe_announces: MESSAGE_TYPE_IDS.subscribe_announces,
+  subscribe_announces_ok: MESSAGE_TYPE_IDS.subscribe_announces_ok,
+  subscribe_announces_error: MESSAGE_TYPE_IDS.subscribe_announces_error,
+  unsubscribe_announces: MESSAGE_TYPE_IDS.unsubscribe_announces,
+  max_subscribe_id: MESSAGE_TYPE_IDS.max_subscribe_id,
+  fetch: MESSAGE_TYPE_IDS.fetch,
+  fetch_ok: MESSAGE_TYPE_IDS.fetch_ok,
+  fetch_error: MESSAGE_TYPE_IDS.fetch_error,
+  fetch_cancel: MESSAGE_TYPE_IDS.fetch_cancel
+};
+function encodeMessageImpl(message) {
+  const dataEncoder = dataStreamEncoders[message.type];
+  if (dataEncoder) {
+    const writer = new BufferWriter();
+    dataEncoder(message, writer);
+    return writer.finish();
+  }
+  const controlEncoder = controlEncoders[message.type];
+  if (!controlEncoder) {
+    throw new Error(`Unknown message type: ${message.type}`);
+  }
+  const payloadWriter = new BufferWriter();
+  controlEncoder(message, payloadWriter);
+  const payload = payloadWriter.finish();
+  const frameWriter = new BufferWriter();
+  frameWriter.writeVarInt(MESSAGE_TYPE_TO_WIRE[message.type]);
+  frameWriter.writeVarInt(payload.byteLength);
+  frameWriter.writeBytes(payload);
+  return frameWriter.finish();
+}
+function decodeMessageImpl(bytes) {
+  try {
+    const reader = new BufferReader(bytes, 0);
+    const typeId = reader.readVarInt();
+    if (DATA_STREAM_TYPE_IDS.has(typeId)) {
+      const decoder2 = dataStreamDecoders.get(typeId);
+      if (!decoder2) {
+        return {
+          ok: false,
+          error: new DecodeError("UNKNOWN_MESSAGE_TYPE", `Unknown data stream type ID: 0x${typeId.toString(16)}`, 0)
+        };
+      }
+      const message2 = decoder2(reader);
+      return { ok: true, value: message2, bytesRead: reader.offset };
+    }
+    const payloadLength = Number(reader.readVarInt());
+    const headerBytes = reader.offset;
+    if (reader.remaining < payloadLength) {
+      return {
+        ok: false,
+        error: new DecodeError("UNEXPECTED_END", `Not enough bytes for payload: need ${payloadLength}, have ${reader.remaining}`, reader.offset)
+      };
+    }
+    const payloadBytes = reader.readBytes(payloadLength);
+    const totalBytesRead = reader.offset;
+    const decoder = controlDecoders.get(typeId);
+    if (!decoder) {
+      return {
+        ok: false,
+        error: new DecodeError("UNKNOWN_MESSAGE_TYPE", `Unknown message type ID: 0x${typeId.toString(16)}`, 0)
+      };
+    }
+    const payloadReader = new BufferReader(payloadBytes, 0);
+    const message = decoder(payloadReader);
+    return { ok: true, value: message, bytesRead: totalBytesRead };
+  } catch (e) {
+    if (e instanceof DecodeError) {
+      return { ok: false, error: e };
+    }
+    throw e;
+  }
+}
+function createStreamDecoderImpl() {
+  let buffer = new Uint8Array(0);
+  return new TransformStream({
+    transform(chunk, controller) {
+      const newBuffer = new Uint8Array(buffer.length + chunk.length);
+      newBuffer.set(buffer, 0);
+      newBuffer.set(chunk, buffer.length);
+      buffer = newBuffer;
+      while (buffer.length > 0) {
+        const result = decodeMessageImpl(buffer);
+        if (!result.ok) {
+          if (result.error.code === "UNEXPECTED_END") {
+            break;
+          }
+          controller.error(result.error);
+          return;
+        }
+        controller.enqueue(result.value);
+        buffer = buffer.slice(result.bytesRead);
+      }
+    },
+    flush(controller) {
+      if (buffer.length > 0) {
+        controller.error(
+          new DecodeError("UNEXPECTED_END", "Stream ended with incomplete message data", 0)
+        );
+      }
+    }
+  });
+}
+function createDraft07Codec() {
+  return {
+    draft: "draft-ietf-moq-transport-07",
+    encodeMessage: encodeMessageImpl,
+    decodeMessage: decodeMessageImpl,
+    encodeVarInt,
+    decodeVarInt,
+    createStreamDecoder: createStreamDecoderImpl
+  };
+}
+
+export {
+  MESSAGE_TYPE_IDS,
+  MESSAGE_ID_TO_TYPE,
+  encodeVarInt,
+  decodeVarInt,
+  createDraft07Codec
+};