@ricsam/isolate-runtime 0.1.14 → 0.1.15

package/README.md

@@ -115,19 +115,16 @@ interface RuntimeOptions {
   cwd?: string;
   /** Enable test environment (describe, it, expect) */
   testEnvironment?: boolean | TestEnvironmentOptions;
-  /** Playwright options - user provides page object */
+  /** Playwright options (handler-first public API) */
   playwright?: PlaywrightOptions;
 }
 
 interface PlaywrightOptions {
-  page: import("playwright").Page;
+  handler: (op: PlaywrightOperation) => Promise<PlaywrightResult>;
   timeout?: number;
   /** Print browser console logs to stdout */
   console?: boolean;
-  /** Browser console log callback (from the page, not sandbox) */
-  onBrowserConsoleLog?: (entry: { level: string; stdout: string; timestamp: number }) => void;
-  onNetworkRequest?: (info: { url: string; method: string; headers: Record<string, string>; timestamp: number }) => void;
-  onNetworkResponse?: (info: { url: string; status: number; headers: Record<string, string>; timestamp: number }) => void;
+  onEvent?: (event: PlaywrightEvent) => void;
 }
 ```
 
@@ -309,20 +306,27 @@ type TestEvent =
 
 ## Playwright Integration
 
-Run browser automation with untrusted code. **You provide the Playwright page object**:
+Run browser automation with untrusted code. Public API is handler-first:
+
+```typescript
+import { defaultPlaywrightHandler } from "@ricsam/isolate-playwright/client";
+
+playwright: { handler: defaultPlaywrightHandler(page) }
+```
 
 ### Script Mode (No Tests)
 
 ```typescript
 import { createRuntime } from "@ricsam/isolate-runtime";
 import { chromium } from "playwright";
+import { defaultPlaywrightHandler } from "@ricsam/isolate-playwright/client";
 
 const browser = await chromium.launch({ headless: true });
 const page = await browser.newPage();
 
 const runtime = await createRuntime({
   playwright: {
-    page,
+    handler: defaultPlaywrightHandler(page),
     console: true, // Print browser console to stdout
   },
 });
@@ -349,6 +353,7 @@ Combine `testEnvironment` and `playwright` for browser testing. Playwright exten
 ```typescript
 import { createRuntime } from "@ricsam/isolate-runtime";
 import { chromium } from "playwright";
+import { defaultPlaywrightHandler } from "@ricsam/isolate-playwright/client";
 
 const browser = await chromium.launch({ headless: true });
 const page = await browser.newPage();
@@ -356,8 +361,12 @@ const page = await browser.newPage();
 const runtime = await createRuntime({
   testEnvironment: true, // Provides describe, it, expect
   playwright: {
-    page,
-    onBrowserConsoleLog: (entry) => console.log("[browser]", entry.stdout),
+    handler: defaultPlaywrightHandler(page),
+    onEvent: (event) => {
+      if (event.type === "browserConsoleLog") {
+        console.log("[browser]", event.stdout);
+      }
+    },
   },
 });
 
@@ -383,6 +392,74 @@ await runtime.dispose();
 await browser.close();
 ```
 
