@moqtap/codec 0.1.0

package/dist/chunk-2NARXGVA.cjs

@@ -0,0 +1,194 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/core/types.ts
+var DecodeError = class extends Error {
+  
+  
+  constructor(code, message, offset) {
+    super(message);
+    this.name = "DecodeError";
+    this.code = code;
+    this.offset = offset;
+  }
+};
+
+// src/core/buffer-reader.ts
+var BufferReader = class {
+  constructor(buffer, offset = 0) {
+    this.buffer = buffer;
+    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    this.pos = offset;
+  }
+  
+  
+  get offset() {
+    return this.pos;
+  }
+  get remaining() {
+    return this.buffer.byteLength - this.pos;
+  }
+  readUint8() {
+    if (this.remaining < 1) {
+      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;
+  }
+  readBytes(length) {
+    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;
+  }
+  readVarInt() {
+    if (this.remaining < 1) {
+      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;
+    let value;
+    switch (prefix) {
+      case 0:
+        length = 1;
+        value = BigInt(first & 63);
+        break;
+      case 1:
+        length = 2;
+        if (this.remaining < 2) {
+          throw new DecodeError("UNEXPECTED_END", "Not enough bytes for 2-byte varint", this.pos);
+        }
+        value = BigInt(this.view.getUint16(this.pos) & 16383);
+        break;
+      case 2:
+        length = 4;
+        if (this.remaining < 4) {
+          throw new DecodeError("UNEXPECTED_END", "Not enough bytes for 4-byte varint", this.pos);
+        }
+        value = BigInt(this.view.getUint32(this.pos)) & 0x3fffffffn;
+        break;
+      case 3:
+        length = 8;
+        if (this.remaining < 8) {
+          throw new DecodeError("UNEXPECTED_END", "Not enough bytes for 8-byte varint", this.pos);
+        }
+        value = this.view.getBigUint64(this.pos) & 0x3fffffffffffffffn;
+        break;
+      default:
+        throw new DecodeError("INVALID_VARINT", "Invalid varint prefix", this.pos);
+    }
+    this.pos += length;
+    return value;
+  }
+  readString() {
+    const length = Number(this.readVarInt());
+    const bytes = this.readBytes(length);
+    return new TextDecoder().decode(bytes);
+  }
+  readTuple() {
+    const count = Number(this.readVarInt());
+    const result = [];
+    for (let i = 0; i < count; i++) {
+      result.push(this.readString());
+    }
+    return result;
+  }
+  readParameters() {
+    const count = Number(this.readVarInt());
+    const params = /* @__PURE__ */ new Map();
+    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);
+    }
+    return params;
+  }
+};
+
+// src/core/buffer-writer.ts
+var BufferWriter = class {
+  
+  
+  
+  constructor(initialSize = 256) {
+    this.buffer = new Uint8Array(initialSize);
+    this.view = new DataView(this.buffer.buffer);
+    this.pos = 0;
+  }
+  get offset() {
+    return this.pos;
+  }
+  ensureCapacity(needed) {
+    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) {
+    this.ensureCapacity(1);
+    this.view.setUint8(this.pos, value);
+    this.pos += 1;
+  }
+  writeBytes(bytes) {
+    this.ensureCapacity(bytes.byteLength);
+    this.buffer.set(bytes, this.pos);
+    this.pos += bytes.byteLength;
+  }
+  writeVarInt(value) {
+    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) | 16384);
+      this.pos += 2;
+    } else if (v < 0x40000000n) {
+      this.ensureCapacity(4);
+      this.view.setUint32(this.pos, Number(v) | 2147483648);
+      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) {
+    const encoded = new TextEncoder().encode(str);
+    this.writeVarInt(encoded.byteLength);
+    this.writeBytes(encoded);
+  }
+  writeTuple(values) {
+    this.writeVarInt(values.length);
+    for (const v of values) {
+      this.writeString(v);
+    }
+  }
+  writeParameters(params) {
+    this.writeVarInt(params.size);
+    for (const [key, value] of params) {
+      this.writeVarInt(key);
+      this.writeVarInt(value.byteLength);
+      this.writeBytes(value);
+    }
+  }
+  finish() {
+    return this.buffer.slice(0, this.pos);
+  }
+};
+
+
+
+
+
+exports.DecodeError = DecodeError; exports.BufferReader = BufferReader; exports.BufferWriter = BufferWriter;

