orchajs 0.20.3 → 0.21.0

package/README.md

@@ -50,6 +50,109 @@ The Google GenAI and Vertex AI adapters use Google's current SDK and require
 Node.js 20 or newer. On Node.js 18, the rest of Orcha—including Amazon
 Bedrock—remains available.
 
+Compiler and playground packages are optional development dependencies. Apps
+created with `create-orcha` include them automatically. Existing projects that
+use the CLI or a bundler integration should install them explicitly:
+
+```bash
+npm install --save-dev esbuild chokidar dotenv
+```
+
+The local playground is also development-only:
+
+```bash
+npm install --save-dev @orchajs/playground-ui
+```
+
+## React, Next.js, and React Native
+
+Application code always imports the same package:
+
+```ts
+import { orcha } from "orchajs";
+```
+
+The framework integration compiles the filesystem registry ahead of time and
+redirects that unchanged import to a small, target-specific runtime. Compiler,
+filesystem, playground, and unused provider code are not included in the
+customer bundle. Provider adapters are selected from the compiled registry, so
+using OpenAI does not include Anthropic, Google, Bedrock, or Vertex AI code.
+
+For React with Vite:
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import { orchaVitePlugin } from "orchajs/vite";
+
+export default defineConfig({
+  plugins: [orchaVitePlugin(), react()],
+});
+```
+
+Webpack-based React applications use the equivalent plugin:
+
+```js
+const { OrchaWebpackPlugin } = require("orchajs/webpack");
+
+const orcha = new OrchaWebpackPlugin();
+module.exports = {
+  resolve: { alias: { "orchajs$": orcha.bundlePath } },
+  plugins: [orcha],
+};
+```
+
+Next.js 16 uses Turbopack by default. Its config may be asynchronous, so the
+integration compiles both browser and Node targets before returning the config
+and also configures Webpack fallback builds:
+
+```ts
+// next.config.ts
+import { withOrcha } from "orchajs/next";
+
+export default async function nextConfig() {
+  return withOrcha({});
+}
+```
+
+Both Expo and bare React Native use the same precompiled runtime and persistent
+AsyncStorage:
+
+```bash
+# Bare React Native
+npm install @react-native-async-storage/async-storage
+
+# Expo
+npx expo install @react-native-async-storage/async-storage
+```
+
+Bare React Native:
+
+```js
+// metro.config.js
+const { getDefaultConfig } = require("@react-native/metro-config");
+const { withOrchaMetro } = require("orchajs/metro");
+
+module.exports = withOrchaMetro(getDefaultConfig(__dirname));
+```
+
+Expo:
+
+```js
+// metro.config.js
+const { getDefaultConfig } = require("expo/metro-config");
+const { withOrchaExpo } = require("orchajs/expo");
+
+module.exports = withOrchaExpo(getDefaultConfig(__dirname));
+```
+
+Browser and React Native builds execute compiled agents locally. Only
+Anthropic, DeepSeek, Google GenAI, and OpenAI are browser-compatible; Bedrock
+and Vertex AI remain server runtimes. Provider credentials included in client
+configuration are visible to end users, so production applications should use
+restricted client credentials or a server-side provider proxy.
+
 ---
 
 ## The convention

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+void import("./cli.js").catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    const dependency = ["esbuild", "chokidar", "dotenv"].find((name) => message.includes(`"${name}"`) || message.includes(`'${name}'`));
+    if (dependency) {
+        console.error(`Orcha development tooling requires optional dependencies. Install them with:\n\n  npm install --save-dev esbuild chokidar dotenv`);
+    }
+    else {
+        console.error(message);
+    }
+    process.exitCode = 1;
+});
+export {};

package/dist/browser.d.ts

@@ -0,0 +1,2 @@
+export declare const orcha: import("./runtime-entry.js").OrchaClient;
+export * from "./runtime-entry.js";

package/dist/browser.js

@@ -0,0 +1,12 @@
+import { generateBrowserProviderResponse } from "./providers/browser.js";
+import { setNativeRuntimeLoader } from "./runtime/actions/execute.js";
+import { createOrcha } from "./runtime/create-orcha.js";
+import { browserRuntimePlatform } from "./runtime/platform-browser.js";
+setNativeRuntimeLoader(async () => {
+    const modulePath = "./runtime/actions/browser-native.js";
+    return import(modulePath);
+});
+export const orcha = createOrcha(() => {
+    throw new Error("The browser runtime requires a precompiled Orcha bundle. Configure the Orcha integration for your application bundler.");
+}, generateBrowserProviderResponse, browserRuntimePlatform);
+export * from "./runtime-entry.js";

package/dist/cli.js

@@ -24,8 +24,7 @@ try {
             await initializeProject(projectRoot);
             break;
         case "dev":
-            assertNoArguments(commandArguments, "dev");
-            await watchProject(projectRoot);
+            await watchProject(projectRoot, parseDevTargets(commandArguments));
             break;
         case "run":
             await runAgent(projectRoot, commandArguments);
@@ -43,9 +42,13 @@ try {
             await exportSession(projectRoot, commandArguments);
             break;
         case "build": {
-            assertNoArguments(commandArguments, "build");
+            const parsed = parseArguments(commandArguments, new Set(["--target"]), new Set());
+            if (parsed.positionals.length > 0) {
+                throw new Error("Usage: orcha build [--target node|browser|react-native]");
+            }
+            const target = parseBuildTarget(parsed.values.get("--target"));
             loadProjectEnvironment(projectRoot);
-            const outputPath = await buildProject({ projectRoot });
+            const outputPath = await buildProject({ projectRoot, target });
             console.log(`Built ${relative(projectRoot, outputPath)}`);
             break;
         }
@@ -112,11 +115,12 @@ async function initializeProject(projectRoot) {
     await ensureGitignore(projectRoot);
     console.log('\nRun "orcha dev" to validate changes or "orcha run exampleAgent --input \\"Hello\\"" to execute the agent.');
 }
-async function watchProject(projectRoot) {
+async function watchProject(projectRoot, targets) {
     const registryDirectory = resolve(projectRoot, "orcha");
     if (!existsSync(registryDirectory)) {
         throw new Error('Missing "orcha/". Run "orcha init" first.');
     }
+    loadProjectEnvironment(projectRoot);
     let validating = false;
     let validateAgain = false;
     let timer;
@@ -127,7 +131,9 @@ async function watchProject(projectRoot) {
         }
         validating = true;
         try {
-            await loadProject(projectRoot);
+            for (const target of targets) {
+                await buildProject({ projectRoot, target });
+            }
             const agents = Object.keys(orcha.getCompiledBundle().agents);
             console.log(`[orcha] valid — ${agents.length} agent${agents.length === 1 ? "" : "s"}: ${agents.join(", ") || "none"}`);
         }
@@ -143,7 +149,7 @@ async function watchProject(projectRoot) {
         }
     };
     await validate();
-    console.log("[orcha] watching orcha/**");
+    console.log(`[orcha] watching orcha/** for ${targets.join(", ")}`);
     const watcher = watch(registryDirectory, { ignoreInitial: true }).on("all", () => {
         clearTimeout(timer);
         timer = setTimeout(() => void validate(), 75);
@@ -344,6 +350,26 @@ function allAgentManifests(agents) {
     }
     return [...manifests.values()];
 }
+function parseDevTargets(arguments_) {
+    const parsed = parseArguments(arguments_, new Set(["--target"]), new Set());
+    if (parsed.positionals.length > 0) {
+        throw new Error("Usage: orcha dev [--target node|browser|react-native|all]");
+    }
+    const target = parsed.values.get("--target") ?? "node";
+    if (target === "all") {
+        return ["browser", "react-native", "node"];
+    }
+    return [parseBuildTarget(target)];
+}
+function parseBuildTarget(value) {
+    if (value === undefined ||
+        value === "node" ||
+        value === "browser" ||
+        value === "react-native") {
+        return value ?? "node";
+    }
+    throw new Error(`Unknown build target "${value}". Expected node, browser, or react-native.`);
+}
 function parseArguments(arguments_, valueOptions, flagOptions = new Set(["--json"])) {
     const parsed = {
         positionals: [],
@@ -605,13 +631,13 @@ function printUsage() {
         "",
         "Commands:",
         "  init                         Add Orcha to the current project",
-        "  dev                          Validate and watch orcha/**",
+        "  dev [--target <runtime>]     Build and watch orcha/**",
         "  run <agent> [options]        Execute or resume an agent",
         "  test [agent | agent/test]    Run agent tests",
         "  playground [options]         Open the local agent playground",
         "  migrate-storage --to <type>  Copy sessions between JSONL and SQLite",
         "  export-session <agent> <id>  Export one session as JSONL",
-        "  build                        Build the production Orcha bundle",
+        "  build [--target <runtime>]   Build for node, browser, or react-native",
         "",
         "Run and test support --json for machine-readable output.",
     ].join("\n"));

package/dist/compiler/build-project.d.ts

@@ -1,4 +1,5 @@
 export interface BuildProjectOptions {
     projectRoot?: string;
+    target?: "node" | "browser" | "react-native";
 }
 export declare function buildProject(options?: BuildProjectOptions): Promise<string>;

package/dist/compiler/build-project.js

@@ -4,9 +4,14 @@ import { dirname, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { build as bundleEntry } from "esbuild";
 import { orcha } from "../orcha.js";
+import { setRegistryCompiler } from "../runtime/compiler-hook.js";
+import { compileRegistry } from "./compile.js";
 import { builtInProviderCatalog, isBuiltInProvider, } from "../providers/catalog.js";
+let registryImportSequence = 0;
 export async function buildProject(options = {}) {
     const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    const target = options.target ?? "node";
+    setRegistryCompiler((configuration, compilerProjectRoot) => compileRegistry(configuration.agents, resolve(compilerProjectRoot, "orcha"), configuration.actions?.runtime ?? "native", target));
     const registryPath = resolve(projectRoot, "orcha/index.ts");
     if (!existsSync(registryPath)) {
         throw new Error('Missing "orcha/index.ts". Run "orcha init" first.');
@@ -14,7 +19,7 @@ export async function buildProject(options = {}) {
     const temporaryDirectory = resolve(projectRoot, ".orcha/.build");
     const registryBundlePath = resolve(temporaryDirectory, "registry.mjs");
     const productionEntryPath = resolve(temporaryDirectory, "production-entry.mjs");
-    const outputPath = resolve(projectRoot, ".orcha/dist/bundle.js");
+    const outputPath = resolve(projectRoot, `.orcha/dist/${bundleFileName(target)}`);
     const manifestPath = resolve(projectRoot, ".orcha/dist/manifest.json");
     await mkdir(temporaryDirectory, { recursive: true });
     await mkdir(dirname(outputPath), { recursive: true });
@@ -34,7 +39,7 @@ export async function buildProject(options = {}) {
         process.env.ORCHA_COMPILING = "1";
         process.env.ORCHA_PROJECT_ROOT = projectRoot;
         try {
-            await import(`${pathToFileURL(registryBundlePath).href}?time=${Date.now()}`);
+            await import(`${pathToFileURL(registryBundlePath).href}?build=${Date.now()}-${registryImportSequence++}`);
         }
         finally {
             if (previousCompiling === undefined) {
@@ -51,11 +56,19 @@ export async function buildProject(options = {}) {
             }
         }
         const compiledBundle = orcha.getCompiledBundle();
+        if (target !== "node" &&
+            compiledBundle.actionRuntime === "sandbox") {
+            throw new Error(`The ${target} target supports precompiled native actions only. Set actions.runtime to "native".`);
+        }
         const runtimeFactoryPath = resolve(dirname(fileURLToPath(import.meta.url)), "../runtime/create-orcha.js").replaceAll("\\", "/");
+        const runtimePlatformPath = resolve(dirname(fileURLToPath(import.meta.url)), `../runtime/platform-${target}.js`).replaceAll("\\", "/");
+        const runtimeEntryPath = resolve(dirname(fileURLToPath(import.meta.url)), "../runtime-entry.js").replaceAll("\\", "/");
         const providerDispatcherPath = resolve(dirname(fileURLToPath(import.meta.url)), "../providers/dispatcher.js").replaceAll("\\", "/");
         const sandboxRuntimeSource = compiledBundle.actionRuntime === "sandbox"
             ? createSandboxRuntimeSource()
             : "";
+        const platformActionRuntimeSource = createPlatformActionRuntimeSource(target);
+        const nodeStorageExports = target === "node" ? createNodeStorageExports() : "";
         const includedProviders = [
             ...new Set(allCompiledAgents(compiledBundle.agents).flatMap((agent) => [
                 agent.provider,
@@ -64,18 +77,22 @@ export async function buildProject(options = {}) {
                     .map((evaluation) => evaluation.provider),
             ])),
         ];
-        const providerRuntimeSource = createProviderRuntimeSource(includedProviders);
+        const providerRuntimeSource = createProviderRuntimeSource(includedProviders, target);
         const needsNodeRequire = compiledBundle.actionRuntime === "sandbox" ||
             includedProviders.includes("vertexai") ||
             includedProviders.includes("bedrock");
         await writeFile(productionEntryPath, [
             `import { createOrcha } from ${JSON.stringify(runtimeFactoryPath)};`,
+            `import { ${runtimePlatformExport(target)} as runtimePlatform } from ${JSON.stringify(runtimePlatformPath)};`,
             `import { createProviderResponseGenerator } from ${JSON.stringify(providerDispatcherPath)};`,
+            `export * from ${JSON.stringify(runtimeEntryPath)};`,
+            nodeStorageExports,
             providerRuntimeSource,
+            platformActionRuntimeSource,
             sandboxRuntimeSource,
             `const compiledBundle = ${JSON.stringify(compiledBundle)};`,
             "const generateProviderResponse = createProviderResponseGenerator(includedProviders);",
-            "export const orcha = createOrcha(() => compiledBundle, generateProviderResponse);",
+            "export const orcha = createOrcha(() => compiledBundle, generateProviderResponse, runtimePlatform);",
             "export default orcha;",
             "",
         ].join("\n"), "utf8");
@@ -84,14 +101,18 @@ export async function buildProject(options = {}) {
             outfile: outputPath,
             bundle: true,
             format: "esm",
-            platform: "node",
-            target: "node18",
+            platform: target === "node" ? "node" : "browser",
+            target: target === "node"
+                ? "node18"
+                : target === "browser"
+                    ? ["chrome110", "firefox110", "safari16"]
+                    : "es2022",
             minify: true,
             legalComments: "none",
             define: {
                 "process.env.ORCHA_INCLUDE_SANDBOX": JSON.stringify(compiledBundle.actionRuntime === "sandbox" ? "1" : "0"),
             },
-            ...(needsNodeRequire
+            ...(needsNodeRequire && target === "node"
                 ? {
                     banner: {
                         js: [
@@ -101,6 +122,13 @@ export async function buildProject(options = {}) {
                     },
                 }
                 : {}),
+            ...(target === "react-native"
+                ? {
+                    external: [
+                        "@react-native-async-storage/async-storage",
+                    ],
+                }
+                : {}),
             logLevel: "silent",
         });
         await writeFile(manifestPath, `${JSON.stringify(compiledBundle)}\n`, "utf8");
@@ -113,6 +141,18 @@ export async function buildProject(options = {}) {
         });
     }
 }
+function bundleFileName(target) {
+    return target === "node" ? "bundle.js" : `bundle.${target}.js`;
+}
+function runtimePlatformExport(target) {
+    if (target === "browser") {
+        return "browserRuntimePlatform";
+    }
+    if (target === "react-native") {
+        return "reactNativeRuntimePlatform";
+    }
+    return "nodeRuntimePlatform";
+}
 function createSandboxRuntimeSource() {
     const runtimeDirectory = dirname(fileURLToPath(import.meta.url));
     const executePath = resolve(runtimeDirectory, "../runtime/actions/execute.js").replaceAll("\\", "/");
@@ -124,13 +164,36 @@ function createSandboxRuntimeSource() {
         "",
     ].join("\n");
 }
+function createPlatformActionRuntimeSource(target) {
+    const runtimeDirectory = dirname(fileURLToPath(import.meta.url));
+    const executePath = resolve(runtimeDirectory, "../runtime/actions/execute.js").replaceAll("\\", "/");
+    const nativePath = resolve(runtimeDirectory, target === "node"
+        ? "../runtime/actions/native.js"
+        : "../runtime/actions/browser-native.js").replaceAll("\\", "/");
+    return [
+        `import { setNativeRuntimeLoader } from ${JSON.stringify(executePath)};`,
+        `import { executeNativeAction } from ${JSON.stringify(nativePath)};`,
+        "setNativeRuntimeLoader(async () => ({ executeNativeAction }));",
+        "",
+    ].join("\n");
+}
+function createNodeStorageExports() {
+    const sourceRoot = dirname(fileURLToPath(import.meta.url));
+    const jsonlPath = resolve(sourceRoot, "../storage/node-jsonl.js").replaceAll("\\", "/");
+    const sqlitePath = resolve(sourceRoot, "../storage/node-sqlite.js").replaceAll("\\", "/");
+    return [
+        `export { NodeJsonlSessionStore } from ${JSON.stringify(jsonlPath)};`,
+        `export { NodeSqliteSessionStore } from ${JSON.stringify(sqlitePath)};`,
+        "",
+    ].join("\n");
+}
 function allCompiledAgents(agents) {
     return Object.values(agents).flatMap((agent) => [
         agent,
         ...Object.values(agent.subagents ?? {}),
     ]);
 }
-function createProviderRuntimeSource(providerNames) {
+function createProviderRuntimeSource(providerNames, target) {
     const providersDirectory = resolve(dirname(fileURLToPath(import.meta.url)), "../providers");
     const imports = [];
     const entries = [];
@@ -138,6 +201,10 @@ function createProviderRuntimeSource(providerNames) {
         if (!isBuiltInProvider(name)) {
             throw new Error(`Provider "${name}" is not built in.`);
         }
+        if (target !== "node" &&
+            (name === "bedrock" || name === "vertexai")) {
+            throw new Error(`Provider "${name}" is not available for the ${target} target.`);
+        }
         const descriptor = builtInProviderCatalog[name];
         const localName = `provider${index}`;
         imports.push(`import { ${descriptor.exportName} as ${localName} } from ${JSON.stringify(resolve(providersDirectory, descriptor.moduleFile))};`);

package/dist/compiler/compile.d.ts

@@ -1,3 +1,3 @@
 import type { AgentRegistration, CompiledBundle } from "../types.js";
-export declare function compileRegistry(registrations: Record<string, AgentRegistration>, registryRoot: string, actionRuntime?: "native" | "sandbox"): CompiledBundle;
+export declare function compileRegistry(registrations: Record<string, AgentRegistration>, registryRoot: string, actionRuntime?: "native" | "sandbox", target?: "node" | "browser" | "react-native"): CompiledBundle;
 export declare function serializeBundle(bundle: CompiledBundle): string;

package/dist/compiler/compile.js

@@ -3,7 +3,7 @@ import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { resolve } from "node:path";
 import { buildSync } from "esbuild";
 import { isBuiltInProvider } from "../providers/catalog.js";
-export function compileRegistry(registrations, registryRoot, actionRuntime = "native") {
+export function compileRegistry(registrations, registryRoot, actionRuntime = "native", target = "node") {
     if (!registrations ||
         typeof registrations !== "object" ||
         Array.isArray(registrations)) {
@@ -20,9 +20,9 @@ export function compileRegistry(registrations, registryRoot, actionRuntime = "na
             if (!subagentKey.trim()) {
                 throw new Error(`Agent "${key}" has an empty subagent name.`);
             }
-            subagents[subagentKey] = compileAgent(subagentKey, registeredPath, registryRoot, actionRuntime);
+            subagents[subagentKey] = compileAgent(subagentKey, registeredPath, registryRoot, actionRuntime, target);
         }
-        const parent = compileAgent(key, normalized.path, registryRoot, actionRuntime);
+        const parent = compileAgent(key, normalized.path, registryRoot, actionRuntime, target);
         agents[key] = Object.freeze({
             ...parent,
             subagentPolicy: Object.keys(subagents).length > 0
@@ -72,7 +72,7 @@ function normalizeAgentRegistration(key, registration) {
         subagents: registration.subagents ?? {},
     };
 }
-function compileAgent(key, registeredPath, registryRoot, actionRuntime) {
+function compileAgent(key, registeredPath, registryRoot, actionRuntime, target) {
     const name = key;
     const sourceDirectory = resolve(registryRoot, registeredPath);
     const configPath = resolve(sourceDirectory, "index.json");
@@ -148,7 +148,7 @@ function compileAgent(key, registeredPath, registryRoot, actionRuntime) {
         reasoningLevel: configuration.reasoningLevel,
         outputType: configuration.outputType ?? "text",
         outputSchema: configuration.outputSchema,
-        actions: compileActions(name, sourceDirectory, actionRuntime),
+        actions: compileActions(name, sourceDirectory, actionRuntime, target),
         skills: compileSkills(name, sourceDirectory),
         evaluations: compileEvaluations(name, sourceDirectory),
         subagentPolicy: configuration.subagents
@@ -157,7 +157,7 @@ function compileAgent(key, registeredPath, registryRoot, actionRuntime) {
         subagents: Object.freeze({}),
     });
 }
-function compileActions(agentName, sourceDirectory, actionRuntime) {
+function compileActions(agentName, sourceDirectory, actionRuntime, target) {
     const actionsDirectory = resolve(sourceDirectory, "actions");
     if (!existsSync(actionsDirectory)) {
         return {};
@@ -229,7 +229,7 @@ function compileActions(agentName, sourceDirectory, actionRuntime) {
             throw new Error(`Agent "${agentName}" has duplicate action name "${configuration.name}".`);
         }
         const compiledSource = execution === "local"
-            ? compileLocalAction(agentName, entry.name, actionsDirectory, actionRuntime)
+            ? compileLocalAction(agentName, entry.name, actionsDirectory, actionRuntime, target)
             : undefined;
         actions[configuration.name] = Object.freeze({
             ...configuration,
@@ -413,7 +413,7 @@ function validateEvaluationConfiguration(agentName, registrationName, configurat
         names.add(metric.name);
     }
 }
-function compileLocalAction(agentName, directoryName, actionsDirectory, actionRuntime) {
+function compileLocalAction(agentName, directoryName, actionsDirectory, actionRuntime, target) {
     const entryPath = resolve(actionsDirectory, directoryName, "index.js");
     if (!existsSync(entryPath)) {
         throw new Error(`Local action "${agentName}/${directoryName}" requires index.js.`);
@@ -426,7 +426,9 @@ function compileLocalAction(agentName, directoryName, actionsDirectory, actionRu
             write: false,
             format: "iife",
             globalName: "__orchaActionModule",
-            platform: actionRuntime === "native" ? "node" : "neutral",
+            platform: actionRuntime === "native" && target === "node"
+                ? "node"
+                : "browser",
             target: "es2022",
             logLevel: "silent",
         });

package/dist/file-content.js

@@ -1,5 +1,3 @@
-import { readFile } from "node:fs/promises";
-import { basename, extname, resolve } from "node:path";
 const MIME_TYPES = {
     ".csv": "text/csv",
     ".doc": "application/msword",
@@ -21,8 +19,8 @@ const MIME_TYPES = {
     ".xls": "application/vnd.ms-excel",
     ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
 };
-export function normalizeLocalFile(filePath, mimeType, projectRoot = process.cwd()) {
-    const absolutePath = resolve(projectRoot, filePath);
+export function normalizeLocalFile(filePath, mimeType, projectRoot = ".") {
+    const absolutePath = resolvePortablePath(projectRoot, filePath);
     return {
         type: "file",
         filePath: absolutePath,
@@ -47,22 +45,60 @@ export function normalizeUrlContent(url, mimeType) {
     };
 }
 export async function readLocalFileContent(content) {
+    const fsModule = "node: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: basename(content.filePath),
+        fileName: portableBasename(content.filePath),
     };
 }
 function normalizeMimeType(mimeType, source) {
     if (mimeType?.trim()) {
         return mimeType.trim().toLowerCase();
     }
-    const inferred = MIME_TYPES[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.`);
     }
     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) : "";
+}

package/dist/index.d.ts

@@ -1,8 +1,4 @@
 export { orcha } from "./orcha.js";
-export { OrchaError } from "./errors.js";
-export type { Orcha, OrchaClient } from "./orcha.js";
+export * from "./runtime-entry.js";
 export { NodeJsonlSessionStore } from "./storage/node-jsonl.js";
 export { NodeSqliteSessionStore } from "./storage/node-sqlite.js";
-export { exportSessionJsonl, migrateSessionStore, } from "./storage/migrate.js";
-export type { SessionStoreMigrationResult, } from "./storage/migrate.js";
-export type { ActionConfiguration, AgentTestActionConfiguration, AgentTestActionExpectation, AgentTestActionResponse, AgentTestAssertionResult, AgentTestCaseConfiguration, AgentTestCaseReport, AgentTestCaseSummary, AgentTestExpectation, AgentTestReport, AgentTestTextExpectation, AgentTestValueExpectation, AgentTestWarning, ApiKeyProviderConfiguration, AwsCredentials, AgentContinueInput, AgentConfiguration, AgentContentInput, AgentInput, AgentRegistration, AgentRuntime, ClientCapability, ClientToolCall, CompletedRunResult, CompiledActionManifest, CompiledAgentManifest, CompiledBundle, CompiledEvaluationManifest, CompiledSkillManifest, EvaluationConfiguration, EvaluationMetricConfiguration, EvaluationMetricResult, EvaluationResult, Execution, ExecutionSnapshot, FailedRunResult, FileContent, FilePathContentInput, LocalFileContent, LocalActionRuntimeConfiguration, MessageContent, MessageContentInput, MetadataValue, OrchaErrorCode, OrchaInitConfiguration, PausedRunResult, PaginationOptions, ProjectConfiguration, ProviderConfiguration, ProviderInitConfigurations, ProviderName, BedrockProviderConfiguration, RunError, RunStatus, RunTestsOptions, ResumeInput, RunResult, SessionEvent, SessionEventListOptions, SessionEvents, SessionEventType, SessionHistory, SessionHistoryItem, SessionList, SessionListOptions, SessionMetadata, SessionSnapshot, SessionStatus, SessionStore, SkillConfiguration, SessionUpdate, StreamingRunSnapshot, SubagentConfiguration, TextContent, ToolResult, ToolResumeInput, UrlContentInput, Usage, VertexAIProviderConfiguration, GoogleServiceAccountCredentials, WaitingRunResult, WaitingForSubagentSnapshot, } from "./types.js";

package/dist/index.js

@@ -1,5 +1,4 @@
 export { orcha } from "./orcha.js";
-export { OrchaError } from "./errors.js";
+export * from "./runtime-entry.js";
 export { NodeJsonlSessionStore } from "./storage/node-jsonl.js";
 export { NodeSqliteSessionStore } from "./storage/node-sqlite.js";
-export { exportSessionJsonl, migrateSessionStore, } from "./storage/migrate.js";

package/dist/integrations/esbuild.js

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

package/dist/integrations/expo.d.ts

@@ -0,0 +1 @@
+export { withOrchaMetro as withOrchaExpo, type OrchaMetroOptions as OrchaExpoOptions, } from "./metro.js";

package/dist/integrations/expo.js

@@ -0,0 +1 @@
+export { withOrchaMetro as withOrchaExpo, } from "./metro.js";

package/dist/integrations/metro.d.ts

@@ -0,0 +1,15 @@
+export interface OrchaMetroOptions {
+    projectRoot?: string;
+}
+interface MetroResolverContext {
+    resolveRequest(context: MetroResolverContext, moduleName: string, platform: string | null): unknown;
+}
+interface MetroConfiguration {
+    resolver?: {
+        resolveRequest?: MetroResolverContext["resolveRequest"];
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export declare function withOrchaMetro<T extends MetroConfiguration>(configuration: T, options?: OrchaMetroOptions): Promise<T>;
+export {};