@ricsam/isolate 0.0.1 → 0.1.0

package/dist/cjs/runtime/script-runtime.cjs

@@ -0,0 +1,97 @@
+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/runtime/script-runtime.ts
+var exports_script_runtime = {};
+__export(exports_script_runtime, {
+  createScriptRuntimeAdapter: () => createScriptRuntimeAdapter
+});
+module.exports = __toCommonJS(exports_script_runtime);
+var import_client = require("../internal/client/index.cjs");
+function createScriptRuntimeAdapter(runtime, diagnostics, options) {
+  return {
+    async eval(code, evalOptions) {
+      const normalizedOptions = typeof evalOptions === "string" ? { filename: evalOptions } : evalOptions;
+      diagnostics.lifecycleState = "active";
+      try {
+        await runtime.eval(code, {
+          filename: normalizedOptions?.filename,
+          executionTimeout: normalizedOptions?.executionTimeout
+        });
+      } catch (error) {
+        diagnostics.lastError = error instanceof Error ? error.message : String(error);
+        throw error;
+      } finally {
+        diagnostics.lifecycleState = "idle";
+      }
+    },
+    async dispose(disposeOptions) {
+      diagnostics.lifecycleState = "disposing";
+      try {
+        options?.onBeforeDispose?.(disposeOptions?.reason);
+        await runtime.dispose(disposeOptions);
+      } catch (error) {
+        if (!import_client.isBenignDisposeError(error)) {
+          diagnostics.lastError = error instanceof Error ? error.message : String(error);
+          throw error;
+        }
+      } finally {
+        diagnostics.lifecycleState = "idle";
+      }
+    },
+    diagnostics: async () => ({
+      ...diagnostics,
+      reused: runtime.reused
+    }),
+    events: {
+      on: (event, handler) => runtime.on(event, handler),
+      emit: async (event, payload) => {
+        runtime.emit(event, payload);
+      }
+    },
+    tests: {
+      run: async (testOptions) => await runtime.testEnvironment.runTests(testOptions?.timeoutMs),
+      hasTests: async () => await runtime.testEnvironment.hasTests(),
+      reset: async () => {
+        await runtime.testEnvironment.reset();
+      }
+    }
+  };
+}
+
+//# debugId=16859BFF49FD2FB864756E2164756E21

