@moqtap/codec 0.2.2 → 0.2.3

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

@@ -1,240 +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;
-  }
-}
+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.readBytesView(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.readBytesView(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.readBytesView(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/varint.ts

@@ -1,23 +1,51 @@
-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";
-
-export function encodeVarInt(value: number | bigint): Uint8Array {
-  const writer = new BufferWriter(8);
-  writer.writeVarInt(value);
-  return writer.finish();
-}
-
-export function decodeVarInt(bytes: Uint8Array, offset = 0): DecodeResult<bigint> {
-  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;
-  }
-}
+import { BufferReader } from "../../core/buffer-reader.js";
+import type { DecodeResult } from "../../core/types.js";
+import { DecodeError } from "../../core/types.js";
+
+export function encodeVarInt(value: number | bigint): Uint8Array {
+  const v = BigInt(value);
+  if (v < 0n) throw new Error("VarInt value must be non-negative");
+
+  if (v < 0x40n) {
+    const buf = new Uint8Array(1);
+    buf[0] = Number(v);
+    return buf;
+  }
+  if (v < 0x4000n) {
+    const buf = new Uint8Array(2);
+    const n = Number(v) | 0x4000;
+    buf[0] = n >> 8;
+    buf[1] = n & 0xff;
+    return buf;
+  }
+  if (v < 0x40000000n) {
+    const buf = new Uint8Array(4);
+    const n = Number(v) | 0x80000000;
+    buf[0] = (n >>> 24) & 0xff;
+    buf[1] = (n >>> 16) & 0xff;
+    buf[2] = (n >>> 8) & 0xff;
+    buf[3] = n & 0xff;
+    return buf;
+  }
+  if (v < 0x4000000000000000n) {
+    const buf = new Uint8Array(8);
+    const tagged = v | 0xc000000000000000n;
+    const view = new DataView(buf.buffer);
+    view.setBigUint64(0, tagged);
+    return buf;
+  }
+  throw new Error("VarInt value exceeds 62-bit range");
+}
+
+export function decodeVarInt(bytes: Uint8Array, offset = 0): DecodeResult<bigint> {
+  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;
+  }
+}

package/src/drafts/draft08/codec.ts

@@ -51,6 +51,10 @@ import type {
   SubgroupStream,
   UnknownParam,
 } from "./types.js";
+
+const textEncoder = /* @__PURE__ */ new TextEncoder();
+const textDecoder = /* @__PURE__ */ new TextDecoder();
+
 // ─── Setup Parameter Encoding/Decoding (all type+length+value) ──────────────
 
 function encodeSetupParams(params: Draft08SetupParams, w: BufferWriter): void {
@@ -63,7 +67,7 @@ function encodeSetupParams(params: Draft08SetupParams, w: BufferWriter): void {
 
   if (params.path !== undefined) {
     w.writeVarInt(SETUP_PARAM_PATH);
-    const encoded = new TextEncoder().encode(params.path);
+    const encoded = textEncoder.encode(params.path);
     w.writeVarInt(encoded.byteLength);
     w.writeBytes(encoded);
   }
@@ -97,7 +101,7 @@ function decodeSetupParams(r: BufferReader): Draft08SetupParams {
 
     if (paramType === SETUP_PARAM_PATH) {
       const bytes = r.readBytes(length);
-      result.path = new TextDecoder().decode(bytes);
+      result.path = textDecoder.decode(bytes);
     } else if (paramType === SETUP_PARAM_MAX_SUBSCRIBE_ID) {
       const blob = r.readBytes(length);
       const tmpReader = new BufferReader(blob);
@@ -123,7 +127,7 @@ function encodeParams(params: Draft08Params, w: BufferWriter): void {
 
   if (params.authorization_info !== undefined) {
     w.writeVarInt(PARAM_AUTHORIZATION_INFO);
-    const encoded = new TextEncoder().encode(params.authorization_info);
+    const encoded = textEncoder.encode(params.authorization_info);
     w.writeVarInt(encoded.byteLength);
     w.writeBytes(encoded);
   }
@@ -164,7 +168,7 @@ function decodeParams(r: BufferReader): Draft08Params {
 
     if (paramType === PARAM_AUTHORIZATION_INFO) {
       const bytes = r.readBytes(length);
-      result.authorization_info = new TextDecoder().decode(bytes);
+      result.authorization_info = textDecoder.decode(bytes);
     } else if (paramType === PARAM_DELIVERY_TIMEOUT) {
       const blob = r.readBytes(length);
       const tmpReader = new BufferReader(blob);
@@ -755,9 +759,9 @@ export function encodeMessage(message: Draft08Message): Uint8Array {
 
   const payloadWriter = new BufferWriter();
   encodePayload(message, payloadWriter);
-  const payload = payloadWriter.finish();
+  const payload = payloadWriter.finishView();
 
-  const writer = new BufferWriter();
+  const writer = new BufferWriter(payload.byteLength + 16);
   writer.writeVarInt(typeId);
   writer.writeVarInt(payload.byteLength);
   writer.writeBytes(payload);
@@ -882,25 +886,30 @@ import {
 
 export function createStreamDecoder(): TransformStream<Uint8Array, Draft08Message> {
   let buffer = new Uint8Array(0);
+  let offset = 0;
   return new TransformStream<Uint8Array, Draft08Message>({
     transform(chunk, controller) {
+      if (offset > 0) {
+        buffer = buffer.subarray(offset);
+        offset = 0;
+      }
       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);
+      while (offset < buffer.length) {
+        const result = decodeMessage(buffer.subarray(offset));
         if (!result.ok) {
           if (result.error.code === "UNEXPECTED_END") break;
           controller.error(result.error);
           return;
         }
         controller.enqueue(result.value);
-        buffer = buffer.slice(result.bytesRead);
+        offset += result.bytesRead;
       }
     },
     flush(controller) {
-      if (buffer.length > 0)
+      if (offset < buffer.length)
         controller.error(new DecodeError("UNEXPECTED_END", "Stream ended with incomplete data", 0));
     },
   });