@ricsam/isolate-runtime 0.1.1 → 0.1.3

package/README.md

@@ -0,0 +1,51 @@
+# @ricsam/isolate-runtime
+
+Umbrella package that combines all APIs.
+
+```typescript
+import { createRuntime } from "@ricsam/isolate-runtime";
+
+const runtime = await createRuntime({
+  // Memory limit in MB
+  memoryLimit: 128,
+  // Console API
+  console: {
+    onLog: (level, ...args) => console.log(`[${level}]`, ...args),
+  },
+  // Fetch API
+  fetch: {
+    onFetch: async (req) => fetch(req),
+  },
+  // File System API (optional)
+  fs: {
+    getDirectory: async (path) => createNodeFileSystemHandler(`./data${path}`),
+  },
+});
+
+// The runtime includes:
+// - runtime.isolate: The V8 isolate
+// - runtime.context: The execution context
+// - runtime.tick(): Process pending timers
+// - runtime.dispose(): Clean up all resources
+
+// Run code
+await runtime.context.eval(`
+  console.log("Hello from sandbox!");
+`, { promise: true });
+
+// Process timers
+await runtime.tick(100);
+
+// Cleanup
+runtime.dispose();
+```
+
+**What's Included:**
+- Core (Blob, File, streams, URL, TextEncoder/Decoder)
+- Console
+- Encoding (atob/btoa)
+- Timers (setTimeout, setInterval)
+- Path utilities
+- Crypto (randomUUID, getRandomValues, subtle)
+- Fetch API
+- File System (if handler provided)

package/dist/cjs/index.cjs

@@ -0,0 +1,115 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// packages/runtime/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  setupTimers: () => import_isolate_timers2.setupTimers,
+  setupPath: () => import_isolate_path2.setupPath,
+  setupFs: () => import_isolate_fs2.setupFs,
+  setupFetch: () => import_isolate_fetch2.setupFetch,
+  setupEncoding: () => import_isolate_encoding2.setupEncoding,
+  setupCrypto: () => import_isolate_crypto2.setupCrypto,
+  setupCore: () => import_isolate_core2.setupCore,
+  setupConsole: () => import_isolate_console2.setupConsole,
+  createRuntime: () => createRuntime,
+  createNodeFileSystemHandler: () => import_isolate_fs2.createNodeFileSystemHandler
+});
+module.exports = __toCommonJS(exports_src);
+var import_isolated_vm = __toESM(require("isolated-vm"));
+var import_isolate_core = require("@ricsam/isolate-core");
+var import_isolate_console = require("@ricsam/isolate-console");
+var import_isolate_encoding = require("@ricsam/isolate-encoding");
+var import_isolate_timers = require("@ricsam/isolate-timers");
+var import_isolate_path = require("@ricsam/isolate-path");
+var import_isolate_crypto = require("@ricsam/isolate-crypto");
+var import_isolate_fetch = require("@ricsam/isolate-fetch");
+var import_isolate_fs = require("@ricsam/isolate-fs");
+var import_isolate_core2 = require("@ricsam/isolate-core");
+var import_isolate_console2 = require("@ricsam/isolate-console");
+var import_isolate_crypto2 = require("@ricsam/isolate-crypto");
+var import_isolate_encoding2 = require("@ricsam/isolate-encoding");
+var import_isolate_fetch2 = require("@ricsam/isolate-fetch");
+var import_isolate_fs2 = require("@ricsam/isolate-fs");
+var import_isolate_path2 = require("@ricsam/isolate-path");
+var import_isolate_timers2 = require("@ricsam/isolate-timers");
+async function createRuntime(options) {
+  const opts = options ?? {};
+  const isolate = new import_isolated_vm.default.Isolate({
+    memoryLimit: opts.memoryLimit
+  });
+  const context = await isolate.createContext();
+  const handles = {};
+  handles.core = await import_isolate_core.setupCore(context);
+  handles.console = await import_isolate_console.setupConsole(context, opts.console);
+  handles.encoding = await import_isolate_encoding.setupEncoding(context);
+  handles.timers = await import_isolate_timers.setupTimers(context);
+  handles.path = await import_isolate_path.setupPath(context);
+  handles.crypto = await import_isolate_crypto.setupCrypto(context);
+  handles.fetch = await import_isolate_fetch.setupFetch(context, opts.fetch);
+  if (opts.fs) {
+    handles.fs = await import_isolate_fs.setupFs(context, opts.fs);
+  }
+  return {
+    isolate,
+    context,
+    fetch: handles.fetch,
+    async tick(ms) {
+      await handles.timers.tick(ms);
+    },
+    dispose() {
+      handles.fs?.dispose();
+      handles.fetch?.dispose();
+      handles.crypto?.dispose();
+      handles.path?.dispose();
+      handles.timers?.dispose();
+      handles.encoding?.dispose();
+      handles.console?.dispose();
+      handles.core?.dispose();
+      context.release();
+      isolate.dispose();
+    }
+  };
+}
+})
+
+//# debugId=4A635399139F1BA664756E2164756E21

