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

package/lib/server/dom.js

@@ -124,7 +124,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 ((0, import_progress.isAbortError)(e) || js.isJavaScriptErrorInEvaluate(e) || (0, import_protocolError.isSessionClosedError)(e))
         throw e;
       return "error:notconnected";
     }
@@ -134,7 +134,7 @@ 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 ((0, import_progress.isAbortError)(e) || js.isJavaScriptErrorInEvaluate(e) || (0, import_protocolError.isSessionClosedError)(e))
         throw e;
       return "error:notconnected";
     }
@@ -209,23 +209,23 @@ class ElementHandle extends js.JSHandle {
   async dispatchEvent(metadata, type, eventInit = {}) {
     return this._frame.dispatchEvent(metadata, ":scope", type, eventInit, { timeout: 0 }, 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);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run(
       (progress) => this._waitAndScrollIntoViewIfNeeded(
         progress,
@@ -289,13 +289,14 @@ 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) {
+      progress.throwIfAborted();
       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;
         }
@@ -332,7 +333,6 @@ class ElementHandle extends js.JSHandle {
       }
       return result;
     }
-    return "done";
   }
   async _retryPointerAction(progress, actionName, waitForEnabled, action, options) {
     const skipActionPreChecks = actionName === "move and up";
@@ -363,51 +363,51 @@ 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) {
@@ -425,7 +425,7 @@ class ElementHandle extends js.JSHandle {
     }
     const actionResult = await this._page.frameManager.waitForSignalsCreatedBy(progress, options.waitAfter === true, async () => {
       if (options.__testHookBeforePointerAction)
-        await options.__testHookBeforePointerAction();
+        await progress.race(options.__testHookBeforePointerAction());
       progress.throwIfAborted();
       let restoreModifiers;
       if (options && options.modifiers)
@@ -441,7 +441,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;
         }
@@ -449,7 +449,7 @@ 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";
     });
     if (actionResult !== "done")
@@ -457,18 +457,18 @@ class ElementHandle extends js.JSHandle {
     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);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run(async (progress) => {
-      await this._markAsTargetElement(metadata);
+      await this._markAsTargetElement(progress);
       const result = await this._hover(progress, options);
       return assertDone(throwRetargetableDOMError(result));
     }, options.timeout);
@@ -477,9 +477,9 @@ class ElementHandle extends js.JSHandle {
     return this._retryPointerAction(progress, "hover", false, (point) => this._page.mouse._move(progress, point.x, point.y), { ...options, waitAfter: "disabled" });
   }
   async click(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run(async (progress) => {
-      await this._markAsTargetElement(metadata);
+      await this._markAsTargetElement(progress);
       const result = await this._click(progress, { ...options, waitAfter: !options.noWaitAfter });
       return assertDone(throwRetargetableDOMError(result));
     }, options.timeout);
@@ -488,9 +488,9 @@ class ElementHandle extends js.JSHandle {
     return this._retryPointerAction(progress, "click", true, (point) => this._page.mouse._click(progress, point.x, point.y, options), options);
   }
   async dblclick(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run(async (progress) => {
-      await this._markAsTargetElement(metadata);
+      await this._markAsTargetElement(progress);
       const result = await this._dblclick(progress, options);
       return assertDone(throwRetargetableDOMError(result));
     }, options.timeout);
@@ -499,9 +499,9 @@ class ElementHandle extends js.JSHandle {
     return this._retryPointerAction(progress, "dblclick", true, (point) => this._page.mouse._click(progress, point.x, point.y, { ...options, clickCount: 2 }), { ...options, waitAfter: "disabled" });
   }
   async tap(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run(async (progress) => {
-      await this._markAsTargetElement(metadata);
+      await this._markAsTargetElement(progress);
       const result = await this._tap(progress, options);
       return assertDone(throwRetargetableDOMError(result));
     }, options.timeout);
@@ -510,9 +510,9 @@ class ElementHandle extends js.JSHandle {
     return this._retryPointerAction(progress, "tap", true, (point) => this._page.touchscreen._tap(progress, point.x, point.y), { ...options, waitAfter: "disabled" });
   }
   async selectOption(metadata, elements, values, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run(async (progress) => {
-      await this._markAsTargetElement(metadata);
+      await this._markAsTargetElement(progress);
       const result = await this._selectOption(progress, elements, values, options);
       return throwRetargetableDOMError(result);
     }, options.timeout);
@@ -520,18 +520,18 @@ class ElementHandle extends js.JSHandle {
   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;
@@ -544,9 +544,9 @@ class ElementHandle extends js.JSHandle {
     return resultingOptions;
   }
   async fill(metadata, value, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run(async (progress) => {
-      await this._markAsTargetElement(metadata);
+      await this._markAsTargetElement(progress);
       const result = await this._fill(progress, value, options);
       assertDone(throwRetargetableDOMError(result));
     }, options.timeout);
@@ -554,17 +554,17 @@ class ElementHandle extends js.JSHandle {
   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 });
+      }, { value, force: options.force }));
       progress.throwIfAborted();
       if (result === "needsinput") {
         if (value)
@@ -578,28 +578,28 @@ class ElementHandle extends js.JSHandle {
     }, options);
   }
   async selectText(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     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 }]) => {
+        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 });
+        }, { force: options.force }));
       }, options);
       assertDone(throwRetargetableDOMError(result));
     }, options.timeout);
   }
   async setInputFiles(metadata, params) {
-    const inputFileItems = await (0, import_fileUploadUtils.prepareFilesForUpload)(this._frame, params);
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run(async (progress) => {
-      await this._markAsTargetElement(metadata);
+      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));
     }, params.timeout);
