@fuzdev/fuz_app 0.113.0 → 0.114.0

package/dist/actions/socket.svelte.js

@@ -16,10 +16,11 @@
  *   to `DEFAULT_QUEUE_MAX_SIZE` requests and flush on reopen. Overflow
  *   rejects with `queue_overflow`. Raw `FrontendWebsocketClient.send`
  *   is drop-on-disconnect (fire-and-forget notifications want that).
- * - **Activity-aware heartbeat** — idles fire a shared `heartbeat` request;
- *   receive-silence past `DEFAULT_HEARTBEAT_RECEIVE_TIMEOUT` closes
- *   with `WS_CLOSE_CLIENT_HEARTBEAT_TIMEOUT` and lets auto-reconnect
- *   pick back up.
+ * - **Activity-aware heartbeat** — a shared `heartbeat` request fires when
+ *   either direction has been idle for the interval; receive-silence past
+ *   the receive timeout (`DEFAULT_HEARTBEAT_RECEIVE_TIMEOUT`, never less
+ *   than `HEARTBEAT_RECEIVE_TIMEOUT_MIN_FACTOR` × the interval) closes with
+ *   `WS_CLOSE_CLIENT_HEARTBEAT_TIMEOUT` and lets auto-reconnect pick back up.
  *
  * @module
  */
@@ -39,8 +40,31 @@ export const DEFAULT_RECONNECT_DELAY_MAX = 10000;
 export const DEFAULT_BACKOFF_FACTOR = 1.5;
 /** Idle interval before sending a heartbeat (ms). */
 export const DEFAULT_HEARTBEAT_INTERVAL = 30_000;
-/** Max receive silence before closing with `WS_CLOSE_CLIENT_HEARTBEAT_TIMEOUT` (ms). */
+/**
+ * Max receive silence before closing with `WS_CLOSE_CLIENT_HEARTBEAT_TIMEOUT`
+ * (ms), for intervals up to half of it — see `resolve_heartbeat_receive_timeout`.
+ */
 export const DEFAULT_HEARTBEAT_RECEIVE_TIMEOUT = 60_000;
+/**
+ * Minimum ratio of the heartbeat receive timeout to the heartbeat interval.
+ *
+ * A heartbeat goes out once a direction has been idle for `interval`, and the
+ * check runs every `interval / 2`, so on an idle socket it can leave up to
+ * 1.5 × `interval` after the last receive — and its response needs a round
+ * trip on top. A receive timeout under 2 × `interval` can close a healthy
+ * idle socket before its heartbeat is answered, so it's clamped up to this.
+ */
+export const HEARTBEAT_RECEIVE_TIMEOUT_MIN_FACTOR = 2;
+/**
+ * Resolve the effective heartbeat receive timeout for `interval`: the given
+ * `receive_timeout` (or `DEFAULT_HEARTBEAT_RECEIVE_TIMEOUT`), raised to at
+ * least `HEARTBEAT_RECEIVE_TIMEOUT_MIN_FACTOR` × `interval`.
+ *
+ * @param interval - heartbeat idle interval in ms
+ * @param receive_timeout - requested receive timeout in ms
+ * @returns the receive timeout in ms the client enforces
+ */
+export const resolve_heartbeat_receive_timeout = (interval, receive_timeout = DEFAULT_HEARTBEAT_RECEIVE_TIMEOUT) => Math.max(receive_timeout, interval * HEARTBEAT_RECEIVE_TIMEOUT_MIN_FACTOR);
 /** Default bound on buffered requests while disconnected. Overflow rejects. */
 export const DEFAULT_QUEUE_MAX_SIZE = 100;
 /**
@@ -70,10 +94,12 @@ export class FrontendWebsocketClient {
     #pending = new Map();
     #queue = [];
     #heartbeat_timer = null;
-    /** Epoch ms of the last outgoing send — used by the heartbeat activity check. */
-    #last_send_time = null;
-    /** Epoch ms of the last incoming message — used by the heartbeat activity check. */
-    #last_receive_time = null;
+    /** Whether a heartbeat request is awaiting its response — at most one is outstanding. */
+    #heartbeat_in_flight = false;
+    /** Epoch ms of the last outgoing send, reset on open — the heartbeat activity baseline. */
+    #heartbeat_send_mark = null;
+    /** Epoch ms of the last incoming message, reset on open — the heartbeat activity baseline. */
+    #heartbeat_receive_mark = null;
     ws = $state.raw(null);
     status = $state.raw('initial');
     reconnect_count = $state.raw(0);
