@fuzdev/fuz_app 0.133.0 → 0.135.0

package/dist/actions/transports_ws_backend.d.ts

@@ -44,6 +44,56 @@
  * uses the two-phase form. The twin of the Rust `fuz_realtime`
  * `ConnectionRegistry`.
  *
+ * ## Outbound bound
+ *
+ * Every frame the server sends a connection goes through one path —
+ * `send_to`, which responses, error frames and socket-scoped notifications
+ * use, and the fan-outs (`send`, `broadcast_filtered`, `send_to_account`,
+ * `request_connection`) — into the connection's `WsOutboundWriter`
+ * (`actions/ws_outbound_writer.ts`). A send never waits and never throws: one
+ * recipient that stopped reading must not slow a producer or another
+ * recipient.
+ *
+ * What waits for a socket is held to a byte budget, `outbound_queue_bytes`
+ * (`DEFAULT_WS_OUTBOUND_QUEUE_BYTES`): each waiting frame is charged its UTF-8
+ * length plus `OUTBOUND_FRAME_OVERHEAD_BYTES`, and a frame is always accepted
+ * when nothing is waiting. Nothing counts frames. A frame sent to an idle
+ * connection goes straight to the socket; the rest of a burst sent in one
+ * synchronous run waits, as does anything sent while the socket's own buffer
+ * is backed up.
+ *
+ * A frame that does not fit **closes the connection** rather than being
+ * dropped alone: the connection is removed in the same synchronous step — the
+ * overflowing send does not count it, later sends miss it, the count accessors
+ * and the cap no longer see it — its controller is aborted, what was waiting
+ * is discarded, and the socket is closed with `WS_CLOSE_OUTBOUND_OVERFLOW`.
+ * Frames already handed to the socket may still reach the client ahead of the
+ * close frame; nothing follows it, the response of the request whose handler
+ * overflowed the connection included. One `warn` line names the connection,
+ * its account, and what was waiting; no audit row is written — a client can
+ * provoke an overflow at will, and a write per overflow would amplify it.
+ *
+ * A socket that holds unwritten bytes past `WS_WRITE_STALL_TIMEOUT` is dropped
+ * with no close frame, and removed the same way, with one `warn` line. Every
+ * other close the transport makes (a revocation, the cap, the shutdown,
+ * `close_connection`) hands the frames still waiting to the socket ahead of
+ * its close frame while the socket's buffer is below
+ * `WS_WRITE_HIGH_WATER_BYTES`, discards the rest, and cuts the socket if the
+ * close frame is still unwritten after `WS_CLOSE_WRITE_TIMEOUT`. A reply sent
+ * to an otherwise idle connection just before such a close reaches the client;
+ * one queued behind a backed-up socket does not.
+ *
+ * A connection the transport closed or dropped is out of its map, so the
+ * per-account cap does not count it while its socket is still closing. What
+ * the runtime holds for such a socket is bounded by the writer
+ * (`actions/ws_outbound_writer.ts`, "Closing" and "Runtimes").
+ *
+ * The twin of the Rust `fuz_realtime` outbound queue — same budget, charge,
+ * close code and deadlines. Where they differ: the Rust spine discards every
+ * frame queued before any close, and queues every frame, where this transport
+ * writes the first frame of a run straight through and, at a close that is
+ * not an overflow, the waiting frames its socket has room for.
+ *
  * ## Shutdown
  *
  * `close_all_sockets` — the close `AppServer.close` runs — closes every
@@ -110,6 +160,18 @@ export declare const is_filterable_broadcast_transport: (transport: Transport) =
  * spine's `DEFAULT_MAX_CONNECTIONS_PER_ACCOUNT`.
  */
 export declare const DEFAULT_MAX_CONNECTIONS_PER_ACCOUNT = 50;
