patchright-core 1.52.4 → 1.55.0

package/lib/server/dom.js

@@ -40,11 +40,9 @@ __export(dom_exports, {
 module.exports = __toCommonJS(dom_exports);
 var import_fs = __toESM(require("fs"));
 var js = __toESM(require("./javascript"));
-var import_progress = require("./progress");
 var import_utils = require("../utils");
 var import_fileUploadUtils = require("./fileUploadUtils");
-var import_protocolError = require("./protocolError");
-var injectedScriptSource = __toESM(require("../generated/injectedScriptSource"));
+var rawInjectedScriptSource = __toESM(require("../generated/injectedScriptSource"));
 class NonRecoverableDOMError extends Error {
 }
 function isNonRecoverableDOMError(error) {
@@ -58,7 +56,7 @@ class FrameExecutionContext extends js.ExecutionContext {
   }
   adoptIfNeeded(handle) {
     if (handle instanceof ElementHandle && handle._context !== this)
-      return this.frame._page._delegate.adoptElementHandle(handle, this);
+      return this.frame._page.delegate.adoptElementHandle(handle, this);
     return null;
   }
   async evaluate(pageFunction, arg) {
@@ -75,25 +73,24 @@ class FrameExecutionContext extends js.ExecutionContext {
   }
   injectedScript() {
     if (!this._injectedScriptPromise) {
-      const custom = [];
-      const selectorsRegistry = this.frame._page.context().selectors();
+      const customEngines = [];
+      const selectorsRegistry = this.frame._page.browserContext.selectors();
       for (const [name, { source: source2 }] of selectorsRegistry._engines)
-        custom.push(`{ name: '${name}', engine: (${source2}) }`);
-      const sdkLanguage = this.frame.attribution.playwright.options.sdkLanguage;
+        customEngines.push({ name, source: `(${source2})` });
+      const sdkLanguage = this.frame._page.browserContext._browser.sdkLanguage();
+      const options = {
+        isUnderTest: (0, import_utils.isUnderTest)(),
+        sdkLanguage,
+        testIdAttributeName: selectorsRegistry.testIdAttributeName(),
+        stableRafCount: this.frame._page.delegate.rafCountForStablePosition(),
+        browserName: this.frame._page.browserContext._browser.options.name,
+        customEngines
+      };
       const source = `
         (() => {
         const module = {};
-        ${injectedScriptSource.source}
-        return new (module.exports.InjectedScript())(
-          globalThis,
-          ${(0, import_utils.isUnderTest)()},
-          "${sdkLanguage}",
-          ${JSON.stringify(selectorsRegistry.testIdAttributeName())},
-          ${this.frame._page._delegate.rafCountForStablePosition()},
-          "${this.frame._page._browserContext._browser.options.name}",
-          ${process.env.PLAYWRIGHT_INPUT_FILE_TEXTBOX ? "true" : "false"},
-          [${custom.join(",\n")}]
-        );
+        ${rawInjectedScriptSource.source}
+        return new (module.exports.InjectedScript())(globalThis, ${JSON.stringify(options)});
         })();
       `;
       this._injectedScriptPromise = this.rawEvaluateHandle(source).then((handle) => {
@@ -125,7 +122,7 @@ class ElementHandle extends js.JSHandle {
       const utility = await this._frame._utilityContext();
       return await utility.evaluate(pageFunction, [await utility.injectedScript(), this, arg]);
     } catch (e) {
-      if (js.isJavaScriptErrorInEvaluate(e) || (0, import_protocolError.isSessionClosedError)(e))
+      if (this._frame.isNonRetriableError(e))
         throw e;
       return "error:notconnected";
     }
@@ -135,20 +132,20 @@ class ElementHandle extends js.JSHandle {
       const utility = await this._frame._utilityContext();
       return await utility.evaluateHandle(pageFunction, [await utility.injectedScript(), this, arg]);
     } catch (e) {
-      if (js.isJavaScriptErrorInEvaluate(e) || (0, import_protocolError.isSessionClosedError)(e))
+      if (this._frame.isNonRetriableError(e))
         throw e;
       return "error:notconnected";
     }
   }
   async ownerFrame() {
-    const frameId = await this._page._delegate.getOwnerFrame(this);
+    const frameId = await this._page.delegate.getOwnerFrame(this);
     if (!frameId)
       return null;
-    const frame = this._page._frameManager.frame(frameId);
+    const frame = this._page.frameManager.frame(frameId);
     if (frame)
       return frame;
-    for (const page of this._page._browserContext.pages()) {
-      const frame2 = page._frameManager.frame(frameId);
+    for (const page of this._page.browserContext.pages()) {
+      const frame2 = page.frameManager.frame(frameId);
       if (frame2)
         return frame2;
     }
@@ -161,58 +158,46 @@ class ElementHandle extends js.JSHandle {
     const isFrameElement = throwRetargetableDOMError(await this.isIframeElement());
     if (!isFrameElement)
       return null;
-    return this._page._delegate.getContentFrame(this);
+    return this._page.delegate.getContentFrame(this);
   }
-  async generateLocatorString() {
-    const selector = await this.evaluateInUtility(async ([injected, node]) => {
-      return injected.generateSelectorSimple(node);
-    }, {});
-    if (selector === "error:notconnected")
-      return;
-    return (0, import_utils.asLocator)("javascript", selector);
+  async getAttribute(progress, name) {
+    return this._frame.getAttribute(progress, ":scope", name, {}, this);
   }
-  async getAttribute(metadata, name) {
-    return this._frame.getAttribute(metadata, ":scope", name, {}, this);
+  async inputValue(progress) {
+    return this._frame.inputValue(progress, ":scope", {}, this);
   }
-  async inputValue(metadata) {
-    return this._frame.inputValue(metadata, ":scope", {}, this);
+  async textContent(progress) {
+    return this._frame.textContent(progress, ":scope", {}, this);
   }
-  async textContent(metadata) {
-    return this._frame.textContent(metadata, ":scope", {}, this);
+  async innerText(progress) {
+    return this._frame.innerText(progress, ":scope", {}, this);
   }
-  async innerText(metadata) {
-    return this._frame.innerText(metadata, ":scope", {}, this);
+  async innerHTML(progress) {
+    return this._frame.innerHTML(progress, ":scope", {}, this);
   }
-  async innerHTML(metadata) {
-    return this._frame.innerHTML(metadata, ":scope", {}, this);
+  async dispatchEvent(progress, type, eventInit = {}) {
+    return this._frame.dispatchEvent(progress, ":scope", type, eventInit, {}, this);
   }
-  async dispatchEvent(metadata, type, eventInit = {}) {
-    return this._frame.dispatchEvent(metadata, ":scope", type, eventInit, {}, this);
-  }
-  async _scrollRectIntoViewIfNeeded(rect) {
-    return await this._page._delegate.scrollRectIntoViewIfNeeded(this, rect);
+  async _scrollRectIntoViewIfNeeded(progress, rect) {
+    return await progress.race(this._page.delegate.scrollRectIntoViewIfNeeded(this, rect));
   }
   async _waitAndScrollIntoViewIfNeeded(progress, waitForVisible) {
     const result = await this._retryAction(progress, "scroll into view", async () => {
       progress.log(`  waiting for element to be stable`);
-      const waitResult = await this.evaluateInUtility(async ([injected, node, { waitForVisible: waitForVisible2 }]) => {
+      const waitResult = await progress.race(this.evaluateInUtility(async ([injected, node, { waitForVisible: waitForVisible2 }]) => {
         return await injected.checkElementStates(node, waitForVisible2 ? ["visible", "stable"] : ["stable"]);
-      }, { waitForVisible });
+      }, { waitForVisible }));
       if (waitResult)
         return waitResult;
-      return await this._scrollRectIntoViewIfNeeded();
+      return await this._scrollRectIntoViewIfNeeded(progress);
     }, {});
     assertDone(throwRetargetableDOMError(result));
   }
-  async scrollIntoViewIfNeeded(metadata, options = {}) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(
-      (progress) => this._waitAndScrollIntoViewIfNeeded(
-        progress,
-        false
-        /* waitForVisible */
-      ),
-      this._page._timeoutSettings.timeout(options)
+  async scrollIntoViewIfNeeded(progress) {
+    await this._waitAndScrollIntoViewIfNeeded(
+      progress,
+      false
+      /* waitForVisible */
     );
   }
   async _clickablePoint() {
@@ -232,7 +217,7 @@ class ElementHandle extends js.JSHandle {
       return Math.abs(area);
     };
     const [quads, metrics] = await Promise.all([
-      this._page._delegate.getContentQuads(this),
+      this._page.delegate.getContentQuads(this),
       this._page.mainFrame()._utilityContext().then((utility) => utility.evaluate(() => ({ width: innerWidth, height: innerHeight })))
     ]);
     if (quads === "error:notconnected")
@@ -242,7 +227,7 @@ class ElementHandle extends js.JSHandle {
     const filtered = quads.map((quad) => intersectQuadWithViewport(quad)).filter((quad) => computeQuadArea(quad) > 0.99);
     if (!filtered.length)
       return "error:notinviewport";
-    if (this._page._browserContext._browser.options.name === "firefox") {
+    if (this._page.browserContext._browser.options.name === "firefox") {
       for (const quad of filtered) {
         const integerPoint = findIntegerPointInsideQuad(quad);
         if (integerPoint)
@@ -269,13 +254,13 @@ class ElementHandle extends js.JSHandle {
   async _retryAction(progress, actionName, action, options) {
     let retry = 0;
     const waitTime = [0, 20, 100, 100, 500];
-    while (progress.isRunning()) {
+    while (true) {
       if (retry) {
         progress.log(`retrying ${actionName} action${options.trial ? " (trial run)" : ""}`);
         const timeout = waitTime[Math.min(retry - 1, waitTime.length - 1)];
         if (timeout) {
           progress.log(`  waiting ${timeout}ms`);
-          const result2 = await this.evaluateInUtility(([injected, node, timeout2]) => new Promise((f) => setTimeout(f, timeout2)), timeout);
+          const result2 = await progress.race(this.evaluateInUtility(([injected, node, timeout2]) => new Promise((f) => setTimeout(f, timeout2)), timeout));
           if (result2 === "error:notconnected")
             return result2;
         }
@@ -302,6 +287,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;
@@ -312,7 +301,6 @@ class ElementHandle extends js.JSHandle {
       }
       return result;
     }
-    return "done";
   }
   async _retryPointerAction(progress, actionName, waitForEnabled, action, options) {
     const skipActionPreChecks = actionName === "move and up";
@@ -337,51 +325,49 @@ class ElementHandle extends js.JSHandle {
           return "done";
         }, forceScrollOptions);
       }
-      return await this._scrollRectIntoViewIfNeeded(position ? { x: position.x, y: position.y, width: 0, height: 0 } : void 0);
+      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 doScrollIntoView().catch(() => {
-      });
+      await progress.race(doScrollIntoView().catch(() => {
+      }));
     }
     if (options.__testHookBeforeStable)
-      await options.__testHookBeforeStable();
+      await progress.race(options.__testHookBeforeStable());
     if (!force) {
       const elementStates = waitForEnabled ? ["visible", "enabled", "stable"] : ["visible", "stable"];
       progress.log(`  waiting for element to be ${waitForEnabled ? "visible, enabled and stable" : "visible and stable"}`);
-      const result = await this.evaluateInUtility(async ([injected, node, { elementStates: elementStates2 }]) => {
+      const result = await progress.race(this.evaluateInUtility(async ([injected, node, { elementStates: elementStates2 }]) => {
         return await injected.checkElementStates(node, elementStates2);
-      }, { elementStates });
+      }, { elementStates }));
       if (result)
         return result;
       progress.log(`  element is ${waitForEnabled ? "visible, enabled and stable" : "visible and stable"}`);
     }
     if (options.__testHookAfterStable)
-      await options.__testHookAfterStable();
+      await progress.race(options.__testHookAfterStable());
     progress.log("  scrolling into view if needed");
-    progress.throwIfAborted();
-    const scrolled = await doScrollIntoView();
+    const scrolled = await progress.race(doScrollIntoView());
     if (scrolled !== "done")
       return scrolled;
     progress.log("  done scrolling");
-    const maybePoint = position ? await this._offsetPoint(position) : await this._clickablePoint();
+    const maybePoint = position ? await progress.race(this._offsetPoint(position)) : await progress.race(this._clickablePoint());
     if (typeof maybePoint === "string")
       return maybePoint;
     const point = roundPoint(maybePoint);
     progress.metadata.point = point;
-    await this.instrumentation.onBeforeInputAction(this, progress.metadata);
+    await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
     let hitTargetInterceptionHandle;
     if (force) {
       progress.log(`  forcing action`);
     } else {
       if (options.__testHookBeforeHitTarget)
-        await options.__testHookBeforeHitTarget();
-      const frameCheckResult = await this._checkFrameIsHitTarget(point);
+        await progress.race(options.__testHookBeforeHitTarget());
+      const frameCheckResult = await progress.race(this._checkFrameIsHitTarget(point));
       if (frameCheckResult === "error:notconnected" || "hitTargetDescription" in frameCheckResult)
         return frameCheckResult;
       const hitPoint = frameCheckResult.framePoint;
       const actionType = actionName === "move and up" ? "drag" : actionName === "hover" || actionName === "tap" ? actionName : "mouse";
-      const handle = await this.evaluateHandleInUtility(([injected, node, { actionType: actionType2, hitPoint: hitPoint2, trial }]) => injected.setupHitTargetInterceptor(node, actionType2, hitPoint2, trial), { actionType, hitPoint, trial: !!options.trial });
+      const handle = await progress.race(this.evaluateHandleInUtility(([injected, node, { actionType: actionType2, hitPoint: hitPoint2, trial }]) => injected.setupHitTargetInterceptor(node, actionType2, hitPoint2, trial), { actionType, hitPoint, trial: !!options.trial }));
       if (handle === "error:notconnected")
         return handle;
       if (!handle._objectId) {
@@ -391,23 +377,17 @@ class ElementHandle extends js.JSHandle {
         return { hitTargetDescription: error };
       }
       hitTargetInterceptionHandle = handle;
-      progress.cleanupWhenAborted(() => {
-        hitTargetInterceptionHandle.evaluate((h) => h.stop()).catch((e) => {
-        });
-        hitTargetInterceptionHandle.dispose();
-      });
     }
-    const actionResult = await this._page._frameManager.waitForSignalsCreatedBy(progress, options.waitAfter === true, async () => {
+    const actionResult = await this._page.frameManager.waitForSignalsCreatedBy(progress, options.waitAfter === true, async () => {
       if (options.__testHookBeforePointerAction)
-        await options.__testHookBeforePointerAction();
-      progress.throwIfAborted();
+        await progress.race(options.__testHookBeforePointerAction());
       let restoreModifiers;
       if (options && options.modifiers)
-        restoreModifiers = await this._page.keyboard.ensureModifiers(options.modifiers);
+        restoreModifiers = await this._page.keyboard.ensureModifiers(progress, options.modifiers);
       progress.log(`  performing ${actionName} action`);
       await action(point);
       if (restoreModifiers)
-        await this._page.keyboard.ensureModifiers(restoreModifiers);
+        await this._page.keyboard.ensureModifiers(progress, restoreModifiers);
       if (hitTargetInterceptionHandle) {
         const stopHitTargetInterception = this._frame.raceAgainstEvaluationStallingEvents(() => {
           return hitTargetInterceptionHandle.evaluate((h) => h.stop());
@@ -415,7 +395,7 @@ class ElementHandle extends js.JSHandle {
           hitTargetInterceptionHandle?.dispose();
         });
         if (options.waitAfter !== false) {
-          const hitTargetResult = await stopHitTargetInterception;
+          const hitTargetResult = await progress.race(stopHitTargetInterception);
           if (hitTargetResult !== "done")
             return hitTargetResult;
         }
@@ -423,89 +403,78 @@ class ElementHandle extends js.JSHandle {
       progress.log(`  ${options.trial ? "trial " : ""}${actionName} action done`);
       progress.log("  waiting for scheduled navigations to finish");
       if (options.__testHookAfterPointerAction)
-        await options.__testHookAfterPointerAction();
+        await progress.race(options.__testHookAfterPointerAction());
       return "done";
+    }).finally(() => {
+      const stopPromise = hitTargetInterceptionHandle?.evaluate((h) => h.stop()).catch(() => {
+      });
+      stopPromise?.then(() => hitTargetInterceptionHandle?.dispose());
     });
     if (actionResult !== "done")
       return actionResult;
     progress.log("  navigations have finished");
     return "done";
   }
-  async _markAsTargetElement(metadata) {
-    if (!metadata.id)
+  async _markAsTargetElement(progress) {
+    if (!progress.metadata.id)
       return;
-    await this.evaluateInUtility(([injected, node, callId]) => {
+    await progress.race(this.evaluateInUtility(([injected, node, callId]) => {
       if (node.nodeType === 1)
         injected.markTargetElements(/* @__PURE__ */ new Set([node]), callId);
-    }, metadata.id);
+    }, progress.metadata.id));
   }
-  async hover(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      await this._markAsTargetElement(metadata);
-      const result = await this._hover(progress, options);
-      return assertDone(throwRetargetableDOMError(result));
-    }, this._page._timeoutSettings.timeout(options));
+  async hover(progress, options) {
+    await this._markAsTargetElement(progress);
+    const result = await this._hover(progress, options);
+    return assertDone(throwRetargetableDOMError(result));
   }
   _hover(progress, options) {
-    return this._retryPointerAction(progress, "hover", false, (point) => this._page.mouse.move(point.x, point.y), { ...options, waitAfter: "disabled" });
+    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);
-    return controller.run(async (progress) => {
-      await this._markAsTargetElement(metadata);
-      const result = await this._click(progress, { ...options, waitAfter: !options.noWaitAfter });
-      return assertDone(throwRetargetableDOMError(result));
-    }, this._page._timeoutSettings.timeout(options));
+  async click(progress, options) {
+    await this._markAsTargetElement(progress);
+    const result = await this._click(progress, { ...options, waitAfter: !options.noWaitAfter });
+    return assertDone(throwRetargetableDOMError(result));
   }
   _click(progress, options) {
-    return this._retryPointerAction(progress, "click", true, (point) => this._page.mouse.click(point.x, point.y, options), options);
+    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);
-    return controller.run(async (progress) => {
-      await this._markAsTargetElement(metadata);
-      const result = await this._dblclick(progress, options);
-      return assertDone(throwRetargetableDOMError(result));
-    }, this._page._timeoutSettings.timeout(options));
+  async dblclick(progress, options) {
+    await this._markAsTargetElement(progress);
+    const result = await this._dblclick(progress, options);
+    return assertDone(throwRetargetableDOMError(result));
   }
   _dblclick(progress, options) {
-    return this._retryPointerAction(progress, "dblclick", true, (point) => this._page.mouse.dblclick(point.x, point.y, options), { ...options, waitAfter: "disabled" });
+    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);
-    return controller.run(async (progress) => {
-      await this._markAsTargetElement(metadata);
-      const result = await this._tap(progress, options);
-      return assertDone(throwRetargetableDOMError(result));
-    }, this._page._timeoutSettings.timeout(options));
+  async tap(progress, options) {
+    await this._markAsTargetElement(progress);
+    const result = await this._tap(progress, options);
+    return assertDone(throwRetargetableDOMError(result));
   }
   _tap(progress, options) {
-    return this._retryPointerAction(progress, "tap", true, (point) => this._page.touchscreen.tap(point.x, point.y), { ...options, waitAfter: "disabled" });
+    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);
-    return controller.run(async (progress) => {
-      await this._markAsTargetElement(metadata);
-      const result = await this._selectOption(progress, elements, values, options);
-      return throwRetargetableDOMError(result);
-    }, this._page._timeoutSettings.timeout(options));
+  async selectOption(progress, elements, values, options) {
+    await this._markAsTargetElement(progress);
+    const result = await this._selectOption(progress, elements, values, options);
+    return throwRetargetableDOMError(result);
   }
   async _selectOption(progress, elements, values, options) {
     let resultingOptions = [];
     const result = await this._retryAction(progress, "select option", async () => {
-      await this.instrumentation.onBeforeInputAction(this, progress.metadata);
+      await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
       if (!options.force)
         progress.log(`  waiting for element to be visible and enabled`);
       const optionsToSelect = [...elements, ...values];
-      const result2 = await this.evaluateInUtility(async ([injected, node, { optionsToSelect: optionsToSelect2, force }]) => {
+      const result2 = await progress.race(this.evaluateInUtility(async ([injected, node, { optionsToSelect: optionsToSelect2, force }]) => {
         if (!force) {
           const checkResult = await injected.checkElementStates(node, ["visible", "enabled"]);
           if (checkResult)
             return checkResult;
         }
         return injected.selectOptions(node, optionsToSelect2);
-      }, { optionsToSelect, force: options.force });
+      }, { optionsToSelect, force: options.force }));
       if (Array.isArray(result2)) {
         progress.log("  selected specified option(s)");
         resultingOptions = result2;
@@ -517,71 +486,61 @@ class ElementHandle extends js.JSHandle {
       return result;
     return resultingOptions;
   }
-  async fill(metadata, value, options = {}) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      await this._markAsTargetElement(metadata);
-      const result = await this._fill(progress, value, options);
-      assertDone(throwRetargetableDOMError(result));
-    }, this._page._timeoutSettings.timeout(options));
+  async fill(progress, value, options) {
+    await this._markAsTargetElement(progress);
+    const result = await this._fill(progress, value, options);
+    assertDone(throwRetargetableDOMError(result));
   }
   async _fill(progress, value, options) {
     progress.log(`  fill("${value}")`);
     return await this._retryAction(progress, "fill", async () => {
-      await this.instrumentation.onBeforeInputAction(this, progress.metadata);
+      await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
       if (!options.force)
         progress.log("  waiting for element to be visible, enabled and editable");
-      const result = await this.evaluateInUtility(async ([injected, node, { value: value2, force }]) => {
+      const result = await progress.race(this.evaluateInUtility(async ([injected, node, { value: value2, force }]) => {
         if (!force) {
           const checkResult = await injected.checkElementStates(node, ["visible", "enabled", "editable"]);
           if (checkResult)
             return checkResult;
         }
         return injected.fill(node, value2);
-      }, { value, force: options.force });
-      progress.throwIfAborted();
+      }, { value, force: options.force }));
       if (result === "needsinput") {
         if (value)
-          await this._page.keyboard.insertText(value);
+          await this._page.keyboard.insertText(progress, value);
         else
-          await this._page.keyboard.press("Delete");
+          await this._page.keyboard.press(progress, "Delete");
         return "done";
       } else {
         return result;
       }
     }, options);
   }
-  async selectText(metadata, options = {}) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      const result = await this._retryAction(progress, "selectText", async () => {
-        if (!options.force)
-          progress.log("  waiting for element to be visible");
-        return await this.evaluateInUtility(async ([injected, node, { force }]) => {
-          if (!force) {
-            const checkResult = await injected.checkElementStates(node, ["visible"]);
-            if (checkResult)
-              return checkResult;
-          }
-          return injected.selectText(node);
-        }, { force: options.force });
-      }, options);
-      assertDone(throwRetargetableDOMError(result));
-    }, this._page._timeoutSettings.timeout(options));
-  }
-  async setInputFiles(metadata, params) {
-    const inputFileItems = await (0, import_fileUploadUtils.prepareFilesForUpload)(this._frame, params);
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      await this._markAsTargetElement(metadata);
-      const result = await this._setInputFiles(progress, inputFileItems);
-      return assertDone(throwRetargetableDOMError(result));
-    }, this._page._timeoutSettings.timeout(params));
+  async selectText(progress, options) {
+    const result = await this._retryAction(progress, "selectText", async () => {
+      if (!options.force)
+        progress.log("  waiting for element to be visible");
+      return await progress.race(this.evaluateInUtility(async ([injected, node, { force }]) => {
+        if (!force) {
+          const checkResult = await injected.checkElementStates(node, ["visible"]);
+          if (checkResult)
+            return checkResult;
+        }
+        return injected.selectText(node);
+      }, { force: options.force }));
+    }, options);
+    assertDone(throwRetargetableDOMError(result));
+  }
+  async setInputFiles(progress, params) {
+    const inputFileItems = await progress.race((0, import_fileUploadUtils.prepareFilesForUpload)(this._frame, params));
+    await this._markAsTargetElement(progress);
+    const result = await this._setInputFiles(progress, inputFileItems);
+    return assertDone(throwRetargetableDOMError(result));
   }
   async _setInputFiles(progress, items) {
     const { filePayloads, localPaths, localDirectory } = items;
     const multiple = filePayloads && filePayloads.length > 1 || localPaths && localPaths.length > 1;
-    const result = await this.evaluateHandleInUtility(([injected, node, { multiple: multiple2, directoryUpload }]) => {
+    const result = await progress.race(this.evaluateHandleInUtility(([injected, node, { multiple: multiple2, directoryUpload }]) => {
       const element = injected.retarget(node, "follow-label");
       if (!element)
         return;
@@ -595,53 +554,44 @@ class ElementHandle extends js.JSHandle {
       if (!directoryUpload && inputElement.webkitdirectory)
         throw injected.createStacklessError("[webkitdirectory] input requires passing a path to a directory");
       return inputElement;
-    }, { multiple, directoryUpload: !!localDirectory });
+    }, { multiple, directoryUpload: !!localDirectory }));
     if (result === "error:notconnected" || !result.asElement())
       return "error:notconnected";
     const retargeted = result.asElement();
-    await this.instrumentation.onBeforeInputAction(this, progress.metadata);
-    progress.throwIfAborted();
+    await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
     if (localPaths || localDirectory) {
       const localPathsOrDirectory = localDirectory ? [localDirectory] : localPaths;
-      await Promise.all(localPathsOrDirectory.map((localPath) => import_fs.default.promises.access(localPath, import_fs.default.constants.F_OK)));
+      await progress.race(Promise.all(localPathsOrDirectory.map((localPath) => import_fs.default.promises.access(localPath, import_fs.default.constants.F_OK))));
       const waitForInputEvent = localDirectory ? this.evaluate((node) => new Promise((fulfill) => {
         node.addEventListener("input", fulfill, { once: true });
       })).catch(() => {
       }) : Promise.resolve();
-      await this._page._delegate.setInputFilePaths(retargeted, localPathsOrDirectory);
-      await waitForInputEvent;
+      await progress.race(this._page.delegate.setInputFilePaths(retargeted, localPathsOrDirectory));
+      await progress.race(waitForInputEvent);
     } else {
-      await retargeted.evaluateInUtility(([injected, node, files]) => injected.setInputFiles(node, files), filePayloads);
+      await progress.race(retargeted.evaluateInUtility(([injected, node, files]) => injected.setInputFiles(node, files), filePayloads));
     }
     return "done";
   }
-  async focus(metadata) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    await controller.run(async (progress) => {
-      await this._markAsTargetElement(metadata);
-      const result = await this._focus(progress);
-      return assertDone(throwRetargetableDOMError(result));
-    }, 0);
+  async focus(progress) {
+    await this._markAsTargetElement(progress);
+    const result = await this._focus(progress);
+    return assertDone(throwRetargetableDOMError(result));
   }
   async _focus(progress, resetSelectionIfNotFocused) {
-    progress.throwIfAborted();
-    return await this.evaluateInUtility(([injected, node, resetSelectionIfNotFocused2]) => injected.focusNode(node, resetSelectionIfNotFocused2), resetSelectionIfNotFocused);
+    return await progress.race(this.evaluateInUtility(([injected, node, resetSelectionIfNotFocused2]) => injected.focusNode(node, resetSelectionIfNotFocused2), resetSelectionIfNotFocused));
   }
   async _blur(progress) {
-    progress.throwIfAborted();
-    return await this.evaluateInUtility(([injected, node]) => injected.blurNode(node), {});
+    return await progress.race(this.evaluateInUtility(([injected, node]) => injected.blurNode(node), {}));
   }
-  async type(metadata, text, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      await this._markAsTargetElement(metadata);
-      const result = await this._type(progress, text, options);
-      return assertDone(throwRetargetableDOMError(result));
-    }, this._page._timeoutSettings.timeout(options));
+  async type(progress, text, options) {
+    await this._markAsTargetElement(progress);
+    const result = await this._type(progress, text, options);
+    return assertDone(throwRetargetableDOMError(result));
   }
   async _type(progress, text, options) {
     progress.log(`elementHandle.type("${text}")`);
-    await this.instrumentation.onBeforeInputAction(this, progress.metadata);
+    await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
     const result = await this._focus(
       progress,
       true
@@ -649,22 +599,18 @@ class ElementHandle extends js.JSHandle {
     );
     if (result !== "done")
       return result;
-    progress.throwIfAborted();
-    await this._page.keyboard.type(text, options);
+    await this._page.keyboard.type(progress, text, options);
     return "done";
   }
-  async press(metadata, key, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      await this._markAsTargetElement(metadata);
-      const result = await this._press(progress, key, options);
-      return assertDone(throwRetargetableDOMError(result));
-    }, this._page._timeoutSettings.timeout(options));
+  async press(progress, key, options) {
+    await this._markAsTargetElement(progress);
+    const result = await this._press(progress, key, options);
+    return assertDone(throwRetargetableDOMError(result));
   }
   async _press(progress, key, options) {
     progress.log(`elementHandle.press("${key}")`);
-    await this.instrumentation.onBeforeInputAction(this, progress.metadata);
-    return this._page._frameManager.waitForSignalsCreatedBy(progress, !options.noWaitAfter, async () => {
+    await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
+    return this._page.frameManager.waitForSignalsCreatedBy(progress, !options.noWaitAfter, async () => {
       const result = await this._focus(
         progress,
         true
@@ -672,33 +618,26 @@ class ElementHandle extends js.JSHandle {
       );
       if (result !== "done")
         return result;
-      progress.throwIfAborted();
-      await this._page.keyboard.press(key, options);
+      await this._page.keyboard.press(progress, key, options);
       return "done";
     });
   }
-  async check(metadata, options) {
-    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));
-    }, this._page._timeoutSettings.timeout(options));
+  async check(progress, options) {
+    const result = await this._setChecked(progress, true, options);
+    return assertDone(throwRetargetableDOMError(result));
   }
-  async uncheck(metadata, options) {
-    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));
-    }, this._page._timeoutSettings.timeout(options));
+  async uncheck(progress, options) {
+    const result = await this._setChecked(progress, false, options);
+    return assertDone(throwRetargetableDOMError(result));
   }
   async _setChecked(progress, state, options) {
     const isChecked = async () => {
-      const result2 = await this.evaluateInUtility(([injected, node]) => injected.elementState(node, "checked"), {});
+      const result2 = await progress.race(this.evaluateInUtility(([injected, node]) => injected.elementState(node, "checked"), {}));
       if (result2 === "error:notconnected" || result2.received === "error:notconnected")
         throwElementIsNotAttached();
       return result2.matches;
     };
-    await this._markAsTargetElement(progress.metadata);
+    await this._markAsTargetElement(progress);
     if (await isChecked() === state)
       return "done";
     const result = await this._click(progress, { ...options, waitAfter: "disabled" });
@@ -711,17 +650,13 @@ class ElementHandle extends js.JSHandle {
     return "done";
   }
   async boundingBox() {
-    return this._page._delegate.getBoundingBox(this);
+    return this._page.delegate.getBoundingBox(this);
   }
-  async ariaSnapshot(options) {
-    return await this.evaluateInUtility(([injected, element, options2]) => injected.ariaSnapshot(element, options2), options);
+  async ariaSnapshot() {
+    return await this.evaluateInUtility(([injected, element]) => injected.ariaSnapshot(element, { mode: "expect" }), {});
   }
-  async screenshot(metadata, options = {}) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(
-      (progress) => this._page._screenshotter.screenshotElement(progress, this, options),
-      this._page._timeoutSettings.timeout(options)
-    );
+  async screenshot(progress, options) {
+    return await this._page.screenshotter.screenshotElement(progress, this, options);
   }
   async querySelector(selector, options) {
     return this._frame.selectors.query(selector, options, this);
@@ -735,42 +670,39 @@ class ElementHandle extends js.JSHandle {
   async evalOnSelectorAll(selector, expression, isFunction, arg) {
     return this._frame.evalOnSelectorAll(selector, expression, isFunction, arg, this);
   }
-  async isVisible(metadata) {
-    return this._frame.isVisible(metadata, ":scope", {}, this);
+  async isVisible(progress) {
+    return this._frame.isVisible(progress, ":scope", {}, this);
   }
-  async isHidden(metadata) {
-    return this._frame.isHidden(metadata, ":scope", {}, this);
+  async isHidden(progress) {
+    return this._frame.isHidden(progress, ":scope", {}, this);
   }
-  async isEnabled(metadata) {
-    return this._frame.isEnabled(metadata, ":scope", {}, this);
+  async isEnabled(progress) {
+    return this._frame.isEnabled(progress, ":scope", {}, this);
   }
-  async isDisabled(metadata) {
-    return this._frame.isDisabled(metadata, ":scope", {}, this);
+  async isDisabled(progress) {
+    return this._frame.isDisabled(progress, ":scope", {}, this);
   }
-  async isEditable(metadata) {
-    return this._frame.isEditable(metadata, ":scope", {}, this);
+  async isEditable(progress) {
+    return this._frame.isEditable(progress, ":scope", {}, this);
   }
-  async isChecked(metadata) {
-    return this._frame.isChecked(metadata, ":scope", {}, this);
+  async isChecked(progress) {
+    return this._frame.isChecked(progress, ":scope", {}, this);
   }
-  async waitForElementState(metadata, state, options = {}) {
-    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 () => {
-        return await this.evaluateInUtility(async ([injected, node, state2]) => {
-          return await injected.checkElementStates(node, [state2]) || "done";
-        }, state);
-      }, {});
-      assertDone(throwRetargetableDOMError(result));
-    }, this._page._timeoutSettings.timeout(options));
+  async waitForElementState(progress, state) {
+    const actionName = `wait for ${state}`;
+    const result = await this._retryAction(progress, actionName, async () => {
+      return await progress.race(this.evaluateInUtility(async ([injected, node, state2]) => {
+        return await injected.checkElementStates(node, [state2]) || "done";
+      }, state));
+    }, {});
+    assertDone(throwRetargetableDOMError(result));
   }
-  async waitForSelector(metadata, selector, options = {}) {
-    return this._frame.waitForSelector(metadata, selector, options, this);
+  async waitForSelector(progress, selector, options) {
+    return await this._frame.waitForSelector(progress, selector, true, options, this);
   }
   async _adoptTo(context) {
     if (this._context !== context) {
-      const adopted = await this._page._delegate.adoptElementHandle(this, context);
+      const adopted = await this._page.delegate.adoptElementHandle(this, context);
       this.dispose();
       return adopted;
     }