package/dist/cjs/index.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": [
+    "import ivm from \"isolated-vm\";\nimport { setupCore } from \"@ricsam/isolate-core\";\nimport { setupConsole } from \"@ricsam/isolate-console\";\nimport { setupEncoding } from \"@ricsam/isolate-encoding\";\nimport { setupTimers } from \"@ricsam/isolate-timers\";\nimport { setupPath } from \"@ricsam/isolate-path\";\nimport { setupCrypto } from \"@ricsam/isolate-crypto\";\nimport { setupFetch } from \"@ricsam/isolate-fetch\";\nimport { setupFs } from \"@ricsam/isolate-fs\";\n\nimport type { ConsoleOptions, ConsoleHandle } from \"@ricsam/isolate-console\";\nimport type { FetchOptions, FetchHandle } from \"@ricsam/isolate-fetch\";\nimport type { FsOptions, FsHandle } from \"@ricsam/isolate-fs\";\nimport type { CoreHandle } from \"@ricsam/isolate-core\";\nimport type { EncodingHandle } from \"@ricsam/isolate-encoding\";\nimport type { TimersHandle } from \"@ricsam/isolate-timers\";\nimport type { PathHandle } from \"@ricsam/isolate-path\";\nimport type { CryptoHandle } from \"@ricsam/isolate-crypto\";\n\nexport interface RuntimeOptions {\n  /** Isolate memory limit in MB */\n  memoryLimit?: number;\n  /** Console options */\n  console?: ConsoleOptions;\n  /** Fetch options */\n  fetch?: FetchOptions;\n  /** File system options (optional - fs only set up if provided) */\n  fs?: FsOptions;\n}\n\nexport interface RuntimeHandle {\n  /** The isolate instance */\n  readonly isolate: ivm.Isolate;\n  /** The context instance */\n  readonly context: ivm.Context;\n  /** The fetch handle for serve() and WebSocket dispatching */\n  readonly fetch: FetchHandle;\n  /** Process pending timers */\n  tick(ms?: number): Promise<void>;\n  /** Dispose all resources */\n  dispose(): void;\n}\n\n/**\n * Create a fully configured isolated-vm runtime\n *\n * Sets up all WHATWG APIs: fetch, fs, console, crypto, encoding, timers\n *\n * @example\n * const runtime = await createRuntime({\n *   console: {\n *     onLog: (level, ...args) => console.log(`[${level}]`, ...args)\n *   },\n *   fetch: {\n *     onFetch: async (request) => fetch(request)\n *   }\n * });\n *\n * await runtime.context.eval(`\n *   console.log(\"Hello from sandbox!\");\n *   const response = await fetch(\"https://example.com\");\n * `);\n *\n * runtime.dispose();\n */\nexport async function createRuntime(\n  options?: RuntimeOptions\n): Promise<RuntimeHandle> {\n  const opts = options ?? {};\n\n  // Create isolate with optional memory limit\n  const isolate = new ivm.Isolate({\n    memoryLimit: opts.memoryLimit,\n  });\n  const context = await isolate.createContext();\n\n  // Store all handles for disposal\n  const handles: {\n    core?: CoreHandle;\n    console?: ConsoleHandle;\n    encoding?: EncodingHandle;\n    timers?: TimersHandle;\n    path?: PathHandle;\n    crypto?: CryptoHandle;\n    fetch?: FetchHandle;\n    fs?: FsHandle;\n  } = {};\n\n  // Setup all APIs in order\n  // Core must be first as it provides Blob, File, streams, URL, etc.\n  handles.core = await setupCore(context);\n\n  // Console\n  handles.console = await setupConsole(context, opts.console);\n\n  // Encoding (btoa/atob)\n  handles.encoding = await setupEncoding(context);\n\n  // Timers (setTimeout, setInterval)\n  handles.timers = await setupTimers(context);\n\n  // Path module\n  handles.path = await setupPath(context);\n\n  // Crypto (randomUUID, getRandomValues)\n  handles.crypto = await setupCrypto(context);\n\n  // Fetch API\n  handles.fetch = await setupFetch(context, opts.fetch);\n\n  // File system (only if handler provided)\n  if (opts.fs) {\n    handles.fs = await setupFs(context, opts.fs);\n  }\n\n  return {\n    isolate,\n    context,\n    fetch: handles.fetch!,\n    async tick(ms?: number) {\n      await handles.timers!.tick(ms);\n    },\n    dispose() {\n      // Dispose all handles\n      handles.fs?.dispose();\n      handles.fetch?.dispose();\n      handles.crypto?.dispose();\n      handles.path?.dispose();\n      handles.timers?.dispose();\n      handles.encoding?.dispose();\n      handles.console?.dispose();\n      handles.core?.dispose();\n\n      // Release context and dispose isolate\n      context.release();\n      isolate.dispose();\n    },\n  };\n}\n\n// Re-export all package types and functions\nexport { setupCore } from \"@ricsam/isolate-core\";\nexport type { CoreHandle, SetupCoreOptions } from \"@ricsam/isolate-core\";\n\nexport { setupConsole } from \"@ricsam/isolate-console\";\nexport type { ConsoleHandle, ConsoleOptions } from \"@ricsam/isolate-console\";\n\nexport { setupCrypto } from \"@ricsam/isolate-crypto\";\nexport type { CryptoHandle } from \"@ricsam/isolate-crypto\";\n\nexport { setupEncoding } from \"@ricsam/isolate-encoding\";\nexport type { EncodingHandle } from \"@ricsam/isolate-encoding\";\n\nexport { setupFetch } from \"@ricsam/isolate-fetch\";\nexport type { FetchHandle, FetchOptions, WebSocketCommand, UpgradeRequest } from \"@ricsam/isolate-fetch\";\n\nexport { setupFs, createNodeFileSystemHandler } from \"@ricsam/isolate-fs\";\nexport type { FsHandle, FsOptions, FileSystemHandler, NodeFileSystemHandlerOptions } from \"@ricsam/isolate-fs\";\n\nexport { setupPath } from \"@ricsam/isolate-path\";\nexport type { PathHandle } from \"@ricsam/isolate-path\";\n\nexport { setupTimers } from \"@ricsam/isolate-timers\";\nexport type { TimersHandle } from \"@ricsam/isolate-timers\";\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAgB,IAAhB;AAC0B,IAA1B;AAC6B,IAA7B;AAC8B,IAA9B;AAC4B,IAA5B;AAC0B,IAA1B;AAC4B,IAA5B;AAC2B,IAA3B;AACwB,IAAxB;AAqI0B,IAA1B;AAG6B,IAA7B;AAG4B,IAA5B;AAG8B,IAA9B;AAG2B,IAA3B;AAGqD,IAArD;AAG0B,IAA1B;AAG4B,IAA5B;AAjGA,eAAsB,aAAa,CACjC,SACwB;AAAA,EACxB,MAAM,OAAO,WAAW,CAAC;AAAA,EAGzB,MAAM,UAAU,IAAI,2BAAI,QAAQ;AAAA,IAC9B,aAAa,KAAK;AAAA,EACpB,CAAC;AAAA,EACD,MAAM,UAAU,MAAM,QAAQ,cAAc;AAAA,EAG5C,MAAM,UASF,CAAC;AAAA,EAIL,QAAQ,OAAO,MAAM,8BAAU,OAAO;AAAA,EAGtC,QAAQ,UAAU,MAAM,oCAAa,SAAS,KAAK,OAAO;AAAA,EAG1D,QAAQ,WAAW,MAAM,sCAAc,OAAO;AAAA,EAG9C,QAAQ,SAAS,MAAM,kCAAY,OAAO;AAAA,EAG1C,QAAQ,OAAO,MAAM,8BAAU,OAAO;AAAA,EAGtC,QAAQ,SAAS,MAAM,kCAAY,OAAO;AAAA,EAG1C,QAAQ,QAAQ,MAAM,gCAAW,SAAS,KAAK,KAAK;AAAA,EAGpD,IAAI,KAAK,IAAI;AAAA,IACX,QAAQ,KAAK,MAAM,0BAAQ,SAAS,KAAK,EAAE;AAAA,EAC7C;AAAA,EAEA,OAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,OAAO,QAAQ;AAAA,SACT,KAAI,CAAC,IAAa;AAAA,MACtB,MAAM,QAAQ,OAAQ,KAAK,EAAE;AAAA;AAAA,IAE/B,OAAO,GAAG;AAAA,MAER,QAAQ,IAAI,QAAQ;AAAA,MACpB,QAAQ,OAAO,QAAQ;AAAA,MACvB,QAAQ,QAAQ,QAAQ;AAAA,MACxB,QAAQ,MAAM,QAAQ;AAAA,MACtB,QAAQ,QAAQ,QAAQ;AAAA,MACxB,QAAQ,UAAU,QAAQ;AAAA,MAC1B,QAAQ,SAAS,QAAQ;AAAA,MACzB,QAAQ,MAAM,QAAQ;AAAA,MAGtB,QAAQ,QAAQ;AAAA,MAChB,QAAQ,QAAQ;AAAA;AAAA,EAEpB;AAAA;",
+  "debugId": "4A635399139F1BA664756E2164756E21",
+  "names": []
+}

