orchajs 0.20.2 → 0.21.0

package/dist-cjs/file-content.js

@@ -24,8 +24,6 @@ __export(file_content_exports, {
   readLocalFileContent: () => readLocalFileContent
 });
 module.exports = __toCommonJS(file_content_exports);
-var import_promises = require("fs/promises");
-var import_path = require("path");
 const MIME_TYPES = {
   ".csv": "text/csv",
   ".doc": "application/msword",
@@ -47,8 +45,8 @@ const MIME_TYPES = {
   ".xls": "application/vnd.ms-excel",
   ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
 };
-function normalizeLocalFile(filePath, mimeType, projectRoot = process.cwd()) {
-  const absolutePath = (0, import_path.resolve)(projectRoot, filePath);
+function normalizeLocalFile(filePath, mimeType, projectRoot = ".") {
+  const absolutePath = resolvePortablePath(projectRoot, filePath);
   return {
     type: "file",
     filePath: absolutePath,
@@ -72,20 +70,22 @@ function normalizeUrlContent(url, mimeType) {
   };
 }
 async function readLocalFileContent(content) {
-  const bytes = await (0, import_promises.readFile)(content.filePath);
+  const fsModule = "fs/promises";
+  const { readFile } = await import(fsModule);
+  const bytes = await readFile(content.filePath);
   const base64 = bytes.toString("base64");
   return {
     bytes,
     base64,
     dataUri: `data:${content.mimeType};base64,${base64}`,
-    fileName: (0, import_path.basename)(content.filePath)
+    fileName: portableBasename(content.filePath)
   };
 }
 function normalizeMimeType(mimeType, source) {
   if (mimeType?.trim()) {
     return mimeType.trim().toLowerCase();
   }
-  const inferred = MIME_TYPES[(0, import_path.extname)(source).toLowerCase()];
+  const inferred = MIME_TYPES[portableExtension(source).toLowerCase()];
   if (!inferred) {
     throw new Error(
       `Could not infer a MIME type for "${source}". Provide mimeType explicitly.`
@@ -93,6 +93,41 @@ function normalizeMimeType(mimeType, source) {
   }
   return inferred;
 }
+function resolvePortablePath(root, filePath) {
+  if (/^(?:\/|[a-zA-Z]:[\\/])/.test(filePath)) {
+    return normalizePath(filePath);
+  }
+  return normalizePath(`${root.replace(/[\\/]+$/, "")}/${filePath}`);
+}
+function normalizePath(path) {
+  const separator = path.includes("\\") ? "\\" : "/";
+  const prefix = path.match(/^(?:[a-zA-Z]:)?[\\/]/)?.[0] ?? "";
+  const source = prefix ? path.slice(prefix.length) : path;
+  const parts = [];
+  for (const part of source.split(/[\\/]+/)) {
+    if (!part || part === ".") {
+      continue;
+    }
+    if (part === "..") {
+      if (parts.length > 0 && parts.at(-1) !== "..") {
+        parts.pop();
+      } else if (!prefix) {
+        parts.push(part);
+      }
+      continue;
+    }
+    parts.push(part);
+  }
+  return `${prefix}${parts.join(separator)}` || ".";
+}
+function portableBasename(path) {
+  return path.split(/[\\/]/).at(-1) ?? path;
+}
+function portableExtension(path) {
+  const name = portableBasename(path);
+  const index = name.lastIndexOf(".");
+  return index > 0 ? name.slice(index) : "";
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   normalizeLocalFile,

package/dist-cjs/index.js

@@ -16,28 +16,23 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 index_exports = {};
 __export(index_exports, {
   NodeJsonlSessionStore: () => import_node_jsonl.NodeJsonlSessionStore,
   NodeSqliteSessionStore: () => import_node_sqlite.NodeSqliteSessionStore,
-  OrchaError: () => import_errors.OrchaError,
-  exportSessionJsonl: () => import_migrate.exportSessionJsonl,
-  migrateSessionStore: () => import_migrate.migrateSessionStore,
   orcha: () => import_orcha.orcha
 });
 module.exports = __toCommonJS(index_exports);
 var import_orcha = require("./orcha.js");
-var import_errors = require("./errors.js");
+__reExport(index_exports, require("./runtime-entry.js"), module.exports);
 var import_node_jsonl = require("./storage/node-jsonl.js");
 var import_node_sqlite = require("./storage/node-sqlite.js");
-var import_migrate = require("./storage/migrate.js");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   NodeJsonlSessionStore,
   NodeSqliteSessionStore,
-  OrchaError,
-  exportSessionJsonl,
-  migrateSessionStore,
-  orcha
+  orcha,
+  ...require("./runtime-entry.js")
 });

package/dist-cjs/integrations/esbuild.js

@@ -26,12 +26,16 @@ var import_path = require("path");
 var import_build_project = require("../compiler/build-project.js");
 function orchaPlugin(options = {}) {
   const projectRoot = (0, import_path.resolve)(options.projectRoot ?? process.cwd());
-  const generatedBundle = (0, import_path.resolve)(projectRoot, ".orcha/dist/bundle.js");
   return {
     name: "orchajs",
     setup(builder) {
+      const target = builder.initialOptions.platform === "browser" ? "browser" : "node";
+      const generatedBundle = (0, import_path.resolve)(
+        projectRoot,
+        `.orcha/dist/${target === "node" ? "bundle.js" : "bundle.browser.js"}`
+      );
       builder.onStart(async () => {
-        await (0, import_build_project.buildProject)({ projectRoot });
+        await (0, import_build_project.buildProject)({ projectRoot, target });
       });
       builder.onResolve({ filter: /^orchajs$/ }, () => ({
         path: generatedBundle

package/dist-cjs/integrations/expo.js

@@ -0,0 +1,29 @@
+"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 expo_exports = {};
+__export(expo_exports, {
+  withOrchaExpo: () => import_metro.withOrchaMetro
+});
+module.exports = __toCommonJS(expo_exports);
+var import_metro = require("./metro.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withOrchaExpo
+});

package/dist-cjs/integrations/metro.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 metro_exports = {};
+__export(metro_exports, {
+  withOrchaMetro: () => withOrchaMetro
+});
+module.exports = __toCommonJS(metro_exports);
+var import_path = require("path");
+var import_runtime_build = require("./runtime-build.js");
+async function withOrchaMetro(configuration, options = {}) {
+  const projectRoot = (0, import_path.resolve)(options.projectRoot ?? process.cwd());
+  await (0, import_runtime_build.queueRuntimeBuild)(projectRoot, "react-native");
+  if (process.env.NODE_ENV !== "production") {
+    (0, import_runtime_build.watchRuntimeTargets)(projectRoot, ["react-native"]);
+  }
+  const existingResolver = configuration.resolver?.resolveRequest;
+  return {
+    ...configuration,
+    resolver: {
+      ...configuration.resolver,
+      resolveRequest(context, moduleName, platform) {
+        const requestedModule = moduleName === "orchajs" ? (0, import_runtime_build.generatedBundlePath)(projectRoot, "react-native") : moduleName;
+        if (existingResolver) {
+          return existingResolver(context, requestedModule, platform);
+        }
+        return context.resolveRequest(context, requestedModule, platform);
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withOrchaMetro
+});

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":