@nice-code/action 0.5.1 → 0.5.2

package/build/index.js

@@ -1,246 +1,2588 @@
-// src/devtools/server/NiceActionServerDevtools.ts
-class ActionServerDevtools {
-  _options;
-  _inFlight = new Map;
-  constructor(options = {}) {
-    const defaultEnabled = typeof process !== "undefined" ? true : true;
-    this._options = {
-      logger: options.logger ?? defaultConsoleLogger,
-      format: options.format ?? "pretty",
-      logPayloads: options.logPayloads ?? true,
-      enabled: options.enabled ?? defaultEnabled
-    };
-  }
-  attachToDomain(domain) {
-    if (!this._options.enabled) {
-      return () => {};
-    }
-    return domain.addActionListener((update) => {
-      const { runningAction, type, time } = update;
-      const actionPath = [...runningAction.allDomains, runningAction.id].join(".");
-      if (type === "started" /* started */) {
-        this._inFlight.set(runningAction.cuid, { startTime: time });
-        this._log("started", actionPath, runningAction.cuid, {
-          ...this._options.logPayloads ? { input: runningAction.state?.request?.input } : {}
+// src/ActionDefinition/Action/Core/ActionCore.ts
+import { nanoid } from "nanoid";
+
+// src/nice_action.static.ts
+var DEFAULT_TRANSPORT_TIMEOUT = 1e4;
+var UNSET_RUNTIME_ENV_ID = "_unset_";
+
+// src/ActionRuntime/utils/runtimeCoordinateToStringIds.ts
+function runtimeCoordinateToStringIds(coordinate) {
+  return [
+    `envId[${coordinate.envId}]perId[${coordinate.perId ?? "_"}]:insId[${coordinate.insId ?? "_"}]`,
+    `envId[${coordinate.envId}]perId[${coordinate.perId ?? "_"}]:insId[_]`,
+    `envId[${coordinate.envId}]perId[_]:insId[_]`
+  ];
+}
+
+// src/ActionRuntime/RuntimeCoordinate.ts
+class RuntimeCoordinate {
+  envId;
+  perId;
+  insId;
+  static get unknown() {
+    return new RuntimeCoordinate({
+      envId: UNSET_RUNTIME_ENV_ID
+    });
+  }
+  static env(envId) {
+    return new RuntimeCoordinate({
+      envId
+    });
+  }
+  withPersistentId(perId) {
+    return this.specify({ perId });
+  }
+  constructor({ envId, perId, insId }) {
+    this.envId = envId;
+    this.perId = perId;
+    this.insId = insId;
+  }
+  specify(specifics) {
+    return new RuntimeCoordinate({
+      envId: this.envId,
+      perId: this.perId,
+      insId: this.insId,
+      ...specifics
+    });
+  }
+  specifyIfUnset(specifics) {
+    return new RuntimeCoordinate({
+      envId: this.envId,
+      perId: this.perId ?? specifics.perId,
+      insId: this.insId ?? specifics.insId
+    });
+  }
+  toJsonObject() {
+    return {
+      envId: this.envId,
+      perId: this.perId,
+      insId: this.insId
+    };
+  }
+  isExactlySame(other) {
+    return this.envId === other.envId && this.perId === other.perId && this.insId === other.insId;
+  }
+  isSameFor(other) {
+    return {
+      id: this.envId === other.envId,
+      perId: this.envId === other.envId && this.perId === other.perId,
+      insId: this.envId === other.envId && this.perId === other.perId && this.insId === other.insId
+    };
+  }
+  similarityLevel(other) {
+    const sameFor = this.isSameFor(other);
+    if (sameFor.insId)
+      return 3;
+    if (sameFor.perId)
+      return 2;
+    if (sameFor.id)
+      return 1;
+    return 0;
+  }
+  get stringId() {
+    return `envId[${this.envId}]perId[${this.perId ?? "_"}]:insId[${this.insId ?? "_"}]`;
+  }
+  toStringIds() {
+    return runtimeCoordinateToStringIds(this);
+  }
+}
+
+// src/ActionDefinition/Action/ActionBase.ts
+class ActionBase {
+  form;
+  _domain;
+  id;
+  domain;
+  allDomains;
+  schema;
+  constructor(form, _domain, id) {
+    this.form = form;
+    this._domain = _domain;
+    this.id = id;
+    this.domain = _domain.domain;
+    this.allDomains = _domain.allDomains;
+    this.schema = _domain.actionSchema[id];
+  }
+  toJsonObject() {
+    return {
+      form: this.form,
+      domain: this.domain,
+      allDomains: this.allDomains,
+      id: this.id
+    };
+  }
+  toJsonString() {
+    return JSON.stringify(this.toJsonObject());
+  }
+}
+
+// src/ActionDefinition/Action/Context/ActionContext.ts
+class ActionContext extends ActionBase {
+  _domain;
+  form = "context" /* context */;
+  _routing;
+  timeCreated;
+  cuid;
+  originClient;
+  constructor(_domain, id, hydrationData) {
+    super("context" /* context */, _domain, id);
+    this._domain = _domain;
+    this.timeCreated = hydrationData.timeCreated;
+    this.cuid = hydrationData.cuid;
+    this._routing = hydrationData.routing;
+    this.originClient = hydrationData.originClient;
+  }
+  _setOriginClient(client) {
+    this.originClient = client;
+  }
+  toJsonString() {
+    return JSON.stringify(this.toJsonObject());
+  }
+  toContextDataJsonObject() {
+    return {
+      timeCreated: this.timeCreated,
+      cuid: this.cuid,
+      routing: this.routing.map((item) => ({
+        runtime: item.runtime.toJsonObject(),
+        handler: item.handler,
+        time: item.time
+      })),
+      originClient: this.originClient.toJsonObject()
+    };
+  }
+  toJsonObject() {
+    return {
+      ...super.toJsonObject(),
+      ...this.toContextDataJsonObject()
+    };
+  }
+  get routing() {
+    return this._routing;
+  }
+  addRouteItem(item) {
+    this._routing.push(item);
+  }
+  deserializeInput(serialized) {
+    return this.schema.deserializeInput(serialized);
+  }
+  serializeInput(raw) {
+    return this.schema.serializeInput(raw);
+  }
+  validateInput(input) {
+    return this.schema.validateInput(input, {
+      domain: this.domain,
+      actionId: this.id
+    });
+  }
+  validateOutput(output) {
+    return this.schema.validateOutput(output, {
+      domain: this.domain,
+      actionId: this.id
+    });
+  }
+}
+
+// src/ActionDefinition/Action/Payload/ActionPayload.ts
+class ActionPayload extends ActionBase {
+  form = "data" /* data */;
+  type;
+  context;
+  time;
+  constructor(context, type, data) {
+    super("data" /* data */, context._domain, context.id);
+    this.context = context;
+    this.type = type;
+    this.time = data.time;
+  }
+  toBaseJsonObject() {
+    return {
+      ...super.toJsonObject(),
+      type: this.type,
+      context: this.context.toContextDataJsonObject(),
+      time: this.time
+    };
+  }
+}
+
+// src/utils/hashPayloadData.ts
+function stableStringify(value) {
+  if (value === null || value === undefined)
+    return String(value);
+  if (typeof value !== "object")
+    return JSON.stringify(value) ?? "undefined";
+  if (Array.isArray(value))
+    return `[${value.map(stableStringify).join(",")}]`;
+  const keys = Object.keys(value).sort();
+  return "{" + keys.map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`).join(",") + "}";
+}
+function fnv1a32(str) {
+  let hash = 2166136261;
+  for (let i = 0;i < str.length; i++) {
+    hash = (hash ^ str.charCodeAt(i)) * 16777619 >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+function hashPayloadData(data) {
+  return fnv1a32(stableStringify(data));
+}
+
+// src/ActionDefinition/Action/Payload/ActionPayload.types.ts
+var EActionPayloadType;
+((EActionPayloadType2) => {
+  EActionPayloadType2["request"] = "request";
+  EActionPayloadType2["progress"] = "progress";
+  EActionPayloadType2["result"] = "result";
+  EActionPayloadType2["stream"] = "stream";
+  EActionPayloadType2["push"] = "push";
+})(EActionPayloadType ||= {});
+var EActionProgressType;
+((EActionProgressType2) => {
+  EActionProgressType2["none"] = "none";
+  EActionProgressType2["percentage"] = "percentage";
+  EActionProgressType2["custom"] = "custom";
+})(EActionProgressType ||= {});
+
+// src/ActionDefinition/Action/Payload/ActionPayload_Progress.ts
+class ActionPayload_Progress extends ActionPayload {
+  progress;
+  constructor(params, progress, data) {
+    super(params.context, "progress" /* progress */, data);
+    this.progress = progress;
+  }
+  toJsonObject() {
+    return {
+      ...this.toBaseJsonObject(),
+      progress: this.progress
+    };
+  }
+  toJsonString() {
+    return JSON.stringify(this.toJsonObject());
+  }
+  toHttpResponse() {
+    return new Response(this.toJsonString(), {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+}
+
+// src/ActionDefinition/Action/Payload/ActionPayload_Result.ts
+class ActionPayload_Result extends ActionPayload {
+  result;
+  outputHash;
+  constructor(params, result, data) {
+    super(params.context, "result" /* result */, data);
+    this.result = result;
+    this.outputHash = result.ok ? hashPayloadData(this.context.schema.serializeOutput(result.output)) : hashPayloadData(result.error.message);
+  }
+  toJsonObject() {
+    const wireResult = this.result.ok ? { ok: true, output: this.context.schema.serializeOutput(this.result.output) } : this.result;
+    return {
+      ...this.toBaseJsonObject(),
+      result: wireResult,
+      outputHash: this.outputHash
+    };
+  }
+  toJsonString() {
+    return JSON.stringify(this.toJsonObject());
+  }
+  toHttpResponse({ useErrorStatus = true } = {}) {
+    return new Response(this.toJsonString(), {
+      status: this.result.ok ? 200 : useErrorStatus ? this.result.error.httpStatusCode : 500,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+}
+
+// src/ActionDefinition/Action/Payload/ActionPayload_Request.ts
+class ActionPayload_Request extends ActionPayload {
+  input;
+  inputHash;
+  _callSite;
+  constructor(params, input, data) {
+    super(params.context, "request" /* request */, data);
+    this.input = input;
+    this.inputHash = hashPayloadData(this.context.schema.serializeInput(input));
+  }
+  successResult(...args) {
+    const output = args[0];
+    const finalOutput = this.context.schema.validateOutput(output, {
+      domain: this.domain,
+      actionId: this.id
+    });
+    return new ActionPayload_Result(this, { ok: true, output: finalOutput }, { time: Date.now() });
+  }
+  errorResult(err) {
+    return new ActionPayload_Result(this, { ok: false, error: err }, { time: Date.now() });
+  }
+  progress(progress) {
+    return new ActionPayload_Progress(this, progress, { time: Date.now() });
+  }
+  toJsonObject() {
+    return {
+      ...super.toBaseJsonObject(),
+      input: this.context.schema.serializeInput(this.input),
+      inputHash: this.inputHash
+    };
+  }
+  toJsonString() {
+    return JSON.stringify(this.toJsonObject());
+  }
+  async runToOutput(options) {
+    const running = await this.run(options);
+    const result = await running.waitForResultPayload();
+    if (result.result.ok)
+      return result.result.output;
+    throw result.result.error;
+  }
+  async runToResultPayload(options) {
+    const value = await this.run(options);
+    return value.waitForResultPayload();
+  }
+  async run(options) {
+    if (this._callSite == null) {
+      this._callSite = new Error().stack;
+    }
+    return this._domain.runAction(this, options);
+  }
+}
+
+// src/ActionDefinition/Action/Core/ActionCore.ts
+class ActionCore extends ActionBase {
+  _domain;
+  form = "core" /* core */;
+  constructor(_domain, id) {
+    super("core" /* core */, _domain, id);
+    this._domain = _domain;
+  }
+  is(action) {
+    return action instanceof ActionPayload && action.domain === this.domain && action.id === this.id;
+  }
+  toJsonObject() {
+    return {
+      id: this.id,
+      form: this.form,
+      domain: this.domain,
+      allDomains: this.allDomains
+    };
+  }
+  request(...args) {
+    const input = args[0];
+    const validatedInput = this.schema.validateInput(input, {
+      actionId: this.id,
+      domain: this.domain
+    });
+    const context = new ActionContext(this._domain, this.id, {
+      cuid: nanoid(),
+      timeCreated: Date.now(),
+      routing: [],
+      originClient: RuntimeCoordinate.unknown
+    });
+    return new ActionPayload_Request({ context }, validatedInput, {
+      time: Date.now()
+    });
+  }
+  deserializeInput(serialized) {
+    return this.schema.deserializeInput(serialized);
+  }
+  serializeInput(raw) {
+    return this.schema.serializeInput(raw);
+  }
+  validateInput(input) {
+    return this.schema.validateInput(input, {
+      domain: this.domain,
+      actionId: this.id
+    });
+  }
+  validateOutput(output) {
+    return this.schema.validateOutput(output, {
+      domain: this.domain,
+      actionId: this.id
+    });
+  }
+}
+// src/ActionDefinition/Action/RunningAction.types.ts
+var ERunningActionState;
+((ERunningActionState2) => {
+  ERunningActionState2["running"] = "running";
+  ERunningActionState2["completed"] = "completed";
+})(ERunningActionState ||= {});
+var ERunningActionUpdateType;
+((ERunningActionUpdateType2) => {
+  ERunningActionUpdateType2["started"] = "started";
+  ERunningActionUpdateType2["progress"] = "progress";
+  ERunningActionUpdateType2["finished"] = "finished";
+})(ERunningActionUpdateType ||= {});
+var ERunningActionFinishedType;
+((ERunningActionFinishedType2) => {
+  ERunningActionFinishedType2["aborted"] = "aborted";
+  ERunningActionFinishedType2["failed"] = "failed";
+  ERunningActionFinishedType2["success"] = "success";
+})(ERunningActionFinishedType ||= {});
+
+// src/ActionDefinition/Action/RunningAction.ts
+class RunningAction {
+  _state;
+  context;
+  cuid;
+  id;
+  _domain;
+  domain;
+  allDomains;
+  parentCuid;
+  callSite;
+  _resultPayloadPromise;
+  _resolveResult;
+  _rejectResult;
+  _isAborted = false;
+  _updates = [];
+  _updateListeners = [];
+  constructor(initialState) {
+    this.context = initialState.context;
+    this.cuid = initialState.context.cuid;
+    this.id = initialState.context.id;
+    this.domain = initialState.context.domain;
+    this.allDomains = initialState.context.allDomains;
+    this._domain = initialState.context._domain;
+    this.parentCuid = initialState.parentCuid;
+    this.callSite = initialState.callSite;
+    this._resultPayloadPromise = new Promise((resolve, reject) => {
+      this._resolveResult = resolve;
+      this._rejectResult = reject;
+    });
+    this._resultPayloadPromise.catch(() => {});
+    this._state = {
+      request: initialState.request,
+      progress: initialState.progress ?? [],
+      result: initialState.result
+    };
+    this._sendUpdate({
+      type: "started" /* started */,
+      runningAction: this,
+      time: Date.now()
+    });
+  }
+  get state() {
+    return this._state;
+  }
+  abort(reason) {
+    this._abort(reason);
+  }
+  addUpdateListeners(listeners) {
+    this._updateListeners.push(...listeners);
+    for (const event of this._updates) {
+      for (const listener of listeners) {
+        listener(event);
+      }
+    }
+    return () => {
+      for (const listener of listeners) {
+        const i = this._updateListeners.indexOf(listener);
+        if (i !== -1)
+          this._updateListeners.splice(i, 1);
+      }
+    };
+  }
+  async* iterateUpdates() {
+    const queue = [];
+    let resolveWaiter = null;
+    const unsubscribe = this.addUpdateListeners([
+      (event) => {
+        queue.push(event);
+        if (resolveWaiter) {
+          resolveWaiter();
+          resolveWaiter = null;
+        }
+      }
+    ]);
+    try {
+      while (true) {
+        if (queue.length === 0) {
+          await new Promise((resolve) => {
+            resolveWaiter = resolve;
+          });
+        }
+        const event = queue.shift();
+        yield event;
+        if (event.type === "finished" /* finished */) {
+          break;
+        }
+      }
+    } finally {
+      unsubscribe();
+    }
+  }
+  _sendUpdate(update) {
+    this._updates.push(update);
+    for (const listener of this._updateListeners)
+      listener(update);
+  }
+  _completeWithResult(result) {
+    if (this._state.result != null || this._isAborted)
+      return false;
+    this._state = {
+      request: this._state.request,
+      progress: this._state.progress,
+      result
+    };
+    this._resolveResult(result);
+    this._sendUpdate({
+      type: "finished" /* finished */,
+      finishType: "success" /* success */,
+      runningAction: this,
+      time: Date.now(),
+      response: result
+    });
+    return true;
+  }
+  _abort(reason) {
+    if (this._state.result != null || this._isAborted)
+      return false;
+    this._isAborted = true;
+    this._rejectResult(reason);
+    this._sendUpdate({
+      type: "finished" /* finished */,
+      finishType: "aborted" /* aborted */,
+      runningAction: this,
+      time: Date.now(),
+      reason
+    });
+    return true;
+  }
+  _failWithError(error) {
+    if (this._state.result != null || this._isAborted)
+      return false;
+    this._isAborted = true;
+    this._rejectResult(error);
+    this._sendUpdate({
+      type: "finished" /* finished */,
+      finishType: "failed" /* failed */,
+      runningAction: this,
+      time: Date.now(),
+      error
+    });
+    return true;
+  }
+  _updateProgress(progress) {
+    if (this._state.result != null || this._isAborted)
+      return;
+    this._state.progress.push(progress);
+    this._sendUpdate({
+      type: "progress" /* progress */,
+      runningAction: this,
+      time: Date.now(),
+      progress: progress.progress
+    });
+  }
+  waitForResultPayload() {
+    return this._resultPayloadPromise;
+  }
+  _resolveFromJson(resultJson) {
+    if (this._state.result != null || this._isAborted)
+      return false;
+    const result = this._domain.hydrateResultPayload(resultJson);
+    return this._completeWithResult(result);
+  }
+}
+// src/ActionRuntime/Handler/Local/ActionLocalHandler.ts
+import { castNiceError as castNiceError2, isNiceErrorObject, NiceError } from "@nice-code/error";
+
+// src/errors/err_nice_action.ts
+import { err, err_nice } from "@nice-code/error";
+var EErrId_NiceAction;
+((EErrId_NiceAction2) => {
+  EErrId_NiceAction2["not_implemented"] = "not_implemented";
+  EErrId_NiceAction2["action_id_not_in_domain"] = "action_id_not_in_domain";
+  EErrId_NiceAction2["domain_already_exists_in_hierarchy"] = "domain_already_exists_in_hierarchy";
+  EErrId_NiceAction2["domain_no_handler"] = "domain_no_handler";
+  EErrId_NiceAction2["hydration_domain_mismatch"] = "hydration_domain_mismatch";
+  EErrId_NiceAction2["hydration_action_state_mismatch"] = "hydration_action_state_mismatch";
+  EErrId_NiceAction2["hydration_action_id_not_found"] = "hydration_action_id_not_found";
+  EErrId_NiceAction2["no_action_execution_handler"] = "no_action_execution_handler";
+  EErrId_NiceAction2["wire_action_not_payload"] = "wire_action_not_payload";
+  EErrId_NiceAction2["wire_not_action_data"] = "wire_not_action_data";
+  EErrId_NiceAction2["client_runtime_already_registered"] = "client_runtime_already_registered";
+  EErrId_NiceAction2["client_runtime_not_registered"] = "client_runtime_not_registered";
+  EErrId_NiceAction2["runtime_reset"] = "runtime_reset";
+  EErrId_NiceAction2["no_client_runtimes_registered"] = "no_client_runtimes_registered";
+  EErrId_NiceAction2["action_input_validation_failed"] = "action_input_validation_failed";
+  EErrId_NiceAction2["action_input_validation_promise"] = "action_input_validation_promise";
+  EErrId_NiceAction2["action_output_validation_failed"] = "action_output_validation_failed";
+  EErrId_NiceAction2["action_output_validation_promise"] = "action_output_validation_promise";
+})(EErrId_NiceAction ||= {});
+var err_nice_action = err_nice.createChildDomain({
+  domain: "err_nice_action",
+  defaultHttpStatusCode: 500,
+  schema: {
+    ["not_implemented" /* not_implemented */]: err({
+      message: ({ label }) => `The "${label}" functionality is not implemented yet.`
+    }),
+    ["action_id_not_in_domain" /* action_id_not_in_domain */]: err({
+      message: ({ actionId, domain }) => `Action with id "${actionId}" does not exist in domain "${domain}".`
+    }),
+    ["domain_already_exists_in_hierarchy" /* domain_already_exists_in_hierarchy */]: err({
+      message: ({ domain, allParentDomains, parentDomain }) => `Domain "${domain}" already exists in the hierarchy under the parent "${parentDomain}". All parent domains ["${allParentDomains.join(", ")}"]`
+    }),
+    ["domain_no_handler" /* domain_no_handler */]: err({
+      message: ({ domain }) => `Domain "${domain}" has no action handler registered.`
+    }),
+    ["hydration_domain_mismatch" /* hydration_domain_mismatch */]: err({
+      message: ({ expected, received }) => `Cannot hydrate action: domain mismatch. Expected "${expected}", got "${received}".`
+    }),
+    ["hydration_action_state_mismatch" /* hydration_action_state_mismatch */]: err({
+      message: ({ expected, received }) => `Cannot hydrate action: action state type mismatch. Expected "${expected}", got "${received}".`
+    }),
+    ["hydration_action_id_not_found" /* hydration_action_id_not_found */]: err({
+      message: ({ domain, actionId }) => `Cannot hydrate action: id "${actionId}" does not exist in domain "${domain}".`
+    }),
+    ["no_action_execution_handler" /* no_action_execution_handler */]: err({
+      message: ({ domain, actionId, specifiedClient }) => `${specifiedClient ? ` The targeted client runtime [${specifiedClient.stringId}] has no` : "No"} action handler registered for "${actionId}" in domain "${domain}".`
+    }),
+    ["wire_action_not_payload" /* wire_action_not_payload */]: err({
+      message: ({ domain, actionId, actionState }) => `Cannot handle wire for action "${actionId}" in domain "${domain}": expected action form of "${"data" /* data */}" and type of "${"request" /* request */}", "${"progress" /* progress */}" or "${"result" /* result */}", got "${actionState}".`
+    }),
+    ["wire_not_action_data" /* wire_not_action_data */]: err({
+      message: () => `Cannot handle wire for action: expected an object with a "domain" property of type string, a "form" property of "${"data" /* data */}" and a "type" property of "${"request" /* request */}", "${"progress" /* progress */}" or "${"result" /* result */}".`
+    }),
+    ["runtime_reset" /* runtime_reset */]: err({
+      message: () => `Runtime has been reset.`
+    }),
+    ["client_runtime_already_registered" /* client_runtime_already_registered */]: err({
+      message: ({ context, client }) => `Environment is already registered${context?.domain ? ` on domain "${context.domain}"` : ""} for client [${client.stringId}]. Each client specifier (exact match on all properties) may only be registered once.`
+    }),
+    ["client_runtime_not_registered" /* client_runtime_not_registered */]: err({
+      message: ({ context, clientStringId }) => `No runtime registered${context?.domain ? ` on domain "${context.domain}"` : ""} for client [${clientStringId}].`
+    }),
+    ["no_client_runtimes_registered" /* no_client_runtimes_registered */]: err({
+      message: ({ context }) => `No runtimes registered${context?.domain ? ` on domain "${context.domain}"` : ""}. Add handlers to a runtime via runtime.addHandlers([handler]) before executing actions.`
+    }),
+    ["action_input_validation_failed" /* action_input_validation_failed */]: err({
+      message: ({ domain, actionId, validationMessage }) => `Input validation failed for action "${actionId}" in domain "${domain}":
+${validationMessage}`,
+      httpStatusCode: 400
+    }),
+    ["action_input_validation_promise" /* action_input_validation_promise */]: err({
+      message: ({ domain, actionId }) => `Input validation for action "${actionId}" in domain "${domain}" returned a promise, which is not supported.`,
+      httpStatusCode: 400
+    }),
+    ["action_output_validation_failed" /* action_output_validation_failed */]: err({
+      message: ({ domain, actionId, validationMessage }) => `Output validation failed for action "${actionId}" in domain "${domain}":
+${validationMessage}`,
+      httpStatusCode: 500
+    }),
+    ["action_output_validation_promise" /* action_output_validation_promise */]: err({
+      message: ({ domain, actionId }) => `Output validation for action "${actionId}" in domain "${domain}" returned a promise, which is not supported.`,
+      httpStatusCode: 500
+    })
+  }
+});
+
+// src/utils/isAction_Base_JsonObject.ts
+var isAction_Base_JsonObject = (obj) => {
+  return typeof obj === "object" && obj !== null && typeof obj.domain === "string" && typeof obj.id === "string" && typeof obj.form === "string";
+};
+
+// src/utils/isActionPayload_Result_JsonObject.ts
+var isActionPayload_Result_JsonObject = (obj) => {
+  return isAction_Base_JsonObject(obj) && obj.result != null && obj.form === "data" /* data */ && obj.type === "result" /* result */;
+};
+
+// src/ActionRuntime/ActionRuntime.ts
+import { castNiceError } from "@nice-code/error";
+import { nanoid as nanoid2 } from "nanoid";
+
+// src/utils/getAssumedRuntimeEnvironment.ts
+import { runtime } from "std-env";
+var getAssumedRuntimeInfo = () => {
+  return {
+    assumed: true,
+    runtimeName: runtime
+  };
+};
+
+// src/utils/isActionPayload_Progress_JsonObject.ts
+var isActionPayload_Progress_JsonObject = (obj) => {
+  return isAction_Base_JsonObject(obj) && "progress" in obj && obj.form === "data" /* data */ && obj.type === "progress" /* progress */;
+};
+
+// src/utils/isActionPayload_Request_JsonObject.ts
+var isActionPayload_Request_JsonObject = (obj) => {
+  return isAction_Base_JsonObject(obj) && "input" in obj && obj.form === "data" /* data */ && obj.type === "request" /* request */;
+};
+
+// src/utils/isActionPayload_Any_JsonObject.ts
+function isActionPayload_Any_JsonObject(obj) {
+  return isActionPayload_Request_JsonObject(obj) || isActionPayload_Result_JsonObject(obj) || isActionPayload_Progress_JsonObject(obj);
+}
+
+// src/ActionRuntime/ActionDomainManager.ts
+class ActionDomainManager {
+  _domains = new Map;
+  addDomain(domain) {
+    this._domains.set(domain.domain, domain);
+  }
+  getDomains() {
+    return [...this._domains.values()];
+  }
+  verifyIsActionJson(action) {
+    if (typeof action.domain !== "string" || typeof action.id !== "string") {
+      throw err_nice_action.fromId("wire_not_action_data" /* wire_not_action_data */);
+    }
+  }
+  getActionDomain(action) {
+    this.verifyIsActionJson(action);
+    const domain = this._domains.get(action.domain);
+    if (!domain) {
+      return;
+    }
+    return domain;
+  }
+  getActionDomainOrThrow(action) {
+    this.verifyIsActionJson(action);
+    const domain = this._domains.get(action.domain);
+    if (!domain) {
+      throw err_nice_action.fromId("domain_no_handler" /* domain_no_handler */, {
+        domain: action.domain
+      });
+    }
+    return domain;
+  }
+  hydrateActionPayload(actionJson) {
+    const domain = this.getActionDomainOrThrow(actionJson);
+    return domain.hydrateAnyAction(actionJson);
+  }
+}
+
+// src/ActionRuntime/Routing/ActionRouter.ts
+class ActionRouter {
+  domainManager = new ActionDomainManager;
+  actionRouteData = new Map;
+  _context;
+  constructor(context) {
+    this._context = context;
+  }
+  mergeRouter(actionRouter) {
+    for (const domain of actionRouter.getDomains()) {
+      this.domainManager.addDomain(domain);
+    }
+    for (const [matchKey, routeDataEntries] of actionRouter.actionRouteData.entries()) {
+      this.actionRouteData.set(matchKey, [...routeDataEntries]);
+    }
+  }
+  addDomainsFromOther(actionRouter) {
+    for (const domain of actionRouter.getDomains()) {
+      this.domainManager.addDomain(domain);
+    }
+  }
+  getRouteDataEntriesForAction(action) {
+    const idKey = `dom[${action.domain}]id[${action.id}]`;
+    const domKey = `dom[${action.domain}]id[_]`;
+    return [
+      ...this.actionRouteData.get(idKey) ?? [],
+      ...this.actionRouteData.get(domKey) ?? []
+    ];
+  }
+  getRouteDataForAction(action) {
+    return this.getRouteDataEntriesForAction(action)[0];
+  }
+  throwNoHandlerForAction(action, context) {
+    if (this._context.contextType === "handler_route" /* handler_route */) {
+      throw err_nice_action.fromId("no_action_execution_handler" /* no_action_execution_handler */, {
+        domain: action.domain,
+        actionId: action.id,
+        specifiedClient: context.targetLocalRuntime?.coordinate
+      });
+    }
+    if (this._context.contextType === "runtime_to_handler" /* runtime_to_handler */) {
+      throw err_nice_action.fromId("no_action_execution_handler" /* no_action_execution_handler */, {
+        domain: action.domain,
+        actionId: action.id,
+        specifiedClient: this._context.runtime.coordinate
+      });
+    }
+    throw err_nice_action.fromId("no_action_execution_handler" /* no_action_execution_handler */, {
+      domain: action.domain,
+      actionId: action.id
+    });
+  }
+  getRouteDataEntriesForActionOrThrow(action, context) {
+    const entries = this.getRouteDataEntriesForAction(action);
+    if (entries.length === 0) {
+      this.throwNoHandlerForAction(action, context);
+    }
+    return entries;
+  }
+  getRouteDataForActionOrThrow(action, context) {
+    const routeData = this.getRouteDataForAction(action);
+    if (!routeData) {
+      this.throwNoHandlerForAction(action, context);
+    }
+    return routeData;
+  }
+  getForKey(key) {
+    return this.actionRouteData.get(key) ?? [];
+  }
+  getRegisteredKeys() {
+    return [...this.actionRouteData.keys()];
+  }
+  getDomains() {
+    return this.domainManager.getDomains();
+  }
+  forDomain(domain, routeData) {
+    this.domainManager.addDomain(domain);
+    this.actionRouteData.set(`dom[${domain.domain}]id[_]`, [routeData]);
+    return this;
+  }
+  forAction(action, routeData) {
+    return this.forActionId(action._domain, action.id, routeData);
+  }
+  forActionId(domain, id, routeData) {
+    this.domainManager.addDomain(domain);
+    this.actionRouteData.set(`dom[${domain.domain}]id[${id}]`, [routeData]);
+    return this;
+  }
+  forActionIds(domain, ids, routeData) {
+    this.domainManager.addDomain(domain);
+    for (const id of ids) {
+      this.forActionId(domain, id, routeData);
+    }
+    return this;
+  }
+  forDomainActionCases(domain, cases) {
+    this.domainManager.addDomain(domain);
+    for (const id of Object.keys(cases)) {
+      const routeData = cases[id];
+      if (routeData != null) {
+        this.actionRouteData.set(`dom[${domain.domain}]id[${id}]`, [routeData]);
+      }
+    }
+    return this;
+  }
+  addForDomain(domain, routeData) {
+    this.domainManager.addDomain(domain);
+    this._push(`dom[${domain.domain}]id[_]`, routeData);
+    return this;
+  }
+  addForAction(domain, id, routeData) {
+    this.domainManager.addDomain(domain);
+    this._push(`dom[${domain.domain}]id[${id}]`, routeData);
+    return this;
+  }
+  addForActionIds(domain, ids, routeData) {
+    this.domainManager.addDomain(domain);
+    for (const id of ids) {
+      this.addForAction(domain, id, routeData);
+    }
+    return this;
+  }
+  addForDomainActionCases(domain, cases) {
+    this.domainManager.addDomain(domain);
+    for (const id of Object.keys(cases)) {
+      const routeData = cases[id];
+      if (routeData != null) {
+        this._push(`dom[${domain.domain}]id[${id}]`, routeData);
+      }
+    }
+    return this;
+  }
+  addForKey(key, routeData) {
+    this._push(key, routeData);
+    return this;
+  }
+  _push(key, routeData) {
+    const existing = this.actionRouteData.get(key);
+    if (existing != null) {
+      existing.push(routeData);
+    } else {
+      this.actionRouteData.set(key, [routeData]);
+    }
+  }
+}
+
+// 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;
+  }
+  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();
+  }
+  registerRunningAction(ra) {
+    this._pendingRunningActions.set(ra.cuid, ra);
+    ra.addUpdateListeners([
+      (update) => {
+        if (update.type === "finished" /* finished */) {
+          this._pendingRunningActions.delete(ra.cuid);
+        }
+      }
+    ]);
+  }
+  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);
+  }
+  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);
+  }
+  async handleActionPayload(action, options) {
+    if (action.type === "request" /* request */) {
+      let handlerForAction;
+      try {
+        handlerForAction = this.getHandlerForActionOrThrow(action, options);
+      } catch (err2) {
+        const runningAction2 = new RunningAction({
+          context: action.context,
+          request: action
+        });
+        runningAction2._completeWithResult(action.errorResult(castNiceError(err2)));
+        return runningAction2;
+      }
+      const runningAction = await handlerForAction.handleActionRequest(action, {
+        ...options,
+        targetLocalRuntime: this
+      });
+      this._trySetupReturnDispatch(runningAction);
+      return runningAction;
+    }
+    throw err_nice_action.fromId("not_implemented" /* not_implemented */, {
+      label: `Handling incoming action payloads of type "${action.type}"`
+    });
+  }
+  _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 (targetExternalClient != null) {
+        return false;
+      }
+      if (action.type === "request" /* request */) {
+        return true;
+      }
+      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 (possibleHandler.handlerType === "external" /* external */) {
+        const score = scoringExternalClient.similarityLevel(possibleHandler.externalClient);
+        if (score > handlerScore) {
+          handlerScore = score;
+          handler = possibleHandler;
+        }
+      }
+    }
+    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);
+        }
+      }
+    }
+    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;
+      }
+    }
+    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`
+    }));
+  }
+  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 {
+  cuid;
+  constructor() {
+    this.cuid = nanoid3();
+  }
+  getActionRouter() {
+    return this.actionRouter;
+  }
+}
+
+// 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
+    });
+    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((err2) => {
+      if (err2 instanceof NiceError) {
+        runningAction._completeWithResult(action.errorResult(err2));
+      } else if (isNiceErrorObject(err2)) {
+        runningAction._completeWithResult(action.errorResult(castNiceError2(err2)));
+      } else {
+        runningAction._abort(err2);
+      }
+    });
+    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);
+    };
+  }
+}
+
+// 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;
+  }
+  _registerRuntime(runtime2) {
+    this._rootDomain._registerRuntime(runtime2);
+  }
+  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
+      });
+    }
+    return new ActionDomain({
+      allDomains: [...this.allDomains, subDomainDef.domain],
+      domain: subDomainDef.domain,
+      actionSchema: subDomainDef.actions
+    }, { rootDomain: this._rootDomain });
+  }
+  get action() {
+    return this._actionMap;
+  }
+  actionsMap() {
+    return this._actionMap;
+  }
+  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
+      });
+    }
+    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;
+  }
+  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
+      });
+    }
+    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);
+    return new ActionPayload_Request({ context: contextAction }, contextAction.deserializeInput(serialized.input), {
+      time: serialized.time
+    });
+  }
+  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);
+      }
+      if (actionJson.type === "result" /* result */) {
+        return this.hydrateResultPayload(actionJson);
+      }
+    }
+    return this.actionForId(actionJson.id);
+  }
+  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 map;
+  }
+}
+// src/ActionRuntime/ActionRuntimeManager.ts
+class ActionRuntimeManager {
+  _runtimes = new Map;
+  _preferredRuntimeClientId = null;
+  _context;
+  constructor(context) {
+    this._context = context ?? {};
+  }
+  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;
+      }
+      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;
+      }
+      const handler = runtime2._getHandlerForAction(action, options);
+      if (handler != null) {
+        return { handler, runtime: runtime2 };
+      }
+      if (throwOnIssue) {
+        throw err_nice_action.fromId("no_action_execution_handler" /* no_action_execution_handler */, {
+          domain: action.domain,
+          actionId: action.id,
+          specifiedClient: localRuntime.coordinate
         });
-      } else if (type === "progress" /* progress */) {
-        this._log("progress", actionPath, runningAction.cuid, { progress: update.progress });
-      } else if (type === "finished" /* finished */) {
-        const timing = this._inFlight.get(runningAction.cuid);
-        const duration = timing != null ? time - timing.startTime : undefined;
-        this._inFlight.delete(runningAction.cuid);
-        const finishType = update.finishType;
-        if (finishType === "success" /* success */) {
-          const result = update.response?.result;
-          if (result != null && !result.ok) {
-            this._log("action-error", actionPath, runningAction.cuid, {
-              ...duration != null ? { duration: `${duration}ms` } : {},
-              error: serializeError(result.error)
-            });
-          } else {
-            this._log("success", actionPath, runningAction.cuid, {
-              ...duration != null ? { duration: `${duration}ms` } : {},
-              ...this._options.logPayloads ? { output: result?.output } : {}
+      }
+    }
+    for (const runtime2 of this._runtimes.values()) {
+      const handler = runtime2._getHandlerForAction(action);
+      if (handler) {
+        return { handler, runtime: runtime2 };
+      }
+    }
+    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
+      });
+    }
+  }
+  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;
+      }
+    }
+    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/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
+      });
+    }
+    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 (err2) {
+      const runningAction2 = new RunningAction({
+        context: actionPayload.context,
+        request: actionPayload,
+        callSite: actionPayload._callSite
+      });
+      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;
+  }
+}
+// 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;
+  }
+  get outputSchema() {
+    return this.outputOptions?.schema;
+  }
+  input(options) {
+    this.inputOptions = options;
+    return this;
+  }
+  output(options) {
+    this.outputOptions = options;
+    return this;
+  }
+  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;
+    }
+    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)
+      });
+    }
+    return result.value;
+  }
+  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;
+  }
+  serializeOutput(rawOutput) {
+    if (this.outputOptions?.serialization) {
+      return this.outputOptions.serialization.serialize(rawOutput);
+    }
+    return rawOutput;
+  }
+  deserializeOutput(serialized) {
+    if (this.outputOptions?.serialization) {
+      return this.outputOptions.serialization.deserialize(serialized);
+    }
+    return serialized;
+  }
+}
+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);
+  }
+  async getReadyTransport(routeActionParams) {
+    const initializingWaiters = [];
+    const unavailableTransports = [];
+    const action = routeActionParams.action;
+    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) {
+            initializingWaiters.push(cached);
+            continue;
+          }
+          return { ...cached, transport };
+        }
+      }
+      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));
+        }
+        return { methods: readyData, transport };
+      }
+      if (statusInfo.status === "unsupported" /* unsupported */) {
+        unavailableTransports.push(transport);
+        continue;
+      }
+      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]
             });
           }
