@fuzdev/fuz_app 0.47.0 → 0.49.0

package/dist/actions/CLAUDE.md

@@ -68,11 +68,45 @@ throws on any non-`remote_notification` kind.
 
 ## Registry + codegen (`action_registry.ts`, `action_codegen.ts`)
 
+**Symmetric design — universal calling abstraction.** SAES is one spec
+shape that drives dispatch across (a) network boundaries (frontend ⇄
+backend over HTTP / WS) and (b) within the same runtime (`local_call`
+actions). `ActionPeer` is symmetric on both sides (`send` + `receive`).
+The two typed surfaces are paired: `FrontendActionsApi` is "what the
+frontend can call" (typed Proxy from `create_rpc_client`);
+`BackendActionsApi` is "what the backend can call" (typed object from
+`create_broadcast_api` today; broader runtime constructors will join).
+The remaining asymmetry today is runtime: there is no
+`create_backend_rpc_client` and `create_broadcast_api` returns
+`Promise<void>` (fire-and-forget broadcast) rather than the
+`Promise<Result<{value}, {error}>>` shape `FrontendActionsApi` methods
+return. Closing those gaps is captured in the SAES quest's API
+review III deferred set — wait for a second backend runtime case.
+
 `ActionRegistry(specs)` is a query/filter wrapper over `ActionSpecUnion[]`.
-Used getters today are `spec_by_method`, `request_response_specs`,
-`remote_notification_specs`, `local_call_specs`, `frontend_methods`,
-`backend_methods`, `methods`. The rest are pre-built stubs — revisit when
-the system matures.
+Codegen-used getter groups:
+
+- Identity: `spec_by_method`, `methods`.
+- Kind-narrow specs + matching `_methods`: `request_response_specs`,
+  `remote_notification_specs`, `local_call_specs`.
+- Narrow handler-side (request_response only, `initiator` excludes own
+  side, drives the typed `BackendActionHandlers` map):
+  `frontend_handled_specs`, `frontend_handled_methods`,
+  `backend_handled_specs`, `backend_handled_methods`.
+- Loose "relevant to this side" (everything the side might encounter,
+  drives the typed-Proxy method enums `FrontendActionMethod` and
+  `BackendActionMethod`): `specs_relevant_to_frontend`,
+  `methods_relevant_to_frontend`, `specs_relevant_to_backend`,
+  `methods_relevant_to_backend`.
+- Broadcast (kind-narrow `remote_notification`, `initiator !== 'frontend'`,
+  excludes `streams` targets): `broadcast_specs`, `broadcast_methods`.
+- Backend-initiated (forward-looking kind-agnostic version of broadcast;
+  same content today, will widen when local_calls or backend
+  `request_response` join): `backend_initiated_specs`,
+  `backend_initiated_methods`.
+
+Other getters (auth, initiator-direction) are pre-built stubs flagged
+`@action-system-review`.
 
 `action_codegen.ts` provides gen helpers (used by consumer `*.gen.ts` files,
 not the runtime):
@@ -83,7 +117,7 @@ not the runtime):
 - `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, 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.
+- `generate_actions_api_method_signature(spec, {sync_returns_value?})` — single source of truth for the typed `FrontendActionsApi` 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`).
 - `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.
@@ -92,51 +126,62 @@ not the runtime):
 - `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)
+### High-level helpers
 
 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()`.
+surrounding `imports.build()`. Use `compose_gen_file` to assemble the block
+list + banner + imports into the final file body in one call.
 
 **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
+`FrontendActionsApi`, `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.
+**Consumer tiers and namespace handling.** Single-source consumers (zzz,
+undying — every spec lives in one local `action_specs.ts`) drop straight
+into the helpers and accept the default `* as specs from specs_module`
+namespace import. 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) call
+`create_namespace_qualifier(sources, imports)` once, then pass the
+returned `qualify_spec` callback to the multi-source helpers
+(`generate_action_specs_record`, `generate_action_inputs_outputs`,
+`generate_backend_actions_api`). When `qualify_spec` is set, the helper
+emits the callback's return value (e.g.
+`admin_specs.account_list_action_spec`) and skips the default `* as specs`
+import — the consumer (or the namespace-qualifier helper) owns the
+multi-namespace imports. The helper appends `.input` / `.output` to the
+qualified identifier in `generate_action_inputs_outputs` automatically;
+the callback returns the bare spec identifier.
 
 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
