@ricsam/isolate-runtime 0.1.4 → 0.1.7

package/dist/cjs/internal.cjs

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

package/dist/cjs/internal.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/internal.ts"],
+  "sourcesContent": [
+    "/**\n * Internal APIs for @ricsam/isolate-runtime\n *\n * These are not part of the public API and may change without notice.\n * Only used by @ricsam/isolate-daemon internally.\n */\n\nimport ivm from \"isolated-vm\";\nimport { setupCore } from \"@ricsam/isolate-core\";\nimport { setupConsole } from \"@ricsam/isolate-console\";\nimport { setupEncoding } from \"@ricsam/isolate-encoding\";\nimport { setupTimers } from \"@ricsam/isolate-timers\";\nimport { setupPath } from \"@ricsam/isolate-path\";\nimport { setupCrypto } from \"@ricsam/isolate-crypto\";\nimport { setupFetch } from \"@ricsam/isolate-fetch\";\nimport { setupFs } from \"@ricsam/isolate-fs\";\n\nimport type { ConsoleOptions, ConsoleHandle } from \"@ricsam/isolate-console\";\nimport type { FetchOptions, FetchHandle } from \"@ricsam/isolate-fetch\";\nimport type { FsOptions, FsHandle } from \"@ricsam/isolate-fs\";\nimport type { CoreHandle } from \"@ricsam/isolate-core\";\nimport type { EncodingHandle } from \"@ricsam/isolate-encoding\";\nimport type { TimersHandle } from \"@ricsam/isolate-timers\";\nimport type { PathHandle } from \"@ricsam/isolate-path\";\nimport type { CryptoHandle } from \"@ricsam/isolate-crypto\";\n\n/**\n * @internal Options for creating a legacy runtime.\n */\nexport interface InternalRuntimeOptions {\n  memoryLimitMB?: number;\n  console?: ConsoleOptions;\n  fetch?: FetchOptions;\n  fs?: FsOptions;\n  /** Current working directory for path.resolve(). Defaults to \"/\" */\n  cwd?: string;\n}\n\n/**\n * @internal Runtime handle with direct isolate/context access.\n * Used by isolate-daemon for low-level operations.\n */\nexport interface InternalRuntimeHandle {\n  readonly isolate: ivm.Isolate;\n  readonly context: ivm.Context;\n  readonly fetch: FetchHandle;\n  readonly timers: TimersHandle;\n  readonly console: ConsoleHandle;\n  dispose(): void;\n}\n\n/**\n * @internal Create a runtime with direct access to isolate and context.\n * This is for internal use by @ricsam/isolate-daemon only.\n */\nexport async function createInternalRuntime(\n  options?: InternalRuntimeOptions\n): Promise<InternalRuntimeHandle> {\n  const opts = options ?? {};\n\n  const isolate = new ivm.Isolate({\n    memoryLimit: opts.memoryLimitMB,\n  });\n\n  const context = await isolate.createContext();\n\n  // Setup all APIs\n  const handles: {\n    core?: CoreHandle;\n    console?: ConsoleHandle;\n    encoding?: EncodingHandle;\n    timers?: TimersHandle;\n    path?: PathHandle;\n    crypto?: CryptoHandle;\n    fetch?: FetchHandle;\n    fs?: FsHandle;\n  } = {};\n\n  handles.core = await setupCore(context);\n  handles.console = await setupConsole(context, opts.console);\n  handles.encoding = await setupEncoding(context);\n  handles.timers = await setupTimers(context);\n  handles.path = await setupPath(context, { cwd: opts.cwd });\n  handles.crypto = await setupCrypto(context);\n  handles.fetch = await setupFetch(context, opts.fetch);\n\n  if (opts.fs) {\n    handles.fs = await setupFs(context, opts.fs);\n  }\n\n  return {\n    isolate,\n    context,\n    fetch: handles.fetch,\n    timers: handles.timers!,\n    console: handles.console!,\n    dispose() {\n      handles.fs?.dispose();\n      handles.fetch?.dispose();\n      handles.crypto?.dispose();\n      handles.path?.dispose();\n      handles.timers?.dispose();\n      handles.encoding?.dispose();\n      handles.console?.dispose();\n      handles.core?.dispose();\n      context.release();\n      isolate.dispose();\n    },\n  };\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOgB,IAAhB;AAC0B,IAA1B;AAC6B,IAA7B;AAC8B,IAA9B;AAC4B,IAA5B;AAC0B,IAA1B;AAC4B,IAA5B;AAC2B,IAA3B;AACwB,IAAxB;AAwCA,eAAsB,qBAAqB,CACzC,SACgC;AAAA,EAChC,MAAM,OAAO,WAAW,CAAC;AAAA,EAEzB,MAAM,UAAU,IAAI,2BAAI,QAAQ;AAAA,IAC9B,aAAa,KAAK;AAAA,EACpB,CAAC;AAAA,EAED,MAAM,UAAU,MAAM,QAAQ,cAAc;AAAA,EAG5C,MAAM,UASF,CAAC;AAAA,EAEL,QAAQ,OAAO,MAAM,8BAAU,OAAO;AAAA,EACtC,QAAQ,UAAU,MAAM,oCAAa,SAAS,KAAK,OAAO;AAAA,EAC1D,QAAQ,WAAW,MAAM,sCAAc,OAAO;AAAA,EAC9C,QAAQ,SAAS,MAAM,kCAAY,OAAO;AAAA,EAC1C,QAAQ,OAAO,MAAM,8BAAU,SAAS,EAAE,KAAK,KAAK,IAAI,CAAC;AAAA,EACzD,QAAQ,SAAS,MAAM,kCAAY,OAAO;AAAA,EAC1C,QAAQ,QAAQ,MAAM,gCAAW,SAAS,KAAK,KAAK;AAAA,EAEpD,IAAI,KAAK,IAAI;AAAA,IACX,QAAQ,KAAK,MAAM,0BAAQ,SAAS,KAAK,EAAE;AAAA,EAC7C;AAAA,EAEA,OAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,OAAO,QAAQ;AAAA,IACf,QAAQ,QAAQ;AAAA,IAChB,SAAS,QAAQ;AAAA,IACjB,OAAO,GAAG;AAAA,MACR,QAAQ,IAAI,QAAQ;AAAA,MACpB,QAAQ,OAAO,QAAQ;AAAA,MACvB,QAAQ,QAAQ,QAAQ;AAAA,MACxB,QAAQ,MAAM,QAAQ;AAAA,MACtB,QAAQ,QAAQ,QAAQ;AAAA,MACxB,QAAQ,UAAU,QAAQ;AAAA,MAC1B,QAAQ,SAAS,QAAQ;AAAA,MACzB,QAAQ,MAAM,QAAQ;AAAA,MACtB,QAAQ,QAAQ;AAAA,MAChB,QAAQ,QAAQ;AAAA;AAAA,EAEpB;AAAA;",
+  "debugId": "D12930C28AC6F96064756E2164756E21",
+  "names": []
+}

