@checkly/playwright-core 1.41.25 → 1.42.11

package/lib/server/dom.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.NonRecoverableDOMError = exports.InjectedScriptPollHandler = exports.FrameExecutionContext = exports.ElementHandle = void 0;
+exports.NonRecoverableDOMError = exports.FrameExecutionContext = exports.ElementHandle = void 0;
 exports.assertDone = assertDone;
 exports.isNonRecoverableDOMError = isNonRecoverableDOMError;
 exports.kUnableToAdoptErrorMessage = void 0;
@@ -136,17 +136,6 @@ class ElementHandle extends js.JSHandle {
       return 'error:notconnected';
     }
   }
-  async evaluatePoll(progress, pageFunction, arg) {
-    try {
-      const utility = await this._frame._utilityContext();
-      const poll = await utility.evaluateHandle(pageFunction, [await utility.injectedScript(), this, arg]);
-      const pollHandler = new InjectedScriptPollHandler(progress, poll);
-      return await pollHandler.finish();
-    } catch (e) {
-      if (js.isJavaScriptErrorInEvaluate(e) || (0, _protocolError.isSessionClosedError)(e)) throw e;
-      return 'error:notconnected';
-    }
-  }
   async ownerFrame() {
     const frameId = await this._page._delegate.getOwnerFrame(this);
     if (!frameId) return null;
@@ -188,25 +177,19 @@ class ElementHandle extends js.JSHandle {
     return await this._page._delegate.scrollRectIntoViewIfNeeded(this, rect);
   }
   async _waitAndScrollIntoViewIfNeeded(progress, waitForVisible) {
-    const timeouts = [0, 50, 100, 250];
-    while (progress.isRunning()) {
-      assertDone(throwRetargetableDOMError(await this._waitForElementStates(progress, waitForVisible ? ['visible', 'stable'] : ['stable'], false /* force */)));
-      progress.throwIfAborted(); // Avoid action that has side-effects.
-      const result = throwRetargetableDOMError(await this._scrollRectIntoViewIfNeeded());
-      if (result === 'error:notvisible') {
-        if (!waitForVisible) {
-          var _timeouts$shift;
-          // Wait for a timeout to avoid retrying too often when not waiting for visible.
-          // If we wait for visible, this should be covered by _waitForElementStates instead.
-          const timeout = (_timeouts$shift = timeouts.shift()) !== null && _timeouts$shift !== void 0 ? _timeouts$shift : 500;
-          progress.log(`  element is not displayed, retrying in ${timeout}ms`);
-          await new Promise(f => setTimeout(f, timeout));
-        }
-        continue;
-      }
-      assertDone(result);
-      return;
-    }
+    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
+      }]) => {
+        return await injected.checkElementStates(node, waitForVisible ? ['visible', 'stable'] : ['stable']);
+      }, {
+        waitForVisible
+      });
+      if (waitResult) return waitResult;
+      return await this._scrollRectIntoViewIfNeeded();
+    }, {});
+    assertDone(throwRetargetableDOMError(result));
   }
   async scrollIntoViewIfNeeded(metadata, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
@@ -261,25 +244,10 @@ class ElementHandle extends js.JSHandle {
       y: box.y + border.top + offset.y
     };
   }
