playwright-core 1.54.0-alpha-2025-06-16 → 1.54.0-alpha-2025-06-18

package/lib/server/frames.js

@@ -119,10 +119,9 @@ class FrameManager {
       return action();
     const barrier = new SignalBarrier(progress);
     this._signalBarriers.add(barrier);
-    if (progress)
-      progress.cleanupWhenAborted(() => this._signalBarriers.delete(barrier));
+    progress.cleanupWhenAborted(() => this._signalBarriers.delete(barrier));
     const result = await action();
-    await this._page.delegate.inputActionEpilogue();
+    await progress.race(this._page.delegate.inputActionEpilogue());
     await barrier.waitFor();
     this._signalBarriers.delete(barrier);
     await new Promise((0, import_utils.makeWaitForNextTask)());
@@ -604,15 +603,15 @@ 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);
-    if (options.visibility)
-      throw new Error("options.visibility is not supported, did you mean options.state?");
-    if (options.waitFor && options.waitFor !== "visible")
-      throw new Error("options.waitFor is not supported, did you mean options.state?");
-    const { state = "visible" } = options;
-    if (!["attached", "detached", "visible", "hidden"].includes(state))
-      throw new Error(`state: expected one of (attached|detached|visible|hidden)`);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run(async (progress) => {
+      if (options.visibility)
+        throw new Error("options.visibility is not supported, did you mean options.state?");
+      if (options.waitFor && options.waitFor !== "visible")
+        throw new Error("options.waitFor is not supported, did you mean options.state?");
+      const { state = "visible" } = options;
+      if (!["attached", "detached", "visible", "hidden"].includes(state))
+        throw new Error(`state: expected one of (attached|detached|visible|hidden)`);
       progress.log(`waiting for ${this._asLocator(selector)}${state === "attached" ? "" : " to be " + state}`);
       return await this.waitForSelectorInternal(progress, selector, true, options, scope);
     }, options.timeout);
@@ -622,14 +621,13 @@ class Frame extends import_instrumentation.SdkObject {
     const promise = this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async (continuePolling) => {
       if (performActionPreChecks)
         await this._page.performActionPreChecks(progress);
-      const resolved = await this.selectors.resolveInjectedForSelector(selector, options, scope);
-      progress.throwIfAborted();
+      const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, options, scope));
       if (!resolved) {
         if (state === "hidden" || state === "detached")
           return null;
         return continuePolling;
       }
-      const result = await resolved.injected.evaluateHandle((injected, { info, root }) => {
+      const result = await progress.raceWithCleanup(resolved.injected.evaluateHandle((injected, { info, root }) => {
         if (root && !root.isConnected)
           throw injected.createStacklessError("Element is not attached to the DOM");
         const elements = injected.querySelectorAll(info.parsed, root || document);
@@ -644,8 +642,8 @@ class Frame extends import_instrumentation.SdkObject {
           log2 = `  locator resolved to ${visible2 ? "visible" : "hidden"} ${injected.previewNode(element2)}`;
         }
         return { log: log2, element: element2, visible: visible2, attached: !!element2 };
-      }, { info: resolved.info, root: resolved.frame === this ? scope : void 0 });
-      const { log, visible, attached } = await result.evaluate((r) => ({ log: r.log, visible: r.visible, attached: r.attached }));
+      }, { info: resolved.info, root: resolved.frame === this ? scope : void 0 }), (handle) => handle.dispose());
+      const { log, visible, attached } = await progress.race(result.evaluate((r) => ({ log: r.log, visible: r.visible, attached: r.attached })));
       if (log)
         progress.log(log);
       const success = { attached, detached: !attached, visible, hidden: !visible }[state];
@@ -657,14 +655,15 @@ class Frame extends import_instrumentation.SdkObject {
         result.dispose();
         return null;
       }
-      const element = state === "attached" || state === "visible" ? await result.evaluateHandle((r) => r.element) : null;
+      const element = state === "attached" || state === "visible" ? await progress.race(result.evaluateHandle((r) => r.element)) : null;
       result.dispose();
       if (!element)
         return null;
       if (options.__testHookBeforeAdoptNode)
