@nice-code/action 0.2.9 → 0.2.11

package/build/index.js

@@ -1,60 +1,2275 @@
-// src/index.ts
-import { ActionCore } from "./ActionDefinition/Action/Core/ActionCore";
+// src/ActionDefinition/Action/Core/ActionCore.ts
+import { nanoid } from "nanoid";
 
-export * from "./ActionDefinition/Action/Core/ActionCore.types";
-export * from "./ActionDefinition/Action/Payload/ActionPayload.types";
-import { RunningAction } from "./ActionDefinition/Action/RunningAction";
-import {
-  ERunningActionFinishedType,
-  ERunningActionState,
-  ERunningActionUpdateType
-} from "./ActionDefinition/Action/RunningAction.types";
-import { ActionDomain } from "./ActionDefinition/Domain/ActionDomain";
-import { ActionRootDomain } from "./ActionDefinition/Domain/ActionRootDomain";
-import { createActionRootDomain } from "./ActionDefinition/Domain/helpers/createRootActionDomain";
-import {
-  ActionSchema,
-  actionSchema
-} from "./ActionDefinition/Schema/ActionSchema";
-import { ActionRuntime } from "./ActionRuntime/ActionRuntime";
-import {
-  ActionExternalClientHandler,
-  createExternalClientHandler
-} from "./ActionRuntime/Handler/ExternalClient/ActionExternalClientHandler";
-
-export * from "./ActionRuntime/Handler/ExternalClient/err_nice_external_client";
-export * from "./ActionRuntime/Handler/ExternalClient/Transport/err_nice_transport";
-export * from "./ActionRuntime/Handler/ExternalClient/Transport/err_nice_transport_ws";
-export * from "./ActionRuntime/Handler/ExternalClient/Transport/Http/TransportHttp";
-export * from "./ActionRuntime/Handler/ExternalClient/Transport/Transport";
-export * from "./ActionRuntime/Handler/ExternalClient/Transport/Transport.types";
-export * from "./ActionRuntime/Handler/ExternalClient/Transport/WebSocket/TransportWebSocket";
-import {
-  ActionLocalHandler,
-  createLocalHandler
-} from "./ActionRuntime/Handler/Local/ActionLocalHandler";
-import {
-  RuntimeCoordinate
-} from "./ActionRuntime/RuntimeCoordinate";
-import { EErrId_NiceAction, err_nice_action } from "./errors/err_nice_action";
-import { isActionPayload_Any_JsonObject } from "./utils/isActionPayload_Any_JsonObject";
-
-export * from "./utils/isActionPayload_Request_JsonObject";
-export * from "./utils/isActionPayload_Result_JsonObject";
-export * from "./utils/typescript/MaybePromise";
+// 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(newInputs) {
+    return new RuntimeCoordinate({
+      envId: this.envId,
+      perId: this.perId,
+      insId: this.insId,
+      ...newInputs
+    });
+  }
+  specifyIfUnset(newInputs) {
+    return new RuntimeCoordinate({
+      envId: this.envId,
+      perId: this.perId ?? newInputs.perId,
+      insId: this.insId ?? newInputs.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/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;
+  constructor(params, result, data) {
+    super(params.context, "result" /* result */, data);
+    this.result = result;
+  }
+  toJsonObject() {
+    return {
+      ...this.toBaseJsonObject(),
+      result: this.result
+    };
+  }
+  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;
+  constructor(params, input, data) {
+    super(params.context, "request" /* request */, data);
+    this.input = 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)
+    };
+  }
+  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) {
+    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;
+  _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._resultPayloadPromise = new Promise((resolve, reject) => {
+      this._resolveResult = resolve;
+      this._rejectResult = reject;
+    });
+    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;
+  }
+  _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/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["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 */}".`
+    }),
+    ["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 { 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;
+  }
+  updateRuntimeCoordinate(newCoordinate) {
+    if (this._coordinate.envId !== newCoordinate.envId) {
+      throw err_nice_action.fromId("not_implemented" /* not_implemented */, {
+        label: `updating RuntimeCoordinate with a different "envId" ("${this._coordinate.envId}" → "${newCoordinate.envId}")`
+      });
+    }
+    this._coordinate = newCoordinate;
+    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) {
+    const handlerForAction = this.getHandlerForActionOrThrow(action, options);
+    if (action.type === "request" /* request */) {
+      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;
+  }
+  _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/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 });
+    this._handleRunningAction(handler, runningAction).catch((err2) => runningAction._abort(err2));
+    return runningAction;
+  }
+  async _handleRunningAction(handler, runningAction) {
+    const state = runningAction.state;
+    if (state.result != null) {
+      return;
+    }
+    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);
+  }
+  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);
+  }
+  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);
+    return new ActionPayload_Result({ context: contextAction }, serialized.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
+        });
+      }
+    }
+    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 { handler, runtime: runtime2 } = this._actionRuntimeManager.getRuntimeAndHandlerForActionOrThrow(actionPayload, options);
+    actionPayload.context._setOriginClient(runtime2.coordinate);
+    const allListeners = [...this._listeners, ...options?.listeners ?? []];
+    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, serialize, deserialize) {
+    if (serialize != null && deserialize != null) {
+      this.inputOptions = { ...options, serialization: { serialize, deserialize } };
+    } else {
+      this.inputOptions = options;
+    }
+    return this;
+  }
+  output(options, serialize, deserialize) {
+    if (serialize != null && deserialize != null) {
+      this.outputOptions = { ...options, serialization: { serialize, deserialize } };
+    } else {
+      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]
+            });
+          }
+          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/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 */
+  };
+}
+
+// src/ActionRuntime/Handler/ExternalClient/Transport/Transport.ts
+var transportOrd = 0;
+
+class Transport {
+  def;
+  transOrd = transportOrd++;
+  type;
+  initialized;
+  constructor(def) {
+    this.def = def;
+    this.type = def.type;
+    this.initialized = def.initialize();
+  }
+  _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)
+    };
+  }
+}
+
+// src/ActionRuntime/Handler/ExternalClient/Transport/Custom/TransportCustom.ts
+class TransportCustom extends Transport {
+  constructor(def) {
+    super({
+      ...def,
+      type: "custom" /* custom */
+    });
+  }
+  _finalizeTransportMethods(inputs) {
+    return {
+      sendActionData: inputs.sendActionData,
+      sendReturnData: inputs.sendReturnData,
+      updateRunConfig: inputs.updateRunConfig
+    };
+  }
+}
+
+// src/ActionRuntime/Handler/ExternalClient/Transport/Http/TransportHttp.ts
+import { castNiceError, NiceError } from "@nice-code/error";
+class TransportHttp extends Transport {
+  constructor(def) {
+    super({
+      ...def,
+      type: "http" /* http */
+    });
+  }
+  _finalizeTransportMethods(methods) {
+    return {
+      sendActionData: (input) => {
+        const request = methods.createRequest(input);
+        this.send({ ...input, params: { request }, runningAction: input.runningAction }).catch((err3) => input.runningAction._abort(err3));
+      },
+      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 {
+              runningAction._completeWithResult(action.errorResult(castNiceError(jsonData)));
+            }
+          } 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 TransportHttp:`, 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 (err3) {
+      if (timedOut) {
+        throw err_nice_transport.fromId("timeout" /* timeout */, { timeout });
+      }
+      if (err3 instanceof NiceError) {
+        throw err3;
+      }
+      throw err_nice_transport.fromId("send_failed" /* send_failed */, {
+        actionState: action.type,
+        actionId: action.id,
+        message: err3 instanceof Error ? err3.message : String(err3)
+      }).withOriginError(err3 instanceof Error ? err3 : undefined);
+    } finally {
+      clearTimeout(timeoutId);
+      unsubscribe();
+    }
+  }
+}
+
+// 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/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/TransportWebSocket.ts
+class TransportWebSocket extends Transport {
+  resolvers;
+  _abortSet = new Set;
+  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)
+          };
+        };
+        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)
+          };
+        }
+        return result;
+      });
+      return {
+        status: "initializing" /* initializing */,
+        initializationPromise: promiseForReadyData,
+        timeStarted: transportStatusInfo.timeStarted
+      };
+    }
+    return {
+      status: "ready" /* ready */,
+      readyData: this._finalizeTransportMethods(transportStatusInfo.readyData)
+    };
+  }
+  _finalizeTransportMethods(wsData) {
+    const ws = wsData.ws;
+    const disconnectListeners = [];
+    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);
+            }
+          }
+        ]);
+      }
+      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()));
+      }
+    };
+  }
+  _parseActionMessage(message) {
+    let json;
+    try {
+      json = JSON.parse(message);
+    } catch {
+      return;
+    }
+    return isActionPayload_Any_JsonObject(json) ? json : undefined;
+  }
+  _abortAll(error) {
+    const snapshot = [...this._abortSet];
+    for (const ra of snapshot) {
+      ra._abort(error);
+    }
+  }
+}
+
+// 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({
+    externalClientSpecifier,
+    transports,
+    defaultTimeout
+  }) {
+    super();
+    this.externalClient = externalClientSpecifier;
+    this.cuid = nanoid4();
+    this._defaultTimeout = defaultTimeout ?? DEFAULT_TRANSPORT_TIMEOUT;
+    for (const def of transports) {
+      if (def.type === "ws" /* ws */) {
+        this.transportManager.addTransport(new TransportWebSocket(def, {
+          onIncomingActionDataJson: (json) => {
+            for (const l of this._incomingActionDataListeners)
+              l(json);
+          }
+        }));
+      } else if (def.type === "http" /* http */) {
+        this.transportManager.addTransport(new TransportHttp(def));
+      } else if (def.type === "custom" /* custom */) {
+        this.transportManager.addTransport(new TransportCustom(def));
+      } else {
+        throw err_nice_action.fromId("not_implemented" /* not_implemented */, {
+          label: `transport type "${def.type}"`
+        });
+      }
+    }
+  }
+  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 { methods, transport } = await this.transportManager.getReadyTransport({
+      action,
+      localClient,
+      externalClient: this.externalClient
+    });
+    action.context.addRouteItem({
+      runtime: localClient,
+      handler: this.toHandlerRouteItem(transport),
+      time: Date.now()
+    });
+    const runningAction = new RunningAction({ context: action.context, request: action });
+    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 (err4) {
+      runningAction._abort(err4);
+    }
+    return runningAction;
+  }
+  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;
+    }
+  }
+  toJsonObject() {
+    return {
+      type: this.handlerType,
+      client: this.externalClient
+    };
+  }
+  toHandlerRouteItem(transport) {
+    return {
+      type: this.handlerType,
+      client: this.externalClient,
+      transOrd: transport.transOrd,
+      transType: transport.type
+    };
+  }
+}
+var createExternalClientHandler = (config) => {
+  return new ActionExternalClientHandler(config);
+};
 export {
+  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,
+  TransportWebSocket,
+  TransportHttp,
+  Transport,
   RuntimeCoordinate,
   RunningAction,
+  ETransportType,
+  ETransportStatus,
   ERunningActionUpdateType,
   ERunningActionState,
   ERunningActionFinishedType,
+  EErrId_NiceTransport_WebSocket,
+  EErrId_NiceTransport,
   EErrId_NiceAction,
+  EActionProgressType,
+  EActionPayloadType,
   ActionSchema,
   ActionRuntime,
   ActionRootDomain,