@nice-code/action 0.8.0 → 0.9.0

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

@@ -1,36 +0,0 @@
-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["actionSchema"] & string = keyof DOM["actionSchema"] & 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"];
-    readonly parentCuid?: string;
-    readonly callSite?: string;
-    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;
-    _failWithError(error: 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

@@ -1,73 +0,0 @@
-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["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["actionSchema"] & string> {
-    context: ActionContext<DOM, ID>;
-    request: ActionPayload_Request<DOM, ID>;
-    progress?: ActionPayload_Progress<DOM, ID>[];
-    result?: ActionPayload_Result<DOM, ID>;
-    parentCuid?: string;
-    callSite?: string;
-}
-export declare enum ERunningActionUpdateType {
-    started = "started",
-    progress = "progress",
-    finished = "finished"
-}
-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["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IRunningActionEvent_Base<ERunningActionUpdateType.started, 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 {
-    aborted = "aborted",
-    failed = "failed",
-    success = "success"
-}
-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["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["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["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["actionSchema"] & string = keyof DOM["actionSchema"] & string> = IRunningActionUpdate_Abort<DOM, ID> | IRunningActionUpdate_Failed<DOM, ID> | IRunningActionUpdate_Success<DOM, ID>;
-export type TRunningActionUpdate<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = IRunningActionUpdate_Started<DOM, ID> | IRunningActionUpdate_Progress<DOM, ID> | TRunningActionUpdateFinished<DOM, ID>;
-export type TRunningActionUpdateListener<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = (update: TRunningActionUpdate<DOM, ID>) => void;
-/**
- * Distributes a union ID into a proper discriminated union of RunningAction update events,
- * so that narrowing on `update.runningAction.id` also narrows `update.runningAction`'s input/output types.
- */
-export type TDistributeRunningActionUpdate<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = ID extends keyof DOM["actionSchema"] & string ? TRunningActionUpdate<DOM, ID> : never;
-export type TDistributeRunningActionUpdateListener<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = (update: TDistributeRunningActionUpdate<DOM, ID>) => void;
-export interface IRunningActionUserMethods<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string> {
-    waitForResultPayload(): Promise<ActionPayload_Result<DOM, ID>>;
-    addUpdateListeners(listeners: TRunningActionUpdateListener<DOM, ID>[]): () => void;
-    iterateUpdates(): AsyncIterable<TRunningActionUpdate<DOM, ID>>;
-    abort(reason?: unknown): void;
-}

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

@@ -1,42 +0,0 @@
-import type { ActionRuntime } from "../../ActionRuntime/ActionRuntime";
-import type { IExecuteActionOptions } from "../../ActionRuntime/Handler/ActionHandler.types";
-import { ActionLocalHandler } from "../../ActionRuntime/Handler/Local/ActionLocalHandler";
-import type { TAction_Any_JsonObject, TDistributeActionPayload_Request, TDistributeActionPayload_Result, TDistributedDomainActions, TNarrowActionJsonTypeToActionInstanceType } from "../Action/Action.combined.types";
-import { type IActionBase } from "../Action/ActionBase.types";
-import { ActionContext } from "../Action/Context/ActionContext";
-import type { IActionContext_Data_JsonObject } from "../Action/Context/ActionContext.types";
-import { ActionCore } from "../Action/Core/ActionCore";
-import { type IActionPayload_Request_JsonObject, type IActionPayload_Result_JsonObject } from "../Action/Payload/ActionPayload.types";
-import { ActionPayload_Request } from "../Action/Payload/ActionPayload_Request";
-import type { RunningAction } from "../Action/RunningAction";
-import type { IActionDomain, IActionDomainChildOptions, TActionDomainChildDef, TWrappableDomainActionHandler } 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>;
-    });
-    get rootDomain(): ActionRootDomain<any>;
-    _registerRuntime(runtime: ActionRuntime): void;
-    createChildDomain<SUB_DOM extends IActionDomainChildOptions>(subDomainDef: SUB_DOM & {
-        [K in Exclude<keyof SUB_DOM, keyof IActionDomainChildOptions>]: never;
-    }): ActionDomain<TActionDomainChildDef<ACT_DOM, SUB_DOM>>;
-    get action(): TActionMap<ACT_DOM>;
-    actionsMap(): TActionMap<ACT_DOM>;
-    actionForId<ID extends keyof ACT_DOM["actionSchema"] & string>(id: ID): ActionCore<ACT_DOM, ID>;
-    wrapAsPartialLocalHandler(wrappedActionExecutor: Partial<TWrappableDomainActionHandler<ACT_DOM>>): ActionLocalHandler;
-    wrapAsLocalHandler(wrappedActionExecutor: TWrappableDomainActionHandler<ACT_DOM>): ActionLocalHandler;
-    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>;
-    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,43 +0,0 @@
-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;
-    actionSchema: SCH;
-}
-export interface IActionRootDomain<ID extends TPossibleDomainId = TPossibleDomainId> extends IActionDomain<[ID], {}> {
-    domain: ID;
-    allDomains: [ID];
-    actionSchema: {};
-}
-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: [...PARENT_DEF["allDomains"], SUB["domain"]];
-    actionSchema: SUB["actions"];
-};
-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];
-} : {
-    Input: never;
-    SerdeInput: never;
-};
-export type TInferOutputFromSchema<SCH extends ActionSchema<any, any, any>> = SCH extends ActionSchema<any, infer OUT, any> ? {
-    Output: OUT[0];
-    SerdeOutput: OUT[1];
-} : never;
-export type TWrappableDomainActionHandler<DOM extends IActionDomain> = {
-    [K in TDomainActionId<DOM>]: (...args: [TInferInputFromSchema<DOM["actionSchema"][K]>["Input"]] extends [never] ? [] : [input: TInferInputFromSchema<DOM["actionSchema"][K]>["Input"]]) => [TInferOutputFromSchema<DOM["actionSchema"][K]>["Output"]] extends [never] ? Promise<void> | void : Promise<TInferOutputFromSchema<DOM["actionSchema"][K]>["Output"]>;
-};

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

