playwright-core 1.54.0-alpha-2025-06-23 → 1.54.0-alpha-2025-06-25

package/lib/protocol/validator.js

@@ -1657,6 +1657,12 @@ import_validatorPrimitives.scheme.FrameFrameElementParams = (0, import_validator
 import_validatorPrimitives.scheme.FrameFrameElementResult = (0, import_validatorPrimitives.tObject)({
   element: (0, import_validatorPrimitives.tChannel)(["ElementHandle"])
 });
+import_validatorPrimitives.scheme.FrameGenerateLocatorStringParams = (0, import_validatorPrimitives.tObject)({
+  selector: import_validatorPrimitives.tString
+});
+import_validatorPrimitives.scheme.FrameGenerateLocatorStringResult = (0, import_validatorPrimitives.tObject)({
+  value: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString)
+});
 import_validatorPrimitives.scheme.FrameHighlightParams = (0, import_validatorPrimitives.tObject)({
   selector: import_validatorPrimitives.tString
 });
@@ -2050,10 +2056,6 @@ import_validatorPrimitives.scheme.ElementHandleFillParams = (0, import_validator
 import_validatorPrimitives.scheme.ElementHandleFillResult = (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({}));
 import_validatorPrimitives.scheme.ElementHandleFocusParams = (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({}));
 import_validatorPrimitives.scheme.ElementHandleFocusResult = (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({}));
-import_validatorPrimitives.scheme.ElementHandleGenerateLocatorStringParams = (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({}));
-import_validatorPrimitives.scheme.ElementHandleGenerateLocatorStringResult = (0, import_validatorPrimitives.tObject)({
-  value: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString)
-});
 import_validatorPrimitives.scheme.ElementHandleGetAttributeParams = (0, import_validatorPrimitives.tObject)({
   name: import_validatorPrimitives.tString
 });

package/lib/remote/playwrightServer.js