+/**
+ * Default byte budget of the frames waiting to be written to one connection,
+ * applied by `BackendWebsocketTransport` unless overridden via
+ * `BackendWebsocketTransportOptions.outbound_queue_bytes`.
+ *
+ * 4 MiB — four messages at `DEFAULT_WS_MAX_MESSAGE_BYTES` as it stands, and a
+ * value of its own: it does not move with the inbound message cap. A consumer
+ * whose server pushes more than this at a client in one burst — large frames,
+ * or long runs of them — sets its own. Same value as the Rust spine's
+ * `DEFAULT_WS_OUTBOUND_QUEUE_BYTES`.
+ */
+export declare const DEFAULT_WS_OUTBOUND_QUEUE_BYTES: number;
 /** Options for `BackendWebsocketTransport`. */
 export interface BackendWebsocketTransportOptions {
     /**
@@ -129,7 +191,21 @@ export interface BackendWebsocketTransportOptions {
      */
     max_connections_per_account?: number | null;
     /**
-     * Logger for cap evictions and failed sends or closes. A cap eviction logs
+     * Byte budget of the frames waiting to be written to one connection. Each
+     * waiting frame is charged its UTF-8 length plus
+     * `OUTBOUND_FRAME_OVERHEAD_BYTES`; a frame that does not fit closes the
+     * connection with `WS_CLOSE_OUTBOUND_OVERFLOW`, and a frame is always
+     * accepted when nothing is waiting, so one message larger than the whole
+     * budget is still deliverable (module doc, "Outbound bound"). Not derived
+     * from the inbound message cap.
+     *
+     * @default DEFAULT_WS_OUTBOUND_QUEUE_BYTES
+     */
+    outbound_queue_bytes?: number;
+    /**
+     * Logger for cap evictions, outbound overflows and stalls, and failed sends
+     * or closes. An overflow or a stall logs one `warn` line — the connection,
+     * its account, and what was waiting. A cap eviction logs
      * at info — the account, how many connections were closed, and the cap —
      * so an operator can see a client that keeps meeting it. Unset falls back
      * to a `[ws]` logger; `null` silences it. `register_action_ws` passes its
@@ -142,7 +218,7 @@ export declare class BackendWebsocketTransport implements FilterableBroadcastTra
     readonly transport_name: "backend_websocket_rpc";
     /**
      * @throws Error when `max_connections_per_account` is neither `null` nor a
-     *   positive integer
+     *   positive integer, or `outbound_queue_bytes` is not a positive integer
      */
     constructor(options?: BackendWebsocketTransportOptions);
     /**
@@ -155,8 +231,9 @@ export declare class BackendWebsocketTransport implements FilterableBroadcastTra
      * later `admit` then refuses. Until admitted it evicts nothing, is not
      * counted toward the per-account cap, and receives no message.
      *
-     * The caller owns the entry until it is admitted: every refusal path calls
-     * `remove_connection` with the returned id.
+     * The caller owns the entry until it is admitted: a refusal closes it with
+     * `close_connection`, and `remove_connection` drops it once its socket has
+     * closed.
      *
      * Once the transport is closing (`close_all_sockets`) the registration is
      * born closed: nothing is inserted, `abort_controller` is aborted, and `ws`
@@ -235,12 +312,36 @@ export declare class BackendWebsocketTransport implements FilterableBroadcastTra
      *
      * Removal only: the socket is not closed and the registered
      * `abort_controller` is not aborted — the caller that ends a socket does
-     * both.
+     * both. What was waiting to be written to it is dropped.
      *
-     * @mutates this - deletes the connection's entry from `#connections` and
-     *   settles its pending peer requests as `connection_gone`
+     * For a socket that has closed (an adapter's close event): on a connection
+     * the transport closed it also drops the close deadline, so calling it while
+     * that socket is still closing leaves a client that is not reading uncut.
+     *
+     * @mutates this - deletes the connection's entry from `#connections`, drops
+     *   its waiting frames and write deadlines, and settles its pending peer
+     *   requests as `connection_gone`
      */
     remove_connection(connection_id: Uuid): void;
+    /**
+     * Close one connection, pending or admitted, with `code` and `reason` — the
+     * close `register_action_ws` makes for a heartbeat timeout, an oversized
+     * message, a failed `on_socket_open`, and a refused admission.
+     *
+     * The connection is removed and its controller aborted at once; frames still
+     * waiting for the socket are handed to it ahead of the close frame while its
+     * buffer has room and discarded otherwise, and the close frame is held to
+     * `WS_CLOSE_WRITE_TIMEOUT` (module doc, "Outbound bound"). A socket whose
+     * `close` throws is logged, not thrown.
+     *
+     * @param connection_id - the id `register_pending` / `add_connection` returned
+     * @param code - the close code
+     * @param reason - the close reason
+     * @returns `false` when the connection is not registered — nothing was closed
+     * @mutates this - removes the connection, aborts its registered controller,
+     *   and closes its `WSContext`
+     */
+    close_connection(connection_id: Uuid, code: number, reason: string): boolean;
     /**
      * Close all sockets associated with a specific session token hash,
      * including a registration still pending admission.
@@ -312,7 +413,10 @@ export declare class BackendWebsocketTransport implements FilterableBroadcastTra
      * When no ACL is needed, callers should prefer `send(message)` / `#broadcast`
      * to skip the per-connection predicate overhead.
      *
-     * @returns the number of sockets the message was sent to
+     * A connection the message overflows is closed and not counted (module doc,
+     * "Outbound bound").
+     *
+     * @returns the number of connections that accepted the message
      */
     broadcast_filtered(message: JsonrpcMessageFromServerToClient, predicate: (identity: ConnectionIdentity) => boolean): number;
     /**
@@ -327,9 +431,28 @@ export declare class BackendWebsocketTransport implements FilterableBroadcastTra
      * for the account (session, bearer, and daemon-token) receives the
      * message.
      *
-     * @returns the number of sockets the message was sent to
+     * @returns the number of connections that accepted the message
      */
     send_to_account(account_id: Uuid, message: JsonrpcMessageFromServerToClient): number;
+    /**
+     * Send one serialized frame to a single admitted connection — the path
+     * `register_action_ws` sends every response, error frame, and socket-scoped
+     * notification through.
+     *
+     * Never waits and never throws. A frame the connection's outbound budget
+     * does not fit closes the connection with `WS_CLOSE_OUTBOUND_OVERFLOW` before
+     * this returns (module doc, "Outbound bound").
+     *
+     * @param connection_id - the id `register_pending` / `add_connection` returned
+     * @param frame - the frame's text, already serialized
+     * @returns `false` when the frame was not accepted: the connection is not
+     *   registered, is still pending admission, or was just closed for the
+     *   overflow this frame caused
+     * @mutates this - queues the frame on the connection's writer; on an
+     *   overflow removes the connection, aborts its controller, and closes its
+     *   `WSContext`
+     */
+    send_to(connection_id: Uuid, frame: string): boolean;
     /**
      * Initiate a JSON-RPC request to a single connected client and await its
      * reply — the server→client request/response direction (ActionPeer).

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

@@ -1 +1 @@
-{"version":3,"file":"transports_ws_backend.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/transports_ws_backend.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"transports_ws_backend.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/transports_ws_backend.ts"],"names":[],"mappings":"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"}

package/dist/actions/transports_ws_backend.js

@@ -44,6 +44,56 @@
  * uses the two-phase form. The twin of the Rust `fuz_realtime`
  * `ConnectionRegistry`.
  *
+ * ## Outbound bound
+ *
+ * Every frame the server sends a connection goes through one path —
+ * `send_to`, which responses, error frames and socket-scoped notifications
+ * use, and the fan-outs (`send`, `broadcast_filtered`, `send_to_account`,
+ * `request_connection`) — into the connection's `WsOutboundWriter`
+ * (`actions/ws_outbound_writer.ts`). A send never waits and never throws: one
+ * recipient that stopped reading must not slow a producer or another
+ * recipient.
+ *
+ * What waits for a socket is held to a byte budget, `outbound_queue_bytes`
+ * (`DEFAULT_WS_OUTBOUND_QUEUE_BYTES`): each waiting frame is charged its UTF-8
+ * length plus `OUTBOUND_FRAME_OVERHEAD_BYTES`, and a frame is always accepted
+ * when nothing is waiting. Nothing counts frames. A frame sent to an idle
+ * connection goes straight to the socket; the rest of a burst sent in one
+ * synchronous run waits, as does anything sent while the socket's own buffer
+ * is backed up.
+ *
+ * A frame that does not fit **closes the connection** rather than being
+ * dropped alone: the connection is removed in the same synchronous step — the
+ * overflowing send does not count it, later sends miss it, the count accessors
+ * and the cap no longer see it — its controller is aborted, what was waiting
+ * is discarded, and the socket is closed with `WS_CLOSE_OUTBOUND_OVERFLOW`.
+ * Frames already handed to the socket may still reach the client ahead of the
+ * close frame; nothing follows it, the response of the request whose handler
+ * overflowed the connection included. One `warn` line names the connection,
+ * its account, and what was waiting; no audit row is written — a client can
+ * provoke an overflow at will, and a write per overflow would amplify it.
+ *
+ * A socket that holds unwritten bytes past `WS_WRITE_STALL_TIMEOUT` is dropped
+ * with no close frame, and removed the same way, with one `warn` line. Every
+ * other close the transport makes (a revocation, the cap, the shutdown,
+ * `close_connection`) hands the frames still waiting to the socket ahead of
+ * its close frame while the socket's buffer is below
+ * `WS_WRITE_HIGH_WATER_BYTES`, discards the rest, and cuts the socket if the
+ * close frame is still unwritten after `WS_CLOSE_WRITE_TIMEOUT`. A reply sent
+ * to an otherwise idle connection just before such a close reaches the client;
+ * one queued behind a backed-up socket does not.
+ *
+ * A connection the transport closed or dropped is out of its map, so the
+ * per-account cap does not count it while its socket is still closing. What
+ * the runtime holds for such a socket is bounded by the writer
+ * (`actions/ws_outbound_writer.ts`, "Closing" and "Runtimes").
+ *
+ * The twin of the Rust `fuz_realtime` outbound queue — same budget, charge,
+ * close code and deadlines. Where they differ: the Rust spine discards every
+ * frame queued before any close, and queues every frame, where this transport
+ * writes the first frame of a run straight through and, at a close that is
+ * not an overflow, the waiting frames its socket has room for.
+ *
  * ## Shutdown
  *
  * `close_all_sockets` — the close `AppServer.close` runs — closes every
@@ -67,8 +117,9 @@ import { Logger } from '@fuzdev/fuz_util/log.ts';
 import { create_uuid } from '@fuzdev/fuz_util/id.ts';
 import { jsonrpc_error_messages } from '../http/jsonrpc_errors.js';
 import { create_jsonrpc_error_response, create_jsonrpc_request, to_jsonrpc_message_id, is_jsonrpc_request } from '../http/jsonrpc_helpers.js';
-import { WS_CLOSE_CONNECTION_LIMIT, WS_CLOSE_GOING_AWAY, WS_CLOSE_GOING_AWAY_REASON, WS_CLOSE_SESSION_REVOKED, WS_CLOSE_SESSION_REVOKED_REASON } from './transports.js';
+import { WS_CLOSE_CONNECTION_LIMIT, WS_CLOSE_GOING_AWAY, WS_CLOSE_GOING_AWAY_REASON, WS_CLOSE_OUTBOUND_OVERFLOW, WS_CLOSE_OUTBOUND_OVERFLOW_REASON, WS_CLOSE_SESSION_REVOKED, WS_CLOSE_SESSION_REVOKED_REASON, utf8_length } from './transports.js';
 import { PendingPeerRequests } from './peer_request.js';
+import { WsOutboundWriter } from './ws_outbound_writer.js';
 /** Type guard for `FilterableBroadcastTransport`. */
 export const is_filterable_broadcast_transport = (transport) => 'broadcast_filtered' in transport &&
     typeof transport.broadcast_filtered === 'function';
@@ -84,16 +135,34 @@ export const is_filterable_broadcast_transport = (transport) => 'broadcast_filte
  * spine's `DEFAULT_MAX_CONNECTIONS_PER_ACCOUNT`.
  */
 export const DEFAULT_MAX_CONNECTIONS_PER_ACCOUNT = 50;
+/**
+ * Default byte budget of the frames waiting to be written to one connection,
+ * applied by `BackendWebsocketTransport` unless overridden via
+ * `BackendWebsocketTransportOptions.outbound_queue_bytes`.
+ *
+ * 4 MiB — four messages at `DEFAULT_WS_MAX_MESSAGE_BYTES` as it stands, and a
+ * value of its own: it does not move with the inbound message cap. A consumer
+ * whose server pushes more than this at a client in one burst — large frames,
+ * or long runs of them — sets its own. Same value as the Rust spine's
+ * `DEFAULT_WS_OUTBOUND_QUEUE_BYTES`.
+ */
+export const DEFAULT_WS_OUTBOUND_QUEUE_BYTES = 4 * 1024 * 1024;
 export class BackendWebsocketTransport {
     transport_name = 'backend_websocket_rpc';
     // Per-account connection cap; `null` = uncapped.
     #max_connections_per_account;
+    // Byte budget of each connection's waiting frames.
+    #outbound_queue_bytes;
     #log;
     // One entry per registered connection, pending or admitted, in
     // registration order (Map iteration is insertion order — the cap's
     // "oldest"). Adding a new identity scope (e.g. `device_id`) means adding a
     // field to `ConnectionIdentity`, not a parallel map.
     #connections = new Map();
+    // Writers of connections the transport has closed, until their socket's
+    // close arrives (`remove_connection`) or the close deadline passes — so the
+    // deadline timer is cleared when the socket goes.
+    #closing_writers = new Map();
     // set once by `close_all_sockets`, never cleared — every later
     // registration is born closed (module doc, "Shutdown")
     #closing = false;
@@ -103,7 +172,7 @@ export class BackendWebsocketTransport {
     #pending = new PendingPeerRequests();
     /**
      * @throws Error when `max_connections_per_account` is neither `null` nor a
-     *   positive integer
+     *   positive integer, or `outbound_queue_bytes` is not a positive integer
      */
     constructor(options) {
         const max = options?.max_connections_per_account === undefined
@@ -113,6 +182,13 @@ export class BackendWebsocketTransport {
             throw new Error(`BackendWebsocketTransport: max_connections_per_account must be a positive integer or null, got ${max}`);
         }
         this.#max_connections_per_account = max;
+        const outbound_queue_bytes = options?.outbound_queue_bytes ?? DEFAULT_WS_OUTBOUND_QUEUE_BYTES;
+        if (!Number.isSafeInteger(outbound_queue_bytes) || outbound_queue_bytes < 1) {
+            // zero would close a connection for the first frame queued behind one
+            // still waiting
+            throw new Error(`BackendWebsocketTransport: outbound_queue_bytes must be a positive integer, got ${outbound_queue_bytes}`);
+        }
+        this.#outbound_queue_bytes = outbound_queue_bytes;
         this.#log = options?.log === undefined ? new Logger('[ws]') : options.log;
     }
     /**
@@ -125,8 +201,9 @@ export class BackendWebsocketTransport {
      * later `admit` then refuses. Until admitted it evicts nothing, is not
      * counted toward the per-account cap, and receives no message.
      *
-     * The caller owns the entry until it is admitted: every refusal path calls
-     * `remove_connection` with the returned id.
+     * The caller owns the entry until it is admitted: a refusal closes it with
+     * `close_connection`, and `remove_connection` drops it once its socket has
+     * closed.
      *
      * Once the transport is closing (`close_all_sockets`) the registration is
      * born closed: nothing is inserted, `abort_controller` is aborted, and `ws`
@@ -223,7 +300,13 @@ export class BackendWebsocketTransport {
             ws,
             identity: { token_hash, account_id, api_token_id },
             admitted,
-            abort_controller
+            abort_controller,
+            writer: new WsOutboundWriter({
+                ws,
+                max_bytes: this.#outbound_queue_bytes,
+                on_stall: (stall) => this.#drop_stalled(connection_id, stall),
+                log: this.#log
+            })
         });
         return connection_id;
     }
@@ -239,14 +322,56 @@ export class BackendWebsocketTransport {
      *
      * Removal only: the socket is not closed and the registered
      * `abort_controller` is not aborted — the caller that ends a socket does
-     * both.
+     * both. What was waiting to be written to it is dropped.
+     *
+     * For a socket that has closed (an adapter's close event): on a connection
+     * the transport closed it also drops the close deadline, so calling it while
+     * that socket is still closing leaves a client that is not reading uncut.
      *
-     * @mutates this - deletes the connection's entry from `#connections` and
-     *   settles its pending peer requests as `connection_gone`
+     * @mutates this - deletes the connection's entry from `#connections`, drops
+     *   its waiting frames and write deadlines, and settles its pending peer
+     *   requests as `connection_gone`
      */
     remove_connection(connection_id) {
+        this.#connections.get(connection_id)?.writer.dispose();
+        // a connection the transport closed: its socket is gone now
+        const closing = this.#closing_writers.get(connection_id);
+        if (closing) {
+            closing.dispose();
+            this.#closing_writers.delete(connection_id);
+        }
         this.#cleanup_connection(connection_id);
     }
+    /**
+     * Close one connection, pending or admitted, with `code` and `reason` — the
+     * close `register_action_ws` makes for a heartbeat timeout, an oversized
+     * message, a failed `on_socket_open`, and a refused admission.
+     *
+     * The connection is removed and its controller aborted at once; frames still
+     * waiting for the socket are handed to it ahead of the close frame while its
+     * buffer has room and discarded otherwise, and the close frame is held to
+     * `WS_CLOSE_WRITE_TIMEOUT` (module doc, "Outbound bound"). A socket whose
+     * `close` throws is logged, not thrown.
+     *
+     * @param connection_id - the id `register_pending` / `add_connection` returned
+     * @param code - the close code
+     * @param reason - the close reason
+     * @returns `false` when the connection is not registered — nothing was closed
+     * @mutates this - removes the connection, aborts its registered controller,
+     *   and closes its `WSContext`
+     */
+    close_connection(connection_id, code, reason) {
+        const entry = this.#connections.get(connection_id);
+        if (!entry)
+            return false;
+        try {
+            this.#end_connection(connection_id, entry, code, reason);
+        }
+        catch (error) {
+            this.#log?.error(`error closing client with ${code}:`, error);
+        }
+        return true;
+    }
     /**
      * Close every connection whose identity matches the predicate — pending or
      * admitted. Never filter on admission here: reaching a registration in
@@ -384,12 +509,63 @@ export class BackendWebsocketTransport {
         // gone, so the request can never complete.
         this.#pending.drain(connection_id);
     }
-    #end_connection(connection_id, entry, code, reason) {
+    #end_connection(connection_id, entry, code, reason, backlog = 'flush') {
         this.#cleanup_connection(connection_id);
         // abort before the close so a handler observing `ctx.signal` bails out
         // without waiting for the close handshake
         entry.abort_controller?.abort();
-        entry.ws.close(code, reason);
+        this.#closing_writers.set(connection_id, entry.writer);
+        entry.writer.close(code, reason, backlog, () => {
+            this.#closing_writers.delete(connection_id);
+        });
+    }
+    /**
+     * Hand one frame to a connection's writer. An overflow closes the
+     * connection before this returns (module doc, "Outbound bound").
+     *
+     * @param bytes - the frame's UTF-8 length, when the caller measured it once
+     *   for several recipients
+     * @returns whether the frame was accepted
+     */
+    #deliver(connection_id, entry, frame, bytes) {
+        const pushed = entry.writer.push(frame, bytes);
+        if (pushed.kind === 'accepted')
+            return true;
+        if (pushed.kind === 'overflow') {
+            this.#close_overflowed(connection_id, entry, pushed.overflow);
+        }
+        return false;
+    }
+    #close_overflowed(connection_id, entry, overflow) {
+        // same line as the Rust spine's registry, so one grep finds either
+        this.#log?.warn('ws: outbound queue overflow, closing the connection', {
+            connection_id,
+            account_id: entry.identity.account_id,
+            ...overflow
+        });
+        try {
+            this.#end_connection(connection_id, entry, WS_CLOSE_OUTBOUND_OVERFLOW, WS_CLOSE_OUTBOUND_OVERFLOW_REASON, 'discard');
+        }
+        catch (error) {
+            // the producer that overflowed this connection must not fail for it
+            this.#log?.error('error closing overflowed client:', error);
+        }
+    }
+    /**
+     * A connection's write deadline passed: remove it and abort its controller.
+     * Its writer has discarded what was waiting and cuts the socket next.
+     */
+    #drop_stalled(connection_id, stall) {
+        const entry = this.#connections.get(connection_id);
+        if (!entry)
+            return;
+        this.#cleanup_connection(connection_id);
+        this.#log?.warn('ws: write stalled, dropping the connection', {
+            connection_id,
+            account_id: entry.identity.account_id,
+            ...stall
+        });
+        entry.abort_controller?.abort();
     }
     /**
      * Make room for one more admitted connection on `account_id`: when the
@@ -416,10 +592,8 @@ export class BackendWebsocketTransport {
         this.#log?.info('ws: connection cap closed oldest', { account_id, closed: excess, max });
     }
     #supersede_connection(connection_id, entry) {
-        this.#cleanup_connection(connection_id);
         try {
-            entry.abort_controller?.abort();
-            entry.ws.close(WS_CLOSE_CONNECTION_LIMIT, 'connection limit');
+            this.#end_connection(connection_id, entry, WS_CLOSE_CONNECTION_LIMIT, 'connection limit');
         }
         catch (error) {
             // the evicted socket is another connection's — a failure closing it
@@ -442,16 +616,15 @@ export class BackendWebsocketTransport {
     }
     #broadcast(message) {
         const serialized = JSON.stringify(message);
-        for (const entry of this.#connections.values()) {
+        // measured once, not once per recipient that has to queue it
+        const bytes = utf8_length(serialized);
+        // deleting the current entry during Map iteration is safe — an overflow
+        // removes its connection
+        for (const [connection_id, entry] of this.#connections) {
             // a registration pending admission is not a connection yet
             if (!entry.admitted)
                 continue;
-            try {
-                entry.ws.send(serialized);
-            }
-            catch (error) {
-                this.#log?.error('error broadcasting to client:', error);
-            }
+            this.#deliver(connection_id, entry, serialized, bytes);
         }
         // TODO hack - remove if not ever needed, I assume this will need to be async so let's hold that assumption
         return Promise.resolve();
@@ -465,21 +638,21 @@ export class BackendWebsocketTransport {
      * When no ACL is needed, callers should prefer `send(message)` / `#broadcast`
      * to skip the per-connection predicate overhead.
      *
-     * @returns the number of sockets the message was sent to
+     * A connection the message overflows is closed and not counted (module doc,
+     * "Outbound bound").
+     *
+     * @returns the number of connections that accepted the message
      */
     broadcast_filtered(message, predicate) {
         const serialized = JSON.stringify(message);
+        // measured once, not once per recipient that has to queue it
+        const bytes = utf8_length(serialized);
         let count = 0;
-        for (const entry of this.#connections.values()) {
+        for (const [connection_id, entry] of this.#connections) {
             if (!entry.admitted || !predicate(entry.identity))
                 continue;
-            try {
-                entry.ws.send(serialized);
+            if (this.#deliver(connection_id, entry, serialized, bytes))
                 count++;
-            }
-            catch (error) {
-                this.#log?.error('error broadcasting filtered to client:', error);
-            }
         }
         return count;
     }
@@ -495,11 +668,35 @@ export class BackendWebsocketTransport {
      * for the account (session, bearer, and daemon-token) receives the
      * message.
      *
-     * @returns the number of sockets the message was sent to
+     * @returns the number of connections that accepted the message
      */
     send_to_account(account_id, message) {
         return this.broadcast_filtered(message, (id) => id.account_id === account_id);
     }
+    /**
+     * Send one serialized frame to a single admitted connection — the path
+     * `register_action_ws` sends every response, error frame, and socket-scoped
+     * notification through.
+     *
+     * Never waits and never throws. A frame the connection's outbound budget
+     * does not fit closes the connection with `WS_CLOSE_OUTBOUND_OVERFLOW` before
+     * this returns (module doc, "Outbound bound").
+     *
+     * @param connection_id - the id `register_pending` / `add_connection` returned
+     * @param frame - the frame's text, already serialized
+     * @returns `false` when the frame was not accepted: the connection is not
+     *   registered, is still pending admission, or was just closed for the
+     *   overflow this frame caused
+     * @mutates this - queues the frame on the connection's writer; on an
+     *   overflow removes the connection, aborts its controller, and closes its
+     *   `WSContext`
+     */
+    send_to(connection_id, frame) {
+        const entry = this.#connections.get(connection_id);
+        if (!entry?.admitted)
+            return false;
+        return this.#deliver(connection_id, entry, frame);
+    }
     /**
      * Initiate a JSON-RPC request to a single connected client and await its
      * reply — the server→client request/response direction (ActionPeer).
@@ -526,17 +723,23 @@ export class BackendWebsocketTransport {
         if (!entry?.admitted) {
             return Promise.resolve({ ok: false, error: { kind: 'connection_gone' } });
         }
-        const { ws } = entry;
         const registered = this.#pending.register(connection_id, options?.timeout_ms);
         if (!registered)
             return Promise.resolve({ ok: false, error: { kind: 'too_many_in_flight' } });
         const { id, outcome } = registered;
+        let frame;
         try {
-            ws.send(JSON.stringify(create_jsonrpc_request(method, params, id)));
+            frame = JSON.stringify(create_jsonrpc_request(method, params, id));
         }
         catch {
-            // Send failed — the socket is gone; settle now so the caller isn't
-            // left awaiting until the deadline.
+            // params that are not JSON reach no client
+            this.#pending.settle(connection_id, id, { ok: false, error: { kind: 'connection_gone' } });
+            return outcome;
+        }
+        if (!this.#deliver(connection_id, entry, frame)) {
+            // Not accepted — the socket refused it, or the frame overflowed the
+            // connection and closed it; settle now so the caller isn't left
+            // awaiting until the deadline.
             this.#pending.settle(connection_id, id, { ok: false, error: { kind: 'connection_gone' } });
         }
         return outcome;

package/dist/actions/ws_endpoint_spec.d.ts

@@ -66,6 +66,15 @@ export interface WsEndpointSpec {
      * @default DEFAULT_MAX_CONNECTIONS_PER_ACCOUNT
      */
     max_connections_per_account?: number | null;
+    /**
+     * Byte budget of the frames waiting to be written to one connection, for
+     * the auto-created transport. See
+     * `RegisterActionWsOptions.outbound_queue_bytes` — rejected alongside
+     * `transport`, which carries its own budget.
+     *
+     * @default DEFAULT_WS_OUTBOUND_QUEUE_BYTES
+     */
+    outbound_queue_bytes?: number;
     /**
      * Server-side heartbeat policy. Default-on (60s receive-silence
      * timeout). Set `false` only when an upstream stack (TCP keepalive,

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;;;;;;;;;;;;;GAaG;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;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACxC;;;;;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;;;;;;OAMG;IACH,2BAA2B,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C;;;;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;;;;OAIG;IACH,eAAe,CAAC,EAAE,CAAC,GAAG,EAAE,kBAAkB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;;;;OAQG;IACH,oBAAoB,CAAC,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;CACxD;AAED,yFAAyF;AACzF,MAAM,MAAM,sBAAsB,GAAG,cAAc,GAAG;IAAE,eAAe,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC;AAEjG;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,GAChC,cAAc,aAAa,CAAC,cAAc,CAAC,GAAG,SAAS,EACvD,iBAAiB,aAAa,CAAC,MAAM,CAAC,KACpC,KAAK,CAAC,sBAAsB,CAAC,GAAG,SAI/B,CAAC"}
+{"version":3,"file":"ws_endpoint_spec.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/ws_endpoint_spec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;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;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACxC;;;;;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;;;;;;OAMG;IACH,2BAA2B,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;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;;;;OAIG;IACH,eAAe,CAAC,EAAE,CAAC,GAAG,EAAE,kBAAkB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;;;;OAQG;IACH,oBAAoB,CAAC,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;CACxD;AAED,yFAAyF;AACzF,MAAM,MAAM,sBAAsB,GAAG,cAAc,GAAG;IAAE,eAAe,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC;AAEjG;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,GAChC,cAAc,aAAa,CAAC,cAAc,CAAC,GAAG,SAAS,EACvD,iBAAiB,aAAa,CAAC,MAAM,CAAC,KACpC,KAAK,CAAC,sBAAsB,CAAC,GAAG,SAI/B,CAAC"}