@@ -1,14 +0,0 @@
-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["actionSchema"]> {
-    readonly domain: ACT_DOM["domain"];
-    readonly allDomains: ACT_DOM["allDomains"];
-    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["actionSchema"] & string>): () => void;
-}

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

@@ -1,24 +0,0 @@
-import type { ActionRuntime } from "../../ActionRuntime/ActionRuntime";
-import type { IExecuteActionOptions } from "../../ActionRuntime/Handler/ActionHandler.types";
-import type { IRuntimeCoordinate } from "../../ActionRuntime/RuntimeCoordinate";
-import type { ActionPayload_Request } from "../Action/Payload/ActionPayload_Request";
-import { 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>>;
-    _registerRuntime(runtime: ActionRuntime): void;
-    _hasRuntime(runtime: ActionRuntime): boolean;
-    getRuntime(clientSpecifier: IRuntimeCoordinate): ActionRuntime | undefined;
-    _runAction<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string, ACT extends ActionPayload_Request<DOM, ID> = ActionPayload_Request<DOM, ID>>(actionPayload: ACT, options?: IExecuteActionOptions<DOM, ID>): Promise<RunningAction<DOM, ID>>;
-}

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

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

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

@@ -1,68 +0,0 @@
-import { err_cast_not_nice, type INiceErrorDomainProps, type InferNiceError, type NiceErrorDomain } from "@nice-code/error";
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-import type { IActionErrorDeclaration, TActionSchemaOptions, TInferDeclaredErrors, TTransportedValue } from "./ActionSchema.types";
-export declare class ActionSchema<INPUT extends TTransportedValue<any, any> = never, OUTPUT extends TTransportedValue<any, any> = never, ERRORS extends readonly IActionErrorDeclaration<any, any>[] = readonly []> {
-    private _errorDeclarations;
-    private inputOptions;
-    private outputOptions;
-    get inputSchema(): StandardSchemaV1 | undefined;
-    get outputSchema(): StandardSchemaV1 | undefined;
-    /**
-     * Declare the input schema (JSON-native or with explicit SERDE type param).
-     * For non-JSON-native inputs, prefer the 3-argument form below to avoid
-     * needing explicit type parameters.
-     */
-    input<VS extends StandardSchemaV1 = StandardSchemaV1, SERDE_IN = any>(options: TActionSchemaOptions<VS, SERDE_IN>): ActionSchema<TTransportedValue<StandardSchemaV1.InferInput<VS>, SERDE_IN>, OUTPUT, ERRORS>;
-    /**
-     * Declare the output schema (JSON-native or with explicit SERDE type param).
-     * For non-JSON-native outputs, prefer the 3-argument form below to avoid
-     * needing explicit type parameters.
-     */
-    output<VS extends StandardSchemaV1 = StandardSchemaV1, SERDE_OUT = any>(options: TActionSchemaOptions<VS, SERDE_OUT>): ActionSchema<INPUT, TTransportedValue<StandardSchemaV1.InferInput<VS>, SERDE_OUT>, ERRORS>;
-    /**
-     * Declare that this action may throw any error from `domain`.
-     * `TInferActionError` will include `NiceError<DEF, keyof schema>` in its union.
-     */
-    throws<ERR_DEF extends INiceErrorDomainProps>(domain: NiceErrorDomain<ERR_DEF>): ActionSchema<INPUT, OUTPUT, readonly [...ERRORS, IActionErrorDeclaration<ERR_DEF, keyof ERR_DEF["schema"] & string>]>;
-    /**
-     * Declare that this action may throw only the listed `ids` from `domain`.
-     * `TInferActionError` will include `NiceError<DEF, IDS[number]>` narrowed to those IDs.
-     */
-    throws<ERR_DEF extends INiceErrorDomainProps, IDS extends ReadonlyArray<keyof ERR_DEF["schema"] & string>>(domain: NiceErrorDomain<ERR_DEF>, ids: IDS): ActionSchema<INPUT, OUTPUT, readonly [...ERRORS, IActionErrorDeclaration<ERR_DEF, IDS[number] & string>]>;
-    /**
-     * Serialize raw input to a JSON-serializable form.
-     * Uses the schema's serialization.serialize if defined; otherwise the input
-     * is already JSON-native and is returned as-is.
-     */
-    serializeInput(rawInput: INPUT[0]): INPUT[1];
-    /**
-     * Deserialize a JSON value back into the raw input type.
-     * Uses serialization.deserialize if defined; otherwise the value is cast
-     * directly (it's already in the correct shape).
-     */
-    deserializeInput(serialized: INPUT[1]): INPUT[0];
-    /**
-     * Validate raw input against the schema defined via `.input({ schema })`.
-     * Throws `action_input_validation_failed` if validation fails.
-     * Returns the validated (and possibly coerced) value on success.
-     * If no input schema was declared, the value is passed through as-is.
-     */
-    validateInput(value: unknown, meta: {
-        domain: string;
-        actionId: string;
-    }): INPUT[0];
-    validateOutput(value: unknown, meta: {
-        domain: string;
-        actionId: string;
-    }): OUTPUT[0];
-    /**
-     * Serialize raw output to a JSON-serializable form.
-     */
-    serializeOutput(rawOutput: OUTPUT[0]): OUTPUT[1];
-    /**
-     * Deserialize a JSON value back into the raw output type.
-     */
-    deserializeOutput(serialized: OUTPUT[1]): OUTPUT[0];
-}
-export type TInferActionError<SCH> = SCH extends ActionSchema<any, any, infer DECLS> ? DECLS extends readonly IActionErrorDeclaration[] ? TInferDeclaredErrors<DECLS> | InferNiceError<typeof err_cast_not_nice> : InferNiceError<typeof err_cast_not_nice> : never;
-export declare const actionSchema: () => ActionSchema;

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