-  async _retryPointerAction(progress, actionName, waitForEnabled, action, options) {
+  async _retryAction(progress, actionName, action, options) {
     let retry = 0;
     // We progressively wait longer between retries, up to 500ms.
     const waitTime = [0, 20, 100, 100, 500];
-
-    // By default, we scroll with protocol method to reveal the action point.
-    // However, that might not work to scroll from under position:sticky elements
-    // that overlay the target element. To fight this, we cycle through different
-    // scroll alignments. This works in most scenarios.
-    const scrollOptions = [undefined, {
-      block: 'end',
-      inline: 'end'
-    }, {
-      block: 'center',
-      inline: 'center'
-    }, {
-      block: 'start',
-      inline: 'start'
-    }];
     while (progress.isRunning()) {
       if (retry) {
         progress.log(`retrying ${actionName} action${options.trial ? ' (trial run)' : ''}, attempt #${retry}`);
@@ -292,8 +260,8 @@ class ElementHandle extends js.JSHandle {
       } else {
         progress.log(`attempting ${actionName} action${options.trial ? ' (trial run)' : ''}`);
       }
-      const forceScrollOptions = scrollOptions[retry % scrollOptions.length];
-      const result = await this._performPointerAction(progress, actionName, waitForEnabled, action, forceScrollOptions, options);
+      if (!options.skipLocatorHandlersCheckpoint && !options.force) await this._frame._page.performLocatorHandlersCheckpoint(progress);
+      const result = await action(retry);
       ++retry;
       if (result === 'error:notvisible') {
         if (options.force) throw new NonRecoverableDOMError('Element is not visible');
@@ -305,14 +273,47 @@ class ElementHandle extends js.JSHandle {
         progress.log('  element is outside of the viewport');
         continue;
       }
+      if (result === 'error:optionsnotfound') {
+        progress.log('  did not find some options');
+        continue;
+      }
       if (typeof result === 'object' && 'hitTargetDescription' in result) {
         progress.log(`  ${result.hitTargetDescription} intercepts pointer events`);
         continue;
       }
+      if (typeof result === 'object' && 'missingState' in result) {
+        progress.log(`  element is not ${result.missingState}`);
+        continue;
+      }
       return result;
     }
     return 'done';
   }
+  async _retryPointerAction(progress, actionName, waitForEnabled, action, options) {
+    // Note: do not perform locator handlers checkpoint to avoid moving the mouse in the middle of a drag operation.
+    const skipLocatorHandlersCheckpoint = actionName === 'move and up';
+    return await this._retryAction(progress, actionName, async retry => {
+      // By default, we scroll with protocol method to reveal the action point.
+      // However, that might not work to scroll from under position:sticky elements
+      // that overlay the target element. To fight this, we cycle through different
+      // scroll alignments. This works in most scenarios.
+      const scrollOptions = [undefined, {
+        block: 'end',
+        inline: 'end'
+      }, {
+        block: 'center',
+        inline: 'center'
+      }, {
+        block: 'start',
+        inline: 'start'
+      }];
+      const forceScrollOptions = scrollOptions[retry % scrollOptions.length];
+      return await this._performPointerAction(progress, actionName, waitForEnabled, action, forceScrollOptions, options);
+    }, {
+      ...options,
+      skipLocatorHandlersCheckpoint
+    });
+  }
   async _performPointerAction(progress, actionName, waitForEnabled, action, forceScrollOptions, options) {
     const {
       force = false,
@@ -340,8 +341,19 @@ class ElementHandle extends js.JSHandle {
       await doScrollIntoView().catch(() => {});
     }
     if (options.__testHookBeforeStable) await options.__testHookBeforeStable();
-    const result = await this._waitForElementStates(progress, waitForEnabled ? ['visible', 'enabled', 'stable'] : ['visible', 'stable'], force);
-    if (result !== 'done') return result;
+    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
+      }]) => {
+        return await injected.checkElementStates(node, elementStates);
+      }, {
+        elementStates
+      });
+      if (result) return result;
+      progress.log(`  element is ${waitForEnabled ? 'visible, enabled and stable' : 'visible and stable'}`);
+    }
     if (options.__testHookAfterStable) await options.__testHookAfterStable();
     progress.log('  scrolling into view if needed');
     progress.throwIfAborted(); // Avoid action that has side-effects.