package/dist/cjs/runtime/script-runtime.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/runtime/script-runtime.ts"],
+  "sourcesContent": [
+    "import type { MutableRuntimeDiagnostics } from \"../bridge/diagnostics.cjs\";\nimport { isBenignDisposeError, type RemoteRuntime } from \"../internal/client/index.cjs\";\nimport type { ScriptRuntime } from \"../types.cjs\";\n\nexport function createScriptRuntimeAdapter(\n  runtime: RemoteRuntime,\n  diagnostics: MutableRuntimeDiagnostics,\n  options?: { onBeforeDispose?: (reason?: string) => void },\n): ScriptRuntime {\n  return {\n    async eval(code, evalOptions) {\n      const normalizedOptions = typeof evalOptions === \"string\"\n        ? { filename: evalOptions }\n        : evalOptions;\n      diagnostics.lifecycleState = \"active\";\n      try {\n        await runtime.eval(code, {\n          filename: normalizedOptions?.filename,\n          executionTimeout: normalizedOptions?.executionTimeout,\n        });\n      } catch (error) {\n        diagnostics.lastError = error instanceof Error ? error.message : String(error);\n        throw error;\n      } finally {\n        diagnostics.lifecycleState = \"idle\";\n      }\n    },\n    async dispose(disposeOptions) {\n      diagnostics.lifecycleState = \"disposing\";\n      try {\n        options?.onBeforeDispose?.(disposeOptions?.reason);\n        await runtime.dispose(disposeOptions);\n      } catch (error) {\n        if (!isBenignDisposeError(error)) {\n          diagnostics.lastError = error instanceof Error ? error.message : String(error);\n          throw error;\n        }\n      } finally {\n        diagnostics.lifecycleState = \"idle\";\n      }\n    },\n    diagnostics: async () => ({\n      ...diagnostics,\n      reused: runtime.reused,\n    }),\n    events: {\n      on: (event, handler) => runtime.on(event, handler),\n      emit: async (event, payload) => {\n        runtime.emit(event, payload);\n      },\n    },\n    tests: {\n      run: async (testOptions) => await runtime.testEnvironment.runTests(testOptions?.timeoutMs),\n      hasTests: async () => await runtime.testEnvironment.hasTests(),\n      reset: async () => {\n        await runtime.testEnvironment.reset();\n      },\n    },\n  };\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACyD,IAAzD;AAGO,SAAS,0BAA0B,CACxC,SACA,aACA,SACe;AAAA,EACf,OAAO;AAAA,SACC,KAAI,CAAC,MAAM,aAAa;AAAA,MAC5B,MAAM,oBAAoB,OAAO,gBAAgB,WAC7C,EAAE,UAAU,YAAY,IACxB;AAAA,MACJ,YAAY,iBAAiB;AAAA,MAC7B,IAAI;AAAA,QACF,MAAM,QAAQ,KAAK,MAAM;AAAA,UACvB,UAAU,mBAAmB;AAAA,UAC7B,kBAAkB,mBAAmB;AAAA,QACvC,CAAC;AAAA,QACD,OAAO,OAAO;AAAA,QACd,YAAY,YAAY,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAAA,QAC7E,MAAM;AAAA,gBACN;AAAA,QACA,YAAY,iBAAiB;AAAA;AAAA;AAAA,SAG3B,QAAO,CAAC,gBAAgB;AAAA,MAC5B,YAAY,iBAAiB;AAAA,MAC7B,IAAI;AAAA,QACF,SAAS,kBAAkB,gBAAgB,MAAM;AAAA,QACjD,MAAM,QAAQ,QAAQ,cAAc;AAAA,QACpC,OAAO,OAAO;AAAA,QACd,IAAI,CAAC,mCAAqB,KAAK,GAAG;AAAA,UAChC,YAAY,YAAY,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAAA,UAC7E,MAAM;AAAA,QACR;AAAA,gBACA;AAAA,QACA,YAAY,iBAAiB;AAAA;AAAA;AAAA,IAGjC,aAAa,aAAa;AAAA,SACrB;AAAA,MACH,QAAQ,QAAQ;AAAA,IAClB;AAAA,IACA,QAAQ;AAAA,MACN,IAAI,CAAC,OAAO,YAAY,QAAQ,GAAG,OAAO,OAAO;AAAA,MACjD,MAAM,OAAO,OAAO,YAAY;AAAA,QAC9B,QAAQ,KAAK,OAAO,OAAO;AAAA;AAAA,IAE/B;AAAA,IACA,OAAO;AAAA,MACL,KAAK,OAAO,gBAAgB,MAAM,QAAQ,gBAAgB,SAAS,aAAa,SAAS;AAAA,MACzF,UAAU,YAAY,MAAM,QAAQ,gBAAgB,SAAS;AAAA,MAC7D,OAAO,YAAY;AAAA,QACjB,MAAM,QAAQ,gBAAgB,MAAM;AAAA;AAAA,IAExC;AAAA,EACF;AAAA;",
+  "debugId": "16859BFF49FD2FB864756E2164756E21",
+  "names": []
+}

package/dist/cjs/server/app-server.cjs

