@fuzdev/fuz_app 0.45.0 → 0.47.0

package/dist/actions/CLAUDE.md

@@ -77,14 +77,66 @@ the system matures.
 `action_codegen.ts` provides gen helpers (used by consumer `*.gen.ts` files,
 not the runtime):
 
+### Primitives
+
 - `ImportBuilder` — tracks value / type / namespace imports; emits `import type` when every entry on a module is a type (tree-shaking). Namespace (`* as specs`) entries are emitted verbatim. Public surface: `add`, `add_type`, `add_many`, `add_types`, `build`, `preview`, `has_imports`, `import_count`, `clear`.
 - `get_executor_phases(spec, executor)` — phases a given executor (`'frontend' | 'backend'`) participates in for the spec. Deduplicates via `Set` (handles `initiator: 'both'` overlap).
-- `get_handler_return_type(spec, phase, imports, path_prefix)` — the TS type a phase handler must return; triggers the `ActionOutputs` import as a side effect.
-- `generate_phase_handlers(spec, executor, imports, {action_event_type?})` — emits the typed handler-map fragment for one action; consumers compose these into `ActionHandlers` types.
-- `generate_actions_api_method_signature(spec, {sync_returns_value?})` — single source of truth for the typed `ActionsApi` method shape. Threads `options?: RpcClientCallOptions` (`{signal?, transport_name?, queue?}`) onto every async method — `request_response`, `remote_notification`, and async `local_call` — and wraps the return in `Promise<Result<...>>`. Notifications were previously emitted as `=> void`, mismatching the runtime (`create_remote_notification_method` returns a Promise that resolves to `Result<{value: void}>`); regenerate consumer typed clients to pick up the corrected shape. Older inline templates using `get_innermost_type_name` directly drop the options arg — also regenerate those.
+- `get_handler_return_type(spec, phase, imports, collections_path?)` — the TS type a phase handler must return; triggers the `ActionOutputs` import (sourced from `collections_path`, default `'./action_collections.js'`) as a side effect.
+- `generate_phase_handlers(spec, executor, imports, {action_event_type?, collections_path?})` — emits the typed handler-map fragment for one action; consumers compose these into `ActionHandlers` types.
+- `generate_actions_api_method_signature(spec, {sync_returns_value?})` — single source of truth for the typed `ActionsApi` method shape. Threads `options?: RpcClientCallOptions` (`{signal?, transport_name?, queue?}`) onto every async method — `request_response`, `remote_notification`, and async `local_call` — and wraps the return in `Promise<Result<...>>`. Notifications were previously emitted as `=> void`, mismatching the runtime (`create_remote_notification_method` returns a Promise that resolves to `Result<{value: void}>`); regenerate consumer typed clients to pick up the corrected shape.
 - `create_banner(origin_path)` — gen banner comment.
 - `to_action_spec_identifier(method)` / `to_action_spec_input_identifier` / `to_action_spec_output_identifier` — naming convention helpers (emit `foo_action_spec` / `foo_action_spec.input` / `foo_action_spec.output`).
