@moqtap/codec 0.2.0 → 0.2.2

package/src/drafts/draft07/data-streams.ts

@@ -0,0 +1,240 @@
+import { BufferReader } from "../../core/buffer-reader.js";
+import { BufferWriter } from "../../core/buffer-writer.js";
+import type { DecodeResult } from "../../core/types.js";
+import { DecodeError } from "../../core/types.js";
+import type {
+  DatagramObject as Draft07DatagramObject,
+  FetchObjectPayload,
+  FetchStream,
+  ObjectPayload,
+  SubgroupStream,
+} from "./types.js";
+
+// ─── Data Stream Encoding/Decoding ─────────────────────────────────────────────
+
+// Stream type IDs for draft-07
+const SUBGROUP_STREAM_TYPE = 0x04n;
+const FETCH_STREAM_TYPE = 0x05n;
+const DATAGRAM_TYPE = 0x01n;
+
+export function encodeSubgroupStream(stream: SubgroupStream): Uint8Array {
+  const w = new BufferWriter();
+  w.writeVarInt(SUBGROUP_STREAM_TYPE);
+  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);
+    if (obj.payloadLength === 0 && obj.status !== undefined) {
+      w.writeVarInt(obj.status);
+    } else {
+      w.writeBytes(obj.payload);
+    }
+  }
+  return w.finish();
+}
+
+export function encodeDatagram(dg: Draft07DatagramObject): Uint8Array {
+  const w = new BufferWriter();
+  w.writeVarInt(DATAGRAM_TYPE);
+  w.writeVarInt(dg.trackAlias);
+  w.writeVarInt(dg.groupId);
+  w.writeVarInt(dg.objectId);
+  w.writeUint8(dg.publisherPriority);
+  w.writeVarInt(dg.payloadLength);
+  if (dg.payloadLength === 0 && dg.status !== undefined) {
+    w.writeVarInt(dg.status);
+  } else {
+    w.writeBytes(dg.payload);
+  }
+  return w.finish();
+}
+
+export function encodeFetchStream(stream: FetchStream): Uint8Array {
+  const w = new BufferWriter();
+  w.writeVarInt(FETCH_STREAM_TYPE);
+  w.writeVarInt(stream.subscribeId);
+  for (const obj of stream.objects) {
+    w.writeVarInt(obj.groupId);
+    w.writeVarInt(obj.subgroupId);
+    w.writeVarInt(obj.objectId);
+    w.writeUint8(obj.publisherPriority);
+    w.writeVarInt(obj.payloadLength);
+    if (obj.payloadLength === 0 && obj.status !== undefined) {
+      w.writeVarInt(obj.status);
+    } else {
+      w.writeBytes(obj.payload);
+    }
+  }
+  return w.finish();
+}
+
+export function decodeSubgroupStream(bytes: Uint8Array): DecodeResult<SubgroupStream> {
+  try {
+    const r = new BufferReader(bytes);
+    const streamType = Number(r.readVarInt());
+    if (streamType !== 0x04) {
+      return {
+        ok: false,
+        error: new DecodeError(
+          "CONSTRAINT_VIOLATION",
+          `Expected subgroup type 0x04, got 0x${streamType.toString(16)}`,
+          0,
+        ),
+      };
+    }
+    const trackAlias = r.readVarInt();
+    const groupId = r.readVarInt();
+    const subgroupId = r.readVarInt();
+    const publisherPriority = r.readUint8();
+    const objects: ObjectPayload[] = [];
+    while (r.remaining > 0) {
+      const byteOffset = r.offset;
+      const objectId = r.readVarInt();
+      const payloadLength = Number(r.readVarInt());
+      let payload: Uint8Array;
+      let status: bigint | undefined;
+      let payloadByteOffset: number;
+      if (payloadLength === 0) {
+        status = r.readVarInt();
+        payloadByteOffset = r.offset;
+        payload = new Uint8Array(0);
+      } else {
+        payloadByteOffset = r.offset;
+        payload = r.readBytes(payloadLength);
+      }
+      const obj: ObjectPayload = {
+        type: "object",
+        objectId,
+        payloadLength,
+        payload,
+        byteOffset,
+        payloadByteOffset,
+      };
+      if (status !== undefined) (obj as unknown as Record<string, unknown>).status = status;
+      objects.push(obj);
+    }
+    return {
+      ok: true,
+      value: {
+        type: "subgroup",
+        streamTypeId: 0x04,
+        trackAlias,
+        groupId,
+        subgroupId,
+        publisherPriority,
+        objects,
+      },
+      bytesRead: r.offset,
+    };
+  } catch (e) {
+    if (e instanceof DecodeError) return { ok: false, error: e };
+    throw e;
+  }
+}
+
+export function decodeDatagram(bytes: Uint8Array): DecodeResult<Draft07DatagramObject> {
+  try {
+    const r = new BufferReader(bytes);
+    const streamType = Number(r.readVarInt());
+    if (streamType !== 0x01) {
+      return {
+        ok: false,
+        error: new DecodeError(
+          "CONSTRAINT_VIOLATION",
+          `Expected datagram type 0x01, got 0x${streamType.toString(16)}`,
+          0,
+        ),
+      };
+    }
+    const trackAlias = r.readVarInt();
+    const groupId = r.readVarInt();
+    const objectId = r.readVarInt();
+    const publisherPriority = r.readUint8();
+    const payloadLength = Number(r.readVarInt());
+    let status: bigint | undefined;
+    let payload: Uint8Array;
+    if (payloadLength === 0) {
+      status = r.readVarInt();
+      payload = new Uint8Array(0);
+    } else {
+      payload = r.readBytes(payloadLength);
+    }
+    const result: Draft07DatagramObject = {
+      type: "datagram",
+      streamTypeId: 0x01,
+      trackAlias,
+      groupId,
+      objectId,
+      publisherPriority,
+      payloadLength,
+      payload,
+    };
+    if (status !== undefined) (result as unknown as Record<string, unknown>).status = status;
+    return { ok: true, value: result, bytesRead: r.offset };
+  } catch (e) {
+    if (e instanceof DecodeError) return { ok: false, error: e };
+    throw e;
+  }
+}
+
+export function decodeFetchStream(bytes: Uint8Array): DecodeResult<FetchStream> {
+  try {
+    const r = new BufferReader(bytes);
+    const streamType = Number(r.readVarInt());
+    if (streamType !== 0x05) {
+      return {
+        ok: false,
+        error: new DecodeError(
+          "CONSTRAINT_VIOLATION",
+          `Expected fetch type 0x05, got 0x${streamType.toString(16)}`,
+          0,
+        ),
+      };
+    }
+    const subscribeId = r.readVarInt();
+    const objects: FetchObjectPayload[] = [];
+    while (r.remaining > 0) {
+      const byteOffset = r.offset;
+      const groupId = r.readVarInt();
+      const subgroupId = r.readVarInt();
+      const objectId = r.readVarInt();
+      const publisherPriority = r.readUint8();
+      const payloadLength = Number(r.readVarInt());
+      let payload: Uint8Array;
+      let status: bigint | undefined;
+      let payloadByteOffset: number;
+      if (payloadLength === 0) {
+        status = r.readVarInt();
+        payloadByteOffset = r.offset;
+        payload = new Uint8Array(0);
+      } else {
+        payloadByteOffset = r.offset;
+        payload = r.readBytes(payloadLength);
+      }
+      const obj: FetchObjectPayload = {
+        type: "object",
+        groupId,
+        subgroupId,
+        objectId,
+        publisherPriority,
+        payloadLength,
+        payload,
+        byteOffset,
+        payloadByteOffset,
+      };
+      if (status !== undefined) (obj as unknown as Record<string, unknown>).status = status;
+      objects.push(obj);
+    }
+    return {
+      ok: true,
+      value: { type: "fetch", subscribeId, objects },
+      bytesRead: r.offset,
+    };
+  } catch (e) {
+    if (e instanceof DecodeError) return { ok: false, error: e };
+    throw e;
+  }
+}