@@ -0,0 +1,158 @@
+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/server/app-server.ts
+var exports_app_server = {};
+__export(exports_app_server, {
+  createAppServerAdapter: () => createAppServerAdapter
+});
+module.exports = __toCommonJS(exports_app_server);
+var import_server = require("../internal/server/index.cjs");
+var import_diagnostics = require("../bridge/diagnostics.cjs");
+var import_runtime_bindings = require("../bridge/runtime-bindings.cjs");
+var import_request_context = require("../bridge/request-context.cjs");
+async function createAppServerAdapter(getConnection, options) {
+  const diagnostics = import_diagnostics.createRuntimeDiagnostics();
+  const server = new import_server.IsolateServer({
+    namespaceId: options.key,
+    getConnection
+  });
+  let runtimeId = options.key;
+  const bindingsAdapter = import_runtime_bindings.createRuntimeBindingsAdapter(options.bindings, () => runtimeId, diagnostics);
+  await server.start({
+    entry: options.entry,
+    entryFilename: options.entryFilename,
+    runtimeOptions: {
+      ...bindingsAdapter.runtimeOptions,
+      cwd: options.cwd,
+      memoryLimitMB: options.memoryLimitMB,
+      executionTimeout: options.executionTimeout,
+      testEnvironment: options.features?.tests ?? false
+    },
+    onWebSocketCommand: (command) => {
+      options.webSockets?.onCommand?.(command);
+    }
+  });
+  runtimeId = server.getRuntime()?.id ?? options.key;
+  async function handleRequest(request, handleOptions) {
+    diagnostics.activeRequests += 1;
+    diagnostics.lifecycleState = "active";
+    try {
+      return await import_request_context.withRequestContext({
+        requestId: handleOptions?.requestId,
+        metadata: handleOptions?.metadata,
+        signal: handleOptions?.signal ?? request.signal
+      }, async () => {
+        const response = await server.fetch.dispatchRequest(request, {
+          signal: handleOptions?.signal,
+          requestId: handleOptions?.requestId,
+          metadata: handleOptions?.metadata
+        });
+        const upgradeRequest = await server.fetch.getUpgradeRequest();
+        if (upgradeRequest?.requested) {
+          return {
+            type: "websocket",
+            upgradeData: {
+              requested: upgradeRequest.requested,
+              connectionId: upgradeRequest.connectionId
+            }
+          };
+        }
+        return {
+          type: "response",
+          response
+        };
+      });
+    } catch (error) {
+      diagnostics.lastError = error instanceof Error ? error.message : String(error);
+      throw error;
+    } finally {
+      diagnostics.activeRequests -= 1;
+      diagnostics.lifecycleState = "idle";
+    }
+  }
+  return {
+    handle: handleRequest,
+    ws: {
+      open: async (connectionId) => {
+        await server.fetch.dispatchWebSocketOpen(connectionId);
+      },
+      message: async (connectionId, data) => {
+        await server.fetch.dispatchWebSocketMessage(connectionId, data);
+      },
+      close: async (connectionId, code, reason) => {
+        await server.fetch.dispatchWebSocketClose(connectionId, code, reason);
+      },
+      error: async (connectionId, error) => {
+        await server.fetch.dispatchWebSocketError(connectionId, error);
+      }
+    },
+    reload: async () => {
+      diagnostics.lifecycleState = "reloading";
+      try {
+        bindingsAdapter.reset("AppServer.reload()");
+        await server.reload();
+        runtimeId = server.getRuntime()?.id ?? options.key;
+      } finally {
+        diagnostics.lifecycleState = "idle";
+      }
+    },
+    dispose: async (disposeOptions) => {
+      diagnostics.lifecycleState = "disposing";
+      try {
+        if (disposeOptions?.hard) {
+          bindingsAdapter.reset(disposeOptions?.reason ?? "AppServer.dispose(hard)");
+          await server.reload();
+          bindingsAdapter.abort(disposeOptions?.reason ?? "AppServer.dispose(hard)");
+          await server.close();
+          return;
+        }
+        bindingsAdapter.abort(disposeOptions?.reason ?? "AppServer.dispose()");
+        await server.close();
+      } finally {
+        diagnostics.lifecycleState = "idle";
+      }
+    },
+    diagnostics: async () => ({
+      ...diagnostics,
+      reused: server.getRuntime()?.reused
+    })
+  };
+}
+
+//# debugId=2EE7DA8CB09A0E0764756E2164756E21

