@moqtap/codec 0.2.2 → 0.3.0

package/src/core/buffer-reader.ts

@@ -1,114 +1,130 @@
-import { DecodeError } from "./types.js";
+import { DecodeError } from './types.js'
+
+const textDecoder = /* @__PURE__ */ new TextDecoder()
 
 export class BufferReader {
-  private readonly view: DataView;
-  private pos: number;
+  private readonly view: DataView
+  private pos: number
 
   constructor(
     readonly buffer: Uint8Array,
     offset = 0,
   ) {
-    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-    this.pos = offset;
+    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength)
+    this.pos = offset
   }
 
   get offset(): number {
-    return this.pos;
+    return this.pos
   }
 
   get remaining(): number {
-    return this.buffer.byteLength - this.pos;
+    return this.buffer.byteLength - this.pos
   }
 
   readUint8(): number {
     if (this.remaining < 1) {
-      throw new DecodeError("UNEXPECTED_END", "Not enough bytes to read uint8", this.pos);
+      throw new DecodeError('UNEXPECTED_END', 'Not enough bytes to read uint8', this.pos)
     }
-    const value = this.view.getUint8(this.pos);
-    this.pos += 1;
-    return value;
+    const value = this.view.getUint8(this.pos)
+    this.pos += 1
+    return value
   }
 
   readBytes(length: number): Uint8Array<ArrayBuffer> {
     if (this.remaining < length) {
       throw new DecodeError(
-        "UNEXPECTED_END",
+        'UNEXPECTED_END',
+        `Not enough bytes: need ${length}, have ${this.remaining}`,
+        this.pos,
+      )
+    }
+    const slice = this.buffer.slice(this.pos, this.pos + length)
+    this.pos += length
+    return slice
+  }
+
+  /** Zero-copy read: returns a view into the underlying buffer. */
+  readBytesView(length: number): Uint8Array<ArrayBuffer> {
+    if (this.remaining < length) {
+      throw new DecodeError(
+        'UNEXPECTED_END',
         `Not enough bytes: need ${length}, have ${this.remaining}`,
         this.pos,
-      );
+      )
     }
