playwright-core 1.54.0-alpha-2025-06-20 → 1.54.0-alpha-1750421372000

package/lib/server/electron/electron.js

@@ -126,22 +126,20 @@ class ElectronApplication extends import_instrumentation.SdkObject {
 class Electron extends import_instrumentation.SdkObject {
   constructor(playwright) {
     super(playwright, "electron");
+    this.logName = "browser";
   }
-  async launch(options) {
-    const {
-      args = []
-    } = options;
-    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), this);
-    controller.setLogName("browser");
+  async launch(metadata, options) {
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run(async (progress) => {
       let app = void 0;
-      let electronArguments = ["--inspect=0", "--remote-debugging-port=0", ...args];
+      let electronArguments = ["--inspect=0", "--remote-debugging-port=0", ...options.args || []];
       if (import_os.default.platform() === "linux") {
         const runningAsRoot = process.geteuid && process.geteuid() === 0;
         if (runningAsRoot && electronArguments.indexOf("--no-sandbox") === -1)
           electronArguments.unshift("--no-sandbox");
       }
-      const artifactsDir = await import_fs.default.promises.mkdtemp(ARTIFACTS_FOLDER);
+      const artifactsDir = await progress.race(import_fs.default.promises.mkdtemp(ARTIFACTS_FOLDER));
+      progress.cleanupWhenAborted(() => (0, import_utils.removeFolders)([artifactsDir]));
       const browserLogsCollector = new import_debugLogger.RecentLogsCollector();
       const env = options.env ? (0, import_processLauncher.envArrayToObject)(options.env) : process.env;
       let command;
@@ -186,8 +184,8 @@ class Electron extends import_instrumentation.SdkObject {
         handleSIGHUP: true,
         onExit: () => app?.emit(ElectronApplication.Events.Close)
       });
-      const waitForXserverError = new Promise(async (resolve, reject) => {
-        waitForLine(progress, launchedProcess, /Unable to open X display/).then(() => reject(new Error([
+      const waitForXserverError = waitForLine(progress, launchedProcess, /Unable to open X display/).then(() => {
+        throw new Error([
           "Unable to open X display!",
           `================================`,
           "Most likely this is because there is no X server available.",
@@ -195,14 +193,14 @@ class Electron extends import_instrumentation.SdkObject {
           "For example: 'xvfb-run npm run test:e2e'",
           `================================`,
           progress.metadata.log
-        ].join("\n")))).catch(() => {
-        });
+        ].join("\n"));
       });
       const nodeMatchPromise = waitForLine(progress, launchedProcess, /^Debugger listening on (ws:\/\/.*)$/);
       const chromeMatchPromise = waitForLine(progress, launchedProcess, /^DevTools listening on (ws:\/\/.*)$/);
       const debuggerDisconnectPromise = waitForLine(progress, launchedProcess, /Waiting for the debugger to disconnect\.\.\./);
       const nodeMatch = await nodeMatchPromise;
       const nodeTransport = await import_transport.WebSocketTransport.connect(progress, nodeMatch[1]);
+      progress.cleanupWhenAborted(() => nodeTransport.close());
       const nodeConnection = new import_crConnection.CRConnection(this, nodeTransport, import_helper.helper.debugProtocolLogger(), browserLogsCollector);
       debuggerDisconnectPromise.then(() => {
         nodeTransport.close();
@@ -213,6 +211,7 @@ class Electron extends import_instrumentation.SdkObject {
         waitForXserverError
       ]);
       const chromeTransport = await import_transport.WebSocketTransport.connect(progress, chromeMatch[1]);
+      progress.cleanupWhenAborted(() => chromeTransport.close());
       const browserProcess = {
         onclose: void 0,
         process: launchedProcess,
@@ -237,15 +236,15 @@ class Electron extends import_instrumentation.SdkObject {
         originalLaunchOptions: { timeout: options.timeout }
       };
       (0, import_browserContext.validateBrowserContextOptions)(contextOptions, browserOptions);
-      const browser = await import_crBrowser.CRBrowser.connect(this.attribution.playwright, chromeTransport, browserOptions);
+      const browser = await progress.race(import_crBrowser.CRBrowser.connect(this.attribution.playwright, chromeTransport, browserOptions));
       app = new ElectronApplication(this, browser, nodeConnection, launchedProcess);
-      await app.initialize();
+      await progress.race(app.initialize());
       return app;
     }, options.timeout);
   }
 }
 function waitForLine(progress, process2, regex) {
-  return new Promise((resolve, reject) => {
+  return progress.race(new Promise((resolve, reject) => {
     const rl = readline.createInterface({ input: process2.stderr });
     const failError = new Error("Process failed to launch!");
     const listeners = [
@@ -266,7 +265,7 @@ function waitForLine(progress, process2, regex) {
     function cleanup() {
       import_eventsHelper.eventsHelper.removeEventListeners(listeners);
     }
-  });
+  }));
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/server/fetch.js

@@ -122,15 +122,11 @@ class APIRequestContext extends import_instrumentation.SdkObject {
       agent = (0, import_utils.createProxyAgent)(proxy, requestUrl);
     let maxRedirects = params.maxRedirects ?? (defaults.maxRedirects ?? 20);
     maxRedirects = maxRedirects === 0 ? -1 : maxRedirects;
-    const timeout = params.timeout;
-    const deadline = timeout && (0, import_utils.monotonicTime)() + timeout;
     const options = {
       method,
       headers,
       agent,
       maxRedirects,
-      timeout,
-      deadline,
       ...(0, import_socksClientCertificatesInterceptor.getMatchingTLSOptionsForOrigin)(this._defaultOptions().clientCertificates, requestUrl.origin),
       __testHookLookup: params.__testHookLookup
     };
@@ -139,10 +135,10 @@ class APIRequestContext extends import_instrumentation.SdkObject {
     const postData = serializePostData(params, headers);
     if (postData)
       setHeader(headers, "content-length", String(postData.byteLength));
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     const fetchResponse = await controller.run((progress) => {
       return this._sendRequestWithRetries(progress, requestUrl, options, postData, params.maxRetries);
-    }, timeout);
+    }, params.timeout);
     const fetchUid = this._storeResponseBody(fetchResponse.body);
     this.fetchLog.set(fetchUid, controller.metadata.log);
     const failOnStatusCode = params.failOnStatusCode !== void 0 ? params.failOnStatusCode : !!defaults.failOnStatusCode;
@@ -182,10 +178,10 @@ ${text}`;
     }
     return cookies;
   }
-  async _updateRequestCookieHeader(url, headers) {
+  async _updateRequestCookieHeader(progress, url, headers) {
     if (getHeader(headers, "cookie") !== void 0)
       return;
-    const contextCookies = await this._cookies(url);
+    const contextCookies = await progress.race(this._cookies(url));
     const cookies = contextCookies.filter((c) => new import_cookieStore.Cookie(c).matches(url));
     if (cookies.length) {
       const valueArray = cookies.map((c) => `${c.name}=${c.value}`);
@@ -199,22 +195,24 @@ ${text}`;
       try {
         return await this._sendRequest(progress, url, options, postData);
       } catch (e) {
+        if ((0, import_progress.isAbortError)(e))
+          throw e;
         e = (0, import_socksClientCertificatesInterceptor.rewriteOpenSSLErrorIfNeeded)(e);
         if (maxRetries === 0)
           throw e;
-        if (i === maxRetries || options.deadline && (0, import_utils.monotonicTime)() + backoff > options.deadline)
+        if (i === maxRetries)
           throw new Error(`Failed after ${i + 1} attempt(s): ${e}`);
         if (e.code !== "ECONNRESET")
           throw e;
         progress.log(`  Received ECONNRESET, will retry after ${backoff}ms.`);
-        await new Promise((f) => setTimeout(f, backoff));
+        await progress.wait(backoff);
         backoff *= 2;
       }
     }
     throw new Error("Unreachable");
   }
   async _sendRequest(progress, url, options, postData) {
-    await this._updateRequestCookieHeader(url, options.headers);
+    await this._updateRequestCookieHeader(progress, url, options.headers);
     const requestCookies = getHeader(options.headers, "cookie")?.split(";").map((p) => {
       const [name, value] = p.split("=").map((v) => v.trim());
       return { name, value };
@@ -227,7 +225,7 @@ ${text}`;
       postData
     };
     this.emit(APIRequestContext.Events.Request, requestEvent);
-    return new Promise((fulfill, reject) => {
+    const resultPromise = new Promise((fulfill, reject) => {
       const requestConstructor = (url.protocol === "https:" ? import_https.default : import_http.default).request;
       const agent = options.agent || (url.protocol === "https:" ? import_happyEyeballs.httpsHappyEyeballsAgent : import_happyEyeballs.httpHappyEyeballsAgent);
       const requestOptions = { ...options, agent };
@@ -308,8 +306,6 @@ ${text}`;
             headers,
             agent: options.agent,
             maxRedirects: options.maxRedirects - 1,
-            timeout: options.timeout,
-            deadline: options.deadline,
             ...(0, import_socksClientCertificatesInterceptor.getMatchingTLSOptionsForOrigin)(this._defaultOptions().clientCertificates, url.origin),
             __testHookLookup: options.__testHookLookup
           };
@@ -387,6 +383,7 @@ ${text}`;
         body.on("end", notifyBodyFinished);
       });
       request.on("error", reject);
+      progress.cleanupWhenAborted(() => request.destroy());
       listeners.push(
         import_utils.eventsHelper.addEventListener(this, APIRequestContext.Events.Dispose, () => {
           reject(new Error("Request context disposed."));
@@ -434,22 +431,11 @@ ${text}`;
         for (const [name, value] of Object.entries(options.headers))
           progress.log(`  ${name}: ${value}`);
       }
-      if (options.deadline) {
-        const rejectOnTimeout = () => {
-          reject(new Error(`Request timed out after ${options.timeout}ms`));
-          request.destroy();
-        };
-        const remaining = options.deadline - (0, import_utils.monotonicTime)();
-        if (remaining <= 0) {
-          rejectOnTimeout();
-          return;
-        }
-        request.setTimeout(remaining, rejectOnTimeout);
-      }
       if (postData)
         request.write(postData);
       request.end();
     });
+    return progress.race(resultPromise);
   }
   _getHttpCredentials(url) {
     if (!this._defaultOptions().httpCredentials?.origin || url.origin.toLowerCase() === this._defaultOptions().httpCredentials?.origin?.toLowerCase())

package/lib/server/firefox/ffPage.js

@@ -363,7 +363,6 @@ class FFPage {
         height: viewportRect.height
       };
     }
-    progress.throwIfAborted();
     const { data } = await this._session.send("Page.screenshot", {
       mimeType: "image/" + format,
       clip: documentRect,

package/lib/server/frames.js

@@ -468,7 +468,7 @@ class Frame extends import_instrumentation.SdkObject {
       this.emit(Frame.Events.RemoveLifecycle, "networkidle");
     }
   }
-  async raceNavigationAction(progress, options, action) {
+  async raceNavigationAction(progress, action) {
     return import_utils.LongStandingScope.raceMultiple([
       this._detachedScope,
       this._page.openScope
@@ -477,14 +477,14 @@ class Frame extends import_instrumentation.SdkObject {
         const data = this._redirectedNavigations.get(e.documentId);
         if (data) {
           progress.log(`waiting for redirected navigation to "${data.url}"`);
-          return data.gotoPromise;
+          return progress.race(data.gotoPromise);
         }
       }
       throw e;
     }));
   }
   redirectNavigation(url, documentId, referer) {
-    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), this);
+    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), this, "strict");
     const data = {
       url,
       gotoPromise: controller.run((progress) => this.gotoImpl(progress, url, { referer }), 0)
@@ -493,10 +493,10 @@ class Frame extends import_instrumentation.SdkObject {
     data.gotoPromise.finally(() => this._redirectedNavigations.delete(documentId));
   }
   async goto(metadata, url, options) {
-    const constructedNavigationURL = (0, import_utils.constructURLBasedOnBaseURL)(this._page.browserContext._options.baseURL, url);
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run((progress) => {
-      return this.raceNavigationAction(progress, options, async () => this.gotoImpl(progress, constructedNavigationURL, options));
+      const constructedNavigationURL = (0, import_utils.constructURLBasedOnBaseURL)(this._page.browserContext._options.baseURL, url);
+      return this.raceNavigationAction(progress, async () => this.gotoImpl(progress, constructedNavigationURL, options));
     }, options.timeout);
   }
   async gotoImpl(progress, url, options) {
@@ -514,7 +514,7 @@ class Frame extends import_instrumentation.SdkObject {
     const navigationEvents = [];
     const collectNavigations = (arg) => navigationEvents.push(arg);
     this.on(Frame.Events.InternalNavigation, collectNavigations);
-    const navigateResult = await this._page.delegate.navigateFrame(this, url, referer).finally(
+    const navigateResult = await progress.race(this._page.delegate.navigateFrame(this, url, referer)).finally(
       () => this.off(Frame.Events.InternalNavigation, collectNavigations)
     );
     let event;
@@ -543,7 +543,7 @@ class Frame extends import_instrumentation.SdkObject {
     if (!this._firedLifecycleEvents.has(waitUntil))
       await import_helper.helper.waitForEvent(progress, this, Frame.Events.AddLifecycle, (e) => e === waitUntil).promise;
     const request = event.newDocument ? event.newDocument.request : void 0;
-    const response = request ? request._finalRequest().response() : null;
+    const response = request ? progress.race(request._finalRequest().response()) : null;
     return response;
   }
   async _waitForNavigation(progress, requiresNewDocument, options) {
@@ -562,7 +562,7 @@ class Frame extends import_instrumentation.SdkObject {
     if (!this._firedLifecycleEvents.has(waitUntil))
       await import_helper.helper.waitForEvent(progress, this, Frame.Events.AddLifecycle, (e) => e === waitUntil).promise;
     const request = navigationEvent.newDocument ? navigationEvent.newDocument.request : void 0;
-    return request ? request._finalRequest().response() : null;
+    return request ? progress.race(request._finalRequest().response()) : null;
   }
   async _waitForLoadState(progress, state) {
     const waitUntil = verifyLifecycle("state", state);
@@ -714,31 +714,32 @@ class Frame extends import_instrumentation.SdkObject {
         return retVal;
       });
     } catch (e) {
-      if ((0, import_progress.isAbortError)(e) || js.isJavaScriptErrorInEvaluate(e) || (0, import_protocolError.isSessionClosedError)(e))
+      if (this.isNonRetriableError(e))
         throw e;
       throw new Error(`Unable to retrieve content because the page is navigating and changing the content.`);
     }
   }
   async setContent(metadata, html, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run(async (progress) => {
-      await this.raceNavigationAction(progress, options, async () => {
+      await this.raceNavigationAction(progress, async () => {
         const waitUntil = options.waitUntil === void 0 ? "load" : options.waitUntil;
         progress.log(`setting frame content, waiting until "${waitUntil}"`);
         const tag = `--playwright--set--content--${this._id}--${++this._setContentCounter}--`;
-        const context = await this._utilityContext();
-        const lifecyclePromise = new Promise((resolve, reject) => {
-          this._page.frameManager._consoleMessageTags.set(tag, () => {
-            this._onClearLifecycle();
-            this._waitForLoadState(progress, waitUntil).then(resolve).catch(reject);
-          });
+        const context = await progress.race(this._utilityContext());
+        const tagPromise = new import_manualPromise.ManualPromise();
+        this._page.frameManager._consoleMessageTags.set(tag, () => {
+          this._onClearLifecycle();
+          tagPromise.resolve();
         });
-        const contentPromise = context.evaluate(({ html: html2, tag: tag2 }) => {
+        progress.cleanupWhenAborted(() => this._page.frameManager._consoleMessageTags.delete(tag));
+        const lifecyclePromise = progress.race(tagPromise).then(() => this._waitForLoadState(progress, waitUntil));
+        const contentPromise = progress.race(context.evaluate(({ html: html2, tag: tag2 }) => {
           document.open();
           console.debug(tag2);
           document.write(html2);
           document.close();
-        }, { html, tag });
+        }, { html, tag }));
         await Promise.all([contentPromise, lifecyclePromise]);
         return null;
       });
@@ -884,13 +885,13 @@ class Frame extends import_instrumentation.SdkObject {
           continue;
         return result;
       } catch (e) {
-        if (this._isErrorThatCannotBeRetried(e))
+        if (this.isNonRetriableError(e))
           throw e;
         continue;
       }
     }
   }
-  _isErrorThatCannotBeRetried(e) {
+  isNonRetriableError(e) {
     if ((0, import_progress.isAbortError)(e))
       return true;
     if (js.isJavaScriptErrorInEvaluate(e) || (0, import_protocolError.isSessionClosedError)(e))
@@ -947,7 +948,7 @@ class Frame extends import_instrumentation.SdkObject {
   }
   async rafrafTimeoutScreenshotElementWithProgress(progress, selector, timeout, options) {
     return await this._retryWithProgressIfNotConnected(progress, selector, true, true, async (handle) => {
-      await handle._frame.rafrafTimeout(timeout);
+      await handle._frame.rafrafTimeout(progress, timeout);
       return await this._page.screenshotter.screenshotElement(progress, handle, options);
     });
   }
@@ -1081,7 +1082,7 @@ class Frame extends import_instrumentation.SdkObject {
         return state.matches;
       }, { info: resolved.info, root: resolved.frame === this ? scope : void 0 }));
     } catch (e) {
-      if ((0, import_progress.isAbortError)(e) || js.isJavaScriptErrorInEvaluate(e) || (0, import_selectorParser.isInvalidSelectorError)(e) || (0, import_protocolError.isSessionClosedError)(e))
+      if (this.isNonRetriableError(e))
         throw e;
       return false;
     }
@@ -1149,9 +1150,9 @@ class Frame extends import_instrumentation.SdkObject {
     return controller.run((progress) => progress.wait(timeout));
   }
   async ariaSnapshot(metadata, selector, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run(async (progress) => {
-      return await this._retryWithProgressIfNotConnected(progress, selector, true, true, (handle) => handle.ariaSnapshot(options));
+      return await this._retryWithProgressIfNotConnected(progress, selector, true, true, (handle) => progress.race(handle.ariaSnapshot(options)));
     }, options.timeout);
   }
   async expect(metadata, selector, options) {
@@ -1165,20 +1166,20 @@ class Frame extends import_instrumentation.SdkObject {
     try {
       let timeout = options.timeout;
       const start = timeout > 0 ? (0, import_utils.monotonicTime)() : 0;
-      await new import_progress.ProgressController(metadata, this).run(async (progress) => {
+      await new import_progress.ProgressController(metadata, this, "strict").run(async (progress) => {
         progress.log(`${(0, import_utils.renderTitleForCall)(metadata)}${timeout ? ` with timeout ${timeout}ms` : ""}`);
         if (selector)
           progress.log(`waiting for ${this._asLocator(selector)}`);
         await this._page.performActionPreChecks(progress);
       }, timeout);
       try {
-        const resultOneShot = await new import_progress.ProgressController(metadata, this).run(async (progress) => {
+        const resultOneShot = await new import_progress.ProgressController(metadata, this, "strict").run(async (progress) => {
           return await this._expectInternal(progress, selector, options, lastIntermediateResult);
         });
         if (resultOneShot.matches !== options.isNot)
           return resultOneShot;
       } catch (e) {
-        if ((0, import_progress.isAbortError)(e) || js.isJavaScriptErrorInEvaluate(e) || (0, import_selectorParser.isInvalidSelectorError)(e))
+        if (this.isNonRetriableError(e))
           throw e;
       }
       if (timeout > 0) {
@@ -1187,7 +1188,7 @@ class Frame extends import_instrumentation.SdkObject {
       }
       if (timeout < 0)
         return { matches: options.isNot, log: (0, import_callLog.compressCallLog)(metadata.log), timedOut: true, received: lastIntermediateResult.received };
-      return await new import_progress.ProgressController(metadata, this).run(async (progress) => {
+      return await new import_progress.ProgressController(metadata, this, "strict").run(async (progress) => {
         return await this.retryWithProgressAndTimeouts(progress, [100, 250, 500, 1e3], async (continuePolling) => {
           await this._page.performActionPreChecks(progress);
           const { matches, received } = await this._expectInternal(progress, selector, options, lastIntermediateResult);
@@ -1209,14 +1210,12 @@ class Frame extends import_instrumentation.SdkObject {
     }
   }
   async _expectInternal(progress, selector, options, lastIntermediateResult) {
-    const selectorInFrame = selector ? await this.selectors.resolveFrameForSelector(selector, { strict: true }) : void 0;
-    progress.throwIfAborted();
+    const selectorInFrame = selector ? await progress.race(this.selectors.resolveFrameForSelector(selector, { strict: true })) : void 0;
     const { frame, info } = selectorInFrame || { frame: this, info: void 0 };
     const world = options.expression === "to.have.property" ? "main" : info?.world ?? "utility";
-    const context = await frame._context(world);
-    const injected = await context.injectedScript();
-    progress.throwIfAborted();
-    const { log, matches, received, missingReceived } = await injected.evaluate(async (injected2, { info: info2, options: options2, callId }) => {
+    const context = await progress.race(frame._context(world));
+    const injected = await progress.race(context.injectedScript());
+    const { log, matches, received, missingReceived } = await progress.race(injected.evaluate(async (injected2, { info: info2, options: options2, callId }) => {
       const elements = info2 ? injected2.querySelectorAll(info2.parsed, document) : [];
       if (callId)
         injected2.markTargetElements(new Set(elements), callId);
@@ -1229,7 +1228,7 @@ class Frame extends import_instrumentation.SdkObject {
       else if (elements.length)
         log2 = `  locator resolved to ${injected2.previewNode(elements[0])}`;
       return { log: log2, ...await injected2.expect(elements[0], options2, elements) };
-    }, { info, options, callId: progress.metadata.id });
+    }, { info, options, callId: progress.metadata.id }));
     if (log)
       progress.log(log);
     if (matches === options.isNot) {
@@ -1240,60 +1239,62 @@ class Frame extends import_instrumentation.SdkObject {
     }
     return { matches, received };
   }
-  async _waitForFunctionExpression(metadata, expression, isFunction, arg, options, world = "main") {
-    const controller = new import_progress.ProgressController(metadata, this);
+  async waitForFunctionExpression(metadata, expression, isFunction, arg, options) {
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    return controller.run((progress) => this.waitForFunctionExpressionImpl(progress, expression, isFunction, arg, options, "main"), options.timeout);
+  }
+  async waitForFunctionExpressionImpl(progress, expression, isFunction, arg, options, world = "main") {
     if (typeof options.pollingInterval === "number")
       (0, import_utils.assert)(options.pollingInterval > 0, "Cannot poll with non-positive interval: " + options.pollingInterval);
     expression = js.normalizeEvaluationExpression(expression, isFunction);
-    return controller.run(async (progress) => {
-      return this.retryWithProgressAndTimeouts(progress, [100], async () => {
-        const context = world === "main" ? await this._mainContext() : await this._utilityContext();
-        const injectedScript = await context.injectedScript();
-        const handle = await injectedScript.evaluateHandle((injected, { expression: expression2, isFunction: isFunction2, polling, arg: arg2 }) => {
-          const predicate = () => {
-            let result2 = globalThis.eval(expression2);
-            if (isFunction2 === true) {
-              result2 = result2(arg2);
-            } else if (isFunction2 === false) {
-              result2 = result2;
-            } else {
-              if (typeof result2 === "function")
-                result2 = result2(arg2);
-            }
-            return result2;
-          };
-          let fulfill;
-          let reject;
-          let aborted = false;
-          const result = new Promise((f, r) => {
-            fulfill = f;
-            reject = r;
-          });
-          const next = () => {
-            if (aborted)
+    return this.retryWithProgressAndTimeouts(progress, [100], async () => {
+      const context = world === "main" ? await progress.race(this._mainContext()) : await progress.race(this._utilityContext());
+      const injectedScript = await progress.race(context.injectedScript());
+      const handle = await progress.race(injectedScript.evaluateHandle((injected, { expression: expression2, isFunction: isFunction2, polling, arg: arg2 }) => {
+        const predicate = () => {
+          let result3 = globalThis.eval(expression2);
+          if (isFunction2 === true) {
+            result3 = result3(arg2);
+          } else if (isFunction2 === false) {
+            result3 = result3;
+          } else {
+            if (typeof result3 === "function")
+              result3 = result3(arg2);
+          }
+          return result3;
+        };
+        let fulfill;
+        let reject;
+        let aborted = false;
+        const result2 = new Promise((f, r) => {
+          fulfill = f;
+          reject = r;
+        });
+        const next = () => {
+          if (aborted)
+            return;
+          try {
+            const success = predicate();
+            if (success) {
+              fulfill(success);
               return;
-            try {
-              const success = predicate();
-              if (success) {
-                fulfill(success);
-                return;
-              }
-              if (typeof polling !== "number")
-                injected.utils.builtins.requestAnimationFrame(next);
-              else
-                injected.utils.builtins.setTimeout(next, polling);
-            } catch (e) {
-              reject(e);
             }
-          };
-          next();
-          return { result, abort: () => aborted = true };
-        }, { expression, isFunction, polling: options.pollingInterval, arg });
-        progress.cleanupWhenAborted(() => handle.evaluate((h) => h.abort()).catch(() => {
-        }));
-        return handle.evaluateHandle((h) => h.result);
-      });
-    }, options.timeout);
+            if (typeof polling !== "number")
+              injected.utils.builtins.requestAnimationFrame(next);
+            else
+              injected.utils.builtins.setTimeout(next, polling);
+          } catch (e) {
+            reject(e);
+          }
+        };
+        next();
+        return { result: result2, abort: () => aborted = true };
+      }, { expression, isFunction, polling: options.pollingInterval, arg }));
+      progress.cleanupWhenAborted(() => handle.evaluate((h) => h.abort()).finally(() => handle.dispose()));
+      const result = await progress.race(handle.evaluateHandle((h) => h.result));
+      handle.dispose();
+      return result;
+    });
   }
   async waitForFunctionValueInUtility(progress, pageFunction) {
     const expression = `() => {
@@ -1302,25 +1303,25 @@ class Frame extends import_instrumentation.SdkObject {
         return result;
       return JSON.stringify(result);
     }`;
-    const handle = await this._waitForFunctionExpression((0, import_instrumentation.serverSideCallMetadata)(), expression, true, void 0, { timeout: progress.timeUntilDeadline() }, "utility");
+    const handle = await this.waitForFunctionExpressionImpl(progress, expression, true, void 0, {}, "utility");
     return JSON.parse(handle.rawValue());
   }
   async title() {
     const context = await this._utilityContext();
     return context.evaluate(() => document.title);
   }
-  async rafrafTimeout(timeout) {
+  async rafrafTimeout(progress, timeout) {
     if (timeout === 0)
       return;
-    const context = await this._utilityContext();
+    const context = await progress.race(this._utilityContext());
     await Promise.all([
       // wait for double raf
-      context.evaluate(() => new Promise((x) => {
+      progress.race(context.evaluate(() => new Promise((x) => {
         requestAnimationFrame(() => {
           requestAnimationFrame(x);
         });
-      })),
-      new Promise((fulfill) => setTimeout(fulfill, timeout))
+      }))),
+      progress.wait(timeout)
     ]);
   }
   _onDetached() {

package/lib/server/helper.js

@@ -66,7 +66,7 @@ class Helper {
     });
     const dispose = () => import_eventsHelper.eventsHelper.removeEventListeners(listeners);
     progress.cleanupWhenAborted(dispose);
-    return { promise, dispose };
+    return { promise: progress.race(promise), dispose };
   }
   static secondsToRoundishMillis(value) {
     return (value * 1e6 | 0) / 1e3;