package/dist/cjs/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@ricsam/isolate-runtime",
+  "version": "0.1.3",
+  "type": "commonjs"
+}

package/dist/mjs/index.mjs

@@ -0,0 +1,71 @@
+// @bun
+// packages/runtime/src/index.ts
+import ivm from "isolated-vm";
+import { setupCore } from "@ricsam/isolate-core";
+import { setupConsole } from "@ricsam/isolate-console";
+import { setupEncoding } from "@ricsam/isolate-encoding";
+import { setupTimers } from "@ricsam/isolate-timers";
+import { setupPath } from "@ricsam/isolate-path";
+import { setupCrypto } from "@ricsam/isolate-crypto";
+import { setupFetch } from "@ricsam/isolate-fetch";
+import { setupFs } from "@ricsam/isolate-fs";
+import { setupCore as setupCore2 } from "@ricsam/isolate-core";
+import { setupConsole as setupConsole2 } from "@ricsam/isolate-console";
+import { setupCrypto as setupCrypto2 } from "@ricsam/isolate-crypto";
+import { setupEncoding as setupEncoding2 } from "@ricsam/isolate-encoding";
+import { setupFetch as setupFetch2 } from "@ricsam/isolate-fetch";
+import { setupFs as setupFs2, createNodeFileSystemHandler } from "@ricsam/isolate-fs";
+import { setupPath as setupPath2 } from "@ricsam/isolate-path";
+import { setupTimers as setupTimers2 } from "@ricsam/isolate-timers";
+async function createRuntime(options) {
+  const opts = options ?? {};
+  const isolate = new ivm.Isolate({
+    memoryLimit: opts.memoryLimit
+  });
+  const context = await isolate.createContext();
+  const handles = {};
+  handles.core = await setupCore(context);
+  handles.console = await setupConsole(context, opts.console);
+  handles.encoding = await setupEncoding(context);
+  handles.timers = await setupTimers(context);
+  handles.path = await setupPath(context);
+  handles.crypto = await setupCrypto(context);
+  handles.fetch = await setupFetch(context, opts.fetch);
+  if (opts.fs) {
+    handles.fs = await setupFs(context, opts.fs);
+  }
+  return {
+    isolate,
+    context,
+    fetch: handles.fetch,
+    async tick(ms) {
+      await handles.timers.tick(ms);
+    },
+    dispose() {
+      handles.fs?.dispose();
+      handles.fetch?.dispose();
+      handles.crypto?.dispose();
+      handles.path?.dispose();
+      handles.timers?.dispose();
+      handles.encoding?.dispose();
+      handles.console?.dispose();
+      handles.core?.dispose();
+      context.release();
+      isolate.dispose();
+    }
+  };
+}
+export {
+  setupTimers2 as setupTimers,
+  setupPath2 as setupPath,
+  setupFs2 as setupFs,
+  setupFetch2 as setupFetch,
+  setupEncoding2 as setupEncoding,
+  setupCrypto2 as setupCrypto,
+  setupCore2 as setupCore,
+  setupConsole2 as setupConsole,
+  createRuntime,
+  createNodeFileSystemHandler
+};
+
+//# debugId=FDBFD94222E0044364756E2164756E21

