orchajs 0.20.3 → 0.22.0

package/dist-cjs/integrations/next.js

@@ -0,0 +1,75 @@
+"use strict"; const __orchaImportMetaUrl = require("url").pathToFileURL(__filename).href;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var next_exports = {};
+__export(next_exports, {
+  withOrcha: () => withOrcha
+});
+module.exports = __toCommonJS(next_exports);
+var import_path = require("path");
+var import_runtime_build = require("./runtime-build.js");
+var import_webpack = require("./webpack.js");
+async function withOrcha(configuration = {}, options = {}) {
+  const projectRoot = (0, import_path.resolve)(options.projectRoot ?? process.cwd());
+  await (0, import_runtime_build.queueRuntimeBuild)(projectRoot, "browser");
+  await (0, import_runtime_build.queueRuntimeBuild)(projectRoot, "node");
+  if (process.env.NODE_ENV !== "production") {
+    (0, import_runtime_build.watchRuntimeTargets)(projectRoot, ["browser", "node"]);
+  }
+  const existingWebpack = configuration.webpack;
+  return {
+    ...configuration,
+    turbopack: {
+      ...configuration.turbopack,
+      resolveAlias: {
+        ...configuration.turbopack?.resolveAlias,
+        orchajs: {
+          browser: (0, import_runtime_build.generatedBundlePath)(projectRoot, "browser")
+        }
+      }
+    },
+    webpack(webpackConfiguration, context) {
+      const target = nextTarget(context);
+      if (target === "node") {
+        return existingWebpack ? existingWebpack(webpackConfiguration, context) : webpackConfiguration;
+      }
+      const plugin = new import_webpack.OrchaWebpackPlugin({
+        projectRoot,
+        target
+      });
+      webpackConfiguration.resolve ??= {};
+      webpackConfiguration.resolve.alias = {
+        ...webpackConfiguration.resolve.alias,
+        orchajs$: plugin.bundlePath
+      };
+      webpackConfiguration.plugins = [
+        ...webpackConfiguration.plugins ?? [],
+        plugin
+      ];
+      return existingWebpack ? existingWebpack(webpackConfiguration, context) : webpackConfiguration;
+    }
+  };
+}
+function nextTarget(context) {
+  return context.isServer && context.nextRuntime !== "edge" ? "node" : "browser";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withOrcha
+});

package/dist-cjs/integrations/runtime-build.js

@@ -0,0 +1,70 @@
+"use strict"; const __orchaImportMetaUrl = require("url").pathToFileURL(__filename).href;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runtime_build_exports = {};
+__export(runtime_build_exports, {
+  generatedBundlePath: () => generatedBundlePath,
+  queueRuntimeBuild: () => queueRuntimeBuild,
+  watchRuntimeTargets: () => watchRuntimeTargets
+});
+module.exports = __toCommonJS(runtime_build_exports);
+var import_path = require("path");
+var import_chokidar = require("chokidar");
+var import_build_project = require("../compiler/build-project.js");
+var import_env = require("../env.js");
+let buildQueue = Promise.resolve();
+const watchedTargets = /* @__PURE__ */ new Set();
+function generatedBundlePath(projectRoot, target) {
+  const fileName = target === "node" ? "bundle.js" : `bundle.${target}.js`;
+  return (0, import_path.resolve)(projectRoot, ".orcha/dist", fileName);
+}
+function queueRuntimeBuild(projectRoot, target) {
+  const build = buildQueue.then(async () => {
+    (0, import_env.loadProjectEnvironment)(projectRoot);
+    await (0, import_build_project.buildProject)({ projectRoot, target });
+  });
+  buildQueue = build.catch(() => void 0);
+  return build;
+}
+function watchRuntimeTargets(projectRoot, targets) {
+  const key = `${projectRoot}:${targets.join(",")}`;
+  if (watchedTargets.has(key)) {
+    return;
+  }
+  watchedTargets.add(key);
+  let timer;
+  (0, import_chokidar.watch)((0, import_path.resolve)(projectRoot, "orcha"), { ignoreInitial: true }).on(
+    "all",
+    () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        void targets.reduce(
+          (pending, target) => pending.then(() => queueRuntimeBuild(projectRoot, target)),
+          Promise.resolve()
+        );
+      }, 75);
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generatedBundlePath,
+  queueRuntimeBuild,
+  watchRuntimeTargets
+});