package/dist/cjs/server/app-server.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/server/app-server.ts"],
+  "sourcesContent": [
+    "import { IsolateServer } from \"../internal/server/index.cjs\";\nimport type { DaemonConnection } from \"../internal/client/index.cjs\";\nimport { createRuntimeDiagnostics } from \"../bridge/diagnostics.cjs\";\nimport { createRuntimeBindingsAdapter } from \"../bridge/runtime-bindings.cjs\";\nimport { withRequestContext } from \"../bridge/request-context.cjs\";\nimport type { AppServer, CreateAppServerOptions, RequestResult } from \"../types.cjs\";\n\nexport async function createAppServerAdapter(\n  getConnection: () => Promise<DaemonConnection>,\n  options: CreateAppServerOptions,\n): Promise<AppServer> {\n  const diagnostics = createRuntimeDiagnostics();\n  const server = new IsolateServer({\n    namespaceId: options.key,\n    getConnection,\n  });\n\n  let runtimeId = options.key;\n  const bindingsAdapter = createRuntimeBindingsAdapter(\n    options.bindings,\n    () => runtimeId,\n    diagnostics,\n  );\n  await server.start({\n    entry: options.entry,\n    entryFilename: options.entryFilename,\n    runtimeOptions: {\n      ...bindingsAdapter.runtimeOptions,\n      cwd: options.cwd,\n      memoryLimitMB: options.memoryLimitMB,\n      executionTimeout: options.executionTimeout,\n      testEnvironment: options.features?.tests ?? false,\n    },\n    onWebSocketCommand: (command) => {\n      options.webSockets?.onCommand?.(command);\n    },\n  });\n  runtimeId = server.getRuntime()?.id ?? options.key;\n\n  async function handleRequest(request: Request, handleOptions?: { requestId?: string; signal?: AbortSignal; metadata?: Record<string, string> }): Promise<RequestResult> {\n    diagnostics.activeRequests += 1;\n    diagnostics.lifecycleState = \"active\";\n    try {\n      return await withRequestContext(\n        {\n          requestId: handleOptions?.requestId,\n          metadata: handleOptions?.metadata,\n          signal: handleOptions?.signal ?? request.signal,\n        },\n        async () => {\n          const response = await server.fetch.dispatchRequest(request, {\n            signal: handleOptions?.signal,\n            requestId: handleOptions?.requestId,\n            metadata: handleOptions?.metadata,\n          });\n          const upgradeRequest = await server.fetch.getUpgradeRequest();\n          if (upgradeRequest?.requested) {\n            return {\n              type: \"websocket\",\n              upgradeData: {\n                requested: upgradeRequest.requested,\n                connectionId: upgradeRequest.connectionId,\n              },\n            };\n          }\n\n          return {\n            type: \"response\",\n            response,\n          };\n        },\n      );\n    } catch (error) {\n      diagnostics.lastError = error instanceof Error ? error.message : String(error);\n      throw error;\n    } finally {\n      diagnostics.activeRequests -= 1;\n      diagnostics.lifecycleState = \"idle\";\n    }\n  }\n\n  return {\n    handle: handleRequest,\n    ws: {\n      open: async (connectionId) => {\n        await server.fetch.dispatchWebSocketOpen(connectionId);\n      },\n      message: async (connectionId, data) => {\n        await server.fetch.dispatchWebSocketMessage(connectionId, data);\n      },\n      close: async (connectionId, code, reason) => {\n        await server.fetch.dispatchWebSocketClose(connectionId, code, reason);\n      },\n      error: async (connectionId, error) => {\n        await server.fetch.dispatchWebSocketError(connectionId, error);\n      },\n    },\n    reload: async () => {\n      diagnostics.lifecycleState = \"reloading\";\n      try {\n        bindingsAdapter.reset(\"AppServer.reload()\");\n        await server.reload();\n        runtimeId = server.getRuntime()?.id ?? options.key;\n      } finally {\n        diagnostics.lifecycleState = \"idle\";\n      }\n    },\n    dispose: async (disposeOptions) => {\n      diagnostics.lifecycleState = \"disposing\";\n      try {\n        if (disposeOptions?.hard) {\n          bindingsAdapter.reset(disposeOptions?.reason ?? \"AppServer.dispose(hard)\");\n          await server.reload();\n          bindingsAdapter.abort(disposeOptions?.reason ?? \"AppServer.dispose(hard)\");\n          await server.close();\n          return;\n        }\n        bindingsAdapter.abort(disposeOptions?.reason ?? \"AppServer.dispose()\");\n        await server.close();\n      } finally {\n        diagnostics.lifecycleState = \"idle\";\n      }\n    },\n    diagnostics: async () => ({\n      ...diagnostics,\n      reused: server.getRuntime()?.reused,\n    }),\n  };\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "2EE7DA8CB09A0E0764756E2164756E21",
+  "names": []
+}

package/dist/cjs/testing/integration-helpers.cjs

