@moqtap/codec 0.1.0

package/dist/chunk-IQPDRQVC.js

@@ -0,0 +1,1185 @@
+import {
+  BufferReader,
+  BufferWriter,
+  DecodeError
+} from "./chunk-YBSEOSSP.js";
+
+// src/drafts/draft14/messages.ts
+var MSG_SUBSCRIBE_UPDATE = 0x02n;
+var MSG_SUBSCRIBE = 0x03n;
+var MSG_SUBSCRIBE_OK = 0x04n;
+var MSG_SUBSCRIBE_ERROR = 0x05n;
+var MSG_PUBLISH_NAMESPACE = 0x06n;
+var MSG_PUBLISH_NAMESPACE_OK = 0x07n;
+var MSG_PUBLISH_NAMESPACE_ERROR = 0x08n;
+var MSG_PUBLISH_NAMESPACE_DONE = 0x09n;
+var MSG_UNSUBSCRIBE = 0x0An;
+var MSG_PUBLISH_DONE = 0x0Bn;
+var MSG_PUBLISH_NAMESPACE_CANCEL = 0x0Cn;
+var MSG_TRACK_STATUS = 0x0Dn;
+var MSG_TRACK_STATUS_OK = 0x0En;
+var MSG_TRACK_STATUS_ERROR = 0x0Fn;
+var MSG_GOAWAY = 0x10n;
+var MSG_SUBSCRIBE_NAMESPACE = 0x11n;
+var MSG_SUBSCRIBE_NAMESPACE_OK = 0x12n;
+var MSG_SUBSCRIBE_NAMESPACE_ERROR = 0x13n;
+var MSG_UNSUBSCRIBE_NAMESPACE = 0x14n;
+var MSG_MAX_REQUEST_ID = 0x15n;
+var MSG_FETCH = 0x16n;
+var MSG_FETCH_CANCEL = 0x17n;
+var MSG_FETCH_OK = 0x18n;
+var MSG_FETCH_ERROR = 0x19n;
+var MSG_REQUESTS_BLOCKED = 0x1An;
+var MSG_PUBLISH = 0x1Dn;
+var MSG_PUBLISH_OK = 0x1En;
+var MSG_PUBLISH_ERROR = 0x1Fn;
+var MSG_CLIENT_SETUP = 0x20n;
+var MSG_SERVER_SETUP = 0x21n;
+var PARAM_ROLE = 0x00n;
+var PARAM_PATH = 0x01n;
+var PARAM_MAX_REQUEST_ID = 0x02n;
+var MESSAGE_TYPE_MAP = /* @__PURE__ */ new Map([
+  [MSG_CLIENT_SETUP, "client_setup"],
+  [MSG_SERVER_SETUP, "server_setup"],
+  [MSG_SUBSCRIBE, "subscribe"],
+  [MSG_SUBSCRIBE_OK, "subscribe_ok"],
+  [MSG_SUBSCRIBE_UPDATE, "subscribe_update"],
+  [MSG_SUBSCRIBE_ERROR, "subscribe_error"],
+  [MSG_UNSUBSCRIBE, "unsubscribe"],
+  [MSG_PUBLISH, "publish"],
+  [MSG_PUBLISH_OK, "publish_ok"],
+  [MSG_PUBLISH_ERROR, "publish_error"],
+  [MSG_PUBLISH_DONE, "publish_done"],
+  [MSG_PUBLISH_NAMESPACE, "publish_namespace"],
+  [MSG_PUBLISH_NAMESPACE_OK, "publish_namespace_ok"],
+  [MSG_PUBLISH_NAMESPACE_ERROR, "publish_namespace_error"],
+  [MSG_PUBLISH_NAMESPACE_DONE, "publish_namespace_done"],
+  [MSG_PUBLISH_NAMESPACE_CANCEL, "publish_namespace_cancel"],
+  [MSG_SUBSCRIBE_NAMESPACE, "subscribe_namespace"],
+  [MSG_SUBSCRIBE_NAMESPACE_OK, "subscribe_namespace_ok"],
+  [MSG_SUBSCRIBE_NAMESPACE_ERROR, "subscribe_namespace_error"],
+  [MSG_UNSUBSCRIBE_NAMESPACE, "unsubscribe_namespace"],
+  [MSG_FETCH, "fetch"],
+  [MSG_FETCH_OK, "fetch_ok"],
+  [MSG_FETCH_ERROR, "fetch_error"],
+  [MSG_FETCH_CANCEL, "fetch_cancel"],
+  [MSG_TRACK_STATUS, "track_status"],
+  [MSG_TRACK_STATUS_OK, "track_status_ok"],
+  [MSG_TRACK_STATUS_ERROR, "track_status_error"],
+  [MSG_GOAWAY, "goaway"],
+  [MSG_MAX_REQUEST_ID, "max_request_id"],
+  [MSG_REQUESTS_BLOCKED, "requests_blocked"]
+]);
+var MESSAGE_ID_MAP = new Map(
+  [...MESSAGE_TYPE_MAP.entries()].map(([id, name]) => [name, id])
+);
+
+// src/drafts/draft14/codec.ts
+function bytesToHex(bytes) {
+  let hex = "";
+  for (let i = 0; i < bytes.byteLength; i++) {
+    hex += bytes[i].toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+  }
+  return bytes;
+}
+function encodeParams(params, writer) {
+  let count = 0;
+  if (params.role !== void 0) count++;
+  if (params.path !== void 0) count++;
+  if (params.max_request_id !== void 0) count++;
+  if (params.unknown) count += params.unknown.length;
+  writer.writeVarInt(count);
+  if (params.role !== void 0) {
+    writer.writeVarInt(PARAM_ROLE);
+    writer.writeVarInt(params.role);
+  }
+  if (params.path !== void 0) {
+    writer.writeVarInt(PARAM_PATH);
+    const encoded = new TextEncoder().encode(params.path);
+    writer.writeVarInt(encoded.byteLength);
+    writer.writeBytes(encoded);
+  }
+  if (params.max_request_id !== void 0) {
+    writer.writeVarInt(PARAM_MAX_REQUEST_ID);
+    writer.writeVarInt(params.max_request_id);
+  }
+  if (params.unknown) {
+    for (const u of params.unknown) {
+      const id = BigInt(u.id);
+      writer.writeVarInt(id);
+      const raw = hexToBytes(u.raw_hex);
+      writer.writeVarInt(raw.byteLength);
+      writer.writeBytes(raw);
+    }
+  }
+}
+function decodeParams(reader) {
+  const count = Number(reader.readVarInt());
+  const result = {};
+  const unknown = [];
+  for (let i = 0; i < count; i++) {
+    const paramType = reader.readVarInt();
+    if (paramType % 2n === 0n) {
+      const value = reader.readVarInt();
+      if (paramType === PARAM_ROLE) {
+        result.role = value;
+      } else if (paramType === PARAM_MAX_REQUEST_ID) {
+        result.max_request_id = value;
+      } else {
+        const tmpWriter = new BufferWriter(16);
+        tmpWriter.writeVarInt(value);
+        const raw = tmpWriter.finish();
+        unknown.push({
+          id: "0x" + paramType.toString(16),
+          length: raw.byteLength,
+          raw_hex: bytesToHex(raw)
+        });
+      }
+    } else {
+      const length = Number(reader.readVarInt());
+      const bytes = reader.readBytes(length);
+      if (paramType === PARAM_PATH) {
+        result.path = new TextDecoder().decode(bytes);
+      } else {
+        unknown.push({
+          id: "0x" + paramType.toString(16),
+          length,
+          raw_hex: bytesToHex(bytes)
+        });
+      }
+    }
+  }
+  if (unknown.length > 0) {
+    result.unknown = unknown;
+  }
+  return result;
+}
+function encodeClientSetupPayload(msg, w) {
+  w.writeVarInt(msg.supported_versions.length);
+  for (const v of msg.supported_versions) {
+    w.writeVarInt(v);
+  }
+  encodeParams(msg.parameters, w);
+}
+function encodeServerSetupPayload(msg, w) {
+  w.writeVarInt(msg.selected_version);
+  encodeParams(msg.parameters, w);
+}
+function encodeSubscribePayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  w.writeTuple(msg.track_namespace);
+  w.writeString(msg.track_name);
+  w.writeUint8(Number(msg.subscriber_priority));
+  w.writeVarInt(msg.group_order);
+  w.writeVarInt(msg.forward);
+  w.writeVarInt(msg.filter_type);
+  const ft = Number(msg.filter_type);
+  if (ft >= 3) {
+    w.writeVarInt(msg.start_group);
+    w.writeVarInt(msg.start_object);
+  }
+  if (ft === 4) {
+    w.writeVarInt(msg.end_group);
+  }
+  encodeParams(msg.parameters, w);
+}
+function encodeSubscribeOkPayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  w.writeVarInt(msg.track_alias);
+  w.writeVarInt(msg.expires);
+  w.writeVarInt(msg.group_order);
+  w.writeVarInt(msg.content_exists);
+  if (Number(msg.content_exists) === 1) {
+    w.writeVarInt(msg.largest_group);
+    w.writeVarInt(msg.largest_object);
+  }
+  encodeParams(msg.parameters, w);
+}
+function encodeSubscribeUpdatePayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  w.writeVarInt(msg.start_group);
+  w.writeVarInt(msg.start_object);
+  w.writeVarInt(msg.end_group);
+  w.writeUint8(Number(msg.subscriber_priority));
+  w.writeVarInt(msg.forward);
+  encodeParams(msg.parameters, w);
+}
+function encodeSubscribeErrorPayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  w.writeVarInt(msg.error_code);
+  w.writeString(msg.reason_phrase);
+}
+function encodeUnsubscribePayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+}
+function encodePublishPayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  w.writeTuple(msg.track_namespace);
+  w.writeString(msg.track_name);
+  w.writeVarInt(msg.forward);
+  encodeParams(msg.parameters, w);
+}
+function encodePublishOkPayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  w.writeVarInt(msg.track_alias);
+  w.writeVarInt(msg.forward);
+  encodeParams(msg.parameters, w);
+}
+function encodePublishErrorPayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  w.writeVarInt(msg.error_code);
+  w.writeString(msg.reason_phrase);
+}
+function encodePublishDonePayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  w.writeVarInt(msg.status_code);
+  w.writeString(msg.reason_phrase);
+}
+function encodePublishNamespacePayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  w.writeTuple(msg.track_namespace);
+  encodeParams(msg.parameters, w);
+}
+function encodePublishNamespaceOkPayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  encodeParams(msg.parameters, w);
+}
+function encodePublishNamespaceErrorPayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  w.writeVarInt(msg.error_code);
+  w.writeString(msg.reason_phrase);
+}
+function encodePublishNamespaceDonePayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  w.writeVarInt(msg.status_code);
+  w.writeString(msg.reason_phrase);
+}
+function encodePublishNamespaceCancelPayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+}
+function encodeSubscribeNamespacePayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  w.writeTuple(msg.namespace_prefix);
+  encodeParams(msg.parameters, w);
+}
+function encodeSubscribeNamespaceOkPayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  encodeParams(msg.parameters, w);
+}
+function encodeSubscribeNamespaceErrorPayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  w.writeVarInt(msg.error_code);
+  w.writeString(msg.reason_phrase);
+}
+function encodeUnsubscribeNamespacePayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+}
+function encodeFetchPayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  w.writeTuple(msg.track_namespace);
+  w.writeString(msg.track_name);
+  w.writeVarInt(msg.start_group);
+  w.writeVarInt(msg.start_object);
+  w.writeVarInt(msg.end_group);
+  encodeParams(msg.parameters, w);
+}
+function encodeFetchOkPayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  w.writeVarInt(msg.track_alias);
+  w.writeVarInt(msg.end_of_track);
+  encodeParams(msg.parameters, w);
+}
+function encodeFetchErrorPayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  w.writeVarInt(msg.error_code);
+  w.writeString(msg.reason_phrase);
+}
+function encodeFetchCancelPayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+}
+function encodeTrackStatusPayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  w.writeTuple(msg.track_namespace);
+  w.writeString(msg.track_name);
+  encodeParams(msg.parameters, w);
+}
+function encodeTrackStatusOkPayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  w.writeVarInt(msg.status_code);
+  const sc = Number(msg.status_code);
+  if (sc === 0 || sc === 3) {
+    w.writeVarInt(msg.largest_group);
+    w.writeVarInt(msg.largest_object);
+  }
+  encodeParams(msg.parameters, w);
+}
+function encodeTrackStatusErrorPayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+  w.writeVarInt(msg.error_code);
+  w.writeString(msg.reason_phrase);
+}
+function encodeGoAwayPayload(msg, w) {
+  w.writeString(msg.new_session_uri);
+}
+function encodeMaxRequestIdPayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+}
+function encodeRequestsBlockedPayload(msg, w) {
+  w.writeVarInt(msg.request_id);
+}
+function decodeClientSetupPayload(r) {
+  const numVersions = Number(r.readVarInt());
+  if (numVersions === 0) {
+    throw new DecodeError("CONSTRAINT_VIOLATION", "CLIENT_SETUP must offer at least one version", r.offset);
+  }
+  const supported_versions = [];
+  for (let i = 0; i < numVersions; i++) {
+    supported_versions.push(r.readVarInt());
+  }
+  const parameters = decodeParams(r);
+  return { type: "client_setup", supported_versions, parameters };
+}
+function decodeServerSetupPayload(r) {
+  const selected_version = r.readVarInt();
+  const parameters = decodeParams(r);
+  return { type: "server_setup", selected_version, parameters };
+}
+function decodeSubscribePayload(r) {
+  const request_id = r.readVarInt();
+  const track_namespace = r.readTuple();
+  const track_name = r.readString();
+  const subscriber_priority = BigInt(r.readUint8());
+  const group_order = r.readVarInt();
+  const forward = r.readVarInt();
+  const filter_type = r.readVarInt();
+  const ft = Number(filter_type);
+  if (ft < 1 || ft > 4) {
+    throw new DecodeError("CONSTRAINT_VIOLATION", `Invalid filter_type: ${ft}`, r.offset);
+  }
+  let start_group;
+  let start_object;
+  let end_group;
+  if (ft >= 3) {
+    start_group = r.readVarInt();
+    start_object = r.readVarInt();
+  }
+  if (ft === 4) {
+    end_group = r.readVarInt();
+  }
+  const parameters = decodeParams(r);
+  const msg = {
+    type: "subscribe",
+    request_id,
+    track_namespace,
+    track_name,
+    subscriber_priority,
+    group_order,
+    forward,
+    filter_type,
+    parameters
+  };
+  if (start_group !== void 0) {
+    return { ...msg, start_group, start_object, end_group };
+  }
+  return msg;
+}
+function decodeSubscribeOkPayload(r) {
+  const request_id = r.readVarInt();
+  const track_alias = r.readVarInt();
+  const expires = r.readVarInt();
+  const group_order = r.readVarInt();
+  const content_exists = r.readVarInt();
+  let largest_group;
+  let largest_object;
+  if (Number(content_exists) === 1) {
+    largest_group = r.readVarInt();
+    largest_object = r.readVarInt();
+  }
+  const parameters = decodeParams(r);
+  const msg = {
+    type: "subscribe_ok",
+    request_id,
+    track_alias,
+    expires,
+    group_order,
+    content_exists,
+    parameters,
+    ...largest_group !== void 0 ? { largest_group, largest_object } : {}
+  };
+  return msg;
+}
+function decodeSubscribeUpdatePayload(r) {
+  const request_id = r.readVarInt();
+  const start_group = r.readVarInt();
+  const start_object = r.readVarInt();
+  const end_group = r.readVarInt();
+  const subscriber_priority = BigInt(r.readUint8());
+  const forward = r.readVarInt();
+  const parameters = decodeParams(r);
+  return {
+    type: "subscribe_update",
+    request_id,
+    start_group,
+    start_object,
+    end_group,
+    subscriber_priority,
+    forward,
+    parameters
+  };
+}
+function decodeSubscribeErrorPayload(r) {
+  const request_id = r.readVarInt();
+  const error_code = r.readVarInt();
+  const reason_phrase = r.readString();
+  return { type: "subscribe_error", request_id, error_code, reason_phrase };
+}
+function decodeUnsubscribePayload(r) {
+  const request_id = r.readVarInt();
+  return { type: "unsubscribe", request_id };
+}
+function decodePublishPayload(r) {
+  const request_id = r.readVarInt();
+  const track_namespace = r.readTuple();
+  const track_name = r.readString();
+  const forward = r.readVarInt();
+  const parameters = decodeParams(r);
+  return { type: "publish", request_id, track_namespace, track_name, forward, parameters };
+}
+function decodePublishOkPayload(r) {
+  const request_id = r.readVarInt();
+  const track_alias = r.readVarInt();
+  const forward = r.readVarInt();
+  const parameters = decodeParams(r);
+  return { type: "publish_ok", request_id, track_alias, forward, parameters };
+}
+function decodePublishErrorPayload(r) {
+  const request_id = r.readVarInt();
+  const error_code = r.readVarInt();
+  const reason_phrase = r.readString();
+  return { type: "publish_error", request_id, error_code, reason_phrase };
+}
+function decodePublishDonePayload(r) {
+  const request_id = r.readVarInt();
+  const status_code = r.readVarInt();
+  const reason_phrase = r.readString();
+  return { type: "publish_done", request_id, status_code, reason_phrase };
+}
+function decodePublishNamespacePayload(r) {
+  const request_id = r.readVarInt();
+  const track_namespace = r.readTuple();
+  const parameters = decodeParams(r);
+  return { type: "publish_namespace", request_id, track_namespace, parameters };
+}
+function decodePublishNamespaceOkPayload(r) {
+  const request_id = r.readVarInt();
+  const parameters = decodeParams(r);
+  return { type: "publish_namespace_ok", request_id, parameters };
+}
+function decodePublishNamespaceErrorPayload(r) {
+  const request_id = r.readVarInt();
+  const error_code = r.readVarInt();
+  const reason_phrase = r.readString();
+  return { type: "publish_namespace_error", request_id, error_code, reason_phrase };
+}
+function decodePublishNamespaceDonePayload(r) {
+  const request_id = r.readVarInt();
+  const status_code = r.readVarInt();
+  const reason_phrase = r.readString();
+  return { type: "publish_namespace_done", request_id, status_code, reason_phrase };
+}
+function decodePublishNamespaceCancelPayload(r) {
+  const request_id = r.readVarInt();
+  return { type: "publish_namespace_cancel", request_id };
+}
+function decodeSubscribeNamespacePayload(r) {
+  const request_id = r.readVarInt();
+  const namespace_prefix = r.readTuple();
+  const parameters = decodeParams(r);
+  return { type: "subscribe_namespace", request_id, namespace_prefix, parameters };
+}
+function decodeSubscribeNamespaceOkPayload(r) {
+  const request_id = r.readVarInt();
+  const parameters = decodeParams(r);
+  return { type: "subscribe_namespace_ok", request_id, parameters };
+}
+function decodeSubscribeNamespaceErrorPayload(r) {
+  const request_id = r.readVarInt();
+  const error_code = r.readVarInt();
+  const reason_phrase = r.readString();
+  return { type: "subscribe_namespace_error", request_id, error_code, reason_phrase };
+}
+function decodeUnsubscribeNamespacePayload(r) {
+  const request_id = r.readVarInt();
+  return { type: "unsubscribe_namespace", request_id };
+}
+function decodeFetchPayload(r) {
+  const request_id = r.readVarInt();
+  const track_namespace = r.readTuple();
+  const track_name = r.readString();
+  const start_group = r.readVarInt();
+  const start_object = r.readVarInt();
+  const end_group = r.readVarInt();
+  const parameters = decodeParams(r);
+  return { type: "fetch", request_id, track_namespace, track_name, start_group, start_object, end_group, parameters };
+}
+function decodeFetchOkPayload(r) {
+  const request_id = r.readVarInt();
+  const track_alias = r.readVarInt();
+  const end_of_track = r.readVarInt();
+  const parameters = decodeParams(r);
+  return { type: "fetch_ok", request_id, track_alias, end_of_track, parameters };
+}
+function decodeFetchErrorPayload(r) {
+  const request_id = r.readVarInt();
+  const error_code = r.readVarInt();
+  const reason_phrase = r.readString();
+  return { type: "fetch_error", request_id, error_code, reason_phrase };
+}
+function decodeFetchCancelPayload(r) {
+  const request_id = r.readVarInt();
+  return { type: "fetch_cancel", request_id };
+}
+function decodeTrackStatusPayload(r) {
+  const request_id = r.readVarInt();
+  const track_namespace = r.readTuple();
+  const track_name = r.readString();
+  const parameters = decodeParams(r);
+  return { type: "track_status", request_id, track_namespace, track_name, parameters };
+}
+function decodeTrackStatusOkPayload(r) {
+  const request_id = r.readVarInt();
+  const status_code = r.readVarInt();
+  const sc = Number(status_code);
+  let largest_group;
+  let largest_object;
+  if (sc === 0 || sc === 3) {
+    largest_group = r.readVarInt();
+    largest_object = r.readVarInt();
+  }
+  const parameters = decodeParams(r);
+  return {
+    type: "track_status_ok",
+    request_id,
+    status_code,
+    parameters,
+    ...largest_group !== void 0 ? { largest_group, largest_object } : {}
+  };
+}
+function decodeTrackStatusErrorPayload(r) {
+  const request_id = r.readVarInt();
+  const error_code = r.readVarInt();
+  const reason_phrase = r.readString();
+  return { type: "track_status_error", request_id, error_code, reason_phrase };
+}
+function decodeGoAwayPayload(r) {
+  const new_session_uri = r.readString();
+  return { type: "goaway", new_session_uri };
+}
+function decodeMaxRequestIdPayload(r) {
+  const request_id = r.readVarInt();
+  return { type: "max_request_id", request_id };
+}
+function decodeRequestsBlockedPayload(r) {
+  const request_id = r.readVarInt();
+  return { type: "requests_blocked", request_id };
+}
+var payloadDecoders = /* @__PURE__ */ new Map([
+  [MSG_CLIENT_SETUP, decodeClientSetupPayload],
+  [MSG_SERVER_SETUP, decodeServerSetupPayload],
+  [MSG_SUBSCRIBE, decodeSubscribePayload],
+  [MSG_SUBSCRIBE_OK, decodeSubscribeOkPayload],
+  [MSG_SUBSCRIBE_UPDATE, decodeSubscribeUpdatePayload],
+  [MSG_SUBSCRIBE_ERROR, decodeSubscribeErrorPayload],
+  [MSG_UNSUBSCRIBE, decodeUnsubscribePayload],
+  [MSG_PUBLISH, decodePublishPayload],
+  [MSG_PUBLISH_OK, decodePublishOkPayload],
+  [MSG_PUBLISH_ERROR, decodePublishErrorPayload],
+  [MSG_PUBLISH_DONE, decodePublishDonePayload],
+  [MSG_PUBLISH_NAMESPACE, decodePublishNamespacePayload],
+  [MSG_PUBLISH_NAMESPACE_OK, decodePublishNamespaceOkPayload],
+  [MSG_PUBLISH_NAMESPACE_ERROR, decodePublishNamespaceErrorPayload],
+  [MSG_PUBLISH_NAMESPACE_DONE, decodePublishNamespaceDonePayload],
+  [MSG_PUBLISH_NAMESPACE_CANCEL, decodePublishNamespaceCancelPayload],
+  [MSG_SUBSCRIBE_NAMESPACE, decodeSubscribeNamespacePayload],
+  [MSG_SUBSCRIBE_NAMESPACE_OK, decodeSubscribeNamespaceOkPayload],
+  [MSG_SUBSCRIBE_NAMESPACE_ERROR, decodeSubscribeNamespaceErrorPayload],
+  [MSG_UNSUBSCRIBE_NAMESPACE, decodeUnsubscribeNamespacePayload],
+  [MSG_FETCH, decodeFetchPayload],
+  [MSG_FETCH_OK, decodeFetchOkPayload],
+  [MSG_FETCH_ERROR, decodeFetchErrorPayload],
+  [MSG_FETCH_CANCEL, decodeFetchCancelPayload],
+  [MSG_TRACK_STATUS, decodeTrackStatusPayload],
+  [MSG_TRACK_STATUS_OK, decodeTrackStatusOkPayload],
+  [MSG_TRACK_STATUS_ERROR, decodeTrackStatusErrorPayload],
+  [MSG_GOAWAY, decodeGoAwayPayload],
+  [MSG_MAX_REQUEST_ID, decodeMaxRequestIdPayload],
+  [MSG_REQUESTS_BLOCKED, decodeRequestsBlockedPayload]
+]);
+function encodeMessage(message) {
+  const typeId = MESSAGE_ID_MAP.get(message.type);
+  if (typeId === void 0) {
+    throw new Error(`Unknown message type: ${message.type}`);
+  }
+  const payloadWriter = new BufferWriter();
+  encodePayload(message, payloadWriter);
+  const payload = payloadWriter.finish();
+  if (payload.byteLength > 65535) {
+    throw new Error(`Payload too large for 16-bit length: ${payload.byteLength}`);
+  }
+  const writer = new BufferWriter();
+  writer.writeVarInt(typeId);
+  writer.writeUint8(payload.byteLength >> 8 & 255);
+  writer.writeUint8(payload.byteLength & 255);
+  writer.writeBytes(payload);
+  return writer.finish();
+}
+function encodePayload(msg, w) {
+  switch (msg.type) {
+    case "client_setup":
+      return encodeClientSetupPayload(msg, w);
+    case "server_setup":
+      return encodeServerSetupPayload(msg, w);
+    case "subscribe":
+      return encodeSubscribePayload(msg, w);
+    case "subscribe_ok":
+      return encodeSubscribeOkPayload(msg, w);
+    case "subscribe_update":
+      return encodeSubscribeUpdatePayload(msg, w);
+    case "subscribe_error":
+      return encodeSubscribeErrorPayload(msg, w);
+    case "unsubscribe":
+      return encodeUnsubscribePayload(msg, w);
+    case "publish":
+      return encodePublishPayload(msg, w);
+    case "publish_ok":
+      return encodePublishOkPayload(msg, w);
+    case "publish_error":
+      return encodePublishErrorPayload(msg, w);
+    case "publish_done":
+      return encodePublishDonePayload(msg, w);
+    case "publish_namespace":
+      return encodePublishNamespacePayload(msg, w);
+    case "publish_namespace_ok":
+      return encodePublishNamespaceOkPayload(msg, w);
+    case "publish_namespace_error":
+      return encodePublishNamespaceErrorPayload(msg, w);
+    case "publish_namespace_done":
+      return encodePublishNamespaceDonePayload(msg, w);
+    case "publish_namespace_cancel":
+      return encodePublishNamespaceCancelPayload(msg, w);
+    case "subscribe_namespace":
+      return encodeSubscribeNamespacePayload(msg, w);
+    case "subscribe_namespace_ok":
+      return encodeSubscribeNamespaceOkPayload(msg, w);
+    case "subscribe_namespace_error":
+      return encodeSubscribeNamespaceErrorPayload(msg, w);
+    case "unsubscribe_namespace":
+      return encodeUnsubscribeNamespacePayload(msg, w);
+    case "fetch":
+      return encodeFetchPayload(msg, w);
+    case "fetch_ok":
+      return encodeFetchOkPayload(msg, w);
+    case "fetch_error":
+      return encodeFetchErrorPayload(msg, w);
+    case "fetch_cancel":
+      return encodeFetchCancelPayload(msg, w);
+    case "track_status":
+      return encodeTrackStatusPayload(msg, w);
+    case "track_status_ok":
+      return encodeTrackStatusOkPayload(msg, w);
+    case "track_status_error":
+      return encodeTrackStatusErrorPayload(msg, w);
+    case "goaway":
+      return encodeGoAwayPayload(msg, w);
+    case "max_request_id":
+      return encodeMaxRequestIdPayload(msg, w);
+    case "requests_blocked":
+      return encodeRequestsBlockedPayload(msg, w);
+    default: {
+      const _exhaustive = msg;
+      throw new Error(`Unhandled message type: ${_exhaustive.type}`);
+    }
+  }
+}
+function decodeMessage(bytes) {
+  try {
+    const reader = new BufferReader(bytes);
+    const typeId = reader.readVarInt();
+    const lenHi = reader.readUint8();
+    const lenLo = reader.readUint8();
+    const payloadLength = lenHi << 8 | lenLo;
+    const payloadBytes = reader.readBytes(payloadLength);
+    const payloadReader = new BufferReader(payloadBytes);
+    const decoder = payloadDecoders.get(typeId);
+    if (!decoder) {
+      return {
+        ok: false,
+        error: new DecodeError("UNKNOWN_MESSAGE_TYPE", `Unknown message type ID: 0x${typeId.toString(16)}`, 0)
+      };
+    }
+    const message = decoder(payloadReader);
+    return { ok: true, value: message, bytesRead: reader.offset };
+  } catch (e) {
+    if (e instanceof DecodeError) {
+      return { ok: false, error: e };
+    }
+    throw e;
+  }
+}
+function encodeSubgroupStream(stream) {
+  const w = new BufferWriter();
+  w.writeVarInt(0n);
+  w.writeVarInt(stream.trackAlias);
+  w.writeVarInt(stream.groupId);
+  w.writeVarInt(stream.subgroupId);
+  w.writeUint8(stream.publisherPriority);
+  for (const obj of stream.objects) {
+    w.writeVarInt(obj.objectId);
+    w.writeVarInt(obj.payloadLength);
+    w.writeBytes(obj.payload);
+  }
+  return w.finish();
+}
+function encodeDatagram(dg) {
+  const w = new BufferWriter();
+  w.writeVarInt(dg.trackAlias);
+  w.writeVarInt(dg.groupId);
+  w.writeVarInt(dg.objectId);
+  w.writeVarInt(dg.payloadLength);
+  w.writeBytes(dg.payload);
+  return w.finish();
+}
+function encodeFetchStream(stream) {
+  const w = new BufferWriter();
+  w.writeVarInt(2n);
+  w.writeVarInt(stream.subscribeRequestId);
+  for (const obj of stream.objects) {
+    w.writeVarInt(obj.objectId);
+    w.writeVarInt(obj.payloadLength);
+    w.writeBytes(obj.payload);
+  }
+  return w.finish();
+}
+function decodeSubgroupStream(bytes) {
+  try {
+    const r = new BufferReader(bytes);
+    const streamType = r.readVarInt();
+    if (streamType !== 0n) {
+      return { ok: false, error: new DecodeError("CONSTRAINT_VIOLATION", `Expected subgroup stream type 0, got ${streamType}`, 0) };
+    }
+    const trackAlias = r.readVarInt();
+    const groupId = r.readVarInt();
+    const subgroupId = r.readVarInt();
+    const publisherPriority = r.readUint8();
+    const objects = [];
+    while (r.remaining > 0) {
+      const objectId = r.readVarInt();
+      const payloadLength = Number(r.readVarInt());
+      const payload = r.readBytes(payloadLength);
+      objects.push({ type: "object", objectId, payloadLength, payload });
+    }
+    return {
+      ok: true,
+      value: { type: "subgroup", trackAlias, groupId, subgroupId, publisherPriority, objects },
+      bytesRead: r.offset
+    };
+  } catch (e) {
+    if (e instanceof DecodeError) return { ok: false, error: e };
+    throw e;
+  }
+}
+function decodeDatagram(bytes) {
+  try {
+    const r = new BufferReader(bytes);
+    const trackAlias = r.readVarInt();
+    const groupId = r.readVarInt();
+    const objectId = r.readVarInt();
+    const payloadLength = Number(r.readVarInt());
+    const payload = r.readBytes(payloadLength);
+    return {
+      ok: true,
+      value: { type: "datagram", trackAlias, groupId, objectId, payloadLength, payload },
+      bytesRead: r.offset
+    };
+  } catch (e) {
+    if (e instanceof DecodeError) return { ok: false, error: e };
+    throw e;
+  }
+}
+function decodeFetchStream(bytes) {
+  try {
+    const r = new BufferReader(bytes);
+    const streamType = r.readVarInt();
+    if (streamType !== 2n) {
+      return { ok: false, error: new DecodeError("CONSTRAINT_VIOLATION", `Expected fetch stream type 2, got ${streamType}`, 0) };
+    }
+    const subscribeRequestId = r.readVarInt();
+    const objects = [];
+    while (r.remaining > 0) {
+      const objectId = r.readVarInt();
+      const payloadLength = Number(r.readVarInt());
+      const payload = r.readBytes(payloadLength);
+      objects.push({ type: "object", objectId, payloadLength, payload });
+    }
+    return {
+      ok: true,
+      value: { type: "fetch", subscribeRequestId, objects },
+      bytesRead: r.offset
+    };
+  } catch (e) {
+    if (e instanceof DecodeError) return { ok: false, error: e };
+    throw e;
+  }
+}
+function decodeDataStream(streamType, bytes) {
+  switch (streamType) {
+    case "subgroup":
+      return decodeSubgroupStream(bytes);
+    case "datagram":
+      return decodeDatagram(bytes);
+    case "fetch":
+      return decodeFetchStream(bytes);
+    default: {
+      const _exhaustive = streamType;
+      throw new Error(`Unknown stream type: ${_exhaustive}`);
+    }
+  }
+}
+function createStreamDecoder() {
+  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 = decodeMessage(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 createSubgroupStreamDecoder() {
+  let buffer = new Uint8Array(0);
+  let headerEmitted = false;
+  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;
+      if (!headerEmitted) {
+        try {
+          const r = new BufferReader(buffer);
+          const streamType = r.readVarInt();
+          if (streamType !== 0n) {
+            controller.error(
+              new DecodeError("CONSTRAINT_VIOLATION", `Expected subgroup stream type 0, got ${streamType}`, 0)
+            );
+            return;
+          }
+          const trackAlias = r.readVarInt();
+          const groupId = r.readVarInt();
+          const subgroupId = r.readVarInt();
+          const publisherPriority = r.readUint8();
+          controller.enqueue({
+            type: "subgroup_header",
+            trackAlias,
+            groupId,
+            subgroupId,
+            publisherPriority
+          });
+          headerEmitted = true;
+          buffer = buffer.slice(r.offset);
+        } catch (e) {
+          if (e instanceof DecodeError && e.code === "UNEXPECTED_END") {
+            return;
+          }
+          controller.error(e);
+          return;
+        }
+      }
+      while (buffer.length > 0) {
+        try {
+          const r = new BufferReader(buffer);
+          const objectId = r.readVarInt();
+          const payloadLength = Number(r.readVarInt());
+          const payload = r.readBytes(payloadLength);
+          controller.enqueue({ type: "object", objectId, payloadLength, payload });
+          buffer = buffer.slice(r.offset);
+        } catch (e) {
+          if (e instanceof DecodeError && e.code === "UNEXPECTED_END") {
+            break;
+          }
+          controller.error(e);
+          return;
+        }
+      }
+    },
+    flush(controller) {
+      if (buffer.length > 0) {
+        controller.error(
+          new DecodeError("UNEXPECTED_END", "Stream ended with incomplete data", 0)
+        );
+      }
+    }
+  });
+}
+function createFetchStreamDecoder() {
+  let buffer = new Uint8Array(0);
+  let headerEmitted = false;
+  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;
+      if (!headerEmitted) {
+        try {
+          const r = new BufferReader(buffer);
+          const streamType = r.readVarInt();
+          if (streamType !== 2n) {
+            controller.error(
+              new DecodeError("CONSTRAINT_VIOLATION", `Expected fetch stream type 2, got ${streamType}`, 0)
+            );
+            return;
+          }
+          const subscribeRequestId = r.readVarInt();
+          controller.enqueue({
+            type: "fetch_header",
+            subscribeRequestId
+          });
+          headerEmitted = true;
+          buffer = buffer.slice(r.offset);
+        } catch (e) {
+          if (e instanceof DecodeError && e.code === "UNEXPECTED_END") {
+            return;
+          }
+          controller.error(e);
+          return;
+        }
+      }
+      while (buffer.length > 0) {
+        try {
+          const r = new BufferReader(buffer);
+          const objectId = r.readVarInt();
+          const payloadLength = Number(r.readVarInt());
+          const payload = r.readBytes(payloadLength);
+          controller.enqueue({ type: "object", objectId, payloadLength, payload });
+          buffer = buffer.slice(r.offset);
+        } catch (e) {
+          if (e instanceof DecodeError && e.code === "UNEXPECTED_END") {
+            break;
+          }
+          controller.error(e);
+          return;
+        }
+      }
+    },
+    flush(controller) {
+      if (buffer.length > 0) {
+        controller.error(
+          new DecodeError("UNEXPECTED_END", "Stream ended with incomplete data", 0)
+        );
+      }
+    }
+  });
+}
+function createDataStreamDecoder() {
+  let buffer = new Uint8Array(0);
+  let detectedType = null;
+  let headerEmitted = false;
+  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;
+      if (detectedType === null) {
+        try {
+          const r = new BufferReader(buffer);
+          const streamType = r.readVarInt();
+          if (streamType === 0n) {
+            detectedType = "subgroup";
+          } else if (streamType === 2n) {
+            detectedType = "fetch";
+          } else {
+            controller.error(
+              new DecodeError("CONSTRAINT_VIOLATION", `Unknown data stream type: ${streamType}`, 0)
+            );
+            return;
+          }
+        } catch (e) {
+          if (e instanceof DecodeError && e.code === "UNEXPECTED_END") {
+            return;
+          }
+          controller.error(e);
+          return;
+        }
+      }
+      if (detectedType === "subgroup") {
+        if (!headerEmitted) {
+          try {
+            const r = new BufferReader(buffer);
+            r.readVarInt();
+            const trackAlias = r.readVarInt();
+            const groupId = r.readVarInt();
+            const subgroupId = r.readVarInt();
+            const publisherPriority = r.readUint8();
+            controller.enqueue({
+              type: "subgroup_header",
+              trackAlias,
+              groupId,
+              subgroupId,
+              publisherPriority
+            });
+            headerEmitted = true;
+            buffer = buffer.slice(r.offset);
+          } catch (e) {
+            if (e instanceof DecodeError && e.code === "UNEXPECTED_END") {
+              return;
+            }
+            controller.error(e);
+            return;
+          }
+        }
+      } else {
+        if (!headerEmitted) {
+          try {
+            const r = new BufferReader(buffer);
+            r.readVarInt();
+            const subscribeRequestId = r.readVarInt();
+            controller.enqueue({
+              type: "fetch_header",
+              subscribeRequestId
+            });
+            headerEmitted = true;
+            buffer = buffer.slice(r.offset);
+          } catch (e) {
+            if (e instanceof DecodeError && e.code === "UNEXPECTED_END") {
+              return;
+            }
+            controller.error(e);
+            return;
+          }
+        }
+      }
+      while (buffer.length > 0) {
+        try {
+          const r = new BufferReader(buffer);
+          const objectId = r.readVarInt();
+          const payloadLength = Number(r.readVarInt());
+          const payload = r.readBytes(payloadLength);
+          controller.enqueue({ type: "object", objectId, payloadLength, payload });
+          buffer = buffer.slice(r.offset);
+        } catch (e) {
+          if (e instanceof DecodeError && e.code === "UNEXPECTED_END") {
+            break;
+          }
+          controller.error(e);
+          return;
+        }
+      }
+    },
+    flush(controller) {
+      if (buffer.length > 0) {
+        controller.error(
+          new DecodeError("UNEXPECTED_END", "Stream ended with incomplete data", 0)
+        );
+      }
+    }
+  });
+}
+function createDraft14Codec() {
+  return {
+    draft: "draft-ietf-moq-transport-14",
+    encodeMessage,
+    decodeMessage,
+    encodeSubgroupStream,
+    encodeDatagram,
+    encodeFetchStream,
+    decodeSubgroupStream,
+    decodeDatagram,
+    decodeFetchStream,
+    decodeDataStream,
+    createStreamDecoder,
+    createSubgroupStreamDecoder,
+    createFetchStreamDecoder,
+    createDataStreamDecoder
+  };
+}
+
+export {
+  MSG_SUBSCRIBE_UPDATE,
+  MSG_SUBSCRIBE,
+  MSG_SUBSCRIBE_OK,
+  MSG_SUBSCRIBE_ERROR,
+  MSG_PUBLISH_NAMESPACE,
+  MSG_PUBLISH_NAMESPACE_OK,
+  MSG_PUBLISH_NAMESPACE_ERROR,
+  MSG_PUBLISH_NAMESPACE_DONE,
+  MSG_UNSUBSCRIBE,
+  MSG_PUBLISH_DONE,
+  MSG_PUBLISH_NAMESPACE_CANCEL,
+  MSG_TRACK_STATUS,
+  MSG_TRACK_STATUS_OK,
+  MSG_TRACK_STATUS_ERROR,
+  MSG_GOAWAY,
+  MSG_SUBSCRIBE_NAMESPACE,
+  MSG_SUBSCRIBE_NAMESPACE_OK,
+  MSG_SUBSCRIBE_NAMESPACE_ERROR,
+  MSG_UNSUBSCRIBE_NAMESPACE,
+  MSG_MAX_REQUEST_ID,
+  MSG_FETCH,
+  MSG_FETCH_CANCEL,
+  MSG_FETCH_OK,
+  MSG_FETCH_ERROR,
+  MSG_REQUESTS_BLOCKED,
+  MSG_PUBLISH,
+  MSG_PUBLISH_OK,
+  MSG_PUBLISH_ERROR,
+  MSG_CLIENT_SETUP,
+  MSG_SERVER_SETUP,
+  PARAM_ROLE,
+  PARAM_PATH,
+  PARAM_MAX_REQUEST_ID,
+  MESSAGE_TYPE_MAP,
+  MESSAGE_ID_MAP,
+  encodeMessage,
+  decodeMessage,
+  encodeSubgroupStream,
+  encodeDatagram,
+  encodeFetchStream,
+  decodeSubgroupStream,
+  decodeDatagram,
+  decodeFetchStream,
+  decodeDataStream,
+  createStreamDecoder,
+  createSubgroupStreamDecoder,
+  createFetchStreamDecoder,
+  createDataStreamDecoder,
+  createDraft14Codec
+};