package/src/drafts/draft07/index.ts

@@ -1,69 +1,89 @@
-// Re-export types consumers need
-export type {
-  Announce,
-  AnnounceCancel,
-  AnnounceError,
-  AnnounceOk,
-  ClientSetup,
-  DecodeErrorCode,
-  DecodeResult,
-  Fetch,
-  FetchCancel,
-  FetchError,
-  FetchOk,
-  FilterType,
-  GoAway,
-  GroupOrderValue,
-  MaxSubscribeId,
-  MoqtMessage,
-  MoqtMessageType,
-  ObjectDatagram,
-  ObjectStream,
-  ServerSetup,
-  StreamHeaderGroup,
-  StreamHeaderSubgroup,
-  StreamHeaderTrack,
-  Subscribe,
-  SubscribeAnnounces,
-  SubscribeAnnouncesError,
-  SubscribeAnnouncesOk,
-  SubscribeDone,
-  SubscribeError,
-  SubscribeOk,
-  SubscribeUpdate,
-  TrackStatus,
-  TrackStatusRequest,
-  Unannounce,
-  Unsubscribe,
-  UnsubscribeAnnounces,
-} from "../../core/types.js";
-export { DecodeError } from "../../core/types.js";
-export { createDraft07Codec } from "./codec.js";
-export { MESSAGE_ID_TO_TYPE, MESSAGE_TYPE_IDS } from "./messages.js";
-export { decodeParameters, encodeParameters } from "./parameters.js";
-export {
-  CLIENT_ONLY_MESSAGES,
-  CONTROL_MESSAGES,
-  DATA_MESSAGES,
-  getLegalIncoming,
-  getLegalOutgoing,
-  SERVER_ONLY_MESSAGES,
-} from "./rules.js";
-export { decodeVarInt, encodeVarInt } from "./varint.js";
-
-import type { DecodeResult, MoqtMessage } from "../../core/types.js";
-import { createDraft07Codec } from "./codec.js";
-
-const defaultCodec = createDraft07Codec();
-
-export function encodeMessage(message: MoqtMessage): Uint8Array {
-  return defaultCodec.encodeMessage(message);
-}
-
-export function decodeMessage(bytes: Uint8Array): DecodeResult<MoqtMessage> {
-  return defaultCodec.decodeMessage(bytes);
-}
-
-export function createStreamDecoder(): TransformStream<Uint8Array, MoqtMessage> {
-  return defaultCodec.createStreamDecoder();
-}
+// Re-export types consumers need
+export type {
+  Announce,
+  AnnounceCancel,
+  AnnounceError,
+  AnnounceOk,
+  ClientSetup,
+  DecodeErrorCode,
+  DecodeResult,
+  Fetch,
+  FetchCancel,
+  FetchError,
+  FetchOk,
+  FilterType,
+  GoAway,
+  GroupOrderValue,
+  MaxSubscribeId,
+  MoqtMessage,
+  MoqtMessageType,
+  ObjectDatagram,
+  ServerSetup,
+  StreamHeaderSubgroup,
+  Subscribe,
+  SubscribeAnnounces,
+  SubscribeAnnouncesError,
+  SubscribeAnnouncesOk,
+  SubscribeDone,
+  SubscribeError,
+  SubscribeOk,
+  SubscribeUpdate,
+  TrackStatus,
+  TrackStatusRequest,
+  Unannounce,
+  Unsubscribe,
+  UnsubscribeAnnounces,
+} from "../../core/types.js";
+export { DecodeError } from "../../core/types.js";
+export type { Draft07Codec } from "./codec.js";
+export {
+  createDraft07Codec,
+  decodeDatagram,
+  decodeFetchStream,
+  decodeSubgroupStream,
+  encodeDatagram,
+  encodeFetchStream,
+  encodeSubgroupStream,
+} from "./codec.js";
+export { MESSAGE_ID_TO_TYPE, MESSAGE_TYPE_IDS } from "./messages.js";
+export { decodeParameters, encodeParameters } from "./parameters.js";
+export {
+  CLIENT_ONLY_MESSAGES,
+  CONTROL_MESSAGES,
+  DATA_MESSAGES,
+  getLegalIncoming,
+  getLegalOutgoing,
+  SERVER_ONLY_MESSAGES,
+} from "./rules.js";
+export { decodeVarInt, encodeVarInt } from "./varint.js";
+export type {
+  DatagramObject as Draft07DatagramObject,
+  DataStreamEvent,
+  DataStreamHeader,
+  Draft07DataStream,
+  FetchObjectPayload,
+  FetchStream,
+  FetchStreamHeader,
+  ObjectPayload,
+  SubgroupStream,
+  SubgroupStreamHeader,
+} from "./types.js";
+
+import type { DecodeResult, MoqtMessage } from "../../core/types.js";
+import type { FetchStream, SubgroupStream } from "./types.js";
+import type { DatagramObject } from "./types.js";
+import { createDraft07Codec } from "./codec.js";
+
+const defaultCodec = createDraft07Codec();
+
+export function encodeMessage(message: MoqtMessage): Uint8Array {
+  return defaultCodec.encodeMessage(message);
+}
+
+export function decodeMessage(bytes: Uint8Array): DecodeResult<MoqtMessage> {
+  return defaultCodec.decodeMessage(bytes);
+}
+
+export function createStreamDecoder(): TransformStream<Uint8Array, MoqtMessage> {
+  return defaultCodec.createStreamDecoder();
+}

