@fuzdev/fuz_app 0.23.0 → 0.25.0

package/dist/actions/action_codegen.d.ts

@@ -110,5 +110,30 @@ export declare const to_action_spec_output_identifier: (method: string) => strin
  */
 export declare const get_innermost_type: (schema: z.ZodType) => z.ZodType;
 export declare const get_innermost_type_name: (schema: z.ZodType) => string;
+/**
+ * Generates one method line of the typed `ActionsApi` interface for a single
+ * spec. Encapsulates the input/options/return-type signature shape so the
+ * surface evolves in one place when fields like `signal` or `transport_name`
+ * are added to per-call options.
+ *
+ * Async methods (request_response, async local_call) get an optional second
+ * `options?: RpcClientCallOptions` arg (`{signal?, transport_name?}`). Sync
+ * local_call methods omit the options arg — `signal` can't cooperatively
+ * interrupt a synchronous handler and there's no transport to select.
+ *
+ * Consumers must import `ActionInputs`, `ActionOutputs`, `Result`,
+ * `JsonrpcErrorObject`, and (for async) `RpcClientCallOptions` into the
+ * generated module — the helper only emits the type references.
+ *
+ * @param spec - the action spec to emit
+ * @param options.sync_returns_value - when true (default), sync local_call
+ *   methods return the output value directly; when false they're wrapped in
+ *   `Result<{value, error}>` like async methods. Set to `false` if your
+ *   ActionsApi treats every method uniformly.
+ * @returns one line like `foo: (input: ActionInputs['foo'], options?: RpcClientCallOptions) => Promise<Result<...>>;`
+ */
+export declare const generate_actions_api_method_signature: (spec: ActionSpecUnion, options?: {
+    sync_returns_value?: boolean;
+}) => string;
 export {};
 //# sourceMappingURL=action_codegen.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"action_codegen.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/action_codegen.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAGtB,OAAO,KAAK,EAAC,eAAe,EAAE,gBAAgB,EAAC,MAAM,kBAAkB,CAAC;AAOxE;;GAEG;AACH,UAAU,UAAU;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,WAAW,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,aAAa;;IACzB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAa;IAE1D;;;;OAIG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAQrC;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAI1C;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI;IAOrD;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI;IAgCtD;;;OAGG;IACH,KAAK,IAAI,MAAM;IAIf;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED;;;OAGG;IACH,OAAO,IAAI,KAAK,CAAC,MAAM,CAAC;IAIxB;;OAEG;IACH,KAAK,IAAI,IAAI;CAqDb;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAC/B,MAAM,eAAe,EACrB,UAAU,UAAU,GAAG,SAAS,KAC9B,KAAK,CAAC,gBAAgB,CA4DxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,uBAAuB,GACnC,MAAM,eAAe,EACrB,OAAO,gBAAgB,EACvB,SAAS,aAAa,EACtB,aAAa,MAAM,KACjB,MAkBF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,GACnC,MAAM,eAAe,EACrB,UAAU,UAAU,GAAG,SAAS,EAChC,SAAS,aAAa,EACtB,UAAU;IAAC,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAAC,KACpC,MA4BF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,GAAI,aAAa,MAAM,KAAG,MACU,CAAC;AAG/D,eAAO,MAAM,yBAAyB,GAAI,QAAQ,MAAM,KAAG,MAAiC,CAAC;AAC7F,eAAO,MAAM,+BAA+B,GAAI,QAAQ,MAAM,KAAG,MACpB,CAAC;AAC9C,eAAO,MAAM,gCAAgC,GAAI,QAAQ,MAAM,KAAG,MACpB,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,CAAC,CAAC,OAwBxD,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,MAI3D,CAAC"}
+{"version":3,"file":"action_codegen.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/action_codegen.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAGtB,OAAO,KAAK,EAAC,eAAe,EAAE,gBAAgB,EAAC,MAAM,kBAAkB,CAAC;AAOxE;;GAEG;AACH,UAAU,UAAU;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,WAAW,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,aAAa;;IACzB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAa;IAE1D;;;;OAIG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAQrC;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAI1C;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI;IAOrD;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI;IAgCtD;;;OAGG;IACH,KAAK,IAAI,MAAM;IAIf;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED;;;OAGG;IACH,OAAO,IAAI,KAAK,CAAC,MAAM,CAAC;IAIxB;;OAEG;IACH,KAAK,IAAI,IAAI;CAqDb;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAC/B,MAAM,eAAe,EACrB,UAAU,UAAU,GAAG,SAAS,KAC9B,KAAK,CAAC,gBAAgB,CA4DxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,uBAAuB,GACnC,MAAM,eAAe,EACrB,OAAO,gBAAgB,EACvB,SAAS,aAAa,EACtB,aAAa,MAAM,KACjB,MAkBF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,GACnC,MAAM,eAAe,EACrB,UAAU,UAAU,GAAG,SAAS,EAChC,SAAS,aAAa,EACtB,UAAU;IAAC,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAAC,KACpC,MA4BF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,GAAI,aAAa,MAAM,KAAG,MACU,CAAC;AAG/D,eAAO,MAAM,yBAAyB,GAAI,QAAQ,MAAM,KAAG,MAAiC,CAAC;AAC7F,eAAO,MAAM,+BAA+B,GAAI,QAAQ,MAAM,KAAG,MACpB,CAAC;AAC9C,eAAO,MAAM,gCAAgC,GAAI,QAAQ,MAAM,KAAG,MACpB,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,CAAC,CAAC,OAwBxD,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,MAI3D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,qCAAqC,GACjD,MAAM,eAAe,EACrB,UAAU;IAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAAC,KACtC,MAmBF,CAAC"}