@@ -86,6 +112,17 @@ export class FrontendWebsocketClient {
     last_close_code = $state.raw(null);
     /** Reason string from the most recent close event (may be empty). */
     last_close_reason = $state.raw(null);
+    /**
+     * Epoch ms of the most recent frame written to the socket — requests,
+     * notifications, heartbeats, and cancels alike. `null` until the first send.
+     */
+    last_send_time = $state.raw(null);
+    /**
+     * Epoch ms of the most recent frame received — responses (including ones
+     * `request` consumes), notifications, and requests alike. `null` until the
+     * first receive.
+     */
+    last_receive_time = $state.raw(null);
     /**
      * The error thrown by the most recent attempted `send()`, or `null` if the
      * most recent attempt succeeded or none has been attempted yet. Populated
@@ -114,8 +151,7 @@ export class FrontendWebsocketClient {
         this.#heartbeat_enabled = heartbeat !== false;
         const heartbeat_config = typeof heartbeat === 'object' && heartbeat !== null ? heartbeat : {};
         this.#heartbeat_interval = heartbeat_config.interval ?? DEFAULT_HEARTBEAT_INTERVAL;
-        this.#heartbeat_receive_timeout =
-            heartbeat_config.receive_timeout ?? DEFAULT_HEARTBEAT_RECEIVE_TIMEOUT;
+        this.#heartbeat_receive_timeout = resolve_heartbeat_receive_timeout(this.#heartbeat_interval, heartbeat_config.receive_timeout);
         const queue = options.queue;
         this.#queue_enabled = queue !== false;
         const queue_config = typeof queue === 'object' ? queue : {};
@@ -199,7 +235,7 @@ export class FrontendWebsocketClient {
         this.#heartbeat_enabled = heartbeat !== false;
         const config = typeof heartbeat === 'object' && heartbeat !== null ? heartbeat : {};
         this.#heartbeat_interval = config.interval ?? DEFAULT_HEARTBEAT_INTERVAL;
-        this.#heartbeat_receive_timeout = config.receive_timeout ?? DEFAULT_HEARTBEAT_RECEIVE_TIMEOUT;
+        this.#heartbeat_receive_timeout = resolve_heartbeat_receive_timeout(this.#heartbeat_interval, config.receive_timeout);
         if (this.connected) {
             this.#start_heartbeat();
         }
@@ -305,7 +341,9 @@ export class FrontendWebsocketClient {
         try {
             this.ws.send(JSON.stringify(data));
             this.last_send_error = null;
-            this.#last_send_time = Date.now();
+            const now = Date.now();
+            this.#heartbeat_send_mark = now;
+            this.last_send_time = now;
             return true;
         }
         catch (error) {
@@ -321,6 +359,10 @@ export class FrontendWebsocketClient {
      * own peer-minted UUID), tracks the pending promise, and resolves when the
      * server sends a matching response.
      *
+     * An `undefined` `params` is omitted from the frame rather than sent as
+     * `{}` — the absent form is the parameterless call every server admits
+     * for a `z.void()` input, including servers that refuse `{}`.
+     *
      * Callers supplying an explicit `options.id` are responsible for
      * uniqueness — the pending map is keyed by id, and a duplicate silently
      * overwrites the prior entry. Auto-minted ids are monotonic and never
@@ -341,7 +383,7 @@ export class FrontendWebsocketClient {
      *
      * @mutates this - inserts the new pending entry into `#pending` (or
      *   buffers into `#queue` when disconnected) and may bump
-     *   `#next_request_id`, `#last_send_time`, `last_send_error`
+     *   `#next_request_id`, `last_send_time`, `last_send_error`
      * @throws ThrownJsonrpcError on the returned promise — never thrown
      *   synchronously. Rejection codes:
      *   - `unauthenticated` — session revoked (entry check or close code)
@@ -352,7 +394,7 @@ export class FrontendWebsocketClient {
      *   - `internal_error` — `ws.send` threw (serialization, buffer full)
      *   - server's wire code verbatim — JSON-RPC error frame from peer
      */
-    request(method, params = {}, options = {}) {
+    request(method, params, options = {}) {
         return new Promise((resolve, reject) => {
             const resolve_typed = resolve;
             const reject_typed = reject;
@@ -366,7 +408,13 @@ export class FrontendWebsocketClient {
                 return;
             }
             const id = options.id ?? ++this.#next_request_id;
-            const frame = { jsonrpc: JSONRPC_VERSION, id, method, params };
+            // an `undefined` `params` is omitted, never defaulted to `{}` — the
+            // absent form is JSON-RPC 2.0 §4.2's parameterless call and the one
+            // shape every server admits for a `z.void()` input, including
+            // servers that refuse `{}`
+            const frame = params === undefined
+                ? { jsonrpc: JSONRPC_VERSION, id, method }
+                : { jsonrpc: JSONRPC_VERSION, id, method, params };
             // Bind the signal listener up-front so `#detach_signal` can find it by
             // reference regardless of which settlement path runs (inline send,
             // queued flush, close-time reject).
@@ -520,8 +568,8 @@ export class FrontendWebsocketClient {
         if (!this.#heartbeat_enabled)
             return;
         const now = Date.now();
-        this.#last_send_time = now;
-        this.#last_receive_time = now;
+        this.#heartbeat_send_mark = now;
+        this.#heartbeat_receive_mark = now;
         // Run the check at half the interval so any event-loop blockage pauses
         // the timer itself; a dead-because-blocked socket is close enough to
         // dead-because-unresponsive that closing is arguably correct.
@@ -538,7 +586,7 @@ export class FrontendWebsocketClient {
         if (!this.connected || !this.ws)
             return;
         const now = Date.now();
-        const last_receive = this.#last_receive_time ?? now;
+        const last_receive = this.#heartbeat_receive_mark ?? now;
         if (now - last_receive >= this.#heartbeat_receive_timeout) {
             this.#log?.info(`[socket] receive timeout (${now - last_receive}ms) — closing ${WS_CLOSE_CLIENT_HEARTBEAT_TIMEOUT}`);
             try {
@@ -549,14 +597,25 @@ export class FrontendWebsocketClient {
             }
             return;
         }
-        const last_activity = Math.max(this.#last_send_time ?? 0, last_receive);
-        if (now - last_activity >= this.#heartbeat_interval) {
+        // Heartbeat when either direction has gone quiet: receive-only silence
+        // would trip this client's receive timeout, send-only silence the
+        // server's. Traffic both ways keeps both fed.
+        // One outstanding heartbeat at a time — its response feeds the receive
+        // side, and if it never comes the receive timeout above closes the socket.
+        const last_send = this.#heartbeat_send_mark ?? now;
+        if (!this.#heartbeat_in_flight &&
+            now - Math.min(last_send, last_receive) >= this.#heartbeat_interval) {
             // Fire-and-forget the heartbeat. If it fails (network, serialization),
             // receive-silence detection above will close the socket on the next
             // tick. No queue — the heartbeat is the thing that tells us the
             // queue needs flushing, it must not fight the queue for the slot.
-            void this.request(heartbeat_action_spec.method, {}, { queue: false }).catch((error) => {
+            this.#heartbeat_in_flight = true;
+            void this.request(heartbeat_action_spec.method, undefined, { queue: false })
+                .catch((error) => {
                 this.#log?.debug('[socket] heartbeat request failed:', error);
+            })
+                .finally(() => {
+                this.#heartbeat_in_flight = false;
             });
         }
     }
@@ -664,7 +723,9 @@ export class FrontendWebsocketClient {
         // Browsers fire `close` after error; reconnect logic lives there.
     };
     #handle_message = (event) => {
-        this.#last_receive_time = Date.now();
+        const now = Date.now();
+        this.#heartbeat_receive_mark = now;
+        this.last_receive_time = now;
         // Intercept JSON-RPC responses for pending `request()` calls. Parse
         // defensively — if the frame isn't valid JSON or isn't a response, fall
         // through to the registered message handlers (which still see every

package/dist/actions/transports.d.ts

@@ -14,6 +14,30 @@ export declare const WS_CLOSE_SESSION_REVOKED = 4001;
 export declare const WS_CLOSE_CLIENT_HEARTBEAT_TIMEOUT = 4002;
 /** WebSocket close code — server timed out with no incoming activity. */
 export declare const WS_CLOSE_SERVER_HEARTBEAT_TIMEOUT = 4003;
+/**
+ * WebSocket close code — an inbound message exceeded the receiver's size cap
+ * (RFC 6455 §7.4.1 "Message Too Big").
+ */
+export declare const WS_CLOSE_MESSAGE_TOO_BIG = 1009;
+/**
+ * Default cap on one WebSocket message, in UTF-8 bytes — equal to the default
+ * HTTP body cap (`DEFAULT_MAX_BODY_SIZE`), so one JSON-RPC request is bounded
+ * the same on both transports. The server closes the socket on a larger
+ * inbound message with `WS_CLOSE_MESSAGE_TOO_BIG` (there's no per-message
+ * error reply), and `FrontendWebsocketTransport` refuses to send one. The
+ * twin of the Rust spine's `DEFAULT_WS_MAX_MESSAGE_BYTES`.
+ */
+export declare const DEFAULT_WS_MAX_MESSAGE_BYTES: number;
+/**
+ * The UTF-8 byte length of `text` when it exceeds `max_bytes`, else `null`.
+ * Skips encoding when the UTF-16 length alone rules it out — a code unit
+ * takes at most 3 UTF-8 bytes.
+ *
+ * @param text - the string to measure
+ * @param max_bytes - the byte cap
+ * @returns the UTF-8 byte length when it exceeds `max_bytes`, else `null`
+ */
+export declare const utf8_length_over: (text: string, max_bytes: number) => number | null;
 export declare const TransportName: z.ZodString;
 export type TransportName = z.infer<typeof TransportName>;
 /**

package/dist/actions/transports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transports.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/transports.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EACX,gCAAgC,EAChC,gCAAgC,EAChC,mBAAmB,EACnB,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,MAAM,oBAAoB,CAAC;AAE5B,mDAAmD;AACnD,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAC7C,sEAAsE;AACtE,eAAO,MAAM,iCAAiC,OAAO,CAAC;AACtD,yEAAyE;AACzE,eAAO,MAAM,iCAAiC,OAAO,CAAC;AAKtD,eAAO,MAAM,aAAa,aAAa,CAAC;AACxC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACpC;;;;;OAKG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,SAAS;IACzB,cAAc,EAAE,aAAa,CAAC;IAE9B,IAAI,CAAC,OAAO,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;IAC/F,IAAI,CACH,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAAC;IACxC,IAAI,CACH,OAAO,EAAE,gCAAgC,EACzC,OAAO,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,gCAAgC,GAAG,IAAI,CAAC,CAAC;IACpD,QAAQ,EAAE,MAAM,OAAO,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,qBAAa,UAAU;;IAItB;;;OAGG;IACH,cAAc,EAAE,OAAO,CAAQ;IAE/B;;;;;OAKG;IACH,kBAAkB,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;IAQ9C;;;;;OAKG;IACH,qBAAqB,CAAC,cAAc,EAAE,aAAa,GAAG,IAAI;IAM1D;;;;;;OAMG;IACH,aAAa,CAAC,cAAc,CAAC,EAAE,aAAa,GAAG,SAAS,GAAG,IAAI;IAO/D,QAAQ,IAAI,OAAO,GAAG,IAAI;IAM1B,qBAAqB,IAAI,SAAS,GAAG,IAAI;IAIzC,0BAA0B,IAAI,aAAa,GAAG,IAAI;IAIlD,qBAAqB,CAAC,cAAc,EAAE,aAAa,GAAG,SAAS,GAAG,IAAI;CAwCtE"}
+{"version":3,"file":"transports.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/transports.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EACX,gCAAgC,EAChC,gCAAgC,EAChC,mBAAmB,EACnB,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,MAAM,oBAAoB,CAAC;AAE5B,mDAAmD;AACnD,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAC7C,sEAAsE;AACtE,eAAO,MAAM,iCAAiC,OAAO,CAAC;AACtD,yEAAyE;AACzE,eAAO,MAAM,iCAAiC,OAAO,CAAC;AACtD;;;GAGG;AACH,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAE7C;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,QAAc,CAAC;AAIxD;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,EAAE,WAAW,MAAM,KAAG,MAAM,GAAG,IAI3E,CAAC;AAKF,eAAO,MAAM,aAAa,aAAa,CAAC;AACxC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACpC;;;;;OAKG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,SAAS;IACzB,cAAc,EAAE,aAAa,CAAC;IAE9B,IAAI,CAAC,OAAO,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;IAC/F,IAAI,CACH,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAAC;IACxC,IAAI,CACH,OAAO,EAAE,gCAAgC,EACzC,OAAO,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,gCAAgC,GAAG,IAAI,CAAC,CAAC;IACpD,QAAQ,EAAE,MAAM,OAAO,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,qBAAa,UAAU;;IAItB;;;OAGG;IACH,cAAc,EAAE,OAAO,CAAQ;IAE/B;;;;;OAKG;IACH,kBAAkB,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;IAQ9C;;;;;OAKG;IACH,qBAAqB,CAAC,cAAc,EAAE,aAAa,GAAG,IAAI;IAM1D;;;;;;OAMG;IACH,aAAa,CAAC,cAAc,CAAC,EAAE,aAAa,GAAG,SAAS,GAAG,IAAI;IAO/D,QAAQ,IAAI,OAAO,GAAG,IAAI;IAM1B,qBAAqB,IAAI,SAAS,GAAG,IAAI;IAIzC,0BAA0B,IAAI,aAAa,GAAG,IAAI;IAIlD,qBAAqB,CAAC,cAAc,EAAE,aAAa,GAAG,SAAS,GAAG,IAAI;CAwCtE"}

package/dist/actions/transports.js

@@ -13,6 +13,36 @@ export const WS_CLOSE_SESSION_REVOKED = 4001;
 export const WS_CLOSE_CLIENT_HEARTBEAT_TIMEOUT = 4002;
 /** WebSocket close code — server timed out with no incoming activity. */
 export const WS_CLOSE_SERVER_HEARTBEAT_TIMEOUT = 4003;
+/**
+ * WebSocket close code — an inbound message exceeded the receiver's size cap
+ * (RFC 6455 §7.4.1 "Message Too Big").
+ */
+export const WS_CLOSE_MESSAGE_TOO_BIG = 1009;
+/**
+ * Default cap on one WebSocket message, in UTF-8 bytes — equal to the default
+ * HTTP body cap (`DEFAULT_MAX_BODY_SIZE`), so one JSON-RPC request is bounded
+ * the same on both transports. The server closes the socket on a larger
+ * inbound message with `WS_CLOSE_MESSAGE_TOO_BIG` (there's no per-message
+ * error reply), and `FrontendWebsocketTransport` refuses to send one. The
+ * twin of the Rust spine's `DEFAULT_WS_MAX_MESSAGE_BYTES`.
+ */
+export const DEFAULT_WS_MAX_MESSAGE_BYTES = 1024 * 1024;
+const text_encoder = new TextEncoder();
+/**
+ * The UTF-8 byte length of `text` when it exceeds `max_bytes`, else `null`.
+ * Skips encoding when the UTF-16 length alone rules it out — a code unit
+ * takes at most 3 UTF-8 bytes.
+ *
+ * @param text - the string to measure
+ * @param max_bytes - the byte cap
+ * @returns the UTF-8 byte length when it exceeds `max_bytes`, else `null`
+ */
+export const utf8_length_over = (text, max_bytes) => {
+    if (text.length * 3 <= max_bytes)
+        return null;
+    const size = text_encoder.encode(text).byteLength;
+    return size > max_bytes ? size : null;
+};
 // TODO figure out the symmetry of frontend and backend transports (none/partial/full?) --
 // we may also need orthogonal abstractions to clarify the transport role
 export const TransportName = z.string(); // not branded for convenience, will just error at runtime, the schema is just for docs atm

package/dist/actions/transports_http.d.ts

@@ -3,14 +3,21 @@
  *
  * @module
  */
-import type { JsonrpcNotification, JsonrpcRequest, JsonrpcResponseOrError, JsonrpcErrorResponse } from '../http/jsonrpc.js';
+import { JsonrpcErrorResponse, type JsonrpcNotification, type JsonrpcRequest, type JsonrpcResponseOrError } from '../http/jsonrpc.js';
 import type { Transport, TransportSendOptions } from './transports.js';
 /**
  * Thin `fetch` adapter for the JSON-RPC endpoint. POST by default; GET when
  * the optional `has_side_effects(method)` callback returns `false` for the
- * method (matches `create_rpc_endpoint`'s GET convention). On non-OK HTTP
- * responses, synthesizes a JSON-RPC error envelope via
- * `http_status_to_jsonrpc_error_code`. Always reports ready.
+ * method (matches `create_rpc_endpoint`'s GET convention). Always reports ready.
+ *
+ * On non-OK HTTP responses, a body that is a JSON-RPC error response for this
+ * request (same `id`, or `null` when the server couldn't read one) is returned
+ * as-is, so the server's `code`, `message`, and `data` reach the caller — the
+ * status → code map is lossy (`queue_overflow` and `rate_limited` share 429).
+ * Any other body (HTML from a proxy, empty, malformed) gets a synthesized
+ * envelope whose code comes from `http_status_to_jsonrpc_error_code`.
+ * A 2xx whose body isn't a JSON-RPC response (an HTML fallback page, say)
+ * becomes an `internal_error` naming the status and content type.
  */
 export declare class FrontendHttpTransport implements Transport {
     #private;

package/dist/actions/transports_http.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transports_http.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/transports_http.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAeH,OAAO,KAAK,EAGX,mBAAmB,EACnB,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEvE;;;;;;GAMG;AACH,qBAAa,qBAAsB,YAAW,SAAS;;IACtD,QAAQ,CAAC,cAAc,EAAG,mBAAmB,CAAU;gBAOtD,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO;IAOzC,IAAI,CACT,OAAO,EAAE,cAAc,EACvB,OAAO,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,sBAAsB,CAAC;IAC5B,IAAI,CACT,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IA2EvC,QAAQ,IAAI,OAAO;CAGnB"}
+{"version":3,"file":"transports_http.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/transports_http.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAiBH,OAAO,EACN,oBAAoB,EAGpB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EAEnB,KAAK,sBAAsB,EAC3B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEvE;;;;;;;;;;;;;GAaG;AACH,qBAAa,qBAAsB,YAAW,SAAS;;IACtD,QAAQ,CAAC,cAAc,EAAG,mBAAmB,CAAU;gBAOtD,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO;IAOzC,IAAI,CACT,OAAO,EAAE,cAAc,EACvB,OAAO,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,sBAAsB,CAAC;IAC5B,IAAI,CACT,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IA+FvC,QAAQ,IAAI,OAAO;CAGnB"}

package/dist/actions/transports_http.js

@@ -4,14 +4,22 @@
  * @module
  */
 import { DEV } from 'esm-env';
-import { ThrownJsonrpcError, jsonrpc_error_messages, http_status_to_jsonrpc_error_code, UNKNOWN_ERROR_MESSAGE } from '../http/jsonrpc_errors.js';
-import { create_jsonrpc_error_response, to_jsonrpc_message_id, is_jsonrpc_error_response } from '../http/jsonrpc_helpers.js';
+import { ThrownJsonrpcError, jsonrpc_error_messages, http_status_to_jsonrpc_error_code, jsonrpc_error_code_to_http_status, UNKNOWN_ERROR_MESSAGE } from '../http/jsonrpc_errors.js';
+import { create_jsonrpc_error_response, to_jsonrpc_message_id, is_jsonrpc_error_response, is_jsonrpc_response } from '../http/jsonrpc_helpers.js';
+import { JsonrpcErrorResponse } from '../http/jsonrpc.js';
 /**
  * Thin `fetch` adapter for the JSON-RPC endpoint. POST by default; GET when
  * the optional `has_side_effects(method)` callback returns `false` for the
- * method (matches `create_rpc_endpoint`'s GET convention). On non-OK HTTP
- * responses, synthesizes a JSON-RPC error envelope via
- * `http_status_to_jsonrpc_error_code`. Always reports ready.
+ * method (matches `create_rpc_endpoint`'s GET convention). Always reports ready.
+ *
+ * On non-OK HTTP responses, a body that is a JSON-RPC error response for this
+ * request (same `id`, or `null` when the server couldn't read one) is returned
+ * as-is, so the server's `code`, `message`, and `data` reach the caller — the
+ * status → code map is lossy (`queue_overflow` and `rate_limited` share 429).
+ * Any other body (HTML from a proxy, empty, malformed) gets a synthesized
+ * envelope whose code comes from `http_status_to_jsonrpc_error_code`.
+ * A 2xx whose body isn't a JSON-RPC response (an HTML fallback page, say)
+ * becomes an `internal_error` naming the status and content type.
  */
 export class FrontendHttpTransport {
     transport_name = 'frontend_http_rpc';
@@ -50,25 +58,38 @@ export class FrontendHttpTransport {
                     signal
                 });
             }
-            const result = await response.json();
-            // For JSON-RPC, we always expect a 200 OK response.
-            // The actual error will be in the JSON-RPC error field.
             if (!response.ok) {
-                return create_jsonrpc_error_response(to_jsonrpc_message_id(message), {
+                const id = to_jsonrpc_message_id(message);
+                const body = to_error_response_for(await read_json_body(response), id);
+                if (body) {
+                    // The code → status map is a function (the status → code direction is
+                    // lossy), so drift is checked in that direction.
+                    if (DEV) {
+                        const expected_status = jsonrpc_error_code_to_http_status(body.error.code);
+                        if (expected_status !== response.status) {
+                            console.warn(`[http_transport] JSON-RPC error code ${body.error.code} maps to HTTP ${expected_status} but the response status is ${response.status}`, body);
+                        }
+                    }
+                    return body;
+                }
+                return create_jsonrpc_error_response(id, {
                     code: http_status_to_jsonrpc_error_code(response.status),
-                    message: `HTTP error: ${response.status} ${response.statusText}`
+                    message: `HTTP error: ${response.status} ${response.statusText}`.trimEnd()
                 });
             }
-            // In development, check if we got a JSON-RPC error with HTTP 200
-            // and verify the error code matches the expected HTTP status.
-            if (DEV && is_jsonrpc_error_response(result)) {
-                const expected_code = http_status_to_jsonrpc_error_code(response.status);
-                const actual_code = result.error.code;
-                if (actual_code !== expected_code) {
-                    console.warn(`[http_transport] JSON-RPC error code mismatch: got ${actual_code} but ${response.status} should map to ${expected_code}`, result);
+            const body = await read_json_body(response);
+            if (is_jsonrpc_error_response(body)) {
+                // JSON-RPC errors should carry a non-2xx status (see `jsonrpc_error_code_to_http_status`).
+                if (DEV) {
+                    console.warn(`[http_transport] JSON-RPC error response with HTTP ${response.status}`, body);
                 }
+                return body;
             }
-            return result;
+            if (is_jsonrpc_response(body))
+                return body;
+            // a 2xx that isn't JSON-RPC — e.g. an HTML page from a static
+            // fallback or proxy answering the RPC path
+            return create_jsonrpc_error_response(to_jsonrpc_message_id(message), jsonrpc_error_messages.internal_error(`response is not JSON-RPC: HTTP ${response.status} ${response.headers.get('content-type') ?? 'without a content type'}`));
         }
         catch (error) {
             if (error instanceof ThrownJsonrpcError) {
@@ -87,3 +108,27 @@ export class FrontendHttpTransport {
         return true;
     }
 }
+/** Read a response body as JSON, or `undefined` when it's empty or not JSON. */
+const read_json_body = async (response) => {
+    try {
+        return JSON.parse(await response.text());
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * `body` as a well-formed JSON-RPC error response answering the request with
+ * `id` — echoing it, or `null` when the server couldn't read one — else `null`.
+ * Ids compare as strings: the GET convention sends the id as a query param,
+ * so a numeric id comes back as its string form.
+ */
+const to_error_response_for = (body, id) => {
+    const parsed = JsonrpcErrorResponse.safeParse(body);
+    if (!parsed.success)
+        return null;
+    const response = parsed.data;
+    if (response.id !== null && String(response.id) !== String(id))
+        return null;
+    return response;
+};

package/dist/actions/transports_ws.d.ts

@@ -16,8 +16,8 @@
  *
  * @module
  */
-import type { JsonrpcNotification, JsonrpcRequest, JsonrpcRequestId, JsonrpcResponseOrError, JsonrpcErrorResponse } from '../http/jsonrpc.js';
-import type { Transport, TransportSendOptions } from './transports.js';
+import type { JsonrpcNotification, JsonrpcRequest, JsonrpcRequestId, JsonrpcResponseOrError, JsonrpcErrorObject, JsonrpcErrorResponse } from '../http/jsonrpc.js';
+import { type Transport, type TransportSendOptions } from './transports.js';
 /**
  * Minimal interface for a WebSocket connection, decoupled from the concrete Socket Cell.
  */
@@ -46,6 +46,28 @@ export interface WebsocketRpcConnection extends WebsocketConnection {
         id?: JsonrpcRequestId;
     }) => Promise<unknown>;
 }
+/** Options for `FrontendWebsocketTransport`. */
+export interface FrontendWebsocketTransportOptions {
+    /**
+     * Largest outbound message, in UTF-8 bytes of its JSON encoding. A larger
+     * request or notification is refused with an `invalid_request` error
+     * (`data.reason` `payload_too_large`) without being sent — the server
+     * closes the socket on an oversized one (failing every request in flight
+     * on it) rather than replying with an error. Defaults to
+     * `DEFAULT_WS_MAX_MESSAGE_BYTES`, the server's default cap; a consumer
+     * that raises the server's `max_message_bytes` passes the same value
+     * here. `null` skips the measurement.
+     *
+     * @default DEFAULT_WS_MAX_MESSAGE_BYTES
+     */
+    max_message_bytes?: number | null;
+}
+/**
+ * The error `FrontendWebsocketTransport` answers an oversized message with —
+ * `invalid_request` (the whole message is refused) carrying
+ * `data.reason: 'payload_too_large'`, the REST 413's reason.
+ */
+export declare const create_message_too_large_error: (size: number, max_message_bytes: number) => JsonrpcErrorObject;
 /**
  * Thin adapter over `WebsocketRpcConnection` (canonical implementation:
  * `FrontendWebsocketClient`). Routes inbound server-pushed requests and
@@ -53,11 +75,14 @@ export interface WebsocketRpcConnection extends WebsocketConnection {
  * response back over the socket; an inbound `peer/ping` is answered by the
  * built-in responder before `receive`. Responses to requests *we* sent are
  * owned by the connection's own `request()` pending map and are ignored here.
+ * An oversized outbound message (`max_message_bytes`) fails with an error
+ * envelope instead of being sent (see
+ * `FrontendWebsocketTransportOptions`).
  */
 export declare class FrontendWebsocketTransport implements Transport {
     #private;
     readonly transport_name: "frontend_websocket_rpc";
-    constructor(connection: WebsocketRpcConnection, receive: (data: unknown) => Promise<unknown>);
+    constructor(connection: WebsocketRpcConnection, receive: (data: unknown) => Promise<unknown>, options?: FrontendWebsocketTransportOptions);
     send(message: JsonrpcRequest, options?: TransportSendOptions): Promise<JsonrpcResponseOrError>;
     send(message: JsonrpcNotification, options?: TransportSendOptions): Promise<JsonrpcErrorResponse | null>;
     is_ready(): boolean;

package/dist/actions/transports_ws.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transports_ws.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/transports_ws.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAaH,OAAO,KAAK,EAGX,mBAAmB,EACnB,cAAc,EACd,gBAAgB,EAChB,sBAAsB,EACtB,oBAAoB,EACpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAKvE;;GAEG;AACH,MAAM,WAAW,mBAAmB;IACnC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,mBAAmB,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;IAC5E,iBAAiB,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;CACnE;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,sBAAuB,SAAQ,mBAAmB;IAClE,OAAO,EAAE,CACR,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,EAAE,CAAC,EAAE,gBAAgB,CAAA;KAAE,KACtE,OAAO,CAAC,OAAO,CAAC,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,qBAAa,0BAA2B,YAAW,SAAS;;IAC3D,QAAQ,CAAC,cAAc,EAAG,wBAAwB,CAAU;gBAOhD,UAAU,EAAE,sBAAsB,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC;IAkDtF,IAAI,CACT,OAAO,EAAE,cAAc,EACvB,OAAO,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,sBAAsB,CAAC;IAC5B,IAAI,CACT,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IA0DvC,QAAQ,IAAI,OAAO;IAInB;;;;;;OAMG;IACH,OAAO,IAAI,IAAI;CAUf"}
+{"version":3,"file":"transports_ws.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/transports_ws.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAiBH,OAAO,KAAK,EAGX,mBAAmB,EACnB,cAAc,EACd,gBAAgB,EAChB,sBAAsB,EACtB,kBAAkB,EAClB,oBAAoB,EAEpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAGN,KAAK,SAAS,EACd,KAAK,oBAAoB,EACzB,MAAM,iBAAiB,CAAC;AAKzB;;GAEG;AACH,MAAM,WAAW,mBAAmB;IACnC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,mBAAmB,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;IAC5E,iBAAiB,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;CACnE;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,sBAAuB,SAAQ,mBAAmB;IAClE,OAAO,EAAE,CACR,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,EAAE,CAAC,EAAE,gBAAgB,CAAA;KAAE,KACtE,OAAO,CAAC,OAAO,CAAC,CAAC;CACtB;AAED,gDAAgD;AAChD,MAAM,WAAW,iCAAiC;IACjD;;;;;;;;;;;OAWG;IACH,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAED;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,GAC1C,MAAM,MAAM,EACZ,mBAAmB,MAAM,KACvB,kBAID,CAAC;AAEH;;;;;;;;;;GAUG;AACH,qBAAa,0BAA2B,YAAW,SAAS;;IAC3D,QAAQ,CAAC,cAAc,EAAG,wBAAwB,CAAU;gBAS3D,UAAU,EAAE,sBAAsB,EAClC,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,EAC5C,OAAO,CAAC,EAAE,iCAAiC;IAsDtC,IAAI,CACT,OAAO,EAAE,cAAc,EACvB,OAAO,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,sBAAsB,CAAC;IAC5B,IAAI,CACT,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IAuEvC,QAAQ,IAAI,OAAO;IAInB;;;;;;OAMG;IACH,OAAO,IAAI,IAAI;CAUf"}

package/dist/actions/transports_ws.js

@@ -17,9 +17,21 @@
  * @module
  */
 import { to_error_message } from '@fuzdev/fuz_util/error.ts';
-import { ThrownJsonrpcError, jsonrpc_error_messages } from '../http/jsonrpc_errors.js';
-import { is_jsonrpc_notification, is_jsonrpc_request, to_jsonrpc_message_id, to_jsonrpc_result, create_jsonrpc_response, create_jsonrpc_error_response } from '../http/jsonrpc_helpers.js';
+import { JSONRPC_ERROR_CODES, ThrownJsonrpcError, jsonrpc_error_messages } from '../http/jsonrpc_errors.js';
+import { ERROR_PAYLOAD_TOO_LARGE } from '../http/error_schemas.js';
+import { is_jsonrpc_notification, is_jsonrpc_request, to_jsonrpc_message_id, create_jsonrpc_response, create_jsonrpc_error_response } from '../http/jsonrpc_helpers.js';
+import { DEFAULT_WS_MAX_MESSAGE_BYTES, utf8_length_over } from './transports.js';
 import { PEER_PING_METHOD, peer_ping_responder } from './peer_ping.js';
+/**
+ * The error `FrontendWebsocketTransport` answers an oversized message with —
+ * `invalid_request` (the whole message is refused) carrying
+ * `data.reason: 'payload_too_large'`, the REST 413's reason.
+ */
+export const create_message_too_large_error = (size, max_message_bytes) => ({
+    code: JSONRPC_ERROR_CODES.invalid_request,
+    message: `message too large: ${size} bytes exceeds the ${max_message_bytes}-byte limit`,
+    data: { reason: ERROR_PAYLOAD_TOO_LARGE }
+});
 /**
  * Thin adapter over `WebsocketRpcConnection` (canonical implementation:
  * `FrontendWebsocketClient`). Routes inbound server-pushed requests and
@@ -27,6 +39,9 @@ import { PEER_PING_METHOD, peer_ping_responder } from './peer_ping.js';
  * response back over the socket; an inbound `peer/ping` is answered by the
  * built-in responder before `receive`. Responses to requests *we* sent are
  * owned by the connection's own `request()` pending map and are ignored here.
+ * An oversized outbound message (`max_message_bytes`) fails with an error
+ * envelope instead of being sent (see
+ * `FrontendWebsocketTransportOptions`).
  */
 export class FrontendWebsocketTransport {
     transport_name = 'frontend_websocket_rpc';
@@ -34,9 +49,13 @@ export class FrontendWebsocketTransport {
     #receive;
     #remove_message_handler;
     #remove_error_handler;
-    constructor(connection, receive) {
+    #max_message_bytes;
+    constructor(connection, receive, options) {
         this.#connection = connection;
         this.#receive = receive;
+        const max_message_bytes = options?.max_message_bytes;
+        this.#max_message_bytes =
+            max_message_bytes === undefined ? DEFAULT_WS_MAX_MESSAGE_BYTES : max_message_bytes;
         // Inbound dispatch — only server-pushed requests/notifications need
         // routing here. Responses to requests we sent are correlated by the
         // connection's own `request()` pending map.
@@ -91,6 +110,15 @@ export class FrontendWebsocketTransport {
         // error frames), and the catch block below preserves that code
         // verbatim in the error envelope. Queuing is routed via `queue`.
         const queue = options?.queue ?? false;
+        if (this.#max_message_bytes !== null) {
+            // TODO measure where the frame is serialized (the connection's `send`)
+            // so a sent message isn't stringified twice — needs the size check on
+            // the `WebsocketRpcConnection` contract
+            const size = utf8_length_over(JSON.stringify(message), this.#max_message_bytes);
+            if (size !== null) {
+                return create_jsonrpc_error_response(to_jsonrpc_message_id(message), create_message_too_large_error(size, this.#max_message_bytes));
+            }
+        }
         if (is_jsonrpc_notification(message) && !this.is_ready()) {
             return create_jsonrpc_error_response(to_jsonrpc_message_id(message), jsonrpc_error_messages.service_unavailable('WebSocket not connected'));
         }
@@ -101,7 +129,8 @@ export class FrontendWebsocketTransport {
                     signal: options?.signal,
                     queue
                 });
-                return create_jsonrpc_response(message.id, to_jsonrpc_result(result));
+                // any JSON value is a valid result — `null`, primitives, and arrays pass through
+                return create_jsonrpc_response(message.id, result);
             }
             catch (error) {
                 if (error instanceof ThrownJsonrpcError) {

package/dist/actions/ws_endpoint_spec.d.ts

@@ -60,6 +60,13 @@ export interface WsEndpointSpec {
     heartbeat?: boolean | ServerHeartbeatOptions;
     /** Optional per-message delay for testing loading states. */
     artificial_delay?: number;
+    /**
+     * Cap on one inbound message, in bytes. See
+     * `RegisterActionWsOptions.max_message_bytes`.
+     *
+     * @default DEFAULT_WS_MAX_MESSAGE_BYTES
+     */
+    max_message_bytes?: number;
     /**
      * Called once per socket after `transport.add_connection` but before
      * the first message dispatches. See

package/dist/actions/ws_endpoint_spec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ws_endpoint_spec.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/ws_endpoint_spec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAC5E,OAAO,KAAK,EACX,sBAAsB,EACtB,kBAAkB,EAClB,iBAAiB,EACjB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAEvE;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC9B,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,eAAe,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACvC;;;;;OAKG;IACH,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC/B;;;;;OAKG;IACH,cAAc,CAAC,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;IACzC;;;;OAIG;IACH,SAAS,CAAC,EAAE,yBAAyB,CAAC;IACtC;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,sBAAsB,CAAC;IAC7C,6DAA6D;IAC7D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,iBAAiB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE;;;OAGG;IACH,eAAe,CAAC,EAAE,CAAC,GAAG,EAAE,kBAAkB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;;;;OAQG;IACH,oBAAoB,CAAC,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;CACxD"}
+{"version":3,"file":"ws_endpoint_spec.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/ws_endpoint_spec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAC5E,OAAO,KAAK,EACX,sBAAsB,EACtB,kBAAkB,EAClB,iBAAiB,EACjB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAEvE;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC9B,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,eAAe,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACvC;;;;;OAKG;IACH,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC/B;;;;;OAKG;IACH,cAAc,CAAC,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;IACzC;;;;OAIG;IACH,SAAS,CAAC,EAAE,yBAAyB,CAAC;IACtC;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,sBAAsB,CAAC;IAC7C,6DAA6D;IAC7D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,iBAAiB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE;;;OAGG;IACH,eAAe,CAAC,EAAE,CAAC,GAAG,EAAE,kBAAkB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;;;;OAQG;IACH,oBAAoB,CAAC,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;CACxD"}