package/dist-cjs/integrations/vite.js

@@ -0,0 +1,57 @@
+"use strict"; const __orchaImportMetaUrl = require("url").pathToFileURL(__filename).href;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vite_exports = {};
+__export(vite_exports, {
+  orchaVitePlugin: () => orchaVitePlugin
+});
+module.exports = __toCommonJS(vite_exports);
+var import_path = require("path");
+var import_runtime_build = require("./runtime-build.js");
+function orchaVitePlugin(options = {}) {
+  let projectRoot = (0, import_path.resolve)(options.projectRoot ?? process.cwd());
+  return {
+    name: "orchajs",
+    enforce: "pre",
+    configResolved(config) {
+      projectRoot = (0, import_path.resolve)(options.projectRoot ?? config.root);
+    },
+    async buildStart() {
+      await (0, import_runtime_build.queueRuntimeBuild)(projectRoot, "browser");
+    },
+    configureServer(server) {
+      const registryDirectory = (0, import_path.resolve)(projectRoot, "orcha");
+      server.watcher.add(registryDirectory);
+      server.watcher.on("all", (_event, path) => {
+        if (path === registryDirectory || path.startsWith(`${registryDirectory}${import_path.sep}`)) {
+          void (0, import_runtime_build.queueRuntimeBuild)(projectRoot, "browser").then(() => {
+            server.ws.send({ type: "full-reload" });
+          });
+        }
+      });
+    },
+    resolveId(source) {
+      return source === "orchajs" ? (0, import_runtime_build.generatedBundlePath)(projectRoot, "browser") : void 0;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  orchaVitePlugin
+});

package/dist-cjs/integrations/webpack.js

@@ -0,0 +1,51 @@
+"use strict"; const __orchaImportMetaUrl = require("url").pathToFileURL(__filename).href;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var webpack_exports = {};
+__export(webpack_exports, {
+  OrchaWebpackPlugin: () => OrchaWebpackPlugin
+});
+module.exports = __toCommonJS(webpack_exports);
+var import_path = require("path");
+var import_runtime_build = require("./runtime-build.js");
+class OrchaWebpackPlugin {
+  #projectRoot;
+  #target;
+  constructor(options = {}) {
+    this.#projectRoot = (0, import_path.resolve)(options.projectRoot ?? process.cwd());
+    this.#target = options.target ?? "browser";
+  }
+  get bundlePath() {
+    return (0, import_runtime_build.generatedBundlePath)(this.#projectRoot, this.#target);
+  }
+  apply(compiler) {
+    compiler.hooks.beforeCompile.tapPromise("orchajs", async () => {
+      await (0, import_runtime_build.queueRuntimeBuild)(this.#projectRoot, this.#target);
+    });
+    compiler.hooks.afterCompile.tap("orchajs", (compilation) => {
+      compilation.contextDependencies.add(
+        (0, import_path.resolve)(this.#projectRoot, "orcha")
+      );
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OrchaWebpackPlugin
+});

package/dist-cjs/orcha.js

@@ -24,10 +24,13 @@ __export(orcha_exports, {
 module.exports = __toCommonJS(orcha_exports);
 var import_fs = require("fs");
 var import_path = require("path");
-var import_compile = require("./compiler/compile.js");
 var import_providers = require("./providers/index.js");
 var import_execute = require("./runtime/actions/execute.js");
+var import_native = require("./runtime/actions/native.js");
+var import_compiler_hook = require("./runtime/compiler-hook.js");
 var import_create_orcha = require("./runtime/create-orcha.js");
+var import_platform_node = require("./runtime/platform-node.js");
+(0, import_execute.setNativeRuntimeLoader)(async () => ({ executeNativeAction: import_native.executeNativeAction }));
 (0, import_execute.setSandboxRuntimeLoader)(async () => {
   const modulePath = "./runtime/actions/sandbox.js";
   return import(modulePath);
@@ -37,26 +40,25 @@ const orcha = (0, import_create_orcha.createOrcha)(
     const projectRoot = (0, import_path.resolve)(
       configuration.root ?? process.env.ORCHA_PROJECT_ROOT ?? process.cwd()
     );
-    if (process.env.ORCHA_COMPILING !== "1" && isPrecompiledRuntime()) {
+    const compiler = (0, import_compiler_hook.getRegistryCompiler)();
+    if (process.env.ORCHA_COMPILING === "1" && compiler) {
+      return compiler(configuration, projectRoot);
+    }
+    if (isPrecompiledRuntime() || (0, import_fs.existsSync)(compiledManifestPath(projectRoot))) {
       return loadCompiledManifest(projectRoot, configuration);
     }
-    const registryRoot = (0, import_path.resolve)(projectRoot, "orcha");
-    return (0, import_compile.compileRegistry)(
-      configuration.agents,
-      registryRoot,
-      configuration.actions?.runtime ?? "native"
+    throw new Error(
+      'Orcha agents must be compiled before runtime initialization. Run "npx orcha dev" during development or "npx orcha build" before starting the application.'
     );
   },
-  import_providers.generateProviderResponse
+  import_providers.generateProviderResponse,
+  import_platform_node.nodeRuntimePlatform
 );
 function isPrecompiledRuntime() {
   return process.env.ORCHA_USE_BUILD === "1" || process.env.NODE_ENV === "production" || process.env.AWS_LAMBDA_FUNCTION_NAME !== void 0 || process.env.AWS_EXECUTION_ENV?.startsWith("AWS_Lambda_") === true;
 }
 function loadCompiledManifest(projectRoot, configuration) {
-  const manifestPath = (0, import_path.resolve)(
-    projectRoot,
-    ".orcha/dist/manifest.json"
-  );
+  const manifestPath = compiledManifestPath(projectRoot);
   if (!(0, import_fs.existsSync)(manifestPath)) {
     throw new Error(
       `ORCHA_PRODUCTION_BUNDLE_MISSING: "${manifestPath}" was not found. Run "npx orcha build" before packaging, include ".orcha/dist" in the deployment, or configure the Orcha build integration.`
@@ -88,6 +90,9 @@ function loadCompiledManifest(projectRoot, configuration) {
   }
   return bundle;
 }
+function compiledManifestPath(projectRoot) {
+  return (0, import_path.resolve)(projectRoot, ".orcha/dist/manifest.json");
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   orcha

package/dist-cjs/playground/server.js

@@ -26,10 +26,11 @@ var import_child_process = require("child_process");
 var import_crypto = require("crypto");
 var import_fs = require("fs");
 var import_promises = require("fs/promises");
+var import_module = require("module");
 var import_path = require("path");
-var import_url = require("url");
 var import_http = require("http");
 var import_chokidar = require("chokidar");
+var import_esbuild = require("esbuild");
 var import_orcha = require("../orcha.js");
 var import_project_loader = require("../project-loader.js");
 var import_testing = require("../testing.js");
@@ -46,6 +47,7 @@ async function startPlayground(options = {}) {
   const mutationToken = (0, import_crypto.randomBytes)(32).toString("base64url");
   const allowedHosts = playgroundHosts(host, port);
   await (0, import_project_loader.loadProject)(projectRoot);
+  const publicRoot = await buildPlaygroundAssets(projectRoot);
   const projectClients = /* @__PURE__ */ new Set();
   const server = (0, import_http.createServer)(async (request, response) => {
     try {
@@ -57,7 +59,8 @@ async function startPlayground(options = {}) {
         port,
         projectClients,
         mutationToken,
-        allowedHosts
+        allowedHosts,
+        publicRoot
       });
     } catch (error) {
       sendJson(response, error instanceof HttpError ? error.status : 500, {
@@ -340,7 +343,7 @@ async function routeRequest(context) {
     return;
   }
   if (method === "GET") {
-    await serveAsset(response, url.pathname);
+    await serveAsset(response, url.pathname, context.publicRoot);
     return;
   }
   sendJson(response, 404, { error: "Not found." });
@@ -472,11 +475,7 @@ async function readAllEventPages(read) {
   }
   return pages.flat();
 }
-async function serveAsset(response, pathname) {
-  const publicRoot = (0, import_path.resolve)(
-    (0, import_path.dirname)((0, import_url.fileURLToPath)(__orchaImportMetaUrl)),
-    "public"
-  );
+async function serveAsset(response, pathname, publicRoot) {
   const requested = pathname === "/" ? "index.html" : pathname.slice(1);
   const path = (0, import_path.resolve)(publicRoot, requested);
   const relativePath = (0, import_path.relative)(publicRoot, path);
@@ -484,7 +483,7 @@ async function serveAsset(response, pathname) {
     const indexPath = (0, import_path.resolve)(publicRoot, "index.html");
     if (!(0, import_fs.existsSync)(indexPath)) {
       sendJson(response, 503, {
-        error: "Playground assets are missing. Rebuild orchajs."
+        error: "Playground assets are missing. Restart the Orcha playground."
       });
       return;
     }
@@ -501,6 +500,60 @@ async function serveAsset(response, pathname) {
   });
   response.end(await (0, import_promises.readFile)(path));
 }
+async function buildPlaygroundAssets(projectRoot) {
+  const require2 = (0, import_module.createRequire)(__orchaImportMetaUrl);
+  let entryPath;
+  let logoPath;
+  try {
+    entryPath = require2.resolve("@orchajs/playground-ui/mount");
+    logoPath = require2.resolve("@orchajs/playground-ui/orcha-logo.svg");
+  } catch (error) {
+    throw new Error(
+      'The playground requires the optional "@orchajs/playground-ui" package. Install it as a development dependency.',
+      { cause: error }
+    );
+  }
+  const publicRoot = (0, import_path.resolve)(projectRoot, ".orcha/playground");
+  await (0, import_promises.mkdir)(publicRoot, { recursive: true });
+  await Promise.all([
+    (0, import_esbuild.build)({
+      entryPoints: [entryPath],
+      outfile: (0, import_path.resolve)(publicRoot, "app.js"),
+      bundle: true,
+      format: "esm",
+      platform: "browser",
+      target: ["chrome110", "firefox110", "safari16"],
+      minify: true,
+      sourcemap: false,
+      legalComments: "none",
+      define: {
+        "process.env.NODE_ENV": JSON.stringify("production")
+      }
+    }),
+    (0, import_promises.copyFile)(logoPath, (0, import_path.resolve)(publicRoot, "orcha-logo.svg")),
+    (0, import_promises.writeFile)(
+      (0, import_path.resolve)(publicRoot, "index.html"),
+      `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="color-scheme" content="light" />
+    <link rel="icon" href="/orcha-logo.svg" type="image/svg+xml" />
+    <title>Orcha Playground</title>
+    <link rel="stylesheet" href="/app.css" />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/app.js"></script>
+  </body>
+</html>
+`,
+      "utf8"
+    )
+  ]);
+  return publicRoot;
+}
 function contentType(path) {
   switch ((0, import_path.extname)(path)) {
     case ".html":

package/dist-cjs/project-loader.js

@@ -27,9 +27,19 @@ var import_promises = require("fs/promises");
 var import_path = require("path");
 var import_url = require("url");
 var import_esbuild = require("esbuild");
+var import_compile = require("./compiler/compile.js");
 var import_env = require("./env.js");
 var import_orcha = require("./orcha.js");
+var import_compiler_hook = require("./runtime/compiler-hook.js");
 async function loadProject(projectRoot) {
+  (0, import_compiler_hook.setRegistryCompiler)(
+    (configuration, compilerProjectRoot) => (0, import_compile.compileRegistry)(
+      configuration.agents,
+      (0, import_path.resolve)(compilerProjectRoot, "orcha"),
+      configuration.actions?.runtime ?? "native",
+      "node"
+    )
+  );
   (0, import_env.loadProjectEnvironment)(projectRoot);
   const registryPath = (0, import_path.resolve)(projectRoot, "orcha/index.ts");
   if (!(0, import_fs.existsSync)(registryPath)) {

package/dist-cjs/providers/browser.js

@@ -0,0 +1,61 @@
+"use strict"; const __orchaImportMetaUrl = require("url").pathToFileURL(__filename).href;
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var browser_exports = {};
+__export(browser_exports, {
+  generateBrowserProviderResponse: () => generateBrowserProviderResponse
+});
+module.exports = __toCommonJS(browser_exports);
+var import_errors = require("../errors.js");
+const loadedProviders = /* @__PURE__ */ new Map();
+const loaders = {
+  anthropic: () => import("./anthropic.js").then((module2) => module2.anthropicProvider),
+  deepseek: () => import("./deepseek.js").then((module2) => module2.deepSeekProvider),
+  googlegenai: () => import("./google-genai.js").then((module2) => module2.googleGenAIProvider),
+  openai: () => import("./openai.js").then((module2) => module2.openAIProvider)
+};
+const generateBrowserProviderResponse = async (name, configuration, request) => {
+  const loader = loaders[name];
+  if (!loader) {
+    throw new import_errors.OrchaError(
+      "provider_error",
+      `Provider "${name}" is not available in browser or React Native runtimes.`
+    );
+  }
+  let provider = loadedProviders.get(name);
+  if (!provider) {
+    provider = loader();
+    loadedProviders.set(name, provider);
+  }
+  return (await provider).generate(configuration, request);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateBrowserProviderResponse
+});

package/dist-cjs/react-native.js

@@ -0,0 +1,48 @@
+"use strict"; const __orchaImportMetaUrl = require("url").pathToFileURL(__filename).href;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var react_native_exports = {};
+__export(react_native_exports, {
+  orcha: () => orcha
+});
+module.exports = __toCommonJS(react_native_exports);
+var import_browser = require("./providers/browser.js");
+var import_execute = require("./runtime/actions/execute.js");
+var import_create_orcha = require("./runtime/create-orcha.js");
+var import_platform_react_native = require("./runtime/platform-react-native.js");
+__reExport(react_native_exports, require("./runtime-entry.js"), module.exports);
+(0, import_execute.setNativeRuntimeLoader)(async () => {
+  const modulePath = "./runtime/actions/browser-native.js";
+  return import(modulePath);
+});
+const orcha = (0, import_create_orcha.createOrcha)(
+  () => {
+    throw new Error(
+      "The React Native runtime requires a precompiled Orcha bundle. Configure the Orcha Metro integration."
+    );
+  },
+  import_browser.generateBrowserProviderResponse,
+  import_platform_react_native.reactNativeRuntimePlatform
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  orcha,
+  ...require("./runtime-entry.js")
+});

package/dist-cjs/runtime/actions/browser-native.js

@@ -0,0 +1,68 @@
+"use strict"; const __orchaImportMetaUrl = require("url").pathToFileURL(__filename).href;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var browser_native_exports = {};
+__export(browser_native_exports, {
+  executeNativeAction: () => executeNativeAction
+});
+module.exports = __toCommonJS(browser_native_exports);
+async function executeNativeAction(action, parameters, context) {
+  if (!action.source) {
+    throw new Error(`Action "${action.name}" has no compiled source.`);
+  }
+  if (/\brequire\s*\(/.test(action.source)) {
+    throw new Error(
+      `Browser action "${action.name}" contains a Node.js require() call. Rebuild it for the browser target.`
+    );
+  }
+  const loadAction = new Function(
+    `"use strict";
+${action.source}
+return __orchaActionModule.default;`
+  );
+  const executable = loadAction();
+  if (typeof executable !== "function") {
+    throw new Error(
+      `Action "${action.name}" index.js must export a default function.`
+    );
+  }
+  const timeoutMs = action.timeoutMs ?? 1e4;
+  let timeout;
+  try {
+    return await Promise.race([
+      Promise.resolve(
+        executable(parameters, context)
+      ),
+      new Promise((_resolve, reject) => {
+        timeout = setTimeout(
+          () => reject(new Error(`Action timed out after ${timeoutMs}ms.`)),
+          timeoutMs
+        );
+      })
+    ]);
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  executeNativeAction
+});