package/dist/actions/action_codegen.js

@@ -316,3 +316,42 @@ export const get_innermost_type_name = (schema) => {
     const def = innermost.def;
     return def.type;
 };
+/**
+ * Generates one method line of the typed `ActionsApi` interface for a single
+ * spec. Encapsulates the input/options/return-type signature shape so the
+ * surface evolves in one place when fields like `signal` or `transport_name`
+ * are added to per-call options.
+ *
+ * Async methods (request_response, async local_call) get an optional second
+ * `options?: RpcClientCallOptions` arg (`{signal?, transport_name?}`). Sync
+ * local_call methods omit the options arg — `signal` can't cooperatively
+ * interrupt a synchronous handler and there's no transport to select.
+ *
+ * Consumers must import `ActionInputs`, `ActionOutputs`, `Result`,
+ * `JsonrpcErrorObject`, and (for async) `RpcClientCallOptions` into the
+ * generated module — the helper only emits the type references.
+ *
+ * @param spec - the action spec to emit
+ * @param options.sync_returns_value - when true (default), sync local_call
+ *   methods return the output value directly; when false they're wrapped in
+ *   `Result<{value, error}>` like async methods. Set to `false` if your
+ *   ActionsApi treats every method uniformly.
+ * @returns one line like `foo: (input: ActionInputs['foo'], options?: RpcClientCallOptions) => Promise<Result<...>>;`
+ */
+export const generate_actions_api_method_signature = (spec, options) => {
+    const sync_returns_value = options?.sync_returns_value ?? true;
+    const innermost_type_name = get_innermost_type_name(spec.input);
+    const has_input = innermost_type_name !== 'null' && innermost_type_name !== 'void';
+    const input_param = has_input
+        ? `input${spec.input.safeParse(undefined).success ? '?' : ''}: ActionInputs['${spec.method}']`
+        : 'input?: void';
+    const is_async = spec.kind === 'request_response' || (spec.kind === 'local_call' && spec.async);
+    const options_param = is_async ? ', options?: RpcClientCallOptions' : '';
+    const result_return = `Result<{value: ActionOutputs['${spec.method}']}, {error: JsonrpcErrorObject}>`;
+    const return_type = is_async
+        ? `Promise<${result_return}>`
+        : sync_returns_value
+            ? `ActionOutputs['${spec.method}']`
+            : result_return;
+    return `${spec.method}: (${input_param}${options_param}) => ${return_type};`;
+};

package/dist/actions/action_peer.d.ts

