@fuzdev/fuz_app 0.97.0 → 0.98.0

package/dist/actions/peer_ping.js

@@ -0,0 +1,189 @@
+/**
+ * Shared `peer/ping` action — the protocol action that exercises the
+ * server→client request/response direction of ActionPeer.
+ *
+ * `peer/ping` is `initiator: 'both'`: the client→server direction overlaps
+ * with `heartbeat`, but the new direction this action drives is the reverse —
+ * a connected client invokes `peer/ping` over its socket, and the handler
+ * turns around and *initiates* a `peer/ping` request back to that same socket
+ * (`ctx.request_client`), awaits the client's echo, validates it against
+ * `PingResponse`, and returns the validated shape. So one client RPC drives
+ * the whole round-trip and every outcome surfaces as that RPC's wire response.
+ *
+ * **Public auth.** A liveness echo is non-sensitive; the WebSocket upgrade
+ * itself still authenticates, so only admitted sockets reach the handler.
+ *
+ * **No return transport (HTTP RPC).** Over HTTP there is no socket to ping —
+ * `ctx.request_client` is absent — so the handler refuses with
+ * `peer_no_transport` rather than `method_not_found`. That requires the action
+ * to be mounted on the HTTP RPC endpoint as well as the WS endpoint (it is, via
+ * the spine's full mount); the manifest excludes it as a protocol action so the
+ * cross-impl diff stays apples-to-apples.
+ *
+ * The `data.reason` discriminators and the `PingResponse` shape are the
+ * cross-impl wire contract — twins of the Rust spine's `REASON_PEER_*`
+ * constants and `PingResponse` (parity by test, not codegen).
+ *
+ * **Frontend-safe.** Like `heartbeat.ts` / `cancel.ts`, this module names
+ * the dispatcher types (`ActionContext`, `RpcAction`) type-only and builds
+ * `peer_ping_action` as a plain literal — it never imports the runtime
+ * `action_rpc.ts` (which would drag the HTTP dispatch core + Hono into any
+ * frontend that pulls `protocol_action_specs`). The frontend responder
+ * (`peer_ping_responder`) lives here too so a real frontend can answer the
+ * server's probe.
+ *
+ * @module
+ */
+import { z } from 'zod';
+import { ThrownJsonrpcError, JSONRPC_ERROR_CODES } from '../http/jsonrpc_errors.js';
+import { DEFAULT_PEER_REQUEST_TIMEOUT } from './peer_request.js';
+/** Wire method name (both directions). Twin of the Rust `PEER_PING_METHOD`. */
+export const PEER_PING_METHOD = 'peer/ping';
+/**
+ * Wire-protocol version reported in `peer/ping` replies
+ * (`PingResponse.protocol_version`). Twin of the Rust spine's value — bump
+ * in lockstep with a breaking peer-protocol change. The far side validates
+ * the reply's *shape*, not this value, so it's informational telemetry
+ * today, but it's the hook a future protocol negotiation reads.
+ */
+export const PEER_PROTOCOL_VERSION = 1;
+// --- `data.reason` discriminators (cross-impl wire contract) ---
+/** The peer did not reply within the deadline. */
+export const REASON_PEER_TIMEOUT = 'peer_timeout';
+/** The socket closed before the peer replied. */
+export const REASON_PEER_CONNECTION_GONE = 'peer_connection_gone';
+/** No return socket — the action ran over a transport that can't initiate a server→client request (HTTP RPC). */
+export const REASON_PEER_NO_TRANSPORT = 'peer_no_transport';
+/** The per-connection in-flight server→client request cap was hit. */
+export const REASON_PEER_TOO_MANY_IN_FLIGHT = 'peer_too_many_in_flight';
+/** The peer replied, but the payload failed `PingResponse` validation. */
+export const REASON_PEER_PING_INVALID_REPLY = 'peer_ping_invalid_reply';
+/** The peer replied with a `PingResponse` whose nonce didn't echo the issued one. */
+export const REASON_PEER_PING_NONCE_MISMATCH = 'peer_ping_nonce_mismatch';
+/**
+ * Input to the client→server `peer/ping` invocation. Both fields optional
+ * (mirrors the Rust `PingActionInput`): `nonce` defaults to a server-issued
+ * value, `timeout_ms` to `DEFAULT_PEER_REQUEST_TIMEOUT` (clamped shorten-only).
+ */
+export const PingActionInput = z
+    .strictObject({
+    nonce: z.number().int().optional(),
+    timeout_ms: z.number().int().positive().optional(),
+})
+    // `.default({})` so omitting `params` entirely (undefined) is accepted — both
+    // fields are optional, so an empty invocation is valid (server-issued nonce,
+    // default timeout). Mirrors `heartbeat`'s nullary `.default({})`.
+    .default({});
+/** Params of the server→client `peer/ping` request frame. Twin of the Rust `PingRequest`. */
+export const PingRequestParams = z.strictObject({
+    nonce: z.number().int(),
+});
+/**
+ * The client's reply shape — also the action's output (the handler returns the
+ * validated echo). Twin of the Rust `PingResponse`.
+ */
+export const PingResponse = z.strictObject({
+    nonce: z.number().int(),
+    protocol_version: z.number().int(),
+});
+/**
+ * `ActionSpec` for the shared `peer/ping`. `initiator: 'both'` (the
+ * client→server invocation drives a server→client request); `auth: public`
+ * (liveness is non-sensitive; the upgrade authenticated the socket);
+ * `side_effects: false` (no state change — the handler only round-trips a ping).
+ */
+export const peer_ping_action_spec = {
+    method: PEER_PING_METHOD,
+    kind: 'request_response',
+    initiator: 'both',
+    auth: { account: 'none', actor: 'none' },
+    side_effects: false,
+    input: PingActionInput,
+    output: PingResponse,
+    async: true,
+    description: 'Liveness round-trip — the handler pings the originating client back over its socket, ' +
+        'validates the echo, and returns it. Refused as no-transport over HTTP RPC.',
+};
+/** Monotonic fallback nonce when the caller omits one — mirrors the Rust `next_nonce`. */
+let next_ping_nonce = 0;
+/** Map a transport-level `PeerRequestError` to the thrown JSON-RPC error the caller sees. */
+const peer_request_error_to_jsonrpc = (error) => {
+    switch (error.kind) {
+        case 'timeout':
+            return new ThrownJsonrpcError(JSONRPC_ERROR_CODES.timeout, 'peer request timed out', {
+                reason: REASON_PEER_TIMEOUT,
+            });
+        case 'connection_gone':
+            return new ThrownJsonrpcError(JSONRPC_ERROR_CODES.service_unavailable, 'peer connection gone', { reason: REASON_PEER_CONNECTION_GONE });
+        case 'too_many_in_flight':
+            return new ThrownJsonrpcError(JSONRPC_ERROR_CODES.queue_overflow, 'too many in-flight peer requests', { reason: REASON_PEER_TOO_MANY_IN_FLIGHT });
+        case 'client_error':
+            // Forward the client's envelope verbatim so its own code / message /
+            // data reach the original caller unchanged.
+            return new ThrownJsonrpcError(error.error.code, error.error.message, error.error.data);
+    }
+};
+/**
+ * Handler — initiates a `peer/ping` request back to the originating client,
+ * awaits the reply, validates it against `PingResponse`, and returns it.
+ *
+ * @throws ThrownJsonrpcError with `data.reason` of `peer_no_transport` (HTTP),
+ *   `peer_timeout` / `peer_connection_gone` / `peer_too_many_in_flight`
+ *   (transport failures), the client's own envelope (`client_error`), or
+ *   `peer_ping_invalid_reply` / `peer_ping_nonce_mismatch` (bad echo).
+ */
+export const peer_ping_handler = async (input, ctx) => {
+    if (!ctx.request_client) {
+        throw new ThrownJsonrpcError(JSONRPC_ERROR_CODES.invalid_request, 'peer/ping has no return transport', { reason: REASON_PEER_NO_TRANSPORT });
+    }
+    const nonce = input.nonce ?? ++next_ping_nonce;
+    // Shorten-only clamp: a remote caller may make the server give up sooner,
+    // never hold the (pooled) connection longer than the default.
+    const timeout_ms = input.timeout_ms == null
+        ? DEFAULT_PEER_REQUEST_TIMEOUT
+        : Math.min(input.timeout_ms, DEFAULT_PEER_REQUEST_TIMEOUT);
+    const request_params = { nonce };
+    const outcome = await ctx.request_client(PEER_PING_METHOD, request_params, { timeout_ms });
+    if (!outcome.ok)
+        throw peer_request_error_to_jsonrpc(outcome.error);
+    const parsed = PingResponse.safeParse(outcome.value);
+    if (!parsed.success) {
+        throw new ThrownJsonrpcError(JSONRPC_ERROR_CODES.validation_error, 'peer/ping reply failed validation', { reason: REASON_PEER_PING_INVALID_REPLY });
+    }
+    if (parsed.data.nonce !== nonce) {
+        throw new ThrownJsonrpcError(JSONRPC_ERROR_CODES.validation_error, 'peer/ping reply nonce mismatch', { reason: REASON_PEER_PING_NONCE_MISMATCH });
+    }
+    return parsed.data;
+};
+/**
+ * Reusable responder for an inbound *server→client* `peer/ping` request — the
+ * mirror of `peer_ping_handler`, run by the **client** (frontend). Validates the
+ * request params and echoes a `PingResponse` carrying the issued nonce. Pure +
+ * transport-agnostic (the production twin of the cross-process test transport's
+ * `echo_responder`); `FrontendWebsocketTransport` wires it so a real frontend
+ * answers the server's liveness probe with zero consumer plumbing. Falls back to
+ * `nonce: 0` on a malformed request — the server then surfaces a nonce mismatch,
+ * the correct outcome for a bad probe.
+ *
+ * @param params - the inbound request's `params` (`PingRequestParams` shape)
+ * @returns the `PingResponse` echo to send back as the reply's `result`
+ */
+export const peer_ping_responder = (params) => {
+    const parsed = PingRequestParams.safeParse(params);
+    return { nonce: parsed.success ? parsed.data.nonce : 0, protocol_version: PEER_PROTOCOL_VERSION };
+};
+/**
+ * Protocol-action tuple — spread into the server's `actions` array (via
+ * `protocol_actions` from `actions/protocol.ts`) so the dispatcher resolves the
+ * `peer/ping` handler on both the WS endpoint and (for the no-transport refusal)
+ * the HTTP RPC endpoint. A plain `RpcAction` literal (not `rpc_action(...)`) so
+ * this module stays free of the runtime `action_rpc.ts` import — the same
+ * frontend-safety discipline `heartbeat_action` / `cancel_action` follow; the
+ * handler's input/output are already pinned by `peer_ping_handler`'s signature.
+ * Usable directly in the spine's `RpcAction[]` full mount and the `Action[]`
+ * protocol bundle alike.
+ */
+export const peer_ping_action = {
+    spec: peer_ping_action_spec,
+    handler: peer_ping_handler,
+};

package/dist/actions/peer_request.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Server→client peer requests (ActionPeer) — the request/response direction a
+ * backend initiates to a connected WebSocket client and awaits a typed reply.
+ *
+ * `PendingPeerRequests` is the correlation registry: it owns the in-flight map
+ * (nested `connection_id → request id` — the nesting **is** the per-connection
+ * isolation guarantee), id allocation (`s{n}`-namespaced so a client's own
+ * request ids can't collide), the per-request deadline, and the per-connection
+ * in-flight cap. It deliberately does **not** touch the socket — the caller
+ * (`BackendWebsocketTransport.request_connection`) does the send and threads the
+ * reply back via `resolve`. This mirrors the Rust `fuz_realtime::peer` split
+ * (the `PendingPeerRequests` registry vs the transport that composes it), and
+ * keeps the registry pure data so it unit-tests without a live socket.
+ *
+ * @module
+ */
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
+import type { Uuid } from '@fuzdev/fuz_util/id.ts';
+import type { JsonrpcErrorObject, JsonrpcErrorResponse, JsonrpcRequestId, JsonrpcRequestParams, JsonrpcResponse, JsonrpcResult } from '../http/jsonrpc.js';
+/**
+ * Default deadline (ms) for a server→client peer request before it resolves
+ * `timeout`. Twin of the Rust spine's `DEFAULT_PEER_TIMEOUT`.
+ */
+export declare const DEFAULT_PEER_REQUEST_TIMEOUT = 10000;
+/**
+ * Per-connection cap on concurrent in-flight server→client requests. A caller
+ * past it gets `too_many_in_flight` instead of growing the pending map
+ * unbounded. Twin of the Rust spine's `DEFAULT_MAX_IN_FLIGHT_PER_CONN`.
+ */
+export declare const MAX_IN_FLIGHT_PEER_REQUESTS_PER_CONNECTION = 256;
+/**
+ * Why a server→client peer request did not yield a client success reply.
+ *
+ * - `timeout` — the client did not answer within the deadline.
+ * - `connection_gone` — the socket closed (or was never registered) before a reply.
+ * - `too_many_in_flight` — the per-connection in-flight cap was hit.
+ * - `client_error` — the client answered with a JSON-RPC error; `error` is
+ *   forwarded verbatim so the initiating handler can surface the client's own
+ *   code / message / data.
+ */
+export type PeerRequestError = {
+    kind: 'timeout';
+} | {
+    kind: 'connection_gone';
+} | {
+    kind: 'too_many_in_flight';
+} | {
+    kind: 'client_error';
+    error: JsonrpcErrorObject;
+};
+/** Outcome of a server→client peer request: the client's success `result`, or a `PeerRequestError`. */
+export type PeerRequestOutcome = {
+    ok: true;
+    value: JsonrpcResult;
+} | {
+    ok: false;
+    error: PeerRequestError;
+};
+/** Per-call options for a server→client peer request. */
+export interface PeerRequestOptions {
+    /**
+     * Deadline (ms) before the request resolves `timeout`. Defaults to the
+     * registry's `default_timeout_ms` (`DEFAULT_PEER_REQUEST_TIMEOUT`). Untrusted
+     * remote-supplied values should be clamped **shorten-only** (never lengthen
+     * the server's hold on a pooled connection) — see `actions/peer_ping.ts`.
+     */
+    timeout_ms?: number;
+}
+/**
+ * Initiate a JSON-RPC request to the connected client and await its reply — the
+ * server→client direction of ActionPeer. Threaded onto
+ * `ActionContext.request_client` for WebSocket handlers (absent on HTTP RPC,
+ * where there is no return socket). Returns a `PeerRequestOutcome`; never throws.
+ */
+export type RequestClient = (method: string, params: JsonrpcRequestParams | undefined, options?: PeerRequestOptions) => Promise<PeerRequestOutcome>;
+/** Options for `PendingPeerRequests`. */
+export interface PendingPeerRequestsOptions {
+    /** Per-connection in-flight cap. Defaults to `MAX_IN_FLIGHT_PEER_REQUESTS_PER_CONNECTION`. */
+    max_in_flight_per_connection?: number;
+    /** Default per-request deadline (ms). Defaults to `DEFAULT_PEER_REQUEST_TIMEOUT`. */
+    default_timeout_ms?: number;
+}
+/**
+ * Correlation registry for in-flight server→client requests, nested by
+ * connection then by the server-issued request id.
+ *
+ * The per-connection nesting makes the in-flight count and the close-time drain
+ * O(1) and is the isolation boundary — a reply on connection B can never settle
+ * a request issued on connection A (it lands in a different inner map). An inner
+ * map is removed as soon as it empties, so an idle connection holds no entry.
+ * The registry never sends on the socket; the caller does the send between
+ * `register` and the first `await`, and routes inbound replies back via
+ * `resolve`.
+ */
+export declare class PendingPeerRequests {
+    #private;
+    constructor(options?: PendingPeerRequestsOptions);
+    /**
+     * Register a pending request for `connection_id` with a deadline, returning
+     * its server-issued `s{n}` id and the outcome promise (settled by a reply,
+     * the deadline, or `drain`). Returns `null` when the connection is at its
+     * in-flight cap — the caller maps that to `too_many_in_flight`. The promise
+     * executor runs synchronously, so the entry is registered before this returns.
+     *
+     * @returns the allocated id + outcome promise, or `null` at the cap
+     * @mutates this - inserts an entry into `#pending`
+     */
+    register(connection_id: Uuid, timeout_ms?: number): {
+        id: JsonrpcRequestId;
+        outcome: Promise<PeerRequestOutcome>;
+    } | null;
+    /**
+     * Settle the pending request matching an inbound reply. A success response
+     * resolves `{ok: true, value: result}`; an error response resolves
+     * `{ok: false, error: {kind: 'client_error', error}}` (forwarded verbatim).
+     *
+     * Returns `false` when no entry matches — an unsolicited, cross-connection,
+     * or already-settled reply — so the caller drops it.
+     *
+     * @returns whether a pending request was settled
+     * @mutates this - clears the matched entry from `#pending`
+     */
+    resolve(connection_id: Uuid, response: JsonrpcResponse | JsonrpcErrorResponse): boolean;
+    /**
+     * Force-settle one pending request with an explicit outcome (the send-failure
+     * path uses this for `connection_gone`). Clears the timer, drops the entry,
+     * resolves the promise. Idempotent — a no-op if the entry is already gone.
+     *
+     * @mutates this - clears the entry from `#pending`
+     */
+    settle(connection_id: Uuid, id: JsonrpcRequestId, outcome: PeerRequestOutcome): void;
+    /**
+     * Settle every pending request on a closing connection as `connection_gone`.
+     * O(1) — drops the connection's inner map in one hop.
+     *
+     * @mutates this - removes the connection's entry from `#pending`
+     */
+    drain(connection_id: Uuid): void;
+    /**
+     * In-flight request count — for `connection_id` when given, else across all
+     * connections. Telemetry / tests.
+     */
+    size(connection_id?: Uuid): number;
+}
+/**
+ * Sampled, bounded audit for an inbound response that matched no pending request
+ * on its connection — an unsolicited `{id, result}`, a cross-connection id echo,
+ * or a late/duplicate reply for an already-settled id. Auditing **every**
+ * rejected frame would let a junk flood turn the log into the DoS target, so
+ * this warns on the first few then samples 1-in-256. Twin of the Rust
+ * `fuz_realtime::peer::audit_unmatched_response`.
+ *
+ * @param log - the WS dispatcher's logger
+ * @param connection_id - the socket the unmatched reply arrived on
+ * @param id - the reply's echoed id (`null` when absent)
+ */
+export declare const audit_unmatched_peer_response: (log: Logger, connection_id: Uuid, id: JsonrpcRequestId | null) => void;
+//# sourceMappingURL=peer_request.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"peer_request.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/peer_request.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AACpD,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,wBAAwB,CAAC;AAEjD,OAAO,KAAK,EACX,kBAAkB,EAClB,oBAAoB,EACpB,gBAAgB,EAChB,oBAAoB,EACpB,eAAe,EACf,aAAa,EACb,MAAM,oBAAoB,CAAC;AAG5B;;;GAGG;AACH,eAAO,MAAM,4BAA4B,QAAS,CAAC;AAEnD;;;;GAIG;AACH,eAAO,MAAM,0CAA0C,MAAM,CAAC;AAE9D;;;;;;;;;GASG;AACH,MAAM,MAAM,gBAAgB,GACzB;IAAC,IAAI,EAAE,SAAS,CAAA;CAAC,GACjB;IAAC,IAAI,EAAE,iBAAiB,CAAA;CAAC,GACzB;IAAC,IAAI,EAAE,oBAAoB,CAAA;CAAC,GAC5B;IAAC,IAAI,EAAE,cAAc,CAAC;IAAC,KAAK,EAAE,kBAAkB,CAAA;CAAC,CAAC;AAErD,uGAAuG;AACvG,MAAM,MAAM,kBAAkB,GAC3B;IAAC,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,aAAa,CAAA;CAAC,GAChC;IAAC,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,gBAAgB,CAAA;CAAC,CAAC;AAExC,yDAAyD;AACzD,MAAM,WAAW,kBAAkB;IAClC;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,CAC3B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,oBAAoB,GAAG,SAAS,EACxC,OAAO,CAAC,EAAE,kBAAkB,KACxB,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAUjC,yCAAyC;AACzC,MAAM,WAAW,0BAA0B;IAC1C,8FAA8F;IAC9F,4BAA4B,CAAC,EAAE,MAAM,CAAC;IACtC,qFAAqF;IACrF,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,mBAAmB;;gBAUnB,OAAO,CAAC,EAAE,0BAA0B;IAMhD;;;;;;;;;OASG;IACH,QAAQ,CACP,aAAa,EAAE,IAAI,EACnB,UAAU,CAAC,EAAE,MAAM,GACjB;QAAC,EAAE,EAAE,gBAAgB,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAA;KAAC,GAAG,IAAI;IAkBtE;;;;;;;;;;OAUG;IACH,OAAO,CAAC,aAAa,EAAE,IAAI,EAAE,QAAQ,EAAE,eAAe,GAAG,oBAAoB,GAAG,OAAO;IAWvF;;;;;;OAMG;IACH,MAAM,CAAC,aAAa,EAAE,IAAI,EAAE,EAAE,EAAE,gBAAgB,EAAE,OAAO,EAAE,kBAAkB,GAAG,IAAI;IAUpF;;;;;OAKG;IACH,KAAK,CAAC,aAAa,EAAE,IAAI,GAAG,IAAI;IAUhC;;;OAGG;IACH,IAAI,CAAC,aAAa,CAAC,EAAE,IAAI,GAAG,MAAM;CAMlC;AAKD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,6BAA6B,GACzC,KAAK,MAAM,EACX,eAAe,IAAI,EACnB,IAAI,gBAAgB,GAAG,IAAI,KACzB,IAQF,CAAC"}

package/dist/actions/peer_request.js

@@ -0,0 +1,167 @@
+/**
+ * Server→client peer requests (ActionPeer) — the request/response direction a
+ * backend initiates to a connected WebSocket client and awaits a typed reply.
+ *
+ * `PendingPeerRequests` is the correlation registry: it owns the in-flight map
+ * (nested `connection_id → request id` — the nesting **is** the per-connection
+ * isolation guarantee), id allocation (`s{n}`-namespaced so a client's own
+ * request ids can't collide), the per-request deadline, and the per-connection
+ * in-flight cap. It deliberately does **not** touch the socket — the caller
+ * (`BackendWebsocketTransport.request_connection`) does the send and threads the
+ * reply back via `resolve`. This mirrors the Rust `fuz_realtime::peer` split
+ * (the `PendingPeerRequests` registry vs the transport that composes it), and
+ * keeps the registry pure data so it unit-tests without a live socket.
+ *
+ * @module
+ */
+import { is_jsonrpc_error_response } from '../http/jsonrpc_helpers.js';
+/**
+ * Default deadline (ms) for a server→client peer request before it resolves
+ * `timeout`. Twin of the Rust spine's `DEFAULT_PEER_TIMEOUT`.
+ */
+export const DEFAULT_PEER_REQUEST_TIMEOUT = 10_000;
+/**
+ * Per-connection cap on concurrent in-flight server→client requests. A caller
+ * past it gets `too_many_in_flight` instead of growing the pending map
+ * unbounded. Twin of the Rust spine's `DEFAULT_MAX_IN_FLIGHT_PER_CONN`.
+ */
+export const MAX_IN_FLIGHT_PEER_REQUESTS_PER_CONNECTION = 256;
+/**
+ * Correlation registry for in-flight server→client requests, nested by
+ * connection then by the server-issued request id.
+ *
+ * The per-connection nesting makes the in-flight count and the close-time drain
+ * O(1) and is the isolation boundary — a reply on connection B can never settle
+ * a request issued on connection A (it lands in a different inner map). An inner
+ * map is removed as soon as it empties, so an idle connection holds no entry.
+ * The registry never sends on the socket; the caller does the send between
+ * `register` and the first `await`, and routes inbound replies back via
+ * `resolve`.
+ */
+export class PendingPeerRequests {
+    #pending = new Map();
+    // Monotonic counter for server-issued ids. Serialized as `s{n}` so a client's
+    // own (self-chosen) request ids on a bidirectional socket can never collide.
+    #next_id = 0;
+    #max_in_flight;
+    #default_timeout_ms;
+    constructor(options) {
+        this.#max_in_flight =
+            options?.max_in_flight_per_connection ?? MAX_IN_FLIGHT_PEER_REQUESTS_PER_CONNECTION;
+        this.#default_timeout_ms = options?.default_timeout_ms ?? DEFAULT_PEER_REQUEST_TIMEOUT;
+    }
+    /**
+     * Register a pending request for `connection_id` with a deadline, returning
+     * its server-issued `s{n}` id and the outcome promise (settled by a reply,
+     * the deadline, or `drain`). Returns `null` when the connection is at its
+     * in-flight cap — the caller maps that to `too_many_in_flight`. The promise
+     * executor runs synchronously, so the entry is registered before this returns.
+     *
+     * @returns the allocated id + outcome promise, or `null` at the cap
+     * @mutates this - inserts an entry into `#pending`
+     */
+    register(connection_id, timeout_ms) {
+        const existing = this.#pending.get(connection_id);
+        if ((existing?.size ?? 0) >= this.#max_in_flight)
+            return null;
+        const conn_pending = existing ?? new Map();
+        if (!existing)
+            this.#pending.set(connection_id, conn_pending);
+        const id = `s${++this.#next_id}`;
+        const ms = timeout_ms ?? this.#default_timeout_ms;
+        const outcome = new Promise((resolve) => {
+            const timer = setTimeout(() => this.settle(connection_id, id, { ok: false, error: { kind: 'timeout' } }), ms);
+            conn_pending.set(id, { resolve, timer });
+        });
+        return { id, outcome };
+    }
+    /**
+     * Settle the pending request matching an inbound reply. A success response
+     * resolves `{ok: true, value: result}`; an error response resolves
+     * `{ok: false, error: {kind: 'client_error', error}}` (forwarded verbatim).
+     *
+     * Returns `false` when no entry matches — an unsolicited, cross-connection,
+     * or already-settled reply — so the caller drops it.
+     *
+     * @returns whether a pending request was settled
+     * @mutates this - clears the matched entry from `#pending`
+     */
+    resolve(connection_id, response) {
+        const { id } = response;
+        if (id == null)
+            return false;
+        if (!this.#pending.get(connection_id)?.has(id))
+            return false;
+        const outcome = is_jsonrpc_error_response(response)
+            ? { ok: false, error: { kind: 'client_error', error: response.error } }
+            : { ok: true, value: response.result };
+        this.settle(connection_id, id, outcome);
+        return true;
+    }
+    /**
+     * Force-settle one pending request with an explicit outcome (the send-failure
+     * path uses this for `connection_gone`). Clears the timer, drops the entry,
+     * resolves the promise. Idempotent — a no-op if the entry is already gone.
+     *
+     * @mutates this - clears the entry from `#pending`
+     */
+    settle(connection_id, id, outcome) {
+        const conn_pending = this.#pending.get(connection_id);
+        const entry = conn_pending?.get(id);
+        if (!entry || !conn_pending)
+            return;
+        clearTimeout(entry.timer);
+        conn_pending.delete(id);
+        if (conn_pending.size === 0)
+            this.#pending.delete(connection_id);
+        entry.resolve(outcome);
+    }
+    /**
+     * Settle every pending request on a closing connection as `connection_gone`.
+     * O(1) — drops the connection's inner map in one hop.
+     *
+     * @mutates this - removes the connection's entry from `#pending`
+     */
+    drain(connection_id) {
+        const conn_pending = this.#pending.get(connection_id);
+        if (!conn_pending)
+            return;
+        for (const entry of conn_pending.values()) {
+            clearTimeout(entry.timer);
+            entry.resolve({ ok: false, error: { kind: 'connection_gone' } });
+        }
+        this.#pending.delete(connection_id);
+    }
+    /**
+     * In-flight request count — for `connection_id` when given, else across all
+     * connections. Telemetry / tests.
+     */
+    size(connection_id) {
+        if (connection_id !== undefined)
+            return this.#pending.get(connection_id)?.size ?? 0;
+        let total = 0;
+        for (const conn_pending of this.#pending.values())
+            total += conn_pending.size;
+        return total;
+    }
+}
+// Module-scope sampling counter for unmatched-response auditing.
+let unmatched_peer_responses = 0;
+/**
+ * Sampled, bounded audit for an inbound response that matched no pending request
+ * on its connection — an unsolicited `{id, result}`, a cross-connection id echo,
+ * or a late/duplicate reply for an already-settled id. Auditing **every**
+ * rejected frame would let a junk flood turn the log into the DoS target, so
+ * this warns on the first few then samples 1-in-256. Twin of the Rust
+ * `fuz_realtime::peer::audit_unmatched_response`.
+ *
+ * @param log - the WS dispatcher's logger
+ * @param connection_id - the socket the unmatched reply arrived on
+ * @param id - the reply's echoed id (`null` when absent)
+ */
+export const audit_unmatched_peer_response = (log, connection_id, id) => {
+    const n = unmatched_peer_responses++;
+    if (n < 8 || n % 256 === 0) {
+        log.warn('ws: dropped unmatched peer response (unsolicited, cross-connection, or already settled)', { connection_id, id, total: n + 1 });
+    }
+};

package/dist/actions/perform_action.d.ts

@@ -45,6 +45,7 @@ import type { Db } from '../db/db.js';
 import { type JsonrpcRequestId, type JsonrpcErrorObject } from '../http/jsonrpc.js';
 import type { RateLimiter } from '../rate_limiter.js';
 import type { RpcAction } from './action_rpc.js';
+import type { RequestClient } from './peer_request.js';
 /**
  * Per-call inputs to `perform_action`. Each transport assembles this from
  * its wire envelope + connection identity.
@@ -68,6 +69,13 @@ export interface PerformActionInput {
     notify: (method: string, params: unknown) => void;
     /** Stable per-socket id on WS; `undefined` on HTTP. */
     connection_id?: Uuid;
+    /**
+     * Initiate a server→client request on the originating WS socket and await
+     * the typed reply (ActionPeer). Present only on WebSocket dispatch;
+     * `undefined` on HTTP RPC (no return socket). Handlers must handle its
+     * absence — e.g. `peer/ping` surfaces `peer_no_transport`.
+     */
+    request_client?: RequestClient;
     /**
      * Test-harness escape hatch. When set, the live authorization phase is
      * skipped and `request_context` is used directly for post-authorization

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

@@ -1 +1 @@
-{"version":3,"file":"perform_action.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/perform_action.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAGH,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AACpD,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,wBAAwB,CAAC;AAEjD,OAAO,EAGN,KAAK,cAAc,EACnB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAC,KAAK,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAC,EAAE,EAAC,MAAM,aAAa,CAAC;AAGpC,OAAO,EAEN,KAAK,gBAAgB,EAErB,KAAK,kBAAkB,EACvB,MAAM,oBAAoB,CAAC;AAa5B,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAEpD,OAAO,KAAK,EAA+B,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAE7E;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IAClC,kEAAkE;IAClE,MAAM,EAAE,SAAS,CAAC;IAClB,mGAAmG;IACnG,UAAU,EAAE,OAAO,CAAC;IACpB,sDAAsD;IACtD,UAAU,EAAE,gBAAgB,CAAC;IAC7B,yDAAyD;IACzD,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,uEAAuE;IACvE,eAAe,EAAE,cAAc,GAAG,IAAI,CAAC;IACvC,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAC;IAClB,oGAAoG;IACpG,MAAM,EAAE,WAAW,CAAC;IACpB,sFAAsF;IACtF,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IAClD,uDAAuD;IACvD,aAAa,CAAC,EAAE,IAAI,CAAC;IACrB;;;;OAIG;IACH,MAAM,CAAC,EAAE;QAAC,eAAe,EAAE,cAAc,GAAG,IAAI,CAAA;KAAC,CAAC;CAClD;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,iBAAiB;IACjC,gGAAgG;IAChG,EAAE,EAAE,EAAE,CAAC;IACP;;;OAGG;IACH,eAAe,EAAE,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IACtC;;;OAGG;IACH,mBAAmB,EAAE,KAAK,CAAC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IACvD,gDAAgD;IAChD,GAAG,EAAE,MAAM,CAAC;IACZ,kEAAkE;IAClE,sBAAsB,EAAE,WAAW,GAAG,IAAI,CAAC;IAC3C,uEAAuE;IACvE,2BAA2B,EAAE,WAAW,GAAG,IAAI,CAAC;CAChD;AAED;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAC5B;IAAC,IAAI,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAC,GAC7B;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,kBAAkB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAAC;AAE9D;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAC1B,OAAO,kBAAkB,EACzB,MAAM,iBAAiB,KACrB,OAAO,CAAC,mBAAmB,CAoK7B,CAAC;AAoFF;;;GAGG;AACH,eAAO,MAAM,iCAAiC,GAC7C,IAAI,gBAAgB,EACpB,QAAQ,mBAAmB,KACzB;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,gBAAgB,CAAA;CAAC,GAAG,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAC,GAAG;IAAC,KAAK,EAAE,kBAAkB,CAAA;CAAC,CAK5F,CAAC"}
+{"version":3,"file":"perform_action.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/perform_action.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAGH,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AACpD,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,wBAAwB,CAAC;AAEjD,OAAO,EAGN,KAAK,cAAc,EACnB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAC,KAAK,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAC,EAAE,EAAC,MAAM,aAAa,CAAC;AAGpC,OAAO,EAEN,KAAK,gBAAgB,EAErB,KAAK,kBAAkB,EACvB,MAAM,oBAAoB,CAAC;AAa5B,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAEpD,OAAO,KAAK,EAA+B,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC7E,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,mBAAmB,CAAC;AAErD;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IAClC,kEAAkE;IAClE,MAAM,EAAE,SAAS,CAAC;IAClB,mGAAmG;IACnG,UAAU,EAAE,OAAO,CAAC;IACpB,sDAAsD;IACtD,UAAU,EAAE,gBAAgB,CAAC;IAC7B,yDAAyD;IACzD,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,uEAAuE;IACvE,eAAe,EAAE,cAAc,GAAG,IAAI,CAAC;IACvC,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAC;IAClB,oGAAoG;IACpG,MAAM,EAAE,WAAW,CAAC;IACpB,sFAAsF;IACtF,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IAClD,uDAAuD;IACvD,aAAa,CAAC,EAAE,IAAI,CAAC;IACrB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,aAAa,CAAC;IAC/B;;;;OAIG;IACH,MAAM,CAAC,EAAE;QAAC,eAAe,EAAE,cAAc,GAAG,IAAI,CAAA;KAAC,CAAC;CAClD;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,iBAAiB;IACjC,gGAAgG;IAChG,EAAE,EAAE,EAAE,CAAC;IACP;;;OAGG;IACH,eAAe,EAAE,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IACtC;;;OAGG;IACH,mBAAmB,EAAE,KAAK,CAAC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IACvD,gDAAgD;IAChD,GAAG,EAAE,MAAM,CAAC;IACZ,kEAAkE;IAClE,sBAAsB,EAAE,WAAW,GAAG,IAAI,CAAC;IAC3C,uEAAuE;IACvE,2BAA2B,EAAE,WAAW,GAAG,IAAI,CAAC;CAChD;AAED;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAC5B;IAAC,IAAI,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAC,GAC7B;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,kBAAkB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAAC;AAE9D;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAC1B,OAAO,kBAAkB,EACzB,MAAM,iBAAiB,KACrB,OAAO,CAAC,mBAAmB,CAsK7B,CAAC;AAoFF;;;GAGG;AACH,eAAO,MAAM,iCAAiC,GAC7C,IAAI,gBAAgB,EACpB,QAAQ,mBAAmB,KACzB;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,gBAAgB,CAAA;CAAC,GAAG,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAC,GAAG;IAAC,KAAK,EAAE,kBAAkB,CAAA;CAAC,CAK5F,CAAC"}

package/dist/actions/perform_action.js

@@ -57,7 +57,7 @@ import { is_public_auth } from '../http/auth_shape.js';
  * still fires when the harness omits `account_id`.
  */
 export const perform_action = async (input, deps) => {
-    const { action, raw_params, request_id: id, account_id, credential_type, client_ip, signal, notify, connection_id, preset, } = input;
+    const { action, raw_params, request_id: id, account_id, credential_type, client_ip, signal, notify, connection_id, request_client, preset, } = input;
     const { db, pending_effects, post_commit_effects, log, action_ip_rate_limiter, action_account_rate_limiter, } = deps;
     const { spec, handler } = action;
     const action_auth = spec.auth;
@@ -139,6 +139,7 @@ export const perform_action = async (input, deps) => {
             auth: request_context,
             request_id: id,
             connection_id,
+            request_client,
             db: effective_db,
             pending_effects,
             post_commit_effects,

package/dist/actions/protocol.d.ts

@@ -1,7 +1,7 @@
 /**
- * Canonical bundles of fuz_app's protocol actions — `heartbeat` and
- * `cancel`. Spread these into consumer registrations on both sides of the
- * wire so the registries stay symmetric without per-consumer plumbing.
+ * Canonical bundles of fuz_app's protocol actions — `heartbeat`, `cancel`,
+ * and `peer/ping`. Spread these into consumer registrations on both sides of
+ * the wire so the registries stay symmetric without per-consumer plumbing.
  *
  * Protocol actions are wire-protocol concerns (liveness, abort) shipped by
  * fuz_app, not consumer domain logic. The split is intentional: the server

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

@@ -1 +1 @@
-{"version":3,"file":"protocol.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,kBAAkB,CAAC;AACtD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,mBAAmB,CAAC;AAI9C;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,EAAE,aAAa,CAAC,MAAM,CAAqC,CAAC;AAEzF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,EAAE,aAAa,CAAC,eAAe,CAEhE,CAAC"}
+{"version":3,"file":"protocol.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,kBAAkB,CAAC;AACtD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,mBAAmB,CAAC;AAK9C;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,EAAE,aAAa,CAAC,MAAM,CAIlD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,EAAE,aAAa,CAAC,eAAe,CAEhE,CAAC"}

package/dist/actions/protocol.js

@@ -1,7 +1,7 @@
 /**
- * Canonical bundles of fuz_app's protocol actions — `heartbeat` and
- * `cancel`. Spread these into consumer registrations on both sides of the
- * wire so the registries stay symmetric without per-consumer plumbing.
+ * Canonical bundles of fuz_app's protocol actions — `heartbeat`, `cancel`,
+ * and `peer/ping`. Spread these into consumer registrations on both sides of
+ * the wire so the registries stay symmetric without per-consumer plumbing.
  *
  * Protocol actions are wire-protocol concerns (liveness, abort) shipped by
  * fuz_app, not consumer domain logic. The split is intentional: the server
@@ -20,6 +20,7 @@
  */
 import { cancel_action } from './cancel.js';
 import { heartbeat_action } from './heartbeat.js';
+import { peer_ping_action } from './peer_ping.js';
 /**
  * Canonical protocol `{spec, handler}` tuples for the server's
  * `register_action_ws` `actions` array. Spread before consumer-owned actions
@@ -29,7 +30,11 @@ import { heartbeat_action } from './heartbeat.js';
  * register_action_ws({actions: [...protocol_actions, ...consumer_actions], ...})
  * ```
  */
-export const protocol_actions = [heartbeat_action, cancel_action];
+export const protocol_actions = [
+    heartbeat_action,
+    cancel_action,
+    peer_ping_action,
+];
 /**
  * Canonical protocol specs for `ActionRegistry` construction on the
  * frontend. Spread before consumer-owned specs so dispatcher-owned methods

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

@@ -1 +1 @@
-{"version":3,"file":"register_action_ws.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/register_action_ws.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,MAAM,CAAC;AAC/B,OAAO,KAAK,EAAC,gBAAgB,EAAE,SAAS,EAAC,MAAM,SAAS,CAAC;AAEzD,OAAO,EAAS,KAAK,MAAM,IAAI,UAAU,EAAC,MAAM,yBAAyB,CAAC;AAC1E,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,wBAAwB,CAAC;AAUjD,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAgBpD,OAAO,KAAK,EAAC,EAAE,EAAC,MAAM,aAAa,CAAC;AACpC,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,mBAAmB,CAAC;AAI9C,OAAO,EAAC,yBAAyB,EAAE,KAAK,kBAAkB,EAAC,MAAM,4BAA4B,CAAC;AAG9F,YAAY,EAAC,MAAM,EAAC,CAAC;AAErB,0EAA0E;AAC1E,eAAO,MAAM,gCAAgC,QAAS,CAAC;AAEvD;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAiB;IACjC,qFAAqF;IACrF,EAAE,EAAE,SAAS,CAAC;IACd,4EAA4E;IAC5E,aAAa,EAAE,IAAI,CAAC;IACpB,oDAAoD;IACpD,QAAQ,EAAE,kBAAkB,CAAC;IAC7B;;;OAGG;IACH,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IAClD,wFAAwF;IACxF,MAAM,EAAE,WAAW,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IAClC,+CAA+C;IAC/C,EAAE,EAAE,SAAS,CAAC;IACd,2CAA2C;IAC3C,aAAa,EAAE,IAAI,CAAC;IACpB,kGAAkG;IAClG,QAAQ,EAAE,kBAAkB,CAAC;CAC7B;AAED,MAAM,WAAW,sBAAsB;IACtC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wCAAwC;AACxC,MAAM,WAAW,uBAAuB;IACvC,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,gCAAgC;IAChC,GAAG,EAAE,IAAI,CAAC;IACV,iEAAiE;IACjE,gBAAgB,EAAE,gBAAgB,CAAC;IACnC;;;;;;;OAOG;IACH,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC/B;;;;;;;;;OASG;IACH,EAAE,EAAE,EAAE,CAAC;IACP;;;;OAIG;IACH,SAAS,CAAC,EAAE,yBAAyB,CAAC;IACtC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,sBAAsB,CAAC;IAC7C,+EAA+E;IAC/E,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qDAAqD;IACrD,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,iBAAiB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE;;;;;OAKG;IACH,eAAe,CAAC,EAAE,CAAC,GAAG,EAAE,kBAAkB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE;;;;;;OAMG;IACH,sBAAsB,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAC5C;;;;;OAKG;IACH,2BAA2B,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;CACjD;AAED,sCAAsC;AACtC,MAAM,WAAW,sBAAsB;IACtC,yEAAyE;IACzE,SAAS,EAAE,yBAAyB,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAS,uBAAuB,KAAG,sBA4VrE,CAAC"}
+{"version":3,"file":"register_action_ws.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/register_action_ws.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,MAAM,CAAC;AAC/B,OAAO,KAAK,EAAC,gBAAgB,EAAE,SAAS,EAAC,MAAM,SAAS,CAAC;AAEzD,OAAO,EAAS,KAAK,MAAM,IAAI,UAAU,EAAC,MAAM,yBAAyB,CAAC;AAC1E,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,wBAAwB,CAAC;AAUjD,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAkBpD,OAAO,KAAK,EAAC,EAAE,EAAC,MAAM,aAAa,CAAC;AACpC,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,mBAAmB,CAAC;AAI9C,OAAO,EAAC,yBAAyB,EAAE,KAAK,kBAAkB,EAAC,MAAM,4BAA4B,CAAC;AAI9F,YAAY,EAAC,MAAM,EAAC,CAAC;AAErB,0EAA0E;AAC1E,eAAO,MAAM,gCAAgC,QAAS,CAAC;AAEvD;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAiB;IACjC,qFAAqF;IACrF,EAAE,EAAE,SAAS,CAAC;IACd,4EAA4E;IAC5E,aAAa,EAAE,IAAI,CAAC;IACpB,oDAAoD;IACpD,QAAQ,EAAE,kBAAkB,CAAC;IAC7B;;;OAGG;IACH,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IAClD,wFAAwF;IACxF,MAAM,EAAE,WAAW,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IAClC,+CAA+C;IAC/C,EAAE,EAAE,SAAS,CAAC;IACd,2CAA2C;IAC3C,aAAa,EAAE,IAAI,CAAC;IACpB,kGAAkG;IAClG,QAAQ,EAAE,kBAAkB,CAAC;CAC7B;AAED,MAAM,WAAW,sBAAsB;IACtC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wCAAwC;AACxC,MAAM,WAAW,uBAAuB;IACvC,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,gCAAgC;IAChC,GAAG,EAAE,IAAI,CAAC;IACV,iEAAiE;IACjE,gBAAgB,EAAE,gBAAgB,CAAC;IACnC;;;;;;;OAOG;IACH,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC/B;;;;;;;;;OASG;IACH,EAAE,EAAE,EAAE,CAAC;IACP;;;;OAIG;IACH,SAAS,CAAC,EAAE,yBAAyB,CAAC;IACtC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,sBAAsB,CAAC;IAC7C,+EAA+E;IAC/E,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qDAAqD;IACrD,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,iBAAiB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE;;;;;OAKG;IACH,eAAe,CAAC,EAAE,CAAC,GAAG,EAAE,kBAAkB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE;;;;;;OAMG;IACH,sBAAsB,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAC5C;;;;;OAKG;IACH,2BAA2B,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;CACjD;AAED,sCAAsC;AACtC,MAAM,WAAW,sBAAsB;IACtC,yEAAyE;IACzE,SAAS,EAAE,yBAAyB,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAS,uBAAuB,KAAG,sBA6XrE,CAAC"}