-        await options.__testHookBeforeAdoptNode();
+        await progress.race(options.__testHookBeforeAdoptNode());
       try {
-        return await element._adoptTo(await resolved.frame._mainContext());
+        const mainContext = await progress.race(resolved.frame._mainContext());
+        return await progress.race(element._adoptTo(mainContext));
       } catch (e) {
         return continuePolling;
       }
@@ -715,7 +714,7 @@ class Frame extends import_instrumentation.SdkObject {
         return retVal;
       });
     } catch (e) {
-      if (js.isJavaScriptErrorInEvaluate(e) || (0, import_protocolError.isSessionClosedError)(e))
+      if ((0, import_progress.isAbortError)(e) || js.isJavaScriptErrorInEvaluate(e) || (0, import_protocolError.isSessionClosedError)(e))
         throw e;
       throw new Error(`Unable to retrieve content because the page is navigating and changing the content.`);
     }
@@ -870,16 +869,15 @@ class Frame extends import_instrumentation.SdkObject {
     const continuePolling = Symbol("continuePolling");
     timeouts = [0, ...timeouts];
     let timeoutIndex = 0;
-    while (progress.isRunning()) {
+    while (true) {
       const timeout = timeouts[Math.min(timeoutIndex++, timeouts.length - 1)];
       if (timeout) {
         const actionPromise = new Promise((f) => setTimeout(f, timeout));
-        await import_utils.LongStandingScope.raceMultiple([
+        await progress.race(import_utils.LongStandingScope.raceMultiple([
           this._page.openScope,
           this._detachedScope
-        ], actionPromise);
+        ], actionPromise));
       }
-      progress.throwIfAborted();
       try {
         const result = await action(continuePolling);
         if (result === continuePolling)
@@ -891,10 +889,10 @@ class Frame extends import_instrumentation.SdkObject {
         continue;
       }
     }
-    progress.throwIfAborted();
-    return void 0;
   }
   _isErrorThatCannotBeRetried(e) {
+    if ((0, import_progress.isAbortError)(e))
+      return true;
     if (js.isJavaScriptErrorInEvaluate(e) || (0, import_protocolError.isSessionClosedError)(e))
       return true;
     if (dom.isNonRecoverableDOMError(e) || (0, import_selectorParser.isInvalidSelectorError)(e))
@@ -908,11 +906,10 @@ class Frame extends import_instrumentation.SdkObject {
     return this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async (continuePolling) => {
       if (performActionPreChecks)
         await this._page.performActionPreChecks(progress);
-      const resolved = await this.selectors.resolveInjectedForSelector(selector, { strict });
-      progress.throwIfAborted();
+      const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, { strict }));
       if (!resolved)
         return continuePolling;
-      const result = await resolved.injected.evaluateHandle((injected, { info, callId }) => {
+      const result = await progress.raceWithCleanup(resolved.injected.evaluateHandle((injected, { info, callId }) => {
         const elements = injected.querySelectorAll(info.parsed, document);
         if (callId)
           injected.markTargetElements(new Set(elements), callId);
@@ -926,15 +923,15 @@ class Frame extends import_instrumentation.SdkObject {
           log2 = `  locator resolved to ${injected.previewNode(element2)}`;
         }
         return { log: log2, success: !!element2, element: element2 };
-      }, { info: resolved.info, callId: progress.metadata.id });
-      const { log, success } = await result.evaluate((r) => ({ log: r.log, success: r.success }));
+      }, { info: resolved.info, callId: progress.metadata.id }), (handle) => handle.dispose());
+      const { log, success } = await progress.race(result.evaluate((r) => ({ log: r.log, success: r.success })));
       if (log)
         progress.log(log);
       if (!success) {
         result.dispose();
         return continuePolling;
       }
-      const element = await result.evaluateHandle((r) => r.element);
+      const element = await progress.race(result.evaluateHandle((r) => r.element));
       result.dispose();
       try {
         const result2 = await action(element);
@@ -955,19 +952,19 @@ class Frame extends import_instrumentation.SdkObject {
     });
   }
   async click(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 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);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     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);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     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) => {
@@ -976,8 +973,7 @@ class Frame extends import_instrumentation.SdkObject {
         }, {
           ...options,
           waitAfter: "disabled",
-          position: options.sourcePosition,
-          timeout: progress.timeUntilDeadline()
+          position: options.sourcePosition
         });
       }));
       dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, options.strict, false, async (handle) => {
@@ -987,34 +983,33 @@ class Frame extends import_instrumentation.SdkObject {
         }, {
           ...options,
           waitAfter: "disabled",
-          position: options.targetPosition,
-          timeout: progress.timeUntilDeadline()
+          position: options.targetPosition
         });
       }));
     }, options.timeout);
   }
   async tap(metadata, selector, options) {
-    if (!this._page.browserContext._options.hasTouch)
-      throw new Error("The page does not support tap. Use hasTouch context option to enable touch support.");
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     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.");
       return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._tap(progress, options)));
     }, options.timeout);
   }
   async fill(metadata, selector, value, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     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);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     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);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     await controller.run(async (progress) => {
       dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._blur(progress)));
     }, options.timeout);
@@ -1069,24 +1064,24 @@ class Frame extends import_instrumentation.SdkObject {
     return result.matches;
   }
   async isVisible(metadata, selector, options = {}, scope) {
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run(async (progress) => {
       progress.log(`  checking visibility of ${this._asLocator(selector)}`);
-      return await this.isVisibleInternal(selector, options, scope);
+      return await this.isVisibleInternal(progress, selector, options, scope);
     }, 0);
   }
-  async isVisibleInternal(selector, options = {}, scope) {
+  async isVisibleInternal(progress, selector, options = {}, scope) {
     try {
-      const resolved = await this.selectors.resolveInjectedForSelector(selector, options, scope);
+      const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, options, scope));
       if (!resolved)
         return false;
-      return await resolved.injected.evaluate((injected, { info, root }) => {
+      return await progress.race(resolved.injected.evaluate((injected, { info, root }) => {
         const element = injected.querySelector(info.parsed, root || document, info.strict);
         const state = element ? injected.elementState(element, "visible") : { matches: false, received: "error:notconnected" };
         return state.matches;
-      }, { info: resolved.info, root: resolved.frame === this ? scope : void 0 });
+      }, { info: resolved.info, root: resolved.frame === this ? scope : void 0 }));
     } catch (e) {
-      if (js.isJavaScriptErrorInEvaluate(e) || (0, import_selectorParser.isInvalidSelectorError)(e) || (0, import_protocolError.isSessionClosedError)(e))
+      if ((0, import_progress.isAbortError)(e) || js.isJavaScriptErrorInEvaluate(e) || (0, import_selectorParser.isInvalidSelectorError)(e) || (0, import_protocolError.isSessionClosedError)(e))
         throw e;
       return false;
     }