@@ -1,28 +0,0 @@
-import { type INiceErrorDomainProps, type NiceErrorDomain } from "@nice-code/error";
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-export type TTransportedValue<RAW_VAL, SERDE_VAL> = [RAW_VAL] | [RAW_VAL, SERDE_VAL];
-export type TActionSerializationDefinition<RAW_VAL = any, SERDE_VAL = any> = {
-    serialize: (value: RAW_VAL) => SERDE_VAL;
-    deserialize: (value: SERDE_VAL) => RAW_VAL;
-};
-export type TActionSchemaOptions<VS extends StandardSchemaV1 = StandardSchemaV1, SERDE_IN = any> = {
-    schema: VS;
-    serialization?: TActionSerializationDefinition<StandardSchemaV1.InferInput<VS>, SERDE_IN>;
-};
-/**
- * One error declaration on an action schema.
- * `IDS` is the subset of error IDs that may be thrown. When the full
- * `keyof schema` union is used it means any ID from the domain can be thrown.
- *
- * Build via `action().throws(domain)` or `action().throws(domain, ids)`.
- */
-export interface IActionErrorDeclaration<ERR_DEF extends INiceErrorDomainProps = INiceErrorDomainProps, IDS extends keyof ERR_DEF["schema"] & string = keyof ERR_DEF["schema"] & string> {
-    readonly _domain: NiceErrorDomain<ERR_DEF>;
-    /** The specific IDs constrained for this declaration, or `undefined` meaning the full domain. */
-    readonly _ids: ReadonlyArray<IDS & string> | undefined;
-}
-/**
- * Union of all `NiceError` types that can be thrown from a tuple of error declarations.
- * Distributes over each declaration and unions the results.
- */
-export type TInferDeclaredErrors<DECLS extends readonly IActionErrorDeclaration[]> = TInferErrorFromDeclaration<DECLS[number]>;

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

