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

package/lib/server/frames.js

@@ -484,7 +484,7 @@ class Frame extends import_instrumentation.SdkObject {
     }));
   }
   redirectNavigation(url, documentId, referer) {
-    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), this, "strict");
+    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), this);
     const data = {
       url,
       gotoPromise: controller.run((progress) => this.gotoImpl(progress, url, { referer }), 0)
@@ -493,7 +493,7 @@ class Frame extends import_instrumentation.SdkObject {
     data.gotoPromise.finally(() => this._redirectedNavigations.delete(documentId));
   }
   async goto(metadata, url, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run((progress) => {
       const constructedNavigationURL = (0, import_utils.constructURLBasedOnBaseURL)(this._page.browserContext._options.baseURL, url);
       return this.raceNavigationAction(progress, async () => this.gotoImpl(progress, constructedNavigationURL, options));
@@ -603,7 +603,7 @@ class Frame extends import_instrumentation.SdkObject {
     return this.selectors.query(selector, options);
   }
   async waitForSelector(metadata, selector, options, scope) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       if (options.visibility)
         throw new Error("options.visibility is not supported, did you mean options.state?");
@@ -720,7 +720,7 @@ class Frame extends import_instrumentation.SdkObject {
     }
   }
   async setContent(metadata, html, 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.raceNavigationAction(progress, async () => {
         const waitUntil = options.waitUntil === void 0 ? "load" : options.waitUntil;
@@ -953,19 +953,19 @@ class Frame extends import_instrumentation.SdkObject {
     });
   }
   async click(metadata, selector, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._click(progress, { ...options, waitAfter: !options.noWaitAfter })));
     }, options.timeout);
   }
   async dblclick(metadata, selector, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._dblclick(progress, options)));
     }, options.timeout);
   }
   async dragAndDrop(metadata, source, target, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     await controller.run(async (progress) => {
       dom.assertDone(await this._retryWithProgressIfNotConnected(progress, source, options.strict, !options.force, async (handle) => {
         return handle._retryPointerAction(progress, "move and down", false, async (point) => {
@@ -990,7 +990,7 @@ class Frame extends import_instrumentation.SdkObject {
     }, options.timeout);
   }
   async tap(metadata, selector, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       if (!this._page.browserContext._options.hasTouch)
         throw new Error("The page does not support tap. Use hasTouch context option to enable touch support.");
@@ -998,23 +998,52 @@ class Frame extends import_instrumentation.SdkObject {
     }, options.timeout);
   }
   async fill(metadata, selector, value, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._fill(progress, value, options)));
     }, options.timeout);
   }
   async focus(metadata, selector, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     await controller.run(async (progress) => {
       dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._focus(progress)));
     }, options.timeout);
   }
   async blur(metadata, selector, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     await controller.run(async (progress) => {
       dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._blur(progress)));
     }, options.timeout);
   }
+  async generateLocatorString(metadata, selector) {
+    const controller = new import_progress.ProgressController(metadata, this);
+    return controller.run(async (progress) => {
+      const element = await progress.race(this.selectors.query(selector));
+      if (!element)
+        throw new Error(`No element matching ${this._asLocator(selector)}`);
+      const generated = await progress.race(element.evaluateInUtility(async ([injected, node]) => {
+        return injected.generateSelectorSimple(node);
+      }, {}));
+      if (!generated)
+        throw new Error(`Unable to generate locator for ${this._asLocator(selector)}`);
+      let frame = element._frame;
+      const result = [generated];
+      while (frame?.parentFrame()) {
+        const frameElement = await progress.race(frame.frameElement());
+        if (frameElement) {
+          const generated2 = await progress.race(frameElement.evaluateInUtility(async ([injected, node]) => {
+            return injected.generateSelectorSimple(node);
+          }, {}));
+          frameElement.dispose();
+          if (generated2 === "error:notconnected" || !generated2)
+            throw new Error(`Unable to generate locator for ${this._asLocator(selector)}`);
+          result.push(generated2);
+        }
+        frame = frame.parentFrame();
+      }
+      return (0, import_utils.asLocator)(this._page.browserContext._browser.sdkLanguage(), result.reverse().join(" >> internal:control=enter-frame >> "));
+    });
+  }
   async textContent(metadata, selector, options, scope) {
     return this._callOnElementOnceMatches(metadata, selector, (injected, element) => element.textContent, void 0, options, scope);
   }