-        } else if (finishType === "failed" /* failed */) {
-          this._log("failed", actionPath, runningAction.cuid, {
-            ...duration != null ? { duration: `${duration}ms` } : {},
-            error: serializeError(update.error)
-          });
-        } else {
-          this._log("aborted", actionPath, runningAction.cuid, {
-            ...duration != null ? { duration: `${duration}ms` } : {},
-            ...update.reason != null ? { reason: String(update.reason) } : {}
-          });
+          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 (cacheKey != null) {
+          this._cache.set(cacheKey, promise);
         }
+        initializingWaiters.push(promise);
+      }
+    }
+    if (initializingWaiters.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
+      });
+    }
+    try {
+      return await Promise.any(initializingWaiters).then();
+    } catch (e) {
+      throw err_nice_transport.fromId("initialization_failed" /* initialization_failed */, {
+        actionId: action.id
+      }).withOriginError(e);
+    }
+  }
+}
+
+// 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);
+          }
+        }
+      });
+      connection.definition = transport;
+      this.transportManager.addTransport(connection);
+    }
+  }
+  forDomain(domain) {
+    this.actionRouter.forDomain(domain, true);
+    return this;
+  }
+  forAction(action) {
+    this.actionRouter.forAction(action, true);
+    return this;
+  }
+  forActionIds(domain, ids) {
+    this.actionRouter.forActionIds(domain, ids, true);
+    return this;
+  }
+  _setIncomingActionDataListener(listener) {
+    this._incomingActionDataListeners.push(listener);
+  }
+  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 { methods, transport } = await this.transportManager.getReadyTransport({
+      action,
+      localClient,
+      externalClient: this.externalClient
+    });
+    action.context.addRouteItem({
+      runtime: localClient,
+      handler: this.toHandlerRouteItem(transport, {
+        action,
+        localClient,
+        externalClient: this.externalClient
+      }),
+      time: Date.now()
     });