@@ -179,15 +179,11 @@ ${uaError}` };
       preLaunchedBrowser: browser,
       denyLaunch: true,
       dispose: async () => {
-        for (const browser2 of this._playwright.allBrowsers()) {
-          for (const context of browser2.contexts()) {
-            if (!context.pages().length)
-              await context.close({ reason: "Connection terminated" });
-            else
-              await context.stopPendingOperations("Connection closed");
-          }
-          if (!browser2.contexts())
-            await browser2.close({ reason: "Connection terminated" });
+        for (const context of browser.contexts()) {
+          if (!context.pages().length)
+            await context.close({ reason: "Connection terminated" });
+          else
+            await context.stopPendingOperations("Connection closed");
         }
       }
     };

package/lib/server/android/android.js

@@ -222,7 +222,7 @@ class AndroidDevice extends import_instrumentation.SdkObject {
     this.emit(AndroidDevice.Events.Close);
   }
   async launchBrowser(metadata, pkg = "com.android.chrome", options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       (0, import_utilsBundle.debug)("pw:android")("Force-stopping", pkg);
       await this._backend.runCommand(`shell:am force-stop ${pkg}`);
@@ -264,7 +264,7 @@ class AndroidDevice extends import_instrumentation.SdkObject {
     return chromeArguments;
   }
   async connectToWebView(metadata, socketName) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       const webView = this._webViews.get(socketName);
       if (!webView)

package/lib/server/bidi/bidiPage.js

@@ -332,7 +332,7 @@ class BidiPage {
   }
   async takeScreenshot(progress, format, documentRect, viewportRect, quality, fitsViewport, scale) {
     const rect = documentRect || viewportRect;
-    const { data } = await this._session.send("browsingContext.captureScreenshot", {
+    const { data } = await progress.race(this._session.send("browsingContext.captureScreenshot", {
       context: this._session.sessionId,
       format: {
         type: `image/${format === "png" ? "png" : "jpeg"}`,
@@ -343,7 +343,7 @@ class BidiPage {
         type: "box",
         ...rect
       }
-    });
+    }));
     return Buffer.from(data, "base64");
   }
   async getContentFrame(handle) {

package/lib/server/browser.js

@@ -50,7 +50,7 @@ class Browser extends import_instrumentation.SdkObject {
     return this.options.sdkLanguage || this.attribution.playwright.options.sdkLanguage;
   }
   newContextFromMetadata(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run((progress) => this.newContext(progress, options));
   }
   async newContext(progress, options) {

package/lib/server/browserContext.js

@@ -160,7 +160,7 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
     return JSON.stringify(paramsCopy);
   }
   async resetForReuse(metadata, params) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run((progress) => this.resetForReuseImpl(progress, params));
   }
   async resetForReuseImpl(progress, params) {
@@ -405,7 +405,7 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
     await this._closePromise;
   }
   newPageFromMetadata(metadata) {
-    const contoller = new import_progress.ProgressController(metadata, this, "strict");
+    const contoller = new import_progress.ProgressController(metadata, this);
     return contoller.run((progress) => this.newPage(progress, false));
   }
   async newPage(progress, isServerSide) {
@@ -422,7 +422,7 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
     this._origins.add(origin);
   }
   storageState(indexedDB = false) {
-    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), this, "strict");
+    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), this);
     return controller.run((progress) => this.storageStateImpl(progress, indexedDB));
   }
   async storageStateImpl(progress, indexedDB) {

package/lib/server/browserType.js

@@ -67,7 +67,7 @@ class BrowserType extends import_instrumentation.SdkObject {
   }
   async launch(metadata, options, protocolLogger) {
     options = this._validateLaunchOptions(options);
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     const browser = await controller.run((progress) => {
       const seleniumHubUrl = options.__testHookSeleniumRemoteURL || process.env.SELENIUM_REMOTE_URL;
       if (seleniumHubUrl)
@@ -80,7 +80,7 @@ class BrowserType extends import_instrumentation.SdkObject {
   }
   async launchPersistentContext(metadata, userDataDir, options) {
     const launchOptions = this._validateLaunchOptions(options);
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     const browser = await controller.run(async (progress) => {
       let clientCertificatesProxy;
       if (options.clientCertificates?.length) {
@@ -239,7 +239,7 @@ class BrowserType extends import_instrumentation.SdkObject {
       close: () => closeOrKill(options.__testHookBrowserCloseTimeout || import_time.DEFAULT_PLAYWRIGHT_TIMEOUT),
       kill
     };
-    progress.cleanupWhenAborted(() => closeOrKill(progress.timeUntilDeadline()));
+    progress.cleanupWhenAborted(() => closeOrKill(import_time.DEFAULT_PLAYWRIGHT_TIMEOUT));
     const { wsEndpoint } = await progress.race([
       this.waitForReadyState(options, browserLogsCollector),
       exitPromise.then(() => ({ wsEndpoint: void 0 }))

package/lib/server/chromium/chromium.js

@@ -62,7 +62,7 @@ class Chromium extends import_browserType.BrowserType {
       this._devtools = this._createDevTools();
   }
   async connectOverCDP(metadata, endpointURL, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       return await this._connectOverCDPInternal(progress, endpointURL, options);
     }, options.timeout);
@@ -179,7 +179,7 @@ class Chromium extends import_browserType.BrowserType {
         headers = remoteHeaders;
     }
     progress.log(`<selenium> connecting to ${hubUrl}`);
-    const response = await (0, import_network.fetchData)({
+    const response = await (0, import_network.fetchData)(progress, {
       url: hubUrl + "session",
       method: "POST",
       headers: {
@@ -188,15 +188,14 @@ class Chromium extends import_browserType.BrowserType {
       },
       data: JSON.stringify({
         capabilities: { alwaysMatch: desiredCapabilities }
-      }),
-      timeout: progress.timeUntilDeadline()
+      })
     }, seleniumErrorHandler);
     const value = JSON.parse(response).value;
     const sessionId = value.sessionId;
     progress.log(`<selenium> connected to sessionId=${sessionId}`);
     const disconnectFromSelenium = async () => {
       progress.log(`<selenium> disconnecting from sessionId=${sessionId}`);
-      await (0, import_network.fetchData)({
+      await (0, import_network.fetchData)(void 0, {
         url: hubUrl + "session/" + sessionId,
         method: "DELETE",
         headers
@@ -227,10 +226,9 @@ class Chromium extends import_browserType.BrowserType {
         if (endpointURL.hostname === "localhost" || endpointURL.hostname === "127.0.0.1") {
           const sessionInfoUrl = new URL(hubUrl).origin + "/grid/api/testsession?session=" + sessionId;
           try {
-            const sessionResponse = await (0, import_network.fetchData)({
+            const sessionResponse = await (0, import_network.fetchData)(progress, {
               url: sessionInfoUrl,
               method: "GET",
-              timeout: progress.timeUntilDeadline(),
               headers
             }, seleniumErrorHandler);
             const proxyId = JSON.parse(sessionResponse).proxyId;
@@ -344,10 +342,10 @@ async function urlToWSEndpoint(progress, endpointURL, headers) {
   url.pathname += "json/version/";
   const httpURL = url.toString();
   const json = await (0, import_network.fetchData)(
+    progress,
     {
       url: httpURL,
-      headers,
-      timeout: progress.timeUntilDeadline()
+      headers
     },
     async (_, resp) => new Error(`Unexpected status ${resp.statusCode} when connecting to ${httpURL}.
 This does not look like a DevTools server, try connecting via ws://.`)