-    const slice = this.buffer.slice(this.pos, this.pos + length);
-    this.pos += length;
-    return slice;
+    const view = this.buffer.subarray(this.pos, this.pos + length)
+    this.pos += length
+    return view as Uint8Array<ArrayBuffer>
   }
 
   readVarInt(): bigint {
     if (this.remaining < 1) {
-      throw new DecodeError("UNEXPECTED_END", "Not enough bytes for varint", this.pos);
+      throw new DecodeError('UNEXPECTED_END', 'Not enough bytes for varint', this.pos)
     }
-    const first = this.view.getUint8(this.pos);
-    const prefix = first >> 6;
-    let length: number;
-    let value: bigint;
+    const first = this.view.getUint8(this.pos)
+    const prefix = first >> 6
+    let length: number
+    let value: bigint
 
     switch (prefix) {
       case 0:
-        length = 1;
-        value = BigInt(first & 0x3f);
-        break;
+        length = 1
+        value = BigInt(first & 0x3f)
+        break
       case 1:
-        length = 2;
+        length = 2
         if (this.remaining < 2) {
-          throw new DecodeError("UNEXPECTED_END", "Not enough bytes for 2-byte varint", this.pos);
+          throw new DecodeError('UNEXPECTED_END', 'Not enough bytes for 2-byte varint', this.pos)
         }
-        value = BigInt(this.view.getUint16(this.pos) & 0x3fff);
-        break;
+        value = BigInt(this.view.getUint16(this.pos) & 0x3fff)
+        break
       case 2:
-        length = 4;
+        length = 4
         if (this.remaining < 4) {
-          throw new DecodeError("UNEXPECTED_END", "Not enough bytes for 4-byte varint", this.pos);
+          throw new DecodeError('UNEXPECTED_END', 'Not enough bytes for 4-byte varint', this.pos)
         }
-        value = BigInt(this.view.getUint32(this.pos)) & 0x3fffffffn;
-        break;
+        value = BigInt(this.view.getUint32(this.pos)) & 0x3fffffffn
+        break
       case 3:
-        length = 8;
+        length = 8
         if (this.remaining < 8) {
-          throw new DecodeError("UNEXPECTED_END", "Not enough bytes for 8-byte varint", this.pos);
+          throw new DecodeError('UNEXPECTED_END', 'Not enough bytes for 8-byte varint', this.pos)
         }
-        value = this.view.getBigUint64(this.pos) & 0x3fffffffffffffffn;
-        break;
+        value = this.view.getBigUint64(this.pos) & 0x3fffffffffffffffn
+        break
       default:
-        throw new DecodeError("INVALID_VARINT", "Invalid varint prefix", this.pos);
+        throw new DecodeError('INVALID_VARINT', 'Invalid varint prefix', this.pos)
     }
 
-    this.pos += length;
-    return value;
+    this.pos += length
+    return value
   }
 
   readString(): string {
-    const length = Number(this.readVarInt());
-    const bytes = this.readBytes(length);
-    return new TextDecoder().decode(bytes);
+    const length = Number(this.readVarInt())
+    const bytes = this.readBytesView(length)
+    return textDecoder.decode(bytes)
   }
 
   readTuple(): string[] {
-    const count = Number(this.readVarInt());
-    const result: string[] = [];
+    const count = Number(this.readVarInt())
+    const result: string[] = []
     for (let i = 0; i < count; i++) {
-      result.push(this.readString());
+      result.push(this.readString())
     }
-    return result;
+    return result
   }
 
   readParameters(): Map<bigint, Uint8Array> {
-    const count = Number(this.readVarInt());
-    const params = new Map<bigint, Uint8Array>();
+    const count = Number(this.readVarInt())
+    const params = new Map<bigint, Uint8Array>()
     for (let i = 0; i < count; i++) {
-      const key = this.readVarInt();
-      const length = Number(this.readVarInt());
-      const value = this.readBytes(length);
-      params.set(key, value);
+      const key = this.readVarInt()
+      const length = Number(this.readVarInt())
+      const value = this.readBytes(length)
+      params.set(key, value)
     }
-    return params;
+    return params
   }
 }

package/src/core/buffer-writer.ts

