@ricsam/isolate-daemon 0.1.0 → 0.1.4

package/dist/cjs/connection.cjs

@@ -1,8 +1,21 @@
 // @bun @bun-cjs
-(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+(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;
@@ -34,11 +47,11 @@ __export(exports_connection, {
 });
 module.exports = __toCommonJS(exports_connection);
 var import_node_crypto = require("crypto");
+var import_isolated_vm = __toESM(require("isolated-vm"));
 var import_isolate_protocol = require("@ricsam/isolate-protocol");
 var import_callback_fs_handler = require("./callback-fs-handler.cjs");
 var import_isolate_test_environment = require("@ricsam/isolate-test-environment");
 var import_isolate_playwright = require("@ricsam/isolate-playwright");
-var import_playwright = require("playwright");
 var import_isolate_runtime = require("@ricsam/isolate-runtime");
 function handleConnection(socket, state) {
   const connection = {
@@ -48,7 +61,9 @@ function handleConnection(socket, state) {
     pendingCallbacks: new Map,
     nextRequestId: 1,
     nextCallbackId: 1,
-    nextStreamId: 1
+    nextStreamId: 1,
+    activeStreams: new Map,
+    streamReceivers: new Map
   };
   state.connections.set(socket, connection);
   const parser = import_isolate_protocol.createFrameParser();
@@ -72,12 +87,6 @@ function handleConnection(socket, state) {
           if (instance.playwrightHandle) {
             instance.playwrightHandle.dispose();
           }
-          if (instance.browserContext) {
-            instance.browserContext.close().catch(() => {});
-          }
-          if (instance.browser) {
-            instance.browser.close().catch(() => {});
-          }
           instance.runtime.dispose();
         } catch {}
         state.isolates.delete(isolateId);
@@ -129,20 +138,56 @@ async function handleMessage(message, connection, state) {
     case import_isolate_protocol.MessageType.DISPATCH_REQUEST:
       await handleDispatchRequest(message, connection, state);
       break;
-    case import_isolate_protocol.MessageType.TICK:
-      await handleTick(message, connection, state);
-      break;
     case import_isolate_protocol.MessageType.CALLBACK_RESPONSE:
       handleCallbackResponse(message, connection);
       break;
-    case import_isolate_protocol.MessageType.SETUP_TEST_ENV:
-      await handleSetupTestEnv(message, connection, state);
+    case import_isolate_protocol.MessageType.WS_OPEN:
+      await handleWsOpen(message, connection, state);
+      break;
+    case import_isolate_protocol.MessageType.WS_MESSAGE:
+      await handleWsMessage(message, connection, state);
+      break;
+    case import_isolate_protocol.MessageType.WS_CLOSE:
+      await handleWsClose(message, connection, state);
+      break;
+    case import_isolate_protocol.MessageType.FETCH_GET_UPGRADE_REQUEST:
+      await handleFetchGetUpgradeRequest(message, connection, state);
+      break;
+    case import_isolate_protocol.MessageType.FETCH_HAS_SERVE_HANDLER:
+      await handleFetchHasServeHandler(message, connection, state);
+      break;
+    case import_isolate_protocol.MessageType.FETCH_HAS_ACTIVE_CONNECTIONS:
+      await handleFetchHasActiveConnections(message, connection, state);
+      break;
+    case import_isolate_protocol.MessageType.FETCH_WS_ERROR:
+      await handleFetchWsError(message, connection, state);
+      break;
+    case import_isolate_protocol.MessageType.TIMERS_CLEAR_ALL:
+      await handleTimersClearAll(message, connection, state);
+      break;
+    case import_isolate_protocol.MessageType.CONSOLE_RESET:
+      await handleConsoleReset(message, connection, state);
+      break;
+    case import_isolate_protocol.MessageType.CONSOLE_GET_TIMERS:
+      await handleConsoleGetTimers(message, connection, state);
+      break;
+    case import_isolate_protocol.MessageType.CONSOLE_GET_COUNTERS:
+      await handleConsoleGetCounters(message, connection, state);
+      break;
+    case import_isolate_protocol.MessageType.CONSOLE_GET_GROUP_DEPTH:
+      await handleConsoleGetGroupDepth(message, connection, state);
       break;
     case import_isolate_protocol.MessageType.RUN_TESTS:
       await handleRunTests(message, connection, state);
       break;
-    case import_isolate_protocol.MessageType.SETUP_PLAYWRIGHT:
-      await handleSetupPlaywright(message, connection, state);
+    case import_isolate_protocol.MessageType.RESET_TEST_ENV:
+      await handleResetTestEnv(message, connection, state);
+      break;
+    case import_isolate_protocol.MessageType.HAS_TESTS:
+      await handleHasTests(message, connection, state);
+      break;
+    case import_isolate_protocol.MessageType.GET_TEST_COUNT:
+      await handleGetTestCount(message, connection, state);
       break;
     case import_isolate_protocol.MessageType.RUN_PLAYWRIGHT_TESTS:
       await handleRunPlaywrightTests(message, connection, state);
@@ -153,9 +198,24 @@ async function handleMessage(message, connection, state) {
     case import_isolate_protocol.MessageType.GET_COLLECTED_DATA:
       await handleGetCollectedData(message, connection, state);
       break;
+    case import_isolate_protocol.MessageType.CLEAR_COLLECTED_DATA:
+      await handleClearCollectedData(message, connection, state);
+      break;
     case import_isolate_protocol.MessageType.PING:
       sendMessage(connection.socket, { type: import_isolate_protocol.MessageType.PONG });
       break;
+    case import_isolate_protocol.MessageType.STREAM_PUSH:
+      handleStreamPush(message, connection);
+      break;
+    case import_isolate_protocol.MessageType.STREAM_PULL:
+      handleStreamPull(message, connection);
+      break;
+    case import_isolate_protocol.MessageType.STREAM_CLOSE:
+      handleStreamClose(message, connection);
+      break;
+    case import_isolate_protocol.MessageType.STREAM_ERROR:
+      handleStreamError(message, connection);
+      break;
     default:
       sendError(connection.socket, message.requestId ?? 0, import_isolate_protocol.ErrorCode.UNKNOWN_MESSAGE_TYPE, `Unknown message type: ${message.type}`);
   }
@@ -170,16 +230,16 @@ async function handleCreateRuntime(message, connection, state) {
     const consoleCallbacks = message.options.callbacks?.console;
     const fetchCallback = message.options.callbacks?.fetch;
     const fsCallbacks = message.options.callbacks?.fs;
-    const runtime = await import_isolate_runtime.createRuntime({
-      memoryLimit: message.options.memoryLimit ?? state.options.defaultMemoryLimit,
-      console: consoleCallbacks ? {
-        onLog: async (level, ...args) => {
-          const levelCallback = consoleCallbacks[level];
-          if (levelCallback) {
-            await invokeClientCallback(connection, levelCallback.callbackId, [level, ...args]);
-          } else if (consoleCallbacks.log) {
-            await invokeClientCallback(connection, consoleCallbacks.log.callbackId, [level, ...args]);
-          }
+    const moduleLoaderCallback = message.options.callbacks?.moduleLoader;
+    const customCallbacks = message.options.callbacks?.custom;
+    const pendingCallbacks = [];
+    const runtime = await import_isolate_runtime.createInternalRuntime({
+      memoryLimitMB: message.options.memoryLimitMB ?? state.options.defaultMemoryLimitMB,
+      cwd: message.options.cwd,
+      console: consoleCallbacks?.onEntry ? {
+        onEntry: (entry) => {
+          const promise = invokeClientCallback(connection, consoleCallbacks.onEntry.callbackId, [entry]).catch(() => {});
+          pendingCallbacks.push(promise);
         }
       } : undefined,
       fetch: fetchCallback ? {
@@ -206,14 +266,25 @@ async function handleCreateRuntime(message, connection, state) {
       ownerConnection: connection.socket,
       callbacks: new Map,
       createdAt: Date.now(),
-      lastActivity: Date.now()
+      lastActivity: Date.now(),
+      pendingCallbacks,
+      returnedCallbacks: new Map,
+      returnedPromises: new Map,
+      returnedIterators: new Map,
+      nextLocalCallbackId: 1e6
     };
-    if (consoleCallbacks) {
-      for (const [name, reg] of Object.entries(consoleCallbacks)) {
-        if (reg) {
-          instance.callbacks.set(reg.callbackId, { ...reg, name });
-        }
-      }
+    if (moduleLoaderCallback) {
+      instance.moduleLoaderCallbackId = moduleLoaderCallback.callbackId;
+      instance.moduleCache = new Map;
+    }
+    if (customCallbacks) {
+      await setupCustomFunctions(runtime.context, customCallbacks, connection, instance);
+    }
+    if (consoleCallbacks?.onEntry) {
+      instance.callbacks.set(consoleCallbacks.onEntry.callbackId, {
+        ...consoleCallbacks.onEntry,
+        name: "onEntry"
+      });
     }
     if (fetchCallback) {
       instance.callbacks.set(fetchCallback.callbackId, fetchCallback);
@@ -225,9 +296,86 @@ async function handleCreateRuntime(message, connection, state) {
         }
       }
     }
+    if (moduleLoaderCallback) {
+      instance.callbacks.set(moduleLoaderCallback.callbackId, moduleLoaderCallback);
+    }
+    if (customCallbacks) {
+      for (const [name, reg] of Object.entries(customCallbacks)) {
+        if (reg) {
+          instance.callbacks.set(reg.callbackId, { ...reg, name });
+        }
+      }
+    }
+    if (message.options.testEnvironment) {
+      const testEnvOption = message.options.testEnvironment;
+      const testEnvOptions = typeof testEnvOption === "object" ? testEnvOption : undefined;
+      const onEventCallback = testEnvOptions?.callbacks?.onEvent;
+      await import_isolate_test_environment.setupTestEnvironment(runtime.context, {
+        onEvent: onEventCallback ? (event) => {
+          const promise = invokeClientCallback(connection, onEventCallback.callbackId, [JSON.stringify(event)]).catch(() => {});
+          pendingCallbacks.push(promise);
+        } : undefined,
+        testTimeout: testEnvOptions?.testTimeout
+      });
+      instance.testEnvironmentEnabled = true;
+      if (onEventCallback) {
+        instance.callbacks.set(onEventCallback.callbackId, {
+          ...onEventCallback,
+          name: "testEnvironment.onEvent"
+        });
+      }
+    }
+    const playwrightCallbacks = message.options.callbacks?.playwright;
+    if (playwrightCallbacks) {
+      const handler = async (op) => {
+        try {
+          const resultJson = await invokeClientCallback(connection, playwrightCallbacks.handlerCallbackId, [JSON.stringify(op)]);
+          return JSON.parse(resultJson);
+        } catch (err) {
+          const error = err;
+          return { ok: false, error: { name: error.name, message: error.message } };
+        }
+      };
+      instance.playwrightHandle = await import_isolate_playwright.setupPlaywright(runtime.context, {
+        handler,
+        console: playwrightCallbacks.console,
+        onEvent: (event) => {
+          if (event.type === "browserConsoleLog" && playwrightCallbacks.onBrowserConsoleLogCallbackId) {
+            const promise = invokeClientCallback(connection, playwrightCallbacks.onBrowserConsoleLogCallbackId, [{ level: event.level, args: event.args, timestamp: event.timestamp }]).catch(() => {});
+            pendingCallbacks.push(promise);
+          } else if (event.type === "networkRequest" && playwrightCallbacks.onNetworkRequestCallbackId) {
+            const promise = invokeClientCallback(connection, playwrightCallbacks.onNetworkRequestCallbackId, [event]).catch(() => {});
+            pendingCallbacks.push(promise);
+          } else if (event.type === "networkResponse" && playwrightCallbacks.onNetworkResponseCallbackId) {
+            const promise = invokeClientCallback(connection, playwrightCallbacks.onNetworkResponseCallbackId, [event]).catch(() => {});
+            pendingCallbacks.push(promise);
+          }
+        }
+      });
+    }
     state.isolates.set(isolateId, instance);
     connection.isolates.add(isolateId);
     state.stats.totalIsolatesCreated++;
+    instance.runtime.fetch.onWebSocketCommand((cmd) => {
+      let data;
+      if (cmd.data instanceof ArrayBuffer) {
+        data = new Uint8Array(cmd.data);
+      } else {
+        data = cmd.data;
+      }
+      const wsCommandMsg = {
+        type: import_isolate_protocol.MessageType.WS_COMMAND,
+        isolateId,
+        command: {
+          type: cmd.type,
+          connectionId: cmd.connectionId,
+          data,
+          code: cmd.code,
+          reason: cmd.reason
+        }
+      };
+      sendMessage(connection.socket, wsCommandMsg);
+    });
     sendOk(connection.socket, message.requestId, { isolateId });
   } catch (err) {
     const error = err;
@@ -248,12 +396,6 @@ async function handleDisposeRuntime(message, connection, state) {
     if (instance.playwrightHandle) {
       instance.playwrightHandle.dispose();
     }
-    if (instance.browserContext) {
-      await instance.browserContext.close();
-    }
-    if (instance.browser) {
-      await instance.browser.close();
-    }
     instance.runtime.dispose();
     state.isolates.delete(message.isolateId);
     connection.isolates.delete(message.isolateId);
@@ -271,13 +413,26 @@ async function handleEval(message, connection, state) {
   }
   instance.lastActivity = Date.now();
   try {
-    const result = instance.runtime.context.evalSync(message.code, {
-      filename: message.filename
+    const mod = await instance.runtime.isolate.compileModule(message.code, {
+      filename: message.filename ?? "<eval>"
     });
-    sendOk(connection.socket, message.requestId, { value: result });
+    if (instance.moduleLoaderCallbackId) {
+      const resolver = createModuleResolver(instance, connection);
+      await mod.instantiate(instance.runtime.context, resolver);
+    } else {
+      await mod.instantiate(instance.runtime.context, (specifier) => {
+        throw new Error(`No module loader registered. Cannot import: ${specifier}`);
+      });
+    }
+    const timeout = message.maxExecutionMs;
+    await mod.evaluate(timeout ? { timeout } : undefined);
+    await Promise.all(instance.pendingCallbacks);
+    instance.pendingCallbacks.length = 0;
+    sendOk(connection.socket, message.requestId, { value: undefined });
   } catch (err) {
     const error = err;
-    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+    const isTimeoutError = error.message?.includes("Script execution timed out");
+    sendError(connection.socket, message.requestId, isTimeoutError ? import_isolate_protocol.ErrorCode.ISOLATE_TIMEOUT : import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
 async function handleDispatchRequest(message, connection, state) {
@@ -288,24 +443,135 @@ async function handleDispatchRequest(message, connection, state) {
   }
   instance.lastActivity = Date.now();
   try {
+    let requestBody = null;
+    if (message.request.bodyStreamId !== undefined) {
+      requestBody = await receiveStreamedBody(connection, message.request.bodyStreamId);
+    } else if (message.request.body) {
+      requestBody = message.request.body;
+    }
     const request = new Request(message.request.url, {
       method: message.request.method,
       headers: message.request.headers,
-      body: message.request.body
+      body: requestBody
     });
-    const response = await instance.runtime.fetch.dispatchRequest(request, {
-      tick: async () => {
-        await instance.runtime.tick();
+    const response = await instance.runtime.fetch.dispatchRequest(request);
+    const contentLength = response.headers.get("content-length");
+    const knownSize = contentLength ? parseInt(contentLength, 10) : null;
+    if (knownSize !== null && knownSize > import_isolate_protocol.STREAM_THRESHOLD) {
+      await sendStreamedResponse(connection, message.requestId, response);
+    } else {
+      const clonedResponse = response.clone();
+      try {
+        const serialized = await serializeResponse(response);
+        if (serialized.body && serialized.body.length > import_isolate_protocol.STREAM_THRESHOLD) {
+          await sendStreamedResponse(connection, message.requestId, clonedResponse);
+        } else {
+          sendOk(connection.socket, message.requestId, { response: serialized });
+        }
+      } catch {
+        await sendStreamedResponse(connection, message.requestId, clonedResponse);
       }
+    }
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+function receiveStreamedBody(connection, streamId) {
+  return new Promise((resolve, reject) => {
+    const receiver = {
+      streamId,
+      requestId: 0,
+      chunks: [],
+      totalBytes: 0,
+      resolve,
+      reject
+    };
+    connection.streamReceivers.set(streamId, receiver);
+    sendMessage(connection.socket, {
+      type: import_isolate_protocol.MessageType.STREAM_PULL,
+      streamId,
+      maxBytes: import_isolate_protocol.STREAM_DEFAULT_CREDIT
     });
-    const serialized = await serializeResponse(response);
-    sendOk(connection.socket, message.requestId, { response: serialized });
+  });
+}
+async function handleWsOpen(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    instance.runtime.fetch.dispatchWebSocketOpen(message.connectionId);
+    sendOk(connection.socket, message.requestId);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleWsMessage(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    const data = message.data instanceof Uint8Array ? message.data.buffer.slice(message.data.byteOffset, message.data.byteOffset + message.data.byteLength) : message.data;
+    instance.runtime.fetch.dispatchWebSocketMessage(message.connectionId, data);
+    sendOk(connection.socket, message.requestId);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleWsClose(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    instance.runtime.fetch.dispatchWebSocketClose(message.connectionId, message.code, message.reason);
+    sendOk(connection.socket, message.requestId);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleFetchGetUpgradeRequest(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    const upgradeRequest = instance.runtime.fetch.getUpgradeRequest();
+    sendOk(connection.socket, message.requestId, upgradeRequest);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleFetchHasServeHandler(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    const hasHandler = instance.runtime.fetch.hasServeHandler();
+    sendOk(connection.socket, message.requestId, hasHandler);
   } catch (err) {
     const error = err;
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
-async function handleTick(message, connection, state) {
+async function handleFetchHasActiveConnections(message, connection, state) {
   const instance = state.isolates.get(message.isolateId);
   if (!instance) {
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
@@ -313,13 +579,103 @@ async function handleTick(message, connection, state) {
   }
   instance.lastActivity = Date.now();
   try {
-    instance.runtime.tick(message.ms);
+    const hasConnections = instance.runtime.fetch.hasActiveConnections();
+    sendOk(connection.socket, message.requestId, hasConnections);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleFetchWsError(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    instance.runtime.fetch.dispatchWebSocketError(message.connectionId, new Error(message.error));
     sendOk(connection.socket, message.requestId);
   } catch (err) {
     const error = err;
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
+async function handleTimersClearAll(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    instance.runtime.timers.clearAll();
+    sendOk(connection.socket, message.requestId);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleConsoleReset(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    instance.runtime.console.reset();
+    sendOk(connection.socket, message.requestId);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleConsoleGetTimers(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    const timers = instance.runtime.console.getTimers();
+    sendOk(connection.socket, message.requestId, Object.fromEntries(timers));
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleConsoleGetCounters(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    const counters = instance.runtime.console.getCounters();
+    sendOk(connection.socket, message.requestId, Object.fromEntries(counters));
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleConsoleGetGroupDepth(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    const depth = instance.runtime.console.getGroupDepth();
+    sendOk(connection.socket, message.requestId, depth);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
 function handleCallbackResponse(message, connection) {
   const pending = connection.pendingCallbacks.get(message.requestId);
   if (!pending) {
@@ -363,6 +719,477 @@ async function invokeClientCallback(connection, callbackId, args, timeout = 1e4)
     sendMessage(connection.socket, invoke);
   });
 }
+var ISOLATE_MARSHAL_CODE = `
+(function() {
+  // Marshal a value (JavaScript \u2192 Ref)
+  function marshalForHost(value, depth = 0) {
+    if (depth > 100) throw new Error('Maximum marshalling depth exceeded');
+
+    if (value === null) return null;
+    if (value === undefined) return { __type: 'UndefinedRef' };
+
+    const type = typeof value;
+    if (type === 'string' || type === 'number' || type === 'boolean') return value;
+    if (type === 'bigint') return { __type: 'BigIntRef', value: value.toString() };
+    if (type === 'function') throw new Error('Cannot marshal functions from isolate');
+    if (type === 'symbol') throw new Error('Cannot marshal Symbol values');
+
+    if (type === 'object') {
+      if (value instanceof Date) {
+        return { __type: 'DateRef', timestamp: value.getTime() };
+      }
+      if (value instanceof RegExp) {
+        return { __type: 'RegExpRef', source: value.source, flags: value.flags };
+      }
+      if (value instanceof URL) {
+        return { __type: 'URLRef', href: value.href };
+      }
+      if (typeof Headers !== 'undefined' && value instanceof Headers) {
+        const pairs = [];
+        value.forEach((v, k) => pairs.push([k, v]));
+        return { __type: 'HeadersRef', pairs };
+      }
+      if (value instanceof Uint8Array) {
+        return { __type: 'Uint8ArrayRef', data: Array.from(value) };
+      }
+      if (value instanceof ArrayBuffer) {
+        return { __type: 'Uint8ArrayRef', data: Array.from(new Uint8Array(value)) };
+      }
+      if (typeof Request !== 'undefined' && value instanceof Request) {
+        throw new Error('Cannot marshal Request from isolate. Use fetch callback instead.');
+      }
+      if (typeof Response !== 'undefined' && value instanceof Response) {
+        throw new Error('Cannot marshal Response from isolate. Return plain objects instead.');
+      }
+      if (typeof File !== 'undefined' && value instanceof File) {
+        throw new Error('Cannot marshal File from isolate.');
+      }
+      if (typeof Blob !== 'undefined' && value instanceof Blob) {
+        throw new Error('Cannot marshal Blob from isolate.');
+      }
+      if (typeof FormData !== 'undefined' && value instanceof FormData) {
+        throw new Error('Cannot marshal FormData from isolate.');
+      }
+      if (Array.isArray(value)) {
+        return value.map(v => marshalForHost(v, depth + 1));
+      }
+      // Plain object
+      const result = {};
+      for (const key of Object.keys(value)) {
+        result[key] = marshalForHost(value[key], depth + 1);
+      }
+      return result;
+    }
+    return value;
+  }
+
+  // Unmarshal a value (Ref \u2192 JavaScript)
+  function unmarshalFromHost(value, depth = 0) {
+    if (depth > 100) throw new Error('Maximum unmarshalling depth exceeded');
+
+    if (value === null) return null;
+    if (typeof value !== 'object') return value;
+
+    if (value.__type) {
+      switch (value.__type) {
+        case 'UndefinedRef': return undefined;
+        case 'DateRef': return new Date(value.timestamp);
+        case 'RegExpRef': return new RegExp(value.source, value.flags);
+        case 'BigIntRef': return BigInt(value.value);
+        case 'URLRef': return new URL(value.href);
+        case 'HeadersRef': return new Headers(value.pairs);
+        case 'Uint8ArrayRef': return new Uint8Array(value.data);
+        case 'RequestRef': {
+          const init = {
+            method: value.method,
+            headers: value.headers,
+            body: value.body ? new Uint8Array(value.body) : null,
+          };
+          if (value.mode) init.mode = value.mode;
+          if (value.credentials) init.credentials = value.credentials;
+          if (value.cache) init.cache = value.cache;
+          if (value.redirect) init.redirect = value.redirect;
+          if (value.referrer) init.referrer = value.referrer;
+          if (value.referrerPolicy) init.referrerPolicy = value.referrerPolicy;
+          if (value.integrity) init.integrity = value.integrity;
+          return new Request(value.url, init);
+        }
+        case 'ResponseRef': {
+          return new Response(value.body ? new Uint8Array(value.body) : null, {
+            status: value.status,
+            statusText: value.statusText,
+            headers: value.headers,
+          });
+        }
+        case 'FileRef': {
+          if (!value.name) {
+            return new Blob([new Uint8Array(value.data)], { type: value.type });
+          }
+          return new File([new Uint8Array(value.data)], value.name, {
+            type: value.type,
+            lastModified: value.lastModified,
+          });
+        }
+        case 'FormDataRef': {
+          const fd = new FormData();
+          for (const [key, entry] of value.entries) {
+            if (typeof entry === 'string') {
+              fd.append(key, entry);
+            } else {
+              const file = unmarshalFromHost(entry, depth + 1);
+              fd.append(key, file);
+            }
+          }
+          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;
+      }
+    }
+
+    if (Array.isArray(value)) {
+      return value.map(v => unmarshalFromHost(v, depth + 1));
+    }
+
+    // Plain object - recursively unmarshal
+    const result = {};
+    for (const key of Object.keys(value)) {
+      result[key] = unmarshalFromHost(value[key], depth + 1);
+    }
+    return result;
+  }
+
+  globalThis.__marshalForHost = marshalForHost;
+  globalThis.__unmarshalFromHost = unmarshalFromHost;
+})();
+`;
+var LOCAL_CALLBACK_THRESHOLD = 1e6;
+function isPromiseRef(value) {
+  return typeof value === "object" && value !== null && value.__type === "PromiseRef";
+}
+function isAsyncIteratorRef(value) {
+  return typeof value === "object" && value !== null && value.__type === "AsyncIteratorRef";
+}
+function isLocalCallbackId(callbackId) {
+  return callbackId >= LOCAL_CALLBACK_THRESHOLD;
+}
+async function setupCustomFunctions(context, customCallbacks, connection, instance) {
+  const global = context.global;
+  function createMarshalContext() {
+    return {
+      registerCallback: (fn) => {
+        const callbackId = instance.nextLocalCallbackId++;
+        instance.returnedCallbacks.set(callbackId, fn);
+        return callbackId;
+      },
+      registerPromise: (promise) => {
+        const promiseId = instance.nextLocalCallbackId++;
+        instance.returnedPromises.set(promiseId, promise);
+        return promiseId;
+      },
+      registerIterator: (iterator) => {
+        const iteratorId = instance.nextLocalCallbackId++;
+        instance.returnedIterators.set(iteratorId, iterator);
+        return iteratorId;
+      }
+    };
+  }
+  function addCallbackIdsToRefs(value) {
+    if (value === null || typeof value !== "object") {
+      return value;
+    }
+    if (isPromiseRef(value)) {
+      if ("__resolveCallbackId" in value) {
+        return value;
+      }
+      const resolveCallbackId = instance.nextLocalCallbackId++;
+      instance.returnedCallbacks.set(resolveCallbackId, async (promiseId) => {
+        const promise = instance.returnedPromises.get(promiseId);
+        if (!promise) {
+          throw new Error(`Promise ${promiseId} not found`);
+        }
+        const result2 = await promise;
+        instance.returnedPromises.delete(promiseId);
+        const ctx = createMarshalContext();
+        const marshalled = await import_isolate_protocol.marshalValue(result2, ctx);
+        return addCallbackIdsToRefs(marshalled);
+      });
+      return {
+        ...value,
+        __resolveCallbackId: resolveCallbackId
+      };
+    }
+    if (isAsyncIteratorRef(value)) {
+      if ("__nextCallbackId" in value) {
+        return value;
+      }
+      const nextCallbackId = instance.nextLocalCallbackId++;
+      instance.returnedCallbacks.set(nextCallbackId, async (iteratorId) => {
+        const iterator = instance.returnedIterators.get(iteratorId);
+        if (!iterator) {
+          throw new Error(`Iterator ${iteratorId} not found`);
+        }
+        const result2 = await iterator.next();
+        if (result2.done) {
+          instance.returnedIterators.delete(iteratorId);
+        }
+        const ctx = createMarshalContext();
+        const marshalledValue = await import_isolate_protocol.marshalValue(result2.value, ctx);
+        return {
+          done: result2.done,
+          value: addCallbackIdsToRefs(marshalledValue)
+        };
+      });
+      const returnCallbackId = instance.nextLocalCallbackId++;
+      instance.returnedCallbacks.set(returnCallbackId, async (iteratorId, returnValue) => {
+        const iterator = instance.returnedIterators.get(iteratorId);
+        instance.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_protocol.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 invokeCallbackRef = new import_isolated_vm.default.Reference(async (callbackId, argsJson) => {
+    const marshalledArgs = JSON.parse(argsJson);
+    const args = import_isolate_protocol.unmarshalValue(marshalledArgs);
+    try {
+      let result;
+      if (isLocalCallbackId(callbackId)) {
+        const callback = instance.returnedCallbacks.get(callbackId);
+        if (!callback) {
+          throw new Error(`Local callback ${callbackId} not found`);
+        }
+        result = await callback(...args);
+      } else {
+        result = await invokeClientCallback(connection, callbackId, args);
+      }
+      const ctx = createMarshalContext();
+      const marshalledResult = await import_isolate_protocol.marshalValue({ ok: true, value: result }, ctx);
+      const processedResult = addCallbackIdsToRefs(marshalledResult);
+      return JSON.stringify(processedResult);
+    } catch (error) {
+      const err = error;
+      return JSON.stringify({
+        ok: false,
+        error: { message: err.message, name: err.name }
+      });
+    }
+  });
+  global.setSync("__customFn_invoke", invokeCallbackRef);
+  context.evalSync(ISOLATE_MARSHAL_CODE);
+  for (const [name, registration] of Object.entries(customCallbacks)) {
+    if (name.includes(":")) {
+      continue;
+    }
+    if (registration.type === "sync") {
+      context.evalSync(`
+        globalThis.${name} = function(...args) {
+          const argsJson = JSON.stringify(__marshalForHost(args));
+          const resultJson = __customFn_invoke.applySyncPromise(
+            undefined,
+            [${registration.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;
+          }
+        };
+      `);
+    } else if (registration.type === "asyncIterator") {
+      const startReg = customCallbacks[`${name}:start`];
+      const nextReg = customCallbacks[`${name}:next`];
+      const returnReg = customCallbacks[`${name}:return`];
+      const throwReg = customCallbacks[`${name}:throw`];
+      if (!startReg || !nextReg || !returnReg || !throwReg) {
+        throw new Error(`Missing companion callbacks for asyncIterator function "${name}"`);
+      }
+      context.evalSync(`
+        globalThis.${name} = function(...args) {
+          // Start the iterator and get the iteratorId
+          const argsJson = JSON.stringify(__marshalForHost(args));
+          const startResultJson = __customFn_invoke.applySyncPromise(
+            undefined,
+            [${startReg.callbackId}, argsJson]
+          );
+          const startResult = JSON.parse(startResultJson);
+          if (!startResult.ok) {
+            const error = new Error(startResult.error.message);
+            error.name = startResult.error.name;
+            throw error;
+          }
+          const iteratorId = __unmarshalFromHost(startResult.value).iteratorId;
+
+          return {
+            [Symbol.asyncIterator]() { return this; },
+            async next() {
+              const argsJson = JSON.stringify(__marshalForHost([iteratorId]));
+              const resultJson = __customFn_invoke.applySyncPromise(
+                undefined,
+                [${nextReg.callbackId}, argsJson]
+              );
+              const result = JSON.parse(resultJson);
+              if (!result.ok) {
+                const error = new Error(result.error.message);
+                error.name = result.error.name;
+                throw error;
+              }
+              const val = __unmarshalFromHost(result.value);
+              return { done: val.done, value: val.value };
+            },
+            async return(v) {
+              const argsJson = JSON.stringify(__marshalForHost([iteratorId, v]));
+              const resultJson = __customFn_invoke.applySyncPromise(
+                undefined,
+                [${returnReg.callbackId}, argsJson]
+              );
+              const result = JSON.parse(resultJson);
+              return { done: true, value: result.ok ? __unmarshalFromHost(result.value) : undefined };
+            },
+            async throw(e) {
+              const argsJson = JSON.stringify(__marshalForHost([iteratorId, { message: e?.message, name: e?.name }]));
+              const resultJson = __customFn_invoke.applySyncPromise(
+                undefined,
+                [${throwReg.callbackId}, argsJson]
+              );
+              const result = JSON.parse(resultJson);
+              if (!result.ok) {
+                const error = new Error(result.error.message);
+                error.name = result.error.name;
+                throw error;
+              }
+              const val = __unmarshalFromHost(result.value);
+              return { done: val.done, value: val.value };
+            }
+          };
+        };
+      `);
+    } else if (registration.type === "async") {
+      context.evalSync(`
+        globalThis.${name} = async function(...args) {
+          const argsJson = JSON.stringify(__marshalForHost(args));
+          const resultJson = __customFn_invoke.applySyncPromise(
+            undefined,
+            [${registration.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;
+          }
+        };
+      `);
+    }
+  }
+}
+function createModuleResolver(instance, connection) {
+  return async (specifier, _referrer) => {
+    const cached = instance.moduleCache?.get(specifier);
+    if (cached)
+      return cached;
+    if (!instance.moduleLoaderCallbackId) {
+      throw new Error(`Module not found: ${specifier}`);
+    }
+    const code = await invokeClientCallback(connection, instance.moduleLoaderCallbackId, [specifier]);
+    const mod = await instance.runtime.isolate.compileModule(code, {
+      filename: specifier
+    });
+    const resolver = createModuleResolver(instance, connection);
+    await mod.instantiate(instance.runtime.context, resolver);
+    instance.moduleCache?.set(specifier, mod);
+    return mod;
+  };
+}
 async function serializeRequest(request) {
   const headers = [];
   request.headers.forEach((value, key) => {
@@ -402,19 +1229,144 @@ function deserializeResponse(data) {
     headers: data.headers
   });
 }
-async function handleSetupTestEnv(message, connection, state) {
-  const instance = state.isolates.get(message.isolateId);
-  if (!instance) {
-    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+function handleStreamPush(message, connection) {
+  const receiver = connection.streamReceivers.get(message.streamId);
+  if (!receiver) {
+    sendMessage(connection.socket, {
+      type: import_isolate_protocol.MessageType.STREAM_ERROR,
+      streamId: message.streamId,
+      error: "Stream not found"
+    });
     return;
   }
-  instance.lastActivity = Date.now();
+  receiver.chunks.push(message.chunk);
+  receiver.totalBytes += message.chunk.length;
+  sendMessage(connection.socket, {
+    type: import_isolate_protocol.MessageType.STREAM_PULL,
+    streamId: message.streamId,
+    maxBytes: import_isolate_protocol.STREAM_DEFAULT_CREDIT
+  });
+}
+function handleStreamPull(message, connection) {
+  const session = connection.activeStreams.get(message.streamId);
+  if (!session) {
+    return;
+  }
+  session.credit += message.maxBytes;
+  if (session.creditResolver) {
+    session.creditResolver();
+    session.creditResolver = undefined;
+  }
+}
+function handleStreamClose(message, connection) {
+  const receiver = connection.streamReceivers.get(message.streamId);
+  if (!receiver) {
+    return;
+  }
+  const totalLength = receiver.chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const body = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of receiver.chunks) {
+    body.set(chunk, offset);
+    offset += chunk.length;
+  }
+  receiver.resolve(body);
+  connection.streamReceivers.delete(message.streamId);
+}
+function handleStreamError(message, connection) {
+  const receiver = connection.streamReceivers.get(message.streamId);
+  if (receiver) {
+    receiver.reject(new Error(message.error));
+    connection.streamReceivers.delete(message.streamId);
+  }
+  const session = connection.activeStreams.get(message.streamId);
+  if (session) {
+    session.state = "closed";
+    connection.activeStreams.delete(message.streamId);
+  }
+}
+function waitForCredit(session) {
+  return new Promise((resolve) => {
+    session.creditResolver = resolve;
+  });
+}
+async function sendStreamedResponse(connection, requestId, response) {
+  const streamId = connection.nextStreamId++;
+  const headers = [];
+  response.headers.forEach((value, key) => {
+    headers.push([key, value]);
+  });
+  const startMsg = {
+    type: import_isolate_protocol.MessageType.RESPONSE_STREAM_START,
+    requestId,
+    streamId,
+    metadata: {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    }
+  };
+  sendMessage(connection.socket, startMsg);
+  if (!response.body) {
+    const endMsg = {
+      type: import_isolate_protocol.MessageType.RESPONSE_STREAM_END,
+      requestId,
+      streamId
+    };
+    sendMessage(connection.socket, endMsg);
+    return;
+  }
+  const session = {
+    streamId,
+    direction: "download",
+    requestId,
+    state: "active",
+    bytesTransferred: 0,
+    credit: import_isolate_protocol.STREAM_DEFAULT_CREDIT
+  };
+  connection.activeStreams.set(streamId, session);
+  const reader = response.body.getReader();
   try {
-    await import_isolate_test_environment.setupTestEnvironment(instance.runtime.context);
-    sendOk(connection.socket, message.requestId);
+    while (true) {
+      while (session.credit < import_isolate_protocol.STREAM_CHUNK_SIZE && session.state === "active") {
+        await waitForCredit(session);
+      }
+      if (session.state !== "active") {
+        throw new Error("Stream cancelled");
+      }
+      const { done, value } = await reader.read();
+      if (done) {
+        const endMsg = {
+          type: import_isolate_protocol.MessageType.RESPONSE_STREAM_END,
+          requestId,
+          streamId
+        };
+        sendMessage(connection.socket, endMsg);
+        break;
+      }
+      for (let offset = 0;offset < value.length; offset += import_isolate_protocol.STREAM_CHUNK_SIZE) {
+        const chunk = value.slice(offset, offset + import_isolate_protocol.STREAM_CHUNK_SIZE);
+        const chunkMsg = {
+          type: import_isolate_protocol.MessageType.RESPONSE_STREAM_CHUNK,
+          requestId,
+          streamId,
+          chunk
+        };
+        sendMessage(connection.socket, chunkMsg);
+        session.credit -= chunk.length;
+        session.bytesTransferred += chunk.length;
+      }
+    }
   } catch (err) {
-    const error = err;
-    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+    const errorMsg = {
+      type: import_isolate_protocol.MessageType.STREAM_ERROR,
+      streamId,
+      error: err.message
+    };
+    sendMessage(connection.socket, errorMsg);
+  } finally {
+    reader.releaseLock();
+    connection.activeStreams.delete(streamId);
   }
 }
 async function handleRunTests(message, connection, state) {
@@ -423,6 +1375,10 @@ async function handleRunTests(message, connection, state) {
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
     return;
   }
+  if (!instance.testEnvironmentEnabled) {
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, "Test environment not enabled. Set testEnvironment: true in createRuntime options.");
+    return;
+  }
   instance.lastActivity = Date.now();
   try {
     const timeout = message.timeout ?? 30000;
@@ -439,119 +1395,69 @@ async function handleRunTests(message, connection, state) {
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
-async function handleSetupPlaywright(message, connection, state) {
+async function handleResetTestEnv(message, connection, state) {
   const instance = state.isolates.get(message.isolateId);
   if (!instance) {
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
     return;
   }
-  if (instance.browser) {
-    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, "Playwright already set up for this isolate");
+  if (!instance.testEnvironmentEnabled) {
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, "Test environment not enabled. Set testEnvironment: true in createRuntime options.");
     return;
   }
   instance.lastActivity = Date.now();
   try {
-    const browserType = message.options.browserType ?? "chromium";
-    const headless = message.options.headless ?? true;
-    let browser;
-    switch (browserType) {
-      case "firefox":
-        browser = await import_playwright.firefox.launch({ headless });
-        break;
-      case "webkit":
-        browser = await import_playwright.webkit.launch({ headless });
-        break;
-      default:
-        browser = await import_playwright.chromium.launch({ headless });
-    }
-    const browserContext = await browser.newContext();
-    const page = await browserContext.newPage();
-    const playwrightHandle = await import_isolate_playwright.setupPlaywright(instance.runtime.context, {
-      page,
-      baseUrl: message.options.baseURL,
-      onConsoleLog: (level, ...args) => {
-        const event = {
-          type: import_isolate_protocol.MessageType.PLAYWRIGHT_EVENT,
-          isolateId: message.isolateId,
-          eventType: "consoleLog",
-          payload: { level, args }
-        };
-        sendMessage(connection.socket, event);
-      },
-      onNetworkRequest: (info) => {
-        const event = {
-          type: import_isolate_protocol.MessageType.PLAYWRIGHT_EVENT,
-          isolateId: message.isolateId,
-          eventType: "networkRequest",
-          payload: info
-        };
-        sendMessage(connection.socket, event);
-      },
-      onNetworkResponse: (info) => {
-        const event = {
-          type: import_isolate_protocol.MessageType.PLAYWRIGHT_EVENT,
-          isolateId: message.isolateId,
-          eventType: "networkResponse",
-          payload: info
-        };
-        sendMessage(connection.socket, event);
-      }
-    });
-    instance.browser = browser;
-    instance.browserContext = browserContext;
-    instance.page = page;
-    instance.playwrightHandle = playwrightHandle;
+    await instance.runtime.context.eval("__resetTestEnvironment()", { promise: true });
     sendOk(connection.socket, message.requestId);
   } catch (err) {
     const error = err;
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
-async function handleRunPlaywrightTests(message, connection, state) {
+async function handleHasTests(message, connection, state) {
   const instance = state.isolates.get(message.isolateId);
   if (!instance) {
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
     return;
   }
-  if (!instance.playwrightHandle) {
-    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, "Playwright not set up for this isolate");
+  if (!instance.testEnvironmentEnabled) {
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, "Test environment not enabled. Set testEnvironment: true in createRuntime options.");
     return;
   }
   instance.lastActivity = Date.now();
   try {
-    const timeout = message.timeout ?? 30000;
-    const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(() => reject(new Error("Playwright test timeout")), timeout);
-    });
-    const results = await Promise.race([
-      import_isolate_playwright.runPlaywrightTests(instance.runtime.context),
-      timeoutPromise
-    ]);
-    sendOk(connection.socket, message.requestId, results);
+    const result = import_isolate_test_environment.hasTests(instance.runtime.context);
+    sendOk(connection.socket, message.requestId, result);
   } catch (err) {
     const error = err;
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
-async function handleResetPlaywrightTests(message, connection, state) {
+async function handleGetTestCount(message, connection, state) {
   const instance = state.isolates.get(message.isolateId);
   if (!instance) {
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
     return;
   }
-  if (!instance.playwrightHandle) {
-    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, "Playwright not set up for this isolate");
+  if (!instance.testEnvironmentEnabled) {
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, "Test environment not enabled. Set testEnvironment: true in createRuntime options.");
     return;
   }
   instance.lastActivity = Date.now();
   try {
-    await import_isolate_playwright.resetPlaywrightTests(instance.runtime.context);
-    sendOk(connection.socket, message.requestId);
+    const result = import_isolate_test_environment.getTestCount(instance.runtime.context);
+    sendOk(connection.socket, message.requestId, result);
   } catch (err) {
     const error = err;
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
+async function handleRunPlaywrightTests(message, connection, _state) {
+  sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, "playwright.runTests() has been removed. Use testEnvironment.runTests() instead.");
+}
+async function handleResetPlaywrightTests(message, connection, _state) {
+  sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, "playwright.reset() has been removed. Use testEnvironment.reset() instead.");
+}
 async function handleGetCollectedData(message, connection, state) {
   const instance = state.isolates.get(message.isolateId);
   if (!instance) {
@@ -559,13 +1465,13 @@ async function handleGetCollectedData(message, connection, state) {
     return;
   }
   if (!instance.playwrightHandle) {
-    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, "Playwright not set up for this isolate");
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, "Playwright not configured. Provide playwright.page in createRuntime options.");
     return;
   }
   instance.lastActivity = Date.now();
   try {
     const data = {
-      consoleLogs: instance.playwrightHandle.getConsoleLogs(),
+      browserConsoleLogs: instance.playwrightHandle.getBrowserConsoleLogs(),
       networkRequests: instance.playwrightHandle.getNetworkRequests(),
       networkResponses: instance.playwrightHandle.getNetworkResponses()
     };
@@ -575,6 +1481,25 @@ async function handleGetCollectedData(message, connection, state) {
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
+async function handleClearCollectedData(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  if (!instance.playwrightHandle) {
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, "Playwright not configured. Provide playwright.page in createRuntime options.");
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    instance.playwrightHandle.clearCollected();
+    sendOk(connection.socket, message.requestId);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
 })
 
-//# debugId=2FA1AEE5C513B77464756E2164756E21
+//# debugId=A7BAC1A3990C35CA64756E2164756E21