@ricsam/isolate 0.0.1 → 0.1.0

package/dist/cjs/daemon.cjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+
+// packages/isolate/src/daemon.ts
+var import_daemon = require("./internal/daemon/index.cjs");
+process.removeAllListeners("warning");
+process.on("warning", (warning) => {
+  if (warning.name === "ExperimentalWarning" && warning.message.includes("stripTypeScriptTypes")) {
+    return;
+  }
+  console.warn(warning);
+});
+function parseArgs(args) {
+  const options = {};
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    switch (arg) {
+      case "--socket":
+        index += 1;
+        if (args[index]) {
+          options.socketPath = args[index];
+        }
+        break;
+      case "--host":
+        index += 1;
+        if (args[index]) {
+          options.host = args[index];
+          options.socketPath = undefined;
+        }
+        break;
+      case "--port":
+        index += 1;
+        if (args[index]) {
+          options.port = Number.parseInt(args[index], 10);
+          options.socketPath = undefined;
+        }
+        break;
+      case "--max-isolates":
+        index += 1;
+        if (args[index]) {
+          options.maxIsolates = Number.parseInt(args[index], 10);
+        }
+        break;
+      case "--memory-limit":
+        index += 1;
+        if (args[index]) {
+          options.defaultMemoryLimitMB = Number.parseInt(args[index], 10);
+        }
+        break;
+      case "--help":
+      case "-h":
+        console.log(`
+Isolate Daemon - Run isolated-vm runtimes accessible via IPC
+
+Usage:
+  isolate-daemon [options]
+
+Options:
+  --socket <path>       Unix socket path (default: /tmp/isolate-daemon.sock)
+  --host <host>         TCP host (default: 127.0.0.1, disables Unix socket)
+  --port <port>         TCP port (default: 47891, disables Unix socket)
+  --max-isolates <n>    Maximum isolates (default: 100)
+  --memory-limit <mb>   Default memory limit in MB (default: 128)
+  --help, -h            Show this help message
+`);
+        process.exit(0);
+      default:
+        if (arg?.startsWith("-")) {
+          console.error(`Unknown option: ${arg}`);
+          process.exit(1);
+        }
+    }
+  }
+  return options;
+}
+async function main() {
+  const daemon = await import_daemon.startDaemon(parseArgs(process.argv.slice(2)));
+  const shutdown = async () => {
+    console.log(`
+Shutting down...`);
+    await daemon.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((error) => {
+  console.error("Failed to start daemon:", error);
+  process.exit(1);
+});
+
+//# debugId=A3FECC3CB418FD2864756E2164756E21

package/dist/cjs/daemon.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/daemon.ts"],
+  "sourcesContent": [
+    "#!/usr/bin/env node\n\nprocess.removeAllListeners(\"warning\");\nprocess.on(\"warning\", (warning) => {\n  if (\n    warning.name === \"ExperimentalWarning\" &&\n    warning.message.includes(\"stripTypeScriptTypes\")\n  ) {\n    return;\n  }\n  console.warn(warning);\n});\n\nimport { startDaemon, type DaemonOptions } from \"./internal/daemon/index.cjs\";\n\nfunction parseArgs(args: string[]): Partial<DaemonOptions> {\n  const options: Partial<DaemonOptions> = {};\n\n  for (let index = 0; index < args.length; index += 1) {\n    const arg = args[index];\n\n    switch (arg) {\n      case \"--socket\":\n        index += 1;\n        if (args[index]) {\n          options.socketPath = args[index];\n        }\n        break;\n      case \"--host\":\n        index += 1;\n        if (args[index]) {\n          options.host = args[index];\n          options.socketPath = undefined;\n        }\n        break;\n      case \"--port\":\n        index += 1;\n        if (args[index]) {\n          options.port = Number.parseInt(args[index]!, 10);\n          options.socketPath = undefined;\n        }\n        break;\n      case \"--max-isolates\":\n        index += 1;\n        if (args[index]) {\n          options.maxIsolates = Number.parseInt(args[index]!, 10);\n        }\n        break;\n      case \"--memory-limit\":\n        index += 1;\n        if (args[index]) {\n          options.defaultMemoryLimitMB = Number.parseInt(args[index]!, 10);\n        }\n        break;\n      case \"--help\":\n      case \"-h\":\n        console.log(`\nIsolate Daemon - Run isolated-vm runtimes accessible via IPC\n\nUsage:\n  isolate-daemon [options]\n\nOptions:\n  --socket <path>       Unix socket path (default: /tmp/isolate-daemon.sock)\n  --host <host>         TCP host (default: 127.0.0.1, disables Unix socket)\n  --port <port>         TCP port (default: 47891, disables Unix socket)\n  --max-isolates <n>    Maximum isolates (default: 100)\n  --memory-limit <mb>   Default memory limit in MB (default: 128)\n  --help, -h            Show this help message\n`);\n        process.exit(0);\n      default:\n        if (arg?.startsWith(\"-\")) {\n          console.error(`Unknown option: ${arg}`);\n          process.exit(1);\n        }\n    }\n  }\n\n  return options;\n}\n\nasync function main() {\n  const daemon = await startDaemon(parseArgs(process.argv.slice(2)));\n  const shutdown = async () => {\n    console.log(\"\\nShutting down...\");\n    await daemon.close();\n    process.exit(0);\n  };\n\n  process.on(\"SIGINT\", shutdown);\n  process.on(\"SIGTERM\", shutdown);\n}\n\nmain().catch((error) => {\n  console.error(\"Failed to start daemon:\", error);\n  process.exit(1);\n});\n"
+  ],
+  "mappings": ";;;AAagD,IAAhD;AAXA,QAAQ,mBAAmB,SAAS;AACpC,QAAQ,GAAG,WAAW,CAAC,YAAY;AAAA,EACjC,IACE,QAAQ,SAAS,yBACjB,QAAQ,QAAQ,SAAS,sBAAsB,GAC/C;AAAA,IACA;AAAA,EACF;AAAA,EACA,QAAQ,KAAK,OAAO;AAAA,CACrB;AAID,SAAS,SAAS,CAAC,MAAwC;AAAA,EACzD,MAAM,UAAkC,CAAC;AAAA,EAEzC,SAAS,QAAQ,EAAG,QAAQ,KAAK,QAAQ,SAAS,GAAG;AAAA,IACnD,MAAM,MAAM,KAAK;AAAA,IAEjB,QAAQ;AAAA,WACD;AAAA,QACH,SAAS;AAAA,QACT,IAAI,KAAK,QAAQ;AAAA,UACf,QAAQ,aAAa,KAAK;AAAA,QAC5B;AAAA,QACA;AAAA,WACG;AAAA,QACH,SAAS;AAAA,QACT,IAAI,KAAK,QAAQ;AAAA,UACf,QAAQ,OAAO,KAAK;AAAA,UACpB,QAAQ,aAAa;AAAA,QACvB;AAAA,QACA;AAAA,WACG;AAAA,QACH,SAAS;AAAA,QACT,IAAI,KAAK,QAAQ;AAAA,UACf,QAAQ,OAAO,OAAO,SAAS,KAAK,QAAS,EAAE;AAAA,UAC/C,QAAQ,aAAa;AAAA,QACvB;AAAA,QACA;AAAA,WACG;AAAA,QACH,SAAS;AAAA,QACT,IAAI,KAAK,QAAQ;AAAA,UACf,QAAQ,cAAc,OAAO,SAAS,KAAK,QAAS,EAAE;AAAA,QACxD;AAAA,QACA;AAAA,WACG;AAAA,QACH,SAAS;AAAA,QACT,IAAI,KAAK,QAAQ;AAAA,UACf,QAAQ,uBAAuB,OAAO,SAAS,KAAK,QAAS,EAAE;AAAA,QACjE;AAAA,QACA;AAAA,WACG;AAAA,WACA;AAAA,QACH,QAAQ,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,CAanB;AAAA,QACO,QAAQ,KAAK,CAAC;AAAA;AAAA,QAEd,IAAI,KAAK,WAAW,GAAG,GAAG;AAAA,UACxB,QAAQ,MAAM,mBAAmB,KAAK;AAAA,UACtC,QAAQ,KAAK,CAAC;AAAA,QAChB;AAAA;AAAA,EAEN;AAAA,EAEA,OAAO;AAAA;AAGT,eAAe,IAAI,GAAG;AAAA,EACpB,MAAM,SAAS,MAAM,0BAAY,UAAU,QAAQ,KAAK,MAAM,CAAC,CAAC,CAAC;AAAA,EACjE,MAAM,WAAW,YAAY;AAAA,IAC3B,QAAQ,IAAI;AAAA,iBAAoB;AAAA,IAChC,MAAM,OAAO,MAAM;AAAA,IACnB,QAAQ,KAAK,CAAC;AAAA;AAAA,EAGhB,QAAQ,GAAG,UAAU,QAAQ;AAAA,EAC7B,QAAQ,GAAG,WAAW,QAAQ;AAAA;AAGhC,KAAK,EAAE,MAAM,CAAC,UAAU;AAAA,EACtB,QAAQ,MAAM,2BAA2B,KAAK;AAAA,EAC9C,QAAQ,KAAK,CAAC;AAAA,CACf;",
+  "debugId": "A3FECC3CB418FD2864756E2164756E21",
+  "names": []
+}

package/dist/cjs/files/index.cjs

@@ -0,0 +1,140 @@
+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;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  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: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// packages/isolate/src/files/index.ts
+var exports_files = {};
+__export(exports_files, {
+  createFileBindings: () => createFileBindings
+});
+module.exports = __toCommonJS(exports_files);
+var import_promises = __toESM(require("node:fs/promises"));
+var import_node_path = __toESM(require("node:path"));
+function resolveSafePath(root, requestedPath) {
+  const resolvedRoot = import_node_path.default.resolve(root);
+  const resolvedPath = import_node_path.default.resolve(import_node_path.default.join(resolvedRoot, requestedPath));
+  if (!resolvedPath.startsWith(`${resolvedRoot}${import_node_path.default.sep}`) && resolvedPath !== resolvedRoot) {
+    throw new Error(`Access denied: ${requestedPath}`);
+  }
+  return resolvedPath;
+}
+function createFileBindings(options) {
+  const allowWrite = options.allowWrite ?? false;
+  return {
+    readFile: async (requestedPath) => {
+      const safePath = resolveSafePath(options.root, requestedPath);
+      const buffer = await import_promises.default.readFile(safePath);
+      return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+    },
+    writeFile: async (requestedPath, data) => {
+      if (!allowWrite) {
+        throw new Error("Write access is disabled for these file bindings.");
+      }
+      const safePath = resolveSafePath(options.root, requestedPath);
+      await import_promises.default.mkdir(import_node_path.default.dirname(safePath), { recursive: true });
+      await import_promises.default.writeFile(safePath, Buffer.from(data));
+    },
+    unlink: async (requestedPath) => {
+      if (!allowWrite) {
+        throw new Error("Write access is disabled for these file bindings.");
+      }
+      const safePath = resolveSafePath(options.root, requestedPath);
+      await import_promises.default.unlink(safePath);
+    },
+    readdir: async (requestedPath) => {
+      const safePath = resolveSafePath(options.root, requestedPath);
+      return await import_promises.default.readdir(safePath);
+    },
+    mkdir: async (requestedPath, mkdirOptions) => {
+      if (!allowWrite) {
+        throw new Error("Write access is disabled for these file bindings.");
+      }
+      const safePath = resolveSafePath(options.root, requestedPath);
+      await import_promises.default.mkdir(safePath, { recursive: mkdirOptions?.recursive ?? false });
+    },
+    rmdir: async (requestedPath) => {
+      if (!allowWrite) {
+        throw new Error("Write access is disabled for these file bindings.");
+      }
+      const safePath = resolveSafePath(options.root, requestedPath);
+      await import_promises.default.rmdir(safePath);
+    },
+    stat: async (requestedPath) => {
+      const safePath = resolveSafePath(options.root, requestedPath);
+      const stats = await import_promises.default.stat(safePath);
+      return {
+        isFile: stats.isFile(),
+        isDirectory: stats.isDirectory(),
+        size: stats.size
+      };
+    },
+    rename: async (from, to) => {
+      if (!allowWrite) {
+        throw new Error("Write access is disabled for these file bindings.");
+      }
+      const safeFrom = resolveSafePath(options.root, from);
+      const safeTo = resolveSafePath(options.root, to);
+      await import_promises.default.rename(safeFrom, safeTo);
+    }
+  };
+}
+
+//# debugId=7ADE4E9E4F27A87864756E2164756E21

package/dist/cjs/files/index.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/files/index.ts"],
+  "sourcesContent": [
+    "import fs from \"node:fs/promises\";\nimport path from \"node:path\";\nimport type { FileBindings } from \"../types.cjs\";\n\nfunction resolveSafePath(root: string, requestedPath: string): string {\n  const resolvedRoot = path.resolve(root);\n  const resolvedPath = path.resolve(path.join(resolvedRoot, requestedPath));\n  if (!resolvedPath.startsWith(`${resolvedRoot}${path.sep}`) && resolvedPath !== resolvedRoot) {\n    throw new Error(`Access denied: ${requestedPath}`);\n  }\n  return resolvedPath;\n}\n\nexport function createFileBindings(options: {\n  root: string;\n  allowWrite?: boolean;\n}): FileBindings {\n  const allowWrite = options.allowWrite ?? false;\n\n  return {\n    readFile: async (requestedPath) => {\n      const safePath = resolveSafePath(options.root, requestedPath);\n      const buffer = await fs.readFile(safePath);\n      return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);\n    },\n    writeFile: async (requestedPath, data) => {\n      if (!allowWrite) {\n        throw new Error(\"Write access is disabled for these file bindings.\");\n      }\n      const safePath = resolveSafePath(options.root, requestedPath);\n      await fs.mkdir(path.dirname(safePath), { recursive: true });\n      await fs.writeFile(safePath, Buffer.from(data));\n    },\n    unlink: async (requestedPath) => {\n      if (!allowWrite) {\n        throw new Error(\"Write access is disabled for these file bindings.\");\n      }\n      const safePath = resolveSafePath(options.root, requestedPath);\n      await fs.unlink(safePath);\n    },\n    readdir: async (requestedPath) => {\n      const safePath = resolveSafePath(options.root, requestedPath);\n      return await fs.readdir(safePath);\n    },\n    mkdir: async (requestedPath, mkdirOptions) => {\n      if (!allowWrite) {\n        throw new Error(\"Write access is disabled for these file bindings.\");\n      }\n      const safePath = resolveSafePath(options.root, requestedPath);\n      await fs.mkdir(safePath, { recursive: mkdirOptions?.recursive ?? false });\n    },\n    rmdir: async (requestedPath) => {\n      if (!allowWrite) {\n        throw new Error(\"Write access is disabled for these file bindings.\");\n      }\n      const safePath = resolveSafePath(options.root, requestedPath);\n      await fs.rmdir(safePath);\n    },\n    stat: async (requestedPath) => {\n      const safePath = resolveSafePath(options.root, requestedPath);\n      const stats = await fs.stat(safePath);\n      return {\n        isFile: stats.isFile(),\n        isDirectory: stats.isDirectory(),\n        size: stats.size,\n      };\n    },\n    rename: async (from, to) => {\n      if (!allowWrite) {\n        throw new Error(\"Write access is disabled for these file bindings.\");\n      }\n      const safeFrom = resolveSafePath(options.root, from);\n      const safeTo = resolveSafePath(options.root, to);\n      await fs.rename(safeFrom, safeTo);\n    },\n  };\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "7ADE4E9E4F27A87864756E2164756E21",
+  "names": []
+}

package/dist/cjs/host/create-isolate-host.cjs

@@ -0,0 +1,235 @@
+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;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  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: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// packages/isolate/src/host/create-isolate-host.ts
+var exports_create_isolate_host = {};
+__export(exports_create_isolate_host, {
+  createIsolateHost: () => createIsolateHost
+});
+module.exports = __toCommonJS(exports_create_isolate_host);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_child_process = require("node:child_process");
+var import_client = require("../internal/client/index.cjs");
+var import_diagnostics = require("../bridge/diagnostics.cjs");
+var import_runtime_bindings = require("../bridge/runtime-bindings.cjs");
+var import_browser_runtime = require("../browser/browser-runtime.cjs");
+var import_script_runtime = require("../runtime/script-runtime.cjs");
+var import_app_server = require("../server/app-server.cjs");
+function resolveDefaultDaemonEntrypoint() {
+  const localPath = import_node_path.default.resolve("/home/runner/work/isolate/isolate/packages/isolate/src/host", "../daemon.ts");
+  if (import_node_fs.default.existsSync(localPath)) {
+    return localPath;
+  }
+  return null;
+}
+async function waitForSocket(socketPath, timeoutMs) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeoutMs) {
+    if (import_node_fs.default.existsSync(socketPath)) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  throw new Error(`Daemon socket not available after ${timeoutMs}ms`);
+}
+
+class HostImpl {
+  options;
+  daemonProcess = null;
+  connection = null;
+  connectionPromise = null;
+  servers = new Set;
+  runtimes = new Set;
+  constructor(options) {
+    this.options = options ?? {};
+  }
+  async createAppServer(options) {
+    const server = await import_app_server.createAppServerAdapter(() => this.getConnection(), options);
+    this.servers.add(server);
+    return server;
+  }
+  async createRuntime(options) {
+    const diagnostics = import_diagnostics.createRuntimeDiagnostics();
+    let runtimeId = options.key ?? "runtime";
+    const bindingsAdapter = import_runtime_bindings.createRuntimeBindingsAdapter(options.bindings, () => runtimeId, diagnostics);
+    const runtime = await this.createRemoteRuntime({
+      ...bindingsAdapter.runtimeOptions,
+      cwd: options.cwd,
+      memoryLimitMB: options.memoryLimitMB,
+      executionTimeout: options.executionTimeout,
+      testEnvironment: options.features?.tests ?? false
+    }, options.key);
+    runtimeId = runtime.id;
+    const adapter = import_script_runtime.createScriptRuntimeAdapter(runtime, diagnostics, {
+      onBeforeDispose: (reason) => bindingsAdapter.abort(reason)
+    });
+    this.runtimes.add(adapter);
+    return adapter;
+  }
+  async createBrowserRuntime(options) {
+    const browserRuntime = await import_browser_runtime.createBrowserRuntimeAdapter(async (runtimeOptions) => await this.createRemoteRuntime(runtimeOptions, options.key), options);
+    this.runtimes.add(browserRuntime);
+    return browserRuntime;
+  }
+  async diagnostics() {
+    return {
+      runtimes: this.runtimes.size,
+      servers: this.servers.size,
+      connected: this.connection?.isConnected() ?? false
+    };
+  }
+  async close() {
+    if (this.connection) {
+      await this.connection.close().catch(() => {});
+    }
+    this.connection = null;
+    this.connectionPromise = null;
+    if (this.daemonProcess) {
+      const process2 = this.daemonProcess;
+      this.daemonProcess = null;
+      await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          process2.kill("SIGKILL");
+          resolve();
+        }, 5000);
+        process2.once("exit", () => {
+          clearTimeout(timeout);
+          resolve();
+        });
+        process2.kill("SIGTERM");
+      });
+    }
+  }
+  async createRemoteRuntime(options, key) {
+    const connection = await this.getConnection();
+    if (key) {
+      return await connection.createNamespace(key).createRuntime(options);
+    }
+    return await connection.createRuntime(options);
+  }
+  async getConnection() {
+    if (this.connection?.isConnected()) {
+      return this.connection;
+    }
+    if (this.connectionPromise) {
+      return this.connectionPromise;
+    }
+    this.connectionPromise = (async () => {
+      await this.ensureDaemon();
+      this.connection = await import_client.connect({
+        socket: this.options.daemon?.socketPath ?? "/tmp/isolate.sock",
+        timeout: this.options.daemon?.timeoutMs ?? 5000
+      });
+      return this.connection;
+    })();
+    return await this.connectionPromise.finally(() => {
+      this.connectionPromise = null;
+    });
+  }
+  async ensureDaemon() {
+    if (this.connection?.isConnected()) {
+      return;
+    }
+    if (this.options.daemon?.autoStart === false) {
+      return;
+    }
+    if (this.daemonProcess) {
+      return;
+    }
+    const socketPath = this.options.daemon?.socketPath ?? "/tmp/isolate.sock";
+    const entrypoint = this.options.daemon?.entrypoint ?? resolveDefaultDaemonEntrypoint();
+    try {
+      if (import_node_fs.default.existsSync(socketPath)) {
+        import_node_fs.default.unlinkSync(socketPath);
+      }
+    } catch {}
+    const cli = entrypoint ? ["node", "--experimental-strip-types", entrypoint, "--socket", socketPath] : ["isolate-daemon", "--socket", socketPath];
+    const cwd = this.options.daemon?.cwd ?? (entrypoint ? import_node_path.default.resolve("/home/runner/work/isolate/isolate/packages/isolate/src/host", "../../..") : process.cwd());
+    this.daemonProcess = import_node_child_process.spawn(cli[0], cli.slice(1), {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        NODE_OPTIONS: ""
+      }
+    });
+    this.daemonProcess.stdout?.on("data", (data) => {
+      console.log("[isolate-host]", data.toString().trim());
+    });
+    this.daemonProcess.stderr?.on("data", (data) => {
+      console.error("[isolate-host]", data.toString().trim());
+    });
+    this.daemonProcess.on("exit", () => {
+      this.daemonProcess = null;
+      this.connection = null;
+      this.connectionPromise = null;
+    });
+    await waitForSocket(socketPath, this.options.daemon?.timeoutMs ?? 1e4);
+  }
+}
+async function createIsolateHost(options) {
+  return new HostImpl(options);
+}
+
+//# debugId=3B3183ABB82F66BC64756E2164756E21

package/dist/cjs/host/create-isolate-host.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/host/create-isolate-host.ts"],
+  "sourcesContent": [
+    "import fs from \"node:fs\";\nimport path from \"node:path\";\nimport { spawn, type ChildProcess } from \"node:child_process\";\nimport { connect, type DaemonConnection, type RemoteRuntime, type RuntimeOptions } from \"../internal/client/index.cjs\";\nimport { createRuntimeDiagnostics } from \"../bridge/diagnostics.cjs\";\nimport { createRuntimeBindingsAdapter } from \"../bridge/runtime-bindings.cjs\";\nimport { createBrowserRuntimeAdapter } from \"../browser/browser-runtime.cjs\";\nimport { createScriptRuntimeAdapter } from \"../runtime/script-runtime.cjs\";\nimport { createAppServerAdapter } from \"../server/app-server.cjs\";\nimport type { CreateBrowserRuntimeOptions, CreateIsolateHostOptions, CreateRuntimeOptions, IsolateHost } from \"../types.cjs\";\n\nfunction resolveDefaultDaemonEntrypoint(): string | null {\n  const localPath = path.resolve(import.meta.dirname, \"../daemon.ts\");\n  if (fs.existsSync(localPath)) {\n    return localPath;\n  }\n  return null;\n}\n\nasync function waitForSocket(socketPath: string, timeoutMs: number): Promise<void> {\n  const startTime = Date.now();\n  while (Date.now() - startTime < timeoutMs) {\n    if (fs.existsSync(socketPath)) {\n      await new Promise((resolve) => setTimeout(resolve, 100));\n      return;\n    }\n    await new Promise((resolve) => setTimeout(resolve, 50));\n  }\n\n  throw new Error(`Daemon socket not available after ${timeoutMs}ms`);\n}\n\nclass HostImpl implements IsolateHost {\n  private readonly options: CreateIsolateHostOptions;\n  private daemonProcess: ChildProcess | null = null;\n  private connection: DaemonConnection | null = null;\n  private connectionPromise: Promise<DaemonConnection> | null = null;\n  private readonly servers = new Set<object>();\n  private readonly runtimes = new Set<object>();\n\n  constructor(options?: CreateIsolateHostOptions) {\n    this.options = options ?? {};\n  }\n\n  async createAppServer(options: CreateRuntimeOptions & { key: string; entry: string; entryFilename?: string; webSockets?: { onCommand?: (command: { type: \"message\" | \"close\"; connectionId: string; data?: string | ArrayBuffer; code?: number; reason?: string }) => void } }) {\n    const server = await createAppServerAdapter(() => this.getConnection(), options);\n    this.servers.add(server);\n    return server;\n  }\n\n  async createRuntime(options: CreateRuntimeOptions) {\n    const diagnostics = createRuntimeDiagnostics();\n    let runtimeId = options.key ?? \"runtime\";\n    const bindingsAdapter = createRuntimeBindingsAdapter(\n      options.bindings,\n      () => runtimeId,\n      diagnostics,\n    );\n    const runtime = await this.createRemoteRuntime(\n      {\n        ...bindingsAdapter.runtimeOptions,\n        cwd: options.cwd,\n        memoryLimitMB: options.memoryLimitMB,\n        executionTimeout: options.executionTimeout,\n        testEnvironment: options.features?.tests ?? false,\n      },\n      options.key,\n    );\n    runtimeId = runtime.id;\n    const adapter = createScriptRuntimeAdapter(runtime, diagnostics, {\n      onBeforeDispose: (reason) => bindingsAdapter.abort(reason),\n    });\n    this.runtimes.add(adapter);\n    return adapter;\n  }\n\n  async createBrowserRuntime(options: CreateBrowserRuntimeOptions) {\n    const browserRuntime = await createBrowserRuntimeAdapter(\n      async (runtimeOptions) => await this.createRemoteRuntime(runtimeOptions, options.key),\n      options,\n    );\n    this.runtimes.add(browserRuntime);\n    return browserRuntime;\n  }\n\n  async diagnostics() {\n    return {\n      runtimes: this.runtimes.size,\n      servers: this.servers.size,\n      connected: this.connection?.isConnected() ?? false,\n    };\n  }\n\n  async close(): Promise<void> {\n    if (this.connection) {\n      await this.connection.close().catch(() => {});\n    }\n    this.connection = null;\n    this.connectionPromise = null;\n\n    if (this.daemonProcess) {\n      const process = this.daemonProcess;\n      this.daemonProcess = null;\n      await new Promise<void>((resolve) => {\n        const timeout = setTimeout(() => {\n          process.kill(\"SIGKILL\");\n          resolve();\n        }, 5000);\n        process.once(\"exit\", () => {\n          clearTimeout(timeout);\n          resolve();\n        });\n        process.kill(\"SIGTERM\");\n      });\n    }\n  }\n\n  private async createRemoteRuntime(options: RuntimeOptions, key?: string): Promise<RemoteRuntime> {\n    const connection = await this.getConnection();\n    if (key) {\n      return await connection.createNamespace(key).createRuntime(options);\n    }\n    return await connection.createRuntime(options);\n  }\n\n  private async getConnection(): Promise<DaemonConnection> {\n    if (this.connection?.isConnected()) {\n      return this.connection;\n    }\n    if (this.connectionPromise) {\n      return this.connectionPromise;\n    }\n\n    this.connectionPromise = (async () => {\n      await this.ensureDaemon();\n      this.connection = await connect({\n        socket: this.options.daemon?.socketPath ?? \"/tmp/isolate.sock\",\n        timeout: this.options.daemon?.timeoutMs ?? 5000,\n      });\n      return this.connection;\n    })();\n\n    return await this.connectionPromise.finally(() => {\n      this.connectionPromise = null;\n    });\n  }\n\n  private async ensureDaemon(): Promise<void> {\n    if (this.connection?.isConnected()) {\n      return;\n    }\n\n    if (this.options.daemon?.autoStart === false) {\n      return;\n    }\n\n    if (this.daemonProcess) {\n      return;\n    }\n\n    const socketPath = this.options.daemon?.socketPath ?? \"/tmp/isolate.sock\";\n    const entrypoint = this.options.daemon?.entrypoint ?? resolveDefaultDaemonEntrypoint();\n\n    try {\n      if (fs.existsSync(socketPath)) {\n        fs.unlinkSync(socketPath);\n      }\n    } catch {\n      // ignore stale socket cleanup failures\n    }\n\n    const cli = entrypoint\n      ? [\"node\", \"--experimental-strip-types\", entrypoint, \"--socket\", socketPath]\n      : [\"isolate-daemon\", \"--socket\", socketPath];\n    const cwd = this.options.daemon?.cwd ?? (entrypoint ? path.resolve(import.meta.dirname, \"../../..\") : process.cwd());\n    this.daemonProcess = spawn(cli[0]!, cli.slice(1), {\n      cwd,\n      stdio: [\"ignore\", \"pipe\", \"pipe\"],\n      env: {\n        ...process.env,\n        NODE_OPTIONS: \"\",\n      },\n    });\n\n    this.daemonProcess.stdout?.on(\"data\", (data: Buffer) => {\n      console.log(\"[isolate-host]\", data.toString().trim());\n    });\n    this.daemonProcess.stderr?.on(\"data\", (data: Buffer) => {\n      console.error(\"[isolate-host]\", data.toString().trim());\n    });\n    this.daemonProcess.on(\"exit\", () => {\n      this.daemonProcess = null;\n      this.connection = null;\n      this.connectionPromise = null;\n    });\n\n    await waitForSocket(socketPath, this.options.daemon?.timeoutMs ?? 10_000);\n  }\n}\n\nexport async function createIsolateHost(options?: CreateIsolateHostOptions): Promise<IsolateHost> {\n  return new HostImpl(options);\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "3B3183ABB82F66BC64756E2164756E21",
+  "names": []
+}

package/dist/cjs/host/index.cjs

@@ -0,0 +1,47 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// packages/isolate/src/host/index.ts
+var exports_host = {};
+__export(exports_host, {
+  createIsolateHost: () => import_create_isolate_host.createIsolateHost
+});
+module.exports = __toCommonJS(exports_host);
+var import_create_isolate_host = require("./create-isolate-host.cjs");
+
+//# debugId=E2B5563EC89D337D64756E2164756E21

package/dist/cjs/host/index.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/host/index.ts"],
+  "sourcesContent": [
+    "export { createIsolateHost } from \"./create-isolate-host.cjs\";\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAkC,IAAlC;",
+  "debugId": "E2B5563EC89D337D64756E2164756E21",
+  "names": []
+}

package/dist/cjs/index.cjs

@@ -0,0 +1,55 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// packages/isolate/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  typecheck: () => import_typecheck.typecheck,
+  getTypeProfile: () => import_typecheck.getTypeProfile,
+  formatTypecheckErrors: () => import_typecheck.formatTypecheckErrors,
+  createModuleResolver: () => import_modules.createModuleResolver,
+  createIsolateHost: () => import_host.createIsolateHost,
+  createFileBindings: () => import_files.createFileBindings
+});
+module.exports = __toCommonJS(exports_src);
+var import_host = require("./host/index.cjs");
+var import_modules = require("./modules/index.cjs");
+var import_files = require("./files/index.cjs");
+var import_typecheck = require("./typecheck/index.cjs");
+
+//# debugId=78CC00D01AC3459064756E2164756E21

package/dist/cjs/index.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": [
+    "export { createIsolateHost } from \"./host/index.cjs\";\nexport { createModuleResolver } from \"./modules/index.cjs\";\nexport { createFileBindings } from \"./files/index.cjs\";\nexport { getTypeProfile, typecheck, formatTypecheckErrors } from \"./typecheck/index.cjs\";\n\nexport type {\n  AppServer,\n  BrowserRuntime,\n  BrowserRuntimeDiagnostics,\n  ConsoleEntry,\n  CreateAppServerOptions,\n  CreateBrowserRuntimeOptions,\n  CreateIsolateHostOptions,\n  CreateRuntimeOptions,\n  FileBindings,\n  HostBindings,\n  HostCallContext,\n  IsolateHost,\n  ModuleImporter,\n  ModuleResolveResult,\n  ModuleResolver,\n  ModuleResolverFallback,\n  ModuleResolverSourceLoader,\n  ModuleSource,\n  PlaywrightEvent,\n  RequestResult,\n  RunResults,\n  ScriptRuntime,\n  TestEvent,\n  ToolBindings,\n  ToolHandler,\n  RuntimeDiagnostics,\n  TypeCapability,\n  TypeProfile,\n  TypeProfileName,\n  TypecheckRequest,\n  WebSocketUpgradeData,\n} from \"./types.cjs\";\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAkC,IAAlC;AACqC,IAArC;AACmC,IAAnC;AACiE,IAAjE;",
+  "debugId": "78CC00D01AC3459064756E2164756E21",
+  "names": []
+}