@moqtap/codec 0.2.0 → 0.2.2

package/dist/drafts/draft14/session-fsm.js

@@ -0,0 +1,648 @@
+import { CLIENT_ONLY_MESSAGES, getLegalIncoming, getLegalOutgoing, SERVER_ONLY_MESSAGES, } from "./rules.js";
+function violation(code, message, currentPhase, offendingMessage) {
+    return { code, message, currentPhase, offendingMessage };
+}
+export class Draft14SessionFSM {
+    _phase = "idle";
+    _role;
+    _subscriptions = new Map();
+    _publishes = new Map();
+    _fetches = new Map();
+    _requestIds = new Set();
+    constructor(role) {
+        this._role = role;
+    }
+    get phase() {
+        return this._phase;
+    }
+    get role() {
+        return this._role;
+    }
+    get subscriptions() {
+        return this._subscriptions;
+    }
+    get announces() {
+        return 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 lifecycle
+            case "publish_namespace":
+                return this.handlePublishNamespace(message, sideEffects);
+            case "publish_namespace_ok":
+                return this.handlePublishNamespaceOk(message, sideEffects);
+            case "publish_namespace_error":
+                return this.handlePublishNamespaceError(message, sideEffects);
+            case "publish_namespace_done":
+                return this.handlePublishNamespaceDone(message, sideEffects);
+            case "publish_namespace_cancel":
+                return this.handlePublishNamespaceCancel(message, sideEffects);
+            // Subscribe namespace lifecycle
+            case "subscribe_namespace":
+                return this.handleSubscribeNamespace(message, sideEffects);
+            case "subscribe_namespace_ok":
+                return this.handleSubscribeNamespaceOk(message, sideEffects);
+            case "subscribe_namespace_error":
+                return this.handleSubscribeNamespaceError(message, sideEffects);
+            case "unsubscribe_namespace":
+                return this.handleUnsubscribeNamespace(message, sideEffects);
+            // Track status lifecycle
+            case "track_status":
+                return this.handleTrackStatus(message, sideEffects);
+            case "track_status_ok":
+                return this.handleTrackStatusOk(message, sideEffects);
+            case "track_status_error":
+                return this.handleTrackStatusError(message, sideEffects);
+            // 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 };
+    }
+    // ─── Publish namespace lifecycle ──────────────────────────────────────────────
+    handlePublishNamespace(message, sideEffects) {
+        const err = this.requireReady(message.type);
+        if (err)
+            return { ok: false, violation: err };
+        const pn = message;
+        const dupErr = this.checkDuplicateRequestId(pn.request_id, message.type);
+        if (dupErr)
+            return { ok: false, violation: dupErr };
+        this._requestIds.add(pn.request_id);
+        return { ok: true, phase: this._phase, sideEffects };
+    }
+    handlePublishNamespaceOk(message, 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 };
+        return { ok: true, phase: this._phase, sideEffects };
+    }
+    handlePublishNamespaceError(message, sideEffects) {
+        const err = this.requireReady(message.type);
+        if (err)
+            return { ok: false, violation: err };
+        const pnErr = message;
+        const idErr = this.checkKnownRequestId(pnErr.request_id, message.type);
+        if (idErr)
+            return { ok: false, violation: idErr };
+        return { ok: true, phase: this._phase, sideEffects };
+    }
+    handlePublishNamespaceDone(message, 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 };
+        return { ok: true, phase: this._phase, sideEffects };
+    }
+    handlePublishNamespaceCancel(message, 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 };
+        return { ok: true, phase: this._phase, sideEffects };
+    }
+    // ─── Subscribe namespace lifecycle ──────────────────────────────────────────────
+    handleSubscribeNamespace(message, sideEffects) {
+        const err = this.requireReady(message.type);
+        if (err)
+            return { ok: false, violation: err };
+        const sn = message;
+        const dupErr = this.checkDuplicateRequestId(sn.request_id, message.type);
+        if (dupErr)
+            return { ok: false, violation: dupErr };
+        this._requestIds.add(sn.request_id);
+        return { ok: true, phase: this._phase, sideEffects };
+    }
+    handleSubscribeNamespaceOk(message, 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 };
+        return { ok: true, phase: this._phase, sideEffects };
+    }
+    handleSubscribeNamespaceError(message, sideEffects) {
+        const err = this.requireReady(message.type);
+        if (err)
+            return { ok: false, violation: err };
+        const snErr = message;
+        const idErr = this.checkKnownRequestId(snErr.request_id, message.type);
+        if (idErr)
+            return { ok: false, violation: idErr };
+        return { ok: true, phase: this._phase, sideEffects };
+    }
+    handleUnsubscribeNamespace(message, sideEffects) {
+        const err = this.requireReady(message.type);
+        if (err)
+            return { ok: false, violation: err };
+        // unsubscribe_namespace has no request_id — namespace-based
+        return { ok: true, phase: this._phase, sideEffects };
+    }
+    // ─── Track status lifecycle ──────────────────────────────────────────────────
+    handleTrackStatus(message, sideEffects) {
+        const err = this.requireReady(message.type);
+        if (err)
+            return { ok: false, violation: err };
+        const ts = message;
+        const dupErr = this.checkDuplicateRequestId(ts.request_id, message.type);
+        if (dupErr)
+            return { ok: false, violation: dupErr };
+        this._requestIds.add(ts.request_id);
+        return { ok: true, phase: this._phase, sideEffects };
+    }
+    handleTrackStatusOk(message, 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 };
+        return { ok: true, phase: this._phase, sideEffects };
+    }
+    handleTrackStatusError(message, sideEffects) {
+        const err = this.requireReady(message.type);
+        if (err)
+            return { ok: false, violation: err };
+        const tsErr = message;
+        const idErr = this.checkKnownRequestId(tsErr.request_id, message.type);
+        if (idErr)
+            return { ok: false, violation: idErr };
+        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();
+    }
+}
+//# sourceMappingURL=session-fsm.js.map