@nice-code/action 0.0.21 → 0.1.0

package/build/index.js

@@ -30,47 +30,76 @@ var __toESM = (mod, isNodeMode, target) => {
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 
-// src/ActionRequestResponse/ActionRequester/NiceActionRequester.ts
-class NiceActionRequester {
-  cases = [];
-  _defaultRequester;
-  async handleAction(action) {
-    for (const actionCase of this.cases) {
-      if (!actionCase._matcher(action))
-        continue;
-      return await actionCase._requester(action);
-    }
-    if (this._defaultRequester) {
-      return await this._defaultRequester(action);
-    }
-    throw new Error(`No handler found for action "${action.coreAction.id}" in domain "${action.coreAction.domain}"`);
-  }
-  forDomain(domain, handler) {
-    this.cases.push({
-      _matcher: (action) => domain.isExactActionDomain(action),
-      _requester: handler
-    });
-    return this;
-  }
-  forActionId(domain, id, handler) {
-    this.cases.push({
-      _matcher: (action) => domain.isExactActionDomain(action) && action.coreAction.id === id,
-      _requester: handler
-    });
-    return this;
-  }
-  forActionIds(domain, ids, handler) {
-    this.cases.push({
-      _matcher: (action) => domain.isExactActionDomain(action) && ids.includes(action.coreAction.id),
-      _requester: handler
-    });
-    return this;
-  }
-  setDefaultHandler(handler) {
-    this._defaultRequester = handler;
-    return this;
-  }
+// ../../node_modules/.bun/std-env@4.1.0/node_modules/std-env/dist/index.mjs
+var e = globalThis.process?.env || Object.create(null);
+var t = globalThis.process || { env: e };
+var n = t !== undefined && t.env && t.env.NODE_ENV || undefined;
+var r = [[`claude`, [`CLAUDECODE`, `CLAUDE_CODE`]], [`replit`, [`REPL_ID`]], [`gemini`, [`GEMINI_CLI`]], [`codex`, [`CODEX_SANDBOX`, `CODEX_THREAD_ID`]], [`opencode`, [`OPENCODE`]], [`pi`, [i(`PATH`, /\.pi[\\/]agent/)]], [`auggie`, [`AUGMENT_AGENT`]], [`goose`, [`GOOSE_PROVIDER`]], [`devin`, [i(`EDITOR`, /devin/)]], [`cursor`, [`CURSOR_AGENT`]], [`kiro`, [i(`TERM_PROGRAM`, /kiro/)]]];
+function i(t2, n2) {
+  return () => {
+    let r2 = e[t2];
+    return r2 ? n2.test(r2) : false;
+  };
 }
+function a() {
+  let t2 = e.AI_AGENT;
+  if (t2)
+    return { name: t2.toLowerCase() };
+  for (let [t3, n2] of r)
+    for (let r2 of n2)
+      if (typeof r2 == `string` ? e[r2] : r2())
+        return { name: t3 };
+  return {};
+}
+var o = a();
+var s = o.name;
+var c = !!o.name;
+var l = [[`APPVEYOR`], [`AWS_AMPLIFY`, `AWS_APP_ID`, { ci: true }], [`AZURE_PIPELINES`, `SYSTEM_TEAMFOUNDATIONCOLLECTIONURI`], [`AZURE_STATIC`, `INPUT_AZURE_STATIC_WEB_APPS_API_TOKEN`], [`APPCIRCLE`, `AC_APPCIRCLE`], [`BAMBOO`, `bamboo_planKey`], [`BITBUCKET`, `BITBUCKET_COMMIT`], [`BITRISE`, `BITRISE_IO`], [`BUDDY`, `BUDDY_WORKSPACE_ID`], [`BUILDKITE`], [`CIRCLE`, `CIRCLECI`], [`CIRRUS`, `CIRRUS_CI`], [`CLOUDFLARE_PAGES`, `CF_PAGES`, { ci: true }], [`CLOUDFLARE_WORKERS`, `WORKERS_CI`, { ci: true }], [`GOOGLE_CLOUDRUN`, `K_SERVICE`], [`GOOGLE_CLOUDRUN_JOB`, `CLOUD_RUN_JOB`], [`CODEBUILD`, `CODEBUILD_BUILD_ARN`], [`CODEFRESH`, `CF_BUILD_ID`], [`DRONE`], [`DRONE`, `DRONE_BUILD_EVENT`], [`DSARI`], [`GITHUB_ACTIONS`], [`GITLAB`, `GITLAB_CI`], [`GITLAB`, `CI_MERGE_REQUEST_ID`], [`GOCD`, `GO_PIPELINE_LABEL`], [`LAYERCI`], [`JENKINS`, `JENKINS_URL`], [`HUDSON`, `HUDSON_URL`], [`MAGNUM`], [`NETLIFY`], [`NETLIFY`, `NETLIFY_LOCAL`, { ci: false }], [`NEVERCODE`], [`RENDER`], [`SAIL`, `SAILCI`], [`SEMAPHORE`], [`SCREWDRIVER`], [`SHIPPABLE`], [`SOLANO`, `TDDIUM`], [`STRIDER`], [`TEAMCITY`, `TEAMCITY_VERSION`], [`TRAVIS`], [`VERCEL`, `NOW_BUILDER`], [`VERCEL`, `VERCEL`, { ci: false }], [`VERCEL`, `VERCEL_ENV`, { ci: false }], [`APPCENTER`, `APPCENTER_BUILD_ID`], [`CODESANDBOX`, `CODESANDBOX_SSE`, { ci: false }], [`CODESANDBOX`, `CODESANDBOX_HOST`, { ci: false }], [`STACKBLITZ`], [`STORMKIT`], [`CLEAVR`], [`ZEABUR`], [`CODESPHERE`, `CODESPHERE_APP_ID`, { ci: true }], [`RAILWAY`, `RAILWAY_PROJECT_ID`], [`RAILWAY`, `RAILWAY_SERVICE_ID`], [`DENO-DEPLOY`, `DENO_DEPLOY`], [`DENO-DEPLOY`, `DENO_DEPLOYMENT_ID`], [`FIREBASE_APP_HOSTING`, `FIREBASE_APP_HOSTING`, { ci: true }], [`EDGEONE_PAGES`, `EO_PAGES_CI`, { ci: true }]];
+function u() {
+  for (let t2 of l)
+    if (e[t2[1] || t2[0]])
+      return { name: t2[0].toLowerCase(), ...t2[2] };
+  return e.SHELL === `/bin/jsh` && t.versions?.webcontainer ? { name: `stackblitz`, ci: false } : { name: ``, ci: false };
+}
+var d = u();
+var f = d.name;
+var p = t.platform || ``;
+var m = !!e.CI || d.ci !== false;
+var h = !!t.stdout?.isTTY;
+var _ = !!e.DEBUG;
+var v = n === `test` || !!e.TEST;
+var y = n === `production` || e.MODE === `production`;
+var b = n === `dev` || n === `development` || e.MODE === `development`;
+var x = !!e.MINIMAL || m || v || !h;
+var S = /^win/i.test(p);
+var C = /^linux/i.test(p);
+var w = /^darwin/i.test(p);
+var T = !e.NO_COLOR && (!!e.FORCE_COLOR || (h || S) && e.TERM !== `dumb` || m);
+var E = (t.versions?.node || ``).replace(/^v/, ``) || null;
+var D = Number(E?.split(`.`)[0]) || null;
+var O = !!t?.versions?.node;
+var k = `Bun` in globalThis;
+var A = `Deno` in globalThis;
+var j = `fastly` in globalThis;
+var M = `Netlify` in globalThis;
+var N = `EdgeRuntime` in globalThis;
+var P = globalThis.navigator?.userAgent === `Cloudflare-Workers`;
+var F = [[M, `netlify`], [N, `edge-light`], [P, `workerd`], [j, `fastly`], [A, `deno`], [k, `bun`], [O, `node`]];
+function I() {
+  let e2 = F.find((e3) => e3[0]);
+  if (e2)
+    return { name: e2[1] };
+}
+var L = I();
+var R = L?.name || ``;
+
+// src/ActionRuntimeEnvironment/utils/getAssumedRuntimeEnvironment.ts
+var getAssumedRuntimeInfo = () => {
+  return {
+    assumed: true,
+    runtimeName: R
+  };
+};
 
 // ../../node_modules/.bun/http-status-codes@2.3.0/node_modules/http-status-codes/build/es/legacy.js
 var ACCEPTED = 202;
@@ -385,14 +414,14 @@ var StatusCodes;
 })(StatusCodes || (StatusCodes = {}));
 // ../../node_modules/.bun/http-status-codes@2.3.0/node_modules/http-status-codes/build/es/index.js
 var __assign = function() {
-  __assign = Object.assign || function(t) {
-    for (var s, i = 1, n = arguments.length;i < n; i++) {
-      s = arguments[i];
-      for (var p in s)
-        if (Object.prototype.hasOwnProperty.call(s, p))
-          t[p] = s[p];
-    }
-    return t;
+  __assign = Object.assign || function(t2) {
+    for (var s2, i2 = 1, n2 = arguments.length;i2 < n2; i2++) {
+      s2 = arguments[i2];
+      for (var p2 in s2)
+        if (Object.prototype.hasOwnProperty.call(s2, p2))
+          t2[p2] = s2[p2];
+    }
+    return t2;
   };
   return __assign.apply(this, arguments);
 };
@@ -512,7 +541,7 @@ class NiceError extends Error {
     const otherIds = other.getIds().map(String).sort();
     if (myIds.length !== otherIds.length)
       return false;
-    return myIds.every((id, i) => id === otherIds[i]);
+    return myIds.every((id, i2) => id === otherIds[i2]);
   }
   toJsonObject() {
     const originError = this.originError ? {
@@ -971,17 +1000,17 @@ var err_nice_handler = err_nice.createChildDomain({
 function isNiceErrorObject(obj) {
   if (typeof obj !== "object" || obj == null)
     return false;
-  const o = obj;
-  if (o["name"] !== "NiceError" || typeof o["message"] !== "string" || typeof o["wasntNice"] !== "boolean" || typeof o["httpStatusCode"] !== "number") {
+  const o2 = obj;
+  if (o2["name"] !== "NiceError" || typeof o2["message"] !== "string" || typeof o2["wasntNice"] !== "boolean" || typeof o2["httpStatusCode"] !== "number") {
     return false;
   }
-  const def = o["def"];
+  const def = o2["def"];
   if (typeof def !== "object" || def == null)
     return false;
-  const d = def;
-  if (typeof d["domain"] !== "string" || !Array.isArray(d["allDomains"]))
+  const d2 = def;
+  if (typeof d2["domain"] !== "string" || !Array.isArray(d2["allDomains"]))
     return false;
-  const errorData = o["errorData"];
+  const errorData = o2["errorData"];
   if (errorData != null) {
     if (typeof errorData !== "object")
       return false;
@@ -990,8 +1019,8 @@ function isNiceErrorObject(obj) {
         continue;
       if (typeof entry !== "object")
         return false;
-      const e = entry;
-      const state = e["contextState"];
+      const e2 = entry;
+      const state = e2["contextState"];
       if (state == null || typeof state !== "object")
         return false;
       const kind = state["kind"];
@@ -1006,8 +1035,8 @@ function isNiceErrorObject(obj) {
 function isRegularErrorJsonObject(obj) {
   if (typeof obj !== "object" || obj == null)
     return false;
-  const o = obj;
-  return typeof o["name"] === "string" && typeof o["message"] === "string";
+  const o2 = obj;
+  return typeof o2["name"] === "string" && typeof o2["message"] === "string";
 }
 
 // ../../node_modules/.bun/tslog@4.10.2/node_modules/tslog/esm/urlToObj.js
@@ -1093,8 +1122,8 @@ function formatTemplate(settings, template, values, hideUnsetPlaceholder = false
     }
   };
   const defaultStyle = null;
-  return templateString.replace(/{{(.+?)}}/g, (_, placeholder) => {
-    const value = values[placeholder] != null ? String(values[placeholder]) : hideUnsetPlaceholder ? "" : _;
+  return templateString.replace(/{{(.+?)}}/g, (_2, placeholder) => {
+    const value = values[placeholder] != null ? String(values[placeholder]) : hideUnsetPlaceholder ? "" : _2;
     return settings.stylePrettyLogs ? styleWrap(value, settings?.prettyLogStyles?.[placeholder] ?? defaultStyle) + ansiColorWrap("", prettyLogStyles.reset) : value;
   });
 }
@@ -1343,14 +1372,14 @@ function isRegExp(re) {
 function isObject(arg) {
   return typeof arg === "object" && arg !== null;
 }
-function isError(e) {
-  return isObject(e) && (objectToString(e) === "[object Error]" || e instanceof Error);
+function isError(e2) {
+  return isObject(e2) && (objectToString(e2) === "[object Error]" || e2 instanceof Error);
 }
-function isDate(d) {
-  return isObject(d) && objectToString(d) === "[object Date]";
+function isDate(d2) {
+  return isObject(d2) && objectToString(d2) === "[object Date]";
 }
-function objectToString(o) {
-  return Object.prototype.toString.call(o);
+function objectToString(o2) {
+  return Object.prototype.toString.call(o2);
 }
 function arrayToHash(array) {
   const hash = {};
@@ -1361,9 +1390,9 @@ function arrayToHash(array) {
 }
 function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
   const output = [];
-  for (let i = 0, l = value.length;i < l; ++i) {
-    if (hasOwn(value, String(i))) {
-      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));
+  for (let i2 = 0, l2 = value.length;i2 < l2; ++i2) {
+    if (hasOwn(value, String(i2))) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i2), true));
     } else {
       output.push("");
     }
@@ -1434,8 +1463,8 @@ function formatValue(ctx, value, recurseTimes = 0) {
 ]`];
   }
   if (isFunction(value)) {
-    const n = value.name ? ": " + value.name : "";
-    base = " [Function" + n + "]";
+    const n2 = value.name ? ": " + value.name : "";
+    base = " [Function" + n2 + "]";
   }
   if (isRegExp(value)) {
     base = " " + RegExp.prototype.toString.call(value);
@@ -1561,9 +1590,9 @@ function _extend(origin, add) {
     return origin;
   const clonedAdd = { ...add };
   const keys = Object.keys(add);
-  let i = keys.length;
-  while (i--) {
-    typedOrigin[keys[i]] = clonedAdd[keys[i]];
+  let i2 = keys.length;
+  while (i2--) {
+    typedOrigin[keys[i2]] = clonedAdd[keys[i2]];
   }
   return typedOrigin;
 }
@@ -1576,7 +1605,7 @@ function formatWithOptions(inspectOptions, ...args) {
     _extend(ctx, inspectOptions);
   }
   const first = args[0];
-  let a = 0;
+  let a2 = 0;
   let str = "";
   let join = "";
   if (typeof first === "string") {
@@ -1585,13 +1614,13 @@ function formatWithOptions(inspectOptions, ...args) {
     }
     let tempStr;
     let lastPos = 0;
-    for (let i = 0;i < first.length - 1; i++) {
-      if (first.charCodeAt(i) === 37) {
-        const nextChar = first.charCodeAt(++i);
-        if (a + 1 !== args.length) {
+    for (let i2 = 0;i2 < first.length - 1; i2++) {
+      if (first.charCodeAt(i2) === 37) {
+        const nextChar = first.charCodeAt(++i2);
+        if (a2 + 1 !== args.length) {
           switch (nextChar) {
             case 115: {
-              const tempArg = args[++a];
+              const tempArg = args[++a2];
               if (typeof tempArg === "number") {
                 tempStr = formatPrimitive(ctx, tempArg);
               } else if (typeof tempArg === "bigint") {
@@ -1609,10 +1638,10 @@ function formatWithOptions(inspectOptions, ...args) {
               break;
             }
             case 106:
-              tempStr = jsonStringifyRecursive(args[++a]);
+              tempStr = jsonStringifyRecursive(args[++a2]);
               break;
             case 100: {
-              const tempNum = args[++a];
+              const tempNum = args[++a2];
               if (typeof tempNum === "bigint") {
                 tempStr = formatPrimitive(ctx, tempNum);
               } else if (typeof tempNum === "symbol") {
@@ -1623,10 +1652,10 @@ function formatWithOptions(inspectOptions, ...args) {
               break;
             }
             case 79:
-              tempStr = inspect(args[++a], inspectOptions);
+              tempStr = inspect(args[++a2], inspectOptions);
               break;
             case 111:
-              tempStr = inspect(args[++a], {
+              tempStr = inspect(args[++a2], {
                 ...inspectOptions,
                 showHidden: true,
                 showProxy: true,
@@ -1634,7 +1663,7 @@ function formatWithOptions(inspectOptions, ...args) {
               });
               break;
             case 105: {
-              const tempInteger = args[++a];
+              const tempInteger = args[++a2];
               if (typeof tempInteger === "bigint") {
                 tempStr = formatPrimitive(ctx, tempInteger);
               } else if (typeof tempInteger === "symbol") {
@@ -1645,7 +1674,7 @@ function formatWithOptions(inspectOptions, ...args) {
               break;
             }
             case 102: {
-              const tempFloat = args[++a];
+              const tempFloat = args[++a2];
               if (typeof tempFloat === "symbol") {
                 tempStr = "NaN";
               } else {
@@ -1654,41 +1683,41 @@ function formatWithOptions(inspectOptions, ...args) {
               break;
             }
             case 99:
-              a += 1;
+              a2 += 1;
               tempStr = "";
               break;
             case 37:
-              str += first.slice(lastPos, i);
-              lastPos = i + 1;
+              str += first.slice(lastPos, i2);
+              lastPos = i2 + 1;
               continue;
             default:
               continue;
           }
-          if (lastPos !== i - 1) {
-            str += first.slice(lastPos, i - 1);
+          if (lastPos !== i2 - 1) {
+            str += first.slice(lastPos, i2 - 1);
           }
           str += tempStr;
-          lastPos = i + 1;
+          lastPos = i2 + 1;
         } else if (nextChar === 37) {
-          str += first.slice(lastPos, i);
-          lastPos = i + 1;
+          str += first.slice(lastPos, i2);
+          lastPos = i2 + 1;
         }
       }
     }
     if (lastPos !== 0) {
-      a++;
+      a2++;
       join = " ";
       if (lastPos < first.length) {
         str += first.slice(lastPos);
       }
     }
   }
-  while (a < args.length) {
-    const value = args[a];
+  while (a2 < args.length) {
+    const value = args[a2];
     str += join;
     str += typeof value !== "string" ? inspect(value, inspectOptions) : value;
     join = " ";
-    a++;
+    a2++;
   }
   return str;
 }
@@ -2455,16 +2484,16 @@ error stack:
       return urlToObject(source);
     } else if (source !== null && typeof source === "object") {
       const baseObject = runtime.isError(source) ? this._cloneError(source) : Object.create(Object.getPrototypeOf(source));
-      return Object.getOwnPropertyNames(source).reduce((o, prop) => {
+      return Object.getOwnPropertyNames(source).reduce((o2, prop) => {
         const lookupKey = this.settings?.maskValuesOfKeysCaseInsensitive !== true ? prop : typeof prop === "string" ? prop.toLowerCase() : String(prop).toLowerCase();
-        o[prop] = keys.includes(lookupKey) ? this.settings.maskPlaceholder : (() => {
+        o2[prop] = keys.includes(lookupKey) ? this.settings.maskPlaceholder : (() => {
           try {
             return this._recursiveCloneAndMaskValuesOfKeys(source[prop], keys, seen);
           } catch {
             return null;
           }
         })();
-        return o;
+        return o2;
       }, baseObject);
     } else {
       if (typeof source === "string") {
@@ -2489,14 +2518,14 @@ error stack:
     } else if (source instanceof Date) {
       return new Date(source.getTime());
     } else if (this.isObject(source)) {
-      return Object.getOwnPropertyNames(source).reduce((o, prop) => {
+      return Object.getOwnPropertyNames(source).reduce((o2, prop) => {
         const descriptor = Object.getOwnPropertyDescriptor(source, prop);
         if (descriptor) {
-          Object.defineProperty(o, prop, descriptor);
+          Object.defineProperty(o2, prop, descriptor);
           const value = source[prop];
-          o[prop] = typeof value === "function" ? value() : this._recursiveCloneAndExecuteFunctions(value, seen);
+          o2[prop] = typeof value === "function" ? value() : this._recursiveCloneAndExecuteFunctions(value, seen);
         }
-        return o;
+        return o2;
       }, Object.create(Object.getPrototypeOf(source)));
     } else {
       return source;
@@ -2786,16 +2815,20 @@ var castNiceError = (error) => {
 var EErrId_NiceAction;
 ((EErrId_NiceAction2) => {
   EErrId_NiceAction2["action_id_not_in_domain"] = "action_id_not_in_domain";
-  EErrId_NiceAction2["domain_action_requester_conflict"] = "domain_action_handler_conflict";
+  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["resolver_domain_not_registered"] = "resolver_domain_not_registered";
-  EErrId_NiceAction2["resolver_action_not_registered"] = "resolver_action_not_registered";
-  EErrId_NiceAction2["action_environment_not_found"] = "action_environment_not_found";
+  EErrId_NiceAction2["no_action_execution_handler"] = "no_action_execution_handler";
+  EErrId_NiceAction2["wire_action_not_primed_or_response"] = "wire_action_not_primed_or_response";
+  EErrId_NiceAction2["wire_not_action_data"] = "wire_not_action_data";
+  EErrId_NiceAction2["action_tag_handler_not_found"] = "action_tag_handler_not_found";
   EErrId_NiceAction2["environment_already_registered"] = "environment_already_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",
@@ -2804,11 +2837,11 @@ var err_nice_action = err_nice.createChildDomain({
     ["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_action_handler_conflict" /* domain_action_requester_conflict */]: err({
-      message: ({ domain }) => `Domain "${domain}" already has a handler set. Multiple handlers for the same domain are not allowed.`
+    ["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. Call setActionHandler() before executing actions.`
+      message: ({ domain }) => `Domain "${domain}" has no action handler registered. Set a runtime environment via setRuntimeEnvironment() and add handlers before executing actions.`
     }),
     ["hydration_domain_mismatch" /* hydration_domain_mismatch */]: err({
       message: ({ expected, received }) => `Cannot hydrate action: domain mismatch. Expected "${expected}", got "${received}".`
@@ -2819,440 +2852,158 @@ var err_nice_action = err_nice.createChildDomain({
     ["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}".`
     }),
-    ["resolver_domain_not_registered" /* resolver_domain_not_registered */]: err({
-      message: ({ domain }) => `No resolver registered for domain "${domain}". Add a NiceActionDomainResolver for this domain to the environment.`
+    ["no_action_execution_handler" /* no_action_execution_handler */]: err({
+      message: ({ domain, actionId }) => `No action handler registered for "${actionId}" in domain "${domain}": no execution handler matched.`
+    }),
+    ["wire_action_not_primed_or_response" /* wire_action_not_primed_or_response */]: err({
+      message: ({ domain, actionId, actionState }) => `Cannot handle wire for action "${actionId}" in domain "${domain}": expected action type of "primed" or "resolved", got "${actionState}".`
     }),
-    ["resolver_action_not_registered" /* resolver_action_not_registered */]: err({
-      message: ({ domain, actionId }) => `No resolver registered for action "${actionId}" in domain "${domain}". Call .resolve("${actionId}", fn) on the domain resolver.`
+    ["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 and a "type" property of "primed" or "resolved".`
     }),
-    ["action_environment_not_found" /* action_environment_not_found */]: err({
-      message: ({ domain, envId }) => `No handler or resolver registered with environment id "${envId}" on domain "${domain}".`
+    ["action_tag_handler_not_found" /* action_tag_handler_not_found */]: err({
+      message: ({ domain, matchTag }) => `No handler registered for tag "${matchTag}" on domain "${domain}".`
     }),
     ["environment_already_registered" /* environment_already_registered */]: err({
-      message: ({ domain, envId }) => `Environment "${envId}" is already registered on domain "${domain}". Each environment id may only be registered once.`
+      message: ({ domain, matchTag }) => `Environment "${matchTag}" is already registered on domain "${domain}". Each environment id may only be registered once.`
     }),
     ["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
     })
   }
 });
 
-// ../../node_modules/.bun/nanoid@5.1.9/node_modules/nanoid/url-alphabet/index.js
-var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+// src/NiceAction/NiceAction.enums.ts
+var EActionState;
+((EActionState2) => {
+  EActionState2["empty"] = "empty";
+  EActionState2["primed"] = "primed";
+  EActionState2["resolved"] = "resolved";
+})(EActionState ||= {});
 
-// ../../node_modules/.bun/nanoid@5.1.9/node_modules/nanoid/index.browser.js
-var nanoid = (size = 21) => {
-  let id = "";
-  let bytes = crypto.getRandomValues(new Uint8Array(size |= 0));
-  while (size--) {
-    id += urlAlphabet[bytes[size] & 63];
+// src/NiceAction/NiceActionPrimed.ts
+class NiceActionPrimed {
+  coreAction;
+  _input;
+  type = "primed" /* primed */;
+  domain;
+  allDomains;
+  id;
+  timePrimed;
+  cuid;
+  schema;
+  timeCreated;
+  constructor(coreAction, _input, hydrationData) {
+    this.coreAction = coreAction;
+    this._input = _input;
+    this.domain = coreAction.domain;
+    this.allDomains = coreAction.allDomains;
+    this.id = coreAction.id;
+    this.timePrimed = hydrationData?.timePrimed ?? Date.now();
+    this.cuid = coreAction.cuid;
+    this.schema = coreAction.schema;
+    this.timeCreated = coreAction.timeCreated;
   }
-  return id;
-};
-
-// ../../node_modules/.bun/valibot@1.3.1+8e24a2f921b8d7be/node_modules/valibot/dist/index.mjs
-var store$4;
-function getGlobalConfig(config$1) {
-  return {
-    lang: config$1?.lang ?? store$4?.lang,
-    message: config$1?.message,
-    abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
-    abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
-  };
-}
-var store$3;
-function getGlobalMessage(lang) {
-  return store$3?.get(lang);
-}
-var store$2;
-function getSchemaMessage(lang) {
-  return store$2?.get(lang);
-}
-var store$1;
-function getSpecificMessage(reference, lang) {
-  return store$1?.get(reference)?.get(lang);
-}
-function _stringify(input) {
-  const type = typeof input;
-  if (type === "string")
-    return `"${input}"`;
-  if (type === "number" || type === "bigint" || type === "boolean")
-    return `${input}`;
-  if (type === "object" || type === "function")
-    return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
-  return type;
-}
-function _addIssue(context, label, dataset, config$1, other) {
-  const input = other && "input" in other ? other.input : dataset.value;
-  const expected = other?.expected ?? context.expects ?? null;
-  const received = other?.received ?? /* @__PURE__ */ _stringify(input);
-  const issue = {
-    kind: context.kind,
-    type: context.type,
-    input,
-    expected,
-    received,
-    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
-    requirement: context.requirement,
-    path: other?.path,
-    issues: other?.issues,
-    lang: config$1.lang,
-    abortEarly: config$1.abortEarly,
-    abortPipeEarly: config$1.abortPipeEarly
-  };
-  const isSchema = context.kind === "schema";
-  const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
-  if (message$1 !== undefined)
-    issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
-  if (isSchema)
-    dataset.typed = false;
-  if (dataset.issues)
-    dataset.issues.push(issue);
-  else
-    dataset.issues = [issue];
-}
-function _getStandardProps(context) {
-  return {
-    version: 1,
-    vendor: "valibot",
-    validate(value$1) {
-      return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
-    }
-  };
-}
-function includes(requirement, message$1) {
-  const expects = /* @__PURE__ */ _stringify(requirement);
-  return {
-    kind: "validation",
-    type: "includes",
-    reference: includes,
-    async: false,
-    expects,
-    requirement,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (dataset.typed && !dataset.value.includes(this.requirement))
-        _addIssue(this, "content", dataset, config$1, { received: `!${expects}` });
-      return dataset;
-    }
-  };
-}
-function length(requirement, message$1) {
-  return {
-    kind: "validation",
-    type: "length",
-    reference: length,
-    async: false,
-    expects: `${requirement}`,
-    requirement,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (dataset.typed && dataset.value.length !== this.requirement)
-        _addIssue(this, "length", dataset, config$1, { received: `${dataset.value.length}` });
-      return dataset;
-    }
-  };
-}
-var _LruCache = class {
-  constructor(config$1) {
-    this.refCount = 0;
-    this.maxSize = config$1?.maxSize ?? 1000;
-    this.maxAge = config$1?.maxAge ?? Infinity;
-    this.hasMaxAge = isFinite(this.maxAge);
-  }
-  #stringify(input) {
-    const type = typeof input;
-    if (type === "string")
-      return `"${input}"`;
-    if (type === "number" || type === "boolean")
-      return `${input}`;
-    if (type === "bigint")
-      return `${input}n`;
-    if (type === "object" || type === "function") {
-      if (input) {
-        this.refIds ??= /* @__PURE__ */ new WeakMap;
-        let id = this.refIds.get(input);
-        if (!id) {
-          id = ++this.refCount;
-          this.refIds.set(input, id);
-        }
-        return `#${id}`;
-      }
-      return "null";
-    }
-    return type;
+  get input() {
+    return this._input;
   }
-  key(input, config$1 = {}) {
-    return `${this.#stringify(input)}|${this.#stringify(config$1.lang)}|${this.#stringify(config$1.message)}|${this.#stringify(config$1.abortEarly)}|${this.#stringify(config$1.abortPipeEarly)}`;
+  getEnvironmentMeta() {
+    return this.coreAction.actionDomain.getEnvironmentMeta();
   }
-  get(key) {
-    if (!this.store)
-      return;
-    const entry = this.store.get(key);
-    if (!entry)
-      return;
-    if (this.hasMaxAge && Date.now() - entry[1] > this.maxAge) {
-      this.store.delete(key);
-      return;
-    }
-    this.store.delete(key);
-    this.store.set(key, entry);
-    return entry[0];
+  toJsonObject() {
+    return {
+      ...this.coreAction.toJsonObject(),
+      type: "primed" /* primed */,
+      input: this.coreAction.schema.serializeInput(this.input),
+      timePrimed: this.timePrimed
+    };
   }
-  set(key, value$1) {
-    this.store ??= /* @__PURE__ */ new Map;
-    this.store.delete(key);
-    const timestamp = this.hasMaxAge ? Date.now() : 0;
-    this.store.set(key, [value$1, timestamp]);
-    if (this.store.size > this.maxSize)
-      this.store.delete(this.store.keys().next().value);
+  toJsonString() {
+    return JSON.stringify(this.toJsonObject());
   }
-  clear() {
-    this.store?.clear();
+  hydratePrimeJson(wire) {
+    return this.coreAction.actionDomain.hydratePrimed(wire);
   }
-};
-function getFallback(schema, dataset, config$1) {
-  return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
-}
-function getDefault(schema, dataset, config$1) {
-  return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
-}
-function array(item, message$1) {
-  return {
-    kind: "schema",
-    type: "array",
-    reference: array,
-    expects: "Array",
-    async: false,
-    item,
-    message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config$1) {
-      const input = dataset.value;
-      if (Array.isArray(input)) {
-        dataset.typed = true;
-        dataset.value = [];
-        for (let key = 0;key < input.length; key++) {
-          const value$1 = input[key];
-          const itemDataset = this.item["~run"]({ value: value$1 }, config$1);
-          if (itemDataset.issues) {
-            const pathItem = {
-              type: "array",
-              origin: "value",
-              input,
-              key,
-              value: value$1
-            };
-            for (const issue of itemDataset.issues) {
-              if (issue.path)
-                issue.path.unshift(pathItem);
-              else
-                issue.path = [pathItem];
-              dataset.issues?.push(issue);
-            }
-            if (!dataset.issues)
-              dataset.issues = itemDataset.issues;
-            if (config$1.abortEarly) {
-              dataset.typed = false;
-              break;
-            }
-          }
-          if (!itemDataset.typed)
-            dataset.typed = false;
-          dataset.value.push(itemDataset.value);
-        }
-      } else
-        _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
-  };
-}
-function literal(literal_, message$1) {
-  return {
-    kind: "schema",
-    type: "literal",
-    reference: literal,
-    expects: /* @__PURE__ */ _stringify(literal_),
-    async: false,
-    literal: literal_,
-    message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config$1) {
-      if (dataset.value === this.literal)
-        dataset.typed = true;
-      else
-        _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
-  };
-}
-function nullish(wrapped, default_) {
-  return {
-    kind: "schema",
-    type: "nullish",
-    reference: nullish,
-    expects: `(${wrapped.expects} | null | undefined)`,
-    async: false,
-    wrapped,
-    default: default_,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config$1) {
-      if (dataset.value === null || dataset.value === undefined) {
-        if (this.default !== undefined)
-          dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
-        if (dataset.value === null || dataset.value === undefined) {
-          dataset.typed = true;
-          return dataset;
-        }
-      }
-      return this.wrapped["~run"](dataset, config$1);
-    }
-  };
-}
-function object(entries$1, message$1) {
-  return {
-    kind: "schema",
-    type: "object",
-    reference: object,
-    expects: "Object",
-    async: false,
-    entries: entries$1,
-    message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config$1) {
-      const input = dataset.value;
-      if (input && typeof input === "object") {
-        dataset.typed = true;
-        dataset.value = {};
-        for (const key in this.entries) {
-          const valueSchema = this.entries[key];
-          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== undefined) {
-            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
-            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
-            if (valueDataset.issues) {
-              const pathItem = {
-                type: "object",
-                origin: "value",
-                input,
-                key,
-                value: value$1
-              };
-              for (const issue of valueDataset.issues) {
-                if (issue.path)
-                  issue.path.unshift(pathItem);
-                else
-                  issue.path = [pathItem];
-                dataset.issues?.push(issue);
-              }
-              if (!dataset.issues)
-                dataset.issues = valueDataset.issues;
-              if (config$1.abortEarly) {
-                dataset.typed = false;
-                break;
-              }
-            }
-            if (!valueDataset.typed)
-              dataset.typed = false;
-            dataset.value[key] = valueDataset.value;
-          } else if (valueSchema.fallback !== undefined)
-            dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
-          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
-            _addIssue(this, "key", dataset, config$1, {
-              input: undefined,
-              expected: `"${key}"`,
-              path: [{
-                type: "object",
-                origin: "key",
-                input,
-                key,
-                value: input[key]
-              }]
-            });
-            if (config$1.abortEarly)
-              break;
-          }
-        }
-      } else
-        _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
-  };
-}
-function string(message$1) {
-  return {
-    kind: "schema",
-    type: "string",
-    reference: string,
-    expects: "string",
-    async: false,
-    message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config$1) {
-      if (typeof dataset.value === "string")
-        dataset.typed = true;
-      else
-        _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
-  };
-}
-function pipe(...pipe$1) {
-  return {
-    ...pipe$1[0],
-    pipe: pipe$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config$1) {
-      for (const item of pipe$1)
-        if (item.kind !== "metadata") {
-          if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
-            dataset.typed = false;
-            break;
-          }
-          if (!dataset.issues || !config$1.abortEarly && !config$1.abortPipeEarly)
-            dataset = item["~run"](dataset, config$1);
-        }
-      return dataset;
+  hydrateResponseJson(wire) {
+    return this.coreAction.actionDomain.hydrateResponse(wire);
+  }
+  errorResponse(err3) {
+    return new NiceActionResponse(this, { ok: false, error: err3 });
+  }
+  toHttpResponse() {
+    return new Response(this.toJsonString(), {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  setResponse(...args) {
+    const output = args[0];
+    const finalOutput = this.coreAction.schema.validateOutput(output, {
+      domain: this.domain,
+      actionId: this.id
+    });
+    return new NiceActionResponse(this, { ok: true, output: finalOutput });
+  }
+  async execute(meta) {
+    return this.coreAction.actionDomain._executeAction(this, { actionMeta: meta ?? {} });
+  }
+  async executeSafe(meta) {
+    try {
+      const value = await this.execute(meta);
+      return { ok: true, output: value };
+    } catch (error) {
+      return { ok: false, error };
     }
-  };
+  }
 }
 
 // src/NiceAction/NiceActionResponse.ts
 class NiceActionResponse {
-  type = "response" /* response */;
+  type = "resolved" /* resolved */;
   domain;
   allDomains;
   id;
   primed;
   result;
   timeResponded;
+  cuid;
+  schema;
+  timeCreated;
   constructor(primed, result, hydrationData) {
     this.primed = primed;
     this.result = result;
     this.domain = primed.coreAction.domain;
     this.allDomains = primed.coreAction.allDomains;
     this.id = primed.coreAction.id;
+    this.cuid = primed.coreAction.cuid;
+    this.schema = primed.coreAction.schema;
+    this.timeCreated = primed.coreAction.timeCreated;
     this.timeResponded = hydrationData?.timeResponded ?? Date.now();
   }
+  getEnvironmentMeta() {
+    return this.primed.coreAction.actionDomain.getEnvironmentMeta();
+  }
   toJsonObject() {
     const base = this.primed.toJsonObject();
     if (this.result.ok) {
       return {
         ...base,
-        type: "response" /* response */,
+        type: "resolved" /* resolved */,
         ok: true,
         output: this.primed.coreAction.schema.serializeOutput(this.result.output),
         timeResponded: this.timeResponded
@@ -3260,7 +3011,7 @@ class NiceActionResponse {
     }
     return {
       ...base,
-      type: "response" /* response */,
+      type: "resolved" /* resolved */,
       ok: false,
       error: this.result.error.toJsonObject(),
       timeResponded: this.timeResponded
@@ -3269,9 +3020,12 @@ class NiceActionResponse {
   toJsonString() {
     return JSON.stringify(this.toJsonObject());
   }
-  toHttpResponse() {
+  hydrateResponseJson(wire) {
+    return this.primed.hydrateResponseJson(wire);
+  }
+  toHttpResponse({ useErrorStatus = true } = {}) {
     return new Response(this.toJsonString(), {
-      status: 200,
+      status: this.result.ok ? 200 : useErrorStatus ? this.result.error.httpStatusCode : 500,
       headers: { "Content-Type": "application/json" }
     });
   }
@@ -3286,78 +3040,38 @@ function hydrateNiceActionResponse(wire, coreAction) {
   return new NiceActionResponse(primed, { ok: false, error: castNiceError(wire.error) }, { timeResponded: wire.timeResponded });
 }
 
-// src/NiceAction/NiceActionPrimed.ts
-class NiceActionPrimed {
-  coreAction;
-  input;
-  type = "primed" /* primed */;
-  domain;
-  allDomains;
-  id;
-  timePrimed;
-  constructor(coreAction, input, hydrationData) {
-    this.coreAction = coreAction;
-    this.input = input;
-    this.domain = coreAction.domain;
-    this.allDomains = coreAction.allDomains;
-    this.id = coreAction.id;
-    this.timePrimed = hydrationData?.timePrimed ?? Date.now();
-  }
-  toJsonObject() {
-    return {
-      ...this.coreAction.toJsonObject(),
-      type: "primed" /* primed */,
-      input: this.coreAction.schema.serializeInput(this.input),
-      timePrimed: this.timePrimed
-    };
-  }
-  toJsonString() {
-    return JSON.stringify(this.toJsonObject());
-  }
-  toHttpResponse() {
-    return new Response(this.toJsonString(), {
-      status: 200,
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-  setOutput(output) {
-    return new NiceActionResponse(this, { ok: true, output });
-  }
-  processResponse(wire) {
-    if (!wire.ok) {
-      throw castNiceError(wire.error);
-    }
-    return this.coreAction.schema.deserializeOutput(wire.output);
-  }
-  async execute(envId) {
-    return this.coreAction._actionDomain._dispatchAction(this, envId);
-  }
-  async executeSafe(envId) {
-    try {
-      const value = await this.execute(envId);
-      return { ok: true, output: value };
-    } catch (error) {
-      return { ok: false, error };
-    }
+// src/utils/isActionResponseJsonObject.ts
+var isActionResponseJsonObject = (obj) => {
+  return typeof obj === "object" && obj !== null && typeof obj.domain === "string" && typeof obj.id === "string" && "input" in obj && (("output" in obj) || ("error" in obj)) && typeof obj.ok === "boolean" && obj.type === "resolved" /* resolved */;
+};
+
+// ../../node_modules/.bun/nanoid@5.1.9/node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// ../../node_modules/.bun/nanoid@5.1.9/node_modules/nanoid/index.browser.js
+var nanoid = (size = 21) => {
+  let id = "";
+  let bytes = crypto.getRandomValues(new Uint8Array(size |= 0));
+  while (size--) {
+    id += urlAlphabet[bytes[size] & 63];
   }
-}
+  return id;
+};
 
 // src/NiceAction/NiceAction.ts
 class NiceAction {
   actionDomain;
   schema;
-  id;
   type = "empty" /* empty */;
+  id;
   domain;
   allDomains;
-  _actionDomain;
   timeCreated;
   cuid;
   constructor(actionDomain, schema, id, hydrationData) {
     this.actionDomain = actionDomain;
     this.schema = schema;
     this.id = id;
-    this._actionDomain = actionDomain;
     this.domain = actionDomain.domain;
     this.allDomains = actionDomain.allDomains;
     this.timeCreated = hydrationData?.timeCreated ?? Date.now();
@@ -3382,57 +3096,105 @@ class NiceAction {
       headers: { "Content-Type": "application/json" }
     });
   }
-  toValidationSchema() {
-    return object({
-      domain: literal(this.domain),
-      allDomains: pipe(array(string()), length(this.allDomains.length), includes(this.domain)),
-      id: literal(this.id)
-    });
-  }
   is(action) {
     return action instanceof NiceActionPrimed && action.coreAction.domain === this.domain && action.coreAction.id === this.id;
   }
   prime(input, hydrationData) {
-    return new NiceActionPrimed(this, input, hydrationData);
+    const validatedInput = this.schema.validateInput(input, {
+      actionId: this.id,
+      domain: this.domain
+    });
+    return new NiceActionPrimed(this, validatedInput, hydrationData);
   }
-  async execute(input, envId) {
-    const primed = new NiceActionPrimed(this, input);
-    return this._actionDomain._dispatchAction(primed, envId);
+  async execute(input, meta) {
+    const primed = this.prime(input);
+    return this.actionDomain._executeAction(primed, { actionMeta: meta ?? {} });
   }
-  async executeSafe(input, envId) {
+  async executeSafe(input, meta) {
     try {
-      const value = await this.execute(input, envId);
+      const value = await this.execute(input, meta);
       return { ok: true, output: value };
     } catch (error) {
       return { ok: false, error };
     }
   }
-  async executeToResponse(input, envId) {
+  async executeToResponse(input, meta) {
     const primed = this.prime(input);
-    const result = await this.executeSafe(input, envId);
+    const result = await primed.executeSafe(meta);
     return new NiceActionResponse(primed, result);
   }
+  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/ActionDomain/NiceActionDomain.ts
-class NiceActionDomain {
+// src/NiceAction/utils/isNiceActionInstance.ts
+function isNiceActionInstance(value) {
+  return value != null && typeof value === "object" && "domain" in value && typeof value.domain === "string" && "id" in value && typeof value.id === "string" && "type" in value && typeof value.type === "string" && ["empty" /* empty */, "primed" /* primed */, "resolved" /* resolved */].includes(value.type);
+}
+
+// src/ActionDomain/NiceActionDomainBase.ts
+class NiceActionDomainBase {
   domain;
   allDomains;
   actions;
   _listeners = [];
-  _requesters = new Map;
-  _responders = new Map;
   constructor(definition) {
     this.domain = definition.domain;
     this.allDomains = definition.allDomains;
     this.actions = definition.actions;
   }
+  addActionListener(listener) {
+    this._listeners.push(listener);
+    return () => {
+      this._listeners = this._listeners.filter((l2) => l2 !== listener);
+    };
+  }
+}
+
+// src/ActionDomain/NiceActionDomain.ts
+class NiceActionDomain extends NiceActionDomainBase {
+  _rootDomain;
+  constructor(definition, {
+    rootDomain
+  }) {
+    super(definition);
+    this._rootDomain = rootDomain;
+  }
+  get rootDomain() {
+    return this._rootDomain;
+  }
+  getEnvironmentMeta() {
+    return this.rootDomain.getEnvironmentMeta();
+  }
   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 NiceActionDomain({
       allDomains: [subDomainDef.domain, ...this.allDomains],
       domain: subDomainDef.domain,
       actions: subDomainDef.actions
-    });
+    }, { rootDomain: this._rootDomain });
   }
   primeUnknown(actionId, input) {
     const action = this.action(actionId).prime(input);
@@ -3451,68 +3213,8 @@ class NiceActionDomain {
     }
     return new NiceAction(this, actionSchema, id, hydrationData);
   }
-  isExactActionDomain(action) {
-    return action instanceof NiceActionPrimed && this.domain === action.domain;
-  }
-  matchAction(action, id) {
-    if (this.isExactActionDomain(action) && action.coreAction.id === id) {
-      return action;
-    }
-    return null;
-  }
-  addActionListener(listener) {
-    this._listeners.push(listener);
-    return () => {
-      this._listeners = this._listeners.filter((l) => l !== listener);
-    };
-  }
-  async _dispatchAction(primed, envId) {
-    if (envId != null) {
-      const envRequester = this._requesters.get(envId);
-      if (envRequester) {
-        const validatedPrimed = await this._withValidatedInput(primed);
-        const result = await envRequester.handleAction(validatedPrimed);
-        for (const listener of this._listeners)
-          await listener(validatedPrimed);
-        return result;
-      }
-      const envResponder = this._responders.get(envId);
-      if (envResponder) {
-        const result = await envResponder._resolvePrimed(primed);
-        for (const listener of this._listeners)
-          await listener(primed);
-        return result;
-      }
-    }
-    const defaultRequester = this._requesters.get(undefined);
-    if (defaultRequester) {
-      const validatedPrimed = await this._withValidatedInput(primed);
-      const result = await defaultRequester.handleAction(validatedPrimed);
-      for (const listener of this._listeners)
-        await listener(validatedPrimed);
-      return result;
-    }
-    const defaultResponder = this._responders.get(undefined);
-    if (defaultResponder) {
-      const result = await defaultResponder._resolvePrimed(primed);
-      for (const listener of this._listeners)
-        await listener(primed);
-      return result;
-    }
-    if (envId != null) {
-      throw err_nice_action.fromId("action_environment_not_found" /* action_environment_not_found */, {
-        domain: this.domain,
-        envId
-      });
-    }
-    throw err_nice_action.fromId("domain_no_handler" /* domain_no_handler */, { domain: this.domain });
-  }
-  async _withValidatedInput(primed) {
-    const validatedInput = await primed.coreAction.schema.validateInput(primed.input, {
-      domain: this.domain,
-      actionId: primed.coreAction.id
-    });
-    return primed.coreAction.prime(validatedInput);
+  isDomainAction(action) {
+    return isNiceActionInstance(action) && action.domain === this.domain;
   }
   hydratePrimed(serialized) {
     if (serialized.type !== "primed" /* primed */) {
@@ -3538,15 +3240,15 @@ class NiceActionDomain {
       cuid: serialized.cuid,
       timeCreated: serialized.timeCreated
     });
-    const rawInput = coreAction.schema.deserializeInput(serialized.input);
+    const rawInput = coreAction.validateInput(coreAction.deserializeInput(serialized.input));
     return new NiceActionPrimed(coreAction, rawInput, {
       timePrimed: serialized.timePrimed
     });
   }
   hydrateResponse(serialized) {
-    if (serialized.type !== "response" /* response */) {
+    if (serialized.type !== "resolved" /* resolved */) {
       throw err_nice_action.fromId("hydration_action_state_mismatch" /* hydration_action_state_mismatch */, {
-        expected: "response" /* response */,
+        expected: "resolved" /* resolved */,
         received: serialized.type
       });
     }
@@ -3569,124 +3271,724 @@ class NiceActionDomain {
     });
     return hydrateNiceActionResponse(serialized, coreAction);
   }
-  setActionRequester(options, handler) {
-    const envId = options?.envId;
-    if (this._requesters.has(envId)) {
-      if (envId != null) {
-        throw err_nice_action.fromId("environment_already_registered" /* environment_already_registered */, {
-          domain: this.domain,
-          envId
-        });
-      }
-      throw err_nice_action.fromId("domain_action_handler_conflict" /* domain_action_requester_conflict */, {
-        domain: this.domain
+  async _executeAction(primed, {
+    actionMeta,
+    listeners
+  }) {
+    const allListeners = [
+      ...listeners ?? [],
+      ...this._listeners
+    ];
+    const output = await this._rootDomain._executeAction(primed, {
+      actionMeta,
+      listeners: allListeners
+    });
+    return output;
+  }
+}
+
+// src/ActionDomain/RootDomain/NiceActionRootDomain.ts
+class NiceActionRootDomain extends NiceActionDomainBase {
+  domainDefinition;
+  _runtimeEnvironment;
+  constructor(domainDefinition) {
+    const domainId = domainDefinition.domain;
+    super({
+      domain: domainId,
+      allDomains: [domainId],
+      actions: {}
+    });
+    this.domainDefinition = domainDefinition;
+  }
+  getEnvironmentMeta() {
+    return {
+      envId: this._runtimeEnvironment?.envId,
+      runtimeInfo: this._runtimeEnvironment?.runtimeInfo ?? getAssumedRuntimeInfo()
+    };
+  }
+  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
       });
     }
-    const h = handler ?? new NiceActionRequester;
-    this._requesters.set(envId, h);
-    return h;
+    return new NiceActionDomain({
+      allDomains: [subDomainDef.domain, ...this.allDomains],
+      domain: subDomainDef.domain,
+      actions: subDomainDef.actions
+    }, { rootDomain: this });
   }
-  registerResponder(resolver, options) {
-    const envId = options?.envId;
-    if (this._responders.has(envId)) {
+  setRuntimeEnvironment(runtime2) {
+    if (this._runtimeEnvironment != null) {
       throw err_nice_action.fromId("environment_already_registered" /* environment_already_registered */, {
         domain: this.domain,
-        envId: envId ?? "(default)"
+        matchTag: this._runtimeEnvironment.envId
       });
     }
-    this._responders.set(envId, resolver);
+    this._runtimeEnvironment = runtime2;
     return this;
   }
+  async _executeAction(primed, {
+    actionMeta,
+    listeners
+  }) {
+    if (this._runtimeEnvironment != null) {
+      const envData = {
+        tag: actionMeta?.tag,
+        meta: actionMeta?.meta,
+        runtime: this.getEnvironmentMeta()
+      };
+      const handler = this._runtimeEnvironment.getHandlerForAction(primed, actionMeta?.tag);
+      const defaultExecution = handler == null ? this._runtimeEnvironment.getDefaultHandler(actionMeta?.tag)?.execution : undefined;
+      if (handler != null || defaultExecution != null) {
+        const allListeners = [...this._listeners, ...listeners ?? []];
+        for (const listener of allListeners) {
+          listener.execution?.(primed, envData);
+        }
+        let response;
+        if (handler != null) {
+          response = await handler.dispatchAction(primed);
+        } else {
+          const rawResult = await defaultExecution(primed, envData);
+          if (rawResult instanceof NiceActionResponse) {
+            response = rawResult;
+          } else if (rawResult != null && isActionResponseJsonObject(rawResult)) {
+            response = primed.coreAction.actionDomain.hydrateResponse(rawResult);
+          } else {
+            response = primed.setResponse(rawResult);
+          }
+        }
+        for (const listener of allListeners) {
+          listener.response?.(response, envData);
+        }
+        if (response.result.ok)
+          return response.result.output;
+        throw response.result.error;
+      }
+    }
+    if (actionMeta.tag != null) {
+      throw err_nice_action.fromId("action_tag_handler_not_found" /* action_tag_handler_not_found */, {
+        domain: this.domain,
+        matchTag: actionMeta.tag
+      });
+    }
+    throw err_nice_action.fromId("domain_no_handler" /* domain_no_handler */, { domain: this.domain });
+  }
 }
 
-// src/ActionDomain/createActionDomain.ts
-var createActionDomain = (definition) => {
-  return new NiceActionDomain({
-    ...definition,
-    allDomains: [definition.domain]
-  });
+// src/ActionDomain/helpers/createRootActionDomain.ts
+var createActionRootDomain = (definition) => {
+  return new NiceActionRootDomain(definition);
 };
-// src/ActionRequestResponse/ActionResponder/NiceActionResponder.ts
-class NiceActionDomainResponder {
-  _domain;
-  _responders = new Map;
-  constructor(domain) {
-    this._domain = domain;
-  }
-  get domainId() {
-    return this._domain.domain;
-  }
-  resolveAction(actionId, fn) {
-    this._responders.set(actionId, fn);
+// src/ActionRuntimeEnvironment/ActionConnect/err_nice_connect.ts
+var err_nice_connect = err_nice_action.createChildDomain({
+  domain: "err_nice_connect",
+  schema: {}
+});
+
+// src/ActionRuntimeEnvironment/ActionConnect/Transport/err_nice_transport.ts
+var EErrId_NiceTransport;
+((EErrId_NiceTransport2) => {
+  EErrId_NiceTransport2["timeout"] = "timeout";
+  EErrId_NiceTransport2["not_found"] = "not_found";
+  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_connect.createChildDomain({
+  domain: "err_nice_transport",
+  schema: {
+    ["timeout" /* timeout */]: err({
+      message: ({ timeout }) => `ActionConnect transport timed out after ${timeout}ms.`
+    }),
+    ["not_found" /* not_found */]: err({
+      message: ({ actionId, routeKey, tag }) => `No connected transport found for action "${actionId}"${routeKey ? ` with route key "${routeKey}"` : ``}${tag ? ` and action tag "${tag}"` : ""}.`
+    }),
+    ["initialization_failed" /* initialization_failed */]: err({
+      message: ({ actionId, routeKey, tag }) => `Transports found for action "${actionId}"${routeKey ? ` with route key "${routeKey}"` : ""}${tag ? ` and action tag "${tag}"` : ""}, but none are ready.`
+    }),
+    ["send_failed" /* send_failed */]: err({
+      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 */]: err({
+      message: ({ actionId }) => `Invalid action response JSON structure for action "${actionId}"`
+    })
+  }
+});
+
+// src/ActionRuntimeEnvironment/ActionConnect/ActionConnect.ts
+var DEFAULT_TIMEOUT = 30000;
+
+class ActionConnect {
+  tag;
+  handlerType = "connect" /* connect */;
+  cuid;
+  _config;
+  _connections = new Map;
+  _connectionByMatchKey = new Map;
+  _handlerKeys = new Set;
+  constructor(connectionConfigs, config = {}) {
+    this.tag = config.tag ?? "_";
+    this.cuid = nanoid();
+    this._config = { requestTimeout: DEFAULT_TIMEOUT, ...config };
+    for (const conn of connectionConfigs) {
+      this._connections.set(conn.routeKey ?? "_", conn);
+    }
+  }
+  get allHandlerKeys() {
+    return [...this._handlerKeys];
+  }
+  routeDomain(domain, route = {}) {
+    this._connectionByMatchKey.set(`${domain.domain}::_`, route);
+    this._handlerKeys.add(`${this.tag}::${domain.domain}::_`);
     return this;
   }
-  async _resolvePrimed(primed) {
-    const resolver = this._responders.get(primed.coreAction.id);
-    if (resolver == null) {
-      throw err_nice_action.fromId("resolver_action_not_registered" /* resolver_action_not_registered */, {
-        domain: primed.domain,
-        actionId: primed.coreAction.id
-      });
+  routeAction(domain, id, route = {}) {
+    this._connectionByMatchKey.set(`${domain.domain}::${id}`, route);
+    this._handlerKeys.add(`${this.tag}::${domain.domain}::${id}`);
+    return this;
+  }
+  routeActionIds(domain, ids, route = {}) {
+    for (const id of ids) {
+      this.routeAction(domain, id, route);
+    }
+    return this;
+  }
+  async dispatchAction(primed) {
+    const route = this._connectionByMatchKey.get(`${primed.domain}::${primed.id}`) ?? this._connectionByMatchKey.get(`${primed.domain}::_`);
+    return this._dispatchViaRoute(primed, route);
+  }
+  disconnect() {
+    for (const conn of this._connections.values()) {
+      conn.disconnect();
+    }
+  }
+  async _dispatchViaRoute(primed, route) {
+    const conn = this._connections.get(route?.routeKey ?? "_");
+    if (conn == null) {
+      return Promise.reject(err_nice_transport.fromId("not_found" /* not_found */, {
+        actionId: primed.id,
+        routeKey: route?.routeKey,
+        tag: this.tag !== "_" ? this.tag : undefined
+      }));
+    }
+    const response = await conn.dispatch(primed, this._config.requestTimeout ?? DEFAULT_TIMEOUT);
+    if (route?.onResponse) {
+      route.onResponse(response);
     }
-    const validatedInput = await primed.coreAction.schema.validateInput(primed.input, {
-      domain: primed.domain,
-      actionId: primed.coreAction.id
-    });
-    const response = await resolver(validatedInput);
     return response;
   }
-  async _dispatch(wire) {
-    const primed = this._domain.hydratePrimed(wire);
-    const resolverFn = this._responders.get(wire.id);
-    if (resolverFn == null) {
-      throw err_nice_action.fromId("resolver_action_not_registered" /* resolver_action_not_registered */, {
-        domain: wire.domain,
-        actionId: wire.id
+}
+// src/ActionRuntimeEnvironment/ActionConnect/Transport/Transport.ts
+class Transport {
+  def;
+  type;
+  requestResolvers = new Map;
+  constructor(def) {
+    this.def = def;
+    this.type = def.type;
+  }
+  get status() {
+    return this._status;
+  }
+  checkAndPrepare() {
+    return this._status;
+  }
+  respond(response) {
+    const resolver = this.requestResolvers.get(response.cuid);
+    if (resolver) {
+      resolver.resolve(response);
+      clearTimeout(resolver.timer);
+      this.requestResolvers.delete(response.cuid);
+    }
+  }
+  makeRequest(primed, connectionDefaultTimeout) {
+    const timeout = this.def.timeout ?? connectionDefaultTimeout;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.requestResolvers.delete(primed.cuid);
+        reject(err_nice_transport.fromId("timeout" /* timeout */, { timeout }));
+      }, timeout);
+      this.requestResolvers.set(primed.cuid, {
+        type: this.type,
+        resolve,
+        reject,
+        timer,
+        primed
       });
-    }
+      this.send(primed).catch((err3) => {
+        this.requestResolvers.delete(primed.cuid);
+        clearTimeout(timer);
+        reject(err3);
+      });
+    });
+  }
+}
+
+// src/ActionRuntimeEnvironment/ActionConnect/Transport/TransportHttp.ts
+class TransportHttp extends Transport {
+  abortControllers = new Map;
+  _status = {
+    status: "ready" /* ready */
+  };
+  async send(primed) {
+    const wire = primed.toJsonObject();
+    const ac = new AbortController;
+    this.abortControllers.set(primed.cuid, ac);
     try {
-      const validatedInput = await primed.coreAction.schema.validateInput(primed.input, {
-        domain: wire.domain,
-        actionId: wire.id
+      const res = await fetch(this.def.url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(wire),
+        signal: ac.signal
       });
-      const output = await resolverFn(validatedInput);
-      return new NiceActionResponse(primed, {
-        ok: true,
-        output
+      if (!res.ok) {
+        try {
+          const jsonData = await res.json();
+          if (isActionResponseJsonObject(jsonData)) {
+            this.respond(primed.coreAction.actionDomain.hydrateResponse(jsonData));
+          } else {
+            this.respond(primed.errorResponse(castNiceError(jsonData)));
+          }
+          return;
+        } catch (e2) {
+          throw err_nice_transport.fromId("send_failed" /* send_failed */, {
+            actionId: primed.id,
+            httpStatusCode: res.status,
+            message: e2.message
+          }).withOriginError(e2);
+        }
+      }
+      const json = await res.json();
+      if (!isActionResponseJsonObject(json)) {
+        throw err_nice_transport.fromId("invalid_action_response" /* invalid_action_response */, {
+          actionId: primed.id
+        });
+      }
+      this.respond(primed.coreAction.actionDomain.hydrateResponse(json));
+    } finally {
+      this.abortControllers.delete(primed.cuid);
+    }
+  }
+  disconnect() {
+    for (const [, ac] of this.abortControllers) {
+      ac.abort();
+    }
+    this.abortControllers.clear();
+  }
+}
+
+// src/ActionRuntimeEnvironment/ActionConnect/Transport/err_nice_transport_ws.ts
+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 */]: err({
+      message: () => `WebSocket transport disconnected.`
+    }),
+    ["ws_create_failed" /* ws_create_failed */]: err({
+      message: ({ originalError }) => `Failed to create WebSocket transport.${originalError ? ` Original error: ${originalError.message}` : ""}`
+    }),
+    ["ws_error" /* ws_error */]: err({
+      message: ({ originalError }) => `WebSocket transport error.${originalError ? ` Original error: ${originalError.message}` : ""}`
+    })
+  }
+});
+
+// src/ActionRuntimeEnvironment/ActionConnect/Transport/TransportWebSocket.ts
+class TransportWebSocket extends Transport {
+  websocket;
+  _status = { status: "uninitialized" /* uninitialized */ };
+  constructor(def) {
+    super(def);
+  }
+  checkAndPrepare() {
+    if (this._status.status === "uninitialized" /* uninitialized */) {
+      this._status = this.startInitializing();
+    }
+    return this._status;
+  }
+  startInitializing() {
+    let resolveInit;
+    const waitForInitialization = new Promise((resolve) => {
+      resolveInit = resolve;
+    });
+    this._connect(resolveInit);
+    return {
+      status: "initializing" /* initializing */,
+      timeStarted: Date.now(),
+      waitForInitialization
+    };
+  }
+  handleMessage(data) {
+    let json;
+    try {
+      json = JSON.parse(data);
+    } catch {
+      return;
+    }
+    if (!isActionResponseJsonObject(json)) {
+      return;
+    }
+    const pending = this.requestResolvers.get(json.cuid);
+    if (pending == null) {
+      return;
+    }
+    this.respond(pending.primed.coreAction.actionDomain.hydrateResponse(json));
+  }
+  rejectPendingWebSocketRequests(error) {
+    for (const [, pending] of this.requestResolvers) {
+      if (pending.type === this.type) {
+        clearTimeout(pending.timer);
+        pending.reject(error);
+        this.requestResolvers.delete(pending.primed.cuid);
+      }
+    }
+  }
+  async _connect(onInitialized) {
+    let initNotified = false;
+    const notifyInit = (newStatus) => {
+      if (!initNotified) {
+        initNotified = true;
+        onInitialized({ transport: this, newStatus });
+      }
+    };
+    try {
+      this.websocket = await this.def.createWebSocket();
+    } catch (e2) {
+      console.error("Failed to create WebSocket:", e2);
+      const error = err_nice_transport_ws.fromId("ws_create_failed" /* ws_create_failed */, {
+        originalError: e2 instanceof Error ? e2 : undefined
       });
-    } catch (e) {
-      return new NiceActionResponse(primed, {
-        ok: false,
-        error: castNiceError(e)
+      const failedStatus = {
+        status: "failed" /* failed */,
+        error,
+        timeFailed: Date.now()
+      };
+      this._status = failedStatus;
+      notifyInit(failedStatus);
+      this.rejectPendingWebSocketRequests(error);
+      return;
+    }
+    this.websocket.addEventListener("open", () => {
+      const readyStatus = {
+        status: "ready" /* ready */
+      };
+      this._status = readyStatus;
+      notifyInit(readyStatus);
+    });
+    this.websocket.addEventListener("message", (event) => {
+      if (typeof event.data === "string") {
+        this.handleMessage(event.data);
+      }
+    });
+    this.websocket.addEventListener("close", (event) => {
+      if (this._status.status === "uninitialized" /* uninitialized */)
+        return;
+      if (this._status.status !== "failed" /* failed */) {
+        console.error("WebSocket closed:", event);
+        const error = err_nice_transport_ws.fromId("ws_disconnected" /* ws_disconnected */);
+        const failedStatus = {
+          status: "failed" /* failed */,
+          error,
+          timeFailed: Date.now()
+        };
+        this._status = failedStatus;
+        notifyInit(failedStatus);
+        this.rejectPendingWebSocketRequests(error);
+      }
+    });
+    this.websocket.addEventListener("error", (event) => {
+      console.error("WebSocket error:", event);
+      const error = err_nice_transport_ws.fromId("ws_error" /* ws_error */, {
+        originalError: event instanceof Error ? event : undefined
       });
+      const failedStatus = {
+        status: "failed" /* failed */,
+        error,
+        timeFailed: Date.now()
+      };
+      this._status = failedStatus;
+      notifyInit(failedStatus);
+      this.rejectPendingWebSocketRequests(error);
+    });
+  }
+  async send(primed) {
+    if (this.websocket == null) {
+      throw err_nice_transport_ws.fromId("ws_disconnected" /* ws_disconnected */);
     }
+    this.websocket.send(primed.toJsonString());
+  }
+  disconnect() {
+    const error = err_nice_transport_ws.fromId("ws_disconnected" /* ws_disconnected */);
+    this._status = { status: "uninitialized" /* uninitialized */ };
+    this.rejectPendingWebSocketRequests(error);
+    this.websocket?.close();
+    this.websocket = undefined;
   }
 }
-function createDomainResolver(domain) {
-  return new NiceActionDomainResponder(domain);
+// src/ActionRuntimeEnvironment/ActionConnect/ConnectionConfig/ConnectionConfig.ts
+class ConnectionConfig {
+  config;
+  routeKey;
+  _transports = [];
+  constructor(input, routeKey) {
+    this.config = input;
+    this.routeKey = routeKey;
+    for (const def of this.config.transports) {
+      if (def.type === "ws" /* ws */) {
+        this._transports.push(new TransportWebSocket(def));
+      } else if (def.type === "http" /* http */) {
+        this._transports.push(new TransportHttp(def));
+      } else {
+        throw new Error(`Unsupported transport type: ${def.type}`);
+      }
+    }
+  }
+  get connected() {
+    return this._transports.some((t2) => t2.status.status === "ready" /* ready */);
+  }
+  async dispatch(primed, defaultTimeout) {
+    const timeout = this.config.defaultTimeout ?? defaultTimeout;
+    const initializingWaiters = [];
+    for (const transport of this._transports) {
+      const statusInfo = transport.checkAndPrepare();
+      if (statusInfo.status === "ready" /* ready */) {
+        return transport.makeRequest(primed, timeout);
+      }
+      if (statusInfo.status === "initializing" /* initializing */) {
+        initializingWaiters.push(statusInfo.waitForInitialization.then((info) => {
+          if (info.newStatus.status !== "ready" /* ready */) {
+            throw info.newStatus;
+          }
+          return transport;
+        }));
+      }
+    }
+    if (initializingWaiters.length === 0) {
+      throw err_nice_transport.fromId("not_found" /* not_found */, {
+        actionId: primed.id
+      });
+    }
+    try {
+      const firstReady = await Promise.any(initializingWaiters);
+      return firstReady.makeRequest(primed, timeout);
+    } catch (e2) {
+      throw err_nice_transport.fromId("initialization_failed" /* initialization_failed */, {
+        actionId: primed.id
+      }).withOriginError(e2);
+    }
+  }
+  disconnect() {
+    for (const transport of this._transports) {
+      transport.disconnect();
+    }
+  }
 }
-// src/ActionRequestResponse/ActionResponder/NiceActionResponderEnvironment.ts
-class NiceActionResponderEnvironment {
-  _resolvers = new Map;
-  constructor(resolvers) {
-    for (const resolver of resolvers) {
-      this._resolvers.set(resolver.domainId, resolver);
+// src/ActionRuntimeEnvironment/ActionHandler/ActionHandler.ts
+class ActionHandler {
+  tag;
+  handlerType = "custom" /* custom */;
+  cuid;
+  _domains = new Map;
+  _handlersByKey = new Map;
+  constructor(config = {}) {
+    this.tag = config.tag ?? "_";
+    this.cuid = nanoid();
+  }
+  get allHandlerKeys() {
+    return [...this._handlersByKey.keys()];
+  }
+  getHandlersForAction(action, matchTag = "_") {
+    if (matchTag !== this.tag) {
+      return;
+    }
+    const keys = [
+      `${matchTag}::${action.domain}::${action.id}`,
+      `${matchTag}::${action.domain}::_`
+    ];
+    for (const key of keys) {
+      const handler = this._handlersByKey.get(key);
+      if (handler != null) {
+        return handler;
+      }
+    }
+  }
+  forDomain(domain, handlers) {
+    this._domains.set(domain.domain, domain);
+    const matchKey = `${this.tag}::${domain.domain}::_`;
+    this._handlersByKey.set(matchKey, handlers);
+    return this;
+  }
+  forAction(domain, id, handlers) {
+    this._domains.set(domain.domain, domain);
+    const matchKey = `${this.tag}::${domain.domain}::${id}`;
+    this._handlersByKey.set(matchKey, handlers);
+    return this;
+  }
+  forActionIds(domain, ids, handlers) {
+    this._domains.set(domain.domain, domain);
+    for (const id of ids) {
+      this.forAction(domain, id, handlers);
+    }
+    return this;
+  }
+  forDomainActionCases(domain, cases) {
+    this._domains.set(domain.domain, domain);
+    for (const id of Object.keys(cases)) {
+      const handlers = cases[id];
+      if (handlers != null) {
+        const matchKey = `${this.tag}::${domain.domain}::${id}`;
+        this._handlersByKey.set(matchKey, handlers);
+      }
+    }
+    return this;
+  }
+  async _tryHandleResponse(response) {
+    const handlers = this.getHandlersForAction(response.primed.coreAction, this.tag);
+    if (handlers?.response) {
+      const result = await handlers.response(response, {
+        tag: this.tag,
+        runtime: response.getEnvironmentMeta()
+      });
+      if (result === undefined) {
+        return { handled: true, response };
+      }
+      if (result instanceof NiceActionResponse) {
+        return { handled: true, response: result };
+      }
+      const domain = this._domains.get(response.domain);
+      if (domain == null) {
+        throw err_nice_action.fromId("domain_no_handler" /* domain_no_handler */, {
+          domain: response.domain
+        });
+      }
+      return { handled: true, response: domain.hydrateResponse(result) };
+    }
+    return { handled: false };
+  }
+  async _tryExecute(primed) {
+    const handlers = this.getHandlersForAction(primed.coreAction, this.tag);
+    if (handlers?.execution == null) {
+      return { handled: false };
+    }
+    const rawResult = await handlers.execution(primed, {
+      tag: this.tag,
+      runtime: primed.getEnvironmentMeta()
+    });
+    let response;
+    if (rawResult instanceof NiceActionResponse) {
+      response = rawResult;
+    } else if (rawResult != null && isActionResponseJsonObject(rawResult)) {
+      const domain = this._domains.get(primed.domain);
+      if (domain == null) {
+        throw err_nice_action.fromId("domain_no_handler" /* domain_no_handler */, {
+          domain: primed.domain
+        });
+      }
+      response = domain.hydrateResponse(rawResult);
+    } else {
+      response = primed.setResponse(rawResult);
     }
+    return { handled: true, response };
   }
-  async dispatch(wire) {
-    const resolver = this._resolvers.get(wire.domain);
-    if (resolver == null) {
-      throw err_nice_action.fromId("resolver_domain_not_registered" /* resolver_domain_not_registered */, {
-        domain: wire.domain
+  async dispatchAction(primed) {
+    const result = await this._tryExecute(primed);
+    if (result.handled)
+      return result.response;
+    throw err_nice_action.fromId("no_action_execution_handler" /* no_action_execution_handler */, {
+      domain: primed.domain,
+      actionId: primed.id
+    });
+  }
+  async handleWire(wire) {
+    if (typeof wire !== "object" || wire == null || typeof wire["domain"] !== "string") {
+      throw err_nice_action.fromId("wire_not_action_data" /* wire_not_action_data */);
+    }
+    const typedWire = wire;
+    const domain = this._domains.get(typedWire.domain);
+    if (domain == null) {
+      throw err_nice_action.fromId("domain_no_handler" /* domain_no_handler */, {
+        domain: typedWire.domain
       });
     }
-    const response = await resolver._dispatch(wire);
-    return response.toJsonObject();
+    if (typedWire.type === "primed" /* primed */) {
+      const primed = domain.hydratePrimed(typedWire);
+      return await this._tryExecute(primed);
+    }
+    if (typedWire.type === "resolved" /* resolved */) {
+      const response = domain.hydrateResponse(typedWire);
+      return await this._tryHandleResponse(response);
+    }
+    const unknownWire = typedWire;
+    throw err_nice_action.fromId("wire_action_not_primed_or_response" /* wire_action_not_primed_or_response */, {
+      domain: unknownWire.domain,
+      actionId: unknownWire.id,
+      actionState: unknownWire.type
+    });
   }
 }
-function createResponderEnvironment(resolvers) {
-  return new NiceActionResponderEnvironment(resolvers);
+var createHandler = (config = {}) => {
+  return new ActionHandler(config);
+};
+// src/ActionRuntimeEnvironment/ActionRuntimeEnvironment.ts
+class ActionRuntimeEnvironment {
+  envId;
+  memCuid;
+  timeCreated;
+  runtimeInfo = getAssumedRuntimeInfo();
+  _handlersByTag = new Map;
+  _defaultHandlers = new Map;
+  constructor(input) {
+    this.envId = input.envId;
+    this.memCuid = `${input.envId}::${nanoid(8)}`;
+    this.timeCreated = Date.now();
+  }
+  addHandlers(handlers) {
+    for (const handler of handlers) {
+      for (const matchKey of handler.allHandlerKeys) {
+        if (!this._handlersByTag.has(matchKey)) {
+          this._handlersByTag.set(matchKey, []);
+        } else if (this._handlersByTag.get(matchKey)?.some((h2) => h2.cuid === handler.cuid) === true) {
+          continue;
+        }
+        const handlersForKey = this._handlersByTag.get(matchKey);
+        this._handlersByTag.set(matchKey, [...handlersForKey, handler]);
+      }
+    }
+    return this;
+  }
+  setDefaultHandler(handler, tag = "_") {
+    this._defaultHandlers.set(tag, handler);
+    return this;
+  }
+  getDefaultHandler(tag = "_") {
+    return this._defaultHandlers.get(tag);
+  }
+  getHandlerForAction(action, tag) {
+    const matchTag = tag ?? "_";
+    return this._handlersByTag.get(`${matchTag}::${action.domain}::${action.id}`)?.[0] ?? this._handlersByTag.get(`${matchTag}::${action.domain}::_`)?.[0];
+  }
+  toJsonObject() {
+    return {
+      envId: this.envId,
+      memCuid: this.memCuid,
+      timeCreated: this.timeCreated,
+      runtimeInfo: this.runtimeInfo
+    };
+  }
 }
+var createActionRuntime = (config) => {
+  return new ActionRuntimeEnvironment(config);
+};
 // ../common-errors/src/validation/standard_schema/extractMessageFromStandardSchema.ts
 function extractPathFromIssue(issue) {
   let pathString = "";
@@ -3740,10 +4042,10 @@ class NiceActionSchema {
   inputOptions;
   outputOptions;
   get inputSchema() {
-    return nullish(this.inputOptions?.schema);
+    return this.inputOptions?.schema;
   }
   get outputSchema() {
-    return nullish(this.outputOptions?.schema);
+    return this.outputOptions?.schema;
   }
   input(options, serialize, deserialize) {
     if (serialize != null && deserialize != null) {
@@ -3777,11 +4079,17 @@ class NiceActionSchema {
     }
     return serialized;
   }
-  async validateInput(value, meta) {
+  validateInput(value, meta) {
     if (this.inputOptions?.schema == null) {
       return value;
     }
-    const result = await this.inputOptions.schema["~standard"].validate(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,
@@ -3791,6 +4099,26 @@ class NiceActionSchema {
     }
     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);
@@ -3809,29 +4137,80 @@ class NiceActionSchema {
 var action = () => {
   return new NiceActionSchema;
 };
-// src/utils/isActionResponseJsonObject.ts
-var isActionResponseJsonObject = (obj) => {
-  return typeof obj === "object" && obj !== null && typeof obj.domain === "string" && typeof obj.id === "string" && "input" in obj && (("output" in obj) || ("error" in obj)) && typeof obj.ok === "boolean";
-};
+// src/NiceAction/MatchAction/MatchAction.ts
+class MatchAction {
+  action;
+  _entries = [];
+  _otherwise;
+  constructor(action2) {
+    this.action = action2;
+  }
+  with(opts) {
+    this._entries.push({ domainStr: opts.domain.domain, id: opts.id, handler: opts.handler });
+    return this;
+  }
+  otherwise(handler) {
+    this._otherwise = handler;
+    return this;
+  }
+  _findMatch() {
+    const { action: action2 } = this;
+    for (const entry of this._entries) {
+      const domainMatches = action2.domain === entry.domainStr;
+      const idMatches = entry.id == null || action2.id === entry.id;
+      if (domainMatches && idMatches) {
+        return { matched: true, handler: entry.handler };
+      }
+    }
+    if (this._otherwise != null) {
+      return { matched: true, handler: this._otherwise };
+    }
+    return { matched: false };
+  }
+  run() {
+    const result = this._findMatch();
+    if (result.matched) {
+      result.handler(this.action);
+    }
+    return result.matched;
+  }
+  async runAsync() {
+    const result = this._findMatch();
+    if (result.matched) {
+      await result.handler(this.action);
+      return true;
+    }
+    return false;
+  }
+}
+var matchAction = (action2) => new MatchAction(action2);
 // src/utils/isPrimedActionJsonObject.ts
 var isPrimedActionJsonObject = (obj) => {
-  return typeof obj === "object" && obj !== null && typeof obj.domain === "string" && typeof obj.id === "string" && "input" in obj;
+  return typeof obj === "object" && obj !== null && typeof obj.domain === "string" && typeof obj.id === "string" && "input" in obj && obj.type === "primed" /* primed */;
 };
 export {
+  matchAction,
   isPrimedActionJsonObject,
   isActionResponseJsonObject,
+  err_nice_transport_ws,
+  err_nice_transport,
+  err_nice_connect,
   err_nice_action,
-  createResponderEnvironment,
-  createDomainResolver,
-  createActionDomain,
+  createHandler,
+  createActionRuntime,
+  createActionRootDomain,
   action,
+  ConnectionConfig as Transport,
   NiceActionSchema,
   NiceActionResponse,
-  NiceActionResponderEnvironment,
-  NiceActionRequester,
   NiceActionPrimed,
-  NiceActionDomainResponder,
   NiceActionDomain,
   NiceAction,
-  EErrId_NiceAction
+  EErrId_NiceTransport_WebSocket,
+  EErrId_NiceTransport,
+  EErrId_NiceAction,
+  EActionState,
+  ActionRuntimeEnvironment,
+  ActionHandler,
+  ActionConnect
 };