@nice-code/action 0.16.0 → 0.17.0

package/build/devtools/browser/index.d.cts

@@ -1,4 +1,4 @@
-import { a as TDevtoolsActionStatus, i as IDevtoolsObservableDomain, n as IActionDevtoolsCoreOptions, o as TDevtoolsListener, r as IDevtoolsActionEntry, s as TDevtoolsPosition, t as ActionDevtoolsCore } from "../../ActionDevtoolsCore-B3JwSaRH.cjs";
+import { a as TDevtoolsActionStatus, i as IDevtoolsObservableDomain, n as IActionDevtoolsCoreOptions, o as TDevtoolsListener, r as IDevtoolsActionEntry, s as TDevtoolsPosition, t as ActionDevtoolsCore } from "../../ActionDevtoolsCore-Dd1qJAwK.cjs";
 
 //#region src/devtools/browser/NiceActionDevtools.d.ts
 interface INiceActionDevtoolsProps {

package/build/devtools/browser/index.d.mts

@@ -1,4 +1,4 @@
-import { a as TDevtoolsActionStatus, i as IDevtoolsObservableDomain, n as IActionDevtoolsCoreOptions, o as TDevtoolsListener, r as IDevtoolsActionEntry, s as TDevtoolsPosition, t as ActionDevtoolsCore } from "../../ActionDevtoolsCore-C4TDUY7-.mjs";
+import { a as TDevtoolsActionStatus, i as IDevtoolsObservableDomain, n as IActionDevtoolsCoreOptions, o as TDevtoolsListener, r as IDevtoolsActionEntry, s as TDevtoolsPosition, t as ActionDevtoolsCore } from "../../ActionDevtoolsCore-C5XrQI1K.mjs";
 
 //#region src/devtools/browser/NiceActionDevtools.d.ts
 interface INiceActionDevtoolsProps {

package/build/devtools/server/index.d.cts

@@ -1,4 +1,4 @@
-import { a as TDevtoolsActionStatus, i as IDevtoolsObservableDomain, n as IActionDevtoolsCoreOptions, o as TDevtoolsListener, r as IDevtoolsActionEntry, t as ActionDevtoolsCore } from "../../ActionDevtoolsCore-B3JwSaRH.cjs";
+import { a as TDevtoolsActionStatus, i as IDevtoolsObservableDomain, n as IActionDevtoolsCoreOptions, o as TDevtoolsListener, r as IDevtoolsActionEntry, t as ActionDevtoolsCore } from "../../ActionDevtoolsCore-Dd1qJAwK.cjs";
 
 //#region src/devtools/server/NiceActionServerDevtools.d.ts
 type TServerDevtoolsLogFn = (message: string, data?: Record<string, unknown>) => void;

package/build/devtools/server/index.d.mts

@@ -1,4 +1,4 @@
-import { a as TDevtoolsActionStatus, i as IDevtoolsObservableDomain, n as IActionDevtoolsCoreOptions, o as TDevtoolsListener, r as IDevtoolsActionEntry, t as ActionDevtoolsCore } from "../../ActionDevtoolsCore-C4TDUY7-.mjs";
+import { a as TDevtoolsActionStatus, i as IDevtoolsObservableDomain, n as IActionDevtoolsCoreOptions, o as TDevtoolsListener, r as IDevtoolsActionEntry, t as ActionDevtoolsCore } from "../../ActionDevtoolsCore-C5XrQI1K.mjs";
 
 //#region src/devtools/server/NiceActionServerDevtools.d.ts
 type TServerDevtoolsLogFn = (message: string, data?: Record<string, unknown>) => void;

package/build/index.cjs

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rolldown_runtime = require("./rolldown-runtime-emK7D4bc.cjs");
 const require_RunningAction_types = require("./RunningAction.types-DjCX1xp5.cjs");
+const require_wsAcceptorCarrier = require("./wsAcceptorCarrier-DHRbsY1X.cjs");
 let nanoid = require("nanoid");
 let _nice_code_error = require("@nice-code/error");
 let _nice_code_common_errors = require("@nice-code/common-errors");
@@ -854,32 +855,6 @@ const err_nice_transport = err_nice_external_client.createChildDomain({
 	}
 });
 //#endregion
-//#region src/ActionRuntime/Transport/Transport.types.ts
-/**
-* Carrier-shape class identity: the one carrier-invariant trait the selection layer reasons about —
-* whether a carrier can push unsolicited frames (`duplex`: WS/WebRTC/BLE/in-memory) or only answers a
-* request with a single correlated reply (`exchange`: HTTP). The concrete carrier kind ("ws", "webrtc",
-* "http", …) is a free-form {@link ITransportRouteInfo.carrierLabel} for display, not a class tag.
-*/
-let ETransportShape = /* @__PURE__ */ function(ETransportShape) {
-	ETransportShape["duplex"] = "duplex";
-	ETransportShape["exchange"] = "exchange";
-	return ETransportShape;
-}({});
-/**
-*
-*  TRANSPORT READINESS RESPONSE
-*
-*/
-let ETransportStatus = /* @__PURE__ */ function(ETransportStatus) {
-	ETransportStatus["uninitialized"] = "uninitialized";
-	ETransportStatus["unsupported"] = "unsupported";
-	ETransportStatus["initializing"] = "initializing";
-	ETransportStatus["ready"] = "ready";
-	ETransportStatus["failed"] = "failed";
-	return ETransportStatus;
-}({});
-//#endregion
 //#region src/ActionRuntime/Transport/ConnectionTransportManager.ts
 var ConnectionTransportManager = class {
 	_cache;
@@ -1199,6 +1174,16 @@ var PeerLinkHandler = class extends ActionHandler {
 	_emitIncoming(json) {
 		for (const listener of this._incomingActionDataListeners) listener(json);
 	}
+	/**
+	* Whether this handler currently holds a *live* connection bound to `origin`. The runtime's return-path
+	* dispatch ({@link ActionRuntime.getReturnHandlerForOrigin}) prefers a handler that owns the origin's
+	* connection over a mere coordinate match, so with several duplex acceptors a result/push routes back
+	* over the carrier the client connected on. Defaults to `false`; an acceptor overrides it from its
+	* connection registry.
+	*/
+	ownsLiveConnectionFor(_origin) {
+		return false;
+	}
 	/** Release any long-lived connections this handler owns (a teardown). No-op by default. */
 	clearTransportCache() {}
 };
@@ -1509,11 +1494,19 @@ var ActionRuntime = class {
 	* Find the best registered external handler that can reach `originClient` directly.
 	* Used to locate the return-path channel for dispatching results back to the action origin.
 	* Returns `undefined` if no handler matches (score > 0 required, i.e. at least id must match).
+	*
+	* A handler that currently holds the origin's *live* connection always wins over a mere coordinate
+	* match — so with several duplex acceptors (e.g. WS + WebRTC) a result/push routes back over the carrier
+	* the client actually connected on, never a same-coordinate sibling that lacks the socket. Only when no
+	* handler owns a live connection do we fall back to the plain best-coordinate-score pick (the
+	* single-acceptor and connector-only cases, unchanged).
 	*/
 	getReturnHandlerForOrigin(originClient) {
 		if (originClient.envId === "_unset_") return void 0;
 		let bestScore = -1;
 		let bestHandler;
+		let bestOwnedScore = -1;
+		let bestOwnedHandler;
 		for (const handler of this._registeredPeerHandlers) {
 			if (!handler.canPush) continue;
 			const score = originClient.similarityLevel(handler.peerClient);
@@ -1521,7 +1514,12 @@ var ActionRuntime = class {
 				bestScore = score;
 				bestHandler = handler;
 			}
+			if (score > bestOwnedScore && handler.ownsLiveConnectionFor(originClient)) {
+				bestOwnedScore = score;
+				bestOwnedHandler = handler;
+			}
 		}
+		if (bestOwnedHandler != null && bestOwnedScore > 0) return bestOwnedHandler;
 		return bestScore > 0 ? bestHandler : void 0;
 	}
 	resetRuntime() {
@@ -2781,6 +2779,14 @@ var AcceptorHandler = class extends PeerLinkHandler {
 	getConnectionForClient(client) {
 		return this._connByClient.get(client.stringId);
 	}
+	/** This acceptor owns the origin's return path when it currently holds a live connection bound to it. */
+	ownsLiveConnectionFor(origin) {
+		return this._connByClient.has(origin.stringId);
+	}
+	/** Whether this acceptor currently tracks `connection` — used to pick the owning handler among several. */
+	hasConnection(connection) {
+		return this._clientByConn.has(connection);
+	}
 	/**
 	* Send (and optionally await) a server-initiated action to a specific connected client. Pass the
 	* connection token directly (e.g. the `ws`) or a client `RuntimeCoordinate` to look one up.
@@ -2928,7 +2934,7 @@ const createAcceptorHandler = (options) => {
 //#endregion
 //#region src/ActionRuntime/Handler/PeerLink/Acceptor/createSecureActionServer.ts
 /** Default accepted set: negotiate per connection to whatever the client picks. */
-const DEFAULT_SERVER_SECURITY_LEVELS = [
+const DEFAULT_SERVER_SECURITY_LEVELS$1 = [
 	"none",
 	"authenticated",
 	"encrypted"
@@ -2943,7 +2949,7 @@ const DEFAULT_SERVER_SECURITY_LEVELS = [
 * {@link createHibernatableWsServerAdapter} to wire persistence + replay.
 */
 function createSecureAcceptorHandler(options) {
-	const link = new _nice_code_util.ClientCryptoKeyLink({ storageAdapter: options.storageAdapter });
+	const link = options.link ?? new _nice_code_util.ClientCryptoKeyLink({ storageAdapter: options.storageAdapter });
 	return new AcceptorHandler({
 		clientEnv: options.clientEnv,
 		createFormatMessage: options.channel.createCodec,
@@ -2951,7 +2957,7 @@ function createSecureAcceptorHandler(options) {
 		runtime: options.runtime,
 		defaultTimeout: options.defaultTimeout,
 		security: {
-			securityLevel: options.securityLevel ?? DEFAULT_SERVER_SECURITY_LEVELS,
+			securityLevel: options.securityLevel ?? DEFAULT_SERVER_SECURITY_LEVELS$1,
 			link,
 			localCoordinate: options.runtime.coordinate.toJsonObject(),
 			dictionaryVersion: options.channel.dictionaryVersion,
@@ -3023,6 +3029,7 @@ function acceptChannel(runtime, channel, options) {
 		runtime,
 		clientEnv: options.clientEnv,
 		storageAdapter: options.storageAdapter,
+		link: options.link,
 		send: options.send,
 		securityLevel: options.securityLevel,
 		verifyKeyResolver: options.verifyKeyResolver,
@@ -3511,7 +3518,8 @@ function createActionFetchHandler(runtime, options = {}) {
 	return async (request) => {
 		if (request.method === "OPTIONS") return withCors(new Response(null, { status: 204 }));
 		const url = new URL(request.url);
-		if (options.onWebSocketUpgrade != null && request.headers.get("Upgrade") === "websocket" && isWebSocketPath(url)) return options.onWebSocketUpgrade(request, url);
+		const isWebSocketUpgrade = options.isWebSocketUpgrade ?? ((req, u) => req.headers.get("Upgrade") === "websocket" && isWebSocketPath(u));
+		if (options.onWebSocketUpgrade != null && isWebSocketUpgrade(request, url)) return options.onWebSocketUpgrade(request, url);
 		if (request.method === "POST" && isActionPath(url)) {
 			if (exchangeAcceptor != null) {
 				const reply = await exchangeAcceptor.handlePost(await request.text());
@@ -3526,6 +3534,151 @@ function createActionFetchHandler(runtime, options = {}) {
 	};
 }
 //#endregion
+//#region src/ActionRuntime/Handler/PeerLink/Acceptor/Hibernation/createHibernatableWsServerAdapter.ts
+/**
+* Wire the hibernation lifecycle for an acceptor handler on a transport whose connections outlive process
+* eviction (e.g. a Durable Object's hibernatable WebSockets). It owns persistence end to end:
+* registers `setAttachment` as the handler's connection-bound callback and immediately replays every
+* live connection's stored binding via `getAttachment`, so results/pushes still route after a wake.
+*
+* Layered on top of the generic {@link AcceptorHandler} — it touches only the handler's neutral
+* `setOnConnectionBound` / `rehydrateConnection` / `receive` / `dropConnection` surface, so no
+* hibernation concern leaks into the handler itself.
+*
+* Construct it once when the handler is built, then forward connection events:
+* ```ts
+* const duplex = createHibernatableWsServerAdapter({ handler, getConnections, getAttachment, setAttachment });
+* // webSocketMessage(ws, msg) => duplex.receive(ws, msg);
+* // webSocketClose/Error(ws)  => duplex.drop(ws);
+* ```
+*/
+function createHibernatableWsServerAdapter(options) {
+	const { handler, getConnections, getAttachment, setAttachment } = options;
+	handler.setOnConnectionBound(setAttachment);
+	for (const connection of getConnections()) {
+		const binding = getAttachment(connection);
+		if (binding != null) handler.rehydrateConnection(connection, binding);
+	}
+	return {
+		receive: (connection, frame) => handler.receive(connection, frame),
+		drop: (connection) => handler.dropConnection(connection)
+	};
+}
+//#endregion
+//#region src/ActionRuntime/Channel/serveChannel.ts
+/** Default accepted set, shared by every carrier: negotiate per connection to whatever the client picks. */
+const DEFAULT_SERVER_SECURITY_LEVELS = [
+	"none",
+	"authenticated",
+	"encrypted"
+];
+/**
+* Serve a secure channel over one or more carriers from a single call — the accept-in dual of
+* `connectChannel`. It builds the crypto identity (a {@link ClientCryptoKeyLink} + a storage-backed TOFU
+* resolver) and the security block (coordinate, dictionary version, accepted levels) *once* from
+* `(runtime, channel)` and fans them across every carrier, so the WebSocket and the secure-HTTP endpoint
+* can never drift apart. It registers your handlers (plus the duplex acceptor it builds) on the runtime,
+* wires hibernation when the duplex carrier declares it, and returns a single {@link IChannelServer} whose
+* `fetch` / `duplex` / `pushToClient` you forward straight to the host:
+* ```ts
+* const server = serveChannel(runtime, channel, {
+*   clientEnv, storage,
+*   carriers: [wsAcceptorCarrier({ send, upgrade, hibernation }), httpAcceptorCarrier()],
+*   handlers: [localHandler],
+* });
+* // fetch(req) => server.fetch(req)
+* // webSocketMessage(conn, m) => server.duplex?.receive(conn, m)
+* // webSocketClose/Error(conn) => server.duplex?.drop(conn)
+* ```
+*
+* `TConn` (the live-connection token a duplex carrier hands back through `send`/`receive`/`drop`) is
+* inferred from the carriers — `WebSocket` for `wsAcceptorCarrier`, the data-channel type for a WebRTC
+* carrier, and so on — so it stays carrier-agnostic.
+*/
+function serveChannel(runtime, channel, options) {
+	const duplexCarriers = options.carriers.filter((carrier) => !require_wsAcceptorCarrier.isExchangeAcceptorCarrier(carrier));
+	const exchangeCarriers = options.carriers.filter(require_wsAcceptorCarrier.isExchangeAcceptorCarrier);
+	if (exchangeCarriers.length > 1) throw new Error("serveChannel: at most one exchange carrier is supported");
+	const exchangeCarrier = exchangeCarriers[0];
+	const exchangeSecure = exchangeCarrier != null && (exchangeCarrier.secure ?? true);
+	const anyDuplexSecure = duplexCarriers.some((carrier) => carrier.secure ?? true);
+	const securityLevel = options.securityLevel ?? DEFAULT_SERVER_SECURITY_LEVELS;
+	let secure;
+	if (anyDuplexSecure || exchangeSecure) {
+		const storage = options.storage;
+		if (storage == null) throw new Error("serveChannel: a secure carrier requires `storage`. Pass it, or set `secure: false` on the carrier for a plain endpoint.");
+		secure = {
+			storage,
+			link: options.link ?? new _nice_code_util.ClientCryptoKeyLink({ storageAdapter: storage }),
+			verifyKeyResolver: options.verifyKeyResolver ?? createStorageTofuVerifyKeyResolver(storage)
+		};
+	}
+	const handlers = [];
+	for (const carrier of duplexCarriers) {
+		const handler = (carrier.secure ?? true) && secure != null ? acceptChannel(runtime, channel, {
+			clientEnv: options.clientEnv,
+			storageAdapter: secure.storage,
+			link: secure.link,
+			verifyKeyResolver: secure.verifyKeyResolver,
+			securityLevel,
+			send: carrier.send,
+			defaultTimeout: options.defaultTimeout
+		}) : createAcceptorHandler({
+			clientEnv: options.clientEnv,
+			createFormatMessage: channel.createCodec,
+			send: carrier.send,
+			runtime,
+			defaultTimeout: options.defaultTimeout
+		});
+		const router = carrier.hibernation != null ? createHibernatableWsServerAdapter({
+			handler,
+			...carrier.hibernation
+		}) : {
+			receive: (connection, frame) => handler.receive(connection, frame),
+			drop: (connection) => handler.dropConnection(connection)
+		};
+		carrier._activate(router);
+		handlers.push(handler);
+	}
+	runtime.addHandlers([...options.handlers ?? [], ...handlers]);
+	const exchangeSecurity = exchangeSecure && secure != null ? {
+		link: secure.link,
+		verifyKeyResolver: secure.verifyKeyResolver,
+		localCoordinate: runtime.coordinate.toJsonObject(),
+		dictionaryVersion: channel.dictionaryVersion,
+		securityLevel
+	} : void 0;
+	const defaultIsUpgrade = (request) => request.headers.get("Upgrade") === "websocket";
+	const upgraders = [];
+	for (const carrier of duplexCarriers) {
+		if (carrier.upgrade == null) continue;
+		upgraders.push({
+			isUpgrade: carrier.isUpgrade ?? defaultIsUpgrade,
+			upgrade: carrier.upgrade
+		});
+	}
+	const fetch = createActionFetchHandler(runtime, {
+		cors: exchangeCarrier?.cors,
+		onWebSocketUpgrade: upgraders.length === 0 ? void 0 : (request, url) => (upgraders.find((u) => u.isUpgrade(request, url)) ?? upgraders[0]).upgrade(request, url),
+		isWebSocketUpgrade: upgraders.length === 0 ? void 0 : (request, url) => upgraders.some((u) => u.isUpgrade(request, url)),
+		isActionPath: exchangeCarrier != null ? exchangeCarrier.isActionPath ?? (() => true) : () => false,
+		security: exchangeSecurity,
+		useErrorStatus: exchangeCarrier?.useErrorStatus
+	});
+	const duplex = duplexCarriers.length === 1 ? duplexCarriers[0] : void 0;
+	const pushToClient = (target, request, pushOptions) => {
+		const owner = target instanceof RuntimeCoordinate ? handlers.find((handler) => handler.ownsLiveConnectionFor(target)) : handlers.find((handler) => handler.hasConnection(target));
+		if (owner == null) throw new Error("serveChannel: no duplex carrier holds a connection for the push target");
+		return owner.pushToClient(runtime, target, request, pushOptions);
+	};
+	return {
+		handlers,
+		fetch,
+		duplex,
+		pushToClient
+	};
+}
+//#endregion
 //#region src/ActionRuntime/Handler/PeerLink/Acceptor/Hibernation/ConnectionStateStore.ts
 /**
 * A typed per-connection state store that co-owns the app state and the acceptor handler's routing
@@ -3633,37 +3786,6 @@ function createConnectionStateStore(handler, options) {
 	return store;
 }
 //#endregion
-//#region src/ActionRuntime/Handler/PeerLink/Acceptor/Hibernation/createHibernatableWsServerAdapter.ts
-/**
-* Wire the hibernation lifecycle for an acceptor handler on a transport whose sockets outlive process
-* eviction (e.g. a Durable Object's hibernatable WebSockets). It owns persistence end to end:
-* registers `setAttachment` as the handler's connection-bound callback and immediately replays every
-* live connection's stored binding via `getAttachment`, so results/pushes still route after a wake.
-*
-* Layered on top of the generic {@link AcceptorHandler} — it touches only the handler's neutral
-* `setOnConnectionBound` / `rehydrateConnection` / `receive` / `dropConnection` surface, so no
-* hibernation concern leaks into the handler itself.
-*
-* Construct it once when the handler is built, then forward socket events:
-* ```ts
-* const wsServer = createHibernatableWsServerAdapter({ handler, getWebSockets, getAttachment, setAttachment });
-* // webSocketMessage(ws, msg) => wsServer.receive(ws, msg);
-* // webSocketClose/Error(ws)  => wsServer.drop(ws);
-* ```
-*/
-function createHibernatableWsServerAdapter(options) {
-	const { handler, getWebSockets, getAttachment, setAttachment } = options;
-	handler.setOnConnectionBound(setAttachment);
-	for (const connection of getWebSockets()) {
-		const binding = getAttachment(connection);
-		if (binding != null) handler.rehydrateConnection(connection, binding);
-	}
-	return {
-		receive: (connection, frame) => handler.receive(connection, frame),
-		drop: (connection) => handler.dropConnection(connection)
-	};
-}
-//#endregion
 //#region src/ActionRuntime/Transport/Carrier/duplex/inMemory/createInMemoryChannel.ts
 /**
 * Two cross-wired in-process byte channels — a loopback carrier with no socket. The client end is a
@@ -3821,6 +3943,22 @@ function rtcCarrier(dataChannel, options = {}) {
 	};
 }
 //#endregion
+//#region src/ActionRuntime/Transport/Carrier/duplex/ws/err_nice_transport_ws.ts
+let EErrId_NiceTransport_WebSocket = /* @__PURE__ */ function(EErrId_NiceTransport_WebSocket) {
+	EErrId_NiceTransport_WebSocket["ws_disconnected"] = "ws_disconnected";
+	EErrId_NiceTransport_WebSocket["ws_create_failed"] = "ws_create_failed";
+	EErrId_NiceTransport_WebSocket["ws_error"] = "ws_error";
+	return EErrId_NiceTransport_WebSocket;
+}({});
+const err_nice_transport_ws = err_nice_transport.createChildDomain({
+	domain: "ws_transport",
+	schema: {
+		["ws_disconnected"]: (0, _nice_code_error.err)({ message: () => `WebSocket transport disconnected.` }),
+		["ws_create_failed"]: (0, _nice_code_error.err)({ message: ({ originalError }) => `Failed to create WebSocket transport.${originalError ? ` Original error: ${originalError.message}` : ""}` }),
+		["ws_error"]: (0, _nice_code_error.err)({ message: ({ originalError }) => `WebSocket transport error.${originalError ? ` Original error: ${originalError.message}` : ""}` })
+	}
+});
+//#endregion
 //#region src/ActionRuntime/Transport/Carrier/duplex/ws/ws_util.ts
 /**
 * Send a text or binary frame over a socket. A binary formatter may hand back a `Uint8Array` whose
@@ -3933,6 +4071,25 @@ function defaultWebSocket(url) {
 	return ws;
 }
 //#endregion
+//#region src/ActionRuntime/Transport/Carrier/exchange/http/httpAcceptorCarrier.ts
+/**
+* An HTTP {@link IExchangeAcceptorCarrier}: the accept-in dual of {@link httpCarrier}. It serves the
+* secure exchange protocol (handshake → token session → encrypted frames) over web-standard
+* `Request`/`Response`. The crypto identity, runtime coordinate, dictionary version, and accepted security
+* levels are all supplied centrally by `serveChannel`, so this only needs to say which requests carry an
+* action envelope and how to answer CORS.
+*/
+function httpAcceptorCarrier(options = {}) {
+	return {
+		shape: "exchange",
+		carrierLabel: options.carrierLabel ?? "http",
+		secure: options.secure,
+		isActionPath: options.isActionPath,
+		cors: options.cors,
+		useErrorStatus: options.useErrorStatus
+	};
+}
+//#endregion
 //#region src/ActionRuntime/Transport/Carrier/exchange/http/httpCarrier.ts
 function shortPath(url) {
 	try {
@@ -4398,22 +4555,6 @@ var ExchangeTransport = class ExchangeTransport extends Transport {
 	}
 };
 //#endregion
-//#region src/ActionRuntime/Transport/Carrier/duplex/ws/err_nice_transport_ws.ts
-let EErrId_NiceTransport_WebSocket = /* @__PURE__ */ function(EErrId_NiceTransport_WebSocket) {
-	EErrId_NiceTransport_WebSocket["ws_disconnected"] = "ws_disconnected";
-	EErrId_NiceTransport_WebSocket["ws_create_failed"] = "ws_create_failed";
-	EErrId_NiceTransport_WebSocket["ws_error"] = "ws_error";
-	return EErrId_NiceTransport_WebSocket;
-}({});
-const err_nice_transport_ws = err_nice_transport.createChildDomain({
-	domain: "ws_transport",
-	schema: {
-		["ws_disconnected"]: (0, _nice_code_error.err)({ message: () => `WebSocket transport disconnected.` }),
-		["ws_create_failed"]: (0, _nice_code_error.err)({ message: ({ originalError }) => `Failed to create WebSocket transport.${originalError ? ` Original error: ${originalError.message}` : ""}` }),
-		["ws_error"]: (0, _nice_code_error.err)({ message: ({ originalError }) => `WebSocket transport error.${originalError ? ` Original error: ${originalError.message}` : ""}` })
-	}
-});
-//#endregion
 //#region src/ActionRuntime/Transport/helpers/createUnsetTransportResolvers.ts
 const createUnsetTransportResolvers = (transportLabel) => ({ onIncomingActionDataJson: (json) => {
 	console.warn(`Received incoming action JSON [${json.domain}:${json.id}] on Transport [${transportLabel}] but no incoming data listener has been set.`);
@@ -4741,8 +4882,8 @@ exports.ERunningActionFinishedType = require_RunningAction_types.ERunningActionF
 exports.ERunningActionState = require_RunningAction_types.ERunningActionState;
 exports.ERunningActionUpdateType = require_RunningAction_types.ERunningActionUpdateType;
 exports.ESecurityLevel = ESecurityLevel;
-exports.ETransportShape = ETransportShape;
-exports.ETransportStatus = ETransportStatus;
+exports.ETransportShape = require_wsAcceptorCarrier.ETransportShape;
+exports.ETransportStatus = require_wsAcceptorCarrier.ETransportStatus;
 exports.ExchangeAcceptor = ExchangeAcceptor;
 exports.ExchangeTransport = ExchangeTransport;
 exports.LinkTransport = LinkTransport;
@@ -4779,16 +4920,20 @@ exports.err_nice_action = err_nice_action;
 exports.err_nice_external_client = err_nice_external_client;
 exports.err_nice_transport = err_nice_transport;
 exports.err_nice_transport_ws = err_nice_transport_ws;
+exports.httpAcceptorCarrier = httpAcceptorCarrier;
 exports.httpCarrier = httpCarrier;
 exports.inMemoryCarrier = inMemoryCarrier;
 exports.isActionPayload_Any_JsonObject = isActionPayload_Any_JsonObject;
 exports.isActionPayload_Request_JsonObject = isActionPayload_Request_JsonObject;
 exports.isActionPayload_Result_JsonObject = isActionPayload_Result_JsonObject;
+exports.isExchangeAcceptorCarrier = require_wsAcceptorCarrier.isExchangeAcceptorCarrier;
 exports.plainTransport = plainTransport;
 exports.rtcCarrier = rtcCarrier;
 exports.rtcDataChannelByteChannel = rtcDataChannelByteChannel;
 exports.runtimeLinkId = runtimeLinkId;
 exports.secureTransport = secureTransport;
+exports.serveChannel = serveChannel;
+exports.wsAcceptorCarrier = require_wsAcceptorCarrier.wsAcceptorCarrier;
 exports.wsCarrier = wsCarrier;
 
 //# sourceMappingURL=index.cjs.map