package/dist/chunk-3BSZ55L3.cjs

@@ -0,0 +1,307 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;
+
+
+
+
+var _chunkQYG6KGOVcjs = require('./chunk-QYG6KGOV.cjs');
+
+// src/drafts/draft07/session-fsm.ts
+function violation(code, message, currentPhase, offendingMessage) {
+  return { code, message, currentPhase, offendingMessage };
+}
+var SessionFSM = (_class = class {
+  __init() {this._phase = "idle"}
+  
+  __init2() {this._subscriptions = /* @__PURE__ */ new Map()}
+  __init3() {this._announces = /* @__PURE__ */ new Map()}
+  constructor(role) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);
+    this._role = role;
+  }
+  get phase() {
+    return this._phase;
+  }
+  get role() {
+    return this._role;
+  }
+  get subscriptions() {
+    return this._subscriptions;
+  }
+  get announces() {
+    return this._announces;
+  }
+  get legalOutgoing() {
+    return _chunkQYG6KGOVcjs.getLegalOutgoing.call(void 0, this._phase, this._role);
+  }
+  get legalIncoming() {
+    return _chunkQYG6KGOVcjs.getLegalIncoming.call(void 0, this._phase, this._role);
+  }
+  // Validate role constraints
+  checkRole(message, direction) {
+    const senderRole = direction === "outbound" ? this._role : this._role === "client" ? "server" : "client";
+    if (_chunkQYG6KGOVcjs.CLIENT_ONLY_MESSAGES.has(message.type) && senderRole !== "client") {
+      return violation("ROLE_VIOLATION", `${message.type} can only be sent by client`, this._phase, message.type);
+    }
+    if (_chunkQYG6KGOVcjs.SERVER_ONLY_MESSAGES.has(message.type) && senderRole !== "server") {
+      return violation("ROLE_VIOLATION", `${message.type} can only be sent by server`, this._phase, message.type);
+    }
+    return null;
+  }
+  validateOutgoing(message) {
+    const roleViolation = this.checkRole(message, "outbound");
+    if (roleViolation) return { ok: false, violation: roleViolation };
+    if (!this.legalOutgoing.has(message.type)) {
+      return {
+        ok: false,
+        violation: violation(
+          this._phase === "idle" || this._phase === "setup" ? "MESSAGE_BEFORE_SETUP" : "UNEXPECTED_MESSAGE",
+          `Cannot send ${message.type} in phase ${this._phase}`,
+          this._phase,
+          message.type
+        )
+      };
+    }
+    return { ok: true };
+  }
+  receive(message) {
+    const roleViolation = this.checkRole(message, "inbound");
+    if (roleViolation) return { ok: false, violation: roleViolation };
+    return this.applyTransition(message, "inbound");
+  }
+  send(message) {
+    const roleViolation = this.checkRole(message, "outbound");
+    if (roleViolation) return { ok: false, violation: roleViolation };
+    return this.applyTransition(message, "outbound");
+  }
+  applyTransition(message, direction) {
+    const sideEffects = [];
+    switch (message.type) {
+      case "client_setup":
+        return this.handleClientSetup(message, direction);
+      case "server_setup":
+        return this.handleServerSetup(message, direction);
+      case "goaway":
+        return this.handleGoAway(message, direction, sideEffects);
+      // Subscription lifecycle
+      case "subscribe":
+        return this.handleSubscribe(message, direction, sideEffects);
+      case "subscribe_ok":
+        return this.handleSubscribeOk(message, direction, sideEffects);
+      case "subscribe_error":
+        return this.handleSubscribeError(message, direction, sideEffects);
+      case "subscribe_done":
+        return this.handleSubscribeDone(message, direction, sideEffects);
+      case "unsubscribe":
+        return this.handleUnsubscribe(message, direction, sideEffects);
+      // Announce lifecycle
+      case "announce":
+        return this.handleAnnounce(message, direction, sideEffects);
+      case "announce_ok":
+        return this.handleAnnounceOk(message, direction, sideEffects);
+      case "announce_error":
+        return this.handleAnnounceError(message, direction, sideEffects);
+      case "announce_cancel":
+        return this.handleAnnounceCancel(message, direction, sideEffects);
+      case "unannounce":
+        return this.handleUnannounce(message, direction, sideEffects);
+      // Fetch lifecycle
+      case "fetch":
+      case "fetch_ok":
+      case "fetch_error":
+      case "fetch_cancel":
+        return this.handleReadyPhaseMessage(message);
+      // Other ready-phase messages
+      default:
+        return this.handleReadyPhaseMessage(message);
+    }
+  }
+  handleClientSetup(_message, direction) {
+    if (this._phase !== "idle") {
+      return { ok: false, violation: violation("SETUP_VIOLATION", "CLIENT_SETUP already sent/received", this._phase, "client_setup") };
+    }
+    if (direction === "outbound" && this._role !== "client") {
+      return { ok: false, violation: violation("ROLE_VIOLATION", "Only client can send CLIENT_SETUP", this._phase, "client_setup") };
+    }
+    this._phase = "setup";
+    return { ok: true, phase: this._phase, sideEffects: [] };
+  }
+  handleServerSetup(_message, direction) {
+    if (this._phase !== "setup") {
+      return { ok: false, violation: violation("SETUP_VIOLATION", "SERVER_SETUP before CLIENT_SETUP", this._phase, "server_setup") };
+    }
+    if (direction === "outbound" && this._role !== "server") {
+      return { ok: false, violation: violation("ROLE_VIOLATION", "Only server can send SERVER_SETUP", this._phase, "server_setup") };
+    }
+    this._phase = "ready";
+    return { ok: true, phase: this._phase, sideEffects: [{ type: "session-ready" }] };
+  }
+  handleGoAway(message, _direction, sideEffects) {
+    if (this._phase !== "ready" && this._phase !== "draining") {
+      return { ok: false, violation: violation("UNEXPECTED_MESSAGE", `GOAWAY not valid in phase ${this._phase}`, this._phase, "goaway") };
+    }
+    this._phase = "draining";
+    const goaway = message;
+    sideEffects.push({ type: "session-draining", goAwayUri: goaway.newSessionUri });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  requireReady(msgType) {
+    if (this._phase !== "ready" && this._phase !== "draining") {
+      return violation(
+        this._phase === "idle" || this._phase === "setup" ? "MESSAGE_BEFORE_SETUP" : "UNEXPECTED_MESSAGE",
+        `${msgType} requires ready phase, current: ${this._phase}`,
+        this._phase,
+        msgType
+      );
+    }
+    return null;
+  }
+  handleSubscribe(message, _direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const sub = message;
+    if (this._subscriptions.has(sub.subscribeId)) {
+      return { ok: false, violation: violation("DUPLICATE_SUBSCRIBE_ID", `Subscribe ID ${sub.subscribeId} already exists`, this._phase, message.type) };
+    }
+    this._subscriptions.set(sub.subscribeId, {
+      subscribeId: sub.subscribeId,
+      phase: "pending",
+      trackNamespace: sub.trackNamespace,
+      trackName: sub.trackName
+    });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleSubscribeOk(message, _direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const ok = message;
+    const existing = this._subscriptions.get(ok.subscribeId);
+    if (!existing) {
+      return { ok: false, violation: violation("UNKNOWN_SUBSCRIBE_ID", `No subscription with ID ${ok.subscribeId}`, this._phase, message.type) };
+    }
+    if (existing.phase !== "pending") {
+      return { ok: false, violation: violation("STATE_VIOLATION", `Subscription ${ok.subscribeId} is ${existing.phase}, not pending`, this._phase, message.type) };
+    }
+    this._subscriptions.set(ok.subscribeId, { ...existing, phase: "active" });
+    sideEffects.push({ type: "subscription-activated", subscribeId: ok.subscribeId });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleSubscribeError(message, _direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const subErr = message;
+    const existing = this._subscriptions.get(subErr.subscribeId);
+    if (!existing) {
+      return { ok: false, violation: violation("UNKNOWN_SUBSCRIBE_ID", `No subscription with ID ${subErr.subscribeId}`, this._phase, message.type) };
+    }
+    if (existing.phase !== "pending") {
+      return { ok: false, violation: violation("STATE_VIOLATION", `Subscription ${subErr.subscribeId} is ${existing.phase}, not pending`, this._phase, message.type) };
+    }
+    this._subscriptions.set(subErr.subscribeId, { ...existing, phase: "error" });
+    sideEffects.push({ type: "subscription-ended", subscribeId: subErr.subscribeId, reason: subErr.reasonPhrase });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleSubscribeDone(message, _direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const done = message;
+    const existing = this._subscriptions.get(done.subscribeId);
+    if (!existing) {
+      return { ok: false, violation: violation("UNKNOWN_SUBSCRIBE_ID", `No subscription with ID ${done.subscribeId}`, this._phase, message.type) };
+    }
+    this._subscriptions.set(done.subscribeId, { ...existing, phase: "done" });
+    sideEffects.push({ type: "subscription-ended", subscribeId: done.subscribeId, reason: done.reasonPhrase });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleUnsubscribe(message, _direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const unsub = message;
+    const existing = this._subscriptions.get(unsub.subscribeId);
+    if (!existing) {
+      return { ok: false, violation: violation("UNKNOWN_SUBSCRIBE_ID", `No subscription with ID ${unsub.subscribeId}`, this._phase, message.type) };
+    }
+    this._subscriptions.set(unsub.subscribeId, { ...existing, phase: "done" });
+    sideEffects.push({ type: "subscription-ended", subscribeId: unsub.subscribeId, reason: "unsubscribed" });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  // Announce handlers
+  namespaceKey(ns) {
+    return ns.join("/");
+  }
+  handleAnnounce(message, _direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const ann = message;
+    const key = this.namespaceKey(ann.trackNamespace);
+    this._announces.set(key, { namespace: ann.trackNamespace, phase: "pending" });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleAnnounceOk(message, _direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const ok = message;
+    const key = this.namespaceKey(ok.trackNamespace);
+    const existing = this._announces.get(key);
+    if (!existing) {
+      return { ok: false, violation: violation("UNEXPECTED_MESSAGE", `No announce for namespace ${key}`, this._phase, message.type) };
+    }
+    this._announces.set(key, { ...existing, phase: "active" });
+    sideEffects.push({ type: "announce-activated", namespace: ok.trackNamespace });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleAnnounceError(message, _direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const annErr = message;
+    const key = this.namespaceKey(annErr.trackNamespace);
+    const existing = this._announces.get(key);
+    if (!existing) {
+      return { ok: false, violation: violation("UNEXPECTED_MESSAGE", `No announce for namespace ${key}`, this._phase, message.type) };
+    }
+    this._announces.set(key, { ...existing, phase: "error" });
+    sideEffects.push({ type: "announce-ended", namespace: annErr.trackNamespace });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleAnnounceCancel(message, _direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const cancel = message;
+    const key = this.namespaceKey(cancel.trackNamespace);
+    const existing = this._announces.get(key);
+    if (existing) {
+      this._announces.delete(key);
+      sideEffects.push({ type: "announce-ended", namespace: cancel.trackNamespace });
+    }
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleUnannounce(message, _direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const unann = message;
+    const key = this.namespaceKey(unann.trackNamespace);
+    const existing = this._announces.get(key);
+    if (existing) {
+      this._announces.delete(key);
+      sideEffects.push({ type: "announce-ended", namespace: unann.trackNamespace });
+    }
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleReadyPhaseMessage(message) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    return { ok: true, phase: this._phase, sideEffects: [] };
+  }
+  reset() {
+    this._phase = "idle";
+    this._subscriptions.clear();
+    this._announces.clear();
+  }
+}, _class);
+
+// src/drafts/draft07/session.ts
+function createDraft07SessionState(options) {
+  return new SessionFSM(options.role);
+}
+
+
+
+exports.createDraft07SessionState = createDraft07SessionState;