@fuzdev/fuz_app 0.49.0 → 0.50.0

package/dist/actions/CLAUDE.md

@@ -120,8 +120,8 @@ not the runtime):
 - `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.
-- `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)`.
+- `PROTOCOL_ACTION_METHODS` (+ `ProtocolActionMethod` type) — readonly tuple `['heartbeat', 'cancel']`. Pairs with `protocol_actions` / `protocol_action_specs` in `actions/protocol.ts` (the runtime bundles). Consumers spread when filtering backend `request_response` methods so dispatcher-owned protocol actions don't leak into `BackendRequestResponseMethod` / handler maps.
+- `is_protocol_action_method(method)` — type predicate paired with `PROTOCOL_ACTION_METHODS`; use this in `method_filter` callbacks instead of `PROTOCOL_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.
@@ -133,14 +133,15 @@ Composed by consumer `*.gen.ts` producers; outputs do not include the banner or
 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`,
-`FrontendActionsApi`, `ActionInputs`, `FrontendActionHandlers`, etc.). Pass
-`include_composables: true` only if a consumer genuinely owns composables
-in their typed API.
+**Protocol actions are filtered by default.** Every spec-iterating helper
+accepts `{include_protocol_actions?: boolean}` (default `false`) and drops
+`heartbeat` / `cancel` from the emitted output. Protocol actions ship from
+fuz_app and are spread into each consumer's `actions` array at
+registration time (via `protocol_actions` from `actions/protocol.ts`) —
+they should not appear in consumer-owned typed surfaces (`ActionMethod`,
+`FrontendActionsApi`, `ActionInputs`, `FrontendActionHandlers`, etc.).
+Pass `include_protocol_actions: true` only if a consumer genuinely owns
+protocol actions in their typed API.
 
 **Consumer tiers and namespace handling.** Single-source consumers (zzz,
 undying — every spec lives in one local `action_specs.ts`) drop straight
@@ -167,15 +168,15 @@ interfaces — and never calls `generate_typed_action_event_alias` or
 zzz) emits the full set including `ActionEventDatas`, `TypedActionEvent`,
 and `FrontendActionHandlers`.
 
-- `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_action_method_enums(specs, imports, {emit?, include_protocol_actions?})` — 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_protocol_actions?})` — 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?, 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_action_specs_record(specs, imports, {specs_module?, qualify_spec?, include_protocol_actions?})` — `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_protocol_actions?})` — `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_protocol_actions?})` — `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_protocol_actions?})` — emits the typed `FrontendActionsApi` interface (configurable via `interface_name`, default `'FrontendActionsApi'`). One method signature per spec via `generate_actions_api_method_signature`. Protocol actions filtered by default; `method_filter: (spec) => boolean` runs after the protocol-action 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_protocol_actions?})` — `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_protocol_actions?})` — `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
@@ -578,12 +579,46 @@ interface ActionPeerSendOptions extends TransportSendOptions {
 Currently partial: `#receive_request`'s `send_response` transition step has
 a known sharp edge ("shouldn't need the guard" TODO).
 
-## Composable actions (`heartbeat.ts`, `cancel.ts`)
+## Protocol actions (`heartbeat.ts`, `cancel.ts`, `protocol.ts`)
 
 Two shared `{spec, handler}` tuples that every consumer spreads into both
 sides' `actions` arrays — disconnect detection and per-request cancel work
 identically across every repo without per-consumer ping plumbing.
 
+The category is wire-protocol concerns shipped by fuz_app, not consumer
+domain logic. The contrast that matters is protocol vs domain: a future
+clock-skew probe or reconnect-resume token belongs in this bundle; a
+`payment_charge` action does not. Avoid the framing "composable vs
+non-composable" — every `Action` is composable by the same mechanism
+(spread into the `actions` array), so the distinction would not carve
+nature at the joints.
+
+### Canonical bundles (`protocol.ts`)
+
+Two const arrays declare the canonical protocol-action set so consumers
+spread one symbol per side instead of importing each primitive
+individually:
+
+- `protocol_actions: ReadonlyArray<Action>` — for the server's
+  `register_action_ws` `actions` array. Spread before consumer-owned
+  actions: `actions: [...protocol_actions, ...consumer_actions]`.
+- `protocol_action_specs: ReadonlyArray<ActionSpecUnion>` — derived via
+  `.map(a => a.spec)` so the two arrays cannot drift. For the frontend
+  `ActionRegistry`. Spread before consumer-owned specs:
+  `new ActionRegistry([...protocol_action_specs, ...action_specs])`.
+
+The asymmetry is intentional — the server runs handlers (heartbeat echo +
+cancel stub), the frontend registry only stores specs. Both bundles plus
+the codegen `include_protocol_actions: false` default form a three-leg
+contract: codegen excludes protocol actions from generated typed surfaces
+because consumers spread these bundles in at registration time.
+
+The bundles are **not** auto-spread by `create_frontend_rpc_client` or
+`register_ws_endpoint` — bundled helpers stay pure factories so the
+dispatch surface stays grep-traceable at every consumer registration site
+and consumers can override individual protocol actions (custom heartbeat,
+etc.) without an opt-out flag.
+
 ### `heartbeat_action`
 
 Method `'heartbeat'`, `request_response`, `initiator: 'frontend'`, `auth:

package/dist/actions/action_codegen.d.ts

@@ -1,24 +1,27 @@
 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.
+ * Method names of fuz_app's protocol actions — `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 protocol actions don't show up in
+ * `BackendRequestResponseMethod` / handler maps. Pairs with `protocol_actions`
+ * / `protocol_action_specs` from `actions/protocol.ts` (the runtime bundles).
  */
-export declare const COMPOSABLE_ACTION_METHODS: readonly ["heartbeat", "cancel"];
+export declare const PROTOCOL_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];
+export type ProtocolActionMethod = (typeof PROTOCOL_ACTION_METHODS)[number];
 /**
- * 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.
+ * Type predicate for filtering protocol-action 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_frontend_actions_api(specs, imports, {
- *   method_filter: (s) => !is_composable_action_method(s.method),
+ *   method_filter: (s) => !is_protocol_action_method(s.method),
  * });
  */
-export declare const is_composable_action_method: (method: string) => method is ComposableActionMethod;
+export declare const is_protocol_action_method: (method: string) => method is ProtocolActionMethod;
 /**
  * Represents an import item with its kind (type, value, or namespace).
  */