package/lib/server/chromium/crPage.js

@@ -210,7 +210,7 @@ class CRPage {
     await this._mainFrameSession._client.send("Emulation.setDefaultBackgroundColorOverride", { color });
   }
   async takeScreenshot(progress, format, documentRect, viewportRect, quality, fitsViewport, scale) {
-    const { visualViewport } = await this._mainFrameSession._client.send("Page.getLayoutMetrics");
+    const { visualViewport } = await progress.race(this._mainFrameSession._client.send("Page.getLayoutMetrics"));
     if (!documentRect) {
       documentRect = {
         x: visualViewport.pageX + viewportRect.x,
@@ -226,8 +226,7 @@ class CRPage {
       const deviceScaleFactor = this._browserContext._options.deviceScaleFactor || 1;
       clip.scale /= deviceScaleFactor;
     }
-    progress.throwIfAborted();
-    const result = await this._mainFrameSession._client.send("Page.captureScreenshot", { format, quality, clip, captureBeyondViewport: !fitsViewport });
+    const result = await progress.race(this._mainFrameSession._client.send("Page.captureScreenshot", { format, quality, clip, captureBeyondViewport: !fitsViewport }));
     return Buffer.from(result.data, "base64");
   }
   async getContentFrame(handle) {

package/lib/server/chromium/videoRecorder.js

@@ -44,7 +44,7 @@ class VideoRecorder {
   static async launch(page, ffmpegPath, options) {
     if (!options.outputFile.endsWith(".webm"))
       throw new Error("File must have .webm extension");
-    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), page, "strict");
+    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), page);
     controller.setLogName("browser");
     return await controller.run(async (progress) => {
       const recorder = new VideoRecorder(page, ffmpegPath, progress);

package/lib/server/dispatchers/elementHandlerDispatcher.js

@@ -55,9 +55,6 @@ class ElementHandleDispatcher extends import_jsHandleDispatcher.JSHandleDispatch
     const frame = await this._elementHandle.contentFrame();
     return { frame: frame ? import_frameDispatcher.FrameDispatcher.from(this._browserContextDispatcher(), frame) : void 0 };
   }
-  async generateLocatorString(params, metadata) {
-    return { value: await this._elementHandle.generateLocatorString() };
-  }
   async getAttribute(params, metadata) {
     const value = await this._elementHandle.getAttribute(metadata, params.name);
     return { value: value === null ? void 0 : value };

package/lib/server/dispatchers/frameDispatcher.js

@@ -144,6 +144,9 @@ class FrameDispatcher extends import_dispatcher.Dispatcher {
   async innerHTML(params, metadata) {
     return { value: await this._frame.innerHTML(metadata, params.selector, params) };
   }
+  async generateLocatorString(params, metadata) {
+    return { value: await this._frame.generateLocatorString(metadata, params.selector) };
+  }
   async getAttribute(params, metadata) {
     const value = await this._frame.getAttribute(metadata, params.selector, params.name, params);
     return { value: value === null ? void 0 : value };

package/lib/server/dispatchers/localUtilsDispatcher.js

@@ -79,7 +79,7 @@ class LocalUtilsDispatcher extends import_dispatcher.Dispatcher {
     return await localUtils.addStackToTracingNoReply(this._stackSessions, params);
   }
   async connect(params, metadata) {
-    const controller = new import_progress.ProgressController(metadata, this._object, "strict");
+    const controller = new import_progress.ProgressController(metadata, this._object);
     return await controller.run(async (progress) => {
       const wsHeaders = {
         "User-Agent": (0, import_userAgent.getUserAgent)(),
@@ -129,10 +129,9 @@ async function urlToWSEndpoint(progress, endpointURL) {
   if (!fetchUrl.pathname.endsWith("/"))
     fetchUrl.pathname += "/";
   fetchUrl.pathname += "json";
-  const json = await (0, import_network.fetchData)({
+  const json = await (0, import_network.fetchData)(progress, {
     url: fetchUrl.toString(),
     method: "GET",
-    timeout: progress.timeUntilDeadline(),
     headers: { "User-Agent": (0, import_userAgent.getUserAgent)() }
   }, async (params, response) => {
     return new Error(`Unexpected status ${response.statusCode} when connecting to ${fetchUrl.toString()}.

package/lib/server/dom.js

@@ -161,35 +161,6 @@ class ElementHandle extends js.JSHandle {
       return null;
     return this._page.delegate.getContentFrame(this);
   }
-  async generateLocatorString() {
-    const selectors = await this._generateSelectorString();
-    if (!selectors.length)
-      return;
-    return (0, import_utils.asLocator)("javascript", selectors.reverse().join(" >> internal:control=enter-frame >> "));
-  }
-  async _generateSelectorString() {
-    const selector = await this.evaluateInUtility(async ([injected, node]) => {
-      return injected.generateSelectorSimple(node);
-    }, {});
-    if (selector === "error:notconnected")
-      return [];
-    let frame = this._frame;
-    const result = [selector];
-    while (frame?.parentFrame()) {
-      const frameElement = await frame.frameElement();
-      if (frameElement) {
-        const selector2 = await frameElement.evaluateInUtility(async ([injected, node]) => {
-          return injected.generateSelectorSimple(node);
-        }, {});
-        frameElement.dispose();
-        if (selector2 === "error:notconnected")
-          return [];
-        result.push(selector2);
-      }
-      frame = frame.parentFrame();
-    }
-    return result;
-  }
   async getAttribute(metadata, name) {
     return this._frame.getAttribute(metadata, ":scope", name, { timeout: 0 }, this);
   }
@@ -224,7 +195,7 @@ class ElementHandle extends js.JSHandle {
     assertDone(throwRetargetableDOMError(result));
   }
   async scrollIntoViewIfNeeded(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(
       (progress) => this._waitAndScrollIntoViewIfNeeded(
         progress,
@@ -289,7 +260,6 @@ class ElementHandle extends js.JSHandle {
     let retry = 0;
     const waitTime = [0, 20, 100, 100, 500];
     while (true) {
-      progress.throwIfAborted();
       if (retry) {
         progress.log(`retrying ${actionName} action${options.trial ? " (trial run)" : ""}`);
         const timeout = waitTime[Math.min(retry - 1, waitTime.length - 1)];
@@ -322,6 +292,10 @@ class ElementHandle extends js.JSHandle {
         progress.log("  did not find some options");
         continue;
       }
+      if (result === "error:optionnotenabled") {
+        progress.log("  option being selected is not enabled");
+        continue;
+      }
       if (typeof result === "object" && "hitTargetDescription" in result) {
         progress.log(`  ${result.hitTargetDescription} intercepts pointer events`);
         continue;
@@ -359,7 +333,6 @@ class ElementHandle extends js.JSHandle {
       return await this._scrollRectIntoViewIfNeeded(progress, position ? { x: position.x, y: position.y, width: 0, height: 0 } : void 0);
     };
     if (this._frame.parentFrame()) {
-      progress.throwIfAborted();
       await progress.race(doScrollIntoView().catch(() => {
       }));
     }
@@ -378,7 +351,6 @@ class ElementHandle extends js.JSHandle {
     if (options.__testHookAfterStable)
       await progress.race(options.__testHookAfterStable());
     progress.log("  scrolling into view if needed");
-    progress.throwIfAborted();
     const scrolled = await progress.race(doScrollIntoView());
     if (scrolled !== "done")
       return scrolled;
@@ -419,7 +391,6 @@ class ElementHandle extends js.JSHandle {
     const actionResult = await this._page.frameManager.waitForSignalsCreatedBy(progress, options.waitAfter === true, async () => {
       if (options.__testHookBeforePointerAction)
         await progress.race(options.__testHookBeforePointerAction());
-      progress.throwIfAborted();
       let restoreModifiers;
       if (options && options.modifiers)
         restoreModifiers = await this._page.keyboard.ensureModifiers(progress, options.modifiers);
@@ -459,7 +430,7 @@ class ElementHandle extends js.JSHandle {
     }, progress.metadata.id));
   }
   async hover(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       await this._markAsTargetElement(progress);
       const result = await this._hover(progress, options);
@@ -470,7 +441,7 @@ class ElementHandle extends js.JSHandle {
     return this._retryPointerAction(progress, "hover", false, (point) => this._page.mouse._move(progress, point.x, point.y), { ...options, waitAfter: "disabled" });
   }
   async click(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       await this._markAsTargetElement(progress);
       const result = await this._click(progress, { ...options, waitAfter: !options.noWaitAfter });
@@ -481,7 +452,7 @@ class ElementHandle extends js.JSHandle {
     return this._retryPointerAction(progress, "click", true, (point) => this._page.mouse._click(progress, point.x, point.y, options), options);
   }
   async dblclick(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       await this._markAsTargetElement(progress);
       const result = await this._dblclick(progress, options);
@@ -492,7 +463,7 @@ class ElementHandle extends js.JSHandle {
     return this._retryPointerAction(progress, "dblclick", true, (point) => this._page.mouse._click(progress, point.x, point.y, { ...options, clickCount: 2 }), { ...options, waitAfter: "disabled" });
   }
   async tap(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       await this._markAsTargetElement(progress);
       const result = await this._tap(progress, options);
@@ -503,7 +474,7 @@ class ElementHandle extends js.JSHandle {
     return this._retryPointerAction(progress, "tap", true, (point) => this._page.touchscreen._tap(progress, point.x, point.y), { ...options, waitAfter: "disabled" });
   }
   async selectOption(metadata, elements, values, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       await this._markAsTargetElement(progress);
       const result = await this._selectOption(progress, elements, values, options);
@@ -537,7 +508,7 @@ class ElementHandle extends js.JSHandle {
     return resultingOptions;
   }
   async fill(metadata, value, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       await this._markAsTargetElement(progress);
       const result = await this._fill(progress, value, options);
@@ -558,7 +529,6 @@ class ElementHandle extends js.JSHandle {
         }
         return injected.fill(node, value2);
       }, { value, force: options.force }));
-      progress.throwIfAborted();
       if (result === "needsinput") {
         if (value)
           await this._page.keyboard._insertText(progress, value);
@@ -571,7 +541,7 @@ class ElementHandle extends js.JSHandle {
     }, options);
   }
   async selectText(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       const result = await this._retryAction(progress, "selectText", async () => {
         if (!options.force)
@@ -589,7 +559,7 @@ class ElementHandle extends js.JSHandle {
     }, options.timeout);
   }
   async setInputFiles(metadata, params) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       const inputFileItems = await progress.race((0, import_fileUploadUtils.prepareFilesForUpload)(this._frame, params));
       await this._markAsTargetElement(progress);
@@ -634,7 +604,7 @@ class ElementHandle extends js.JSHandle {
     return "done";
   }
   async focus(metadata) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     await controller.run(async (progress) => {
       await this._markAsTargetElement(progress);
       const result = await this._focus(progress);
@@ -648,7 +618,7 @@ class ElementHandle extends js.JSHandle {
     return await progress.race(this.evaluateInUtility(([injected, node]) => injected.blurNode(node), {}));
   }
   async type(metadata, text, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       await this._markAsTargetElement(progress);
       const result = await this._type(progress, text, options);
@@ -669,7 +639,7 @@ class ElementHandle extends js.JSHandle {
     return "done";
   }
   async press(metadata, key, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       await this._markAsTargetElement(progress);
       const result = await this._press(progress, key, options);
@@ -692,14 +662,14 @@ class ElementHandle extends js.JSHandle {
     });
   }
   async check(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       const result = await this._setChecked(progress, true, options);
       return assertDone(throwRetargetableDOMError(result));
     }, options.timeout);
   }
   async uncheck(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       const result = await this._setChecked(progress, false, options);
       return assertDone(throwRetargetableDOMError(result));
@@ -731,7 +701,7 @@ class ElementHandle extends js.JSHandle {
     return await this.evaluateInUtility(([injected, element, options2]) => injected.ariaSnapshot(element, options2), options);
   }
   async screenshot(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(
       (progress) => this._page.screenshotter.screenshotElement(progress, this, options),
       options.timeout
@@ -768,7 +738,7 @@ class ElementHandle extends js.JSHandle {
     return this._frame.isChecked(metadata, ":scope", { timeout: 0 }, this);
   }
   async waitForElementState(metadata, state, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       const actionName = `wait for ${state}`;
       const result = await this._retryAction(progress, actionName, async () => {

package/lib/server/electron/electron.js

@@ -129,7 +129,7 @@ class Electron extends import_instrumentation.SdkObject {
     this.logName = "browser";
   }
   async launch(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       let app = void 0;
       let electronArguments = ["--inspect=0", "--remote-debugging-port=0", ...options.args || []];

package/lib/server/fetch.js

@@ -135,7 +135,7 @@ 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, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     const fetchResponse = await controller.run((progress) => {
       return this._sendRequestWithRetries(progress, requestUrl, options, postData, params.maxRetries);
     }, params.timeout);

package/lib/server/firefox/ffPage.js

@@ -363,12 +363,12 @@ class FFPage {
         height: viewportRect.height
       };
     }
-    const { data } = await this._session.send("Page.screenshot", {
+    const { data } = await progress.race(this._session.send("Page.screenshot", {
       mimeType: "image/" + format,
       clip: documentRect,
       quality,
       omitDeviceScaleFactor: scale === "css"
-    });
+    }));
     return Buffer.from(data, "base64");
   }
   async getContentFrame(handle) {