@moqtap/codec 0.2.3 → 0.4.0

package/src/core/buffer-writer.ts

@@ -1,100 +1,100 @@
-const textEncoder = /* @__PURE__ */ new TextEncoder();
-
-export class BufferWriter {
-  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;
-  }
-
-  get offset(): number {
-    return this.pos;
-  }
-
-  private ensureCapacity(needed: number): void {
-    const required = this.pos + needed;
-    if (required <= this.buffer.byteLength) return;
-
-    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);
-  }
-
-  writeUint8(value: number): void {
-    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;
-  }
-
-  writeVarInt(value: number | bigint): void {
-    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;
-    } else if (v < 0x4000n) {
-      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;
-    } else if (v < 0x4000000000000000n) {
-      this.ensureCapacity(8);
-      this.view.setBigUint64(this.pos, v | 0xc000000000000000n);
-      this.pos += 8;
-    } else {
-      throw new Error("VarInt value exceeds 62-bit range");
-    }
-  }
-
-  writeString(str: string): void {
-    const encoded = textEncoder.encode(str);
-    this.writeVarInt(encoded.byteLength);
-    this.writeBytes(encoded);
-  }
-
-  writeTuple(values: string[]): void {
-    this.writeVarInt(values.length);
-    for (const v of values) {
-      this.writeString(v);
-    }
-  }
-
-  writeParameters(params: Map<bigint, Uint8Array>): void {
-    this.writeVarInt(params.size);
-    for (const [key, value] of params) {
-      this.writeVarInt(key);
-      this.writeVarInt(value.byteLength);
-      this.writeBytes(value);
-    }
-  }
-
-  /** Returns an owned copy of the written bytes. */
-  finish(): Uint8Array {
-    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);
-  }
-}
+const textEncoder = /* @__PURE__ */ new TextEncoder()
+
+export class BufferWriter {
+  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
+  }
+
+  get offset(): number {
+    return this.pos
+  }
+
+  private ensureCapacity(needed: number): void {
+    const required = this.pos + needed
+    if (required <= this.buffer.byteLength) return
+
+    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)
+  }
+
+  writeUint8(value: number): void {
+    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
+  }
+
+  writeVarInt(value: number | bigint): void {
+    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
+    } else if (v < 0x4000n) {
+      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
+    } else if (v < 0x4000000000000000n) {
+      this.ensureCapacity(8)
+      this.view.setBigUint64(this.pos, v | 0xc000000000000000n)
+      this.pos += 8
+    } else {
+      throw new Error('VarInt value exceeds 62-bit range')
+    }
+  }
+
+  writeString(str: string): void {
+    const encoded = textEncoder.encode(str)
+    this.writeVarInt(encoded.byteLength)
+    this.writeBytes(encoded)
+  }
+
+  writeTuple(values: string[]): void {
+    this.writeVarInt(values.length)
+    for (const v of values) {
+      this.writeString(v)
+    }
+  }
+
+  writeParameters(params: Map<bigint, Uint8Array>): void {
+    this.writeVarInt(params.size)
+    for (const [key, value] of params) {
+      this.writeVarInt(key)
+      this.writeVarInt(value.byteLength)
+      this.writeBytes(value)
+    }
+  }
+
+  /** Returns an owned copy of the written bytes. */
+  finish(): Uint8Array {
+    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,21 +1,21 @@
-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;
-}
+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' }