@@ -174,10 +177,10 @@ export declare const ACTION_METHOD_ENUM_KINDS_ALL: ReadonlySet<ActionMethodEnumK
  * `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
- * their typed surface. Empty kinds are skipped so the helper never emits
- * `z.enum([])` (zod runtime-throws on that).
+ * Protocol-action methods (`heartbeat`, `cancel`) are filtered out by
+ * default — pass `include_protocol_actions: 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).
@@ -187,12 +190,12 @@ export declare const ACTION_METHOD_ENUM_KINDS_ALL: ReadonlySet<ActionMethodEnumK
  * and jsdoc.
  *
  * @param options.emit - subset of enums to emit; defaults to all nine.
- * @param options.include_composables - when true, retains `heartbeat` /
+ * @param options.include_protocol_actions - 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;
+    include_protocol_actions?: boolean;
 }) => string;
 /**
  * Emit a single named `z.enum([...])` + `z.infer` block for an arbitrary
@@ -200,9 +203,10 @@ export declare const generate_action_method_enums: (specs: ReadonlyArray<ActionS
  * 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.
+ * Mirrors the built-in helper's contract: protocol actions 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
@@ -212,7 +216,7 @@ export declare const generate_action_method_enum_block: (specs: ReadonlyArray<Ac
     name: string;
     jsdoc: string;
     predicate: (spec: ActionSpecUnion) => boolean;
-    include_composables?: boolean;
+    include_protocol_actions?: boolean;
 }) => string;
 /**
  * Emit the fixed-shape `TypedActionEvent` alias used by `FrontendActionHandlers`
@@ -245,7 +249,7 @@ export declare const generate_typed_action_event_alias: (imports: ImportBuilder,
 export declare const generate_action_specs_record: (specs: ReadonlyArray<ActionSpecUnion>, imports: ImportBuilder, options?: {
     specs_module?: string;
     qualify_spec?: (spec: ActionSpecUnion) => string;
-    include_composables?: boolean;
+    include_protocol_actions?: boolean;
 }) => string;
 /**
  * Emit `ActionInputs` + `ActionOutputs` runtime consts and matching interfaces.
@@ -263,7 +267,7 @@ export declare const generate_action_specs_record: (specs: ReadonlyArray<ActionS
 export declare const generate_action_inputs_outputs: (specs: ReadonlyArray<ActionSpecUnion>, imports: ImportBuilder, options?: {
     specs_module?: string;
     qualify_spec?: (spec: ActionSpecUnion) => string;
-    include_composables?: boolean;
+    include_protocol_actions?: boolean;
 }) => string;
 /**
  * Emit the `ActionEventDatas` interface — one `ActionEvent*Data` variant per
@@ -288,12 +292,13 @@ export declare const generate_action_inputs_outputs: (specs: ReadonlyArray<Actio
 export declare const generate_action_event_datas: (specs: ReadonlyArray<ActionSpecUnion>, imports: ImportBuilder, options?: {
     same_file?: boolean;
     collections_path?: string;
-    include_composables?: boolean;
+    include_protocol_actions?: boolean;
 }) => string;
 /**
  * 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`.
+ * (e.g. omit additional methods alongside the default protocol-action
+ * filter) via `method_filter`.
  *
  * Adds the `Result`, `JsonrpcErrorObject`, and `RpcClientCallOptions` type
  * imports plus `ActionInputs` / `ActionOutputs` (sourced from `collections_path`).
@@ -308,7 +313,7 @@ export declare const generate_frontend_actions_api: (specs: ReadonlyArray<Action
     method_filter?: (spec: ActionSpecUnion) => boolean;
     collections_path?: string;
     sync_returns_value?: boolean;
-    include_composables?: boolean;
+    include_protocol_actions?: boolean;
 }) => string;
 /**
  * Emit the `FrontendActionHandlers` interface — wraps `generate_phase_handlers`
@@ -318,7 +323,7 @@ export declare const generate_frontend_actions_api: (specs: ReadonlyArray<Action
  */
 export declare const generate_frontend_action_handlers: (specs: ReadonlyArray<ActionSpecUnion>, imports: ImportBuilder, options?: {
     collections_path?: string;
-    include_composables?: boolean;
+    include_protocol_actions?: boolean;
 }) => string;
 /**
  * Emit BOTH the typed `BackendActionsApi` interface AND the
@@ -355,7 +360,7 @@ export declare const generate_backend_actions_api: (specs: ReadonlyArray<ActionS
     specs_module?: string;
     collections_path?: string;
     qualify_spec?: (spec: ActionSpecUnion) => string;
-    include_composables?: boolean;
+    include_protocol_actions?: boolean;
 }) => string;
 /**
  * Emit the `BackendActionHandlers` mapped type — one entry per

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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"}

package/dist/actions/action_codegen.js

@@ -2,24 +2,27 @@ 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);
+ * Method names of fuz_app's protocol actions — `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 protocol actions don't show up in
+ * `BackendRequestResponseMethod` / handler maps. Pairs with `protocol_actions`
+ * / `protocol_action_specs` from `actions/protocol.ts` (the runtime bundles).
+ */
+export const PROTOCOL_ACTION_METHODS = ['heartbeat', 'cancel'];
+const PROTOCOL_METHOD_SET = new Set(PROTOCOL_ACTION_METHODS);
 /**
- * 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.
+ * Type predicate for filtering protocol-action 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_frontend_actions_api(specs, imports, {
- *   method_filter: (s) => !is_composable_action_method(s.method),
+ *   method_filter: (s) => !is_protocol_action_method(s.method),
  * });
  */
-export const is_composable_action_method = (method) => COMPOSABLE_METHOD_SET.has(method);
+export const is_protocol_action_method = (method) => PROTOCOL_METHOD_SET.has(method);
 /**
  * Manages imports for generated code, building them on demand.
  * Automatically optimizes type-only imports to use `import type` syntax.
@@ -404,12 +407,13 @@ export const ACTION_METHOD_ENUM_KINDS_ALL = new Set([
 ]);
 /**
  * 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
+ * Protocol actions ship from fuz_app and are spread into every consumer's
+ * `actions` array at registration time (via `protocol_actions` from
+ * `actions/protocol.ts`) — they should not appear in consumer-owned typed
  * surfaces (`ActionMethod`, `FrontendActionsApi`, `ActionInputs`, etc.) by
  * default.
  */