@@ -1065,7 +1094,7 @@ class Frame extends import_instrumentation.SdkObject {
     return result.matches;
   }
   async isVisible(metadata, selector, options = {}, scope) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       progress.log(`  checking visibility of ${this._asLocator(selector)}`);
       return await this.isVisibleInternal(progress, selector, options, scope);
@@ -1103,54 +1132,54 @@ class Frame extends import_instrumentation.SdkObject {
     return this._elementState(metadata, selector, "checked", options, scope);
   }
   async hover(metadata, selector, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._hover(progress, options)));
     }, options.timeout);
   }
   async selectOption(metadata, selector, 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) => {
       return await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._selectOption(progress, elements, values, options));
     }, options.timeout);
   }
   async setInputFiles(metadata, selector, params) {
     const inputFileItems = await (0, import_fileUploadUtils.prepareFilesForUpload)(this, params);
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, params.strict, true, (handle) => handle._setInputFiles(progress, inputFileItems)));
     }, params.timeout);
   }
   async type(metadata, selector, text, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._type(progress, text, options)));
     }, options.timeout);
   }
   async press(metadata, selector, key, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._press(progress, key, options)));
     }, options.timeout);
   }
   async check(metadata, selector, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._setChecked(progress, true, options)));
     }, options.timeout);
   }
   async uncheck(metadata, selector, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._setChecked(progress, false, options)));
     }, options.timeout);
   }
   async waitForTimeout(metadata, timeout) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run((progress) => progress.wait(timeout));
   }
   async ariaSnapshot(metadata, selector, 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._retryWithProgressIfNotConnected(progress, selector, true, true, (handle) => progress.race(handle.ariaSnapshot(options)));
     }, options.timeout);
@@ -1162,43 +1191,32 @@ class Frame extends import_instrumentation.SdkObject {
     return result;
   }
   async _expectImpl(metadata, selector, options) {
+    const controller = new import_progress.ProgressController(metadata, this);
     const lastIntermediateResult = { isSet: false };
-    try {
-      let timeout = options.timeout;
-      const start = timeout > 0 ? (0, import_utils.monotonicTime)() : 0;
-      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);
+    return await controller.run(async (progress) => {
+      progress.log(`${(0, import_utils.renderTitleForCall)(metadata)}${options.timeout ? ` with timeout ${options.timeout}ms` : ""}`);
+      if (selector)
+        progress.log(`waiting for ${this._asLocator(selector)}`);
+      await this._page.performActionPreChecks(progress);
+      progress.legacyDisableTimeout();
       try {
-        const resultOneShot = await new import_progress.ProgressController(metadata, this, "strict").run(async (progress) => {
-          return await this._expectInternal(progress, selector, options, lastIntermediateResult);
-        });
+        const resultOneShot = await this._expectInternal(progress, selector, options, lastIntermediateResult, true);
         if (resultOneShot.matches !== options.isNot)
           return resultOneShot;
       } catch (e) {
         if (this.isNonRetriableError(e))
           throw e;
       }
-      if (timeout > 0) {
-        const elapsed = (0, import_utils.monotonicTime)() - start;
-        timeout -= elapsed;
-      }
-      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, "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);
-          if (matches === options.isNot) {
-            return continuePolling;
-          }
-          return { matches, received };
-        });
-      }, timeout);
-    } catch (e) {
+      progress.legacyEnableTimeout();
+      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, false);
+        if (matches === options.isNot) {
+          return continuePolling;
+        }
+        return { matches, received };
+      });
+    }, options.timeout).catch((e) => {
       if (js.isJavaScriptErrorInEvaluate(e) || (0, import_selectorParser.isInvalidSelectorError)(e))
         throw e;
       const result = { matches: options.isNot, log: (0, import_callLog.compressCallLog)(metadata.log) };
@@ -1207,15 +1225,16 @@ class Frame extends import_instrumentation.SdkObject {
       if (e instanceof import_errors.TimeoutError)
         result.timedOut = true;
       return result;
-    }
+    });
   }
