orchajs 0.20.2 → 0.21.0

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 {};

package/dist/integrations/metro.js

@@ -0,0 +1,25 @@
+import { resolve } from "node:path";
+import { generatedBundlePath, queueRuntimeBuild, watchRuntimeTargets, } from "./runtime-build.js";
+export async function withOrchaMetro(configuration, options = {}) {
+    const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    await queueRuntimeBuild(projectRoot, "react-native");
+    if (process.env.NODE_ENV !== "production") {
+        watchRuntimeTargets(projectRoot, ["react-native"]);
+    }
+    const existingResolver = configuration.resolver?.resolveRequest;
+    return {
+        ...configuration,
+        resolver: {
+            ...configuration.resolver,
+            resolveRequest(context, moduleName, platform) {
+                const requestedModule = moduleName === "orchajs"
+                    ? generatedBundlePath(projectRoot, "react-native")
+                    : moduleName;
+                if (existingResolver) {
+                    return existingResolver(context, requestedModule, platform);
+                }
+                return context.resolveRequest(context, requestedModule, platform);
+            },
+        },
+    };
+}

package/dist/integrations/next.d.ts

@@ -0,0 +1,23 @@
+export interface OrchaNextOptions {
+    projectRoot?: string;
+}
+interface NextWebpackContext {
+    isServer: boolean;
+    nextRuntime?: string;
+}
+interface WebpackConfiguration {
+    plugins?: unknown[];
+    resolve?: {
+        alias?: Record<string, unknown>;
+    };
+}
+interface NextConfiguration {
+    turbopack?: {
+        resolveAlias?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+    webpack?: (configuration: WebpackConfiguration, context: NextWebpackContext) => WebpackConfiguration;
+    [key: string]: unknown;
+}
+export declare function withOrcha<T extends NextConfiguration>(configuration?: T, options?: OrchaNextOptions): Promise<T>;
+export {};

package/dist/integrations/next.js

@@ -0,0 +1,53 @@
+import { resolve } from "node:path";
+import { generatedBundlePath, queueRuntimeBuild, watchRuntimeTargets, } from "./runtime-build.js";
+import { OrchaWebpackPlugin } from "./webpack.js";
+export async function withOrcha(configuration = {}, options = {}) {
+    const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    await queueRuntimeBuild(projectRoot, "browser");
+    await queueRuntimeBuild(projectRoot, "node");
+    if (process.env.NODE_ENV !== "production") {
+        watchRuntimeTargets(projectRoot, ["browser", "node"]);
+    }
+    const existingWebpack = configuration.webpack;
+    return {
+        ...configuration,
+        turbopack: {
+            ...configuration.turbopack,
+            resolveAlias: {
+                ...configuration.turbopack?.resolveAlias,
+                orchajs: {
+                    browser: generatedBundlePath(projectRoot, "browser"),
+                },
+            },
+        },
+        webpack(webpackConfiguration, context) {
+            const target = nextTarget(context);
+            if (target === "node") {
+                return existingWebpack
+                    ? existingWebpack(webpackConfiguration, context)
+                    : webpackConfiguration;
+            }
+            const plugin = new 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";
+}

package/dist/integrations/runtime-build.d.ts

@@ -0,0 +1,4 @@
+export type RuntimeBuildTarget = "node" | "browser" | "react-native";
+export declare function generatedBundlePath(projectRoot: string, target: RuntimeBuildTarget): string;
+export declare function queueRuntimeBuild(projectRoot: string, target: RuntimeBuildTarget): Promise<void>;
+export declare function watchRuntimeTargets(projectRoot: string, targets: RuntimeBuildTarget[]): void;

package/dist/integrations/runtime-build.js

@@ -0,0 +1,32 @@
+import { resolve } from "node:path";
+import { watch } from "chokidar";
+import { buildProject } from "../compiler/build-project.js";
+import { loadProjectEnvironment } from "../env.js";
+let buildQueue = Promise.resolve();
+const watchedTargets = new Set();
+export function generatedBundlePath(projectRoot, target) {
+    const fileName = target === "node" ? "bundle.js" : `bundle.${target}.js`;
+    return resolve(projectRoot, ".orcha/dist", fileName);
+}
+export function queueRuntimeBuild(projectRoot, target) {
+    const build = buildQueue.then(async () => {
+        loadProjectEnvironment(projectRoot);
+        await buildProject({ projectRoot, target });
+    });
+    buildQueue = build.catch(() => undefined);
+    return build;
+}
+export function watchRuntimeTargets(projectRoot, targets) {
+    const key = `${projectRoot}:${targets.join(",")}`;
+    if (watchedTargets.has(key)) {
+        return;
+    }
+    watchedTargets.add(key);
+    let timer;
+    watch(resolve(projectRoot, "orcha"), { ignoreInitial: true }).on("all", () => {
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+            void targets.reduce((pending, target) => pending.then(() => queueRuntimeBuild(projectRoot, target)), Promise.resolve());
+        }, 75);
+    });
+}

package/dist/integrations/vite.d.ts

@@ -0,0 +1,23 @@
+export interface OrchaVitePluginOptions {
+    projectRoot?: string;
+}
+export declare function orchaVitePlugin(options?: OrchaVitePluginOptions): {
+    name: string;
+    enforce: "pre";
+    configResolved(config: {
+        root: string;
+    }): void;
+    buildStart(): Promise<void>;
+    configureServer(server: {
+        watcher: {
+            add(path: string): void;
+            on(event: "all", listener: (_event: string, path: string) => void): void;
+        };
+        ws: {
+            send(message: {
+                type: "full-reload";
+            }): void;
+        };
+    }): void;
+    resolveId(source: string): string | undefined;
+};

package/dist/integrations/vite.js

@@ -0,0 +1,32 @@
+import { resolve, sep } from "node:path";
+import { generatedBundlePath, queueRuntimeBuild, } from "./runtime-build.js";
+export function orchaVitePlugin(options = {}) {
+    let projectRoot = resolve(options.projectRoot ?? process.cwd());
+    return {
+        name: "orchajs",
+        enforce: "pre",
+        configResolved(config) {
+            projectRoot = resolve(options.projectRoot ?? config.root);
+        },
+        async buildStart() {
+            await queueRuntimeBuild(projectRoot, "browser");
+        },
+        configureServer(server) {
+            const registryDirectory = resolve(projectRoot, "orcha");
+            server.watcher.add(registryDirectory);
+            server.watcher.on("all", (_event, path) => {
+                if (path === registryDirectory ||
+                    path.startsWith(`${registryDirectory}${sep}`)) {
+                    void queueRuntimeBuild(projectRoot, "browser").then(() => {
+                        server.ws.send({ type: "full-reload" });
+                    });
+                }
+            });
+        },
+        resolveId(source) {
+            return source === "orchajs"
+                ? generatedBundlePath(projectRoot, "browser")
+                : undefined;
+        },
+    };
+}

package/dist/integrations/webpack.d.ts

@@ -0,0 +1,24 @@
+import { type RuntimeBuildTarget } from "./runtime-build.js";
+export interface OrchaWebpackPluginOptions {
+    projectRoot?: string;
+    target?: RuntimeBuildTarget;
+}
+interface WebpackCompiler {
+    hooks: {
+        beforeCompile: {
+            tapPromise(name: string, callback: () => Promise<void>): void;
+        };
+        afterCompile: {
+            tap(name: string, callback: (compilation: {
+                contextDependencies: Set<string>;
+            }) => void): void;
+        };
+    };
+}
+export declare class OrchaWebpackPlugin {
+    #private;
+    constructor(options?: OrchaWebpackPluginOptions);
+    get bundlePath(): string;
+    apply(compiler: WebpackCompiler): void;
+}
+export {};

package/dist/integrations/webpack.js

@@ -0,0 +1,21 @@
+import { resolve } from "node:path";
+import { generatedBundlePath, queueRuntimeBuild, } from "./runtime-build.js";
+export class OrchaWebpackPlugin {
+    #projectRoot;
+    #target;
+    constructor(options = {}) {
+        this.#projectRoot = resolve(options.projectRoot ?? process.cwd());
+        this.#target = options.target ?? "browser";
+    }
+    get bundlePath() {
+        return generatedBundlePath(this.#projectRoot, this.#target);
+    }
+    apply(compiler) {
+        compiler.hooks.beforeCompile.tapPromise("orchajs", async () => {
+            await queueRuntimeBuild(this.#projectRoot, this.#target);
+        });
+        compiler.hooks.afterCompile.tap("orchajs", (compilation) => {
+            compilation.contextDependencies.add(resolve(this.#projectRoot, "orcha"));
+        });
+    }
+}