-const filter_composables = (specs, include_composables) => include_composables ? specs : specs.filter((s) => !is_composable_action_method(s.method));
+const filter_protocol_actions = (specs, include_protocol_actions) => include_protocol_actions ? specs : specs.filter((s) => !is_protocol_action_method(s.method));
 /**
  * Resolve the per-spec identifier qualifier used by the multi-source helpers
  * (`generate_action_specs_record`, `generate_action_inputs_outputs`,
@@ -434,10 +438,10 @@ const resolve_spec_qualifier = (imports, options) => {
  * `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
- * their typed surface. Empty kinds are skipped so the helper never emits
- * `z.enum([])` (zod runtime-throws on that).
+ * Protocol-action methods (`heartbeat`, `cancel`) are filtered out by
+ * default — pass `include_protocol_actions: 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).
@@ -447,12 +451,12 @@ const resolve_spec_qualifier = (imports, options) => {
  * and jsdoc.
  *
  * @param options.emit - subset of enums to emit; defaults to all nine.
- * @param options.include_composables - when true, retains `heartbeat` /
+ * @param options.include_protocol_actions - 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 filtered = filter_protocol_actions(specs, options?.include_protocol_actions);
     const registry = new ActionRegistry([...filtered]);
     const blocks = [];
     const emit_block = (kind, name, methods, jsdoc) => {
@@ -488,16 +492,17 @@ export const generate_action_method_enums = (specs, imports, options) => {
  * 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.
+ * Mirrors the built-in helper's contract: protocol actions 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 const generate_action_method_enum_block = (specs, imports, options) => {
-    const filtered = filter_composables(specs, options.include_composables);
+    const filtered = filter_protocol_actions(specs, options.include_protocol_actions);
     const methods = filtered.filter(options.predicate).map((s) => s.method);
     if (methods.length === 0)
         return '';
@@ -544,7 +549,7 @@ type TypedActionEvent<
  *   is ignored when `qualify_spec` is set. Single-source consumers omit it.
  */
 export const generate_action_specs_record = (specs, imports, options) => {
-    const filtered = filter_composables(specs, options?.include_composables);
+    const filtered = filter_protocol_actions(specs, options?.include_protocol_actions);
     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`
@@ -588,7 +593,7 @@ export const action_specs: Array<ActionSpecUnion> = Object.values(ActionSpecs);`
  *   and `specs_module` is ignored. Single-source consumers omit it.
  */
 export const generate_action_inputs_outputs = (specs, imports, options) => {
-    const filtered = filter_composables(specs, options?.include_composables);
+    const filtered = filter_protocol_actions(specs, options?.include_protocol_actions);
     if (filtered.length === 0) {
         // Empty spec list — emit minimal valid output and skip the `zod` /
         // `* as specs` imports that would have nothing to reference.
@@ -663,7 +668,7 @@ ${outputs_type}
  *   path the import resolves to.
  */
 export const generate_action_event_datas = (specs, imports, options) => {
-    const filtered = filter_composables(specs, options?.include_composables);
+    const filtered = filter_protocol_actions(specs, options?.include_protocol_actions);
     if (filtered.length === 0) {
         // Empty spec list — emit `interface ActionEventDatas {}` and skip
         // the optional collections-path import that would be unused.
@@ -703,7 +708,8 @@ ${lines.join('\n')}
 /**
  * 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`.
+ * (e.g. omit additional methods alongside the default protocol-action
+ * filter) via `method_filter`.
  *
  * Adds the `Result`, `JsonrpcErrorObject`, and `RpcClientCallOptions` type
  * imports plus `ActionInputs` / `ActionOutputs` (sourced from `collections_path`).
@@ -715,9 +721,9 @@ ${lines.join('\n')}
  * hand-roll the interface (the helper's job is the standard symmetric shape).
  */
 export const generate_frontend_actions_api = (specs, imports, options) => {
-    const composable_filtered = filter_composables(specs, options?.include_composables);
+    const protocol_filtered = filter_protocol_actions(specs, options?.include_protocol_actions);
     const filter = options?.method_filter;
-    const filtered = filter ? composable_filtered.filter((s) => filter(s)) : composable_filtered;
+    const filtered = filter ? protocol_filtered.filter((s) => filter(s)) : protocol_filtered;
     const interface_doc = `/**
  * Typed dispatch surface for the frontend's RPC client. Symmetric counterpart
  * of \`BackendActionsApi\`. Async methods (request_response, remote_notification,
@@ -755,7 +761,7 @@ ${lines}
  * 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 filtered = filter_protocol_actions(specs, options?.include_protocol_actions);
     const interface_doc = `/**
  * Frontend action handlers organized by method and phase.
  * Generated using spec.initiator to determine valid phases:
@@ -815,8 +821,8 @@ ${lines};
  *   Single-source consumers omit it.
  */
 export const generate_backend_actions_api = (specs, imports, options) => {
-    const composable_filtered = filter_composables(specs, options?.include_composables);
-    const registry = new ActionRegistry([...composable_filtered]);
+    const protocol_filtered = filter_protocol_actions(specs, options?.include_protocol_actions);
+    const registry = new ActionRegistry([...protocol_filtered]);
     const broadcast = registry.broadcast_specs;
     imports.add_type('@fuzdev/fuz_app/actions/action_spec.js', 'ActionSpecUnion');
     const interface_doc = `/**

package/dist/actions/action_types.d.ts

@@ -3,8 +3,8 @@
  *
  * These types sit above `action_spec.ts` (pure Zod schemas) and below the
  * dispatchers (`register_action_ws.ts`, `action_rpc.ts`). Extracted so the
- * shared composable fuz_app actions (e.g. `heartbeat_action`) can name them
- * without pulling in server-only modules.
+ * shared protocol actions (e.g. `heartbeat_action`) can name them without
+ * pulling in server-only modules.
  *
  * @module
  */

package/dist/actions/action_types.js

@@ -3,8 +3,8 @@
  *
  * These types sit above `action_spec.ts` (pure Zod schemas) and below the
  * dispatchers (`register_action_ws.ts`, `action_rpc.ts`). Extracted so the
- * shared composable fuz_app actions (e.g. `heartbeat_action`) can name them
- * without pulling in server-only modules.
+ * shared protocol actions (e.g. `heartbeat_action`) can name them without
+ * pulling in server-only modules.
  *
  * @module
  */

package/dist/actions/cancel.d.ts

@@ -1,6 +1,6 @@
 /**
- * Shared cancel action — the second composable fuz_app primitive, validating
- * the spec+handler tuple pattern on a notification-kind action.
+ * Shared cancel action — a fuz_app protocol action validating the
+ * spec+handler tuple pattern on a notification-kind action.
  *
  * Semantics: the client sends `{jsonrpc, method: 'cancel', params:
  * {request_id}}` to abort an in-flight request on the same socket.
@@ -11,13 +11,14 @@
  *
  * The handler field is an empty stub: cancel semantics are dispatcher-owned
  * (the dispatcher has the `{request_id → AbortController}` map, not the
- * handler). The handler exists for symmetry with other composable primitives
+ * handler). The handler exists for symmetry with other protocol actions
  * like `heartbeat_action`; the dispatcher never calls it. Consumers
- * spread `cancel_action` into their server's `actions` array so
- * `spec_by_method` knows about it (enabling input validation on incoming
- * cancels) and so `create_rpc_client` codegen produces `app.api.cancel()`
- * when desired — though `FrontendWebsocketClient.request({signal})` sends
- * the cancel on abort without needing the typed API.
+ * spread `cancel_action` (or the `protocol_actions` bundle from
+ * `./protocol.js`) into their server's `actions` array so `spec_by_method`
+ * knows about it (enabling input validation on incoming cancels) and so
+ * `create_rpc_client` codegen produces `app.api.cancel()` when desired —
+ * though `FrontendWebsocketClient.request({signal})` sends the cancel on
+ * abort without needing the typed API.
  *
  * Wire format is snake_case `cancel` with `{request_id}`, not MCP's
  * `$/cancelRequest` with `{requestId}` — fuz_app's WS transport isn't MCP,
@@ -67,9 +68,10 @@ export declare const cancel_action_spec: {
  */
 export declare const cancel_handler: () => void;
 /**
- * Composable tuple — spread into the server's `actions` array so the
- * dispatcher registers the spec for input validation and so `create_rpc_client`
- * codegen sees the method. The client doesn't need to call it directly;
+ * Protocol-action tuple — spread into the server's `actions` array (or via
+ * `protocol_actions` from `./protocol.js`) so the dispatcher registers the
+ * spec for input validation and so `create_rpc_client` codegen sees the
+ * method. The client doesn't need to call it directly;
  * `FrontendWebsocketClient.request({signal})` sends the cancel notification
  * automatically when the signal fires.
  */

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

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

package/dist/actions/cancel.js

@@ -1,6 +1,6 @@
 /**
- * Shared cancel action — the second composable fuz_app primitive, validating
- * the spec+handler tuple pattern on a notification-kind action.
+ * Shared cancel action — a fuz_app protocol action validating the
+ * spec+handler tuple pattern on a notification-kind action.
  *
  * Semantics: the client sends `{jsonrpc, method: 'cancel', params:
  * {request_id}}` to abort an in-flight request on the same socket.
@@ -11,13 +11,14 @@
  *
  * The handler field is an empty stub: cancel semantics are dispatcher-owned
  * (the dispatcher has the `{request_id → AbortController}` map, not the
- * handler). The handler exists for symmetry with other composable primitives
+ * handler). The handler exists for symmetry with other protocol actions
  * like `heartbeat_action`; the dispatcher never calls it. Consumers
- * spread `cancel_action` into their server's `actions` array so
- * `spec_by_method` knows about it (enabling input validation on incoming
- * cancels) and so `create_rpc_client` codegen produces `app.api.cancel()`
- * when desired — though `FrontendWebsocketClient.request({signal})` sends
- * the cancel on abort without needing the typed API.
+ * spread `cancel_action` (or the `protocol_actions` bundle from
+ * `./protocol.js`) into their server's `actions` array so `spec_by_method`
+ * knows about it (enabling input validation on incoming cancels) and so
+ * `create_rpc_client` codegen produces `app.api.cancel()` when desired —
+ * though `FrontendWebsocketClient.request({signal})` sends the cancel on
+ * abort without needing the typed API.
  *
  * Wire format is snake_case `cancel` with `{request_id}`, not MCP's
  * `$/cancelRequest` with `{requestId}` — fuz_app's WS transport isn't MCP,
@@ -64,9 +65,10 @@ export const cancel_action_spec = {
  */
 export const cancel_handler = () => { }; // eslint-disable-line @typescript-eslint/no-empty-function
 /**
- * Composable tuple — spread into the server's `actions` array so the
- * dispatcher registers the spec for input validation and so `create_rpc_client`
- * codegen sees the method. The client doesn't need to call it directly;
+ * Protocol-action tuple — spread into the server's `actions` array (or via
+ * `protocol_actions` from `./protocol.js`) so the dispatcher registers the
+ * spec for input validation and so `create_rpc_client` codegen sees the
+ * method. The client doesn't need to call it directly;
  * `FrontendWebsocketClient.request({signal})` sends the cancel notification
  * automatically when the signal fires.
  */

package/dist/actions/frontend_rpc_client.d.ts

@@ -58,6 +58,15 @@ export interface CreateFrontendRpcClientOptions<TApi extends object = object> {
      * list silently return `undefined` from the Proxy — the generic `TApi`
      * cannot constrain runtime membership, so consumers must keep this list
      * in sync with the typed surface (codegen recommended).
+     *
+     * Protocol actions (`heartbeat`, `cancel`) are **not** auto-spread —
+     * they're filtered out of generated `action_specs` by codegen's
+     * `include_protocol_actions: false` default and consumers spread them
+     * in explicitly so the contract stays visible at every registration
+     * site. For WS-using consumers, spread `protocol_action_specs` from
+     * `actions/protocol.ts` here:
+     * `specs: [...protocol_action_specs, ...action_specs]`. HTTP-only
+     * consumers can omit them.
      */
     specs: ReadonlyArray<ActionSpecUnion>;
     /**

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;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"}
+{"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;;;;;;;;;;;;;;OAcG;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/heartbeat.d.ts

@@ -1,9 +1,9 @@
 /**
- * Shared heartbeat action — the first composable fuz_app primitive carrying
- * both a spec and a handler in one tuple. Consumers spread
- * `heartbeat_action` into both the server's and the client's `actions`
- * array so disconnect detection works identically across every repo without
- * per-consumer ping plumbing.
+ * Shared heartbeat action — a fuz_app protocol action carrying both a spec
+ * and a handler in one tuple. Consumers spread `heartbeat_action` (or the
+ * `protocol_actions` bundle from `./protocol.js`) into the server's
+ * `actions` array so disconnect detection works identically across every
+ * repo without per-consumer ping plumbing.
  *
  * The client's activity-aware heartbeat timer (in
  * `FrontendWebsocketClient`) issues a `heartbeat` request whenever the
@@ -38,9 +38,12 @@ export declare const heartbeat_action_spec: {
 /** Handler — nullary echo. Stateless, suitable for high-frequency pings. */
 export declare const heartbeat_handler: () => Record<string, never>;
 /**
- * Composable tuple — spread into the server's `actions` array for dispatch
- * and into the client's `actions` array so `create_rpc_client` types
- * `app.api.heartbeat()` against the shared spec.
+ * Protocol-action tuple — spread into the server's `actions` array for
+ * dispatch (or via `protocol_actions` from `./protocol.js`) so the
+ * dispatcher resolves the heartbeat handler. The frontend-side spread
+ * happens via `protocol_action_specs` — the client doesn't run the echo
+ * handler, but the spec must be in `ActionRegistry` so `create_rpc_client`
+ * types `app.api.heartbeat()` against the shared spec.
  */
 export declare const heartbeat_action: Action;
 //# sourceMappingURL=heartbeat.d.ts.map

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

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

package/dist/actions/heartbeat.js

@@ -1,9 +1,9 @@
 /**
- * Shared heartbeat action — the first composable fuz_app primitive carrying
- * both a spec and a handler in one tuple. Consumers spread
- * `heartbeat_action` into both the server's and the client's `actions`
- * array so disconnect detection works identically across every repo without
- * per-consumer ping plumbing.
+ * Shared heartbeat action — a fuz_app protocol action carrying both a spec
+ * and a handler in one tuple. Consumers spread `heartbeat_action` (or the
+ * `protocol_actions` bundle from `./protocol.js`) into the server's
+ * `actions` array so disconnect detection works identically across every
+ * repo without per-consumer ping plumbing.
  *
  * The client's activity-aware heartbeat timer (in
  * `FrontendWebsocketClient`) issues a `heartbeat` request whenever the
@@ -37,9 +37,12 @@ export const heartbeat_action_spec = {
 /** Handler — nullary echo. Stateless, suitable for high-frequency pings. */
 export const heartbeat_handler = () => ({});
 /**
- * Composable tuple — spread into the server's `actions` array for dispatch
- * and into the client's `actions` array so `create_rpc_client` types
- * `app.api.heartbeat()` against the shared spec.
+ * Protocol-action tuple — spread into the server's `actions` array for
+ * dispatch (or via `protocol_actions` from `./protocol.js`) so the
+ * dispatcher resolves the heartbeat handler. The frontend-side spread
+ * happens via `protocol_action_specs` — the client doesn't run the echo
+ * handler, but the spec must be in `ActionRegistry` so `create_rpc_client`
+ * types `app.api.heartbeat()` against the shared spec.
  */
 export const heartbeat_action = {
     spec: heartbeat_action_spec,

package/dist/actions/protocol.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Canonical bundles of fuz_app's protocol actions — `heartbeat` and
+ * `cancel`. Spread these into consumer registrations on both sides of the
+ * wire so the registries stay symmetric without per-consumer plumbing.
+ *
+ * Protocol actions are wire-protocol concerns (liveness, abort) shipped by
+ * fuz_app, not consumer domain logic. The split is intentional: the server
+ * needs `{spec, handler}` tuples to drive dispatch; the frontend
+ * `ActionRegistry` only stores specs. The codegen
+ * `include_protocol_actions: false` default (in `action_codegen.ts`) is the
+ * third leg of this contract — protocol actions are excluded from
+ * generated typed surfaces because consumers spread them in at
+ * registration time.
+ *
+ * Adding a future protocol action (e.g. clock-skew probe, reconnect-resume
+ * token) means appending to these arrays in one place; no consumer
+ * migration required.
+ *
+ * @module
+ */
+import type { ActionSpecUnion } from './action_spec.js';
+import type { Action } from './action_types.js';
+/**
+ * Canonical protocol `{spec, handler}` tuples for the server's
+ * `register_action_ws` `actions` array. Spread before consumer-owned actions
+ * so disconnect detection and per-request cancel work uniformly:
+ *
+ * ```ts
+ * register_action_ws({actions: [...protocol_actions, ...consumer_actions], ...})
+ * ```
+ */
+export declare const protocol_actions: ReadonlyArray<Action>;
+/**
+ * Canonical protocol specs for `ActionRegistry` construction on the
+ * frontend. Spread before consumer-owned specs so dispatcher-owned methods
+ * are present in the lookup map even though codegen excludes them from the
+ * generated `action_specs` array:
+ *
+ * ```ts
+ * new ActionRegistry([...protocol_action_specs, ...action_specs])
+ * ```
+ *
+ * Derived from `protocol_actions` so a future protocol action lands in one
+ * place — the two arrays cannot drift.
+ */
+export declare const protocol_action_specs: ReadonlyArray<ActionSpecUnion>;
+//# sourceMappingURL=protocol.d.ts.map

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

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

package/dist/actions/protocol.js

@@ -0,0 +1,46 @@
+/**
+ * Canonical bundles of fuz_app's protocol actions — `heartbeat` and
+ * `cancel`. Spread these into consumer registrations on both sides of the
+ * wire so the registries stay symmetric without per-consumer plumbing.
+ *
+ * Protocol actions are wire-protocol concerns (liveness, abort) shipped by
+ * fuz_app, not consumer domain logic. The split is intentional: the server
+ * needs `{spec, handler}` tuples to drive dispatch; the frontend
+ * `ActionRegistry` only stores specs. The codegen
+ * `include_protocol_actions: false` default (in `action_codegen.ts`) is the
+ * third leg of this contract — protocol actions are excluded from
+ * generated typed surfaces because consumers spread them in at
+ * registration time.
+ *
+ * Adding a future protocol action (e.g. clock-skew probe, reconnect-resume
+ * token) means appending to these arrays in one place; no consumer
+ * migration required.
+ *
+ * @module
+ */
+import { cancel_action } from './cancel.js';
+import { heartbeat_action } from './heartbeat.js';
+/**
+ * Canonical protocol `{spec, handler}` tuples for the server's
+ * `register_action_ws` `actions` array. Spread before consumer-owned actions
+ * so disconnect detection and per-request cancel work uniformly:
+ *
+ * ```ts
+ * register_action_ws({actions: [...protocol_actions, ...consumer_actions], ...})
+ * ```
+ */
+export const protocol_actions = [heartbeat_action, cancel_action];
+/**
+ * Canonical protocol specs for `ActionRegistry` construction on the
+ * frontend. Spread before consumer-owned specs so dispatcher-owned methods
+ * are present in the lookup map even though codegen excludes them from the
+ * generated `action_specs` array:
+ *
+ * ```ts
+ * new ActionRegistry([...protocol_action_specs, ...action_specs])
+ * ```
+ *
+ * Derived from `protocol_actions` so a future protocol action lands in one
+ * place — the two arrays cannot drift.
+ */
+export const protocol_action_specs = protocol_actions.map((a) => a.spec);

package/dist/actions/register_action_ws.d.ts

@@ -2,7 +2,7 @@
  * WebSocket JSON-RPC dispatch — the low-level WS transport binding.
  *
  * Most consumers should mount WS endpoints via `register_ws_endpoint`
- * (`./register_ws_endpoint.js`), which wraps this function with the standard
+ * (`actions/register_ws_endpoint.ts`), which wraps this function with the standard
  * upgrade stack (origin check + auth + optional role). This module stays
  * exported as the lower-level entry point for tests that drive the
  * dispatcher directly via `create_ws_test_harness`.
@@ -97,8 +97,9 @@ export interface RegisterActionWsOptions<TCtx extends BaseHandlerContext> {
      * The actions registered on this endpoint — each carries a spec (drives
      * method lookup, per-action auth, input/output validation) and an
      * optional handler (omit for client-only specs like inbound
-     * notifications). Include the shared `heartbeat_action` here to
-     * complete the disconnect-detection pairing with the frontend client.
+     * notifications). Spread `protocol_actions` from `actions/protocol.ts`
+     * here to complete the disconnect-detection + per-request cancel
+     * pairing with the frontend client.
      */
     actions: ReadonlyArray<Action<TCtx>>;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"register_action_ws.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/register_action_ws.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,KAAK,EAAC,OAAO,EAAE,IAAI,EAAC,MAAM,MAAM,CAAC;AACxC,OAAO,KAAK,EAAC,gBAAgB,EAAE,SAAS,EAAC,MAAM,SAAS,CAAC;AAEzD,OAAO,EAAS,KAAK,MAAM,IAAI,UAAU,EAAC,MAAM,yBAAyB,CAAC;AAC1E,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,wBAAwB,CAAC;AAiBjD,OAAO,EAAC,KAAK,MAAM,EAAE,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAG7F,OAAO,EAAC,yBAAyB,EAAE,KAAK,kBAAkB,EAAC,MAAM,4BAA4B,CAAC;AAE9F,YAAY,EAAC,MAAM,EAAE,kBAAkB,EAAE,eAAe,EAAC,CAAC;AAE1D,0EAA0E;AAC1E,eAAO,MAAM,gCAAgC,QAAS,CAAC;AAEvD;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAiB;IACjC,qFAAqF;IACrF,EAAE,EAAE,SAAS,CAAC;IACd,4EAA4E;IAC5E,aAAa,EAAE,IAAI,CAAC;IACpB,oDAAoD;IACpD,QAAQ,EAAE,kBAAkB,CAAC;IAC7B;;;OAGG;IACH,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IAClD,wFAAwF;IACxF,MAAM,EAAE,WAAW,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IAClC,+CAA+C;IAC/C,EAAE,EAAE,SAAS,CAAC;IACd,2CAA2C;IAC3C,aAAa,EAAE,IAAI,CAAC;IACpB,kGAAkG;IAClG,QAAQ,EAAE,kBAAkB,CAAC;CAC7B;AAED,MAAM,WAAW,sBAAsB;IACtC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wCAAwC;AACxC,MAAM,WAAW,uBAAuB,CAAC,IAAI,SAAS,kBAAkB;IACvE,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,gCAAgC;IAChC,GAAG,EAAE,IAAI,CAAC;IACV,iEAAiE;IACjE,gBAAgB,EAAE,gBAAgB,CAAC;IACnC;;;;;;OAMG;IACH,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IACrC;;;;;OAKG;IACH,cAAc,EAAE,CAAC,IAAI,EAAE,kBAAkB,EAAE,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IAC/D;;;;OAIG;IACH,SAAS,CAAC,EAAE,yBAAyB,CAAC;IACtC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,sBAAsB,CAAC;IAC7C,+EAA+E;IAC/E,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qDAAqD;IACrD,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,iBAAiB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE;;;;;OAKG;IACH,eAAe,CAAC,EAAE,CAAC,GAAG,EAAE,kBAAkB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpE;AAED,sCAAsC;AACtC,MAAM,WAAW,sBAAsB;IACtC,yEAAyE;IACzE,SAAS,EAAE,yBAAyB,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,kBAAkB,GAAI,IAAI,SAAS,kBAAkB,EACjE,SAAS,uBAAuB,CAAC,IAAI,CAAC,KACpC,sBA8WF,CAAC"}
+{"version":3,"file":"register_action_ws.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/register_action_ws.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,KAAK,EAAC,OAAO,EAAE,IAAI,EAAC,MAAM,MAAM,CAAC;AACxC,OAAO,KAAK,EAAC,gBAAgB,EAAE,SAAS,EAAC,MAAM,SAAS,CAAC;AAEzD,OAAO,EAAS,KAAK,MAAM,IAAI,UAAU,EAAC,MAAM,yBAAyB,CAAC;AAC1E,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,wBAAwB,CAAC;AAiBjD,OAAO,EAAC,KAAK,MAAM,EAAE,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAG7F,OAAO,EAAC,yBAAyB,EAAE,KAAK,kBAAkB,EAAC,MAAM,4BAA4B,CAAC;AAE9F,YAAY,EAAC,MAAM,EAAE,kBAAkB,EAAE,eAAe,EAAC,CAAC;AAE1D,0EAA0E;AAC1E,eAAO,MAAM,gCAAgC,QAAS,CAAC;AAEvD;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAiB;IACjC,qFAAqF;IACrF,EAAE,EAAE,SAAS,CAAC;IACd,4EAA4E;IAC5E,aAAa,EAAE,IAAI,CAAC;IACpB,oDAAoD;IACpD,QAAQ,EAAE,kBAAkB,CAAC;IAC7B;;;OAGG;IACH,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IAClD,wFAAwF;IACxF,MAAM,EAAE,WAAW,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IAClC,+CAA+C;IAC/C,EAAE,EAAE,SAAS,CAAC;IACd,2CAA2C;IAC3C,aAAa,EAAE,IAAI,CAAC;IACpB,kGAAkG;IAClG,QAAQ,EAAE,kBAAkB,CAAC;CAC7B;AAED,MAAM,WAAW,sBAAsB;IACtC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wCAAwC;AACxC,MAAM,WAAW,uBAAuB,CAAC,IAAI,SAAS,kBAAkB;IACvE,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,gCAAgC;IAChC,GAAG,EAAE,IAAI,CAAC;IACV,iEAAiE;IACjE,gBAAgB,EAAE,gBAAgB,CAAC;IACnC;;;;;;;OAOG;IACH,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IACrC;;;;;OAKG;IACH,cAAc,EAAE,CAAC,IAAI,EAAE,kBAAkB,EAAE,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IAC/D;;;;OAIG;IACH,SAAS,CAAC,EAAE,yBAAyB,CAAC;IACtC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,sBAAsB,CAAC;IAC7C,+EAA+E;IAC/E,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qDAAqD;IACrD,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,iBAAiB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE;;;;;OAKG;IACH,eAAe,CAAC,EAAE,CAAC,GAAG,EAAE,kBAAkB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpE;AAED,sCAAsC;AACtC,MAAM,WAAW,sBAAsB;IACtC,yEAAyE;IACzE,SAAS,EAAE,yBAAyB,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,kBAAkB,GAAI,IAAI,SAAS,kBAAkB,EACjE,SAAS,uBAAuB,CAAC,IAAI,CAAC,KACpC,sBA8WF,CAAC"}

package/dist/actions/register_action_ws.js

@@ -2,7 +2,7 @@
  * WebSocket JSON-RPC dispatch — the low-level WS transport binding.
  *
  * Most consumers should mount WS endpoints via `register_ws_endpoint`
- * (`./register_ws_endpoint.js`), which wraps this function with the standard
+ * (`actions/register_ws_endpoint.ts`), which wraps this function with the standard
  * upgrade stack (origin check + auth + optional role). This module stays
  * exported as the lower-level entry point for tests that drive the
  * dispatcher directly via `create_ws_test_harness`.

package/dist/auth/account_action_specs.d.ts

@@ -2,7 +2,7 @@
  * Account RPC action specs — declarative contract for self-service account
  * operations. Import this module for the specs, Input/Output schemas, and
  * the `all_account_action_specs` registry. Handlers live in
- * `./account_actions.js` so consumers doing typed-client codegen or surface
+ * `auth/account_actions.ts` so consumers doing typed-client codegen or surface
  * reporting don't transitively drag in server-only query code.
  *
  * @module

package/dist/auth/account_action_specs.js

@@ -2,7 +2,7 @@
  * Account RPC action specs — declarative contract for self-service account
  * operations. Import this module for the specs, Input/Output schemas, and
  * the `all_account_action_specs` registry. Handlers live in
- * `./account_actions.js` so consumers doing typed-client codegen or surface
+ * `auth/account_actions.ts` so consumers doing typed-client codegen or surface
  * reporting don't transitively drag in server-only query code.
  *
  * @module

package/dist/auth/account_actions.d.ts

@@ -9,14 +9,14 @@
  * - API token management: `account_token_create`, `account_token_list`,
  *   `account_token_revoke`.
  *
- * The action specs themselves live in `./account_action_specs.js`. Every spec
+ * The action specs themselves live in `auth/account_action_specs.ts`. Every spec
  * declares `auth: 'authenticated'` so the dispatcher enforces auth before the
  * handler runs. Revoke operations are account-scoped (via
  * `query_session_revoke_for_account` / `query_revoke_api_token_for_account`)
  * so passing another account's session or token id returns `revoked: false`
  * rather than revealing whether the id exists.
  *
- * Counterpart to `account_routes.ts`, which keeps the cookie-lifecycle flows
+ * Counterpart to `auth/account_routes.ts`, which keeps the cookie-lifecycle flows
  * (`login`, `logout`, `password`, `signup`, `bootstrap`) on REST.
  *
  * @module

package/dist/auth/account_actions.js

@@ -9,14 +9,14 @@
  * - API token management: `account_token_create`, `account_token_list`,
  *   `account_token_revoke`.
  *
- * The action specs themselves live in `./account_action_specs.js`. Every spec
+ * The action specs themselves live in `auth/account_action_specs.ts`. Every spec
  * declares `auth: 'authenticated'` so the dispatcher enforces auth before the
  * handler runs. Revoke operations are account-scoped (via
  * `query_session_revoke_for_account` / `query_revoke_api_token_for_account`)
  * so passing another account's session or token id returns `revoked: false`
  * rather than revealing whether the id exists.
  *
- * Counterpart to `account_routes.ts`, which keeps the cookie-lifecycle flows
+ * Counterpart to `auth/account_routes.ts`, which keeps the cookie-lifecycle flows
  * (`login`, `logout`, `password`, `signup`, `bootstrap`) on REST.
  *
  * @module

package/dist/auth/admin_action_specs.d.ts

@@ -2,7 +2,7 @@
  * Admin RPC action specs — declarative contract for admin-only operations.
  *
  * Import this module for the specs, Input/Output schemas, and the
- * `all_admin_action_specs` registry. Handlers live in `./admin_actions.js`.
+ * `all_admin_action_specs` registry. Handlers live in `auth/admin_actions.ts`.
  *
  * Authorization is declared at the spec level (`auth: {role: ROLE_ADMIN}`)
  * so the RPC dispatcher enforces admin before the handler runs and the

package/dist/auth/admin_action_specs.js

@@ -2,7 +2,7 @@
  * Admin RPC action specs — declarative contract for admin-only operations.
  *
  * Import this module for the specs, Input/Output schemas, and the
- * `all_admin_action_specs` registry. Handlers live in `./admin_actions.js`.
+ * `all_admin_action_specs` registry. Handlers live in `auth/admin_actions.ts`.
  *
  * Authorization is declared at the spec level (`auth: {role: ROLE_ADMIN}`)
  * so the RPC dispatcher enforces admin before the handler runs and the

package/dist/auth/admin_actions.d.ts

@@ -11,13 +11,13 @@
  *   when `AdminActionOptions.app_settings` is provided — the mutable ref is
  *   owned by the server context and shared with signup middleware).
  *
- * The action specs themselves live in `./admin_action_specs.js`. Mutations
+ * The action specs themselves live in `auth/admin_action_specs.ts`. Mutations
  * emit matching audit events via `audit_log_fire_and_forget`.
  *
  * Authorization is declared at the spec level (`auth: {role: 'admin'}`) so
  * the RPC dispatcher enforces it before the handler runs and the generated
  * surface accurately reports the requirement. `permit_revoke` in
- * `permit_offer_actions.ts` uses the same spec-level pattern even though its
+ * `auth/permit_offer_actions.ts` uses the same spec-level pattern even though its
  * sibling methods are authenticated-but-not-admin — the dispatcher checks
  * auth per-spec, so mixed-auth endpoints compose cleanly. Handler-level
  * gates are reserved for input-dependent elevation (e.g.

package/dist/auth/admin_actions.js

@@ -11,13 +11,13 @@
  *   when `AdminActionOptions.app_settings` is provided — the mutable ref is
  *   owned by the server context and shared with signup middleware).
  *
- * The action specs themselves live in `./admin_action_specs.js`. Mutations
+ * The action specs themselves live in `auth/admin_action_specs.ts`. Mutations
  * emit matching audit events via `audit_log_fire_and_forget`.
  *
  * Authorization is declared at the spec level (`auth: {role: 'admin'}`) so
  * the RPC dispatcher enforces it before the handler runs and the generated
  * surface accurately reports the requirement. `permit_revoke` in
- * `permit_offer_actions.ts` uses the same spec-level pattern even though its
+ * `auth/permit_offer_actions.ts` uses the same spec-level pattern even though its
  * sibling methods are authenticated-but-not-admin — the dispatcher checks
  * auth per-spec, so mixed-auth endpoints compose cleanly. Handler-level
  * gates are reserved for input-dependent elevation (e.g.

package/dist/auth/permit_offer_action_specs.d.ts

@@ -4,7 +4,7 @@
  *
  * Import this module for the specs, Input/Output schemas, `ERROR_OFFER_*`
  * reason constants, and the `all_permit_offer_action_specs` registry.
- * Handlers live in `./permit_offer_actions.js`.
+ * Handlers live in `auth/permit_offer_actions.ts`.
  *
  * Authorization enforcement: offer-lifecycle specs declare
  * `auth: 'authenticated'` and rely on `query_*` IDOR guards or in-handler

package/dist/auth/permit_offer_action_specs.js

@@ -4,7 +4,7 @@
  *
  * Import this module for the specs, Input/Output schemas, `ERROR_OFFER_*`
  * reason constants, and the `all_permit_offer_action_specs` registry.
- * Handlers live in `./permit_offer_actions.js`.
+ * Handlers live in `auth/permit_offer_actions.ts`.
  *
  * Authorization enforcement: offer-lifecycle specs declare
  * `auth: 'authenticated'` and rely on `query_*` IDOR guards or in-handler

package/dist/auth/permit_offer_actions.d.ts

@@ -4,7 +4,7 @@
  * Seven actions: six offer-lifecycle methods (create / accept / decline /
  * retract / list / history) plus `permit_revoke` (admin-only). All mount
  * on a consumer's JSON-RPC endpoint via `create_rpc_endpoint`. The action
- * specs themselves live in `./permit_offer_action_specs.js`. Mutations
+ * specs themselves live in `auth/permit_offer_action_specs.ts`. Mutations
  * declare `side_effects: true` so the RPC dispatcher wraps the handler in
  * a DB transaction; `permit_offer_list` and `permit_offer_history` declare
  * `side_effects: false` so they are addressable via GET.

package/dist/auth/permit_offer_actions.js

@@ -4,7 +4,7 @@
  * Seven actions: six offer-lifecycle methods (create / accept / decline /
  * retract / list / history) plus `permit_revoke` (admin-only). All mount
  * on a consumer's JSON-RPC endpoint via `create_rpc_endpoint`. The action
- * specs themselves live in `./permit_offer_action_specs.js`. Mutations
+ * specs themselves live in `auth/permit_offer_action_specs.ts`. Mutations
  * declare `side_effects: true` so the RPC dispatcher wraps the handler in
  * a DB transaction; `permit_offer_list` and `permit_offer_history` declare
  * `side_effects: false` so they are addressable via GET.

package/dist/auth/standard_action_specs.d.ts

@@ -1,7 +1,7 @@
 /**
  * Aggregate spec list mirroring `create_standard_rpc_actions` on the backend.
  *
- * `create_standard_rpc_actions` (in `./standard_rpc_actions.js`) bundles three
+ * `create_standard_rpc_actions` (in `auth/standard_rpc_actions.ts`) bundles three
  * action registries into one mounted RPC surface: admin + permit_offer +
  * account. Frontends mounting that surface need the matching spec list to
  * feed `create_rpc_client` so the typed Proxy knows about every standard

package/dist/auth/standard_action_specs.js

@@ -1,7 +1,7 @@
 /**
  * Aggregate spec list mirroring `create_standard_rpc_actions` on the backend.
  *
- * `create_standard_rpc_actions` (in `./standard_rpc_actions.js`) bundles three
+ * `create_standard_rpc_actions` (in `auth/standard_rpc_actions.ts`) bundles three
  * action registries into one mounted RPC surface: admin + permit_offer +
  * account. Frontends mounting that surface need the matching spec list to
  * feed `create_rpc_client` so the typed Proxy knows about every standard

package/package.json

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