@nice-code/action 0.6.3 → 0.8.0

package/build/index.js

@@ -689,7 +689,7 @@ var isActionPayload_Result_JsonObject = (obj) => {
 
 // src/ActionRuntime/ActionRuntime.ts
 import { castNiceError } from "@nice-code/error";
-import { nanoid as nanoid2 } from "nanoid";
+import { nanoid as nanoid4 } from "nanoid";
 
 // src/utils/getAssumedRuntimeEnvironment.ts
 import { runtime } from "std-env";
@@ -715,6 +715,21 @@ function isActionPayload_Any_JsonObject(obj) {
   return isActionPayload_Request_JsonObject(obj) || isActionPayload_Result_JsonObject(obj) || isActionPayload_Progress_JsonObject(obj);
 }
 
+// src/ActionRuntime/Handler/ExternalClient/ActionExternalClientHandler.ts
+import { nanoid as nanoid3 } from "nanoid";
+
+// src/ActionRuntime/HandlerCallStack.ts
+var _stack = [];
+function pushHandlerCuid(cuid) {
+  _stack.push(cuid);
+}
+function popHandlerCuid() {
+  _stack.pop();
+}
+function peekHandlerCuid() {
+  return _stack[_stack.length - 1];
+}
+
 // src/ActionRuntime/ActionDomainManager.ts
 class ActionDomainManager {
   _domains = new Map;
@@ -899,693 +914,753 @@ class ActionRouter {
   }
 }
 
-// src/ActionRuntime/ActionRuntime.ts
-class ActionRuntime {
-  _coordinate;
-  timeCreated;
-  runtimeInfo = getAssumedRuntimeInfo();
-  actionRouter;
-  _pendingRunningActions = new Map;
-  _registeredExternalHandlers = [];
-  _applied = false;
-  static getDefault() {
-    return getDefaultActionRuntime();
-  }
-  constructor(coordinate) {
-    this._coordinate = coordinate.specifyIfUnset({
-      insId: nanoid2(14)
-    });
-    this.timeCreated = Date.now();
-    this.actionRouter = new ActionRouter({
-      contextType: "runtime_to_handler" /* runtime_to_handler */,
-      runtime: this
-    });
-  }
-  get coordinate() {
-    return this._coordinate;
+// src/ActionRuntime/Handler/ActionHandler.ts
+import { nanoid as nanoid2 } from "nanoid";
+
+class ActionHandler {
+  cuid;
+  constructor() {
+    this.cuid = nanoid2();
   }
-  specifyRuntimeCoordinate(specifics) {
-    if (specifics.envId != null && this._coordinate.envId !== specifics.envId) {
-      throw err_nice_action.fromId("not_implemented" /* not_implemented */, {
-        label: `updating RuntimeCoordinate with a different "envId" ("${this._coordinate.envId}" → "${specifics.envId}")`
-      });
-    }
-    this._coordinate = this._coordinate.specify(specifics);
-    this.apply();
+  getActionRouter() {
+    return this.actionRouter;
   }
-  registerRunningAction(ra) {
-    this._pendingRunningActions.set(ra.cuid, ra);
-    ra.addUpdateListeners([
-      (update) => {
-        if (update.type === "finished" /* finished */) {
-          this._pendingRunningActions.delete(ra.cuid);
-        }
-      }
-    ]);
+}
+
+// src/ActionRuntime/Handler/ExternalClient/Transport/err_nice_transport.ts
+import { err as err2 } from "@nice-code/error";
+
+// src/ActionRuntime/Handler/ExternalClient/err_nice_external_client.ts
+var err_nice_external_client = err_nice_action.createChildDomain({
+  domain: "err_nice_external_client",
+  schema: {}
+});
+
+// src/ActionRuntime/Handler/ExternalClient/Transport/err_nice_transport.ts
+var EErrId_NiceTransport;
+((EErrId_NiceTransport2) => {
+  EErrId_NiceTransport2["timeout"] = "timeout";
+  EErrId_NiceTransport2["not_found"] = "not_found";
+  EErrId_NiceTransport2["unsupported"] = "unsupported";
+  EErrId_NiceTransport2["initialization_failed"] = "initialization_failed";
+  EErrId_NiceTransport2["send_failed"] = "send_failed";
+  EErrId_NiceTransport2["invalid_action_response"] = "invalid_action_response";
+})(EErrId_NiceTransport ||= {});
+var err_nice_transport = err_nice_external_client.createChildDomain({
+  domain: "err_nice_transport",
+  schema: {
+    ["timeout" /* timeout */]: err2({
+      message: ({ timeout }) => `ActionConnect transport timed out after ${timeout}ms.`
+    }),
+    ["not_found" /* not_found */]: err2({
+      message: ({ actionId }) => `No connected transport found for action "${actionId}".`
+    }),
+    ["unsupported" /* unsupported */]: err2({
+      message: ({ transportTypes }) => `${transportTypes.length} Transport(s) [${transportTypes.join(", ")}] found but returned "unsupported" status.`
+    }),
+    ["initialization_failed" /* initialization_failed */]: err2({
+      message: ({ actionId }) => `Transports found for action "${actionId}", but none are ready.`
+    }),
+    ["send_failed" /* send_failed */]: err2({
+      message: ({ actionId, httpStatusCode, message }) => `Failed to send action "${actionId}" [${httpStatusCode ?? "Unknown status"}]: ${message ?? "Unknown error"}.`,
+      httpStatusCode: ({ httpStatusCode }) => httpStatusCode ?? 500
+    }),
+    ["invalid_action_response" /* invalid_action_response */]: err2({
+      message: ({ actionId }) => `Invalid action response JSON structure for action "${actionId}"`
+    })
   }
-  resolveIncomingActionPayload(json) {
-    if (json.type === "request" /* request */) {
-      this.handleActionPayloadWire(json).catch((err2) => {
-        console.error(`[ActionRuntime] Incoming action [${json.domain}:${json.id}:${json.form}:${json.type}] unhandled:`, err2);
-      });
-      return;
-    }
-    this._pendingRunningActions.get(json.context.cuid)?._resolveFromJson(json);
+});
+
+// src/ActionRuntime/Handler/ExternalClient/Transport/Transport.types.ts
+var ETransportType;
+((ETransportType2) => {
+  ETransportType2["ws"] = "ws";
+  ETransportType2["http"] = "http";
+  ETransportType2["custom"] = "custom";
+})(ETransportType ||= {});
+var ETransportStatus;
+((ETransportStatus2) => {
+  ETransportStatus2["uninitialized"] = "uninitialized";
+  ETransportStatus2["unsupported"] = "unsupported";
+  ETransportStatus2["initializing"] = "initializing";
+  ETransportStatus2["ready"] = "ready";
+  ETransportStatus2["failed"] = "failed";
+})(ETransportStatus ||= {});
+
+// src/ActionRuntime/Handler/ExternalClient/Transport/ConnectionTransportManager.ts
+class ConnectionTransportManager {
+  _cache;
+  _transports = [];
+  constructor(_cache) {
+    this._cache = _cache;
   }
-  async handleActionPayloadWire(wire) {
-    let action;
-    if (isActionPayload_Any_JsonObject(wire)) {
-      const domain = this.actionRouter.domainManager.getActionDomainOrThrow(wire);
-      action = domain.hydrateAnyAction(wire);
-    }
-    if (action == null) {
-      throw err_nice_action.fromId("wire_not_action_data" /* wire_not_action_data */);
-    }
-    return this.handleActionPayload(action);
+  addTransport(transport) {
+    this._transports.push(transport);
   }
-  async handleActionPayload(action, options) {
-    if (action.type === "request" /* request */) {
-      const observers = action.context._domain._collectActionObservers();
-      let handlerForAction;
-      try {
-        handlerForAction = this.getHandlerForActionOrThrow(action, options);
-      } catch (err2) {
-        const runningAction2 = new RunningAction({
-          context: action.context,
-          request: action
-        });
-        runningAction2.addUpdateListeners(observers);
-        runningAction2._completeWithResult(action.errorResult(castNiceError(err2)));
-        return runningAction2;
-      }
-      const runningAction = await handlerForAction.handleActionRequest(action, {
-        ...options,
-        targetLocalRuntime: this
-      });
-      runningAction.addUpdateListeners(observers);
-      this._trySetupReturnDispatch(runningAction);
-      return runningAction;
-    }
-    throw err_nice_action.fromId("not_implemented" /* not_implemented */, {
-      label: `Handling incoming action payloads of type "${action.type}"`
-    });
+  getPreferredTransport() {
+    return this._transports[0];
   }
-  _getHandlerForAction(action, options) {
-    const handlers = this.actionRouter.getRouteDataEntriesForAction(action);
-    const targetExternalClient = options?.targetExternalClient;
-    const possibleHandlers = handlers.filter((handler2) => {
-      if (handler2.handlerType === "external" /* external */) {
-        if (targetExternalClient && !targetExternalClient.isSameFor(handler2.externalClient).id) {
-          return false;
+  async getReadyTransport(routeActionParams) {
+    const action = routeActionParams.action;
+    const candidates = [];
+    const unavailableTransports = [];
+    for (const transport of this._transports) {
+      const cacheKey = transport.getCacheKey(routeActionParams);
+      if (cacheKey != null) {
+        const cached = this._cache.get(cacheKey);
+        if (cached != null) {
+          if (cached instanceof Promise) {
+            candidates.push(cached);
+            continue;
+          }
+          candidates.push(Promise.resolve({ ...cached, transport }));
+          break;
         }
-        return true;
-      }
-      if (targetExternalClient != null) {
-        return false;
       }
-      if (action.type === "request" /* request */) {
-        return true;
+      const statusInfo = transport.getTransport(routeActionParams);
+      if (statusInfo.status === "ready" /* ready */) {
+        const readyData = statusInfo.readyData;
+        if (cacheKey != null) {
+          const entry = { methods: readyData, transport };
+          this._cache.set(cacheKey, entry);
+          readyData.addOnDisconnectListener?.(() => {
+            if (this._cache.get(cacheKey) === entry)
+              this._cache.delete(cacheKey);
+          });
+        }
+        candidates.push(Promise.resolve({ methods: readyData, transport }));
+        break;
       }
-      return false;
-    });
-    if (possibleHandlers.length === 0) {
-      return;
-    }
-    const scoringExternalClient = targetExternalClient ?? RuntimeCoordinate.unknown;
-    let handlerScore = -1;
-    let handler;
-    for (const possibleHandler of possibleHandlers) {
-      if (possibleHandler.handlerType === "local" /* local */ && handler == null) {
-        return possibleHandler;
+      if (statusInfo.status === "unsupported" /* unsupported */) {
+        unavailableTransports.push(transport);
+        continue;
       }
-      if (possibleHandler.handlerType === "external" /* external */) {
-        const score = scoringExternalClient.similarityLevel(possibleHandler.externalClient);
-        if (score > handlerScore) {
-          handlerScore = score;
-          handler = possibleHandler;
+      if (statusInfo.status === "initializing" /* initializing */) {
+        const promise = statusInfo.initializationPromise.then((info) => {
+          if (info.status === "failed" /* failed */) {
+            throw info.error;
+          }
+          if (info.status === "unsupported" /* unsupported */) {
+            throw err_nice_transport.fromId("unsupported" /* unsupported */, {
+              transportTypes: [transport.type]
+            });
+          }
+          const readyData = info.readyData;
+          const entry = { methods: readyData, transport };
+          if (cacheKey != null) {
+            if (this._cache.get(cacheKey) === promise) {
+              this._cache.set(cacheKey, entry);
+              readyData.addOnDisconnectListener?.(() => {
+                if (this._cache.get(cacheKey) === entry)
+                  this._cache.delete(cacheKey);
+              });
+            } else {
+              readyData.disconnect?.();
+            }
+          }
+          return entry;
+        }).catch((e) => {
+          if (cacheKey != null && this._cache.get(cacheKey) === promise) {
+            this._cache.delete(cacheKey);
+          }
+          throw e;
+        });
+        if (cacheKey != null) {
+          this._cache.set(cacheKey, promise);
         }
+        candidates.push(promise);
       }
     }
-    return handler;
-  }
-  getHandlerForActionOrThrow(action, options) {
-    const handler = this._getHandlerForAction(action, options);
-    if (handler == null) {
-      throw err_nice_action.fromId("no_action_execution_handler" /* no_action_execution_handler */, {
-        actionId: action.id,
-        domain: action.domain,
-        specifiedClient: options?.targetExternalClient
-      });
-    }
-    return handler;
-  }
-  addHandlers(handlers) {
-    for (const handler of handlers) {
-      if (handler.handlerType === "external" /* external */) {
-        handler._setIncomingActionDataListener((json) => this.resolveIncomingActionPayload(json));
-        this._registeredExternalHandlers.push(handler);
-      }
-      const handlerRouter = handler.getActionRouter();
-      this.actionRouter.addDomainsFromOther(handlerRouter);
-      if (this._applied) {
-        this.apply();
-      }
-      for (const key of handlerRouter.getRegisteredKeys()) {
-        const alreadyRegistered = this.actionRouter.getForKey(key).some((h) => h.cuid === handler.cuid);
-        if (!alreadyRegistered) {
-          this.actionRouter.addForKey(key, handler);
-        }
+    if (candidates.length === 0) {
+      if (unavailableTransports.length > 0) {
+        throw err_nice_transport.fromId("unsupported" /* unsupported */, {
+          transportTypes: unavailableTransports.map((t) => t.type)
+        });
       }
+      throw err_nice_transport.fromId("not_found" /* not_found */, {
+        actionId: action.id
+      });
     }
-    return this;
-  }
-  applyRuntimeForDomain(domain) {
-    const rootDomain = domain.rootDomain;
-    if (!rootDomain._hasRuntime(this)) {
-      rootDomain._registerRuntime(this);
-    }
-  }
-  apply() {
-    this._applied = true;
-    for (const domain of this.actionRouter.getDomains()) {
-      this.applyRuntimeForDomain(domain);
-    }
-    return this;
-  }
-  getReturnHandlerForOrigin(originClient) {
-    if (originClient.envId === UNSET_RUNTIME_ENV_ID)
-      return;
-    let bestScore = -1;
-    let bestHandler;
-    for (const handler of this._registeredExternalHandlers) {
-      const score = originClient.similarityLevel(handler.externalClient);
-      if (score > bestScore) {
-        bestScore = score;
-        bestHandler = handler;
+    let lastError;
+    for (const candidate of candidates) {
+      try {
+        return await candidate;
+      } catch (e) {
+        lastError = e;
       }
     }
-    return bestScore > 0 ? bestHandler : undefined;
-  }
-  resetRuntime() {
-    for (const ra of this._pendingRunningActions.values()) {
-      ra._abort(err_nice_action.fromId("runtime_reset" /* runtime_reset */));
-    }
-    for (const handler of this._registeredExternalHandlers) {
-      handler.clearTransportCache();
-    }
-  }
-  _trySetupReturnDispatch(runningAction) {
-    const originClient = runningAction.context.originClient;
-    if (originClient.envId === UNSET_RUNTIME_ENV_ID || originClient.isSameFor(this._coordinate).id) {
-      return;
-    }
-    runningAction.addUpdateListeners([
-      (update) => {
-        if (update.type === "finished" /* finished */ && update.finishType === "success" /* success */) {
-          const returnHandler = this.getReturnHandlerForOrigin(originClient);
-          returnHandler?.sendReturnPayload(update.response, { targetLocalRuntime: this }).catch(() => {});
-        }
-      }
-    ]);
-  }
-}
-var runtimeState = {
-  defaultLocalRuntime: undefined,
-  assumedRuntimeInfo: undefined
-};
-function getDefaultActionRuntime() {
-  if (runtimeState.assumedRuntimeInfo == null) {
-    runtimeState.assumedRuntimeInfo = getAssumedRuntimeInfo();
-  }
-  if (runtimeState.defaultLocalRuntime == null) {
-    runtimeState.defaultLocalRuntime = new ActionRuntime(RuntimeCoordinate.unknown.specify({
-      perId: `${runtimeState.assumedRuntimeInfo?.runtimeName ?? "unknown"}-runtime`
-    }));
+    throw err_nice_transport.fromId("initialization_failed" /* initialization_failed */, {
+      actionId: action.id
+    }).withOriginError(lastError);
   }
-  return runtimeState.defaultLocalRuntime;
-}
-
-// src/ActionRuntime/HandlerCallStack.ts
-var _stack = [];
-function pushHandlerCuid(cuid) {
-  _stack.push(cuid);
-}
-function popHandlerCuid() {
-  _stack.pop();
 }
-function peekHandlerCuid() {
-  return _stack[_stack.length - 1];
-}
-
-// src/ActionRuntime/Handler/ActionHandler.ts
-import { nanoid as nanoid3 } from "nanoid";
 
-class ActionHandler {
+// src/ActionRuntime/Handler/ExternalClient/ActionExternalClientHandler.ts
+class ActionExternalClientHandler extends ActionHandler {
+  externalClient;
+  handlerType = "external" /* external */;
   cuid;
-  constructor() {
-    this.cuid = nanoid3();
-  }
-  getActionRouter() {
-    return this.actionRouter;
-  }
-}
-
-// src/ActionRuntime/Handler/Local/ActionLocalHandler.ts
-class ActionLocalHandler extends ActionHandler {
-  handlerType = "local" /* local */;
+  _defaultTimeout;
+  _transportCache = new Map;
+  transportManager = new ConnectionTransportManager(this._transportCache);
+  _incomingActionDataListeners = [];
   actionRouter = new ActionRouter({
     contextType: "handler_route" /* handler_route */,
     handler: this
   });
-  constructor() {
+  constructor({
+    runtimeCoordinate: externalClientSpecifier,
+    transports,
+    defaultTimeout
+  }) {
     super();
+    this.externalClient = externalClientSpecifier;
+    this.cuid = nanoid3();
+    this._defaultTimeout = defaultTimeout ?? DEFAULT_TRANSPORT_TIMEOUT;
+    for (const transport of transports) {
+      const connection = transport._createConnection({
+        resolvers: {
+          onIncomingActionDataJson: (json) => {
+            for (const l of this._incomingActionDataListeners)
+              l(json);
+          }
+        }
+      });
+      connection.definition = transport;
+      this.transportManager.addTransport(connection);
+    }
   }
-  forDomain(domain, handler) {
-    this.actionRouter.forDomain(domain, handler);
+  forDomain(domain) {
+    this.actionRouter.forDomain(domain, true);
     return this;
   }
-  forAction(action, handler) {
-    this.actionRouter.forAction(action, handler);
+  forAction(action) {
+    this.actionRouter.forAction(action, true);
     return this;
   }
-  forActionIds(domain, ids, handler) {
-    this.actionRouter.forActionIds(domain, ids, handler);
+  forActionIds(domain, ids) {
+    this.actionRouter.forActionIds(domain, ids, true);
     return this;
   }
-  forDomainActionCases(domain, cases) {
-    this.actionRouter.forDomainActionCases(domain, cases);
-    return this;
+  _setIncomingActionDataListener(listener) {
+    this._incomingActionDataListeners.push(listener);
   }
   async handleActionRequest(action, config) {
-    const targetLocalRuntime = config?.targetLocalRuntime ?? ActionRuntime.getDefault();
-    const handler = this.actionRouter.getRouteDataForActionOrThrow(action, {
-      targetLocalRuntime
-    });
-    action.context.addRouteItem({
-      runtime: targetLocalRuntime.coordinate,
-      handler: this.toHandlerRouteItem(),
+    const localRuntime = config?.targetLocalRuntime ?? ActionRuntime.getDefault();
+    const localClient = localRuntime.coordinate;
+    const incomingTimeout = config?.timeout ?? this._defaultTimeout;
+    const parentCuid = peekHandlerCuid();
+    const callSite = action._callSite ?? new Error().stack;
+    const routeParams = {
+      action,
+      localClient,
+      externalClient: this.externalClient
+    };
+    const preferredTransport = this.transportManager.getPreferredTransport();
+    const routeItem = preferredTransport != null ? {
+      runtime: localClient,
+      handler: this.toHandlerRouteItem(preferredTransport, routeParams),
       time: Date.now()
-    });
+    } : undefined;
+    if (routeItem != null)
+      action.context.addRouteItem(routeItem);
     const runningAction = new RunningAction({
       context: action.context,
       request: action,
-      parentCuid: peekHandlerCuid(),
-      callSite: action._callSite ?? new Error().stack
-    });
-    this._handleRunningAction(handler, runningAction).catch((err2) => {
-      if (err2 instanceof NiceError) {
-        runningAction._completeWithResult(action.errorResult(err2));
-      } else if (isNiceErrorObject(err2)) {
-        runningAction._completeWithResult(action.errorResult(castNiceError2(err2)));
-      } else {
-        runningAction._abort(err2);
-      }
+      parentCuid,
+      callSite
     });
+    localRuntime.registerRunningAction(runningAction);
+    this._dispatchWhenTransportReady(runningAction, routeParams, routeItem, incomingTimeout);
     return runningAction;
   }
-  async _handleRunningAction(handler, runningAction) {
-    const state = runningAction.state;
-    if (state.result != null) {
-      return;
-    }
-    await Promise.resolve();
-    pushHandlerCuid(runningAction.cuid);
+  async _dispatchWhenTransportReady(runningAction, routeParams, routeItem, incomingTimeout) {
+    const action = routeParams.action;
     try {
-      const rawResult = await handler(state.request);
-      let result;
-      if (rawResult instanceof ActionPayload_Result) {
-        result = rawResult;
-      } else if (rawResult != null && isActionPayload_Result_JsonObject(rawResult)) {
-        const domain = this.actionRouter.domainManager.getActionDomainOrThrow(state.request);
-        result = domain.hydrateResultPayload(rawResult);
+      const { methods, transport } = await this.transportManager.getReadyTransport(routeParams);
+      const handlerRouteItem = this.toHandlerRouteItem(transport, routeParams);
+      if (routeItem != null) {
+        routeItem.handler = handlerRouteItem;
+        routeItem.time = Date.now();
       } else {
-        result = state.request.successResult(rawResult);
+        action.context.addRouteItem({
+          runtime: routeParams.localClient,
+          handler: handlerRouteItem,
+          time: Date.now()
+        });
       }
-      runningAction._completeWithResult(result);
-    } finally {
-      popHandlerCuid();
+      const sendInput = {
+        ...routeParams,
+        runningAction,
+        timeout: incomingTimeout
+      };
+      if (action.type === "request" /* request */ && methods.updateRunConfig != null) {
+        const runConfig = methods.updateRunConfig(sendInput);
+        sendInput.timeout = runConfig?.timeout ?? incomingTimeout;
+      }
+      methods.sendActionData(sendInput);
+    } catch (err3) {
+      runningAction._abort(err3);
     }
   }
-  async handlePayloadWireOrThrow(wire, config) {
-    const hydratedAction = this.actionRouter.domainManager.hydrateActionPayload(wire);
-    if (!(hydratedAction instanceof ActionPayload_Request)) {
-      throw err_nice_action.fromId("wire_action_not_payload" /* wire_action_not_payload */, {
-        domain: hydratedAction.domain,
-        actionId: hydratedAction.id,
-        actionState: hydratedAction.type ?? hydratedAction.form
+  async sendReturnPayload(payload, config) {
+    const localClient = config.targetLocalRuntime.coordinate;
+    try {
+      const { methods } = await this.transportManager.getReadyTransport({
+        action: payload,
+        localClient,
+        externalClient: this.externalClient
       });
+      if (methods.sendReturnData == null)
+        return false;
+      methods.sendReturnData(payload, { localClient, externalClient: this.externalClient });
+      return true;
+    } catch {
+      return false;
     }
-    return await this.handleActionRequest(hydratedAction, config);
   }
   toJsonObject() {
     return {
-      type: this.handlerType
+      type: this.handlerType,
+      client: this.externalClient
     };
   }
-  toHandlerRouteItem() {
+  toHandlerRouteItem(transport, input) {
     return {
-      type: this.handlerType
-    };
-  }
-}
-var createLocalHandler = () => {
-  return new ActionLocalHandler;
-};
-
-// src/utils/isAction_Context_JsonObject.ts
-var isAction_Context_JsonObject = (obj) => {
-  return isAction_Base_JsonObject(obj) && obj.form === "context" /* context */;
-};
-
-// src/utils/isAction_Core_JsonObject.ts
-var isAction_Core_JsonObject = (obj) => {
-  return isAction_Base_JsonObject(obj) && obj.form === "core" /* core */;
-};
-
-// src/utils/isAction_Any_JsonObject.ts
-function isAction_Any_JsonObject(obj) {
-  return isActionPayload_Any_JsonObject(obj) || isAction_Context_JsonObject(obj) || isAction_Core_JsonObject(obj);
-}
-
-// src/utils/assertIsActionJson.ts
-function assertIsActionJson(obj) {
-  if (!isAction_Any_JsonObject(obj)) {
-    throw err_nice_action.fromId("wire_not_action_data" /* wire_not_action_data */);
-  }
-}
-
-// src/utils/isAction_Any_Instance.ts
-function isAction_Any_Instance(value) {
-  return value instanceof ActionCore || value instanceof ActionPayload || value instanceof ActionContext;
-}
-
-// src/ActionDefinition/Domain/ActionDomainBase.ts
-class ActionDomainBase {
-  domain;
-  allDomains;
-  actionSchema;
-  _listeners = [];
-  constructor(definition) {
-    this.domain = definition.domain;
-    this.allDomains = definition.allDomains;
-    this.actionSchema = definition.actionSchema;
-  }
-  addActionListener(listener) {
-    this._listeners.push(listener);
-    return () => {
-      this._listeners = this._listeners.filter((l) => l !== listener);
+      type: this.handlerType,
+      client: this.externalClient,
+      transOrd: transport.transOrd,
+      transType: transport.type,
+      transInfo: transport.getRouteInfo(input)
     };
   }
-  _getActionObservers() {
-    return this._listeners;
+  clearTransportCache() {
+    for (const entry of this._transportCache.values()) {
+      if (entry instanceof Promise) {
+        entry.then((ready) => ready.methods.disconnect?.()).catch(() => {});
+      } else {
+        entry.methods.disconnect?.();
+      }
+    }
+    this._transportCache.clear();
   }
 }
+var createExternalClientHandler = (config) => {
+  return new ActionExternalClientHandler(config);
+};
 
-// src/ActionDefinition/Domain/ActionDomain.ts
-class ActionDomain extends ActionDomainBase {
-  _rootDomain;
-  _actionMap;
-  constructor(definition, {
-    rootDomain
-  }) {
-    super(definition);
-    this._rootDomain = rootDomain;
-    this._actionMap = this.createActionMap();
-  }
-  get rootDomain() {
-    return this._rootDomain;
+// src/ActionRuntime/ActionRuntime.ts
+class ActionRuntime {
+  _coordinate;
+  timeCreated;
+  runtimeInfo = getAssumedRuntimeInfo();
+  actionRouter;
+  _pendingRunningActions = new Map;
+  _registeredExternalHandlers = [];
+  _applied = false;
+  static getDefault() {
+    return getDefaultActionRuntime();
   }
-  _collectActionObservers() {
-    return [...this._rootDomain._getActionObservers(), ...this._getActionObservers()];
+  constructor(coordinate) {
+    this._coordinate = coordinate.specifyIfUnset({
+      insId: nanoid4(14)
+    });
+    this.timeCreated = Date.now();
+    this.actionRouter = new ActionRouter({
+      contextType: "runtime_to_handler" /* runtime_to_handler */,
+      runtime: this
+    });
   }
-  _registerRuntime(runtime2) {
-    this._rootDomain._registerRuntime(runtime2);
+  get coordinate() {
+    return this._coordinate;
   }
-  createChildDomain(subDomainDef) {
-    if (this.allDomains.includes(subDomainDef.domain)) {
-      throw err_nice_action.fromId("domain_already_exists_in_hierarchy" /* domain_already_exists_in_hierarchy */, {
-        domain: subDomainDef.domain,
-        allParentDomains: this.allDomains,
-        parentDomain: this.domain
+  specifyRuntimeCoordinate(specifics) {
+    if (specifics.envId != null && this._coordinate.envId !== specifics.envId) {
+      throw err_nice_action.fromId("not_implemented" /* not_implemented */, {
+        label: `updating RuntimeCoordinate with a different "envId" ("${this._coordinate.envId}" → "${specifics.envId}")`
       });
     }
-    return new ActionDomain({
-      allDomains: [...this.allDomains, subDomainDef.domain],
-      domain: subDomainDef.domain,
-      actionSchema: subDomainDef.actions
-    }, { rootDomain: this._rootDomain });
-  }
-  get action() {
-    return this._actionMap;
+    this._coordinate = this._coordinate.specify(specifics);
+    this.apply();
   }
-  actionsMap() {
-    return this._actionMap;
+  registerRunningAction(ra) {
+    this._pendingRunningActions.set(ra.cuid, ra);
+    ra.addUpdateListeners([
+      (update) => {
+        if (update.type === "finished" /* finished */) {
+          this._pendingRunningActions.delete(ra.cuid);
+        }
+      }
+    ]);
   }
-  actionForId(id) {
-    const actionSchema = this.actionSchema[id];
-    if (!actionSchema) {
-      throw err_nice_action.fromId("action_id_not_in_domain" /* action_id_not_in_domain */, {
-        domain: this.domain,
-        actionId: id
+  resolveIncomingActionPayload(json) {
+    if (json.type === "request" /* request */) {
+      this.handleActionPayloadWire(json).catch((err3) => {
+        console.error(`[ActionRuntime] Incoming action [${json.domain}:${json.id}:${json.form}:${json.type}] unhandled:`, err3);
       });
+      return;
     }
-    return new ActionCore(this, id);
-  }
-  wrapAsPartialLocalHandler(wrappedActionExecutor) {
-    const _handler = new ActionLocalHandler;
-    const executor = wrappedActionExecutor;
-    for (const actionKey in wrappedActionExecutor) {
-      if (!this.actionSchema[actionKey]) {
-        continue;
-      }
-      _handler.forAction(this.actionForId(actionKey), (request) => executor[request.id](request.input));
-    }
-    return _handler;
-  }
-  wrapAsLocalHandler(wrappedActionExecutor) {
-    const _handler = new ActionLocalHandler;
-    const executor = wrappedActionExecutor;
-    return _handler.forDomain(this, (request) => executor[request.id](request.input));
-  }
-  hydrateContext(id, contextData) {
-    return new ActionContext(this, id, {
-      timeCreated: contextData.timeCreated,
-      cuid: contextData.cuid,
-      routing: contextData.routing.map((item) => {
-        return {
-          runtime: new RuntimeCoordinate(item.runtime),
-          handler: item.handler,
-          time: item.time
-        };
-      }),
-      originClient: contextData.originClient ? new RuntimeCoordinate(contextData.originClient) : RuntimeCoordinate.unknown
-    });
-  }
-  isDomainAction(action) {
-    return isAction_Any_Instance(action) && action.domain === this.domain;
+    this._pendingRunningActions.get(json.context.cuid)?._resolveFromJson(json);
   }
-  hydrateRequestPayload(serialized) {
-    if (serialized.type !== "request" /* request */) {
-      throw err_nice_action.fromId("hydration_action_state_mismatch" /* hydration_action_state_mismatch */, {
-        expected: "request" /* request */,
-        received: serialized.type
-      });
+  async handleActionPayloadWire(wire) {
+    let action;
+    if (isActionPayload_Any_JsonObject(wire)) {
+      const domain = this.actionRouter.domainManager.getActionDomainOrThrow(wire);
+      action = domain.hydrateAnyAction(wire);
     }
-    if (serialized.domain !== this.domain) {
-      throw err_nice_action.fromId("hydration_domain_mismatch" /* hydration_domain_mismatch */, {
-        expected: this.domain,
-        received: serialized.domain
-      });
+    if (action == null) {
+      throw err_nice_action.fromId("wire_not_action_data" /* wire_not_action_data */);
     }
-    const id = serialized.id;
-    if (!this.actionSchema[id]) {
-      throw err_nice_action.fromId("hydration_action_id_not_found" /* hydration_action_id_not_found */, {
-        domain: this.domain,
-        actionId: serialized.id
+    return this.handleActionPayload(action);
+  }
+  async handleActionPayload(action, options) {
+    if (action.type === "request" /* request */) {
+      const observers = action.context._domain._collectActionObservers();
+      let handlerForAction;
+      try {
+        handlerForAction = this.getHandlerForActionOrThrow(action, options);
+      } catch (err3) {
+        const runningAction2 = new RunningAction({
+          context: action.context,
+          request: action
+        });
+        runningAction2.addUpdateListeners(observers);
+        runningAction2._completeWithResult(action.errorResult(castNiceError(err3)));
+        return runningAction2;
+      }
+      const runningAction = await handlerForAction.handleActionRequest(action, {
+        ...options,
+        targetLocalRuntime: this
       });
+      runningAction.addUpdateListeners(observers);
+      this._trySetupReturnDispatch(runningAction);
+      return runningAction;
     }
-    const contextAction = this.hydrateContext(id, serialized.context);
-    return new ActionPayload_Request({ context: contextAction }, contextAction.deserializeInput(serialized.input), {
-      time: serialized.time
+    throw err_nice_action.fromId("not_implemented" /* not_implemented */, {
+      label: `Handling incoming action payloads of type "${action.type}"`
     });
   }
-  hydrateResultPayload(serialized) {
-    if (serialized.type !== "result" /* result */) {
-      throw err_nice_action.fromId("hydration_action_state_mismatch" /* hydration_action_state_mismatch */, {
-        expected: "result" /* result */,
-        received: serialized.type
-      });
-    }
-    if (serialized.domain !== this.domain) {
-      throw err_nice_action.fromId("hydration_domain_mismatch" /* hydration_domain_mismatch */, {
-        expected: this.domain,
-        received: serialized.domain
-      });
-    }
-    const id = serialized.id;
-    if (!this.actionSchema[id]) {
-      throw err_nice_action.fromId("hydration_action_id_not_found" /* hydration_action_id_not_found */, {
-        domain: this.domain,
-        actionId: serialized.id
-      });
-    }
-    const contextAction = this.hydrateContext(id, serialized.context);
-    const result = serialized.result.ok ? {
-      ok: true,
-      output: contextAction.schema.deserializeOutput(serialized.result.output)
-    } : serialized.result;
-    return new ActionPayload_Result({ context: contextAction }, result, {
-      time: serialized.time
-    });
-  }
-  hydrateAnyAction(actionJson) {
-    assertIsActionJson(actionJson);
-    if (actionJson.form === "data" /* data */) {
-      if (actionJson.type === "request" /* request */) {
-        return this.hydrateRequestPayload(actionJson);
+  _getHandlerForAction(action, options) {
+    const handlers = this.actionRouter.getRouteDataEntriesForAction(action);
+    const targetExternalClient = options?.targetExternalClient;
+    const possibleHandlers = handlers.filter((handler2) => {
+      if (handler2.handlerType === "external" /* external */) {
+        if (targetExternalClient && !targetExternalClient.isSameFor(handler2.externalClient).id) {
+          return false;
+        }
+        return true;
       }
-      if (actionJson.type === "result" /* result */) {
-        return this.hydrateResultPayload(actionJson);
+      if (targetExternalClient != null) {
+        return false;
       }
-    }
-    return this.actionForId(actionJson.id);
-  }
-  async runAction(request, options) {
-    const allListeners = [
-      ...options?.listeners ?? [],
-      ...this._listeners
-    ];
-    return this._rootDomain._runAction(request, {
-      ...options,
-      listeners: allListeners
+      if (action.type === "request" /* request */) {
+        return true;
+      }
+      return false;
     });
-  }
-  createActionMap() {
-    const map = {};
-    for (const id in this.actionSchema) {
-      map[id] = new ActionCore(this, id);
+    if (possibleHandlers.length === 0) {
+      return;
     }
-    return map;
-  }
-}
-// src/ActionRuntime/ActionRuntimeManager.ts
-class ActionRuntimeManager {
-  _runtimes = new Map;
-  _preferredRuntimeClientId = null;
-  _context;
-  constructor(context) {
-    this._context = context ?? {};
+    const scoringExternalClient = targetExternalClient ?? RuntimeCoordinate.unknown;
+    let handlerScore = -1;
+    let handler;
+    for (const possibleHandler of possibleHandlers) {
+      if (possibleHandler.handlerType === "local" /* local */ && handler == null) {
+        return possibleHandler;
+      }
+      if (possibleHandler.handlerType === "external" /* external */) {
+        const score = scoringExternalClient.similarityLevel(possibleHandler.externalClient);
+        if (score > handlerScore) {
+          handlerScore = score;
+          handler = possibleHandler;
+        }
+      }
+    }
+    return handler;
   }
-  registerRuntime(runtime2) {
-    const runtimeId = runtime2.coordinate.stringId;
-    if (this._runtimes.has(runtimeId)) {
-      throw err_nice_action.fromId("client_runtime_already_registered" /* client_runtime_already_registered */, {
-        context: this._context,
-        client: runtime2.coordinate
+  getHandlerForActionOrThrow(action, options) {
+    const handler = this._getHandlerForAction(action, options);
+    if (handler == null) {
+      throw err_nice_action.fromId("no_action_execution_handler" /* no_action_execution_handler */, {
+        actionId: action.id,
+        domain: action.domain,
+        specifiedClient: options?.targetExternalClient
       });
     }
-    for (const id of runtime2.coordinate.toStringIds()) {
-      if (this._runtimes.has(id)) {
-        continue;
-      }
-      this._runtimes.set(id, runtime2);
-    }
+    return handler;
   }
-  getRuntimeAndHandlerForAction(action, options, throwOnIssue) {
-    const localRuntime = options?.targetLocalRuntime;
-    if (localRuntime != null) {
-      const runtime2 = throwOnIssue ? this.getBestRuntimeOrThrow(options?.targetLocalRuntime?.coordinate) : this.getBestRuntime(options?.targetLocalRuntime?.coordinate);
-      if (runtime2 == null) {
-        return;
+  addHandlers(handlers) {
+    for (const handler of handlers) {
+      if (handler.handlerType === "external" /* external */) {
+        handler._setIncomingActionDataListener((json) => this.resolveIncomingActionPayload(json));
+        this._registeredExternalHandlers.push(handler);
       }
-      const handler = runtime2._getHandlerForAction(action, options);
-      if (handler != null) {
-        return { handler, runtime: runtime2 };
+      const handlerRouter = handler.getActionRouter();
+      this.actionRouter.addDomainsFromOther(handlerRouter);
+      if (this._applied) {
+        this.apply();
       }
-      if (throwOnIssue) {
-        throw err_nice_action.fromId("no_action_execution_handler" /* no_action_execution_handler */, {
-          domain: action.domain,
-          actionId: action.id,
-          specifiedClient: localRuntime.coordinate
-        });
+      for (const key of handlerRouter.getRegisteredKeys()) {
+        const alreadyRegistered = this.actionRouter.getForKey(key).some((h) => h.cuid === handler.cuid);
+        if (!alreadyRegistered) {
+          this.actionRouter.addForKey(key, handler);
+        }
       }
     }
-    for (const runtime2 of this._runtimes.values()) {
-      const handler = runtime2._getHandlerForAction(action);
-      if (handler) {
-        return { handler, runtime: runtime2 };
-      }
+    return this;
+  }
+  connectTo(externalCoordinate, options) {
+    const handler = new ActionExternalClientHandler({
+      runtimeCoordinate: externalCoordinate,
+      transports: options.transports,
+      defaultTimeout: options.defaultTimeout
+    });
+    for (const domain of options.domains ?? []) {
+      handler.forDomain(domain);
     }
-    if (throwOnIssue) {
-      throw err_nice_action.fromId("no_action_execution_handler" /* no_action_execution_handler */, {
-        domain: action.domain,
-        actionId: action.id,
-        specifiedClient: options?.targetLocalRuntime?.coordinate
-      });
+    for (const action of options.actions ?? []) {
+      handler.forAction(action);
     }
+    this.addHandlers([handler, ...options.localHandlers ?? []]);
+    this.apply();
+    return handler;
   }
-  getRuntimeAndHandlerForActionOrThrow(action, options) {
-    return this.getRuntimeAndHandlerForAction(action, options, true);
+  applyRuntimeForDomain(domain) {
+    const rootDomain = domain.rootDomain;
+    if (!rootDomain._hasRuntime(this)) {
+      rootDomain._registerRuntime(this);
+    }
   }
-  setPreferredRuntime(runtime2) {
-    const runtimeId = runtime2.coordinate.stringId;
-    this._preferredRuntimeClientId = runtimeId;
+  apply() {
+    this._applied = true;
+    for (const domain of this.actionRouter.getDomains()) {
+      this.applyRuntimeForDomain(domain);
+    }
+    return this;
   }
-  getPreferredRuntime() {
-    if (this._preferredRuntimeClientId) {
-      const runtime2 = this._runtimes.get(this._preferredRuntimeClientId);
-      if (runtime2) {
-        return runtime2;
+  getReturnHandlerForOrigin(originClient) {
+    if (originClient.envId === UNSET_RUNTIME_ENV_ID)
+      return;
+    let bestScore = -1;
+    let bestHandler;
+    for (const handler of this._registeredExternalHandlers) {
+      const score = originClient.similarityLevel(handler.externalClient);
+      if (score > bestScore) {
+        bestScore = score;
+        bestHandler = handler;
       }
     }
-    return this._runtimes.values().next().value;
+    return bestScore > 0 ? bestHandler : undefined;
   }
-  getBestRuntimeForSpecifier(clientSpecifier) {
-    const actionClient = new RuntimeCoordinate(clientSpecifier);
-    const ids = actionClient.toStringIds();
-    for (const id of ids) {
-      const runtime2 = this._runtimes.get(id);
-      if (runtime2) {
-        return runtime2;
-      }
+  resetRuntime() {
+    for (const ra of this._pendingRunningActions.values()) {
+      ra._abort(err_nice_action.fromId("runtime_reset" /* runtime_reset */));
+    }
+    for (const handler of this._registeredExternalHandlers) {
+      handler.clearTransportCache();
     }
   }
-  getBestRuntime(clientSpecifier) {
-    return clientSpecifier != null ? this.getBestRuntimeForSpecifier(clientSpecifier) : this.getPreferredRuntime();
+  _trySetupReturnDispatch(runningAction) {
+    const originClient = runningAction.context.originClient;
+    if (originClient.envId === UNSET_RUNTIME_ENV_ID || originClient.isSameFor(this._coordinate).id) {
+      return;
+    }
+    runningAction.addUpdateListeners([
+      (update) => {
+        if (update.type === "finished" /* finished */ && update.finishType === "success" /* success */) {
+          const returnHandler = this.getReturnHandlerForOrigin(originClient);
+          returnHandler?.sendReturnPayload(update.response, { targetLocalRuntime: this }).catch(() => {});
+        }
+      }
+    ]);
   }
-  hasRuntime(runtime2) {
-    return this._runtimes.has(runtime2.coordinate.stringId);
+}
+var runtimeState = {
+  defaultLocalRuntime: undefined,
+  assumedRuntimeInfo: undefined
+};
+function getDefaultActionRuntime() {
+  if (runtimeState.assumedRuntimeInfo == null) {
+    runtimeState.assumedRuntimeInfo = getAssumedRuntimeInfo();
   }
-  getBestRuntimeOrThrow(specifier) {
-    const runtime2 = this.getBestRuntime(specifier);
-    if (!runtime2) {
-      if (specifier == null) {
-        throw err_nice_action.fromId("no_client_runtimes_registered" /* no_client_runtimes_registered */, {
-          context: this._context
-        });
-      }
-      throw err_nice_action.fromId("client_runtime_not_registered" /* client_runtime_not_registered */, {
-        context: this._context,
-        clientStringId: runtimeCoordinateToStringIds(specifier)[0]
-      });
-    }
-    return runtime2;
+  if (runtimeState.defaultLocalRuntime == null) {
+    runtimeState.defaultLocalRuntime = new ActionRuntime(RuntimeCoordinate.unknown.specify({
+      perId: `${runtimeState.assumedRuntimeInfo?.runtimeName ?? "unknown"}-runtime`
+    }));
   }
+  return runtimeState.defaultLocalRuntime;
 }
 
-// src/ActionDefinition/Domain/ActionRootDomain.ts
-class ActionRootDomain extends ActionDomainBase {
-  domainDefinition;
-  _actionRuntimeManager;
-  constructor(domainDefinition) {
-    const domainId = domainDefinition.domain;
-    super({
-      domain: domainId,
-      allDomains: [domainId],
-      actionSchema: {}
+// src/ActionRuntime/Handler/Local/ActionLocalHandler.ts
+class ActionLocalHandler extends ActionHandler {
+  handlerType = "local" /* local */;
+  actionRouter = new ActionRouter({
+    contextType: "handler_route" /* handler_route */,
+    handler: this
+  });
+  constructor() {
+    super();
+  }
+  forDomain(domain, handler) {
+    this.actionRouter.forDomain(domain, handler);
+    return this;
+  }
+  forAction(action, handler) {
+    this.actionRouter.forAction(action, handler);
+    return this;
+  }
+  forActionIds(domain, ids, handler) {
+    this.actionRouter.forActionIds(domain, ids, handler);
+    return this;
+  }
+  forDomainActionCases(domain, cases) {
+    this.actionRouter.forDomainActionCases(domain, cases);
+    return this;
+  }
+  async handleActionRequest(action, config) {
+    const targetLocalRuntime = config?.targetLocalRuntime ?? ActionRuntime.getDefault();
+    const handler = this.actionRouter.getRouteDataForActionOrThrow(action, {
+      targetLocalRuntime
     });
-    this.domainDefinition = domainDefinition;
-    this._actionRuntimeManager = new ActionRuntimeManager({ domain: domainId });
+    action.context.addRouteItem({
+      runtime: targetLocalRuntime.coordinate,
+      handler: this.toHandlerRouteItem(),
+      time: Date.now()
+    });
+    const runningAction = new RunningAction({
+      context: action.context,
+      request: action,
+      parentCuid: peekHandlerCuid(),
+      callSite: action._callSite ?? new Error().stack
+    });
+    this._handleRunningAction(handler, runningAction).catch((err3) => {
+      if (err3 instanceof NiceError) {
+        runningAction._completeWithResult(action.errorResult(err3));
+      } else if (isNiceErrorObject(err3)) {
+        runningAction._completeWithResult(action.errorResult(castNiceError2(err3)));
+      } else {
+        runningAction._abort(err3);
+      }
+    });
+    return runningAction;
+  }
+  async _handleRunningAction(handler, runningAction) {
+    const state = runningAction.state;
+    if (state.result != null) {
+      return;
+    }
+    await Promise.resolve();
+    pushHandlerCuid(runningAction.cuid);
+    try {
+      const rawResult = await handler(state.request);
+      let result;
+      if (rawResult instanceof ActionPayload_Result) {
+        result = rawResult;
+      } else if (rawResult != null && isActionPayload_Result_JsonObject(rawResult)) {
+        const domain = this.actionRouter.domainManager.getActionDomainOrThrow(state.request);
+        result = domain.hydrateResultPayload(rawResult);
+      } else {
+        result = state.request.successResult(rawResult);
+      }
+      runningAction._completeWithResult(result);
+    } finally {
+      popHandlerCuid();
+    }
+  }
+  async handlePayloadWireOrThrow(wire, config) {
+    const hydratedAction = this.actionRouter.domainManager.hydrateActionPayload(wire);
+    if (!(hydratedAction instanceof ActionPayload_Request)) {
+      throw err_nice_action.fromId("wire_action_not_payload" /* wire_action_not_payload */, {
+        domain: hydratedAction.domain,
+        actionId: hydratedAction.id,
+        actionState: hydratedAction.type ?? hydratedAction.form
+      });
+    }
+    return await this.handleActionRequest(hydratedAction, config);
+  }
+  toJsonObject() {
+    return {
+      type: this.handlerType
+    };
+  }
+  toHandlerRouteItem() {
+    return {
+      type: this.handlerType
+    };
+  }
+}
+var createLocalHandler = () => {
+  return new ActionLocalHandler;
+};
+
+// src/utils/isAction_Context_JsonObject.ts
+var isAction_Context_JsonObject = (obj) => {
+  return isAction_Base_JsonObject(obj) && obj.form === "context" /* context */;
+};
+
+// src/utils/isAction_Core_JsonObject.ts
+var isAction_Core_JsonObject = (obj) => {
+  return isAction_Base_JsonObject(obj) && obj.form === "core" /* core */;
+};
+
+// src/utils/isAction_Any_JsonObject.ts
+function isAction_Any_JsonObject(obj) {
+  return isActionPayload_Any_JsonObject(obj) || isAction_Context_JsonObject(obj) || isAction_Core_JsonObject(obj);
+}
+
+// src/utils/assertIsActionJson.ts
+function assertIsActionJson(obj) {
+  if (!isAction_Any_JsonObject(obj)) {
+    throw err_nice_action.fromId("wire_not_action_data" /* wire_not_action_data */);
+  }
+}
+
+// src/utils/isAction_Any_Instance.ts
+function isAction_Any_Instance(value) {
+  return value instanceof ActionCore || value instanceof ActionPayload || value instanceof ActionContext;
+}
+
+// src/ActionDefinition/Domain/ActionDomainBase.ts
+class ActionDomainBase {
+  domain;
+  allDomains;
+  actionSchema;
+  _listeners = [];
+  constructor(definition) {
+    this.domain = definition.domain;
+    this.allDomains = definition.allDomains;
+    this.actionSchema = definition.actionSchema;
+  }
+  addActionListener(listener) {
+    this._listeners.push(listener);
+    return () => {
+      this._listeners = this._listeners.filter((l) => l !== listener);
+    };
+  }
+  _getActionObservers() {
+    return this._listeners;
+  }
+}
+
+// src/ActionDefinition/Domain/ActionDomain.ts
+class ActionDomain extends ActionDomainBase {
+  _rootDomain;
+  _actionMap;
+  constructor(definition, {
+    rootDomain
+  }) {
+    super(definition);
+    this._rootDomain = rootDomain;
+    this._actionMap = this.createActionMap();
+  }
+  get rootDomain() {
+    return this._rootDomain;
+  }
+  _collectActionObservers() {
+    return [...this._rootDomain._getActionObservers(), ...this._getActionObservers()];
+  }
+  _registerRuntime(runtime2) {
+    this._rootDomain._registerRuntime(runtime2);
   }
   createChildDomain(subDomainDef) {
     if (this.allDomains.includes(subDomainDef.domain)) {
@@ -1599,440 +1674,402 @@ class ActionRootDomain extends ActionDomainBase {
       allDomains: [...this.allDomains, subDomainDef.domain],
       domain: subDomainDef.domain,
       actionSchema: subDomainDef.actions
-    }, { rootDomain: this });
-  }
-  _registerRuntime(runtime2) {
-    this._actionRuntimeManager.registerRuntime(runtime2);
+    }, { rootDomain: this._rootDomain });
   }
-  _hasRuntime(runtime2) {
-    return this._actionRuntimeManager.hasRuntime(runtime2);
+  get action() {
+    return this._actionMap;
   }
-  getRuntime(clientSpecifier) {
-    return this._actionRuntimeManager.getBestRuntimeForSpecifier(clientSpecifier);
+  actionsMap() {
+    return this._actionMap;
   }
-  async _runAction(actionPayload, options) {
-    const allListeners = [...this._listeners, ...options?.listeners ?? []];
-    let handlerAndRuntime;
-    try {
-      handlerAndRuntime = this._actionRuntimeManager.getRuntimeAndHandlerForActionOrThrow(actionPayload, options);
-    } catch (err2) {
-      const runningAction2 = new RunningAction({
-        context: actionPayload.context,
-        request: actionPayload,
-        callSite: actionPayload._callSite
+  actionForId(id) {
+    const actionSchema = this.actionSchema[id];
+    if (!actionSchema) {
+      throw err_nice_action.fromId("action_id_not_in_domain" /* action_id_not_in_domain */, {
+        domain: this.domain,
+        actionId: id
       });
-      runningAction2.addUpdateListeners(allListeners);
-      runningAction2._failWithError(err2);
-      throw err2;
     }
-    const { handler, runtime: runtime2 } = handlerAndRuntime;
-    actionPayload.context._setOriginClient(runtime2.coordinate);
-    const runningAction = await handler.handleActionRequest(actionPayload, {
-      targetLocalRuntime: runtime2
-    });
-    runningAction.addUpdateListeners(allListeners);
-    return runningAction;
+    return new ActionCore(this, id);
   }
-}
-// src/ActionDefinition/Domain/helpers/createRootActionDomain.ts
-var createActionRootDomain = (definition) => {
-  return new ActionRootDomain(definition);
-};
-// src/ActionDefinition/Schema/ActionSchema.ts
-import { extractMessageFromStandardSchema } from "@nice-code/common-errors";
-class ActionSchema {
-  _errorDeclarations = [];
-  inputOptions;
-  outputOptions;
-  get inputSchema() {
-    return this.inputOptions?.schema;
+  wrapAsPartialLocalHandler(wrappedActionExecutor) {
+    const _handler = new ActionLocalHandler;
+    const executor = wrappedActionExecutor;
+    for (const actionKey in wrappedActionExecutor) {
+      if (!this.actionSchema[actionKey]) {
+        continue;
+      }
+      _handler.forAction(this.actionForId(actionKey), (request) => executor[request.id](request.input));
+    }
+    return _handler;
   }
-  get outputSchema() {
-    return this.outputOptions?.schema;
+  wrapAsLocalHandler(wrappedActionExecutor) {
+    const _handler = new ActionLocalHandler;
+    const executor = wrappedActionExecutor;
+    return _handler.forDomain(this, (request) => executor[request.id](request.input));
   }
-  input(options) {
-    this.inputOptions = options;
-    return this;
+  hydrateContext(id, contextData) {
+    return new ActionContext(this, id, {
+      timeCreated: contextData.timeCreated,
+      cuid: contextData.cuid,
+      routing: contextData.routing.map((item) => {
+        return {
+          runtime: new RuntimeCoordinate(item.runtime),
+          handler: item.handler,
+          time: item.time
+        };
+      }),
+      originClient: contextData.originClient ? new RuntimeCoordinate(contextData.originClient) : RuntimeCoordinate.unknown
+    });
   }
-  output(options) {
-    this.outputOptions = options;
-    return this;
+  isDomainAction(action) {
+    return isAction_Any_Instance(action) && action.domain === this.domain;
   }
-  throws(domain, ids) {
-    this._errorDeclarations.push({ _domain: domain, _ids: ids });
-    return this;
-  }
-  serializeInput(rawInput) {
-    if (this.inputOptions?.serialization) {
-      return this.inputOptions.serialization.serialize(rawInput);
-    }
-    return rawInput;
-  }
-  deserializeInput(serialized) {
-    if (this.inputOptions?.serialization) {
-      return this.inputOptions.serialization.deserialize(serialized);
-    }
-    return serialized;
-  }
-  validateInput(value, meta) {
-    if (this.inputOptions?.schema == null) {
-      return value;
+  hydrateRequestPayload(serialized) {
+    if (serialized.type !== "request" /* request */) {
+      throw err_nice_action.fromId("hydration_action_state_mismatch" /* hydration_action_state_mismatch */, {
+        expected: "request" /* request */,
+        received: serialized.type
+      });
     }
-    const result = this.inputOptions.schema["~standard"].validate(value);
-    if (result instanceof Promise) {
-      throw err_nice_action.fromId("action_input_validation_promise" /* action_input_validation_promise */, {
-        domain: meta.domain,
-        actionId: meta.actionId
+    if (serialized.domain !== this.domain) {
+      throw err_nice_action.fromId("hydration_domain_mismatch" /* hydration_domain_mismatch */, {
+        expected: this.domain,
+        received: serialized.domain
       });
     }
-    if (result.issues != null) {
-      throw err_nice_action.fromId("action_input_validation_failed" /* action_input_validation_failed */, {
-        domain: meta.domain,
-        actionId: meta.actionId,
-        validationMessage: extractMessageFromStandardSchema(result)
+    const id = serialized.id;
+    if (!this.actionSchema[id]) {
+      throw err_nice_action.fromId("hydration_action_id_not_found" /* hydration_action_id_not_found */, {
+        domain: this.domain,
+        actionId: serialized.id
       });
     }
-    return result.value;
+    const contextAction = this.hydrateContext(id, serialized.context);
+    return new ActionPayload_Request({ context: contextAction }, contextAction.deserializeInput(serialized.input), {
+      time: serialized.time
+    });
   }
-  validateOutput(value, meta) {
-    if (this.outputOptions?.schema == null) {
-      return value;
+  hydrateResultPayload(serialized) {
+    if (serialized.type !== "result" /* result */) {
+      throw err_nice_action.fromId("hydration_action_state_mismatch" /* hydration_action_state_mismatch */, {
+        expected: "result" /* result */,
+        received: serialized.type
+      });
     }
-    const result = this.outputOptions.schema["~standard"].validate(value);
-    if (result instanceof Promise) {
-      throw err_nice_action.fromId("action_output_validation_promise" /* action_output_validation_promise */, {
-        domain: meta.domain,
-        actionId: meta.actionId
+    if (serialized.domain !== this.domain) {
+      throw err_nice_action.fromId("hydration_domain_mismatch" /* hydration_domain_mismatch */, {
+        expected: this.domain,
+        received: serialized.domain
       });
     }
-    if (result.issues != null) {
-      throw err_nice_action.fromId("action_output_validation_failed" /* action_output_validation_failed */, {
-        domain: meta.domain,
-        actionId: meta.actionId,
-        validationMessage: extractMessageFromStandardSchema(result)
+    const id = serialized.id;
+    if (!this.actionSchema[id]) {
+      throw err_nice_action.fromId("hydration_action_id_not_found" /* hydration_action_id_not_found */, {
+        domain: this.domain,
+        actionId: serialized.id
       });
     }
-    return result.value;
+    const contextAction = this.hydrateContext(id, serialized.context);
+    const result = serialized.result.ok ? {
+      ok: true,
+      output: contextAction.schema.deserializeOutput(serialized.result.output)
+    } : serialized.result;
+    return new ActionPayload_Result({ context: contextAction }, result, {
+      time: serialized.time
+    });
   }
-  serializeOutput(rawOutput) {
-    if (this.outputOptions?.serialization) {
-      return this.outputOptions.serialization.serialize(rawOutput);
+  hydrateAnyAction(actionJson) {
+    assertIsActionJson(actionJson);
+    if (actionJson.form === "data" /* data */) {
+      if (actionJson.type === "request" /* request */) {
+        return this.hydrateRequestPayload(actionJson);
+      }
+      if (actionJson.type === "result" /* result */) {
+        return this.hydrateResultPayload(actionJson);
+      }
     }
-    return rawOutput;
+    return this.actionForId(actionJson.id);
   }
-  deserializeOutput(serialized) {
-    if (this.outputOptions?.serialization) {
-      return this.outputOptions.serialization.deserialize(serialized);
+  async runAction(request, options) {
+    const allListeners = [
+      ...options?.listeners ?? [],
+      ...this._listeners
+    ];
+    return this._rootDomain._runAction(request, {
+      ...options,
+      listeners: allListeners
+    });
+  }
+  createActionMap() {
+    const map = {};
+    for (const id in this.actionSchema) {
+      map[id] = new ActionCore(this, id);
     }
-    return serialized;
+    return map;
   }
 }
-var actionSchema = () => {
-  return new ActionSchema;
-};
-// src/ActionRuntime/Handler/ExternalClient/ActionExternalClientHandler.ts
-import { nanoid as nanoid4 } from "nanoid";
-
-// src/ActionRuntime/Handler/ExternalClient/Transport/err_nice_transport.ts
-import { err as err2 } from "@nice-code/error";
-
-// src/ActionRuntime/Handler/ExternalClient/err_nice_external_client.ts
-var err_nice_external_client = err_nice_action.createChildDomain({
-  domain: "err_nice_external_client",
-  schema: {}
-});
-
-// src/ActionRuntime/Handler/ExternalClient/Transport/err_nice_transport.ts
-var EErrId_NiceTransport;
-((EErrId_NiceTransport2) => {
-  EErrId_NiceTransport2["timeout"] = "timeout";
-  EErrId_NiceTransport2["not_found"] = "not_found";
-  EErrId_NiceTransport2["unsupported"] = "unsupported";
-  EErrId_NiceTransport2["initialization_failed"] = "initialization_failed";
-  EErrId_NiceTransport2["send_failed"] = "send_failed";
-  EErrId_NiceTransport2["invalid_action_response"] = "invalid_action_response";
-})(EErrId_NiceTransport ||= {});
-var err_nice_transport = err_nice_external_client.createChildDomain({
-  domain: "err_nice_transport",
-  schema: {
-    ["timeout" /* timeout */]: err2({
-      message: ({ timeout }) => `ActionConnect transport timed out after ${timeout}ms.`
-    }),
-    ["not_found" /* not_found */]: err2({
-      message: ({ actionId }) => `No connected transport found for action "${actionId}".`
-    }),
-    ["unsupported" /* unsupported */]: err2({
-      message: ({ transportTypes }) => `${transportTypes.length} Transport(s) [${transportTypes.join(", ")}] found but returned "unsupported" status.`
-    }),
-    ["initialization_failed" /* initialization_failed */]: err2({
-      message: ({ actionId }) => `Transports found for action "${actionId}", but none are ready.`
-    }),
-    ["send_failed" /* send_failed */]: err2({
-      message: ({ actionId, httpStatusCode, message }) => `Failed to send action "${actionId}" [${httpStatusCode ?? "Unknown status"}]: ${message ?? "Unknown error"}.`,
-      httpStatusCode: ({ httpStatusCode }) => httpStatusCode ?? 500
-    }),
-    ["invalid_action_response" /* invalid_action_response */]: err2({
-      message: ({ actionId }) => `Invalid action response JSON structure for action "${actionId}"`
-    })
-  }
-});
-
-// src/ActionRuntime/Handler/ExternalClient/Transport/Transport.types.ts
-var ETransportType;
-((ETransportType2) => {
-  ETransportType2["ws"] = "ws";
-  ETransportType2["http"] = "http";
-  ETransportType2["custom"] = "custom";
-})(ETransportType ||= {});
-var ETransportStatus;
-((ETransportStatus2) => {
-  ETransportStatus2["uninitialized"] = "uninitialized";
-  ETransportStatus2["unsupported"] = "unsupported";
-  ETransportStatus2["initializing"] = "initializing";
-  ETransportStatus2["ready"] = "ready";
-  ETransportStatus2["failed"] = "failed";
-})(ETransportStatus ||= {});
-
-// src/ActionRuntime/Handler/ExternalClient/Transport/ConnectionTransportManager.ts
-class ConnectionTransportManager {
-  _cache;
-  _transports = [];
-  constructor(_cache) {
-    this._cache = _cache;
-  }
-  addTransport(transport) {
-    this._transports.push(transport);
-  }
-  getPreferredTransport() {
-    return this._transports[0];
+// src/ActionRuntime/ActionRuntimeManager.ts
+class ActionRuntimeManager {
+  _runtimes = new Map;
+  _preferredRuntimeClientId = null;
+  _context;
+  constructor(context) {
+    this._context = context ?? {};
   }
-  async getReadyTransport(routeActionParams) {
-    const action = routeActionParams.action;
-    const candidates = [];
-    const unavailableTransports = [];
-    for (const transport of this._transports) {
-      const cacheKey = transport.getCacheKey(routeActionParams);
-      if (cacheKey != null) {
-        const cached = this._cache.get(cacheKey);
-        if (cached != null) {
-          if (cached instanceof Promise) {
-            candidates.push(cached);
-            continue;
-          }
-          candidates.push(Promise.resolve({ ...cached, transport }));
-          break;
-        }
+  registerRuntime(runtime2) {
+    const runtimeId = runtime2.coordinate.stringId;
+    if (this._runtimes.has(runtimeId)) {
+      throw err_nice_action.fromId("client_runtime_already_registered" /* client_runtime_already_registered */, {
+        context: this._context,
+        client: runtime2.coordinate
+      });
+    }
+    for (const id of runtime2.coordinate.toStringIds()) {
+      if (this._runtimes.has(id)) {
+        continue;
       }
-      const statusInfo = transport.getTransport(routeActionParams);
-      if (statusInfo.status === "ready" /* ready */) {
-        const readyData = statusInfo.readyData;
-        if (cacheKey != null) {
-          this._cache.set(cacheKey, { methods: readyData, transport });
-          readyData.addOnDisconnectListener?.(() => this._cache.delete(cacheKey));
-        }
-        candidates.push(Promise.resolve({ methods: readyData, transport }));
-        break;
+      this._runtimes.set(id, runtime2);
+    }
+  }
+  getRuntimeAndHandlerForAction(action, options, throwOnIssue) {
+    const localRuntime = options?.targetLocalRuntime;
+    if (localRuntime != null) {
+      const runtime2 = throwOnIssue ? this.getBestRuntimeOrThrow(options?.targetLocalRuntime?.coordinate) : this.getBestRuntime(options?.targetLocalRuntime?.coordinate);
+      if (runtime2 == null) {
+        return;
       }
-      if (statusInfo.status === "unsupported" /* unsupported */) {
-        unavailableTransports.push(transport);
-        continue;
+      const handler = runtime2._getHandlerForAction(action, options);
+      if (handler != null) {
+        return { handler, runtime: runtime2 };
       }
-      if (statusInfo.status === "initializing" /* initializing */) {
-        const promise = statusInfo.initializationPromise.then((info) => {
-          if (info.status === "failed" /* failed */) {
-            throw info.error;
-          }
-          if (info.status === "unsupported" /* unsupported */) {
-            throw err_nice_transport.fromId("unsupported" /* unsupported */, {
-              transportTypes: [transport.type]
-            });
-          }
-          const readyData = info.readyData;
-          if (cacheKey != null) {
-            this._cache.set(cacheKey, { methods: readyData, transport });
-            readyData.addOnDisconnectListener?.(() => this._cache.delete(cacheKey));
-          }
-          return { methods: readyData, transport };
-        }).catch((e) => {
-          if (cacheKey != null)
-            this._cache.delete(cacheKey);
-          throw e;
+      if (throwOnIssue) {
+        throw err_nice_action.fromId("no_action_execution_handler" /* no_action_execution_handler */, {
+          domain: action.domain,
+          actionId: action.id,
+          specifiedClient: localRuntime.coordinate
         });
-        if (cacheKey != null) {
-          this._cache.set(cacheKey, promise);
-        }
-        candidates.push(promise);
       }
     }
-    if (candidates.length === 0) {
-      if (unavailableTransports.length > 0) {
-        throw err_nice_transport.fromId("unsupported" /* unsupported */, {
-          transportTypes: unavailableTransports.map((t) => t.type)
-        });
+    for (const runtime2 of this._runtimes.values()) {
+      const handler = runtime2._getHandlerForAction(action);
+      if (handler) {
+        return { handler, runtime: runtime2 };
       }
-      throw err_nice_transport.fromId("not_found" /* not_found */, {
-        actionId: action.id
+    }
+    if (throwOnIssue) {
+      throw err_nice_action.fromId("no_action_execution_handler" /* no_action_execution_handler */, {
+        domain: action.domain,
+        actionId: action.id,
+        specifiedClient: options?.targetLocalRuntime?.coordinate
       });
     }
-    let lastError;
-    for (const candidate of candidates) {
-      try {
-        return await candidate;
-      } catch (e) {
-        lastError = e;
+  }
+  getRuntimeAndHandlerForActionOrThrow(action, options) {
+    return this.getRuntimeAndHandlerForAction(action, options, true);
+  }
+  setPreferredRuntime(runtime2) {
+    const runtimeId = runtime2.coordinate.stringId;
+    this._preferredRuntimeClientId = runtimeId;
+  }
+  getPreferredRuntime() {
+    if (this._preferredRuntimeClientId) {
+      const runtime2 = this._runtimes.get(this._preferredRuntimeClientId);
+      if (runtime2) {
+        return runtime2;
       }
     }
-    throw err_nice_transport.fromId("initialization_failed" /* initialization_failed */, {
-      actionId: action.id
-    }).withOriginError(lastError);
+    return this._runtimes.values().next().value;
+  }
+  getBestRuntimeForSpecifier(clientSpecifier) {
+    const actionClient = new RuntimeCoordinate(clientSpecifier);
+    const ids = actionClient.toStringIds();
+    for (const id of ids) {
+      const runtime2 = this._runtimes.get(id);
+      if (runtime2) {
+        return runtime2;
+      }
+    }
+  }
+  getBestRuntime(clientSpecifier) {
+    return clientSpecifier != null ? this.getBestRuntimeForSpecifier(clientSpecifier) : this.getPreferredRuntime();
+  }
+  hasRuntime(runtime2) {
+    return this._runtimes.has(runtime2.coordinate.stringId);
+  }
+  getBestRuntimeOrThrow(specifier) {
+    const runtime2 = this.getBestRuntime(specifier);
+    if (!runtime2) {
+      if (specifier == null) {
+        throw err_nice_action.fromId("no_client_runtimes_registered" /* no_client_runtimes_registered */, {
+          context: this._context
+        });
+      }
+      throw err_nice_action.fromId("client_runtime_not_registered" /* client_runtime_not_registered */, {
+        context: this._context,
+        clientStringId: runtimeCoordinateToStringIds(specifier)[0]
+      });
+    }
+    return runtime2;
   }
 }
 
-// src/ActionRuntime/Handler/ExternalClient/ActionExternalClientHandler.ts
-class ActionExternalClientHandler extends ActionHandler {
-  externalClient;
-  handlerType = "external" /* external */;
-  cuid;
-  _defaultTimeout;
-  _transportCache = new Map;
-  transportManager = new ConnectionTransportManager(this._transportCache);
-  _incomingActionDataListeners = [];
-  actionRouter = new ActionRouter({
-    contextType: "handler_route" /* handler_route */,
-    handler: this
-  });
-  constructor({
-    runtimeCoordinate: externalClientSpecifier,
-    transports,
-    defaultTimeout
-  }) {
-    super();
-    this.externalClient = externalClientSpecifier;
-    this.cuid = nanoid4();
-    this._defaultTimeout = defaultTimeout ?? DEFAULT_TRANSPORT_TIMEOUT;
-    for (const transport of transports) {
-      const connection = transport._createConnection({
-        resolvers: {
-          onIncomingActionDataJson: (json) => {
-            for (const l of this._incomingActionDataListeners)
-              l(json);
-          }
-        }
+// src/ActionDefinition/Domain/ActionRootDomain.ts
+class ActionRootDomain extends ActionDomainBase {
+  domainDefinition;
+  _actionRuntimeManager;
+  constructor(domainDefinition) {
+    const domainId = domainDefinition.domain;
+    super({
+      domain: domainId,
+      allDomains: [domainId],
+      actionSchema: {}
+    });
+    this.domainDefinition = domainDefinition;
+    this._actionRuntimeManager = new ActionRuntimeManager({ domain: domainId });
+  }
+  createChildDomain(subDomainDef) {
+    if (this.allDomains.includes(subDomainDef.domain)) {
+      throw err_nice_action.fromId("domain_already_exists_in_hierarchy" /* domain_already_exists_in_hierarchy */, {
+        domain: subDomainDef.domain,
+        allParentDomains: this.allDomains,
+        parentDomain: this.domain
       });
-      connection.definition = transport;
-      this.transportManager.addTransport(connection);
     }
+    return new ActionDomain({
+      allDomains: [...this.allDomains, subDomainDef.domain],
+      domain: subDomainDef.domain,
+      actionSchema: subDomainDef.actions
+    }, { rootDomain: this });
+  }
+  _registerRuntime(runtime2) {
+    this._actionRuntimeManager.registerRuntime(runtime2);
+  }
+  _hasRuntime(runtime2) {
+    return this._actionRuntimeManager.hasRuntime(runtime2);
+  }
+  getRuntime(clientSpecifier) {
+    return this._actionRuntimeManager.getBestRuntimeForSpecifier(clientSpecifier);
+  }
+  async _runAction(actionPayload, options) {
+    const allListeners = [...this._listeners, ...options?.listeners ?? []];
+    let handlerAndRuntime;
+    try {
+      handlerAndRuntime = this._actionRuntimeManager.getRuntimeAndHandlerForActionOrThrow(actionPayload, options);
+    } catch (err3) {
+      const runningAction2 = new RunningAction({
+        context: actionPayload.context,
+        request: actionPayload,
+        callSite: actionPayload._callSite
+      });
+      runningAction2.addUpdateListeners(allListeners);
+      runningAction2._failWithError(err3);
+      throw err3;
+    }
+    const { handler, runtime: runtime2 } = handlerAndRuntime;
+    actionPayload.context._setOriginClient(runtime2.coordinate);
+    const runningAction = await handler.handleActionRequest(actionPayload, {
+      targetLocalRuntime: runtime2
+    });
+    runningAction.addUpdateListeners(allListeners);
+    return runningAction;
   }
-  forDomain(domain) {
-    this.actionRouter.forDomain(domain, true);
-    return this;
+}
+// src/ActionDefinition/Domain/helpers/createRootActionDomain.ts
+var createActionRootDomain = (definition) => {
+  return new ActionRootDomain(definition);
+};
+// src/ActionDefinition/Schema/ActionSchema.ts
+import { extractMessageFromStandardSchema } from "@nice-code/common-errors";
+class ActionSchema {
+  _errorDeclarations = [];
+  inputOptions;
+  outputOptions;
+  get inputSchema() {
+    return this.inputOptions?.schema;
   }
-  forAction(action) {
-    this.actionRouter.forAction(action, true);
+  get outputSchema() {
+    return this.outputOptions?.schema;
+  }
+  input(options) {
+    this.inputOptions = options;
     return this;
   }
-  forActionIds(domain, ids) {
-    this.actionRouter.forActionIds(domain, ids, true);
+  output(options) {
+    this.outputOptions = options;
     return this;
   }
-  _setIncomingActionDataListener(listener) {
-    this._incomingActionDataListeners.push(listener);
+  throws(domain, ids) {
+    this._errorDeclarations.push({ _domain: domain, _ids: ids });
+    return this;
   }
-  async handleActionRequest(action, config) {
-    const localRuntime = config?.targetLocalRuntime ?? ActionRuntime.getDefault();
-    const localClient = localRuntime.coordinate;
-    const incomingTimeout = config?.timeout ?? this._defaultTimeout;
-    const parentCuid = peekHandlerCuid();
-    const callSite = action._callSite ?? new Error().stack;
-    const routeParams = {
-      action,
-      localClient,
-      externalClient: this.externalClient
-    };
-    const preferredTransport = this.transportManager.getPreferredTransport();
-    const routeItem = preferredTransport != null ? {
-      runtime: localClient,
-      handler: this.toHandlerRouteItem(preferredTransport, routeParams),
-      time: Date.now()
-    } : undefined;
-    if (routeItem != null)
-      action.context.addRouteItem(routeItem);
-    const runningAction = new RunningAction({
-      context: action.context,
-      request: action,
-      parentCuid,
-      callSite
-    });
-    localRuntime.registerRunningAction(runningAction);
-    this._dispatchWhenTransportReady(runningAction, routeParams, routeItem, incomingTimeout);
-    return runningAction;
+  serializeInput(rawInput) {
+    if (this.inputOptions?.serialization) {
+      return this.inputOptions.serialization.serialize(rawInput);
+    }
+    return rawInput;
   }
-  async _dispatchWhenTransportReady(runningAction, routeParams, routeItem, incomingTimeout) {
-    const action = routeParams.action;
-    try {
-      const { methods, transport } = await this.transportManager.getReadyTransport(routeParams);
-      const handlerRouteItem = this.toHandlerRouteItem(transport, routeParams);
-      if (routeItem != null) {
-        routeItem.handler = handlerRouteItem;
-        routeItem.time = Date.now();
-      } else {
-        action.context.addRouteItem({
-          runtime: routeParams.localClient,
-          handler: handlerRouteItem,
-          time: Date.now()
-        });
-      }
-      const sendInput = {
-        ...routeParams,
-        runningAction,
-        timeout: incomingTimeout
-      };
-      if (action.type === "request" /* request */ && methods.updateRunConfig != null) {
-        const runConfig = methods.updateRunConfig(sendInput);
-        sendInput.timeout = runConfig?.timeout ?? incomingTimeout;
-      }
-      methods.sendActionData(sendInput);
-    } catch (err3) {
-      runningAction._abort(err3);
+  deserializeInput(serialized) {
+    if (this.inputOptions?.serialization) {
+      return this.inputOptions.serialization.deserialize(serialized);
     }
+    return serialized;
   }
-  async sendReturnPayload(payload, config) {
-    const localClient = config.targetLocalRuntime.coordinate;
-    try {
-      const { methods } = await this.transportManager.getReadyTransport({
-        action: payload,
-        localClient,
-        externalClient: this.externalClient
+  validateInput(value, meta) {
+    if (this.inputOptions?.schema == null) {
+      return value;
+    }
+    const result = this.inputOptions.schema["~standard"].validate(value);
+    if (result instanceof Promise) {
+      throw err_nice_action.fromId("action_input_validation_promise" /* action_input_validation_promise */, {
+        domain: meta.domain,
+        actionId: meta.actionId
+      });
+    }
+    if (result.issues != null) {
+      throw err_nice_action.fromId("action_input_validation_failed" /* action_input_validation_failed */, {
+        domain: meta.domain,
+        actionId: meta.actionId,
+        validationMessage: extractMessageFromStandardSchema(result)
       });
-      if (methods.sendReturnData == null)
-        return false;
-      methods.sendReturnData(payload, { localClient, externalClient: this.externalClient });
-      return true;
-    } catch {
-      return false;
     }
+    return result.value;
   }
-  toJsonObject() {
-    return {
-      type: this.handlerType,
-      client: this.externalClient
-    };
+  validateOutput(value, meta) {
+    if (this.outputOptions?.schema == null) {
+      return value;
+    }
+    const result = this.outputOptions.schema["~standard"].validate(value);
+    if (result instanceof Promise) {
+      throw err_nice_action.fromId("action_output_validation_promise" /* action_output_validation_promise */, {
+        domain: meta.domain,
+        actionId: meta.actionId
+      });
+    }
+    if (result.issues != null) {
+      throw err_nice_action.fromId("action_output_validation_failed" /* action_output_validation_failed */, {
+        domain: meta.domain,
+        actionId: meta.actionId,
+        validationMessage: extractMessageFromStandardSchema(result)
+      });
+    }
+    return result.value;
   }
-  toHandlerRouteItem(transport, input) {
-    return {
-      type: this.handlerType,
-      client: this.externalClient,
-      transOrd: transport.transOrd,
-      transType: transport.type,
-      transInfo: transport.getRouteInfo(input)
-    };
+  serializeOutput(rawOutput) {
+    if (this.outputOptions?.serialization) {
+      return this.outputOptions.serialization.serialize(rawOutput);
+    }
+    return rawOutput;
   }
-  clearTransportCache() {
-    this._transportCache.clear();
+  deserializeOutput(serialized) {
+    if (this.outputOptions?.serialization) {
+      return this.outputOptions.serialization.deserialize(serialized);
+    }
+    return serialized;
   }
 }
-var createExternalClientHandler = (config) => {
-  return new ActionExternalClientHandler(config);
+var actionSchema = () => {
+  return new ActionSchema;
 };
 // src/ActionRuntime/Handler/ExternalClient/Transport/Transport.ts
 class Transport {
@@ -2956,6 +2993,9 @@ function createBinaryWsSessionFactory(domains, options) {
     };
   };
 }
+// src/ActionRuntime/Handler/ExternalClient/Transport/WebSocket/secureWsChannel.ts
+import { ClientCryptoKeyLink } from "@nice-code/util";
+
 // src/utils/decodeActionFrame.ts
 function decodeActionFrame(frame, decoder) {
   const decoded = decoder?.incoming?.(frame) ?? (typeof frame === "string" ? parseJsonActionFrame(frame) : undefined);
@@ -3006,8 +3046,8 @@ var HANDSHAKE_TIMEOUT_MS = 15000;
 
 class WebSocketConnection extends TransportConnection {
   resolvers;
-  _abortSet = new Set;
   _liveSocketUrl;
+  _intentionalCloses = new WeakSet;
   constructor(def, resolvers) {
     super({ ...def, type: "ws" /* ws */ });
     this.resolvers = resolvers ?? createUnsetTransportResolvers("ws" /* ws */);
@@ -3089,20 +3129,22 @@ class WebSocketConnection extends TransportConnection {
   _finalizeTransportMethods(wsData) {
     const ws = wsData.ws;
     const disconnectListeners = [];
+    const abortSet = new Set;
     this._captureSocketUrl(ws);
-    this._attachLifecycle(ws, disconnectListeners);
+    this._attachLifecycle(ws, disconnectListeners, abortSet);
     ws.addEventListener("message", async (event) => {
       const frame = await this._normalizeFrame(event.data);
       if (frame !== undefined)
         await this._handleIncomingActionFrame(frame, wsData, undefined);
     });
-    return this._buildSendMethods(ws, wsData, undefined, disconnectListeners);
+    return this._buildSendMethods(ws, wsData, undefined, disconnectListeners, abortSet);
   }
   async _finalizeSecureMethods(wsData) {
     const ws = wsData.ws;
     const disconnectListeners = [];
+    const abortSet = new Set;
     this._captureSocketUrl(ws);
-    this._attachLifecycle(ws, disconnectListeners);
+    this._attachLifecycle(ws, disconnectListeners, abortSet);
     let active = false;
     let crypto;
     const handshakeQueue = [];
@@ -3146,7 +3188,7 @@ class WebSocketConnection extends TransportConnection {
     for (const frame of pendingActionFrames)
       await this._handleIncomingActionFrame(frame, wsData, crypto);
     pendingActionFrames.length = 0;
-    return this._buildSendMethods(ws, wsData, crypto, disconnectListeners);
+    return this._buildSendMethods(ws, wsData, crypto, disconnectListeners, abortSet);
   }
   async _runClientHandshake(ws, secure, nextHandshakeMessage) {
     await secure.link.initialize();
@@ -3175,20 +3217,31 @@ class WebSocketConnection extends TransportConnection {
     const result = await handshake.onAccept(accept);
     return result.securityLevel === "encrypted" /* encrypted */ ? createActionFrameCrypto({ link: secure.link, linkedClientId: result.linkedClientId }) : undefined;
   }
-  _buildSendMethods(ws, wsData, crypto, disconnectListeners) {
+  _buildSendMethods(ws, wsData, crypto, disconnectListeners, abortSet) {
     let sendChain = Promise.resolve();
     const enqueueSend = (frame) => {
+      if (ws.readyState !== WebSocket.OPEN)
+        return;
       if (crypto == null) {
         sendFrame(ws, frame);
         return;
       }
       const bytes = toFrameBytes(frame);
-      sendChain = sendChain.then(() => crypto.encryptFrame(bytes)).then((encrypted) => sendFrame(ws, encrypted)).catch((err4) => console.error("[ws] failed to encrypt/send frame", err4));
+      sendChain = sendChain.then(() => crypto.encryptFrame(bytes)).then((encrypted) => {
+        if (ws.readyState === WebSocket.OPEN)
+          sendFrame(ws, encrypted);
+      }).catch((err4) => console.error("[ws] failed to encrypt/send frame", err4));
     };
     const sendActionData = (inputs) => {
       const { action, runningAction, timeout } = inputs;
+      if (ws.readyState !== WebSocket.OPEN) {
+        if (action.type === "request" /* request */) {
+          runningAction._abort(err_nice_transport_ws.fromId("ws_disconnected" /* ws_disconnected */));
+        }
+        return;
+      }
       if (action.type === "request" /* request */) {
-        this._abortSet.add(runningAction);
+        abortSet.add(runningAction);
         const timeoutId = setTimeout(() => {
           runningAction._abort(err_nice_transport.fromId("timeout" /* timeout */, { timeout }));
         }, timeout);
@@ -3196,7 +3249,7 @@ class WebSocketConnection extends TransportConnection {
           (update) => {
             if (update.type === "finished" /* finished */) {
               clearTimeout(timeoutId);
-              this._abortSet.delete(runningAction);
+              abortSet.delete(runningAction);
             }
           }
         ]);
@@ -3209,6 +3262,12 @@ class WebSocketConnection extends TransportConnection {
       addOnDisconnectListener: (cb) => {
         disconnectListeners.push(cb);
       },
+      disconnect: () => {
+        this._intentionalCloses.add(ws);
+        try {
+          ws.close();
+        } catch {}
+      },
       sendReturnData: (payload, clients) => {
         const formatted = clients != null ? wsData.formatMessage?.outgoing({ action: payload, ...clients }) : undefined;
         enqueueSend(formatted ?? JSON.stringify(payload.toJsonObject()));
@@ -3243,24 +3302,25 @@ class WebSocketConnection extends TransportConnection {
     if (ws.url != null && ws.url !== "")
       this._liveSocketUrl = ws.url;
   }
-  _attachLifecycle(ws, disconnectListeners) {
+  _attachLifecycle(ws, disconnectListeners, abortSet) {
     ws.addEventListener("close", (event) => {
-      console.error("WebSocket closed:", event);
+      if (!this._intentionalCloses.has(ws))
+        console.error("WebSocket closed:", event);
       for (const cb of disconnectListeners)
         cb();
-      this._abortAll(err_nice_transport_ws.fromId("ws_disconnected" /* ws_disconnected */));
+      this._abortAll(abortSet, err_nice_transport_ws.fromId("ws_disconnected" /* ws_disconnected */));
     });
     ws.addEventListener("error", (event) => {
       console.error("WebSocket error:", event);
       for (const cb of disconnectListeners)
         cb();
-      this._abortAll(err_nice_transport_ws.fromId("ws_error" /* ws_error */, {
+      this._abortAll(abortSet, err_nice_transport_ws.fromId("ws_error" /* ws_error */, {
         originalError: event instanceof Error ? event : undefined
       }));
     });
   }
-  _abortAll(error) {
-    const snapshot = [...this._abortSet];
+  _abortAll(abortSet, error) {
+    const snapshot = [...abortSet];
     for (const ra of snapshot) {
       ra._abort(error);
     }
@@ -3313,11 +3373,109 @@ class WebSocketTransport extends Transport {
     };
   }
 }
+
+// src/ActionRuntime/Handler/ExternalClient/Transport/WebSocket/secureWsChannel.ts
+function deriveDictionaryVersion(domains) {
+  const { intToRoute } = buildActionRouteDictionary(domains);
+  const signature = intToRoute.map((route) => `${route.domain}:${route.id}`).join(",");
+  let hash = 2166136261;
+  for (let i = 0;i < signature.length; i++) {
+    hash ^= signature.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `auto:${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+function defineSecureWsChannel(options) {
+  return {
+    dictionaryVersion: options.dictionaryVersion ?? deriveDictionaryVersion(options.domains),
+    createCodec: createBinaryWsSessionFactory(options.domains, options.sessionOptions)
+  };
+}
+function createSecureWebSocketTransport(options) {
+  const link = new ClientCryptoKeyLink({ storageAdapter: options.storageAdapter });
+  return WebSocketTransport.create({
+    createWebSocket: options.createWebSocket ?? (() => {
+      const ws = new WebSocket(options.url);
+      ws.binaryType = "arraybuffer";
+      return ws;
+    }),
+    getTransportCacheKey: options.getTransportCacheKey ?? (() => [options.url]),
+    createFormatMessage: options.channel.createCodec,
+    updateRunConfig: options.updateRunConfig,
+    getRouteInfo: options.getRouteInfo,
+    security: {
+      securityLevel: options.securityLevel,
+      link,
+      localCoordinate: options.runtime.coordinate.toJsonObject(),
+      dictionaryVersion: options.channel.dictionaryVersion
+    }
+  });
+}
+// src/ActionRuntime/Handler/Server/WsConnectionStateStore.ts
+class WsConnectionStateStore {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  get(connection) {
+    return this._readAttachment(connection).app ?? null;
+  }
+  set(connection, app) {
+    const existing = this._readAttachment(connection);
+    this.options.write(connection, { app, binding: existing.binding });
+  }
+  clearApp(connection) {
+    const existing = this._readAttachment(connection);
+    this.options.write(connection, { binding: existing.binding });
+  }
+  entries() {
+    return this.options.getConnections().map((connection) => [connection, this._readAttachment(connection).app ?? null]);
+  }
+  _persistBinding(connection, binding) {
+    const existing = this._readAttachment(connection);
+    this.options.write(connection, { app: existing.app, binding });
+  }
+  _readBinding(connection) {
+    return this._readAttachment(connection).binding;
+  }
+  _readAttachment(connection) {
+    try {
+      const raw = this.options.read(connection);
+      if (typeof raw !== "object" || raw === null)
+        return {};
+      const attachment = raw;
+      const result = {};
+      if (attachment.binding != null)
+        result.binding = attachment.binding;
+      if (attachment.app !== undefined) {
+        const app = this._validateApp(attachment.app);
+        if (app !== undefined)
+          result.app = app;
+      }
+      return result;
+    } catch {
+      return {};
+    }
+  }
+  _validateApp(value) {
+    const schema = this.options.schema;
+    if (schema == null)
+      return value;
+    const result = schema["~standard"].validate(value);
+    if (result instanceof Promise)
+      return;
+    if (result.issues != null)
+      return;
+    return result.value;
+  }
+}
+
 // src/ActionRuntime/Handler/Server/ActionServerHandler.ts
 class ActionServerHandler extends ActionExternalClientHandler {
   _formatMessage;
   _createFormatMessage;
   _send;
+  _runtime;
   _serverTimeout;
   _onConnectionBound;
   _incomingListeners = [];
@@ -3340,6 +3498,7 @@ class ActionServerHandler extends ActionExternalClientHandler {
     this._formatMessage = options.formatMessage;
     this._createFormatMessage = options.createFormatMessage;
     this._send = options.send;
+    this._runtime = options.runtime;
     this._serverTimeout = options.defaultTimeout ?? DEFAULT_TRANSPORT_TIMEOUT;
     this._onConnectionBound = options.onConnectionBound;
     this._security = options.security;
@@ -3365,6 +3524,19 @@ class ActionServerHandler extends ActionExternalClientHandler {
   _setIncomingActionDataListener(listener) {
     this._incomingListeners.push(listener);
   }
+  setOnConnectionBound(onConnectionBound) {
+    this._onConnectionBound = onConnectionBound;
+  }
+  createConnectionState(options) {
+    const store = new WsConnectionStateStore(options);
+    this.setOnConnectionBound((connection, binding) => store._persistBinding(connection, binding));
+    for (const connection of options.getConnections()) {
+      const binding = store._readBinding(connection);
+      if (binding != null)
+        this.rehydrateConnection(connection, binding);
+    }
+    return store;
+  }
   receive(connection, frame) {
     if (this._security == null || !this._handshakeMode) {
       this._receivePlain(connection, frame);
@@ -3539,6 +3711,41 @@ class ActionServerHandler extends ActionExternalClientHandler {
     const connection = this._resolveConnection(target);
     return this._dispatch(runtime2, connection, request, options?.timeout);
   }
+  forConnectionDomainCases(domain, cases) {
+    const handler = new ActionLocalHandler;
+    const executor = cases;
+    const wrapped = {};
+    const wrappedRecord = wrapped;
+    for (const id in cases) {
+      const caseFn = executor[id];
+      if (caseFn == null)
+        continue;
+      wrappedRecord[id] = (request) => caseFn(request, this.getConnectionForClient(request.context.originClient));
+    }
+    return handler.forDomainActionCases(domain, wrapped);
+  }
+  broadcast(makeRequest, options) {
+    const runtime2 = options?.runtime ?? this._runtime;
+    if (runtime2 == null) {
+      throw err_nice_transport.fromId("not_found" /* not_found */, {
+        actionId: "server-handler-runtime (construct with `runtime` or pass `options.runtime`)"
+      });
+    }
+    for (const connection of this._clientByConn.keys()) {
+      if (options?.except != null && connection === options.except)
+        continue;
+      if (options?.where != null && !options.where(connection))
+        continue;
+      try {
+        this.pushToClient(runtime2, connection, makeRequest(), { timeout: options?.timeout });
+      } catch (error) {
+        if (options?.onError != null)
+          options.onError(error, connection);
+        else
+          console.error("[ws-server] broadcast push failed", error);
+      }
+    }
+  }
   async sendReturnPayload(payload, config) {
     const connection = this._connByClient.get(payload.context.originClient.stringId);
     if (connection == null)
@@ -3627,6 +3834,78 @@ class ActionServerHandler extends ActionExternalClientHandler {
 var createServerHandler = (options) => {
   return new ActionServerHandler(options);
 };
+// src/ActionRuntime/Handler/Server/createActionFetchHandler.ts
+var DEFAULT_CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type",
+  "Access-Control-Max-Age": "86400"
+};
+function createActionFetchHandler(runtime2, options = {}) {
+  const corsHeaders = options.cors === false ? {} : options.cors ?? DEFAULT_CORS_HEADERS;
+  const isActionPath = options.isActionPath ?? ((url) => url.pathname.endsWith("/action"));
+  const isWebSocketPath = options.isWebSocketPath ?? ((url) => url.pathname.endsWith("/ws"));
+  const withCors = (response) => {
+    if (options.cors === false)
+      return response;
+    const headers = new Headers(response.headers);
+    for (const [key, value] of Object.entries(corsHeaders))
+      headers.set(key, value);
+    return new Response(response.body, { status: response.status, headers });
+  };
+  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);
+    }
+    if (request.method === "POST" && isActionPath(url)) {
+      const running = await runtime2.handleActionPayloadWire(await request.json());
+      const result = await running.waitForResultPayload();
+      return withCors(result.toHttpResponse({ useErrorStatus: options.useErrorStatus }));
+    }
+    return withCors(new Response("Not found", { status: 404 }));
+  };
+}
+// src/ActionRuntime/Handler/Server/createSecureActionServer.ts
+import { ClientCryptoKeyLink as ClientCryptoKeyLink2 } from "@nice-code/util";
+var DEFAULT_SERVER_SECURITY_LEVELS = [
+  "none" /* none */,
+  "authenticated" /* authenticated */,
+  "encrypted" /* encrypted */
+];
+function createSecureActionServerHandler(options) {
+  const link = new ClientCryptoKeyLink2({ storageAdapter: options.storageAdapter });
+  return new ActionServerHandler({
+    clientEnv: options.clientEnv,
+    createFormatMessage: options.channel.createCodec,
+    send: options.send,
+    runtime: options.runtime,
+    defaultTimeout: options.defaultTimeout,
+    security: {
+      securityLevel: options.securityLevel ?? DEFAULT_SERVER_SECURITY_LEVELS,
+      link,
+      localCoordinate: options.runtime.coordinate.toJsonObject(),
+      dictionaryVersion: options.channel.dictionaryVersion,
+      verifyKeyResolver: options.verifyKeyResolver ?? createStorageTofuVerifyKeyResolver(options.storageAdapter)
+    }
+  });
+}
+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)
+  };
+}
 export {
   runtimeLinkId,
   isActionPayload_Result_JsonObject,
@@ -3637,20 +3916,26 @@ export {
   err_nice_external_client,
   err_nice_action,
   encodeHandshakeMessage,
+  defineSecureWsChannel,
   decodeHandshakeMessage,
   decodeActionFrame,
   createStorageTofuVerifyKeyResolver,
   createServerHandshake,
   createServerHandler,
+  createSecureWebSocketTransport,
+  createSecureActionServerHandler,
   createLocalHandler,
   createInMemoryTofuVerifyKeyResolver,
+  createHibernatableWsServerAdapter,
   createExternalClientHandler,
   createClientHandshake,
   createBinaryWsSessionFactory,
   createBinaryWsAdapter,
   createActionRootDomain,
   createActionFrameCrypto,
+  createActionFetchHandler,
   actionSchema,
+  WsConnectionStateStore,
   WebSocketTransport,
   Transport,
   RuntimeCoordinate,