playwright-core 1.54.0-alpha-2025-06-12 → 1.54.0-alpha-2025-06-14

package/lib/server/firefox/ffInput.js

@@ -58,7 +58,7 @@ class RawKeyboardImpl {
   constructor(client) {
     this._client = client;
   }
-  async keydown(modifiers, keyName, description, autoRepeat) {
+  async keydown(progress, modifiers, keyName, description, autoRepeat) {
     let text = description.text;
     if (text === "\r")
       text = "";
@@ -72,8 +72,9 @@ class RawKeyboardImpl {
       location,
       text
     });
+    progress.throwIfAborted();
   }
-  async keyup(modifiers, keyName, description) {
+  async keyup(progress, modifiers, keyName, description) {
     const { code, key, location } = description;
     await this._client.send("Page.dispatchKeyEvent", {
       type: "keyup",
@@ -83,16 +84,18 @@ class RawKeyboardImpl {
       location,
       repeat: false
     });
+    progress.throwIfAborted();
   }
-  async sendText(text) {
+  async sendText(progress, text) {
     await this._client.send("Page.insertText", { text });
+    progress.throwIfAborted();
   }
 }
 class RawMouseImpl {
   constructor(client) {
     this._client = client;
   }
-  async move(x, y, button, buttons, modifiers, forClick) {
+  async move(progress, x, y, button, buttons, modifiers, forClick) {
     await this._client.send("Page.dispatchMouseEvent", {
       type: "mousemove",
       button: 0,
@@ -101,8 +104,9 @@ class RawMouseImpl {
       y: Math.floor(y),
       modifiers: toModifiersMask(modifiers)
     });
+    progress.throwIfAborted();
   }
-  async down(x, y, button, buttons, modifiers, clickCount) {
+  async down(progress, x, y, button, buttons, modifiers, clickCount) {
     await this._client.send("Page.dispatchMouseEvent", {
       type: "mousedown",
       button: toButtonNumber(button),
@@ -112,8 +116,9 @@ class RawMouseImpl {
       modifiers: toModifiersMask(modifiers),
       clickCount
     });
+    progress.throwIfAborted();
   }
-  async up(x, y, button, buttons, modifiers, clickCount) {
+  async up(progress, x, y, button, buttons, modifiers, clickCount) {
     await this._client.send("Page.dispatchMouseEvent", {
       type: "mouseup",
       button: toButtonNumber(button),
@@ -123,8 +128,9 @@ class RawMouseImpl {
       modifiers: toModifiersMask(modifiers),
       clickCount
     });
+    progress.throwIfAborted();
   }
-  async wheel(x, y, buttons, modifiers, deltaX, deltaY) {
+  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", {
       deltaX,
@@ -134,6 +140,7 @@ class RawMouseImpl {
       deltaZ: 0,
       modifiers: toModifiersMask(modifiers)
     });
+    progress.throwIfAborted();
   }
   setPage(page) {
     this._page = page;
@@ -143,12 +150,13 @@ class RawTouchscreenImpl {
   constructor(client) {
     this._client = client;
   }
-  async tap(x, y, modifiers) {
+  async tap(progress, x, y, modifiers) {
     await this._client.send("Page.dispatchTapEvent", {
       x,
       y,
       modifiers: toModifiersMask(modifiers)
     });
+    progress.throwIfAborted();
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/server/firefox/ffPage.js

@@ -475,8 +475,8 @@ class FFPage {
   }
   async inputActionEpilogue() {
   }
-  async resetForReuse() {
-    await this.rawMouse.move(-1, -1, "none", /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), false);
+  async resetForReuse(progress) {
+    await this.rawMouse.move(progress, -1, -1, "none", /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), false);
   }
   async getFrameElement(frame) {
     const parent = frame.parentFrame();

package/lib/server/frames.js

@@ -488,7 +488,7 @@ class Frame extends import_instrumentation.SdkObject {
     const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), this);
     const data = {
       url,
-      gotoPromise: controller.run((progress) => this._gotoAction(progress, url, { referer }), 0)
+      gotoPromise: controller.run((progress) => this.gotoImpl(progress, url, { referer }), 0)
     };
     this._redirectedNavigations.set(documentId, data);
     data.gotoPromise.finally(() => this._redirectedNavigations.delete(documentId));
@@ -497,10 +497,10 @@ class Frame extends import_instrumentation.SdkObject {
     const constructedNavigationURL = (0, import_utils.constructURLBasedOnBaseURL)(this._page.browserContext._options.baseURL, url);
     const controller = new import_progress.ProgressController(metadata, this);
     return controller.run((progress) => {
-      return this.raceNavigationAction(progress, options, async () => this._gotoAction(progress, constructedNavigationURL, options));
+      return this.raceNavigationAction(progress, options, async () => this.gotoImpl(progress, constructedNavigationURL, options));
     }, options.timeout);
   }
-  async _gotoAction(progress, url, options) {
+  async gotoImpl(progress, url, options) {
     const waitUntil = verifyLifecycle("waitUntil", options.waitUntil === void 0 ? "load" : options.waitUntil);
     progress.log(`navigating to "${url}", waiting until "${waitUntil}"`);
     const headers = this._page.extraHTTPHeaders() || [];
@@ -971,8 +971,8 @@ class Frame extends import_instrumentation.SdkObject {
     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) => {
-          await this._page.mouse.move(point.x, point.y);
-          await this._page.mouse.down();
+          await this._page.mouse._move(progress, point.x, point.y);
+          await this._page.mouse._down(progress);
         }, {
           ...options,
           waitAfter: "disabled",
@@ -982,8 +982,8 @@ class Frame extends import_instrumentation.SdkObject {
       }));
       dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, options.strict, false, async (handle) => {
         return handle._retryPointerAction(progress, "move and up", false, async (point) => {
-          await this._page.mouse.move(point.x, point.y);
-          await this._page.mouse.up();
+          await this._page.mouse._move(progress, point.x, point.y);
+          await this._page.mouse._up(progress);
         }, {
           ...options,
           waitAfter: "disabled",

package/lib/server/input.js

@@ -38,21 +38,27 @@ __export(input_exports, {
 module.exports = __toCommonJS(input_exports);
 var import_utils = require("../utils");
 var keyboardLayout = __toESM(require("./usKeyboardLayout"));
+var import_progress = require("./progress");
 const keypadLocation = keyboardLayout.keypadLocation;
 const kModifiers = ["Alt", "Control", "Meta", "Shift"];
 class Keyboard {
-  constructor(raw) {
+  constructor(raw, page) {
     this._pressedModifiers = /* @__PURE__ */ new Set();
     this._pressedKeys = /* @__PURE__ */ new Set();
     this._raw = raw;
+    this._page = page;
   }
-  async down(key) {
+  async down(metadata, key) {
+    const controller = new import_progress.ProgressController(metadata, this._page);
+    return controller.run((progress) => this._down(progress, key));
+  }
+  async _down(progress, key) {
     const description = this._keyDescriptionForString(key);
     const autoRepeat = this._pressedKeys.has(description.code);
     this._pressedKeys.add(description.code);
     if (kModifiers.includes(description.key))
       this._pressedModifiers.add(description.key);
-    await this._raw.keydown(this._pressedModifiers, key, description, autoRepeat);
+    await this._raw.keydown(progress, this._pressedModifiers, key, description, autoRepeat);
   }
   _keyDescriptionForString(str) {
     const keyString = resolveSmartModifierString(str);
@@ -64,29 +70,45 @@ class Keyboard {
       return { ...description, text: "" };
     return description;
   }
-  async up(key) {
+  async up(metadata, key) {
+    const controller = new import_progress.ProgressController(metadata, this._page);
+    return controller.run((progress) => this._up(progress, key));
+  }
+  async _up(progress, key) {
     const description = this._keyDescriptionForString(key);
     if (kModifiers.includes(description.key))
       this._pressedModifiers.delete(description.key);
     this._pressedKeys.delete(description.code);
-    await this._raw.keyup(this._pressedModifiers, key, description);
+    await this._raw.keyup(progress, this._pressedModifiers, key, description);
   }
-  async insertText(text) {
-    await this._raw.sendText(text);
+  async insertText(metadata, text) {
+    const controller = new import_progress.ProgressController(metadata, this._page);
+    return controller.run((progress) => this._insertText(progress, text));
   }
-  async type(text, options) {
+  async _insertText(progress, text) {
+    await this._raw.sendText(progress, text);
+  }
+  async type(metadata, text, options) {
+    const controller = new import_progress.ProgressController(metadata, this._page);
+    return controller.run((progress) => this._type(progress, text, options));
+  }
+  async _type(progress, text, options) {
     const delay = options && options.delay || void 0;
     for (const char of text) {
       if (usKeyboardLayout.has(char)) {
-        await this.press(char, { delay });
+        await this._press(progress, char, { delay });
       } else {
         if (delay)
-          await new Promise((f) => setTimeout(f, delay));
-        await this.insertText(char);
+          await wait(progress, delay);
+        await this._insertText(progress, char);
       }
     }
   }
-  async press(key, options = {}) {
+  async press(metadata, key, options) {
+    const controller = new import_progress.ProgressController(metadata, this._page);
+    return controller.run((progress) => this._press(progress, key, options));
+  }
+  async _press(progress, key, options = {}) {
     function split(keyString) {
       const keys = [];
       let building = "";
@@ -104,15 +126,15 @@ class Keyboard {
     const tokens = split(key);
     key = tokens[tokens.length - 1];
     for (let i = 0; i < tokens.length - 1; ++i)
-      await this.down(tokens[i]);
-    await this.down(key);
+      await this._down(progress, tokens[i]);
+    await this._down(progress, key);
     if (options.delay)
-      await new Promise((f) => setTimeout(f, options.delay));
-    await this.up(key);
+      await wait(progress, options.delay);
+    await this._up(progress, key);
     for (let i = tokens.length - 2; i >= 0; --i)
-      await this.up(tokens[i]);
+      await this._up(progress, tokens[i]);
   }
-  async ensureModifiers(mm) {
+  async ensureModifiers(progress, mm) {
     const modifiers = mm.map(resolveSmartModifier);
     for (const modifier of modifiers) {
       if (!kModifiers.includes(modifier))
@@ -123,9 +145,9 @@ class Keyboard {
       const needDown = modifiers.includes(key);
       const isDown = this._pressedModifiers.has(key);
       if (needDown && !isDown)
-        await this.down(key);
+        await this._down(progress, key);
       else if (!needDown && isDown)
-        await this.up(key);
+        await this._up(progress, key);
     }
     return restore;
   }
@@ -151,9 +173,14 @@ class Mouse {
     this._page = page;
     this._keyboard = this._page.keyboard;
   }
-  async move(x, y, options = {}, metadata) {
-    if (metadata)
-      metadata.point = { x, y };
+  currentPoint() {
+    return { x: this._x, y: this._y };
+  }
+  async move(metadata, x, y, options) {
+    const controller = new import_progress.ProgressController(metadata, this._page);
+    return controller.run((progress) => this._move(progress, x, y, options));
+  }
+  async _move(progress, x, y, options = {}) {
     const { steps = 1 } = options;
     const fromX = this._x;
     const fromY = this._y;
@@ -162,53 +189,59 @@ class Mouse {
     for (let i = 1; i <= steps; i++) {
       const middleX = fromX + (x - fromX) * (i / steps);
       const middleY = fromY + (y - fromY) * (i / steps);
-      await this._raw.move(middleX, middleY, this._lastButton, this._buttons, this._keyboard._modifiers(), !!options.forClick);
+      await this._raw.move(progress, middleX, middleY, this._lastButton, this._buttons, this._keyboard._modifiers(), !!options.forClick);
     }
   }
-  async down(options = {}, metadata) {
-    if (metadata)
-      metadata.point = { x: this._x, y: this._y };
+  async down(metadata, options) {
+    const controller = new import_progress.ProgressController(metadata, this._page);
+    return controller.run((progress) => this._down(progress, options));
+  }
+  async _down(progress, options = {}) {
     const { button = "left", clickCount = 1 } = options;
     this._lastButton = button;
     this._buttons.add(button);
-    await this._raw.down(this._x, this._y, this._lastButton, this._buttons, this._keyboard._modifiers(), clickCount);
+    await this._raw.down(progress, this._x, this._y, this._lastButton, this._buttons, this._keyboard._modifiers(), clickCount);
   }
-  async up(options = {}, metadata) {
-    if (metadata)
-      metadata.point = { x: this._x, y: this._y };
+  async up(metadata, options) {
+    const controller = new import_progress.ProgressController(metadata, this._page);
+    return controller.run((progress) => this._up(progress, options));
+  }
+  async _up(progress, options = {}) {
     const { button = "left", clickCount = 1 } = options;
     this._lastButton = "none";
     this._buttons.delete(button);
-    await this._raw.up(this._x, this._y, button, this._buttons, this._keyboard._modifiers(), clickCount);
+    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);
+    return controller.run((progress) => this._click(progress, x, y, options));
   }
-  async click(x, y, options = {}, metadata) {
-    if (metadata)
-      metadata.point = { x, y };
+  async _click(progress, x, y, options = {}) {
     const { delay = null, clickCount = 1 } = options;
     if (delay) {
-      this.move(x, y, { forClick: true });
+      this._move(progress, x, y, { forClick: true });
       for (let cc = 1; cc <= clickCount; ++cc) {
-        await this.down({ ...options, clickCount: cc });
-        await new Promise((f) => setTimeout(f, delay));
-        await this.up({ ...options, clickCount: cc });
+        await this._down(progress, { ...options, clickCount: cc });
+        await wait(progress, delay);
+        await this._up(progress, { ...options, clickCount: cc });
         if (cc < clickCount)
-          await new Promise((f) => setTimeout(f, delay));
+          await wait(progress, delay);
       }
     } else {
       const promises = [];
-      promises.push(this.move(x, y, { forClick: true }));
+      promises.push(this._move(progress, x, y, { forClick: true }));
       for (let cc = 1; cc <= clickCount; ++cc) {
-        promises.push(this.down({ ...options, clickCount: cc }));
-        promises.push(this.up({ ...options, clickCount: cc }));
+        promises.push(this._down(progress, { ...options, clickCount: cc }));
+        promises.push(this._up(progress, { ...options, clickCount: cc }));
       }
       await Promise.all(promises);
     }
   }
-  async dblclick(x, y, options = {}) {
-    await this.click(x, y, { ...options, clickCount: 2 });
-  }
-  async wheel(deltaX, deltaY) {
-    await this._raw.wheel(this._x, this._y, this._buttons, this._keyboard._modifiers(), deltaX, deltaY);
+  async wheel(metadata, deltaX, deltaY) {
+    const controller = new import_progress.ProgressController(metadata, this._page);
+    return controller.run(async (progress) => {
+      await this._raw.wheel(progress, this._x, this._y, this._buttons, this._keyboard._modifiers(), deltaX, deltaY);
+    });
   }
 }
 const aliases = /* @__PURE__ */ new Map([
@@ -261,14 +294,20 @@ class Touchscreen {
     this._raw = raw;
     this._page = page;
   }
-  async tap(x, y, metadata) {
-    if (metadata)
-      metadata.point = { x, y };
+  async tap(metadata, x, y) {
+    const controller = new import_progress.ProgressController(metadata, this._page);
+    return controller.run((progress) => this._tap(progress, x, y));
+  }
+  async _tap(progress, x, y) {
     if (!this._page.browserContext._options.hasTouch)
       throw new Error("hasTouch must be enabled on the browser context before using the touchscreen.");
-    await this._raw.tap(x, y, this._page.keyboard._modifiers());
+    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/launchApp.js

@@ -67,7 +67,7 @@ async function launchApp(browserType, options) {
     context.on("page", async (newPage) => {
       if (newPage.mainFrame().url() === "chrome://new-tab-page/") {
         await page.bringToFront();
-        await newPage.close((0, import_instrumentation.serverSideCallMetadata)());
+        await newPage.close();
       }
     });
   }

package/lib/server/page.js

@@ -83,7 +83,7 @@ class Page extends import_instrumentation.SdkObject {
     this.delegate = delegate;
     this.browserContext = browserContext;
     this.accessibility = new accessibility.Accessibility(delegate.getAccessibilityTree.bind(delegate));
-    this.keyboard = new input.Keyboard(delegate.rawKeyboard);
+    this.keyboard = new input.Keyboard(delegate.rawKeyboard, this);
     this.mouse = new input.Mouse(delegate.rawMouse, this);
     this.touchscreen = new input.Touchscreen(delegate.rawTouchscreen, this);
     this.screenshotter = new import_screenshotter.Screenshotter(this);
@@ -153,9 +153,9 @@ class Page extends import_instrumentation.SdkObject {
     else
       this._eventsToEmitAfterInitialized.push({ event, args });
   }
-  async resetForReuse(metadata) {
+  async resetForReuse(progress) {
     this._locatorHandlers.clear();
-    await this.mainFrame().goto(metadata, "about:blank", { timeout: 0 });
+    await this.mainFrame().gotoImpl(progress, "about:blank", {});
     this._emulatedSize = void 0;
     this._emulatedMedia = {};
     this._extraHTTPHeaders = void 0;
@@ -163,7 +163,7 @@ class Page extends import_instrumentation.SdkObject {
       this.delegate.updateEmulatedViewportSize(),
       this.delegate.updateEmulateMedia()
     ]);
-    await this.delegate.resetForReuse();
+    await this.delegate.resetForReuse(progress);
   }
   _didClose() {
     this.frameManager.dispose();
@@ -530,7 +530,7 @@ class Page extends import_instrumentation.SdkObject {
       options.timeout
     );
   }
-  async close(metadata, options = {}) {
+  async close(options = {}) {
     if (this._closedState === "closed")
       return;
     if (options.reason)

package/lib/server/recorder/recorderRunner.js

@@ -38,7 +38,7 @@ async function performAction(pageAliases, actionInContext) {
   if (action.name === "openPage")
     throw Error("Not reached");
   if (action.name === "closePage") {
-    await mainFrame._page.close(callMetadata);
+    await mainFrame._page.close();
     return;
   }
   const selector = (0, import_recorderUtils.buildFullSelector)(actionInContext.frame.framePath, action.selector);

package/lib/server/webkit/wkInput.js

@@ -65,7 +65,7 @@ class RawKeyboardImpl {
   setSession(session) {
     this._session = session;
   }
-  async keydown(modifiers, keyName, description, autoRepeat) {
+  async keydown(progress, modifiers, keyName, description, autoRepeat) {
     const parts = [];
     for (const modifier of ["Shift", "Control", "Alt", "Meta"]) {
       if (modifiers.has(modifier))
@@ -89,8 +89,9 @@ class RawKeyboardImpl {
       macCommands: commands,
       isKeypad: description.location === input.keypadLocation
     });
+    progress.throwIfAborted();
   }
-  async keyup(modifiers, keyName, description) {
+  async keyup(progress, modifiers, keyName, description) {
     const { code, key } = description;
     await this._pageProxySession.send("Input.dispatchKeyEvent", {
       type: "keyUp",
@@ -100,9 +101,11 @@ class RawKeyboardImpl {
       code,
       isKeypad: description.location === input.keypadLocation
     });
+    progress.throwIfAborted();
   }
-  async sendText(text) {
+  async sendText(progress, text) {
     await this._session.send("Page.insertText", { text });
+    progress.throwIfAborted();
   }
 }
 class RawMouseImpl {
@@ -112,7 +115,7 @@ class RawMouseImpl {
   setSession(session) {
     this._session = session;
   }
-  async move(x, y, button, buttons, modifiers, forClick) {
+  async move(progress, x, y, button, buttons, modifiers, forClick) {
     await this._pageProxySession.send("Input.dispatchMouseEvent", {
       type: "move",
       button,
@@ -121,8 +124,9 @@ class RawMouseImpl {
       y,
       modifiers: toModifiersMask(modifiers)
     });
+    progress.throwIfAborted();
   }
-  async down(x, y, button, buttons, modifiers, clickCount) {
+  async down(progress, x, y, button, buttons, modifiers, clickCount) {
     await this._pageProxySession.send("Input.dispatchMouseEvent", {
       type: "down",
       button,
@@ -132,8 +136,9 @@ class RawMouseImpl {
       modifiers: toModifiersMask(modifiers),
       clickCount
     });
+    progress.throwIfAborted();
   }
-  async up(x, y, button, buttons, modifiers, clickCount) {
+  async up(progress, x, y, button, buttons, modifiers, clickCount) {
     await this._pageProxySession.send("Input.dispatchMouseEvent", {
       type: "up",
       button,
@@ -143,12 +148,14 @@ class RawMouseImpl {
       modifiers: toModifiersMask(modifiers),
       clickCount
     });
+    progress.throwIfAborted();
   }
-  async wheel(x, y, buttons, modifiers, deltaX, deltaY) {
+  async wheel(progress, x, y, buttons, modifiers, deltaX, deltaY) {
     if (this._page?.browserContext._options.isMobile)
       throw new Error("Mouse wheel is not supported in mobile WebKit");
     await this._session.send("Page.updateScrollingState");
     await this._page.mainFrame().evaluateExpression(`new Promise(requestAnimationFrame)`, { world: "utility" });
+    progress.throwIfAborted();
     await this._pageProxySession.send("Input.dispatchWheelEvent", {
       x,
       y,
@@ -156,6 +163,7 @@ class RawMouseImpl {
       deltaY,
       modifiers: toModifiersMask(modifiers)
     });
+    progress.throwIfAborted();
   }
   setPage(page) {
     this._page = page;
@@ -165,12 +173,13 @@ class RawTouchscreenImpl {
   constructor(session) {
     this._pageProxySession = session;
   }
-  async tap(x, y, modifiers) {
+  async tap(progress, x, y, modifiers) {
     await this._pageProxySession.send("Input.dispatchTapEvent", {
       x,
       y,
       modifiers: toModifiersMask(modifiers)
     });
+    progress.throwIfAborted();
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/server/webkit/wkPage.js

@@ -907,7 +907,7 @@ class WKPage {
   }
   async inputActionEpilogue() {
   }
-  async resetForReuse() {
+  async resetForReuse(progress) {
   }
   async getFrameElement(frame) {
     const parent = frame.parentFrame();