orchajs 0.20.2 → 0.21.0

package/dist/orcha.js

@@ -1,9 +1,12 @@
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { compileRegistry } from "./compiler/compile.js";
 import { generateProviderResponse } from "./providers/index.js";
-import { setSandboxRuntimeLoader } from "./runtime/actions/execute.js";
+import { setNativeRuntimeLoader, setSandboxRuntimeLoader, } from "./runtime/actions/execute.js";
+import { executeNativeAction } from "./runtime/actions/native.js";
+import { getRegistryCompiler } from "./runtime/compiler-hook.js";
 import { createOrcha } from "./runtime/create-orcha.js";
+import { nodeRuntimePlatform } from "./runtime/platform-node.js";
+setNativeRuntimeLoader(async () => ({ executeNativeAction }));
 setSandboxRuntimeLoader(async () => {
     const modulePath = "./runtime/actions/sandbox.js";
     return import(modulePath);
@@ -12,13 +15,16 @@ export const orcha = createOrcha((configuration) => {
     const projectRoot = resolve(configuration.root ??
         process.env.ORCHA_PROJECT_ROOT ??
         process.cwd());
-    if (process.env.ORCHA_COMPILING !== "1" &&
-        isPrecompiledRuntime()) {
+    const compiler = getRegistryCompiler();
+    if (process.env.ORCHA_COMPILING === "1" && compiler) {
+        return compiler(configuration, projectRoot);
+    }
+    if (isPrecompiledRuntime() ||
+        existsSync(compiledManifestPath(projectRoot))) {
         return loadCompiledManifest(projectRoot, configuration);
     }
-    const registryRoot = resolve(projectRoot, "orcha");
-    return compileRegistry(configuration.agents, registryRoot, configuration.actions?.runtime ?? "native");
-}, generateProviderResponse);
+    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.');
+}, generateProviderResponse, nodeRuntimePlatform);
 function isPrecompiledRuntime() {
     return (process.env.ORCHA_USE_BUILD === "1" ||
         process.env.NODE_ENV === "production" ||
@@ -26,7 +32,7 @@ function isPrecompiledRuntime() {
         process.env.AWS_EXECUTION_ENV?.startsWith("AWS_Lambda_") === true);
 }
 function loadCompiledManifest(projectRoot, configuration) {
-    const manifestPath = resolve(projectRoot, ".orcha/dist/manifest.json");
+    const manifestPath = compiledManifestPath(projectRoot);
     if (!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.`);
     }
@@ -56,3 +62,6 @@ function loadCompiledManifest(projectRoot, configuration) {
     }
     return bundle;
 }
+function compiledManifestPath(projectRoot) {
+    return resolve(projectRoot, ".orcha/dist/manifest.json");
+}

package/dist/playground/server.js

@@ -1,11 +1,12 @@
 import { spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { dirname, extname, isAbsolute, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { copyFile, mkdir, readFile, writeFile, } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { extname, isAbsolute, relative, resolve } from "node:path";
 import { createServer, } from "node:http";
 import { watch } from "chokidar";
+import { build } from "esbuild";
 import { orcha } from "../orcha.js";
 import { loadProject } from "../project-loader.js";
 import { listTests, runTests } from "../testing.js";
@@ -20,6 +21,7 @@ export async function startPlayground(options = {}) {
     const mutationToken = randomBytes(32).toString("base64url");
     const allowedHosts = playgroundHosts(host, port);
     await loadProject(projectRoot);
+    const publicRoot = await buildPlaygroundAssets(projectRoot);
     const projectClients = new Set();
     const server = createServer(async (request, response) => {
         try {
@@ -32,6 +34,7 @@ export async function startPlayground(options = {}) {
                 projectClients,
                 mutationToken,
                 allowedHosts,
+                publicRoot,
             });
         }
         catch (error) {
@@ -312,7 +315,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." });
@@ -444,8 +447,7 @@ async function readAllEventPages(read) {
     }
     return pages.flat();
 }
-async function serveAsset(response, pathname) {
-    const publicRoot = resolve(dirname(fileURLToPath(import.meta.url)), "public");
+async function serveAsset(response, pathname, publicRoot) {
     const requested = pathname === "/" ? "index.html" : pathname.slice(1);
     const path = resolve(publicRoot, requested);
     const relativePath = relative(publicRoot, path);
@@ -455,7 +457,7 @@ async function serveAsset(response, pathname) {
         const indexPath = resolve(publicRoot, "index.html");
         if (!existsSync(indexPath)) {
             sendJson(response, 503, {
-                error: "Playground assets are missing. Rebuild orchajs.",
+                error: "Playground assets are missing. Restart the Orcha playground.",
             });
             return;
         }
@@ -472,6 +474,54 @@ async function serveAsset(response, pathname) {
     });
     response.end(await readFile(path));
 }
+async function buildPlaygroundAssets(projectRoot) {
+    const require = createRequire(import.meta.url);
+    let entryPath;
+    let logoPath;
+    try {
+        entryPath = require.resolve("@orchajs/playground-ui/mount");
+        logoPath = require.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 = resolve(projectRoot, ".orcha/playground");
+    await mkdir(publicRoot, { recursive: true });
+    await Promise.all([
+        build({
+            entryPoints: [entryPath],
+            outfile: 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"),
+            },
+        }),
+        copyFile(logoPath, resolve(publicRoot, "orcha-logo.svg")),
+        writeFile(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 (extname(path)) {
         case ".html":

package/dist/project-loader.js

@@ -3,9 +3,12 @@ import { mkdir, rm } from "node:fs/promises";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { build as bundleEntry } from "esbuild";
+import { compileRegistry } from "./compiler/compile.js";
 import { loadProjectEnvironment } from "./env.js";
 import { orcha } from "./orcha.js";
+import { setRegistryCompiler } from "./runtime/compiler-hook.js";
 export async function loadProject(projectRoot) {
+    setRegistryCompiler((configuration, compilerProjectRoot) => compileRegistry(configuration.agents, resolve(compilerProjectRoot, "orcha"), configuration.actions?.runtime ?? "native", "node"));
     loadProjectEnvironment(projectRoot);
     const registryPath = resolve(projectRoot, "orcha/index.ts");
     if (!existsSync(registryPath)) {

package/dist/providers/browser.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderResponseGenerator } from "./types.js";
+export declare const generateBrowserProviderResponse: ProviderResponseGenerator;

package/dist/providers/browser.js

@@ -0,0 +1,20 @@
+import { OrchaError } from "../errors.js";
+const loadedProviders = new Map();
+const loaders = {
+    anthropic: () => import("./anthropic.js").then((module) => module.anthropicProvider),
+    deepseek: () => import("./deepseek.js").then((module) => module.deepSeekProvider),
+    googlegenai: () => import("./google-genai.js").then((module) => module.googleGenAIProvider),
+    openai: () => import("./openai.js").then((module) => module.openAIProvider),
+};
+export const generateBrowserProviderResponse = async (name, configuration, request) => {
+    const loader = loaders[name];
+    if (!loader) {
+        throw new 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);
+};

package/dist/react-native.d.ts

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

package/dist/react-native.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 { reactNativeRuntimePlatform } from "./runtime/platform-react-native.js";
+setNativeRuntimeLoader(async () => {
+    const modulePath = "./runtime/actions/browser-native.js";
+    return import(modulePath);
+});
+export const orcha = createOrcha(() => {
+    throw new Error("The React Native runtime requires a precompiled Orcha bundle. Configure the Orcha Metro integration.");
+}, generateBrowserProviderResponse, reactNativeRuntimePlatform);
+export * from "./runtime-entry.js";

package/dist/runtime/actions/browser-native.d.ts

@@ -0,0 +1,3 @@
+import type { CompiledActionManifest } from "../../types.js";
+import type { LocalActionContext } from "./context.js";
+export declare function executeNativeAction(action: CompiledActionManifest, parameters: Record<string, unknown>, context: LocalActionContext): Promise<unknown>;

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

@@ -0,0 +1,28 @@
+export 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";\n${action.source}\nreturn __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 ?? 10_000;
+    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);
+        }
+    }
+}

package/dist/runtime/actions/execute.d.ts

@@ -1,8 +1,15 @@
 import type { CompiledActionManifest, LocalActionRuntimeConfiguration, SessionMetadata } from "../../types.js";
+import { type LocalActionContext } from "./context.js";
 type SandboxRuntime = typeof import("./sandbox.js");
 type SandboxRuntimeLoader = () => Promise<SandboxRuntime>;
+interface NativeRuntime {
+    executeNativeAction(action: CompiledActionManifest, parameters: Record<string, unknown>, context: LocalActionContext): Promise<unknown>;
+}
+type NativeRuntimeLoader = () => Promise<NativeRuntime>;
 /** @internal Supplies the statically bundled sandbox in production builds. */
 export declare function setSandboxRuntimeLoader(loader: SandboxRuntimeLoader): void;
+/** @internal Supplies the platform-specific native action executor. */
+export declare function setNativeRuntimeLoader(loader: NativeRuntimeLoader): void;
 export declare function executeLocalAction(options: {
     action: CompiledActionManifest;
     parameters: Record<string, unknown>;

package/dist/runtime/actions/execute.js

@@ -1,5 +1,7 @@
-import { createLocalActionContext } from "./context.js";
-import { executeNativeAction } from "./native.js";
+import { createLocalActionContext, } from "./context.js";
+let loadConfiguredNativeRuntime = async () => {
+    throw new Error("The native action runtime was not included in this Orcha build.");
+};
 let loadConfiguredSandboxRuntime = async () => {
     throw new Error("The QuickJS sandbox runtime was not included in this Orcha build.");
 };
@@ -7,9 +9,14 @@ let loadConfiguredSandboxRuntime = async () => {
 export function setSandboxRuntimeLoader(loader) {
     loadConfiguredSandboxRuntime = loader;
 }
+/** @internal Supplies the platform-specific native action executor. */
+export function setNativeRuntimeLoader(loader) {
+    loadConfiguredNativeRuntime = loader;
+}
 export async function executeLocalAction(options) {
     const context = createLocalActionContext(options);
     if (options.configuration.runtime === "native") {
+        const { executeNativeAction } = await loadConfiguredNativeRuntime();
         return executeNativeAction(options.action, options.parameters, context);
     }
     if (process.env.ORCHA_INCLUDE_SANDBOX !== "0") {

package/dist/runtime/agent.d.ts

@@ -17,6 +17,7 @@ export declare class RuntimeAgent implements AgentRuntime {
         delegatedOnly?: boolean;
         sessionIdPrefix?: string;
         projectRoot?: string;
+        randomUUID?: () => string;
     });
     get agent(): string;
     get clientTools(): CompiledActionManifest[];

package/dist/runtime/agent.js

@@ -1,10 +1,10 @@
-import { randomUUID } from "node:crypto";
 import { OrchaError } from "../errors.js";
 import { normalizeLocalFile, normalizeUrlContent, } from "../file-content.js";
 import { messagesFromEvents, normalizePersistedToolResults, SessionEventWriter, } from "./session-events.js";
 import { validateStructuredValue } from "./structured-output.js";
 import { executeLocalAction } from "./actions/execute.js";
 import { createExecution, } from "./execution.js";
+import { portableRandomUUID } from "./random-id.js";
 const LOAD_SKILL_TOOL_NAME = "load_skill";
 const RUN_AGENT_TOOL_NAME = "run_agent";
 const RESUME_AGENT_TOOL_NAME = "resume_agent";
@@ -27,6 +27,7 @@ export class RuntimeAgent {
     #agentKey;
     #sessionIdPrefix;
     #projectRoot;
+    #randomUUID;
     #evaluationTasks = new Map();
     #sessionIdleWaiters = new Map();
     constructor(options) {
@@ -40,7 +41,8 @@ export class RuntimeAgent {
         this.#delegatedOnly = options.delegatedOnly ?? false;
         this.#agentKey = options.manifest.key ?? options.manifest.name;
         this.#sessionIdPrefix = options.sessionIdPrefix ?? "ses_";
-        this.#projectRoot = options.projectRoot ?? process.cwd();
+        this.#projectRoot = options.projectRoot ?? ".";
+        this.#randomUUID = options.randomUUID ?? portableRandomUUID;
     }
     get agent() {
         return this.#agentKey;
@@ -65,7 +67,7 @@ export class RuntimeAgent {
         return this.#run(input);
     }
     createDelegatedSessionId() {
-        return createSessionId(this.#sessionIdPrefix);
+        return createSessionId(this.#sessionIdPrefix, this.#randomUUID);
     }
     runAsChild(sessionId, input, lineage) {
         const normalized = typeof input === "string" ? { content: input } : input;
@@ -76,7 +78,8 @@ export class RuntimeAgent {
     }
     #run(input, lineage, requestedSessionId) {
         const normalized = typeof input === "string" ? { content: input } : input;
-        const sessionId = requestedSessionId ?? createSessionId(this.#sessionIdPrefix);
+        const sessionId = requestedSessionId ??
+            createSessionId(this.#sessionIdPrefix, this.#randomUUID);
         if (typeof normalized === "object" &&
             normalized !== null &&
             "sessionId" in normalized) {
@@ -1836,7 +1839,7 @@ function normalizeMetadata(metadata) {
     }
     return normalized;
 }
-function createSessionId(prefix) {
+function createSessionId(prefix, randomUUID) {
     const utcTimestamp = new Date()
         .toISOString()
         .replace(/\.\d{3}Z$/, "")

package/dist/runtime/compiler-hook.d.ts

@@ -0,0 +1,5 @@
+import type { CompiledBundle, OrchaInitConfiguration } from "../types.js";
+export type RegistryCompiler = (configuration: OrchaInitConfiguration, projectRoot: string) => CompiledBundle;
+/** @internal Installed by Node development tooling, never by runtime bundles. */
+export declare function setRegistryCompiler(compiler: RegistryCompiler): void;
+export declare function getRegistryCompiler(): RegistryCompiler | undefined;

package/dist/runtime/compiler-hook.js

@@ -0,0 +1,8 @@
+let registryCompiler;
+/** @internal Installed by Node development tooling, never by runtime bundles. */
+export function setRegistryCompiler(compiler) {
+    registryCompiler = compiler;
+}
+export function getRegistryCompiler() {
+    return registryCompiler;
+}

package/dist/runtime/create-orcha.d.ts

@@ -1,4 +1,5 @@
 import type { ProviderResponseGenerator } from "../providers/types.js";
+import type { RuntimePlatform } from "./platform.js";
 import type { AgentRuntime, CompiledBundle, OrchaInitConfiguration } from "../types.js";
 export interface Orcha {
     init(configuration: OrchaInitConfiguration): OrchaClient;
@@ -8,4 +9,4 @@ export interface Orcha {
 }
 export type OrchaClient = Orcha & Record<string, AgentRuntime>;
 export type BundleResolver = (configuration: OrchaInitConfiguration) => CompiledBundle;
-export declare function createOrcha(resolveBundle: BundleResolver, generateProviderResponse: ProviderResponseGenerator): OrchaClient;
+export declare function createOrcha(resolveBundle: BundleResolver, generateProviderResponse: ProviderResponseGenerator, platform: RuntimePlatform): OrchaClient;

package/dist/runtime/create-orcha.js

@@ -1,7 +1,4 @@
-import { resolve } from "node:path";
 import { RuntimeAgent } from "./agent.js";
-import { createSessionStore } from "../storage/create-store.js";
-import { syncAmarsiaProject } from "../amarsia/sync.js";
 import { setOrchaRuntimeContext } from "./context.js";
 class OrchaRuntimeCore {
     #agents = new Map();
@@ -11,22 +8,21 @@ class OrchaRuntimeCore {
     #sessionControls = new Map();
     #resolveBundle;
     #generateProviderResponse;
-    constructor(resolveBundle, generateProviderResponse) {
+    #platform;
+    constructor(resolveBundle, generateProviderResponse, platform) {
         this.#resolveBundle = resolveBundle;
         this.#generateProviderResponse = generateProviderResponse;
+        this.#platform = platform;
     }
     attachClient(client) {
         this.#client = client;
     }
     init(configuration) {
-        const projectRoot = resolve(configuration.root ??
-            process.env.ORCHA_PROJECT_ROOT ??
-            process.cwd());
-        const bundle = this.#resolveBundle(configuration);
-        if (configuration.amarsia?.key) {
-            syncAmarsiaProject({
-                key: configuration.amarsia.key,
-                endpoint: configuration.amarsia.endpoint,
+        const projectRoot = this.#platform.projectRoot(configuration);
+        const bundle = configuration.bundle ?? this.#resolveBundle(configuration);
+        if (configuration.amarsia?.key && this.#platform.syncProject) {
+            this.#platform.syncProject({
+                configuration,
                 bundle,
                 projectRoot,
             });
@@ -46,12 +42,10 @@ class OrchaRuntimeCore {
             runtimeConfiguration.actions?.runtime !== bundle.actionRuntime) {
             throw new Error(`Production bundle expects local action runtime "${bundle.actionRuntime}".`);
         }
-        const storageDirectory = configuration.storage?.directory ?? ".orcha/sessions";
-        const createStore = (manifest) => createSessionStore({
-            strategy: configuration.storage?.strategy,
-            directory: storageDirectory,
+        const createStore = (manifest) => this.#platform.createSessionStore({
+            configuration,
             projectRoot,
-            agentName: manifest.key ?? manifest.name,
+            manifest,
         });
         const agents = new Map();
         for (const [name, manifest] of Object.entries(bundle.agents)) {
@@ -66,6 +60,7 @@ class OrchaRuntimeCore {
                     generateProviderResponse: this.#generateProviderResponse,
                     delegatedOnly: true,
                     projectRoot,
+                    randomUUID: this.#platform.randomUUID,
                 }),
             ]));
             agents.set(name, new RuntimeAgent({
@@ -77,6 +72,7 @@ class OrchaRuntimeCore {
                 generateProviderResponse: this.#generateProviderResponse,
                 subagents,
                 projectRoot,
+                randomUUID: this.#platform.randomUUID,
             }));
         }
         this.#bundle = bundle;
@@ -103,8 +99,8 @@ class OrchaRuntimeCore {
         return this.#agents.get(name);
     }
 }
-export function createOrcha(resolveBundle, generateProviderResponse) {
-    const core = new OrchaRuntimeCore(resolveBundle, generateProviderResponse);
+export function createOrcha(resolveBundle, generateProviderResponse, platform) {
+    const core = new OrchaRuntimeCore(resolveBundle, generateProviderResponse, platform);
     const client = new Proxy(core, {
         get(target, property) {
             if (typeof property === "string") {

package/dist/runtime/platform-browser.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimePlatform } from "./platform.js";
+export declare const browserRuntimePlatform: RuntimePlatform;

package/dist/runtime/platform-browser.js

@@ -0,0 +1,15 @@
+import { BrowserIndexedDbSessionStore } from "../storage/browser-indexeddb.js";
+import { portableRandomUUID } from "./random-id.js";
+export const browserRuntimePlatform = {
+    randomUUID: portableRandomUUID,
+    projectRoot(configuration) {
+        return configuration.root ?? "/";
+    },
+    createSessionStore({ configuration, manifest }) {
+        const strategy = configuration.storage?.strategy ?? "indexeddb";
+        if (strategy !== "indexeddb") {
+            throw new Error(`Browser runtimes require storage strategy "indexeddb", received "${strategy}".`);
+        }
+        return new BrowserIndexedDbSessionStore(manifest.key ?? manifest.name, configuration.storage?.directory ?? "orchajs");
+    },
+};

package/dist/runtime/platform-node.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimePlatform } from "./platform.js";
+export declare const nodeRuntimePlatform: RuntimePlatform;

package/dist/runtime/platform-node.js

@@ -0,0 +1,31 @@
+import { randomUUID } from "node:crypto";
+import { resolve } from "node:path";
+import { syncAmarsiaProject } from "../amarsia/sync.js";
+import { createSessionStore } from "../storage/create-store.js";
+export const nodeRuntimePlatform = {
+    randomUUID,
+    projectRoot(configuration) {
+        return resolve(configuration.root ??
+            process.env.ORCHA_PROJECT_ROOT ??
+            process.cwd());
+    },
+    createSessionStore({ configuration, projectRoot, manifest }) {
+        return createSessionStore({
+            strategy: configuration.storage?.strategy,
+            directory: configuration.storage?.directory,
+            projectRoot,
+            agentName: manifest.key ?? manifest.name,
+        });
+    },
+    syncProject({ configuration, bundle, projectRoot }) {
+        if (!configuration.amarsia?.key) {
+            return;
+        }
+        syncAmarsiaProject({
+            key: configuration.amarsia.key,
+            endpoint: configuration.amarsia.endpoint,
+            bundle,
+            projectRoot,
+        });
+    },
+};

package/dist/runtime/platform-react-native.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimePlatform } from "./platform.js";
+export declare const reactNativeRuntimePlatform: RuntimePlatform;

package/dist/runtime/platform-react-native.js

@@ -0,0 +1,15 @@
+import { ReactNativeJsonlSessionStore } from "../storage/react-native-jsonl.js";
+import { portableRandomUUID } from "./random-id.js";
+export const reactNativeRuntimePlatform = {
+    randomUUID: portableRandomUUID,
+    projectRoot(configuration) {
+        return configuration.root ?? "/";
+    },
+    createSessionStore({ configuration, manifest }) {
+        const strategy = configuration.storage?.strategy ?? "react-native";
+        if (strategy !== "react-native") {
+            throw new Error(`React Native requires storage strategy "react-native", received "${strategy}".`);
+        }
+        return new ReactNativeJsonlSessionStore(manifest.key ?? manifest.name);
+    },
+};

package/dist/runtime/platform.d.ts

@@ -0,0 +1,15 @@
+import type { CompiledAgentManifest, CompiledBundle, OrchaInitConfiguration, SessionStore } from "../types.js";
+export interface RuntimePlatform {
+    randomUUID(): string;
+    projectRoot(configuration: OrchaInitConfiguration): string;
+    createSessionStore(options: {
+        configuration: OrchaInitConfiguration;
+        projectRoot: string;
+        manifest: CompiledAgentManifest;
+    }): SessionStore;
+    syncProject?(options: {
+        configuration: OrchaInitConfiguration;
+        bundle: CompiledBundle;
+        projectRoot: string;
+    }): void;
+}

package/dist/runtime/platform.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/random-id.d.ts

@@ -0,0 +1 @@
+export declare function portableRandomUUID(): string;

package/dist/runtime/random-id.js

@@ -0,0 +1,26 @@
+let fallbackSequence = 0;
+export function portableRandomUUID() {
+    const crypto = globalThis.crypto;
+    if (typeof crypto?.randomUUID === "function") {
+        return crypto.randomUUID();
+    }
+    if (typeof crypto?.getRandomValues === "function") {
+        return formatUuid(crypto.getRandomValues(new Uint8Array(16)));
+    }
+    fallbackSequence = (fallbackSequence + 1) >>> 0;
+    const bytes = new Uint8Array(16);
+    let state = Date.now() ^
+        fallbackSequence ^
+        Math.floor(Math.random() * 0x1_0000_0000);
+    for (let index = 0; index < bytes.length; index += 1) {
+        state = (Math.imul(state, 1_664_525) + 1_013_904_223) >>> 0;
+        bytes[index] = state >>> 24;
+    }
+    return formatUuid(bytes);
+}
+function formatUuid(bytes) {
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const value = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+    return `${value.slice(0, 8)}-${value.slice(8, 12)}-${value.slice(12, 16)}-${value.slice(16, 20)}-${value.slice(20)}`;
+}

package/dist/runtime-entry.d.ts

@@ -0,0 +1,5 @@
+export { OrchaError } from "./errors.js";
+export type { Orcha, OrchaClient, } from "./runtime/create-orcha.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/runtime-entry.js

@@ -0,0 +1,2 @@
+export { OrchaError } from "./errors.js";
+export { exportSessionJsonl, migrateSessionStore, } from "./storage/migrate.js";

package/dist/storage/browser-indexeddb.d.ts

@@ -1,20 +1,11 @@
 import type { SessionEvent, SessionStore } from "../types.js";
-/**
- * Future browser storage strategy.
- *
- * It will persist the same ordered SessionEvent records used by the JSONL
- * strategy in IndexedDB. Import and export will preserve the canonical JSONL
- * representation so a session can move between browser, Node, and remote
- * stores without changing the runtime or replay engine.
- *
- * Required before implementation:
- * - transactional sequence allocation;
- * - multi-tab writer coordination;
- * - quota and eviction handling;
- * - schema migrations and JSONL import/export.
- */
 export declare class BrowserIndexedDbSessionStore implements SessionStore {
-    read(_sessionId: string): Promise<SessionEvent[]>;
-    append(_sessionId: string, _events: SessionEvent[]): Promise<void>;
+    #private;
+    constructor(namespace: string, databaseName?: string);
+    read(sessionId: string): Promise<SessionEvent[]>;
+    append(sessionId: string, events: SessionEvent[]): Promise<void>;
     listSessionIds(): Promise<string[]>;
+    subscribe(sessionId: string, listener: (events: SessionEvent[]) => void): () => void;
+    subscribeAll(listener: (sessionId: string, events: SessionEvent[]) => void): () => void;
+    describeLocation(sessionId: string): Promise<string>;
 }