@nice-code/action 0.1.2 → 0.2.0

package/build/types/ActionRuntime/Handler/ExternalClient/Transport/WebSocket/TransportWebSocket.types.d.ts

@@ -0,0 +1,13 @@
+import type { IActionPayload_Request_JsonObject, IActionPayload_Result_JsonObject } from "../../../../../ActionDefinition/Action/Payload/ActionPayload.types";
+import type { ETransportType, IActionTransportDef, IActionTransportInitialized, IActionTransportReadyData_Base, ITransportRouteActionParams } from "../Transport.types";
+export interface IActionTransportReadyData_Ws extends IActionTransportReadyData_Base {
+    formatMessage?: {
+        outgoing: (input: ITransportRouteActionParams) => string;
+        incoming?: (input: string) => IActionPayload_Result_JsonObject<any> | IActionPayload_Request_JsonObject<any> | undefined;
+    };
+    ws: WebSocket;
+}
+export interface IActionTransportInitialized_Ws extends IActionTransportInitialized<ITransportRouteActionParams, IActionTransportReadyData_Ws> {
+}
+export interface IActionTransportDef_Ws extends IActionTransportDef<ETransportType.ws, IActionTransportInitialized_Ws> {
+}

package/build/types/{ActionRuntimeEnvironment/ActionConnect → ActionRuntime/Handler/ExternalClient}/Transport/err_nice_transport.d.ts

@@ -1,7 +1,8 @@
+import type { ETransportType } from "./Transport.types";
 export declare enum EErrId_NiceTransport {
     timeout = "timeout",
     not_found = "not_found",
-    not_available = "not_available",
+    unsupported = "unsupported",
     initialization_failed = "initialization_failed",
     send_failed = "send_failed",
     invalid_action_response = "invalid_action_response"
@@ -15,18 +16,15 @@ export declare const err_nice_transport: import("@nice-code/error").NiceErrorDom
         }, import("@nice-code/error").JSONSerializableValue>;
         not_found: import("@nice-code/error").INiceErrorIdMetadata<{
             actionId: string;
-            routeKey?: string;
-            tag?: string;
         }, import("@nice-code/error").JSONSerializableValue>;