@@ -0,0 +1,127 @@
+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/testing/integration-helpers.ts
+var exports_integration_helpers = {};
+__export(exports_integration_helpers, {
+  withTimeout: () => withTimeout,
+  expectResponse: () => expectResponse,
+  createTestId: () => createTestId,
+  createTestHost: () => createTestHost
+});
+module.exports = __toCommonJS(exports_integration_helpers);
+var import_strict = __toESM(require("node:assert/strict"));
+var import_promises = __toESM(require("node:fs/promises"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_crypto = require("node:crypto");
+var import___ = require("../index.cjs");
+function sanitizeLabel(label) {
+  return label.replace(/[^a-z0-9_-]+/gi, "-").toLowerCase();
+}
+function createTestId(label) {
+  return `${sanitizeLabel(label)}-${process.pid}-${import_node_crypto.randomUUID()}`;
+}
+function createTestSocketPath(label) {
+  const suffix = import_node_crypto.randomUUID().slice(0, 8);
+  return import_node_path.default.join("/tmp", `isolate-${sanitizeLabel(label)}-${suffix}.sock`);
+}
+async function createTestHost(label) {
+  const socketPath = createTestSocketPath(label);
+  await import_promises.default.rm(socketPath, { force: true });
+  const host = await import___.createIsolateHost({
+    daemon: {
+      socketPath,
+      timeoutMs: 15000
+    }
+  });
+  return {
+    host,
+    socketPath,
+    cleanup: async () => {
+      await host.close().catch(() => {});
+      await import_promises.default.rm(socketPath, { force: true }).catch(() => {});
+    }
+  };
+}
+function expectResponse(result) {
+  if (result.type !== "response") {
+    import_strict.default.fail(`Expected a response result, received ${result.type}`);
+  }
+  return result.response;
+}
+async function withTimeout(promise, timeoutMs, label) {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new Error(`Timed out after ${timeoutMs}ms: ${label}`));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timeoutId !== undefined) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+
+//# debugId=6A3F8AEBA5D735B964756E2164756E21

package/dist/cjs/testing/integration-helpers.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/testing/integration-helpers.ts"],
+  "sourcesContent": [
+    "import assert from \"node:assert/strict\";\nimport fs from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { randomUUID } from \"node:crypto\";\nimport { createIsolateHost } from \"../index.cjs\";\nimport type { IsolateHost, RequestResult } from \"../types.cjs\";\n\nfunction sanitizeLabel(label: string): string {\n  return label.replace(/[^a-z0-9_-]+/gi, \"-\").toLowerCase();\n}\n\nexport function createTestId(label: string): string {\n  return `${sanitizeLabel(label)}-${process.pid}-${randomUUID()}`;\n}\n\nfunction createTestSocketPath(label: string): string {\n  const suffix = randomUUID().slice(0, 8);\n  return path.join(\"/tmp\", `isolate-${sanitizeLabel(label)}-${suffix}.sock`);\n}\n\nexport async function createTestHost(\n  label: string,\n): Promise<{\n  host: IsolateHost;\n  socketPath: string;\n  cleanup: () => Promise<void>;\n}> {\n  const socketPath = createTestSocketPath(label);\n  await fs.rm(socketPath, { force: true });\n\n  const host = await createIsolateHost({\n    daemon: {\n      socketPath,\n      timeoutMs: 15_000,\n    },\n  });\n\n  return {\n    host,\n    socketPath,\n    cleanup: async () => {\n      await host.close().catch(() => {});\n      await fs.rm(socketPath, { force: true }).catch(() => {});\n    },\n  };\n}\n\nexport function expectResponse(result: RequestResult): Response {\n  if (result.type !== \"response\") {\n    assert.fail(`Expected a response result, received ${result.type}`);\n  }\n  return result.response;\n}\n\nexport async function withTimeout<T>(\n  promise: Promise<T>,\n  timeoutMs: number,\n  label: string,\n): Promise<T> {\n  let timeoutId: ReturnType<typeof setTimeout> | undefined;\n  const timeoutPromise = new Promise<T>((_, reject) => {\n    timeoutId = setTimeout(() => {\n      reject(new Error(`Timed out after ${timeoutMs}ms: ${label}`));\n    }, timeoutMs);\n  });\n\n  try {\n    return await Promise.race([promise, timeoutPromise]);\n  } finally {\n    if (timeoutId !== undefined) {\n      clearTimeout(timeoutId);\n    }\n  }\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAmB,IAAnB;AACe,IAAf;AACiB,IAAjB;AAC2B,IAA3B;AACkC,IAAlC;AAGA,SAAS,aAAa,CAAC,OAAuB;AAAA,EAC5C,OAAO,MAAM,QAAQ,kBAAkB,GAAG,EAAE,YAAY;AAAA;AAGnD,SAAS,YAAY,CAAC,OAAuB;AAAA,EAClD,OAAO,GAAG,cAAc,KAAK,KAAK,QAAQ,OAAO,8BAAW;AAAA;AAG9D,SAAS,oBAAoB,CAAC,OAAuB;AAAA,EACnD,MAAM,SAAS,8BAAW,EAAE,MAAM,GAAG,CAAC;AAAA,EACtC,OAAO,yBAAK,KAAK,QAAQ,WAAW,cAAc,KAAK,KAAK,aAAa;AAAA;AAG3E,eAAsB,cAAc,CAClC,OAKC;AAAA,EACD,MAAM,aAAa,qBAAqB,KAAK;AAAA,EAC7C,MAAM,wBAAG,GAAG,YAAY,EAAE,OAAO,KAAK,CAAC;AAAA,EAEvC,MAAM,OAAO,MAAM,4BAAkB;AAAA,IACnC,QAAQ;AAAA,MACN;AAAA,MACA,WAAW;AAAA,IACb;AAAA,EACF,CAAC;AAAA,EAED,OAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,SAAS,YAAY;AAAA,MACnB,MAAM,KAAK,MAAM,EAAE,MAAM,MAAM,EAAE;AAAA,MACjC,MAAM,wBAAG,GAAG,YAAY,EAAE,OAAO,KAAK,CAAC,EAAE,MAAM,MAAM,EAAE;AAAA;AAAA,EAE3D;AAAA;AAGK,SAAS,cAAc,CAAC,QAAiC;AAAA,EAC9D,IAAI,OAAO,SAAS,YAAY;AAAA,IAC9B,sBAAO,KAAK,wCAAwC,OAAO,MAAM;AAAA,EACnE;AAAA,EACA,OAAO,OAAO;AAAA;AAGhB,eAAsB,WAAc,CAClC,SACA,WACA,OACY;AAAA,EACZ,IAAI;AAAA,EACJ,MAAM,iBAAiB,IAAI,QAAW,CAAC,GAAG,WAAW;AAAA,IACnD,YAAY,WAAW,MAAM;AAAA,MAC3B,OAAO,IAAI,MAAM,mBAAmB,gBAAgB,OAAO,CAAC;AAAA,OAC3D,SAAS;AAAA,GACb;AAAA,EAED,IAAI;AAAA,IACF,OAAO,MAAM,QAAQ,KAAK,CAAC,SAAS,cAAc,CAAC;AAAA,YACnD;AAAA,IACA,IAAI,cAAc,WAAW;AAAA,MAC3B,aAAa,SAAS;AAAA,IACxB;AAAA;AAAA;",
+  "debugId": "6A3F8AEBA5D735B964756E2164756E21",
+  "names": []
+}

package/dist/cjs/typecheck/index.cjs

@@ -0,0 +1,96 @@
+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/typecheck/index.ts
+var exports_typecheck = {};
+__export(exports_typecheck, {
+  typecheck: () => typecheck,
+  getTypeProfile: () => getTypeProfile,
+  formatTypecheckErrors: () => formatTypecheckErrors
+});
+module.exports = __toCommonJS(exports_typecheck);
+var import_typecheck = require("../internal/typecheck/index.cjs");
+var CAPABILITY_MAP = {
+  fetch: ["fetch"],
+  files: ["fs"],
+  tests: ["testEnvironment"],
+  browser: ["playwright"],
+  tools: [],
+  console: ["console"],
+  encoding: ["encoding"],
+  timers: ["timers"]
+};
+var PROFILE_DEFAULTS = {
+  backend: ["console", "encoding", "fetch", "files", "timers"],
+  agent: ["console", "encoding", "fetch", "files", "timers"],
+  "browser-test": ["console", "encoding", "fetch", "tests", "browser", "timers"]
+};
+function unique(values) {
+  return [...new Set(values)];
+}
+function getTypeProfile(input) {
+  const profile = input?.profile ?? "backend";
+  const capabilities = unique([...PROFILE_DEFAULTS[profile] ?? PROFILE_DEFAULTS.backend, ...input?.capabilities ?? []]);
+  const include = unique([
+    "core",
+    ...capabilities.flatMap((capability) => CAPABILITY_MAP[capability])
+  ]);
+  return {
+    profile,
+    capabilities,
+    include,
+    files: include.map((key) => ({
+      name: `isolate-${key}.d.ts`,
+      content: import_typecheck.TYPE_DEFINITIONS[key]
+    })).filter((entry) => Boolean(entry.content))
+  };
+}
+function typecheck(request) {
+  const profile = getTypeProfile({
+    profile: request.profile,
+    capabilities: request.capabilities
+  });
+  return import_typecheck.typecheckIsolateCode(request.code, {
+    include: profile.include,
+    libraryTypes: request.libraryTypes,
+    compilerOptions: request.compilerOptions
+  });
+}
+var formatTypecheckErrors = import_typecheck.formatTypecheckErrors;
+
+//# debugId=9B14BEFE5761FAF164756E2164756E21

package/dist/cjs/typecheck/index.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/typecheck/index.ts"],
+  "sourcesContent": [
+    "import { TYPE_DEFINITIONS, formatTypecheckErrors as formatLegacyTypecheckErrors, typecheckIsolateCode } from \"../internal/typecheck/index.cjs\";\nimport type { TypeCapability, TypeProfile, TypeProfileName, TypecheckRequest } from \"../types.cjs\";\n\ntype IncludedType = \"core\" | \"fetch\" | \"fs\" | \"console\" | \"encoding\" | \"timers\" | \"testEnvironment\" | \"playwright\";\n\nconst CAPABILITY_MAP: Record<TypeCapability, IncludedType[]> = {\n  fetch: [\"fetch\"],\n  files: [\"fs\"],\n  tests: [\"testEnvironment\"],\n  browser: [\"playwright\"],\n  tools: [],\n  console: [\"console\"],\n  encoding: [\"encoding\"],\n  timers: [\"timers\"],\n};\n\nconst PROFILE_DEFAULTS: Record<TypeProfileName, TypeCapability[]> = {\n  backend: [\"console\", \"encoding\", \"fetch\", \"files\", \"timers\"],\n  agent: [\"console\", \"encoding\", \"fetch\", \"files\", \"timers\"],\n  \"browser-test\": [\"console\", \"encoding\", \"fetch\", \"tests\", \"browser\", \"timers\"],\n};\n\nfunction unique<T>(values: T[]): T[] {\n  return [...new Set(values)];\n}\n\nexport function getTypeProfile(input?: {\n  profile?: TypeProfileName;\n  capabilities?: TypeCapability[];\n}): TypeProfile {\n  const profile = input?.profile ?? \"backend\";\n  const capabilities = unique([...(PROFILE_DEFAULTS[profile] ?? PROFILE_DEFAULTS.backend), ...(input?.capabilities ?? [])]);\n  const include: IncludedType[] = unique([\n    \"core\",\n    ...capabilities.flatMap((capability) => CAPABILITY_MAP[capability]),\n  ]) as IncludedType[];\n\n  return {\n    profile,\n    capabilities,\n    include,\n    files: include\n      .map((key) => ({\n        name: `isolate-${key}.d.ts`,\n        content: TYPE_DEFINITIONS[key as keyof typeof TYPE_DEFINITIONS],\n      }))\n      .filter((entry) => Boolean(entry.content)) as Array<{ name: string; content: string }>,\n  };\n}\n\nexport function typecheck(request: TypecheckRequest) {\n  const profile = getTypeProfile({\n    profile: request.profile,\n    capabilities: request.capabilities,\n  });\n\n  return typecheckIsolateCode(request.code, {\n    include: profile.include,\n    libraryTypes: request.libraryTypes,\n    compilerOptions: request.compilerOptions as never,\n  });\n}\n\nexport const formatTypecheckErrors = formatLegacyTypecheckErrors;\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAA6G,IAA7G;AAKA,IAAM,iBAAyD;AAAA,EAC7D,OAAO,CAAC,OAAO;AAAA,EACf,OAAO,CAAC,IAAI;AAAA,EACZ,OAAO,CAAC,iBAAiB;AAAA,EACzB,SAAS,CAAC,YAAY;AAAA,EACtB,OAAO,CAAC;AAAA,EACR,SAAS,CAAC,SAAS;AAAA,EACnB,UAAU,CAAC,UAAU;AAAA,EACrB,QAAQ,CAAC,QAAQ;AACnB;AAEA,IAAM,mBAA8D;AAAA,EAClE,SAAS,CAAC,WAAW,YAAY,SAAS,SAAS,QAAQ;AAAA,EAC3D,OAAO,CAAC,WAAW,YAAY,SAAS,SAAS,QAAQ;AAAA,EACzD,gBAAgB,CAAC,WAAW,YAAY,SAAS,SAAS,WAAW,QAAQ;AAC/E;AAEA,SAAS,MAAS,CAAC,QAAkB;AAAA,EACnC,OAAO,CAAC,GAAG,IAAI,IAAI,MAAM,CAAC;AAAA;AAGrB,SAAS,cAAc,CAAC,OAGf;AAAA,EACd,MAAM,UAAU,OAAO,WAAW;AAAA,EAClC,MAAM,eAAe,OAAO,CAAC,GAAI,iBAAiB,YAAY,iBAAiB,SAAU,GAAI,OAAO,gBAAgB,CAAC,CAAE,CAAC;AAAA,EACxH,MAAM,UAA0B,OAAO;AAAA,IACrC;AAAA,IACA,GAAG,aAAa,QAAQ,CAAC,eAAe,eAAe,WAAW;AAAA,EACpE,CAAC;AAAA,EAED,OAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,OAAO,QACJ,IAAI,CAAC,SAAS;AAAA,MACb,MAAM,WAAW;AAAA,MACjB,SAAS,kCAAiB;AAAA,IAC5B,EAAE,EACD,OAAO,CAAC,UAAU,QAAQ,MAAM,OAAO,CAAC;AAAA,EAC7C;AAAA;AAGK,SAAS,SAAS,CAAC,SAA2B;AAAA,EACnD,MAAM,UAAU,eAAe;AAAA,IAC7B,SAAS,QAAQ;AAAA,IACjB,cAAc,QAAQ;AAAA,EACxB,CAAC;AAAA,EAED,OAAO,sCAAqB,QAAQ,MAAM;AAAA,IACxC,SAAS,QAAQ;AAAA,IACjB,cAAc,QAAQ;AAAA,IACtB,iBAAiB,QAAQ;AAAA,EAC3B,CAAC;AAAA;AAGI,IAAM,wBAAwB;",
+  "debugId": "9B14BEFE5761FAF164756E2164756E21",
+  "names": []
+}

package/dist/cjs/types.cjs

@@ -0,0 +1,30 @@
+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;
+
+// packages/isolate/src/types.ts
+var exports_types = {};
+module.exports = __toCommonJS(exports_types);
+
+//# debugId=F784E54F0F2F1AFF64756E2164756E21

package/dist/cjs/types.cjs.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "F784E54F0F2F1AFF64756E2164756E21",
+  "names": []
+}