@@ -11,6 +11,13 @@ import { Transports, type TransportName } from './transports.js';
 import type { ActionEventEnvironment } from './action_event_types.js';
 export interface ActionPeerSendOptions {
     transport_name?: TransportName;
+    /**
+     * Per-call `AbortSignal`. Forwarded into the chosen transport's `send`,
+     * which bottoms out at `FrontendWebsocketClient.request({signal})` for WS
+     * (sends the shared `cancel` notification on abort) and at
+     * `fetch({signal})` for HTTP. Backend transport ignores it.
+     */
+    signal?: AbortSignal;
 }
 export interface ActionPeerOptions {
     environment: ActionEventEnvironment;

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

@@ -1 +1 @@
-{"version":3,"file":"action_peer.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/action_peer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAEN,gCAAgC,EAChC,mBAAmB,EACnB,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,MAAM,oBAAoB,CAAC;AAU5B,OAAO,EAAC,UAAU,EAAE,KAAK,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAC/D,OAAO,KAAK,EAAC,sBAAsB,EAAC,MAAM,yBAAyB,CAAC;AAOpE,MAAM,WAAW,qBAAqB;IACrC,cAAc,CAAC,EAAE,aAAa,CAAC;CAC/B;AAED,MAAM,WAAW,iBAAiB;IACjC,WAAW,EAAE,sBAAsB,CAAC;IAGpC,UAAU,CAAC,EAAE,UAAU,CAAC;IAGxB,oBAAoB,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,CAAC;CACtD;AAED,qBAAa,UAAU;;IACtB,QAAQ,CAAC,WAAW,EAAE,sBAAsB,CAAC;IAC7C,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAMhC,oBAAoB,EAAE,qBAAqB,CAAC;gBAEhC,OAAO,EAAE,iBAAiB;IAOhC,IAAI,CACT,OAAO,EAAE,cAAc,EACvB,OAAO,CAAC,EAAE,qBAAqB,GAC7B,OAAO,CAAC,sBAAsB,CAAC;IAC5B,IAAI,CACT,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,qBAAqB,GAC7B,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IA2CjC,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,gCAAgC,GAAG,IAAI,CAAC;CAyIjF"}
+{"version":3,"file":"action_peer.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/action_peer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAEN,gCAAgC,EAChC,mBAAmB,EACnB,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,MAAM,oBAAoB,CAAC;AAU5B,OAAO,EAAC,UAAU,EAAE,KAAK,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAC/D,OAAO,KAAK,EAAC,sBAAsB,EAAC,MAAM,yBAAyB,CAAC;AAOpE,MAAM,WAAW,qBAAqB;IACrC,cAAc,CAAC,EAAE,aAAa,CAAC;IAC/B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,WAAW,iBAAiB;IACjC,WAAW,EAAE,sBAAsB,CAAC;IAGpC,UAAU,CAAC,EAAE,UAAU,CAAC;IAGxB,oBAAoB,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,CAAC;CACtD;AAED,qBAAa,UAAU;;IACtB,QAAQ,CAAC,WAAW,EAAE,sBAAsB,CAAC;IAC7C,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAMhC,oBAAoB,EAAE,qBAAqB,CAAC;gBAEhC,OAAO,EAAE,iBAAiB;IAOhC,IAAI,CACT,OAAO,EAAE,cAAc,EACvB,OAAO,CAAC,EAAE,qBAAqB,GAC7B,OAAO,CAAC,sBAAsB,CAAC;IAC5B,IAAI,CACT,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,qBAAqB,GAC7B,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IA2CjC,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,gCAAgC,GAAG,IAAI,CAAC;CAyIjF"}

package/dist/actions/action_peer.js

@@ -33,7 +33,7 @@ export class ActionPeer {
             }
             const message_type = is_jsonrpc_request(message) ? 'request' : 'notification';
             this.environment.log?.debug(`[peer] send ${message_type}:`, message.method, `via ${transport.transport_name}`);
-            const result = await transport.send(message);
+            const result = await transport.send(message, { signal: options?.signal });
             if (result && 'error' in result) {
                 this.environment.log?.error(`[peer] send ${message_type} failed:`, message.method, result.error.message);
             }

package/dist/actions/action_types.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Shared type surface for the action system — context, handler, composable Action tuple.
+ *
+ * These types sit above `action_spec.ts` (pure Zod schemas) and below the
+ * dispatchers (`register_action_ws.ts`, `action_rpc.ts`). Extracted so the
+ * shared composable fuz_app actions (e.g. `heartbeat_action`) can name them
+ * without pulling in server-only modules.
+ *
+ * @module
+ */
+import type { JsonrpcRequestId } from '../http/jsonrpc.js';
+import type { Uuid } from '../uuid.js';
+import type { ActionSpecUnion } from './action_spec.js';
+/**
+ * Minimum per-request context every server-side WS handler receives.
+ *
+ * Consumers extend this with domain-specific fields via the dispatcher's
+ * `extend_context` option. Mirrors the HTTP-side `ActionContext` and Rust's
+ * `Ctx<'a>` shape (`request_id` + `NotifyFn` + `CancellationToken`).
+ */
+export interface BaseHandlerContext {
+    /** JSON-RPC envelope request id — echoed back on the response. */
+    request_id: JsonrpcRequestId;
+    /**
+     * Stable per-socket connection id assigned by
+     * `BackendWebsocketTransport.add_connection` — same reference across every
+     * message on this socket, also passed to `on_socket_open` /
+     * `on_socket_close`. Consumers key per-connection domain state on this
+     * directly instead of trying to derive it from signals (which are
+     * per-message composites of `AbortSignal.any([socket, request])`).
+     */
+    connection_id: Uuid;
+    /**
+     * Send a request-scoped JSON-RPC notification to the originating socket.
+     * Not a broadcast — the message only reaches the client whose request
+     * triggered this handler.
+     */
+    notify: (method: string, params: unknown) => void;
+    /**
+     * Fires on socket close OR on a client-initiated `cancel` notification
+     * matching this request's id. Streaming handlers poll for early
+     * termination; per-message composite (`AbortSignal.any([socket, request])`)
+     * — not stable across messages.
+     */
+    signal: AbortSignal;
+}
+/**
+ * Handler signature — receives validated input and per-request context.
+ *
+ * Named to disambiguate from `actions/action_rpc.ts`'s `ActionHandler`
+ * (HTTP-side, `ActionContext` + two generic slots). The WS variant is
+ * single-slotted on the context and returns `unknown`.
+ */
+export type WsActionHandler<TCtx extends BaseHandlerContext = BaseHandlerContext> = (input: unknown, ctx: TCtx) => unknown;
+/**
+ * A spec paired with its optional handler — the composable unit passed to
+ * {@link register_action_ws} and {@link create_rpc_client}. The server uses
+ * both fields; the client reads only {@link spec} (the {@link handler} is
+ * ignored, harmless). Shared fuz_app primitives (e.g. `heartbeat_action`)
+ * export a complete tuple so consumers spread them into both sides'
+ * `actions` array without inventing per-repo ping plumbing.
+ *
+ * Left open for future fields (`rate_limit`, ACL, middleware hooks) so
+ * additions attach to the action itself instead of scattering across
+ * parallel arrays.
+ */
+export interface Action<TCtx extends BaseHandlerContext = BaseHandlerContext> {
+    spec: ActionSpecUnion;
+    /** Server-side handler. Ignored by the client. Omit for client-only specs. */
+    handler?: WsActionHandler<TCtx>;
+}
+//# sourceMappingURL=action_types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"action_types.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/action_types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,YAAY,CAAC;AACrC,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,kBAAkB,CAAC;AAEtD;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IAClC,kEAAkE;IAClE,UAAU,EAAE,gBAAgB,CAAC;IAC7B;;;;;;;OAOG;IACH,aAAa,EAAE,IAAI,CAAC;IACpB;;;;OAIG;IACH,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IAClD;;;;;OAKG;IACH,MAAM,EAAE,WAAW,CAAC;CACpB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,CAAC,IAAI,SAAS,kBAAkB,GAAG,kBAAkB,IAAI,CACnF,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,IAAI,KACL,OAAO,CAAC;AAEb;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,MAAM,CAAC,IAAI,SAAS,kBAAkB,GAAG,kBAAkB;IAC3E,IAAI,EAAE,eAAe,CAAC;IACtB,8EAA8E;IAC9E,OAAO,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC,CAAC;CAChC"}

package/dist/actions/action_types.js

@@ -0,0 +1,11 @@
+/**
+ * Shared type surface for the action system — context, handler, composable Action tuple.
+ *
+ * These types sit above `action_spec.ts` (pure Zod schemas) and below the
+ * dispatchers (`register_action_ws.ts`, `action_rpc.ts`). Extracted so the
+ * shared composable fuz_app actions (e.g. `heartbeat_action`) can name them
+ * without pulling in server-only modules.
+ *
+ * @module
+ */
+export {};

package/dist/actions/cancel.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Shared cancel action — the second composable fuz_app primitive, validating
+ * the spec+handler tuple pattern on a notification-kind action.
+ *
+ * Semantics: the client sends `{jsonrpc, method: 'cancel', params:
+ * {request_id}}` to abort an in-flight request on the same socket.
+ * {@link register_action_ws} intercepts this notification and aborts the
+ * matching pending request's `ctx.signal`. Unknown ids are no-ops by design —
+ * races between response arrival and cancel delivery are safe without extra
+ * coordination.
+ *
+ * The handler field is an empty stub: cancel semantics are dispatcher-owned
+ * (the dispatcher has the `{request_id → AbortController}` map, not the
+ * handler). The handler exists for symmetry with other composable primitives
+ * like {@link heartbeat_action}; the dispatcher never calls it. Consumers
+ * spread {@link cancel_action} into their server's `actions` array so
+ * `spec_by_method` knows about it (enabling input validation on incoming
+ * cancels) and so `create_rpc_client` codegen produces `app.api.cancel()`
+ * when desired — though `FrontendWebsocketClient.request({signal})` sends
+ * the cancel on abort without needing the typed API.
+ *
+ * Wire format is snake_case `cancel` with `{request_id}`, not MCP's
+ * `$/cancelRequest` with `{requestId}` — fuz_app's WS transport isn't MCP,
+ * and adopting MCP's convention would leak protocol-specific framing into
+ * the base transport. When MCP elicitation (Phase 5) lands, a translation
+ * layer at the MCP adapter is the right seam.
+ *
+ * @module
+ */
+import { z } from 'zod';
+import type { Action } from './action_types.js';
+/** Method name on the wire — shared across every fuz_app consumer. */
+export declare const CANCEL_METHOD = "cancel";
+/**
+ * Params for a {@link CANCEL_METHOD} notification. `request_id` is the id of
+ * the pending request to abort. Must match the id of a request sent on the
+ * same socket; cancels from other sockets (or for unknown ids) are ignored.
+ */
+export declare const CancelNotificationParams: z.ZodObject<{
+    request_id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+}, z.core.$strict>;
+export type CancelNotificationParams = z.infer<typeof CancelNotificationParams>;
+/**
+ * `ActionSpec` for the shared cancel. `auth: null` matches every other
+ * remote-notification spec — upgrade-time auth has already admitted the
+ * socket, so per-action auth on a fire-and-forget notification is moot. The
+ * per-connection `{request_id → AbortController}` map enforces socket-scoped
+ * ownership naturally: a different socket's cancel for the same id misses
+ * in its own map.
+ */
+export declare const cancel_action_spec: {
+    method: string;
+    initiator: "both" | "frontend" | "backend";
+    input: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    description: string;
+    kind: "remote_notification";
+    auth: null;
+    side_effects: true;
+    output: z.ZodVoid;
+    async: true;
+    streams?: string | undefined;
+};
+/**
+ * Placeholder handler — cancel semantics are owned by {@link register_action_ws},
+ * not invoked per-handler. Exported for symmetry with the {@link Action}
+ * tuple shape; the dispatcher short-circuits cancel notifications before any
+ * handler lookup happens.
+ */
+export declare const cancel_handler: () => void;
+/**
+ * Composable tuple — spread into the server's `actions` array so the
+ * dispatcher registers the spec for input validation and so `create_rpc_client`
+ * codegen sees the method. The client doesn't need to call it directly;
+ * `FrontendWebsocketClient.request({signal})` sends the cancel notification
+ * automatically when the signal fires.
+ */
+export declare const cancel_action: Action;
+//# sourceMappingURL=cancel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cancel.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/cancel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAItB,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,mBAAmB,CAAC;AAE9C,sEAAsE;AACtE,eAAO,MAAM,aAAa,WAAW,CAAC;AAEtC;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;kBAEnC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEhF;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;CAW7B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,cAAc,QAAO,IAAU,CAAC;AAE7C;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,EAAE,MAG3B,CAAC"}

package/dist/actions/cancel.js

@@ -0,0 +1,79 @@
+/**
+ * Shared cancel action — the second composable fuz_app primitive, validating
+ * the spec+handler tuple pattern on a notification-kind action.
+ *
+ * Semantics: the client sends `{jsonrpc, method: 'cancel', params:
+ * {request_id}}` to abort an in-flight request on the same socket.
+ * {@link register_action_ws} intercepts this notification and aborts the
+ * matching pending request's `ctx.signal`. Unknown ids are no-ops by design —
+ * races between response arrival and cancel delivery are safe without extra
+ * coordination.
+ *
+ * The handler field is an empty stub: cancel semantics are dispatcher-owned
+ * (the dispatcher has the `{request_id → AbortController}` map, not the
+ * handler). The handler exists for symmetry with other composable primitives
+ * like {@link heartbeat_action}; the dispatcher never calls it. Consumers
+ * spread {@link cancel_action} into their server's `actions` array so
+ * `spec_by_method` knows about it (enabling input validation on incoming
+ * cancels) and so `create_rpc_client` codegen produces `app.api.cancel()`
+ * when desired — though `FrontendWebsocketClient.request({signal})` sends
+ * the cancel on abort without needing the typed API.
+ *
+ * Wire format is snake_case `cancel` with `{request_id}`, not MCP's
+ * `$/cancelRequest` with `{requestId}` — fuz_app's WS transport isn't MCP,
+ * and adopting MCP's convention would leak protocol-specific framing into
+ * the base transport. When MCP elicitation (Phase 5) lands, a translation
+ * layer at the MCP adapter is the right seam.
+ *
+ * @module
+ */
+import { z } from 'zod';
+import { JsonrpcRequestId } from '../http/jsonrpc.js';
+import { RemoteNotificationActionSpec } from './action_spec.js';
+/** Method name on the wire — shared across every fuz_app consumer. */
+export const CANCEL_METHOD = 'cancel';
+/**
+ * Params for a {@link CANCEL_METHOD} notification. `request_id` is the id of
+ * the pending request to abort. Must match the id of a request sent on the
+ * same socket; cancels from other sockets (or for unknown ids) are ignored.
+ */
+export const CancelNotificationParams = z.strictObject({
+    request_id: JsonrpcRequestId,
+});
+/**
+ * `ActionSpec` for the shared cancel. `auth: null` matches every other
+ * remote-notification spec — upgrade-time auth has already admitted the
+ * socket, so per-action auth on a fire-and-forget notification is moot. The
+ * per-connection `{request_id → AbortController}` map enforces socket-scoped
+ * ownership naturally: a different socket's cancel for the same id misses
+ * in its own map.
+ */
+export const cancel_action_spec = RemoteNotificationActionSpec.parse({
+    method: CANCEL_METHOD,
+    kind: 'remote_notification',
+    initiator: 'frontend',
+    auth: null,
+    side_effects: true,
+    input: CancelNotificationParams,
+    output: z.void(),
+    async: true,
+    description: 'Client-initiated cancellation of an in-flight request by id. Dispatcher-handled: aborts the ctx.signal of the matching pending request on the same socket. Unknown or completed ids no-op.',
+});
+/**
+ * Placeholder handler — cancel semantics are owned by {@link register_action_ws},
+ * not invoked per-handler. Exported for symmetry with the {@link Action}
+ * tuple shape; the dispatcher short-circuits cancel notifications before any
+ * handler lookup happens.
+ */
+export const cancel_handler = () => { }; // eslint-disable-line @typescript-eslint/no-empty-function
+/**
+ * Composable tuple — spread into the server's `actions` array so the
+ * dispatcher registers the spec for input validation and so `create_rpc_client`
+ * codegen sees the method. The client doesn't need to call it directly;
+ * `FrontendWebsocketClient.request({signal})` sends the cancel notification
+ * automatically when the signal fires.
+ */
+export const cancel_action = {
+    spec: cancel_action_spec,
+    handler: cancel_handler,
+};

package/dist/actions/heartbeat.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Shared heartbeat action — the first composable fuz_app primitive carrying
+ * both a spec and a handler in one tuple. Consumers spread
+ * {@link heartbeat_action} into both the server's and the client's `actions`
+ * array so disconnect detection works identically across every repo without
+ * per-consumer ping plumbing.
+ *
+ * The client's activity-aware heartbeat timer (in
+ * `FrontendWebsocketClient`) issues a `heartbeat` request whenever the
+ * connection has been idle for its configured interval; server-side the
+ * dispatcher tracks receive time, so incoming heartbeats keep the socket
+ * alive without any handler-level state.
+ *
+ * Nullary input/output today. `{client_ts, server_ts}` fields can be added
+ * later if clock-skew telemetry ever matters — the {@link Action} container
+ * is open for additions without churning consumer call sites.
+ *
+ * @module
+ */
+import { z } from 'zod';
+import type { Action } from './action_types.js';
+/** Method name on the wire — shared across every fuz_app consumer. */
+export declare const HEARTBEAT_METHOD = "heartbeat";
+/**
+ * `ActionSpec` for the shared heartbeat. `authenticated` auth — upgrade-time
+ * auth has already admitted the socket; heartbeats don't need role gating.
+ * `side_effects: false` keeps it orthogonal to state changes.
+ */
+export declare const heartbeat_action_spec: {
+    method: string;
+    initiator: "both" | "frontend" | "backend";
+    side_effects: boolean;
+    input: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    output: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    description: string;
+    kind: "request_response";
+    auth: "authenticated" | "keeper" | "public" | {
+        role: string;
+    };
+    async: true;
+    streams?: string | undefined;
+};
+/** Handler — nullary echo. Stateless, suitable for high-frequency pings. */
+export declare const heartbeat_handler: () => Record<string, never>;
+/**
+ * Composable tuple — spread into the server's `actions` array for dispatch
+ * and into the client's `actions` array so `create_rpc_client` types
+ * `app.api.heartbeat()` against the shared spec.
+ */
+export declare const heartbeat_action: Action;
+//# sourceMappingURL=heartbeat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"heartbeat.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/heartbeat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAGtB,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,mBAAmB,CAAC;AAE9C,sEAAsE;AACtE,eAAO,MAAM,gBAAgB,cAAc,CAAC;AAE5C;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;CAUhC,CAAC;AAEH,4EAA4E;AAC5E,eAAO,MAAM,iBAAiB,QAAO,MAAM,CAAC,MAAM,EAAE,KAAK,CAAS,CAAC;AAEnE;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAG9B,CAAC"}

