@nice-code/action 0.8.0 → 0.9.0

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

@@ -1,16 +0,0 @@
-import { type IActionTransportReady, type ITransportRouteActionParams, type TTransportCache } from "./Transport.types";
-import type { TransportConnection } from "./TransportConnection";
-export declare class ConnectionTransportManager {
-    private _cache;
-    private _transports;
-    constructor(_cache: TTransportCache);
-    addTransport(transport: TransportConnection): void;
-    /**
-     * The highest-priority transport (first declared). Used to label an action's route *before* the
-     * transport has finished connecting — so a still-connecting action shows its (expected) destination
-     * instead of an "unknown" hop. {@link getReadyTransport} still decides the real winner, and the
-     * caller corrects the hop if a lower-priority transport ends up serving the action.
-     */
-    getPreferredTransport(): TransportConnection | undefined;
-    getReadyTransport(routeActionParams: ITransportRouteActionParams): Promise<IActionTransportReady>;
-}

package/build/types/ActionRuntime/Handler/ExternalClient/Transport/Custom/CustomConnection.d.ts

@@ -1,7 +0,0 @@
-import { ETransportType, type IActionTransportReadyData_Methods, type ITransportRouteActionParams } from "../Transport.types";
-import { TransportConnection } from "../TransportConnection";
-import type { IActionTransportDef_Custom, IActionTransportInitialized_Custom, IActionTransportReadyData_Custom, TActionTransportDef_Custom_NoType } from "./TransportCustom.types";
-export declare class CustomConnection extends TransportConnection<ETransportType.custom, ITransportRouteActionParams, IActionTransportReadyData_Custom, IActionTransportInitialized_Custom, IActionTransportDef_Custom> {
-    constructor(def: TActionTransportDef_Custom_NoType);
-    protected _finalizeTransportMethods(inputs: IActionTransportReadyData_Custom): IActionTransportReadyData_Methods;
-}

package/build/types/ActionRuntime/Handler/ExternalClient/Transport/Custom/CustomTransport.d.ts

@@ -1,43 +0,0 @@
-import { type ITransportConnectionContext, Transport } from "../Transport";
-import { ETransportType, type ITransportMethod_SendActionData_Input, type ITransportRouteActionParams, type ITransportRouteInfo, type TSendReturnDataMethod, type TUpdateActionRunConfig } from "../Transport.types";
-import { CustomConnection } from "./CustomConnection";
-import type { IActionTransportInitialized_Custom } from "./TransportCustom.types";
-interface ICustomTransportSharedOptions {
-    updateRunConfig?: TUpdateActionRunConfig;
-    getTransportCacheKey?: (input: ITransportRouteActionParams) => string[];
-    /** Short label shown in the devtools chip (defaults to "custom"). */
-    label?: string;
-    /** Override the devtools route info for a specific action. */
-    getRouteInfo?: (input: ITransportRouteActionParams) => ITransportRouteInfo;
-}
-export interface ICustomTransportSendOptions extends ICustomTransportSharedOptions {
-    /** Send a request/progress payload to the external client. */
-    sendActionData: (input: ITransportMethod_SendActionData_Input) => void;
-    /** Optional return-path dispatch for bidirectional channels. */
-    sendReturnData?: TSendReturnDataMethod;
-    closeTransport?: (input?: ITransportRouteActionParams) => void;
-}
-export interface ICustomTransportAdvancedOptions extends ICustomTransportSharedOptions {
-    /** Full control over readiness/initialization for the custom channel. */
-    getTransport: IActionTransportInitialized_Custom["getTransport"];
-}
-export type TCustomTransportOptions = (ICustomTransportSendOptions & {
-    mode: "send";
-}) | (ICustomTransportAdvancedOptions & {
-    mode: "advanced";
-});
-/**
- * Reusable custom transport definition for channels nice-action doesn't model natively. Create one
- * with `CustomTransport.create({ sendActionData })` for the simple case, or
- * `CustomTransport.createAdvanced({ getTransport })` for full control over the lifecycle.
- */
-export declare class CustomTransport extends Transport<ETransportType.custom> {
-    private readonly options;
-    readonly type = ETransportType.custom;
-    constructor(options: TCustomTransportOptions);
-    static create(options: ICustomTransportSendOptions): CustomTransport;
-    static createAdvanced(options: ICustomTransportAdvancedOptions): CustomTransport;
-    _createConnection(_ctx: ITransportConnectionContext): CustomConnection;
-    getRouteInfo(input: ITransportRouteActionParams): ITransportRouteInfo;
-}
-export {};