+### Multi-Page Testing
+
+For tests that need multiple pages or browser contexts, provide `createPage` and/or `createContext` callbacks:
+
+```typescript
+import { createRuntime } from "@ricsam/isolate-runtime";
+import { chromium } from "playwright";
+import { defaultPlaywrightHandler } from "@ricsam/isolate-playwright/client";
+
+const browser = await chromium.launch({ headless: true });
+const browserContext = await browser.newContext();
+const page = await browserContext.newPage();
+
+const runtime = await createRuntime({
+  testEnvironment: true,
+  playwright: {
+    handler: defaultPlaywrightHandler(page, {
+      // Called when isolate code calls context.newPage()
+      createPage: async (context) => context.newPage(),
+      // Called when isolate code calls browser.newContext()
+      createContext: async (options) => browser.newContext(options),
+    }),
+  },
+});
+
+await runtime.eval(`
+  test('multi-page test', async () => {
+    // Create additional pages
+    const page2 = await context.newPage();
+
+    // Navigate independently
+    await page.goto('https://example.com/page1');
+    await page2.goto('https://example.com/page2');
+
+    // Work with multiple pages
+    await page.locator('#button').click();
+    await page2.locator('#input').fill('text');
+
+    await page2.close();
+  });
+
+  test('multi-context test', async () => {
+    // Create isolated context (separate cookies, storage)
+    const ctx2 = await browser.newContext();
+    const page2 = await ctx2.newPage();
+
+    // Cookies are isolated between contexts
+    await context.addCookies([{ name: 'test', value: '1', domain: 'example.com', path: '/' }]);
+    const ctx1Cookies = await context.cookies();
+    const ctx2Cookies = await ctx2.cookies();
+
+    expect(ctx1Cookies.some(c => c.name === 'test')).toBe(true);
+    expect(ctx2Cookies.some(c => c.name === 'test')).toBe(false);
+
+    await ctx2.close();
+  });
+`);
+
+const results = await runtime.testEnvironment.runTests();
+await runtime.dispose();
+await browser.close();
+```
+
+**Behavior without lifecycle callbacks:**
+- `context.newPage()` without `createPage`: Throws error
+- `browser.newContext()` without `createContext`: Throws error
+- `context.cookies()`, `context.addCookies()`, `context.clearCookies()`: Work without callbacks
+
 ## Included APIs
 
 - Core (Blob, File, streams, URL, TextEncoder/Decoder)
@@ -394,20 +471,7 @@ await browser.close();
 - Fetch API
 - File System (if handler provided)
 - Test Environment (if enabled)
-- Playwright (if page provided)
-
-## Legacy API
-
-For backwards compatibility with code that needs direct isolate/context access:
-
-```typescript
-import { createLegacyRuntime } from "@ricsam/isolate-runtime";
-
-const runtime = await createLegacyRuntime();
-// runtime.isolate and runtime.context are available
-await runtime.context.eval(`console.log("Hello")`);
-runtime.dispose(); // sync
-```
+- Playwright (if handler provided)
 
 ## License
 

package/dist/cjs/index.cjs

@@ -4,23 +4,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __reExport = (target, mod, secondTarget) => {
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(target, key) && key !== "default")
-      __defProp(target, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  if (secondTarget) {
-    for (let key of __getOwnPropNames(mod))
-      if (!__hasOwnProp.call(secondTarget, key) && key !== "default")
-        __defProp(secondTarget, key, {
-          get: () => mod[key],
-          enumerable: true
-        });
-    return secondTarget;
-  }
-};
 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;
@@ -74,6 +57,8 @@ __export(exports_src, {
   normalizeEntryFilename: () => import_isolate_protocol2.normalizeEntryFilename,
   hasTests: () => import_isolate_test_environment2.hasTests,
   getTestCount: () => import_isolate_test_environment2.getTestCount,
+  getDefaultPlaywrightHandlerMetadata: () => import_isolate_playwright2.getDefaultPlaywrightHandlerMetadata,
+  defaultPlaywrightHandler: () => import_isolate_playwright2.defaultPlaywrightHandler,
   createRuntime: () => createRuntime,
   createPlaywrightHandler: () => import_isolate_playwright2.createPlaywrightHandler,
   createNodeFileSystemHandler: () => import_isolate_fs2.createNodeFileSystemHandler
@@ -106,7 +91,6 @@ var import_isolate_path2 = require("@ricsam/isolate-path");
 var import_isolate_timers2 = require("@ricsam/isolate-timers");
 var import_isolate_test_environment2 = require("@ricsam/isolate-test-environment");
 var import_isolate_playwright2 = require("@ricsam/isolate-playwright");
-__reExport(exports_src, require("./internal.cjs"), module.exports);
 var iteratorSessions = new Map;
 var nextIteratorId = 1;
 var ISOLATE_MARSHAL_CODE = `
@@ -232,6 +216,68 @@ var ISOLATE_MARSHAL_CODE = `
           }
           return fd;
         }