package/dist/actions/heartbeat.js

@@ -0,0 +1,50 @@
+/**
+ * Shared heartbeat action — the first composable fuz_app primitive carrying
+ * both a spec and a handler in one tuple. Consumers spread
+ * {@link heartbeat_action} into both the server's and the client's `actions`
+ * array so disconnect detection works identically across every repo without
+ * per-consumer ping plumbing.
+ *
+ * The client's activity-aware heartbeat timer (in
+ * `FrontendWebsocketClient`) issues a `heartbeat` request whenever the
+ * connection has been idle for its configured interval; server-side the
+ * dispatcher tracks receive time, so incoming heartbeats keep the socket
+ * alive without any handler-level state.
+ *
+ * Nullary input/output today. `{client_ts, server_ts}` fields can be added
+ * later if clock-skew telemetry ever matters — the {@link Action} container
+ * is open for additions without churning consumer call sites.
+ *
+ * @module
+ */
+import { z } from 'zod';
+import { RequestResponseActionSpec } from './action_spec.js';
+/** Method name on the wire — shared across every fuz_app consumer. */
+export const HEARTBEAT_METHOD = 'heartbeat';
+/**
+ * `ActionSpec` for the shared heartbeat. `authenticated` auth — upgrade-time
+ * auth has already admitted the socket; heartbeats don't need role gating.
+ * `side_effects: false` keeps it orthogonal to state changes.
+ */
+export const heartbeat_action_spec = RequestResponseActionSpec.parse({
+    method: HEARTBEAT_METHOD,
+    kind: 'request_response',
+    initiator: 'frontend',
+    auth: 'authenticated',
+    side_effects: false,
+    input: z.strictObject({}),
+    output: z.strictObject({}),
+    async: true,
+    description: 'Shared activity ping — keeps the socket alive and exercises the dispatch path.',
+});
+/** Handler — nullary echo. Stateless, suitable for high-frequency pings. */
+export const heartbeat_handler = () => ({});
+/**
+ * Composable tuple — spread into the server's `actions` array for dispatch
+ * and into the client's `actions` array so `create_rpc_client` types
+ * `app.api.heartbeat()` against the shared spec.
+ */
+export const heartbeat_action = {
+    spec: heartbeat_action_spec,
+    handler: heartbeat_handler,
+};

