@nice-code/action 0.2.1 → 0.2.2

package/build/index.js

@@ -143,7 +143,7 @@ class ActionBase {
     this.id = id;
     this.domain = _domain.domain;
     this.allDomains = _domain.allDomains;
-    this.schema = _domain.actions[id];
+    this.schema = _domain.actionSchema[id];
   }
   toJsonObject() {
     return {
@@ -251,8 +251,9 @@ var EActionPayloadType;
 ((EActionPayloadType2) => {
   EActionPayloadType2["request"] = "request";
   EActionPayloadType2["progress"] = "progress";
-  EActionPayloadType2["stream"] = "stream";
   EActionPayloadType2["result"] = "result";
+  EActionPayloadType2["stream"] = "stream";
+  EActionPayloadType2["push"] = "push";
 })(EActionPayloadType ||= {});
 var EActionProgressType;
 ((EActionProgressType2) => {
@@ -572,7 +573,7 @@ class RunningAction {
     return this._completeWithResult(result);
   }
 }
-// ../nice-error/build/index.js
+// ../../node_modules/.bun/@nice-code+error@0.1.3+7524df1edfed9f02/node_modules/@nice-code/error/build/index.js
 var ACCEPTED = 202;
 var BAD_GATEWAY = 502;
 var BAD_REQUEST = 400;
@@ -3257,7 +3258,7 @@ var EErrId_NiceAction;
   EErrId_NiceAction2["hydration_action_state_mismatch"] = "hydration_action_state_mismatch";
   EErrId_NiceAction2["hydration_action_id_not_found"] = "hydration_action_id_not_found";
   EErrId_NiceAction2["no_action_execution_handler"] = "no_action_execution_handler";
-  EErrId_NiceAction2["wire_action_not_primed_or_response"] = "wire_action_not_primed_or_response";
+  EErrId_NiceAction2["wire_action_not_payload"] = "wire_action_not_payload";
   EErrId_NiceAction2["wire_not_action_data"] = "wire_not_action_data";
   EErrId_NiceAction2["client_runtime_already_registered"] = "client_runtime_already_registered";
   EErrId_NiceAction2["client_runtime_not_registered"] = "client_runtime_not_registered";
@@ -3295,11 +3296,11 @@ var err_nice_action = err_nice.createChildDomain({
     ["no_action_execution_handler" /* no_action_execution_handler */]: err({
       message: ({ domain, actionId, specifiedClient }) => `${specifiedClient ? ` The targeted client runtime [${specifiedClient.stringId}] has no` : "No"} action handler registered for "${actionId}" in domain "${domain}".`
     }),
-    ["wire_action_not_primed_or_response" /* wire_action_not_primed_or_response */]: err({
-      message: ({ domain, actionId, actionState }) => `Cannot handle wire for action "${actionId}" in domain "${domain}": expected action type of "primed" or "resolved", got "${actionState}".`
+    ["wire_action_not_payload" /* wire_action_not_payload */]: err({
+      message: ({ domain, actionId, actionState }) => `Cannot handle wire for action "${actionId}" in domain "${domain}": expected action form of "${"data" /* data */}" and type of "${"request" /* request */}", "${"progress" /* progress */}" or "${"result" /* result */}", got "${actionState}".`
     }),
     ["wire_not_action_data" /* wire_not_action_data */]: err({
-      message: () => `Cannot handle wire for action: expected an object with a "domain" property of type string and a "type" property of "primed" or "resolved".`
+      message: () => `Cannot handle wire for action: expected an object with a "domain" property of type string, a "form" property of "${"data" /* data */}" and a "type" property of "${"request" /* request */}", "${"progress" /* progress */}" or "${"result" /* result */}".`
     }),
     ["client_runtime_already_registered" /* client_runtime_already_registered */]: err({
       message: ({ context, client }) => `Environment is already registered${context?.domain ? ` on domain "${context.domain}"` : ""} for client [${client.stringId}]. Each client specifier (exact match on all properties) may only be registered once.`
@@ -3348,22 +3349,17 @@ var isAction_Core_JsonObject = (obj) => {
 
 // src/utils/isActionPayload_Progress_JsonObject.ts
 var isActionPayload_Progress_JsonObject = (obj) => {
-  return isAction_Base_JsonObject(obj) && "input" in obj && obj.type === "progress" /* progress */;
+  return isAction_Base_JsonObject(obj) && "progress" in obj && obj.form === "data" /* data */ && obj.type === "progress" /* progress */;
 };
 
 // src/utils/isActionPayload_Request_JsonObject.ts
 var isActionPayload_Request_JsonObject = (obj) => {
-  return isAction_Base_JsonObject(obj) && "input" in obj && obj.type === "request" /* request */;
+  return isAction_Base_JsonObject(obj) && "input" in obj && obj.form === "data" /* data */ && obj.type === "request" /* request */;
 };
 
 // src/utils/isActionPayload_Result_JsonObject.ts
 var isActionPayload_Result_JsonObject = (obj) => {
-  if (!isAction_Base_JsonObject(obj))
-    return false;
-  if (obj.type !== "result" /* result */)
-    return false;
-  const result = obj.result;
-  return result != null && typeof result === "object" && typeof result.ok === "boolean" && (("output" in result) || ("error" in result));
+  return isAction_Base_JsonObject(obj) && obj.result != null && obj.form === "data" /* data */ && obj.type === "result" /* result */;
 };
 
 // src/utils/isActionPayload_Any_JsonObject.ts
@@ -3392,12 +3388,12 @@ function isAction_Any_Instance(value) {
 class ActionDomainBase {
   domain;
   allDomains;
-  actions;
+  actionSchema;
   _listeners = [];
   constructor(definition) {
     this.domain = definition.domain;
     this.allDomains = definition.allDomains;
-    this.actions = definition.actions;
+    this.actionSchema = definition.actionSchema;
   }
   addActionListener(listener) {
     this._listeners.push(listener);
@@ -3410,11 +3406,13 @@ class ActionDomainBase {
 // src/ActionDefinition/Domain/ActionDomain.ts
 class ActionDomain extends ActionDomainBase {
   _rootDomain;
+  _actionMap;
   constructor(definition, {
     rootDomain
   }) {
     super(definition);
     this._rootDomain = rootDomain;
+    this._actionMap = this.createActionMap();
   }
   get rootDomain() {
     return this._rootDomain;
@@ -3428,13 +3426,19 @@ class ActionDomain extends ActionDomainBase {
       });
     }
     return new ActionDomain({
-      allDomains: [subDomainDef.domain, ...this.allDomains],
+      allDomains: [...this.allDomains, subDomainDef.domain],
       domain: subDomainDef.domain,
-      actions: subDomainDef.actions
+      actionSchema: subDomainDef.actions
     }, { rootDomain: this._rootDomain });
   }
-  action(id) {
-    const actionSchema = this.actions[id];
+  get action() {
+    return this._actionMap;
+  }
+  actionsMap() {
+    return this._actionMap;
+  }
+  actionForId(id) {
+    const actionSchema = this.actionSchema[id];
     if (!actionSchema) {
       throw err_nice_action.fromId("action_id_not_in_domain" /* action_id_not_in_domain */, {
         domain: this.domain,
@@ -3460,7 +3464,7 @@ class ActionDomain extends ActionDomainBase {
   isDomainAction(action) {
     return isAction_Any_Instance(action) && action.domain === this.domain;
   }
-  hydrateRequest(serialized) {
+  hydrateRequestPayload(serialized) {
     if (serialized.type !== "request" /* request */) {
       throw err_nice_action.fromId("hydration_action_state_mismatch" /* hydration_action_state_mismatch */, {
         expected: "request" /* request */,
@@ -3474,7 +3478,7 @@ class ActionDomain extends ActionDomainBase {
       });
     }
     const id = serialized.id;
-    if (!this.actions[id]) {
+    if (!this.actionSchema[id]) {
       throw err_nice_action.fromId("hydration_action_id_not_found" /* hydration_action_id_not_found */, {
         domain: this.domain,
         actionId: serialized.id
@@ -3499,7 +3503,7 @@ class ActionDomain extends ActionDomainBase {
       });
     }
     const id = serialized.id;
-    if (!this.actions[id]) {
+    if (!this.actionSchema[id]) {
       throw err_nice_action.fromId("hydration_action_id_not_found" /* hydration_action_id_not_found */, {
         domain: this.domain,
         actionId: serialized.id
@@ -3514,13 +3518,13 @@ class ActionDomain extends ActionDomainBase {
     assertIsActionJson(actionJson);
     if (actionJson.form === "data" /* data */) {
       if (actionJson.type === "request" /* request */) {
-        return this.hydrateRequest(actionJson);
+        return this.hydrateRequestPayload(actionJson);
       }
       if (actionJson.type === "result" /* result */) {
         return this.hydrateResultPayload(actionJson);
       }
     }
-    return this.action(actionJson.id);
+    return this.actionForId(actionJson.id);
   }
   async runAction(request, options) {
     const allListeners = [
@@ -3532,6 +3536,13 @@ class ActionDomain extends ActionDomainBase {
       listeners: allListeners
     });
   }
+  createActionMap() {
+    const map = {};
+    for (const id in this.actionSchema) {
+      map[id] = new ActionCore(this, id);
+    }
+    return map;
+  }
 }
 // src/ActionRuntime/ActionRuntimeManager.ts
 class ActionRuntimeManager {
@@ -3563,7 +3574,7 @@ class ActionRuntimeManager {
       if (runtime2 == null) {
         return;
       }
-      const handler = runtime2.getHandlerForAction(action, options);
+      const handler = runtime2._getHandlerForAction(action, options);
       if (handler != null) {
         return { handler, runtime: runtime2 };
       }
@@ -3576,7 +3587,7 @@ class ActionRuntimeManager {
       }
     }
     for (const runtime2 of this._runtimes.values()) {
-      const handler = runtime2.getHandlerForAction(action);
+      const handler = runtime2._getHandlerForAction(action);
       if (handler) {
         return { handler, runtime: runtime2 };
       }
@@ -3644,7 +3655,7 @@ class ActionRootDomain extends ActionDomainBase {
     super({
       domain: domainId,
       allDomains: [domainId],
-      actions: {}
+      actionSchema: {}
     });
     this.domainDefinition = domainDefinition;
     this._actionRuntimeManager = new ActionRuntimeManager({ domain: domainId });
@@ -3658,9 +3669,9 @@ class ActionRootDomain extends ActionDomainBase {
       });
     }
     return new ActionDomain({
-      allDomains: [subDomainDef.domain, ...this.allDomains],
+      allDomains: [...this.allDomains, subDomainDef.domain],
       domain: subDomainDef.domain,
-      actions: subDomainDef.actions
+      actionSchema: subDomainDef.actions
     }, { rootDomain: this });
   }
   addActionRuntime(runtime2) {
@@ -3670,11 +3681,11 @@ class ActionRootDomain extends ActionDomainBase {
   getRuntime(clientSpecifier) {
     return this._actionRuntimeManager.getBestRuntimeForSpecifier(clientSpecifier);
   }
-  async _runAction(primed, options) {
-    const { handler, runtime: runtime2 } = this._actionRuntimeManager.getRuntimeAndHandlerForActionOrThrow(primed, options);
-    primed.context._setOriginClient(runtime2.clientSpecifier);
+  async _runAction(actionPayload, options) {
+    const { handler, runtime: runtime2 } = this._actionRuntimeManager.getRuntimeAndHandlerForActionOrThrow(actionPayload, options);
+    actionPayload.context._setOriginClient(runtime2.clientSpecifier);
     const allListeners = [...this._listeners, ...options?.listeners ?? []];
-    const runningAction = await handler.handleActionRequest(primed, {
+    const runningAction = await handler.handleActionRequest(actionPayload, {
       targetLocalRuntime: runtime2
     });
     runningAction.addUpdateListeners(allListeners);
@@ -3685,7 +3696,7 @@ class ActionRootDomain extends ActionDomainBase {
 var createActionRootDomain = (definition) => {
   return new ActionRootDomain(definition);
 };
-// ../common-errors/build/index.js
+// ../../node_modules/.bun/@nice-code+common-errors@0.1.3+51eba3db27e14993/node_modules/@nice-code/common-errors/build/index.js
 var ACCEPTED2 = 202;
 var BAD_GATEWAY2 = 502;
 var BAD_REQUEST2 = 400;
@@ -6586,7 +6597,7 @@ class ActionRuntime {
   resolveIncomingActionPayload(json) {
     if (json.type === "request" /* request */) {
       this.handleActionPayloadWire(json).catch((err3) => {
-        console.error(`[ActionRuntime] Incoming primed action [${json.domain}:${json.id}] unhandled:`, err3);
+        console.error(`[ActionRuntime] Incoming action [${json.domain}:${json.id}:${json.form}:${json.type}] unhandled:`, err3);
       });
       return;
     }
@@ -6595,10 +6606,8 @@ class ActionRuntime {
   async handleActionPayloadWire(wire) {
     let action;
     if (isActionPayload_Any_JsonObject(wire)) {
-      const domain = this.actionRouter.domainManager.getActionDomain(wire);
-      if (domain) {
-        action = domain.hydrateAnyAction(wire);
-      }
+      const domain = this.actionRouter.domainManager.getActionDomainOrThrow(wire);
+      action = domain.hydrateAnyAction(wire);
     }
     if (action == null) {
       throw err_nice_action.fromId("wire_not_action_data" /* wire_not_action_data */);
@@ -6619,7 +6628,7 @@ class ActionRuntime {
       label: `Handling incoming action payloads of type "${action.type}"`
     });
   }
-  getHandlerForAction(action, options) {
+  _getHandlerForAction(action, options) {
     const handlers = this.actionRouter.getRouteDataEntriesForAction(action);
     const targetExternalClient = options?.targetExternalClient;
     const possibleHandlers = handlers.filter((handler2) => {
@@ -6658,7 +6667,7 @@ class ActionRuntime {
     return handler;
   }
   getHandlerForActionOrThrow(action, options) {
-    const handler = this.getHandlerForAction(action, options);
+    const handler = this._getHandlerForAction(action, options);
     if (handler == null) {
       throw err_nice_action.fromId("no_action_execution_handler" /* no_action_execution_handler */, {
         actionId: action.id,
@@ -7196,9 +7205,9 @@ class TransportWebSocket extends Transport {
     };
     ws.addEventListener("message", (event) => {
       if (typeof event.data === "string") {
-        const actionJson = wsData.formatMessage?.incoming?.(event.data) ?? this._parseActionMessage(event.data);
-        if (actionJson != null) {
-          this.resolvers.onIncomingActionDataJson(actionJson);
+        const rawJson = wsData.formatMessage?.incoming?.(event.data) ?? this._parseActionMessage(event.data);
+        if (rawJson != null && isActionPayload_Any_JsonObject(rawJson)) {
+          this.resolvers.onIncomingActionDataJson(rawJson);
         }
       }
     });
@@ -7426,7 +7435,7 @@ class ActionLocalHandler extends ActionHandler {
   async handlePayloadWireOrThrow(wire, config) {
     const hydratedAction = this.actionRouter.domainManager.hydrateActionPayload(wire);
     if (!(hydratedAction instanceof ActionPayload_Request)) {
-      throw err_nice_action.fromId("wire_action_not_primed_or_response" /* wire_action_not_primed_or_response */, {
+      throw err_nice_action.fromId("wire_action_not_payload" /* wire_action_not_payload */, {
         domain: hydratedAction.domain,
         actionId: hydratedAction.id,
         actionState: hydratedAction.type ?? hydratedAction.form

package/build/react-query/index.js

@@ -3099,7 +3099,15 @@ function useMutation(options, queryClient) {
   }
   return { ...result, mutate, mutateAsync: result.mutate };
 }
-// src/react-query/index.ts
+// src/react-query/hooks/useActionMutation.ts
+function useActionMutation(action, options) {
+  const mutationOptions2 = options ?? {};
+  return useMutation({
+    mutationFn: (input) => action.request(input).runToOutput(),
+    ...mutationOptions2
+  });
+}
+// src/react-query/hooks/useActionQuery.ts
 function niceActionQueryKey(action, input) {
   if (input === undefined) {
     return ["nice-action", action.domain, action.allDomains, action.id];
@@ -3115,15 +3123,8 @@ function useNiceQuery(action, input, options) {
     ...queryOptions2
   });
 }
-function useNiceMutation(action, options) {
-  const mutationOptions2 = options ?? {};
-  return useMutation({
-    mutationFn: (input) => action.request(input).runToOutput(),
-    ...mutationOptions2
-  });
-}
 export {
   useNiceQuery,
-  useNiceMutation,
+  useActionMutation,
   niceActionQueryKey
 };

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

@@ -12,26 +12,26 @@ import type { ActionPayload_Result } from "./Payload/ActionPayload_Result";
  * Distributes a union ID into a proper discriminated union of ActionPayload_Request instances,
  * so that narrowing on `.id` also narrows `.input`.
  */
-export type TDistributeActionPayload_Request<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string> = ID extends keyof DOM["actions"] & string ? ActionPayload_Request<DOM, ID> : never;
+export type TDistributeActionPayload_Request<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string> = ID extends keyof DOM["actionSchema"] & string ? ActionPayload_Request<DOM, ID> : never;
 /**
  * Distributes a union ID into a proper discriminated union of ActionPayload_Result instances,
  * so that narrowing on `.id` also narrows `.result`.
  */
-export type TDistributeActionPayload_Result<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string> = ID extends keyof DOM["actions"] & string ? ActionPayload_Result<DOM, ID> : never;
-export type TAction_Any_Instance<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = ActionCore<DOM, ID> | TActionPayload_Any_Instance<DOM, ID> | ActionContext<DOM, ID>;
+export type TDistributeActionPayload_Result<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string> = ID extends keyof DOM["actionSchema"] & string ? ActionPayload_Result<DOM, ID> : never;
+export type TAction_Any_Instance<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = ActionCore<DOM, ID> | TActionPayload_Any_Instance<DOM, ID> | ActionContext<DOM, ID>;
 /**
  *
  *  COMBINED JSON TYPES
  *
  */
-export type TAction_Any_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = IActionCore_JsonObject<DOM, ID> | TActionPayload_Any_JsonObject<DOM, ID> | IActionContext_JsonObject<DOM, ID>;
+export type TAction_Any_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = IActionCore_JsonObject<DOM, ID> | TActionPayload_Any_JsonObject<DOM, ID> | IActionContext_JsonObject<DOM, ID>;
 /**
  *
  *  UTILITY TYPES
  *
  */
 export type TDistributedDomainActions<DOM extends IActionDomain, ACT extends IActionBase<any, DOM, any>> = {
-    [ID in keyof DOM["actions"] & string]: TNarrowActionType<DOM, ACT, ID>;
-}[keyof DOM["actions"] & string];
-export type TNarrowActionType<DOM extends IActionDomain, ACT extends IActionBase<any, DOM, any>, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = ACT extends ActionPayload_Result<any> ? ActionPayload_Result<DOM, ID> : ACT extends ActionPayload_Request<any> ? ActionPayload_Request<DOM, ID> : ACT extends ActionPayload_Progress<any> ? ActionPayload_Progress<DOM, ID> : ACT extends ActionCore<any> ? ActionCore<DOM, ID> : never;
-export type TNarrowActionJsonTypeToActionInstanceType<DOM extends IActionDomain, ACT extends TAction_Any_JsonObject<DOM>, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = ACT extends IActionPayload_Request_JsonObject<any> ? ActionPayload_Request<DOM, ID> : ACT extends IActionPayload_Result_JsonObject<any> ? ActionPayload_Result<DOM, ID> : ACT extends IActionPayload_Progress_JsonObject<any> ? ActionPayload_Progress<DOM, ID> : ACT extends IActionCore_JsonObject<any> ? ActionCore<DOM, ID> : never;
+    [ID in keyof DOM["actionSchema"] & string]: TNarrowActionType<DOM, ACT, ID>;
+}[keyof DOM["actionSchema"] & string];
+export type TNarrowActionType<DOM extends IActionDomain, ACT extends IActionBase<any, DOM, any>, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = ACT extends ActionPayload_Result<any> ? ActionPayload_Result<DOM, ID> : ACT extends ActionPayload_Request<any> ? ActionPayload_Request<DOM, ID> : ACT extends ActionPayload_Progress<any> ? ActionPayload_Progress<DOM, ID> : ACT extends ActionCore<any> ? ActionCore<DOM, ID> : never;
+export type TNarrowActionJsonTypeToActionInstanceType<DOM extends IActionDomain, ACT extends TAction_Any_JsonObject<DOM>, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = ACT extends IActionPayload_Request_JsonObject<any> ? ActionPayload_Request<DOM, ID> : ACT extends IActionPayload_Result_JsonObject<any> ? ActionPayload_Result<DOM, ID> : ACT extends IActionPayload_Progress_JsonObject<any> ? ActionPayload_Progress<DOM, ID> : ACT extends IActionCore_JsonObject<any> ? ActionCore<DOM, ID> : never;

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

@@ -1,13 +1,13 @@
 import type { ActionDomain } from "../Domain/ActionDomain";
 import type { IActionDomain } from "../Domain/ActionDomain.types";
 import type { EActionForm, IActionBase, IActionBase_JsonObject } from "./ActionBase.types";
-export declare abstract class ActionBase<FORM extends EActionForm, DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> implements IActionBase<FORM, DOM, ID> {
+export declare abstract class ActionBase<FORM extends EActionForm, DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> implements IActionBase<FORM, DOM, ID> {
     readonly form: FORM;
     readonly _domain: ActionDomain<DOM>;
     readonly id: ID;
     readonly domain: DOM["domain"];
     readonly allDomains: DOM["allDomains"];
-    readonly schema: DOM["actions"][ID];
+    readonly schema: DOM["actionSchema"][ID];
     constructor(form: FORM, _domain: ActionDomain<DOM>, id: ID);
     protected toJsonObject(): IActionBase_JsonObject<FORM, DOM, ID>;
     protected toJsonString(): string;

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

@@ -7,16 +7,16 @@ export declare enum EActionForm {
 }
 export interface INiceActionIdAndDomain<DOM extends IActionDomain = IActionDomain> {
     domain: DOM["domain"];
-    id: keyof DOM["actions"] & string;
+    id: keyof DOM["actionSchema"] & string;
 }
-export interface IActionBase<FORM extends EActionForm, DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends INiceActionIdAndDomain<DOM> {
+export interface IActionBase<FORM extends EActionForm, DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends INiceActionIdAndDomain<DOM> {
     id: ID;
     form: FORM;
     _domain: ActionDomain<DOM>;
     allDomains: DOM["allDomains"];
-    schema: DOM["actions"][ID];
+    schema: DOM["actionSchema"][ID];
 }
-export interface IActionBase_JsonObject<FORM extends EActionForm = EActionForm, DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> {
+export interface IActionBase_JsonObject<FORM extends EActionForm = EActionForm, DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> {
     form: FORM;
     domain: DOM["domain"];
     allDomains: DOM["allDomains"];

package/build/types/ActionDefinition/Action/Context/ActionContext.d.ts

@@ -4,7 +4,7 @@ import type { IActionDomain, TInferInputFromSchema, TInferOutputFromSchema } fro
 import { ActionBase } from "../ActionBase";
 import { EActionForm } from "../ActionBase.types";
 import type { IActionContext, IActionContext_Data, IActionContext_Data_JsonObject, IActionContext_JsonObject, IActionRouteItem } from "./ActionContext.types";
-export declare class ActionContext<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends ActionBase<EActionForm.context, DOM, ID> implements IActionContext<DOM, ID> {
+export declare class ActionContext<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends ActionBase<EActionForm.context, DOM, ID> implements IActionContext<DOM, ID> {
     readonly _domain: ActionDomain<DOM>;
     readonly form = EActionForm.context;
     readonly _routing: IActionRouteItem[];
@@ -18,8 +18,8 @@ export declare class ActionContext<DOM extends IActionDomain, ID extends keyof D
     toJsonObject(): IActionContext_JsonObject<DOM, ID>;
     get routing(): IActionRouteItem[];
     addRouteItem(item: IActionRouteItem): void;
-    deserializeInput(serialized: TInferInputFromSchema<DOM["actions"][ID]>["SerdeInput"]): TInferInputFromSchema<DOM["actions"][ID]>["Input"];
-    serializeInput(raw: TInferInputFromSchema<DOM["actions"][ID]>["Input"]): TInferInputFromSchema<DOM["actions"][ID]>["SerdeInput"];
-    validateInput(input: unknown): TInferInputFromSchema<DOM["actions"][ID]>["Input"];
-    validateOutput(output: unknown): TInferOutputFromSchema<DOM["actions"][ID]>["Output"];
+    deserializeInput(serialized: TInferInputFromSchema<DOM["actionSchema"][ID]>["SerdeInput"]): TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"];
+    serializeInput(raw: TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"]): TInferInputFromSchema<DOM["actionSchema"][ID]>["SerdeInput"];
+    validateInput(input: unknown): TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"];
+    validateOutput(output: unknown): TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"];
 }

package/build/types/ActionDefinition/Action/Context/ActionContext.types.d.ts

@@ -13,7 +13,7 @@ export interface IActionContext_Data {
     routing: IActionRouteItem[];
     originClient: ActionClientSpecifier;
 }
-export interface IActionContext<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends IActionBase<EActionForm.context, DOM, ID>, IActionContext_Data {
+export interface IActionContext<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IActionBase<EActionForm.context, DOM, ID>, IActionContext_Data {
 }
 /**
  *
@@ -31,5 +31,5 @@ export interface IActionContext_Data_JsonObject {
     routing: IActionRouteItem_JsonObject[];
     originClient: IActionClientSpecifier;
 }
-export interface IActionContext_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends IActionBase_JsonObject<EActionForm.context, DOM, ID>, IActionContext_Data_JsonObject {
+export interface IActionContext_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IActionBase_JsonObject<EActionForm.context, DOM, ID>, IActionContext_Data_JsonObject {
 }

package/build/types/ActionDefinition/Action/Core/ActionCore.d.ts

@@ -5,15 +5,15 @@ import { ActionBase } from "../ActionBase";
 import { EActionForm, type IActionBase, type IActionBase_JsonObject } from "../ActionBase.types";
 import { ActionPayload_Request } from "../Payload/ActionPayload_Request";
 import type { IActionCore } from "./ActionCore.types";
-export declare class ActionCore<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends ActionBase<EActionForm.core, DOM, ID> implements IActionCore<DOM, ID> {
+export declare class ActionCore<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends ActionBase<EActionForm.core, DOM, ID> implements IActionCore<DOM, ID> {
     readonly _domain: ActionDomain<DOM>;
     readonly form = EActionForm.core;
     constructor(_domain: ActionDomain<DOM>, id: ID);
     is<ACT extends IActionBase<any, any, any>>(action: ACT | unknown | null | undefined): action is TNarrowActionType<DOM, ACT, ID>;
     toJsonObject(): IActionBase_JsonObject<EActionForm.core, DOM, ID>;
-    request(input: TInferInputFromSchema<DOM["actions"][ID]>["Input"]): ActionPayload_Request<DOM, ID>;
-    deserializeInput(serialized: TInferInputFromSchema<DOM["actions"][ID]>["SerdeInput"]): TInferInputFromSchema<DOM["actions"][ID]>["Input"];
-    serializeInput(raw: TInferInputFromSchema<DOM["actions"][ID]>["Input"]): TInferInputFromSchema<DOM["actions"][ID]>["SerdeInput"];
-    validateInput(input: unknown): TInferInputFromSchema<DOM["actions"][ID]>["Input"];
-    validateOutput(output: unknown): TInferOutputFromSchema<DOM["actions"][ID]>["Output"];
+    request(input: TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"]): ActionPayload_Request<DOM, ID>;
+    deserializeInput(serialized: TInferInputFromSchema<DOM["actionSchema"][ID]>["SerdeInput"]): TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"];
+    serializeInput(raw: TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"]): TInferInputFromSchema<DOM["actionSchema"][ID]>["SerdeInput"];
+    validateInput(input: unknown): TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"];
+    validateOutput(output: unknown): TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"];
 }

package/build/types/ActionDefinition/Action/Core/ActionCore.types.d.ts

@@ -1,8 +1,8 @@
 import type { IActionDomain } from "../../Domain/ActionDomain.types";
 import type { EActionForm, IActionBase } from "../ActionBase.types";
-export interface IActionCore<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends IActionBase<EActionForm.core, DOM, ID> {
+export interface IActionCore<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IActionBase<EActionForm.core, DOM, ID> {
 }
-export type IActionCore_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = {
+export type IActionCore_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = {
     form: EActionForm.core;
     domain: DOM["domain"];
     allDomains: DOM["allDomains"];

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

@@ -3,7 +3,7 @@ import { ActionBase } from "../ActionBase";
 import { EActionForm } from "../ActionBase.types";
 import type { ActionContext } from "../Context/ActionContext";
 import type { EActionPayloadType, IActionPayload_Base, IActionPayload_Base_JsonObject, IActionPayload_Data_Base } from "./ActionPayload.types";
-export declare abstract class ActionPayload<DT extends EActionPayloadType, DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends ActionBase<EActionForm.data, DOM, ID> implements IActionPayload_Base<DT, DOM, ID> {
+export declare abstract class ActionPayload<DT extends EActionPayloadType, DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends ActionBase<EActionForm.data, DOM, ID> implements IActionPayload_Base<DT, DOM, ID> {
     readonly form: EActionForm.data;
     readonly type: DT;
     readonly context: ActionContext<DOM, ID>;

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

@@ -11,13 +11,14 @@ import type { ActionPayload_Result } from "./ActionPayload_Result";
 export declare enum EActionPayloadType {
     request = "request",
     progress = "progress",
+    result = "result",
     stream = "stream",
-    result = "result"
+    push = "push"
 }
 export interface IActionPayload_Data_Base {
     time: number;
 }
-export interface IActionPayload_Base<DT extends EActionPayloadType, DOM extends IActionDomain, ID extends keyof DOM["actions"] & string> extends IActionBase<EActionForm.data, DOM, ID>, IActionPayload_Data_Base {
+export interface IActionPayload_Base<DT extends EActionPayloadType, DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string> extends IActionBase<EActionForm.data, DOM, ID>, IActionPayload_Data_Base {
     readonly type: DT;
     readonly context: ActionContext<DOM, ID>;
 }
@@ -42,8 +43,8 @@ export type TActionResultOutcome<OUT, ERR> = {
     ok: false;
     error: ERR;
 };
-export interface IActionPayload_Result<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string> extends IActionPayload_Base<EActionPayloadType.result, DOM, ID> {
-    readonly result: TActionResultOutcome<TInferOutputFromSchema<DOM["actions"][ID]>["Output"], TInferActionError<DOM["actions"][ID]>>;
+export interface IActionPayload_Result<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string> extends IActionPayload_Base<EActionPayloadType.result, DOM, ID> {
+    readonly result: TActionResultOutcome<TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"], TInferActionError<DOM["actionSchema"][ID]>>;
 }
 /**
  *
@@ -68,7 +69,7 @@ export interface IActionProgress_Custom {
     data: any;
 }
 export type TActionProgress = IActionProgress_None | IActionProgress_Percentage | IActionProgress_Custom;
-export interface IActionPayload_Progress<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string> extends IActionPayload_Base<EActionPayloadType.progress, DOM, ID> {
+export interface IActionPayload_Progress<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string> extends IActionPayload_Base<EActionPayloadType.progress, DOM, ID> {
     readonly progress: TActionProgress;
 }
 /**
@@ -78,22 +79,22 @@ export interface IActionPayload_Progress<DOM extends IActionDomain, ID extends k
  *  [                   ]
  *
  */
-export interface IActionPayload_Base_JsonObject<DT extends EActionPayloadType, DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends IActionBase_JsonObject<EActionForm.data, DOM, ID> {
+export interface IActionPayload_Base_JsonObject<DT extends EActionPayloadType, DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IActionBase_JsonObject<EActionForm.data, DOM, ID> {
     type: DT;
     context: IActionContext_Data_JsonObject;
     time: number;
 }
-export interface IActionPayload_Request_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends IActionPayload_Base_JsonObject<EActionPayloadType.request, DOM, ID> {
+export interface IActionPayload_Request_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IActionPayload_Base_JsonObject<EActionPayloadType.request, DOM, ID> {
     type: EActionPayloadType.request;
-    input: TInferInputFromSchema<DOM["actions"][ID]>["SerdeInput"];
+    input: TInferInputFromSchema<DOM["actionSchema"][ID]>["SerdeInput"];
 }
-export interface IActionPayload_Progress_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends IActionPayload_Base_JsonObject<EActionPayloadType.progress, DOM, ID> {
+export interface IActionPayload_Progress_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IActionPayload_Base_JsonObject<EActionPayloadType.progress, DOM, ID> {
     type: EActionPayloadType.progress;
     progress: TActionProgress;
 }
-export interface IActionPayload_Result_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends IActionPayload_Base_JsonObject<EActionPayloadType.result, DOM, ID> {
+export interface IActionPayload_Result_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IActionPayload_Base_JsonObject<EActionPayloadType.result, DOM, ID> {
     type: EActionPayloadType.result;
-    result: TActionResultOutcome<TInferOutputFromSchema<DOM["actions"][ID]>["Output"], TInferActionError<DOM["actions"][ID]>>;
+    result: TActionResultOutcome<TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"], TInferActionError<DOM["actionSchema"][ID]>>;
 }
 /**
  *
@@ -102,5 +103,5 @@ export interface IActionPayload_Result_JsonObject<DOM extends IActionDomain = IA
  *  [                  ]
  *
  */
-export type TActionPayload_Any_Instance<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = ActionPayload_Request<DOM, ID> | ActionPayload_Result<DOM, ID> | ActionPayload_Progress<DOM, ID>;
-export type TActionPayload_Any_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = IActionPayload_Request_JsonObject<DOM, ID> | IActionPayload_Progress_JsonObject<DOM, ID> | IActionPayload_Result_JsonObject<DOM, ID>;
+export type TActionPayload_Any_Instance<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = ActionPayload_Request<DOM, ID> | ActionPayload_Result<DOM, ID> | ActionPayload_Progress<DOM, ID>;
+export type TActionPayload_Any_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = IActionPayload_Request_JsonObject<DOM, ID> | IActionPayload_Progress_JsonObject<DOM, ID> | IActionPayload_Result_JsonObject<DOM, ID>;

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

@@ -4,7 +4,7 @@ import { ActionPayload } from "./ActionPayload";
 import type { IActionPayload_Data_Base, IActionPayload_Progress, IActionPayload_Progress_JsonObject, TActionProgress } from "./ActionPayload.types";
 import { EActionPayloadType } from "./ActionPayload.types";
 import { ActionPayload_Request } from "./ActionPayload_Request";
-export declare class ActionPayload_Progress<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends ActionPayload<EActionPayloadType.progress, DOM, ID> implements IActionPayload_Progress<DOM, ID> {
+export declare class ActionPayload_Progress<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends ActionPayload<EActionPayloadType.progress, DOM, ID> implements IActionPayload_Progress<DOM, ID> {
     readonly progress: TActionProgress;
     constructor(params: {
         context: ActionContext<DOM, ID>;

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,29 +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 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["actions"] & string = keyof DOM["actions"] & string> = ID extends keyof DOM["actions"] & string ? TRunningActionUpdate<DOM, ID> : never;
-export type TDistributeRunningActionUpdateListener<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = (update: TDistributeRunningActionUpdate<DOM, ID>) => void;
-export interface IRunningActionUserMethods<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string> {
+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

@@ -10,8 +10,12 @@ 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<any>;
     });
@@ -19,11 +23,15 @@ export declare class ActionDomain<ACT_DOM extends IActionDomain = IActionDomain>
     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): TDistributeActionPayload_Request<ACT_DOM, ID>;
-    hydrateResultPayload<ID extends keyof ACT_DOM["actions"] & string, R extends IActionPayload_Result_JsonObject<ACT_DOM, ID>>(serialized: R): TDistributeActionPayload_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,10 +23,10 @@ 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];

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

@@ -1,14 +1,14 @@
 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: TDistributeRunningActionUpdateListener<ACT_DOM, keyof ACT_DOM["actions"] & string>): () => 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/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

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

package/build/types/errors/err_nice_action.d.ts

@@ -9,7 +9,7 @@ export declare enum EErrId_NiceAction {
     hydration_action_state_mismatch = "hydration_action_state_mismatch",
     hydration_action_id_not_found = "hydration_action_id_not_found",
     no_action_execution_handler = "no_action_execution_handler",
-    wire_action_not_primed_or_response = "wire_action_not_primed_or_response",
+    wire_action_not_payload = "wire_action_not_payload",
     wire_not_action_data = "wire_not_action_data",
     client_runtime_already_registered = "client_runtime_already_registered",
     client_runtime_not_registered = "client_runtime_not_registered",
@@ -55,7 +55,7 @@ export declare const err_nice_action: import("@nice-code/error").NiceErrorDomain
             actionId: string;
             specifiedClient?: ActionClientSpecifier;
         }, import("@nice-code/error").JSONSerializableValue>;
-        wire_action_not_primed_or_response: import("@nice-code/error").INiceErrorIdMetadata<{
+        wire_action_not_payload: import("@nice-code/error").INiceErrorIdMetadata<{
             domain: string;
             actionId: string;
             actionState: string | undefined;

package/build/types/react-query/hooks/useActionMutation.d.ts

@@ -0,0 +1,6 @@
+import { type UseMutationOptions, type UseMutationResult } from "@tanstack/react-query";
+import type { ActionCore } from "../../ActionDefinition/Action/Core/ActionCore";
+import type { IActionDomain, TInferInputFromSchema, TInferOutputFromSchema } from "../../ActionDefinition/Domain/ActionDomain.types";
+import type { TInferActionError } from "../../ActionDefinition/Schema/ActionSchema";
+export type TUseNiceMutationOptions<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string, SCH extends DOM["actionSchema"][ID] = DOM["actionSchema"][ID], TContext = unknown> = Omit<UseMutationOptions<TInferOutputFromSchema<SCH>["Output"], TInferActionError<SCH>, TInferInputFromSchema<SCH>["Input"], TContext>, "mutationFn">;
+export declare function useActionMutation<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string, SCH extends DOM["actionSchema"][ID], TContext = unknown>(action: ActionCore<DOM, ID>, options?: TUseNiceMutationOptions<DOM, ID, SCH, TContext>): UseMutationResult<TInferOutputFromSchema<SCH>["Output"], TInferActionError<SCH>, TInferInputFromSchema<SCH>["Input"], TContext>;

package/build/types/react-query/hooks/useActionQuery.d.ts

@@ -0,0 +1,15 @@
+import { type QueryKey, type UseQueryOptions, type UseQueryResult } from "@tanstack/react-query";
+import type { ActionCore } from "../../ActionDefinition/Action/Core/ActionCore";
+import type { IActionDomain, TInferInputFromSchema, TInferOutputFromSchema } from "../../ActionDefinition/Domain/ActionDomain.types";
+import type { TInferActionError } from "../../ActionDefinition/Schema/ActionSchema";
+export declare function niceActionQueryKey<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(action: ActionCore<DOM, ID>): readonly ["nice-action", DOM["domain"], DOM["allDomains"], ID];
+export declare function niceActionQueryKey<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(action: ActionCore<DOM, ID>, input: TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"]): readonly [
+    "nice-action",
+    DOM["domain"],
+    DOM["allDomains"],
+    ID,
+    TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"],
+    string | undefined
+];
+export type TUseNiceQueryOptions<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string, SCH extends DOM["actionSchema"][ID] = DOM["actionSchema"][ID], TSelect = TInferOutputFromSchema<SCH>["Output"]> = Omit<UseQueryOptions<TInferOutputFromSchema<SCH>["Output"], TInferActionError<SCH>, TSelect, QueryKey>, "queryKey" | "queryFn">;
+export declare function useNiceQuery<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string, SCH extends DOM["actionSchema"][ID], TSelect = TInferOutputFromSchema<SCH>["Output"]>(action: ActionCore<DOM, ID>, input: TInferInputFromSchema<SCH>["Input"] | null | undefined, options?: TUseNiceQueryOptions<DOM, ID, SCH, TSelect>): UseQueryResult<TSelect, TInferActionError<SCH>>;

package/build/types/react-query/index.d.ts

@@ -1,72 +1,2 @@
-import type { QueryKey, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from "@tanstack/react-query";
-import type { ActionCore } from "../ActionDefinition/Action/Core/ActionCore";
-import type { IActionDomain, TInferInputFromSchema, TInferOutputFromSchema } from "../ActionDefinition/Domain/ActionDomain.types";
-import type { TInferActionError } from "../ActionDefinition/Schema/ActionSchema";
-/**
- * Builds a stable TanStack Query key for a Nice Action.
- *
- * Overload 1 (no input) — returns a prefix key suitable for `queryClient.invalidateQueries`,
- * which will match every cached query for this action regardless of input.
- *
- * Overload 2 (with input) — returns the exact key used by `useNiceQuery` for the given input.
- * Use this when you need to read or invalidate a single cached result.
- *
- * @example
- * // Invalidate all cached results for an action
- * queryClient.invalidateQueries({ queryKey: niceActionQueryKey(domain.action("getUser")) });
- *
- * // Invalidate a specific cached result
- * queryClient.invalidateQueries({ queryKey: niceActionQueryKey(domain.action("getUser"), { userId: "123" }) });
- */
-export declare function niceActionQueryKey<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string>(action: ActionCore<DOM, ID>): readonly ["nice-action", DOM["domain"], DOM["allDomains"], ID];
-export declare function niceActionQueryKey<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string>(action: ActionCore<DOM, ID>, input: TInferInputFromSchema<DOM["actions"][ID]>["Input"]): readonly [
-    "nice-action",
-    DOM["domain"],
-    DOM["allDomains"],
-    ID,
-    TInferInputFromSchema<DOM["actions"][ID]>["Input"],
-    string | undefined
-];
-export type TUseNiceQueryOptions<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string, SCH extends DOM["actions"][ID] = DOM["actions"][ID], TSelect = TInferOutputFromSchema<SCH>["Output"]> = Omit<UseQueryOptions<TInferOutputFromSchema<SCH>["Output"], TInferActionError<SCH>, TSelect, QueryKey>, "queryKey" | "queryFn">;
-export type TUseNiceMutationOptions<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string, SCH extends DOM["actions"][ID] = DOM["actions"][ID], TContext = unknown> = Omit<UseMutationOptions<TInferOutputFromSchema<SCH>["Output"], TInferActionError<SCH>, TInferInputFromSchema<SCH>["Input"], TContext>, "mutationFn">;
-/**
- * Execute a Nice Action as a TanStack Query.
- *
- * Automatically constructs a stable query key from the action's domain, id, and input.
- * Passing `null` or `undefined` as `input` disables the query (sets `enabled: false`),
- * which allows conditional execution while respecting React's rules of hooks.
- *
- * The `tag` option targets a specific named handler registered on the runtime environment.
- *
- * Supports TanStack Query's `select` option with full type inference — if you pass a
- * `select` transformer, `data` will be typed as the transformer's return type.
- *
- * @example
- * const { data, isPending, error } = useNiceQuery(
- *   domain.action("getUser"),
- *   { userId: "123" },
- * );
- *
- * @example
- * // Conditionally enabled
- * const { data } = useNiceQuery(domain.action("getUser"), userId ? { userId } : null);
- */
-export declare function useNiceQuery<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string, SCH extends DOM["actions"][ID], TSelect = TInferOutputFromSchema<SCH>["Output"]>(action: ActionCore<DOM, ID>, input: TInferInputFromSchema<SCH>["Input"] | null | undefined, options?: TUseNiceQueryOptions<DOM, ID, SCH, TSelect>): UseQueryResult<TSelect, TInferActionError<SCH>>;
-/**
- * Execute a Nice Action as a TanStack Mutation.
- *
- * Ideal for actions that change server state — form submissions, updates, deletes, etc.
- * The input is provided at call time via `mutation.mutate(input)` or `mutation.mutateAsync(input)`.
- *
- * The `tag` option targets a specific named handler registered on the runtime environment.
- *
- * @example
- * const mutation = useNiceMutation(domain.action("createUser"));
- *
- * function handleSubmit(data: CreateUserInput) {
- *   mutation.mutate(data, {
- *     onSuccess: (user) => router.push(`/users/${user.id}`),
- *   });
- * }
- */
-export declare function useNiceMutation<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string, SCH extends DOM["actions"][ID], TContext = unknown>(action: ActionCore<DOM, ID>, options?: TUseNiceMutationOptions<DOM, ID, SCH, TContext>): UseMutationResult<TInferOutputFromSchema<SCH>["Output"], TInferActionError<SCH>, TInferInputFromSchema<SCH>["Input"], TContext>;
+export * from "./hooks/useActionMutation";
+export * from "./hooks/useActionQuery";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nice-code/action",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "private": false,
   "type": "module",
   "exports": {