@moqtap/codec 0.1.0

package/dist/chunk-GDRGWFEK.cjs

@@ -0,0 +1,498 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;// src/drafts/draft14/rules.ts
+var CONTROL_MESSAGES = /* @__PURE__ */ new Set([
+  "client_setup",
+  "server_setup",
+  "subscribe",
+  "subscribe_ok",
+  "subscribe_update",
+  "subscribe_error",
+  "unsubscribe",
+  "publish",
+  "publish_ok",
+  "publish_error",
+  "publish_done",
+  "publish_namespace",
+  "publish_namespace_ok",
+  "publish_namespace_error",
+  "publish_namespace_done",
+  "publish_namespace_cancel",
+  "subscribe_namespace",
+  "subscribe_namespace_ok",
+  "subscribe_namespace_error",
+  "unsubscribe_namespace",
+  "fetch",
+  "fetch_ok",
+  "fetch_error",
+  "fetch_cancel",
+  "track_status",
+  "track_status_ok",
+  "track_status_error",
+  "goaway",
+  "max_request_id",
+  "requests_blocked"
+]);
+var CLIENT_ONLY_MESSAGES = /* @__PURE__ */ new Set([
+  "client_setup"
+]);
+var SERVER_ONLY_MESSAGES = /* @__PURE__ */ new Set([
+  "server_setup"
+]);
+var BIDIRECTIONAL_MESSAGES = /* @__PURE__ */ new Set([
+  "subscribe",
+  "subscribe_ok",
+  "subscribe_update",
+  "subscribe_error",
+  "unsubscribe",
+  "publish",
+  "publish_ok",
+  "publish_error",
+  "publish_done",
+  "publish_namespace",
+  "publish_namespace_ok",
+  "publish_namespace_error",
+  "publish_namespace_done",
+  "publish_namespace_cancel",
+  "subscribe_namespace",
+  "subscribe_namespace_ok",
+  "subscribe_namespace_error",
+  "unsubscribe_namespace",
+  "fetch",
+  "fetch_ok",
+  "fetch_error",
+  "fetch_cancel",
+  "track_status",
+  "track_status_ok",
+  "track_status_error",
+  "goaway",
+  "max_request_id",
+  "requests_blocked"
+]);
+function getLegalOutgoing(phase, role) {
+  const legal = /* @__PURE__ */ new Set();
+  switch (phase) {
+    case "idle":
+      if (role === "client") legal.add("client_setup");
+      break;
+    case "setup":
+      if (role === "server") legal.add("server_setup");
+      break;
+    case "ready": {
+      legal.add("goaway");
+      for (const msg of BIDIRECTIONAL_MESSAGES) {
+        legal.add(msg);
+      }
+      break;
+    }
+    case "draining":
+      break;
+  }
+  return legal;
+}
+function getLegalIncoming(phase, role) {
+  const remoteRole = role === "client" ? "server" : "client";
+  return getLegalOutgoing(phase, remoteRole);
+}
+
+// src/drafts/draft14/session-fsm.ts
+function violation(code, message, currentPhase, offendingMessage) {
+  return { code, message, currentPhase, offendingMessage };
+}
+var Draft14SessionFSM = (_class = class {
+  __init() {this._phase = "idle"}
+  
+  __init2() {this._subscriptions = /* @__PURE__ */ new Map()}
+  __init3() {this._publishes = /* @__PURE__ */ new Map()}
+  __init4() {this._fetches = /* @__PURE__ */ new Map()}
+  __init5() {this._requestIds = /* @__PURE__ */ new Set()}
+  constructor(role) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);
+    this._role = role;
+  }
+  get phase() {
+    return this._phase;
+  }
+  get role() {
+    return this._role;
+  }
+  get subscriptions() {
+    return this._subscriptions;
+  }
+  get announces() {
+    return /* @__PURE__ */ new Map();
+  }
+  get publishes() {
+    return this._publishes;
+  }
+  get fetches() {
+    return this._fetches;
+  }
+  get legalOutgoing() {
+    return getLegalOutgoing(this._phase, this._role);
+  }
+  get legalIncoming() {
+    return getLegalIncoming(this._phase, this._role);
+  }
+  // Validate role constraints
+  checkRole(message, direction) {
+    const senderRole = direction === "outbound" ? this._role : this._role === "client" ? "server" : "client";
+    if (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 (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;
+  }
+  checkDuplicateRequestId(requestId, msgType) {
+    if (this._requestIds.has(requestId)) {
+      return violation("DUPLICATE_REQUEST_ID", `Request ID ${requestId} already in use`, this._phase, msgType);
+    }
+    return null;
+  }
+  checkKnownRequestId(requestId, msgType) {
+    if (!this._requestIds.has(requestId)) {
+      return violation("UNKNOWN_REQUEST_ID", `No request with ID ${requestId}`, this._phase, msgType);
+    }
+    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);
+      // Subscribe 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_update":
+        return this.handleSubscribeUpdate(message, direction, sideEffects);
+      case "unsubscribe":
+        return this.handleUnsubscribe(message, direction, sideEffects);
+      // Publish lifecycle
+      case "publish":
+        return this.handlePublish(message, direction, sideEffects);
+      case "publish_ok":
+        return this.handlePublishOk(message, direction, sideEffects);
+      case "publish_error":
+        return this.handlePublishError(message, direction, sideEffects);
+      case "publish_done":
+        return this.handlePublishDone(message, direction, sideEffects);
+      // Fetch lifecycle
+      case "fetch":
+        return this.handleFetch(message, direction, sideEffects);
+      case "fetch_ok":
+        return this.handleFetchOk(message, direction, sideEffects);
+      case "fetch_error":
+        return this.handleFetchError(message, direction, sideEffects);
+      case "fetch_cancel":
+        return this.handleFetchCancel(message, direction, sideEffects);
+      // Publish namespace, subscribe namespace, track status, and 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.new_session_uri });
+    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;
+  }
+  // ─── Subscribe lifecycle ──────────────────────────────────────────────────────
+  handleSubscribe(message, _direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const sub = message;
+    const dupErr = this.checkDuplicateRequestId(sub.request_id, message.type);
+    if (dupErr) return { ok: false, violation: dupErr };
+    this._requestIds.add(sub.request_id);
+    this._subscriptions.set(sub.request_id, {
+      subscribeId: sub.request_id,
+      phase: "pending",
+      trackNamespace: sub.track_namespace,
+      trackName: sub.track_name
+    });
+    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 idErr = this.checkKnownRequestId(ok.request_id, message.type);
+    if (idErr) return { ok: false, violation: idErr };
+    const existing = this._subscriptions.get(ok.request_id);
+    if (!existing) {
+      return { ok: false, violation: violation("UNKNOWN_REQUEST_ID", `No subscription with request ID ${ok.request_id}`, this._phase, message.type) };
+    }
+    if (existing.phase !== "pending") {
+      return { ok: false, violation: violation("STATE_VIOLATION", `Subscription ${ok.request_id} is ${existing.phase}, not pending`, this._phase, message.type) };
+    }
+    this._subscriptions.set(ok.request_id, { ...existing, phase: "active" });
+    sideEffects.push({ type: "subscription-activated", subscribeId: ok.request_id });
+    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 idErr = this.checkKnownRequestId(subErr.request_id, message.type);
+    if (idErr) return { ok: false, violation: idErr };
+    const existing = this._subscriptions.get(subErr.request_id);
+    if (!existing) {
+      return { ok: false, violation: violation("UNKNOWN_REQUEST_ID", `No subscription with request ID ${subErr.request_id}`, this._phase, message.type) };
+    }
+    if (existing.phase !== "pending") {
+      return { ok: false, violation: violation("STATE_VIOLATION", `Subscription ${subErr.request_id} is ${existing.phase}, not pending`, this._phase, message.type) };
+    }
+    this._subscriptions.set(subErr.request_id, { ...existing, phase: "error" });
+    sideEffects.push({ type: "subscription-ended", subscribeId: subErr.request_id, reason: subErr.reason_phrase });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleSubscribeUpdate(message, _direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const update = message;
+    const idErr = this.checkKnownRequestId(update.request_id, message.type);
+    if (idErr) return { ok: false, violation: idErr };
+    const existing = this._subscriptions.get(update.request_id);
+    if (!existing) {
+      return { ok: false, violation: violation("UNKNOWN_REQUEST_ID", `No subscription with request ID ${update.request_id}`, this._phase, message.type) };
+    }
+    if (existing.phase !== "active") {
+      return { ok: false, violation: violation("STATE_VIOLATION", `Subscription ${update.request_id} is ${existing.phase}, not active`, this._phase, message.type) };
+    }
+    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 idErr = this.checkKnownRequestId(unsub.request_id, message.type);
+    if (idErr) return { ok: false, violation: idErr };
+    const existing = this._subscriptions.get(unsub.request_id);
+    if (!existing) {
+      return { ok: false, violation: violation("UNKNOWN_REQUEST_ID", `No subscription with request ID ${unsub.request_id}`, this._phase, message.type) };
+    }
+    this._subscriptions.set(unsub.request_id, { ...existing, phase: "done" });
+    sideEffects.push({ type: "subscription-ended", subscribeId: unsub.request_id, reason: "unsubscribed" });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  // ─── Publish lifecycle ────────────────────────────────────────────────────────
+  handlePublish(message, _direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const pub = message;
+    const dupErr = this.checkDuplicateRequestId(pub.request_id, message.type);
+    if (dupErr) return { ok: false, violation: dupErr };
+    this._requestIds.add(pub.request_id);
+    this._publishes.set(pub.request_id, {
+      requestId: pub.request_id,
+      phase: "pending"
+    });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handlePublishOk(message, _direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const ok = message;
+    const idErr = this.checkKnownRequestId(ok.request_id, message.type);
+    if (idErr) return { ok: false, violation: idErr };
+    const existing = this._publishes.get(ok.request_id);
+    if (!existing) {
+      return { ok: false, violation: violation("UNKNOWN_REQUEST_ID", `No publish with request ID ${ok.request_id}`, this._phase, message.type) };
+    }
+    if (existing.phase !== "pending") {
+      return { ok: false, violation: violation("STATE_VIOLATION", `Publish ${ok.request_id} is ${existing.phase}, not pending`, this._phase, message.type) };
+    }
+    this._publishes.set(ok.request_id, { ...existing, phase: "active" });
+    sideEffects.push({ type: "publish-activated", requestId: ok.request_id });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handlePublishError(message, _direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const pubErr = message;
+    const idErr = this.checkKnownRequestId(pubErr.request_id, message.type);
+    if (idErr) return { ok: false, violation: idErr };
+    const existing = this._publishes.get(pubErr.request_id);
+    if (!existing) {
+      return { ok: false, violation: violation("UNKNOWN_REQUEST_ID", `No publish with request ID ${pubErr.request_id}`, this._phase, message.type) };
+    }
+    if (existing.phase !== "pending") {
+      return { ok: false, violation: violation("STATE_VIOLATION", `Publish ${pubErr.request_id} is ${existing.phase}, not pending`, this._phase, message.type) };
+    }
+    this._publishes.set(pubErr.request_id, { ...existing, phase: "error" });
+    sideEffects.push({ type: "publish-ended", requestId: pubErr.request_id, reason: pubErr.reason_phrase });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handlePublishDone(message, _direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const done = message;
+    const idErr = this.checkKnownRequestId(done.request_id, message.type);
+    if (idErr) return { ok: false, violation: idErr };
+    const existing = this._publishes.get(done.request_id);
+    if (!existing) {
+      return { ok: false, violation: violation("UNKNOWN_REQUEST_ID", `No publish with request ID ${done.request_id}`, this._phase, message.type) };
+    }
+    this._publishes.set(done.request_id, { ...existing, phase: "done" });
+    sideEffects.push({ type: "publish-ended", requestId: done.request_id, reason: done.reason_phrase });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  // ─── Fetch lifecycle ──────────────────────────────────────────────────────────
+  handleFetch(message, _direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const fetch = message;
+    const dupErr = this.checkDuplicateRequestId(fetch.request_id, message.type);
+    if (dupErr) return { ok: false, violation: dupErr };
+    this._requestIds.add(fetch.request_id);
+    this._fetches.set(fetch.request_id, {
+      requestId: fetch.request_id,
+      phase: "pending"
+    });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleFetchOk(message, _direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const ok = message;
+    const idErr = this.checkKnownRequestId(ok.request_id, message.type);
+    if (idErr) return { ok: false, violation: idErr };
+    const existing = this._fetches.get(ok.request_id);
+    if (!existing) {
+      return { ok: false, violation: violation("UNKNOWN_REQUEST_ID", `No fetch with request ID ${ok.request_id}`, this._phase, message.type) };
+    }
+    if (existing.phase !== "pending") {
+      return { ok: false, violation: violation("STATE_VIOLATION", `Fetch ${ok.request_id} is ${existing.phase}, not pending`, this._phase, message.type) };
+    }
+    this._fetches.set(ok.request_id, { ...existing, phase: "active" });
+    sideEffects.push({ type: "fetch-activated", requestId: ok.request_id });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleFetchError(message, _direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const fetchErr = message;
+    const idErr = this.checkKnownRequestId(fetchErr.request_id, message.type);
+    if (idErr) return { ok: false, violation: idErr };
+    const existing = this._fetches.get(fetchErr.request_id);
+    if (!existing) {
+      return { ok: false, violation: violation("UNKNOWN_REQUEST_ID", `No fetch with request ID ${fetchErr.request_id}`, this._phase, message.type) };
+    }
+    if (existing.phase !== "pending") {
+      return { ok: false, violation: violation("STATE_VIOLATION", `Fetch ${fetchErr.request_id} is ${existing.phase}, not pending`, this._phase, message.type) };
+    }
+    this._fetches.set(fetchErr.request_id, { ...existing, phase: "error" });
+    sideEffects.push({ type: "fetch-ended", requestId: fetchErr.request_id, reason: fetchErr.reason_phrase });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleFetchCancel(message, _direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const cancel = message;
+    const idErr = this.checkKnownRequestId(cancel.request_id, message.type);
+    if (idErr) return { ok: false, violation: idErr };
+    const existing = this._fetches.get(cancel.request_id);
+    if (!existing) {
+      return { ok: false, violation: violation("UNKNOWN_REQUEST_ID", `No fetch with request ID ${cancel.request_id}`, this._phase, message.type) };
+    }
+    this._fetches.set(cancel.request_id, { ...existing, phase: "cancelled" });
+    sideEffects.push({ type: "fetch-ended", requestId: cancel.request_id, reason: "cancelled" });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  // ─── Generic ready-phase handler ──────────────────────────────────────────────
+  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._publishes.clear();
+    this._fetches.clear();
+    this._requestIds.clear();
+  }
+}, _class);
+
+// src/drafts/draft14/session.ts
+function createDraft14SessionState(options) {
+  return new Draft14SessionFSM(options.role);
+}
+
+
+
+
+
+
+
+
+
+
+exports.CONTROL_MESSAGES = CONTROL_MESSAGES; exports.CLIENT_ONLY_MESSAGES = CLIENT_ONLY_MESSAGES; exports.SERVER_ONLY_MESSAGES = SERVER_ONLY_MESSAGES; exports.BIDIRECTIONAL_MESSAGES = BIDIRECTIONAL_MESSAGES; exports.getLegalOutgoing = getLegalOutgoing; exports.getLegalIncoming = getLegalIncoming; exports.Draft14SessionFSM = Draft14SessionFSM; exports.createDraft14SessionState = createDraft14SessionState;