@@ -607,7 +607,7 @@ class ElementHandle extends js.JSHandle {
   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;
@@ -621,53 +621,50 @@ 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);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     await controller.run(async (progress) => {
-      await this._markAsTargetElement(metadata);
+      await this._markAsTargetElement(progress);
       const result = await this._focus(progress);
       return assertDone(throwRetargetableDOMError(result));
     }, 0);
   }
   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);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run(async (progress) => {
-      await this._markAsTargetElement(metadata);
+      await this._markAsTargetElement(progress);
       const result = await this._type(progress, text, options);
       return assertDone(throwRetargetableDOMError(result));
     }, options.timeout);
   }
   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
@@ -675,21 +672,20 @@ class ElementHandle extends js.JSHandle {
     );
     if (result !== "done")
       return result;
-    progress.throwIfAborted();
     await this._page.keyboard._type(progress, text, options);
     return "done";
   }
   async press(metadata, key, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run(async (progress) => {
-      await this._markAsTargetElement(metadata);
+      await this._markAsTargetElement(progress);
       const result = await this._press(progress, key, options);
       return assertDone(throwRetargetableDOMError(result));
     }, options.timeout);
   }
   async _press(progress, key, options) {
     progress.log(`elementHandle.press("${key}")`);
-    await this.instrumentation.onBeforeInputAction(this, progress.metadata);
+    await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
     return this._page.frameManager.waitForSignalsCreatedBy(progress, !options.noWaitAfter, async () => {
       const result = await this._focus(
         progress,
@@ -698,20 +694,19 @@ class ElementHandle extends js.JSHandle {
       );
       if (result !== "done")
         return result;
-      progress.throwIfAborted();
       await this._page.keyboard._press(progress, key, options);
       return "done";
     });
   }
   async check(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run(async (progress) => {
       const result = await this._setChecked(progress, true, options);
       return assertDone(throwRetargetableDOMError(result));
     }, options.timeout);
   }
   async uncheck(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run(async (progress) => {
       const result = await this._setChecked(progress, false, options);
       return assertDone(throwRetargetableDOMError(result));
@@ -719,12 +714,12 @@ class ElementHandle extends js.JSHandle {
   }
   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" });
@@ -780,13 +775,13 @@ class ElementHandle extends js.JSHandle {
     return this._frame.isChecked(metadata, ":scope", { timeout: 0 }, this);
   }
   async waitForElementState(metadata, state, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     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 progress.race(this.evaluateInUtility(async ([injected, node, state2]) => {
           return await injected.checkElementStates(node, [state2]) || "done";
-        }, state);
+        }, state));
       }, {});
       assertDone(throwRetargetableDOMError(result));
     }, options.timeout);