package/dist/mjs/index.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": [
+    "import ivm from \"isolated-vm\";\nimport { setupCore } from \"@ricsam/isolate-core\";\nimport { setupConsole } from \"@ricsam/isolate-console\";\nimport { setupEncoding } from \"@ricsam/isolate-encoding\";\nimport { setupTimers } from \"@ricsam/isolate-timers\";\nimport { setupPath } from \"@ricsam/isolate-path\";\nimport { setupCrypto } from \"@ricsam/isolate-crypto\";\nimport { setupFetch } from \"@ricsam/isolate-fetch\";\nimport { setupFs } from \"@ricsam/isolate-fs\";\n\nimport type { ConsoleOptions, ConsoleHandle } from \"@ricsam/isolate-console\";\nimport type { FetchOptions, FetchHandle } from \"@ricsam/isolate-fetch\";\nimport type { FsOptions, FsHandle } from \"@ricsam/isolate-fs\";\nimport type { CoreHandle } from \"@ricsam/isolate-core\";\nimport type { EncodingHandle } from \"@ricsam/isolate-encoding\";\nimport type { TimersHandle } from \"@ricsam/isolate-timers\";\nimport type { PathHandle } from \"@ricsam/isolate-path\";\nimport type { CryptoHandle } from \"@ricsam/isolate-crypto\";\n\nexport interface RuntimeOptions {\n  /** Isolate memory limit in MB */\n  memoryLimit?: number;\n  /** Console options */\n  console?: ConsoleOptions;\n  /** Fetch options */\n  fetch?: FetchOptions;\n  /** File system options (optional - fs only set up if provided) */\n  fs?: FsOptions;\n}\n\nexport interface RuntimeHandle {\n  /** The isolate instance */\n  readonly isolate: ivm.Isolate;\n  /** The context instance */\n  readonly context: ivm.Context;\n  /** The fetch handle for serve() and WebSocket dispatching */\n  readonly fetch: FetchHandle;\n  /** Process pending timers */\n  tick(ms?: number): Promise<void>;\n  /** Dispose all resources */\n  dispose(): void;\n}\n\n/**\n * Create a fully configured isolated-vm runtime\n *\n * Sets up all WHATWG APIs: fetch, fs, console, crypto, encoding, timers\n *\n * @example\n * const runtime = await createRuntime({\n *   console: {\n *     onLog: (level, ...args) => console.log(`[${level}]`, ...args)\n *   },\n *   fetch: {\n *     onFetch: async (request) => fetch(request)\n *   }\n * });\n *\n * await runtime.context.eval(`\n *   console.log(\"Hello from sandbox!\");\n *   const response = await fetch(\"https://example.com\");\n * `);\n *\n * runtime.dispose();\n */\nexport async function createRuntime(\n  options?: RuntimeOptions\n): Promise<RuntimeHandle> {\n  const opts = options ?? {};\n\n  // Create isolate with optional memory limit\n  const isolate = new ivm.Isolate({\n    memoryLimit: opts.memoryLimit,\n  });\n  const context = await isolate.createContext();\n\n  // Store all handles for disposal\n  const handles: {\n    core?: CoreHandle;\n    console?: ConsoleHandle;\n    encoding?: EncodingHandle;\n    timers?: TimersHandle;\n    path?: PathHandle;\n    crypto?: CryptoHandle;\n    fetch?: FetchHandle;\n    fs?: FsHandle;\n  } = {};\n\n  // Setup all APIs in order\n  // Core must be first as it provides Blob, File, streams, URL, etc.\n  handles.core = await setupCore(context);\n\n  // Console\n  handles.console = await setupConsole(context, opts.console);\n\n  // Encoding (btoa/atob)\n  handles.encoding = await setupEncoding(context);\n\n  // Timers (setTimeout, setInterval)\n  handles.timers = await setupTimers(context);\n\n  // Path module\n  handles.path = await setupPath(context);\n\n  // Crypto (randomUUID, getRandomValues)\n  handles.crypto = await setupCrypto(context);\n\n  // Fetch API\n  handles.fetch = await setupFetch(context, opts.fetch);\n\n  // File system (only if handler provided)\n  if (opts.fs) {\n    handles.fs = await setupFs(context, opts.fs);\n  }\n\n  return {\n    isolate,\n    context,\n    fetch: handles.fetch!,\n    async tick(ms?: number) {\n      await handles.timers!.tick(ms);\n    },\n    dispose() {\n      // Dispose all handles\n      handles.fs?.dispose();\n      handles.fetch?.dispose();\n      handles.crypto?.dispose();\n      handles.path?.dispose();\n      handles.timers?.dispose();\n      handles.encoding?.dispose();\n      handles.console?.dispose();\n      handles.core?.dispose();\n\n      // Release context and dispose isolate\n      context.release();\n      isolate.dispose();\n    },\n  };\n}\n\n// Re-export all package types and functions\nexport { setupCore } from \"@ricsam/isolate-core\";\nexport type { CoreHandle, SetupCoreOptions } from \"@ricsam/isolate-core\";\n\nexport { setupConsole } from \"@ricsam/isolate-console\";\nexport type { ConsoleHandle, ConsoleOptions } from \"@ricsam/isolate-console\";\n\nexport { setupCrypto } from \"@ricsam/isolate-crypto\";\nexport type { CryptoHandle } from \"@ricsam/isolate-crypto\";\n\nexport { setupEncoding } from \"@ricsam/isolate-encoding\";\nexport type { EncodingHandle } from \"@ricsam/isolate-encoding\";\n\nexport { setupFetch } from \"@ricsam/isolate-fetch\";\nexport type { FetchHandle, FetchOptions, WebSocketCommand, UpgradeRequest } from \"@ricsam/isolate-fetch\";\n\nexport { setupFs, createNodeFileSystemHandler } from \"@ricsam/isolate-fs\";\nexport type { FsHandle, FsOptions, FileSystemHandler, NodeFileSystemHandlerOptions } from \"@ricsam/isolate-fs\";\n\nexport { setupPath } from \"@ricsam/isolate-path\";\nexport type { PathHandle } from \"@ricsam/isolate-path\";\n\nexport { setupTimers } from \"@ricsam/isolate-timers\";\nexport type { TimersHandle } from \"@ricsam/isolate-timers\";\n"
+  ],
+  "mappings": ";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAqIA,sBAAS;AAGT,yBAAS;AAGT,wBAAS;AAGT,0BAAS;AAGT,uBAAS;AAGT,oBAAS;AAGT,sBAAS;AAGT,wBAAS;AAjGT,eAAsB,aAAa,CACjC,SACwB;AAAA,EACxB,MAAM,OAAO,WAAW,CAAC;AAAA,EAGzB,MAAM,UAAU,IAAI,IAAI,QAAQ;AAAA,IAC9B,aAAa,KAAK;AAAA,EACpB,CAAC;AAAA,EACD,MAAM,UAAU,MAAM,QAAQ,cAAc;AAAA,EAG5C,MAAM,UASF,CAAC;AAAA,EAIL,QAAQ,OAAO,MAAM,UAAU,OAAO;AAAA,EAGtC,QAAQ,UAAU,MAAM,aAAa,SAAS,KAAK,OAAO;AAAA,EAG1D,QAAQ,WAAW,MAAM,cAAc,OAAO;AAAA,EAG9C,QAAQ,SAAS,MAAM,YAAY,OAAO;AAAA,EAG1C,QAAQ,OAAO,MAAM,UAAU,OAAO;AAAA,EAGtC,QAAQ,SAAS,MAAM,YAAY,OAAO;AAAA,EAG1C,QAAQ,QAAQ,MAAM,WAAW,SAAS,KAAK,KAAK;AAAA,EAGpD,IAAI,KAAK,IAAI;AAAA,IACX,QAAQ,KAAK,MAAM,QAAQ,SAAS,KAAK,EAAE;AAAA,EAC7C;AAAA,EAEA,OAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,OAAO,QAAQ;AAAA,SACT,KAAI,CAAC,IAAa;AAAA,MACtB,MAAM,QAAQ,OAAQ,KAAK,EAAE;AAAA;AAAA,IAE/B,OAAO,GAAG;AAAA,MAER,QAAQ,IAAI,QAAQ;AAAA,MACpB,QAAQ,OAAO,QAAQ;AAAA,MACvB,QAAQ,QAAQ,QAAQ;AAAA,MACxB,QAAQ,MAAM,QAAQ;AAAA,MACtB,QAAQ,QAAQ,QAAQ;AAAA,MACxB,QAAQ,UAAU,QAAQ;AAAA,MAC1B,QAAQ,SAAS,QAAQ;AAAA,MACzB,QAAQ,MAAM,QAAQ;AAAA,MAGtB,QAAQ,QAAQ;AAAA,MAChB,QAAQ,QAAQ;AAAA;AAAA,EAEpB;AAAA;",
+  "debugId": "FDBFD94222E0044364756E2164756E21",
+  "names": []
+}