package/build/types/ActionRuntime/Handler/ExternalClient/Transport/Custom/TransportCustom.types.d.ts

@@ -1,11 +0,0 @@
-import type { ETransportType, IActionTransportDef, IActionTransportInitialized, IActionTransportReadyData_Base, ITransportMethod_SendActionData_Input, ITransportRouteActionParams, TSendReturnDataMethod } from "../Transport.types";
-export interface IActionTransportReadyData_Custom extends IActionTransportReadyData_Base {
-    sendActionData: (input: ITransportMethod_SendActionData_Input) => void;
-    sendReturnData?: TSendReturnDataMethod;
-    closeTransport: (input?: ITransportRouteActionParams) => void;
-}
-export interface IActionTransportInitialized_Custom extends IActionTransportInitialized<ITransportRouteActionParams, IActionTransportReadyData_Custom> {
-}
-export interface IActionTransportDef_Custom extends IActionTransportDef<ETransportType.custom, IActionTransportInitialized_Custom> {
-}
-export type TActionTransportDef_Custom_NoType = Omit<IActionTransportDef_Custom, "type">;

package/build/types/ActionRuntime/Handler/ExternalClient/Transport/Http/HttpConnection.d.ts

@@ -1,8 +0,0 @@
-import { ETransportType, type IActionTransportReadyData_Methods, type ITransportDispatchAction, type ITransportRouteActionParams } from "../Transport.types";
-import { TransportConnection } from "../TransportConnection";
-import type { IActionTransportDef_Http, IActionTransportInitialized_Http, IActionTransportReadyData_Http, IActionTransportReadyParams_Http } from "./TransportHttp.types";
-export declare class HttpConnection extends TransportConnection<ETransportType.http, ITransportRouteActionParams, IActionTransportReadyData_Http, IActionTransportInitialized_Http, IActionTransportDef_Http> {
-    constructor(def: Omit<IActionTransportDef_Http, "type">);
-    _finalizeTransportMethods(methods: IActionTransportReadyData_Http): IActionTransportReadyData_Methods;
-    protected send(input: ITransportDispatchAction<IActionTransportReadyParams_Http>): Promise<void>;
-}

package/build/types/ActionRuntime/Handler/ExternalClient/Transport/Http/HttpTransport.d.ts

@@ -1,26 +0,0 @@
-import { type ITransportConnectionContext, Transport } from "../Transport";
-import { ETransportType, type ITransportRouteActionParams, type ITransportRouteInfo, type TUpdateActionRunConfig } from "../Transport.types";
-import { HttpConnection } from "./HttpConnection";
-import type { IHttpRequestParams } from "./TransportHttp.types";
-export interface IHttpTransportOptions {
-    /**
-     * Build the HTTP request for an action. Return a static request for the simple case, or derive the
-     * url / headers / body from the action params for full control.
-     */
-    createRequest: (input: ITransportRouteActionParams) => IHttpRequestParams;
-    updateRunConfig?: TUpdateActionRunConfig;
-    getTransportCacheKey?: (input: ITransportRouteActionParams) => string[];
-}
-/**
- * Reusable HTTP transport definition. Create one with `HttpTransport.create({ createRequest })` — the
- * single `createRequest` function lets you keep it simple (`() => ({ url })`) or derive the request
- * per action.
- */
-export declare class HttpTransport extends Transport<ETransportType.http> {
-    private readonly options;
-    readonly type = ETransportType.http;
-    constructor(options: IHttpTransportOptions);
-    static create(options: IHttpTransportOptions): HttpTransport;
-    _createConnection(_ctx: ITransportConnectionContext): HttpConnection;
-    getRouteInfo(input: ITransportRouteActionParams): ITransportRouteInfo;
-}

package/build/types/ActionRuntime/Handler/ExternalClient/Transport/Http/TransportHttp.types.d.ts

@@ -1,16 +0,0 @@
-import type { ETransportType, IActionTransportDef, IActionTransportInitialized, IActionTransportReadyData_Base, ITransportRouteActionParams } from "../Transport.types";
-export interface IHttpRequestParams {
-    url: string;
-    headers?: Record<string, string>;
-    body?: string;
-}
-export interface IActionTransportReadyParams_Http {
-    request: IHttpRequestParams;
-}
-export interface IActionTransportReadyData_Http extends IActionTransportReadyData_Base {
-    createRequest: (input: ITransportRouteActionParams) => IHttpRequestParams;
-}
-export interface IActionTransportInitialized_Http extends IActionTransportInitialized<ITransportRouteActionParams, IActionTransportReadyData_Http> {
-}
-export interface IActionTransportDef_Http extends IActionTransportDef<ETransportType.http, IActionTransportInitialized_Http> {
-}

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

@@ -1,27 +0,0 @@
-import type { IActionTransportResolvers } from "./Transport.types";
-import { type ETransportType, type ITransportRouteActionParams, type ITransportRouteInfo } from "./Transport.types";
-import type { TransportConnection } from "./TransportConnection";
-/**
- * Context handed to a {@link Transport} definition when a handler builds a live connection from it.
- * Only bidirectional transports (WebSocket / Custom) make use of `resolvers`.
- */
-export interface ITransportConnectionContext {
-    resolvers?: IActionTransportResolvers;
-}
-/**
- * Reusable transport definition. Devs construct these (`HttpTransport.create({ createRequest })`,
- * `WebSocketTransport.create({ createWebSocket })`, …) and pass them to an
- * `ActionExternalClientHandler`. A single
- * definition can be shared across multiple handlers — each handler builds its own live
- * {@link TransportConnection} via {@link TransportConnection._createConnection}.
- */
-export declare abstract class Transport<T extends ETransportType = ETransportType> {
-    abstract readonly type: T;
-    /** Internal: build a fresh, per-handler live connection from this definition. */
-    abstract _createConnection(ctx: ITransportConnectionContext): TransportConnection<T>;
-    /**
-     * Resolve human-readable info about how a specific action would be routed through this transport
-     * (e.g. the request URL/method, or the WebSocket endpoint). Surfaced in the action devtools.
-     */
-    abstract getRouteInfo(input: ITransportRouteActionParams): ITransportRouteInfo;
-}

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

@@ -1,131 +0,0 @@
-import type { NiceError } from "@nice-code/error";
-import type { IActionPayload_Request_JsonObject, IActionPayload_Result_JsonObject, TActionPayload_Any_Instance, TActionPayload_Any_JsonObject } from "../../../../ActionDefinition/Action/Payload/ActionPayload.types";
-import type { ActionPayload_Request } from "../../../../ActionDefinition/Action/Payload/ActionPayload_Request";
-import type { ActionPayload_Result } from "../../../../ActionDefinition/Action/Payload/ActionPayload_Result";
-import type { RunningAction } from "../../../../ActionDefinition/Action/RunningAction";
-import type { RuntimeCoordinate } from "../../../RuntimeCoordinate";
-import type { TransportConnection } from "./TransportConnection";
-export declare enum ETransportType {
-    ws = "ws",
-    http = "http",
-    custom = "custom"
-}
-/**
- * Serializable, display-only description of how an action was routed through a transport. Stored on
- * the action's route items and shown in the devtools external-handler chips. Keep this free of
- * sensitive data (e.g. auth headers) — route items travel over the wire.
- */
-export interface ITransportRouteInfo {
-    type: ETransportType;
-    /** Short label for chips, e.g. "POST /resolve_action" or "ws host/resolve_action/ws". */
-    summary?: string;
-    url?: string;
-    method?: string;
-    detail?: Record<string, string | number | boolean>;
-}
-export interface IUpdateActionRunConfig_Output {
-    timeout?: number;
-}
-export type TUpdateActionRunConfig = (input: ITransportRouteActionParams & {
-    timeout: number;
-}) => IUpdateActionRunConfig_Output;
-export interface IActionTransportReadyData_Base {
-    updateRunConfig?: TUpdateActionRunConfig;
-}
-/**
- *
- *  TRANSPORT READINESS RESPONSE
- *
- */
-export declare enum ETransportStatus {
-    uninitialized = "uninitialized",
-    unsupported = "unsupported",
-    initializing = "initializing",
-    ready = "ready",
-    failed = "failed"
-}
-export interface ITransportStatusInfo_Base<S extends ETransportStatus> {
-    status: S;
-}
-export interface ITransportStatusInfo_Failed extends ITransportStatusInfo_Base<ETransportStatus.failed> {
-    error: NiceError;
-    timeFailed: number;
-}
-export interface ITransportStatusInfo_Unsupported extends ITransportStatusInfo_Base<ETransportStatus.unsupported> {
-}
-export interface ITransportStatusInfo_Ready<READY extends IActionTransportReadyData_Base> extends ITransportStatusInfo_Base<ETransportStatus.ready> {
-    readyData: READY;
-}
-export type TTransportInitializationFinishedInfo<READY extends IActionTransportReadyData_Base> = ITransportStatusInfo_Ready<READY> | ITransportStatusInfo_Failed | ITransportStatusInfo_Unsupported;
-export interface ITransportStatusInfo_Initializing<READY extends IActionTransportReadyData_Base> extends ITransportStatusInfo_Base<ETransportStatus.initializing> {
-    timeStarted: number;
-    initializationPromise: Promise<TTransportInitializationFinishedInfo<READY>>;
-}
-export type TTransportStatusInfo<READY extends IActionTransportReadyData_Base> = ITransportStatusInfo_Base<ETransportStatus.uninitialized> | ITransportStatusInfo_Unsupported | ITransportStatusInfo_Initializing<READY> | ITransportStatusInfo_Ready<READY> | ITransportStatusInfo_Failed;
-export type TTransportStatusInfo_GetTransport_Output<READY extends IActionTransportReadyData_Base> = ITransportStatusInfo_Base<ETransportStatus.uninitialized> | ITransportStatusInfo_Unsupported | Omit<ITransportStatusInfo_Initializing<READY>, "timeStarted"> | ITransportStatusInfo_Ready<READY> | Omit<ITransportStatusInfo_Failed, "timeFailed">;
-/**
- *
- *  TRANSPORT ROUTING
- *
- */
-export interface ITransportRouteClientParams {
-    localClient: RuntimeCoordinate;
-    externalClient: RuntimeCoordinate;
-}
-export interface ITransportRouteActionParams extends ITransportRouteClientParams {
-    action: TActionPayload_Any_Instance<any, any>;
-}
-export interface ITransportMethod_SendActionData_Input extends ITransportRouteActionParams {
-    runningAction: RunningAction<any, any>;
-    timeout: number;
-}
-export interface ITransportDispatchAction<P> extends ITransportMethod_SendActionData_Input {
-    params: P;
-}
-export type TSendActionDataMethod = (input: ITransportMethod_SendActionData_Input) => void;
-export type TSendReturnDataMethod = (payload: TActionPayload_Any_Instance<any, any>, 
-/**
- * The local/external client pair this payload is being returned over. Bidirectional transports use
- * it to build the full route params their outgoing formatter expects (e.g. binary packing). Optional
- * so existing return-data implementations keep type-checking.
- */
-clients?: ITransportRouteClientParams) => void;
-export interface IActionTransportReadyData_Methods extends IActionTransportReadyData_Base {
-    sendActionData: TSendActionDataMethod;
-    /**
-     * Optional — implement on bidirectional transports (WebSocket, Custom) to enable return-path
-     * routing. When present, the runtime uses this to dispatch results and progress payloads directly
-     * back to `originClient` without going through the original request transport.
-     */
-    sendReturnData?: TSendReturnDataMethod;
-    addOnDisconnectListener?: (callback: () => void) => void;
-    /**
-     * Optional — implement on transports holding a long-lived connection (WebSocket, Custom) to close it
-     * deliberately. Called by `ActionExternalClientHandler.clearTransportCache()` so a teardown actually
-     * releases the underlying socket instead of leaving it open until GC.
-     */
-    disconnect?: () => void;
-}
-export interface IActionTransportReady {
-    methods: IActionTransportReadyData_Methods;
-    transport: TransportConnection;
-}
-export type TTransportCache = Map<string, IActionTransportReady | Promise<IActionTransportReady>>;
-export type TOnResolveIncomingRequest = (request: ActionPayload_Request<any>) => void;
-export type TOnResolveIncomingRequestJson = (request: IActionPayload_Request_JsonObject<any>) => void;
-export type TOnResolveIncomingResponse = (response: ActionPayload_Result<any>) => void;
-export type TOnResolveIncomingResponseJson = (response: IActionPayload_Result_JsonObject<any>) => void;
-export type TOnResolveAnyIncomingActionData = (actionData: ActionPayload_Request<any> | ActionPayload_Result<any>) => void;
-export type TOnResolveAnyIncomingActionData_Json = (actionData: TActionPayload_Any_JsonObject<any>) => void;
-export interface IActionTransportResolvers {
-    onIncomingActionDataJson: TOnResolveAnyIncomingActionData_Json;
-}
-export type TGetTransportFn<IN extends ITransportRouteActionParams, READY extends IActionTransportReadyData_Base> = (input: IN) => TTransportStatusInfo_GetTransport_Output<READY>;
-export interface IActionTransportInitialized<IN extends ITransportRouteActionParams, READY extends IActionTransportReadyData_Base> {
-    getTransportCacheKey?: (input: IN) => string[];
-    getTransport: TGetTransportFn<IN, READY>;
-}
-export interface IActionTransportDef<TYPE extends ETransportType, INIT extends IActionTransportInitialized<any, any>> {
-    type: TYPE;
-    initialize: () => INIT;
-}

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

@@ -1,27 +0,0 @@
-import type { Transport } from "./Transport";
-import { type ETransportType, type IActionTransportDef, type IActionTransportInitialized, type IActionTransportReadyData_Base, type IActionTransportReadyData_Methods, type ITransportRouteActionParams, type ITransportRouteInfo, type TTransportStatusInfo } from "./Transport.types";
-/**
- * Live, per-handler transport runtime built from a reusable {@link Transport} definition. Holds the
- * connection-scoped state (ordinal, initialized config, sockets / abort sets) that must not be shared
- * across handlers. Construct these via `definition._createConnection(...)`, never directly.
- */
-export declare abstract class TransportConnection<T extends ETransportType = ETransportType, RP extends ITransportRouteActionParams = ITransportRouteActionParams, RD extends IActionTransportReadyData_Base = IActionTransportReadyData_Base, I extends IActionTransportInitialized<RP, RD> = IActionTransportInitialized<RP, RD>, DEF extends IActionTransportDef<T, I> = IActionTransportDef<T, I>> {
-    readonly def: DEF;
-    readonly transOrd: number;
-    readonly type: T;
-    readonly initialized: I;
-    /** Backref to the public definition that created this connection (used for devtools route info). */
-    definition?: Transport<T>;
-    constructor(def: DEF);
-    /**
-     * Devtools route info for an action routed through this live connection. Defaults to the stateless
-     * {@link definition}'s info; connections override to enrich it from live state (e.g. the actual
-     * resolved socket URL) when the definition couldn't resolve it on its own.
-     */
-    getRouteInfo(input: RP): ITransportRouteInfo | undefined;
-    protected abstract _finalizeTransportMethods(inputs: RD): IActionTransportReadyData_Methods;
-    protected _getCacheKey(input: RP): string | null;
-    getCacheKey(input: RP): string | null;
-    getTransport(input: RP): TTransportStatusInfo<IActionTransportReadyData_Methods>;
-    protected _processTransportStatus(input: RP): TTransportStatusInfo<IActionTransportReadyData_Methods>;
-}

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

@@ -1,41 +0,0 @@
-import type { ClientCryptoKeyLink } from "@nice-code/util";
-import type { TActionPayload_Any_JsonObject } from "../../../../../ActionDefinition/Action/Payload/ActionPayload.types";
-import type { IRuntimeCoordinate } from "../../../../RuntimeCoordinate";
-import type { ETransportType, IActionTransportDef, IActionTransportInitialized, IActionTransportReadyData_Base, ITransportRouteActionParams } from "../Transport.types";
-import type { ESecurityLevel } from "./actionWsHandshake";
-/**
- * Client-side secure-channel config for a WebSocket. When present (and `securityLevel !== none`), the
- * connection runs the {@link createClientHandshake} handshake during initialization — authenticating
- * the identity and, for the `encrypted` level, deriving a shared key that encrypts every action frame.
- */
-export interface IWsClientSecureChannel {
-    securityLevel: ESecurityLevel;
-    /** This client's crypto identity (verify + exchange key pairs, optionally persisted). */
-    link: ClientCryptoKeyLink;
-    /** This client's runtime coordinate — its authenticated identity to the server. */
-    localCoordinate: IRuntimeCoordinate;
-    /** Wire dictionary version; the server rejects the handshake on a mismatch. */
-    dictionaryVersion: string;
-}
-export interface IActionTransportReadyData_Ws extends IActionTransportReadyData_Base {
-    formatMessage?: {
-        /**
-         * Pack an outgoing action payload. Return a `string` for text frames (JSON) or a binary
-         * `Uint8Array`/`ArrayBuffer` for optimized binary frames (e.g. msgpackr).
-         */
-        outgoing: (input: ITransportRouteActionParams) => string | Uint8Array | ArrayBuffer;
-        /**
-         * Unpack an incoming frame back into the wire JSON object the runtime hydrates + validates.
-         * Return `undefined` to defer to the connection's built-in JSON parser — this is how binary
-         * adapters stay backward compatible with plain-JSON clients on the same socket.
-         */
-        incoming?: (input: string | ArrayBuffer | Uint8Array | Blob) => TActionPayload_Any_JsonObject<any, any> | undefined;
-    };
-    ws: WebSocket;
-    /** Optional authenticated/encrypted channel; the connection runs the handshake during init. */
-    secureChannel?: IWsClientSecureChannel;
-}
-export interface IActionTransportInitialized_Ws extends IActionTransportInitialized<ITransportRouteActionParams, IActionTransportReadyData_Ws> {
-}
-export interface IActionTransportDef_Ws extends IActionTransportDef<ETransportType.ws, IActionTransportInitialized_Ws> {
-}

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

@@ -1,34 +0,0 @@
-import { ETransportType, type IActionTransportReadyData_Methods, type IActionTransportResolvers, type ITransportRouteActionParams, type ITransportRouteInfo, type TTransportStatusInfo } from "../Transport.types";
-import { TransportConnection } from "../TransportConnection";
-import type { IActionTransportDef_Ws, IActionTransportInitialized_Ws, IActionTransportReadyData_Ws } from "./TransportWebSocket.types";
-export declare class WebSocketConnection extends TransportConnection<ETransportType.ws, ITransportRouteActionParams, IActionTransportReadyData_Ws, IActionTransportInitialized_Ws, IActionTransportDef_Ws> {
-    private resolvers;
-    /** URL of the most recently resolved live socket — surfaced to devtools when the definition can't. */
-    private _liveSocketUrl?;
-    /** Sockets we closed on purpose (via `disconnect`), so their `close` event stays quiet. */
-    private _intentionalCloses;
-    constructor(def: Omit<IActionTransportDef_Ws, "type">, resolvers?: IActionTransportResolvers);
-    protected _getCacheKey(_input: ITransportRouteActionParams): string;
-    protected _processTransportStatus(input: ITransportRouteActionParams): TTransportStatusInfo<IActionTransportReadyData_Methods>;
-    getRouteInfo(input: ITransportRouteActionParams): ITransportRouteInfo | undefined;
-    private _isSecure;
-    private _awaitOpen;
-    /** Non-secure connections finalize synchronously; secure ones run the handshake first. */
-    private _finalize;
-    _finalizeTransportMethods(wsData: IActionTransportReadyData_Ws): IActionTransportReadyData_Methods;
-    /**
-     * Secure path: a single message listener feeds the handshake until it completes, then routes action
-     * frames (decrypting for the `encrypted` level). Frames that arrive in the gap between accept and
-     * activation are buffered and flushed, so nothing is lost.
-     */
-    private _finalizeSecureMethods;
-    private _runClientHandshake;
-    private _buildSendMethods;
-    /** Decode (and, when encrypted, decrypt) one inbound action frame and hand it to the runtime. */
-    private _handleIncomingActionFrame;
-    /** Accept text + binary frames (ArrayBuffer / Uint8Array / Blob); Blobs are converted to a buffer. */
-    private _normalizeFrame;
-    private _captureSocketUrl;
-    private _attachLifecycle;
-    private _abortAll;
-}

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

@@ -1,60 +0,0 @@
-import { type ITransportConnectionContext, Transport } from "../Transport";
-import { ETransportType, type ITransportRouteActionParams, type ITransportRouteInfo, type TUpdateActionRunConfig } from "../Transport.types";
-import type { IActionTransportInitialized_Ws, IActionTransportReadyData_Ws } from "./TransportWebSocket.types";
-import { WebSocketConnection } from "./WebSocketConnection";
-interface IWebSocketTransportSharedOptions {
-    /** Custom (de)serialization of action payloads on the wire (shared across all sockets). */
-    formatMessage?: IActionTransportReadyData_Ws["formatMessage"];
-    /**
-     * Per-socket codec factory — called once for each socket so stateful codecs (e.g. the
-     * `createBinaryWsSessionFactory` session, which holds per-connection correlation + identity state)
-     * get their own instance and reset cleanly on reconnect. Takes precedence over `formatMessage`.
-     */
-    createFormatMessage?: () => IActionTransportReadyData_Ws["formatMessage"];
-    updateRunConfig?: TUpdateActionRunConfig;
-    /**
-     * Keys that identify a reusable socket, so a single socket is shared across actions to the same
-     * endpoint instead of opening one per action.
-     */
-    getTransportCacheKey?: (input: ITransportRouteActionParams) => string[];
-    /** Override the devtools route info for a specific action. */
-    getRouteInfo?: (input: ITransportRouteActionParams) => ITransportRouteInfo;
-    /**
-     * Secure-channel config. When set (and `securityLevel !== none`), the connection runs the
-     * authenticated handshake during initialization and, at the `encrypted` level, encrypts every frame.
-     */
-    security?: IActionTransportReadyData_Ws["secureChannel"];
-}
-export interface IWebSocketTransportSocketOptions extends IWebSocketTransportSharedOptions {
-    /** Open (or reuse) the WebSocket for an action — keep it simple or derive it per action. */
-    createWebSocket: (input: ITransportRouteActionParams) => WebSocket;
-}
-export interface IWebSocketTransportAdvancedOptions extends IWebSocketTransportSharedOptions {
-    /**
-     * Full control over readiness/initialization. Use this for contextual support detection (return
-     * `{ status: ETransportStatus.unsupported }` when the socket shouldn't be used) or async url
-     * building (return `{ status: ETransportStatus.initializing, initializationPromise }` that resolves
-     * to a `ready` socket).
-     */
-    getTransport: IActionTransportInitialized_Ws["getTransport"];
-}
-export type TWebSocketTransportOptions = (IWebSocketTransportSocketOptions & {
-    mode: "socket";
-}) | (IWebSocketTransportAdvancedOptions & {
-    mode: "advanced";
-});
-/**
- * Reusable WebSocket transport definition. Create one with `WebSocketTransport.create({ createWebSocket })`
- * for the common case, or `WebSocketTransport.createAdvanced({ getTransport })` for full control over
- * readiness. The underlying socket is cached (via `getTransportCacheKey`) and reused across actions.
- */
-export declare class WebSocketTransport extends Transport<ETransportType.ws> {
-    private readonly options;
-    readonly type = ETransportType.ws;
-    constructor(options: TWebSocketTransportOptions);
-    static create(options: IWebSocketTransportSocketOptions): WebSocketTransport;
-    static createAdvanced(options: IWebSocketTransportAdvancedOptions): WebSocketTransport;
-    _createConnection(ctx: ITransportConnectionContext): WebSocketConnection;
-    getRouteInfo(input: ITransportRouteActionParams): ITransportRouteInfo;
-}
-export {};

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

@@ -1,31 +0,0 @@
-import type { ClientCryptoKeyLink, TTypeAndId } from "@nice-code/util";
-/**
- * Async AES-GCM transform for the `encrypted` security level. It wraps the opaque binary frame a
- * session codec produces (it does NOT look inside it), encrypting on the way out and decrypting on the
- * way in with the shared key established by the handshake.
- *
- * It is deliberately separate from the (synchronous) session `formatMessage`: WebCrypto is always
- * Promise-based, so encryption has to happen at the transport's async I/O boundary — the connection
- * encrypts after `session.outgoing()` and decrypts before `session.incoming()`. The `authenticated`
- * and `none` levels use no crypto transform at all (frames go out as the session produced them).
- *
- * Wire shape of an encrypted frame: `pack([nonceBytes, ciphertextBytes])` — msgpack carries the two
- * binary fields with a couple of bytes of overhead, no base64 inflation.
- */
-export interface IActionFrameCrypto {
-    /** Encrypt one session frame for sending. */
-    encryptFrame(frame: Uint8Array): Promise<Uint8Array>;
-    /** Decrypt one received frame back to the session frame. Throws on a non-binary / malformed /
-     * tampered frame — the caller (transport) decides how to react (drop / close). */
-    decryptFrame(frame: string | ArrayBuffer | Uint8Array): Promise<Uint8Array>;
-}
-export interface IActionFrameCryptoConfig {
-    link: ClientCryptoKeyLink;
-    /** The handshake-established link id for the remote (key + connection-registry id). */
-    linkedClientId: TTypeAndId;
-}
-/**
- * Build the encrypt/decrypt transform for a connection whose handshake settled on the `encrypted`
- * level. Keyed by the link + `linkedClientId`, so it reuses the cached shared AES-GCM key.
- */
-export declare function createActionFrameCrypto({ link, linkedClientId, }: IActionFrameCryptoConfig): IActionFrameCrypto;

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

@@ -1,41 +0,0 @@
-import type { IActionContext_Data_JsonObject } from "../../../../../ActionDefinition/Action/Context/ActionContext.types";
-import { EActionPayloadType, type TActionPayload_Any_JsonObject } from "../../../../../ActionDefinition/Action/Payload/ActionPayload.types";
-import type { ActionDomain } from "../../../../../ActionDefinition/Domain/ActionDomain";
-import type { TPossibleDomainIdList } from "../../../../../ActionDefinition/Domain/ActionDomain.types";
-/**
- * Shared building blocks for the binary action codecs (the stateless {@link createBinaryWsAdapter} and
- * the per-connection `createBinaryWsSessionFactory`). Both map a `domain:id` route to a tiny integer
- * and reduce the verbose JSON wire to a positional tuple — they only differ in how much context they
- * carry per frame, so the dictionary + payload (de)assembly live here.
- */
-/**
- * Tiny integer codes for the payload type, so the verbose `"request"`/`"result"`/`"progress"`
- * strings never hit the wire. The index in {@link ReversePayloadType} must line up with the value.
- */
-export declare const PayloadTypeToInt: Record<EActionPayloadType.request | EActionPayloadType.result | EActionPayloadType.progress, number>;
-export declare const ReversePayloadType: readonly [EActionPayloadType.request, EActionPayloadType.result, EActionPayloadType.progress];
-export interface IActionRouteMeta {
-    domain: string;
-    id: string;
-    allDomains: TPossibleDomainIdList;
-}
-export interface IActionRouteDictionary {
-    /** `domain:id` → wire integer. */
-    routeToInt: Map<string, number>;
-    /** wire integer → route metadata for reconstruction. */
-    intToRoute: IActionRouteMeta[];
-}
-/**
- * Build the positional `domain:id` ↔ integer dictionary. Both ends of a channel MUST build it from
- * the same domains in the same order — the mapping is positional, so a mismatch routes to the wrong
- * action. Add new transported domains to the end of the list.
- */
-export declare function buildActionRouteDictionary(domains: ActionDomain<any>[]): IActionRouteDictionary;
-/** Pull the type-specific payload (`input` / `result` / `progress`) out of a wire JSON object. */
-export declare function extractWirePayload(json: TActionPayload_Any_JsonObject<any, any>): unknown;
-/**
- * Reassemble a full wire JSON object from its decoded parts. `inputHash`/`outputHash` are emitted
- * empty — the hydration constructors recompute them — and the result still satisfies
- * `isActionPayload_Any_JsonObject` so it flows through validation like a JSON frame.
- */
-export declare function assembleWireJson(routeMeta: IActionRouteMeta, payloadType: (typeof ReversePayloadType)[number], time: number, context: IActionContext_Data_JsonObject, payloadData: any): TActionPayload_Any_JsonObject<any, any>;