@grabbit-labs/dynafetch 0.2.2 → 0.2.4

package/dist/index.js

@@ -325,7 +325,8 @@ async function withDynafetchSession(options, run) {
   try {
     return await sessionStore.run({ sessionId: session.sessionId }, run);
   } finally {
-    callWorker("closeSession", { sessionId: session.sessionId }).catch(() => {
+    const closeTimeoutMs = Math.min(resolveRpcTimeoutMs(options), 5e3);
+    await callWorker("closeSession", { sessionId: session.sessionId }, closeTimeoutMs).catch(() => {
     });
     transport.release();
   }
@@ -814,6 +815,34 @@ function shouldSkipDynamicScriptUrl(url, pageUrl, policy) {
 }
 
 // ../../src/phantom/execute.ts
+var esbuildModulePromise = null;
+var esbuildRefCount = 0;
+async function acquireEsbuildModule() {
+  if (!esbuildModulePromise) {
+    esbuildModulePromise = import("esbuild");
+  }
+  esbuildRefCount++;
+  try {
+    return await esbuildModulePromise;
+  } catch (error2) {
+    esbuildRefCount = Math.max(0, esbuildRefCount - 1);
+    if (esbuildRefCount === 0) esbuildModulePromise = null;
+    throw error2;
+  }
+}
+function releaseEsbuildModule(esbuildMod) {
+  if (!esbuildMod) return;
+  esbuildRefCount = Math.max(0, esbuildRefCount - 1);
+  if (esbuildRefCount > 0) return;
+  const stopFn = esbuildMod?.stop || esbuildMod?.default?.stop;
+  if (typeof stopFn === "function") {
+    try {
+      stopFn.call(esbuildMod?.default ?? esbuildMod);
+    } catch {
+    }
+  }
+  esbuildModulePromise = null;
+}
 var Executor = class {
   constructor(harvestData, options = null) {
     this.logs = [];
@@ -845,6 +874,10 @@ var Executor = class {
     this.moduleInFlight = /* @__PURE__ */ new Map();
     // entryUrl -> promise
     this.windowClosed = false;
+    this.esbuildModule = null;
+    this.originalGlobalMessageChannel = void 0;
+    this.originalGlobalMessagePort = void 0;
+    this.activeTimerHandles = /* @__PURE__ */ new Set();
     // Simple telemetry counters (useful for debugging).
     this.telemetry_stubbed = 0;
     this.telemetry_proxy = 0;
@@ -936,6 +969,33 @@ var Executor = class {
     if (!warning) return;
     this.warnings.add(warning);
   }
+  unrefNewMessagePorts(initialHandles) {
+    for (const handle of process._getActiveHandles()) {
+      if (initialHandles.has(handle)) continue;
+      if (handle?.constructor?.name !== "MessagePort") continue;
+      try {
+        handle.unref?.();
+      } catch {
+      }
+    }
+  }
+  clearTrackedTimers(window) {
+    for (const handle of this.activeTimerHandles) {
+      try {
+        window.clearTimeout?.(handle);
+      } catch {
+      }
+      try {
+        window.clearInterval?.(handle);
+      } catch {
+      }
+      try {
+        handle?.unref?.();
+      } catch {
+      }
+    }
+    this.activeTimerHandles.clear();
+  }
   applyDefaults(quiescence, moduleWaitMsOverride) {
     const hardMaxCap = this.clampMs(Number(process.env.PHANTOM_QUIESCENCE_MAX_CAP_MS ?? 8e3), 500, 6e4);
     const minWaitMs = this.clampMs(quiescence?.minWaitMs ?? 75, 0, 1e4);
@@ -1213,7 +1273,8 @@ var Executor = class {
           if (!this.windowClosed) window.eval(cached);
           return;
         }
-        const esbuildMod = await import("esbuild");
+        const esbuildMod = this.esbuildModule ?? await acquireEsbuildModule();
+        this.esbuildModule = esbuildMod;
         const buildFn = esbuildMod?.build || esbuildMod?.default?.build;
         if (typeof buildFn !== "function") {
           throw new Error("esbuild.build not available (esbuild import failed)");
@@ -1372,14 +1433,66 @@ var Executor = class {
       };
     }
     const g = globalThis;
-    if (!window.Headers && g.Headers) window.Headers = g.Headers;
-    if (!window.Request && g.Request) window.Request = g.Request;
-    if (!window.Response && g.Response) window.Response = g.Response;
-    if (!window.AbortController && g.AbortController) window.AbortController = g.AbortController;
-    if (!window.AbortSignal && g.AbortSignal) window.AbortSignal = g.AbortSignal;
+    if (g.Headers) window.Headers = g.Headers;
+    if (g.Response) window.Response = g.Response;
+    if (g.AbortController) window.AbortController = g.AbortController;
+    if (g.AbortSignal) window.AbortSignal = g.AbortSignal;
     if (!window.TextEncoder && g.TextEncoder) window.TextEncoder = g.TextEncoder;
     if (!window.TextDecoder && g.TextDecoder) window.TextDecoder = g.TextDecoder;
     if (!window.structuredClone && g.structuredClone) window.structuredClone = g.structuredClone.bind(g);
+    const normalizeUrlForRequest = (value) => {
+      if (typeof value !== "string") return value;
+      try {
+        return new URL(value, window.location.href).toString();
+      } catch {
+        return value;
+      }
+    };
+    const normalizeAbortSignalForRequest = (signal) => {
+      if (!signal || !g.AbortController || !g.AbortSignal) return signal;
+      if (signal instanceof g.AbortSignal) return signal;
+      if (typeof signal.aborted !== "boolean") return void 0;
+      const controller = new g.AbortController();
+      if (signal.aborted) {
+        try {
+          controller.abort(signal.reason);
+        } catch {
+          controller.abort();
+        }
+        return controller.signal;
+      }
+      if (typeof signal.addEventListener === "function") {
+        try {
+          signal.addEventListener("abort", () => {
+            try {
+              controller.abort(signal.reason);
+            } catch {
+              controller.abort();
+            }
+          }, { once: true });
+        } catch {
+        }
+      }
+      return controller.signal;
+    };
+    if (g.Request) {
+      const NativeRequest = g.Request;
+      const RequestShim = class Request extends NativeRequest {
+        constructor(input, init) {
+          const normalizedInput = typeof input === "string" ? normalizeUrlForRequest(input) : input instanceof URL ? normalizeUrlForRequest(input.toString()) : input;
+          const normalizedInit = init && typeof init === "object" ? {
+            ...init,
+            signal: normalizeAbortSignalForRequest(init.signal)
+          } : init;
+          super(normalizedInput, normalizedInit);
+        }
+      };
+      try {
+        Object.setPrototypeOf(RequestShim, NativeRequest);
+      } catch {
+      }
+      window.Request = RequestShim;
+    }
     const makeStorage = () => {
       const store = /* @__PURE__ */ new Map();
       return {
@@ -1439,8 +1552,27 @@ var Executor = class {
     }
     {
       const _g = globalThis;
-      if (!window.MessageChannel && _g.MessageChannel) window.MessageChannel = _g.MessageChannel;
-      if (!window.MessagePort && _g.MessagePort) window.MessagePort = _g.MessagePort;
+      if (_g.MessageChannel) {
+        if (this.originalGlobalMessageChannel === void 0) {
+          this.originalGlobalMessageChannel = _g.MessageChannel;
+        }
+        const NativeMessageChannel = _g.MessageChannel;
+        const UnrefMessageChannel = class MessageChannel extends NativeMessageChannel {
+          constructor() {
+            super();
+            this.port1?.unref?.();
+            this.port2?.unref?.();
+          }
+        };
+        window.MessageChannel = UnrefMessageChannel;
+        _g.MessageChannel = UnrefMessageChannel;
+      }
+      if (_g.MessagePort) {
+        if (this.originalGlobalMessagePort === void 0) {
+          this.originalGlobalMessagePort = _g.MessagePort;
+        }
+        window.MessagePort = _g.MessagePort;
+      }
     }
     if (!window.requestIdleCallback) {
       window.requestIdleCallback = (cb) => window.setTimeout(() => cb({
@@ -1559,8 +1691,41 @@ var Executor = class {
     };
     const _setTimeout = window.setTimeout?.bind(window);
     const _setInterval = window.setInterval?.bind(window);
-    if (_setTimeout) window.setTimeout = (cb, ms, ...rest) => _setTimeout(wrapCb(cb), ms, ...rest);
-    if (_setInterval) window.setInterval = (cb, ms, ...rest) => _setInterval(wrapCb(cb), ms, ...rest);
+    const _clearTimeout = window.clearTimeout?.bind(window);
+    const _clearInterval = window.clearInterval?.bind(window);
+    if (_setTimeout) {
+      window.setTimeout = (cb, ms, ...rest) => {
+        let handle;
+        const wrapped = wrapCb((...args) => {
+          this.activeTimerHandles.delete(handle);
+          return typeof cb === "function" ? cb(...args) : cb;
+        });
+        handle = _setTimeout(wrapped, ms, ...rest);
+        this.activeTimerHandles.add(handle);
+        handle?.unref?.();
+        return handle;
+      };
+    }
+    if (_setInterval) {
+      window.setInterval = (cb, ms, ...rest) => {
+        const handle = _setInterval(wrapCb(cb), ms, ...rest);
+        this.activeTimerHandles.add(handle);
+        handle?.unref?.();
+        return handle;
+      };
+    }
+    if (_clearTimeout) {
+      window.clearTimeout = (handle) => {
+        this.activeTimerHandles.delete(handle);
+        return _clearTimeout(handle);
+      };
+    }
+    if (_clearInterval) {
+      window.clearInterval = (handle) => {
+        this.activeTimerHandles.delete(handle);
+        return _clearInterval(handle);
+      };
+    }
     if (window.queueMicrotask) {
       const _q = window.queueMicrotask.bind(window);
       window.queueMicrotask = (cb) => _q(wrapCb(cb));
@@ -1664,12 +1829,13 @@ var Executor = class {
   async execute() {
     const onNodeUncaught = (err) => this.recordExecutionError(err, "uncaughtException");
     const onNodeUnhandled = (reason) => this.recordExecutionError(reason, "unhandledRejection");
+    const initialActiveHandles = new Set(process._getActiveHandles());
     process.on("uncaughtException", onNodeUncaught);
     process.on("unhandledRejection", onNodeUnhandled);
     try {
       const virtualConsole = new VirtualConsole();
       virtualConsole.on("log", (...args) => log("[JSDOM Log]", ...args));
-      virtualConsole.on("error", (...args) => console.error("[JSDOM Error]", ...args));
+      virtualConsole.on("error", (...args) => warn("[JSDOM Error]", ...args));
       virtualConsole.on("warn", (...args) => warn("[JSDOM Warn]", ...args));
       const cookieJar = new CookieJar();
       this.harvestData.cookies.forEach((c) => {
@@ -2077,10 +2243,6 @@ var Executor = class {
       log(`[Executor] Quiescence reached in ${Date.now() - quiescenceStart}ms ${reason}`);
       const renderedHtml = this.serializeDocument(window);
       this.windowClosed = true;
-      try {
-        window.close();
-      } catch {
-      }
       const result = {
         logs: this.logs,
         matchedRequests: this.earlyMatches,
@@ -2091,8 +2253,21 @@ var Executor = class {
       };
       const shutdownGraceMs = this.clampMs(Number(process.env.PHANTOM_SHUTDOWN_GRACE_MS ?? 50), 10, 5e3);
       await new Promise((r) => setTimeout(r, shutdownGraceMs));
+      this.clearTrackedTimers(window);
+      this.unrefNewMessagePorts(initialActiveHandles);
       return result;
     } finally {
+      const g = globalThis;
+      if (this.originalGlobalMessageChannel !== void 0) {
+        g.MessageChannel = this.originalGlobalMessageChannel;
+        this.originalGlobalMessageChannel = void 0;
+      }
+      if (this.originalGlobalMessagePort !== void 0) {
+        g.MessagePort = this.originalGlobalMessagePort;
+        this.originalGlobalMessagePort = void 0;
+      }
+      releaseEsbuildModule(this.esbuildModule);
+      this.esbuildModule = null;
       process.off("uncaughtException", onNodeUncaught);
       process.off("unhandledRejection", onNodeUnhandled);
     }
@@ -2185,6 +2360,12 @@ var Executor = class {
     };
     window.__phantom = {
       fetch: async (input, opts = {}) => {
+        if (that.windowClosed) {
+          return new (window.Response || global.Response)("", {
+            status: 200,
+            headers: toSafeResponseHeaders({})
+          });
+        }
         const norm = await normalizeFetchInput(input, opts);
         const start = Date.now();
         const headers = {
@@ -2262,6 +2443,7 @@ var Executor = class {
         }
       },
       dynamicImport: async (url) => {
+        if (that.windowClosed) return {};
         const fullUrl = new URL(url, window.location.href).toString();
         const start = Date.now();
         const logEntry = {
@@ -2374,6 +2556,12 @@ var Executor = class {
           this.onloadend?.({ type: "loadend" });
         }
         async send(body) {
+          if (that.windowClosed) {
+            this.readyState = 4;
+            this.status = 0;
+            this.onloadend?.({ type: "loadend" });
+            return;
+          }
           const start = Date.now();
           const headers = {
             "User-Agent": window.navigator.userAgent,