patchright-core 1.52.4 → 1.55.0

package/lib/server/chromium/chromiumSwitches.js

@@ -21,31 +21,17 @@ __export(chromiumSwitches_exports, {
   chromiumSwitches: () => chromiumSwitches
 });
 module.exports = __toCommonJS(chromiumSwitches_exports);
-const disabledFeatures = [
+const disabledFeatures = (assistantMode) => [
   // See https://github.com/microsoft/playwright/pull/10380
   "AcceptCHFrame",
-  // See https://github.com/microsoft/playwright/pull/10679
-  "AutoExpandDetailsElement",
   // See https://github.com/microsoft/playwright/issues/14047
   "AvoidUnnecessaryBeforeUnloadCheckSync",
-  // See https://github.com/microsoft/playwright/pull/12992
-  "CertificateTransparencyComponentUpdater",
-  // This makes Page.frameScheduledNavigation arrive much later after a click,
-  // making our navigation auto-wait after click not working.
-  // Can be removed once we deperecate noWaitAfter.
-  // See https://github.com/microsoft/playwright/pull/34372.
-  "DeferRendererTasksAfterInput",
   "DestroyProfileOnBrowserClose",
   // See https://github.com/microsoft/playwright/pull/13854
   "DialMediaRouteProvider",
-  // Chromium is disabling manifest version 2. Allow testing it as long as Chromium can actually run it.
-  // Disabled in https://chromium-review.googlesource.com/c/chromium/src/+/6265903.
-  "ExtensionManifestV2Disabled",
   "GlobalMediaControls",
   // See https://github.com/microsoft/playwright/pull/27605
   "HttpsUpgrades",
-  "ImprovedCookieControls",
-  "LazyFrameLoading",
   // Hides the Lens feature in the URL address bar. Its not working in unofficial builds.
   "LensOverlay",
   // See https://github.com/microsoft/playwright/pull/8162
@@ -55,9 +41,12 @@ const disabledFeatures = [
   // See https://github.com/microsoft/playwright/issues/32230
   "ThirdPartyStoragePartitioning",
   // See https://github.com/microsoft/playwright/issues/16126
-  "Translate"
-];
-const chromiumSwitches = [
+  "Translate",
+  // See https://issues.chromium.org/u/1/issues/435410220
+  "AutoDeElevate",
+  assistantMode ? "AutomationControlled" : ""
+].filter(Boolean);
+const chromiumSwitches = (assistantMode, channel) => [
   "--disable-field-trial-config",
   // https://source.chromium.org/chromium/chromium/src/+/main:testing/variations/README.md
   "--disable-background-networking",
@@ -68,7 +57,8 @@ const chromiumSwitches = [
   // Avoids unneeded network activity after startup.
   "--no-default-browser-check",
   "--disable-dev-shm-usage",
-  "--disable-features=" + disabledFeatures.join(","),
+  "--disable-features=" + disabledFeatures(assistantMode).join(","),
+  channel === "chromium-tip-of-tree" ? "--enable-features=CDPScreenshotNewSurface" : "",
   "--disable-hang-monitor",
   "--disable-prompt-on-repost",
   "--disable-renderer-backgrounding",
@@ -81,8 +71,11 @@ const chromiumSwitches = [
   "--export-tagged-pdf",
   // https://chromium-review.googlesource.com/c/chromium/src/+/4853540
   "--disable-search-engine-choice-screen",
+  // Edge can potentially restart on Windows (msRelaunchNoCompatLayer) which looses its file descriptors (stdout/stderr) and CDP (3/4). Disable until fixed upstream.
+  "--edge-skip-compat-layer-relaunch",
+  assistantMode ? "" : "--enable-automation",
   "--disable-blink-features=AutomationControlled"
-];
+].filter(Boolean);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   chromiumSwitches

package/lib/server/chromium/crBrowser.js

@@ -66,7 +66,7 @@ class CRBrowser extends import_browser.Browser {
   }
   static async connect(parent, transport, options, devtools) {
     options = { ...options };
-    const connection = new import_crConnection.CRConnection(transport, options.protocolLogger, options.browserLogsCollector);
+    const connection = new import_crConnection.CRConnection(parent, transport, options.protocolLogger, options.browserLogsCollector);
     const browser = new CRBrowser(parent, connection, options);
     browser._devtools = devtools;
     if (browser.isClank())
@@ -133,7 +133,7 @@ class CRBrowser extends import_browser.Browser {
   async _waitForAllPagesToBeInitialized() {
     await Promise.all([...this._crPages.values()].map((crPage) => crPage._page.waitForInitializedOrError()));
   }
-  _onAttachedToTarget({ targetInfo, sessionId, waitingForDebugger }) {
+  _onAttachedToTarget({ targetInfo, sessionId }) {
     if (targetInfo.type === "browser")
       return;
     const session = this._session.createChildSession(sessionId);
@@ -210,7 +210,7 @@ class CRBrowser extends import_browser.Browser {
   }
   _findOwningPage(frameId) {
     for (const crPage of this._crPages.values()) {
-      const frame = crPage._page._frameManager.frame(frameId);
+      const frame = crPage._page.frameManager.frame(frameId);
       if (frame)
         return crPage;
     }
@@ -243,7 +243,7 @@ class CRBrowser extends import_browser.Browser {
   }
   async startTracing(page, options = {}) {
     (0, import_assert.assert)(!this._tracingRecording, "Cannot start recording trace while already recording trace.");
-    this._tracingClient = page ? page._delegate._mainFrameSession._client : this._session;
+    this._tracingClient = page ? page.delegate._mainFrameSession._client : this._session;
     const defaultCategories = [
       "-*",
       "devtools.timeline",
@@ -323,25 +323,57 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
     return this._crPages().map((crPage) => crPage._page);
   }
   async doCreateNewPage() {
-    (0, import_browserContext.assertBrowserContextIsNotOwned)(this);
     const { targetId } = await this._browser._session.send("Target.createTarget", { url: "about:blank", browserContextId: this._browserContextId });
     return this._browser._crPages.get(targetId)._page;
   }
   async doGetCookies(urls) {
     const { cookies } = await this._browser._session.send("Storage.getCookies", { browserContextId: this._browserContextId });
     return network.filterCookies(cookies.map((c) => {
-      const copy = { sameSite: "Lax", ...c };
-      delete copy.size;
-      delete copy.priority;
-      delete copy.session;
-      delete copy.sameParty;
-      delete copy.sourceScheme;
-      delete copy.sourcePort;
+      const { name, value, domain, path: path2, expires, httpOnly, secure, sameSite } = c;
+      const copy = {
+        name,
+        value,
+        domain,
+        path: path2,
+        expires,
+        httpOnly,
+        secure,
+        sameSite: sameSite ?? "Lax"
+      };
+      if (c.partitionKey) {
+        copy._crHasCrossSiteAncestor = c.partitionKey.hasCrossSiteAncestor;
+        copy.partitionKey = c.partitionKey.topLevelSite;
+      }
       return copy;
     }), urls);
   }
   async addCookies(cookies) {
-    await this._browser._session.send("Storage.setCookies", { cookies: network.rewriteCookies(cookies), browserContextId: this._browserContextId });
+    function toChromiumCookie(cookie) {
+      const { name, value, url, domain, path: path2, expires, httpOnly, secure, sameSite, partitionKey, _crHasCrossSiteAncestor } = cookie;
+      const copy = {
+        name,
+        value,
+        url,
+        domain,
+        path: path2,
+        expires,
+        httpOnly,
+        secure,
+        sameSite
+      };
+      if (partitionKey) {
+        copy.partitionKey = {
+          topLevelSite: partitionKey,
+          // _crHasCrossSiteAncestor is non-standard, set it true by default if the cookie is partitioned.
+          hasCrossSiteAncestor: _crHasCrossSiteAncestor ?? true
+        };
+      }
+      return copy;
+    }
+    await this._browser._session.send("Storage.setCookies", {
+      cookies: network.rewriteCookies(cookies).map(toChromiumCookie),
+      browserContextId: this._browserContextId
+    });
   }
   async doClearCookies() {
     await this._browser._session.send("Storage.clearCookies", { browserContextId: this._browserContextId });
@@ -363,7 +395,8 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
       ["payment-handler", "paymentHandler"],
       // chrome-specific permissions we have.
       ["midi-sysex", "midiSysex"],
-      ["storage-access", "storageAccess"]
+      ["storage-access", "storageAccess"],
+      ["local-fonts", "localFonts"]
     ]);
     const filtered = permissions.map((permission) => {
       const protocolPermission = webPermissionToProtocol.get(permission);
@@ -380,51 +413,55 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
     (0, import_browserContext.verifyGeolocation)(geolocation);
     this._options.geolocation = geolocation;
     for (const page of this.pages())
-      await page._delegate.updateGeolocation();
+      await page.delegate.updateGeolocation();
   }
-  async setExtraHTTPHeaders(headers) {
-    this._options.extraHTTPHeaders = headers;
+  async doUpdateExtraHTTPHeaders() {
     for (const page of this.pages())
-      await page._delegate.updateExtraHTTPHeaders();
+      await page.delegate.updateExtraHTTPHeaders();
     for (const sw of this.serviceWorkers())
       await sw.updateExtraHTTPHeaders();
   }
   async setUserAgent(userAgent) {
     this._options.userAgent = userAgent;
     for (const page of this.pages())
-      await page._delegate.updateUserAgent();
+      await page.delegate.updateUserAgent();
   }
-  async setOffline(offline) {
-    this._options.offline = offline;
+  async doUpdateOffline() {
     for (const page of this.pages())
-      await page._delegate.updateOffline();
+      await page.delegate.updateOffline();
     for (const sw of this.serviceWorkers())
       await sw.updateOffline();
   }
   async doSetHTTPCredentials(httpCredentials) {
     this._options.httpCredentials = httpCredentials;
     for (const page of this.pages())
-      await page._delegate.updateHttpCredentials();
+      await page.delegate.updateHttpCredentials();
     for (const sw of this.serviceWorkers())
       await sw.updateHttpCredentials();
   }
   async doAddInitScript(initScript) {
     for (const page of this.pages())
-      await page._delegate.addInitScript(initScript);
+      await page.delegate.addInitScript(initScript);
+  }
+  async doRemoveInitScripts(initScripts) {
+    for (const page of this.pages()) await page.delegate.removeInitScripts();
   }
   async doUpdateRequestInterception() {
     for (const page of this.pages())
-      await page._delegate.updateRequestInterception();
+      await page.delegate.updateRequestInterception();
     for (const sw of this.serviceWorkers())
       await sw.updateRequestInterception();
   }
+  async doUpdateDefaultViewport() {
+  }
+  async doUpdateDefaultEmulatedMedia() {
+  }
+  async doExposePlaywrightBinding() {
+    for (const page of this._crPages())
+      await page.exposePlaywrightBinding();
+  }
   async doClose(reason) {
-    const openedBeforeUnloadDialogs = [];
-    for (const crPage of this._crPages()) {
-      const dialogs = [...crPage._page._frameManager._openedDialogs].filter((dialog) => dialog.type() === "beforeunload");
-      openedBeforeUnloadDialogs.push(...dialogs);
-    }
-    await Promise.all(openedBeforeUnloadDialogs.map((dialog) => dialog.dismiss()));
+    await this.dialogManager.closeBeforeUnloadDialogs();
     if (!this._browserContextId) {
       await this.stopVideoRecording();
       await this._browser.close({ reason });
@@ -433,7 +470,7 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
     await this._browser._session.send("Target.disposeBrowserContext", { browserContextId: this._browserContextId });
     this._browser._contexts.delete(this._browserContextId);
     for (const [targetId, serviceWorker] of this._browser._serviceWorkers) {
-      if (serviceWorker._browserContext !== this)
+      if (serviceWorker.browserContext !== this)
         continue;
       serviceWorker.didClose();
       this._browser._serviceWorkers.delete(targetId);
@@ -469,14 +506,14 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
     return result;
   }
   serviceWorkers() {
-    return Array.from(this._browser._serviceWorkers.values()).filter((serviceWorker) => serviceWorker._browserContext === this);
+    return Array.from(this._browser._serviceWorkers.values()).filter((serviceWorker) => serviceWorker.browserContext === this);
   }
   async newCDPSession(page) {
     let targetId = null;
     if (page instanceof import_page.Page) {
-      targetId = page._delegate._targetId;
+      targetId = page.delegate._targetId;
     } else if (page instanceof import_frames.Frame) {
-      const session = page._page._delegate._sessions.get(page._id);
+      const session = page._page.delegate._sessions.get(page._id);
       if (!session)
         throw new Error(`This frame does not have a separate CDP session, it is a part of the parent frame's session`);
       targetId = session._targetId;
@@ -486,14 +523,11 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
     const rootSession = await this._browser._clientRootSession();
     return rootSession.attachToTarget(targetId);
   }
-  async doRemoveInitScripts() {
-    for (const page of this.pages()) await page._delegate.removeInitScripts();
-  }
   async doExposeBinding(binding) {
-    for (const page of this.pages()) await page._delegate.exposeBinding(binding);
+    for (const page of this.pages()) await page.delegate.exposeBinding(binding);
   }
   async doRemoveExposedBindings() {
-    for (const page of this.pages()) await page._delegate.removeExposedBindings();
+    for (const page of this.pages()) await page.delegate.removeExposedBindings();
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/server/chromium/crConnection.js

@@ -25,18 +25,18 @@ __export(crConnection_exports, {
   kBrowserCloseMessageId: () => kBrowserCloseMessageId
 });
 module.exports = __toCommonJS(crConnection_exports);
-var import_events = require("events");
 var import_utils = require("../../utils");
 var import_debugLogger = require("../utils/debugLogger");
 var import_helper = require("../helper");
 var import_protocolError = require("../protocolError");
+var import_instrumentation = require("../instrumentation");
 const ConnectionEvents = {
   Disconnected: Symbol("ConnectionEvents.Disconnected")
 };
 const kBrowserCloseMessageId = -9999;
-class CRConnection extends import_events.EventEmitter {
-  constructor(transport, protocolLogger, browserLogsCollector) {
-    super();
+class CRConnection extends import_instrumentation.SdkObject {
+  constructor(parent, transport, protocolLogger, browserLogsCollector) {
+    super(parent, "cr-connection");
     this._lastId = 0;
     this._sessions = /* @__PURE__ */ new Map();
     this._closed = false;
@@ -83,9 +83,9 @@ class CRConnection extends import_events.EventEmitter {
     return new CDPSession(this.rootSession, sessionId);
   }
 }
-class CRSession extends import_events.EventEmitter {
+class CRSession extends import_instrumentation.SdkObject {
   constructor(connection, parentSession, sessionId, eventListener) {
-    super();
+    super(connection, "cr-session");
     this._callbacks = /* @__PURE__ */ new Map();
     this._crashed = false;
     this._closed = false;
@@ -160,11 +160,10 @@ class CRSession extends import_events.EventEmitter {
     this._callbacks.clear();
   }
 }
-class CDPSession extends import_events.EventEmitter {
+class CDPSession extends import_instrumentation.SdkObject {
   constructor(parentSession, sessionId) {
-    super();
+    super(parentSession, "cdp-session");
     this._listeners = [];
-    this.guid = `cdp-session@${sessionId}`;
     this._session = parentSession.createChildSession(sessionId, (method, params) => this.emit(CDPSession.Events.Event, { method, params }));
     this._listeners = [import_utils.eventsHelper.addEventListener(parentSession, "Target.detachedFromTarget", (event) => {
       if (event.sessionId === sessionId)

package/lib/server/chromium/crCoverage.js

@@ -23,19 +23,20 @@ __export(crCoverage_exports, {
 module.exports = __toCommonJS(crCoverage_exports);
 var import_utils = require("../../utils");
 var import_eventsHelper = require("../utils/eventsHelper");
+var import_progress = require("../progress");
 class CRCoverage {
   constructor(client) {
     this._jsCoverage = new JSCoverage(client);
     this._cssCoverage = new CSSCoverage(client);
   }
-  async startJSCoverage(options) {
-    return await this._jsCoverage.start(options);
+  async startJSCoverage(progress, options) {
+    await (0, import_progress.raceUncancellableOperationWithCleanup)(progress, () => this._jsCoverage.start(options), () => this._jsCoverage.stop());
   }
   async stopJSCoverage() {
     return await this._jsCoverage.stop();
   }
-  async startCSSCoverage(options) {
-    return await this._cssCoverage.start(options);
+  async startCSSCoverage(progress, options) {
+    await (0, import_progress.raceUncancellableOperationWithCleanup)(progress, () => this._cssCoverage.start(options), () => this._cssCoverage.stop());
   }
   async stopCSSCoverage() {
     return await this._cssCoverage.stop();
@@ -92,8 +93,8 @@ class JSCoverage {
       this._scriptSources.set(event.scriptId, response.scriptSource);
   }
   async stop() {
-    (0, import_utils.assert)(this._enabled, "JSCoverage is not enabled");
-    this._enabled = false;
+    if (!this._enabled)
+      return { entries: [] };
     const [profileResponse] = await Promise.all([
       this._client.send("Profiler.takePreciseCoverage"),
       this._client.send("Profiler.stopPreciseCoverage"),
@@ -101,6 +102,7 @@ class JSCoverage {
       this._client.send("Debugger.disable")
     ]);
     import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
+    this._enabled = false;
     const coverage = { entries: [] };
     for (const entry of profileResponse.result) {
       if (!this._scriptIds.has(entry.scriptId))
@@ -159,14 +161,15 @@ class CSSCoverage {
     }
   }
   async stop() {
-    (0, import_utils.assert)(this._enabled, "CSSCoverage is not enabled");
-    this._enabled = false;
+    if (!this._enabled)
+      return { entries: [] };
     const ruleTrackingResponse = await this._client.send("CSS.stopRuleUsageTracking");
     await Promise.all([
       this._client.send("CSS.disable"),
       this._client.send("DOM.disable")
     ]);
     import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
+    this._enabled = false;
     const styleSheetIdToCoverage = /* @__PURE__ */ new Map();
     for (const entry of ruleTrackingResponse.ruleUsage) {
       let ranges = styleSheetIdToCoverage.get(entry.styleSheetId);

package/lib/server/chromium/crDragDrop.js

@@ -44,16 +44,16 @@ class DragManager {
     this._dragState = null;
     return true;
   }
-  async interceptDragCausedByMove(x, y, button, buttons, modifiers, moveCallback) {
+  async interceptDragCausedByMove(progress, x, y, button, buttons, modifiers, moveCallback) {
     this._lastPosition = { x, y };
     if (this._dragState) {
-      await this._crPage._mainFrameSession._client.send("Input.dispatchDragEvent", {
+      await progress.race(this._crPage._mainFrameSession._client.send("Input.dispatchDragEvent", {
         type: "dragOver",
         x,
         y,
         data: this._dragState,
         modifiers: (0, import_crProtocolHelper.toModifiersMask)(modifiers)
-      });
+      }));
       return;
     }
     if (button !== "left")
@@ -80,43 +80,48 @@ class DragManager {
         return val;
       };
     }
-    await this._crPage._page.safeNonStallingEvaluateInAllFrames(`(${setupDragListeners.toString()})()`, "utility");
-    client.on("Input.dragIntercepted", onDragIntercepted);
     try {
+      let expectingDrag = false;
+      await progress.race(this._crPage._page.safeNonStallingEvaluateInAllFrames(`(${setupDragListeners.toString()})()`, "utility"));
+      client.on("Input.dragIntercepted", onDragIntercepted);
       await client.send("Input.setInterceptDrags", { enabled: true });
-    } catch {
-      client.off("Input.dragIntercepted", onDragIntercepted);
-      return moveCallback();
+      try {
+        await progress.race(moveCallback());
+        expectingDrag = (await Promise.all(this._crPage._page.frames().map(async (frame) => {
+          return frame.nonStallingEvaluateInExistingContext("window.__cleanupDrag?.()", "utility").catch(() => false);
+        }))).some((x2) => x2);
+      } finally {
+        client.off("Input.dragIntercepted", onDragIntercepted);
+        await client.send("Input.setInterceptDrags", { enabled: false });
+      }
+      this._dragState = expectingDrag ? (await dragInterceptedPromise).data : null;
+    } catch (error) {
+      this._crPage._page.safeNonStallingEvaluateInAllFrames("window.__cleanupDrag?.()", "utility").catch(() => {
+      });
+      throw error;
     }
-    await moveCallback();
-    const expectingDrag = (await Promise.all(this._crPage._page.frames().map(async (frame) => {
-      return frame.nonStallingEvaluateInExistingContext("window.__cleanupDrag && window.__cleanupDrag()", "utility").catch(() => false);
-    }))).some((x2) => x2);
-    this._dragState = expectingDrag ? (await dragInterceptedPromise).data : null;
-    client.off("Input.dragIntercepted", onDragIntercepted);
-    await client.send("Input.setInterceptDrags", { enabled: false });
     if (this._dragState) {
-      await this._crPage._mainFrameSession._client.send("Input.dispatchDragEvent", {
+      await progress.race(this._crPage._mainFrameSession._client.send("Input.dispatchDragEvent", {
         type: "dragEnter",
         x,
         y,
         data: this._dragState,
         modifiers: (0, import_crProtocolHelper.toModifiersMask)(modifiers)
-      });
+      }));
     }
   }
   isDragging() {
     return !!this._dragState;
   }
-  async drop(x, y, modifiers) {
+  async drop(progress, x, y, modifiers) {
     (0, import_utils.assert)(this._dragState, "missing drag state");
-    await this._crPage._mainFrameSession._client.send("Input.dispatchDragEvent", {
+    await progress.race(this._crPage._mainFrameSession._client.send("Input.dispatchDragEvent", {
       type: "drop",
       x,
       y,
       data: this._dragState,
       modifiers: (0, import_crProtocolHelper.toModifiersMask)(modifiers)
-    });
+    }));
     this._dragState = null;
   }
 }

package/lib/server/chromium/crExecutionContext.js

@@ -35,6 +35,7 @@ module.exports = __toCommonJS(crExecutionContext_exports);
 var import_assert = require("../../utils/isomorphic/assert");
 var import_crProtocolHelper = require("./crProtocolHelper");
 var import_stackTrace = require("../../utils/isomorphic/stackTrace");
+var import_utilityScriptSerializers = require("../../utils/isomorphic/utilityScriptSerializers");
 var js = __toESM(require("../javascript"));
 var dom = __toESM(require("../dom"));
 var import_protocolError = require("../protocolError");
@@ -77,7 +78,7 @@ class CRExecutionContext {
     }).catch(rewriteError);
     if (exceptionDetails)
       throw new js.JavaScriptErrorInEvaluate((0, import_crProtocolHelper.getExceptionMessage)(exceptionDetails));
-    return returnByValue ? js.parseEvaluationResultValue(remoteObject.value) : createHandle(utilityScript._context, remoteObject);
+    return returnByValue ? (0, import_utilityScriptSerializers.parseEvaluationResultValue)(remoteObject.value) : createHandle(utilityScript._context, remoteObject);
   }
   async getProperties(object) {
     const response = await this._client.send("Runtime.getProperties", {

package/lib/server/chromium/crInput.js

@@ -59,12 +59,12 @@ class RawKeyboardImpl {
     commands = commands.filter((x) => !x.startsWith("insert"));
     return commands.map((c) => c.substring(0, c.length - 1));
   }
-  async keydown(modifiers, keyName, description, autoRepeat) {
+  async keydown(progress, modifiers, keyName, description, autoRepeat) {
     const { code, key, location, text } = description;
-    if (code === "Escape" && await this._dragManger.cancelDrag())
+    if (code === "Escape" && await progress.race(this._dragManger.cancelDrag()))
       return;
     const commands = this._commandsForCode(code, modifiers);
-    await this._client.send("Input.dispatchKeyEvent", {
+    await progress.race(this._client.send("Input.dispatchKeyEvent", {
       type: text ? "keyDown" : "rawKeyDown",
       modifiers: (0, import_crProtocolHelper.toModifiersMask)(modifiers),
       windowsVirtualKeyCode: description.keyCodeWithoutLocation,
@@ -76,21 +76,21 @@ class RawKeyboardImpl {
       autoRepeat,
       location,
       isKeypad: location === input.keypadLocation
-    });
+    }));
   }
-  async keyup(modifiers, keyName, description) {
+  async keyup(progress, modifiers, keyName, description) {
     const { code, key, location } = description;
-    await this._client.send("Input.dispatchKeyEvent", {
+    await progress.race(this._client.send("Input.dispatchKeyEvent", {
       type: "keyUp",
       modifiers: (0, import_crProtocolHelper.toModifiersMask)(modifiers),
       key,
       windowsVirtualKeyCode: description.keyCodeWithoutLocation,
       code,
       location
-    });
+    }));
   }
-  async sendText(text) {
-    await this._client.send("Input.insertText", { text });
+  async sendText(progress, text) {
+    await progress.race(this._client.send("Input.insertText", { text }));
   }
 }
 class RawMouseImpl {
@@ -99,41 +99,44 @@ class RawMouseImpl {
     this._client = client;
     this._dragManager = dragManager;
   }
-  async move(x, y, button, buttons, modifiers, forClick) {
+  async move(progress, x, y, button, buttons, modifiers, forClick) {
     const actualMove = async () => {
-      await this._client.send("Input.dispatchMouseEvent", {
+      await progress.race(this._client.send("Input.dispatchMouseEvent", {
         type: "mouseMoved",
         button,
         buttons: (0, import_crProtocolHelper.toButtonsMask)(buttons),
         x,
         y,
-        modifiers: (0, import_crProtocolHelper.toModifiersMask)(modifiers)
-      });
+        modifiers: (0, import_crProtocolHelper.toModifiersMask)(modifiers),
+        force: buttons.size > 0 ? 0.5 : 0
+      }));
     };
     if (forClick) {
-      return actualMove();
+      await actualMove();
+      return;
     }
-    await this._dragManager.interceptDragCausedByMove(x, y, button, buttons, modifiers, actualMove);
+    await this._dragManager.interceptDragCausedByMove(progress, x, y, button, buttons, modifiers, actualMove);
   }
-  async down(x, y, button, buttons, modifiers, clickCount) {
+  async down(progress, x, y, button, buttons, modifiers, clickCount) {
     if (this._dragManager.isDragging())
       return;
-    await this._client.send("Input.dispatchMouseEvent", {
+    await progress.race(this._client.send("Input.dispatchMouseEvent", {
       type: "mousePressed",
       button,
       buttons: (0, import_crProtocolHelper.toButtonsMask)(buttons),
       x,
       y,
       modifiers: (0, import_crProtocolHelper.toModifiersMask)(modifiers),
-      clickCount
-    });
+      clickCount,
+      force: buttons.size > 0 ? 0.5 : 0
+    }));
   }
-  async up(x, y, button, buttons, modifiers, clickCount) {
+  async up(progress, x, y, button, buttons, modifiers, clickCount) {
     if (this._dragManager.isDragging()) {
-      await this._dragManager.drop(x, y, modifiers);
+      await this._dragManager.drop(progress, x, y, modifiers);
       return;
     }
-    await this._client.send("Input.dispatchMouseEvent", {
+    await progress.race(this._client.send("Input.dispatchMouseEvent", {
       type: "mouseReleased",
       button,
       buttons: (0, import_crProtocolHelper.toButtonsMask)(buttons),
@@ -141,25 +144,25 @@ class RawMouseImpl {
       y,
       modifiers: (0, import_crProtocolHelper.toModifiersMask)(modifiers),
       clickCount
-    });
+    }));
   }
-  async wheel(x, y, buttons, modifiers, deltaX, deltaY) {
-    await this._client.send("Input.dispatchMouseEvent", {
+  async wheel(progress, x, y, buttons, modifiers, deltaX, deltaY) {
+    await progress.race(this._client.send("Input.dispatchMouseEvent", {
       type: "mouseWheel",
       x,
       y,
       modifiers: (0, import_crProtocolHelper.toModifiersMask)(modifiers),
       deltaX,
       deltaY
-    });
+    }));
   }
 }
 class RawTouchscreenImpl {
   constructor(client) {
     this._client = client;
   }
-  async tap(x, y, modifiers) {
-    await Promise.all([
+  async tap(progress, x, y, modifiers) {
+    await progress.race(Promise.all([
       this._client.send("Input.dispatchTouchEvent", {
         type: "touchStart",
         modifiers: (0, import_crProtocolHelper.toModifiersMask)(modifiers),
@@ -173,7 +176,7 @@ class RawTouchscreenImpl {
         modifiers: (0, import_crProtocolHelper.toModifiersMask)(modifiers),
         touchPoints: []
       })
-    ]);
+    ]));
   }
 }
 // Annotate the CommonJS export names for ESM import in node: