@scelar/nodepod 1.0.0

package/dist/index.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const index = require('./index-DsMGS-xc.cjs');
+
+
+
+exports.DependencyInstaller = index.DependencyInstaller;
+exports.IframeSandbox = index.IframeSandbox;
+exports.MemoryVolume = index.MemoryVolume;
+exports.Nodepod = index.Nodepod;
+exports.NodepodFS = index.NodepodFS;
+exports.NodepodProcess = index.NodepodProcess;
+exports.NodepodTerminal = index.NodepodTerminal;
+exports.ProcessHandle = index.ProcessHandle;
+exports.ProcessManager = index.ProcessManager;
+exports.ProcessWorkerAdapter = index.ProcessWorkerAdapter;
+exports.RequestProxy = index.RequestProxy;
+exports.SANDBOX_DEPLOYMENT_GUIDE = index.SANDBOX_DEPLOYMENT_GUIDE;
+exports.ScriptEngine = index.ScriptEngine;
+exports.SharedVFSController = index.SharedVFSController;
+exports.SharedVFSReader = index.SharedVFSReader;
+exports.SyncChannelController = index.SyncChannelController;
+exports.SyncChannelWorker = index.SyncChannelWorker;
+exports.VFSBridge = index.VFSBridge;
+exports.WorkerSandbox = index.WorkerSandbox;
+exports.WorkerVFS = index.WorkerVFS;
+exports.assert = index.assert;
+exports.buildFileSystemBridge = index.buildFileSystemBridge;
+exports.buildProcessEnv = index.buildProcessEnv;
+exports.chokidar = index.watcherPolyfill;
+exports.createProcessContext = index.createProcessContext;
+exports.createWorkspace = index.createWorkspace;
+exports.default = index.createWorkspace;
+exports.esbuild = index.esbuildPolyfill;
+exports.events = index.events;
+exports.executeCode = index.executeCode;
+exports.fsevents = index.macEventsPolyfill;
+exports.generateSandboxDeployment = index.generateSandboxDeployment;
+exports.getActiveContext = index.getActiveContext;
+exports.getProxyInstance = index.getProxyInstance;
+exports.getSandboxHostingConfig = index.getSandboxHostingConfig;
+exports.getSandboxPageHtml = index.getSandboxPageHtml;
+exports.http = index.httpPolyfill;
+exports.install = index.install;
+exports.isSharedArrayBufferAvailable = index.isSharedArrayBufferAvailable;
+exports.module = index.module;
+exports.net = index.tcpPolyfill;
+exports.npm = index.installer;
+exports.path = index.pathPolyfill;
+exports.perf_hooks = index.perfPolyfill;
+exports.querystring = index.qsPolyfill;
+exports.readdirp = index.scannerPolyfill;
+exports.resetProxy = index.resetProxy;
+exports.rollup = index.rollupPolyfill;
+exports.setActiveContext = index.setActiveContext;
+exports.spawnEngine = index.spawnEngine;
+exports.spawnProcessWorkerEngine = index.spawnProcessWorkerEngine;
+exports.stream = index.stream;
+exports.url = index.urlPolyfill;
+exports.util = index.helpersPolyfill;
+exports.worker_threads = index.threadPoolPolyfill;
+exports.ws = index.wsPolyfill;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.mjs

@@ -0,0 +1,59 @@
+import { p, I, q, s, t, v, w, P, x, y, z, A, S, C, F, G, H, J, K, O, Q, U, X, Z, _, $, $ as $2, a0, a1, a2, a3, a4, l, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af, ag, ah, ai, aj, ak, al, am, an, ao, ap, aq, ar } from "./index-Cb1Cgdnd.js";
+export {
+  p as DependencyInstaller,
+  I as IframeSandbox,
+  q as MemoryVolume,
+  s as Nodepod,
+  t as NodepodFS,
+  v as NodepodProcess,
+  w as NodepodTerminal,
+  P as ProcessHandle,
+  x as ProcessManager,
+  y as ProcessWorkerAdapter,
+  z as RequestProxy,
+  A as SANDBOX_DEPLOYMENT_GUIDE,
+  S as ScriptEngine,
+  C as SharedVFSController,
+  F as SharedVFSReader,
+  G as SyncChannelController,
+  H as SyncChannelWorker,
+  J as VFSBridge,
+  K as WorkerSandbox,
+  O as WorkerVFS,
+  Q as assert,
+  U as buildFileSystemBridge,
+  X as buildProcessEnv,
+  Z as chokidar,
+  _ as createProcessContext,
+  $ as createWorkspace,
+  $2 as default,
+  a0 as esbuild,
+  a1 as events,
+  a2 as executeCode,
+  a3 as fsevents,
+  a4 as generateSandboxDeployment,
+  l as getActiveContext,
+  a5 as getProxyInstance,
+  a6 as getSandboxHostingConfig,
+  a7 as getSandboxPageHtml,
+  a8 as http,
+  a9 as install,
+  aa as isSharedArrayBufferAvailable,
+  ab as module,
+  ac as net,
+  ad as npm,
+  ae as path,
+  af as perf_hooks,
+  ag as querystring,
+  ah as readdirp,
+  ai as resetProxy,
+  aj as rollup,
+  ak as setActiveContext,
+  al as spawnEngine,
+  am as spawnProcessWorkerEngine,
+  an as stream,
+  ao as url,
+  ap as util,
+  aq as worker_threads,
+  ar as ws
+};

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@scelar/nodepod",
+  "version": "1.0.0",
+  "description": "Browser-native Node.js runtime environment",
+  "type": "module",
+  "license": "MIT WITH Commons-Clause",
+  "author": "R1ck404 (https://github.com/R1ck404)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ScelarOrg/Nodepod.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ScelarOrg/Nodepod/issues"
+  },
+  "homepage": "https://github.com/ScelarOrg/Nodepod#readme",
+  "keywords": [
+    "node",
+    "browser",
+    "runtime",
+    "sandbox",
+    "typescript",
+    "virtual-filesystem",
+    "polyfill",
+    "webcontainer",
+    "in-browser",
+    "nodejs"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "src",
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build:lib": "vite build --config vite.lib.config.js && cp static/__sw__.js dist/__sw__.js",
+    "build:types": "tsc --project tsconfig.build.json",
+    "build:publish": "npm run build:lib && npm run build:types",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "acorn": "^8.15.0",
+    "acorn-jsx": "^5.3.2",
+    "brotli": "^1.3.3",
+    "brotli-wasm": "^3.0.1",
+    "comlink": "^4.4.2",
+    "pako": "^2.1.0",
+    "resolve.exports": "^2.0.3",
+    "zod": "^4.3.6"
+  },
+  "peerDependencies": {
+    "@xterm/xterm": "^6.0.0",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/addon-webgl": "^0.19.0"
+  },
+  "peerDependenciesMeta": {
+    "@xterm/xterm": {
+      "optional": true
+    },
+    "@xterm/addon-fit": {
+      "optional": true
+    },
+    "@xterm/addon-webgl": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.10",
+    "@types/pako": "^2.0.4",
+    "esbuild": "^0.27.2",
+    "typescript": "^5.9.3",
+    "vite": "^5.4.0",
+    "vite-plugin-top-level-await": "^1.6.0",
+    "vite-plugin-wasm": "^3.5.0",
+    "vitest": "^4.0.18"
+  }
+}

package/src/__tests__/smoke.test.ts

@@ -0,0 +1,11 @@
+import { describe, it, expect } from "vitest";
+import { MemoryVolume } from "../memory-volume";
+
+describe("smoke", () => {
+  it("MemoryVolume read/write round-trip", () => {
+    const vol = new MemoryVolume();
+    vol.mkdirSync("/tmp", { recursive: true });
+    vol.writeFileSync("/tmp/hello.txt", "world");
+    expect(vol.readFileSync("/tmp/hello.txt", "utf8")).toBe("world");
+  });
+});

package/src/constants/cdn-urls.ts

