rebrowser-playwright-core 1.48.2 → 1.49.0

package/lib/server/frames.js

@@ -22,7 +22,6 @@ var _selectorParser = require("../utils/isomorphic/selectorParser");
 var _frameSelectors = require("./frameSelectors");
 var _errors = require("./errors");
 var _fileUploadUtils = require("./fileUploadUtils");
-var _crExecutionContext = require("./chromium/crExecutionContext");
 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; }
 /**
@@ -61,7 +60,6 @@ class FrameManager {
     this._webSockets = new Map();
     this._openedDialogs = new Set();
     this._closeAllOpeningDialogs = false;
-    this.__re__contexts = undefined;
     this._page = page;
     this._mainFrame = undefined;
   }
@@ -197,6 +195,11 @@ class FrameManager {
   frameCommittedSameDocumentNavigation(frameId, url) {
     const frame = this._frames.get(frameId);
     if (!frame) return;
+    const pending = frame.pendingDocument();
+    if (pending && pending.documentId === undefined && pending.request === undefined) {
+      // WebKit has notified about the same-document navigation being requested, so clear it.
+      frame.setPendingDocument(undefined);
+    }
     frame._url = url;
     const navigationEvent = {
       url,
@@ -429,7 +432,8 @@ class Frame extends _instrumentation.SdkObject {
     if (this._inflightRequests.size === 0) this._startNetworkIdleTimer();
     this._page.mainFrame()._recalculateNetworkIdle(this);
     this._onLifecycleEvent('commit');
-    this.__re__contexts = undefined;
+    const crSession = (this._page._delegate._sessions.get(this._id) || this._page._delegate._mainFrameSession)._client;
+    crSession.emit('Runtime.executionContextsCleared');
   }
   setPendingDocument(documentInfo) {
     this._pendingDocument = documentInfo;
@@ -584,174 +588,29 @@ class Frame extends _instrumentation.SdkObject {
   async frameElement() {
     return this._page._delegate.getFrameElement(this);
   }
-  async __re__getMainWorld({
-    client,
-    frameId
-  }) {
-    let contextId;
-
-    // random name to make it harder to detect for any 3rd party script by watching window object and events
-    const randomName = [...Array(Math.floor(Math.random() * (10 + 1)) + 10)].map(() => Math.random().toString(36)[2]).join('');
-    process.env['REBROWSER_PATCHES_DEBUG'] && console.log(`[rebrowser-patches][getMainWorld] binding name = ${randomName}`);
-
-    // add the binding
-    await client.send('Runtime.addBinding', {
-      name: randomName
-    });
-
-    // listen for 'Runtime.bindingCalled' event
-    const bindingCalledHandler = ({
-      name,
-      payload,
-      executionContextId
-    }) => {
-      process.env['REBROWSER_PATCHES_DEBUG'] && console.log('[rebrowser-patches][bindingCalledHandler]', {
-        name,
-        payload,
-        executionContextId
-      });
-      if (contextId > 0) {
-        // already acquired the id
-        return;
-      }
-      if (name !== randomName) {
-        // ignore irrelevant bindings
-        return;
-      }
-      if (payload !== frameId) {
-        // ignore irrelevant frames
-        return;
-      }
-      contextId = executionContextId;
-      // remove this listener
-      client.off('Runtime.bindingCalled', bindingCalledHandler);
-    };
-    client.on('Runtime.bindingCalled', bindingCalledHandler);
-
-    // we could call the binding right from addScriptToEvaluateOnNewDocument, but this way it will be called in all existing frames and it's hard to distinguish children from the parent
-    await client.send('Page.addScriptToEvaluateOnNewDocument', {
-      source: `document.addEventListener('${randomName}', (e) => self['${randomName}'](e.detail.frameId))`,
-      runImmediately: true
-    });
-
-    // create new isolated world for this frame
-    const createIsolatedWorldResult = await client.send('Page.createIsolatedWorld', {
-      frameId,
-      // use randomName for worldName to distinguish from normal utility world
-      worldName: randomName,
-      grantUniveralAccess: true
-    });
-
-    // emit event in the specific frame from the isolated world
-    await client.send('Runtime.evaluate', {
-      expression: `document.dispatchEvent(new CustomEvent('${randomName}', { detail: { frameId: '${frameId}' } }))`,
-      contextId: createIsolatedWorldResult.executionContextId
-    });
-    process.env['REBROWSER_PATCHES_DEBUG'] && console.log(`[rebrowser-patches][getMainWorld] result:`, {
-      contextId
-    });
-    return contextId;
-  }
-  async __re__getIsolatedWorld({
-    client,
-    frameId,
-    worldName
-  }) {
-    const createIsolatedWorldResult = await client.send('Page.createIsolatedWorld', {
-      frameId,
-      worldName,
-      grantUniveralAccess: true
-    });
-    process.env['REBROWSER_PATCHES_DEBUG'] && console.log(`[rebrowser-patches][getIsolatedWorld] result:`, createIsolatedWorldResult);
-    return createIsolatedWorldResult.executionContextId;
-  }
-  _context(world) {
-    const fixMode = process.env['REBROWSER_PATCHES_RUNTIME_FIX_MODE'] || 'addBinding';
-    process.env['REBROWSER_PATCHES_DEBUG'] && console.log(`[rebrowser-patches][frames._context] frameId = ${this._id}, world = ${world}, fixMode = ${fixMode}`);
-    if (fixMode !== '0') {
-      if (typeof this.__re__contexts === 'undefined') {
-        this.__re__contexts = {};
-      }
-      const frameSession = this._page._delegate._sessions.get(this._id) || this._page._delegate._mainFrameSession;
-      const client = frameSession._client;
-      const utilityWorldName = process.env['REBROWSER_PATCHES_UTILITY_WORLD_NAME'] !== '0' ? process.env['REBROWSER_PATCHES_UTILITY_WORLD_NAME'] || 'util' : '__playwright_utility_world__';
-      let getWorldPromise;
-      if (fixMode === 'addBinding') {
-        if (this.__re__contexts[world] !== undefined) {
-          return Promise.resolve(this.__re__contexts[world]);
-        }
-        if (world === 'utility') {
-          getWorldPromise = this.__re__getIsolatedWorld({
-            client,
-            frameId: this._id,
-            worldName: utilityWorldName
-          }).then(contextId => {
-            return {
-              id: contextId,
-              name: utilityWorldName,
-              auxData: {
-                frameId: this._id,
-                isDefault: false
-              }
-            };
-          });
-        } else if (world === 'main') {
-          getWorldPromise = this.__re__getMainWorld({
-            client,
-            frameId: this._id
-          }).then(contextId => {
-            return {
-              id: contextId,
-              name: '',
-              auxData: {
-                frameId: this._id,
-                isDefault: true
-              }
-            };
-          });
-        }
-        getWorldPromise = getWorldPromise.then(contextPayload => {
-          const delegate = new _crExecutionContext.CRExecutionContext(client, contextPayload);
-          this.__re__contexts[world] = new dom.FrameExecutionContext(delegate, this, world);
-          return this.__re__contexts[world];
-        });
-      } else if (fixMode === 'alwaysIsolated') {
-        // use only utility context
-        if (this.__re__contexts.utility !== undefined) {
-          return Promise.resolve(this.__re__contexts.utility);
-        }
-        getWorldPromise = this.__re__getIsolatedWorld({
-          client,
-          frameId: this._id,
-          worldName: utilityWorldName
-        }).then(contextId => {
-          const contextPayload = {
-            id: contextId,
-            name: utilityWorldName,
-            auxData: {
-              frameId: this._id,
-              isDefault: false
-            }
-          };
-          const delegate = new _crExecutionContext.CRExecutionContext(client, contextPayload);
-          this.__re__contexts.utility = new dom.FrameExecutionContext(delegate, this, 'utility');
-          return this.__re__contexts.utility;
-        });
-      }
-      return getWorldPromise.catch(error => {
-        if (error.message.includes('No frame for given id found')) {
-          // ignore, frame is already gone
-          return {
-            destroyedReason: 'Frame was detached'
-          };
-        }
-        _debugLogger.debugLogger.log('error', error);
-        console.error('[rebrowser-patches][frames._context] cannot get world, error:', error);
+  _context(world, useContextPromise = false) {
+    if (process.env['REBROWSER_PATCHES_RUNTIME_FIX_MODE'] === '0' || this._contextData.get(world).context || useContextPromise) {
+      return this._contextData.get(world).contextPromise.then(contextOrDestroyedReason => {
+        if (contextOrDestroyedReason instanceof js.ExecutionContext) return contextOrDestroyedReason;
+        throw new Error(contextOrDestroyedReason.destroyedReason);
       });
     }
-    return this._contextData.get(world).contextPromise.then(contextOrDestroyedReason => {
-      if (contextOrDestroyedReason instanceof js.ExecutionContext) return contextOrDestroyedReason;
-      throw new Error(contextOrDestroyedReason.destroyedReason);
+    const crSession = (this._page._delegate._sessions.get(this._id) || this._page._delegate._mainFrameSession)._client;
+    return crSession.__re__emitExecutionContext({
+      world,
+      targetId: this._id,
+      frame: this
+    }).then(() => {
+      return this._context(world, true);
+    }).catch(error => {
+      if (error.message.includes('No frame for given id found')) {
+        // ignore, frame is already gone
+        return {
+          destroyedReason: 'Frame was detached'
+        };
+      }
+      _debugLogger.debugLogger.log('error', error);
+      console.error('[rebrowser-patches][frames._context] cannot get world, error:', error);
     });
   }
   _mainContext() {
@@ -793,12 +652,12 @@ class Frame extends _instrumentation.SdkObject {
       return await this.waitForSelectorInternal(progress, selector, true, options, scope);
     }, this._page._timeoutSettings.timeout(options));
   }
-  async waitForSelectorInternal(progress, selector, performLocatorHandlersCheckpoint, options, scope) {
+  async waitForSelectorInternal(progress, selector, performActionPreChecks, options, scope) {
     const {
       state = 'visible'
     } = options;
     const promise = this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async continuePolling => {
-      if (performLocatorHandlersCheckpoint) await this._page.performLocatorHandlersCheckpoint(progress);
+      if (performActionPreChecks) await this._page.performActionPreChecks(progress);
       const resolved = await this.selectors.resolveInjectedForSelector(selector, options, scope);
       progress.throwIfAborted();
       if (!resolved) {
@@ -809,6 +668,7 @@ class Frame extends _instrumentation.SdkObject {
         info,
         root
       }) => {
+        if (root && !root.isConnected) throw injected.createStacklessError('Element is not attached to the DOM');
         const elements = injected.querySelectorAll(info.parsed, root || document);
         const element = elements[0];
         const visible = element ? injected.utils.isElementVisible(element) : false;
@@ -1114,19 +974,21 @@ class Frame extends _instrumentation.SdkObject {
     // Retry upon all other errors.
     return false;
   }
-  async _retryWithProgressIfNotConnected(progress, selector, strict, performLocatorHandlersCheckpoint, action) {
+  async _retryWithProgressIfNotConnected(progress, selector, strict, performActionPreChecks, action) {
     progress.log(`waiting for ${this._asLocator(selector)}`);
     return this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async continuePolling => {
-      if (performLocatorHandlersCheckpoint) await this._page.performLocatorHandlersCheckpoint(progress);
+      if (performActionPreChecks) await this._page.performActionPreChecks(progress);
       const resolved = await this.selectors.resolveInjectedForSelector(selector, {
         strict
       });
       progress.throwIfAborted();
       if (!resolved) return continuePolling;
       const result = await resolved.injected.evaluateHandle((injected, {
-        info
+        info,
+        callId
       }) => {
         const elements = injected.querySelectorAll(info.parsed, document);
+        if (callId) injected.markTargetElements(new Set(elements), callId);
         const element = elements[0];
         let log = '';
         if (elements.length > 1) {
@@ -1141,7 +1003,8 @@ class Frame extends _instrumentation.SdkObject {
           element
         };
       }, {
-        info: resolved.info
+        info: resolved.info,
+        callId: progress.metadata.id
       });
       const {
         log,
@@ -1170,7 +1033,7 @@ class Frame extends _instrumentation.SdkObject {
     });
   }
   async rafrafTimeoutScreenshotElementWithProgress(progress, selector, timeout, options) {
-    return await this._retryWithProgressIfNotConnected(progress, selector, true /* strict */, true /* performLocatorHandlersCheckpoint */, async handle => {
+    return await this._retryWithProgressIfNotConnected(progress, selector, true /* strict */, true /* performActionPreChecks */, async handle => {
       await handle._frame.rafrafTimeout(timeout);
       return await this._page._screenshotter.screenshotElement(progress, handle, options);
     });
@@ -1178,7 +1041,7 @@ class Frame extends _instrumentation.SdkObject {
   async click(metadata, selector, options) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._click(progress, {
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._click(progress, {
         ...options,
         waitAfter: !options.noWaitAfter
       })));
@@ -1187,13 +1050,13 @@ class Frame extends _instrumentation.SdkObject {
   async dblclick(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._dblclick(progress, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._dblclick(progress, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async dragAndDrop(metadata, source, target, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     await controller.run(async progress => {
-      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, source, options.strict, !options.force /* performLocatorHandlersCheckpoint */, async handle => {
+      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, source, options.strict, !options.force /* performActionPreChecks */, 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();
@@ -1205,7 +1068,7 @@ class Frame extends _instrumentation.SdkObject {
         });
       }));
       // Note: do not perform locator handlers checkpoint to avoid moving the mouse in the middle of a drag operation.
-      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, options.strict, false /* performLocatorHandlersCheckpoint */, async handle => {
+      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, options.strict, false /* performActionPreChecks */, 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();
@@ -1222,25 +1085,25 @@ class Frame extends _instrumentation.SdkObject {
     if (!this._page._browserContext._options.hasTouch) throw new Error('The page does not support tap. Use hasTouch context option to enable touch support.');
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._tap(progress, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._tap(progress, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async fill(metadata, selector, value, options) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._fill(progress, value, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._fill(progress, value, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async focus(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     await controller.run(async progress => {
-      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._focus(progress)));
+      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performActionPreChecks */, handle => handle._focus(progress)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async blur(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     await controller.run(async progress => {
-      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._blur(progress)));
+      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performActionPreChecks */, handle => handle._blur(progress)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async textContent(metadata, selector, options = {}, scope) {
@@ -1340,44 +1203,44 @@ class Frame extends _instrumentation.SdkObject {
   async hover(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._hover(progress, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._hover(progress, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async selectOption(metadata, selector, elements, values, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._selectOption(progress, elements, values, options));
+      return await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._selectOption(progress, elements, values, options));
     }, this._page._timeoutSettings.timeout(options));
   }
   async setInputFiles(metadata, selector, params) {
     const inputFileItems = await (0, _fileUploadUtils.prepareFilesForUpload)(this, params);
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, params.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._setInputFiles(progress, inputFileItems)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, params.strict, true /* performActionPreChecks */, handle => handle._setInputFiles(progress, inputFileItems)));
     }, this._page._timeoutSettings.timeout(params));
   }
   async type(metadata, selector, text, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._type(progress, text, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performActionPreChecks */, handle => handle._type(progress, text, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async press(metadata, selector, key, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._press(progress, key, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performActionPreChecks */, handle => handle._press(progress, key, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async check(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._setChecked(progress, true, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._setChecked(progress, true, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async uncheck(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._setChecked(progress, false, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._setChecked(progress, false, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async waitForTimeout(metadata, timeout) {
@@ -1386,6 +1249,12 @@ class Frame extends _instrumentation.SdkObject {
       await new Promise(resolve => setTimeout(resolve, timeout));
     });
   }
+  async ariaSnapshot(metadata, selector, options = {}) {
+    const controller = new _progress.ProgressController(metadata, this);
+    return controller.run(async progress => {
+      return await this._retryWithProgressIfNotConnected(progress, selector, true /* strict */, true /* performActionPreChecks */, handle => handle.ariaSnapshot());
+    }, this._page._timeoutSettings.timeout(options));
+  }
   async expect(metadata, selector, options) {
     const result = await this._expectImpl(metadata, selector, options);
     // Library mode special case for the expect errors which are return values, not exceptions.
@@ -1409,7 +1278,7 @@ class Frame extends _instrumentation.SdkObject {
       await new _progress.ProgressController(metadata, this).run(async progress => {
         progress.log(`${metadata.apiName}${timeout ? ` with timeout ${timeout}ms` : ''}`);
         progress.log(`waiting for ${this._asLocator(selector)}`);
-        await this._page.performLocatorHandlersCheckpoint(progress);
+        await this._page.performActionPreChecks(progress);
       }, timeout);
 
       // Step 2: perform one-shot expect check without a timeout.
@@ -1430,7 +1299,7 @@ class Frame extends _instrumentation.SdkObject {
       }
       if (timeout < 0) return {
         matches: options.isNot,
-        log: metadata.log,
+        log: (0, _utils.compressCallLog)(metadata.log),
         timedOut: true,
         received: lastIntermediateResult.received
       };
@@ -1438,7 +1307,7 @@ class Frame extends _instrumentation.SdkObject {
       // Step 3: auto-retry expect with increasing timeouts. Bounded by the total remaining time.
       return await new _progress.ProgressController(metadata, this).run(async progress => {
         return await this.retryWithProgressAndTimeouts(progress, [100, 250, 500, 1000], async continuePolling => {
-          await this._page.performLocatorHandlersCheckpoint(progress);
+          await this._page.performActionPreChecks(progress);
           const {
             matches,
             received
@@ -1461,7 +1330,7 @@ class Frame extends _instrumentation.SdkObject {
       if (js.isJavaScriptErrorInEvaluate(e) || (0, _selectorParser.isInvalidSelectorError)(e)) throw e;
       const result = {
         matches: options.isNot,
-        log: metadata.log
+        log: (0, _utils.compressCallLog)(metadata.log)
       };
       if (lastIntermediateResult.isSet) result.received = lastIntermediateResult.received;
       if (e instanceof _errors.TimeoutError) result.timedOut = true;
@@ -1496,10 +1365,10 @@ class Frame extends _instrumentation.SdkObject {
       callId
     }) => {
       const elements = info ? injected.querySelectorAll(info.parsed, document) : [];
+      if (callId) injected.markTargetElements(new Set(elements), callId);
       const isArray = options.expression === 'to.have.count' || options.expression.endsWith('.array');
       let log = '';
       if (isArray) log = `  locator resolved to ${elements.length} element${elements.length === 1 ? '' : 's'}`;else if (elements.length > 1) throw injected.strictModeViolationError(info.parsed, elements);else if (elements.length) log = `  locator resolved to ${injected.previewNode(elements[0])}`;
-      if (callId) injected.markTargetElements(new Set(elements), callId);
       return {
         log,
         ...(await injected.expect(elements[0], options, elements))
@@ -1817,5 +1686,6 @@ function renderUnexpectedValue(expression, received) {
   if (expression === 'to.be.readonly') return received ? 'readonly' : 'editable';
   if (expression === 'to.be.empty') return received ? 'empty' : 'not empty';
   if (expression === 'to.be.focused') return received ? 'focused' : 'not focused';
+  if (expression === 'to.match.aria') return received ? received.raw : received;
   return received;
 }

package/lib/server/index.js

@@ -45,12 +45,6 @@ Object.defineProperty(exports, "installBrowsersForNpmInstall", {
     return _registry.installBrowsersForNpmInstall;
   }
 });
-Object.defineProperty(exports, "installDefaultBrowsersForNpmInstall", {
-  enumerable: true,
-  get: function () {
-    return _registry.installDefaultBrowsersForNpmInstall;
-  }
-});
 Object.defineProperty(exports, "installRootRedirect", {
   enumerable: true,
   get: function () {

package/lib/server/javascript.js

@@ -55,9 +55,6 @@ class ExecutionContext extends _instrumentation.SdkObject {
   rawEvaluateHandle(expression) {
     return this._raceAgainstContextDestroyed(this._delegate.rawEvaluateHandle(expression));
   }
-  rawCallFunctionNoReply(func, ...args) {
-    this._delegate.rawCallFunctionNoReply(func, ...args);
-  }
   evaluateWithArguments(expression, returnByValue, utilityScript, values, objectIds) {
     return this._raceAgainstContextDestroyed(this._delegate.evaluateWithArguments(expression, returnByValue, utilityScript, values, objectIds));
   }
@@ -108,9 +105,6 @@ class JSHandle extends _instrumentation.SdkObject {
     this._preview = this._objectId ? preview || `JSHandle@${this._objectType}` : String(value);
     if (this._objectId && globalThis.leakedJSHandles) globalThis.leakedJSHandles.set(this, new Error('Leaked JSHandle'));
   }
-  callFunctionNoReply(func, arg) {
-    this._context.rawCallFunctionNoReply(func, this, arg);
-  }
   async evaluate(pageFunction, arg) {
     return evaluate(this._context, true /* returnByValue */, pageFunction, this, arg);
   }

package/lib/server/page.js

@@ -22,6 +22,7 @@ var _instrumentation = require("./instrumentation");
 var _selectorParser = require("../utils/isomorphic/selectorParser");
 var _utilityScriptSerializers = require("./isomorphic/utilityScriptSerializers");
 var _errors = require("./errors");
+var _helper = require("./helper");
 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; }
 /**
@@ -308,7 +309,29 @@ class Page extends _instrumentation.SdkObject {
   unregisterLocatorHandler(uid) {
     this._locatorHandlers.delete(uid);
   }
-  async performLocatorHandlersCheckpoint(progress) {
+  async performActionPreChecks(progress) {
+    await this._performWaitForNavigationCheck(progress);
+    progress.throwIfAborted();
+    await this._performLocatorHandlersCheckpoint(progress);
+    progress.throwIfAborted();
+    // Wait once again, just in case a locator handler caused a navigation.
+    await this._performWaitForNavigationCheck(progress);
+  }
+  async _performWaitForNavigationCheck(progress) {
+    var _mainFrame$pendingDoc;
+    if (process.env.PLAYWRIGHT_SKIP_NAVIGATION_CHECK) return;
+    const mainFrame = this._frameManager.mainFrame();
+    if (!mainFrame || !mainFrame.pendingDocument()) return;
+    const url = (_mainFrame$pendingDoc = mainFrame.pendingDocument()) === null || _mainFrame$pendingDoc === void 0 || (_mainFrame$pendingDoc = _mainFrame$pendingDoc.request) === null || _mainFrame$pendingDoc === void 0 ? void 0 : _mainFrame$pendingDoc.url();
+    const toUrl = url ? `" ${(0, _utils.trimStringWithEllipsis)(url, 200)}"` : '';
+    progress.log(`  waiting for${toUrl} navigation to finish...`);
+    await _helper.helper.waitForEvent(progress, mainFrame, frames.Frame.Events.InternalNavigation, e => {
+      if (!e.isPublic) return false;
+      if (!e.error) progress.log(`  navigated to "${(0, _utils.trimStringWithEllipsis)(mainFrame.url(), 200)}"`);
+      return true;
+    }).promise;
+  }
+  async _performLocatorHandlersCheckpoint(progress) {
     // Do not run locator handlers from inside locator handler callbacks to avoid deadlocks.
     if (this._locatorHandlerRunningCounter) return;
     for (const [uid, handler] of this._locatorHandlers) {
@@ -409,7 +432,7 @@ class Page extends _instrumentation.SdkObject {
     const rafrafScreenshot = locator ? async (progress, timeout) => {
       return await locator.frame.rafrafTimeoutScreenshotElementWithProgress(progress, locator.selector, timeout, options || {});
     } : async (progress, timeout) => {
-      await this.performLocatorHandlersCheckpoint(progress);
+      await this.performActionPreChecks(progress);
       await this.mainFrame().rafrafTimeout(timeout);
       return await this._screenshotter.screenshotPage(progress, options || {});
     };
@@ -472,19 +495,23 @@ class Page extends _instrumentation.SdkObject {
         progress.log(`screenshot matched expectation`);
         return {};
       }
-      if (areEqualScreenshots(actual, options.expected, previous)) {
+      if (areEqualScreenshots(actual, options.expected, undefined)) {
         progress.log(`screenshot matched expectation`);
         return {};
       }
       throw new Error(intermediateResult.errorMessage);
     }, callTimeout).catch(e => {
+      var _intermediateResult;
       // Q: Why not throw upon isSessionClosedError(e) as in other places?
       // A: We want user to receive a friendly diff between actual and expected/previous.
       if (js.isJavaScriptErrorInEvaluate(e) || (0, _selectorParser.isInvalidSelectorError)(e)) throw e;
+      let errorMessage = e.message;
+      if (e instanceof _errors.TimeoutError && (_intermediateResult = intermediateResult) !== null && _intermediateResult !== void 0 && _intermediateResult.previous) errorMessage = `Failed to take two consecutive stable screenshots.`;
       return {
-        log: e.message ? [...metadata.log, e.message] : metadata.log,
+        log: (0, _utils.compressCallLog)(e.message ? [...metadata.log, e.message] : metadata.log),
         ...intermediateResult,
-        errorMessage: e.message
+        errorMessage,
+        timedOut: e instanceof _errors.TimeoutError
       };
     });
   }
@@ -596,16 +623,20 @@ Page.Events = {
   Worker: 'worker'
 };
 class Worker extends _instrumentation.SdkObject {
-  constructor(parent, url) {
+  constructor(parent, url, targetId, session) {
     super(parent, 'worker');
     this._url = void 0;
     this._executionContextPromise = void 0;
     this._executionContextCallback = void 0;
     this._existingExecutionContext = null;
     this.openScope = new _utils.LongStandingScope();
+    this._targetId = void 0;
+    this._session = void 0;
     this._url = url;
     this._executionContextCallback = () => {};
     this._executionContextPromise = new Promise(x => this._executionContextCallback = x);
+    this._targetId = targetId;
+    this._session = session;
   }
   _createExecutionContext(delegate) {
     this._existingExecutionContext = new js.ExecutionContext(this, delegate, 'worker');
@@ -619,14 +650,23 @@ class Worker extends _instrumentation.SdkObject {
     this.emit(Worker.Events.Close, this);
     this.openScope.close(new Error('Worker closed'));
   }
+  async getExecutionContext() {
+    if (process.env['REBROWSER_PATCHES_RUNTIME_FIX_MODE'] !== '0' && !this._existingExecutionContext) {
+      await this._session.__re__emitExecutionContext({
+        world: 'main',
+        targetId: this._targetId
+      });
+    }
+    return this._executionContextPromise;
+  }
   async evaluateExpression(expression, isFunction, arg) {
-    return js.evaluateExpression(await this._executionContextPromise, expression, {
+    return js.evaluateExpression(await this.getExecutionContext(), expression, {
       returnByValue: true,
       isFunction
     }, arg);
   }
   async evaluateExpressionHandle(expression, isFunction, arg) {
-    return js.evaluateExpression(await this._executionContextPromise, expression, {
+    return js.evaluateExpression(await this.getExecutionContext(), expression, {
       returnByValue: false,
       isFunction
     }, arg);

package/lib/server/progress.js

@@ -70,9 +70,6 @@ class ProgressController {
       throwIfAborted: () => {
         if (this._state === 'aborted') throw new AbortedError();
       },
-      beforeInputAction: async element => {
-        await this.instrumentation.onBeforeInputAction(this.sdkObject, this.metadata, element);
-      },
       metadata: this.metadata
     };
     const timeoutError = new _errors.TimeoutError(`Timeout ${this._timeout}ms exceeded.`);