package/dist/mjs/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@ricsam/isolate-runtime",
+  "version": "0.1.3",
+  "type": "module"
+}

package/dist/types/index.d.ts

@@ -0,0 +1,65 @@
+import ivm from "isolated-vm";
+import type { ConsoleOptions } from "@ricsam/isolate-console";
+import type { FetchOptions, FetchHandle } from "@ricsam/isolate-fetch";
+import type { FsOptions } from "@ricsam/isolate-fs";
+export interface RuntimeOptions {
+    /** Isolate memory limit in MB */
+    memoryLimit?: number;
+    /** Console options */
+    console?: ConsoleOptions;
+    /** Fetch options */
+    fetch?: FetchOptions;
+    /** File system options (optional - fs only set up if provided) */
+    fs?: FsOptions;
+}
+export interface RuntimeHandle {
+    /** The isolate instance */
+    readonly isolate: ivm.Isolate;
+    /** The context instance */
+    readonly context: ivm.Context;
+    /** The fetch handle for serve() and WebSocket dispatching */
+    readonly fetch: FetchHandle;
+    /** Process pending timers */
+    tick(ms?: number): Promise<void>;
+    /** Dispose all resources */
+    dispose(): void;
+}
+/**
+ * Create a fully configured isolated-vm runtime
+ *
+ * Sets up all WHATWG APIs: fetch, fs, console, crypto, encoding, timers
+ *
+ * @example
+ * const runtime = await createRuntime({
+ *   console: {
+ *     onLog: (level, ...args) => console.log(`[${level}]`, ...args)
+ *   },
+ *   fetch: {
+ *     onFetch: async (request) => fetch(request)
+ *   }
+ * });
+ *
+ * await runtime.context.eval(`
+ *   console.log("Hello from sandbox!");
+ *   const response = await fetch("https://example.com");
+ * `);
+ *
+ * runtime.dispose();
+ */
+export declare function createRuntime(options?: RuntimeOptions): Promise<RuntimeHandle>;
+export { setupCore } from "@ricsam/isolate-core";
+export type { CoreHandle, SetupCoreOptions } from "@ricsam/isolate-core";
+export { setupConsole } from "@ricsam/isolate-console";
+export type { ConsoleHandle, ConsoleOptions } from "@ricsam/isolate-console";
+export { setupCrypto } from "@ricsam/isolate-crypto";
+export type { CryptoHandle } from "@ricsam/isolate-crypto";
+export { setupEncoding } from "@ricsam/isolate-encoding";
+export type { EncodingHandle } from "@ricsam/isolate-encoding";
+export { setupFetch } from "@ricsam/isolate-fetch";
+export type { FetchHandle, FetchOptions, WebSocketCommand, UpgradeRequest } from "@ricsam/isolate-fetch";
+export { setupFs, createNodeFileSystemHandler } from "@ricsam/isolate-fs";
+export type { FsHandle, FsOptions, FileSystemHandler, NodeFileSystemHandlerOptions } from "@ricsam/isolate-fs";
+export { setupPath } from "@ricsam/isolate-path";
+export type { PathHandle } from "@ricsam/isolate-path";
+export { setupTimers } from "@ricsam/isolate-timers";
+export type { TimersHandle } from "@ricsam/isolate-timers";

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@ricsam/isolate-runtime",
-  "version": "0.1.1",
-  "type": "module",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "version": "0.1.3",
+  "main": "./dist/cjs/index.cjs",
+  "types": "./dist/types/index.d.ts",
   "exports": {
     ".": {
-      "import": "./src/index.ts",
-      "types": "./src/index.ts"
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/cjs/index.cjs",
+      "import": "./dist/mjs/index.mjs"
     }
   },
   "scripts": {
@@ -25,12 +25,37 @@
     "@ricsam/isolate-timers": "*",
     "isolated-vm": "^6"
   },
-  "devDependencies": {
-    "@ricsam/isolate-test-utils": "*",
-    "@types/node": "^24",
-    "typescript": "^5"
-  },
   "peerDependencies": {
     "isolated-vm": "^6"
-  }
-}
+  },
+  "author": "Richard Samuelsson",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ricsam/isolate.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ricsam/isolate/issues"
+  },
+  "homepage": "https://github.com/ricsam/isolate#readme",
+  "keywords": [
+    "isolated-vm",
+    "sandbox",
+    "javascript",
+    "runtime",
+    "fetch",
+    "filesystem",
+    "streams",
+    "v8",
+    "isolate"
+  ],
+  "description": "Complete isolated-vm V8 sandbox runtime with fetch, fs, and core bindings",
+  "module": "./dist/mjs/index.mjs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}

package/CHANGELOG.md

@@ -1,15 +0,0 @@
-# @ricsam/isolate-runtime
-
-## 0.1.1
-
-### Patch Changes
-
-- initial release
-- Updated dependencies
-  - @ricsam/isolate-console@0.1.1
-  - @ricsam/isolate-core@0.1.1
-  - @ricsam/isolate-crypto@0.1.1
-  - @ricsam/isolate-encoding@0.1.1
-  - @ricsam/isolate-fetch@0.1.1
-  - @ricsam/isolate-fs@0.1.1
-  - @ricsam/isolate-timers@0.1.1

package/src/index.test.ts