@@ -1,91 +1,100 @@
+const textEncoder = /* @__PURE__ */ new TextEncoder()
+
 export class BufferWriter {
-  private buffer: Uint8Array;
-  private view: DataView;
-  private pos: number;
+  private buffer: Uint8Array
+  private view: DataView
+  private pos: number
 
   constructor(initialSize = 256) {
-    this.buffer = new Uint8Array(initialSize);
-    this.view = new DataView(this.buffer.buffer);
-    this.pos = 0;
+    this.buffer = new Uint8Array(initialSize)
+    this.view = new DataView(this.buffer.buffer)
+    this.pos = 0
   }
 
   get offset(): number {
-    return this.pos;
+    return this.pos
   }
 
   private ensureCapacity(needed: number): void {
-    const required = this.pos + needed;
-    if (required <= this.buffer.byteLength) return;
+    const required = this.pos + needed
+    if (required <= this.buffer.byteLength) return
 
-    let newSize = this.buffer.byteLength * 2;
-    while (newSize < required) newSize *= 2;
+    let newSize = this.buffer.byteLength * 2
+    while (newSize < required) newSize *= 2
 
-    const newBuffer = new Uint8Array(newSize);
-    newBuffer.set(this.buffer);
-    this.buffer = newBuffer;
-    this.view = new DataView(this.buffer.buffer);
+    const newBuffer = new Uint8Array(newSize)
+    newBuffer.set(this.buffer)
+    this.buffer = newBuffer
+    this.view = new DataView(this.buffer.buffer)
   }
 
   writeUint8(value: number): void {
-    this.ensureCapacity(1);
-    this.view.setUint8(this.pos, value);
-    this.pos += 1;
+    this.ensureCapacity(1)
+    this.view.setUint8(this.pos, value)
+    this.pos += 1
   }
 
   writeBytes(bytes: Uint8Array): void {
-    this.ensureCapacity(bytes.byteLength);
-    this.buffer.set(bytes, this.pos);
-    this.pos += bytes.byteLength;
+    this.ensureCapacity(bytes.byteLength)
+    this.buffer.set(bytes, this.pos)
+    this.pos += bytes.byteLength
   }
 
   writeVarInt(value: number | bigint): void {
-    const v = BigInt(value);
-    if (v < 0n) throw new Error("VarInt value must be non-negative");
+    const v = BigInt(value)
+    if (v < 0n) throw new Error('VarInt value must be non-negative')
 
     if (v < 0x40n) {
-      this.ensureCapacity(1);
-      this.view.setUint8(this.pos, Number(v));
-      this.pos += 1;
+      this.ensureCapacity(1)
+      this.view.setUint8(this.pos, Number(v))
+      this.pos += 1
     } else if (v < 0x4000n) {
-      this.ensureCapacity(2);
-      this.view.setUint16(this.pos, Number(v) | 0x4000);
-      this.pos += 2;
+      this.ensureCapacity(2)
+      this.view.setUint16(this.pos, Number(v) | 0x4000)
+      this.pos += 2
     } else if (v < 0x40000000n) {
-      this.ensureCapacity(4);
-      this.view.setUint32(this.pos, Number(v) | 0x80000000);
-      this.pos += 4;
+      this.ensureCapacity(4)
+      this.view.setUint32(this.pos, Number(v) | 0x80000000)
+      this.pos += 4
     } else if (v < 0x4000000000000000n) {
-      this.ensureCapacity(8);
-      this.view.setBigUint64(this.pos, v | 0xc000000000000000n);
-      this.pos += 8;
+      this.ensureCapacity(8)
+      this.view.setBigUint64(this.pos, v | 0xc000000000000000n)
+      this.pos += 8
     } else {
-      throw new Error("VarInt value exceeds 62-bit range");
+      throw new Error('VarInt value exceeds 62-bit range')
     }
   }
 
   writeString(str: string): void {
-    const encoded = new TextEncoder().encode(str);
-    this.writeVarInt(encoded.byteLength);
-    this.writeBytes(encoded);
+    const encoded = textEncoder.encode(str)
+    this.writeVarInt(encoded.byteLength)
+    this.writeBytes(encoded)
   }
 
   writeTuple(values: string[]): void {
-    this.writeVarInt(values.length);
+    this.writeVarInt(values.length)
     for (const v of values) {
-      this.writeString(v);
+      this.writeString(v)
     }
   }
 
   writeParameters(params: Map<bigint, Uint8Array>): void {
-    this.writeVarInt(params.size);
+    this.writeVarInt(params.size)
     for (const [key, value] of params) {
-      this.writeVarInt(key);
-      this.writeVarInt(value.byteLength);
-      this.writeBytes(value);
+      this.writeVarInt(key)
+      this.writeVarInt(value.byteLength)
+      this.writeBytes(value)
     }
   }
 
+  /** Returns an owned copy of the written bytes. */
   finish(): Uint8Array {
-    return this.buffer.slice(0, this.pos);
+    if (this.pos === this.buffer.byteLength) return this.buffer
+    return this.buffer.slice(0, this.pos)
+  }
+
+  /** Returns a zero-copy view of the written bytes. Valid only until the next write. */
+  finishView(): Uint8Array {
+    return this.buffer.subarray(0, this.pos)
   }
 }

package/src/core/errors.ts

@@ -1 +1 @@
-export { DecodeError, type DecodeErrorCode } from "./types.js";
+export { DecodeError, type DecodeErrorCode } from './types.js'

package/src/core/hex.ts

