@moqtap/codec 0.8.1 → 0.9.0

package/dist/chunk-WX5PU7HF.js

@@ -0,0 +1,868 @@
+// src/drafts/draft20/rules.ts
+var CONTROL_MESSAGES = /* @__PURE__ */ new Set([
+  "setup",
+  "subscribe",
+  "subscribe_ok",
+  "request_update",
+  "publish_state_notify",
+  "publish",
+  "publish_done",
+  "publish_namespace",
+  "namespace",
+  "namespace_done",
+  "subscribe_namespace",
+  "subscribe_tracks",
+  "publish_skipped",
+  "fetch",
+  "fetch_ok",
+  "track_status",
+  "request_ok",
+  "request_error",
+  "goaway"
+]);
+var CLIENT_ONLY_MESSAGES = /* @__PURE__ */ new Set();
+var SERVER_ONLY_MESSAGES = /* @__PURE__ */ new Set();
+var BIDIRECTIONAL_MESSAGES = /* @__PURE__ */ new Set([
+  "setup",
+  "subscribe",
+  "subscribe_ok",
+  "request_update",
+  "publish_state_notify",
+  "publish",
+  "publish_done",
+  "publish_namespace",
+  "namespace",
+  "namespace_done",
+  "subscribe_namespace",
+  "subscribe_tracks",
+  "publish_skipped",
+  "fetch",
+  "fetch_ok",
+  "track_status",
+  "request_ok",
+  "request_error",
+  "goaway"
+]);
+var REQUEST_STREAM_OPENERS = /* @__PURE__ */ new Set([
+  "subscribe",
+  "publish",
+  "fetch",
+  "track_status",
+  "publish_namespace",
+  "subscribe_namespace",
+  "subscribe_tracks"
+]);
+function getLegalOutgoing(phase, _role) {
+  const legal = /* @__PURE__ */ new Set();
+  switch (phase) {
+    case "idle":
+      legal.add("setup");
+      break;
+    case "setup":
+      legal.add("setup");
+      break;
+    case "ready": {
+      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/draft20/session-fsm.ts
+function violation(code, message, currentPhase, offendingMessage) {
+  return { code, message, currentPhase, offendingMessage };
+}
+function hasFillParameters(params) {
+  return params?.fill_parameters;
+}
+var Draft20SessionFSM = class {
+  _phase = "idle";
+  _role;
+  _setupDirection = null;
+  _subscriptions = /* @__PURE__ */ new Map();
+  _subscriptionMeta = /* @__PURE__ */ new Map();
+  _publishes = /* @__PURE__ */ new Map();
+  _fetches = /* @__PURE__ */ new Map();
+  _requests = /* @__PURE__ */ new Map();
+  _requestIds = /* @__PURE__ */ new Set();
+  _pendingSubscribes = [];
+  _pendingPublishes = [];
+  _pendingFetches = [];
+  /**
+   * The peer's MAX_REQUEST_UPDATES (Setup Option 0x08), learned from its SETUP.
+   * 0 means the peer does not limit REQUEST_UPDATE concurrency, and 0 is also
+   * the default when the option is absent.
+   */
+  _peerMaxRequestUpdates = 0n;
+  /** The local endpoint's own advertised MAX_REQUEST_UPDATES. */
+  _localMaxRequestUpdates = 0n;
+  constructor(role) {
+    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);
+  }
+  /**
+   * Every fill fetch stream currently tracked, across all subscriptions, keyed
+   * by the Request ID that opened it.
+   *
+   * Fill fetch streams are unidirectional and carry no control messages, so
+   * nothing here is inferred from a message alone; the transport events that
+   * end one are reported with {@link closeFillFetchStream}.
+   */
+  get fillFetchStreams() {
+    const all = /* @__PURE__ */ new Map();
+    for (const meta of this._subscriptionMeta.values()) {
+      for (const [requestId, fill] of meta.fills) all.set(requestId, fill);
+    }
+    return all;
+  }
+  /** The fill fetch streams belonging to one subscription. */
+  fillFetchStreamsFor(subscribeId) {
+    return this._subscriptionMeta.get(subscribeId)?.fills ?? /* @__PURE__ */ new Map();
+  }
+  /** A subscription's current Forward State, or undefined if it is unknown here. */
+  forwardStateOf(subscribeId) {
+    return this._subscriptionMeta.get(subscribeId)?.forwardState;
+  }
+  /** What kind of request a Request ID names, or undefined if it names none. */
+  requestKindOf(requestId) {
+    return this._requests.get(requestId)?.kind;
+  }
+  checkDuplicateRequestId(requestId, msgType) {
+    if (this._requestIds.has(requestId)) {
+      return violation(
+        "DUPLICATE_REQUEST_ID",
+        `Request ID ${requestId} already in use`,
+        this._phase,
+        msgType
+      );
+    }
+    return null;
+  }
+  validateOutgoing(message) {
+    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) {
+    return this.applyTransition(message, "inbound", void 0);
+  }
+  send(message) {
+    return this.applyTransition(message, "outbound", void 0);
+  }
+  /**
+   * Receive a message that arrived on a known request stream.
+   *
+   * Prefer this over {@link receive} for anything that carries no Request ID of
+   * its own — SUBSCRIBE_OK, REQUEST_OK, REQUEST_ERROR, PUBLISH_DONE, FETCH_OK
+   * and PUBLISH_STATE_NOTIFY. Without the stream, the request-kind and
+   * direction rules of Section 10.10 cannot be checked at all, and the
+   * response-matching below falls back to FIFO guessing.
+   */
+  receiveOn(requestId, message) {
+    return this.applyTransition(message, "inbound", requestId);
+  }
+  /** Send a message on a known request stream. See {@link receiveOn}. */
+  sendOn(requestId, message) {
+    return this.applyTransition(message, "outbound", requestId);
+  }
+  applyTransition(message, direction, streamRequestId) {
+    const sideEffects = [];
+    switch (message.type) {
+      case "setup":
+        return this.handleSetup(message, direction);
+      case "goaway":
+        return this.handleGoAway(message, sideEffects);
+      case "subscribe":
+        return this.handleSubscribe(message, direction, sideEffects);
+      case "subscribe_ok":
+        return this.handleSubscribeOk(streamRequestId, sideEffects);
+      case "request_update":
+        return this.handleRequestUpdate(message, direction, streamRequestId, sideEffects);
+      case "publish_state_notify":
+        return this.handlePublishStateNotify(direction, streamRequestId, sideEffects);
+      case "publish":
+        return this.handlePublish(message, direction, sideEffects);
+      case "publish_done":
+        return this.handlePublishDone(streamRequestId, sideEffects);
+      case "fetch":
+        return this.handleFetch(message, direction, sideEffects);
+      case "fetch_ok":
+        return this.handleFetchOk(streamRequestId, sideEffects);
+      case "request_ok":
+        return this.handleRequestOk(streamRequestId, sideEffects);
+      case "request_error":
+        return this.handleRequestError(streamRequestId, sideEffects);
+      case "track_status":
+        return this.handleGenericRequest(message, "track_status", direction, sideEffects);
+      case "publish_namespace":
+        return this.handleGenericRequest(message, "publish_namespace", direction, sideEffects);
+      case "subscribe_namespace":
+        return this.handleGenericRequest(message, "subscribe_namespace", direction, sideEffects);
+      case "subscribe_tracks":
+        return this.handleGenericRequest(message, "subscribe_tracks", direction, sideEffects);
+      default:
+        return this.handleReadyPhaseMessage(message);
+    }
+  }
+  handleSetup(message, direction) {
+    const setup = message;
+    const advertised = setup.options.max_request_updates ?? 0n;
+    if (direction === "inbound") this._peerMaxRequestUpdates = advertised;
+    else this._localMaxRequestUpdates = advertised;
+    if (this._phase === "idle") {
+      this._setupDirection = direction;
+      this._phase = "setup";
+      return { ok: true, phase: this._phase, sideEffects: [] };
+    }
+    if (this._phase === "setup") {
+      if (direction === this._setupDirection) {
+        return {
+          ok: false,
+          violation: violation(
+            "SETUP_VIOLATION",
+            `Second SETUP must be ${this._setupDirection === "inbound" ? "outbound" : "inbound"}, got ${direction}`,
+            this._phase,
+            "setup"
+          )
+        };
+      }
+      this._phase = "ready";
+      return {
+        ok: true,
+        phase: this._phase,
+        sideEffects: [{ type: "session-ready" }]
+      };
+    }
+    return {
+      ok: false,
+      violation: violation(
+        "SETUP_VIOLATION",
+        "SETUP not valid in current phase",
+        this._phase,
+        "setup"
+      )
+    };
+  }
+  handleGoAway(message, 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;
+  }
+  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);
+    const publisherSide = direction === "outbound" ? "remote" : "local";
+    this._subscriptions.set(sub.request_id, {
+      subscribeId: sub.request_id,
+      phase: "pending",
+      trackNamespace: sub.track_namespace,
+      trackName: sub.track_name
+    });
+    const forwardState = sub.parameters.forward === 0n ? 0 : 1;
+    this._subscriptionMeta.set(sub.request_id, {
+      publisherSide,
+      forwardState,
+      fills: /* @__PURE__ */ new Map()
+    });
+    this._requests.set(sub.request_id, {
+      kind: "subscription",
+      publisherSide,
+      outstandingUpdates: 0
+    });
+    this._pendingSubscribes.push(sub.request_id);
+    this.applyFillParameters(sub.request_id, sub.request_id, sub.parameters, sideEffects);
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  /**
+   * Open a fill fetch stream if this message asked for one — draft-20 Sections
+   * 5.1.3 and 5.1.3.1, both new in draft-20.
+   *
+   * Three rules, all of which the draft states as bullets and all of which are
+   * easy to get wrong by analogy with draft-19's Joining FETCH:
+   *
+   *  1. Presence of FILL_PARAMETERS is the request. There is no separate
+   *     message and no Fetch Type; an empty FILL_PARAMETERS still opens a
+   *     stream, with every setting inherited from the subscription.
+   *  2. It only opens one "while Forward State is 1". FILL_PARAMETERS carried
+   *     while Forward State is 0 opens nothing, and later transitioning to
+   *     Forward State 1 without re-sending FILL_PARAMETERS opens nothing
+   *     either — so this is checked at the moment the message is processed and
+   *     never retried.
+   *  3. Streams accumulate. The new one is keyed by the opening message's
+   *     Request ID and does not disturb any stream already open on the same
+   *     subscription.
+   *
+   * The opened stream has no FETCH_OK: per DECISIONS.md D7 (SPEC-DELTA Section
+   * 11 Q9) there is no End Location and no End Of Track for a fill, and stream
+   * FIN is the only completion signal. Nothing here synthesizes one, and the
+   * stream is deliberately absent from {@link fetches}.
+   */
+  applyFillParameters(subscribeId, openingRequestId, params, sideEffects) {
+    if (hasFillParameters(params) === void 0) return;
+    const meta = this._subscriptionMeta.get(subscribeId);
+    if (meta === void 0) return;
+    if (meta.forwardState !== 1) return;
+    meta.fills.set(openingRequestId, {
+      requestId: openingRequestId,
+      subscribeId,
+      phase: "open"
+    });
+    sideEffects.push({
+      type: "fill-fetch-stream-opened",
+      subscribeId,
+      requestId: openingRequestId
+    });
+  }
+  /**
+   * Report the transport event that ended a fill fetch stream.
+   *
+   * A fill fetch stream carries no control message of its own, so its end is
+   * never inferable from the message sequence:
+   *
+   *  - `'complete'` — the publisher FINed the stream. Section 5.1.3.1 makes
+   *    that the ONLY completion signal; there is no FETCH_OK to read an End
+   *    Location or an End Of Track flag from (DECISIONS.md D7 / Q9).
+   *  - `'reset'` — the publisher reset it, which is how a fill failure is
+   *    signalled, "because there is no REQUEST_ERROR associated with a fill
+   *    fetch stream".
+   *  - `'cancelled'` — the subscriber sent STOP_SENDING.
+   *
+   * Either way "Resetting or cancelling a fill fetch stream, by either
+   * endpoint, does not affect the subscription, which continues to deliver
+   * objects using subscribe subgroups and datagrams", so the subscription's
+   * own state is untouched here.
+   */
+  closeFillFetchStream(requestId, phase) {
+    for (const meta of this._subscriptionMeta.values()) {
+      const fill = meta.fills.get(requestId);
+      if (fill === void 0) continue;
+      meta.fills.set(requestId, { ...fill, phase });
+      return [
+        {
+          type: "fill-fetch-stream-closed",
+          subscribeId: fill.subscribeId,
+          requestId,
+          reason: phase
+        }
+      ];
+    }
+    return [];
+  }
+  handleSubscribeOk(streamRequestId, sideEffects) {
+    const err = this.requireReady("subscribe_ok");
+    if (err) return { ok: false, violation: err };
+    const requestId = streamRequestId ?? this._pendingSubscribes.shift();
+    if (requestId === void 0) {
+      return {
+        ok: false,
+        violation: violation(
+          "UNEXPECTED_MESSAGE",
+          "SUBSCRIBE_OK with no pending subscribe",
+          this._phase,
+          "subscribe_ok"
+        )
+      };
+    }
+    if (streamRequestId !== void 0) {
+      this.dropPending(this._pendingSubscribes, streamRequestId);
+    }
+    const existing = this._subscriptions.get(requestId);
+    if (existing && existing.phase === "pending") {
+      this._subscriptions.set(requestId, { ...existing, phase: "active" });
+      sideEffects.push({
+        type: "subscription-activated",
+        subscribeId: requestId
+      });
+    }
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleRequestUpdate(message, direction, streamRequestId, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const update = message;
+    const dupErr = this.checkDuplicateRequestId(update.request_id, message.type);
+    if (dupErr) return { ok: false, violation: dupErr };
+    this._requestIds.add(update.request_id);
+    const targetId = streamRequestId;
+    const target = targetId !== void 0 ? this._requests.get(targetId) : void 0;
+    if (target !== void 0) {
+      const limit = direction === "inbound" ? this._localMaxRequestUpdates : this._peerMaxRequestUpdates;
+      if (limit > 0n && BigInt(target.outstandingUpdates) >= limit) {
+        return {
+          ok: false,
+          violation: violation(
+            "STATE_VIOLATION",
+            `REQUEST_UPDATE on request ${targetId} exceeds MAX_REQUEST_UPDATES (${limit})`,
+            this._phase,
+            "request_update"
+          )
+        };
+      }
+      target.outstandingUpdates += 1;
+    }
+    if (targetId !== void 0 && target !== void 0) {
+      if (target.kind !== "subscription") {
+        if (hasFillParameters(update.parameters) !== void 0) {
+          return {
+            ok: false,
+            violation: violation(
+              "STATE_VIOLATION",
+              `FILL_PARAMETERS may only appear in a REQUEST_UPDATE for a subscription, but request ${targetId} is a ${target.kind}`,
+              this._phase,
+              "request_update"
+            )
+          };
+        }
+      } else {
+        const meta = this._subscriptionMeta.get(targetId);
+        if (meta !== void 0) {
+          if (update.parameters.forward !== void 0) {
+            meta.forwardState = update.parameters.forward === 0n ? 0 : 1;
+          }
+          this.applyFillParameters(targetId, update.request_id, update.parameters, sideEffects);
+        }
+      }
+    }
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  /**
+   * PUBLISH_STATE_NOTIFY — draft-20 Section 10.10, new in draft-20.
+   *
+   * Three properties set it apart from every other control message, and all
+   * three are enforced here:
+   *
+   *  - **Unilateral.** "The receiver does not respond with REQUEST_OK or
+   *    REQUEST_ERROR", so nothing is queued as pending and nothing is
+   *    dequeued. A REQUEST_OK arriving later belongs to some other request.
+   *  - **Not rate-limited.** "The message is not subject to the
+   *    MAX_REQUEST_UPDATES limit", so `outstandingUpdates` is deliberately not
+   *    touched — that counter exists only for REQUEST_UPDATE.
+   *  - **Publisher to subscriber, subscriptions only.** "An endpoint that
+   *    receives a PUBLISH_STATE_NOTIFY for any other request type, or from the
+   *    subscriber, MUST close the session with a PROTOCOL_VIOLATION."
+   *
+   * The last one needs the request stream, because the message has no Request
+   * ID field. Called through {@link receive}/{@link send} without one, the
+   * kind and direction rules cannot be evaluated and the message is allowed
+   * through unchecked rather than guessed at.
+   */
+  handlePublishStateNotify(direction, streamRequestId, sideEffects) {
+    const err = this.requireReady("publish_state_notify");
+    if (err) return { ok: false, violation: err };
+    if (streamRequestId === void 0) {
+      return { ok: true, phase: this._phase, sideEffects };
+    }
+    const request = this._requests.get(streamRequestId);
+    if (request === void 0) {
+      return {
+        ok: false,
+        violation: violation(
+          "UNKNOWN_REQUEST_ID",
+          `PUBLISH_STATE_NOTIFY on unknown request ${streamRequestId}`,
+          this._phase,
+          "publish_state_notify"
+        )
+      };
+    }
+    if (request.kind !== "subscription") {
+      return {
+        ok: false,
+        violation: violation(
+          "STATE_VIOLATION",
+          `PUBLISH_STATE_NOTIFY applies only to subscriptions, but request ${streamRequestId} is a ${request.kind}`,
+          this._phase,
+          "publish_state_notify"
+        )
+      };
+    }
+    const fromPublisher = direction === "outbound" ? request.publisherSide === "local" : request.publisherSide === "remote";
+    if (!fromPublisher) {
+      return {
+        ok: false,
+        violation: violation(
+          "ROLE_VIOLATION",
+          `PUBLISH_STATE_NOTIFY is sent only by the publisher; request ${streamRequestId} has the publisher on the other side`,
+          this._phase,
+          "publish_state_notify"
+        )
+      };
+    }
+    sideEffects.push({ type: "subscription-state-notified", subscribeId: streamRequestId });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  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);
+    const publisherSide = direction === "outbound" ? "local" : "remote";
+    this._publishes.set(pub.request_id, {
+      requestId: pub.request_id,
+      phase: "pending"
+    });
+    this._subscriptions.set(pub.request_id, {
+      subscribeId: pub.request_id,
+      phase: "pending",
+      trackNamespace: pub.track_namespace,
+      trackName: pub.track_name
+    });
+    this._subscriptionMeta.set(pub.request_id, {
+      publisherSide,
+      forwardState: pub.parameters.forward === 0n ? 0 : 1,
+      fills: /* @__PURE__ */ new Map()
+    });
+    this._requests.set(pub.request_id, {
+      kind: "subscription",
+      publisherSide,
+      outstandingUpdates: 0
+    });
+    this._pendingPublishes.push(pub.request_id);
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handlePublishDone(streamRequestId, sideEffects) {
+    const err = this.requireReady("publish_done");
+    if (err) return { ok: false, violation: err };
+    let requestId = streamRequestId;
+    if (requestId === void 0) {
+      for (const [reqId, pub2] of this._publishes) {
+        if (pub2.phase === "active") {
+          requestId = reqId;
+          break;
+        }
+      }
+    }
+    if (requestId === void 0) return { ok: true, phase: this._phase, sideEffects };
+    const pub = this._publishes.get(requestId);
+    if (pub !== void 0 && pub.phase !== "done") {
+      this._publishes.set(requestId, { ...pub, phase: "done" });
+      sideEffects.push({ type: "publish-ended", requestId, reason: "done" });
+    }
+    const sub = this._subscriptions.get(requestId);
+    if (sub !== void 0 && sub.phase !== "done") {
+      this._subscriptions.set(requestId, { ...sub, phase: "done" });
+      sideEffects.push({
+        type: "subscription-ended",
+        subscribeId: requestId,
+        reason: "publish_done"
+      });
+    }
+    const meta = this._subscriptionMeta.get(requestId);
+    if (meta !== void 0) {
+      for (const [fillId, fill] of meta.fills) {
+        if (fill.phase !== "open") continue;
+        meta.fills.set(fillId, { ...fill, phase: "reset" });
+        sideEffects.push({
+          type: "fill-fetch-stream-closed",
+          subscribeId: requestId,
+          requestId: fillId,
+          reason: "subscription-ended"
+        });
+      }
+    }
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  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"
+    });
+    this._requests.set(fetch.request_id, {
+      kind: "fetch",
+      // The receiver of a FETCH serves it, so the peer publishes the objects.
+      publisherSide: direction === "outbound" ? "remote" : "local",
+      outstandingUpdates: 0
+    });
+    this._pendingFetches.push(fetch.request_id);
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleFetchOk(streamRequestId, sideEffects) {
+    const err = this.requireReady("fetch_ok");
+    if (err) return { ok: false, violation: err };
+    const requestId = streamRequestId ?? this._pendingFetches.shift();
+    if (requestId === void 0) {
+      return {
+        ok: false,
+        violation: violation(
+          "UNEXPECTED_MESSAGE",
+          "FETCH_OK with no pending fetch",
+          this._phase,
+          "fetch_ok"
+        )
+      };
+    }
+    if (streamRequestId !== void 0) {
+      const kind = this._requests.get(requestId)?.kind;
+      if (kind !== void 0 && kind !== "fetch") {
+        return {
+          ok: false,
+          violation: violation(
+            "STATE_VIOLATION",
+            `FETCH_OK on request ${requestId}, which is a ${kind}; a fill fetch stream has no FETCH_OK`,
+            this._phase,
+            "fetch_ok"
+          )
+        };
+      }
+      this.dropPending(this._pendingFetches, requestId);
+    }
+    const existing = this._fetches.get(requestId);
+    if (existing && existing.phase === "pending") {
+      this._fetches.set(requestId, { ...existing, phase: "active" });
+      sideEffects.push({ type: "fetch-activated", requestId });
+    }
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleRequestError(streamRequestId, sideEffects) {
+    const err = this.requireReady("request_error");
+    if (err) return { ok: false, violation: err };
+    if (streamRequestId !== void 0) {
+      this.restoreUpdateCredit(streamRequestId);
+      const sub = this._subscriptions.get(streamRequestId);
+      if (sub !== void 0 && sub.phase === "pending") {
+        this._subscriptions.set(streamRequestId, { ...sub, phase: "error" });
+        this.dropPending(this._pendingSubscribes, streamRequestId);
+        sideEffects.push({
+          type: "subscription-ended",
+          subscribeId: streamRequestId,
+          reason: "request_error"
+        });
+      }
+      const pub = this._publishes.get(streamRequestId);
+      if (pub !== void 0 && pub.phase === "pending") {
+        this._publishes.set(streamRequestId, { ...pub, phase: "error" });
+        this.dropPending(this._pendingPublishes, streamRequestId);
+        sideEffects.push({
+          type: "publish-ended",
+          requestId: streamRequestId,
+          reason: "request_error"
+        });
+      }
+      const f = this._fetches.get(streamRequestId);
+      if (f !== void 0 && f.phase === "pending") {
+        this._fetches.set(streamRequestId, { ...f, phase: "error" });
+        this.dropPending(this._pendingFetches, streamRequestId);
+        sideEffects.push({
+          type: "fetch-ended",
+          requestId: streamRequestId,
+          reason: "request_error"
+        });
+      }
+      return { ok: true, phase: this._phase, sideEffects };
+    }
+    const subId = this.dequeuePending(this._pendingSubscribes, this._subscriptions);
+    if (subId !== void 0) {
+      const sub = this._subscriptions.get(subId);
+      this._subscriptions.set(subId, { ...sub, phase: "error" });
+      sideEffects.push({
+        type: "subscription-ended",
+        subscribeId: subId,
+        reason: "request_error"
+      });
+      return { ok: true, phase: this._phase, sideEffects };
+    }
+    const pubId = this.dequeuePending(this._pendingPublishes, this._publishes);
+    if (pubId !== void 0) {
+      const pub = this._publishes.get(pubId);
+      this._publishes.set(pubId, { ...pub, phase: "error" });
+      sideEffects.push({
+        type: "publish-ended",
+        requestId: pubId,
+        reason: "request_error"
+      });
+      return { ok: true, phase: this._phase, sideEffects };
+    }
+    const fetchId = this.dequeuePending(this._pendingFetches, this._fetches);
+    if (fetchId !== void 0) {
+      const f = this._fetches.get(fetchId);
+      this._fetches.set(fetchId, { ...f, phase: "error" });
+      sideEffects.push({
+        type: "fetch-ended",
+        requestId: fetchId,
+        reason: "request_error"
+      });
+      return { ok: true, phase: this._phase, sideEffects };
+    }
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleRequestOk(streamRequestId, sideEffects) {
+    const err = this.requireReady("request_ok");
+    if (err) return { ok: false, violation: err };
+    if (streamRequestId !== void 0) {
+      this.restoreUpdateCredit(streamRequestId);
+      const pub = this._publishes.get(streamRequestId);
+      if (pub !== void 0 && pub.phase === "pending") {
+        this._publishes.set(streamRequestId, { ...pub, phase: "active" });
+        this.dropPending(this._pendingPublishes, streamRequestId);
+        sideEffects.push({ type: "publish-activated", requestId: streamRequestId });
+        const sub = this._subscriptions.get(streamRequestId);
+        if (sub !== void 0 && sub.phase === "pending") {
+          this._subscriptions.set(streamRequestId, { ...sub, phase: "active" });
+          sideEffects.push({ type: "subscription-activated", subscribeId: streamRequestId });
+        }
+      }
+      return { ok: true, phase: this._phase, sideEffects };
+    }
+    const pubId = this.dequeuePending(this._pendingPublishes, this._publishes);
+    if (pubId !== void 0) {
+      const pub = this._publishes.get(pubId);
+      this._publishes.set(pubId, { ...pub, phase: "active" });
+      sideEffects.push({ type: "publish-activated", requestId: pubId });
+    }
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleGenericRequest(message, kind, direction, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const requestId = message.request_id;
+    if (requestId === void 0) return { ok: true, phase: this._phase, sideEffects };
+    const dupErr = this.checkDuplicateRequestId(requestId, message.type);
+    if (dupErr) return { ok: false, violation: dupErr };
+    this._requestIds.add(requestId);
+    this._requests.set(requestId, {
+      kind,
+      // Only subscriptions have a publisher in the Section 10.10 sense; the
+      // value is recorded for symmetry and never consulted for these kinds.
+      publisherSide: direction === "outbound" ? "remote" : "local",
+      outstandingUpdates: 0
+    });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  restoreUpdateCredit(requestId) {
+    const request = this._requests.get(requestId);
+    if (request !== void 0 && request.outstandingUpdates > 0) {
+      request.outstandingUpdates -= 1;
+    }
+  }
+  dropPending(queue, requestId) {
+    const index = queue.indexOf(requestId);
+    if (index >= 0) queue.splice(index, 1);
+  }
+  dequeuePending(queue, stateMap) {
+    while (queue.length > 0) {
+      const id = queue[0];
+      const state = stateMap.get(id);
+      if (state && state.phase === "pending") {
+        queue.shift();
+        return id;
+      }
+      queue.shift();
+    }
+    return void 0;
+  }
+  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._setupDirection = null;
+    this._subscriptions.clear();
+    this._subscriptionMeta.clear();
+    this._publishes.clear();
+    this._fetches.clear();
+    this._requests.clear();
+    this._requestIds.clear();
+    this._pendingSubscribes.length = 0;
+    this._pendingPublishes.length = 0;
+    this._pendingFetches.length = 0;
+    this._peerMaxRequestUpdates = 0n;
+    this._localMaxRequestUpdates = 0n;
+  }
+};
+
+// src/drafts/draft20/session.ts
+function createDraft20SessionState(role) {
+  return new Draft20SessionFSM(role);
+}
+
+export {
+  CONTROL_MESSAGES,
+  CLIENT_ONLY_MESSAGES,
+  SERVER_ONLY_MESSAGES,
+  BIDIRECTIONAL_MESSAGES,
+  REQUEST_STREAM_OPENERS,
+  getLegalOutgoing,
+  getLegalIncoming,
+  Draft20SessionFSM,
+  createDraft20SessionState
+};