@@ -1,503 +0,0 @@
-import { test, describe } from "node:test";
-import assert from "node:assert";
-import { createRuntime, type RuntimeHandle } from "./index.ts";
-
-describe("@ricsam/isolate-runtime", () => {
-  describe("createRuntime", () => {
-    test("creates runtime with default options", async () => {
-      const runtime = await createRuntime();
-      try {
-        assert(runtime.isolate, "isolate should be defined");
-        assert(runtime.context, "context should be defined");
-        assert(typeof runtime.tick === "function", "tick should be a function");
-        assert(
-          typeof runtime.dispose === "function",
-          "dispose should be a function"
-        );
-      } finally {
-        runtime.dispose();
-      }
-    });
-
-    test("runtime has all globals defined", async () => {
-      const runtime = await createRuntime();
-      try {
-        const result = await runtime.context.eval(`
-          JSON.stringify({
-            hasFetch: typeof fetch === 'function',
-            hasConsole: typeof console === 'object',
-            hasCrypto: typeof crypto === 'object',
-            hasSetTimeout: typeof setTimeout === 'function',
-            hasSetInterval: typeof setInterval === 'function',
-            hasClearTimeout: typeof clearTimeout === 'function',
-            hasClearInterval: typeof clearInterval === 'function',
-            hasPath: typeof path === 'object',
-            hasTextEncoder: typeof TextEncoder === 'function',
-            hasTextDecoder: typeof TextDecoder === 'function',
-            hasBlob: typeof Blob === 'function',
-            hasFile: typeof File === 'function',
-            hasURL: typeof URL === 'function',
-            hasURLSearchParams: typeof URLSearchParams === 'function',
-            hasHeaders: typeof Headers === 'function',
-            hasRequest: typeof Request === 'function',
-            hasResponse: typeof Response === 'function',
-            hasFormData: typeof FormData === 'function',
-            hasAbortController: typeof AbortController === 'function',
-            hasAbortSignal: typeof AbortSignal === 'function',
-            hasReadableStream: typeof ReadableStream === 'function',
-            hasBtoa: typeof btoa === 'function',
-            hasAtob: typeof atob === 'function',
-          })
-        `);
-        const globals = JSON.parse(result as string);
-
-        assert.strictEqual(globals.hasFetch, true, "fetch should be defined");
-        assert.strictEqual(
-          globals.hasConsole,
-          true,
-          "console should be defined"
-        );
-        assert.strictEqual(globals.hasCrypto, true, "crypto should be defined");
-        assert.strictEqual(
-          globals.hasSetTimeout,
-          true,
-          "setTimeout should be defined"
-        );
-        assert.strictEqual(
-          globals.hasSetInterval,
-          true,
-          "setInterval should be defined"
-        );
-        assert.strictEqual(
-          globals.hasClearTimeout,
-          true,
-          "clearTimeout should be defined"
-        );
-        assert.strictEqual(
-          globals.hasClearInterval,
-          true,
-          "clearInterval should be defined"
-        );
-        assert.strictEqual(globals.hasPath, true, "path should be defined");
-        assert.strictEqual(
-          globals.hasTextEncoder,
-          true,
-          "TextEncoder should be defined"
-        );
-        assert.strictEqual(
-          globals.hasTextDecoder,
-          true,
-          "TextDecoder should be defined"
-        );
-        assert.strictEqual(globals.hasBlob, true, "Blob should be defined");
-        assert.strictEqual(globals.hasFile, true, "File should be defined");
-        assert.strictEqual(globals.hasURL, true, "URL should be defined");
-        assert.strictEqual(
-          globals.hasURLSearchParams,
-          true,
-          "URLSearchParams should be defined"
-        );
-        assert.strictEqual(
-          globals.hasHeaders,
-          true,
-          "Headers should be defined"
-        );
-        assert.strictEqual(
-          globals.hasRequest,
-          true,
-          "Request should be defined"
-        );
-        assert.strictEqual(
-          globals.hasResponse,
-          true,
-          "Response should be defined"
-        );
-        assert.strictEqual(
-          globals.hasFormData,
-          true,
-          "FormData should be defined"
-        );
-        assert.strictEqual(
-          globals.hasAbortController,
-          true,
-          "AbortController should be defined"
-        );
-        assert.strictEqual(
-          globals.hasAbortSignal,
-          true,
-          "AbortSignal should be defined"
-        );
-        assert.strictEqual(
-          globals.hasReadableStream,
-          true,
-          "ReadableStream should be defined"
-        );
-        assert.strictEqual(globals.hasBtoa, true, "btoa should be defined");
-        assert.strictEqual(globals.hasAtob, true, "atob should be defined");
-      } finally {
-        runtime.dispose();
-      }
-    });
-
-    test("dispose cleans up resources", async () => {
-      const runtime = await createRuntime();
-      runtime.dispose();
-
-      // After dispose, the isolate should be disposed
-      // Attempting to use it should throw
-      assert.throws(
-        () => {
-          runtime.isolate.createContextSync();
-        },
-        /disposed/i,
-        "isolate should be disposed"
-      );
-    });
-
-    test("accepts memory limit option", async () => {
-      const runtime = await createRuntime({
-        memoryLimit: 128,
-      });
-      try {
-        assert(runtime.isolate, "isolate should be created with memory limit");
-      } finally {
-        runtime.dispose();
-      }
-    });
-  });
-
-  describe("console integration", () => {
-    test("console.log is captured", async () => {
-      const logs: Array<{ level: string; args: unknown[] }> = [];
-
-      const runtime = await createRuntime({
-        console: {
-          onLog: (level, ...args) => {
-            logs.push({ level, args });
-          },
-        },
-      });
-
-      try {
-        await runtime.context.eval(`
-          console.log("hello", "world");
-          console.warn("warning message");
-          console.error("error message");
-        `);
-
-        assert.strictEqual(logs.length, 3, "should have captured 3 logs");
-        assert.strictEqual(logs[0].level, "log");
-        assert.deepStrictEqual(logs[0].args, ["hello", "world"]);
-        assert.strictEqual(logs[1].level, "warn");
-        assert.deepStrictEqual(logs[1].args, ["warning message"]);
-        assert.strictEqual(logs[2].level, "error");
-        assert.deepStrictEqual(logs[2].args, ["error message"]);
-      } finally {
-        runtime.dispose();
-      }
-    });
-  });
-
-  describe("fetch integration", () => {
-    test("fetch calls onFetch handler", async () => {
-      let capturedRequest: Request | null = null;
-
-      const runtime = await createRuntime({
-        fetch: {
-          onFetch: async (request) => {
-            capturedRequest = request;
-            return new Response(JSON.stringify({ message: "mocked" }), {
-              status: 200,
-              headers: { "Content-Type": "application/json" },
-            });
-          },
-        },
-      });
-
-      try {
-        const result = await runtime.context.eval(
-          `
-          (async () => {
-            const response = await fetch("https://example.com/api", {
-              method: "POST",
-              headers: { "X-Custom": "header" },
-              body: "test body"
-            });
-            return JSON.stringify({
-              status: response.status,
-              body: await response.json()
-            });
-          })()
-        `,
-          { promise: true }
-        );
-
-        const data = JSON.parse(result as string);
-        assert.strictEqual(data.status, 200);
-        assert.deepStrictEqual(data.body, { message: "mocked" });
-
-        // Verify the request was captured correctly
-        assert(capturedRequest, "request should be captured");
-        assert.strictEqual(capturedRequest!.url, "https://example.com/api");
-        assert.strictEqual(capturedRequest!.method, "POST");
-        assert.strictEqual(capturedRequest!.headers.get("X-Custom"), "header");
-      } finally {
-        runtime.dispose();
-      }
-    });
-  });
-
-  describe("timers integration", () => {
-    test("setTimeout works with tick()", async () => {
-      const runtime = await createRuntime();
-
-      try {
-        // Set up a timeout that modifies a global variable
-        await runtime.context.eval(`
-          globalThis.timerFired = false;
-          globalThis.timerValue = 0;
-          setTimeout(() => {
-            globalThis.timerFired = true;
-            globalThis.timerValue = 42;
-          }, 100);
-        `);
-
-        // Before tick, timer should not have fired
-        let result = await runtime.context.eval(`globalThis.timerFired`);
-        assert.strictEqual(result, false, "timer should not fire before tick");
-
-        // Tick forward 50ms - still not enough
-        await runtime.tick(50);
-        result = await runtime.context.eval(`globalThis.timerFired`);
-        assert.strictEqual(result, false, "timer should not fire at 50ms");
-
-        // Tick forward another 50ms (total 100ms) - now it should fire
-        await runtime.tick(50);
-        result = await runtime.context.eval(`globalThis.timerFired`);
-        assert.strictEqual(result, true, "timer should fire at 100ms");
-
-        result = await runtime.context.eval(`globalThis.timerValue`);
-        assert.strictEqual(result, 42, "timer should have set value");
-      } finally {
-        runtime.dispose();
-      }
-    });
-
-    test("setInterval works with tick()", async () => {
-      const runtime = await createRuntime();
-
-      try {
-        await runtime.context.eval(`
-          globalThis.intervalCount = 0;
-          setInterval(() => {
-            globalThis.intervalCount++;
-          }, 100);
-        `);
-
-        // Tick incrementally - interval fires at each 100ms boundary
-        await runtime.tick(100); // t=100ms, first fire
-        let count = await runtime.context.eval(`globalThis.intervalCount`);
-        assert.strictEqual(count, 1, "interval should fire once at 100ms");
-
-        await runtime.tick(100); // t=200ms, second fire
-        count = await runtime.context.eval(`globalThis.intervalCount`);
-        assert.strictEqual(count, 2, "interval should fire twice at 200ms");
-      } finally {
-        runtime.dispose();
-      }
-    });
-  });
-
-  describe("crypto integration", () => {
-    test("crypto.randomUUID generates valid UUIDs", async () => {
-      const runtime = await createRuntime();
-
-      try {
-        const uuid = (await runtime.context.eval(
-          `crypto.randomUUID()`
-        )) as string;
-        assert.match(
-          uuid,
-          /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
-          "should generate valid UUID v4"
-        );
-      } finally {
-        runtime.dispose();
-      }
-    });
-  });
-
-  describe("path integration", () => {
-    test("path.join works correctly", async () => {
-      const runtime = await createRuntime();
-
-      try {
-        const result = await runtime.context.eval(`path.join('a', 'b', 'c')`);
-        assert.strictEqual(result, "a/b/c");
-      } finally {
-        runtime.dispose();
-      }
-    });
-  });
-
-  describe("encoding integration", () => {
-    test("btoa and atob work correctly", async () => {
-      const runtime = await createRuntime();
-
-      try {
-        const encoded = await runtime.context.eval(`btoa('hello')`);
-        assert.strictEqual(encoded, "aGVsbG8=");
-
-        const decoded = await runtime.context.eval(`atob('aGVsbG8=')`);
-        assert.strictEqual(decoded, "hello");
-      } finally {
-        runtime.dispose();
-      }
-    });
-  });
-
-  describe("GC disposal", () => {
-    test("resources are cleaned up on dispose", async () => {
-      const runtime = await createRuntime();
-
-      // Create some resources
-      await runtime.context.eval(`
-        const blob = new Blob(["test"]);
-        const url = new URL("https://example.com");
-        setTimeout(() => {}, 1000);
-      `);
-
-      // Dispose should not throw
-      assert.doesNotThrow(() => {
-        runtime.dispose();
-      }, "dispose should not throw");
-
-      // After dispose, attempting to use the context should fail
-      await assert.rejects(
-        async () => {
-          await runtime.context.eval(`1 + 1`);
-        },
-        /released|disposed/i,
-        "context should be released after dispose"
-      );
-    });
-  });
-
-  describe("fs integration", () => {
-    test("getDirectory works when handler provided", async () => {
-      const files = new Map<
-        string,
-        { data: Uint8Array; lastModified: number; type: string }
-      >();
-      const directories = new Set<string>(["/"]); // Root directory exists
-
-      const createHandler = () => ({
-        async getFileHandle(path: string, options?: { create?: boolean }) {
-          if (!files.has(path) && !options?.create) {
-            throw new Error("[NotFoundError]File not found");
-          }
-          if (!files.has(path) && options?.create) {
-            files.set(path, {
-              data: new Uint8Array(0),
-              lastModified: Date.now(),
-              type: "",
-            });
-          }
-        },
-        async getDirectoryHandle(path: string, options?: { create?: boolean }) {
-          if (!directories.has(path) && !options?.create) {
-            throw new Error("[NotFoundError]Directory not found");
-          }
-          if (options?.create) {
-            directories.add(path);
-          }
-        },
-        async removeEntry(path: string) {
-          files.delete(path);
-          directories.delete(path);
-        },
-        async readDirectory(path: string) {
-          const entries: Array<{ name: string; kind: "file" | "directory" }> =
-            [];
-          for (const filePath of files.keys()) {
-            const dir = filePath.substring(0, filePath.lastIndexOf("/")) || "/";
-            if (dir === path) {
-              entries.push({
-                name: filePath.substring(filePath.lastIndexOf("/") + 1),
-                kind: "file",
-              });
-            }
-          }
-          for (const dirPath of directories) {
-            if (dirPath !== path && dirPath.startsWith(path)) {
-              const relativePath = dirPath.substring(path.length);
-              const parts = relativePath.split("/").filter(Boolean);
-              if (parts.length === 1) {
-                entries.push({ name: parts[0], kind: "directory" });
-              }
-            }
-          }
-          return entries;
-        },
-        async readFile(path: string) {
-          const file = files.get(path);
-          if (!file) {
-            throw new Error("[NotFoundError]File not found");
-          }
-          return {
-            data: file.data,
-            size: file.data.length,
-            lastModified: file.lastModified,
-            type: file.type,
-          };
-        },
-        async writeFile(path: string, data: Uint8Array) {
-          const existing = files.get(path);
-          files.set(path, {
-            data,
-            lastModified: Date.now(),
-            type: existing?.type ?? "",
-          });
-        },
-        async truncateFile(path: string, size: number) {
-          const file = files.get(path);
-          if (file) {
-            file.data = file.data.slice(0, size);
-          }
-        },
-        async getFileMetadata(path: string) {
-          const file = files.get(path);
-          if (!file) {
-            throw new Error("[NotFoundError]File not found");
-          }
-          return {
-            size: file.data.length,
-            lastModified: file.lastModified,
-            type: file.type,
-          };
-        },
-      });
-
-      const runtime = await createRuntime({
-        fs: {
-          getDirectory: async () => createHandler(),
-        },
-      });
-
-      try {
-        const result = await runtime.context.eval(
-          `
-          (async () => {
-            const root = await getDirectory("/");
-            return root.kind;
-          })()
-        `,
-          { promise: true }
-        );
-        assert.strictEqual(result, "directory");
-      } finally {
-        runtime.dispose();
-      }
-    });
-  });
-});