@@ -1,17 +1,21 @@
-/** Convert a Uint8Array to a lowercase hex string. */
-export function bytesToHex(bytes: Uint8Array): string {
-  let hex = "";
-  for (let i = 0; i < bytes.byteLength; i++) {
-    hex += (bytes[i] as number).toString(16).padStart(2, "0");
-  }
-  return hex;
-}
-
-/** Convert a hex string to a Uint8Array. */
-export function hexToBytes(hex: string): Uint8Array {
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < hex.length; i += 2) {
-    bytes[i / 2] = Number.parseInt(hex.substring(i, i + 2), 16);
-  }
-  return bytes;
-}
+const HEX_TABLE = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) =>
+  i.toString(16).padStart(2, '0'),
+)
+
+/** Convert a Uint8Array to a lowercase hex string. */
+export function bytesToHex(bytes: Uint8Array): string {
+  const parts = new Array<string>(bytes.byteLength)
+  for (let i = 0; i < bytes.byteLength; i++) {
+    parts[i] = HEX_TABLE[bytes[i]!]!
+  }
+  return parts.join('')
+}
+
+/** Convert a hex string to a Uint8Array. */
+export function hexToBytes(hex: string): Uint8Array {
+  const bytes = new Uint8Array(hex.length / 2)
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = Number.parseInt(hex.substring(i, i + 2), 16)
+  }
+  return bytes
+}

package/src/core/session-types.ts

@@ -1,90 +1,92 @@
-import type { MoqtMessage, MoqtMessageType } from "./types.js";
+import type { Draft } from './types.js'
 
-export type SessionPhase = "idle" | "setup" | "ready" | "draining" | "closed" | "error";
+export type SessionPhase = 'idle' | 'setup' | 'ready' | 'draining' | 'closed' | 'error'
 
-export type SubscriptionPhase = "pending" | "active" | "error" | "done";
+export type SubscriptionPhase = 'pending' | 'active' | 'error' | 'done'
 
-export type AnnouncePhase = "pending" | "active" | "error";
+export type AnnouncePhase = 'pending' | 'active' | 'error'
 
-export type PublishPhase = "pending" | "active" | "error" | "done";
+export type PublishPhase = 'pending' | 'active' | 'error' | 'done'
 
-export type FetchPhase = "pending" | "active" | "error" | "cancelled";
+export type FetchPhase = 'pending' | 'active' | 'error' | 'cancelled'
 
 export interface SubscriptionState {
-  readonly subscribeId: bigint;
-  readonly phase: SubscriptionPhase;
-  readonly trackNamespace: string[];
-  readonly trackName: string;
+  readonly subscribeId: bigint
+  readonly phase: SubscriptionPhase
+  readonly trackNamespace: string[]
+  readonly trackName: string
 }
 
 export interface AnnounceState {
-  readonly namespace: string[];
-  readonly phase: AnnouncePhase;
+  readonly namespace: string[]
+  readonly phase: AnnouncePhase
 }
 
 export interface PublishState {
-  readonly requestId: bigint;
-  readonly phase: PublishPhase;
+  readonly requestId: bigint
+  readonly phase: PublishPhase
 }
 
 export interface FetchState {
-  readonly requestId: bigint;
-  readonly phase: FetchPhase;
+  readonly requestId: bigint
+  readonly phase: FetchPhase
 }
 