@@ -354,7 +366,9 @@ class ElementHandle extends js.JSHandle {
     progress.metadata.point = point;
     await progress.beforeInputAction(this);
     let hitTargetInterceptionHandle;
-    if (!options.force) {
+    if (force) {
+      progress.log(`  forcing action`);
+    } else {
       if (options.__testHookBeforeHitTarget) await options.__testHookBeforeHitTarget();
       const frameCheckResult = await this._checkFrameIsHitTarget(point);
       if (frameCheckResult === 'error:notconnected' || 'hitTargetDescription' in frameCheckResult) return frameCheckResult;
@@ -462,22 +476,32 @@ class ElementHandle extends js.JSHandle {
     }, this._page._timeoutSettings.timeout(options));
   }
   async _selectOption(progress, elements, values, options) {
-    const optionsToSelect = [...elements, ...values];
-    await progress.beforeInputAction(this);
-    return this._page._frameManager.waitForSignalsCreatedBy(progress, options.noWaitAfter, async () => {
-      progress.throwIfAborted(); // Avoid action that has side-effects.
-      progress.log('  selecting specified option(s)');
-      const result = await this.evaluatePoll(progress, ([injected, node, {
+    let resultingOptions = [];
+    await this._retryAction(progress, 'select option', async () => {
+      await progress.beforeInputAction(this);
+      if (!options.force) progress.log(`  waiting for element to be visible and enabled`);
+      const optionsToSelect = [...elements, ...values];
+      const result = await this.evaluateInUtility(async ([injected, node, {
         optionsToSelect,
         force
       }]) => {
-        return injected.waitForElementStatesAndPerformAction(node, ['visible', 'enabled'], force, injected.selectOptions.bind(injected, optionsToSelect));
+        if (!force) {
+          const checkResult = await injected.checkElementStates(node, ['visible', 'enabled']);
+          if (checkResult) return checkResult;
+        }
+        return injected.selectOptions(node, optionsToSelect);
       }, {
         optionsToSelect,
         force: options.force
       });
+      if (Array.isArray(result)) {
+        progress.log('  selected specified option(s)');
+        resultingOptions = result;
+        return 'done';
+      }
       return result;
-    });
+    }, options);
+    return resultingOptions;
   }
   async fill(metadata, value, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
@@ -487,38 +511,51 @@ class ElementHandle extends js.JSHandle {
     }, this._page._timeoutSettings.timeout(options));
   }
   async _fill(progress, value, options) {
-    progress.log(`elementHandle.fill("${value}")`);
-    await progress.beforeInputAction(this);
-    return this._page._frameManager.waitForSignalsCreatedBy(progress, options.noWaitAfter, async () => {
-      progress.log('  waiting for element to be visible, enabled and editable');
-      const filled = await this.evaluatePoll(progress, ([injected, node, {
-        value,
-        force
-      }]) => {
-        return injected.waitForElementStatesAndPerformAction(node, ['visible', 'enabled', 'editable'], force, injected.fill.bind(injected, value));
-      }, {
-        value,
-        force: options.force
-      });
-      progress.throwIfAborted(); // Avoid action that has side-effects.
-      if (filled === 'error:notconnected') return filled;
-      progress.log('  element is visible, enabled and editable');
-      if (filled === 'needsinput') {
+    progress.log(`  fill("${value}")`);
+    return await this._retryAction(progress, 'fill', async () => {
+      await progress.beforeInputAction(this);
+      return this._page._frameManager.waitForSignalsCreatedBy(progress, options.noWaitAfter, async () => {
+        if (!options.force) progress.log('  waiting for element to be visible, enabled and editable');
+        const result = await this.evaluateInUtility(async ([injected, node, {
+          value,
+          force
+        }]) => {
+          if (!force) {
+            const checkResult = await injected.checkElementStates(node, ['visible', 'enabled', 'editable']);
+            if (checkResult) return checkResult;
+          }
+          return injected.fill(node, value);
+        }, {
+          value,
+          force: options.force
+        });
         progress.throwIfAborted(); // Avoid action that has side-effects.
-        if (value) await this._page.keyboard.insertText(value);else await this._page.keyboard.press('Delete');
-      } else {
-        assertDone(filled);
-      }
-      return 'done';
-    }, 'input');
+        if (result === 'needsinput') {
+          if (value) await this._page.keyboard.insertText(value);else await this._page.keyboard.press('Delete');
+          return 'done';
+        } else {
+          return result;
+        }
+      }, 'input');
+    }, options);
   }
   async selectText(metadata, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      progress.throwIfAborted(); // Avoid action that has side-effects.
-      const result = await this.evaluatePoll(progress, ([injected, node, force]) => {
-        return injected.waitForElementStatesAndPerformAction(node, ['visible'], force, injected.selectText.bind(injected));
-      }, options.force);
+      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));
   }
@@ -669,10 +706,12 @@ class ElementHandle extends js.JSHandle {
   async waitForElementState(metadata, state, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      progress.log(`  waiting for element to be ${state}`);
-      const result = await this.evaluatePoll(progress, ([injected, node, state]) => {
-        return injected.waitForElementStatesAndPerformAction(node, [state], false, () => 'done');
-      }, state);
+      const actionName = `wait for ${state}`;
+      const result = await this._retryAction(progress, actionName, async () => {
+        return await this.evaluateInUtility(async ([injected, node, state]) => {
+          return (await injected.checkElementStates(node, [state])) || 'done';
+        }, state);
+      }, {});
       assertDone(throwRetargetableDOMError(result));
     }, this._page._timeoutSettings.timeout(options));
   }
@@ -687,22 +726,6 @@ class ElementHandle extends js.JSHandle {
     }
     return this;
   }