+`ActionMethod` + `FrontendActionsApi` + `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`.
+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_action_method_enums(specs, imports, {emit?, include_composables?})` — up to nine `z.enum` + `z.infer` pairs (`ActionMethod`, `RequestResponseActionMethod`, `RemoteNotificationActionMethod`, `LocalCallActionMethod`, `FrontendActionMethod`, `BackendActionMethod`, `FrontendRequestResponseMethod`, `BackendRequestResponseMethod`, `BroadcastActionMethod`). `emit: ReadonlySet<ActionMethodEnumKind>` restricts to a subset (Tier 1 HTTP-only consumers don't need all nine). 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. The `frontend_handled` / `backend_handled` / `broadcast` kinds use the registry's narrow handler-side / streams-aware getters; the loose `frontend` / `backend` kinds preserve the everything-relevant-to-this-side semantic for the typed-Proxy method enum.
+- `generate_action_method_enum_block(specs, imports, {name, jsdoc, predicate, include_composables?})` — lower-level escape hatch for genuinely cross-product enums the discriminator doesn't cover. Caller owns the predicate, name, and jsdoc.
 - `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`.
+- `generate_action_specs_record(specs, imports, {specs_module?, qualify_spec?, include_composables?})` — `ActionSpecs` runtime const + interface + `action_specs: Array<ActionSpecUnion>` value. Adds `* as specs` from `specs_module` unless `qualify_spec` is set (then `specs_module` is ignored and the consumer owns namespace imports).
+- `generate_action_inputs_outputs(specs, imports, {specs_module?, qualify_spec?, include_composables?})` — `ActionInputs` and `ActionOutputs` runtime consts + interfaces. Same `qualify_spec` semantics as `generate_action_specs_record`; the helper appends `.input` / `.output` to the qualified identifier.
+- `generate_action_event_datas(specs, imports, {same_file?, collections_path?, include_composables?})` — `ActionEventDatas` interface; per-spec variant by kind (`ActionEventRequestResponseData` / `ActionEventRemoteNotificationData` / `ActionEventLocalCallData`). `same_file` (default `true`) is the file-layout switch: when `true`, assumes `ActionInputs` / `ActionOutputs` are in the same module and adds no import (the zzz pattern); when `false`, adds the type imports from `collections_path` (default `'./action_collections.js'`). `collections_path` alone is a no-op — the surprising omit-vs-default behavior of earlier versions has been replaced.
+- `generate_frontend_actions_api(specs, imports, {interface_name?, method_filter?, collections_path?, sync_returns_value?, include_composables?})` — emits the typed `FrontendActionsApi` interface (configurable via `interface_name`, default `'FrontendActionsApi'`). One method signature per spec via `generate_actions_api_method_signature`. Composables filtered by default; `method_filter: (spec) => boolean` runs after the composable filter. Renamed from `generate_actions_api` in API review III to make the side-of-the-wire intent visible at every consumer site.
+- `generate_frontend_action_handlers(specs, imports, {collections_path?, include_composables?})` — `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, {interface_name?, spec_array_name?, specs_module?, collections_path?, qualify_spec?, include_composables?})` — `BackendActionsApi` interface AND `broadcast_action_specs: ReadonlyArray<ActionSpecUnion>` array (both names configurable). Filter: `kind === 'remote_notification' && initiator !== 'frontend'`, with `streams`-target methods (request-scoped progress notifications invoked via `ctx.notify`) excluded — the discriminator is `ActionSpec.streams`, not a manual list. Adds `ActionInputs` (from `collections_path`) + `ActionSpecUnion`, plus `* as specs` from `specs_module` unless `qualify_spec` is set. Method shape today is `(input) => Promise<void>` (matches `create_broadcast_api`'s fire-and-forget runtime); generalizing to per-kind shapes via `generate_actions_api_method_signature` is deferred until a second backend runtime constructor lands (see SAES quest § API review III deferred set).
+- `generate_backend_action_handlers_map(imports, options?)` — emits the `BackendActionHandlers` mapped type (`{[K in BackendRequestResponseMethod]: (input: ActionInputs[K], ctx: BackendHandlerContext) => ActionOutputs[K] | Promise<ActionOutputs[K]>}`). Replaces the hand-maintained `Exclude<>` + parallel mapped-type pattern (zzz had this at `zzz/src/lib/server/zzz_action_handlers.ts:42-66`). Configurable type name, method enum name, and context type name; configurable `collections_path` / `metatypes_path` for the type imports.
+
+### Wrapper + multi-source helper
+
+- `compose_gen_file({origin_path, imports, blocks})` — encapsulates the per-`*.gen.ts` boilerplate (banner + `imports.build()` + blocks join + template literal). Returns the full file body. Each consumer producer collapses to one `compose_gen_file` call wrapping the helper invocations.
+- `create_namespace_qualifier(sources, imports)` — multi-source consumer helper. Takes `ReadonlyArray<{ns, module, specs}>`, registers `import * as ns from module` for each on `imports`, builds the `method_to_ns` lookup with duplicate-method detection, returns `{qualify_spec, all_specs}` ready to thread through the high-level helpers. Closes the per-file boilerplate gap that kept tx + visiones on hand-rolled template strings even after the `qualify_spec?` callback landed (the per-call callback wasn't enough — the import dance + dup-check was the real boilerplate).
 
 ## HTTP bridge (`action_bridge.ts`)
 
@@ -640,12 +685,12 @@ 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.
+a generated `FrontendActionsApi` 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.
+Cast the return to a generated `FrontendActionsApi` 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`
 
