@nice-code/action 0.4.11 → 0.5.1

package/build/index.js

@@ -1,2588 +1,246 @@
-// 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
-        });
-      }
-    }
-    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
+// 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 } : {}
         });
-      }
-      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 (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 } : {}
             });
           }
-          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);
+        } 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) } : {}
+          });
         }
-        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;
   }
-  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;
+  _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;
     }
-  }
-  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();
+    const prefix = PRETTY_PREFIX[event] ?? `[${event}]`;
+    const suffix = Object.keys(data).length > 0 ? `  ${formatPrettyData(data)}` : "";
+    logger(`${prefix} ${actionPath}  cuid=${cuid}${suffix}`);
   }
 }
-var createExternalClientHandler = (config) => {
-  return new ActionExternalClientHandler(config);
+var PRETTY_PREFIX = {
+  started: "[nice-action] ►",
+  progress: "[nice-action]  ",
+  success: "[nice-action] ✓",
+  failed: "[nice-action] ✗",
+  aborted: "[nice-action] ○"
 };
-// 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 */
-    };
+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);
   }
-  return {
-    status: "uninitialized" /* uninitialized */
-  };
 }
-
-// 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
-      };
+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);
     }
-    return {
-      status: "ready" /* ready */,
-      readyData: this._finalizeTransportMethods(transportStatusInfo.readyData)
-    };
   }
+  return err;
 }
-
-// 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
-    };
-  }
+function defaultConsoleLogger(message) {
+  console.log(message);
 }
-
-// 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"
-    };
+// src/devtools/core/ActionDevtoolsCore.ts
+function serializeErrorForDisplay(error) {
+  if (error != null && typeof error === "object" && error.name === "NiceError" && typeof error.toJsonObject === "function") {
+    return error.toJsonObject();
   }
+  return error;
 }
-// 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) {
+function extractRouting(context) {
+  return (context?.routing ?? []).map((item) => {
+    const handler = item.handler;
+    const isExternal = handler?.type === "external";
     return {
-      sendActionData: (input) => {
-        const request = methods.createRequest(input);
-        this.send({ ...input, params: { request }, runningAction: input.runningAction }).catch((err4) => input.runningAction._abort(err4));
+      runtime: {
+        envId: item.runtime?.envId ?? "unknown",
+        perId: item.runtime?.perId,
+        insId: item.runtime?.insId
       },
-      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();
-    }
-  }
-}
-
-// 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)}`
+      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
     };
-  }
+  });
 }
-// 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;
-  }
+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/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)
-          };
+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
         };
-        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)
+        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 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);
+          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 { ...base, status: "success", output: result?.output, outputHash };
           }
-        ]);
-      }
-      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);
-        }
+          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.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/Transport/WebSocket/WebSocketTransport.ts
-class WebSocketTransport extends Transport {
-  options;
-  type = "ws" /* ws */;
-  constructor(options) {
-    super();
-    this.options = options;
+  getEntries() {
+    return this._entries;
   }
-  static create(options) {
-    return new WebSocketTransport({ ...options, mode: "socket" });
+  subscribe(listener) {
+    this._listeners.add(listener);
+    listener(this._entries);
+    return () => {
+      this._listeners.delete(listener);
+    };
   }
-  static createAdvanced(options) {
-    return new WebSocketTransport({ ...options, mode: "advanced" });
+  clear() {
+    this._entries = [];
+    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);
+  _updateEntry(cuid, updater) {
+    this._entries = this._entries.map((e) => e.cuid === cuid ? updater(e) : e);
+    this._notify();
   }
-  getRouteInfo(input) {
-    if (this.options.getRouteInfo != null)
-      return this.options.getRouteInfo(input);
-    return {
-      type: "ws" /* ws */,
-      summary: "ws"
-    };
+  _notify() {
+    const snapshot = this._entries;
+    for (const listener of this._listeners)
+      listener(snapshot);
   }
 }
 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,
-  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
+  ActionServerDevtools,
+  ActionDevtoolsCore
 };