package/src/index.ts

@@ -1,164 +0,0 @@
-import ivm from "isolated-vm";
-import { setupCore } from "@ricsam/isolate-core";
-import { setupConsole } from "@ricsam/isolate-console";
-import { setupEncoding } from "@ricsam/isolate-encoding";
-import { setupTimers } from "@ricsam/isolate-timers";
-import { setupPath } from "@ricsam/isolate-path";
-import { setupCrypto } from "@ricsam/isolate-crypto";
-import { setupFetch } from "@ricsam/isolate-fetch";
-import { setupFs } from "@ricsam/isolate-fs";
-
-import type { ConsoleOptions, ConsoleHandle } from "@ricsam/isolate-console";
-import type { FetchOptions, FetchHandle } from "@ricsam/isolate-fetch";
-import type { FsOptions, FsHandle } from "@ricsam/isolate-fs";
-import type { CoreHandle } from "@ricsam/isolate-core";
-import type { EncodingHandle } from "@ricsam/isolate-encoding";
-import type { TimersHandle } from "@ricsam/isolate-timers";
-import type { PathHandle } from "@ricsam/isolate-path";
-import type { CryptoHandle } from "@ricsam/isolate-crypto";
-
-export interface RuntimeOptions {
-  /** Isolate memory limit in MB */
-  memoryLimit?: number;
-  /** Console options */
-  console?: ConsoleOptions;
-  /** Fetch options */
-  fetch?: FetchOptions;
-  /** File system options (optional - fs only set up if provided) */
-  fs?: FsOptions;
-}
-
-export interface RuntimeHandle {
-  /** The isolate instance */
-  readonly isolate: ivm.Isolate;
-  /** The context instance */
-  readonly context: ivm.Context;
-  /** The fetch handle for serve() and WebSocket dispatching */
-  readonly fetch: FetchHandle;
-  /** Process pending timers */
-  tick(ms?: number): Promise<void>;
-  /** Dispose all resources */
-  dispose(): void;
-}
-
-/**
- * Create a fully configured isolated-vm runtime
- *
- * Sets up all WHATWG APIs: fetch, fs, console, crypto, encoding, timers
- *
- * @example
- * const runtime = await createRuntime({
- *   console: {
- *     onLog: (level, ...args) => console.log(`[${level}]`, ...args)
- *   },
- *   fetch: {
- *     onFetch: async (request) => fetch(request)
- *   }
- * });
- *
- * await runtime.context.eval(`
- *   console.log("Hello from sandbox!");
- *   const response = await fetch("https://example.com");
- * `);
- *
- * runtime.dispose();
- */
-export async function createRuntime(
-  options?: RuntimeOptions
-): Promise<RuntimeHandle> {
-  const opts = options ?? {};
-
-  // Create isolate with optional memory limit
-  const isolate = new ivm.Isolate({
-    memoryLimit: opts.memoryLimit,
-  });
-  const context = await isolate.createContext();
-
-  // Store all handles for disposal
-  const handles: {
-    core?: CoreHandle;
-    console?: ConsoleHandle;
-    encoding?: EncodingHandle;
-    timers?: TimersHandle;
-    path?: PathHandle;
-    crypto?: CryptoHandle;
-    fetch?: FetchHandle;
-    fs?: FsHandle;
-  } = {};
-
-  // Setup all APIs in order
-  // Core must be first as it provides Blob, File, streams, URL, etc.
-  handles.core = await setupCore(context);
-
-  // Console
-  handles.console = await setupConsole(context, opts.console);
-
-  // Encoding (btoa/atob)
-  handles.encoding = await setupEncoding(context);
-
-  // Timers (setTimeout, setInterval)
-  handles.timers = await setupTimers(context);
-
-  // Path module
-  handles.path = await setupPath(context);
-
-  // Crypto (randomUUID, getRandomValues)
-  handles.crypto = await setupCrypto(context);
-
-  // Fetch API
-  handles.fetch = await setupFetch(context, opts.fetch);
-
-  // File system (only if handler provided)
-  if (opts.fs) {
-    handles.fs = await setupFs(context, opts.fs);
-  }
-
-  return {
-    isolate,
-    context,
-    fetch: handles.fetch!,
-    async tick(ms?: number) {
-      await handles.timers!.tick(ms);
-    },
-    dispose() {
-      // Dispose all handles
-      handles.fs?.dispose();
-      handles.fetch?.dispose();
-      handles.crypto?.dispose();
-      handles.path?.dispose();
-      handles.timers?.dispose();
-      handles.encoding?.dispose();
-      handles.console?.dispose();
-      handles.core?.dispose();
-
-      // Release context and dispose isolate
-      context.release();
-      isolate.dispose();
-    },
-  };
-}
-
-// Re-export all package types and functions
-export { setupCore } from "@ricsam/isolate-core";
-export type { CoreHandle, SetupCoreOptions } from "@ricsam/isolate-core";
-
-export { setupConsole } from "@ricsam/isolate-console";
-export type { ConsoleHandle, ConsoleOptions } from "@ricsam/isolate-console";
-
-export { setupCrypto } from "@ricsam/isolate-crypto";
-export type { CryptoHandle } from "@ricsam/isolate-crypto";
-
-export { setupEncoding } from "@ricsam/isolate-encoding";
-export type { EncodingHandle } from "@ricsam/isolate-encoding";
-
-export { setupFetch } from "@ricsam/isolate-fetch";
-export type { FetchHandle, FetchOptions, WebSocketCommand, UpgradeRequest } from "@ricsam/isolate-fetch";
-
-export { setupFs, createNodeFileSystemHandler } from "@ricsam/isolate-fs";
-export type { FsHandle, FsOptions, FileSystemHandler, NodeFileSystemHandlerOptions } from "@ricsam/isolate-fs";
-
-export { setupPath } from "@ricsam/isolate-path";
-export type { PathHandle } from "@ricsam/isolate-path";
-
-export { setupTimers } from "@ricsam/isolate-timers";
-export type { TimersHandle } from "@ricsam/isolate-timers";

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "rootDir": "./src"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
-}