package/dist/actions/register_action_ws.d.ts

@@ -24,34 +24,12 @@
 import type { Context, Hono } from 'hono';
 import type { UpgradeWebSocket, WSContext } from 'hono/ws';
 import { type Logger as LoggerType } from '@fuzdev/fuz_util/log.js';
-import { type JsonrpcRequestId } from '../http/jsonrpc.js';
 import type { Uuid } from '../uuid.js';
-import type { ActionSpecUnion } from './action_spec.js';
+import { type Action, type BaseHandlerContext, type WsActionHandler } from './action_types.js';
 import { BackendWebsocketTransport, type ConnectionIdentity } from './transports_ws_backend.js';
-/**
- * Minimum per-request context every handler receives.
- *
- * Consumers extend this with domain-specific fields via
- * `RegisterActionWsOptions.extend_context` (e.g., a `backend` singleton
- * or the authenticated `RequestContext`). Keeping the base minimal matches
- * the HTTP-side `ActionContext` (from `actions/action_rpc.ts`) and mirrors
- * Rust's `Ctx<'a>` shape (`request_id` + `NotifyFn` + `CancellationToken`).
- */
-export interface BaseHandlerContext {
-    /** JSON-RPC envelope request id — echoed back on the response. */
-    request_id: JsonrpcRequestId;
-    /**
-     * Send a request-scoped JSON-RPC notification to the originating socket.
-     * Not a broadcast — the message only reaches the client whose request
-     * triggered this handler. Streaming handlers (e.g. `completion_progress`)
-     * route chunks through this.
-     */
-    notify: (method: string, params: unknown) => void;
-    /** Fires on socket close; streaming handlers poll for early termination. */
-    signal: AbortSignal;
-}
-/** Handler signature — receives validated input and per-request context. */
-export type WsActionHandler<TCtx extends BaseHandlerContext> = (input: unknown, ctx: TCtx) => unknown;
+export type { Action, BaseHandlerContext, WsActionHandler };
+/** Default inactivity window before the server closes a silent socket. */
+export declare const DEFAULT_SERVER_HEARTBEAT_TIMEOUT = 60000;
 /**
  * Context passed to the `on_socket_open` hook.
  *
@@ -91,6 +69,15 @@ export interface SocketCloseContext {
     /** Auth identity captured at open time — still valid even if the transport already cleaned up. */
     identity: ConnectionIdentity;
 }
