@nice-code/action 0.1.3 → 0.2.0

package/build/react-query/index.js

@@ -3100,25 +3100,25 @@ function useMutation(options, queryClient) {
   return { ...result, mutate, mutateAsync: result.mutate };
 }
 // src/react-query/index.ts
-function niceActionQueryKey(action, input, meta) {
+function niceActionQueryKey(action, input) {
   if (input === undefined) {
     return ["nice-action", action.domain, action.allDomains, action.id];
   }
-  return ["nice-action", action.domain, action.allDomains, action.id, input, meta?.tag];
+  return ["nice-action", action.domain, action.allDomains, action.id, input];
 }
 function useNiceQuery(action, input, options) {
-  const { tag, meta, enabled, ...queryOptions2 } = options ?? {};
+  const { enabled, ...queryOptions2 } = options ?? {};
   return useQuery({
-    queryKey: input != null ? niceActionQueryKey(action, input, { tag, meta }) : niceActionQueryKey(action),
-    queryFn: () => action.execute(input, { tag, meta }),
+    queryKey: input != null ? niceActionQueryKey(action, input) : niceActionQueryKey(action),
+    queryFn: () => action.request(input).runToOutput(),
     enabled: input != null && (enabled ?? true),
     ...queryOptions2
   });
 }
 function useNiceMutation(action, options) {
-  const { tag, meta, ...mutationOptions2 } = options ?? {};
+  const mutationOptions2 = options ?? {};
   return useMutation({
-    mutationFn: (input) => action.execute(input, { tag, meta }),
+    mutationFn: (input) => action.request(input).runToOutput(),
     ...mutationOptions2
   });
 }

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

@@ -0,0 +1,27 @@
+import type { IActionDomain } from "../Domain/ActionDomain.types";
+import type { IActionBase } from "./ActionBase.types";
+import type { ActionContext } from "./Context/ActionContext";
+import type { IActionContext_JsonObject } from "./Context/ActionContext.types";
+import type { ActionCore } from "./Core/ActionCore";
+import type { IActionCore_JsonObject } from "./Core/ActionCore.types";
+import type { IActionPayload_Progress_JsonObject, IActionPayload_Request_JsonObject, IActionPayload_Result_JsonObject, TActionPayload_Any_Instance, TActionPayload_Any_JsonObject } from "./Payload/ActionPayload.types";
+import type { ActionPayload_Progress } from "./Payload/ActionPayload_Progress";
+import type { ActionPayload_Request } from "./Payload/ActionPayload_Request";
+import type { ActionPayload_Result } from "./Payload/ActionPayload_Result";
+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>;
+/**
+ *
+ *  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>;
+/**
+ *
+ *  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;

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

@@ -0,0 +1,14 @@
+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> {
+    readonly form: FORM;
+    readonly _domain: ActionDomain<DOM>;
+    readonly id: ID;
+    readonly domain: DOM["domain"];
+    readonly allDomains: DOM["allDomains"];
+    readonly schema: DOM["actions"][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

@@ -0,0 +1,24 @@
+import type { ActionDomain } from "../Domain/ActionDomain";
+import type { IActionDomain } from "../Domain/ActionDomain.types";
+export declare enum EActionForm {
+    core = "core",
+    context = "context",
+    data = "data"
+}
+export interface INiceActionIdAndDomain<DOM extends IActionDomain = IActionDomain> {
+    domain: DOM["domain"];
+    id: keyof DOM["actions"] & string;
+}
+export interface IActionBase<FORM extends EActionForm, DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends INiceActionIdAndDomain<DOM> {
+    id: ID;
+    form: FORM;
+    _domain: ActionDomain<DOM>;
+    allDomains: DOM["allDomains"];
+    schema: DOM["actions"][ID];
+}
+export interface IActionBase_JsonObject<FORM extends EActionForm = EActionForm, DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> {
+    form: FORM;
+    domain: DOM["domain"];
+    allDomains: DOM["allDomains"];
+    id: ID;
+}

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

@@ -0,0 +1,26 @@
+import type { JSONSerializableValue } from "@nice-code/error";
+import type { ActionDomain } from "../../Domain/ActionDomain";
+import type { IActionDomain, TInferInputFromSchema, TInferOutputFromSchema } from "../../Domain/ActionDomain.types";
+import { ActionBase } from "../ActionBase";
+import { EActionForm } from "../ActionBase.types";
+import { ActionClientSpecifier } from "../../../ActionRuntime/Client/ActionClientSpecifier";
+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> {
+    readonly _domain: ActionDomain<DOM>;
+    readonly form = EActionForm.context;
+    readonly _routing: IActionRouteItem[];
+    readonly timeCreated: number;
+    readonly cuid: string;
+    originClient: ActionClientSpecifier;
+    constructor(_domain: ActionDomain<DOM>, id: ID, hydrationData: IActionContext_Data);
+    _setOriginClient(client: ActionClientSpecifier): void;
+    toJsonString(): string;
+    toContextDataJsonObject(): IActionContext_Data_JsonObject;
+    toJsonObject(): IActionContext_JsonObject<DOM, ID>;
+    get routing(): IActionRouteItem[];
+    addRouteItem(item: IActionRouteItem): void;
+    deserializeInput(serialized: JSONSerializableValue): TInferInputFromSchema<DOM["actions"][ID]>["Input"];
+    serializeInput(raw: TInferInputFromSchema<DOM["actions"][ID]>["Input"]): JSONSerializableValue;
+    validateInput(input: unknown): TInferInputFromSchema<DOM["actions"][ID]>["Input"];
+    validateOutput(output: unknown): TInferOutputFromSchema<DOM["actions"][ID]>["Output"];
+}

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

@@ -0,0 +1,35 @@
+import type { ActionClientSpecifier, IActionClientSpecifier } from "../../../ActionRuntime/Client/ActionClientSpecifier";
+import type { IActionDomain } from "../../Domain/ActionDomain.types";
+import type { EActionForm, IActionBase, IActionBase_JsonObject } from "../ActionBase.types";
+import type { IActionRouteItemHandler } from "../Payload/ActionPayload.types";
+export interface IActionRouteItem {
+    runtime: ActionClientSpecifier;
+    handler: IActionRouteItemHandler;
+    time: number;
+}
+export interface IActionContext_Data {
+    cuid: string;
+    timeCreated: number;
+    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 {
+}
+/**
+ *
+ *  JSON TYPES
+ *
+ */
+export interface IActionRouteItem_JsonObject {
+    runtime: IActionClientSpecifier;
+    handler: IActionRouteItemHandler;
+    time: number;
+}
+export interface IActionContext_Data_JsonObject {
+    cuid: string;
+    timeCreated: number;
+    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 {
+}

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

@@ -0,0 +1,20 @@
+import type { JSONSerializableValue } from "@nice-code/error";
+import type { ActionDomain } from "../../Domain/ActionDomain";
+import type { IActionDomain, TInferInputFromSchema, TInferOutputFromSchema } from "../../Domain/ActionDomain.types";
+import type { TNarrowActionType } from "../Action.combined.types";
+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> {
+    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: JSONSerializableValue): TInferInputFromSchema<DOM["actions"][ID]>["Input"];
+    serializeInput(raw: TInferInputFromSchema<DOM["actions"][ID]>["Input"]): JSONSerializableValue;
+    validateInput(input: unknown): TInferInputFromSchema<DOM["actions"][ID]>["Input"];
+    validateOutput(output: unknown): TInferOutputFromSchema<DOM["actions"][ID]>["Output"];
+}

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

@@ -0,0 +1,10 @@
+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 type IActionCore_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = {
+    form: EActionForm.core;
+    domain: DOM["domain"];
+    allDomains: DOM["allDomains"];
+    id: ID;
+};

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

@@ -0,0 +1,14 @@
+import type { IActionDomain } from "../../Domain/ActionDomain.types";
+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> {
+    readonly form: EActionForm.data;
+    readonly type: DT;
+    readonly context: ActionContext<DOM, ID>;
+    readonly time: number;
+    protected constructor(context: ActionContext<DOM, ID>, type: DT, data: IActionPayload_Data_Base);
+    protected toBaseJsonObject(): IActionPayload_Base_JsonObject<DT, DOM, ID>;
+    abstract toJsonObject(): IActionPayload_Base_JsonObject<DT, DOM, ID>;
+}

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

@@ -0,0 +1,106 @@
+import type { TInferActionError } from "../../..";
+import type { IActionHandler_ExternalClient_Json, IActionHandler_Local_Json } from "../../../ActionRuntime/Handler/ActionHandler.types";
+import type { ETransportType } from "../../../ActionRuntime/Handler/ExternalClient/Transport/Transport.types";
+import type { IActionDomain, TInferInputFromSchema, TInferOutputFromSchema } from "../../Domain/ActionDomain.types";
+import type { EActionForm, IActionBase, IActionBase_JsonObject } from "../ActionBase.types";
+import type { ActionContext } from "../Context/ActionContext";
+import type { IActionContext_Data_JsonObject } from "../Context/ActionContext.types";
+import type { ActionPayload_Progress } from "./ActionPayload_Progress";
+import type { ActionPayload_Request } from "./ActionPayload_Request";
+import type { ActionPayload_Result } from "./ActionPayload_Result";
+export declare enum EActionPayloadType {
+    request = "request",
+    progress = "progress",
+    stream = "stream",
+    result = "result"
+}
+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 {
+    readonly type: DT;
+    readonly context: ActionContext<DOM, ID>;
+}
+export type IActionRouteItemHandler = IActionHandler_Local_Json | (IActionHandler_ExternalClient_Json & {
+    transType: ETransportType;
+    transOrd: number;
+});
+/**
+ *  [                        ]
+ *  [  ACTION PAYLOAD TYPES  ]
+ *  [                        ]
+ */
+/**
+ *
+ *  [ RESULT ]
+ *
+ */
+export type TActionResultOutcome<OUT, ERR> = {
+    ok: true;
+    output: OUT;
+} | {
+    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]>>;
+}
+/**
+ *
+ *  [ PROGRESS ]
+ *
+ */
+export declare enum EActionProgressType {
+    none = "none",
+    percentage = "percentage",
+    custom = "custom"
+}
+export interface IActionProgress_None {
+    type: EActionProgressType.none;
+}
+export interface IActionProgress_Percentage {
+    type: EActionProgressType.percentage;
+    progress: number;
+    message?: string;
+}
+export interface IActionProgress_Custom {
+    type: EActionProgressType.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> {
+    readonly progress: TActionProgress;
+}
+/**
+ *
+ *  [                   ]
+ *  [  Wire JSON types  ]
+ *  [                   ]
+ *
+ */
+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> {
+    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> {
+    type: EActionPayloadType.request;
+    input: TInferInputFromSchema<DOM["actions"][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> {
+    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> {
+    type: EActionPayloadType.result;
+    result: TActionResultOutcome<TInferOutputFromSchema<DOM["actions"][ID]>["Output"], TInferActionError<DOM["actions"][ID]>>;
+}
+/**
+ *
+ *  [                  ]
+ *  [  COMBINED TYPES  ]
+ *  [                  ]
+ *
+ */
+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>;

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

@@ -0,0 +1,15 @@
+import type { IActionDomain } from "../../Domain/ActionDomain.types";
+import type { ActionContext } from "../Context/ActionContext";
+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> {
+    readonly progress: TActionProgress;
+    constructor(params: {
+        context: ActionContext<DOM, ID>;
+    } | ActionPayload_Request<DOM, ID>, progress: TActionProgress, data: IActionPayload_Data_Base);
+    toJsonObject(): IActionPayload_Progress_JsonObject<DOM, ID>;
+    toJsonString(): string;
+    toHttpResponse(): Response;
+}

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

@@ -0,0 +1,24 @@
+import type { IExecuteActionOptions } from "../../../ActionRuntime/Handler/ActionHandler.types";
+import type { IActionDomain, TInferInputFromSchema, TInferOutputFromSchema } from "../../Domain/ActionDomain.types";
+import type { TInferActionError } from "../../Schema/ActionSchema";
+import type { ActionContext } from "../Context/ActionContext";
+import type { RunningAction } from "../RunningAction";
+import { ActionPayload } from "./ActionPayload";
+import type { IActionPayload_Data_Base, TActionProgress } from "./ActionPayload.types";
+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"];
+    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>;
+    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"]>;
+    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

@@ -0,0 +1,18 @@
+import type { IActionDomain, TInferOutputFromSchema } from "../../Domain/ActionDomain.types";
+import type { TInferActionError } from "../../Schema/ActionSchema";
+import type { ActionContext } from "../Context/ActionContext";
+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]>>;
+    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);
+    toJsonObject(): IActionPayload_Result_JsonObject<DOM, ID>;
+    toJsonString(): string;
+    toHttpResponse({ useErrorStatus }?: {
+        useErrorStatus?: boolean;
+    }): Response;
+}

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

@@ -0,0 +1,33 @@
+import type { ActionDomain } from "../..";
+import type { IActionDomain } from "../Domain/ActionDomain.types";
+import type { ActionContext } from "./Context/ActionContext";
+import { type IActionPayload_Result_JsonObject } from "./Payload/ActionPayload.types";
+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> {
+    protected _state: IRunningActionState<DOM, ID>;
+    readonly context: ActionContext<DOM, ID>;
+    readonly cuid: string;
+    readonly id: ID;
+    readonly _domain: ActionDomain<DOM>;
+    readonly domain: DOM["domain"];
+    readonly allDomains: DOM["allDomains"];
+    private readonly _resultPayloadPromise;
+    private _resolveResult;
+    private _rejectResult;
+    private _isAborted;
+    private readonly _updates;
+    private readonly _updateListeners;
+    constructor(initialState: IRunningActionState_ConstructorParams<DOM, ID>);
+    get state(): IRunningActionState<DOM, ID>;
+    abort(reason?: unknown): void;
+    addUpdateListeners(listeners: TRunningActionUpdateListener<DOM, ID>[]): () => void;
+    iterateUpdates(): AsyncIterable<TRunningActionUpdate<DOM, ID>>;
+    _sendUpdate(update: TRunningActionUpdate<DOM, ID>): void;
+    _completeWithResult(result: ActionPayload_Result<DOM, ID>): boolean;
+    _abort(reason?: unknown): boolean;
+    _updateProgress(progress: ActionPayload_Progress<DOM, ID>): void;
+    waitForResultPayload(): Promise<ActionPayload_Result<DOM, ID>>;
+    _resolveFromJson(resultJson: IActionPayload_Result_JsonObject<DOM, ID>): boolean;
+}

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

@@ -0,0 +1,65 @@
+import type { IActionDomain } from "../Domain/ActionDomain.types";
+import type { TInferActionError } from "../Schema/ActionSchema";
+import type { ActionContext } from "./Context/ActionContext";
+import type { TActionProgress } from "./Payload/ActionPayload.types";
+import type { ActionPayload_Progress } from "./Payload/ActionPayload_Progress";
+import type { ActionPayload_Request } from "./Payload/ActionPayload_Request";
+import type { ActionPayload_Result } from "./Payload/ActionPayload_Result";
+import type { RunningAction } from "./RunningAction";
+export declare enum ERunningActionState {
+    running = "running",
+    completed = "completed"
+}
+export interface IRunningActionState<DOM extends IActionDomain, ID extends keyof DOM["actions"] & 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> {
+    context: ActionContext<DOM, ID>;
+    request: ActionPayload_Request<DOM, ID>;
+    progress?: ActionPayload_Progress<DOM, ID>[];
+    result?: ActionPayload_Result<DOM, ID>;
+}
+export declare enum ERunningActionUpdateType {
+    started = "started",
+    progress = "progress",
+    finished = "finished"
+}
+export interface IRunningActionEvent_Base<T extends ERunningActionUpdateType, DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & 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_Progress<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends IRunningActionEvent_Base<ERunningActionUpdateType.progress, DOM, ID> {
+    progress: TActionProgress;
+}
+export declare enum ERunningActionFinishedType {
+    aborted = "aborted",
+    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> {
+    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> {
+    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_Success<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> extends IRunningActionUpdate_Finished<ERunningActionFinishedType.success, DOM, ID> {
+    response: ActionPayload_Result<DOM, ID>;
+}
+export type TRunningActionUpdateFinished<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = IRunningActionUpdate_Abort<DOM, ID> | IRunningActionUpdate_Failed<DOM, ID> | IRunningActionUpdate_Success<DOM, ID>;
+export type TRunningActionUpdate<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = IRunningActionUpdate_Started<DOM, ID> | IRunningActionUpdate_Progress<DOM, ID> | TRunningActionUpdateFinished<DOM, ID>;
+export type TRunningActionUpdateListener<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = (update: TRunningActionUpdate<DOM, ID>) => void;
+export interface IRunningActionUserMethods<DOM extends IActionDomain, ID extends keyof DOM["actions"] & string> {
+    waitForResultPayload(): Promise<ActionPayload_Result<DOM, ID>>;
+    addUpdateListeners(listeners: TRunningActionUpdateListener<DOM, ID>[]): () => void;
+    iterateUpdates(): AsyncIterable<TRunningActionUpdate<DOM, ID>>;
+    abort(reason?: unknown): void;
+}

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

@@ -0,0 +1,30 @@
+import type { IExecuteActionOptions } from "../../ActionRuntime/Handler/ActionHandler.types";
+import type { TAction_Any_JsonObject, TDistributedDomainActions, TNarrowActionJsonTypeToActionInstanceType } from "../Action/Action.combined.types";
+import { type IActionBase } from "../Action/ActionBase.types";
+import { ActionContext } from "../Action/Context/ActionContext";
+import type { IActionContext_Data_JsonObject } from "../Action/Context/ActionContext.types";
+import { ActionCore } from "../Action/Core/ActionCore";
+import { type IActionPayload_Request_JsonObject, type IActionPayload_Result_JsonObject } from "../Action/Payload/ActionPayload.types";
+import { ActionPayload_Request } from "../Action/Payload/ActionPayload_Request";
+import { ActionPayload_Result } from "../Action/Payload/ActionPayload_Result";
+import type { RunningAction } from "../Action/RunningAction";
+import type { IActionDomain, IActionDomainChildOptions, TActionDomainChildDef } from "./ActionDomain.types";
+import { ActionDomainBase } from "./ActionDomainBase";
+import { type ActionRootDomain } from "./ActionRootDomain";
+export declare class ActionDomain<ACT_DOM extends IActionDomain = IActionDomain> extends ActionDomainBase<ACT_DOM> {
+    private _rootDomain;
+    constructor(definition: ACT_DOM, { rootDomain, }: {
+        rootDomain: ActionRootDomain;
+    });
+    get rootDomain(): ActionRootDomain<import("./ActionDomain.types").IActionRootDomain<string>>;
+    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>;
+    isDomainAction<ACT extends IActionBase<any, ACT_DOM, any>>(action: ACT | unknown | null | undefined): action is TDistributedDomainActions<ACT_DOM, ACT>;
+    hydrateRequest<ID extends keyof ACT_DOM["actions"] & string, P extends IActionPayload_Request_JsonObject<ACT_DOM, ID>>(serialized: P): ActionPayload_Request<ACT_DOM, ID>;
+    hydrateResultPayload<ID extends keyof ACT_DOM["actions"] & string, R extends IActionPayload_Result_JsonObject<ACT_DOM, ID>>(serialized: R): ActionPayload_Result<ACT_DOM, ID>;
+    hydrateAnyAction<ID extends keyof ACT_DOM["actions"] & string, AJ extends TAction_Any_JsonObject<ACT_DOM, ID>>(actionJson: AJ): TNarrowActionJsonTypeToActionInstanceType<ACT_DOM, AJ, ID>;
+    runAction<ID extends keyof ACT_DOM["actions"] & string, ACT extends ActionPayload_Request<ACT_DOM, ID>>(request: ACT, options?: IExecuteActionOptions<ACT_DOM, ID>): Promise<RunningAction<ACT_DOM, ID>>;
+}

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

@@ -0,0 +1,37 @@
+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 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.
+ * Does NOT include class methods.
+ */
+export interface IActionDomain<IDS extends TPossibleDomainIdList = TPossibleDomainIdList, SCH extends TActionDomainSchema = TActionDomainSchema> {
+    domain: IDS[0] & string;
+    allDomains: IDS;
+    actions: SCH;
+}
+export interface IActionRootDomain<ID extends TPossibleDomainId = TPossibleDomainId> extends IActionDomain<[ID], {}> {
+    domain: ID;
+    allDomains: [ID];
+    actions: {};
+}
+export interface IActionDomainChildOptions<ERR_DOMAIN extends string = string, SCHEMA extends TActionDomainSchema = TActionDomainSchema> {
+    domain: ERR_DOMAIN;
+    actions: SCHEMA;
+}
+export type TActionDomainChildDef<PARENT_DEF extends IActionDomain, SUB extends IActionDomainChildOptions> = {
+    domain: SUB["domain"];
+    allDomains: [SUB["domain"], ...PARENT_DEF["allDomains"]];
+    actions: SUB["actions"];
+};
+export type TDomainActionId<DOM extends IActionDomain> = keyof DOM["actions"] & string;
+export type TInferInputFromSchema<SCH extends ActionSchema<any, any, any>> = SCH extends ActionSchema<infer IN, any, any> ? {
+    Input: IN[0];
+    SerdeInput: IN[1];
+} : never;
+export type TInferOutputFromSchema<SCH extends ActionSchema<any, any, any>> = SCH extends ActionSchema<any, infer OUT, any> ? {
+    Output: OUT[0];
+    SerdeOutput: OUT[1];
+} : never;

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

@@ -0,0 +1,14 @@
+import type { 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"]> {
+    readonly domain: ACT_DOM["domain"];
+    readonly allDomains: ACT_DOM["allDomains"];
+    readonly actions: ACT_DOM["actions"];
+    protected _listeners: TRunningActionUpdateListener<any, any>[];
+    constructor(definition: ACT_DOM);
+    /**
+     * Add an observer that is called after every action dispatched through this domain.
+     * Returns an unsubscribe function — call it to remove the listener.
+     */
+    addActionListener(listener: TRunningActionUpdateListener<ACT_DOM, any>): () => void;
+}

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

@@ -0,0 +1,23 @@
+import type { ActionRuntime } from "../../ActionRuntime/ActionRuntime";
+import type { IActionClientSpecifier } from "../../ActionRuntime/Client/ActionClientSpecifier";
+import type { IExecuteActionOptions } from "../../ActionRuntime/Handler/ActionHandler.types";
+import type { ActionPayload_Request } from "../Action/Payload/ActionPayload_Request";
+import type { RunningAction } from "../Action/RunningAction";
+import { ActionDomain } from "./ActionDomain";
+import type { IActionDomain, IActionDomainChildOptions, IActionRootDomain, TActionDomainChildDef } from "./ActionDomain.types";
+import { ActionDomainBase } from "./ActionDomainBase";
+export declare class ActionRootDomain<ROOT_DOM extends IActionRootDomain = IActionRootDomain> extends ActionDomainBase<ROOT_DOM> {
+    readonly domainDefinition: {
+        domain: ROOT_DOM["domain"];
+    };
+    private _actionRuntimeManager;
+    constructor(domainDefinition: {
+        domain: ROOT_DOM["domain"];
+    });
+    createChildDomain<SUB_DOM extends IActionDomainChildOptions>(subDomainDef: SUB_DOM & {
+        [K in Exclude<keyof SUB_DOM, keyof IActionDomainChildOptions>]: never;
+    }): 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>>;
+}

package/build/types/ActionDefinition/Domain/helpers/createRootActionDomain.d.ts

@@ -0,0 +1,5 @@
+import type { IActionRootDomain } from "../ActionDomain.types";
+import { ActionRootDomain } from "../ActionRootDomain";
+export declare const createActionRootDomain: <ID extends string>(definition: {
+    domain: ID;
+}) => ActionRootDomain<IActionRootDomain<ID>>;