-  async _waitForElementStates(progress, states, force) {
-    const title = joinWithAnd(states);
-    progress.log(`  waiting for element to be ${title}`);
-    const result = await this.evaluatePoll(progress, ([injected, node, {
-      states,
-      force
-    }]) => {
-      return injected.waitForElementStatesAndPerformAction(node, states, force, () => 'done');
-    }, {
-      states,
-      force
-    });
-    if (result === 'error:notconnected') return result;
-    progress.log(`  element is ${title}`);
-    return result;
-  }
   async _checkFrameIsHitTarget(point) {
     let frame = this._frame;
     const data = [];
@@ -751,63 +774,7 @@ class ElementHandle extends js.JSHandle {
     };
   }
 }
-
-// Handles an InjectedScriptPoll running in injected script:
-// - streams logs into progress;
-// - cancels the poll when progress cancels.
 exports.ElementHandle = ElementHandle;
-class InjectedScriptPollHandler {
-  constructor(progress, poll) {
-    this._progress = void 0;
-    this._poll = void 0;
-    this._progress = progress;
-    this._poll = poll;
-    // Ensure we cancel the poll before progress aborts and returns:
-    //   - no unnecessary work in the page;
-    //   - no possible side effects after progress promise rejects.
-    this._progress.cleanupWhenAborted(() => this.cancel());
-    this._streamLogs();
-  }
-  async _streamLogs() {
-    while (this._poll && this._progress.isRunning()) {
-      const log = await this._poll.evaluate(poll => poll.takeNextLogs()).catch(e => []);
-      if (!this._poll || !this._progress.isRunning()) return;
-      for (const entry of log) this._progress.logEntry(entry);
-    }
-  }
-  async finishHandle() {
-    try {
-      const result = await this._poll.evaluateHandle(poll => poll.run());
-      await this._finishInternal();
-      return result;
-    } finally {
-      await this.cancel();
-    }
-  }
-  async finish() {
-    try {
-      const result = await this._poll.evaluate(poll => poll.run());
-      await this._finishInternal();
-      return result;
-    } finally {
-      await this.cancel();
-    }
-  }
-  async _finishInternal() {
-    if (!this._poll) return;
-    // Retrieve all the logs before continuing.
-    const log = await this._poll.evaluate(poll => poll.takeLastLogs()).catch(e => []);
-    for (const entry of log) this._progress.logEntry(entry);
-  }
-  async cancel() {
-    if (!this._poll) return;
-    const copy = this._poll;
-    this._poll = null;
-    await copy.evaluate(p => p.cancel()).catch(e => {});
-    copy.dispose();
-  }
-}
-exports.InjectedScriptPollHandler = InjectedScriptPollHandler;
 function throwRetargetableDOMError(result) {
   if (result === 'error:notconnected') throw new Error('Element is not attached to the DOM');
   return result;
@@ -838,8 +805,4 @@ function compensateHalfIntegerRoundingError(point) {
   const remainderY = point.y - Math.floor(point.y);
   if (remainderY > 0.49 && remainderY < 0.51) point.y -= 0.02;
 }
-function joinWithAnd(strings) {
-  if (strings.length <= 1) return strings.join('');
-  return strings.slice(0, strings.length - 1).join(', ') + ' and ' + strings[strings.length - 1];
-}
 const kUnableToAdoptErrorMessage = exports.kUnableToAdoptErrorMessage = 'Unable to adopt element handle from a different document';

package/lib/server/electron/electron.js

@@ -20,8 +20,10 @@ var _progress = require("../progress");
 var _helper = require("../helper");
 var _eventsHelper = require("../../utils/eventsHelper");
 var readline = _interopRequireWildcard(require("readline"));
-var _debugLogger = require("../../common/debugLogger");
+var _debugLogger = require("../../utils/debugLogger");
 var _instrumentation = require("../instrumentation");
+var _crProtocolHelper = require("../chromium/crProtocolHelper");
+var _console = require("../console");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -54,10 +56,6 @@ class ElectronApplication extends _instrumentation.SdkObject {
     this._process = void 0;
     this._process = process;
     this._browserContext = browser._defaultContext;
-    this._browserContext.on(_browserContext.BrowserContext.Events.Close, () => {
-      // Emit application closed after context closed.
-      Promise.resolve().then(() => this.emit(ElectronApplication.Events.Close));
-    });
     this._nodeConnection = nodeConnection;
     this._nodeSession = nodeConnection.rootSession;
     this._nodeSession.on('Runtime.executionContextCreated', async event => {
@@ -74,14 +72,40 @@ class ElectronApplication extends _instrumentation.SdkObject {
       });
       this._nodeElectronHandlePromise.resolve(new js.JSHandle(this._nodeExecutionContext, 'object', 'ElectronModule', remoteObject.objectId));
     });
+    this._nodeSession.on('Runtime.consoleAPICalled', event => this._onConsoleAPI(event));
+    const appClosePromise = new Promise(f => this.once(ElectronApplication.Events.Close, f));
     this._browserContext.setCustomCloseHandler(async () => {
       await this._browserContext.stopVideoRecording();
       const electronHandle = await this._nodeElectronHandlePromise;
       await electronHandle.evaluate(({
         app
       }) => app.quit()).catch(() => {});
+      this._nodeConnection.close();
+      await appClosePromise;
     });
   }