-- `get_innermost_type(schema)` / `get_innermost_type_name(schema)` — unwrap Zod `ZodOptional` / `ZodNullable` / `ZodDefault` / transforms / pipes / prefaults to reach the base schema.
+- `COMPOSABLE_ACTION_METHODS` (+ `ComposableActionMethod` type) — readonly tuple `['heartbeat', 'cancel']`. Consumers spread when filtering backend `request_response` methods so dispatcher-owned composables don't leak into `BackendRequestResponseMethod` / handler maps.
+- `is_composable_action_method(method)` — type predicate paired with `COMPOSABLE_ACTION_METHODS`; use this in `method_filter` callbacks instead of `COMPOSABLE_ACTION_METHODS.includes(s.method as never)`.
+- `DEFAULT_COLLECTIONS_PATH = './action_collections.js'` — shared default for every helper that takes a `collections_path?`.
+- `DEFAULT_SPECS_MODULE = './action_specs.js'` — shared default for helpers that emit `specs.{method}_action_spec` and need a `* as specs` namespace import.
+- `DEFAULT_METATYPES_PATH = './action_metatypes.js'` — shared default for the sibling module carrying the generated `ActionMethod` enum.
+
+### High-level helpers (Step 1 of codegen orchestration upstream — 2026-04-26)
+
+Each accepts `(specs, imports, options?)` and returns one block of declarations.
+Composed by consumer `*.gen.ts` producers; outputs do not include the banner or
+surrounding `imports.build()`.
+
+**Composables are filtered by default.** Every spec-iterating helper accepts
+`{include_composables?: boolean}` (default `false`) and drops `heartbeat` /
+`cancel` from the emitted output. Composables ship from fuz_app and are
+spread into each consumer's `actions` array at registration time — they
+should not appear in consumer-owned typed surfaces (`ActionMethod`,
+`ActionsApi`, `ActionInputs`, `FrontendActionHandlers`, etc.). Pass
+`include_composables: true` only if a consumer genuinely owns composables
+in their typed API.
+
+**Consumer tiers and the single-namespace assumption.** Single-source consumers
+(zzz, undying — every spec lives in one local `action_specs.ts`) drop straight
+into the helpers. Multi-source consumers (tx, visiones — which stitch local
+specs together with `all_admin_action_specs` / `all_permit_offer_action_specs` /
+`all_account_action_specs` / `all_self_service_role_action_specs` from fuz_app)
+need a per-method namespace lookup, and the helpers that emit
+`specs.{method}_action_spec` (`generate_action_specs_record`,
+`generate_action_inputs_outputs`, `generate_backend_actions_api`) currently
+assume one `* as specs from specs_module` import covers everything. Multi-source
+consumers keep using the lower-level primitives directly
+(`to_action_spec_input_identifier`, `to_action_spec_output_identifier`,
+`ActionRegistry`) — see tx's `action_collections.gen.ts` for the current
+pattern. A `qualify_spec?: (spec) => string` callback is the planned extension
+point; design it against the Step 3 (tx parity) consumer.
+
+Tier 1 (HTTP-only, e.g. tx/visiones) emits a smaller surface — typically just
+`ActionMethod` + `ActionsApi` + `ActionInputs` / `ActionOutputs` interfaces —
+and never calls `generate_typed_action_event_alias` or
+`generate_frontend_action_handlers`. Tier 2 (`TypedActionEvent`-aware, e.g.
+zzz) emits the full set including `ActionEventDatas`, `TypedActionEvent`, and
+`FrontendActionHandlers`.
+
+- `generate_action_method_enums(specs, imports, {emit?})` — up to six `z.enum` + `z.infer` pairs (`ActionMethod`, `RequestResponseActionMethod`, `RemoteNotificationActionMethod`, `LocalCallActionMethod`, `FrontendActionMethod`, `BackendActionMethod`). `emit: ReadonlySet<ActionMethodEnumKind>` restricts to a subset (Tier 1 HTTP-only consumers don't need all six). Skips kinds whose method list is empty (`z.enum([])` is invalid) and skips the `zod` import when no blocks are emitted. Adds `import {z} from 'zod'` only when at least one block is produced.
+- `generate_typed_action_event_alias(imports, {collections_path?, metatypes_path?})` — fixed-shape `TypedActionEvent<TMethod, TPhase, TStep>` alias narrowing `ActionEvent.data` against `ActionEventDatas`. Adds the three fuz_app type imports + `ActionEventDatas` (from `collections_path`) + `ActionMethod` (from `metatypes_path`).
+- `generate_action_specs_record(specs, imports, {specs_module?})` — `ActionSpecs` runtime const + interface + `action_specs: Array<ActionSpecUnion>` value. Adds `* as specs` from `specs_module`.
+- `generate_action_inputs_outputs(specs, imports, {specs_module?})` — `ActionInputs` and `ActionOutputs` runtime consts + interfaces. Adds `* as specs` from `specs_module`.
+- `generate_action_event_datas(specs, imports, {collections_path?})` — `ActionEventDatas` interface; per-spec variant by kind (`ActionEventRequestResponseData` / `ActionEventRemoteNotificationData` / `ActionEventLocalCallData`). When `collections_path` is set, adds `ActionInputs` / `ActionOutputs` type imports from that path; default (unset) assumes same-file scope, the zzz pattern where this helper feeds the same `action_collections.ts` output as `generate_action_inputs_outputs`.
+- `generate_actions_api(specs, imports, {method_filter?, collections_path?, sync_returns_value?})` — `ActionsApi` interface. Composables filtered by default; `method_filter: (spec) => boolean` runs after the composable filter for tx-style additional subsets.
+- `generate_frontend_action_handlers(specs, imports, {collections_path?})` — `FrontendActionHandlers` interface (Tier 2 only — wraps `generate_phase_handlers` with `action_event_type: 'TypedActionEvent'`). Pair with `generate_typed_action_event_alias`.
+- `generate_backend_actions_api(specs, imports, {specs_module?, collections_path?})` — `BackendActionsApi` interface AND `broadcast_action_specs: ReadonlyArray<ActionSpecUnion>` array. Filter: `kind === 'remote_notification' && initiator !== 'frontend'`. Adds the `* as specs` namespace import + `ActionInputs` (from `collections_path`) + `ActionSpecUnion`.
 
 ## HTTP bridge (`action_bridge.ts`)
 

package/dist/actions/action_codegen.d.ts

@@ -1,4 +1,24 @@
 import type { ActionSpecUnion, ActionEventPhase } from './action_spec.js';
+/**
+ * Method names of composable actions exported from fuz_app — `heartbeat` (auth-aware
+ * client liveness probe) and `cancel` (request-scoped abort signal). Consumers spread
+ * this list when filtering backend request_response methods so the dispatcher-owned
+ * composables don't show up in `BackendRequestResponseMethod` / handler maps.
+ */
+export declare const COMPOSABLE_ACTION_METHODS: readonly ["heartbeat", "cancel"];
+/** Methods that ship from fuz_app, kept out of consumer-owned method enums + handler maps. */
+export type ComposableActionMethod = (typeof COMPOSABLE_ACTION_METHODS)[number];
+/**
+ * Type predicate for filtering composable methods out of a typed `ActionsApi`
+ * `method_filter`. Avoids the `(... as never)` cast required to call
+ * `Array.prototype.includes` on the readonly tuple at narrow string types.
+ *
+ * @example
+ * generate_actions_api(specs, imports, {
+ *   method_filter: (s) => !is_composable_action_method(s.method),
+ * });
+ */
+export declare const is_composable_action_method: (method: string) => method is ComposableActionMethod;
 /**
  * Represents an import item with its kind (type, value, or namespace).
  */
@@ -79,20 +99,30 @@ export declare class ImportBuilder {
  * Determines which phases an executor can handle based on the action spec.
  */
 export declare const get_executor_phases: (spec: ActionSpecUnion, executor: "frontend" | "backend") => Array<ActionEventPhase>;
+/** Default `collections_path` — every consumer's gen producers point at the sibling `action_collections.js`. */
+export declare const DEFAULT_COLLECTIONS_PATH = "./action_collections.js";
+/** Default `specs_module` — sibling `action_specs.js` namespace bundled by the consumer. */
+export declare const DEFAULT_SPECS_MODULE = "./action_specs.js";
+/** Default `metatypes_path` — sibling `action_metatypes.js` carrying the generated `ActionMethod`. */
+export declare const DEFAULT_METATYPES_PATH = "./action_metatypes.js";
 /**
- * Gets the handler return type for a specific phase and spec.
- * Also adds necessary imports to the `ImportBuilder`.
+ * Gets the handler return type for a specific phase and spec. Adds an
+ * `ActionOutputs` import (from `collections_path`) when the phase carries an
+ * output (request_response `receive_request`, local_call `execute`).
  */
-export declare const get_handler_return_type: (spec: ActionSpecUnion, phase: ActionEventPhase, imports: ImportBuilder, path_prefix: string) => string;
+export declare const get_handler_return_type: (spec: ActionSpecUnion, phase: ActionEventPhase, imports: ImportBuilder, collections_path?: string) => string;
 /**
  * Generates the phase handlers for an action spec using the unified ActionEvent type
  * with the new phase/step type parameters.
  *
  * @param options.action_event_type - custom type name to use instead of `ActionEvent`
  *   (consumers can define a narrowed type that carries typed input/output via their codegen maps)
+ * @param options.collections_path - import path the side-effect `ActionOutputs` import
+ *   resolves to. Defaults to `'./action_collections.js'`.
  */
 export declare const generate_phase_handlers: (spec: ActionSpecUnion, executor: "frontend" | "backend", imports: ImportBuilder, options?: {
     action_event_type?: string;
+    collections_path?: string;
 }) => string;
 /**
  * Creates a file banner comment.
@@ -132,5 +162,141 @@ export declare const to_action_spec_output_identifier: (method: string) => strin
 export declare const generate_actions_api_method_signature: (spec: ActionSpecUnion, options?: {
     sync_returns_value?: boolean;
 }) => string;
+/** Discriminator for `generate_action_method_enums` — which method-set enums to emit. */
+export type ActionMethodEnumKind = 'all' | 'request_response' | 'remote_notification' | 'local_call' | 'frontend' | 'backend';
+/** Default emit set — every enum kind. */
+export declare const ACTION_METHOD_ENUM_KINDS_ALL: ReadonlySet<ActionMethodEnumKind>;
+/**
+ * Emit one or more `z.enum([...])` declarations for action method names —
+ * `ActionMethod`, `RequestResponseActionMethod`, `RemoteNotificationActionMethod`,
+ * `LocalCallActionMethod`, `FrontendActionMethod`, `BackendActionMethod`. Pairs
+ * each runtime const with a `z.infer` type alias under the same identifier.
+ *
+ * Composable methods (`heartbeat`, `cancel`) are filtered out by default —
+ * pass `include_composables: true` if a consumer genuinely wants them on
+ * their typed surface. Empty kinds are skipped so the helper never emits
+ * `z.enum([])` (zod runtime-throws on that).
+ *
+ * Adds `import {z} from 'zod';` to `imports` only when at least one block
+ * is emitted (idempotent).
+ *
+ * @param options.emit - subset of enums to emit; defaults to all six.
+ * @param options.include_composables - when true, retains `heartbeat` /
+ *   `cancel` in the emitted enums. Default `false`.
+ */
+export declare const generate_action_method_enums: (specs: ReadonlyArray<ActionSpecUnion>, imports: ImportBuilder, options?: {
+    emit?: ReadonlySet<ActionMethodEnumKind>;
+    include_composables?: boolean;
+}) => string;
+/**
+ * Emit the fixed-shape `TypedActionEvent` alias used by `FrontendActionHandlers`
+ * to narrow `ActionEvent.data` against the consumer's generated `ActionEventDatas`
+ * map. Registers the four fuz_app type imports it needs (`ActionEvent`,
+ * `ActionEventPhase`, `ActionEventStep`, `ActionEventDatas`) plus the
+ * `ActionMethod` type import — sourced from `collections_path` and
+ * `metatypes_path` respectively.
+ *
+ * Pair with `generate_action_method_enums` (emits `ActionMethod` into
+ * `metatypes_path`) and `generate_action_event_datas` (emits
+ * `ActionEventDatas` into `collections_path`).
+ */
+export declare const generate_typed_action_event_alias: (imports: ImportBuilder, options?: {
+    collections_path?: string;
+    metatypes_path?: string;
+}) => string;
+/**
+ * Emit the `ActionSpecs` runtime const + interface + the `action_specs:
+ * Array<ActionSpecUnion>` value bundling every spec. Adds the `* as specs`
+ * namespace import + the `ActionSpecUnion` type import.
+ *
+ * **Single-namespace.** Every spec is referenced as `specs.{method}_action_spec`.
+ * Multi-source consumers (tx, visiones) need a per-method namespace lookup
+ * and currently use lower-level primitives instead — see the `--- High-level
+ * codegen helpers ---` banner above for the rationale and the planned
+ * `qualify_spec?` extension point.
+ */
+export declare const generate_action_specs_record: (specs: ReadonlyArray<ActionSpecUnion>, imports: ImportBuilder, options?: {
+    specs_module?: string;
+    include_composables?: boolean;
+}) => string;
+/**
+ * Emit `ActionInputs` + `ActionOutputs` runtime consts and matching interfaces.
+ * The runtime consts reference `specs.{method}_action_spec.input` /
+ * `.output`; the interfaces use `z.infer`.
+ *
+ * Adds `import {z} from 'zod';` and the `* as specs` namespace import.
+ *
+ * **Single-namespace.** Same caveat as `generate_action_specs_record` —
+ * multi-source consumers use the lower-level primitives.
+ */
+export declare const generate_action_inputs_outputs: (specs: ReadonlyArray<ActionSpecUnion>, imports: ImportBuilder, options?: {
+    specs_module?: string;
+    include_composables?: boolean;
+}) => string;
+/**
+ * Emit the `ActionEventDatas` interface — one `ActionEvent*Data` variant per
+ * method, parameterized by the spec's kind:
+ * - `request_response` → `ActionEventRequestResponseData<method, input, output>`
+ * - `remote_notification` → `ActionEventRemoteNotificationData<method, input>`
+ * - `local_call` → `ActionEventLocalCallData<method, input, output>`
+ *
+ * Adds the per-kind data type imports (only the kinds that appear in `specs`).
+ *
+ * @param options.collections_path - when set, adds `ActionInputs` /
+ *   `ActionOutputs` type imports from this path. Leave unset (default) when
+ *   the producer emits `ActionEventDatas` in the same file as
+ *   `ActionInputs` / `ActionOutputs` — same-file scope means no imports
+ *   needed (the zzz pattern, where `generate_action_inputs_outputs` and
+ *   this helper feed the same `action_collections.ts` output).
+ */
+export declare const generate_action_event_datas: (specs: ReadonlyArray<ActionSpecUnion>, imports: ImportBuilder, options?: {
+    collections_path?: string;
+    include_composables?: boolean;
+}) => string;
+/**
+ * Emit the `ActionsApi` interface — one method signature per spec via
+ * `generate_actions_api_method_signature`. Optionally filter the spec set
+ * (e.g. omit composable methods) via `method_filter`.
+ *
+ * Adds the `Result`, `JsonrpcErrorObject`, and `RpcClientCallOptions` type
+ * imports plus `ActionInputs` / `ActionOutputs` (sourced from `collections_path`).
+ */
+export declare const generate_actions_api: (specs: ReadonlyArray<ActionSpecUnion>, imports: ImportBuilder, options?: {
+    method_filter?: (spec: ActionSpecUnion) => boolean;
+    collections_path?: string;
+    sync_returns_value?: boolean;
+    include_composables?: boolean;
+}) => string;
+/**
+ * Emit the `FrontendActionHandlers` interface — wraps `generate_phase_handlers`
+ * with the `TypedActionEvent` action-event type and standard 1-tab per-method
+ * indentation. Pairs with `generate_typed_action_event_alias` (emits the
+ * matching `TypedActionEvent` alias) — call both in the same gen producer.
+ */
+export declare const generate_frontend_action_handlers: (specs: ReadonlyArray<ActionSpecUnion>, imports: ImportBuilder, options?: {
+    collections_path?: string;
+    include_composables?: boolean;
+}) => string;
+/**
+ * Emit BOTH the typed `BackendActionsApi` interface AND the
+ * `broadcast_action_specs` runtime array. The interface is shaped for
+ * `create_broadcast_api`: backend-initiated `remote_notification` methods,
+ * each `(input) => Promise<void>`. The array bundles the matching specs as a
+ * `ReadonlyArray<ActionSpecUnion>`.
+ *
+ * Filter: `kind === 'remote_notification' && initiator !== 'frontend'`.
+ *
+ * Adds the `* as specs` namespace import (from `specs_module`), the
+ * `ActionInputs` type import (from `collections_path`), and the
+ * `ActionSpecUnion` type import.
+ *
+ * **Single-namespace.** Same caveat as `generate_action_specs_record` —
+ * multi-source consumers use the lower-level primitives.
+ */
+export declare const generate_backend_actions_api: (specs: ReadonlyArray<ActionSpecUnion>, imports: ImportBuilder, options?: {
+    specs_module?: string;
+    collections_path?: string;
+    include_composables?: 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":"AAGA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,qCAAqC,GACjD,MAAM,eAAe,EACrB,UAAU;IAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAAC,KACtC,MAoBF,CAAC"}
+{"version":3,"file":"action_codegen.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/action_codegen.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,eAAe,EAAE,gBAAgB,EAAC,MAAM,kBAAkB,CAAC;AAGxE;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,kCAAmC,CAAC;AAE1E,8FAA8F;AAC9F,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAC;AAIhF;;;;;;;;;GASG;AACH,eAAO,MAAM,2BAA2B,GAAI,QAAQ,MAAM,KAAG,MAAM,IAAI,sBACrC,CAAC;AAOnC;;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,gHAAgH;AAChH,eAAO,MAAM,wBAAwB,4BAA4B,CAAC;AAElE,4FAA4F;AAC5F,eAAO,MAAM,oBAAoB,sBAAsB,CAAC;AAExD,sGAAsG;AACtG,eAAO,MAAM,sBAAsB,0BAA0B,CAAC;AAE9D;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,GACnC,MAAM,eAAe,EACrB,OAAO,gBAAgB,EACvB,SAAS,aAAa,EACtB,mBAAkB,MAAiC,KACjD,MAkBF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,GACnC,MAAM,eAAe,EACrB,UAAU,UAAU,GAAG,SAAS,EAChC,SAAS,aAAa,EACtB,UAAU;IAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAAC,KAC/D,MA2BF,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;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,qCAAqC,GACjD,MAAM,eAAe,EACrB,UAAU;IAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAAC,KACtC,MAoBF,CAAC;AAsBF,yFAAyF;AACzF,MAAM,MAAM,oBAAoB,GAC7B,KAAK,GACL,kBAAkB,GAClB,qBAAqB,GACrB,YAAY,GACZ,UAAU,GACV,SAAS,CAAC;AAEb,0CAA0C;AAC1C,eAAO,MAAM,4BAA4B,EAAE,WAAW,CAAC,oBAAoB,CAOzE,CAAC;AAcH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,4BAA4B,GACxC,OAAO,aAAa,CAAC,eAAe,CAAC,EACrC,SAAS,aAAa,EACtB,UAAU;IAAC,IAAI,CAAC,EAAE,WAAW,CAAC,oBAAoB,CAAC,CAAC;IAAC,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAAC,KACjF,MA6DF,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iCAAiC,GAC7C,SAAS,aAAa,EACtB,UAAU;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAC,KAC5D,MAcF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,4BAA4B,GACxC,OAAO,aAAa,CAAC,eAAe,CAAC,EACrC,SAAS,aAAa,EACtB,UAAU;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAAC,KAC9D,MAuCF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,8BAA8B,GAC1C,OAAO,aAAa,CAAC,eAAe,CAAC,EACrC,SAAS,aAAa,EACtB,UAAU;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAAC,KAC9D,MA+DF,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,2BAA2B,GACvC,OAAO,aAAa,CAAC,eAAe,CAAC,EACrC,SAAS,aAAa,EACtB,UAAU;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAAC,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAAC,KAClE,MAwCF,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAChC,OAAO,aAAa,CAAC,eAAe,CAAC,EACrC,SAAS,aAAa,EACtB,UAAU;IACT,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,eAAe,KAAK,OAAO,CAAC;IACnD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC9B,KACC,MAuCF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC,GAC7C,OAAO,aAAa,CAAC,eAAe,CAAC,EACrC,SAAS,aAAa,EACtB,UAAU;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAAC,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAAC,KAClE,MA+BF,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,4BAA4B,GACxC,OAAO,aAAa,CAAC,eAAe,CAAC,EACrC,SAAS,aAAa,EACtB,UAAU;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAAC,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAAC,KACzF,MAwCF,CAAC"}

package/dist/actions/action_codegen.js

@@ -1,5 +1,25 @@
 import { UnreachableError } from '@fuzdev/fuz_util/error.js';
 import { zod_get_base_type } from '@fuzdev/fuz_util/zod.js';
+import { ActionRegistry } from './action_registry.js';
+/**
+ * Method names of composable actions exported from fuz_app — `heartbeat` (auth-aware
+ * client liveness probe) and `cancel` (request-scoped abort signal). Consumers spread
+ * this list when filtering backend request_response methods so the dispatcher-owned
+ * composables don't show up in `BackendRequestResponseMethod` / handler maps.
+ */
+export const COMPOSABLE_ACTION_METHODS = ['heartbeat', 'cancel'];
+const COMPOSABLE_METHOD_SET = new Set(COMPOSABLE_ACTION_METHODS);
+/**
+ * Type predicate for filtering composable methods out of a typed `ActionsApi`
+ * `method_filter`. Avoids the `(... as never)` cast required to call
+ * `Array.prototype.includes` on the readonly tuple at narrow string types.
+ *
+ * @example
+ * generate_actions_api(specs, imports, {
+ *   method_filter: (s) => !is_composable_action_method(s.method),
+ * });
+ */
+export const is_composable_action_method = (method) => COMPOSABLE_METHOD_SET.has(method);
 /**
  * Manages imports for generated code, building them on demand.
  * Automatically optimizes type-only imports to use `import type` syntax.
@@ -223,21 +243,28 @@ export const get_executor_phases = (spec, executor) => {
     // Deduplicate phases (e.g., send_error added twice for initiator:'both' backend actions)
     return Array.from(new Set(phases));
 };
+/** Default `collections_path` — every consumer's gen producers point at the sibling `action_collections.js`. */
+export const DEFAULT_COLLECTIONS_PATH = './action_collections.js';
+/** Default `specs_module` — sibling `action_specs.js` namespace bundled by the consumer. */
+export const DEFAULT_SPECS_MODULE = './action_specs.js';
+/** Default `metatypes_path` — sibling `action_metatypes.js` carrying the generated `ActionMethod`. */
+export const DEFAULT_METATYPES_PATH = './action_metatypes.js';
 /**
- * Gets the handler return type for a specific phase and spec.
- * Also adds necessary imports to the `ImportBuilder`.
+ * Gets the handler return type for a specific phase and spec. Adds an
+ * `ActionOutputs` import (from `collections_path`) when the phase carries an
+ * output (request_response `receive_request`, local_call `execute`).
  */
-export const get_handler_return_type = (spec, phase, imports, path_prefix) => {
+export const get_handler_return_type = (spec, phase, imports, collections_path = DEFAULT_COLLECTIONS_PATH) => {
     // For request_response receive_request, handler returns the output
     if (spec.kind === 'request_response' && phase === 'receive_request') {
-        imports.add_type(`${path_prefix}action_collections.js`, 'ActionOutputs');
+        imports.add_type(collections_path, 'ActionOutputs');
         const base_type = `ActionOutputs['${spec.method}']`;
         // Request/response actions are always async
         return `${base_type} | Promise<${base_type}>`;
     }
     // For local_call execute, handler returns the output
     if (spec.kind === 'local_call' && phase === 'execute') {
-        imports.add_type(`${path_prefix}action_collections.js`, 'ActionOutputs');
+        imports.add_type(collections_path, 'ActionOutputs');
         const base_type = `ActionOutputs['${spec.method}']`;
         return spec.async ? `${base_type} | Promise<${base_type}>` : base_type;
     }
@@ -250,6 +277,8 @@ export const get_handler_return_type = (spec, phase, imports, path_prefix) => {
  *
  * @param options.action_event_type - custom type name to use instead of `ActionEvent`
  *   (consumers can define a narrowed type that carries typed input/output via their codegen maps)
+ * @param options.collections_path - import path the side-effect `ActionOutputs` import
+ *   resolves to. Defaults to `'./action_collections.js'`.
  */
 export const generate_phase_handlers = (spec, executor, imports, options) => {
     const { method } = spec;
@@ -258,16 +287,15 @@ export const generate_phase_handlers = (spec, executor, imports, options) => {
         return `${method}?: never`;
     }
     const action_event_type = options?.action_event_type ?? 'ActionEvent';
+    const collections_path = options?.collections_path ?? DEFAULT_COLLECTIONS_PATH;
     // Only add the default ActionEvent import if using the default type name
     if (action_event_type === 'ActionEvent') {
         imports.add_type('@fuzdev/fuz_app/actions/action_event.js', 'ActionEvent');
     }
-    // Generate handler definitions for each phase
-    const path_prefix = executor === 'frontend' ? './' : '../';
     const phase_handlers = phases
         .map((phase) => {
         // Pass imports to get_handler_return_type so it can add necessary imports
-        const return_type = get_handler_return_type(spec, phase, imports, path_prefix);
+        const return_type = get_handler_return_type(spec, phase, imports, collections_path);
         return `${phase}?: (
 			action_event: ${action_event_type}<'${method}', '${phase}', 'handling'>
 		) => ${return_type}`;
@@ -328,3 +356,384 @@ export const generate_actions_api_method_signature = (spec, options) => {
             : result_return;
     return `${spec.method}: (${input_param}${options_param}) => ${return_type};`;
 };
+/** Default emit set — every enum kind. */
+export const ACTION_METHOD_ENUM_KINDS_ALL = new Set([
+    'all',
+    'request_response',
+    'remote_notification',
+    'local_call',
+    'frontend',
+    'backend',
+]);
+/**
+ * Filter `heartbeat` / `cancel` out of `specs` unless the consumer opts back in.
+ * Composables ship from fuz_app and are spread into every consumer's `actions`
+ * array at registration time — they should not appear in consumer-owned typed
+ * surfaces (`ActionMethod`, `ActionsApi`, `ActionInputs`, etc.) by default.
+ */
+const filter_composables = (specs, include_composables) => include_composables ? specs : specs.filter((s) => !is_composable_action_method(s.method));
+/**
+ * Emit one or more `z.enum([...])` declarations for action method names —
+ * `ActionMethod`, `RequestResponseActionMethod`, `RemoteNotificationActionMethod`,
+ * `LocalCallActionMethod`, `FrontendActionMethod`, `BackendActionMethod`. Pairs
+ * each runtime const with a `z.infer` type alias under the same identifier.
+ *
+ * Composable methods (`heartbeat`, `cancel`) are filtered out by default —
+ * pass `include_composables: true` if a consumer genuinely wants them on
+ * their typed surface. Empty kinds are skipped so the helper never emits
+ * `z.enum([])` (zod runtime-throws on that).
+ *
+ * Adds `import {z} from 'zod';` to `imports` only when at least one block
+ * is emitted (idempotent).
+ *
+ * @param options.emit - subset of enums to emit; defaults to all six.
+ * @param options.include_composables - when true, retains `heartbeat` /
+ *   `cancel` in the emitted enums. Default `false`.
+ */
+export const generate_action_method_enums = (specs, imports, options) => {
+    const emit = options?.emit ?? ACTION_METHOD_ENUM_KINDS_ALL;
+    const filtered = filter_composables(specs, options?.include_composables);
+    const registry = new ActionRegistry([...filtered]);
+    const blocks = [];
+    const emit_block = (kind, name, methods, jsdoc) => {
+        if (!emit.has(kind))
+            return;
+        // `z.enum([])` is invalid — skip empty kinds rather than emit broken code.
+        // Consumers that need a kind to exist should check their spec set, not the helper.
+        if (methods.length === 0)
+            return;
+        const lines = methods.map((m) => `\t'${m}',`).join('\n');
+        blocks.push(`/**\n * ${jsdoc}\n */\nexport const ${name} = z.enum([\n${lines}\n]);
+export type ${name} = z.infer<typeof ${name}>;`);
+    };
+    emit_block('all', 'ActionMethod', registry.methods, 'All action method names. Request/response actions have two types per method.');
+    emit_block('request_response', 'RequestResponseActionMethod', registry.request_response_methods, 'Names of all request_response actions.');
+    emit_block('remote_notification', 'RemoteNotificationActionMethod', registry.remote_notification_methods, 'Names of all remote_notification actions.');
+    emit_block('local_call', 'LocalCallActionMethod', registry.local_call_methods, 'Names of all local_call actions.');
+    emit_block('frontend', 'FrontendActionMethod', registry.frontend_methods, 'Names of all actions that may be handled on the client.');
+    emit_block('backend', 'BackendActionMethod', registry.backend_methods, 'Names of all actions that may be handled on the server.');
+    if (blocks.length === 0)
+        return '';
+    imports.add('zod', 'z');
+    return blocks.join('\n\n');
+};
+/**
+ * Emit the fixed-shape `TypedActionEvent` alias used by `FrontendActionHandlers`
+ * to narrow `ActionEvent.data` against the consumer's generated `ActionEventDatas`
+ * map. Registers the four fuz_app type imports it needs (`ActionEvent`,
+ * `ActionEventPhase`, `ActionEventStep`, `ActionEventDatas`) plus the
+ * `ActionMethod` type import — sourced from `collections_path` and
+ * `metatypes_path` respectively.
+ *
+ * Pair with `generate_action_method_enums` (emits `ActionMethod` into
+ * `metatypes_path`) and `generate_action_event_datas` (emits
+ * `ActionEventDatas` into `collections_path`).
+ */
+export const generate_typed_action_event_alias = (imports, options) => {
+    const collections_path = options?.collections_path ?? DEFAULT_COLLECTIONS_PATH;
+    const metatypes_path = options?.metatypes_path ?? DEFAULT_METATYPES_PATH;
+    imports.add_type('@fuzdev/fuz_app/actions/action_event.js', 'ActionEvent');
+    imports.add_type('@fuzdev/fuz_app/actions/action_spec.js', 'ActionEventPhase');
+    imports.add_type('@fuzdev/fuz_app/actions/action_event_types.js', 'ActionEventStep');
+    imports.add_type(collections_path, 'ActionEventDatas');
+    imports.add_type(metatypes_path, 'ActionMethod');
+    return `/** ActionEvent narrowed with the generated ActionEventDatas for typed input/output. */
+type TypedActionEvent<
+	TMethod extends ActionMethod,
+	TPhase extends ActionEventPhase,
+	TStep extends ActionEventStep,
+> = ActionEvent<TMethod, TPhase, TStep> & {readonly data: ActionEventDatas[TMethod]};`;
+};
+/**
+ * Emit the `ActionSpecs` runtime const + interface + the `action_specs:
+ * Array<ActionSpecUnion>` value bundling every spec. Adds the `* as specs`
+ * namespace import + the `ActionSpecUnion` type import.
+ *
+ * **Single-namespace.** Every spec is referenced as `specs.{method}_action_spec`.
+ * Multi-source consumers (tx, visiones) need a per-method namespace lookup
+ * and currently use lower-level primitives instead — see the `--- High-level
+ * codegen helpers ---` banner above for the rationale and the planned
+ * `qualify_spec?` extension point.
+ */
+export const generate_action_specs_record = (specs, imports, options) => {
+    const filtered = filter_composables(specs, options?.include_composables);
+    imports.add_type('@fuzdev/fuz_app/actions/action_spec.js', 'ActionSpecUnion');
+    if (filtered.length === 0) {
+        // Empty spec list — emit minimal valid output and skip the `* as specs`
+        // import that would have nothing to reference.
+        return `/**
+ * Action specifications indexed by method name.
+ * These represent the complete action spec definitions.
+ */
+export const ActionSpecs = {} as const;
+export interface ActionSpecs {}
+
+export const action_specs: Array<ActionSpecUnion> = Object.values(ActionSpecs);`;
+    }
+    const specs_module = options?.specs_module ?? DEFAULT_SPECS_MODULE;
+    imports.add(specs_module, '* as specs');
+    const value_lines = filtered
+        .map((s) => `\t${s.method}: specs.${s.method}_action_spec,`)
+        .join('\n');
+    const type_lines = filtered
+        .map((s) => `\t${s.method}: typeof specs.${s.method}_action_spec;`)
+        .join('\n');
+    return `/**
+ * Action specifications indexed by method name.
+ * These represent the complete action spec definitions.
+ */
+export const ActionSpecs = {
+${value_lines}
+} as const;
+export interface ActionSpecs {
+${type_lines}
+}
+
+export const action_specs: Array<ActionSpecUnion> = Object.values(ActionSpecs);`;
+};
+/**
+ * Emit `ActionInputs` + `ActionOutputs` runtime consts and matching interfaces.
+ * The runtime consts reference `specs.{method}_action_spec.input` /
+ * `.output`; the interfaces use `z.infer`.
+ *
+ * Adds `import {z} from 'zod';` and the `* as specs` namespace import.
+ *
+ * **Single-namespace.** Same caveat as `generate_action_specs_record` —
+ * multi-source consumers use the lower-level primitives.
+ */
+export const generate_action_inputs_outputs = (specs, imports, options) => {
+    const filtered = filter_composables(specs, options?.include_composables);
+    if (filtered.length === 0) {
+        // Empty spec list — emit minimal valid output and skip the `zod` /
+        // `* as specs` imports that would have nothing to reference.
+        return `/**
+ * Action parameter schemas indexed by method name.
+ * These represent the input data for each action,
+ * e.g. JSON-RPC request/notification params and local call arguments.
+ */
+export const ActionInputs = {} as const;
+export interface ActionInputs {}
+
+/**
+ * Action result schemas indexed by method name.
+ * These represent the output data for each action,
+ * e.g. JSON-RPC response results and local call return values.
+ */
+export const ActionOutputs = {} as const;
+export interface ActionOutputs {}`;
+    }
+    imports.add('zod', 'z');
+    const specs_module = options?.specs_module ?? DEFAULT_SPECS_MODULE;
+    imports.add(specs_module, '* as specs');
+    const inputs_value = filtered
+        .map((s) => `\t${s.method}: specs.${s.method}_action_spec.input,`)
+        .join('\n');
+    const inputs_type = filtered
+        .map((s) => `\t${s.method}: z.infer<typeof specs.${s.method}_action_spec.input>;`)
+        .join('\n');
+    const outputs_value = filtered
+        .map((s) => `\t${s.method}: specs.${s.method}_action_spec.output,`)
+        .join('\n');
+    const outputs_type = filtered
+        .map((s) => `\t${s.method}: z.infer<typeof specs.${s.method}_action_spec.output>;`)
+        .join('\n');
+    return `/**
+ * Action parameter schemas indexed by method name.
+ * These represent the input data for each action,
+ * e.g. JSON-RPC request/notification params and local call arguments.
+ */
+export const ActionInputs = {
+${inputs_value}
+} as const;
+export interface ActionInputs {
+${inputs_type}
+}
+
+/**
+ * Action result schemas indexed by method name.
+ * These represent the output data for each action,
+ * e.g. JSON-RPC response results and local call return values.
+ */
+export const ActionOutputs = {
+${outputs_value}
+} as const;
+export interface ActionOutputs {
+${outputs_type}
+}`;
+};
+/**
+ * Emit the `ActionEventDatas` interface — one `ActionEvent*Data` variant per
+ * method, parameterized by the spec's kind:
+ * - `request_response` → `ActionEventRequestResponseData<method, input, output>`
+ * - `remote_notification` → `ActionEventRemoteNotificationData<method, input>`
+ * - `local_call` → `ActionEventLocalCallData<method, input, output>`
+ *
+ * Adds the per-kind data type imports (only the kinds that appear in `specs`).
+ *
+ * @param options.collections_path - when set, adds `ActionInputs` /
+ *   `ActionOutputs` type imports from this path. Leave unset (default) when
+ *   the producer emits `ActionEventDatas` in the same file as
+ *   `ActionInputs` / `ActionOutputs` — same-file scope means no imports
+ *   needed (the zzz pattern, where `generate_action_inputs_outputs` and
+ *   this helper feed the same `action_collections.ts` output).
+ */
+export const generate_action_event_datas = (specs, imports, options) => {
+    const filtered = filter_composables(specs, options?.include_composables);
+    if (filtered.length === 0) {
+        // Empty spec list — emit `interface ActionEventDatas {}` and skip
+        // the optional collections-path import that would be unused.
+        return `/**
+ * Action event data types indexed by method name.
+ * These represent the full discriminated union of all possible states
+ * for each action's event data, properly typed with inputs and outputs.
+ */
+export interface ActionEventDatas {}`;
+    }
+    if (options?.collections_path) {
+        imports.add_types(options.collections_path, 'ActionInputs', 'ActionOutputs');
+    }
+    const lines = filtered.map((spec) => {
+        const data_type = spec.kind === 'request_response'
+            ? 'ActionEventRequestResponseData'
+            : spec.kind === 'remote_notification'
+                ? 'ActionEventRemoteNotificationData'
+                : 'ActionEventLocalCallData';
+        imports.add_type('@fuzdev/fuz_app/actions/action_event_data.js', data_type);
+        const type_args = spec.kind === 'remote_notification'
+            ? `<'${spec.method}', ActionInputs['${spec.method}']>`
+            : `<'${spec.method}', ActionInputs['${spec.method}'], ActionOutputs['${spec.method}']>`;
+        return `\t${spec.method}: ${data_type}${type_args};`;
+    });
+    return `/**
+ * Action event data types indexed by method name.
+ * These represent the full discriminated union of all possible states
+ * for each action's event data, properly typed with inputs and outputs.
+ */
+export interface ActionEventDatas {
+${lines.join('\n')}
+}`;
+};
+/**
+ * Emit the `ActionsApi` interface — one method signature per spec via
+ * `generate_actions_api_method_signature`. Optionally filter the spec set
+ * (e.g. omit composable methods) via `method_filter`.
+ *
+ * Adds the `Result`, `JsonrpcErrorObject`, and `RpcClientCallOptions` type
+ * imports plus `ActionInputs` / `ActionOutputs` (sourced from `collections_path`).
+ */
+export const generate_actions_api = (specs, imports, options) => {
+    const composable_filtered = filter_composables(specs, options?.include_composables);
+    const filter = options?.method_filter;
+    const filtered = filter ? composable_filtered.filter((s) => filter(s)) : composable_filtered;
+    const interface_doc = `/**
+ * Interface for action dispatch functions.
+ * Async methods (request_response, remote_notification, async local_call)
+ * return \`Promise<Result<...>>\` and accept an optional \`RpcClientCallOptions\`
+ * second arg that threads \`signal\`, \`transport_name\`, and \`queue\` through to
+ * the peer. Sync local_call methods return values directly.
+ */`;
+    if (filtered.length === 0) {
+        // Empty spec list — emit `ActionsApi {}` and skip every import. None
+        // of the symbols would be referenced by the empty body.
+        return `${interface_doc}
+export interface ActionsApi {}`;
+    }
+    const collections_path = options?.collections_path ?? DEFAULT_COLLECTIONS_PATH;
+    imports.add_type('@fuzdev/fuz_util/result.js', 'Result');
+    imports.add_type('@fuzdev/fuz_app/http/jsonrpc.js', 'JsonrpcErrorObject');
+    imports.add_type('@fuzdev/fuz_app/actions/rpc_client.js', 'RpcClientCallOptions');
+    imports.add_types(collections_path, 'ActionInputs', 'ActionOutputs');
+    const lines = filtered
+        .map((spec) => generate_actions_api_method_signature(spec, {
+        sync_returns_value: options?.sync_returns_value,
+    }))
+        .map((line) => `\t${line}`)
+        .join('\n');
+    return `${interface_doc}
+export interface ActionsApi {
+${lines}
+}`;
+};
+/**
+ * Emit the `FrontendActionHandlers` interface — wraps `generate_phase_handlers`
+ * with the `TypedActionEvent` action-event type and standard 1-tab per-method
+ * indentation. Pairs with `generate_typed_action_event_alias` (emits the
+ * matching `TypedActionEvent` alias) — call both in the same gen producer.
+ */
+export const generate_frontend_action_handlers = (specs, imports, options) => {
+    const filtered = filter_composables(specs, options?.include_composables);
+    const interface_doc = `/**
+ * Frontend action handlers organized by method and phase.
+ * Generated using spec.initiator to determine valid phases:
+ * - initiator: 'frontend' → send/execute phases
+ * - initiator: 'backend' → receive phases
+ * - initiator: 'both' → all valid phases
+ */`;
+    if (filtered.length === 0) {
+        // Empty spec list — emit `FrontendActionHandlers {}` and skip the
+        // dangling `;` that the body template would otherwise produce.
+        return `${interface_doc}
+export interface FrontendActionHandlers {}`;
+    }
+    const handler_options = {
+        action_event_type: 'TypedActionEvent',
+        collections_path: options?.collections_path,
+    };
+    const lines = filtered
+        .map((spec) => generate_phase_handlers(spec, 'frontend', imports, handler_options))
+        .filter(Boolean)
+        .map((block) => `\t${block}`)
+        .join(';\n');
+    return `${interface_doc}
+export interface FrontendActionHandlers {
+${lines};
+}`;
+};
+/**
+ * Emit BOTH the typed `BackendActionsApi` interface AND the
+ * `broadcast_action_specs` runtime array. The interface is shaped for
+ * `create_broadcast_api`: backend-initiated `remote_notification` methods,
+ * each `(input) => Promise<void>`. The array bundles the matching specs as a
+ * `ReadonlyArray<ActionSpecUnion>`.
+ *
+ * Filter: `kind === 'remote_notification' && initiator !== 'frontend'`.
+ *
+ * Adds the `* as specs` namespace import (from `specs_module`), the
+ * `ActionInputs` type import (from `collections_path`), and the
+ * `ActionSpecUnion` type import.
+ *
+ * **Single-namespace.** Same caveat as `generate_action_specs_record` —
+ * multi-source consumers use the lower-level primitives.
+ */
+export const generate_backend_actions_api = (specs, imports, options) => {
+    const composable_filtered = filter_composables(specs, options?.include_composables);
+    const broadcast = composable_filtered.filter((s) => s.kind === 'remote_notification' && s.initiator !== 'frontend');
+    imports.add_type('@fuzdev/fuz_app/actions/action_spec.js', 'ActionSpecUnion');
+    const interface_doc = `/**
+ * Broadcast-style notifications from the backend to all connected clients.
+ * Request-scoped streaming goes through \`ctx.notify\` instead — it's
+ * socket-scoped, not a broadcast.
+ */`;
+    if (broadcast.length === 0) {
+        // No backend-initiated remote_notifications — skip `* as specs` and
+        // `ActionInputs` imports that would have nothing to reference.
+        return `${interface_doc}
+export interface BackendActionsApi {}
+
+export const broadcast_action_specs: ReadonlyArray<ActionSpecUnion> = [];`;
+    }
+    const specs_module = options?.specs_module ?? DEFAULT_SPECS_MODULE;
+    const collections_path = options?.collections_path ?? DEFAULT_COLLECTIONS_PATH;
+    imports.add(specs_module, '* as specs');
+    imports.add_type(collections_path, 'ActionInputs');
+    const interface_body = '\n' +
+        broadcast
+            .map((s) => `\t${s.method}: (input: ActionInputs['${s.method}']) => Promise<void>;`)
+            .join('\n') +
+        '\n';
+    const array_body = '\n' + broadcast.map((s) => `\tspecs.${s.method}_action_spec,`).join('\n') + '\n';
+    return `${interface_doc}
+export interface BackendActionsApi {${interface_body}}
+
+export const broadcast_action_specs: ReadonlyArray<ActionSpecUnion> = [${array_body}];`;
+};

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

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

package/dist/actions/action_event_helpers.js

@@ -29,14 +29,12 @@ export const is_send_request_with_parsed_input = (data) => is_send_request(data)
 export const is_notification_send_with_parsed_input = (data) => is_notification_send(data) && (data.step === 'parsed' || data.step === 'handling');
 // Validation helpers
 export const validate_step_transition = (from, to) => {
-    const valid_transitions = ACTION_EVENT_STEP_TRANSITIONS[from];
-    if (!valid_transitions.includes(to)) {
+    if (!ACTION_EVENT_STEP_TRANSITIONS[from].includes(to)) {
         throw new Error(`Invalid step transition from '${from}' to '${to}'`);
     }
 };
 export const validate_phase_for_kind = (kind, phase) => {
-    const valid_phases = ACTION_EVENT_PHASE_BY_KIND[kind];
-    if (!valid_phases.includes(phase)) {
+    if (!ACTION_EVENT_PHASE_BY_KIND[kind].includes(phase)) {
         throw new Error(`Invalid phase '${phase}' for ${kind} action`);
     }
 };
@@ -85,12 +83,22 @@ export const create_initial_data = (kind, phase, method, executor, input) => ({
 });
 export const extract_action_result = (event) => {
     const { data } = event;
+    // `data.error` populated → error path. This covers two cases:
+    // 1. `step === 'failed'` — explicit terminal failure.
+    // 2. `phase === 'receive_error' | 'send_error'` reached `step === 'handled'`
+    //    because no handler was registered for the error phase. The dispatcher
+    //    silently transitions to `handled` in that case but leaves `data.error`
+    //    populated. Reading `step === 'handled'` first would return
+    //    `{ok: true, value: null}` and surprise every caller that doesn't
+    //    register an error-phase handler. Preferring `data.error` lets
+    //    consumers skip the boilerplate `receive_error` rethrow stub.
+    if (data.error) {
+        return { ok: false, error: data.error };
+    }
     if (data.step === 'handled') {
         return { ok: true, value: data.output };
     }
-    if (data.step === 'failed') {
-        return { ok: false, error: data.error };
-    }
-    // Programming error - event not in terminal state
+    // `step === 'failed'` with `data.error === null` is a malformed event;
+    // type narrowing accepts it, runtime never produces it.
     throw new Error(`cannot extract result: event in non-terminal state (step: ${data.step})`);
 };

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

@@ -1 +1 @@
-{"version":3,"file":"action_event_types.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/action_event_types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AACtB,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAEpD,OAAO,KAAK,EAAC,gBAAgB,EAAE,UAAU,EAAE,eAAe,EAAC,MAAM,kBAAkB,CAAC;AAEpF,eAAO,MAAM,cAAc;;;EAAkC,CAAC;AAC9D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,eAAO,MAAM,eAAe;;;;;;EAAiE,CAAC;AAC9F,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,eAAO,MAAM,6BAA6B,EAMrC,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC,CAAC;AAE7D,eAAO,MAAM,0BAA0B,EAWlC,MAAM,CAAC,UAAU,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAC;AAEzD,eAAO,MAAM,8BAA8B,EAUtC,MAAM,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,IAAI,CAAC,CAAC;AAEvD,MAAM,WAAW,sBAAsB;IACtC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,qBAAqB,EAAE,CACtB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,gBAAgB,KACnB,CAAC,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC,GAAG,SAAS,CAAC;IACvC,kBAAkB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,eAAe,GAAG,SAAS,CAAC;IACpE,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B"}
+{"version":3,"file":"action_event_types.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/action_event_types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AACtB,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAEpD,OAAO,KAAK,EAAC,gBAAgB,EAAE,UAAU,EAAE,eAAe,EAAC,MAAM,kBAAkB,CAAC;AAEpF,eAAO,MAAM,cAAc;;;EAAkC,CAAC;AAC9D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,eAAO,MAAM,eAAe;;;;;;EAAiE,CAAC;AAC9F,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAS9D,eAAO,MAAM,6BAA6B,EAAE,MAAM,CACjD,eAAe,EACf,aAAa,CAAC,eAAe,CAAC,CAO9B,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,MAAM,CAAC,UAAU,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAW1F,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,MAAM,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,IAAI,CAU5F,CAAC;AAEF,MAAM,WAAW,sBAAsB;IACtC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,qBAAqB,EAAE,CACtB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,gBAAgB,KACnB,CAAC,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC,GAAG,SAAS,CAAC;IACvC,kBAAkB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,eAAe,GAAG,SAAS,CAAC;IACpE,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B"}

package/dist/actions/action_event_types.js

@@ -6,6 +6,12 @@
 import { z } from 'zod';
 export const ActionExecutor = z.enum(['frontend', 'backend']);
 export const ActionEventStep = z.enum(['initial', 'parsed', 'handling', 'handled', 'failed']);
+// The constants below use `Record<K, V> = {...}` rather than
+// `as const satisfies Record<K, V>`. The typed annotation gives full
+// completeness checking (TS rejects missing keys, excess keys, and wrong
+// value types on the object literal) without narrowing lookups to literal
+// tuple types — a `satisfies` shape forces every `X[k]` reader to widen
+// back to `ReadonlyArray<V>` themselves to call `.includes(...)`.
 export const ACTION_EVENT_STEP_TRANSITIONS = {
     initial: ['parsed', 'failed'],
     parsed: ['handling', 'failed'],

package/dist/actions/frontend_rpc_client.d.ts

@@ -3,9 +3,10 @@
  *
  * 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).
+ * consumer repeats. `lookup_action_handler` defaults to `() => undefined`
+ * (HTTP-only frontends rarely need handlers); pass `options.lookup_action_handler`
+ * to wire WS-pushed `remote_notification` dispatch or a `receive_error` /
+ * `local_call` hook.
  *
  * Returns both Proxy shapes from one factory call:
  *
@@ -38,10 +39,9 @@
  * 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`).
+ * `local_call` specs in `specs` no-op unless `lookup_action_handler`
+ * resolves a handler for the `'execute'` phase. Frontend-side `local_call`
+ * is uncommon; the factory targets wire-dispatched actions by default.
  *
  * @module
  */
@@ -94,6 +94,24 @@ export interface CreateFrontendRpcClientOptions<TApi extends object = object> {
      * site when `TApi` is a generated `ActionsApi` interface.
      */
     on_action_event?: (event: ActionEvent<keyof TApi & string>) => void;
+    /**
+     * Optional handler resolver. Wired onto `environment.lookup_action_handler`
+     * — the registry the dispatcher uses to find handlers for inbound
+     * messages and lifecycle phases. Defaults to `() => undefined`, which
+     * is fine for HTTP-only frontends that never receive a server-pushed
+     * notification or register a `receive_error` recovery hook.
+     *
+     * Common reasons to provide this:
+     * - **Server-pushed notifications over WS** — return a handler for
+     *   `(method, 'receive')` so a `remote_notification` arriving on the
+     *   socket dispatches to your subscriber bus (tx-style).
+     * - **Per-method retry / telemetry on errors** — return a handler for
+     *   `(method, 'receive_error')`. Note that as of the
+     *   `extract_action_result` fix, a missing handler already produces
+     *   `{ok: false, error}` — the stub is no longer required just to
+     *   surface server errors.
+     */
+    lookup_action_handler?: ActionEventEnvironment['lookup_action_handler'];
 }
 /** Bundle returned by `create_frontend_rpc_client`. */
 export interface FrontendRpcClient<TApi> {

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

@@ -1 +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"}
+{"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;IACpE;;;;;;;;;;;;;;;;OAgBG;IACH,qBAAqB,CAAC,EAAE,sBAAsB,CAAC,uBAAuB,CAAC,CAAC;CACxE;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

@@ -3,9 +3,10 @@
  *
  * 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).
+ * consumer repeats. `lookup_action_handler` defaults to `() => undefined`
+ * (HTTP-only frontends rarely need handlers); pass `options.lookup_action_handler`
+ * to wire WS-pushed `remote_notification` dispatch or a `receive_error` /
+ * `local_call` hook.
  *
  * Returns both Proxy shapes from one factory call:
  *
@@ -38,10 +39,9 @@
  * 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`).
+ * `local_call` specs in `specs` no-op unless `lookup_action_handler`
+ * resolves a handler for the `'execute'` phase. Frontend-side `local_call`
+ * is uncommon; the factory targets wire-dispatched actions by default.
  *
  * @module
  */
@@ -64,7 +64,7 @@ export const create_frontend_rpc_client = (options) => {
     const environment = {
         executor: 'frontend',
         lookup_action_spec: (method) => registry.spec_by_method.get(method),
-        lookup_action_handler: () => undefined,
+        lookup_action_handler: options.lookup_action_handler ?? (() => undefined),
     };
     const transports = new Transports();
     if (options.transports) {

package/dist/actions/rpc_client.d.ts

@@ -89,15 +89,23 @@ export interface RpcClientCallOptions extends ActionPeerSendOptions {
  * as `=> void`, sync `local_call` methods) pass through unchanged — there
  * is nothing to unwrap.
  *
- * Input + options parameters are preserved verbatim so generics, branded
- * Uuids, and per-call `RpcClientCallOptions` keep working.
+ * Input + options parameters are preserved verbatim via `...args: infer TArgs`
+ * so the conditional matches both required-input (`input: T`) and
+ * optional-input (`input?: T` / nullary) signatures uniformly. Required-input
+ * shapes (e.g. `admin_session_revoke_all(input: AdminSessionRevokeAllInput)`)
+ * are not assignable to a `(input?: TInput) => …` pattern under
+ * `--strictFunctionTypes`, so an earlier `(input?, options?) =>` form
+ * silently fell through to `TApi[K]` and left those methods Result-shaped —
+ * `create_admin_rpc_adapters(api)` would then reject the typed throwing
+ * Proxy because half its surface still returned `Result<...>`. The rest-args
+ * form preserves both required and optional parameters and resolves the gap.
  */
 export type ThrowingApi<TApi> = {
-    [K in keyof TApi]: TApi[K] extends (input?: infer TInput, options?: infer TOptions) => Promise<Result<{
+    [K in keyof TApi]: TApi[K] extends (...args: infer TArgs) => Promise<Result<{
         value: infer TValue;
     }, {
         error: JsonrpcErrorObject;
-    }>> ? (input?: TInput, options?: TOptions) => Promise<TValue> : TApi[K];
+    }>> ? (...args: TArgs) => Promise<TValue> : TApi[K];
 };
 /**
  * Wrap a typed RPC client so every call resolves to its unwrapped value or

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;;;;;;;;;;;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"}
+{"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;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,WAAW,CAAC,IAAI,IAAI;KAC9B,CAAC,IAAI,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,SAAS,CAClC,GAAG,IAAI,EAAE,MAAM,KAAK,KAChB,OAAO,CAAC,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,MAAM,CAAA;KAAC,EAAE;QAAC,KAAK,EAAE,kBAAkB,CAAA;KAAC,CAAC,CAAC,GACrE,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC,MAAM,CAAC,GACnC,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"}

package/dist/ui/admin_rpc_adapters.d.ts

@@ -55,8 +55,8 @@ export interface AdminRpcApi {
     admin_session_list: () => Promise<AdminSessionListOutput>;
     admin_session_revoke_all: (input: AdminSessionRevokeAllInput) => Promise<AdminSessionRevokeAllOutput>;
     admin_token_revoke_all: (input: AdminTokenRevokeAllInput) => Promise<AdminTokenRevokeAllOutput>;
-    audit_log_list: (input?: AuditLogListInput) => Promise<AuditLogListOutput>;
-    audit_log_permit_history: (input?: AuditLogPermitHistoryInput) => Promise<AuditLogPermitHistoryOutput>;
+    audit_log_list: (input: AuditLogListInput) => Promise<AuditLogListOutput>;
+    audit_log_permit_history: (input: AuditLogPermitHistoryInput) => Promise<AuditLogPermitHistoryOutput>;
     invite_list: () => Promise<InviteListOutput>;
     invite_create: (input: InviteCreateInput) => Promise<InviteCreateOutput>;
     invite_delete: (input: InviteDeleteInput) => Promise<InviteDeleteOutput>;

package/dist/ui/admin_rpc_adapters.d.ts.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzdev/fuz_app",
-  "version": "0.45.0",
+  "version": "0.47.0",
   "description": "fullstack app library",
   "glyph": "🗝",
   "logo": "logo.svg",