-export interface SessionStateOptions {
-  codec: { draft: string };
-  role: "client" | "server";
+export type SessionStateOptionsRole = 'client' | 'server'
+
+export interface SessionStateOptions<T extends Draft> {
+  codec: { draft: T }
+  role: SessionStateOptionsRole
 }
 
-export interface SessionState<M = MoqtMessage, T extends string = MoqtMessageType> {
-  readonly phase: SessionPhase;
-  readonly role: "client" | "server";
-  receive(message: M): TransitionResult<T>;
-  validateOutgoing(message: M): ValidationResult<T>;
-  send(message: M): TransitionResult<T>;
-  readonly subscriptions: ReadonlyMap<bigint, SubscriptionState>;
-  readonly announces: ReadonlyMap<string, AnnounceState>;
-  readonly legalOutgoing: ReadonlySet<T>;
-  readonly legalIncoming: ReadonlySet<T>;
-  reset(): void;
+export interface SessionState<M, T extends string> {
+  readonly phase: SessionPhase
+  readonly role: 'client' | 'server'
+  receive(message: M): TransitionResult<T>
+  validateOutgoing(message: M): ValidationResult<T>
+  send(message: M): TransitionResult<T>
+  readonly subscriptions: ReadonlyMap<bigint, SubscriptionState>
+  readonly announces: ReadonlyMap<string, AnnounceState>
+  readonly legalOutgoing: ReadonlySet<T>
+  readonly legalIncoming: ReadonlySet<T>
+  reset(): void
 }
 
-export type TransitionResult<T extends string = MoqtMessageType> =
+export type TransitionResult<T extends string> =
   | { ok: true; phase: SessionPhase; sideEffects: SideEffect[] }
-  | { ok: false; violation: ProtocolViolation<T> };
+  | { ok: false; violation: ProtocolViolation<T> }
 
-export type ValidationResult<T extends string = MoqtMessageType> =
+export type ValidationResult<T extends string> =
   | { ok: true }
-  | { ok: false; violation: ProtocolViolation<T> };
+  | { ok: false; violation: ProtocolViolation<T> }
 
-export interface ProtocolViolation<T extends string = MoqtMessageType> {
-  readonly code: ProtocolViolationCode;
-  readonly message: string;
-  readonly currentPhase: SessionPhase;
-  readonly offendingMessage: T;
+export interface ProtocolViolation<T extends string> {
+  readonly code: ProtocolViolationCode
+  readonly message: string
+  readonly currentPhase: SessionPhase
+  readonly offendingMessage: T
 }
 
 export type ProtocolViolationCode =
-  | "MESSAGE_BEFORE_SETUP"
-  | "UNEXPECTED_MESSAGE"
-  | "DUPLICATE_SUBSCRIBE_ID"
-  | "UNKNOWN_SUBSCRIBE_ID"
-  | "DUPLICATE_REQUEST_ID"
-  | "UNKNOWN_REQUEST_ID"
-  | "ROLE_VIOLATION"
-  | "STATE_VIOLATION"
-  | "SETUP_VIOLATION";
+  | 'MESSAGE_BEFORE_SETUP'
+  | 'UNEXPECTED_MESSAGE'
+  | 'DUPLICATE_SUBSCRIBE_ID'
+  | 'UNKNOWN_SUBSCRIBE_ID'
+  | 'DUPLICATE_REQUEST_ID'
+  | 'UNKNOWN_REQUEST_ID'
+  | 'ROLE_VIOLATION'
+  | 'STATE_VIOLATION'
+  | 'SETUP_VIOLATION'
 
 export type SideEffect =
-  | { type: "subscription-activated"; subscribeId: bigint }
-  | { type: "subscription-ended"; subscribeId: bigint; reason: string }
-  | { type: "announce-activated"; namespace: string[] }
-  | { type: "announce-ended"; namespace: string[] }
-  | { type: "publish-activated"; requestId: bigint }
-  | { type: "publish-ended"; requestId: bigint; reason: string }
-  | { type: "fetch-activated"; requestId: bigint }
-  | { type: "fetch-ended"; requestId: bigint; reason: string }
-  | { type: "session-ready" }
-  | { type: "session-draining"; goAwayUri: string }
-  | { type: "session-closed" };
+  | { type: 'subscription-activated'; subscribeId: bigint }
+  | { type: 'subscription-ended'; subscribeId: bigint; reason: string }
+  | { type: 'announce-activated'; namespace: string[] }
+  | { type: 'announce-ended'; namespace: string[] }
+  | { type: 'publish-activated'; requestId: bigint }
+  | { type: 'publish-ended'; requestId: bigint; reason: string }
+  | { type: 'fetch-activated'; requestId: bigint }
+  | { type: 'fetch-ended'; requestId: bigint; reason: string }
+  | { type: 'session-ready' }
+  | { type: 'session-draining'; goAwayUri: string }
+  | { type: 'session-closed' }