@ricsam/isolate-daemon 0.1.13 → 0.1.15

package/dist/cjs/connection.cjs

@@ -1,20 +1,7 @@
-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;
@@ -46,14 +33,31 @@ __export(exports_connection, {
 });
 module.exports = __toCommonJS(exports_connection);
 var import_node_crypto = require("node:crypto");
-var import_node_path = __toESM(require("node:path"));
-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_isolate_runtime = require("@ricsam/isolate-runtime");
-var import_isolate_transform = require("@ricsam/isolate-transform");
+var LINKER_CONFLICT_ERROR = "Module is currently being linked by another linker";
+function getErrorText(error) {
+  if (error instanceof Error) {
+    const cause = error.cause;
+    const causeText = cause instanceof Error ? `${cause.name}: ${cause.message}
+${cause.stack ?? ""}` : cause != null ? String(cause) : "";
+    return [error.name, error.message, error.stack, causeText].filter((part) => part != null && part !== "").join(`
+`);
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error ?? "");
+  }
+}
+function isLinkerConflictError(error) {
+  const text = getErrorText(error).toLowerCase();
+  return text.includes(LINKER_CONFLICT_ERROR.toLowerCase());
+}
 function handleConnection(socket, state) {
   const connection = {
     socket,
@@ -86,22 +90,17 @@ function handleConnection(socket, state) {
       const instance = state.isolates.get(isolateId);
       if (instance) {
         if (instance.namespaceId != null && !instance.isDisposed) {
-          softDeleteRuntime(instance, state);
+          if (instance.isPoisoned) {
+            hardDeleteRuntime(instance, state).catch(() => {});
+          } else {
+            softDeleteRuntime(instance, state);
+          }
         } else if (!instance.isDisposed) {
-          try {
-            if (instance.playwrightHandle) {
-              instance.playwrightHandle.dispose();
-            }
-            instance.runtime.dispose();
-          } catch {}
-          state.isolates.delete(isolateId);
+          hardDeleteRuntime(instance, state).catch(() => {});
         }
       }
     }
     for (const [, pending] of connection.pendingCallbacks) {
-      if (pending.timeoutId) {
-        clearTimeout(pending.timeoutId);
-      }
       pending.reject(new Error("Connection closed"));
     }
     connection.pendingCallbacks.clear();
@@ -199,12 +198,6 @@ async function handleMessage(message, connection, state) {
     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);
-      break;
-    case import_isolate_protocol.MessageType.RESET_PLAYWRIGHT_TESTS:
-      await handleResetPlaywrightTests(message, connection, state);
-      break;
     case import_isolate_protocol.MessageType.GET_COLLECTED_DATA:
       await handleGetCollectedData(message, connection, state);
       break;
@@ -235,34 +228,69 @@ async function handleMessage(message, connection, state) {
     case import_isolate_protocol.MessageType.CALLBACK_STREAM_END:
       handleCallbackStreamEnd(message, connection);
       break;
+    case import_isolate_protocol.MessageType.CLIENT_EVENT:
+      handleClientEvent(message, connection, state);
+      break;
     default:
       sendError(connection.socket, message.requestId ?? 0, import_isolate_protocol.ErrorCode.UNKNOWN_MESSAGE_TYPE, `Unknown message type: ${message.type}`);
   }
 }
+async function hardDeleteRuntime(instance, state) {
+  try {
+    await instance.runtime.dispose();
+  } finally {
+    state.isolates.delete(instance.isolateId);
+    if (instance.namespaceId != null) {
+      const indexed = state.namespacedRuntimes.get(instance.namespaceId);
+      if (indexed?.isolateId === instance.isolateId) {
+        state.namespacedRuntimes.delete(instance.namespaceId);
+      }
+    }
+    instance.isDisposed = true;
+    instance.disposedAt = undefined;
+    instance.ownerConnection = null;
+    if (instance.callbackContext) {
+      instance.callbackContext.connection = null;
+    }
+  }
+}
 function softDeleteRuntime(instance, state) {
   instance.isDisposed = true;
   instance.disposedAt = Date.now();
   instance.ownerConnection = null;
+  if (instance.callbackContext) {
+    instance.callbackContext.connection = null;
+  }
   instance.callbacks.clear();
   instance.runtime.timers.clearAll();
   instance.runtime.console.reset();
-  instance.pendingCallbacks.length = 0;
+  instance.runtime.pendingCallbacks.length = 0;
   instance.returnedCallbacks?.clear();
   instance.returnedPromises?.clear();
   instance.returnedIterators?.clear();
+  instance.runtime.clearModuleCache();
 }
 function reuseNamespacedRuntime(instance, connection, message, state) {
   instance.ownerConnection = connection.socket;
   instance.isDisposed = false;
+  instance.isPoisoned = false;
   instance.disposedAt = undefined;
   instance.lastActivity = Date.now();
   connection.isolates.add(instance.isolateId);
   const callbacks = message.options.callbacks;
+  const testEnvOptions = message.options.testEnvironment != null && typeof message.options.testEnvironment === "object" ? message.options.testEnvironment : undefined;
   if (instance.callbackContext) {
     instance.callbackContext.connection = connection;
     instance.callbackContext.consoleOnEntry = callbacks?.console?.onEntry?.callbackId;
     instance.callbackContext.fetch = callbacks?.fetch?.callbackId;
     instance.callbackContext.moduleLoader = callbacks?.moduleLoader?.callbackId;
+    instance.callbackContext.testEnvironmentOnEvent = testEnvOptions?.callbacks?.onEvent?.callbackId;
+    instance.callbackContext.playwright = {
+      handlerCallbackId: callbacks?.playwright?.handlerCallbackId,
+      onBrowserConsoleLogCallbackId: callbacks?.playwright?.onBrowserConsoleLogCallbackId,
+      onNetworkRequestCallbackId: callbacks?.playwright?.onNetworkRequestCallbackId,
+      onNetworkResponseCallbackId: callbacks?.playwright?.onNetworkResponseCallbackId
+    };
     instance.callbackContext.fs = {
       readFile: callbacks?.fs?.readFile?.callbackId,
       writeFile: callbacks?.fs?.writeFile?.callbackId,
@@ -299,7 +327,6 @@ function reuseNamespacedRuntime(instance, connection, message, state) {
     }
   }
   if (callbacks?.moduleLoader) {
-    instance.moduleLoaderCallbackId = callbacks.moduleLoader.callbackId;
     instance.callbacks.set(callbacks.moduleLoader.callbackId, callbacks.moduleLoader);
   }
   if (callbacks?.custom) {
@@ -309,23 +336,46 @@ function reuseNamespacedRuntime(instance, connection, message, state) {
       }
     }
   }
+  if (testEnvOptions?.callbacks?.onEvent) {
+    instance.callbacks.set(testEnvOptions.callbacks.onEvent.callbackId, {
+      ...testEnvOptions.callbacks.onEvent,
+      name: "testEnvironment.onEvent"
+    });
+  }
+  if (callbacks?.playwright) {
+    instance.callbacks.set(callbacks.playwright.handlerCallbackId, {
+      callbackId: callbacks.playwright.handlerCallbackId,
+      name: "playwright.handler",
+      type: "async"
+    });
+    if (callbacks.playwright.onBrowserConsoleLogCallbackId !== undefined) {
+      instance.callbacks.set(callbacks.playwright.onBrowserConsoleLogCallbackId, {
+        callbackId: callbacks.playwright.onBrowserConsoleLogCallbackId,
+        name: "playwright.onBrowserConsoleLog",
+        type: "sync"
+      });
+    }
+    if (callbacks.playwright.onNetworkRequestCallbackId !== undefined) {
+      instance.callbacks.set(callbacks.playwright.onNetworkRequestCallbackId, {
+        callbackId: callbacks.playwright.onNetworkRequestCallbackId,
+        name: "playwright.onNetworkRequest",
+        type: "sync"
+      });
+    }
+    if (callbacks.playwright.onNetworkResponseCallbackId !== undefined) {
+      instance.callbacks.set(callbacks.playwright.onNetworkResponseCallbackId, {
+        callbackId: callbacks.playwright.onNetworkResponseCallbackId,
+        name: "playwright.onNetworkResponse",
+        type: "sync"
+      });
+    }
+  }
   instance.returnedCallbacks = new Map;
   instance.returnedPromises = new Map;
   instance.returnedIterators = new Map;
   instance.nextLocalCallbackId = 1e6;
-  if (callbacks?.custom) {
-    const newCallbackIdMap = {};
-    for (const [name, reg] of Object.entries(callbacks.custom)) {
-      if (reg) {
-        newCallbackIdMap[name] = reg.callbackId;
-      }
-    }
-    try {
-      instance.runtime.context.global.setSync("__customFnCallbackIds", new import_isolated_vm.default.ExternalCopy(newCallbackIdMap).copyInto());
-    } catch {}
-  }
 }
-function evictOldestDisposedRuntime(state) {
+async function evictOldestDisposedRuntime(state) {
   let oldest = null;
   let oldestTime = Infinity;
   for (const [, instance] of state.isolates) {
@@ -338,21 +388,15 @@ function evictOldestDisposedRuntime(state) {
   }
   if (oldest) {
     try {
-      if (oldest.playwrightHandle) {
-        oldest.playwrightHandle.dispose();
-      }
-      oldest.runtime.dispose();
+      await hardDeleteRuntime(oldest, state);
     } catch {}
-    state.isolates.delete(oldest.isolateId);
-    if (oldest.namespaceId != null) {
-      state.namespacedRuntimes.delete(oldest.namespaceId);
-    }
     return true;
   }
   return false;
 }
 async function handleCreateRuntime(message, connection, state) {
   const namespaceId = message.options.namespaceId;
+  let namespaceCreationLocked = false;
   if (namespaceId != null) {
     const existing = state.namespacedRuntimes.get(namespaceId);
     if (existing) {
@@ -374,26 +418,38 @@ async function handleCreateRuntime(message, connection, state) {
       });
       return;
     }
-  }
-  if (state.isolates.size >= state.options.maxIsolates) {
-    if (!evictOldestDisposedRuntime(state)) {
-      sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_MEMORY_LIMIT, `Maximum isolates (${state.options.maxIsolates}) reached`);
+    if (state.namespacedCreatesInFlight.has(namespaceId)) {
+      sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, `Namespace "${namespaceId}" creation already in progress`);
       return;
     }
+    state.namespacedCreatesInFlight.add(namespaceId);
+    namespaceCreationLocked = true;
   }
   try {
+    if (state.isolates.size >= state.options.maxIsolates) {
+      if (!await evictOldestDisposedRuntime(state)) {
+        sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_MEMORY_LIMIT, `Maximum isolates (${state.options.maxIsolates}) reached`);
+        return;
+      }
+    }
     const isolateId = import_node_crypto.randomUUID();
     const consoleCallbacks = message.options.callbacks?.console;
     const fetchCallback = message.options.callbacks?.fetch;
     const fsCallbacks = message.options.callbacks?.fs;
     const moduleLoaderCallback = message.options.callbacks?.moduleLoader;
     const customCallbacks = message.options.callbacks?.custom;
-    const pendingCallbacks = [];
     const callbackContext = {
       connection,
       consoleOnEntry: consoleCallbacks?.onEntry?.callbackId,
       fetch: fetchCallback?.callbackId,
       moduleLoader: moduleLoaderCallback?.callbackId,
+      testEnvironmentOnEvent: message.options.testEnvironment != null && typeof message.options.testEnvironment === "object" ? message.options.testEnvironment.callbacks?.onEvent?.callbackId : undefined,
+      playwright: {
+        handlerCallbackId: message.options.callbacks?.playwright?.handlerCallbackId,
+        onBrowserConsoleLogCallbackId: message.options.callbacks?.playwright?.onBrowserConsoleLogCallbackId,
+        onNetworkRequestCallbackId: message.options.callbacks?.playwright?.onNetworkRequestCallbackId,
+        onNetworkResponseCallbackId: message.options.callbacks?.playwright?.onNetworkResponseCallbackId
+      },
       fs: {
         readFile: fsCallbacks?.readFile?.callbackId,
         writeFile: fsCallbacks?.writeFile?.callbackId,
@@ -405,7 +461,247 @@ async function handleCreateRuntime(message, connection, state) {
       },
       custom: new Map(customCallbacks ? Object.entries(customCallbacks).map(([name, reg]) => [name, reg.callbackId]) : [])
     };
-    const runtime = await import_isolate_runtime.createInternalRuntime({
+    const instance = {
+      isolateId,
+      runtime: null,
+      ownerConnection: connection.socket,
+      callbacks: new Map,
+      createdAt: Date.now(),
+      lastActivity: Date.now(),
+      returnedCallbacks: new Map,
+      returnedPromises: new Map,
+      returnedIterators: new Map,
+      nextLocalCallbackId: 1e6,
+      namespaceId,
+      isDisposed: false,
+      isPoisoned: false,
+      callbackContext
+    };
+    let bridgedCustomFunctions;
+    let customFnMarshalOptions;
+    if (customCallbacks) {
+      const createMarshalContext = () => ({
+        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;
+        }
+      });
+      const addCallbackIdsToRefs = (value) => {
+        if (value === null || typeof value !== "object")
+          return value;
+        if (import_isolate_protocol.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 (import_isolate_protocol.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 LOCAL_CALLBACK_THRESHOLD = 1e6;
+      const invokeCallback = async (callbackId, args) => {
+        if (callbackId >= LOCAL_CALLBACK_THRESHOLD) {
+          const callback = instance.returnedCallbacks.get(callbackId);
+          if (!callback) {
+            throw new Error(`Local callback ${callbackId} not found`);
+          }
+          return await callback(...args);
+        } else {
+          const conn = callbackContext.connection;
+          if (!conn) {
+            throw new Error(`No connection available for callback ${callbackId}`);
+          }
+          return invokeClientCallback(conn, callbackId, args);
+        }
+      };
+      customFnMarshalOptions = { createMarshalContext, addCallbackIdsToRefs, invokeCallback };
+      bridgedCustomFunctions = {};
+      for (const [name, registration] of Object.entries(customCallbacks)) {
+        if (name.includes(":"))
+          continue;
+        const callbackContext_ = callbackContext;
+        if (registration.type === "asyncIterator") {
+          bridgedCustomFunctions[name] = {
+            type: "asyncIterator",
+            fn: (...args) => {
+              const startCallbackId = callbackContext_.custom.get(`${name}:start`);
+              const nextCallbackId = callbackContext_.custom.get(`${name}:next`);
+              const returnCallbackId = callbackContext_.custom.get(`${name}:return`);
+              async function* bridgedIterator() {
+                const conn = callbackContext_.connection;
+                if (!conn || startCallbackId === undefined) {
+                  throw new Error(`AsyncIterator callback '${name}' not available`);
+                }
+                const startResult = await invokeClientCallback(conn, startCallbackId, args);
+                const iteratorId = startResult.iteratorId;
+                try {
+                  while (true) {
+                    const nextConn = callbackContext_.connection;
+                    if (!nextConn || nextCallbackId === undefined) {
+                      throw new Error(`AsyncIterator callback '${name}' not available`);
+                    }
+                    const nextResult = await invokeClientCallback(nextConn, nextCallbackId, [iteratorId]);
+                    if (nextResult.done)
+                      return nextResult.value;
+                    yield nextResult.value;
+                  }
+                } finally {
+                  const retConn = callbackContext_.connection;
+                  if (retConn && returnCallbackId !== undefined) {
+                    await invokeClientCallback(retConn, returnCallbackId, [iteratorId]).catch(() => {});
+                  }
+                }
+              }
+              return bridgedIterator();
+            }
+          };
+        } else {
+          bridgedCustomFunctions[name] = {
+            type: registration.type,
+            fn: async (...args) => {
+              const conn = callbackContext_.connection;
+              const cbId = callbackContext_.custom.get(name);
+              if (!conn || cbId === undefined) {
+                throw new Error(`Custom function callback '${name}' not available`);
+              }
+              return invokeClientCallback(conn, cbId, args);
+            }
+          };
+        }
+      }
+    }
+    let moduleLoader;
+    if (moduleLoaderCallback) {
+      moduleLoader = async (specifier, importer) => {
+        const conn = callbackContext.connection;
+        const cbId = callbackContext.moduleLoader;
+        if (!conn || cbId === undefined) {
+          throw new Error("Module loader callback not available");
+        }
+        return invokeClientCallback(conn, cbId, [specifier, importer]);
+      };
+    }
+    let testEnvironment;
+    if (message.options.testEnvironment) {
+      const testEnvOption = message.options.testEnvironment;
+      const testEnvOptions = typeof testEnvOption === "object" ? testEnvOption : undefined;
+      testEnvironment = {
+        onEvent: testEnvOptions?.callbacks?.onEvent ? (event) => {
+          const conn = callbackContext.connection;
+          const callbackId = callbackContext.testEnvironmentOnEvent;
+          if (!conn || callbackId === undefined) {
+            return;
+          }
+          const promise = invokeClientCallback(conn, callbackId, [JSON.stringify(event)]).catch(() => {});
+          instance.runtime?.pendingCallbacks?.push(promise);
+        } : undefined,
+        testTimeout: testEnvOptions?.testTimeout
+      };
+      if (testEnvOptions?.callbacks?.onEvent) {
+        instance.callbacks.set(testEnvOptions.callbacks.onEvent.callbackId, {
+          ...testEnvOptions.callbacks.onEvent,
+          name: "testEnvironment.onEvent"
+        });
+      }
+    }
+    let playwrightOptions;
+    const playwrightCallbacks = message.options.callbacks?.playwright;
+    if (playwrightCallbacks) {
+      playwrightOptions = {
+        handler: async (op) => {
+          const conn = callbackContext.connection;
+          const callbackId = callbackContext.playwright.handlerCallbackId;
+          if (!conn || callbackId === undefined) {
+            return {
+              ok: false,
+              error: {
+                name: "Error",
+                message: "Playwright handler callback not available"
+              }
+            };
+          }
+          try {
+            const resultJson = await invokeClientCallback(conn, callbackId, [JSON.stringify(op)]);
+            return JSON.parse(resultJson);
+          } catch (err) {
+            const error = err;
+            return { ok: false, error: { name: error.name, message: error.message } };
+          }
+        },
+        console: playwrightCallbacks.console,
+        onEvent: (event) => {
+          const conn = callbackContext.connection;
+          if (!conn) {
+            return;
+          }
+          if (event.type === "browserConsoleLog" && callbackContext.playwright.onBrowserConsoleLogCallbackId !== undefined) {
+            const promise = invokeClientCallback(conn, callbackContext.playwright.onBrowserConsoleLogCallbackId, [{ level: event.level, stdout: event.stdout, timestamp: event.timestamp }]).catch(() => {});
+            instance.runtime?.pendingCallbacks?.push(promise);
+          } else if (event.type === "networkRequest" && callbackContext.playwright.onNetworkRequestCallbackId !== undefined) {
+            const promise = invokeClientCallback(conn, callbackContext.playwright.onNetworkRequestCallbackId, [event]).catch(() => {});
+            instance.runtime?.pendingCallbacks?.push(promise);
+          } else if (event.type === "networkResponse" && callbackContext.playwright.onNetworkResponseCallbackId !== undefined) {
+            const promise = invokeClientCallback(conn, callbackContext.playwright.onNetworkResponseCallbackId, [event]).catch(() => {});
+            instance.runtime?.pendingCallbacks?.push(promise);
+          }
+        }
+      };
+    }
+    const runtime = await import_isolate_runtime.createRuntime({
       memoryLimitMB: message.options.memoryLimitMB ?? state.options.defaultMemoryLimitMB,
       cwd: message.options.cwd,
       console: {
@@ -415,28 +711,31 @@ async function handleCreateRuntime(message, connection, state) {
           if (!conn || callbackId === undefined)
             return;
           const promise = invokeClientCallback(conn, callbackId, [entry]).catch(() => {});
-          pendingCallbacks.push(promise);
+          runtime.pendingCallbacks.push(promise);
         }
       },
-      fetch: {
-        onFetch: async (request) => {
-          const conn = callbackContext.connection;
-          const callbackId = callbackContext.fetch;
-          if (!conn || callbackId === undefined) {
-            throw new Error("Fetch callback not available");
-          }
-          const serialized = await serializeRequest(request);
-          const result = await invokeClientCallback(conn, callbackId, [serialized], 60000);
-          if (result && typeof result === "object" && result.__streamingResponse) {
-            const response = result.response;
-            response.__isCallbackStream = true;
-            return response;
-          }
-          return deserializeResponse(result);
+      fetch: async (url, init) => {
+        const conn = callbackContext.connection;
+        const callbackId = callbackContext.fetch;
+        if (!conn || callbackId === undefined) {
+          throw new Error("Fetch callback not available");
         }
+        const serialized = {
+          url,
+          method: init.method,
+          headers: init.headers,
+          body: init.rawBody
+        };
+        const result = await invokeClientCallback(conn, callbackId, [serialized]);
+        if (result && typeof result === "object" && result.__streamingResponse) {
+          const response = result.response;
+          response.__isCallbackStream = true;
+          return response;
+        }
+        return import_isolate_protocol.deserializeResponse(result);
       },
       fs: {
-        getDirectory: async (path2) => {
+        getDirectory: async (dirPath) => {
           const conn = callbackContext.connection;
           if (!conn) {
             throw new Error("FS callbacks not available");
@@ -445,35 +744,17 @@ async function handleCreateRuntime(message, connection, state) {
             connection: conn,
             callbackContext,
             invokeClientCallback,
-            basePath: path2
+            basePath: dirPath
           });
         }
-      }
+      },
+      moduleLoader,
+      customFunctions: bridgedCustomFunctions,
+      customFunctionsMarshalOptions: customFnMarshalOptions,
+      testEnvironment,
+      playwright: playwrightOptions
     });
-    const instance = {
-      isolateId,
-      runtime,
-      ownerConnection: connection.socket,
-      callbacks: new Map,
-      createdAt: Date.now(),
-      lastActivity: Date.now(),
-      pendingCallbacks,
-      returnedCallbacks: new Map,
-      returnedPromises: new Map,
-      returnedIterators: new Map,
-      nextLocalCallbackId: 1e6,
-      namespaceId,
-      isDisposed: false,
-      callbackContext
-    };
-    if (moduleLoaderCallback) {
-      instance.moduleLoaderCallbackId = moduleLoaderCallback.callbackId;
-      instance.moduleCache = new Map;
-      instance.moduleToFilename = new Map;
-    }
-    if (customCallbacks) {
-      await setupCustomFunctions(runtime.context, customCallbacks, connection, instance);
-    }
+    instance.runtime = runtime;
     if (consoleCallbacks?.onEntry) {
       instance.callbacks.set(consoleCallbacks.onEntry.callbackId, {
         ...consoleCallbacks.onEntry,
@@ -500,52 +781,33 @@ async function handleCreateRuntime(message, connection, state) {
         }
       }
     }
-    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
+    if (playwrightCallbacks) {
+      instance.callbacks.set(playwrightCallbacks.handlerCallbackId, {
+        callbackId: playwrightCallbacks.handlerCallbackId,
+        name: "playwright.handler",
+        type: "async"
       });
-      instance.testEnvironmentEnabled = true;
-      if (onEventCallback) {
-        instance.callbacks.set(onEventCallback.callbackId, {
-          ...onEventCallback,
-          name: "testEnvironment.onEvent"
+      if (playwrightCallbacks.onBrowserConsoleLogCallbackId !== undefined) {
+        instance.callbacks.set(playwrightCallbacks.onBrowserConsoleLogCallbackId, {
+          callbackId: playwrightCallbacks.onBrowserConsoleLogCallbackId,
+          name: "playwright.onBrowserConsoleLog",
+          type: "sync"
+        });
+      }
+      if (playwrightCallbacks.onNetworkRequestCallbackId !== undefined) {
+        instance.callbacks.set(playwrightCallbacks.onNetworkRequestCallbackId, {
+          callbackId: playwrightCallbacks.onNetworkRequestCallbackId,
+          name: "playwright.onNetworkRequest",
+          type: "sync"
+        });
+      }
+      if (playwrightCallbacks.onNetworkResponseCallbackId !== undefined) {
+        instance.callbacks.set(playwrightCallbacks.onNetworkResponseCallbackId, {
+          callbackId: playwrightCallbacks.onNetworkResponseCallbackId,
+          name: "playwright.onNetworkResponse",
+          type: "sync"
         });
       }
-    }
-    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, stdout: event.stdout, 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);
@@ -553,30 +815,99 @@ async function handleCreateRuntime(message, connection, state) {
     if (namespaceId != null) {
       state.namespacedRuntimes.set(namespaceId, instance);
     }
-    instance.runtime.fetch.onWebSocketCommand((cmd) => {
+    runtime.fetch.onWebSocketCommand((cmd) => {
+      const targetConnection = callbackContext.connection;
+      if (!targetConnection) {
+        return;
+      }
       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,
+      const payload = {
+        type: cmd.type,
+        connectionId: cmd.connectionId,
+        data,
+        code: cmd.code,
+        reason: cmd.reason
+      };
+      sendMessage(targetConnection.socket, {
+        type: import_isolate_protocol.MessageType.ISOLATE_EVENT,
         isolateId,
-        command: {
-          type: cmd.type,
-          connectionId: cmd.connectionId,
-          data,
+        event: import_isolate_protocol.IsolateEvents.WS_COMMAND,
+        payload
+      });
+    });
+    runtime.fetch.onClientWebSocketCommand((cmd) => {
+      const targetConnection = callbackContext.connection;
+      if (!targetConnection) {
+        return;
+      }
+      let data;
+      if (cmd.data instanceof ArrayBuffer) {
+        data = new Uint8Array(cmd.data);
+      } else {
+        data = cmd.data;
+      }
+      if (cmd.type === "connect") {
+        const payload = {
+          socketId: cmd.socketId,
+          url: cmd.url,
+          protocols: cmd.protocols
+        };
+        sendMessage(targetConnection.socket, {
+          type: import_isolate_protocol.MessageType.ISOLATE_EVENT,
+          isolateId,
+          event: import_isolate_protocol.IsolateEvents.WS_CLIENT_CONNECT,
+          payload
+        });
+      } else if (cmd.type === "send") {
+        const payload = {
+          socketId: cmd.socketId,
+          data
+        };
+        sendMessage(targetConnection.socket, {
+          type: import_isolate_protocol.MessageType.ISOLATE_EVENT,
+          isolateId,
+          event: import_isolate_protocol.IsolateEvents.WS_CLIENT_SEND,
+          payload
+        });
+      } else if (cmd.type === "close") {
+        const payload = {
+          socketId: cmd.socketId,
           code: cmd.code,
           reason: cmd.reason
-        }
-      };
-      sendMessage(connection.socket, wsCommandMsg);
+        };
+        sendMessage(targetConnection.socket, {
+          type: import_isolate_protocol.MessageType.ISOLATE_EVENT,
+          isolateId,
+          event: import_isolate_protocol.IsolateEvents.WS_CLIENT_CLOSE,
+          payload
+        });
+      }
+    });
+    runtime.fetch.onEvent((eventName, payload) => {
+      const targetConnection = callbackContext.connection;
+      if (!targetConnection) {
+        return;
+      }
+      sendMessage(targetConnection.socket, {
+        type: import_isolate_protocol.MessageType.ISOLATE_EVENT,
+        isolateId,
+        event: eventName,
+        payload
+      });
     });
     sendOk(connection.socket, message.requestId, { isolateId, reused: false });
   } catch (err) {
     const error = err;
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  } finally {
+    if (namespaceCreationLocked && namespaceId != null) {
+      state.namespacedCreatesInFlight.delete(namespaceId);
+    }
   }
 }
 async function handleDisposeRuntime(message, connection, state) {
@@ -592,17 +923,20 @@ async function handleDisposeRuntime(message, connection, state) {
   try {
     connection.isolates.delete(message.isolateId);
     if (instance.namespaceId != null) {
-      softDeleteRuntime(instance, state);
-    } else {
-      if (instance.playwrightHandle) {
-        instance.playwrightHandle.dispose();
+      if (instance.isPoisoned) {
+        await hardDeleteRuntime(instance, state);
+      } else {
+        softDeleteRuntime(instance, state);
       }
-      instance.runtime.dispose();
-      state.isolates.delete(message.isolateId);
+    } else {
+      await hardDeleteRuntime(instance, state);
     }
     sendOk(connection.socket, message.requestId);
   } catch (err) {
     const error = err;
+    if (instance.namespaceId != null && isLinkerConflictError(error)) {
+      instance.isPoisoned = true;
+    }
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
@@ -614,47 +948,16 @@ async function handleEval(message, connection, state) {
   }
   instance.lastActivity = Date.now();
   try {
-    const filename = import_isolate_protocol.normalizeEntryFilename(message.filename);
-    const transformed = await import_isolate_transform.transformEntryCode(message.code, filename);
-    if (transformed.sourceMap) {
-      if (!instance.sourceMaps) {
-        instance.sourceMaps = new Map;
-      }
-      instance.sourceMaps.set(filename, transformed.sourceMap);
-    }
-    const mod = await instance.runtime.isolate.compileModule(transformed.code, {
-      filename
+    await instance.runtime.eval(message.code, {
+      filename: message.filename
     });
-    if (instance.moduleLoaderCallbackId) {
-      instance.moduleToFilename?.set(mod, filename);
-      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}`);
-      });
-    }
-    await mod.evaluate();
-    const ns = mod.namespace;
-    const runRef = await ns.get("default", { reference: true });
-    try {
-      await runRef.apply(undefined, [], {
-        result: { promise: true },
-        ...message.maxExecutionMs ? { timeout: message.maxExecutionMs } : {}
-      });
-    } finally {
-      runRef.release();
-    }
-    await Promise.all(instance.pendingCallbacks);
-    instance.pendingCallbacks.length = 0;
     sendOk(connection.socket, message.requestId, { value: undefined });
   } catch (err) {
     const error = err;
-    if (error.stack && instance.sourceMaps?.size) {
-      error.stack = import_isolate_transform.mapErrorStack(error.stack, instance.sourceMaps);
+    if (instance.namespaceId != null && isLinkerConflictError(error)) {
+      instance.isPoisoned = true;
     }
-    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 });
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
 async function handleDispatchRequest(message, connection, state) {
@@ -762,6 +1065,39 @@ async function handleWsClose(message, connection, state) {
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
+function handleClientEvent(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance)
+    return;
+  instance.lastActivity = Date.now();
+  switch (message.event) {
+    case import_isolate_protocol.ClientEvents.WS_CLIENT_OPENED: {
+      const payload = message.payload;
+      instance.runtime.fetch.dispatchClientWebSocketOpen(payload.socketId, payload.protocol, payload.extensions);
+      break;
+    }
+    case import_isolate_protocol.ClientEvents.WS_CLIENT_MESSAGE: {
+      const payload = message.payload;
+      const data = payload.data instanceof Uint8Array ? payload.data.buffer.slice(payload.data.byteOffset, payload.data.byteOffset + payload.data.byteLength) : payload.data;
+      instance.runtime.fetch.dispatchClientWebSocketMessage(payload.socketId, data);
+      break;
+    }
+    case import_isolate_protocol.ClientEvents.WS_CLIENT_CLOSED: {
+      const payload = message.payload;
+      instance.runtime.fetch.dispatchClientWebSocketClose(payload.socketId, payload.code, payload.reason, payload.wasClean);
+      break;
+    }
+    case import_isolate_protocol.ClientEvents.WS_CLIENT_ERROR: {
+      const payload = message.payload;
+      instance.runtime.fetch.dispatchClientWebSocketError(payload.socketId);
+      break;
+    }
+    default: {
+      instance.runtime.fetch.dispatchEvent(message.event, message.payload);
+      break;
+    }
+  }
+}
 async function handleFetchGetUpgradeRequest(message, connection, state) {
   const instance = state.isolates.get(message.isolateId);
   if (!instance) {
@@ -904,9 +1240,6 @@ function handleCallbackResponse(message, connection) {
     return;
   }
   connection.pendingCallbacks.delete(message.requestId);
-  if (pending.timeoutId) {
-    clearTimeout(pending.timeoutId);
-  }
   if (message.error) {
     const error = new Error(message.error.message);
     error.name = message.error.name;
@@ -918,17 +1251,12 @@ function handleCallbackResponse(message, connection) {
     pending.resolve(message.result);
   }
 }
-async function invokeClientCallback(connection, callbackId, args, timeout = 1e4) {
+async function invokeClientCallback(connection, callbackId, args) {
   const requestId = connection.nextCallbackId++;
   return new Promise((resolve, reject) => {
-    const timeoutId = setTimeout(() => {
-      connection.pendingCallbacks.delete(requestId);
-      reject(new Error("Callback timeout"));
-    }, timeout);
     const pending = {
       resolve,
-      reject,
-      timeoutId
+      reject
     };
     connection.pendingCallbacks.set(requestId, pending);
     const invoke = {
@@ -940,530 +1268,6 @@ async function invokeClientCallback(connection, callbackId, args, timeout = 1e4)
     sendMessage(connection.socket, invoke);
   });
 }
-var ISOLATE_MARSHAL_CODE = `
-(function() {
-  // Marshal a value (JavaScript → 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 → 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 {
-        const conn = instance.callbackContext?.connection || connection;
-        result = await invokeClientCallback(conn, 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);
-  const callbackIdMap = {};
-  for (const [name, registration] of Object.entries(customCallbacks)) {
-    callbackIdMap[name] = registration.callbackId;
-  }
-  global.setSync("__customFnCallbackIds", new import_isolated_vm.default.ExternalCopy(callbackIdMap).copyInto());
-  for (const [name, registration] of Object.entries(customCallbacks)) {
-    if (name.includes(":")) {
-      continue;
-    }
-    if (registration.type === "sync") {
-      context.evalSync(`
-        globalThis.${name} = function(...args) {
-          const callbackId = globalThis.__customFnCallbackIds["${name}"];
-          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;
-          }
-        };
-      `);
-    } 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 startCallbackId = globalThis.__customFnCallbackIds["${name}:start"];
-          const argsJson = JSON.stringify(__marshalForHost(args));
-          const startResultJson = __customFn_invoke.applySyncPromise(
-            undefined,
-            [startCallbackId, 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 nextCallbackId = globalThis.__customFnCallbackIds["${name}:next"];
-              const argsJson = JSON.stringify(__marshalForHost([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;
-              }
-              const val = __unmarshalFromHost(result.value);
-              return { done: val.done, value: val.value };
-            },
-            async return(v) {
-              const returnCallbackId = globalThis.__customFnCallbackIds["${name}:return"];
-              const argsJson = JSON.stringify(__marshalForHost([iteratorId, v]));
-              const resultJson = __customFn_invoke.applySyncPromise(
-                undefined,
-                [returnCallbackId, argsJson]
-              );
-              const result = JSON.parse(resultJson);
-              return { done: true, value: result.ok ? __unmarshalFromHost(result.value) : undefined };
-            },
-            async throw(e) {
-              const throwCallbackId = globalThis.__customFnCallbackIds["${name}:throw"];
-              const argsJson = JSON.stringify(__marshalForHost([iteratorId, { message: e?.message, name: e?.name }]));
-              const resultJson = __customFn_invoke.applySyncPromise(
-                undefined,
-                [throwCallbackId, 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 callbackId = globalThis.__customFnCallbackIds["${name}"];
-          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;
-          }
-        };
-      `);
-    }
-  }
-}
-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 importerPath = instance.moduleToFilename?.get(referrer) ?? "<unknown>";
-    const importerResolveDir = import_node_path.default.posix.dirname(importerPath);
-    const result = await invokeClientCallback(connection, instance.moduleLoaderCallbackId, [specifier, { path: importerPath, resolveDir: importerResolveDir }]);
-    const { code, resolveDir } = result;
-    const hash = import_isolate_transform.contentHash(code);
-    const cacheKey = `${specifier}:${hash}`;
-    const hashCached = instance.moduleCache?.get(cacheKey);
-    if (hashCached)
-      return hashCached;
-    const transformed = await import_isolate_transform.transformModuleCode(code, specifier);
-    if (transformed.sourceMap) {
-      if (!instance.sourceMaps) {
-        instance.sourceMaps = new Map;
-      }
-      instance.sourceMaps.set(specifier, transformed.sourceMap);
-    }
-    const mod = await instance.runtime.isolate.compileModule(transformed.code, {
-      filename: specifier
-    });
-    const resolvedPath = import_node_path.default.posix.join(resolveDir, import_node_path.default.posix.basename(specifier));
-    instance.moduleToFilename?.set(mod, resolvedPath);
-    const resolver = createModuleResolver(instance, connection);
-    await mod.instantiate(instance.runtime.context, resolver);
-    instance.moduleCache?.set(specifier, mod);
-    instance.moduleCache?.set(cacheKey, mod);
-    return mod;
-  };
-}
-async function serializeRequest(request) {
-  const headers = [];
-  request.headers.forEach((value, key) => {
-    headers.push([key, value]);
-  });
-  let body = null;
-  if (request.body) {
-    body = new Uint8Array(await request.arrayBuffer());
-  }
-  return {
-    method: request.method,
-    url: request.url,
-    headers,
-    body
-  };
-}
-function deserializeResponse(data) {
-  return new Response(data.body, {
-    status: data.status,
-    statusText: data.statusText,
-    headers: data.headers
-  });
-}
 function handleStreamPush(message, connection) {
   const receiver = connection.streamReceivers.get(message.streamId);
   if (!receiver) {
@@ -1591,9 +1395,6 @@ function handleCallbackStreamStart(message, connection) {
   const pending = connection.pendingCallbacks.get(message.requestId);
   if (pending) {
     connection.pendingCallbacks.delete(message.requestId);
-    if (pending.timeoutId) {
-      clearTimeout(pending.timeoutId);
-    }
     const response = new Response(readableStream, {
       status: message.metadata.status,
       statusText: message.metadata.statusText,
@@ -1723,28 +1524,11 @@ 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;
-    let timeoutId;
-    const timeoutPromise = new Promise((_, reject) => {
-      timeoutId = setTimeout(() => reject(new Error("Test timeout")), timeout);
-    });
-    try {
-      const results = await Promise.race([
-        import_isolate_test_environment.runTests(instance.runtime.context),
-        timeoutPromise
-      ]);
-      sendOk(connection.socket, message.requestId, results);
-    } finally {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-    }
+    const results = await instance.runtime.testEnvironment.runTests(timeout);
+    sendOk(connection.socket, message.requestId, results);
   } catch (err) {
     const error = err;
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
@@ -1756,13 +1540,9 @@ async function handleResetTestEnv(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 {
-    await instance.runtime.context.eval("__resetTestEnvironment()", { promise: true });
+    instance.runtime.testEnvironment.reset();
     sendOk(connection.socket, message.requestId);
   } catch (err) {
     const error = err;
@@ -1775,13 +1555,9 @@ async function handleHasTests(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 result = import_isolate_test_environment.hasTests(instance.runtime.context);
+    const result = instance.runtime.testEnvironment.hasTests();
     sendOk(connection.socket, message.requestId, result);
   } catch (err) {
     const error = err;
@@ -1794,42 +1570,24 @@ async function handleGetTestCount(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 result = import_isolate_test_environment.getTestCount(instance.runtime.context);
+    const result = instance.runtime.testEnvironment.getTestCount();
     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) {
     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 {
-    const data = {
-      browserConsoleLogs: instance.playwrightHandle.getBrowserConsoleLogs(),
-      networkRequests: instance.playwrightHandle.getNetworkRequests(),
-      networkResponses: instance.playwrightHandle.getNetworkResponses()
-    };
+    const data = instance.runtime.playwright.getCollectedData();
     sendOk(connection.socket, message.requestId, data);
   } catch (err) {
     const error = err;
@@ -1842,13 +1600,9 @@ async function handleClearCollectedData(message, connection, state) {
     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();
+    instance.runtime.playwright.clearCollectedData();
     sendOk(connection.socket, message.requestId);
   } catch (err) {
     const error = err;
@@ -1856,4 +1610,4 @@ async function handleClearCollectedData(message, connection, state) {
   }
 }
 
-//# debugId=32017BAA615D918C64756E2164756E21
+//# debugId=20B12DB74E4F312D64756E2164756E21