+        case 'CallbackRef': {
+          // Create a proxy function that invokes the callback
+          const callbackId = value.callbackId;
+          return function(...args) {
+            const argsJson = JSON.stringify(marshalForHost(args));
+            const resultJson = __customFn_invoke.applySyncPromise(undefined, [callbackId, argsJson]);
+            const result = JSON.parse(resultJson);
+            if (result.ok) {
+              return unmarshalFromHost(result.value);
+            } else {
+              const error = new Error(result.error.message);
+              error.name = result.error.name;
+              throw error;
+            }
+          };
+        }
+        case 'PromiseRef': {
+          // Create a proxy Promise that resolves via callback
+          const promiseId = value.promiseId;
+          return new Promise((resolve, reject) => {
+            try {
+              const argsJson = JSON.stringify([promiseId]);
+              const resultJson = __customFn_invoke.applySyncPromise(undefined, [value.__resolveCallbackId, argsJson]);
+              const result = JSON.parse(resultJson);
+              if (result.ok) {
+                resolve(unmarshalFromHost(result.value));
+              } else {
+                reject(new Error(result.error.message));
+              }
+            } catch (e) {
+              reject(e);
+            }
+          });
+        }
+        case 'AsyncIteratorRef': {
+          const iteratorId = value.iteratorId;
+          const nextCallbackId = value.__nextCallbackId;
+          const returnCallbackId = value.__returnCallbackId;
+          return {
+            [Symbol.asyncIterator]() { return this; },
+            async next() {
+              const argsJson = JSON.stringify([iteratorId]);
+              const resultJson = __customFn_invoke.applySyncPromise(undefined, [nextCallbackId, argsJson]);
+              const result = JSON.parse(resultJson);
+              if (!result.ok) {
+                const error = new Error(result.error.message);
+                error.name = result.error.name;
+                throw error;
+              }
+              return {
+                done: result.value.done,
+                value: unmarshalFromHost(result.value.value)
+              };
+            },
+            async return(v) {
+              const argsJson = JSON.stringify([iteratorId, marshalForHost(v)]);
+              const resultJson = __customFn_invoke.applySyncPromise(undefined, [returnCallbackId, argsJson]);
+              const result = JSON.parse(resultJson);
+              return { done: true, value: result.ok ? unmarshalFromHost(result.value) : undefined };
+            }
+          };
+        }
         default:
           // Unknown ref type, return as-is
           break;
@@ -255,9 +301,27 @@ var ISOLATE_MARSHAL_CODE = `
   globalThis.__unmarshalFromHost = unmarshalFromHost;
 })();
 `;
