@roj-ai/isolate-runtime 0.0.0 → 0.2.14

package/dist/modules.js

@@ -0,0 +1,52 @@
+/**
+ * The Worker Loader module map a host builds once per runtime version (`./build`) and completes with
+ * one app bundle per instance. Free of Bun and Node APIs, so a host can use it inside a Worker.
+ */
+/** The module name the main module imports the app's config from. */
+export const APP_BUNDLE_MODULE = 'roj-app-bundle';
+/** The runtime's modules plus one app bundle: what a host passes to `LOADER.get()`. */
+export function withAppBundle(runtime, appBundle) {
+    return { mainModule: runtime.mainModule, modules: { ...runtime.modules, [APP_BUNDLE_MODULE]: { js: appBundle } } };
+}
+/** The loader resolves a specifier against the importing module's directory, a bare one included. */
+function resolveModuleName(importer, specifier) {
+    if (specifier.startsWith('/'))
+        return specifier.slice(1);
+    const parts = importer.split('/').slice(0, -1);
+    for (const part of specifier.split('/')) {
+        if (part === '..')
+            parts.pop();
+        else if (part !== '.')
+            parts.push(part);
+    }
+    return parts.join('/');
+}
+const STATIC_IMPORT = /^(?:import|export)\b[^;'"]*?\bfrom\s*["']([^"']+)["']|^import\s*["']([^"']+)["']/gm;
+const DYNAMIC_IMPORT = /\bimport\(\s*["']([^"']+)["']\s*\)/g;
+/** Bun's `target: 'bun'` output loads CommonJS dependencies through it; workerd has no such API. */
+const BUN_REQUIRE = 'import.meta.require';
+/**
+ * Imports that would not resolve under the loader's rules, plus any use of `import.meta.require`,
+ * reported with that as the specifier. Bun's unminified ESM output keeps every static import at the
+ * start of a line, which is what the scan relies on. Platform builtins (`node:`, `cloudflare:`) are not checked.
+ */
+export function unresolvedImports(modules) {
+    const missing = [];
+    for (const [name, module] of Object.entries(modules)) {
+        const source = typeof module === 'string' ? module : module.js;
+        const specifiers = [
+            ...[...source.matchAll(STATIC_IMPORT)].map(match => match[1] ?? match[2]),
+            ...[...source.matchAll(DYNAMIC_IMPORT)].map(match => match[1]),
+        ];
+        for (const specifier of specifiers) {
+            if (specifier === undefined || /^(?:node|cloudflare):/.test(specifier))
+                continue;
+            if (!(resolveModuleName(name, specifier) in modules))
+                missing.push({ module: name, specifier });
+        }
+        if (source.includes(BUN_REQUIRE))
+            missing.push({ module: name, specifier: BUN_REQUIRE });
+    }
+    return missing;
+}
+//# sourceMappingURL=modules.js.map

package/dist/modules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modules.js","sourceRoot":"","sources":["../src/modules.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAUH,qEAAqE;AACrE,MAAM,CAAC,MAAM,iBAAiB,GAAG,gBAAgB,CAAA;AAEjD,uFAAuF;AACvF,MAAM,UAAU,aAAa,CAAC,OAAuB,EAAE,SAAiB;IACvE,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE,OAAO,EAAE,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,iBAAiB,CAAC,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,CAAA;AACnH,CAAC;AAED,qGAAqG;AACrG,SAAS,iBAAiB,CAAC,QAAgB,EAAE,SAAiB;IAC7D,IAAI,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;IACxD,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IAC9C,KAAK,MAAM,IAAI,IAAI,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QACzC,IAAI,IAAI,KAAK,IAAI;YAAE,KAAK,CAAC,GAAG,EAAE,CAAA;aACzB,IAAI,IAAI,KAAK,GAAG;YAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACxC,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACvB,CAAC;AAED,MAAM,aAAa,GAAG,oFAAoF,CAAA;AAC1G,MAAM,cAAc,GAAG,qCAAqC,CAAA;AAC5D,oGAAoG;AACpG,MAAM,WAAW,GAAG,qBAAqB,CAAA;AAEzC;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,OAAqC;IACtE,MAAM,OAAO,GAA4C,EAAE,CAAA;IAC3D,KAAK,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACtD,MAAM,MAAM,GAAG,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAA;QAC9D,MAAM,UAAU,GAAG;YAClB,GAAG,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC;YACzE,GAAG,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;SAC9D,CAAA;QACD,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACpC,IAAI,SAAS,KAAK,SAAS,IAAI,uBAAuB,CAAC,IAAI,CAAC,SAAS,CAAC;gBAAE,SAAQ;YAChF,IAAI,CAAC,CAAC,iBAAiB,CAAC,IAAI,EAAE,SAAS,CAAC,IAAI,OAAO,CAAC;gBAAE,OAAO,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAA;QAChG,CAAC;QACD,IAAI,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC;YAAE,OAAO,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,CAAC,CAAA;IACzF,CAAC;IACD,OAAO,OAAO,CAAA;AACf,CAAC"}

package/dist/runtime.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The Roj runtime for a Durable Object that runs untrusted app code.
+ *
+ * Everything persistent lives in the object's own SQLite: the kompjutr filesystem,
+ * the event log, the LLM call log and the wake rows. Everything else comes from
+ * {@link RuntimeHost}, the only capability the object holds. Outbound `fetch`
+ * goes wherever the host routed the isolate's global outbound, which is where
+ * provider keys and tool credentials are added — the runtime never holds them.
+ *
+ * It answers the same HTTP surface as the sandbox runtime (`/rpc`, `/status`,
+ * `/sessions/*`), so a host can reuse its sandbox client. Requests reach it only
+ * through the host, which authenticates the caller and stamps `_caller`.
+ */
+import { type DurableObjectStorageLike } from '@kompjutr/do';
+import type { Config, RojConfig } from '@roj-ai/sdk';
+import { type AlarmSchedulerStats, type SyncKvLike } from './alarm-scheduler.js';
+import type { RuntimeHost } from './host-contract.js';
+/** The parts of `DurableObjectState` the runtime uses. */
+export interface IsolateRuntimeState {
+    storage: DurableObjectStorageLike & {
+        kv: SyncKvLike;
+    };
+    waitUntil(promise: Promise<unknown>): void;
+}
+export interface IsolateRuntimeOptions {
+    userConfig: RojConfig;
+    host: RuntimeHost;
+    state: IsolateRuntimeState;
+    /** Overrides of the built-in config, e.g. `llmMock` in tests. */
+    config?: Partial<Config>;
+    /** See `AlarmSchedulerHost.inFlightRetryMs`. */
+    inFlightRetryMs?: number;
+}
+export interface IsolateRuntime {
+    /** Loads open sessions, which recovers agents an eviction left mid-turn. Await before serving. */
+    start(): Promise<void>;
+    fetch(request: Request): Promise<Response>;
+    /** Call from the host's `alarm()`. Returns the wake keys delivered. */
+    deliverWakes(): Promise<string[]>;
+    schedulerStats(): AlarmSchedulerStats;
+}
+/**
+ * Stands in for the provider key, so the SDK's key check passes. The host's
+ * egress replaces the authorization header on provider requests.
+ */
+export declare const EGRESS_PROVIDED_KEY = "provided-by-host-egress";
+export declare function createIsolateRuntime(options: IsolateRuntimeOptions): IsolateRuntime;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,KAAK,wBAAwB,EAAa,MAAM,cAAc,CAAA;AAGvE,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEpD,OAAO,EAAwB,KAAK,mBAAmB,EAAE,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACtG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAGrD,0DAA0D;AAC1D,MAAM,WAAW,mBAAmB;IACnC,OAAO,EAAE,wBAAwB,GAAG;QAAE,EAAE,EAAE,UAAU,CAAA;KAAE,CAAA;IACtD,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAA;CAC1C;AAED,MAAM,WAAW,qBAAqB;IACrC,UAAU,EAAE,SAAS,CAAA;IACrB,IAAI,EAAE,WAAW,CAAA;IACjB,KAAK,EAAE,mBAAmB,CAAA;IAC1B,iEAAiE;IACjE,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;IACxB,gDAAgD;IAChD,eAAe,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,cAAc;IAC9B,kGAAkG;IAClG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACtB,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;IAC1C,uEAAuE;IACvE,YAAY,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;IACjC,cAAc,IAAI,mBAAmB,CAAA;CACrC;AAID;;;GAGG;AACH,eAAO,MAAM,mBAAmB,4BAA4B,CAAA;AAE5D,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB,GAAG,cAAc,CA0DnF"}

package/dist/runtime.js

@@ -0,0 +1,80 @@
+/**
+ * The Roj runtime for a Durable Object that runs untrusted app code.
+ *
+ * Everything persistent lives in the object's own SQLite: the kompjutr filesystem,
+ * the event log, the LLM call log and the wake rows. Everything else comes from
+ * {@link RuntimeHost}, the only capability the object holds. Outbound `fetch`
+ * goes wherever the host routed the isolate's global outbound, which is where
+ * provider keys and tool credentials are added — the runtime never holds them.
+ *
+ * It answers the same HTTP surface as the sandbox runtime (`/rpc`, `/status`,
+ * `/sessions/*`), so a host can reuse its sandbox client. Requests reach it only
+ * through the host, which authenticates the caller and stamps `_caller`.
+ */
+import { Workspace } from '@kompjutr/do';
+import { createKompjutrPlatform, KompjutrEventStore } from '@roj-ai/kompjutr-platform';
+import { bootstrap, createSystemFromServices } from '@roj-ai/sdk';
+import { createApp } from '@roj-ai/sdk/transport/http/app';
+import { createAlarmScheduler } from './alarm-scheduler.js';
+import { ISOLATE_RUNTIME_NAME, ISOLATE_RUNTIME_VERSION } from './info.js';
+const DATA_ROOT = '/data';
+/**
+ * Stands in for the provider key, so the SDK's key check passes. The host's
+ * egress replaces the authorization header on provider requests.
+ */
+export const EGRESS_PROVIDED_KEY = 'provided-by-host-egress';
+export function createIsolateRuntime(options) {
+    const { state, host } = options;
+    // `loadConfig()` reads process.env and the cwd, which an isolate has neither of.
+    const config = {
+        port: 0,
+        host: 'localhost',
+        dataPath: DATA_ROOT,
+        persistence: 'memory',
+        logLevel: 'warn',
+        logFormat: 'json',
+        llmLoggingEnabled: true,
+        openRouterApiKey: EGRESS_PROVIDED_KEY,
+        agentRuntime: { name: ISOLATE_RUNTIME_NAME, version: ISOLATE_RUNTIME_VERSION },
+        ...options.config,
+    };
+    const workspace = new Workspace({ storage: state.storage });
+    workspace.filesystem.mkdir(DATA_ROOT, { recursive: true });
+    const scheduler = createAlarmScheduler({
+        storage: {
+            kv: state.storage.kv,
+            setAlarm: scheduledTime => host.setAlarm(scheduledTime),
+            deleteAlarm: () => host.deleteAlarm(),
+        },
+        waitUntil: promise => state.waitUntil(promise),
+        inFlightRetryMs: options.inFlightRetryMs,
+    });
+    const services = bootstrap(config, options.userConfig, createKompjutrPlatform(workspace, { scheduler }), {
+        pluginProfile: 'isolate',
+        eventStore: new KompjutrEventStore(workspace.db),
+    });
+    const system = createSystemFromServices(services, {
+        onUserOutput: notification => {
+            state.waitUntil(host.broadcast({ type: notification.type, payload: notification.payload, ts: Date.now() }));
+        },
+    });
+    const app = createApp({ ...services, sessionRuntime: system.sessionManager });
+    return {
+        async start() {
+            await system.sessionManager.loadAllSessions();
+            await scheduler.flush();
+        },
+        async fetch(request) {
+            const response = await app.fetch(request);
+            await scheduler.flush();
+            return response;
+        },
+        async deliverWakes() {
+            const keys = await scheduler.deliverDue(key => system.sessionManager.dispatchWake(key));
+            await scheduler.flush();
+            return keys;
+        },
+        schedulerStats: () => scheduler.stats(),
+    };
+}
+//# sourceMappingURL=runtime.js.map

package/dist/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAiC,SAAS,EAAE,MAAM,cAAc,CAAA;AACvE,OAAO,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AACtF,OAAO,EAAE,SAAS,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AAEjE,OAAO,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAA;AAC1D,OAAO,EAAE,oBAAoB,EAA6C,MAAM,sBAAsB,CAAA;AAEtG,OAAO,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAA;AA2BzE,MAAM,SAAS,GAAG,OAAO,CAAA;AAEzB;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,yBAAyB,CAAA;AAE5D,MAAM,UAAU,oBAAoB,CAAC,OAA8B;IAClE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAA;IAC/B,iFAAiF;IACjF,MAAM,MAAM,GAAW;QACtB,IAAI,EAAE,CAAC;QACP,IAAI,EAAE,WAAW;QACjB,QAAQ,EAAE,SAAS;QACnB,WAAW,EAAE,QAAQ;QACrB,QAAQ,EAAE,MAAM;QAChB,SAAS,EAAE,MAAM;QACjB,iBAAiB,EAAE,IAAI;QACvB,gBAAgB,EAAE,mBAAmB;QACrC,YAAY,EAAE,EAAE,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,uBAAuB,EAAE;QAC9E,GAAG,OAAO,CAAC,MAAM;KACjB,CAAA;IAED,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAA;IAC3D,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAA;IAC1D,MAAM,SAAS,GAAG,oBAAoB,CAAC;QACtC,OAAO,EAAE;YACR,EAAE,EAAE,KAAK,CAAC,OAAO,CAAC,EAAE;YACpB,QAAQ,EAAE,aAAa,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC;YACvD,WAAW,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE;SACrC;QACD,SAAS,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC;QAC9C,eAAe,EAAE,OAAO,CAAC,eAAe;KACxC,CAAC,CAAA;IACF,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,EAAE,sBAAsB,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE;QACxG,aAAa,EAAE,SAAS;QACxB,UAAU,EAAE,IAAI,kBAAkB,CAAC,SAAS,CAAC,EAAE,CAAC;KAChD,CAAC,CAAA;IACF,MAAM,MAAM,GAAG,wBAAwB,CAAC,QAAQ,EAAE;QACjD,YAAY,EAAE,YAAY,CAAC,EAAE;YAC5B,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,YAAY,CAAC,OAAO,EAAE,EAAE,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAA;QAC5G,CAAC;KACD,CAAC,CAAA;IACF,MAAM,GAAG,GAAG,SAAS,CAAC,EAAE,GAAG,QAAQ,EAAE,cAAc,EAAE,MAAM,CAAC,cAAc,EAAE,CAAC,CAAA;IAE7E,OAAO;QACN,KAAK,CAAC,KAAK;YACV,MAAM,MAAM,CAAC,cAAc,CAAC,eAAe,EAAE,CAAA;YAC7C,MAAM,SAAS,CAAC,KAAK,EAAE,CAAA;QACxB,CAAC;QAED,KAAK,CAAC,KAAK,CAAC,OAAO;YAClB,MAAM,QAAQ,GAAG,MAAM,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;YACzC,MAAM,SAAS,CAAC,KAAK,EAAE,CAAA;YACvB,OAAO,QAAQ,CAAA;QAChB,CAAC;QAED,KAAK,CAAC,YAAY;YACjB,MAAM,IAAI,GAAG,MAAM,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,cAAc,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAA;YACvF,MAAM,SAAS,CAAC,KAAK,EAAE,CAAA;YACvB,OAAO,IAAI,CAAA;QACZ,CAAC;QAED,cAAc,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,KAAK,EAAE;KACvC,CAAA;AACF,CAAC"}

package/dist/testing.d.ts

@@ -0,0 +1,17 @@
+/** In-memory stand-ins for the Durable Object storage the scheduler uses. Tests only. */
+import type { AlarmStorageLike, SyncKvLike } from './alarm-scheduler.js';
+export declare class MemoryKv implements SyncKvLike {
+    #private;
+    list(options?: {
+        prefix?: string;
+    }): Iterable<[string, unknown]>;
+    put(key: string, value: unknown): void;
+    delete(key: string): boolean;
+}
+export declare class MemoryAlarmStorage implements AlarmStorageLike {
+    readonly kv: MemoryKv;
+    alarm: number | null;
+    setAlarm(scheduledTime: number): Promise<void>;
+    deleteAlarm(): Promise<void>;
+}
+//# sourceMappingURL=testing.d.ts.map

package/dist/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAAA,yFAAyF;AAEzF,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAExE,qBAAa,QAAS,YAAW,UAAU;;IAG1C,IAAI,CAAC,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,QAAQ,CAAC,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAKhE,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAItC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;CAG5B;AAED,qBAAa,kBAAmB,YAAW,gBAAgB;IAC1D,QAAQ,CAAC,EAAE,WAAiB;IAC5B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAO;IAErB,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI9C,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;CAGlC"}

package/dist/testing.js

@@ -0,0 +1,25 @@
+/** In-memory stand-ins for the Durable Object storage the scheduler uses. Tests only. */
+export class MemoryKv {
+    #rows = new Map();
+    list(options) {
+        const prefix = options?.prefix ?? '';
+        return [...this.#rows].filter(([key]) => key.startsWith(prefix)).sort(([a], [b]) => a.localeCompare(b));
+    }
+    put(key, value) {
+        this.#rows.set(key, value);
+    }
+    delete(key) {
+        return this.#rows.delete(key);
+    }
+}
+export class MemoryAlarmStorage {
+    kv = new MemoryKv();
+    alarm = null;
+    async setAlarm(scheduledTime) {
+        this.alarm = scheduledTime;
+    }
+    async deleteAlarm() {
+        this.alarm = null;
+    }
+}
+//# sourceMappingURL=testing.js.map

package/dist/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.js","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAAA,yFAAyF;AAIzF,MAAM,OAAO,QAAQ;IACX,KAAK,GAAG,IAAI,GAAG,EAAmB,CAAA;IAE3C,IAAI,CAAC,OAA6B;QACjC,MAAM,MAAM,GAAG,OAAO,EAAE,MAAM,IAAI,EAAE,CAAA;QACpC,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAA;IACxG,CAAC;IAED,GAAG,CAAC,GAAW,EAAE,KAAc;QAC9B,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;IAC3B,CAAC;IAED,MAAM,CAAC,GAAW;QACjB,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;IAC9B,CAAC;CACD;AAED,MAAM,OAAO,kBAAkB;IACrB,EAAE,GAAG,IAAI,QAAQ,EAAE,CAAA;IAC5B,KAAK,GAAkB,IAAI,CAAA;IAE3B,KAAK,CAAC,QAAQ,CAAC,aAAqB;QACnC,IAAI,CAAC,KAAK,GAAG,aAAa,CAAA;IAC3B,CAAC;IAED,KAAK,CAAC,WAAW;QAChB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAA;IAClB,CAAC;CACD"}

package/package.json

@@ -1,13 +1,62 @@
 {
 	"name": "@roj-ai/isolate-runtime",
-	"version": "0.0.0",
-	"description": "Placeholder that reserves the package name for trusted publishing. Real releases come from CI.",
+	"version": "0.2.14",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"roj": {
+		"bunOnlyExports": [
+			"./build"
+		]
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		},
+		"./host": {
+			"types": "./dist/host.d.ts",
+			"import": "./dist/host.js",
+			"default": "./dist/host.js"
+		},
+		"./build": {
+			"types": "./dist/build.d.ts",
+			"import": "./dist/build.js",
+			"default": "./dist/build.js"
+		}
+	},
+	"files": [
+		"src",
+		"dist",
+		"!src/**/*.test.ts",
+		"!dist/**/*.test.*"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/contember/roj.git",
 		"directory": "packages/isolate-runtime"
 	},
-	"publishConfig": {
-		"access": "public"
+	"homepage": "https://github.com/contember/roj/tree/main/packages/isolate-runtime#readme",
+	"bugs": {
+		"url": "https://github.com/contember/roj/issues"
+	},
+	"scripts": {
+		"type-check": "tsc --noEmit && tsc -p tsconfig.worker.json && tsc -p e2e/tsconfig.json",
+		"test:e2e": "bun test ./e2e"
+	},
+	"dependencies": {
+		"@kompjutr/do": "0.1.4",
+		"@roj-ai/kompjutr-platform": "^0.2.14",
+		"@roj-ai/sdk": "^0.2.14"
+	},
+	"devDependencies": {
+		"@cloudflare/workers-types": "5.20260925.1",
+		"@types/bun": "^1.3.3",
+		"typescript": "^5.9.3",
+		"wrangler": "4.143.0"
 	}
 }

package/src/alarm-scheduler.ts

@@ -0,0 +1,234 @@
+/**
+ * Scheduler over a Durable Object's single alarm slot.
+ *
+ * A DO has no process between wakes, so it implements the plain {@link Scheduler}
+ * port rather than `LiveScheduler`: the host delivers through {@link AlarmScheduler.deliverDue}
+ * from its own `alarm()` handler, in whichever isolate happens to be alive by then.
+ * The slot is reached through {@link AlarmStorageLike}, so a DO facet, which has no
+ * alarm of its own, can borrow its parent's.
+ *
+ * Two shapes of the SDK dictate the design. It arms without awaiting —
+ * `scheduleProcessing()` and `shutdown()` are synchronous, so the promises are
+ * dropped — and it cancels a key then re-arms it in the same frame. So the state
+ * that decides what is due (in-memory key→dueAt maps and their rows in the DO's
+ * synchronous KV) moves synchronously, where nothing can reorder it; the alarm
+ * slot, which is asynchronous storage I/O, is reconciled afterwards against the
+ * maps as they stand when the write runs — never against the arguments that queued it.
+ */
+
+import type { Scheduler, WakeHandler } from '@roj-ai/sdk/platform'
+
+/** Synchronous key-value surface of a SQLite-backed Durable Object (`storage.kv`). */
+export interface SyncKvLike {
+	list(options?: { prefix?: string }): Iterable<[string, unknown]>
+	put(key: string, value: unknown): void
+	delete(key: string): boolean
+}
+
+/** The parts of `DurableObjectStorage` a wake needs: one alarm, and rows to survive in. */
+export interface AlarmStorageLike {
+	kv: SyncKvLike
+	setAlarm(scheduledTime: number): Promise<void>
+	deleteAlarm(): Promise<void>
+	/** Optional so a test double need not implement it; see `applyAlarm`. */
+	sync?(): Promise<void>
+}
+
+export interface AlarmSchedulerHost {
+	storage: AlarmStorageLike
+	/**
+	 * Keeps a promise nobody awaits alive. `DurableObjectState.waitUntil` puts it
+	 * on the actor's IoContext, so an arm issued during a request outlives the
+	 * frame that issued it.
+	 */
+	waitUntil?(promise: Promise<unknown>): void
+	/** How long after a delivery starts it is delivered again unless it finished. Default 5 minutes. */
+	inFlightRetryMs?: number
+}
+
+export interface AlarmSchedulerStats {
+	/** Wakes armed and not yet delivered. */
+	pending: number
+	/** Deliveries started and not finished, each with a retry armed. */
+	inFlight: number
+	/** What the alarm slot holds, as far as this isolate knows. */
+	armedAt: number | null
+	/** Alarms drained since this isolate booted. */
+	drains: number
+	/** Wakes handed to a delivery handler since this isolate booted. */
+	delivered: number
+}
+
+export interface AlarmScheduler extends Scheduler {
+	/**
+	 * Drain every wake now due, re-arm for the next, then hand each drained key to
+	 * `deliver`. Call from the DO's `alarm()`; returns the keys delivered.
+	 */
+	deliverDue(deliver: WakeHandler): Promise<string[]>
+	/** Settle the pending alarm writes. Call before an entry point returns. Throws when the slot cannot be written. */
+	flush(): Promise<void>
+	/**
+	 * Ignore wakes and cancels while `fn` runs.
+	 *
+	 * `SessionManager.shutdown()` cancels every agent's wakes — right when a
+	 * session is being torn down, wrong when the isolate is merely going away,
+	 * which drops exactly the wake this port exists to preserve. Only the host
+	 * knows which of the two it is doing.
+	 */
+	suspend<T>(fn: () => Promise<T>): Promise<T>
+	stats(): AlarmSchedulerStats
+}
+
+/** Namespaced so wakes cannot collide with whatever else the host keeps in storage. */
+const WAKE_PREFIX = 'roj:wake:'
+const RETRY_PREFIX = 'roj:retry:'
+
+const DEFAULT_IN_FLIGHT_RETRY_MS = 5 * 60_000
+
+/**
+ * Clock slack when draining. workerd pins `Date.now()` between I/O, so an alarm
+ * can read as fractionally early; without slack that costs an extra round trip.
+ */
+const DRAIN_SLACK_MS = 10
+
+/** A key→time map mirrored into KV rows, so it outlives the isolate. */
+function persistedTimes(kv: SyncKvLike, prefix: string) {
+	const times = new Map<string, number>()
+	for (const [key, value] of kv.list({ prefix })) {
+		if (typeof value === 'number') times.set(key.slice(prefix.length), value)
+	}
+	return {
+		times,
+		set(key: string, at: number): void {
+			times.set(key, at)
+			kv.put(prefix + key, at)
+		},
+		delete(key: string): boolean {
+			// The map mirrors the rows, so a key it does not hold has no row either.
+			if (!times.delete(key)) return false
+			kv.delete(prefix + key)
+			return true
+		},
+		dueBy(cutoff: number): string[] {
+			return [...times].filter(([, at]) => at <= cutoff).map(([key]) => key)
+		},
+	}
+}
+
+export function createAlarmScheduler(host: AlarmSchedulerHost): AlarmScheduler {
+	const storage = host.storage
+	const track = host.waitUntil?.bind(host)
+	const inFlightRetryMs = host.inFlightRetryMs ?? DEFAULT_IN_FLIGHT_RETRY_MS
+	const wakes = persistedTimes(storage.kv, WAKE_PREFIX)
+	// A delivery lost to an eviction never reaches its end, and its wake row is already gone.
+	// The retry row brings the alarm back, so the session loads and recovers its agents.
+	const retries = persistedTimes(storage.kv, RETRY_PREFIX)
+	let armedAt: number | undefined
+	let tail: Promise<void> = Promise.resolve()
+	let suspended = 0
+	let drains = 0
+	let delivered = 0
+
+	const earliest = (): number | undefined => {
+		let min: number | undefined
+		for (const at of [...wakes.times.values(), ...retries.times.values()]) {
+			if (min === undefined || at < min) min = at
+		}
+		return min
+	}
+
+	const applyAlarm = async (): Promise<void> => {
+		const target = earliest()
+		if (target === armedAt) return
+		if (target === undefined) await storage.deleteAlarm()
+		else await storage.setAlarm(target)
+		armedAt = target
+		// Awaiting the write only queues it; sync() is what waits for it to be durable,
+		// and an isolate aborted before that point loses the arm.
+		await storage.sync?.()
+	}
+
+	/** Queue one alarm write. Serialized, because there is only one slot to race over. */
+	const reconcile = (): Promise<void> => {
+		const next = tail.then(applyAlarm)
+		// The tail must never reject, or every later reconcile inherits this failure.
+		const settled = next.catch(() => undefined)
+		tail = settled
+		track?.(settled)
+		return next
+	}
+
+	// A previous isolate may have died between writing rows and committing its alarm.
+	if (wakes.times.size > 0 || retries.times.size > 0) void reconcile().catch(() => undefined)
+
+	return {
+		async wake(key: string, delayMs: number): Promise<void> {
+			if (suspended > 0) return
+			// Synchronous, so the cancel-then-arm pair the SDK issues in one frame
+			// cannot land out of order however long the alarm write takes.
+			wakes.set(key, Date.now() + Math.max(delayMs, 0))
+			await reconcile()
+		},
+
+		async cancel(key: string): Promise<void> {
+			if (suspended > 0) return
+			if (!wakes.delete(key)) return
+			await reconcile()
+		},
+
+		async deliverDue(deliver: WakeHandler): Promise<string[]> {
+			// workerd clears the slot before delivering, so this isolate holds nothing.
+			armedAt = undefined
+			drains += 1
+
+			const cutoff = Date.now() + DRAIN_SLACK_MS
+			const due = [...new Set([...wakes.dueBy(cutoff), ...retries.dueBy(cutoff)])]
+			const retryAt = Date.now() + inFlightRetryMs
+			for (const key of due) {
+				wakes.delete(key)
+				retries.set(key, retryAt)
+			}
+
+			// Re-arm before dispatching: a wake that runs long, or throws, must not
+			// strand the ones behind it.
+			await reconcile()
+
+			// Concurrently: one wake runs a whole agent turn, and the slot fires one alarm at a time.
+			await Promise.all(due.map(async key => {
+				delivered += 1
+				try {
+					await deliver(key)
+					retries.delete(key)
+				} catch {
+					// The handler owns its error reporting. The retry row stays, so the wake is delivered again.
+				}
+			}))
+			if (due.length > 0) await reconcile()
+			return due
+		},
+
+		async flush(): Promise<void> {
+			// Deliveries and agent work chain further reconciles as they run.
+			let seen: Promise<void> | undefined
+			while (seen !== tail) {
+				seen = tail
+				await seen
+			}
+			// A failed write leaves rows the slot does not cover. Try once more, and let a second failure surface.
+			if (earliest() !== armedAt) await reconcile()
+		},
+
+		async suspend<T>(fn: () => Promise<T>): Promise<T> {
+			suspended += 1
+			try {
+				return await fn()
+			} finally {
+				suspended -= 1
+			}
+		},
+
+		stats(): AlarmSchedulerStats {
+			return { pending: wakes.times.size, inFlight: retries.times.size, armedAt: armedAt ?? null, drains, delivered }
+		},
+	}
+}

package/src/build.ts

@@ -0,0 +1,95 @@
+/**
+ * Builds the modules a host hands to the Worker Loader to run the runtime as a facet.
+ *
+ * The SDK is built once per runtime version and shared by every app bundle. An app
+ * bundle is `roj build` output in `externalSdk` mode: it imports `@roj-ai/sdk` and its
+ * subpaths as bare specifiers, which resolve to small shim modules re-exporting the
+ * shared build. The runtime's main module imports the same shims, so the app and the
+ * runtime share one SDK instance.
+ *
+ * The loader resolves a specifier relative to the importing module's directory, a bare
+ * one included. The shims sit at the root, so the app bundle and the main module reach
+ * them by name; the shims reach the SDK by absolute path.
+ */
+
+import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { join, posix } from 'node:path'
+import { APP_BUNDLE_MODULE, type LoaderModule, type RuntimeModules } from './modules.js'
+
+export type { LoaderModule, RuntimeModules } from './modules.js'
+export { APP_BUNDLE_MODULE, unresolvedImports, withAppBundle } from './modules.js'
+
+const MAIN_MODULE = 'main.js'
+const SDK_DIR = 'sdk'
+const PLATFORM_EXTERNALS = ['node:*', 'cloudflare:*']
+/** SDK subpaths an isolate cannot run or an app bundle has no use for. */
+const EXCLUDED_SDK_EXPORTS = new Set(['./package.json', './bun-platform', './testing'])
+
+const packageRoot = join(import.meta.dir, '..')
+
+async function bunBuild(options: Parameters<typeof Bun.build>[0]): Promise<void> {
+	const result = await Bun.build({ target: 'node', format: 'esm', ...options })
+	if (!result.success) throw new AggregateError(result.logs, 'isolate runtime build failed')
+}
+
+async function sdkSubpaths(): Promise<string[]> {
+	const manifestPath = Bun.resolveSync('@roj-ai/sdk/package.json', packageRoot)
+	const manifest: { exports: Record<string, unknown>; roj?: { bunOnlyExports?: string[] } } = await Bun.file(manifestPath).json()
+	const bunOnly = new Set(manifest.roj?.bunOnlyExports ?? [])
+	return Object.keys(manifest.exports).filter(subpath => !EXCLUDED_SDK_EXPORTS.has(subpath) && !bunOnly.has(subpath))
+}
+
+/** `.` → `@roj-ai/sdk`, `./tools/shell` → `@roj-ai/sdk/tools/shell`. */
+const specifierOf = (subpath: string) => (subpath === '.' ? '@roj-ai/sdk' : `@roj-ai/sdk/${subpath.slice(2)}`)
+/** `.` → `index`, `./tools/shell` → `tools__shell`: flat, so every entry lands in one directory. */
+const entryNameOf = (subpath: string) => (subpath === '.' ? 'index' : subpath.slice(2).replaceAll('/', '__'))
+
+async function readModules(dir: string, prefix: string): Promise<Record<string, string>> {
+	const modules: Record<string, string> = {}
+	for (const file of await readdir(dir)) {
+		modules[posix.join(prefix, file)] = await readFile(join(dir, file), 'utf8')
+	}
+	return modules
+}
+
+/** Builds the runtime from the installed `@roj-ai/*` packages. Needs Bun. */
+export async function buildRuntimeModules(): Promise<RuntimeModules> {
+	// Entries must resolve `@roj-ai/sdk` the way this package does, so they live inside it.
+	const workDir = join(packageRoot, `.isolate-build-${crypto.randomUUID()}`)
+	try {
+		const subpaths = await sdkSubpaths()
+		const entriesDir = join(workDir, 'entries')
+		await mkdir(entriesDir, { recursive: true })
+		const entries: string[] = []
+		for (const subpath of subpaths) {
+			const entry = join(entriesDir, `${entryNameOf(subpath)}.ts`)
+			await writeFile(entry, `export * from '${specifierOf(subpath)}'\n`)
+			entries.push(entry)
+		}
+
+		await bunBuild({
+			entrypoints: entries,
+			outdir: join(workDir, SDK_DIR),
+			splitting: true,
+			external: PLATFORM_EXTERNALS,
+			naming: { entry: '[name].js', chunk: 'chunk-[hash].js' },
+		})
+		await bunBuild({
+			entrypoints: [join(packageRoot, 'src/worker/main.ts')],
+			outdir: join(workDir, 'main'),
+			naming: MAIN_MODULE,
+			external: [...PLATFORM_EXTERNALS, '@roj-ai/sdk', '@roj-ai/sdk/*', APP_BUNDLE_MODULE],
+		})
+
+		const modules: Record<string, LoaderModule> = {
+			[MAIN_MODULE]: await readFile(join(workDir, 'main', MAIN_MODULE), 'utf8'),
+			...(await readModules(join(workDir, SDK_DIR), SDK_DIR)),
+		}
+		for (const subpath of subpaths) {
+			modules[specifierOf(subpath)] = { js: `export * from '/${SDK_DIR}/${entryNameOf(subpath)}.js'\n` }
+		}
+		return { mainModule: MAIN_MODULE, modules }
+	} finally {
+		await rm(workDir, { recursive: true, force: true })
+	}
+}