+    const runningAction = new RunningAction({
+      context: action.context,
+      request: action,
+      parentCuid,
+      callSite
+    });
+    localRuntime.registerRunningAction(runningAction);
+    const routeActionParams = {
+      action,
+      runningAction,
+      localClient,
+      externalClient: this.externalClient,
+      timeout: incomingTimeout
+    };
+    if (action.type === "request" /* request */ && methods.updateRunConfig != null) {
+      const runConfig = methods.updateRunConfig(routeActionParams);
+      routeActionParams.timeout = runConfig?.timeout ?? incomingTimeout;
+    }
+    try {
+      methods.sendActionData(routeActionParams);
+    } catch (err3) {
+      runningAction._abort(err3);
+    }
+    return runningAction;
   }
-  _log(event, actionPath, cuid, data) {
-    const { logger, format } = this._options;
-    if (format === "json") {
-      logger(JSON.stringify({ time: new Date().toISOString(), event, action: actionPath, cuid, ...data }));
-      return;
+  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);
+      return true;
+    } catch {
+      return false;
     }
-    const prefix = PRETTY_PREFIX[event] ?? `[${event}]`;
-    const suffix = Object.keys(data).length > 0 ? `  ${formatPrettyData(data)}` : "";
-    logger(`${prefix} ${actionPath}  cuid=${cuid}${suffix}`);
+  }
+  toJsonObject() {
+    return {
+      type: this.handlerType,
+      client: this.externalClient
+    };
+  }
+  toHandlerRouteItem(transport, input) {
+    return {
+      type: this.handlerType,
+      client: this.externalClient,
+      transOrd: transport.transOrd,
+      transType: transport.type,
+      transInfo: transport.getRouteInfo(input)
+    };
+  }
+  clearTransportCache() {
+    this._transportCache.clear();
   }
 }