-async function setupCustomFunctions(context, customFunctions) {
+async function setupCustomFunctions(context, customFunctions, marshalOptions) {
   const global = context.global;
-  const invokeCallbackRef = new import_isolated_vm.default.Reference(async (name, argsJson) => {
+  const invokeCallbackRef = new import_isolated_vm.default.Reference(async (nameOrId, argsJson) => {
+    if (typeof nameOrId === "number" && marshalOptions) {
+      const rawArgs2 = JSON.parse(argsJson);
+      const args2 = import_isolate_protocol3.unmarshalValue(rawArgs2);
+      try {
+        const result = await marshalOptions.invokeCallback(nameOrId, args2);
+        const ctx = marshalOptions.createMarshalContext();
+        const marshalledResult = await import_isolate_protocol3.marshalValue(result, ctx);
+        const processedResult = marshalOptions.addCallbackIdsToRefs(marshalledResult);
+        return JSON.stringify({ ok: true, value: processedResult });
+      } catch (error) {
+        const err = error;
+        return JSON.stringify({
+          ok: false,
+          error: { message: err.message, name: err.name }
+        });
+      }
+    }
+    const name = String(nameOrId);
     const def = customFunctions[name];
     if (!def) {
       return JSON.stringify({
@@ -271,7 +335,13 @@ async function setupCustomFunctions(context, customFunctions) {
     const rawArgs = JSON.parse(argsJson);
     const args = import_isolate_protocol3.unmarshalValue(rawArgs);
     try {
-      const result = def.type === "async" ? await def.fn(...args) : def.fn(...args);
+      const result = await def.fn(...args);
+      if (marshalOptions) {
+        const ctx = marshalOptions.createMarshalContext();
+        const marshalledResult2 = await import_isolate_protocol3.marshalValue(result, ctx);
+        const processedResult = marshalOptions.addCallbackIdsToRefs(marshalledResult2);
+        return JSON.stringify({ ok: true, value: processedResult });
+      }
       const marshalledResult = await import_isolate_protocol3.marshalValue(result);
       return JSON.stringify({ ok: true, value: marshalledResult });
     } catch (error) {
@@ -327,7 +397,14 @@ async function setupCustomFunctions(context, customFunctions) {
       if (result.done) {
         iteratorSessions.delete(iteratorId);
       }
-      const marshalledValue = await import_isolate_protocol3.marshalValue(result.value);
+      let marshalledValue;
+      if (marshalOptions) {
+        const ctx = marshalOptions.createMarshalContext();
+        marshalledValue = await import_isolate_protocol3.marshalValue(result.value, ctx);
+        marshalledValue = marshalOptions.addCallbackIdsToRefs(marshalledValue);
+      } else {
+        marshalledValue = await import_isolate_protocol3.marshalValue(result.value);
+      }
       return JSON.stringify({
         ok: true,
         done: result.done,
@@ -353,7 +430,14 @@ async function setupCustomFunctions(context, customFunctions) {
       const value = import_isolate_protocol3.unmarshalValue(rawValue);
       const result = await session.iterator.return?.(value);
       iteratorSessions.delete(iteratorId);
-      const marshalledValue = await import_isolate_protocol3.marshalValue(result?.value);
+      let marshalledValue;
+      if (marshalOptions) {
+        const ctx = marshalOptions.createMarshalContext();
+        marshalledValue = await import_isolate_protocol3.marshalValue(result?.value, ctx);
+        marshalledValue = marshalOptions.addCallbackIdsToRefs(marshalledValue);
+      } else {
+        marshalledValue = await import_isolate_protocol3.marshalValue(result?.value);
+      }
       return JSON.stringify({ ok: true, done: true, value: marshalledValue });
     } catch (error) {
       const err = error;
@@ -383,7 +467,14 @@ async function setupCustomFunctions(context, customFunctions) {
       });
       const result = await session.iterator.throw?.(error);
       iteratorSessions.delete(iteratorId);
-      const marshalledValue = await import_isolate_protocol3.marshalValue(result?.value);
+      let marshalledValue;
+      if (marshalOptions) {
+        const ctx = marshalOptions.createMarshalContext();
+        marshalledValue = await import_isolate_protocol3.marshalValue(result?.value, ctx);
+        marshalledValue = marshalOptions.addCallbackIdsToRefs(marshalledValue);
+      } else {
+        marshalledValue = await import_isolate_protocol3.marshalValue(result?.value);
+      }
       return JSON.stringify({
         ok: true,
         done: result?.done ?? true,
@@ -474,8 +565,114 @@ async function setupCustomFunctions(context, customFunctions) {
   }
   return invokeCallbackRef;
 }
+function createLocalCustomFunctionsMarshalOptions() {
+  const returnedCallbacks = new Map;
+  const returnedPromises = new Map;
+  const returnedIterators = new Map;
+  let nextLocalCallbackId = 1e6;
+  const createMarshalContext = () => ({
+    registerCallback: (fn) => {
+      const callbackId = nextLocalCallbackId++;
+      returnedCallbacks.set(callbackId, fn);
+      return callbackId;
+    },
+    registerPromise: (promise) => {
+      const promiseId = nextLocalCallbackId++;
+      returnedPromises.set(promiseId, promise);
+      return promiseId;
+    },
+    registerIterator: (iterator) => {
+      const iteratorId = nextLocalCallbackId++;
+      returnedIterators.set(iteratorId, iterator);
+      return iteratorId;
+    }
+  });
+  const isPromiseRef = (value) => typeof value === "object" && value !== null && value.__type === "PromiseRef";
+  const isAsyncIteratorRef = (value) => typeof value === "object" && value !== null && value.__type === "AsyncIteratorRef";
+  const addCallbackIdsToRefs = (value) => {
+    if (value === null || typeof value !== "object")
+      return value;
+    if (isPromiseRef(value)) {
+      if ("__resolveCallbackId" in value)
+        return value;
+      const resolveCallbackId = nextLocalCallbackId++;
+      returnedCallbacks.set(resolveCallbackId, async (promiseId) => {
+        const promise = returnedPromises.get(promiseId);
+        if (!promise) {
+          throw new Error(`Promise ${promiseId} not found`);
+        }
+        const result2 = await promise;
+        returnedPromises.delete(promiseId);
+        const ctx = createMarshalContext();
+        const marshalled = await import_isolate_protocol3.marshalValue(result2, ctx);
+        return addCallbackIdsToRefs(marshalled);
+      });
+      return { ...value, __resolveCallbackId: resolveCallbackId };
+    }
+    if (isAsyncIteratorRef(value)) {
+      if ("__nextCallbackId" in value)
+        return value;
+      const nextCallbackId = nextLocalCallbackId++;
+      returnedCallbacks.set(nextCallbackId, async (iteratorId) => {
+        const iterator = returnedIterators.get(iteratorId);
+        if (!iterator) {
+          throw new Error(`Iterator ${iteratorId} not found`);
+        }
+        const result2 = await iterator.next();
+        if (result2.done) {
+          returnedIterators.delete(iteratorId);
+        }
+        const ctx = createMarshalContext();
+        const marshalledValue = await import_isolate_protocol3.marshalValue(result2.value, ctx);
+        return {
+          done: result2.done,
+          value: addCallbackIdsToRefs(marshalledValue)
+        };
+      });
+      const returnCallbackId = nextLocalCallbackId++;
+      returnedCallbacks.set(returnCallbackId, async (iteratorId, returnValue) => {
+        const iterator = returnedIterators.get(iteratorId);
+        returnedIterators.delete(iteratorId);
+        if (!iterator || !iterator.return) {
+          return { done: true, value: undefined };
+        }
+        const result2 = await iterator.return(returnValue);
+        const ctx = createMarshalContext();
+        const marshalledValue = await import_isolate_protocol3.marshalValue(result2.value, ctx);
+        return {
+          done: true,
+          value: addCallbackIdsToRefs(marshalledValue)
+        };
+      });
+      return {
+        ...value,
+        __nextCallbackId: nextCallbackId,
+        __returnCallbackId: returnCallbackId
+      };
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => addCallbackIdsToRefs(item));
+    }
+    const result = {};
+    for (const key of Object.keys(value)) {
+      result[key] = addCallbackIdsToRefs(value[key]);
+    }
+    return result;
+  };
+  const invokeCallback = async (callbackId, args) => {
+    const callback = returnedCallbacks.get(callbackId);
+    if (!callback) {
+      throw new Error(`Local callback ${callbackId} not found`);
+    }
+    return await callback(...args);
+  };
+  return { createMarshalContext, addCallbackIdsToRefs, invokeCallback };
+}
 function createModuleResolver(state) {
   return async (specifier, referrer) => {
+    const staticCached = state.staticModuleCache.get(specifier);
+    if (staticCached)
+      return staticCached;
     const cached = state.moduleCache.get(specifier);
     if (cached)
       return cached;
@@ -484,16 +681,21 @@ function createModuleResolver(state) {
     }
     const importerPath = state.moduleToFilename.get(referrer) ?? "<unknown>";
     const importerResolveDir = import_node_path.default.posix.dirname(importerPath);
-    const { code, resolveDir } = await state.moduleLoader(specifier, {
+    const result = await state.moduleLoader(specifier, {
       path: importerPath,
       resolveDir: importerResolveDir
     });
+    const { code, resolveDir } = result;
     const hash = import_isolate_transform.contentHash(code);
     const cacheKey = `${specifier}:${hash}`;
     const hashCached = state.moduleCache.get(cacheKey);
     if (hashCached)
       return hashCached;
-    const transformed = await import_isolate_transform.transformModuleCode(code, specifier);
+    let transformed = state.transformCache.get(hash);
+    if (!transformed) {
+      transformed = await import_isolate_transform.transformModuleCode(code, specifier);
+      state.transformCache.set(hash, transformed);
+    }
     if (transformed.sourceMap) {
       state.sourceMaps.set(specifier, transformed.sourceMap);
     }
@@ -502,8 +704,12 @@ function createModuleResolver(state) {
     });
     const resolvedPath = import_node_path.default.posix.join(resolveDir, import_node_path.default.posix.basename(specifier));
     state.moduleToFilename.set(mod, resolvedPath);
-    state.moduleCache.set(specifier, mod);
-    state.moduleCache.set(cacheKey, mod);
+    if (result.static) {
+      state.staticModuleCache.set(specifier, mod);
+    } else {
+      state.moduleCache.set(specifier, mod);
+      state.moduleCache.set(cacheKey, mod);
+    }
     const resolver = createModuleResolver(state);
     await mod.instantiate(state.context, resolver);
     return mod;
@@ -514,8 +720,8 @@ function convertFetchCallback(callback) {
     return {};
   }
   return {
-    onFetch: async (request) => {
-      return Promise.resolve(callback(request));
+    onFetch: async (url, init) => {
+      return Promise.resolve(callback(url, init));
     }
   };
 }
@@ -531,8 +737,11 @@ async function createRuntime(options) {
     context,
     handles: {},
     moduleCache: new Map,
+    staticModuleCache: new Map,
+    transformCache: new Map,
     moduleToFilename: new Map,
     sourceMaps: new Map,
+    pendingCallbacks: [],
     moduleLoader: opts.moduleLoader,
     customFunctions: opts.customFunctions
   };
@@ -547,13 +756,17 @@ async function createRuntime(options) {
     state.handles.fs = await import_isolate_fs.setupFs(context, opts.fs);
   }
   if (opts.customFunctions) {
-    state.customFnInvokeRef = await setupCustomFunctions(context, opts.customFunctions);
+    const customMarshalOptions = opts.customFunctionsMarshalOptions ?? createLocalCustomFunctionsMarshalOptions();
+    state.customFnInvokeRef = await setupCustomFunctions(context, opts.customFunctions, customMarshalOptions);
   }
   if (opts.testEnvironment) {
     const testEnvOptions = typeof opts.testEnvironment === "object" ? opts.testEnvironment : undefined;
     state.handles.testEnvironment = await import_isolate_test_environment.setupTestEnvironment(context, testEnvOptions);
   }
   if (opts.playwright) {
+    if (!opts.playwright.handler) {
+      throw new Error("Playwright configured without handler. Provide playwright.handler in createRuntime options.");
+    }
     let eventCallback = opts.playwright.onEvent;
     if (opts.playwright.console && opts.console?.onEntry) {
       const originalCallback = eventCallback;
@@ -572,12 +785,13 @@ async function createRuntime(options) {
         }
       };
     }
-    state.handles.playwright = await import_isolate_playwright.setupPlaywright(context, {
-      page: opts.playwright.page,
+    const playwrightSetupOptions = {
+      handler: opts.playwright.handler,
       timeout: opts.playwright.timeout,
       console: opts.playwright.console && !opts.console?.onEntry,
       onEvent: eventCallback
-    });
+    };
+    state.handles.playwright = await import_isolate_playwright.setupPlaywright(context, playwrightSetupOptions);
   }
   const fetchHandle = {
     async dispatchRequest(request, options2) {
@@ -633,6 +847,36 @@ async function createRuntime(options) {
         throw new Error("Fetch handle not available");
       }
       return state.handles.fetch.hasActiveConnections();
+    },
+    dispatchClientWebSocketOpen(socketId, protocol, extensions) {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchClientWebSocketOpen(socketId, protocol, extensions);
+    },
+    dispatchClientWebSocketMessage(socketId, data) {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchClientWebSocketMessage(socketId, data);
+    },
+    dispatchClientWebSocketClose(socketId, code, reason, wasClean) {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchClientWebSocketClose(socketId, code, reason, wasClean);
+    },
+    dispatchClientWebSocketError(socketId) {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchClientWebSocketError(socketId);
+    },
+    onClientWebSocketCommand(callback) {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      return state.handles.fetch.onClientWebSocketCommand(callback);
     }
   };
   const timersHandle = {
@@ -655,11 +899,27 @@ async function createRuntime(options) {
     }
   };
   const testEnvironmentHandle = {
-    async runTests(_timeout) {
+    async runTests(timeout) {
       if (!state.handles.testEnvironment) {
         throw new Error("Test environment not enabled. Set testEnvironment: true in createRuntime options.");
       }
-      return import_isolate_test_environment.runTests(state.context);
+      if (timeout === undefined) {
+        return import_isolate_test_environment.runTests(state.context);
+      }
+      let timeoutId;
+      const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error("Test timeout")), timeout);
+      });
+      try {
+        return await Promise.race([
+          import_isolate_test_environment.runTests(state.context),
+          timeoutPromise
+        ]);
+      } finally {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+      }
     },
     hasTests() {
       if (!state.handles.testEnvironment) {
@@ -680,7 +940,7 @@ async function createRuntime(options) {
   const playwrightHandle = {
     getCollectedData() {
       if (!state.handles.playwright) {
-        throw new Error("Playwright not configured. Provide playwright.page in createRuntime options.");
+        throw new Error("Playwright not configured. Provide playwright.handler in createRuntime options.");
       }
       return {
         browserConsoleLogs: state.handles.playwright.getBrowserConsoleLogs(),
@@ -694,6 +954,7 @@ async function createRuntime(options) {
   };
   return {
     id,
+    pendingCallbacks: state.pendingCallbacks,
     fetch: fetchHandle,
     timers: timersHandle,
     console: consoleHandle,
@@ -724,6 +985,10 @@ async function createRuntime(options) {
         } finally {
           runRef.release();
         }
+        if (state.pendingCallbacks.length > 0) {
+          await Promise.all(state.pendingCallbacks);
+          state.pendingCallbacks.length = 0;
+        }
       } catch (err) {
         const error = err;
         if (error.stack && state.sourceMaps.size > 0) {
@@ -732,6 +997,11 @@ async function createRuntime(options) {
         throw error;
       }
     },
+    clearModuleCache() {
+      state.moduleCache.clear();
+      state.moduleToFilename.clear();
+      state.sourceMaps.clear();
+    },
     async dispose() {
       if (state.customFnInvokeRef) {
         state.customFnInvokeRef.release();
@@ -753,4 +1023,4 @@ async function createRuntime(options) {
   };
 }
 
-//# debugId=230C5D24BE3157C264756E2164756E21
+//# debugId=6EFB8447C7EE485F64756E2164756E21