patchright-core 1.48.2 → 1.49.1

package/lib/server/frames.js

@@ -201,6 +201,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,
@@ -603,7 +608,8 @@ class Frame extends _instrumentation.SdkObject {
         nodeId: globalDoc.nodeId
       });
     }
-    if (this.isDetached()) throw new Error('Frame was detached');
+
+    // if (this.isDetached()) throw new Error('Frame was detached');
     try {
       var client = this._page._delegate._sessionForFrame(this)._client;
     } catch (e) {
@@ -664,6 +670,7 @@ class Frame extends _instrumentation.SdkObject {
         worldName: world
       });
       if (!result) {
+        // if (this.isDetached()) throw new Error("Frame was detached");
         return;
       }
       var executionContextId = result.executionContextId;
@@ -729,12 +736,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) {
@@ -745,6 +752,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;
@@ -1058,19 +1066,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) {
@@ -1085,7 +1095,8 @@ class Frame extends _instrumentation.SdkObject {
           element
         };
       }, {
-        info: resolved.info
+        info: resolved.info,
+        callId: progress.metadata.id
       });
       const {
         log,
@@ -1114,7 +1125,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);
     });
@@ -1122,7 +1133,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
       })));
@@ -1131,13 +1142,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();
@@ -1149,7 +1160,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();
@@ -1166,25 +1177,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) {
@@ -1284,44 +1295,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) {
@@ -1330,6 +1341,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.
@@ -1353,7 +1370,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.
@@ -1374,7 +1391,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
       };
@@ -1382,7 +1399,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
@@ -1405,7 +1422,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;
@@ -1440,10 +1457,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))
@@ -1706,44 +1723,19 @@ class Frame extends _instrumentation.SdkObject {
     return (0, _utils.asLocator)(this._page.attribution.playwright.options.sdkLanguage, selector);
   }
   async _getFrameMainFrameContextId(client) {
-    var globalDocument = await client._sendMayFail('DOM.getFrameOwner', {
+    var globalDocument = await client._sendMayFail("DOM.getFrameOwner", {
       frameId: this._id
     });
     if (globalDocument && globalDocument.nodeId) {
-      for (const executionContextId of this._page._delegate._sessionForFrame(this)._parsedExecutionContextIds) {
-        var documentObj = await client._sendMayFail("DOM.resolveNode", {
-          nodeId: globalDocument.nodeId
+      var descibedNode = await client._sendMayFail("DOM.describeNode", {
+        backendNodeId: globalDocument.backendNodeId
+      });
+      if (descibedNode) {
+        var resolvedNode = await client._sendMayFail("DOM.resolveNode", {
+          nodeId: descibedNode.node.contentDocument.nodeId
         });
-        if (documentObj) {
-          var globalThis = await client._sendMayFail('Runtime.evaluate', {
-            expression: "document",
-            serializationOptions: {
-              serialization: "idOnly"
-            },
-            contextId: executionContextId
-          });
-          if (globalThis) {
-            var globalThisObjId = globalThis["result"]['objectId'];
-            var requestedNode = await client.send("DOM.requestNode", {
-              objectId: globalThisObjId
-            });
-            var node = await client._sendMayFail("DOM.describeNode", {
-              nodeId: requestedNode.nodeId,
-              pierce: true,
-              depth: 10
-            });
-            if (node && node.node.documentURL == this._url) {
-              var node0 = await client._sendMayFail("DOM.resolveNode", {
-                nodeId: requestedNode.nodeId
-              });
-              if (node0 && node.node.nodeId - 1 == globalDocument.nodeId) {
-                // && (node.node.backendNodeId + 1 == globalDocument.backendNodeId)
-                var _executionContextId = parseInt(node0.object.objectId.split('.')[1], 10);
-                return _executionContextId;
-              }
-            }
-          }
-        }
+        var _executionContextId = parseInt(resolvedNode.object.objectId.split(".")[1], 10);
+        return _executionContextId;
       }
     }
     return 0;
@@ -1804,5 +1796,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
       };
     });
   }

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.`);

package/lib/server/recorder/recorderApp.js

@@ -38,7 +38,7 @@ class EmptyRecorderApp extends _events.EventEmitter {
   async setPaused(paused) {}
   async setMode(mode) {}
   async setRunningFile(file) {}
-  async setSelector(selector, userGesture) {}
+  async elementPicked(elementInfo, userGesture) {}
   async updateCallLogs(callLogs) {}
   async setSources(sources) {}
   async setActions(actions, sources) {}
@@ -165,23 +165,14 @@ class RecorderApp extends _events.EventEmitter {
     }
   }
   async setActions(actions, sources) {}
-  async setSelector(selector, userGesture) {
-    if (userGesture) {
-      var _this$_recorder;
-      if (((_this$_recorder = this._recorder) === null || _this$_recorder === void 0 ? void 0 : _this$_recorder.mode()) === 'inspecting') {
-        this._recorder.setMode('standby');
-        this._page.bringToFront();
-      } else {
-        var _this$_recorder2;
-        (_this$_recorder2 = this._recorder) === null || _this$_recorder2 === void 0 || _this$_recorder2.setMode('recording');
-      }
-    }
-    await this._page.mainFrame().evaluateExpression((data => {
-      window.playwrightSetSelector(data.selector, data.userGesture);
+  async elementPicked(elementInfo, userGesture) {
+    if (userGesture) this._page.bringToFront();
+    await this._page.mainFrame().evaluateExpression((param => {
+      window.playwrightElementPicked(param.elementInfo, param.userGesture);
     }).toString(), {
       isFunction: true
     }, {
-      selector,
+      elementInfo,
       userGesture
     }).catch(() => {});
   }

package/lib/server/recorder/recorderInTraceViewer.js

@@ -77,9 +77,9 @@ class RecorderInTraceViewer extends _events.EventEmitter {
       file
     });
   }
-  async setSelector(selector, userGesture) {
-    this._transport.deliverEvent('setSelector', {
-      selector,
+  async elementPicked(elementInfo, userGesture) {
+    this._transport.deliverEvent('elementPicked', {
+      elementInfo,
       userGesture
     });
   }

package/lib/server/recorder/recorderUtils.js

@@ -73,11 +73,12 @@ function callMetadataForAction(pageAliases, actionInContext) {
   const mainFrame = mainFrameForAction(pageAliases, actionInContext);
   const {
     method,
+    apiName,
     params
   } = (0, _recorderUtils.traceParamsForAction)(actionInContext);
   const callMetadata = {
     id: `call@${(0, _utils.createGuid)()}`,
-    apiName: 'page.' + method,
+    apiName,
     objectId: mainFrame.guid,
     pageId: mainFrame._page.guid,
     frameId: mainFrame.guid,