-var PRETTY_PREFIX = {
-  started: "[nice-action] ►",
-  progress: "[nice-action]  ",
-  success: "[nice-action] ✓",
-  failed: "[nice-action] ✗",
-  aborted: "[nice-action] ○"
+var createExternalClientHandler = (config) => {
+  return new ActionExternalClientHandler(config);
 };
-function formatPrettyData(data) {
-  return Object.entries(data).map(([k, v]) => `${k}=${safeStringify(v)}`).join(" ");
-}
-function safeStringify(value) {
-  if (value === undefined)
-    return "undefined";
-  if (value === null)
-    return "null";
-  if (typeof value === "string")
-    return `"${value}"`;
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
+// src/ActionRuntime/Handler/ExternalClient/Transport/Transport.ts
+class Transport {
+}
+
+// src/ActionRuntime/Handler/ExternalClient/Transport/helpers/addTransportStatusMetadata.ts
+function addTransportStatusMetadata(transportStatus) {
+  if (transportStatus.status === "ready" /* ready */) {
+    return {
+      status: "ready" /* ready */,
+      readyData: transportStatus.readyData
+    };
   }
+  if (transportStatus.status === "initializing" /* initializing */) {
+    return {
+      status: "initializing" /* initializing */,
+      initializationPromise: transportStatus.initializationPromise,
+      timeStarted: Date.now()
+    };
+  }
+  if (transportStatus.status === "failed" /* failed */) {
+    return {
+      status: "failed" /* failed */,
+      error: transportStatus.error,
+      timeFailed: Date.now()
+    };
+  }
+  if (transportStatus.status === "unsupported" /* unsupported */) {
+    return {
+      status: "unsupported" /* unsupported */
+    };
+  }
+  return {
+    status: "uninitialized" /* uninitialized */
+  };
 }
-function serializeError(err) {
-  if (err == null)
-    return err;
-  if (err instanceof Error)
-    return { message: err.message, name: err.name, stack: err.stack };
-  if (typeof err === "object") {
-    try {
-      return JSON.parse(JSON.stringify(err));
-    } catch {
-      return String(err);
+
+// src/ActionRuntime/Handler/ExternalClient/Transport/TransportConnection.ts
+var transportOrd = 0;
+
+class TransportConnection {
+  def;
+  transOrd = transportOrd++;
+  type;
+  initialized;
+  definition;
+  constructor(def) {
+    this.def = def;
+    this.type = def.type;
+    this.initialized = def.initialize();
+  }
+  getRouteInfo(input) {
+    return this.definition?.getRouteInfo(input);
+  }
+  _getCacheKey(input) {
+    const parts = this.initialized.getTransportCacheKey?.(input);
+    if (parts == null)
+      return null;
+    return parts.join("\x00");
+  }
+  getCacheKey(input) {
+    const inner = this._getCacheKey(input);
+    if (inner == null)
+      return null;
+    return `${this.transOrd}:${inner}`;
+  }
+  getTransport(input) {
+    return this._processTransportStatus(input);
+  }
+  _processTransportStatus(input) {
+    const transportStatusInfo = addTransportStatusMetadata(this.initialized.getTransport(input));
+    if (transportStatusInfo.status !== "initializing" /* initializing */ && transportStatusInfo.status !== "ready" /* ready */) {
+      return transportStatusInfo;
     }
+    if (transportStatusInfo.status === "initializing" /* initializing */) {
+      const promiseForReadyData = transportStatusInfo.initializationPromise.then((result) => {
+        if (result.status === "ready" /* ready */) {
+          return {
+            status: "ready" /* ready */,
+            readyData: this._finalizeTransportMethods(result.readyData)
+          };
+        }
+        return result;
+      });
+      return {
+        status: "initializing" /* initializing */,
+        timeStarted: transportStatusInfo.timeStarted,
+        initializationPromise: promiseForReadyData
+      };
+    }
+    return {
+      status: "ready" /* ready */,
+      readyData: this._finalizeTransportMethods(transportStatusInfo.readyData)
+    };
   }
-  return err;
 }
-function defaultConsoleLogger(message) {
-  console.log(message);
+
+// src/ActionRuntime/Handler/ExternalClient/Transport/Custom/CustomConnection.ts
+class CustomConnection extends TransportConnection {
+  constructor(def) {
+    super({
+      ...def,
+      type: "custom" /* custom */
+    });
+  }
+  _finalizeTransportMethods(inputs) {
+    return {
+      sendActionData: inputs.sendActionData,
+      sendReturnData: inputs.sendReturnData,
+      updateRunConfig: inputs.updateRunConfig
+    };
+  }
 }
-// src/devtools/core/ActionDevtoolsCore.ts
-function serializeErrorForDisplay(error) {
-  if (error != null && typeof error === "object" && error.name === "NiceError" && typeof error.toJsonObject === "function") {
-    return error.toJsonObject();
+
+// src/ActionRuntime/Handler/ExternalClient/Transport/Custom/CustomTransport.ts
+class CustomTransport extends Transport {
+  options;
+  type = "custom" /* custom */;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  static create(options) {
+    return new CustomTransport({ ...options, mode: "send" });
+  }
+  static createAdvanced(options) {
+    return new CustomTransport({ ...options, mode: "advanced" });
+  }
+  _createConnection(_ctx) {
+    const options = this.options;
+    let getTransport;
+    if (options.mode === "advanced") {
+      getTransport = options.getTransport;
+    } else {
+      getTransport = () => ({
+        status: "ready" /* ready */,
+        readyData: {
+          sendActionData: options.sendActionData,
+          sendReturnData: options.sendReturnData,
+          updateRunConfig: options.updateRunConfig,
+          closeTransport: options.closeTransport ?? (() => {})
+        }
+      });
+    }
+    return new CustomConnection({
+      initialize: () => ({
+        getTransportCacheKey: options.getTransportCacheKey,
+        getTransport
+      })
+    });
+  }
+  getRouteInfo(input) {
+    if (this.options.getRouteInfo != null)
+      return this.options.getRouteInfo(input);
+    return {
+      type: "custom" /* custom */,
+      summary: this.options.label ?? "custom"
+    };
   }
-  return error;
 }
-function extractRouting(context) {
-  return (context?.routing ?? []).map((item) => {
-    const handler = item.handler;
-    const isExternal = handler?.type === "external";
+// src/ActionRuntime/Handler/ExternalClient/Transport/err_nice_transport_ws.ts
+import { err as err3 } from "@nice-code/error";
+var EErrId_NiceTransport_WebSocket;
+((EErrId_NiceTransport_WebSocket2) => {
+  EErrId_NiceTransport_WebSocket2["ws_disconnected"] = "ws_disconnected";
+  EErrId_NiceTransport_WebSocket2["ws_create_failed"] = "ws_create_failed";
+  EErrId_NiceTransport_WebSocket2["ws_error"] = "ws_error";
+})(EErrId_NiceTransport_WebSocket ||= {});
+var err_nice_transport_ws = err_nice_transport.createChildDomain({
+  domain: "ws_transport",
+  schema: {
+    ["ws_disconnected" /* ws_disconnected */]: err3({
+      message: () => `WebSocket transport disconnected.`
+    }),
+    ["ws_create_failed" /* ws_create_failed */]: err3({
+      message: ({ originalError }) => `Failed to create WebSocket transport.${originalError ? ` Original error: ${originalError.message}` : ""}`
+    }),
+    ["ws_error" /* ws_error */]: err3({
+      message: ({ originalError }) => `WebSocket transport error.${originalError ? ` Original error: ${originalError.message}` : ""}`
+    })
+  }
+});
+// src/ActionRuntime/Handler/ExternalClient/Transport/Http/HttpConnection.ts
+import { castNiceError as castNiceError3, isNiceErrorObject as isNiceErrorObject2, NiceError as NiceError2 } from "@nice-code/error";
+class HttpConnection extends TransportConnection {
+  constructor(def) {
+    super({
+      ...def,
+      type: "http" /* http */
+    });
+  }
+  _finalizeTransportMethods(methods) {
     return {
-      runtime: {
-        envId: item.runtime?.envId ?? "unknown",
-        perId: item.runtime?.perId,
-        insId: item.runtime?.insId
+      sendActionData: (input) => {
+        const request = methods.createRequest(input);
+        this.send({ ...input, params: { request }, runningAction: input.runningAction }).catch((err4) => input.runningAction._abort(err4));
       },
-      handlerType: isExternal ? "external" : "local",
-      handlerClient: isExternal && handler.client != null ? {
-        envId: handler.client.envId ?? "unknown",
-        perId: handler.client.perId,
-        insId: handler.client.insId
-      } : undefined,
-      transport: isExternal ? handler.transType : undefined,
-      transportSummary: isExternal ? handler.transInfo?.summary : undefined,
-      transportUrl: isExternal ? handler.transInfo?.url : undefined,
-      time: item.time
+      updateRunConfig: methods.updateRunConfig
     };
-  });
+  }
+  async send(input) {
+    const {
+      action,
+      runningAction,
+      timeout,
+      params: { request }
+    } = input;
+    const wire = action.toJsonObject();
+    const ac = new AbortController;
+    let timedOut = false;
+    const timeoutId = setTimeout(() => {
+      timedOut = true;
+      ac.abort();
+    }, timeout);
+    const unsubscribe = input.runningAction.addUpdateListeners([
+      (update) => {
+        if (update.type === "finished" /* finished */) {
+          clearTimeout(timeoutId);
+          ac.abort();
+        }
+      }
+    ]);
+    try {
+      const res = await fetch(request.url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...request.headers },
+        body: request.body ?? JSON.stringify(wire),
+        signal: ac.signal
+      });
+      if (!res.ok) {
+        if (action.type === "request" /* request */) {
+          try {
+            const jsonData = await res.json();
+            if (isActionPayload_Result_JsonObject(jsonData)) {
+              runningAction._completeWithResult(action._domain.hydrateResultPayload(jsonData));
+            } else if (isNiceErrorObject2(jsonData)) {
+              runningAction._completeWithResult(action.errorResult(castNiceError3(jsonData)));
+            } else {
+              runningAction._completeWithResult(action.errorResult(err_nice_transport.fromId("invalid_action_response" /* invalid_action_response */, {
+                actionId: action.id
+              })));
+            }
+          } catch (e) {
+            throw err_nice_transport.fromId("send_failed" /* send_failed */, {
+              actionState: action.type,
+              actionId: action.id,
+              httpStatusCode: res.status,
+              message: e.message
+            }).withOriginError(e);
+          }
+        } else {
+          let text;
+          try {
+            text = await res.text();
+          } catch (e) {
+            console.warn(`Failed to read error response body for failed HTTP request in HttpConnection:`, e);
+          }
+          throw err_nice_transport.fromId("send_failed" /* send_failed */, {
+            actionState: action.type,
+            actionId: action.id,
+            httpStatusCode: res.status,
+            message: text ?? `HTTP error with status ${res.status}`
+          });
+        }
+        return;
+      }
+      if (action.type === "request" /* request */) {
+        const json = await res.json();
+        if (!isActionPayload_Result_JsonObject(json)) {
+          throw err_nice_transport.fromId("invalid_action_response" /* invalid_action_response */, {
+            actionId: action.id
+          });
+        }
+        runningAction._completeWithResult(action._domain.hydrateResultPayload(json));
+      }
+    } catch (err4) {
+      if (timedOut) {
+        throw err_nice_transport.fromId("timeout" /* timeout */, { timeout });
+      }
+      if (err4 instanceof NiceError2) {
+        throw err4;
+      }
+      throw err_nice_transport.fromId("send_failed" /* send_failed */, {
+        actionState: action.type,
+        actionId: action.id,
+        message: err4 instanceof Error ? err4.message : String(err4)
+      }).withOriginError(err4 instanceof Error ? err4 : undefined);
+    } finally {
+      clearTimeout(timeoutId);
+      unsubscribe();
+    }
+  }
 }
-function extractMeta(context) {
-  return {
-    timeCreated: context?.timeCreated ?? Date.now(),
-    originClient: {
-      envId: context?.originClient?.envId ?? "unknown",
-      perId: context?.originClient?.perId,
-      insId: context?.originClient?.insId
-    },
-    routing: extractRouting(context)
-  };
+
+// src/ActionRuntime/Handler/ExternalClient/Transport/Http/HttpTransport.ts
+function shortPath(url) {
+  try {
+    return new URL(url).pathname || url;
+  } catch {
+    return url;
+  }
+}
+
+class HttpTransport extends Transport {
+  options;
+  type = "http" /* http */;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  static create(options) {
+    return new HttpTransport(options);
+  }
+  _createConnection(_ctx) {
+    return new HttpConnection({
+      initialize: () => ({
+        getTransportCacheKey: this.options.getTransportCacheKey,
+        getTransport: () => ({
+          status: "ready" /* ready */,
+          readyData: {
+            createRequest: this.options.createRequest,
+            updateRunConfig: this.options.updateRunConfig
+          }
+        })
+      })
+    });
+  }
+  getRouteInfo(input) {
+    const { url } = this.options.createRequest(input);
+    return {
+      type: "http" /* http */,
+      method: "POST",
+      url,
+      summary: `POST ${shortPath(url)}`
+    };
+  }
+}
+// src/ActionRuntime/Handler/ExternalClient/Transport/helpers/createUnsetTransportResolvers.ts
+var createUnsetTransportResolvers = (type) => ({
+  onIncomingActionDataJson: (json) => {
+    console.warn(`Received incoming action JSON [${json.domain}:${json.id}] on Transport [${type}] but no incoming data listener has been set.`);
+  }
+});
+
+// src/ActionRuntime/Handler/ExternalClient/Transport/WebSocket/ws_util.ts
+function shortWs(url) {
+  try {
+    const u = new URL(url);
+    return `${u.host}${u.pathname}`;
+  } catch {
+    return url;
+  }
 }
 
-class ActionDevtoolsCore {
-  _entries = [];
-  _listeners = new Set;
-  constructor(_options = {}) {}
-  attachToDomain(domain) {
-    return domain.addActionListener((update) => {
-      const { runningAction, type, time } = update;
-      if (type === "started" /* started */) {
-        const entry = {
-          cuid: runningAction.cuid,
-          actionId: runningAction.id,
-          domain: runningAction.domain,
-          allDomains: [...runningAction.allDomains],
-          status: "running",
-          startTime: time,
-          input: runningAction.state?.request?.input,
-          inputHash: runningAction.state?.request?.inputHash,
-          progressUpdates: [],
-          meta: extractMeta(runningAction.context),
-          parentCuid: runningAction.parentCuid,
-          callSite: runningAction.callSite
+// src/ActionRuntime/Handler/ExternalClient/Transport/WebSocket/WebSocketConnection.ts
+class WebSocketConnection extends TransportConnection {
+  resolvers;
+  _abortSet = new Set;
+  _liveSocketUrl;
+  constructor(def, resolvers) {
+    super({ ...def, type: "ws" /* ws */ });
+    this.resolvers = resolvers ?? createUnsetTransportResolvers("ws" /* ws */);
+  }
+  _getCacheKey(_input) {
+    return this.initialized.getTransportCacheKey?.(_input).join("\x00") ?? "";
+  }
+  _processTransportStatus(input) {
+    const transportStatusInfo = addTransportStatusMetadata(this.initialized.getTransport(input));
+    if (transportStatusInfo.status !== "initializing" /* initializing */ && transportStatusInfo.status !== "ready" /* ready */) {
+      return transportStatusInfo;
+    }
+    if (transportStatusInfo.status === "ready" /* ready */) {
+      const ws = transportStatusInfo.readyData.ws;
+      if (ws.readyState !== WebSocket.OPEN) {
+        const initialization = async () => {
+          await new Promise((resolve, reject) => {
+            ws.addEventListener("open", () => resolve(), { once: true });
+            ws.addEventListener("error", (event) => reject(event), { once: true });
+            ws.addEventListener("close", (event) => reject(new Error(`WebSocket closed before open: code=${event.code}`)), { once: true });
+          });
+          return {
+            status: "ready" /* ready */,
+            readyData: this._finalizeTransportMethods(transportStatusInfo.readyData)
+          };
         };
-        this._entries = [entry, ...this._entries];
-        this._notify();
-      } else if (type === "progress" /* progress */) {
-        this._updateEntry(runningAction.cuid, (e) => ({
-          ...e,
-          progressUpdates: [...e.progressUpdates, update.progress]
-        }));
-      } else if (type === "finished" /* finished */) {
-        this._updateEntry(runningAction.cuid, (e) => {
-          const finishedRoutingContext = update.response?.context ?? runningAction.context;
-          const base = {
-            ...e,
-            endTime: time,
-            meta: { ...e.meta, routing: extractRouting(finishedRoutingContext) }
+        return {
+          status: "initializing" /* initializing */,
+          timeStarted: Date.now(),
+          initializationPromise: initialization()
+        };
+      }
+    }
+    if (transportStatusInfo.status === "initializing" /* initializing */) {
+      const promiseForReadyData = transportStatusInfo.initializationPromise.then(async (result) => {
+        if (result.status === "ready" /* ready */) {
+          const ws = result.readyData.ws;
+          await new Promise((resolve, reject) => {
+            ws.addEventListener("open", () => resolve(), { once: true });
+            ws.addEventListener("error", (event) => reject(event), { once: true });
+            ws.addEventListener("close", (event) => reject(new Error(`WebSocket closed before open: code=${event.code}`)), { once: true });
+          });
+          return {
+            status: "ready" /* ready */,
+            readyData: this._finalizeTransportMethods(result.readyData)
           };
-          const finishType = update.finishType;
-          if (finishType === "success" /* success */) {
-            const result = update.response?.result;
-            const outputHash = update.response?.outputHash;
-            if (result != null && !result.ok) {
-              const rawError = result.error;
-              const errorStack2 = rawError instanceof Error ? rawError.stack : undefined;
-              return {
-                ...base,
-                status: "action-error",
-                outputHash,
-                error: serializeErrorForDisplay(rawError),
-                errorStack: errorStack2
-              };
+        }
+        return result;
+      });
+      return {
+        status: "initializing" /* initializing */,
+        initializationPromise: promiseForReadyData,
+        timeStarted: transportStatusInfo.timeStarted
+      };
+    }
+    return {
+      status: "ready" /* ready */,
+      readyData: this._finalizeTransportMethods(transportStatusInfo.readyData)
+    };
+  }
+  getRouteInfo(input) {
+    const base = this.definition?.getRouteInfo(input);
+    if (base?.url != null || this._liveSocketUrl == null)
+      return base;
+    return {
+      type: "ws" /* ws */,
+      ...base,
+      url: this._liveSocketUrl,
+      summary: `ws ${shortWs(this._liveSocketUrl)}`
+    };
+  }
+  _finalizeTransportMethods(wsData) {
+    const ws = wsData.ws;
+    const disconnectListeners = [];
+    if (ws.url != null && ws.url !== "")
+      this._liveSocketUrl = ws.url;
+    const sendActionData = (inputs) => {
+      const { action, runningAction, timeout } = inputs;
+      if (action.type === "request" /* request */) {
+        this._abortSet.add(runningAction);
+        const timeoutId = setTimeout(() => {
+          runningAction._abort(err_nice_transport.fromId("timeout" /* timeout */, { timeout }));
+        }, timeout);
+        runningAction.addUpdateListeners([
+          (update) => {
+            if (update.type === "finished" /* finished */) {
+              clearTimeout(timeoutId);
+              this._abortSet.delete(runningAction);
             }
-            return { ...base, status: "success", output: result?.output, outputHash };
           }
-          if (finishType === "failed" /* failed */) {
-            const rawError = update.error;
-            const errorStack2 = rawError instanceof Error ? rawError.stack : undefined;
-            return { ...base, status: "failed", error: serializeErrorForDisplay(rawError), errorStack: errorStack2 };
-          }
-          const abortReason = update.reason;
-          const errorStack = abortReason instanceof Error ? abortReason.stack : undefined;
-          return { ...base, status: "aborted", abortReason: serializeErrorForDisplay(abortReason), errorStack };
-        });
+        ]);
       }
+      ws.send(wsData.formatMessage?.outgoing(inputs) ?? JSON.stringify(inputs.action.toJsonObject()));
+    };
+    ws.addEventListener("message", (event) => {
+      if (typeof event.data === "string") {
+        const rawJson = wsData.formatMessage?.incoming?.(event.data) ?? this._parseActionMessage(event.data);
+        if (rawJson != null && isActionPayload_Any_JsonObject(rawJson)) {
+          this.resolvers.onIncomingActionDataJson(rawJson);
+        }
+      }
+    });
+    ws.addEventListener("close", (event) => {
+      console.error("WebSocket closed:", event);
+      for (const cb of disconnectListeners)
+        cb();
+      this._abortAll(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 */, {
+        originalError: event instanceof Error ? event : undefined
+      }));
+    });
+    return {
+      sendActionData,
+      updateRunConfig: wsData.updateRunConfig,
+      addOnDisconnectListener: (cb) => {
+        disconnectListeners.push(cb);
+      },
+      sendReturnData: (payload) => {
+        ws.send(JSON.stringify(payload.toJsonObject()));
+      }
+    };
   }
-  getEntries() {
-    return this._entries;
+  _parseActionMessage(message) {
+    let json;
+    try {
+      json = JSON.parse(message);
+    } catch {
+      return;
+    }
+    return isActionPayload_Any_JsonObject(json) ? json : undefined;
   }
-  subscribe(listener) {
-    this._listeners.add(listener);
-    listener(this._entries);
-    return () => {
-      this._listeners.delete(listener);
-    };
+  _abortAll(error) {
+    const snapshot = [...this._abortSet];
+    for (const ra of snapshot) {
+      ra._abort(error);
+    }
   }
-  clear() {
-    this._entries = [];
-    this._notify();
+}
+
+// src/ActionRuntime/Handler/ExternalClient/Transport/WebSocket/WebSocketTransport.ts
+class WebSocketTransport extends Transport {
+  options;
+  type = "ws" /* ws */;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  static create(options) {
+    return new WebSocketTransport({ ...options, mode: "socket" });
+  }
+  static createAdvanced(options) {
+    return new WebSocketTransport({ ...options, mode: "advanced" });
   }
-  _updateEntry(cuid, updater) {
-    this._entries = this._entries.map((e) => e.cuid === cuid ? updater(e) : e);
-    this._notify();
+  _createConnection(ctx) {
+    const options = this.options;
+    let getTransport;
+    if (options.mode === "advanced") {
+      getTransport = options.getTransport;
+    } else {
+      getTransport = (input) => ({
+        status: "ready" /* ready */,
+        readyData: {
+          ws: options.createWebSocket(input),
+          formatMessage: options.formatMessage,
+          updateRunConfig: options.updateRunConfig
+        }
+      });
+    }
+    return new WebSocketConnection({
+      initialize: () => ({
+        getTransportCacheKey: options.getTransportCacheKey,
+        getTransport
+      })
+    }, ctx.resolvers);
   }
-  _notify() {
-    const snapshot = this._entries;
-    for (const listener of this._listeners)
-      listener(snapshot);
+  getRouteInfo(input) {
+    if (this.options.getRouteInfo != null)
+      return this.options.getRouteInfo(input);
+    return {
+      type: "ws" /* ws */,
+      summary: "ws"
+    };
   }
 }
 export {
-  ActionServerDevtools,
-  ActionDevtoolsCore
+  isActionPayload_Result_JsonObject,
+  isActionPayload_Request_JsonObject,
+  isActionPayload_Any_JsonObject,
+  err_nice_transport_ws,
+  err_nice_transport,
+  err_nice_external_client,
+  err_nice_action,
+  createLocalHandler,
+  createExternalClientHandler,
+  createActionRootDomain,
+  actionSchema,
+  WebSocketTransport,
+  Transport,
+  RuntimeCoordinate,
+  RunningAction,
+  HttpTransport,
+  ETransportType,
+  ETransportStatus,
+  ERunningActionUpdateType,
+  ERunningActionState,
+  ERunningActionFinishedType,
+  EErrId_NiceTransport_WebSocket,
+  EErrId_NiceTransport,
+  EErrId_NiceAction,
+  EActionProgressType,
+  EActionPayloadType,
+  CustomTransport,
+  ActionSchema,
+  ActionRuntime,
+  ActionRootDomain,
+  ActionLocalHandler,
+  ActionExternalClientHandler,
+  ActionDomain,
+  ActionCore
 };