@ricsam/isolate 0.1.10 → 0.1.12

package/dist/cjs/internal/client/connection.cjs

@@ -94,8 +94,13 @@ async function connect(options = {}) {
     callbackStreamReaders: new Map,
     activeCallbackInvocations: new Map,
     callbackAbortControllers: new Map,
+    clientIteratorSessions: new Map,
+    returnedPromiseRegistry: new Map,
+    returnedIteratorRegistry: new Map,
     closing: false,
-    namespacedRuntimes: new Map
+    namespacedRuntimes: new Map,
+    nextClientIteratorId: 1,
+    nextReturnedRefId: 1
   };
   function setupSocket(sock) {
     const parser = import_protocol.createFrameParser();
@@ -139,6 +144,9 @@ async function connect(options = {}) {
       }
       state.callbackAbortControllers.clear();
       state.activeCallbackInvocations.clear();
+      state.clientIteratorSessions.clear();
+      state.returnedPromiseRegistry.clear();
+      state.returnedIteratorRegistry.clear();
       if (!state.closing && state.namespacedRuntimes.size > 0) {
         state.reconnecting = reconnect(state, options).catch(() => {
           state.namespacedRuntimes.clear();
@@ -247,6 +255,17 @@ async function connect(options = {}) {
       id,
       createRuntime: (runtimeOptions) => createRuntime(state, runtimeOptions, id)
     }),
+    disposeNamespace: async (id, options2) => {
+      state.namespacedRuntimes.delete(id);
+      const requestId = state.nextRequestId++;
+      const request = {
+        type: import_protocol.MessageType.DISPOSE_NAMESPACE,
+        requestId,
+        namespaceId: id,
+        reason: typeof options2?.reason === "string" && options2.reason.length > 0 ? options2.reason : undefined
+      };
+      await sendRequest(state, request);
+    },
     close: async () => {
       state.closing = true;
       state.connected = false;
@@ -659,145 +678,57 @@ async function createRuntime(state, options = {}, namespaceId) {
     callbacks.custom = registerCustomFunctions(state, options.customFunctions);
   }
   let playwrightHandler;
-  const browserConsoleLogs = [];
-  const pageErrors = [];
-  const networkRequests = [];
-  const networkResponses = [];
-  const requestFailures = [];
-  const pageListenerCleanups = [];
+  let getCollectedData = () => ({
+    browserConsoleLogs: [],
+    pageErrors: [],
+    networkRequests: [],
+    networkResponses: [],
+    requestFailures: []
+  });
+  let getTrackedResources = () => ({
+    contexts: [],
+    pages: []
+  });
+  let clearCollectedData = () => {};
+  const playwrightListenerCleanups = [];
   if (normalizedPlaywrightOptions) {
     playwrightHandler = normalizedPlaywrightOptions.handler;
     if (!playwrightHandler) {
       throw new Error("playwright.handler is required when using playwright options");
     }
-    const page = import_client.getDefaultPlaywrightHandlerMetadata(playwrightHandler)?.page;
+    const handlerMetadata = import_client.getPlaywrightHandlerMetadata(playwrightHandler);
+    if (handlerMetadata) {
+      getCollectedData = () => handlerMetadata.collector.getCollectedData();
+      getTrackedResources = () => handlerMetadata.collector.getTrackedResources();
+      clearCollectedData = () => {
+        handlerMetadata.collector.clearCollectedData();
+      };
+      playwrightListenerCleanups.push(handlerMetadata.collector.onEvent((event) => {
+        if (normalizedPlaywrightOptions.onEvent) {
+          normalizedPlaywrightOptions.onEvent(event);
+        }
+        if (event.type === "browserConsoleLog") {
+          if (normalizedPlaywrightOptions.console && options.console?.onEntry) {
+            options.console.onEntry({
+              type: "browserOutput",
+              level: event.level,
+              stdout: event.stdout,
+              location: event.location,
+              timestamp: event.timestamp
+            });
+          } else if (normalizedPlaywrightOptions.console) {
+            const prefix = event.level === "error" ? "[browser:error]" : "[browser]";
+            console.log(prefix, event.stdout);
+          }
+        }
+      }));
+    }
     const handlerCallbackId = state.nextCallbackId++;
     state.callbacks.set(handlerCallbackId, async (opJson) => {
       const op = JSON.parse(opJson);
       const result2 = await playwrightHandler(op);
       return JSON.stringify(result2);
     });
-    if (page) {
-      const requestIds = new WeakMap;
-      let nextRequestId = 1;
-      const getRequestId = (request2) => {
-        let requestId2 = requestIds.get(request2);
-        if (!requestId2) {
-          requestId2 = `req_${nextRequestId++}`;
-          requestIds.set(request2, requestId2);
-        }
-        return requestId2;
-      };
-      const toLocation = (location) => {
-        if (!location || !location.url && location.lineNumber == null && location.columnNumber == null) {
-          return;
-        }
-        return {
-          url: location.url || undefined,
-          lineNumber: location.lineNumber != null ? location.lineNumber + 1 : undefined,
-          columnNumber: location.columnNumber != null ? location.columnNumber + 1 : undefined
-        };
-      };
-      const onConsole = (msg) => {
-        const entry = {
-          level: msg.type(),
-          stdout: msg.text(),
-          location: toLocation(msg.location()),
-          timestamp: Date.now()
-        };
-        browserConsoleLogs.push(entry);
-        if (normalizedPlaywrightOptions.onEvent) {
-          normalizedPlaywrightOptions.onEvent({
-            type: "browserConsoleLog",
-            ...entry
-          });
-        }
-        if (normalizedPlaywrightOptions.console && options.console?.onEntry) {
-          options.console.onEntry({
-            type: "browserOutput",
-            ...entry
-          });
-        } else if (normalizedPlaywrightOptions.console) {
-          const prefix = entry.level === "error" ? "[browser:error]" : "[browser]";
-          console.log(prefix, entry.stdout);
-        }
-      };
-      const onRequest = (request2) => {
-        const info = {
-          requestId: getRequestId(request2),
-          url: request2.url(),
-          method: request2.method(),
-          headers: request2.headers(),
-          postData: request2.postData() ?? undefined,
-          resourceType: request2.resourceType(),
-          timestamp: Date.now()
-        };
-        networkRequests.push(info);
-        if (normalizedPlaywrightOptions.onEvent) {
-          normalizedPlaywrightOptions.onEvent({
-            type: "networkRequest",
-            ...info
-          });
-        }
-      };
-      const onResponse = (response) => {
-        const request2 = response.request();
-        const info = {
-          requestId: getRequestId(request2),
-          url: response.url(),
-          status: response.status(),
-          statusText: response.statusText(),
-          headers: response.headers(),
-          resourceType: request2.resourceType(),
-          timestamp: Date.now()
-        };
-        networkResponses.push(info);
-        if (normalizedPlaywrightOptions.onEvent) {
-          normalizedPlaywrightOptions.onEvent({
-            type: "networkResponse",
-            ...info
-          });
-        }
-      };
-      const onRequestFailed = (request2) => {
-        const info = {
-          requestId: getRequestId(request2),
-          url: request2.url(),
-          method: request2.method(),
-          failureText: request2.failure()?.errorText || "request failed",
-          resourceType: request2.resourceType(),
-          timestamp: Date.now()
-        };
-        requestFailures.push(info);
-        if (normalizedPlaywrightOptions.onEvent) {
-          normalizedPlaywrightOptions.onEvent({
-            type: "requestFailure",
-            ...info
-          });
-        }
-      };
-      const onPageError = (error) => {
-        const entry = {
-          name: error.name,
-          message: error.message,
-          stack: error.stack,
-          timestamp: Date.now()
-        };
-        pageErrors.push(entry);
-        if (normalizedPlaywrightOptions.onEvent) {
-          normalizedPlaywrightOptions.onEvent({
-            type: "pageError",
-            ...entry
-          });
-        }
-      };
-      page.on("console", onConsole);
-      page.on("request", onRequest);
-      page.on("response", onResponse);
-      page.on("requestfailed", onRequestFailed);
-      page.on("pageerror", onPageError);
-      pageListenerCleanups.push(() => page.removeListener("console", onConsole), () => page.removeListener("request", onRequest), () => page.removeListener("response", onResponse), () => page.removeListener("requestfailed", onRequestFailed), () => page.removeListener("pageerror", onPageError));
-    }
     callbacks.playwright = {
       handlerCallbackId,
       console: normalizedPlaywrightOptions.console && !options.console?.onEntry
@@ -828,7 +759,10 @@ async function createRuntime(state, options = {}, namespaceId) {
       testEnvironmentOption = true;
     }
   }
-  const playwrightOption = normalizedPlaywrightOptions?.timeout !== undefined ? { timeout: normalizedPlaywrightOptions.timeout } : undefined;
+  const playwrightOption = normalizedPlaywrightOptions ? {
+    timeout: normalizedPlaywrightOptions.timeout,
+    hasDefaultPage: normalizedPlaywrightOptions.hasDefaultPage
+  } : undefined;
   const requestId = state.nextRequestId++;
   const request = {
     type: import_protocol.MessageType.CREATE_RUNTIME,
@@ -1139,23 +1073,19 @@ async function createRuntime(state, options = {}, namespaceId) {
       if (!playwrightEnabled) {
         throw new Error("Playwright not configured. Provide playwright.handler in createRuntime options.");
       }
-      return {
-        browserConsoleLogs: [...browserConsoleLogs],
-        pageErrors: [...pageErrors],
-        networkRequests: [...networkRequests],
-        networkResponses: [...networkResponses],
-        requestFailures: [...requestFailures]
-      };
+      return getCollectedData();
+    },
+    getTrackedResources() {
+      if (!playwrightEnabled) {
+        throw new Error("Playwright not configured. Provide playwright.handler in createRuntime options.");
+      }
+      return getTrackedResources();
     },
     clearCollectedData() {
       if (!playwrightEnabled) {
         throw new Error("Playwright not configured. Provide playwright.handler in createRuntime options.");
       }
-      browserConsoleLogs.length = 0;
-      pageErrors.length = 0;
-      networkRequests.length = 0;
-      networkResponses.length = 0;
-      requestFailures.length = 0;
+      clearCollectedData();
     }
   };
   return {
@@ -1210,7 +1140,7 @@ async function createRuntime(state, options = {}, namespaceId) {
       });
     },
     dispose: async (options2) => {
-      for (const cleanup of pageListenerCleanups) {
+      for (const cleanup of playwrightListenerCleanups) {
         cleanup();
       }
       isolateWsCallbacks.delete(isolateId);
@@ -1454,10 +1384,6 @@ function registerModuleLoaderCallback(state, callback) {
   });
   return { callbackId, name: "moduleLoader", type: "async" };
 }
-var clientIteratorSessions = new Map;
-var nextClientIteratorId = 1;
-var returnedPromiseRegistry = new Map;
-var returnedIteratorRegistry = new Map;
 function registerCustomFunctions(state, customFunctions) {
   const registrations = {};
   const addCallbackIdsToRefs = (value) => {
@@ -1468,12 +1394,12 @@ function registerCustomFunctions(state, customFunctions) {
       const resolveCallbackId = state.nextCallbackId++;
       state.callbacks.set(resolveCallbackId, async (...args) => {
         const promiseId = args[0];
-        const promise = returnedPromiseRegistry.get(promiseId);
+        const promise = state.returnedPromiseRegistry.get(promiseId);
         if (!promise) {
           throw new Error(`Promise ${promiseId} not found`);
         }
         const promiseResult = await promise;
-        returnedPromiseRegistry.delete(promiseId);
+        state.returnedPromiseRegistry.delete(promiseId);
         const marshalledResult = await import_protocol.marshalValue(promiseResult, marshalCtx);
         return addCallbackIdsToRefs(marshalledResult);
       });
@@ -1486,13 +1412,13 @@ function registerCustomFunctions(state, customFunctions) {
       const nextCallbackId = state.nextCallbackId++;
       state.callbacks.set(nextCallbackId, async (...args) => {
         const iteratorId = args[0];
-        const iterator = returnedIteratorRegistry.get(iteratorId);
+        const iterator = state.returnedIteratorRegistry.get(iteratorId);
         if (!iterator) {
           throw new Error(`Iterator ${iteratorId} not found`);
         }
         const iterResult = await iterator.next();
         if (iterResult.done) {
-          returnedIteratorRegistry.delete(iteratorId);
+          state.returnedIteratorRegistry.delete(iteratorId);
         }
         const marshalledValue = await import_protocol.marshalValue(iterResult.value, marshalCtx);
         return {
@@ -1504,8 +1430,8 @@ function registerCustomFunctions(state, customFunctions) {
       state.callbacks.set(returnCallbackId, async (...args) => {
         const iteratorId = args[0];
         const returnValue = args[1];
-        const iterator = returnedIteratorRegistry.get(iteratorId);
-        returnedIteratorRegistry.delete(iteratorId);
+        const iterator = state.returnedIteratorRegistry.get(iteratorId);
+        state.returnedIteratorRegistry.delete(iteratorId);
         if (!iterator || !iterator.return) {
           return { done: true, value: undefined };
         }
@@ -1520,7 +1446,7 @@ function registerCustomFunctions(state, customFunctions) {
       state.callbacks.set(throwCallbackId, async (...args) => {
         const iteratorId = args[0];
         const errorValue = args[1];
-        const iterator = returnedIteratorRegistry.get(iteratorId);
+        const iterator = state.returnedIteratorRegistry.get(iteratorId);
         if (!iterator) {
           throw new Error(`Iterator ${iteratorId} not found`);
         }
@@ -1531,7 +1457,7 @@ function registerCustomFunctions(state, customFunctions) {
           const thrownError = Object.assign(new Error(errorValue?.message ?? "Iterator throw()"), { name: errorValue?.name ?? "Error", stack: errorValue?.stack });
           const iterResult = await iterator.throw(thrownError);
           if (iterResult.done) {
-            returnedIteratorRegistry.delete(iteratorId);
+            state.returnedIteratorRegistry.delete(iteratorId);
           }
           const marshalledValue = await import_protocol.marshalValue(iterResult.value, marshalCtx);
           return {
@@ -1539,7 +1465,7 @@ function registerCustomFunctions(state, customFunctions) {
             value: addCallbackIdsToRefs(marshalledValue)
           };
         } catch (error) {
-          returnedIteratorRegistry.delete(iteratorId);
+          state.returnedIteratorRegistry.delete(iteratorId);
           throw error;
         }
       });
@@ -1570,13 +1496,13 @@ function registerCustomFunctions(state, customFunctions) {
       return returnedCallbackId;
     },
     registerPromise: (promise) => {
-      const promiseId = state.nextCallbackId++;
-      returnedPromiseRegistry.set(promiseId, promise);
+      const promiseId = state.nextReturnedRefId++;
+      state.returnedPromiseRegistry.set(promiseId, promise);
       return promiseId;
     },
     registerIterator: (iterator) => {
-      const iteratorId = state.nextCallbackId++;
-      returnedIteratorRegistry.set(iteratorId, iterator);
+      const iteratorId = state.nextReturnedRefId++;
+      state.returnedIteratorRegistry.set(iteratorId, iterator);
       return iteratorId;
     }
   };
@@ -1588,6 +1514,71 @@ function registerCustomFunctions(state, customFunctions) {
       return import_protocol.unmarshalValue(result, unmarshalCtx);
     };
   };
+  unmarshalCtx.createPromiseProxy = (promiseId, ref) => {
+    const resolveCallbackId = ref?.__resolveCallbackId;
+    if (typeof resolveCallbackId !== "number") {
+      throw new Error(`Promise ${promiseId} is missing a resolve callback`);
+    }
+    return (async () => {
+      const result = await invokeDaemonCallback(state, resolveCallbackId, [promiseId]);
+      return import_protocol.unmarshalValue(result, unmarshalCtx);
+    })();
+  };
+  unmarshalCtx.createIteratorProxy = (iteratorId, ref) => {
+    const nextCallbackId = ref?.__nextCallbackId;
+    const returnCallbackId = ref?.__returnCallbackId;
+    const throwCallbackId = ref?.__throwCallbackId;
+    if (typeof nextCallbackId !== "number") {
+      throw new Error(`Iterator ${iteratorId} is missing a next callback`);
+    }
+    const invokeIteratorCallback = async (callbackId, args, label) => {
+      const result = await invokeDaemonCallback(state, callbackId, args);
+      if (!result || typeof result !== "object" || !("done" in result)) {
+        throw new Error(`${label} returned an invalid iterator result`);
+      }
+      return result;
+    };
+    return {
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+      async next() {
+        const result = await invokeIteratorCallback(nextCallbackId, [iteratorId], "Iterator next()");
+        return {
+          done: Boolean(result.done),
+          value: import_protocol.unmarshalValue(result.value, unmarshalCtx)
+        };
+      },
+      async return(value) {
+        if (typeof returnCallbackId !== "number") {
+          return { done: true, value };
+        }
+        const result = await invokeIteratorCallback(returnCallbackId, [iteratorId, value], "Iterator return()");
+        return {
+          done: result.done ?? true,
+          value: import_protocol.unmarshalValue(result.value, unmarshalCtx)
+        };
+      },
+      async throw(errorValue) {
+        if (typeof throwCallbackId !== "number") {
+          throw errorValue;
+        }
+        const serializedError = errorValue && typeof errorValue === "object" ? {
+          message: errorValue.message,
+          name: errorValue.name,
+          stack: errorValue.stack
+        } : {
+          message: String(errorValue ?? "Iterator throw()"),
+          name: "Error"
+        };
+        const result = await invokeIteratorCallback(throwCallbackId, [iteratorId, serializedError], "Iterator throw()");
+        return {
+          done: Boolean(result.done),
+          value: import_protocol.unmarshalValue(result.value, unmarshalCtx)
+        };
+      }
+    };
+  };
   for (const [name, def] of Object.entries(customFunctions)) {
     if (def.type === "asyncIterator") {
       const startCallbackId = state.nextCallbackId++;
@@ -1595,8 +1586,8 @@ function registerCustomFunctions(state, customFunctions) {
         try {
           const fn = def.fn;
           const iterator = fn(...import_protocol.unmarshalValue(args, unmarshalCtx));
-          const iteratorId = nextClientIteratorId++;
-          clientIteratorSessions.set(iteratorId, { iterator });
+          const iteratorId = state.nextClientIteratorId++;
+          state.clientIteratorSessions.set(iteratorId, { iterator });
           return { iteratorId };
         } catch (error) {
           throw error;
@@ -1604,39 +1595,39 @@ function registerCustomFunctions(state, customFunctions) {
       });
       const nextCallbackId = state.nextCallbackId++;
       state.callbacks.set(nextCallbackId, async (iteratorId) => {
-        const session = clientIteratorSessions.get(iteratorId);
+        const session = state.clientIteratorSessions.get(iteratorId);
         if (!session) {
           throw new Error(`Iterator session ${iteratorId} not found`);
         }
         try {
           const result = await session.iterator.next();
           if (result.done) {
-            clientIteratorSessions.delete(iteratorId);
+            state.clientIteratorSessions.delete(iteratorId);
           }
           return { done: result.done, value: await import_protocol.marshalValue(result.value) };
         } catch (error) {
-          clientIteratorSessions.delete(iteratorId);
+          state.clientIteratorSessions.delete(iteratorId);
           throw error;
         }
       });
       const returnCallbackId = state.nextCallbackId++;
       state.callbacks.set(returnCallbackId, async (iteratorId, value) => {
-        const session = clientIteratorSessions.get(iteratorId);
+        const session = state.clientIteratorSessions.get(iteratorId);
         if (!session) {
           return { done: true, value: await import_protocol.marshalValue(undefined) };
         }
         try {
           const result = await session.iterator.return?.(value);
-          clientIteratorSessions.delete(iteratorId);
+          state.clientIteratorSessions.delete(iteratorId);
           return { done: true, value: await import_protocol.marshalValue(result?.value) };
         } catch (error) {
-          clientIteratorSessions.delete(iteratorId);
+          state.clientIteratorSessions.delete(iteratorId);
           throw error;
         }
       });
       const throwCallbackId = state.nextCallbackId++;
       state.callbacks.set(throwCallbackId, async (iteratorId, errorData) => {
-        const session = clientIteratorSessions.get(iteratorId);
+        const session = state.clientIteratorSessions.get(iteratorId);
         if (!session) {
           throw new Error(`Iterator session ${iteratorId} not found`);
         }
@@ -1644,10 +1635,10 @@ function registerCustomFunctions(state, customFunctions) {
           const errInfo = errorData;
           const error = Object.assign(new Error(errInfo.message), { name: errInfo.name });
           const result = await session.iterator.throw?.(error);
-          clientIteratorSessions.delete(iteratorId);
+          state.clientIteratorSessions.delete(iteratorId);
           return { done: result?.done ?? true, value: await import_protocol.marshalValue(result?.value) };
         } catch (error) {
-          clientIteratorSessions.delete(iteratorId);
+          state.clientIteratorSessions.delete(iteratorId);
           throw error;
         }
       });
@@ -1968,4 +1959,4 @@ function handleClientWsClose(isolateId, payload, state) {
   }
 }
 
-//# debugId=6EEF0F611807A4E264756E2164756E21
+//# debugId=6DFCE44C7F91C20864756E2164756E21