@@ -1107,53 +1102,51 @@ 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);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     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);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     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);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     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);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     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);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     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);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     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);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     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);
-    return controller.run(async () => {
-      await new Promise((resolve) => setTimeout(resolve, timeout));
-    });
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    return controller.run((progress) => progress.wait(timeout));
   }
   async ariaSnapshot(metadata, selector, options) {
     const controller = new import_progress.ProgressController(metadata, this);
@@ -1174,7 +1167,8 @@ class Frame extends import_instrumentation.SdkObject {
       const start = timeout > 0 ? (0, import_utils.monotonicTime)() : 0;
       await new import_progress.ProgressController(metadata, this).run(async (progress) => {
         progress.log(`${(0, import_utils.renderTitleForCall)(metadata)}${timeout ? ` with timeout ${timeout}ms` : ""}`);
-        progress.log(`waiting for ${this._asLocator(selector)}`);
+        if (selector)
+          progress.log(`waiting for ${this._asLocator(selector)}`);
         await this._page.performActionPreChecks(progress);
       }, timeout);
       try {
@@ -1184,7 +1178,7 @@ class Frame extends import_instrumentation.SdkObject {
         if (resultOneShot.matches !== options.isNot)
           return resultOneShot;
       } catch (e) {
-        if (js.isJavaScriptErrorInEvaluate(e) || (0, import_selectorParser.isInvalidSelectorError)(e))
+        if ((0, import_progress.isAbortError)(e) || js.isJavaScriptErrorInEvaluate(e) || (0, import_selectorParser.isInvalidSelectorError)(e))
           throw e;
       }
       if (timeout > 0) {
@@ -1215,7 +1209,7 @@ class Frame extends import_instrumentation.SdkObject {
     }
   }
   async _expectInternal(progress, selector, options, lastIntermediateResult) {
-    const selectorInFrame = await this.selectors.resolveFrameForSelector(selector, { strict: true });
+    const selectorInFrame = selector ? await this.selectors.resolveFrameForSelector(selector, { strict: true }) : void 0;
     progress.throwIfAborted();
     const { frame, info } = selectorInFrame || { frame: this, info: void 0 };
     const world = options.expression === "to.have.property" ? "main" : info?.world ?? "utility";
@@ -1342,16 +1336,15 @@ class Frame extends import_instrumentation.SdkObject {
     this._parentFrame = null;
   }
   async _callOnElementOnceMatches(metadata, selector, body, taskData, options, scope) {
-    const callbackText = body.toString();
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run(async (progress) => {
+      const callbackText = body.toString();
       progress.log(`waiting for ${this._asLocator(selector)}`);
       const promise = this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async (continuePolling) => {
-        const resolved = await this.selectors.resolveInjectedForSelector(selector, options, scope);
-        progress.throwIfAborted();
+        const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, options, scope));
         if (!resolved)
           return continuePolling;
-        const { log, success, value } = await resolved.injected.evaluate((injected, { info, callbackText: callbackText2, taskData: taskData2, callId, root }) => {
+        const { log, success, value } = await progress.race(resolved.injected.evaluate((injected, { info, callbackText: callbackText2, taskData: taskData2, callId, root }) => {
           const callback = injected.eval(callbackText2);
           const element = injected.querySelector(info.parsed, root || document, info.strict);
           if (!element)
@@ -1360,7 +1353,7 @@ class Frame extends import_instrumentation.SdkObject {
           if (callId)
             injected.markTargetElements(/* @__PURE__ */ new Set([element]), callId);
           return { log: log2, success: true, value: callback(injected, element, taskData2) };
-        }, { info: resolved.info, callbackText, taskData, callId: progress.metadata.id, root: resolved.frame === this ? scope : void 0 });
+        }, { info: resolved.info, callbackText, taskData, callId: progress.metadata.id, root: resolved.frame === this ? scope : void 0 }));
         if (log)
           progress.log(log);
         if (!success)
@@ -1453,26 +1446,27 @@ class SignalBarrier {
   }
   waitFor() {
     this.release();
-    return this._promise;
+    return this._progress.race(this._promise);
   }
-  async addFrameNavigation(frame) {
+  addFrameNavigation(frame) {
     if (frame.parentFrame())
       return;
     this.retain();
-    const waiter = import_helper.helper.waitForEvent(null, frame, Frame.Events.InternalNavigation, (e) => {
+    const waiter = import_helper.helper.waitForEvent(this._progress, frame, Frame.Events.InternalNavigation, (e) => {
       if (!e.isPublic)
         return false;
       if (!e.error && this._progress)
         this._progress.log(`  navigated to "${frame._url}"`);
       return true;
     });
-    await import_utils.LongStandingScope.raceMultiple([
+    import_utils.LongStandingScope.raceMultiple([
       frame._page.openScope,
       frame._detachedScope
     ], waiter.promise).catch(() => {
+    }).finally(() => {
+      waiter.dispose();
+      this.release();
     });
-    waiter.dispose();
-    this.release();
   }
   retain() {
     ++this._protectCount;

package/lib/server/helper.js

@@ -65,8 +65,7 @@ class Helper {
       }));
     });
     const dispose = () => import_eventsHelper.eventsHelper.removeEventListeners(listeners);
-    if (progress)
-      progress.cleanupWhenAborted(dispose);
+    progress.cleanupWhenAborted(dispose);
     return { promise, dispose };
   }
   static secondsToRoundishMillis(value) {

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);
+    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
     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);
+    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
     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);
+    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
     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);
+    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
     return controller.run((progress) => this._type(progress, text, options));
   }
   async _type(progress, text, options) {
@@ -99,13 +99,13 @@ class Keyboard {
         await this._press(progress, char, { delay });
       } else {
         if (delay)
-          await wait(progress, delay);
+          await progress.wait(delay);
         await this._insertText(progress, char);
       }
     }
   }
   async press(metadata, key, options) {
-    const controller = new import_progress.ProgressController(metadata, this._page);
+    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
     return controller.run((progress) => this._press(progress, key, options));
   }
   async _press(progress, key, options = {}) {
@@ -129,7 +129,7 @@ class Keyboard {
       await this._down(progress, tokens[i]);
     await this._down(progress, key);
     if (options.delay)
-      await wait(progress, options.delay);
+      await progress.wait(options.delay);
     await this._up(progress, key);
     for (let i = tokens.length - 2; i >= 0; --i)
       await this._up(progress, tokens[i]);
@@ -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);
+    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
     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);
+    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
     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);
+    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
     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);
+    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
     return controller.run((progress) => this._click(progress, x, y, options));
   }
   async _click(progress, x, y, options = {}) {
@@ -222,10 +222,10 @@ class Mouse {
       this._move(progress, x, y, { forClick: true });
       for (let cc = 1; cc <= clickCount; ++cc) {
         await this._down(progress, { ...options, clickCount: cc });
-        await wait(progress, delay);
+        await progress.wait(delay);
         await this._up(progress, { ...options, clickCount: cc });
         if (cc < clickCount)
-          await wait(progress, delay);
+          await progress.wait(delay);
       }
     } else {
       const promises = [];
@@ -238,7 +238,7 @@ class Mouse {
     }
   }
   async wheel(metadata, deltaX, deltaY) {
-    const controller = new import_progress.ProgressController(metadata, this._page);
+    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
     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);
+    const controller = new import_progress.ProgressController(metadata, this._page, "strict");
     return controller.run((progress) => this._tap(progress, x, y));
   }
   async _tap(progress, x, y) {
@@ -304,10 +304,6 @@ class Touchscreen {
     await this._raw.tap(progress, x, y, this._page.keyboard._modifiers());
   }
 }
