@nice-code/action 0.8.0 → 0.10.0

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

@@ -1,187 +0,0 @@
-import { type ClientCryptoKeyLink, type StorageAdapter, type TSerializedCryptoKeyData_Ed25519_Raw, type TSerializedCryptoKeyData_X25519_Raw, type TTypeAndId } from "@nice-code/util";
-import * as v from "valibot";
-import { type IRuntimeCoordinate } from "../../../../RuntimeCoordinate";
-/** How much the channel protects after the handshake — chosen by the consumer (perf vs security). */
-export declare enum ESecurityLevel {
-    /** No handshake; identity is self-asserted (fastest, dev / trusted networks). */
-    none = "none",
-    /** Handshake authenticates identity (sign/verify + key pin); frames stay plaintext over TLS. */
-    authenticated = "authenticated",
-    /** Authenticated handshake + every frame AES-GCM encrypted with the derived shared key. */
-    encrypted = "encrypted"
-}
-export declare enum EHandshakeMessageType {
-    hello = "hello",
-    welcome = "welcome",
-    prove = "prove",
-    accept = "accept",
-    reject = "reject"
-}
-declare const vHsHello: v.ObjectSchema<{
-    readonly t: v.LiteralSchema<EHandshakeMessageType.hello, undefined>;
-    readonly protocol: v.StringSchema<undefined>;
-    readonly securityLevel: v.PicklistSchema<[ESecurityLevel.none, ESecurityLevel.authenticated, ESecurityLevel.encrypted], undefined>;
-    readonly dictionaryVersion: v.StringSchema<undefined>;
-    readonly client: v.ObjectSchema<{
-        readonly envId: v.StringSchema<undefined>;
-        readonly perId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        readonly insId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>;
-    readonly clientNonce: v.StringSchema<undefined>;
-    readonly verifyPublicKey: v.CustomSchema<`ed25519::raw_base64::${string}`, undefined>;
-    readonly exchangePublicKey: v.OptionalSchema<v.CustomSchema<`x25519::raw_base64::${string}`, undefined>, undefined>;
-}, undefined>;
-declare const vHsWelcome: v.ObjectSchema<{
-    readonly t: v.LiteralSchema<EHandshakeMessageType.welcome, undefined>;
-    readonly securityLevel: v.PicklistSchema<[ESecurityLevel.none, ESecurityLevel.authenticated, ESecurityLevel.encrypted], undefined>;
-    readonly dictionaryVersion: v.StringSchema<undefined>;
-    readonly server: v.ObjectSchema<{
-        readonly envId: v.StringSchema<undefined>;
-        readonly perId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        readonly insId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>;
-    readonly serverNonce: v.StringSchema<undefined>;
-    readonly verifyPublicKey: v.CustomSchema<`ed25519::raw_base64::${string}`, undefined>;
-    readonly exchangePublicKey: v.OptionalSchema<v.CustomSchema<`x25519::raw_base64::${string}`, undefined>, undefined>;
-}, undefined>;
-declare const vHsProve: v.ObjectSchema<{
-    readonly t: v.LiteralSchema<EHandshakeMessageType.prove, undefined>;
-    readonly signatureBase64: v.StringSchema<undefined>;
-}, undefined>;
-declare const vHsAccept: v.ObjectSchema<{
-    readonly t: v.LiteralSchema<EHandshakeMessageType.accept, undefined>;
-    readonly signatureBase64: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-}, undefined>;
-declare const vHsReject: v.ObjectSchema<{
-    readonly t: v.LiteralSchema<EHandshakeMessageType.reject, undefined>;
-    readonly reason: v.StringSchema<undefined>;
-}, undefined>;
-declare const vHandshakeMessage: v.VariantSchema<"t", [v.ObjectSchema<{
-    readonly t: v.LiteralSchema<EHandshakeMessageType.hello, undefined>;
-    readonly protocol: v.StringSchema<undefined>;
-    readonly securityLevel: v.PicklistSchema<[ESecurityLevel.none, ESecurityLevel.authenticated, ESecurityLevel.encrypted], undefined>;
-    readonly dictionaryVersion: v.StringSchema<undefined>;
-    readonly client: v.ObjectSchema<{
-        readonly envId: v.StringSchema<undefined>;
-        readonly perId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        readonly insId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>;
-    readonly clientNonce: v.StringSchema<undefined>;
-    readonly verifyPublicKey: v.CustomSchema<`ed25519::raw_base64::${string}`, undefined>;
-    readonly exchangePublicKey: v.OptionalSchema<v.CustomSchema<`x25519::raw_base64::${string}`, undefined>, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly t: v.LiteralSchema<EHandshakeMessageType.welcome, undefined>;
-    readonly securityLevel: v.PicklistSchema<[ESecurityLevel.none, ESecurityLevel.authenticated, ESecurityLevel.encrypted], undefined>;
-    readonly dictionaryVersion: v.StringSchema<undefined>;
-    readonly server: v.ObjectSchema<{
-        readonly envId: v.StringSchema<undefined>;
-        readonly perId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        readonly insId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>;
-    readonly serverNonce: v.StringSchema<undefined>;
-    readonly verifyPublicKey: v.CustomSchema<`ed25519::raw_base64::${string}`, undefined>;
-    readonly exchangePublicKey: v.OptionalSchema<v.CustomSchema<`x25519::raw_base64::${string}`, undefined>, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly t: v.LiteralSchema<EHandshakeMessageType.prove, undefined>;
-    readonly signatureBase64: v.StringSchema<undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly t: v.LiteralSchema<EHandshakeMessageType.accept, undefined>;
-    readonly signatureBase64: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly t: v.LiteralSchema<EHandshakeMessageType.reject, undefined>;
-    readonly reason: v.StringSchema<undefined>;
-}, undefined>], undefined>;
-export type THsHello = v.InferOutput<typeof vHsHello>;
-export type THsWelcome = v.InferOutput<typeof vHsWelcome>;
-export type THsProve = v.InferOutput<typeof vHsProve>;
-export type THsAccept = v.InferOutput<typeof vHsAccept>;
-export type THsReject = v.InferOutput<typeof vHsReject>;
-export type THandshakeMessage = v.InferOutput<typeof vHandshakeMessage>;
-/** Serialize a handshake message for the wire (handshake frames are JSON — they aren't the hot path). */
-export declare function encodeHandshakeMessage(message: THandshakeMessage): string;
-/** Parse + structurally validate an incoming handshake frame; `undefined` if it isn't one. */
-export declare function decodeHandshakeMessage(raw: string): THandshakeMessage | undefined;
-/** Stable link id for a runtime coordinate — the key both the crypto link and the connection use. */
-export declare function runtimeLinkId(coordinate: IRuntimeCoordinate): TTypeAndId;
-/**
- * Everything needed to re-derive the shared AES-GCM key for an `encrypted` link after a restart —
- * the remote's public keys + the HKDF salt/info used at handshake time. The local (server) key pair is
- * recovered from its own persisted `ClientCryptoKeyLink` storage, so re-linking with this material
- * yields the identical shared key without a fresh handshake.
- */
-export interface IHandshakeEncryptionKeyMaterial {
-    verifyPublicKey: TSerializedCryptoKeyData_Ed25519_Raw;
-    exchangePublicKey: TSerializedCryptoKeyData_X25519_Raw;
-    saltString: string;
-    infoString: string;
-    bindVerifyKeysIntoDerivation: boolean;
-}
-/** Outcome of a completed handshake — what the transport/handler needs to wire the channel. */
-export interface IHandshakeResult {
-    /** The crypto-link id (and connection-registry key) for the authenticated remote. */
-    linkedClientId: TTypeAndId;
-    /** The remote's authenticated coordinate. */
-    remote: IRuntimeCoordinate;
-    securityLevel: ESecurityLevel;
-    /** For the `encrypted` level: material to restore the shared key after eviction (persist it). */
-    encryptionKeyMaterial?: IHandshakeEncryptionKeyMaterial;
-}
-export interface IClientVerifyKeyResolveInput {
-    client: IRuntimeCoordinate;
-    verifyPublicKey: TSerializedCryptoKeyData_Ed25519_Raw;
-}
-export interface IClientVerifyKeyResolver {
-    /**
-     * Decide whether a presented verify key is trusted for a client identity. The signature is already
-     * verified by the time this runs, so this is purely the identity-pinning decision. Swap in a
-     * persistent / pre-provisioned implementation without touching the protocol.
-     */
-    resolve(input: IClientVerifyKeyResolveInput): Promise<{
-        trusted: boolean;
-        reason?: string;
-    }>;
-}
-/**
- * In-memory trust-on-first-use resolver: trusts (and pins) the first verify key seen for a client
- * identity, then rejects a different key for that identity. The default; replace with a storage-backed
- * resolver for cross-restart pinning (see Step 5).
- */
-export declare function createInMemoryTofuVerifyKeyResolver(): IClientVerifyKeyResolver;
-/**
- * Storage-backed trust-on-first-use resolver: pins survive process restarts / Durable Object eviction
- * (e.g. back it with `createDurableObjectStorageAdapter`). Same policy as the in-memory variant — trust
- * + pin the first verify key per client identity, reject a different one thereafter.
- */
-export declare function createStorageTofuVerifyKeyResolver(storageAdapter: StorageAdapter): IClientVerifyKeyResolver;
-export interface IClientHandshakeConfig {
-    link: ClientCryptoKeyLink;
-    localCoordinate: IRuntimeCoordinate;
-    dictionaryVersion: string;
-    securityLevel: ESecurityLevel;
-}
-export declare function createClientHandshake(config: IClientHandshakeConfig): {
-    createHello(): Promise<THsHello>;
-    onWelcome(welcome: THsWelcome): Promise<THsProve>;
-    onAccept(accept: THsAccept): Promise<IHandshakeResult>;
-};
-export interface IServerHandshakeConfig {
-    link: ClientCryptoKeyLink;
-    localCoordinate: IRuntimeCoordinate;
-    dictionaryVersion: string;
-    /**
-     * The level(s) this server accepts. A single level is strict (the client must match). An array is a
-     * negotiable allowed set — the server adopts whichever level the client requests, as long as it's in
-     * the set (lets one backend serve `authenticated` and `encrypted` clients at once). `none` in the set
-     * is handled by the transport/handler (a `none` client never reaches the handshake).
-     */
-    securityLevel: ESecurityLevel | readonly ESecurityLevel[];
-    /** Trust decision for a client's verify key. Defaults to in-memory TOFU. */
-    verifyKeyResolver?: IClientVerifyKeyResolver;
-}
-export declare function createServerHandshake(config: IServerHandshakeConfig): {
-    onHello(hello: THsHello): Promise<THsWelcome | THsReject>;
-    onProve(prove: THsProve): Promise<THsAccept | THsReject>;
-    /** The completed handshake result once `onProve` has accepted, else `undefined`. */
-    getResult(): IHandshakeResult | undefined;
-};
-export {};

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

@@ -1,20 +0,0 @@
-import type { ActionDomain } from "../../../../../ActionDefinition/Domain/ActionDomain";
-import type { IActionTransportReadyData_Ws } from "./TransportWebSocket.types";
-/**
- * Builds a *stateless* `formatMessage` pipeline for {@link WebSocketTransport}, packing action
- * payloads into a compact msgpackr binary frame instead of JSON. The `domain`/`id` route collapses to
- * a single integer drawn from a shared dictionary; `form`/`type`, the recomputable
- * `inputHash`/`outputHash`, and the per-frame `context.routing`/`context.timeCreated` are all dropped
- * (see {@link ENVELOPE}).
- *
- * No validation runs here: `incoming` blindly reconstructs the wire JSON shape and hands it back to
- * the connection, which flows into `ActionRuntime` → `domain.hydrateAnyAction()` where the Valibot
- * schemas validate it exactly as they would for a JSON frame.
- *
- * Both ends of the socket MUST construct the adapter with the same domains in the same order — the
- * integer dictionary is positional. Mismatched dictionaries will route to the wrong action.
- *
- * Because `incoming` returns `undefined` for text frames, a binary server can still serve plain-JSON
- * clients on the same runtime (the connection falls back to its built-in JSON parser).
- */
-export declare function createBinaryWsAdapter(domains: ActionDomain<any>[]): NonNullable<IActionTransportReadyData_Ws["formatMessage"]>;

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

@@ -1,31 +0,0 @@
-import type { ActionDomain } from "../../../../../ActionDefinition/Domain/ActionDomain";
-import type { IActionTransportReadyData_Ws } from "./TransportWebSocket.types";
-type TFormatMessage = NonNullable<IActionTransportReadyData_Ws["formatMessage"]>;
-export interface IBinaryWsSessionOptions {
-    /** Override how long an unresolved correlation is retained before being swept (ms). */
-    correlationTtlMs?: number;
-}
-/**
- * Builds a factory of *stateful, per-connection* codecs for {@link WebSocketTransport} /
- * `ActionServerHandler` — the maximally compact binary wire. Call the returned factory once per live
- * connection (each socket on the client, each accepted connection on the server) so every channel
- * gets its own correlation + identity state.
- *
- * On top of everything {@link createBinaryWsAdapter} drops, a session also drops:
- * - **`cuid`** — replaced by a per-connection integer correlation id. The initiator maps it to its
- *   real cuid; the responder echoes it; each side reconstructs the cuid from its own map. Correlation
- *   only needs to be unique per socket, so a counter suffices.
- * - **`originClient` after the first request** — the first request each side sends carries its
- *   identity; the peer remembers it and injects it into later frames. Replies omit it entirely (a
- *   reply carries the initiator's own origin, which the initiator already knows).
- *
- * Both ends MUST build the factory from the same domains in the same order (positional dictionary).
- * Text frames still return `undefined` from `incoming`, so JSON clients remain interoperable.
- *
- * Hibernation note: after a server connection is evicted its session resets, so a still-connected
- * client (whose session persists) will keep omitting `originClient`. The server must therefore restore
- * the connection→client binding from its own store (see `ActionServerHandler.rehydrateConnection`) and
- * inject `originClient` from there — the session alone can't recover it.
- */
-export declare function createBinaryWsSessionFactory(domains: ActionDomain<any>[], options?: IBinaryWsSessionOptions): () => TFormatMessage;
-export {};

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

@@ -1,63 +0,0 @@
-import { type StorageAdapter } from "@nice-code/util";
-import type { ActionDomain } from "../../../../../ActionDefinition/Domain/ActionDomain";
-import type { ActionRuntime } from "../../../../ActionRuntime";
-import type { ITransportRouteActionParams, ITransportRouteInfo, TUpdateActionRunConfig } from "../Transport.types";
-import { ESecurityLevel } from "./actionWsHandshake";
-import { type IBinaryWsSessionOptions } from "./createBinaryWsSessionFactory";
-import type { IActionTransportReadyData_Ws } from "./TransportWebSocket.types";
-import { WebSocketTransport } from "./WebSocketTransport";
-/** The per-connection binary session codec — built once per socket from the channel's domains. */
-type TChannelCodec = NonNullable<IActionTransportReadyData_Ws["formatMessage"]>;
-/**
- * The shared identity of a secure WebSocket channel: the wire dictionary version both ends check
- * during the handshake, plus the per-connection codec factory both ends build from the *same* domain
- * list. Define it once (typically in code shared by client and server) and hand it to
- * {@link createSecureWebSocketTransport} on the client and `createSecureActionServerHandler` on the
- * server, so the codec and version can never drift apart.
- */
-export interface ISecureWsChannel {
-    /** Wire dictionary version — derived from the domains by default; the handshake rejects a mismatch. */
-    dictionaryVersion: string;
-    /** Per-connection session codec factory (call once per live connection). */
-    createCodec: () => TChannelCodec;
-}
-/**
- * Bundle a secure channel's shared identity from its transported domains. Both ends MUST call this
- * with the same domains in the same order (the binary wire dictionary is positional). The
- * `dictionaryVersion` is derived from those domains unless you pin an explicit one.
- */
-export declare function defineSecureWsChannel(options: {
-    /** Domains transported over this channel, in a stable order. Add new ones to the *end*. */
-    domains: ActionDomain<any>[];
-    /** Pin a human-readable version instead of the derived hash (must match on both ends). */
-    dictionaryVersion?: string;
-    /** Tuning for the per-connection binary session (e.g. correlation TTL). */
-    sessionOptions?: IBinaryWsSessionOptions;
-}): ISecureWsChannel;
-export interface ISecureWebSocketTransportOptions {
-    /** The shared channel identity (codec + dictionary version). */
-    channel: ISecureWsChannel;
-    /** This client's runtime — its coordinate is the authenticated identity sent in the handshake. */
-    runtime: ActionRuntime;
-    /** Backing store for this client's crypto identity (a stable verify key across reloads). */
-    storageAdapter: StorageAdapter;
-    /** The level this client requests; the server must allow it. */
-    securityLevel: ESecurityLevel;
-    /** Endpoint URL — drives both the socket and the per-endpoint cache key. */
-    url: string;
-    /** Override socket creation (defaults to a `new WebSocket(url)` with `binaryType = "arraybuffer"`). */
-    createWebSocket?: (input: ITransportRouteActionParams) => WebSocket;
-    /** Override the reuse key (defaults to `[url]`, so one socket is shared per endpoint). */
-    getTransportCacheKey?: (input: ITransportRouteActionParams) => string[];
-    updateRunConfig?: TUpdateActionRunConfig;
-    getRouteInfo?: (input: ITransportRouteActionParams) => ITransportRouteInfo;
-}
-/**
- * Build a {@link WebSocketTransport} for the secure binary channel with the boilerplate folded in: it
- * creates the {@link ClientCryptoKeyLink} from `storageAdapter`, opens an `arraybuffer` socket to
- * `url`, caches it per endpoint, installs the channel's per-connection codec, and assembles the
- * `security` block from the runtime coordinate + channel version. Pass `createWebSocket` /
- * `getTransportCacheKey` to take over those bits when you need to.
- */
-export declare function createSecureWebSocketTransport(options: ISecureWebSocketTransportOptions): WebSocketTransport;
-export {};

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

@@ -1,11 +0,0 @@
-/**
- * Send a text or binary frame over a socket. A binary formatter may hand back a `Uint8Array` whose
- * backing buffer is typed as `ArrayBufferLike` (msgpackr pools buffers / may be `SharedArrayBuffer`),
- * which `WebSocket.send`'s `BufferSource` parameter rejects — copy it into a fresh `ArrayBuffer`-backed
- * view so the type (and the bytes) are safe to send.
- */
-export declare function sendFrame(ws: WebSocket, data: string | Uint8Array | ArrayBuffer): void;
-/** Normalize any frame form to bytes (for the AES-GCM layer, which works on `Uint8Array`). */
-export declare function toFrameBytes(frame: string | Uint8Array | ArrayBuffer): Uint8Array;
-/** Compact a WebSocket URL to `host/pathname` for devtools display, falling back to the raw url. */
-export declare function shortWs(url: string): string;

package/build/types/ActionRuntime/Handler/ExternalClient/Transport/err_nice_transport.d.ts

@@ -1,36 +0,0 @@
-import type { ETransportType } from "./Transport.types";
-export declare enum EErrId_NiceTransport {
-    timeout = "timeout",
-    not_found = "not_found",
-    unsupported = "unsupported",
-    initialization_failed = "initialization_failed",
-    send_failed = "send_failed",
-    invalid_action_response = "invalid_action_response"
-}
-export declare const err_nice_transport: import("@nice-code/error").NiceErrorDomain<{
-    domain: string;
-    allDomains: [string, string, string, "err_nice"];
-    schema: {
-        timeout: import("@nice-code/error").INiceErrorIdMetadata<{
-            timeout: number;
-        }, import("@nice-code/error").JSONSerializableValue>;
-        not_found: import("@nice-code/error").INiceErrorIdMetadata<{
-            actionId: string;
-        }, import("@nice-code/error").JSONSerializableValue>;
-        unsupported: import("@nice-code/error").INiceErrorIdMetadata<{
-            transportTypes: ETransportType[];
-        }, import("@nice-code/error").JSONSerializableValue>;
-        initialization_failed: import("@nice-code/error").INiceErrorIdMetadata<{
-            actionId: string;
-        }, import("@nice-code/error").JSONSerializableValue>;
-        send_failed: import("@nice-code/error").INiceErrorIdMetadata<{
-            actionState: string;
-            actionId: string;
-            httpStatusCode?: number;
-            message?: string;
-        }, import("@nice-code/error").JSONSerializableValue>;
-        invalid_action_response: import("@nice-code/error").INiceErrorIdMetadata<{
-            actionId: string;
-        }, import("@nice-code/error").JSONSerializableValue>;
-    };
-}>;

package/build/types/ActionRuntime/Handler/ExternalClient/Transport/err_nice_transport_ws.d.ts

@@ -1,18 +0,0 @@
-export declare enum EErrId_NiceTransport_WebSocket {
-    ws_disconnected = "ws_disconnected",
-    ws_create_failed = "ws_create_failed",
-    ws_error = "ws_error"
-}
-export declare const err_nice_transport_ws: import("@nice-code/error").NiceErrorDomain<{
-    domain: string;
-    allDomains: [string, string, string, string, "err_nice"];
-    schema: {
-        ws_disconnected: import("@nice-code/error").INiceErrorIdMetadata<Record<string, never>, import("@nice-code/error").JSONSerializableValue>;
-        ws_create_failed: import("@nice-code/error").INiceErrorIdMetadata<{
-            originalError?: Error;
-        }, import("@nice-code/error").JSONSerializableValue>;
-        ws_error: import("@nice-code/error").INiceErrorIdMetadata<{
-            originalError?: Error;
-        }, import("@nice-code/error").JSONSerializableValue>;
-    };
-}>;

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

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

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

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

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

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

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

@@ -1,55 +0,0 @@
-import type { ActionCore } from "../../../ActionDefinition/Action/Core/ActionCore";
-import type { IActionRouteItemHandler } from "../../../ActionDefinition/Action/Payload/ActionPayload.types";
-import { ActionPayload_Request } from "../../../ActionDefinition/Action/Payload/ActionPayload_Request";
-import { RunningAction } from "../../../ActionDefinition/Action/RunningAction";
-import type { ActionDomain } from "../../../ActionDefinition/Domain/ActionDomain";
-import type { IActionDomain } from "../../../ActionDefinition/Domain/ActionDomain.types";
-import { ActionRouter } from "../../Routing/ActionRouter";
-import { ActionHandler } from "../ActionHandler";
-import { EActionHandlerType, type IActionHandler_Local, type IActionHandler_Local_Json, type IHandleActionOptions } from "../ActionHandler.types";
-import type { THandleActionExecutionFn } from "./ActionLocalHandler.types";
-export declare class ActionLocalHandler extends ActionHandler<EActionHandlerType.local> implements IActionHandler_Local {
-    readonly handlerType = EActionHandlerType.local;
-    readonly actionRouter: ActionRouter<THandleActionExecutionFn<any, any>>;
-    constructor();
-    /**
-     * Register a handler for all actions in a domain.
-     * Receives the full primed action — use `matchAction()` to narrow to a specific action id.
-     * Useful for forwarding all domain actions to a remote endpoint.
-     * Lower priority than `forAction`.
-     */
-    forDomain<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>, handler: THandleActionExecutionFn<FOR_DOM>): this;
-    /**
-     * Register a handler for a base action instance. Takes priority over domain-wide handlers.
-     * Receives the full primed action with narrowed input type.
-     * Useful for handling specific actions locally while forwarding the rest of the domain. For example, a local "ping" action that checks connectivity without needing a round trip.
-     */
-    forAction<ACT_DOM extends IActionDomain, ID extends keyof ACT_DOM["actionSchema"] & string>(action: ActionCore<ACT_DOM, ID>, handler: THandleActionExecutionFn<ACT_DOM, ID>): this;
-    /**
-     * Register a handler for multiple action IDs (first-match-wins among cases).
-     * Receives the full primed action narrowed to the union of those IDs.
-     * Use `act.coreAction.id` to branch on which action was dispatched.
-     */
-    forActionIds<ACT_DOM extends IActionDomain, IDS extends ReadonlyArray<keyof ACT_DOM["actionSchema"] & string>>(domain: ActionDomain<ACT_DOM>, ids: IDS, handler: THandleActionExecutionFn<ACT_DOM, IDS[number]>): this;
-    /**
-     * Register per-action handlers for a domain using a single map, without needing
-     * separate `forAction` calls. Unregistered action IDs are unaffected.
-     *
-     * @example
-     * ```ts
-     * handler.forDomainActionCases(userDomain, {
-     *   getUser:    (primed) => db.getUser(primed.input.userId),
-     *   deleteUser: (primed) => db.deleteUser(primed.input.userId),
-     * });
-     * ```
-     */
-    forDomainActionCases<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>, cases: {
-        [ID in keyof FOR_DOM["actionSchema"] & string]?: THandleActionExecutionFn<FOR_DOM, ID>;
-    }): this;
-    handleActionRequest<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(action: ActionPayload_Request<DOM, ID>, config?: IHandleActionOptions): Promise<RunningAction<DOM, ID>>;
-    private _handleRunningAction;
-    handlePayloadWireOrThrow(wire: unknown, config?: IHandleActionOptions): Promise<RunningAction<any, any>>;
-    toJsonObject(): IActionHandler_Local_Json;
-    toHandlerRouteItem(): IActionRouteItemHandler;
-}
-export declare const createLocalHandler: () => ActionLocalHandler;

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

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