package/dist/mjs/bridge/diagnostics.mjs

@@ -0,0 +1,18 @@
+// packages/isolate/src/bridge/diagnostics.ts
+function createRuntimeDiagnostics() {
+  return {
+    activeRequests: 0,
+    activeResources: 0,
+    pendingFiles: 0,
+    pendingFetches: 0,
+    pendingModules: 0,
+    pendingTools: 0,
+    streamCount: 0,
+    lifecycleState: "idle"
+  };
+}
+export {
+  createRuntimeDiagnostics
+};
+
+//# debugId=7952FE3EC6EC2B1164756E2164756E21

package/dist/mjs/bridge/diagnostics.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/bridge/diagnostics.ts"],
+  "sourcesContent": [
+    "import type { RuntimeDiagnostics } from \"../types.mjs\";\n\nexport interface MutableRuntimeDiagnostics extends RuntimeDiagnostics {\n  activeRequests: number;\n  activeResources: number;\n  pendingFiles: number;\n  pendingFetches: number;\n  pendingModules: number;\n  pendingTools: number;\n  streamCount: number;\n  lifecycleState: \"idle\" | \"active\" | \"reloading\" | \"disposing\";\n}\n\nexport function createRuntimeDiagnostics(): MutableRuntimeDiagnostics {\n  return {\n    activeRequests: 0,\n    activeResources: 0,\n    pendingFiles: 0,\n    pendingFetches: 0,\n    pendingModules: 0,\n    pendingTools: 0,\n    streamCount: 0,\n    lifecycleState: \"idle\",\n  };\n}\n"
+  ],
+  "mappings": ";AAaO,SAAS,wBAAwB,GAA8B;AAAA,EACpE,OAAO;AAAA,IACL,gBAAgB;AAAA,IAChB,iBAAiB;AAAA,IACjB,cAAc;AAAA,IACd,gBAAgB;AAAA,IAChB,gBAAgB;AAAA,IAChB,cAAc;AAAA,IACd,aAAa;AAAA,IACb,gBAAgB;AAAA,EAClB;AAAA;",
+  "debugId": "7952FE3EC6EC2B1164756E2164756E21",
+  "names": []
+}