-async function wait(progress, ms) {
-  await new Promise((f) => setTimeout(f, Math.min(ms, progress.timeUntilDeadline())));
-  progress.throwIfAborted();
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Keyboard,

package/lib/server/page.js

@@ -55,6 +55,7 @@ var import_manualPromise = require("../utils/isomorphic/manualPromise");
 var import_utilityScriptSerializers = require("../utils/isomorphic/utilityScriptSerializers");
 var import_callLog = require("./callLog");
 var rawBindingsControllerSource = __toESM(require("../generated/bindingsControllerSource"));
+var import_protocolError = require("./protocolError");
 class Page extends import_instrumentation.SdkObject {
   constructor(delegate, browserContext) {
     super(browserContext, "page");
@@ -340,7 +341,7 @@ class Page extends import_instrumentation.SdkObject {
       return;
     for (const [uid, handler] of this._locatorHandlers) {
       if (!handler.resolved) {
-        if (await this.mainFrame().isVisibleInternal(handler.selector, { strict: true })) {
+        if (await this.mainFrame().isVisibleInternal(progress, handler.selector, { strict: true })) {
           handler.resolved = new import_manualPromise.ManualPromise();
           this.emit(Page.Events.LocatorHandlerTriggered, uid);
         }
@@ -357,8 +358,7 @@ class Page extends import_instrumentation.SdkObject {
             progress.log(`  locator handler has finished`);
           }
         });
-        await this.openScope.race(promise).finally(() => --this._locatorHandlerRunningCounter);
-        progress.throwIfAborted();
+        await progress.race(this.openScope.race(promise)).finally(() => --this._locatorHandlerRunningCounter);
         progress.log(`  interception handler has finished, continuing`);
       }
     }
@@ -784,7 +784,7 @@ async function snapshotFrameForAI(metadata, frame, frameOrdinal, frameIds) {
           return continuePolling;
         return snapshotOrRetry;
       } catch (e) {
-        if (js.isJavaScriptErrorInEvaluate(e))
+        if ((0, import_progress.isAbortError)(e) || (0, import_protocolError.isSessionClosedError)(e) || js.isJavaScriptErrorInEvaluate(e))
           throw e;
         return continuePolling;
       }