-  async _expectInternal(progress, selector, options, lastIntermediateResult) {
-    const selectorInFrame = selector ? await progress.race(this.selectors.resolveFrameForSelector(selector, { strict: true })) : void 0;
+  async _expectInternal(progress, selector, options, lastIntermediateResult, noAbort) {
+    const race = (p) => noAbort ? p : progress.race(p);
+    const selectorInFrame = selector ? await 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 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 context = await race(frame._context(world));
+    const injected = await race(context.injectedScript());
+    const { log, matches, received, missingReceived } = await 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);
@@ -1240,7 +1259,7 @@ class Frame extends import_instrumentation.SdkObject {
     return { matches, received };
   }
   async waitForFunctionExpression(metadata, expression, isFunction, arg, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run((progress) => this.waitForFunctionExpressionImpl(progress, expression, isFunction, arg, options, "main"), options.timeout);
   }
   async waitForFunctionExpressionImpl(progress, expression, isFunction, arg, options, world = "main") {
@@ -1337,7 +1356,7 @@ class Frame extends import_instrumentation.SdkObject {
     this._parentFrame = null;
   }
   async _callOnElementOnceMatches(metadata, selector, body, taskData, options, scope) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       const callbackText = body.toString();
       progress.log(`waiting for ${this._asLocator(selector)}`);

package/lib/server/input.js

@@ -49,7 +49,7 @@ class Keyboard {
     this._page = page;
   }
   async down(metadata, key) {
-    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
+    const controller = new import_progress.ProgressController(metadata, this._page);
     return controller.run((progress) => this._down(progress, key));
   }
   async _down(progress, key) {
@@ -71,7 +71,7 @@ class Keyboard {
     return description;
   }
   async up(metadata, key) {
-    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
+    const controller = new import_progress.ProgressController(metadata, this._page);
     return controller.run((progress) => this._up(progress, key));
   }
   async _up(progress, key) {
@@ -82,14 +82,14 @@ class Keyboard {
     await this._raw.keyup(progress, this._pressedModifiers, key, description);
   }
   async insertText(metadata, text) {
-    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
+    const controller = new import_progress.ProgressController(metadata, this._page);
     return controller.run((progress) => this._insertText(progress, text));
   }
   async _insertText(progress, text) {
     await this._raw.sendText(progress, text);
   }
   async type(metadata, text, options) {
-    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
+    const controller = new import_progress.ProgressController(metadata, this._page);
     return controller.run((progress) => this._type(progress, text, options));
   }
   async _type(progress, text, options) {
@@ -105,7 +105,7 @@ class Keyboard {
     }
   }
   async press(metadata, key, options) {
-    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
+    const controller = new import_progress.ProgressController(metadata, this._page);
     return controller.run((progress) => this._press(progress, key, options));
   }
   async _press(progress, key, options = {}) {
@@ -177,7 +177,7 @@ class Mouse {
     return { x: this._x, y: this._y };
   }
   async move(metadata, x, y, options) {
-    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
+    const controller = new import_progress.ProgressController(metadata, this._page);
     return controller.run((progress) => this._move(progress, x, y, options));
   }
   async _move(progress, x, y, options = {}) {
@@ -193,7 +193,7 @@ class Mouse {
     }
   }
   async down(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
+    const controller = new import_progress.ProgressController(metadata, this._page);
     return controller.run((progress) => this._down(progress, options));
   }
   async _down(progress, options = {}) {
@@ -203,7 +203,7 @@ class Mouse {
     await this._raw.down(progress, this._x, this._y, this._lastButton, this._buttons, this._keyboard._modifiers(), clickCount);
   }
   async up(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
+    const controller = new import_progress.ProgressController(metadata, this._page);
     return controller.run((progress) => this._up(progress, options));
   }
   async _up(progress, options = {}) {
@@ -213,7 +213,7 @@ class Mouse {
     await this._raw.up(progress, this._x, this._y, button, this._buttons, this._keyboard._modifiers(), clickCount);
   }
   async click(metadata, x, y, options) {
-    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
+    const controller = new import_progress.ProgressController(metadata, this._page);
     return controller.run((progress) => this._click(progress, x, y, options));
   }
   async _click(progress, x, y, options = {}) {
@@ -238,7 +238,7 @@ class Mouse {
     }
   }
   async wheel(metadata, deltaX, deltaY) {
-    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
+    const controller = new import_progress.ProgressController(metadata, this._page);
     return controller.run(async (progress) => {
       await this._raw.wheel(progress, this._x, this._y, this._buttons, this._keyboard._modifiers(), deltaX, deltaY);
     });
@@ -295,7 +295,7 @@ class Touchscreen {
     this._page = page;
   }
   async tap(metadata, x, y) {
-    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
+    const controller = new import_progress.ProgressController(metadata, this._page);
     return controller.run((progress) => this._tap(progress, x, y));
   }
   async _tap(progress, x, y) {

package/lib/server/page.js

@@ -249,7 +249,7 @@ class Page extends import_instrumentation.SdkObject {
     this.emitOnContextOnceInitialized(import_browserContext.BrowserContext.Events.Console, message);
   }
   async reload(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run((progress) => this.mainFrame().raceNavigationAction(progress, async () => {
       const [response] = await Promise.all([
         // Reload must be a new document, and should not be confused with a stray pushState.
@@ -260,7 +260,7 @@ class Page extends import_instrumentation.SdkObject {
     }), options.timeout);
   }
   async goBack(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run((progress) => this.mainFrame().raceNavigationAction(progress, async () => {
       let error;
       const waitPromise = this.mainFrame()._waitForNavigation(progress, false, options).catch((e) => {
@@ -280,7 +280,7 @@ class Page extends import_instrumentation.SdkObject {
     }), options.timeout);
   }
   async goForward(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run((progress) => this.mainFrame().raceNavigationAction(progress, async () => {
       let error;
       const waitPromise = this.mainFrame()._waitForNavigation(progress, false, options).catch((e) => {
@@ -321,9 +321,7 @@ class Page extends import_instrumentation.SdkObject {
   }
   async performActionPreChecks(progress) {
     await this._performWaitForNavigationCheck(progress);
-    progress.throwIfAborted();
     await this._performLocatorHandlersCheckpoint(progress);
-    progress.throwIfAborted();
     await this._performWaitForNavigationCheck(progress);
   }
   async _performWaitForNavigationCheck(progress) {
@@ -355,7 +353,6 @@ class Page extends import_instrumentation.SdkObject {
         ++this._locatorHandlerRunningCounter;
         progress.log(`  found ${(0, import_utils2.asLocator)(this.browserContext._browser.sdkLanguage(), handler.selector)}, intercepting action to run the handler`);
         const promise = handler.resolved.then(async () => {
-          progress.throwIfAborted();
           if (!handler.noWaitAfter) {
             progress.log(`  locator handler has finished, waiting for ${(0, import_utils2.asLocator)(this.browserContext._browser.sdkLanguage(), handler.selector)} to be hidden`);
             await this.mainFrame().waitForSelectorInternal(progress, handler.selector, false, { state: "hidden" });
@@ -450,7 +447,7 @@ class Page extends import_instrumentation.SdkObject {
       return await this.screenshotter.screenshotPage(progress, options || {});
     };
     const comparator = (0, import_comparators.getComparator)("image/png");
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     if (!options.expected && options.isNot)
       return { errorMessage: '"not" matcher requires expected result' };
     try {
@@ -630,7 +627,7 @@ class Page extends import_instrumentation.SdkObject {
     this._isServerSideOnly = true;
   }
   snapshotForAI(metadata) {
-    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    const controller = new import_progress.ProgressController(metadata, this);
     return controller.run(async (progress) => {
       this.lastSnapshotFrameIds = [];
       const snapshot = await snapshotFrameForAI(progress, this.mainFrame(), 0, this.lastSnapshotFrameIds);

package/lib/server/progress.js

@@ -26,7 +26,7 @@ var import_errors = require("./errors");
 var import_utils = require("../utils");
 var import_manualPromise = require("../utils/isomorphic/manualPromise");
 class ProgressController {
-  constructor(metadata, sdkObject, strictMode) {
+  constructor(metadata, sdkObject) {
     this._forceAbortPromise = new import_manualPromise.ManualPromise();
     this._donePromise = new import_manualPromise.ManualPromise();
     // Cleanups to be run only in the case of abort.
@@ -38,8 +38,7 @@ class ProgressController {
     // progress only finishes after the inner callback exits, guaranteeing no work after the timeout.
     this._strictMode = false;
     this._state = "before";
-    this._deadline = 0;
-    this._strictMode = strictMode === "strict";
+    this._strictMode = !process.env.PLAYWRIGHT_LEGACY_TIMEOUTS;
     this.metadata = metadata;
     this.sdkObject = sdkObject;
     this.instrumentation = sdkObject.instrumentation;
@@ -59,27 +58,44 @@ class ProgressController {
       await this._donePromise;
   }
   async run(task, timeout) {
-    this._deadline = timeout ? (0, import_utils.monotonicTime)() + timeout : 0;
     (0, import_utils.assert)(this._state === "before");
     this._state = "running";
     this.sdkObject.attribution.context?._activeProgressControllers.add(this);
+    const deadline = timeout ? Math.min((0, import_utils.monotonicTime)() + timeout, 2147483647) : 0;
+    const timeoutError = new import_errors.TimeoutError(`Timeout ${timeout}ms exceeded.`);
+    let timer;
+    const startTimer = () => {
+      if (!deadline)
+        return;
+      const onTimeout = () => {
+        if (this._state === "running") {
+          this._state = { error: timeoutError };
+          this._forceAbortPromise.reject(timeoutError);
+        }
+      };
+      const remaining = deadline - (0, import_utils.monotonicTime)();
+      if (remaining <= 0)
+        onTimeout();
+      else
+        timer = setTimeout(onTimeout, remaining);
+    };
     const progress = {
       log: (message) => {
         if (this._state === "running")
           this.metadata.log.push(message);
         this.instrumentation.onCallLog(this.sdkObject, this.metadata, this._logName, message);
       },
-      timeUntilDeadline: () => this._deadline ? this._deadline - (0, import_utils.monotonicTime)() : 2147483647,
-      // 2^31-1 safe setTimeout in Node.
       cleanupWhenAborted: (cleanup) => {
+        if (this._strictMode) {
+          if (this._state !== "running")
+            throw new Error("Internal error: cannot register cleanup after operation has finished.");
+          this._cleanups.push(cleanup);
+          return;
+        }
         if (this._state === "running")
           this._cleanups.push(cleanup);
         else
-          runCleanup(cleanup);
-      },
-      throwIfAborted: () => {
-        if (typeof this._state === "object")
-          throw this._state.error;
+          runCleanup(typeof this._state === "object" ? this._state.error : void 0, cleanup);
       },
       metadata: this.metadata,
       race: (promise) => {
@@ -96,15 +112,19 @@ class ProgressController {
         let timer2;
         const promise = new Promise((f) => timer2 = setTimeout(f, timeout2));
         return progress.race(promise).finally(() => clearTimeout(timer2));
+      },
+      legacyDisableTimeout: () => {
+        if (this._strictMode)
+          return;
+        clearTimeout(timer);
+      },
+      legacyEnableTimeout: () => {
+        if (this._strictMode)
+          return;
+        startTimer();
       }
     };
-    const timeoutError = new import_errors.TimeoutError(`Timeout ${timeout}ms exceeded.`);
-    const timer = setTimeout(() => {
-      if (this._state === "running") {
-        this._state = { error: timeoutError };
-        this._forceAbortPromise.reject(timeoutError);
-      }
-    }, progress.timeUntilDeadline());
+    startTimer();
     try {
       const promise = task(progress);
       const result = this._strictMode ? await promise : await Promise.race([promise, this._forceAbortPromise]);
@@ -112,7 +132,7 @@ class ProgressController {
       return result;
     } catch (error) {
       this._state = { error };
-      await Promise.all(this._cleanups.splice(0).map(runCleanup));
+      await Promise.all(this._cleanups.splice(0).map((cleanup) => runCleanup(error, cleanup)));
       throw error;
     } finally {
       this.sdkObject.attribution.context?._activeProgressControllers.delete(this);
@@ -121,9 +141,9 @@ class ProgressController {
     }
   }
 }
-async function runCleanup(cleanup) {
+async function runCleanup(error, cleanup) {
   try {
-    await cleanup();
+    await cleanup(error);
   } catch (e) {
   }
 }

package/lib/server/recorder/recorderApp.js

@@ -127,7 +127,7 @@ class RecorderApp extends import_events.EventEmitter {
         timeout: 0
       }
     });
-    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), context._browser, "strict");
+    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), context._browser);
     await controller.run(async (progress) => {
       await context._browser._defaultContext._loadDefaultContextAsIs(progress);
     });

package/lib/server/registry/index.js

@@ -1089,7 +1089,7 @@ ${e.stack}`);
   async _installMSEdgeChannel(channel, scripts) {
     const scriptArgs = [];
     if (process.platform !== "linux") {
-      const products = lowercaseAllKeys(JSON.parse(await (0, import_network.fetchData)({ url: "https://edgeupdates.microsoft.com/api/products" })));
+      const products = lowercaseAllKeys(JSON.parse(await (0, import_network.fetchData)(void 0, { url: "https://edgeupdates.microsoft.com/api/products" })));
       const productName = {
         "msedge": "Stable",
         "msedge-beta": "Beta",

package/lib/server/registry/oopDownloadBrowserMain.js

@@ -47,7 +47,7 @@ function downloadFile(options) {
     headers: {
       "User-Agent": options.userAgent
     },
-    timeout: options.socketTimeout
+    socketTimeout: options.socketTimeout
   }, (response) => {
     log(`-- response status code: ${response.statusCode}`);
     if (response.statusCode !== 200) {

package/lib/server/screenshotter.js

@@ -253,7 +253,7 @@ class Screenshotter {
     }
     const cleanupHighlight = await this._maskElements(progress, options);
     const quality = format === "jpeg" ? options.quality ?? 80 : void 0;
-    const buffer = await progress.race(this._page.delegate.takeScreenshot(progress, format, documentRect, viewportRect, quality, fitsViewport, options.scale || "device"));
+    const buffer = await this._page.delegate.takeScreenshot(progress, format, documentRect, viewportRect, quality, fitsViewport, options.scale || "device");
     await cleanupHighlight();
     if (shouldSetDefaultBackground)
       await progress.race(this._page.delegate.setBackgroundColor());

package/lib/server/trace/viewer/traceViewer.js

@@ -158,7 +158,7 @@ async function openTraceViewerApp(url, browserName, options) {
       timeout: 0
     }
   });
-  const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), context._browser, "strict");
+  const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), context._browser);
   await controller.run(async (progress) => {
     await context._browser._defaultContext._loadDefaultContextAsIs(progress);
   });

package/lib/server/transport.js

@@ -43,8 +43,6 @@ class WebSocketTransport {
     this._ws = new import_utilsBundle.ws(url, [], {
       maxPayload: 256 * 1024 * 1024,
       // 256Mb,
-      // Prevent internal http client error when passing negative timeout.
-      handshakeTimeout: Math.max(progress?.timeUntilDeadline() ?? import_utils.DEFAULT_PLAYWRIGHT_TIMEOUT, 1),
       headers: options.headers,
       followRedirects: options.followRedirects,
       agent: /^(https|wss):\/\//.test(url) ? import_happyEyeballs.httpsHappyEyeballsAgent : import_happyEyeballs.httpHappyEyeballsAgent,