+export interface ServerHeartbeatOptions {
+    /**
+     * Receive-silence (ms) past which the server closes the socket with
+     * {@link WS_CLOSE_SERVER_HEARTBEAT_TIMEOUT}. Any incoming message resets
+     * the counter — chatty clients never trip it. First {@link timeout}
+     * window after socket open is exempt (cold-start grace).
+     */
+    timeout?: number;
+}
 /** Options for `register_action_ws`. */
 export interface RegisterActionWsOptions<TCtx extends BaseHandlerContext> {
     /** Mount path (e.g., `/api/ws`). */
@@ -99,10 +86,14 @@ export interface RegisterActionWsOptions<TCtx extends BaseHandlerContext> {
     app: Hono;
     /** Hono's `upgradeWebSocket` helper from the runtime adapter. */
     upgradeWebSocket: UpgradeWebSocket;
-    /** Action specs — drives method lookup, per-action auth, and input/output validation. */
-    specs: ReadonlyArray<ActionSpecUnion>;
-    /** Handler map keyed by `spec.method`. */
-    handlers: Record<string, WsActionHandler<TCtx>>;
+    /**
+     * The actions registered on this endpoint — each carries a spec (drives
+     * method lookup, per-action auth, input/output validation) and an
+     * optional handler (omit for client-only specs like inbound
+     * notifications). Include the shared {@link heartbeat_action} here to
+     * complete the disconnect-detection pairing with the frontend client.
+     */
+    actions: ReadonlyArray<Action<TCtx>>;
     /**
      * Build the per-request context from the base and the upgrade-time Hono
      * context. Called once per incoming message. Consumers use this to attach
@@ -116,6 +107,13 @@ export interface RegisterActionWsOptions<TCtx extends BaseHandlerContext> {
      * handle for `create_ws_auth_guard` and `send_to`/`broadcast`.
      */
     transport?: BackendWebsocketTransport;
+    /**
+     * Server-side heartbeat policy. Default-on (receive-silence detection,
+     * 60s timeout). `false` disables the timer entirely — only do this if
+     * the upstream stack (TCP keepalive, Cloudflare idle timeout, etc.)
+     * already owns disconnect detection. Pass an object to tune the timeout.
+     */
+    heartbeat?: boolean | ServerHeartbeatOptions;
     /** Optional per-message delay for testing loading states. Ignored when `0`. */
     artificial_delay?: number;
     /** Optional logger; defaults to `[ws]` namespace. */

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;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,KAAK,EAAC,OAAO,EAAE,IAAI,EAAC,MAAM,MAAM,CAAC;AACxC,OAAO,KAAK,EAAC,gBAAgB,EAAE,SAAS,EAAC,MAAM,SAAS,CAAC;AAEzD,OAAO,EAAS,KAAK,MAAM,IAAI,UAAU,EAAC,MAAM,yBAAyB,CAAC;AAK1E,OAAO,EAAkB,KAAK,gBAAgB,EAAC,MAAM,oBAAoB,CAAC;AAW1E,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,YAAY,CAAC;AACrC,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAC,yBAAyB,EAAE,KAAK,kBAAkB,EAAC,MAAM,4BAA4B,CAAC;AAE9F;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IAClC,kEAAkE;IAClE,UAAU,EAAE,gBAAgB,CAAC;IAC7B;;;;;OAKG;IACH,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IAClD,4EAA4E;IAC5E,MAAM,EAAE,WAAW,CAAC;CACpB;AAED,4EAA4E;AAC5E,MAAM,MAAM,eAAe,CAAC,IAAI,SAAS,kBAAkB,IAAI,CAC9D,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,IAAI,KACL,OAAO,CAAC;AAEb;;;;;;;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,wCAAwC;AACxC,MAAM,WAAW,uBAAuB,CAAC,IAAI,SAAS,kBAAkB;IACvE,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,gCAAgC;IAChC,GAAG,EAAE,IAAI,CAAC;IACV,iEAAiE;IACjE,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,yFAAyF;IACzF,KAAK,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IACtC,0CAA0C;IAC1C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC;IAChD;;;;;OAKG;IACH,cAAc,EAAE,CAAC,IAAI,EAAE,kBAAkB,EAAE,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IAC/D;;;;OAIG;IACH,SAAS,CAAC,EAAE,yBAAyB,CAAC;IACtC,+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;CACpE;AAED,sCAAsC;AACtC,MAAM,WAAW,sBAAsB;IACtC,yEAAyE;IACzE,SAAS,EAAE,yBAAyB,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,kBAAkB,GAAI,IAAI,SAAS,kBAAkB,EACjE,SAAS,uBAAuB,CAAC,IAAI,CAAC,KACpC,sBAwRF,CAAC"}
+{"version":3,"file":"register_action_ws.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/register_action_ws.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,KAAK,EAAC,OAAO,EAAE,IAAI,EAAC,MAAM,MAAM,CAAC;AACxC,OAAO,KAAK,EAAC,gBAAgB,EAAE,SAAS,EAAC,MAAM,SAAS,CAAC;AAEzD,OAAO,EAAS,KAAK,MAAM,IAAI,UAAU,EAAC,MAAM,yBAAyB,CAAC;AAgB1E,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,YAAY,CAAC;AAErC,OAAO,EAAC,KAAK,MAAM,EAAE,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAG7F,OAAO,EAAC,yBAAyB,EAAE,KAAK,kBAAkB,EAAC,MAAM,4BAA4B,CAAC;AAE9F,YAAY,EAAC,MAAM,EAAE,kBAAkB,EAAE,eAAe,EAAC,CAAC;AAE1D,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,CAAC,IAAI,SAAS,kBAAkB;IACvE,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,gCAAgC;IAChC,GAAG,EAAE,IAAI,CAAC;IACV,iEAAiE;IACjE,gBAAgB,EAAE,gBAAgB,CAAC;IACnC;;;;;;OAMG;IACH,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IACrC;;;;;OAKG;IACH,cAAc,EAAE,CAAC,IAAI,EAAE,kBAAkB,EAAE,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IAC/D;;;;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;CACpE;AAED,sCAAsC;AACtC,MAAM,WAAW,sBAAsB;IACtC,yEAAyE;IACzE,SAAS,EAAE,yBAAyB,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,kBAAkB,GAAI,IAAI,SAAS,kBAAkB,EACjE,SAAS,uBAAuB,CAAC,IAAI,CAAC,KACpC,sBAwWF,CAAC"}