package/dist/cjs/package.json

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

package/dist/mjs/index.mjs

@@ -9,54 +9,454 @@ import { setupPath } from "@ricsam/isolate-path";
 import { setupCrypto } from "@ricsam/isolate-crypto";
 import { setupFetch } from "@ricsam/isolate-fetch";
 import { setupFs } from "@ricsam/isolate-fs";
+import {
+  setupTestEnvironment,
+  runTests as runTestsInContext,
+  hasTests as hasTestsInContext,
+  getTestCount as getTestCountInContext
+} from "@ricsam/isolate-test-environment";
+import { setupPlaywright } from "@ricsam/isolate-playwright";
 import { setupCore as setupCore2 } from "@ricsam/isolate-core";
-import { setupConsole as setupConsole2 } from "@ricsam/isolate-console";
+import { setupConsole as setupConsole2, simpleConsoleHandler } from "@ricsam/isolate-console";
 import { setupCrypto as setupCrypto2 } from "@ricsam/isolate-crypto";
 import { setupEncoding as setupEncoding2 } from "@ricsam/isolate-encoding";
 import { setupFetch as setupFetch2 } from "@ricsam/isolate-fetch";
 import { setupFs as setupFs2, createNodeFileSystemHandler } from "@ricsam/isolate-fs";
 import { setupPath as setupPath2 } from "@ricsam/isolate-path";
 import { setupTimers as setupTimers2 } from "@ricsam/isolate-timers";