-        not_available: import("@nice-code/error").INiceErrorIdMetadata<{
-            transportCount: number;
+        unsupported: import("@nice-code/error").INiceErrorIdMetadata<{
+            transportTypes: ETransportType[];
         }, import("@nice-code/error").JSONSerializableValue>;
         initialization_failed: import("@nice-code/error").INiceErrorIdMetadata<{
             actionId: string;
-            routeKey?: string;
-            tag?: string;
         }, import("@nice-code/error").JSONSerializableValue>;
         send_failed: import("@nice-code/error").INiceErrorIdMetadata<{
+            actionState: string;
             actionId: string;
             httpStatusCode?: number;
             message?: string;

package/build/types/ActionRuntime/Handler/ExternalClient/Transport/helpers/addTransportStatusMetadata.d.ts

@@ -0,0 +1,2 @@
+import { type IActionTransportReadyData_Base, type TTransportStatusInfo, type TTransportStatusInfo_GetTransport_Output } from "../Transport.types";
+export declare function addTransportStatusMetadata<READY extends IActionTransportReadyData_Base>(transportStatus: TTransportStatusInfo_GetTransport_Output<READY>): TTransportStatusInfo<READY>;

package/build/types/ActionRuntime/Handler/ExternalClient/Transport/helpers/createUnsetTransportResolvers.d.ts

@@ -0,0 +1,2 @@
+import type { ETransportType, IActionTransportResolvers } from "../Transport.types";
+export declare const createUnsetTransportResolvers: (type: ETransportType) => IActionTransportResolvers;

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

@@ -0,0 +1,5 @@
+export declare const err_nice_external_client: import("@nice-code/error").NiceErrorDomain<{
+    domain: string;
+    allDomains: [string, string, "err_nice"];
+    schema: {};
+}>;

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

@@ -0,0 +1,55 @@
+import type { ActionCore } from "../../../ActionDefinition/Action/Core/ActionCore";
+import type { IActionRouteItemHandler } from "../../../ActionDefinition/Action/Payload/ActionPayload.types";
+import { ActionPayload_Request } from "../../../ActionDefinition/Action/Payload/ActionPayload_Request";
+import { RunningAction } from "../../../ActionDefinition/Action/RunningAction";
+import type { ActionDomain } from "../../../ActionDefinition/Domain/ActionDomain";
+import type { IActionDomain } from "../../../ActionDefinition/Domain/ActionDomain.types";
+import { ActionRouter } from "../../Routing/ActionRouter";
+import { ActionHandler } from "../ActionHandler";
+import { EActionHandlerType, type IActionHandler_Local, type IActionHandler_Local_Json, type IHandleActionOptions } from "../ActionHandler.types";
+import type { THandleActionExecutionFn } from "./ActionLocalHandler.types";
+export declare class ActionLocalHandler extends ActionHandler<EActionHandlerType.local> implements IActionHandler_Local {
+    readonly handlerType = EActionHandlerType.local;
+    readonly actionRouter: ActionRouter<THandleActionExecutionFn<any, any>>;
+    constructor();
+    /**
+     * Register a handler for all actions in a domain.
+     * Receives the full primed action — use `matchAction()` to narrow to a specific action id.
+     * Useful for forwarding all domain actions to a remote endpoint.
+     * Lower priority than `forAction`.
+     */
+    forDomain<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>, handler: THandleActionExecutionFn<FOR_DOM>): this;
+    /**
+     * Register a handler for a base action instance. Takes priority over domain-wide handlers.
+     * 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;
+    /**
+     * 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;
+    /**
+     * Register per-action handlers for a domain using a single map, without needing
+     * separate `forAction` calls. Unregistered action IDs are unaffected.
+     *
+     * @example
+     * ```ts
+     * handler.forDomainActionCases(userDomain, {
+     *   getUser:    (primed) => db.getUser(primed.input.userId),
+     *   deleteUser: (primed) => db.deleteUser(primed.input.userId),
+     * });
+     * ```
+     */
+    forDomainActionCases<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>, cases: {
+        [ID in keyof FOR_DOM["actions"] & 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>>;
+    private _handleRunningAction;
+    handlePayloadWireOrThrow(wire: unknown, config?: IHandleActionOptions): Promise<RunningAction<any, any>>;
+    toJsonObject(): IActionHandler_Local_Json;
+    toHandlerRouteItem(): IActionRouteItemHandler;
+}
+export declare const createLocalHandler: () => ActionLocalHandler;

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

@@ -0,0 +1,6 @@
+import type { MaybePromise } from "bun";
+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>;

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

@@ -0,0 +1,55 @@
+import type { INiceActionIdAndDomain } from "../../ActionDefinition/Action/ActionBase.types";
+import type { ActionCore } from "../../ActionDefinition/Action/Core/ActionCore";
+import type { ActionDomain } from "../../ActionDefinition/Domain/ActionDomain";
+import type { IActionDomain } from "../../ActionDefinition/Domain/ActionDomain.types";
+import { ActionDomainManager } from "../ActionDomainManager";
+import type { IHandleActionOptions } from "../Handler/ActionHandler.types";
+import { type IActionRouterContext, type TMatchHandlerKey } from "./ActionRouter.types";
+export declare class ActionRouter<DATA> {
+    readonly domainManager: ActionDomainManager;
+    private actionRouteData;
+    private _context;
+    constructor(context: IActionRouterContext);
+    /** Copy all routes from another router into this one, replacing any overlapping keys. */
+    mergeRouter(actionRouter: ActionRouter<DATA>): void;
+    addDomainsFromOther(actionRouter: ActionRouter<DATA>): void;
+    /** All FNs registered for an action, ID-specific entries first then domain wildcard. */
+    getRouteDataEntriesForAction(action: {
+        domain: string;
+        id: string;
+    }): DATA[];
+    /** First FN registered for an action (ID-specific beats domain wildcard). */
+    getRouteDataForAction(action: INiceActionIdAndDomain): DATA | undefined;
+    private throwNoHandlerForAction;
+    getRouteDataEntriesForActionOrThrow(action: INiceActionIdAndDomain, context: IHandleActionOptions): DATA[];
+    getRouteDataForActionOrThrow(action: INiceActionIdAndDomain, context: IHandleActionOptions): DATA;
+    /** All FNs stored under an exact match key. */
+    getForKey(key: TMatchHandlerKey): readonly DATA[];
+    /** Every match key that has at least one registered FN. */
+    getRegisteredKeys(): TMatchHandlerKey[];
+    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;
+    /** 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;
+    /** 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;
+    /** 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;
+    }): 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;
+    /** 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;
+    /** 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;
+    }): 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;
+    private _push;
+}

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

@@ -0,0 +1,20 @@
+import type { ActionRuntime } from "../ActionRuntime";
+import type { TActionHandler } from "../Handler/ActionHandler.types";
+/**
+ * Format: `dom[${domainName}]id[${actionId | "_"}]`
+ * The wildcard `_` matches any action ID within a domain.
+ */
+export type TMatchHandlerKey = `${"dom"}[${string}]id[${string | "_"}]`;
+export declare enum EActionRouterContextType {
+    runtime_to_handler = "runtime_to_handler",
+    handler_route = "handler_route"
+}
+export interface IActionRouterContext_HandlerRoute {
+    contextType: EActionRouterContextType.handler_route;
+    handler: TActionHandler;
+}
+export interface IActionRouterContext_RuntimeToHandler {
+    contextType: EActionRouterContextType.runtime_to_handler;
+    runtime: ActionRuntime;
+}
+export type IActionRouterContext = IActionRouterContext_HandlerRoute | IActionRouterContext_RuntimeToHandler;

package/build/types/ActionRuntime/test/helpers/new_action_test_data.d.ts

@@ -0,0 +1,301 @@
+import { ActionRuntime } from "../../ActionRuntime";
+import { type ActionExternalClientHandler } from "../../Handler/ExternalClient/ActionExternalClientHandler";
+import type { IActionTransportDef_Custom } from "../../Handler/ExternalClient/Transport/Custom/TransportCustom.types";
+import { type ActionLocalHandler } from "../../Handler/Local/ActionLocalHandler";
+export declare function _test_initializeCustomTransport(externalClientRuntime: ActionRuntime): IActionTransportDef_Custom["initialize"];
+export declare function _test_createActions(): {
+    domains: {
+        root: import("../../..").ActionRootDomain<import("../../..").IActionRootDomain<"test_root">>;
+        test_dom_user: import("../../..").ActionDomain<import("../../..").TActionDomainChildDef<import("../../..").IActionRootDomain<"test_root">, {
+            domain: string;
+            actions: {
+                sign_in: import("../../..").ActionSchema<[{
+                    username: string;
+                    password: string;
+                }] | [{
+                    username: string;
+                    password: string;
+                }, never], [{
+                    success: boolean;
+                }] | [{
+                    success: boolean;
+                }, any], readonly []>;
+            };
+        }>>;
+        test_dom_edit_doc: import("../../..").ActionDomain<import("../../..").TActionDomainChildDef<import("../../..").IActionRootDomain<"test_root">, {
+            domain: string;
+            actions: {
+                edit_doc: import("../../..").ActionSchema<[{
+                    docId: string;
+                    newContent: string;
+                }] | [{
+                    docId: string;
+                    newContent: string;
+                }, never], [{
+                    success: boolean;
+                }] | [{
+                    success: boolean;
+                }, any], readonly []>;
+                get_doc: import("../../..").ActionSchema<[{
+                    docId: string;
+                }] | [{
+                    docId: string;
+                }, never], [{
+                    content: string;
+                }] | [{
+                    content: string;
+                }, any], readonly []>;
+            };
+        }>>;
+        test_dom_push_doc: import("../../..").ActionDomain<import("../../..").TActionDomainChildDef<import("../../..").IActionRootDomain<"test_root">, {
+            domain: string;
+            actions: {
+                push_doc_update: import("../../..").ActionSchema<[{
+                    docId: string;
+                    updateContent: string;
+                }] | [{
+                    docId: string;
+                    updateContent: string;
+                }, never], [{
+                    updated: boolean;
+                }] | [{
+                    updated: boolean;
+                }, any], readonly []>;
+            };
+        }>>;
+    };
+    actions: {
+        action_user_sign_in: import("../../..").ActionCore<import("../../..").TActionDomainChildDef<import("../../..").IActionRootDomain<"test_root">, {
+            domain: string;
+            actions: {
+                sign_in: import("../../..").ActionSchema<[{
+                    username: string;
+                    password: string;
+                }] | [{
+                    username: string;
+                    password: string;
+                }, never], [{
+                    success: boolean;
+                }] | [{
+                    success: boolean;
+                }, any], readonly []>;
+            };
+        }>, "sign_in">;
+        action_edit_doc_edit: import("../../..").ActionCore<import("../../..").TActionDomainChildDef<import("../../..").IActionRootDomain<"test_root">, {
+            domain: string;
+            actions: {
+                edit_doc: import("../../..").ActionSchema<[{
+                    docId: string;
+                    newContent: string;
+                }] | [{
+                    docId: string;
+                    newContent: string;
+                }, never], [{
+                    success: boolean;
+                }] | [{
+                    success: boolean;
+                }, any], readonly []>;
+                get_doc: import("../../..").ActionSchema<[{
+                    docId: string;
+                }] | [{
+                    docId: string;
+                }, never], [{
+                    content: string;
+                }] | [{
+                    content: string;
+                }, any], readonly []>;
+            };
+        }>, "edit_doc">;
+        action_edit_doc_get: import("../../..").ActionCore<import("../../..").TActionDomainChildDef<import("../../..").IActionRootDomain<"test_root">, {
+            domain: string;
+            actions: {
+                edit_doc: import("../../..").ActionSchema<[{
+                    docId: string;
+                    newContent: string;
+                }] | [{
+                    docId: string;
+                    newContent: string;
+                }, never], [{
+                    success: boolean;
+                }] | [{
+                    success: boolean;
+                }, any], readonly []>;
+                get_doc: import("../../..").ActionSchema<[{
+                    docId: string;
+                }] | [{
+                    docId: string;
+                }, never], [{
+                    content: string;
+                }] | [{
+                    content: string;
+                }, any], readonly []>;
+            };
+        }>, "get_doc">;
+        action_push_doc_update: import("../../..").ActionCore<import("../../..").TActionDomainChildDef<import("../../..").IActionRootDomain<"test_root">, {
+            domain: string;
+            actions: {
+                push_doc_update: import("../../..").ActionSchema<[{
+                    docId: string;
+                    updateContent: string;
+                }] | [{
+                    docId: string;
+                    updateContent: string;
+                }, never], [{
+                    updated: boolean;
+                }] | [{
+                    updated: boolean;
+                }, any], readonly []>;
+            };
+        }>, "push_doc_update">;
+    };
+};
+export declare const _test_createTestActionRuntimeData: () => {
+    domains: {
+        root: import("../../..").ActionRootDomain<import("../../..").IActionRootDomain<"test_root">>;
+        test_dom_user: import("../../..").ActionDomain<import("../../..").TActionDomainChildDef<import("../../..").IActionRootDomain<"test_root">, {
+            domain: string;
+            actions: {
+                sign_in: import("../../..").ActionSchema<[{
+                    username: string;
+                    password: string;
+                }] | [{
+                    username: string;
+                    password: string;
+                }, never], [{
+                    success: boolean;
+                }] | [{
+                    success: boolean;
+                }, any], readonly []>;
+            };
+        }>>;
+        test_dom_edit_doc: import("../../..").ActionDomain<import("../../..").TActionDomainChildDef<import("../../..").IActionRootDomain<"test_root">, {
+            domain: string;
+            actions: {
+                edit_doc: import("../../..").ActionSchema<[{
+                    docId: string;
+                    newContent: string;
+                }] | [{
+                    docId: string;
+                    newContent: string;
+                }, never], [{
+                    success: boolean;
+                }] | [{
+                    success: boolean;
+                }, any], readonly []>;
+                get_doc: import("../../..").ActionSchema<[{
+                    docId: string;
+                }] | [{
+                    docId: string;
+                }, never], [{
+                    content: string;
+                }] | [{
+                    content: string;
+                }, any], readonly []>;
+            };
+        }>>;
+        test_dom_push_doc: import("../../..").ActionDomain<import("../../..").TActionDomainChildDef<import("../../..").IActionRootDomain<"test_root">, {
+            domain: string;
+            actions: {
+                push_doc_update: import("../../..").ActionSchema<[{
+                    docId: string;
+                    updateContent: string;
+                }] | [{
+                    docId: string;
+                    updateContent: string;
+                }, never], [{
+                    updated: boolean;
+                }] | [{
+                    updated: boolean;
+                }, any], readonly []>;
+            };
+        }>>;
+    };
+    actions: {
+        action_user_sign_in: import("../../..").ActionCore<import("../../..").TActionDomainChildDef<import("../../..").IActionRootDomain<"test_root">, {
+            domain: string;
+            actions: {
+                sign_in: import("../../..").ActionSchema<[{
+                    username: string;
+                    password: string;
+                }] | [{
+                    username: string;
+                    password: string;
+                }, never], [{
+                    success: boolean;
+                }] | [{
+                    success: boolean;
+                }, any], readonly []>;
+            };
+        }>, "sign_in">;
+        action_edit_doc_edit: import("../../..").ActionCore<import("../../..").TActionDomainChildDef<import("../../..").IActionRootDomain<"test_root">, {
+            domain: string;
+            actions: {
+                edit_doc: import("../../..").ActionSchema<[{
+                    docId: string;
+                    newContent: string;
+                }] | [{
+                    docId: string;
+                    newContent: string;
+                }, never], [{
+                    success: boolean;
+                }] | [{
+                    success: boolean;
+                }, any], readonly []>;
+                get_doc: import("../../..").ActionSchema<[{
+                    docId: string;
+                }] | [{
+                    docId: string;
+                }, never], [{
+                    content: string;
+                }] | [{
+                    content: string;
+                }, any], readonly []>;
+            };
+        }>, "edit_doc">;
+        action_edit_doc_get: import("../../..").ActionCore<import("../../..").TActionDomainChildDef<import("../../..").IActionRootDomain<"test_root">, {
+            domain: string;
+            actions: {
+                edit_doc: import("../../..").ActionSchema<[{
+                    docId: string;
+                    newContent: string;
+                }] | [{
+                    docId: string;
+                    newContent: string;
+                }, never], [{
+                    success: boolean;
+                }] | [{
+                    success: boolean;
+                }, any], readonly []>;
+                get_doc: import("../../..").ActionSchema<[{
+                    docId: string;
+                }] | [{
+                    docId: string;
+                }, never], [{
+                    content: string;
+                }] | [{
+                    content: string;
+                }, any], readonly []>;
+            };
+        }>, "get_doc">;
+        action_push_doc_update: import("../../..").ActionCore<import("../../..").TActionDomainChildDef<import("../../..").IActionRootDomain<"test_root">, {
+            domain: string;
+            actions: {
+                push_doc_update: import("../../..").ActionSchema<[{
+                    docId: string;
+                    updateContent: string;
+                }] | [{
+                    docId: string;
+                    updateContent: string;
+                }, never], [{
+                    updated: boolean;
+                }] | [{
+                    updated: boolean;
+                }, any], readonly []>;
+            };
+        }>, "push_doc_update">;
+    };
+    web_app_to_server_handler: ActionExternalClientHandler;
+    web_app_runtime: ActionRuntime;
+    server_runtime: ActionRuntime;
+    server_action_handler: ActionLocalHandler;
+};

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

@@ -1,5 +1,7 @@
-import type { EActionState } from "../NiceAction/NiceAction.enums";
+import type { IActionRuntimeManagerContext } from "../ActionRuntime/ActionRuntime.types";
+import type { ActionClientSpecifier, TClientSpecifierStringId } from "../ActionRuntime/Client/ActionClientSpecifier";
 export declare enum EErrId_NiceAction {
+    not_implemented = "not_implemented",
     action_id_not_in_domain = "action_id_not_in_domain",
     domain_already_exists_in_hierarchy = "domain_already_exists_in_hierarchy",
     domain_no_handler = "domain_no_handler",
@@ -9,8 +11,9 @@ export declare enum EErrId_NiceAction {
     no_action_execution_handler = "no_action_execution_handler",
     wire_action_not_primed_or_response = "wire_action_not_primed_or_response",
     wire_not_action_data = "wire_not_action_data",
-    action_tag_handler_not_found = "action_tag_handler_not_found",
-    environment_already_registered = "environment_already_registered",
+    client_runtime_already_registered = "client_runtime_already_registered",
+    client_runtime_not_registered = "client_runtime_not_registered",
+    no_client_runtimes_registered = "no_client_runtimes_registered",
     action_input_validation_failed = "action_input_validation_failed",
     action_input_validation_promise = "action_input_validation_promise",
     action_output_validation_failed = "action_output_validation_failed",
@@ -20,6 +23,9 @@ export declare const err_nice_action: import("@nice-code/error").NiceErrorDomain
     domain: string;
     allDomains: [string, "err_nice"];
     schema: {
+        not_implemented: import("@nice-code/error").INiceErrorIdMetadata<{
+            label: string;
+        }, import("@nice-code/error").JSONSerializableValue>;
         action_id_not_in_domain: import("@nice-code/error").INiceErrorIdMetadata<{
             domain: string;
             actionId: string;
@@ -37,8 +43,8 @@ export declare const err_nice_action: import("@nice-code/error").NiceErrorDomain
             received: string;
         }, import("@nice-code/error").JSONSerializableValue>;
         hydration_action_state_mismatch: import("@nice-code/error").INiceErrorIdMetadata<{
-            expected: EActionState;
-            received: EActionState;
+            expected: string;
+            received: string;
         }, import("@nice-code/error").JSONSerializableValue>;
         hydration_action_id_not_found: import("@nice-code/error").INiceErrorIdMetadata<{
             domain: string;
@@ -47,20 +53,24 @@ export declare const err_nice_action: import("@nice-code/error").NiceErrorDomain
         no_action_execution_handler: import("@nice-code/error").INiceErrorIdMetadata<{
             domain: string;
             actionId: string;
+            specifiedClient?: ActionClientSpecifier;
         }, import("@nice-code/error").JSONSerializableValue>;
         wire_action_not_primed_or_response: import("@nice-code/error").INiceErrorIdMetadata<{
             domain: string;
             actionId: string;
-            actionState: EActionState | undefined;
+            actionState: string | undefined;
         }, import("@nice-code/error").JSONSerializableValue>;
         wire_not_action_data: import("@nice-code/error").INiceErrorIdMetadata<any, import("@nice-code/error").JSONSerializableValue>;
-        action_tag_handler_not_found: import("@nice-code/error").INiceErrorIdMetadata<{
-            domain: string;
-            matchTag: string;
+        client_runtime_already_registered: import("@nice-code/error").INiceErrorIdMetadata<{
+            context?: IActionRuntimeManagerContext;
+            client: ActionClientSpecifier;
         }, import("@nice-code/error").JSONSerializableValue>;
-        environment_already_registered: import("@nice-code/error").INiceErrorIdMetadata<{
-            domain: string;
-            matchTag: string;
+        client_runtime_not_registered: import("@nice-code/error").INiceErrorIdMetadata<{
+            context?: IActionRuntimeManagerContext;
+            clientStringId: TClientSpecifierStringId;
+        }, import("@nice-code/error").JSONSerializableValue>;
+        no_client_runtimes_registered: import("@nice-code/error").INiceErrorIdMetadata<{
+            context?: IActionRuntimeManagerContext;
         }, import("@nice-code/error").JSONSerializableValue>;
         action_input_validation_failed: import("@nice-code/error").INiceErrorIdMetadata<{
             domain: string;