+  async _onConsoleAPI(event) {
+    if (event.executionContextId === 0) {
+      // DevTools protocol stores the last 1000 console messages. These
+      // messages are always reported even for removed execution contexts. In
+      // this case, they are marked with executionContextId = 0 and are
+      // reported upon enabling Runtime agent.
+      //
+      // Ignore these messages since:
+      // - there's no execution context we can use to operate with message
+      //   arguments
+      // - these messages are reported before Playwright clients can subscribe
+      //   to the 'console'
+      //   page event.
+      //
+      // @see https://github.com/GoogleChrome/puppeteer/issues/3865
+      return;
+    }
+    if (!this._nodeExecutionContext) return;
+    const args = event.args.map(arg => this._nodeExecutionContext.createHandle(arg));
+    const message = new _console.ConsoleMessage(null, event.type, undefined, args, (0, _crProtocolHelper.toConsoleMessageLocation)(event.stackTrace));
+    this.emit(ElectronApplication.Events.Console, message);
+  }
   async initialize() {
     await this._nodeSession.send('Runtime.enable', {});
     // Delay loading the app until browser is started and the browser targets are configured to auto-attach.
@@ -96,13 +120,10 @@ class ElectronApplication extends _instrumentation.SdkObject {
     return this._browserContext;
   }
   async close() {
-    const progressController = new _progress.ProgressController((0, _instrumentation.serverSideCallMetadata)(), this);
-    const closed = progressController.run(progress => _helper.helper.waitForEvent(progress, this, ElectronApplication.Events.Close).promise);
+    // This will call BrowserContext.setCustomCloseHandler.
     await this._browserContext.close({
       reason: 'Application exited'
     });
-    this._nodeConnection.close();
-    await closed;
   }
   async browserWindow(page) {
     // Assume CRPage as Electron is always Chromium.
@@ -119,7 +140,8 @@ class ElectronApplication extends _instrumentation.SdkObject {
 }
 exports.ElectronApplication = ElectronApplication;
 ElectronApplication.Events = {
-  Close: 'close'
+  Close: 'close',
+  Console: 'console'
 };
 class Electron extends _instrumentation.SdkObject {
   constructor(playwright) {
@@ -133,10 +155,11 @@ class Electron extends _instrumentation.SdkObject {
     controller.setLogName('browser');
     return controller.run(async progress => {
       let app = undefined;
+      // --remote-debugging-port=0 must be the last playwright's argument, loader.ts relies on it.
       const electronArguments = ['--inspect=0', '--remote-debugging-port=0', ...args];
       if (_os.default.platform() === 'linux') {
         const runningAsRoot = process.geteuid && process.geteuid() === 0;
-        if (runningAsRoot && electronArguments.indexOf('--no-sandbox') === -1) electronArguments.push('--no-sandbox');
+        if (runningAsRoot && electronArguments.indexOf('--no-sandbox') === -1) electronArguments.unshift('--no-sandbox');
       }
       const artifactsDir = await _fs.default.promises.mkdtemp(ARTIFACTS_FOLDER);
       const browserLogsCollector = new _debugLogger.RecentLogsCollector();
@@ -183,7 +206,10 @@ class Electron extends _instrumentation.SdkObject {
         handleSIGINT: true,
         handleSIGTERM: true,
         handleSIGHUP: true,
-        onExit: () => {}
+        onExit: () => {
+          var _app;
+          return (_app = app) === null || _app === void 0 ? void 0 : _app.emit(ElectronApplication.Events.Close);
+        }
       });
       const waitForXserverError = new Promise(async (resolve, reject) => {
         waitForLine(progress, launchedProcess, /Unable to open X display/).then(() => reject(new Error(['Unable to open X display!', `================================`, 'Most likely this is because there is no X server available.', "Use 'xvfb-run' on Linux to launch your tests with an emulated display server.", "For example: 'xvfb-run npm run test:e2e'", `================================`, progress.metadata.log].join('\n')))).catch(() => {});

package/lib/server/electron/loader.js

@@ -23,8 +23,10 @@ const {
   chromiumSwitches
 } = require('../chromium/chromiumSwitches');
 
-// [Electron, -r, loader.js, --inspect=0, --remote-debugging-port=0, ...args]
-process.argv.splice(1, 4);
+// Always pass user arguments first, see https://github.com/microsoft/playwright/issues/16614 and
+// https://github.com/microsoft/playwright/issues/29198.
+// [Electron, -r, loader.js[, --no-sandbox>], --inspect=0, --remote-debugging-port=0, ...args]
+process.argv.splice(1, process.argv.indexOf('--remote-debugging-port=0'));
 for (const arg of chromiumSwitches) {
   const match = arg.match(/--([^=]*)=?(.*)/);
   app.commandLine.appendSwitch(match[1], match[2]);

package/lib/server/fetch.js

@@ -149,6 +149,7 @@ class APIRequestContext extends _instrumentation.SdkObject {
       queryParams: (0, _fetch.parseQueryParameters)(fetchResponse.url),
       url: params.tokenizedURL || fetchResponse.url,
       timings: (0, _fetch.getTimings)(fetchResponse.timings),
+      requestBody: (0, _fetch.getRequestBody)(postData, params.multipartData, options),
       body: (0, _fetch.getBody)(fetchResponse.body),
       method: options.method
     };

package/lib/server/firefox/ffAccessibility.js

@@ -200,7 +200,7 @@ class FFAXNode {
       if (!(numericalProperty in this._payload)) continue;
       node[numericalProperty] = this._payload[numericalProperty];
     }
-    const tokenProperties = ['autocomplete', 'haspopup', 'invalid', 'orientation'];
+    const tokenProperties = ['autocomplete', 'haspopup', 'orientation'];
     for (const tokenProperty of tokenProperties) {
       const value = this._payload[tokenProperty];
       if (!value || value === 'false') continue;
@@ -210,6 +210,7 @@ class FFAXNode {
     axNode.valueString = this._payload.value;
     if ('checked' in this._payload) axNode.checked = this._payload.checked === true ? 'checked' : this._payload.checked === 'mixed' ? 'mixed' : 'unchecked';
     if ('pressed' in this._payload) axNode.pressed = this._payload.pressed === true ? 'pressed' : 'released';
+    if ('invalid' in this._payload) axNode.invalid = this._payload.invalid === true ? 'true' : 'false';
     return axNode;
   }
 }

package/lib/server/firefox/ffConnection.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.kBrowserCloseMessageId = exports.FFSession = exports.FFConnection = exports.ConnectionEvents = void 0;
 var _events = require("events");
-var _debugLogger = require("../../common/debugLogger");
+var _debugLogger = require("../../utils/debugLogger");
 var _helper = require("../helper");
 var _protocolError = require("../protocolError");
 /**

package/lib/server/firefox/ffPage.js

@@ -14,7 +14,7 @@ var _ffExecutionContext = require("./ffExecutionContext");
 var _ffInput = require("./ffInput");
 var _ffNetworkManager = require("./ffNetworkManager");
 var _stackTrace = require("../../utils/stackTrace");
-var _debugLogger = require("../../common/debugLogger");
+var _debugLogger = require("../../utils/debugLogger");
 var _manualPromise = require("../../utils/manualPromise");
 var _browserContext = require("../browserContext");
 var _errors = require("../errors");