@nice-code/action 0.4.4 → 0.4.6

package/build/types/ActionRuntime/Handler/ExternalClient/Transport/Custom/{TransportCustom.d.ts → CustomConnection.d.ts}

@@ -1,7 +1,7 @@
-import { Transport } from "../Transport";
 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 TransportCustom extends Transport<ETransportType.custom, ITransportRouteActionParams, IActionTransportReadyData_Custom, IActionTransportInitialized_Custom, IActionTransportDef_Custom> {
+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

@@ -0,0 +1,33 @@
+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";
+export interface ICustomTransportOptions {
+    /** 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;
+    updateRunConfig?: TUpdateActionRunConfig;
+    getTransportCacheKey?: (input: ITransportRouteActionParams) => string[];
+    /**
+     * Advanced escape hatch — full control over readiness/initialization. When provided, the simple
+     * `sendActionData` / `sendReturnData` / `closeTransport` fields are ignored.
+     */
+    getTransport?: IActionTransportInitialized_Custom["getTransport"];
+    /** 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;
+}
+/**
+ * Reusable custom transport definition for channels nice-action doesn't model natively. Provide
+ * `sendActionData` for the simple case, or `getTransport` for full control over the lifecycle.
+ */
+export declare class CustomTransport extends Transport<ETransportType.custom> {
+    private readonly options;
+    readonly type = ETransportType.custom;
+    constructor(options: ICustomTransportOptions);
+    _createConnection(_ctx: ITransportConnectionContext): CustomConnection;
+    getRouteInfo(input: ITransportRouteActionParams): ITransportRouteInfo;
+}

package/build/types/ActionRuntime/Handler/ExternalClient/Transport/Http/{TransportHttp.d.ts → HttpConnection.d.ts}

@@ -1,7 +1,7 @@
-import { Transport } from "../Transport";
 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 TransportHttp extends Transport<ETransportType.http, ITransportRouteActionParams, IActionTransportReadyData_Http, IActionTransportInitialized_Http, IActionTransportDef_Http> {
+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

@@ -0,0 +1,28 @@
+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";
+type TMaybeResolved<T> = T | ((input: ITransportRouteActionParams) => T);
+export interface IHttpTransportOptions {
+    /** Endpoint URL, either static or derived per action. */
+    url: TMaybeResolved<string>;
+    /** Optional extra headers, either static or derived per action. */
+    headers?: TMaybeResolved<Record<string, string>>;
+    /** Advanced escape hatch — full control over the request. Overrides `url` / `headers`. */
+    createRequest?: (input: ITransportRouteActionParams) => IHttpRequestParams;
+    updateRunConfig?: TUpdateActionRunConfig;
+    getTransportCacheKey?: (input: ITransportRouteActionParams) => string[];
+}
+/**
+ * Reusable HTTP transport definition. Common case is just `new HttpTransport({ url })`; pass
+ * functions for `url` / `headers` to derive them per action, or `createRequest` for full control.
+ */
+export declare class HttpTransport extends Transport<ETransportType.http> {
+    private readonly options;
+    readonly type = ETransportType.http;
+    constructor(options: IHttpTransportOptions);
+    private _resolveRequest;
+    _createConnection(_ctx: ITransportConnectionContext): HttpConnection;
+    getRouteInfo(input: ITransportRouteActionParams): ITransportRouteInfo;
+}
+export {};

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

@@ -1,5 +1,5 @@
 import type { ETransportType, IActionTransportDef, IActionTransportInitialized, IActionTransportReadyData_Base, ITransportRouteActionParams } from "../Transport.types";
-interface IHttpRequestParams {
+export interface IHttpRequestParams {
     url: string;
     headers?: Record<string, string>;
     body?: string;
@@ -14,4 +14,3 @@ export interface IActionTransportInitialized_Http extends IActionTransportInitia
 }
 export interface IActionTransportDef_Http extends IActionTransportDef<ETransportType.http, IActionTransportInitialized_Http> {
 }
-export {};

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

@@ -1,13 +1,26 @@
-import { type ETransportType, type IActionTransportDef, type IActionTransportInitialized, type IActionTransportReadyData_Base, type IActionTransportReadyData_Methods, type ITransportRouteActionParams, type TTransportStatusInfo } from "./Transport.types";
-export declare abstract class Transport<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;
-    constructor(def: DEF);
-    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>;
+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 (`new HttpTransport({ url })`,
+ * `new WebSocketTransport({ url })`, …) 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

@@ -4,12 +4,25 @@ import type { ActionPayload_Request } from "../../../../ActionDefinition/Action/
 import type { ActionPayload_Result } from "../../../../ActionDefinition/Action/Payload/ActionPayload_Result";
 import type { RunningAction } from "../../../../ActionDefinition/Action/RunningAction";
 import type { RuntimeCoordinate } from "../../../RuntimeCoordinate";
-import type { Transport } from "./Transport";
+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;
 }
@@ -83,7 +96,7 @@ export interface IActionTransportReadyData_Methods extends IActionTransportReady
 }
 export interface IActionTransportReady {
     methods: IActionTransportReadyData_Methods;
-    transport: Transport;
+    transport: TransportConnection;
 }
 export type TTransportCache = Map<string, IActionTransportReady | Promise<IActionTransportReady>>;
 export type TOnResolveIncomingRequest = (request: ActionPayload_Request<any>) => void;

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

@@ -0,0 +1,27 @@
+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.d.ts → WebSocketConnection.d.ts}

@@ -1,12 +1,15 @@
-import { Transport } from "../Transport";
-import { ETransportType, type IActionTransportReadyData_Methods, type IActionTransportResolvers, type ITransportRouteActionParams, type TTransportStatusInfo } from "../Transport.types";
+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 TransportWebSocket extends Transport<ETransportType.ws, ITransportRouteActionParams, IActionTransportReadyData_Ws, IActionTransportInitialized_Ws, IActionTransportDef_Ws> {
+export declare class WebSocketConnection extends TransportConnection<ETransportType.ws, ITransportRouteActionParams, IActionTransportReadyData_Ws, IActionTransportInitialized_Ws, IActionTransportDef_Ws> {
     private resolvers;
     private _abortSet;
+    /** URL of the most recently resolved live socket — surfaced to devtools when the definition can't. */
+    private _liveSocketUrl?;
     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;
     _finalizeTransportMethods(wsData: IActionTransportReadyData_Ws): IActionTransportReadyData_Methods;
     private _parseActionMessage;
     private _abortAll;

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

@@ -0,0 +1,41 @@
+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";
+type TMaybeResolved<T> = T | ((input: ITransportRouteActionParams) => T);
+export interface IWebSocketTransportOptions {
+    /** WebSocket endpoint URL, either static or derived per action. Optional when `getTransport` is used. */
+    url?: TMaybeResolved<string>;
+    /** Advanced escape hatch — provide your own socket (e.g. with sub-protocols). Overrides `url`. */
+    createWebSocket?: (input: ITransportRouteActionParams) => WebSocket;
+    /** Custom (de)serialization of action payloads on the wire. */
+    formatMessage?: IActionTransportReadyData_Ws["formatMessage"];
+    updateRunConfig?: TUpdateActionRunConfig;
+    /**
+     * Keys that identify a reusable socket. Defaults to the resolved url, so a single socket is shared
+     * across actions to the same endpoint instead of opening one per action.
+     */
+    getTransportCacheKey?: (input: ITransportRouteActionParams) => string[];
+    /**
+     * Advanced escape hatch — 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). When provided, `url` / `createWebSocket` are ignored.
+     */
+    getTransport?: IActionTransportInitialized_Ws["getTransport"];
+    /** Override the devtools route info for a specific action (useful alongside `getTransport`). */
+    getRouteInfo?: (input: ITransportRouteActionParams) => ITransportRouteInfo;
+}
+/**
+ * Reusable WebSocket transport definition. Common case is just `new WebSocketTransport({ url })`. The
+ * underlying socket is cached (by url, by default) and reused across actions to the same endpoint.
+ */
+export declare class WebSocketTransport extends Transport<ETransportType.ws> {
+    private readonly options;
+    readonly type = ETransportType.ws;
+    constructor(options: IWebSocketTransportOptions);
+    private _createSocket;
+    _createConnection(ctx: ITransportConnectionContext): WebSocketConnection;
+    getRouteInfo(input: ITransportRouteActionParams): ITransportRouteInfo;
+}
+export {};

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

@@ -0,0 +1,2 @@
+/** 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/test/helpers/new_action_test_data.d.ts

@@ -1,8 +1,8 @@
 import { ActionRuntime } from "../../ActionRuntime";
 import { type ActionExternalClientHandler } from "../../Handler/ExternalClient/ActionExternalClientHandler";
-import type { IActionTransportDef_Custom } from "../../Handler/ExternalClient/Transport/Custom/TransportCustom.types";
+import { CustomTransport } from "../../Handler/ExternalClient/Transport/Custom/CustomTransport";
 import { type ActionLocalHandler } from "../../Handler/Local/ActionLocalHandler";
-export declare function _test_initializeCustomTransport(externalClientRuntime: ActionRuntime): IActionTransportDef_Custom["initialize"];
+export declare function _test_createCustomTransport(externalClientRuntime: ActionRuntime): CustomTransport;
 export declare function _test_createActions(): {
     domains: {
         root: import("../../..").ActionRootDomain<import("../../..").IActionRootDomain<"test_root">>;

package/build/types/devtools/browser/components/HandlerChips.d.ts

@@ -1,6 +1,17 @@
 import type { IDevtoolsActionEntry, IDevtoolsRouteItem } from "../../core/ActionDevtools.types";
 import { ESize } from "../ui_util/size";
+import type { ITooltipConfig } from "./Tooltip";
 export declare function getExternalLabel(hop: IDevtoolsRouteItem): string | null;
+/**
+ * Extended transport details (request/WebSocket endpoint) for the external handler — shown on hover
+ * only, so the chip/label itself stays short.
+ */
+export declare function getTransportTooltip(hop: IDevtoolsRouteItem): ITooltipConfig | undefined;
+/**
+ * Aggregate transport tooltip for a chip/label that represents one or more external hops (e.g. a
+ * grouped child-dispatch chip that accumulates several transports for the same runtime).
+ */
+export declare function getTransportTooltipForHops(hops: IDevtoolsRouteItem[]): ITooltipConfig | undefined;
 interface IHandlerChipsProps {
     entry: IDevtoolsActionEntry;
     size: ESize;

package/build/types/devtools/browser/components/Tooltip.d.ts

@@ -1,4 +1,4 @@
-import type { ReactNode } from "react";
+import { type CSSProperties, type ReactNode } from "react";
 export interface ITooltipConfig {
     content: ReactNode;
     title?: ReactNode;
@@ -12,3 +12,13 @@ export declare function Tooltip({ anchor, config, children, }: {
     config: ITooltipConfig;
     children?: ReactNode;
 }): import("react/jsx-runtime").JSX.Element;
+/**
+ * Wraps inline content so it shows `config` as a hover tooltip. When `config` is null the children
+ * render untouched (no hover handlers, no tooltip). Useful for non-Chip text labels that still need
+ * the same tooltip treatment as Chips.
+ */
+export declare function HoverTooltip({ config, children, style, }: {
+    config?: ITooltipConfig;
+    children: ReactNode;
+    style?: CSSProperties;
+}): import("react/jsx-runtime").JSX.Element;

package/build/types/devtools/core/ActionDevtools.types.d.ts

@@ -10,7 +10,12 @@ export interface IDevtoolsRouteItem {
         perId?: string;
         insId?: string;
     };
+    /** Transport type string (e.g. "http", "ws", "custom"). */
     transport?: string;
+    /** Short transport summary for chips (e.g. "POST /resolve_action"). */
+    transportSummary?: string;
+    /** Resolved endpoint (request URL / WebSocket URL), when available. */
+    transportUrl?: string;
     time: number;
     label?: string;
 }

package/build/types/index.d.ts

@@ -16,13 +16,13 @@ export type { TActionSchemaOptions, TActionSerializationDefinition, TTransported
 export { ActionRuntime } from "./ActionRuntime/ActionRuntime";
 export { ActionExternalClientHandler, createExternalClientHandler, } from "./ActionRuntime/Handler/ExternalClient/ActionExternalClientHandler";
 export * from "./ActionRuntime/Handler/ExternalClient/err_nice_external_client";
+export * from "./ActionRuntime/Handler/ExternalClient/Transport/Custom/CustomTransport";
 export * from "./ActionRuntime/Handler/ExternalClient/Transport/err_nice_transport";
 export * from "./ActionRuntime/Handler/ExternalClient/Transport/err_nice_transport_ws";
-export * from "./ActionRuntime/Handler/ExternalClient/Transport/Http/TransportHttp";
-export * from "./ActionRuntime/Handler/ExternalClient/Transport/Transport";
-export type { TActionTransportDef } from "./ActionRuntime/Handler/ExternalClient/Transport/Transport.combined.types";
+export { HttpTransport, type IHttpTransportOptions, } from "./ActionRuntime/Handler/ExternalClient/Transport/Http/HttpTransport";
+export { type ITransportConnectionContext, Transport, } from "./ActionRuntime/Handler/ExternalClient/Transport/Transport";
 export * from "./ActionRuntime/Handler/ExternalClient/Transport/Transport.types";
-export * from "./ActionRuntime/Handler/ExternalClient/Transport/WebSocket/TransportWebSocket";
+export { type IWebSocketTransportOptions, WebSocketTransport, } from "./ActionRuntime/Handler/ExternalClient/Transport/WebSocket/WebSocketTransport";
 export { ActionLocalHandler, createLocalHandler, } from "./ActionRuntime/Handler/Local/ActionLocalHandler";
 export * from "./ActionRuntime/RuntimeCoordinate";
 export { EErrId_NiceAction, err_nice_action } from "./errors/err_nice_action";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nice-code/action",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "private": false,
   "type": "module",
   "exports": {
@@ -44,9 +44,9 @@
     "build-types": "tsc --project tsconfig.build.json"
   },
   "dependencies": {
-    "@nice-code/common-errors": "0.4.4",
-    "@nice-code/error": "0.4.4",
-    "@nice-code/util": "0.4.4",
+    "@nice-code/common-errors": "0.4.6",
+    "@nice-code/error": "0.4.6",
+    "@nice-code/util": "0.4.6",
     "@standard-schema/spec": "^1.1.0",
     "@tanstack/react-virtual": "^3.13.26",
     "http-status-codes": "^2.3.0",

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

@@ -1,4 +0,0 @@
-import type { IActionTransportDef_Custom } from "./Custom/TransportCustom.types";
-import type { IActionTransportDef_Http } from "./Http/TransportHttp.types";
-import type { IActionTransportDef_Ws } from "./WebSocket/TransportWebSocket.types";
-export type TActionTransportDef = IActionTransportDef_Ws | IActionTransportDef_Http | IActionTransportDef_Custom;