@checkly/playwright-core 1.41.23 → 1.41.26

package/lib/server/dom.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.NonRecoverableDOMError = exports.FrameExecutionContext = exports.ElementHandle = void 0;
+exports.NonRecoverableDOMError = exports.InjectedScriptPollHandler = exports.FrameExecutionContext = exports.ElementHandle = void 0;
 exports.assertDone = assertDone;
 exports.isNonRecoverableDOMError = isNonRecoverableDOMError;
 exports.kUnableToAdoptErrorMessage = void 0;
@@ -136,6 +136,17 @@ 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;
@@ -177,19 +188,25 @@ class ElementHandle extends js.JSHandle {
     return await 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
-      }]) => {
-        return await injected.checkElementStates(node, waitForVisible ? ['visible', 'stable'] : ['stable']);
-      }, {
-        waitForVisible
-      });
-      if (waitResult) return waitResult;
-      return await this._scrollRectIntoViewIfNeeded();
-    }, {});
-    assertDone(throwRetargetableDOMError(result));
+    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;
+    }
   }
   async scrollIntoViewIfNeeded(metadata, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
@@ -244,10 +261,25 @@ class ElementHandle extends js.JSHandle {
       y: box.y + border.top + offset.y
     };
   }
-  async _retryAction(progress, actionName, action, options) {
+  async _retryPointerAction(progress, actionName, waitForEnabled, 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}`);
@@ -260,8 +292,8 @@ class ElementHandle extends js.JSHandle {
       } else {
         progress.log(`attempting ${actionName} action${options.trial ? ' (trial run)' : ''}`);
       }
-      if (!options.skipLocatorHandlersCheckpoint && !options.force) await this._frame._page.performLocatorHandlersCheckpoint(progress);
-      const result = await action(retry);
+      const forceScrollOptions = scrollOptions[retry % scrollOptions.length];
+      const result = await this._performPointerAction(progress, actionName, waitForEnabled, action, forceScrollOptions, options);
       ++retry;
       if (result === 'error:notvisible') {
         if (options.force) throw new NonRecoverableDOMError('Element is not visible');
@@ -273,47 +305,14 @@ 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,
@@ -341,19 +340,8 @@ class ElementHandle extends js.JSHandle {
       await doScrollIntoView().catch(() => {});
     }
     if (options.__testHookBeforeStable) await 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
-      }]) => {
-        return await injected.checkElementStates(node, elementStates);
-      }, {
-        elementStates
-      });
-      if (result) return result;
-      progress.log(`  element is ${waitForEnabled ? 'visible, enabled and stable' : 'visible and stable'}`);
-    }
+    const result = await this._waitForElementStates(progress, waitForEnabled ? ['visible', 'enabled', 'stable'] : ['visible', 'stable'], force);
+    if (result !== 'done') return result;
     if (options.__testHookAfterStable) await options.__testHookAfterStable();
     progress.log('  scrolling into view if needed');
     progress.throwIfAborted(); // Avoid action that has side-effects.
@@ -366,9 +354,7 @@ class ElementHandle extends js.JSHandle {
     progress.metadata.point = point;
     await progress.beforeInputAction(this);
     let hitTargetInterceptionHandle;
-    if (force) {
-      progress.log(`  forcing action`);
-    } else {
+    if (!options.force) {
       if (options.__testHookBeforeHitTarget) await options.__testHookBeforeHitTarget();
       const frameCheckResult = await this._checkFrameIsHitTarget(point);
       if (frameCheckResult === 'error:notconnected' || 'hitTargetDescription' in frameCheckResult) return frameCheckResult;
@@ -476,32 +462,22 @@ class ElementHandle extends js.JSHandle {
     }, this._page._timeoutSettings.timeout(options));
   }
   async _selectOption(progress, elements, values, options) {
-    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, {
+    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, {
         optionsToSelect,
         force
       }]) => {
-        if (!force) {
-          const checkResult = await injected.checkElementStates(node, ['visible', 'enabled']);
-          if (checkResult) return checkResult;
-        }
-        return injected.selectOptions(node, optionsToSelect);
+        return injected.waitForElementStatesAndPerformAction(node, ['visible', 'enabled'], force, injected.selectOptions.bind(injected, 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);
@@ -511,51 +487,38 @@ class ElementHandle extends js.JSHandle {
     }, this._page._timeoutSettings.timeout(options));
   }
   async _fill(progress, value, options) {
-    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.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.throwIfAborted(); // Avoid action that has side-effects.
-        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);
+        if (value) await this._page.keyboard.insertText(value);else await this._page.keyboard.press('Delete');
+      } else {
+        assertDone(filled);
+      }
+      return 'done';
+    }, 'input');
   }
   async selectText(metadata, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      const result = await this._retryAction(progress, 'selectText', async () => {
-        if (!options.force) progress.log('  waiting for element to be visible');
-        return await this.evaluateInUtility(async ([injected, node, {
-          force
-        }]) => {
-          if (!force) {
-            const checkResult = await injected.checkElementStates(node, ['visible']);
-            if (checkResult) return checkResult;
-          }
-          return injected.selectText(node);
-        }, {
-          force: options.force
-        });
-      }, options);
+      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);
       assertDone(throwRetargetableDOMError(result));
     }, this._page._timeoutSettings.timeout(options));
   }
@@ -706,12 +669,10 @@ class ElementHandle extends js.JSHandle {
   async waitForElementState(metadata, state, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      const actionName = `wait for ${state}`;
-      const result = await this._retryAction(progress, actionName, async () => {
-        return await this.evaluateInUtility(async ([injected, node, state]) => {
-          return (await injected.checkElementStates(node, [state])) || 'done';
-        }, state);
-      }, {});
+      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);
       assertDone(throwRetargetableDOMError(result));
     }, this._page._timeoutSettings.timeout(options));
   }
@@ -726,6 +687,22 @@ 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 = [];
@@ -774,7 +751,63 @@ 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;
@@ -805,4 +838,8 @@ 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,10 +20,8 @@ var _progress = require("../progress");
 var _helper = require("../helper");
 var _eventsHelper = require("../../utils/eventsHelper");
 var readline = _interopRequireWildcard(require("readline"));
-var _debugLogger = require("../../utils/debugLogger");
+var _debugLogger = require("../../common/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 }; }
@@ -56,6 +54,10 @@ 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 => {
@@ -72,40 +74,14 @@ 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.
@@ -120,10 +96,13 @@ class ElectronApplication extends _instrumentation.SdkObject {
     return this._browserContext;
   }
   async close() {
-    // This will call BrowserContext.setCustomCloseHandler.
+    const progressController = new _progress.ProgressController((0, _instrumentation.serverSideCallMetadata)(), this);
+    const closed = progressController.run(progress => _helper.helper.waitForEvent(progress, this, ElectronApplication.Events.Close).promise);
     await this._browserContext.close({
       reason: 'Application exited'
     });
+    this._nodeConnection.close();
+    await closed;
   }
   async browserWindow(page) {
     // Assume CRPage as Electron is always Chromium.
@@ -140,8 +119,7 @@ class ElectronApplication extends _instrumentation.SdkObject {
 }
 exports.ElectronApplication = ElectronApplication;
 ElectronApplication.Events = {
-  Close: 'close',
-  Console: 'console'
+  Close: 'close'
 };
 class Electron extends _instrumentation.SdkObject {
   constructor(playwright) {
@@ -155,11 +133,10 @@ 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.unshift('--no-sandbox');
+        if (runningAsRoot && electronArguments.indexOf('--no-sandbox') === -1) electronArguments.push('--no-sandbox');
       }
       const artifactsDir = await _fs.default.promises.mkdtemp(ARTIFACTS_FOLDER);
       const browserLogsCollector = new _debugLogger.RecentLogsCollector();
@@ -206,10 +183,7 @@ class Electron extends _instrumentation.SdkObject {
         handleSIGINT: true,
         handleSIGTERM: true,
         handleSIGHUP: true,
-        onExit: () => {
-          var _app;
-          return (_app = app) === null || _app === void 0 ? void 0 : _app.emit(ElectronApplication.Events.Close);
-        }
+        onExit: () => {}
       });
       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,10 +23,8 @@ const {
   chromiumSwitches
 } = require('../chromium/chromiumSwitches');
 
-// 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'));
+// [Electron, -r, loader.js, --inspect=0, --remote-debugging-port=0, ...args]
+process.argv.splice(1, 4);
 for (const arg of chromiumSwitches) {
   const match = arg.match(/--([^=]*)=?(.*)/);
   app.commandLine.appendSwitch(match[1], match[2]);

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', 'orientation'];
+    const tokenProperties = ['autocomplete', 'haspopup', 'invalid', 'orientation'];
     for (const tokenProperty of tokenProperties) {
       const value = this._payload[tokenProperty];
       if (!value || value === 'false') continue;
@@ -210,7 +210,6 @@ 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("../../utils/debugLogger");
+var _debugLogger = require("../../common/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("../../utils/debugLogger");
+var _debugLogger = require("../../common/debugLogger");
 var _manualPromise = require("../../utils/manualPromise");
 var _browserContext = require("../browserContext");
 var _errors = require("../errors");