package/src/drafts/draft07/messages.ts

@@ -1,44 +1,42 @@
-// MoQT draft-ietf-moq-transport-07 message type IDs (wire format)
-export const 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
-} as const;
-
-// Reverse map: wire ID -> message type name
-export const MESSAGE_ID_TO_TYPE = new Map<bigint, string>();
-for (const [name, id] of Object.entries(MESSAGE_TYPE_IDS)) {
-  // For duplicate IDs, control stream messages take priority in the reverse map
-  if (!MESSAGE_ID_TO_TYPE.has(id) || name !== "stream_header_subgroup") {
-    MESSAGE_ID_TO_TYPE.set(id, name);
-  }
-}
+// MoQT draft-ietf-moq-transport-07 message type IDs (wire format)
+export const 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 (Section 7, Table 5)
+  object_datagram: 0x01n,
+  stream_header_subgroup: 0x04n, // Note: same ID as subscribe_ok but used on data streams, context disambiguates
+  fetch_header: 0x05n, // Note: same ID as subscribe_error but used on data streams, context disambiguates
+} as const;
+
+// Reverse map: wire ID -> message type name
+export const MESSAGE_ID_TO_TYPE = new Map<bigint, string>();
+for (const [name, id] of Object.entries(MESSAGE_TYPE_IDS)) {
+  // For duplicate IDs, control stream messages take priority in the reverse map
+  if (!MESSAGE_ID_TO_TYPE.has(id) || name !== "stream_header_subgroup") {
+    MESSAGE_ID_TO_TYPE.set(id, name);
+  }
+}