@nice-code/action 0.2.0 → 0.2.2

package/build/types/ActionDefinition/Action/Payload/ActionPayload_Request.d.ts

@@ -8,17 +8,17 @@ import type { IActionPayload_Data_Base, TActionProgress } from "./ActionPayload.
 import { EActionPayloadType, type IActionPayload_Request_JsonObject } from "./ActionPayload.types";
 import { ActionPayload_Progress } from "./ActionPayload_Progress";
 import { ActionPayload_Result } from "./ActionPayload_Result";
-export declare class ActionPayload_Request<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends ActionPayload<EActionPayloadType.request, DOM, ID> {
-    readonly input: TInferInputFromSchema<DOM["actions"][ID]>["Input"];
+export declare class ActionPayload_Request<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends ActionPayload<EActionPayloadType.request, DOM, ID> {
+    readonly input: TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"];
     constructor(params: {
         context: ActionContext<DOM, ID>;
-    }, input: TInferInputFromSchema<DOM["actions"][ID]>["Input"], data: IActionPayload_Data_Base);
-    successResult(...args: [TInferOutputFromSchema<DOM["actions"][ID]>["Output"]] extends [never] ? [] | [output: TInferOutputFromSchema<DOM["actions"][ID]>["Output"]] : [output: TInferOutputFromSchema<DOM["actions"][ID]>["Output"]]): ActionPayload_Result<DOM, ID>;
-    errorResult(err: TInferActionError<DOM["actions"][ID]>): ActionPayload_Result<DOM, ID>;
+    }, input: TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"], data: IActionPayload_Data_Base);
+    successResult(...args: [TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"]] extends [never] ? [] | [output: TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"]] : [output: TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"]]): ActionPayload_Result<DOM, ID>;
+    errorResult(err: TInferActionError<DOM["actionSchema"][ID]>): ActionPayload_Result<DOM, ID>;
     progress(progress: TActionProgress): ActionPayload_Progress<DOM, ID>;
     toJsonObject(): IActionPayload_Request_JsonObject<DOM, ID>;
     toJsonString(): string;
-    runToOutput(options?: IExecuteActionOptions<DOM, ID>): Promise<TInferOutputFromSchema<DOM["actions"][ID]>["Output"]>;
+    runToOutput(options?: IExecuteActionOptions<DOM, ID>): Promise<TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"]>;
     runToResultPayload(options?: IExecuteActionOptions<DOM, ID>): Promise<ActionPayload_Result<DOM, ID>>;
     run(options?: IExecuteActionOptions<DOM, ID>): Promise<RunningAction<DOM, ID>>;
 }

package/build/types/ActionDefinition/Action/Payload/ActionPayload_Result.d.ts

@@ -5,11 +5,11 @@ import { ActionPayload } from "./ActionPayload";
 import type { IActionPayload_Data_Base, TActionResultOutcome } from "./ActionPayload.types";
 import { EActionPayloadType, type IActionPayload_Result_JsonObject } from "./ActionPayload.types";
 import { ActionPayload_Request } from "./ActionPayload_Request";
-export declare class ActionPayload_Result<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends ActionPayload<EActionPayloadType.result, DOM, ID> {
-    readonly result: TActionResultOutcome<TInferOutputFromSchema<DOM["actions"][ID]>["Output"], TInferActionError<DOM["actions"][ID]>>;
+export declare class ActionPayload_Result<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends ActionPayload<EActionPayloadType.result, DOM, ID> {
+    readonly result: TActionResultOutcome<TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"], TInferActionError<DOM["actionSchema"][ID]>>;
     constructor(params: {
         context: ActionContext<DOM, ID>;
-    } | ActionPayload_Request<DOM, ID>, result: TActionResultOutcome<TInferOutputFromSchema<DOM["actions"][ID]>["Output"], TInferActionError<DOM["actions"][ID]>>, data: IActionPayload_Data_Base);
+    } | ActionPayload_Request<DOM, ID>, result: TActionResultOutcome<TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"], TInferActionError<DOM["actionSchema"][ID]>>, data: IActionPayload_Data_Base);
     toJsonObject(): IActionPayload_Result_JsonObject<DOM, ID>;
     toJsonString(): string;
     toHttpResponse({ useErrorStatus }?: {

package/build/types/ActionDefinition/Action/RunningAction.d.ts

@@ -5,7 +5,7 @@ import { type IActionPayload_Result_JsonObject } from "./Payload/ActionPayload.t
 import type { ActionPayload_Progress } from "./Payload/ActionPayload_Progress";
 import type { ActionPayload_Result } from "./Payload/ActionPayload_Result";
 import { type IRunningActionState, type IRunningActionState_ConstructorParams, type IRunningActionUserMethods, type TRunningActionUpdate, type TRunningActionUpdateListener } from "./RunningAction.types";
-export declare class RunningAction<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> implements IRunningActionUserMethods<DOM, ID> {
+export declare class RunningAction<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> implements IRunningActionUserMethods<DOM, ID> {
     protected _state: IRunningActionState<DOM, ID>;
     readonly context: ActionContext<DOM, ID>;
     readonly cuid: string;

package/build/types/ActionDefinition/Action/RunningAction.types.d.ts

@@ -10,12 +10,12 @@ export declare enum ERunningActionState {
     running = "running",
     completed = "completed"
 }
-export interface IRunningActionState<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string> {
+export interface IRunningActionState<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string> {
     request: ActionPayload_Request<DOM, ID>;
     progress: ActionPayload_Progress<DOM, ID>[];
     result?: ActionPayload_Result<DOM, ID>;
 }
-export interface IRunningActionState_ConstructorParams<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string> {
+export interface IRunningActionState_ConstructorParams<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string> {
     context: ActionContext<DOM, ID>;
     request: ActionPayload_Request<DOM, ID>;
     progress?: ActionPayload_Progress<DOM, ID>[];
@@ -26,14 +26,14 @@ export declare enum ERunningActionUpdateType {
     progress = "progress",
     finished = "finished"
 }
-export interface IRunningActionEvent_Base<T extends ERunningActionUpdateType, DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> {
+export interface IRunningActionEvent_Base<T extends ERunningActionUpdateType, DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> {
     type: T;
     runningAction: RunningAction<DOM, ID>;
     time: number;
 }
-export interface IRunningActionUpdate_Started<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends IRunningActionEvent_Base<ERunningActionUpdateType.started, DOM, ID> {
+export interface IRunningActionUpdate_Started<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IRunningActionEvent_Base<ERunningActionUpdateType.started, DOM, ID> {
 }
-export interface IRunningActionUpdate_Progress<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends IRunningActionEvent_Base<ERunningActionUpdateType.progress, DOM, ID> {
+export interface IRunningActionUpdate_Progress<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IRunningActionEvent_Base<ERunningActionUpdateType.progress, DOM, ID> {
     progress: TActionProgress;
 }
 export declare enum ERunningActionFinishedType {
@@ -41,23 +41,29 @@ export declare enum ERunningActionFinishedType {
     failed = "failed",
     success = "success"
 }
-export interface IRunningActionUpdate_Finished<FT extends ERunningActionFinishedType, DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends IRunningActionEvent_Base<ERunningActionUpdateType.finished, DOM, ID> {
+export interface IRunningActionUpdate_Finished<FT extends ERunningActionFinishedType, DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IRunningActionEvent_Base<ERunningActionUpdateType.finished, DOM, ID> {
     finishType: FT;
     reason?: unknown;
 }
-export interface IRunningActionUpdate_Abort<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends IRunningActionUpdate_Finished<ERunningActionFinishedType.aborted, DOM, ID> {
+export interface IRunningActionUpdate_Abort<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IRunningActionUpdate_Finished<ERunningActionFinishedType.aborted, DOM, ID> {
     reason?: unknown;
 }
-export interface IRunningActionUpdate_Failed<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends IRunningActionUpdate_Finished<ERunningActionFinishedType.failed, DOM, ID> {
-    error: TInferActionError<DOM["actions"][ID]>;
+export interface IRunningActionUpdate_Failed<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IRunningActionUpdate_Finished<ERunningActionFinishedType.failed, DOM, ID> {
+    error: TInferActionError<DOM["actionSchema"][ID]>;
 }
-export interface IRunningActionUpdate_Success<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends IRunningActionUpdate_Finished<ERunningActionFinishedType.success, DOM, ID> {
+export interface IRunningActionUpdate_Success<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IRunningActionUpdate_Finished<ERunningActionFinishedType.success, DOM, ID> {
     response: ActionPayload_Result<DOM, ID>;
 }
-export type TRunningActionUpdateFinished<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = IRunningActionUpdate_Abort<DOM, ID> | IRunningActionUpdate_Failed<DOM, ID> | IRunningActionUpdate_Success<DOM, ID>;
-export type TRunningActionUpdate<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = IRunningActionUpdate_Started<DOM, ID> | IRunningActionUpdate_Progress<DOM, ID> | TRunningActionUpdateFinished<DOM, ID>;
-export type TRunningActionUpdateListener<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = (update: TRunningActionUpdate<DOM, ID>) => void;
-export interface IRunningActionUserMethods<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string> {
+export type TRunningActionUpdateFinished<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = IRunningActionUpdate_Abort<DOM, ID> | IRunningActionUpdate_Failed<DOM, ID> | IRunningActionUpdate_Success<DOM, ID>;
+export type TRunningActionUpdate<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = IRunningActionUpdate_Started<DOM, ID> | IRunningActionUpdate_Progress<DOM, ID> | TRunningActionUpdateFinished<DOM, ID>;
+export type TRunningActionUpdateListener<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = (update: TRunningActionUpdate<DOM, ID>) => void;
+/**
+ * Distributes a union ID into a proper discriminated union of RunningAction update events,
+ * so that narrowing on `update.runningAction.id` also narrows `update.runningAction`'s input/output types.
+ */
+export type TDistributeRunningActionUpdate<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = ID extends keyof DOM["actionSchema"] & string ? TRunningActionUpdate<DOM, ID> : never;
+export type TDistributeRunningActionUpdateListener<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = (update: TDistributeRunningActionUpdate<DOM, ID>) => void;
+export interface IRunningActionUserMethods<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string> {
     waitForResultPayload(): Promise<ActionPayload_Result<DOM, ID>>;
     addUpdateListeners(listeners: TRunningActionUpdateListener<DOM, ID>[]): () => void;
     iterateUpdates(): AsyncIterable<TRunningActionUpdate<DOM, ID>>;

package/build/types/ActionDefinition/Domain/ActionDomain.d.ts

@@ -1,30 +1,37 @@
 import type { IExecuteActionOptions } from "../../ActionRuntime/Handler/ActionHandler.types";
-import type { TAction_Any_JsonObject, TDistributedDomainActions, TNarrowActionJsonTypeToActionInstanceType } from "../Action/Action.combined.types";
+import type { TAction_Any_JsonObject, TDistributeActionPayload_Request, TDistributeActionPayload_Result, TDistributedDomainActions, TNarrowActionJsonTypeToActionInstanceType } from "../Action/Action.combined.types";
 import { type IActionBase } from "../Action/ActionBase.types";
 import { ActionContext } from "../Action/Context/ActionContext";
 import type { IActionContext_Data_JsonObject } from "../Action/Context/ActionContext.types";
 import { ActionCore } from "../Action/Core/ActionCore";
 import { type IActionPayload_Request_JsonObject, type IActionPayload_Result_JsonObject } from "../Action/Payload/ActionPayload.types";
 import { ActionPayload_Request } from "../Action/Payload/ActionPayload_Request";
-import { ActionPayload_Result } from "../Action/Payload/ActionPayload_Result";
 import type { RunningAction } from "../Action/RunningAction";
 import type { IActionDomain, IActionDomainChildOptions, TActionDomainChildDef } from "./ActionDomain.types";
 import { ActionDomainBase } from "./ActionDomainBase";
 import { type ActionRootDomain } from "./ActionRootDomain";
+type TActionMap<ACT_DOM extends IActionDomain> = {
+    [K in keyof ACT_DOM["actionSchema"] & string]: ActionCore<ACT_DOM, K>;
+};
 export declare class ActionDomain<ACT_DOM extends IActionDomain = IActionDomain> extends ActionDomainBase<ACT_DOM> {
     private _rootDomain;
+    private readonly _actionMap;
     constructor(definition: ACT_DOM, { rootDomain, }: {
-        rootDomain: ActionRootDomain;
+        rootDomain: ActionRootDomain<any>;
     });
-    get rootDomain(): ActionRootDomain<import("./ActionDomain.types").IActionRootDomain<string>>;
+    get rootDomain(): ActionRootDomain<any>;
     createChildDomain<SUB_DOM extends IActionDomainChildOptions>(subDomainDef: SUB_DOM & {
         [K in Exclude<keyof SUB_DOM, keyof IActionDomainChildOptions>]: never;
     }): ActionDomain<TActionDomainChildDef<ACT_DOM, SUB_DOM>>;
-    action<ID extends keyof ACT_DOM["actions"] & string>(id: ID): ActionCore<ACT_DOM, ID>;
-    hydrateContext<ID extends keyof ACT_DOM["actions"] & string>(id: ID, contextData: IActionContext_Data_JsonObject): ActionContext<ACT_DOM, ID>;
+    get action(): TActionMap<ACT_DOM>;
+    actionsMap(): TActionMap<ACT_DOM>;
+    actionForId<ID extends keyof ACT_DOM["actionSchema"] & string>(id: ID): ActionCore<ACT_DOM, ID>;
+    hydrateContext<ID extends keyof ACT_DOM["actionSchema"] & string>(id: ID, contextData: IActionContext_Data_JsonObject): ActionContext<ACT_DOM, ID>;
     isDomainAction<ACT extends IActionBase<any, ACT_DOM, any>>(action: ACT | unknown | null | undefined): action is TDistributedDomainActions<ACT_DOM, ACT>;
-    hydrateRequest<ID extends keyof ACT_DOM["actions"] & string, P extends IActionPayload_Request_JsonObject<ACT_DOM, ID>>(serialized: P): ActionPayload_Request<ACT_DOM, ID>;
-    hydrateResultPayload<ID extends keyof ACT_DOM["actions"] & string, R extends IActionPayload_Result_JsonObject<ACT_DOM, ID>>(serialized: R): ActionPayload_Result<ACT_DOM, ID>;
-    hydrateAnyAction<ID extends keyof ACT_DOM["actions"] & string, AJ extends TAction_Any_JsonObject<ACT_DOM, ID>>(actionJson: AJ): TNarrowActionJsonTypeToActionInstanceType<ACT_DOM, AJ, ID>;
-    runAction<ID extends keyof ACT_DOM["actions"] & string, ACT extends ActionPayload_Request<ACT_DOM, ID>>(request: ACT, options?: IExecuteActionOptions<ACT_DOM, ID>): Promise<RunningAction<ACT_DOM, ID>>;
+    hydrateRequestPayload<ID extends keyof ACT_DOM["actionSchema"] & string, P extends IActionPayload_Request_JsonObject<ACT_DOM, ID>>(serialized: P): TDistributeActionPayload_Request<ACT_DOM, ID>;
+    hydrateResultPayload<ID extends keyof ACT_DOM["actionSchema"] & string, R extends IActionPayload_Result_JsonObject<ACT_DOM, ID>>(serialized: R): TDistributeActionPayload_Result<ACT_DOM, ID>;
+    hydrateAnyAction<ID extends keyof ACT_DOM["actionSchema"] & string, AJ extends TAction_Any_JsonObject<ACT_DOM, ID>>(actionJson: AJ): TNarrowActionJsonTypeToActionInstanceType<ACT_DOM, AJ, ID>;
+    runAction<ID extends keyof ACT_DOM["actionSchema"] & string, ACT extends ActionPayload_Request<ACT_DOM, ID>>(request: ACT, options?: IExecuteActionOptions<ACT_DOM, ID>): Promise<RunningAction<ACT_DOM, ID>>;
+    private createActionMap;
 }
+export {};

package/build/types/ActionDefinition/Domain/ActionDomain.types.d.ts

@@ -1,7 +1,7 @@
 import type { ActionSchema } from "../Schema/ActionSchema";
 import type { IActionErrorDeclaration, TTransportedValue } from "../Schema/ActionSchema.types";
 export type TPossibleDomainId = string;
-export type TPossibleDomainIdList = [TPossibleDomainId, ...TPossibleDomainId[]];
+export type TPossibleDomainIdList = [...TPossibleDomainId[], TPossibleDomainId];
 export type TActionDomainSchema = Record<string, ActionSchema<TTransportedValue<any, any>, TTransportedValue<any, any>, readonly IActionErrorDeclaration<any, any>[]>>;
 /**
  * Data shape for a domain — used for construction and as the type-level schema carrier.
@@ -10,12 +10,12 @@ export type TActionDomainSchema = Record<string, ActionSchema<TTransportedValue<
 export interface IActionDomain<IDS extends TPossibleDomainIdList = TPossibleDomainIdList, SCH extends TActionDomainSchema = TActionDomainSchema> {
     domain: IDS[0] & string;
     allDomains: IDS;
-    actions: SCH;
+    actionSchema: SCH;
 }
 export interface IActionRootDomain<ID extends TPossibleDomainId = TPossibleDomainId> extends IActionDomain<[ID], {}> {
     domain: ID;
     allDomains: [ID];
-    actions: {};
+    actionSchema: {};
 }
 export interface IActionDomainChildOptions<ERR_DOMAIN extends string = string, SCHEMA extends TActionDomainSchema = TActionDomainSchema> {
     domain: ERR_DOMAIN;
@@ -23,14 +23,17 @@ export interface IActionDomainChildOptions<ERR_DOMAIN extends string = string, S
 }
 export type TActionDomainChildDef<PARENT_DEF extends IActionDomain, SUB extends IActionDomainChildOptions> = {
     domain: SUB["domain"];
-    allDomains: [SUB["domain"], ...PARENT_DEF["allDomains"]];
-    actions: SUB["actions"];
+    allDomains: [...PARENT_DEF["allDomains"], SUB["domain"]];
+    actionSchema: SUB["actions"];
 };
-export type TDomainActionId<DOM extends IActionDomain> = keyof DOM["actions"] & string;
+export type TDomainActionId<DOM extends IActionDomain> = keyof DOM["actionSchema"] & string;
 export type TInferInputFromSchema<SCH extends ActionSchema<any, any, any>> = SCH extends ActionSchema<infer IN, any, any> ? {
     Input: IN[0];
     SerdeInput: IN[1];
-} : never;
+} : {
+    Input: never;
+    SerdeInput: never;
+};
 export type TInferOutputFromSchema<SCH extends ActionSchema<any, any, any>> = SCH extends ActionSchema<any, infer OUT, any> ? {
     Output: OUT[0];
     SerdeOutput: OUT[1];

package/build/types/ActionDefinition/Domain/ActionDomainBase.d.ts

@@ -1,14 +1,14 @@
-import type { TRunningActionUpdateListener } from "../Action/RunningAction.types";
+import type { TDistributeRunningActionUpdateListener, TRunningActionUpdateListener } from "../Action/RunningAction.types";
 import type { IActionDomain } from "./ActionDomain.types";
-export declare abstract class ActionDomainBase<ACT_DOM extends IActionDomain = IActionDomain> implements IActionDomain<ACT_DOM["allDomains"], ACT_DOM["actions"]> {
+export declare abstract class ActionDomainBase<ACT_DOM extends IActionDomain = IActionDomain> implements IActionDomain<ACT_DOM["allDomains"], ACT_DOM["actionSchema"]> {
     readonly domain: ACT_DOM["domain"];
     readonly allDomains: ACT_DOM["allDomains"];
-    readonly actions: ACT_DOM["actions"];
+    readonly actionSchema: ACT_DOM["actionSchema"];
     protected _listeners: TRunningActionUpdateListener<any, any>[];
     constructor(definition: ACT_DOM);
     /**
      * Add an observer that is called after every action dispatched through this domain.
      * Returns an unsubscribe function — call it to remove the listener.
      */
-    addActionListener(listener: TRunningActionUpdateListener<ACT_DOM, any>): () => void;
+    addActionListener(listener: TDistributeRunningActionUpdateListener<ACT_DOM, keyof ACT_DOM["actionSchema"] & string>): () => void;
 }

package/build/types/ActionDefinition/Domain/ActionRootDomain.d.ts

@@ -19,5 +19,5 @@ export declare class ActionRootDomain<ROOT_DOM extends IActionRootDomain = IActi
     }): ActionDomain<TActionDomainChildDef<ROOT_DOM, SUB_DOM>>;
     addActionRuntime(runtime: ActionRuntime): this;
     getRuntime(clientSpecifier: IActionClientSpecifier): ActionRuntime | undefined;
-    _runAction<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string, ACT extends ActionPayload_Request<DOM, ID> = ActionPayload_Request<DOM, ID>>(primed: ACT, options?: IExecuteActionOptions<DOM, ID>): Promise<RunningAction<DOM, ID>>;
+    _runAction<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string, ACT extends ActionPayload_Request<DOM, ID> = ActionPayload_Request<DOM, ID>>(actionPayload: ACT, options?: IExecuteActionOptions<DOM, ID>): Promise<RunningAction<DOM, ID>>;
 }

package/build/types/ActionDefinition/Schema/ActionSchema.d.ts

@@ -1,4 +1,4 @@
-import { err_cast_not_nice, type INiceErrorDomainProps, type InferNiceError, type JSONSerializableValue, type NiceErrorDomain } from "@nice-code/error";
+import { err_cast_not_nice, type INiceErrorDomainProps, type InferNiceError, type NiceErrorDomain } from "@nice-code/error";
 import type { StandardSchemaV1 } from "@standard-schema/spec";
 import type { IActionErrorDeclaration, TActionSchemaOptions, TInferDeclaredErrors, TTransportedValue } from "./ActionSchema.types";
 export declare class ActionSchema<INPUT extends TTransportedValue<any, any> = never, OUTPUT extends TTransportedValue<any, any> = never, ERRORS extends readonly IActionErrorDeclaration<any, any>[] = readonly []> {
@@ -12,14 +12,14 @@ export declare class ActionSchema<INPUT extends TTransportedValue<any, any> = ne
      * For non-JSON-native inputs, prefer the 3-argument form below to avoid
      * needing explicit type parameters.
      */
-    input<VS extends StandardSchemaV1 = StandardSchemaV1, SERDE_IN extends JSONSerializableValue = never>(options: TActionSchemaOptions<VS, SERDE_IN>): ActionSchema<TTransportedValue<StandardSchemaV1.InferInput<VS>, SERDE_IN>, OUTPUT, ERRORS>;
+    input<VS extends StandardSchemaV1 = StandardSchemaV1, SERDE_IN = any>(options: TActionSchemaOptions<VS, SERDE_IN>): ActionSchema<TTransportedValue<StandardSchemaV1.InferInput<VS>, SERDE_IN>, OUTPUT, ERRORS>;
     /**
      * Declare the input schema with serialization via sequential parameters.
      * TypeScript infers SERDE_IN from `serialize`'s return type (left-to-right),
      * then provides it as the contextual type for `deserialize`'s parameter —
      * no explicit type parameters or casts needed.
      */
-    input<VS extends StandardSchemaV1, SERDE_IN extends JSONSerializableValue>(options: {
+    input<VS extends StandardSchemaV1, SERDE_IN = any>(options: {
         schema: VS;
     }, serialize: (raw: StandardSchemaV1.InferInput<VS>) => SERDE_IN, deserialize: (serde: SERDE_IN) => StandardSchemaV1.InferInput<VS>): ActionSchema<TTransportedValue<StandardSchemaV1.InferInput<VS>, SERDE_IN>, OUTPUT, ERRORS>;
     /**
@@ -27,14 +27,14 @@ export declare class ActionSchema<INPUT extends TTransportedValue<any, any> = ne
      * For non-JSON-native outputs, prefer the 3-argument form below to avoid
      * needing explicit type parameters.
      */
-    output<VS extends StandardSchemaV1 = StandardSchemaV1, SERDE_OUT extends JSONSerializableValue = JSONSerializableValue>(options: TActionSchemaOptions<VS, SERDE_OUT>): ActionSchema<INPUT, TTransportedValue<StandardSchemaV1.InferInput<VS>, SERDE_OUT>, ERRORS>;
+    output<VS extends StandardSchemaV1 = StandardSchemaV1, SERDE_OUT = any>(options: TActionSchemaOptions<VS, SERDE_OUT>): ActionSchema<INPUT, TTransportedValue<StandardSchemaV1.InferInput<VS>, SERDE_OUT>, ERRORS>;
     /**
      * Declare the output schema with serialization via sequential parameters.
      * TypeScript infers SERDE_OUT from `serialize`'s return type (left-to-right),
      * then provides it as the contextual type for `deserialize`'s parameter —
      * no explicit type parameters or casts needed.
      */
-    output<VS extends StandardSchemaV1, SERDE_OUT extends JSONSerializableValue>(options: {
+    output<VS extends StandardSchemaV1, SERDE_OUT = any>(options: {
         schema: VS;
     }, serialize: (raw: StandardSchemaV1.InferInput<VS>) => SERDE_OUT, deserialize: (serde: SERDE_OUT) => StandardSchemaV1.InferInput<VS>): ActionSchema<INPUT, TTransportedValue<StandardSchemaV1.InferInput<VS>, SERDE_OUT>, ERRORS>;
     /**
@@ -52,13 +52,13 @@ export declare class ActionSchema<INPUT extends TTransportedValue<any, any> = ne
      * Uses the schema's serialization.serialize if defined; otherwise the input
      * is already JSON-native and is returned as-is.
      */
-    serializeInput(rawInput: INPUT[0]): JSONSerializableValue;
+    serializeInput(rawInput: INPUT[0]): INPUT[1];
     /**
      * Deserialize a JSON value back into the raw input type.
      * Uses serialization.deserialize if defined; otherwise the value is cast
      * directly (it's already in the correct shape).
      */
-    deserializeInput(serialized: JSONSerializableValue): INPUT[0];
+    deserializeInput(serialized: INPUT[1]): INPUT[0];
     /**
      * Validate raw input against the schema defined via `.input({ schema })`.
      * Throws `action_input_validation_failed` if validation fails.

package/build/types/ActionDefinition/Schema/ActionSchema.types.d.ts

@@ -1,17 +1,13 @@
-import { type INiceErrorDomainProps, type JSONSerializableValue, type NiceErrorDomain } from "@nice-code/error";
+import { type INiceErrorDomainProps, type NiceErrorDomain } from "@nice-code/error";
 import type { StandardSchemaV1 } from "@standard-schema/spec";
-export type TActionJsonSerializableValue = JSONSerializableValue;
-export type TTransportedValue<RAW_VAL, SERDE_VAL extends TActionJsonSerializableValue> = RAW_VAL extends TActionJsonSerializableValue ? [RAW_VAL] | [RAW_VAL, SERDE_VAL] : [RAW_VAL, SERDE_VAL];
-export type TActionSerializationDefinition<RAW_VAL = any, SERDE_VAL extends TActionJsonSerializableValue = TActionJsonSerializableValue> = {
+export type TTransportedValue<RAW_VAL, SERDE_VAL> = [RAW_VAL] | [RAW_VAL, SERDE_VAL];
+export type TActionSerializationDefinition<RAW_VAL = any, SERDE_VAL = any> = {
     serialize: (value: RAW_VAL) => SERDE_VAL;
     deserialize: (value: SERDE_VAL) => RAW_VAL;
 };
-export type TActionSchemaOptions<VS extends StandardSchemaV1 = StandardSchemaV1, SERDE_IN extends TActionJsonSerializableValue = TActionJsonSerializableValue> = StandardSchemaV1.InferInput<VS> extends TActionJsonSerializableValue ? {
+export type TActionSchemaOptions<VS extends StandardSchemaV1 = StandardSchemaV1, SERDE_IN = any> = {
     schema: VS;
     serialization?: TActionSerializationDefinition<StandardSchemaV1.InferInput<VS>, SERDE_IN>;
-} : {
-    schema: VS;
-    serialization: TActionSerializationDefinition<StandardSchemaV1.InferInput<VS>, SERDE_IN>;
 };
 /**
  * One error declaration on an action schema.

package/build/types/ActionRuntime/ActionDomainManager.d.ts

@@ -9,5 +9,5 @@ export declare class ActionDomainManager {
     verifyIsActionJson(action: INiceActionIdAndDomain<any>): void;
     getActionDomain<DOM extends IActionDomain, ACT extends INiceActionIdAndDomain<DOM>>(action: ACT): ActionDomain<DOM> | undefined;
     getActionDomainOrThrow<DOM extends IActionDomain, ACT extends INiceActionIdAndDomain<DOM>>(action: ACT): ActionDomain<DOM>;
-    hydrateActionPayload<D extends IActionDomain, ID extends keyof D["actions"] & string, A extends TAction_Any_JsonObject<D, ID>>(actionJson: A): TNarrowActionJsonTypeToActionInstanceType<D, A, ID>;
+    hydrateActionPayload<D extends IActionDomain, ID extends keyof D["actionSchema"] & string, A extends TAction_Any_JsonObject<D, ID>>(actionJson: A): TNarrowActionJsonTypeToActionInstanceType<D, A, ID>;
 }

package/build/types/ActionRuntime/ActionRuntime.d.ts

@@ -22,14 +22,9 @@ export declare class ActionRuntime {
      * the correct handler, and return the response. The most specific handler
      * match is chosen (action-ID-specific beats domain-wildcard).
      */
-    handleActionPayloadWire<D extends IActionDomain, ID extends keyof D["actions"] & string>(wire: TActionPayload_Any_JsonObject<D, ID>): Promise<RunningAction<D, ID>>;
+    handleActionPayloadWire<D extends IActionDomain, ID extends keyof D["actionSchema"] & string>(wire: TActionPayload_Any_JsonObject<D, ID>): Promise<RunningAction<D, ID>>;
     handleActionPayloadWire(wire: unknown): Promise<RunningAction<any, any>>;
-    handleActionPayload<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string>(action: TActionPayload_Any_Instance<DOM, ID>, options?: Omit<IHandleActionOptions, "targetLocalRuntime">): Promise<RunningAction<DOM, ID>>;
-    /**
-     * Return the first handler registered for the given action, or `undefined`
-     * if none has been registered (action-ID-specific beats domain-wildcard).
-     */
-    getHandlerForAction<ACT extends TActionPayload_Any_Instance<any, any>>(action: ACT, options?: Omit<IHandleActionOptions, "targetLocalRuntime">): TActionHandler | undefined;
+    handleActionPayload<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(action: TActionPayload_Any_Instance<DOM, ID>, options?: Omit<IHandleActionOptions, "targetLocalRuntime">): Promise<RunningAction<DOM, ID>>;
     getHandlerForActionOrThrow<ACT extends TActionPayload_Any_Instance<any, any>>(action: ACT, options?: Omit<IHandleActionOptions, "localRuntime">): TActionHandler;
     /**
      * Register one or more handlers. Each handler's own `actionRouter` defines

package/build/types/ActionRuntime/Handler/ActionHandler.d.ts

@@ -10,7 +10,7 @@ export declare abstract class ActionHandler<T extends EActionHandlerType> implem
     abstract readonly actionRouter: ActionRouter<any>;
     constructor();
     getActionRouter(): ActionRouter<any>;
-    abstract handleActionRequest<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string>(action: ActionPayload_Request<DOM, ID>, config?: IHandleActionOptions): Promise<RunningAction<DOM, ID>>;
+    abstract handleActionRequest<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(action: ActionPayload_Request<DOM, ID>, config?: IHandleActionOptions): Promise<RunningAction<DOM, ID>>;
     abstract toJsonObject(): TActionHandler_Json;
     abstract toHandlerRouteItem(...args: any[]): IActionRouteItemHandler;
 }

package/build/types/ActionRuntime/Handler/ActionHandler.types.d.ts

@@ -24,7 +24,7 @@ export interface IHandleActionOptions {
     targetExternalClient?: ActionClientSpecifier;
     targetLocalRuntime?: ActionRuntime;
 }
-export interface IExecuteActionOptions<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends IHandleActionOptions {
+export interface IExecuteActionOptions<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IHandleActionOptions {
     listeners?: TRunningActionUpdateListener<DOM, ID>[];
 }
 export type TAtLeastOne<T extends object> = {
@@ -35,9 +35,6 @@ export interface IActionHandler_Base<T extends EActionHandlerType> {
     handlerType: T;
     getActionRouter: () => ActionRouter<any>;
 }
-export interface IHandleActionPrimed_Input_Base<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> {
-    action: ActionPayload_Request<DOM, ID>;
-}
 /**
  *
  *  LOCAL ACTION HANDLER
@@ -46,7 +43,7 @@ export interface IHandleActionPrimed_Input_Base<DOM extends IActionDomain = IAct
 export interface IHandleActionOptions_Local extends IHandleActionOptions {
 }
 export interface IActionHandler_Local extends IActionHandler_Base<EActionHandlerType.local> {
-    handleActionRequest: <DOM extends IActionDomain, ID extends keyof DOM["actions"] & string>(action: ActionPayload_Request<DOM, ID>, config?: IHandleActionOptions_Local) => Promise<RunningAction<DOM, ID>>;
+    handleActionRequest: <DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(action: ActionPayload_Request<DOM, ID>, config?: IHandleActionOptions_Local) => Promise<RunningAction<DOM, ID>>;
 }
 /**
  *
@@ -57,7 +54,7 @@ export interface IHandleActionOptions_External extends IHandleActionOptions {
 }
 export interface IActionHandler_ExternalClient extends IActionHandler_Base<EActionHandlerType.external> {
     externalClient: ActionClientSpecifier;
-    handleActionRequest: <DOM extends IActionDomain, ID extends keyof DOM["actions"] & string>(action: ActionPayload_Request<DOM, ID>, config?: IHandleActionOptions_External) => Promise<RunningAction<DOM, ID>>;
+    handleActionRequest: <DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(action: ActionPayload_Request<DOM, ID>, config?: IHandleActionOptions_External) => Promise<RunningAction<DOM, ID>>;
     _setIncomingActionDataListener(listener: (json: TActionPayload_Any_JsonObject<any>) => void): void;
 }
 /**

package/build/types/ActionRuntime/Handler/ExternalClient/ActionExternalClientHandler.d.ts

@@ -22,10 +22,10 @@ export declare class ActionExternalClientHandler extends ActionHandler<EActionHa
     readonly actionRouter: ActionRouter<true>;
     constructor({ externalClientSpecifier, transports, defaultTimeout, }: IActionExternalClientRequestHandlerConfig);
     forDomain<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>): this;
-    forAction<ACT_DOM extends IActionDomain, ID extends keyof ACT_DOM["actions"] & string>(action: ActionCore<ACT_DOM, ID>): this;
-    forActionIds<ACT_DOM extends IActionDomain, IDS extends ReadonlyArray<keyof ACT_DOM["actions"] & string>>(domain: ActionDomain<ACT_DOM>, ids: IDS): this;
+    forAction<ACT_DOM extends IActionDomain, ID extends keyof ACT_DOM["actionSchema"] & string>(action: ActionCore<ACT_DOM, ID>): this;
+    forActionIds<ACT_DOM extends IActionDomain, IDS extends ReadonlyArray<keyof ACT_DOM["actionSchema"] & string>>(domain: ActionDomain<ACT_DOM>, ids: IDS): this;
     _setIncomingActionDataListener(listener: (json: TActionPayload_Any_JsonObject<any, any>) => void): void;
-    handleActionRequest<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string>(action: ActionPayload_Request<DOM, ID>, config?: IHandleActionOptions): Promise<RunningAction<DOM, ID>>;
+    handleActionRequest<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(action: ActionPayload_Request<DOM, ID>, config?: IHandleActionOptions): Promise<RunningAction<DOM, ID>>;
     /**
      * Dispatch a result or progress payload directly back to the external client via the best
      * available bidirectional transport (WebSocket / Custom). Used for return-path routing when the

package/build/types/ActionRuntime/Handler/Local/ActionLocalHandler.d.ts

@@ -24,13 +24,13 @@ export declare class ActionLocalHandler extends ActionHandler<EActionHandlerType
      * Receives the full primed action with narrowed input type.
      * Useful for handling specific actions locally while forwarding the rest of the domain. For example, a local "ping" action that checks connectivity without needing a round trip.
      */
-    forAction<ACT_DOM extends IActionDomain, ID extends keyof ACT_DOM["actions"] & string>(action: ActionCore<ACT_DOM, ID>, handler: THandleActionExecutionFn<ACT_DOM, ID>): this;
+    forAction<ACT_DOM extends IActionDomain, ID extends keyof ACT_DOM["actionSchema"] & string>(action: ActionCore<ACT_DOM, ID>, handler: THandleActionExecutionFn<ACT_DOM, ID>): this;
     /**
      * Register a handler for multiple action IDs (first-match-wins among cases).
      * Receives the full primed action narrowed to the union of those IDs.
      * Use `act.coreAction.id` to branch on which action was dispatched.
      */
-    forActionIds<ACT_DOM extends IActionDomain, IDS extends ReadonlyArray<keyof ACT_DOM["actions"] & string>>(domain: ActionDomain<ACT_DOM>, ids: IDS, handler: THandleActionExecutionFn<ACT_DOM, IDS[number]>): this;
+    forActionIds<ACT_DOM extends IActionDomain, IDS extends ReadonlyArray<keyof ACT_DOM["actionSchema"] & string>>(domain: ActionDomain<ACT_DOM>, ids: IDS, handler: THandleActionExecutionFn<ACT_DOM, IDS[number]>): this;
     /**
      * Register per-action handlers for a domain using a single map, without needing
      * separate `forAction` calls. Unregistered action IDs are unaffected.
@@ -44,9 +44,9 @@ export declare class ActionLocalHandler extends ActionHandler<EActionHandlerType
      * ```
      */
     forDomainActionCases<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>, cases: {
-        [ID in keyof FOR_DOM["actions"] & string]?: THandleActionExecutionFn<FOR_DOM, ID>;
+        [ID in keyof FOR_DOM["actionSchema"] & string]?: THandleActionExecutionFn<FOR_DOM, ID>;
     }): this;
-    handleActionRequest<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string>(action: ActionPayload_Request<DOM, ID>, config?: IHandleActionOptions): Promise<RunningAction<DOM, ID>>;
+    handleActionRequest<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(action: ActionPayload_Request<DOM, ID>, config?: IHandleActionOptions): Promise<RunningAction<DOM, ID>>;
     private _handleRunningAction;
     handlePayloadWireOrThrow(wire: unknown, config?: IHandleActionOptions): Promise<RunningAction<any, any>>;
     toJsonObject(): IActionHandler_Local_Json;

package/build/types/ActionRuntime/Handler/Local/ActionLocalHandler.types.d.ts

@@ -1,6 +1,7 @@
 import type { MaybePromise } from "bun";
+import type { TDistributeActionPayload_Request } from "../../../ActionDefinition/Action/Action.combined.types";
 import type { IActionPayload_Result_JsonObject } from "../../../ActionDefinition/Action/Payload/ActionPayload.types";
-import type { ActionPayload_Request } from "../../../ActionDefinition/Action/Payload/ActionPayload_Request";
 import type { ActionPayload_Result } from "../../../ActionDefinition/Action/Payload/ActionPayload_Result";
 import type { IActionDomain, TInferOutputFromSchema } from "../../../ActionDefinition/Domain/ActionDomain.types";
-export type THandleActionExecutionFn<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = (action: ActionPayload_Request<DOM, ID>) => MaybePromise<ActionPayload_Result<DOM, ID> | IActionPayload_Result_JsonObject<DOM, ID> | TInferOutputFromSchema<DOM["actions"][ID]>["Output"] | undefined>;
+export type { TDistributeActionPayload_Request };
+export type THandleActionExecutionFn<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = (action: TDistributeActionPayload_Request<DOM, ID>) => MaybePromise<ActionPayload_Result<DOM, ID> | IActionPayload_Result_JsonObject<DOM, ID> | TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"] | undefined>;

package/build/types/ActionRuntime/Routing/ActionRouter.d.ts

@@ -30,24 +30,24 @@ export declare class ActionRouter<DATA> {
     getDomains(): ActionDomain[];
     /** Register a handler for all actions in a domain, replacing any existing one. */
     forDomain<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>, routeData: DATA): this;
-    forAction<ACT_DOM extends IActionDomain, ID extends keyof ACT_DOM["actions"] & string>(action: ActionCore<ACT_DOM, ID>, routeData: DATA): this;
+    forAction<ACT_DOM extends IActionDomain, ID extends keyof ACT_DOM["actionSchema"] & string>(action: ActionCore<ACT_DOM, ID>, routeData: DATA): this;
     /** Register a handler for a specific action, replacing any existing one. */
-    forActionId<ACT_DOM extends IActionDomain, ID extends keyof ACT_DOM["actions"] & string>(domain: ActionDomain<ACT_DOM>, id: ID, routeData: DATA): this;
+    forActionId<ACT_DOM extends IActionDomain, ID extends keyof ACT_DOM["actionSchema"] & string>(domain: ActionDomain<ACT_DOM>, id: ID, routeData: DATA): this;
     /** Register one handler for several action IDs, replacing any existing ones. */
-    forActionIds<ACT_DOM extends IActionDomain, IDS extends ReadonlyArray<keyof ACT_DOM["actions"] & string>>(domain: ActionDomain<ACT_DOM>, ids: IDS, routeData: DATA): this;
+    forActionIds<ACT_DOM extends IActionDomain, IDS extends ReadonlyArray<keyof ACT_DOM["actionSchema"] & string>>(domain: ActionDomain<ACT_DOM>, ids: IDS, routeData: DATA): this;
     /** Register per-action handlers from a cases map, replacing any existing ones. */
     forDomainActionCases<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>, cases: {
-        [ID in keyof FOR_DOM["actions"] & string]?: DATA;
+        [ID in keyof FOR_DOM["actionSchema"] & string]?: DATA;
     }): this;
     /** Append a handler for all actions in a domain (accumulates alongside existing). */
     addForDomain<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>, routeData: DATA): this;
     /** Append a handler for a specific action (accumulates alongside existing). */
-    addForAction<ACT_DOM extends IActionDomain, ID extends keyof ACT_DOM["actions"] & string>(domain: ActionDomain<ACT_DOM>, id: ID, routeData: DATA): this;
+    addForAction<ACT_DOM extends IActionDomain, ID extends keyof ACT_DOM["actionSchema"] & string>(domain: ActionDomain<ACT_DOM>, id: ID, routeData: DATA): this;
     /** Append one handler for several action IDs (accumulates alongside existing). */
-    addForActionIds<ACT_DOM extends IActionDomain, IDS extends ReadonlyArray<keyof ACT_DOM["actions"] & string>>(domain: ActionDomain<ACT_DOM>, ids: IDS, routeData: DATA): this;
+    addForActionIds<ACT_DOM extends IActionDomain, IDS extends ReadonlyArray<keyof ACT_DOM["actionSchema"] & string>>(domain: ActionDomain<ACT_DOM>, ids: IDS, routeData: DATA): this;
     /** Append per-action handlers from a cases map (accumulates alongside existing). */
     addForDomainActionCases<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>, cases: {
-        [ID in keyof FOR_DOM["actions"] & string]?: DATA;
+        [ID in keyof FOR_DOM["actionSchema"] & string]?: DATA;
     }): this;
     /** Append a handler directly by its raw match key (used when the key is known ahead of time). */
     addForKey(key: TMatchHandlerKey, routeData: DATA): this;