package/lib/server/firefox/ffInput.js

@@ -63,7 +63,7 @@ class RawKeyboardImpl {
     if (text === "\r")
       text = "";
     const { code, key, location } = description;
-    await this._client.send("Page.dispatchKeyEvent", {
+    await progress.race(this._client.send("Page.dispatchKeyEvent", {
       type: "keydown",
       keyCode: description.keyCodeWithoutLocation,
       code,
@@ -71,24 +71,21 @@ class RawKeyboardImpl {
       repeat: autoRepeat,
       location,
       text
-    });
-    progress.throwIfAborted();
+    }));
   }
   async keyup(progress, modifiers, keyName, description) {
     const { code, key, location } = description;
-    await this._client.send("Page.dispatchKeyEvent", {
+    await progress.race(this._client.send("Page.dispatchKeyEvent", {
       type: "keyup",
       key,
       keyCode: description.keyCodeWithoutLocation,
       code,
       location,
       repeat: false
-    });
-    progress.throwIfAborted();
+    }));
   }
   async sendText(progress, text) {
-    await this._client.send("Page.insertText", { text });
-    progress.throwIfAborted();
+    await progress.race(this._client.send("Page.insertText", { text }));
   }
 }
 class RawMouseImpl {
@@ -96,18 +93,17 @@ class RawMouseImpl {
     this._client = client;
   }
   async move(progress, x, y, button, buttons, modifiers, forClick) {
-    await this._client.send("Page.dispatchMouseEvent", {
+    await progress.race(this._client.send("Page.dispatchMouseEvent", {
       type: "mousemove",
       button: 0,
       buttons: toButtonsMask(buttons),
       x: Math.floor(x),
       y: Math.floor(y),
       modifiers: toModifiersMask(modifiers)
-    });
-    progress.throwIfAborted();
+    }));
   }
   async down(progress, x, y, button, buttons, modifiers, clickCount) {
-    await this._client.send("Page.dispatchMouseEvent", {
+    await progress.race(this._client.send("Page.dispatchMouseEvent", {
       type: "mousedown",
       button: toButtonNumber(button),
       buttons: toButtonsMask(buttons),
@@ -115,11 +111,10 @@ class RawMouseImpl {
       y: Math.floor(y),
       modifiers: toModifiersMask(modifiers),
       clickCount
-    });
-    progress.throwIfAborted();
+    }));
   }
   async up(progress, x, y, button, buttons, modifiers, clickCount) {
-    await this._client.send("Page.dispatchMouseEvent", {
+    await progress.race(this._client.send("Page.dispatchMouseEvent", {
       type: "mouseup",
       button: toButtonNumber(button),
       buttons: toButtonsMask(buttons),
@@ -127,20 +122,18 @@ class RawMouseImpl {
       y: Math.floor(y),
       modifiers: toModifiersMask(modifiers),
       clickCount
-    });
-    progress.throwIfAborted();
+    }));
   }
   async wheel(progress, x, y, buttons, modifiers, deltaX, deltaY) {
     await this._page.mainFrame().evaluateExpression(`new Promise(requestAnimationFrame)`, { world: "utility" });
-    await this._client.send("Page.dispatchWheelEvent", {
+    await progress.race(this._client.send("Page.dispatchWheelEvent", {
       deltaX,
       deltaY,
       x: Math.floor(x),
       y: Math.floor(y),
       deltaZ: 0,
       modifiers: toModifiersMask(modifiers)
-    });
-    progress.throwIfAborted();
+    }));
   }
   setPage(page) {
     this._page = page;
@@ -151,12 +144,11 @@ class RawTouchscreenImpl {
     this._client = client;
   }
   async tap(progress, x, y, modifiers) {
-    await this._client.send("Page.dispatchTapEvent", {
+    await progress.race(this._client.send("Page.dispatchTapEvent", {
       x,
       y,
       modifiers: toModifiersMask(modifiers)
-    });
-    progress.throwIfAborted();
+    }));
   }
 }
 // Annotate the CommonJS export names for ESM import in node: