@nice-code/action 0.1.3 → 0.2.0

package/build/types/ActionRuntimeEnvironment/ActionHandler/ActionHandler.d.ts

@@ -1,80 +0,0 @@
-import type { NiceActionDomain } from "../../ActionDomain/NiceActionDomain";
-import type { INiceActionDomain } from "../../ActionDomain/NiceActionDomain.types";
-import type { INiceAction } from "../../NiceAction/NiceAction.types";
-import type { NiceActionPrimed } from "../../NiceAction/NiceActionPrimed";
-import { NiceActionResponse } from "../../NiceAction/NiceActionResponse";
-import { EActionHandlerType, type IActionHandler, type IActionHandlerInputs, type TExecutionAndResponseHandlers, type TExecutionAndResponseHandlers_Domain, type THandleActionResult, type TMatchHandlerKey } from "./ActionHandler.types";
-export declare class ActionHandler implements IActionHandler {
-    readonly tag: string | "_";
-    readonly handlerType = EActionHandlerType.custom;
-    readonly cuid: string;
-    readonly _domains: Map<string, NiceActionDomain<any>>;
-    private _handlersByKey;
-    constructor(config?: IActionHandlerInputs["actionMeta"]);
-    get allHandlerKeys(): TMatchHandlerKey[];
-    private getHandlersForAction;
-    /**
-     * 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 INiceActionDomain>(domain: NiceActionDomain<FOR_DOM>, handlers: TExecutionAndResponseHandlers_Domain<FOR_DOM>): this;
-    /**
-     * Register a typed handler for a specific action ID.
-     * The handler receives the full primed action with narrowed input type.
-     * Takes priority over `forDomain` for the same domain.
-     */
-    forAction<ACT_DOM extends INiceActionDomain, ID extends keyof ACT_DOM["actions"] & string>(domain: NiceActionDomain<ACT_DOM>, id: ID, handlers: TExecutionAndResponseHandlers<INiceAction<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 INiceActionDomain, IDS extends ReadonlyArray<keyof ACT_DOM["actions"] & string>>(domain: NiceActionDomain<ACT_DOM>, ids: IDS, handlers: TExecutionAndResponseHandlers<INiceAction<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:    { execution: (primed) => db.getUser(primed.input.userId) },
-     *   deleteUser: { execution: (primed) => db.deleteUser(primed.input.userId) },
-     * });
-     * ```
-     */
-    forDomainActionCases<FOR_DOM extends INiceActionDomain>(domain: NiceActionDomain<FOR_DOM>, cases: {
-        [ID in keyof FOR_DOM["actions"] & string]?: TExecutionAndResponseHandlers<INiceAction<FOR_DOM, ID>>;
-    }): this;
-    private _tryHandleResponse;
-    protected _tryExecute(primed: NiceActionPrimed<any, any, any>): Promise<THandleActionResult>;
-    /**
-     * Dispatch a primed action. Throws if no execution handler matches.
-     */
-    dispatchAction(primed: NiceActionPrimed<any, any>): Promise<NiceActionResponse<any, any>>;
-    /**
-     * Dispatch a wire-format action (primed or resolved).
-     *
-     * Returns `{ handled: true, response }` when a handler matched, or
-     * `{ handled: false }` when no handler is registered for the action.
-     *
-     * Throws for structural errors only:
-     * - `domain_no_handler` — domain not known to this handler
-     * - `hydration_*` — the wire payload is malformed
-     * - `handle_wire_not_primed_or_response` — unknown wire type
-     *
-     * Execution errors thrown by handlers propagate as-is.
-     *
-     * @example
-     * ```ts
-     * app.post("/actions", async (req, res) => {
-     *   const result = await handler.handleWire(req.body);
-     *   if (result.handled) res.json(result.response.toJsonObject());
-     *   else res.status(404).end();
-     * });
-     * ```
-     */
-    handleWire(wire: unknown): Promise<THandleActionResult>;
-}
-export declare const createHandler: (config?: IActionHandlerInputs["actionMeta"]) => ActionHandler;

package/build/types/ActionRuntimeEnvironment/ActionHandler/ActionHandler.types.d.ts

@@ -1,69 +0,0 @@
-import type { INiceActionDomain, TInferOutputFromSchema } from "../../ActionDomain/NiceActionDomain.types";
-import type { INiceAction, TNiceActionResponse_JsonObject } from "../../NiceAction/NiceAction.types";
-import type { TDistributedDomainActions } from "../../NiceAction/NiceActionCombined.types";
-import type { NiceActionPrimed } from "../../NiceAction/NiceActionPrimed";
-import type { NiceActionResponse } from "../../NiceAction/NiceActionResponse";
-import type { MaybePromise } from "../../utils/maybePromise";
-import type { IRuntimeEnvironmentMeta } from "../ActionRuntimeEnvironment.types";
-export type TAtLeastOne<T extends object> = {
-    [K in keyof T]-?: Required<Pick<T, K>> & Partial<Omit<T, K>>;
-}[keyof T];
-/**
- * Format: `${matchTag | "_"}::${domainName}::${actionName | "_"}`
- */
-export type TMatchHandlerKey = `${string}::${string | "_"}`;
-export interface IActionMetaInputs {
-    /**
-     * An action "tag" for the handler.
-     *
-     * This can be used to specify which handler should be used for a given
-     * action.
-     */
-    tag?: string;
-    meta?: any;
-}
-export interface IActionMetaInputsWithRuntime extends IActionMetaInputs {
-    runtime: IRuntimeEnvironmentMeta;
-}
-export type THandleActionExecutionFn<A extends INiceAction<any, any>> = A extends INiceAction<infer DOM, infer IDS> ? (primed: NiceActionPrimed<DOM, IDS>, envData: IActionMetaInputsWithRuntime) => MaybePromise<NiceActionResponse<DOM, IDS> | TNiceActionResponse_JsonObject<DOM, IDS> | TInferOutputFromSchema<DOM["actions"][IDS]>["Output"] | undefined> : never;
-export type THandleActionResponseFn<A extends INiceAction<any, any>> = A extends INiceAction<infer DOM, infer IDS> ? (response: NiceActionResponse<DOM, IDS>, envData: IActionMetaInputsWithRuntime) => MaybePromise<NiceActionResponse<DOM, IDS> | TNiceActionResponse_JsonObject<DOM, IDS> | undefined> : never;
-export type TExecutionAndResponseHandlers<A extends INiceAction<any, any>> = TAtLeastOne<{
-    execution: THandleActionExecutionFn<A>;
-    response: THandleActionResponseFn<A>;
-}>;
-export type THandleActionExecutionFn_Domain<DOM extends INiceActionDomain> = (primed: TDistributedDomainActions<NiceActionPrimed<DOM>, DOM>, envData: IActionMetaInputsWithRuntime) => MaybePromise<NiceActionResponse<DOM, keyof DOM["actions"] & string> | TNiceActionResponse_JsonObject<DOM, keyof DOM["actions"] & string> | TInferOutputFromSchema<DOM["actions"][keyof DOM["actions"] & string]>["Output"] | undefined>;
-export type THandleActionResponseFn_Domain<DOM extends INiceActionDomain> = (response: TDistributedDomainActions<NiceActionResponse<DOM>, DOM>, envData: IActionMetaInputsWithRuntime) => MaybePromise<NiceActionResponse<DOM, keyof DOM["actions"] & string> | TNiceActionResponse_JsonObject<DOM, keyof DOM["actions"] & string> | undefined>;
-export type TExecutionAndResponseHandlers_Domain<DOM extends INiceActionDomain> = TAtLeastOne<{
-    execution: THandleActionExecutionFn_Domain<DOM>;
-    response: THandleActionResponseFn_Domain<DOM>;
-}>;
-export type TListenToActionExecutionFn<DOM extends INiceActionDomain> = (primed: TDistributedDomainActions<NiceActionPrimed<DOM>, DOM>, envData: IActionMetaInputsWithRuntime) => void;
-export type TListenToActionResponseFn<DOM extends INiceActionDomain> = (response: TDistributedDomainActions<NiceActionResponse<DOM>, DOM>, envData: IActionMetaInputsWithRuntime) => void;
-export type TExecutionAndResponseListeners<DOM extends INiceActionDomain> = TAtLeastOne<{
-    execution: TListenToActionExecutionFn<DOM>;
-    response: TListenToActionResponseFn<DOM>;
-}>;
-export interface IActionHandlerInputs<DOM extends INiceActionDomain = INiceActionDomain> {
-    listeners?: TExecutionAndResponseListeners<DOM>[];
-    actionMeta: IActionMetaInputs;
-}
-export type THandleActionResult = {
-    handled: true;
-    response: NiceActionResponse<any, any>;
-} | {
-    handled: false;
-};
-export type TStoredHandlers<A extends INiceAction<any, any> = INiceAction<any, any>> = {
-    execution?: THandleActionExecutionFn<A>;
-    response?: THandleActionResponseFn<A>;
-};
-export declare enum EActionHandlerType {
-    connect = "connect",
-    custom = "custom"
-}
-export interface IActionHandler {
-    cuid: string;
-    handlerType: EActionHandlerType;
-    allHandlerKeys: TMatchHandlerKey[];
-    dispatchAction: (primed: NiceActionPrimed<any, any>) => Promise<NiceActionResponse<any, any>>;
-}

package/build/types/ActionRuntimeEnvironment/ActionRuntimeEnvironment.d.ts

@@ -1,32 +0,0 @@
-import type { INiceAction } from "../NiceAction/NiceAction.types";
-import type { IActionHandler, TStoredHandlers } from "./ActionHandler/ActionHandler.types";
-import type { IActionRuntimeEnvironment_JsonObject, IRuntimeMeta } from "./ActionRuntimeEnvironment.types";
-interface IActionRuntimeEnvironment_Constructor_Input {
-    envId: string;
-}
-export declare class ActionRuntimeEnvironment {
-    readonly envId: string;
-    /**
-     * A unique identifier for this runtime environment instance.
-     *
-     * Format: `${envId}::${randomSuffix}` where `envId` is the runtime static ID and `randomSuffix` is a short random
-     * string to distinguish multiple instances of the same runtime.
-     */
-    readonly memCuid: string;
-    readonly timeCreated: number;
-    readonly runtimeInfo: IRuntimeMeta;
-    private _handlersByTag;
-    private _defaultHandlers;
-    constructor(input: IActionRuntimeEnvironment_Constructor_Input);
-    addHandlers(handlers: IActionHandler[]): this;
-    setDefaultHandler(handler: TStoredHandlers, tag?: string): this;
-    getDefaultHandler(tag?: string): TStoredHandlers | undefined;
-    /**
-     * Return the first handler registered for the given matchTag, or undefined
-     * if none has been registered.
-     */
-    getHandlerForAction(action: Pick<INiceAction<any, any>, "domain" | "id">, tag?: string): IActionHandler | undefined;
-    toJsonObject(): IActionRuntimeEnvironment_JsonObject;
-}
-export declare const createActionRuntime: (config: IActionRuntimeEnvironment_Constructor_Input) => ActionRuntimeEnvironment;
-export {};

package/build/types/ActionRuntimeEnvironment/ActionRuntimeEnvironment.types.d.ts

@@ -1,15 +0,0 @@
-import type { RuntimeName } from "std-env";
-export interface IRuntimeMeta {
-    assumed: boolean;
-    runtimeName: RuntimeName;
-}
-export interface IActionRuntimeEnvironment_JsonObject {
-    envId: string;
-    memCuid: string;
-    timeCreated: number;
-    runtimeInfo: IRuntimeMeta;
-}
-export interface IRuntimeEnvironmentMeta {
-    envId?: string;
-    runtimeInfo: IRuntimeMeta;
-}

package/build/types/ActionRuntimeEnvironment/utils/getAssumedRuntimeEnvironment.d.ts

@@ -1,2 +0,0 @@
-import type { IRuntimeMeta } from "../ActionRuntimeEnvironment.types";
-export declare const getAssumedRuntimeInfo: () => IRuntimeMeta;

package/build/types/ActionSchema/NiceActionSchema.types.d.ts

@@ -1,32 +0,0 @@
-import { type INiceErrorDomainProps, type JSONSerializableValue, type NiceErrorDomain } from "@nice-code/error";
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-export type TNiceActionJsonSerializableValue = JSONSerializableValue;
-export type TTransportedValue<RAW_VAL, SERDE_VAL extends TNiceActionJsonSerializableValue> = RAW_VAL extends TNiceActionJsonSerializableValue ? [RAW_VAL] | [RAW_VAL, SERDE_VAL] : [RAW_VAL, SERDE_VAL];
-export type TNiceActionSerializationDefinition<RAW_VAL = any, SERDE_VAL extends TNiceActionJsonSerializableValue = TNiceActionJsonSerializableValue> = {
-    serialize: (value: RAW_VAL) => SERDE_VAL;
-    deserialize: (value: SERDE_VAL) => RAW_VAL;
-};
-export type TNiceActonSchemaOptions<VS extends StandardSchemaV1 = StandardSchemaV1, SERDE_IN extends TNiceActionJsonSerializableValue = TNiceActionJsonSerializableValue> = StandardSchemaV1.InferInput<VS> extends TNiceActionJsonSerializableValue ? {
-    schema: VS;
-    serialization?: TNiceActionSerializationDefinition<StandardSchemaV1.InferInput<VS>, SERDE_IN>;
-} : {
-    schema: VS;
-    serialization: TNiceActionSerializationDefinition<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 INiceActionErrorDeclaration<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 INiceActionErrorDeclaration[]> = TInferErrorFromDeclaration<DECLS[number]>;

package/build/types/ActionSchema/action.d.ts

@@ -1,2 +0,0 @@
-import { NiceActionSchema } from "./NiceActionSchema";
-export declare const action: () => NiceActionSchema;

package/build/types/NiceAction/MatchAction/MatchAction.d.ts

@@ -1,27 +0,0 @@
-import type { INiceActionDomain } from "../../ActionDomain/NiceActionDomain.types";
-import type { MaybePromise } from "../../utils/maybePromise";
-import type { INiceAction } from "../NiceAction.types";
-import type { TNarrowActionType } from "../NiceActionCombined.types";
-type TMatchHandler<A extends INiceAction<any>> = (action: A) => MaybePromise<void>;
-type THandlerForId<ACT extends INiceAction<any>> = (action: ACT) => MaybePromise<void>;
-declare class MatchAction<ACT extends INiceAction<any>> {
-    readonly action: ACT;
-    private _entries;
-    private _otherwise?;
-    constructor(action: ACT);
-    with<D extends INiceActionDomain, ID extends keyof D["actions"] & string>(opts: {
-        domain: D;
-        id: ID;
-        handler: THandlerForId<TNarrowActionType<ACT, D, ID>>;
-    }): this;
-    with<D extends INiceActionDomain>(opts: {
-        domain: D;
-        handler: TMatchHandler<TNarrowActionType<ACT, D, keyof D["actions"] & string>>;
-    }): this;
-    otherwise(handler: TMatchHandler<ACT>): this;
-    private _findMatch;
-    run(): boolean;
-    runAsync(): Promise<boolean>;
-}
-export declare const matchAction: <ACT extends INiceAction<any>>(action: ACT) => MatchAction<ACT>;
-export {};

package/build/types/NiceAction/NiceAction.d.ts

@@ -1,64 +0,0 @@
-import type { JSONSerializableValue } from "@nice-code/error";
-import type { NiceActionDomain } from "../ActionDomain/NiceActionDomain";
-import type { INiceActionDomain, TInferInputFromSchema, TInferOutputFromSchema } from "../ActionDomain/NiceActionDomain.types";
-import type { IActionMetaInputs } from "../ActionRuntimeEnvironment/ActionHandler/ActionHandler.types";
-import type { TInferActionError } from "../ActionSchema/NiceActionSchema";
-import { EActionState } from "./NiceAction.enums";
-import { type INiceAction, type INiceAction_JsonObject, type INiceActionPrimed_JsonObject, type TNiceActionResult } from "./NiceAction.types";
-import type { TNarrowActionType } from "./NiceActionCombined.types";
-import { NiceActionPrimed } from "./NiceActionPrimed";
-import { NiceActionResponse } from "./NiceActionResponse";
-export declare class NiceAction<DOM extends INiceActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string, SCH extends DOM["actions"][ID] = DOM["actions"][ID]> implements INiceAction<DOM, ID> {
-    readonly actionDomain: NiceActionDomain<DOM>;
-    readonly schema: SCH;
-    readonly type = EActionState.empty;
-    readonly id: ID;
-    readonly domain: DOM["domain"];
-    readonly allDomains: DOM["allDomains"];
-    readonly timeCreated: number;
-    readonly cuid: string;
-    constructor(actionDomain: NiceActionDomain<DOM>, schema: SCH, id: ID, hydrationData?: Pick<INiceAction_JsonObject<DOM, ID>, "cuid" | "timeCreated">);
-    /**
-     * Serialize this action definition (without input) to a JSON-safe object.
-     * Useful for describing which action will be invoked without yet having input.
-     */
-    toJsonObject(): INiceAction_JsonObject<DOM, ID>;
-    toJsonString(): string;
-    toHttpResponse(): Response;
-    is<ACT extends INiceAction<any>>(action: ACT | unknown | null | undefined): action is TNarrowActionType<ACT, DOM, ID>;
-    prime(input: TInferInputFromSchema<SCH>["Input"], hydrationData?: Pick<INiceActionPrimed_JsonObject<DOM, ID>, "timePrimed">): NiceActionPrimed<DOM, ID, SCH>;
-    execute(input: TInferInputFromSchema<SCH>["Input"], meta?: IActionMetaInputs): Promise<TInferOutputFromSchema<SCH>["Output"]>;
-    /**
-     * Like `execute`, but catches thrown errors and returns a `NiceActionResult` discriminated union
-     * instead of propagating. On success: `{ ok: true, output }`. On failure: `{ ok: false, error }`.
-     *
-     * The `error` type is the union of all `NiceError` types declared via `.throws()` on the schema,
-     * plus `InferNiceError<typeof err_cast_not_nice>` as the always-present fallback.
-     *
-     * @example
-     * ```ts
-     * const result = await domain.action("getUser").executeSafe({ userId: "123" });
-     * if (!result.ok) {
-     *   result.error.handleWithSync([
-     *     forDomain(err_auth, (h) => res.status(401).end()),
-     *   ]);
-     *   return;
-     * }
-     * console.log(result.output); // typed as the action's OUTPUT
-     * ```
-     */
-    executeSafe(input: TInferInputFromSchema<SCH>["Input"], meta?: IActionMetaInputs): Promise<TNiceActionResult<TInferOutputFromSchema<SCH>["Output"], TInferActionError<SCH>>>;
-    /**
-     * Prime this action with input, execute it, and return a `NiceActionResponse`
-     * that carries both the original primed action (domain + actionId + input) and
-     * the result (`{ ok: true, output }` or `{ ok: false, error }`).
-     *
-     * The response can be serialized for cross-boundary transport via `toJsonObject()`.
-     * Reconstruct on the receiving end with `domain.hydrateResponse(wire)`.
-     */
-    executeToResponse(input: TInferInputFromSchema<SCH>["Input"], meta?: IActionMetaInputs): Promise<NiceActionResponse<DOM, ID, SCH>>;
-    deserializeInput(serialized: JSONSerializableValue): TInferInputFromSchema<SCH>["Input"];
-    serializeInput(raw: TInferInputFromSchema<SCH>["Input"]): JSONSerializableValue;
-    validateInput(input: unknown): TInferInputFromSchema<SCH>["Input"];
-    validateOutput(output: unknown): TInferOutputFromSchema<SCH>["Output"];
-}

package/build/types/NiceAction/NiceAction.enums.d.ts

@@ -1,5 +0,0 @@
-export declare enum EActionState {
-    empty = "empty",
-    primed = "primed",
-    resolved = "resolved"
-}

package/build/types/NiceAction/NiceAction.types.d.ts

@@ -1,78 +0,0 @@
-import type { INiceErrorJsonObject } from "@nice-code/error";
-import type { INiceActionDomain, TInferInputFromSchema, TInferOutputFromSchema } from "../ActionDomain/NiceActionDomain.types";
-import type { EActionState } from "./NiceAction.enums";
-export interface INiceAction<DOM extends INiceActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> {
-    id: ID;
-    type: EActionState;
-    domain: DOM["domain"];
-    allDomains: DOM["allDomains"];
-    schema: DOM["actions"][ID];
-    cuid: string;
-    timeCreated: number;
-}
-/**
- * Wire format for a serialized NiceActionPrimed — safe to JSON.stringify / transmit.
- */
-export type INiceAction_JsonObject<DOM extends INiceActionDomain = INiceActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = {
-    type: EActionState.empty;
-    domain: DOM["domain"];
-    allDomains: DOM["allDomains"];
-    id: ID;
-    cuid: string;
-    timeCreated: number;
-};
-/**
- * Wire format for a serialized NiceActionPrimed — safe to JSON.stringify / transmit.
- */
-export type INiceActionPrimed_JsonObject<DOM extends INiceActionDomain = INiceActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = Omit<INiceAction_JsonObject<DOM, ID>, "type"> & {
-    type: EActionState.primed;
-    input: TInferInputFromSchema<DOM["actions"][ID]>["SerdeInput"];
-    timePrimed: number;
-};
-/**
- * Return type of `executeSafe` — a discriminated union of success and failure.
- *
- * - `{ ok: true; output: OUT }` — the action completed and returned `OUT`
- * - `{ ok: false; error: ERR }` — the action threw; `ERR` is the declared error union
- *
- * @example
- * ```ts
- * const result = await domain.action("getUser").executeSafe({ userId: "123" });
- * if (!result.ok) {
- *   result.error.handleWithSync([
- *     forDomain(err_auth, (h) => res.status(401).end()),
- *   ]);
- *   return;
- * }
- * console.log(result.output); // typed as the action's OUTPUT
- * ```
- */
-export type TNiceActionResult<OUT, ERR> = {
-    ok: true;
-    output: OUT;
-} | {
-    ok: false;
-    error: ERR;
-};
-/**
- * Wire format for a serialized NiceActionResponse — safe to JSON.stringify / transmit.
- *
- * Carries the original action identity (domain + actionId + serialized input) alongside
- * either the serialized output value or a serialized NiceError.
- *
- * Produced by `NiceActionResponse.toJsonObject()`.
- * Reconstructed by `NiceActionDomain.hydrateResponse()`.
- */
-export interface INiceActionResponse_JsonObject_Base<DOM extends INiceActionDomain, ID extends keyof DOM["actions"] & string> extends Omit<INiceActionPrimed_JsonObject<DOM, ID>, "type"> {
-    type: EActionState.resolved;
-    timeResponded: number;
-}
-export type INiceActionResponse_JsonObject_Success<DOM extends INiceActionDomain = INiceActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = INiceActionResponse_JsonObject_Base<DOM, ID> & {
-    ok: true;
-    output: TInferOutputFromSchema<DOM["actions"][ID]>["SerdeOutput"];
-};
-export type INiceActionResponse_JsonObject_Failure<DOM extends INiceActionDomain = INiceActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = INiceActionResponse_JsonObject_Base<DOM, ID> & {
-    ok: false;
-    error: INiceErrorJsonObject;
-};
-export type TNiceActionResponse_JsonObject<DOM extends INiceActionDomain = INiceActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = INiceActionResponse_JsonObject_Success<DOM, ID> | INiceActionResponse_JsonObject_Failure<DOM, ID>;

package/build/types/NiceAction/NiceActionCombined.types.d.ts

@@ -1,10 +0,0 @@
-import type { INiceActionDomain } from "../ActionDomain/NiceActionDomain.types";
-import type { NiceAction } from "./NiceAction";
-import type { INiceAction } from "./NiceAction.types";
-import type { NiceActionPrimed } from "./NiceActionPrimed";
-import type { NiceActionResponse } from "./NiceActionResponse";
-export type TNiceActionInstanceAny<DOM extends INiceActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string> = NiceAction<DOM, ID, DOM["actions"][ID]> | NiceActionPrimed<DOM, ID, DOM["actions"][ID]> | NiceActionResponse<DOM, ID, DOM["actions"][ID]>;
-export type TNarrowActionType<ACT extends INiceAction<any>, D extends INiceActionDomain, ID extends keyof D["actions"] & string = keyof D["actions"] & string> = ACT extends NiceActionResponse<any> ? NiceActionResponse<D, ID> : ACT extends NiceActionPrimed<any> ? NiceActionPrimed<D, ID> : ACT extends NiceAction<any> ? NiceAction<D, ID> : INiceAction<D, ID>;
-export type TDistributedDomainActions<ACT extends INiceAction<any>, DOM extends INiceActionDomain> = {
-    [ID in keyof DOM["actions"] & string]: TNarrowActionType<ACT, DOM, ID>;
-}[keyof DOM["actions"] & string];

package/build/types/NiceAction/NiceActionPrimed.d.ts

@@ -1,43 +0,0 @@
-import type { INiceActionDomain, TInferInputFromSchema, TInferOutputFromSchema } from "../ActionDomain/NiceActionDomain.types";
-import type { IActionMetaInputs } from "../ActionRuntimeEnvironment/ActionHandler/ActionHandler.types";
-import type { IRuntimeEnvironmentMeta } from "../ActionRuntimeEnvironment/ActionRuntimeEnvironment.types";
-import type { TInferActionError } from "../ActionSchema/NiceActionSchema";
-import type { NiceAction } from "./NiceAction";
-import { EActionState } from "./NiceAction.enums";
-import { type INiceAction, type INiceActionPrimed_JsonObject, type TNiceActionResponse_JsonObject, type TNiceActionResult } from "./NiceAction.types";
-import { NiceActionResponse } from "./NiceActionResponse";
-export declare class NiceActionPrimed<DOM extends INiceActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string, SCH extends DOM["actions"][ID] = DOM["actions"][ID]> implements INiceAction<DOM, ID> {
-    readonly coreAction: NiceAction<DOM, ID, SCH>;
-    private _input;
-    readonly type = EActionState.primed;
-    readonly domain: DOM["domain"];
-    readonly allDomains: DOM["allDomains"];
-    readonly id: ID;
-    readonly timePrimed: number;
-    readonly cuid: string;
-    readonly schema: SCH;
-    readonly timeCreated: number;
-    constructor(coreAction: NiceAction<DOM, ID, SCH>, _input: TInferInputFromSchema<SCH>["Input"], hydrationData?: Pick<INiceActionPrimed_JsonObject<DOM, ID>, "timePrimed">);
-    get input(): TInferInputFromSchema<SCH>["Input"];
-    getEnvironmentMeta(): IRuntimeEnvironmentMeta;
-    /**
-     * Serialize this primed action to a JSON-safe wire format.
-     * The input is passed through the schema's serialize function if one is defined,
-     * otherwise the (already JSON-native) input is used as-is.
-     */
-    toJsonObject(): INiceActionPrimed_JsonObject<DOM, ID>;
-    toJsonString(): string;
-    hydratePrimeJson(wire: INiceActionPrimed_JsonObject<DOM, ID>): NiceActionPrimed<DOM, ID, SCH>;
-    hydrateResponseJson(wire: TNiceActionResponse_JsonObject<DOM, ID>): NiceActionResponse<DOM, ID, SCH>;
-    errorResponse(err: TInferActionError<SCH>): NiceActionResponse<DOM, ID, SCH>;
-    toHttpResponse(): Response;
-    setResponse(...args: [TInferOutputFromSchema<SCH>["Output"]] extends [never] ? [] : [output: TInferOutputFromSchema<SCH>["Output"]]): NiceActionResponse<DOM, ID, SCH>;
-    execute(meta?: IActionMetaInputs): Promise<TInferOutputFromSchema<SCH>["Output"]>;
-    /**
-     * Like `execute`, but catches thrown errors and returns a `NiceActionResult` discriminated union
-     * instead of propagating. On success: `{ ok: true, output }`. On failure: `{ ok: false, error }`.
-     *
-     * Mirrors `NiceAction.executeSafe` — useful when re-executing a hydrated primed action.
-     */
-    executeSafe(meta?: IActionMetaInputs): Promise<TNiceActionResult<TInferOutputFromSchema<SCH>["Output"], TInferActionError<SCH>>>;
-}

package/build/types/NiceAction/NiceActionResponse.d.ts

@@ -1,42 +0,0 @@
-import type { INiceActionDomain, TInferOutputFromSchema } from "../ActionDomain/NiceActionDomain.types";
-import type { IRuntimeEnvironmentMeta } from "../ActionRuntimeEnvironment/ActionRuntimeEnvironment.types";
-import type { TInferActionError } from "../ActionSchema/NiceActionSchema";
-import type { NiceAction } from "./NiceAction";
-import { EActionState } from "./NiceAction.enums";
-import { type INiceAction, type TNiceActionResponse_JsonObject, type TNiceActionResult } from "./NiceAction.types";
-import { NiceActionPrimed } from "./NiceActionPrimed";
-export declare class NiceActionResponse<DOM extends INiceActionDomain, ID extends keyof DOM["actions"] & string = keyof DOM["actions"] & string, SCH extends DOM["actions"][ID] = DOM["actions"][ID]> implements INiceAction<DOM, ID> {
-    readonly type = EActionState.resolved;
-    readonly domain: DOM["domain"];
-    readonly allDomains: DOM["allDomains"];
-    readonly id: ID;
-    readonly primed: NiceActionPrimed<DOM, ID, SCH>;
-    readonly result: TNiceActionResult<TInferOutputFromSchema<SCH>["Output"], TInferActionError<SCH>>;
-    readonly timeResponded: number;
-    readonly cuid: string;
-    readonly schema: SCH;
-    readonly timeCreated: number;
-    constructor(primed: NiceActionPrimed<DOM, ID, SCH>, result: TNiceActionResult<TInferOutputFromSchema<SCH>["Output"], TInferActionError<SCH>>, hydrationData?: Pick<TNiceActionResponse_JsonObject<DOM, ID>, "timeResponded">);
-    getEnvironmentMeta(): IRuntimeEnvironmentMeta;
-    /**
-     * Serialize this response to a JSON-safe wire format.
-     *
-     * On success, the output is passed through the schema's serialize function
-     * if one is defined, otherwise used as-is.
-     * On failure, the error is serialized via `NiceError.toJsonObject()`.
-     */
-    toJsonObject(): TNiceActionResponse_JsonObject;
-    toJsonString(): string;
-    hydrateResponseJson(wire: TNiceActionResponse_JsonObject<DOM, ID>): NiceActionResponse<DOM, ID, SCH>;
-    toHttpResponse({ useErrorStatus }?: {
-        useErrorStatus?: boolean;
-    }): Response;
-}
-/**
- * Reconstruct a loosely-typed NiceActionResponse from its wire format.
- * Called by `NiceActionDomain.hydrateResponse` — not part of the public API.
- *
- * The result's error type is `NiceError<TUnknownNiceErrorDef>` (from `castNiceError`).
- * Use `handleWith` / `forDomain` / `isExact` to narrow on the receiving end.
- */
-export declare function hydrateNiceActionResponse<DOM extends INiceActionDomain>(wire: TNiceActionResponse_JsonObject, coreAction: NiceAction<DOM, keyof DOM["actions"] & string, DOM["actions"][keyof DOM["actions"] & string]>): NiceActionResponse<DOM, keyof DOM["actions"] & string, DOM["actions"][keyof DOM["actions"] & string]>;

package/build/types/NiceAction/utils/isNiceActionInstance.d.ts

@@ -1,3 +0,0 @@
-import type { INiceAction } from "../NiceAction.types";
-import type { TNarrowActionType } from "../NiceActionCombined.types";
-export declare function isNiceActionInstance<ACT extends INiceAction<any>>(value: unknown | ACT): value is TNarrowActionType<ACT, any, any>;

package/build/types/utils/isActionResponseJsonObject.d.ts

@@ -1,2 +0,0 @@
-import type { TNiceActionResponse_JsonObject } from "../NiceAction/NiceAction.types";
-export declare const isActionResponseJsonObject: (obj: unknown) => obj is TNiceActionResponse_JsonObject;

package/build/types/utils/isPrimedActionJsonObject.d.ts

@@ -1,2 +0,0 @@
-import type { INiceActionPrimed_JsonObject } from "../NiceAction/NiceAction.types";
-export declare const isPrimedActionJsonObject: (obj: unknown) => obj is INiceActionPrimed_JsonObject;