@@ -1,13 +0,0 @@
-import type { TAction_Any_JsonObject, TNarrowActionJsonTypeToActionInstanceType } from "../ActionDefinition/Action/Action.combined.types";
-import type { INiceActionIdAndDomain } from "../ActionDefinition/Action/ActionBase.types";
-import type { ActionDomain } from "../ActionDefinition/Domain/ActionDomain";
-import type { IActionDomain } from "../ActionDefinition/Domain/ActionDomain.types";
-export declare class ActionDomainManager {
-    private _domains;
-    addDomain(domain: ActionDomain<any>): void;
-    getDomains(): ActionDomain<any>[];
-    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["actionSchema"] & string, A extends TAction_Any_JsonObject<D, ID>>(actionJson: A): TNarrowActionJsonTypeToActionInstanceType<D, A, ID>;
-}

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

@@ -1,78 +0,0 @@
-import type { ActionCore } from "../ActionDefinition/Action/Core/ActionCore";
-import type { TActionPayload_Any_Instance } from "../ActionDefinition/Action/Payload/ActionPayload.types";
-import { type TActionPayload_Any_JsonObject } from "../ActionDefinition/Action/Payload/ActionPayload.types";
-import { RunningAction } from "../ActionDefinition/Action/RunningAction";
-import type { ActionDomain } from "../ActionDefinition/Domain/ActionDomain";
-import type { IActionDomain } from "../ActionDefinition/Domain/ActionDomain.types";
-import type { IRuntimeMeta, TActionRuntimeHandler } from "./ActionRuntime.types";
-import { type IHandleActionOptions, type TActionHandler } from "./Handler/ActionHandler.types";
-import { ActionExternalClientHandler } from "./Handler/ExternalClient/ActionExternalClientHandler";
-import type { Transport } from "./Handler/ExternalClient/Transport/Transport";
-import { type IRuntimeCoordinateSpecifics, RuntimeCoordinate } from "./RuntimeCoordinate";
-export declare class ActionRuntime {
-    private _coordinate;
-    readonly timeCreated: number;
-    readonly runtimeInfo: IRuntimeMeta;
-    private readonly actionRouter;
-    private readonly _pendingRunningActions;
-    private readonly _registeredExternalHandlers;
-    private _applied;
-    static getDefault(): ActionRuntime;
-    constructor(coordinate: RuntimeCoordinate);
-    get coordinate(): RuntimeCoordinate;
-    specifyRuntimeCoordinate(specifics: IRuntimeCoordinateSpecifics & {
-        envId?: string;
-    }): void;
-    registerRunningAction(ra: RunningAction<any, any>): void;
-    resolveIncomingActionPayload(json: TActionPayload_Any_JsonObject<any, any>): void;
-    /**
-     * Handle an incoming action wire (e.g. from a transport layer), route it to
-     * 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["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["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
-     * which domains/actions it handles — those routing keys are mirrored into
-     * this runtime's router so the same action can be served by multiple handlers.
-     * Duplicate registrations (same handler cuid for the same key) are skipped.
-     */
-    addHandlers(handlers: TActionRuntimeHandler[]): this;
-    /**
-     * Declare an external "backend client" in one call: build an
-     * {@link ActionExternalClientHandler} for `externalCoordinate` carrying the given
-     * `transports`, route the listed `domains`/`actions` to it, register it (plus any
-     * `localHandlers` — e.g. server→client push handlers that share the same channel)
-     * on this runtime, and `apply()`. Returns the external handler so the caller can
-     * later `clearTransportCache()` it.
-     *
-     * Sugar over `new ActionExternalClientHandler(...).forDomain(...)` + `addHandlers([...])`,
-     * so a single runtime can host one handler per backend target with its transports
-     * declared once and reused across every action routed to that backend.
-     */
-    connectTo(externalCoordinate: RuntimeCoordinate, options: {
-        transports: Transport[];
-        domains?: ActionDomain<any>[];
-        actions?: ActionCore<any, any>[];
-        localHandlers?: TActionRuntimeHandler[];
-        defaultTimeout?: number;
-    }): ActionExternalClientHandler;
-    private applyRuntimeForDomain;
-    /**
-     * Register this runtime with all root domains covered by its currently-added handlers,
-     * making it eligible to execute actions dispatched from those domains.
-     * After apply() is called, any subsequent addHandlers() calls also auto-register.
-     */
-    apply(): this;
-    /**
-     * Find the best registered external handler that can reach `originClient` directly.
-     * Used to locate the return-path channel for dispatching results back to the action origin.
-     * Returns `undefined` if no handler matches (score > 0 required, i.e. at least id must match).
-     */
-    getReturnHandlerForOrigin(originClient: RuntimeCoordinate): ActionExternalClientHandler | undefined;
-    resetRuntime(): void;
-    private _trySetupReturnDispatch;
-}

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

