@fuzdev/fuz_app 0.43.0 → 0.45.0

package/dist/actions/CLAUDE.md

@@ -581,16 +581,119 @@ per-method transport selector. Useful when methods are registered on
 different backend dispatchers (e.g. streaming action on WS, rest on HTTP).
 Returning `undefined` falls through to the peer's default selection.
 
-`RpcClientActionHistory` — duck-typed integration point for consumers
-(e.g. zzz's Actions cell) that want to record every dispatched event.
-`add_from_json({method, action_event_data})` returns an object with
-`listen_to_action_event(event)` — the Proxy wires each new event into the
-history if supplied.
+`on_action_event: (event: ActionEvent<keyof TApi & string>) => void` —
+optional callback fired once per dispatched action with the live
+`ActionEvent`. Consumers wire reactive state inside the callback — e.g.
+zzz's `Actions` cell calls its own `add_from_json` +
+`listen_to_action_event` here so the history plumbing stays inside zzz
+instead of leaking onto the rpc_client surface. `event.spec.method` and
+`event.data.method` narrow to `keyof TApi & string` so consumers passing
+a generated `ActionsApi` get the literal method-name union without an
+`as ActionMethod` cast at the call site.
 
 Cast the return to a generated `ActionsApi` interface for full typing:
 codegen via `generate_actions_api_method_signature` keeps the shape
 consistent. See ../../docs/usage.md §Typed Client Codegen.
 
+### Throwing variants — `create_throwing_rpc_call` + `create_throwing_api`
+
+Two helpers wrap a typed `create_rpc_client` Proxy so `{ok: false}` results
+throw an `Error` with `{code, message, data?}` (catch blocks read
+`err.data?.reason` — optional chaining required because JSON-RPC `data`
+is spec-level optional). Same hardening on both: only `{code, data}` cross
+onto the Error, leaving `name` / `stack` as the native Error's own so
+attacker-shaped `result.error` payloads cannot overwrite them.
+
+| Helper                     | Shape                            | Use at                                                                     |
+| -------------------------- | -------------------------------- | -------------------------------------------------------------------------- |
+| `create_throwing_rpc_call` | `(method, input?) => Promise<T>` | adapter wiring (e.g. `ui/admin_rpc_adapters.ts`) — method comes from a map |
+| `create_throwing_api`      | typed Proxy over `ActionsApi`    | direct call sites — `await api.foo(input)` keeps full inference            |
+
+**Layered design.** Result is the protocol primitive — `create_rpc_client`
+returns `Result<{value}, {error}>` per call with no Error allocation. The
+throwing wrappers sit _above_ it as ergonomic adapters; both shapes share
+the same underlying transport and call sites pick per-site. `Result` is
+preferable when the call site inspects `error.data.reason` (no Error
+allocation, no try/catch nesting) or when overhead matters (reconnect
+storms, hot paths). Throwing is preferable when the call site doesn't
+inspect — `await api.foo()` reads cleaner than the `if (!r.ok) throw …`
+ritual.
+
+`create_frontend_rpc_client` ships both shapes by default — see
+[Frontend factory](#frontend-factory-frontend_rpc_clientts) below. Direct
+consumers of `create_rpc_client` pass their typed `ActionsApi` as the
+generic to get the typed Result-shaped Proxy without casts, then build
+the throwing form on top:
+
+```ts
+const api_result = create_rpc_client<MyActionsApi>({peer, environment});
+const api = create_throwing_api(api_result);
+// hot path:    await api.foo(input)
+// rare branch: const r = await api_result.foo(input); if (!r.ok) { … }
+```
+
+`create_throwing_rpc_call` is **not** a peer choice for direct call sites —
+it's a niche primitive for method-name-mapping adapter factories
+(`ui/admin_rpc_adapters.ts`) where the method string comes from a domain
+mapping rather than a typed call site. Use it only at adapter boundaries.
+
+`ThrowingApi<TApi>` (the mapped type returned by `create_throwing_api`)
+strips `Promise<Result<{value: T}, {error: JsonrpcErrorObject}>>` to
+`Promise<T>` on every method that matches the `request_response` /
+async `local_call` return shape; `remote_notification` (`=> void`) and
+sync `local_call` methods pass through. The Proxy inspects each call's
+result shape at runtime and only unwraps when it sees a Result, so
+non-Result returns flow through unchanged.
+
+Both helpers throw `"rpc method not found: <name>"` on invocation of an
+unknown method. For `create_throwing_api` the thrower is returned from
+the Proxy get trap so `api.missing()` errors with the same clear
+message rather than the JS default `"api.missing is not a function"`.
+Symbol props and `then` stay `undefined` so the Proxy doesn't get
+probed as a thenable by `await`.
+
+### Frontend factory (`frontend_rpc_client.ts`)
+
+`create_frontend_rpc_client<TApi>({specs, path?, transports?, transport_for_method?, on_action_event?})`
+bundles the `ActionRegistry + ActionEventEnvironment + Transports +
+ActionPeer + create_rpc_client + create_throwing_api` boilerplate every
+consumer repeats — plus the `lookup_action_handler: () => undefined`
+stub (frontend never registers `request_response` handlers; every
+method dispatches over the wire). The `as unknown as TApi` cast happens
+inside the helper, so call sites get a typed return without the cast
+hostility.
+
+Returns both Proxy shapes from one factory call:
+
+- `api: ThrowingApi<TApi>` — typed throwing Proxy. Default for hot-path call sites.
+- `api_result: TApi` — typed Result-shaped Proxy. For sites that inspect `error.data.reason` without try/catch.
+- `peer`, `environment` — exposed for advanced consumers that want to register more transports or share the environment with a separate dispatcher.
+
+```ts
+const {api, api_result} = create_frontend_rpc_client<MyActionsApi>({
+	specs: all_standard_action_specs,
+});
+// hot path:    await api.account_verify()
+// rare branch: const r = await api_result.account_verify(); if (!r.ok) { … }
+```
+
+Default transport is `FrontendHttpTransport(path ?? '/api/rpc')`. Pass
+`transports` for WS-first or mixed setups — when supplied, the default
+HTTP transport is **not** registered. `local_call` specs in `specs`
+silently no-op because `lookup_action_handler` always returns
+`undefined`; this factory targets wire-dispatched actions.
+
+`transport_for_method` and `on_action_event` are pure pass-throughs to
+`create_rpc_client` — exposed so consumers needing per-method routing
+(tx-style WS-for-actions / HTTP-for-rest split) or per-dispatch event
+wiring (zzz-style reactive Cells observing `ActionEvent` lifecycle)
+don't have to drop down to manual `create_rpc_client` construction
+(which forfeits the bundled `api` / `api_result` pair).
+
+`all_standard_action_specs` (in `../auth/standard_action_specs.ts`) is
+the matching aggregate spec list mirroring `create_standard_rpc_actions`
+on the backend — see `../auth/CLAUDE.md` §`standard_rpc_actions.ts`.
+
 ## Broadcast API (`broadcast_api.ts`)
 
 `create_broadcast_api({peer, specs, log?, should_deliver?})` — builds a

package/dist/actions/action_event.d.ts

@@ -17,7 +17,16 @@ export type ActionEventChangeObserver<TMethod extends string = string> = (new_da
 export declare class ActionEvent<TMethod extends string = string, TPhase extends ActionEventPhase = ActionEventPhase, TStep extends ActionEventStep = ActionEventStep> {
     #private;
     readonly environment: ActionEventEnvironment;
-    readonly spec: ActionSpecUnion;
+    /**
+     * `method` narrows to `TMethod` so consumers passing a typed `TApi` to
+     * `create_rpc_client` get `event.spec.method` typed as the union of
+     * their API's method names rather than plain `string`. The runtime
+     * value comes from `lookup_action_spec(method)` keyed off the Proxy
+     * get trap, so the narrowing matches the dispatched method.
+     */
+    readonly spec: ActionSpecUnion & {
+        method: TMethod;
+    };
     get data(): ActionEventDataUnion<TMethod> & {
         phase: TPhase;
         step: TStep;

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

@@ -1 +1 @@
-{"version":3,"file":"action_event.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/action_event.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,OAAO,KAAK,EAAC,gBAAgB,EAAc,eAAe,EAAC,MAAM,kBAAkB,CAAC;AAWpF,OAAO,KAAK,EACX,cAAc,EACd,sBAAsB,EACtB,mBAAmB,EAEnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAC,sBAAsB,EAAE,eAAe,EAAC,MAAM,yBAAyB,CAAC;AACrF,OAAO,EAAkB,KAAK,oBAAoB,EAAC,MAAM,wBAAwB,CAAC;AAclF,MAAM,MAAM,yBAAyB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,IAAI,CACxE,QAAQ,EAAE,oBAAoB,CAAC,OAAO,CAAC,EACvC,QAAQ,EAAE,oBAAoB,CAAC,OAAO,CAAC,EACvC,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,KACvB,IAAI,CAAC;AAEV;;GAEG;AACH,qBAAa,WAAW,CACvB,OAAO,SAAS,MAAM,GAAG,MAAM,EAC/B,MAAM,SAAS,gBAAgB,GAAG,gBAAgB,EAClD,KAAK,SAAS,eAAe,GAAG,eAAe;;IAK/C,QAAQ,CAAC,WAAW,EAAE,sBAAsB,CAAC;IAC7C,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAE/B,IAAI,IAAI,IAAI,oBAAoB,CAAC,OAAO,CAAC,GAAG;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,KAAK,CAAA;KAAC,CAEvE;gBAGA,WAAW,EAAE,sBAAsB,EACnC,IAAI,EAAE,eAAe,EACrB,IAAI,EAAE,oBAAoB,CAAC,OAAO,CAAC;IAOpC,MAAM,IAAI,oBAAoB,CAAC,OAAO,CAAC;IAMvC,OAAO,CAAC,QAAQ,EAAE,yBAAyB,CAAC,OAAO,CAAC,GAAG,MAAM,IAAI;IAKjE,QAAQ,CAAC,QAAQ,EAAE,oBAAoB,CAAC,OAAO,CAAC,GAAG,IAAI;IAUvD;;OAEG;IACH,KAAK,IAAI,IAAI;IA8Cb;;OAEG;IAGG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IA0CnC;;OAEG;IACH,WAAW,IAAI,IAAI;IAkCnB;;OAEG;IACH,UAAU,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI;IAezC,WAAW,IAAI,OAAO;IAItB,eAAe,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI;IAIxC,WAAW,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAQ1C,YAAY,CAAC,QAAQ,EAAE,sBAAsB,GAAG,IAAI;IAUpD,gBAAgB,CAAC,YAAY,EAAE,mBAAmB,GAAG,IAAI;CAyKzD;AAGD;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,SAAS,MAAM,GAAG,MAAM,EAClE,aAAa,sBAAsB,EACnC,MAAM,eAAe,EACrB,OAAO,OAAO,EACd,gBAAgB,gBAAgB,KAC9B,WAAW,CAAC,OAAO,CAiBrB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,6BAA6B,GAAI,OAAO,SAAS,MAAM,GAAG,MAAM,EAC5E,MAAM,oBAAoB,CAAC,OAAO,CAAC,EACnC,aAAa,sBAAsB,KACjC,WAAW,CAAC,OAAO,CAOrB,CAAC;AAIF,eAAO,MAAM,kBAAkB,GAC9B,UAAU,OAAO,EACjB,aAAa,sBAAsB,KACjC,WAGF,CAAC"}
+{"version":3,"file":"action_event.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/action_event.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,OAAO,KAAK,EAAC,gBAAgB,EAAc,eAAe,EAAC,MAAM,kBAAkB,CAAC;AAWpF,OAAO,KAAK,EACX,cAAc,EACd,sBAAsB,EACtB,mBAAmB,EAEnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAC,sBAAsB,EAAE,eAAe,EAAC,MAAM,yBAAyB,CAAC;AACrF,OAAO,EAAkB,KAAK,oBAAoB,EAAC,MAAM,wBAAwB,CAAC;AAclF,MAAM,MAAM,yBAAyB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,IAAI,CACxE,QAAQ,EAAE,oBAAoB,CAAC,OAAO,CAAC,EACvC,QAAQ,EAAE,oBAAoB,CAAC,OAAO,CAAC,EACvC,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,KACvB,IAAI,CAAC;AAEV;;GAEG;AACH,qBAAa,WAAW,CACvB,OAAO,SAAS,MAAM,GAAG,MAAM,EAC/B,MAAM,SAAS,gBAAgB,GAAG,gBAAgB,EAClD,KAAK,SAAS,eAAe,GAAG,eAAe;;IAK/C,QAAQ,CAAC,WAAW,EAAE,sBAAsB,CAAC;IAC7C;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG;QAAC,MAAM,EAAE,OAAO,CAAA;KAAC,CAAC;IAEnD,IAAI,IAAI,IAAI,oBAAoB,CAAC,OAAO,CAAC,GAAG;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,KAAK,CAAA;KAAC,CAEvE;gBAGA,WAAW,EAAE,sBAAsB,EACnC,IAAI,EAAE,eAAe,EACrB,IAAI,EAAE,oBAAoB,CAAC,OAAO,CAAC;IAOpC,MAAM,IAAI,oBAAoB,CAAC,OAAO,CAAC;IAMvC,OAAO,CAAC,QAAQ,EAAE,yBAAyB,CAAC,OAAO,CAAC,GAAG,MAAM,IAAI;IAKjE,QAAQ,CAAC,QAAQ,EAAE,oBAAoB,CAAC,OAAO,CAAC,GAAG,IAAI;IAUvD;;OAEG;IACH,KAAK,IAAI,IAAI;IA8Cb;;OAEG;IAGG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IA0CnC;;OAEG;IACH,WAAW,IAAI,IAAI;IAkCnB;;OAEG;IACH,UAAU,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI;IAezC,WAAW,IAAI,OAAO;IAItB,eAAe,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI;IAIxC,WAAW,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAQ1C,YAAY,CAAC,QAAQ,EAAE,sBAAsB,GAAG,IAAI;IAUpD,gBAAgB,CAAC,YAAY,EAAE,mBAAmB,GAAG,IAAI;CAyKzD;AAGD;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,SAAS,MAAM,GAAG,MAAM,EAClE,aAAa,sBAAsB,EACnC,MAAM,eAAe,EACrB,OAAO,OAAO,EACd,gBAAgB,gBAAgB,KAC9B,WAAW,CAAC,OAAO,CAiBrB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,6BAA6B,GAAI,OAAO,SAAS,MAAM,GAAG,MAAM,EAC5E,MAAM,oBAAoB,CAAC,OAAO,CAAC,EACnC,aAAa,sBAAsB,KACjC,WAAW,CAAC,OAAO,CAOrB,CAAC;AAIF,eAAO,MAAM,kBAAkB,GAC9B,UAAU,OAAO,EACjB,aAAa,sBAAsB,KACjC,WAGF,CAAC"}

package/dist/actions/action_event.js

@@ -19,6 +19,13 @@ export class ActionEvent {
     #data;
     #listeners = new Set();
     environment;
+    /**
+     * `method` narrows to `TMethod` so consumers passing a typed `TApi` to
+     * `create_rpc_client` get `event.spec.method` typed as the union of
+     * their API's method names rather than plain `string`. The runtime
+     * value comes from `lookup_action_spec(method)` keyed off the Proxy
+     * get trap, so the narrowing matches the dispatched method.
+     */
     spec;
     get data() {
         return this.#data;

package/dist/actions/broadcast_api.d.ts

@@ -94,5 +94,5 @@ export type BroadcastApi = Record<string, (input: never) => Promise<void>>;
  * array in sync. Codegen (`action_collections.gen.ts`) is a natural fit
  * if the consumer already generates per-method type maps.
  */
-export declare const create_broadcast_api: <TApi = BroadcastApi>(options: CreateBroadcastApiOptions) => TApi;
+export declare const create_broadcast_api: <TApi extends object>(options: CreateBroadcastApiOptions) => TApi;
 //# sourceMappingURL=broadcast_api.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"broadcast_api.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/broadcast_api.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAS,KAAK,MAAM,IAAI,UAAU,EAAC,MAAM,yBAAyB,CAAC;AAG1E,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAEN,KAAK,kBAAkB,EACvB,MAAM,4BAA4B,CAAC;AAEpC;;;;;;;;GAQG;AACH,MAAM,MAAM,eAAe,GAAG,CAC7B,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,KACV,OAAO,CAAC;AAEb,0CAA0C;AAC1C,MAAM,WAAW,yBAAyB;IACzC,8DAA8D;IAC9D,IAAI,EAAE,UAAU,CAAC;IACjB;;;;;OAKG;IACH,KAAK,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IACtC,gFAAgF;IAChF,GAAG,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IACxB;;;;;;;;;OASG;IACH,cAAc,CAAC,EAAE,eAAe,CAAC;CACjC;AAED;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,oBAAoB,GAAI,IAAI,GAAG,YAAY,EACvD,SAAS,yBAAyB,KAChC,IAoDF,CAAC"}
+{"version":3,"file":"broadcast_api.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/broadcast_api.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAS,KAAK,MAAM,IAAI,UAAU,EAAC,MAAM,yBAAyB,CAAC;AAG1E,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAEN,KAAK,kBAAkB,EACvB,MAAM,4BAA4B,CAAC;AAEpC;;;;;;;;GAQG;AACH,MAAM,MAAM,eAAe,GAAG,CAC7B,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,KACV,OAAO,CAAC;AAEb,0CAA0C;AAC1C,MAAM,WAAW,yBAAyB;IACzC,8DAA8D;IAC9D,IAAI,EAAE,UAAU,CAAC;IACjB;;;;;OAKG;IACH,KAAK,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IACtC,gFAAgF;IAChF,GAAG,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IACxB;;;;;;;;;OASG;IACH,cAAc,CAAC,EAAE,eAAe,CAAC;CACjC;AAED;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,oBAAoB,GAAI,IAAI,SAAS,MAAM,EACvD,SAAS,yBAAyB,KAChC,IAoDF,CAAC"}

package/dist/actions/frontend_rpc_client.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Frontend-only typed RPC client factory.
+ *
+ * Bundles the `ActionRegistry + ActionEventEnvironment + Transports +
+ * ActionPeer + create_rpc_client + create_throwing_api` boilerplate every
+ * consumer repeats — plus the `lookup_action_handler: () => undefined`
+ * stub (frontend never registers `request_response` handlers; every method
+ * dispatches over the wire).
+ *
+ * Returns both Proxy shapes from one factory call:
+ *
+ * - `api` — typed throwing Proxy. `await api.foo(input)` returns the
+ *   unwrapped value or throws an `Error` carrying `{code, data}` from the
+ *   JSON-RPC error. Use at hot-path call sites.
+ * - `api_result` — typed Result-shaped Proxy. `await api_result.foo(input)`
+ *   returns `Result<{value}, {error: JsonrpcErrorObject}>`. Use when call
+ *   sites want to inspect `error.data.reason` without try/catch — and
+ *   anywhere allocating an `Error` per `{ok: false}` is wasteful (e.g.
+ *   reconnect-storm `service_unavailable` paths). Result is the protocol
+ *   primitive; the throwing form is a wrapper over it. Both share the
+ *   same underlying transport — pick per call site, no construction cost.
+ *
+ * Generic `TApi` is the consumer's typed Proxy interface. The `as unknown
+ * as TApi` double cast happens inside the helper so call sites get a
+ * typed return value without the cast hostility. `api`'s type is
+ * `ThrowingApi<TApi>` — the mapped type strips the Result wrapper.
+ *
+ * ```ts
+ * const {api, api_result} = create_frontend_rpc_client<MyActionsApi>({
+ *   specs: all_specs,
+ * });
+ * // hot path:    await api.account_verify()
+ * // rare branch: const r = await api_result.account_verify(); if (!r.ok) { … }
+ * ```
+ *
+ * Returns the underlying `peer` and `environment` alongside the two api
+ * shapes so advanced consumers (zzz-style frontends needing extra
+ * transports / WS notification handlers / action-history wiring) can
+ * extend without recreating the bundle.
+ *
+ * Note: `local_call` specs in `specs` will silently no-op because
+ * `lookup_action_handler` always returns `undefined` — the frontend
+ * factory is for wire-dispatched actions. Frontend-side `local_call`
+ * needs a different wiring shape (custom `environment.lookup_action_handler`).
+ *
+ * @module
+ */
+import { ActionPeer } from './action_peer.js';
+import { type Transport } from './transports.js';
+import { type ThrowingApi, type TransportForMethod } from './rpc_client.js';
+import type { ActionEvent } from './action_event.js';
+import type { ActionEventEnvironment } from './action_event_types.js';
+import type { ActionSpecUnion } from './action_spec.js';
+/** Options for `create_frontend_rpc_client`. */
+export interface CreateFrontendRpcClientOptions<TApi extends object = object> {
+    /**
+     * Action specs the typed Proxy can dispatch. Methods absent from this
+     * list silently return `undefined` from the Proxy — the generic `TApi`
+     * cannot constrain runtime membership, so consumers must keep this list
+     * in sync with the typed surface (codegen recommended).
+     */
+    specs: ReadonlyArray<ActionSpecUnion>;
+    /**
+     * HTTP RPC endpoint path for the default `FrontendHttpTransport`.
+     * Defaults to `/api/rpc`. Ignored when `transports` is provided.
+     */
+    path?: string;
+    /**
+     * Optional explicit transport list. When provided, the default
+     * `FrontendHttpTransport(path)` is **not** registered — the caller is
+     * responsible for at least one ready transport. Use for WS-first or
+     * WS+HTTP mixed setups.
+     */
+    transports?: ReadonlyArray<Transport>;
+    /**
+     * Optional per-method transport selector — pure pass-through to
+     * `create_rpc_client`. Return the transport name to use for a given
+     * method, or `undefined` to fall back to the peer's default selection.
+     *
+     * Useful when methods are registered on different backend dispatchers
+     * (e.g. streaming actions on WS, REST RPC on HTTP) — a tx-style mixed
+     * setup. Per-call `RpcClientCallOptions.transport_name` overrides this
+     * for individual dispatches.
+     */
+    transport_for_method?: TransportForMethod;
+    /**
+     * Optional callback fired once per dispatched action — pure pass-through
+     * to `create_rpc_client`. Used by zzz-style consumers that thread the
+     * `ActionEvent` into a reactive cell (`add_from_json` + `listen_to_action_event`)
+     * for `pending` / `failed` / `value` derivations.
+     *
+     * `event.spec.method` and `event.data.method` narrow to
+     * `keyof TApi & string` — drop the `as ActionMethod` cast at the call
+     * site when `TApi` is a generated `ActionsApi` interface.
+     */
+    on_action_event?: (event: ActionEvent<keyof TApi & string>) => void;
+}
+/** Bundle returned by `create_frontend_rpc_client`. */
+export interface FrontendRpcClient<TApi> {
+    /**
+     * Typed throwing Proxy. `await api.method(input)` returns the unwrapped
+     * value or throws an `Error` with `{code, data}` from the JSON-RPC
+     * error. Default for call sites that don't inspect errors.
+     */
+    api: ThrowingApi<TApi>;
+    /**
+     * Typed Result-shaped Proxy. `await api_result.method(input)` returns
+     * `Result<{value}, {error: JsonrpcErrorObject}>`. Use when call sites
+     * inspect `error.data.reason` without try/catch, or when Error
+     * allocation per `{ok: false}` would be wasteful.
+     */
+    api_result: TApi;
+    /** Underlying peer — exposed for consumers that need to register more transports or send raw messages. */
+    peer: ActionPeer;
+    /** Action environment — exposed for consumers that need to share it (e.g. attach a notification handler registry). */
+    environment: ActionEventEnvironment;
+}
+/**
+ * Build a frontend-only typed RPC client.
+ *
+ * @param options - `specs` (required), optional `path` / `transports` /
+ *   `transport_for_method` / `on_action_event`
+ * @returns `{api, api_result, peer, environment}` — both Proxy shapes plus
+ *   the underlying primitives. `api` throws on `{ok: false}`; `api_result`
+ *   returns the Result.
+ */
+export declare const create_frontend_rpc_client: <TApi extends object>(options: CreateFrontendRpcClientOptions<TApi>) => FrontendRpcClient<TApi>;
+//# sourceMappingURL=frontend_rpc_client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"frontend_rpc_client.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/frontend_rpc_client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAGH,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAa,KAAK,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAE3D,OAAO,EAGN,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAC,sBAAsB,EAAC,MAAM,yBAAyB,CAAC;AACpE,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,kBAAkB,CAAC;AAEtD,gDAAgD;AAChD,MAAM,WAAW,8BAA8B,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM;IAC3E;;;;;OAKG;IACH,KAAK,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IACtC;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,UAAU,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;IACtC;;;;;;;;;OASG;IACH,oBAAoB,CAAC,EAAE,kBAAkB,CAAC;IAC1C;;;;;;;;;OASG;IACH,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,IAAI,CAAC;CACpE;AAED,uDAAuD;AACvD,MAAM,WAAW,iBAAiB,CAAC,IAAI;IACtC;;;;OAIG;IACH,GAAG,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;IACvB;;;;;OAKG;IACH,UAAU,EAAE,IAAI,CAAC;IACjB,0GAA0G;IAC1G,IAAI,EAAE,UAAU,CAAC;IACjB,sHAAsH;IACtH,WAAW,EAAE,sBAAsB,CAAC;CACpC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,GAAI,IAAI,SAAS,MAAM,EAC7D,SAAS,8BAA8B,CAAC,IAAI,CAAC,KAC3C,iBAAiB,CAAC,IAAI,CAsBxB,CAAC"}

package/dist/actions/frontend_rpc_client.js

@@ -0,0 +1,86 @@
+/**
+ * Frontend-only typed RPC client factory.
+ *
+ * Bundles the `ActionRegistry + ActionEventEnvironment + Transports +
+ * ActionPeer + create_rpc_client + create_throwing_api` boilerplate every
+ * consumer repeats — plus the `lookup_action_handler: () => undefined`
+ * stub (frontend never registers `request_response` handlers; every method
+ * dispatches over the wire).
+ *
+ * Returns both Proxy shapes from one factory call:
+ *
+ * - `api` — typed throwing Proxy. `await api.foo(input)` returns the
+ *   unwrapped value or throws an `Error` carrying `{code, data}` from the
+ *   JSON-RPC error. Use at hot-path call sites.
+ * - `api_result` — typed Result-shaped Proxy. `await api_result.foo(input)`
+ *   returns `Result<{value}, {error: JsonrpcErrorObject}>`. Use when call
+ *   sites want to inspect `error.data.reason` without try/catch — and
+ *   anywhere allocating an `Error` per `{ok: false}` is wasteful (e.g.
+ *   reconnect-storm `service_unavailable` paths). Result is the protocol
+ *   primitive; the throwing form is a wrapper over it. Both share the
+ *   same underlying transport — pick per call site, no construction cost.
+ *
+ * Generic `TApi` is the consumer's typed Proxy interface. The `as unknown
+ * as TApi` double cast happens inside the helper so call sites get a
+ * typed return value without the cast hostility. `api`'s type is
+ * `ThrowingApi<TApi>` — the mapped type strips the Result wrapper.
+ *
+ * ```ts
+ * const {api, api_result} = create_frontend_rpc_client<MyActionsApi>({
+ *   specs: all_specs,
+ * });
+ * // hot path:    await api.account_verify()
+ * // rare branch: const r = await api_result.account_verify(); if (!r.ok) { … }
+ * ```
+ *
+ * Returns the underlying `peer` and `environment` alongside the two api
+ * shapes so advanced consumers (zzz-style frontends needing extra
+ * transports / WS notification handlers / action-history wiring) can
+ * extend without recreating the bundle.
+ *
+ * Note: `local_call` specs in `specs` will silently no-op because
+ * `lookup_action_handler` always returns `undefined` — the frontend
+ * factory is for wire-dispatched actions. Frontend-side `local_call`
+ * needs a different wiring shape (custom `environment.lookup_action_handler`).
+ *
+ * @module
+ */
+import { ActionRegistry } from './action_registry.js';
+import { ActionPeer } from './action_peer.js';
+import { Transports } from './transports.js';
+import { FrontendHttpTransport } from './transports_http.js';
+import { create_rpc_client, create_throwing_api, } from './rpc_client.js';
+/**
+ * Build a frontend-only typed RPC client.
+ *
+ * @param options - `specs` (required), optional `path` / `transports` /
+ *   `transport_for_method` / `on_action_event`
+ * @returns `{api, api_result, peer, environment}` — both Proxy shapes plus
+ *   the underlying primitives. `api` throws on `{ok: false}`; `api_result`
+ *   returns the Result.
+ */
+export const create_frontend_rpc_client = (options) => {
+    const registry = new ActionRegistry([...options.specs]);
+    const environment = {
+        executor: 'frontend',
+        lookup_action_spec: (method) => registry.spec_by_method.get(method),
+        lookup_action_handler: () => undefined,
+    };
+    const transports = new Transports();
+    if (options.transports) {
+        for (const t of options.transports)
+            transports.register_transport(t);
+    }
+    else {
+        transports.register_transport(new FrontendHttpTransport(options.path ?? '/api/rpc'));
+    }
+    const peer = new ActionPeer({ environment, transports });
+    const api_result = create_rpc_client({
+        peer,
+        environment,
+        on_action_event: options.on_action_event,
+        transport_for_method: options.transport_for_method,
+    });
+    const api = create_throwing_api(api_result);
+    return { api, api_result, peer, environment };
+};

package/dist/actions/rpc_client.d.ts

@@ -5,14 +5,17 @@
  * - **Tier 1** (simple, for tx): transport send/receive, Result return. No `environment`.
  * - **Tier 2** (full, for zzz): ActionEvent lifecycle with `environment`.
  *
- * Consumers cast the return to their generated `ActionsApi` interface for full type safety.
+ * Pass the consumer's generated `ActionsApi` interface as `<TApi>` to flow
+ * full type safety through without an explicit cast at the call site.
  *
  * @module
  */
+import type { Result } from '@fuzdev/fuz_util/result.js';
 import type { ActionEventEnvironment } from './action_event_types.js';
+import { type ActionEvent } from './action_event.js';
 import type { ActionPeer, ActionPeerSendOptions } from './action_peer.js';
-import type { ActionEventDataUnion } from './action_event_data.js';
 import type { TransportName } from './transports.js';
+import type { JsonrpcErrorObject } from '../http/jsonrpc.js';
 /**
  * Optional per-method transport selector. Return the transport to use for a
  * given method, or `undefined` to let the peer pick via its fallback rules.
@@ -22,21 +25,21 @@ import type { TransportName } from './transports.js';
  * RPC surface lives on HTTP.
  */
 export type TransportForMethod = (method: string) => TransportName | undefined;
-/** Duck-typed action history — consumers pass their concrete Actions cell. */
-export interface RpcClientActionHistory {
-    add_from_json: (json: {
-        method: string;
-        action_event_data: ActionEventDataUnion;
-    }) => {
-        listen_to_action_event: (event: any) => void;
-    } | undefined;
-}
 /** Options for `create_rpc_client`. */
-export interface CreateRpcClientOptions {
+export interface CreateRpcClientOptions<TApi extends object = object> {
     peer: ActionPeer;
     environment: ActionEventEnvironment;
-    /** Optional action history tracking (duck-typed Actions cell). */
-    actions?: RpcClientActionHistory;
+    /**
+     * Optional callback fired once per dispatched action with the live
+     * `ActionEvent`. Consumers wire reactive state here — e.g. zzz's `Actions`
+     * cell calls `add_from_json` + `listen_to_action_event` inside the
+     * callback so its history stays decoupled from the rpc_client surface.
+     *
+     * `event.spec.method` and `event.data.method` narrow to
+     * `keyof TApi & string` — drop the `as ActionMethod` cast at the call
+     * site when `TApi` is a generated `ActionsApi` interface.
+     */
+    on_action_event?: (event: ActionEvent<keyof TApi & string>) => void;
     /**
      * Optional per-method transport selector. When provided, the client calls
      * `peer.send(msg, {transport_name})` with the returned transport for each
@@ -53,10 +56,22 @@ export interface CreateRpcClientOptions {
  * - `remote_notification` → send notification, return Result
  * - `local_call` → execute locally (sync or async), return Result or throw
  *
- * @param options - client options (peer, environment, optional action history)
- * @returns a Proxy that responds to any method name found in the environment's specs
+ * Generic `TApi` is the consumer's typed Proxy interface (typically a
+ * codegen-derived `ActionsApi`). Required — no default, so forgetting it
+ * is a type error rather than a silent slide into `any`. The `as unknown
+ * as TApi` coercion lives inside this function so call sites get a typed
+ * return without a cast at the seam. `TApi` is a type-layer promise about
+ * what the Proxy responds to; the runtime walks `specs` (kept in sync by
+ * the consumer, codegen recommended).
+ *
+ * ```ts
+ * const api_result = create_rpc_client<MyActionsApi>({peer, environment});
+ * ```
+ *
+ * @param options - client options (peer, environment, optional callbacks)
+ * @returns a Proxy typed as `TApi` that responds to any method name found in the environment's specs
  */
-export declare const create_rpc_client: (options: CreateRpcClientOptions) => Record<string, (...args: Array<any>) => any>;
+export declare const create_rpc_client: <TApi extends object>(options: CreateRpcClientOptions<TApi>) => TApi;
 /**
  * Per-call options accepted by every typed Proxy method. Same shape as
  * `ActionPeerSendOptions` — the client threads these through unchanged
@@ -66,51 +81,62 @@ export declare const create_rpc_client: (options: CreateRpcClientOptions) => Rec
 export interface RpcClientCallOptions extends ActionPeerSendOptions {
 }
 /**
- * `method, input -> unwrapped output` signature for adapter wiring.
+ * Maps a typed `ActionsApi` to a throwing variant.
+ *
+ * For each method whose return type matches the `create_rpc_client` shape
+ * (`Promise<Result<{value: T}, {error: JsonrpcErrorObject}>>`), the wrapped
+ * method returns `Promise<T>` directly. Other shapes (notifications typed
+ * as `=> void`, sync `local_call` methods) pass through unchanged — there
+ * is nothing to unwrap.
  *
- * The typed `create_rpc_client` Proxy returns `Result<T, JsonrpcErrorObject>`
- * on every call. UI adapters (e.g. `admin_rpc_adapters.ts`) want a
- * throw-on-error shape so form components can match on `error.data.reason`
- * via catch blocks. `create_throwing_rpc_call` bridges the two.
+ * Input + options parameters are preserved verbatim so generics, branded
+ * Uuids, and per-call `RpcClientCallOptions` keep working.
  */
-export type ThrowingRpcCall = <TOutput = unknown>(method: string, input?: unknown) => Promise<TOutput>;
+export type ThrowingApi<TApi> = {
+    [K in keyof TApi]: TApi[K] extends (input?: infer TInput, options?: infer TOptions) => Promise<Result<{
+        value: infer TValue;
+    }, {
+        error: JsonrpcErrorObject;
+    }>> ? (input?: TInput, options?: TOptions) => Promise<TValue> : TApi[K];
+};
 /**
- * Wrap a typed RPC client so every call returns its unwrapped value or throws.
- *
- * On `{ok: false}`, throws an `Error` whose `message` comes from the
- * JSON-RPC error object, plus `{code, data}` as own properties — so
- * catch blocks reading `err.message` / `err.code` / `err.data?.reason`
- * all work. On unknown method, throws a clear "rpc method not found"
- * error instead of the cryptic `undefined is not a function` that
- * would otherwise surface.
- *
- * Invariant upheld by `create_rpc_client`: every `{ok: false}` return
- * carries a well-formed `JsonrpcErrorObject` with `code` + `message`.
- * Callers must still use optional chaining on `err.data` because the
- * JSON-RPC `data` field is spec-level optional — a handler that throws
- * `jsonrpc_errors.forbidden()` without a `data` argument produces
- * `err.data === undefined`.
- *
- * Only `{code, data}` cross onto the thrown Error — `message` flows
- * through the `Error` constructor argument, and `name` / `stack` are
- * left as the Error's own so attacker-shaped `result.error` payloads
- * cannot overwrite them.
- *
- * The mapped-type generic constraint accepts both shapes without a cast:
- * a codegen-derived typed `ActionsApi` (named-method interface, e.g.
- * `{account_verify: (input) => Promise<Result<...>>, ...}`) and a loose
- * `Record<string, (input?: any) => Promise<any> | void>`. Using `keyof TApi`
- * in the constraint avoids the index-signature requirement that would
- * otherwise force consumers to `as unknown as Record<string, …>` their
- * generated client. The `| void` arm tolerates `remote_notification`
- * methods, whose `ActionsApi` signature is `(input) => void` even though
- * `create_remote_notification_method` returns a Promise at runtime — the
- * throwing wrapper is intended for `request_response` calls but must
- * accept mixed `ActionsApi` shapes without forcing a cast at the seam.
- *
- * @param api - typed RPC client from `create_rpc_client` (or any object
- *   whose values are all `(input?) => Promise<...> | void` functions —
- *   notably the consumer's generated `ActionsApi` interface)
+ * Wrap a typed RPC client so every call resolves to its unwrapped value or
+ * throws an `Error` carrying the JSON-RPC `{code, message, data?}` shape.
+ *
+ * Implementation is a Proxy because the underlying `create_rpc_client`
+ * return is itself a Proxy with no concrete keys — a key-by-key wrap would
+ * need to enumerate the typed surface, which only the consumer's generated
+ * `ActionsApi` interface knows.
+ *
+ * Pass-through on non-Result returns is deliberate: sync `local_call`
+ * Proxy methods return values directly (see `create_sync_local_call_method`
+ * above). The Proxy can't distinguish those at get-time, so the wrapper
+ * inspects `result` shape at call-time and only unwraps when it sees a
+ * Result. Non-object returns pass through unchanged.
+ *
+ * Only `{code, data}` cross onto the thrown Error — `name` / `stack` are
+ * left as the Error's own properties so attacker-shaped `result.error`
+ * payloads cannot overwrite them.
+ *
+ * Recommended consumer convention: `create_frontend_rpc_client` ships
+ * both shapes by default — `api` (throwing) for hot-path call sites and
+ * `api_result` (Result) for sites that inspect `error.data.reason`
+ * without try/catch. Result is the protocol primitive; this wrapper is
+ * the ergonomic layer over it. Picking is per call site — both Proxies
+ * share the same underlying transport.
+ *
+ * Catch blocks read `err.data?.reason` — optional chaining required
+ * because JSON-RPC `data` is spec-level optional.
+ *
+ * On unknown string-keyed methods, the get trap returns a function that
+ * throws `"rpc method not found: <prop>"` on invocation — clearer than
+ * the JS default `"api.foo is not a function"`. Symbol props and `then`
+ * stay undefined so the Proxy isn't accidentally treated as a thenable
+ * (`await api` would otherwise probe `then` and trip the thrower).
+ *
+ * @param api_result - typed Result-returning RPC client from
+ *   `create_rpc_client<ActionsApi>(...)`. The "_result" suffix names
+ *   what the underlying calls return (`Result<{value}, {error}>`).
  */
-export declare const create_throwing_rpc_call: <TApi extends Record<keyof TApi, (input?: any) => Promise<any> | void>>(api: TApi) => ThrowingRpcCall;
+export declare const create_throwing_api: <TApi extends object>(api_result: TApi) => ThrowingApi<TApi>;
 //# sourceMappingURL=rpc_client.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"rpc_client.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/rpc_client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAQH,OAAO,KAAK,EAAC,sBAAsB,EAAC,MAAM,yBAAyB,CAAC;AAOpE,OAAO,KAAK,EAAC,UAAU,EAAE,qBAAqB,EAAC,MAAM,kBAAkB,CAAC;AACxE,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAGnD;;;;;;;GAOG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,aAAa,GAAG,SAAS,CAAC;AAM/E,8EAA8E;AAC9E,MAAM,WAAW,sBAAsB;IACtC,aAAa,EAAE,CAAC,IAAI,EAAE;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,oBAAoB,CAAA;KAAC,KAC5E;QACA,sBAAsB,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;KAC5C,GACD,SAAS,CAAC;CACb;AAED,uCAAuC;AACvC,MAAM,WAAW,sBAAsB;IACtC,IAAI,EAAE,UAAU,CAAC;IACjB,WAAW,EAAE,sBAAsB,CAAC;IACpC,kEAAkE;IAClE,OAAO,CAAC,EAAE,sBAAsB,CAAC;IACjC;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,kBAAkB,CAAC;CAC1C;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,GAC7B,SAAS,sBAAsB,KAC7B,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,GAAG,CAgB7C,CAAC;AA2DF;;;;;GAKG;AACH,MAAM,WAAW,oBAAqB,SAAQ,qBAAqB;CAAG;AAgItE;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,GAAG,OAAO,EAC/C,MAAM,EAAE,MAAM,EACd,KAAK,CAAC,EAAE,OAAO,KACX,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,wBAAwB,GACpC,IAAI,SAAS,MAAM,CAAC,MAAM,IAAI,EAAE,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,EAErE,KAAK,IAAI,KACP,eAcF,CAAC"}
+{"version":3,"file":"rpc_client.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/rpc_client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,4BAA4B,CAAC;AAQvD,OAAO,KAAK,EAAC,sBAAsB,EAAC,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAsB,KAAK,WAAW,EAAC,MAAM,mBAAmB,CAAC;AAMxE,OAAO,KAAK,EAAC,UAAU,EAAE,qBAAqB,EAAC,MAAM,kBAAkB,CAAC;AACxE,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAEnD,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAE3D;;;;;;;GAOG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,aAAa,GAAG,SAAS,CAAC;AAM/E,uCAAuC;AACvC,MAAM,WAAW,sBAAsB,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM;IACnE,IAAI,EAAE,UAAU,CAAC;IACjB,WAAW,EAAE,sBAAsB,CAAC;IACpC;;;;;;;;;OASG;IACH,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,IAAI,CAAC;IACpE;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,kBAAkB,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,iBAAiB,GAAI,IAAI,SAAS,MAAM,EACpD,SAAS,sBAAsB,CAAC,IAAI,CAAC,KACnC,IA4BF,CAAC;AA6DF;;;;;GAKG;AACH,MAAM,WAAW,oBAAqB,SAAQ,qBAAqB;CAAG;AAoHtE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,CAAC,IAAI,IAAI;KAC9B,CAAC,IAAI,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,SAAS,CAClC,KAAK,CAAC,EAAE,MAAM,MAAM,EACpB,OAAO,CAAC,EAAE,MAAM,QAAQ,KACpB,OAAO,CAAC,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,MAAM,CAAA;KAAC,EAAE;QAAC,KAAK,EAAE,kBAAkB,CAAA;KAAC,CAAC,CAAC,GACrE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,QAAQ,KAAK,OAAO,CAAC,MAAM,CAAC,GACvD,IAAI,CAAC,CAAC,CAAC;CACV,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,mBAAmB,GAAI,IAAI,SAAS,MAAM,EAAE,YAAY,IAAI,KAAG,WAAW,CAAC,IAAI,CA8B3F,CAAC"}