+import { setupTestEnvironment as setupTestEnvironment2, runTests, hasTests, getTestCount } from "@ricsam/isolate-test-environment";
+import { setupPlaywright as setupPlaywright2, createPlaywrightHandler } from "@ricsam/isolate-playwright";
+
+export * from "./internal.mjs";
+var iteratorSessions = new Map;
+var nextIteratorId = 1;
+async function setupCustomFunctions(context, customFunctions) {
+  const global = context.global;
+  const invokeCallbackRef = new ivm.Reference(async (name, argsJson) => {
+    const def = customFunctions[name];
+    if (!def) {
+      return JSON.stringify({
+        ok: false,
+        error: { message: `Custom function '${name}' not found`, name: "Error" }
+      });
+    }
+    const args = JSON.parse(argsJson);
+    try {
+      const result = def.type === "async" ? await def.fn(...args) : def.fn(...args);
+      return JSON.stringify({ ok: true, value: result });
+    } catch (error) {
+      const err = error;
+      return JSON.stringify({
+        ok: false,
+        error: { message: err.message, name: err.name }
+      });
+    }
+  });
+  global.setSync("__customFn_invoke", invokeCallbackRef);
+  const iterStartRef = new ivm.Reference(async (name, argsJson) => {
+    const def = customFunctions[name];
+    if (!def || def.type !== "asyncIterator") {
+      return JSON.stringify({
+        ok: false,
+        error: { message: `Async iterator function '${name}' not found`, name: "Error" }
+      });
+    }
+    try {
+      const args = JSON.parse(argsJson);
+      const fn = def.fn;
+      const iterator = fn(...args);
+      const iteratorId = nextIteratorId++;
+      iteratorSessions.set(iteratorId, { iterator });
+      return JSON.stringify({ ok: true, iteratorId });
+    } catch (error) {
+      const err = error;
+      return JSON.stringify({
+        ok: false,
+        error: { message: err.message, name: err.name }
+      });
+    }
+  });
+  global.setSync("__iter_start", iterStartRef);
+  const iterNextRef = new ivm.Reference(async (iteratorId) => {
+    const session = iteratorSessions.get(iteratorId);
+    if (!session) {
+      return JSON.stringify({
+        ok: false,
+        error: { message: `Iterator session ${iteratorId} not found`, name: "Error" }
+      });
+    }
+    try {
+      const result = await session.iterator.next();
+      if (result.done) {
+        iteratorSessions.delete(iteratorId);
+      }
+      return JSON.stringify({ ok: true, done: result.done, value: result.value });
+    } catch (error) {
+      const err = error;
+      iteratorSessions.delete(iteratorId);
+      return JSON.stringify({
+        ok: false,
+        error: { message: err.message, name: err.name }
+      });
+    }
+  });
+  global.setSync("__iter_next", iterNextRef);
+  const iterReturnRef = new ivm.Reference(async (iteratorId, valueJson) => {
+    const session = iteratorSessions.get(iteratorId);
+    if (!session) {
+      return JSON.stringify({ ok: true, done: true, value: undefined });
+    }
+    try {
+      const value = valueJson ? JSON.parse(valueJson) : undefined;
+      const result = await session.iterator.return?.(value);
+      iteratorSessions.delete(iteratorId);
+      return JSON.stringify({ ok: true, done: true, value: result?.value });
+    } catch (error) {
+      const err = error;
+      iteratorSessions.delete(iteratorId);
+      return JSON.stringify({
+        ok: false,
+        error: { message: err.message, name: err.name }
+      });
+    }
+  });
+  global.setSync("__iter_return", iterReturnRef);
+  const iterThrowRef = new ivm.Reference(async (iteratorId, errorJson) => {
+    const session = iteratorSessions.get(iteratorId);
+    if (!session) {
+      return JSON.stringify({
+        ok: false,
+        error: { message: `Iterator session ${iteratorId} not found`, name: "Error" }
+      });
+    }
+    try {
+      const errorData = JSON.parse(errorJson);
+      const error = Object.assign(new Error(errorData.message), { name: errorData.name });
+      const result = await session.iterator.throw?.(error);
+      iteratorSessions.delete(iteratorId);
+      return JSON.stringify({ ok: true, done: result?.done ?? true, value: result?.value });
+    } catch (error) {
+      const err = error;
+      iteratorSessions.delete(iteratorId);
+      return JSON.stringify({
+        ok: false,
+        error: { message: err.message, name: err.name }
+      });
+    }
+  });
+  global.setSync("__iter_throw", iterThrowRef);
+  for (const name of Object.keys(customFunctions)) {
+    const def = customFunctions[name];
+    if (def.type === "async") {
+      context.evalSync(`
+        globalThis.${name} = async function(...args) {
+          const resultJson = __customFn_invoke.applySyncPromise(
+            undefined,
+            ["${name}", JSON.stringify(args)]
+          );
+          const result = JSON.parse(resultJson);
+          if (result.ok) {
+            return result.value;
+          } else {
+            const error = new Error(result.error.message);
+            error.name = result.error.name;
+            throw error;
+          }
+        };
+      `);
+    } else if (def.type === "sync") {
+      context.evalSync(`
+        globalThis.${name} = function(...args) {
+          const resultJson = __customFn_invoke.applySyncPromise(
+            undefined,
+            ["${name}", JSON.stringify(args)]
+          );
+          const result = JSON.parse(resultJson);
+          if (result.ok) {
+            return result.value;
+          } else {
+            const error = new Error(result.error.message);
+            error.name = result.error.name;
+            throw error;
+          }
+        };
+      `);
+    } else if (def.type === "asyncIterator") {
+      context.evalSync(`
+        globalThis.${name} = function(...args) {
+          const startResult = JSON.parse(__iter_start.applySyncPromise(undefined, ["${name}", JSON.stringify(args)]));
+          if (!startResult.ok) {
+            throw Object.assign(new Error(startResult.error.message), { name: startResult.error.name });
+          }
+          const iteratorId = startResult.iteratorId;
+          return {
+            [Symbol.asyncIterator]() { return this; },
+            async next() {
+              const result = JSON.parse(__iter_next.applySyncPromise(undefined, [iteratorId]));
+              if (!result.ok) {
+                throw Object.assign(new Error(result.error.message), { name: result.error.name });
+              }
+              return { done: result.done, value: result.value };
+            },
+            async return(v) {
+              const result = JSON.parse(__iter_return.applySyncPromise(undefined, [iteratorId, JSON.stringify(v)]));
+              return { done: true, value: result.value };
+            },
+            async throw(e) {
+              const result = JSON.parse(__iter_throw.applySyncPromise(undefined, [iteratorId, JSON.stringify({ message: e.message, name: e.name })]));
+              if (!result.ok) {
+                throw Object.assign(new Error(result.error.message), { name: result.error.name });
+              }
+              return { done: result.done, value: result.value };
+            }
+          };
+        };
+      `);
+    }
+  }
+  return invokeCallbackRef;
+}
+function createModuleResolver(state) {
+  return async (specifier, _referrer) => {
+    const cached = state.moduleCache.get(specifier);
+    if (cached)
+      return cached;
+    if (!state.moduleLoader) {
+      throw new Error(`No module loader registered. Cannot import: ${specifier}`);
+    }
+    const code = await state.moduleLoader(specifier);
+    const mod = await state.isolate.compileModule(code, {
+      filename: specifier
+    });
+    state.moduleCache.set(specifier, mod);
+    const resolver = createModuleResolver(state);
+    await mod.instantiate(state.context, resolver);
+    return mod;
+  };
+}
+function convertFetchCallback(callback) {
+  if (!callback) {
+    return {};
+  }
+  return {
+    onFetch: async (request) => {
+      return Promise.resolve(callback(request));
+    }
+  };
+}
 async function createRuntime(options) {
   const opts = options ?? {};
+  const id = crypto.randomUUID();
   const isolate = new ivm.Isolate({
-    memoryLimit: opts.memoryLimit
+    memoryLimit: opts.memoryLimitMB
   });
   const context = await isolate.createContext();
-  const handles = {};
-  handles.core = await setupCore(context);
-  handles.console = await setupConsole(context, opts.console);
-  handles.encoding = await setupEncoding(context);
-  handles.timers = await setupTimers(context);
-  handles.path = await setupPath(context);
-  handles.crypto = await setupCrypto(context);
-  handles.fetch = await setupFetch(context, opts.fetch);
+  const state = {
+    isolate,
+    context,
+    handles: {},
+    moduleCache: new Map,
+    moduleLoader: opts.moduleLoader,
+    customFunctions: opts.customFunctions
+  };
+  state.handles.core = await setupCore(context);
+  state.handles.console = await setupConsole(context, opts.console);
+  state.handles.encoding = await setupEncoding(context);
+  state.handles.timers = await setupTimers(context);
+  state.handles.path = await setupPath(context, { cwd: opts.cwd });
+  state.handles.crypto = await setupCrypto(context);
+  state.handles.fetch = await setupFetch(context, convertFetchCallback(opts.fetch));
   if (opts.fs) {
-    handles.fs = await setupFs(context, opts.fs);
+    state.handles.fs = await setupFs(context, opts.fs);
+  }
+  if (opts.customFunctions) {
+    state.customFnInvokeRef = await setupCustomFunctions(context, opts.customFunctions);
   }
+  if (opts.testEnvironment) {
+    const testEnvOptions = typeof opts.testEnvironment === "object" ? opts.testEnvironment : undefined;
+    state.handles.testEnvironment = await setupTestEnvironment(context, testEnvOptions);
+  }
+  if (opts.playwright) {
+    let eventCallback = opts.playwright.onEvent;
+    if (opts.playwright.console && opts.console?.onEntry) {
+      const originalCallback = eventCallback;
+      const consoleHandler = opts.console.onEntry;
+      eventCallback = (event) => {
+        if (originalCallback) {
+          originalCallback(event);
+        }
+        if (event.type === "browserConsoleLog") {
+          consoleHandler({
+            type: "browserOutput",
+            level: event.level,
+            args: event.args,
+            timestamp: event.timestamp
+          });
+        }
+      };
+    }
+    state.handles.playwright = await setupPlaywright(context, {
+      page: opts.playwright.page,
+      timeout: opts.playwright.timeout,
+      baseUrl: opts.playwright.baseUrl,
+      console: opts.playwright.console && !opts.console?.onEntry,
+      onEvent: eventCallback
+    });
+  }
+  const fetchHandle = {
+    async dispatchRequest(request, options2) {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      return state.handles.fetch.dispatchRequest(request, options2);
+    },
+    getUpgradeRequest() {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      return state.handles.fetch.getUpgradeRequest();
+    },
+    dispatchWebSocketOpen(connectionId) {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchWebSocketOpen(connectionId);
+    },
+    dispatchWebSocketMessage(connectionId, message) {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchWebSocketMessage(connectionId, message);
+    },
+    dispatchWebSocketClose(connectionId, code, reason) {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchWebSocketClose(connectionId, code, reason);
+    },
+    dispatchWebSocketError(connectionId, error) {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchWebSocketError(connectionId, error);
+    },
+    onWebSocketCommand(callback) {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      return state.handles.fetch.onWebSocketCommand(callback);
+    },
+    hasServeHandler() {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      return state.handles.fetch.hasServeHandler();
+    },
+    hasActiveConnections() {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      return state.handles.fetch.hasActiveConnections();
+    }
+  };
+  const timersHandle = {
+    clearAll() {
+      state.handles.timers?.clearAll();
+    }
+  };
+  const consoleHandle = {
+    reset() {
+      state.handles.console?.reset();
+    },
+    getTimers() {
+      return state.handles.console?.getTimers() ?? new Map;
+    },
+    getCounters() {
+      return state.handles.console?.getCounters() ?? new Map;
+    },
+    getGroupDepth() {
+      return state.handles.console?.getGroupDepth() ?? 0;
+    }
+  };
+  const testEnvironmentHandle = {
+    async runTests(_timeout) {
+      if (!state.handles.testEnvironment) {
+        throw new Error("Test environment not enabled. Set testEnvironment: true in createRuntime options.");
+      }
+      return runTestsInContext(state.context);
+    },
+    hasTests() {
+      if (!state.handles.testEnvironment) {
+        throw new Error("Test environment not enabled. Set testEnvironment: true in createRuntime options.");
+      }
+      return hasTestsInContext(state.context);
+    },
+    getTestCount() {
+      if (!state.handles.testEnvironment) {
+        throw new Error("Test environment not enabled. Set testEnvironment: true in createRuntime options.");
+      }
+      return getTestCountInContext(state.context);
+    },
+    reset() {
+      state.handles.testEnvironment?.dispose();
+    }
+  };
+  const playwrightHandle = {
+    getCollectedData() {
+      if (!state.handles.playwright) {
+        throw new Error("Playwright not configured. Provide playwright.page in createRuntime options.");
+      }
+      return {
+        browserConsoleLogs: state.handles.playwright.getBrowserConsoleLogs(),
+        networkRequests: state.handles.playwright.getNetworkRequests(),
+        networkResponses: state.handles.playwright.getNetworkResponses()
+      };
+    },
+    clearCollectedData() {
+      state.handles.playwright?.clearCollected();
+    }
+  };
   return {
-    isolate,
-    context,
-    fetch: handles.fetch,
-    async tick(ms) {
-      await handles.timers.tick(ms);
-    },
-    dispose() {
-      handles.fs?.dispose();
-      handles.fetch?.dispose();
-      handles.crypto?.dispose();
-      handles.path?.dispose();
-      handles.timers?.dispose();
-      handles.encoding?.dispose();
-      handles.console?.dispose();
-      handles.core?.dispose();
-      context.release();
-      isolate.dispose();
+    id,
+    fetch: fetchHandle,
+    timers: timersHandle,
+    console: consoleHandle,
+    testEnvironment: testEnvironmentHandle,
+    playwright: playwrightHandle,
+    async eval(code, filenameOrOptions) {
+      const options2 = typeof filenameOrOptions === "string" ? { filename: filenameOrOptions } : filenameOrOptions;
+      const mod = await state.isolate.compileModule(code, {
+        filename: options2?.filename ?? "<eval>"
+      });
+      const resolver = createModuleResolver(state);
+      await mod.instantiate(state.context, resolver);
+      await mod.evaluate(options2?.maxExecutionMs ? { timeout: options2.maxExecutionMs } : undefined);
+    },
+    async dispose() {
+      if (state.customFnInvokeRef) {
+        state.customFnInvokeRef.release();
+      }
+      state.handles.playwright?.dispose();
+      state.handles.testEnvironment?.dispose();
+      state.handles.fs?.dispose();
+      state.handles.fetch?.dispose();
+      state.handles.crypto?.dispose();
+      state.handles.path?.dispose();
+      state.handles.timers?.dispose();
+      state.handles.encoding?.dispose();
+      state.handles.console?.dispose();
+      state.handles.core?.dispose();
+      state.moduleCache.clear();
+      state.context.release();
+      state.isolate.dispose();
     }
   };
 }
 export {
+  simpleConsoleHandler,
   setupTimers2 as setupTimers,
+  setupTestEnvironment2 as setupTestEnvironment,
+  setupPlaywright2 as setupPlaywright,
   setupPath2 as setupPath,
   setupFs2 as setupFs,
   setupFetch2 as setupFetch,
@@ -64,8 +464,12 @@ export {
   setupCrypto2 as setupCrypto,
   setupCore2 as setupCore,
   setupConsole2 as setupConsole,
+  runTests,
+  hasTests,
+  getTestCount,
   createRuntime,
+  createPlaywrightHandler,
   createNodeFileSystemHandler
 };
 
-//# debugId=FDBFD94222E0044364756E2164756E21
+//# debugId=727908D2ABC724D264756E2164756E21