@@ -656,10 +701,10 @@ 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            |
+| 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 `FrontendActionsApi` | 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
@@ -673,12 +718,12 @@ 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:
+consumers of `create_rpc_client` pass their typed `FrontendActionsApi`
+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_result = create_rpc_client<FrontendActionsApi>({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) { … }
@@ -722,7 +767,7 @@ Returns both Proxy shapes from one factory call:
 - `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>({
+const {api, api_result} = create_frontend_rpc_client<FrontendActionsApi>({
 	specs: all_standard_action_specs,
 });
 // hot path:    await api.account_verify()

package/dist/actions/action_codegen.d.ts

@@ -9,12 +9,12 @@ 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`
+ * Type predicate for filtering composable methods out of a typed `FrontendActionsApi`
  * `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, {
+ * generate_frontend_actions_api(specs, imports, {
  *   method_filter: (s) => !is_composable_action_method(s.method),
  * });
  */
@@ -132,10 +132,10 @@ export declare const to_action_spec_identifier: (method: string) => string;
 export declare const to_action_spec_input_identifier: (method: string) => string;
 export declare const to_action_spec_output_identifier: (method: string) => string;
 /**
- * Generates one method line of the typed `ActionsApi` interface for a single
- * spec. Encapsulates the input/options/return-type signature shape so the
- * surface evolves in one place when fields like `signal` or `transport_name`
- * are added to per-call options.
+ * Generates one method line of the typed `FrontendActionsApi` interface for a
+ * single spec. Encapsulates the input/options/return-type signature shape so
+ * the surface evolves in one place when fields like `signal` or
+ * `transport_name` are added to per-call options.
  *
  * Async methods (`request_response`, `remote_notification`, async
  * `local_call`) get an optional second `options?: RpcClientCallOptions` arg
@@ -156,21 +156,23 @@ export declare const to_action_spec_output_identifier: (method: string) => strin
  * @param options.sync_returns_value - when true (default), sync local_call
  *   methods return the output value directly; when false they're wrapped in
  *   `Result<{value, error}>` like async methods. Set to `false` if your
- *   ActionsApi treats every method uniformly.
+ *   FrontendActionsApi treats every method uniformly.
  * @returns one line like `foo: (input: ActionInputs['foo'], options?: RpcClientCallOptions) => Promise<Result<...>>;`
  */
 export declare const generate_actions_api_method_signature: (spec: ActionSpecUnion, options?: {
     sync_returns_value?: boolean;
 }) => string;
 /** Discriminator for `generate_action_method_enums` — which method-set enums to emit. */
-export type ActionMethodEnumKind = 'all' | 'request_response' | 'remote_notification' | 'local_call' | 'frontend' | 'backend';
+export type ActionMethodEnumKind = 'all' | 'request_response' | 'remote_notification' | 'local_call' | 'frontend' | 'backend' | 'frontend_handled' | 'backend_handled' | 'broadcast';
 /** 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.
+ * `LocalCallActionMethod`, `FrontendActionMethod`, `BackendActionMethod`,
+ * `FrontendRequestResponseMethod`, `BackendRequestResponseMethod`,
+ * `BroadcastActionMethod`. 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
@@ -180,7 +182,11 @@ export declare const ACTION_METHOD_ENUM_KINDS_ALL: ReadonlySet<ActionMethodEnumK
  * 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.
+ * For genuinely cross-product enums the discriminator doesn't cover, use
+ * `generate_action_method_enum_block` — caller owns the predicate, name,
+ * and jsdoc.
+ *
+ * @param options.emit - subset of enums to emit; defaults to all nine.
  * @param options.include_composables - when true, retains `heartbeat` /
  *   `cancel` in the emitted enums. Default `false`.
  */
@@ -188,6 +194,26 @@ export declare const generate_action_method_enums: (specs: ReadonlyArray<ActionS
     emit?: ReadonlySet<ActionMethodEnumKind>;
     include_composables?: boolean;
 }) => string;
+/**
+ * Emit a single named `z.enum([...])` + `z.infer` block for an arbitrary
+ * spec subset. Lower-level escape hatch from `generate_action_method_enums` —
+ * for cross-product or domain-specific enums the built-in discriminator
+ * doesn't cover.
+ *
+ * Mirrors the built-in helper's contract: composables filtered by default,
+ * empty subsets return `''` (skip rather than emit `z.enum([])`), `zod`
+ * import registered idempotently only when at least one method qualifies.
+ *
+ * The cross-product space is open-ended; rather than grow the
+ * `ActionMethodEnumKind` discriminator one cross-product at a time, callers
+ * own the subset shape — name, jsdoc, predicate.
+ */
+export declare const generate_action_method_enum_block: (specs: ReadonlyArray<ActionSpecUnion>, imports: ImportBuilder, options: {
+    name: string;
+    jsdoc: string;
+    predicate: (spec: ActionSpecUnion) => boolean;
+    include_composables?: boolean;
+}) => string;
 /**
  * Emit the fixed-shape `TypedActionEvent` alias used by `FrontendActionHandlers`
  * to narrow `ActionEvent.data` against the consumer's generated `ActionEventDatas`
@@ -209,14 +235,16 @@ export declare const generate_typed_action_event_alias: (imports: ImportBuilder,
  * 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.
+ * @param options.qualify_spec - per-spec qualified identifier callback for
+ *   multi-source consumers (e.g. ``(s) => `admin_specs.${s.method}_action_spec` ``).
+ *   When set, the helper emits the callback's return value instead of
+ *   ``specs.${method}_action_spec`` and skips the default `* as specs`
+ *   import — the consumer manages its own namespace imports. `specs_module`
+ *   is ignored when `qualify_spec` is set. Single-source consumers omit it.
  */
 export declare const generate_action_specs_record: (specs: ReadonlyArray<ActionSpecUnion>, imports: ImportBuilder, options?: {
     specs_module?: string;
+    qualify_spec?: (spec: ActionSpecUnion) => string;
     include_composables?: boolean;
 }) => string;
 /**
@@ -226,11 +254,15 @@ export declare const generate_action_specs_record: (specs: ReadonlyArray<ActionS
  *
  * 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.
+ * @param options.qualify_spec - per-spec qualified identifier callback for
+ *   multi-source consumers. The helper appends `.input` / `.output` to the
+ *   callback's return value. When set, the helper skips the default
+ *   `* as specs` import — the consumer manages its own namespace imports —
+ *   and `specs_module` is ignored. Single-source consumers omit it.
  */
 export declare const generate_action_inputs_outputs: (specs: ReadonlyArray<ActionSpecUnion>, imports: ImportBuilder, options?: {
     specs_module?: string;
+    qualify_spec?: (spec: ActionSpecUnion) => string;
     include_composables?: boolean;
 }) => string;
 /**
@@ -242,26 +274,37 @@ export declare const generate_action_inputs_outputs: (specs: ReadonlyArray<Actio
  *
  * 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).
+ * @param options.same_file - when `true` (default), assumes `ActionInputs` /
+ *   `ActionOutputs` are in the same module as the emitted `ActionEventDatas`
+ *   and adds no import (the zzz pattern, where `generate_action_inputs_outputs`
+ *   and this helper feed the same `action_collections.ts` output). When
+ *   `false`, adds `ActionInputs` / `ActionOutputs` type imports from
+ *   `collections_path`.
+ * @param options.collections_path - import path used when `same_file: false`.
+ *   Defaults to `'./action_collections.js'`. Ignored when `same_file: true`
+ *   — `same_file` is the file-layout switch; `collections_path` is just the
+ *   path the import resolves to.
  */
 export declare const generate_action_event_datas: (specs: ReadonlyArray<ActionSpecUnion>, imports: ImportBuilder, options?: {
+    same_file?: boolean;
     collections_path?: string;
     include_composables?: boolean;
 }) => string;
 /**
- * Emit the `ActionsApi` interface — one method signature per spec via
+ * Emit the `FrontendActionsApi` 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`).
+ *
+ * The interface name is fixed at `FrontendActionsApi` — the symmetric counterpart
+ * of `BackendActionsApi`. Earlier consumer-named variants (`MyActionsApi`,
+ * `VisionesActionsApi`) were retired in API review III to make the side-of-the-wire
+ * intent visible at every call site. If a consumer needs a different name they
+ * hand-roll the interface (the helper's job is the standard symmetric shape).
  */
-export declare const generate_actions_api: (specs: ReadonlyArray<ActionSpecUnion>, imports: ImportBuilder, options?: {
+export declare const generate_frontend_actions_api: (specs: ReadonlyArray<ActionSpecUnion>, imports: ImportBuilder, options?: {
     method_filter?: (spec: ActionSpecUnion) => boolean;
     collections_path?: string;
     sync_returns_value?: boolean;
@@ -284,19 +327,146 @@ export declare const generate_frontend_action_handlers: (specs: ReadonlyArray<Ac
  * each `(input) => Promise<void>`. The array bundles the matching specs as a
  * `ReadonlyArray<ActionSpecUnion>`.
  *
- * Filter: `kind === 'remote_notification' && initiator !== 'frontend'`.
+ * Filter: `kind === 'remote_notification' && initiator !== 'frontend'`,
+ * additionally excluding methods that are the target of another spec's
+ * `streams` field. Streams targets (e.g. `completion_progress`,
+ * `ollama_progress`) are request-scoped notifications invoked via
+ * `ctx.notify` inside their parent handler — they're never callable through
+ * the broadcast API. The discriminator is `ActionSpec.streams`, not a manual
+ * exclusion list.
  *
  * 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.
+ * Method signature shape today is `(input) => Promise<void>` — matches the
+ * fire-and-forget runtime of `create_broadcast_api`. Generalizing per-kind
+ * via `generate_actions_api_method_signature` is deferred until a second
+ * backend runtime constructor lands (see SAES quest § API review III).
+ *
+ * @param options.qualify_spec - per-spec qualified identifier callback for
+ *   multi-source consumers. When set, the helper emits the callback's return
+ *   value instead of ``specs.${method}_action_spec`` in the broadcast array
+ *   and skips the default `* as specs` import — the consumer manages its own
+ *   namespace imports. `specs_module` is ignored when `qualify_spec` is set.
+ *   Single-source consumers omit it.
  */
 export declare const generate_backend_actions_api: (specs: ReadonlyArray<ActionSpecUnion>, imports: ImportBuilder, options?: {
     specs_module?: string;
     collections_path?: string;
+    qualify_spec?: (spec: ActionSpecUnion) => string;
     include_composables?: boolean;
 }) => string;
+/**
+ * Emit the `BackendActionHandlers` mapped type — one entry per
+ * `BackendRequestResponseMethod`, each `(input, ctx) => output | Promise<output>`.
+ * Replaces the hand-maintained `Exclude<>` + parallel mapped-type pattern
+ * (zzz had this at `zzz/src/lib/server/zzz_action_handlers.ts:42-66`).
+ *
+ * The context type is consumer-defined (e.g. zzz's `ZzzHandlerContext`). Pass
+ * `context_type` to name it; the helper assumes it's importable or defined
+ * in the emitted module's scope (consumer's responsibility).
+ *
+ * Adds `ActionInputs` / `ActionOutputs` type imports from `collections_path`
+ * and the `BackendRequestResponseMethod` import from `metatypes_path`.
+ *
+ * @param options.type_name - default `'BackendActionHandlers'`.
+ * @param options.method_enum_name - default `'BackendRequestResponseMethod'`.
+ *   Pair with `generate_action_method_enums` emitting the `'backend_handled'` kind.
+ * @param options.context_type - default `'BackendHandlerContext'`. Caller's
+ *   handler context type — must be in scope at the emit site.
+ * @param options.collections_path - default `'./action_collections.js'`.
+ * @param options.metatypes_path - default `'./action_metatypes.js'`.
+ */
+export declare const generate_backend_action_handlers_map: (imports: ImportBuilder, options?: {
+    type_name?: string;
+    method_enum_name?: string;
+    context_type?: string;
+    collections_path?: string;
+    metatypes_path?: string;
+}) => string;
+/**
+ * One source in a multi-source consumer's namespace map. `ns` is the local
+ * alias used inside the generated file; `module` is the import path; `specs`
+ * is the runtime spec array. `create_namespace_qualifier` consumes a list of
+ * these.
+ */
+export interface SpecSource {
+    ns: string;
+    module: string;
+    specs: ReadonlyArray<ActionSpecUnion>;
+}
+/**
+ * Multi-source consumer helper. Takes a list of `{ns, module, specs}` rows,
+ * registers `import * as ns from module` for each on `imports`, builds the
+ * `method_to_ns` lookup with duplicate-method detection, and returns
+ * `{qualify_spec, all_specs}` ready to thread through the high-level
+ * helpers.
+ *
+ * Closes the per-file boilerplate gap that kept tx + visiones on hand-rolled
+ * template strings even after `qualify_spec?` landed in API review II — the
+ * per-call callback wasn't enough; the import dance + dup-check was the
+ * real boilerplate.
+ *
+ * @example
+ * ```ts
+ * const sources = [
+ *   {ns: 'tx_specs', module: './action_specs.js', specs: all_tx_action_specs},
+ *   {ns: 'admin_specs', module: '@fuzdev/fuz_app/auth/admin_action_specs.js', specs: all_admin_action_specs},
+ * ];
+ *
+ * export const gen: Gen = ({origin_path}) => {
+ *   const imports = new ImportBuilder();
+ *   const {qualify_spec, all_specs} = create_namespace_qualifier(sources, imports);
+ *   return compose_gen_file({
+ *     origin_path,
+ *     imports,
+ *     blocks: [
+ *       generate_action_specs_record(all_specs, imports, {qualify_spec}),
+ *       generate_action_inputs_outputs(all_specs, imports, {qualify_spec}),
+ *     ],
+ *   });
+ * };
+ * ```
+ *
+ * @throws if two sources contain the same method name (same-method detection
+ *   is the consumer's primary debugging signal).
+ */
+export declare const create_namespace_qualifier: (sources: ReadonlyArray<SpecSource>, imports: ImportBuilder) => {
+    qualify_spec: (spec: ActionSpecUnion) => string;
+    all_specs: ReadonlyArray<ActionSpecUnion>;
+};
+/**
+ * Wrap the per-`*.gen.ts` boilerplate (banner + `imports.build()` +
+ * blocks join + template literal) into one call. Returns the full file body
+ * as a string ready to return from a `Gen` function.
+ *
+ * Each consumer producer collapses to one `compose_gen_file` call wrapping
+ * the helper invocations.
+ *
+ * @example
+ * ```ts
+ * export const gen: Gen = ({origin_path}) => {
+ *   const imports = new ImportBuilder();
+ *   return compose_gen_file({
+ *     origin_path,
+ *     imports,
+ *     blocks: [
+ *       generate_action_specs_record(all_action_specs, imports),
+ *       generate_action_inputs_outputs(all_action_specs, imports),
+ *       generate_action_event_datas(all_action_specs, imports),
+ *     ],
+ *   });
+ * };
+ * ```
+ *
+ * Empty blocks (`''`) are filtered out so helpers that short-circuit on
+ * empty spec sets don't introduce stray double blank lines.
+ */
+export declare const compose_gen_file: (input: {
+    origin_path: string;
+    imports: ImportBuilder;
+    blocks: ReadonlyArray<string>;
+}) => 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":"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"}
+{"version":3,"file":"action_codegen.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/action_codegen.ts"],"names":[],"mappings":"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"}