@@ -0,0 +1,18 @@
+// Pinned CDN versions and URLs
+
+export const PINNED_ESBUILD_WASM = '0.20.0';
+export const PINNED_ROLLUP_BROWSER = '4.9.0';
+export const PINNED_BROTLI_WASM = '3.0.1';
+export const PINNED_LIGHTNINGCSS_WASM = '1.31.1';
+
+export const CDN_ESBUILD_ESM = `https://esm.sh/esbuild-wasm@${PINNED_ESBUILD_WASM}`;
+export const CDN_ESBUILD_BINARY = `https://esm.sh/esbuild-wasm@${PINNED_ESBUILD_WASM}/esbuild.wasm`;
+export const CDN_ESBUILD_BROWSER = `https://esm.sh/esbuild-wasm@${PINNED_ESBUILD_WASM}/esm/browser.min.js`;
+export const CDN_ROLLUP_BROWSER = `https://esm.sh/@rollup/browser@${PINNED_ROLLUP_BROWSER}`;
+export const CDN_BROTLI_WASM = `https://esm.sh/brotli-wasm@${PINNED_BROTLI_WASM}`;
+export const CDN_LIGHTNINGCSS_WASM = `https://esm.sh/lightningcss-wasm@${PINNED_LIGHTNINGCSS_WASM}`;
+
+// new Function hides import() from bundler static analysis so CDN URLs work at runtime
+// eslint-disable-next-line @typescript-eslint/no-implied-eval
+const _dynamicImport = new Function("url", "return import(url)") as (url: string) => Promise<any>;
+export { _dynamicImport as cdnImport };

package/src/constants/config.ts

@@ -0,0 +1,236 @@
+// Centralized config constants. Import from here instead of hardcoding.
+
+// ---------------------------------------------------------------------------
+// Runtime version strings
+// ---------------------------------------------------------------------------
+
+export const VERSIONS = {
+  NODE: "v22.12.0",
+  NODE_BARE: "22.12.0",
+  NPM: "10.0.0",
+  PNPM: "9.15.4",
+  YARN: "4.6.0",
+  BUN: "1.1.38",
+  BUN_V: "v1.1.38",
+  GIT: "2.43.0",
+} as const;
+
+export const NODE_SUB_VERSIONS = {
+  node: VERSIONS.NODE_BARE,
+  v8: "11.3.244.8",
+  uv: "1.44.2",
+  modules: "115",
+  openssl: "3.0.13",
+  napi: "9",
+  webcontainer: "1.0.0",
+} as const;
+
+// ---------------------------------------------------------------------------
+// npm registry
+// ---------------------------------------------------------------------------
+
+export const NPM_REGISTRY_URL = "https://registry.npmjs.org";
+export const NPM_REGISTRY_URL_SLASH = "https://registry.npmjs.org/";
+
+// ---------------------------------------------------------------------------
+// CDN (pako only -- the rest are in cdn-urls.ts)
+// ---------------------------------------------------------------------------
+
+export const PINNED_PAKO = "2.1.0";
+export const CDN_PAKO = `https://esm.sh/pako@${PINNED_PAKO}`;
+
+// ---------------------------------------------------------------------------
+// Module resolution file extensions
+// ---------------------------------------------------------------------------
+
+export const RESOLVE_EXTENSIONS = [
+  ".js",
+  ".ts",
+  ".jsx",
+  ".tsx",
+  ".mjs",
+  ".cjs",
+  ".json",
+] as const;
+
+export const MAIN_FIELD_EXTENSIONS = [
+  ".js",
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".jsx",
+  ".json",
+  ".mjs",
+  ".cjs",
+] as const;
+
+export const INDEX_FILES = [
+  "index.js",
+  "index.ts",
+  "index.tsx",
+  "index.mjs",
+  "index.cjs",
+] as const;
+
+export const IMPORTS_FIELD_EXTENSIONS = [
+  ".js",
+  ".ts",
+  ".cjs",
+  ".mjs",
+  ".json",
+] as const;
+
+export const ESBUILD_LOADER_MAP: Record<string, string> = {
+  ".ts": "ts",
+  ".tsx": "tsx",
+  ".js": "js",
+  ".mjs": "js",
+  ".cjs": "js",
+  ".jsx": "jsx",
+  ".json": "json",
+  ".css": "css",
+  ".map": "json",
+  ".txt": "text",
+  ".wasm": "file",
+};
+
+// ---------------------------------------------------------------------------
+// Mock system environment
+// ---------------------------------------------------------------------------
+
+export const MOCK_OS = {
+  PLATFORM: "linux" as const,
+  ARCH: "x64" as const,
+  TYPE: "Linux",
+  RELEASE: "5.10.0",
+  VERSION: "#1 SMP",
+  MACHINE: "x86_64",
+  HOSTNAME: "localhost",
+  HOMEDIR: "/home/user",
+  TMPDIR: "/tmp",
+  SHELL: "/bin/bash",
+  USERNAME: "user",
+  ENDIANNESS: "LE" as const,
+} as const;
+
+export const MOCK_IDS = {
+  UID: 1000,
+  GID: 1000,
+} as const;
+
+export const MOCK_FS = {
+  BLOCK_SIZE: 4096,
+  BLOCK_CALC_SIZE: 512,
+} as const;
+
+export const MOCK_CPU = {
+  MODEL: "Virtual CPU",
+  SPEED: 2400,
+  COUNT: 2,
+} as const;
+
+export const MOCK_MEMORY = {
+  TOTAL: 4 * 1024 * 1024 * 1024,
+  FREE: 2 * 1024 * 1024 * 1024,
+  RSS: 50 * 1024 * 1024,
+  HEAP_TOTAL: 30 * 1024 * 1024,
+  HEAP_USED: 20 * 1024 * 1024,
+  EXTERNAL: 1 * 1024 * 1024,
+} as const;
+
+export const MOCK_LOADAVG: readonly [number, number, number] = [0.5, 0.5, 0.5];
+
+export const DEFAULT_TERMINAL = {
+  COLUMNS: 80,
+  ROWS: 24,
+  FONT_SIZE: 13,
+} as const;
+
+export const MOCK_PROCESS = {
+  PID: 1,
+  PPID: 0,
+  TITLE: "node",
+  EXEC_PATH: "/usr/local/bin/node",
+} as const;
+
+// ---------------------------------------------------------------------------
+// Default environment variables
+// ---------------------------------------------------------------------------
+
+export const DEFAULT_ENV = {
+  NODE_ENV: "development",
+  PATH: "/usr/local/bin:/usr/bin:/bin",
+  HOME: "/",
+  SHELL: "/bin/sh",
+  TERM: "xterm-256color",
+  COLORTERM: "truecolor",
+  REQUIRES_WASM: "true",
+  npm_config_user_agent: `npm/${VERSIONS.NPM} node/${VERSIONS.NODE} linux x64 workspaces/false`,
+  npm_execpath: "/usr/local/lib/node_modules/npm/bin/npm-cli.js",
+  npm_node_execpath: "/usr/local/bin/node",
+} as const;
+
+// ---------------------------------------------------------------------------
+// Timeouts and limits
+// ---------------------------------------------------------------------------
+
+export const TIMEOUTS = {
+  SYNC_OP: 120_000,
+  WAIT_LOOP_TICK: 200,
+  SW_HEARTBEAT: 20_000,
+  WORKER_REAP_INTERVAL: 10_000,
+  WORKER_IDLE_TIMEOUT: 30_000,
+  WORKER_INIT_TIMEOUT: 30_000,
+  HTTP_KEEP_ALIVE: 5000,
+  HTTP_HEADERS: 60000,
+  HTTP_DISPATCH_SAFETY: 120000,
+} as const;
+
+export const LIMITS = {
+  MAX_RESOLVE_DEPTH: 50,
+  MODULE_CACHE_MAX: 2000,
+  MAX_WORKERS_CAP: 6,
+} as const;
+
+// ---------------------------------------------------------------------------
+// Port range for net.Server.listen(0)
+// ---------------------------------------------------------------------------
+
+export const PORT_RANGE = {
+  BASE: 3000,
+  RANGE: 1000,
+} as const;
+
+// ---------------------------------------------------------------------------
+// CDN
+// ---------------------------------------------------------------------------
+
+export const DEFAULT_NODEPOD_CDN = "https://unpkg.com/@scelar/nodepod/dist/index.js";
+
+// ---------------------------------------------------------------------------
+// PIDs
+// ---------------------------------------------------------------------------
+
+export const MOCK_PID = {
+  BASE: 1000,
+  RANGE: 10000,
+} as const;
+
+// ---------------------------------------------------------------------------
+// Shell constants
+// ---------------------------------------------------------------------------
+
+export const LS_BLOCK_SIZE = 512;
+export const YES_REPEAT_COUNT = 100;
+
+// ---------------------------------------------------------------------------
+// WebSocket opcodes (RFC 6455)
+// ---------------------------------------------------------------------------
+
+export const WS_OPCODE = {
+  TEXT: 0x01,
+  BINARY: 0x02,
+  CLOSE: 0x08,
+  PING: 0x09,
+  PONG: 0x0a,
+} as const;

package/src/cross-origin.ts

@@ -0,0 +1,26 @@
+// optional CORS proxy for APIs that don't allow browser origins
+
+let activeProxy: string | null = null;
+
+export function setProxy(url: string | null): void {
+  activeProxy = url;
+}
+
+export function getProxy(): string | null {
+  return activeProxy;
+}
+
+export function isProxyActive(): boolean {
+  return activeProxy !== null;
+}
+
+export async function proxiedFetch(url: string, init?: RequestInit): Promise<Response> {
+  if (activeProxy) {
+    return fetch(activeProxy + encodeURIComponent(url), init);
+  }
+  return fetch(url, init);
+}
+
+export function resolveProxyUrl(url: string): string {
+  return activeProxy ? activeProxy + encodeURIComponent(url) : url;
+}

package/src/engine-factory.ts

@@ -0,0 +1,176 @@
+// spawns a ScriptEngine in the requested execution mode:
+// sandboxUrl → cross-origin iframe, useWorker → Worker thread, otherwise main thread
+
+import { ScriptEngine } from './script-engine';
+import { WorkerSandbox } from './worker-sandbox';
+import { IframeSandbox } from './iframe-sandbox';
+import type { MemoryVolume } from './memory-volume';
+import type { IScriptEngine, ExecutionOutcome, SpawnEngineConfig, EngineConfig } from './engine-types';
+import { ProcessManager } from './threading/process-manager';
+import { VFSBridge } from './threading/vfs-bridge';
+
+function canUseWorker(): boolean {
+  return typeof Worker !== 'undefined';
+}
+
+// wraps the synchronous ScriptEngine behind the async IScriptEngine interface
+class SyncEngineAdapter implements IScriptEngine {
+  private engine: ScriptEngine;
+
+  constructor(vol: MemoryVolume, cfg: EngineConfig = {}) {
+    this.engine = new ScriptEngine(vol, cfg);
+  }
+
+  async execute(code: string, filename?: string): Promise<ExecutionOutcome> {
+    return Promise.resolve(this.engine.execute(code, filename));
+  }
+
+  async runFile(filename: string): Promise<ExecutionOutcome> {
+    return Promise.resolve(this.engine.runFile(filename));
+  }
+
+  clearCache(): void { this.engine.clearCache(); }
+  getVolume(): MemoryVolume { return this.engine.getVolume(); }
+
+  unwrap(): ScriptEngine { return this.engine; }
+}
+
+// create a script engine in the appropriate execution mode
+// throws if neither sandboxUrl nor allowUnsafeEval is specified
+export async function spawnEngine(
+  vol: MemoryVolume,
+  config: SpawnEngineConfig = {},
+): Promise<IScriptEngine> {
+  const { sandboxUrl, allowUnsafeEval, useWorker = false, ...engineCfg } = config;
+
+  if (sandboxUrl) {
+    const sandbox = new IframeSandbox(sandboxUrl, vol, engineCfg);
+    await sandbox.execute('/* sandbox ready check */', '/__sandbox_init__.js');
+    return sandbox;
+  }
+
+  if (!allowUnsafeEval) {
+    throw new Error(
+      'nodepod: For security, you must either:\n' +
+      '  1. Use sandbox mode: { sandboxUrl: "https://your-sandbox.example.com" }\n' +
+      '  2. Explicitly opt-in to same-origin: { allowUnsafeEval: true }\n\n' +
+      'Same-origin execution allows code to access cookies, localStorage, and IndexedDB.\n' +
+      'Only use allowUnsafeEval for trusted code or demos.'
+    );
+  }
+
+  let shouldUseWorker = false;
+  if (useWorker === true) {
+    shouldUseWorker = canUseWorker();
+  } else if (useWorker === 'auto') {
+    shouldUseWorker = canUseWorker();
+  }
+
+  if (shouldUseWorker) {
+    const worker = new WorkerSandbox(vol, engineCfg);
+    await worker.execute('/* worker ready check */', '/__worker_init__.js');
+    return worker;
+  }
+
+  return new SyncEngineAdapter(vol, engineCfg);
+}
+
+// ---- Process-worker engine adapter ----
+
+// wraps ProcessManager-based workers behind IScriptEngine.
+// each execute()/runFile() spawns a new worker process.
+class ProcessWorkerAdapter implements IScriptEngine {
+  private _vol: MemoryVolume;
+  private _processManager: ProcessManager;
+  private _vfsBridge: VFSBridge;
+  private _cfg: EngineConfig;
+
+  constructor(vol: MemoryVolume, cfg: EngineConfig = {}) {
+    this._vol = vol;
+    this._cfg = cfg;
+    this._processManager = new ProcessManager(vol);
+    this._vfsBridge = new VFSBridge(vol);
+    this._processManager.setVFSBridge(this._vfsBridge);
+
+    this._vfsBridge.setBroadcaster((path, content, excludePid) => {
+      const isDirectory = content !== null && content.byteLength === 0;
+      this._processManager.broadcastVFSChange(path, content, isDirectory, excludePid);
+    });
+  }
+
+  async execute(code: string, filename?: string): Promise<ExecutionOutcome> {
+    const tmpFile = filename ?? '/__exec_tmp__.js';
+    this._vol.writeFileSync(tmpFile, code as any);
+
+    const result = await this._runInWorker(tmpFile);
+    return result;
+  }
+
+  async runFile(filename: string): Promise<ExecutionOutcome> {
+    return this._runInWorker(filename);
+  }
+
+  private async _runInWorker(filePath: string): Promise<ExecutionOutcome> {
+    return new Promise<ExecutionOutcome>((resolve) => {
+      const handle = this._processManager.spawn({
+        command: 'node',
+        args: [filePath],
+        cwd: this._cfg.cwd ?? '/',
+        env: (this._cfg as any).env ?? {},
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      handle.on('stdout', (data: string) => { stdout += data; });
+      handle.on('stderr', (data: string) => { stderr += data; });
+
+      handle.on('ready', () => {
+        handle.exec({
+          type: 'exec',
+          filePath,
+          args: [],
+          cwd: this._cfg.cwd,
+          env: (this._cfg as any).env,
+        });
+      });
+
+      handle.on('exit', (_exitCode: number) => {
+        resolve({
+          exports: {},
+          module: {
+            id: filePath,
+            filename: filePath,
+            exports: {},
+            loaded: true,
+            children: [],
+            paths: [],
+          },
+        });
+      });
+    });
+  }
+
+  clearCache(): void { }
+  getVolume(): MemoryVolume { return this._vol; }
+
+  getProcessManager(): ProcessManager { return this._processManager; }
+
+  teardown(): void {
+    this._processManager.teardown();
+  }
+}
+
+// create a process-worker engine where each execution runs in a dedicated Web Worker
+export async function spawnProcessWorkerEngine(
+  vol: MemoryVolume,
+  config: EngineConfig = {},
+): Promise<ProcessWorkerAdapter> {
+  return new ProcessWorkerAdapter(vol, config);
+}
+
+export { ScriptEngine } from './script-engine';
+export { WorkerSandbox } from './worker-sandbox';
+export { IframeSandbox } from './iframe-sandbox';
+export { ProcessWorkerAdapter };
+export type { IScriptEngine, ExecutionOutcome, EngineConfig, SpawnEngineConfig, VolumeSnapshot } from './engine-types';