@@ -1,22 +0,0 @@
-import type { RuntimeName } from "std-env";
-import type { ActionRuntime } from "./ActionRuntime";
-import type { TActionHandler } from "./Handler/ActionHandler.types";
-import type { ActionExternalClientHandler } from "./Handler/ExternalClient/ActionExternalClientHandler";
-import type { ActionLocalHandler } from "./Handler/Local/ActionLocalHandler";
-import type { RuntimeCoordinate } from "./RuntimeCoordinate";
-export interface IRuntimeMeta {
-    assumed: boolean;
-    runtimeName: RuntimeName;
-}
-export interface IRuntimeEnvironmentMeta {
-    client: RuntimeCoordinate;
-    runtimeInfo: IRuntimeMeta;
-}
-export interface IActionRuntimeManagerContext {
-    domain?: string;
-}
-export interface IActionHandlerAndRuntime {
-    handler: TActionHandler;
-    runtime: ActionRuntime;
-}
-export type TActionRuntimeHandler = ActionLocalHandler | ActionExternalClientHandler;

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

@@ -1,20 +0,0 @@
-import type { TActionPayload_Any_Instance } from "../ActionDefinition/Action/Payload/ActionPayload.types";
-import type { ActionRuntime } from "./ActionRuntime";
-import type { IActionHandlerAndRuntime, IActionRuntimeManagerContext } from "./ActionRuntime.types";
-import type { IHandleActionOptions } from "./Handler/ActionHandler.types";
-import { type IRuntimeCoordinate } from "./RuntimeCoordinate";
-export declare class ActionRuntimeManager {
-    private _runtimes;
-    private _preferredRuntimeClientId;
-    private _context;
-    constructor(context?: IActionRuntimeManagerContext);
-    registerRuntime(runtime: ActionRuntime): void;
-    getRuntimeAndHandlerForAction(action: TActionPayload_Any_Instance<any, any>, options?: IHandleActionOptions, throwOnIssue?: boolean): IActionHandlerAndRuntime | undefined;
-    getRuntimeAndHandlerForActionOrThrow(action: TActionPayload_Any_Instance<any, any>, options?: IHandleActionOptions): IActionHandlerAndRuntime;
-    setPreferredRuntime(runtime: ActionRuntime): void;
-    getPreferredRuntime(): ActionRuntime | undefined;
-    getBestRuntimeForSpecifier(clientSpecifier: IRuntimeCoordinate): ActionRuntime | undefined;
-    getBestRuntime(clientSpecifier?: IRuntimeCoordinate): ActionRuntime | undefined;
-    hasRuntime(runtime: ActionRuntime): boolean;
-    getBestRuntimeOrThrow(specifier?: IRuntimeCoordinate): ActionRuntime;
-}

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

@@ -1,16 +0,0 @@
-import type { IActionRouteItemHandler } from "../../ActionDefinition/Action/Payload/ActionPayload.types";
-import type { ActionPayload_Request } from "../../ActionDefinition/Action/Payload/ActionPayload_Request";
-import type { RunningAction } from "../../ActionDefinition/Action/RunningAction";
-import type { IActionDomain } from "../../ActionDefinition/Domain/ActionDomain.types";
-import { ActionRouter } from "../Routing/ActionRouter";
-import type { EActionHandlerType, IActionHandler_Base, IHandleActionOptions, TActionHandler_Json } from "./ActionHandler.types";
-export declare abstract class ActionHandler<T extends EActionHandlerType> implements IActionHandler_Base<T> {
-    abstract readonly handlerType: T;
-    readonly cuid: string;
-    abstract readonly actionRouter: ActionRouter<any>;
-    constructor();
-    getActionRouter(): ActionRouter<any>;
-    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

@@ -1,65 +0,0 @@
-import type { TActionPayload_Any_JsonObject } from "../../ActionDefinition/Action/Payload/ActionPayload.types";
-import type { ActionPayload_Request } from "../../ActionDefinition/Action/Payload/ActionPayload_Request";
-import type { RunningAction } from "../../ActionDefinition/Action/RunningAction";
-import type { TRunningActionUpdateListener } from "../../ActionDefinition/Action/RunningAction.types";
-import type { IActionDomain } from "../../ActionDefinition/Domain/ActionDomain.types";
-import type { ActionRuntime } from "../ActionRuntime";
-import type { ActionRouter } from "../Routing/ActionRouter";
-import type { IRuntimeCoordinate, RuntimeCoordinate } from "../RuntimeCoordinate";
-export declare enum EActionHandlerType {
-    external = "external",
-    local = "local"
-}
-export interface IActionHandler_Json<T extends EActionHandlerType> {
-    type: T;
-}
-export interface IActionHandler_ExternalClient_Json extends IActionHandler_Json<EActionHandlerType.external> {
-    client: IRuntimeCoordinate;
-}
-export interface IActionHandler_Local_Json extends IActionHandler_Json<EActionHandlerType.local> {
-}
-export type TActionHandler_Json = IActionHandler_Local_Json | IActionHandler_ExternalClient_Json;
-export interface IHandleActionOptions {
-    timeout?: number;
-    targetExternalClient?: RuntimeCoordinate;
-    targetLocalRuntime?: ActionRuntime;
-}
-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> = {
-    [K in keyof T]-?: Required<Pick<T, K>> & Partial<Omit<T, K>>;
-}[keyof T];
-export interface IActionHandler_Base<T extends EActionHandlerType> {
-    cuid: string;
-    handlerType: T;
-    getActionRouter: () => ActionRouter<any>;
-}
-/**
- *
- *  LOCAL ACTION HANDLER
- *
- */
-export interface IHandleActionOptions_Local extends IHandleActionOptions {
-}
-export interface IActionHandler_Local extends IActionHandler_Base<EActionHandlerType.local> {
-    handleActionRequest: <DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(action: ActionPayload_Request<DOM, ID>, config?: IHandleActionOptions_Local) => Promise<RunningAction<DOM, ID>>;
-}
-/**
- *
- *  EXTERNAL CLIENT ACTION HANDLER
- *
- */
-export interface IHandleActionOptions_External extends IHandleActionOptions {
-}
-export interface IActionHandler_ExternalClient extends IActionHandler_Base<EActionHandlerType.external> {
-    externalClient: RuntimeCoordinate;
-    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;
-}
-/**
- *
- *  COMBINED
- *
- */
-export type TActionHandler = IActionHandler_Local | IActionHandler_ExternalClient;

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

@@ -1,45 +0,0 @@
-import type { ActionCore } from "../../../ActionDefinition/Action/Core/ActionCore";
-import type { IActionRouteItemHandler, TActionPayload_Any_Instance, TActionPayload_Any_JsonObject } from "../../../ActionDefinition/Action/Payload/ActionPayload.types";
-import type { 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 { ActionRuntime } from "../../ActionRuntime";
-import { ActionRouter } from "../../Routing/ActionRouter";
-import { RuntimeCoordinate } from "../../RuntimeCoordinate";
-import { ActionHandler } from "../ActionHandler";
-import { EActionHandlerType, type IActionHandler_ExternalClient, type IActionHandler_ExternalClient_Json, type IHandleActionOptions } from "../ActionHandler.types";
-import type { IActionExternalClientRequestHandlerConfig } from "./ActionExternalClientHandler.types";
-import { type ITransportRouteActionParams } from "./Transport/Transport.types";
-import type { TransportConnection } from "./Transport/TransportConnection";
-export declare class ActionExternalClientHandler extends ActionHandler<EActionHandlerType.external> implements IActionHandler_ExternalClient {
-    readonly externalClient: RuntimeCoordinate;
-    readonly handlerType = EActionHandlerType.external;
-    readonly cuid: string;
-    private _defaultTimeout;
-    private _transportCache;
-    private transportManager;
-    private _incomingActionDataListeners;
-    readonly actionRouter: ActionRouter<true>;
-    constructor({ runtimeCoordinate: externalClientSpecifier, transports, defaultTimeout, }: IActionExternalClientRequestHandlerConfig);
-    forDomain<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>): 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["actionSchema"] & string>(action: ActionPayload_Request<DOM, ID>, config?: IHandleActionOptions): Promise<RunningAction<DOM, ID>>;
-    private _dispatchWhenTransportReady;
-    /**
-     * 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
-     * local runtime recognises that it has a direct channel to the action's originClient.
-     *
-     * Returns `true` if the payload was sent, `false` if no suitable transport was available.
-     */
-    sendReturnPayload(payload: TActionPayload_Any_Instance<any, any>, config: {
-        targetLocalRuntime: ActionRuntime;
-    }): Promise<boolean>;
-    toJsonObject(): IActionHandler_ExternalClient_Json;
-    toHandlerRouteItem(transport: TransportConnection, input: ITransportRouteActionParams): IActionRouteItemHandler;
-    clearTransportCache(): void;
-}
-export declare const createExternalClientHandler: (config: IActionExternalClientRequestHandlerConfig) => ActionExternalClientHandler;

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

@@ -1,7 +0,0 @@
-import type { RuntimeCoordinate } from "../../RuntimeCoordinate";
-import type { Transport } from "./Transport/Transport";
-export interface IActionExternalClientRequestHandlerConfig {
-    defaultTimeout?: number;
-    runtimeCoordinate: RuntimeCoordinate;
-    transports: Transport[];
-}