@smoothdeploy/playwright-core 1.57.1 → 1.58.1-beta-1770452953000

package/lib/server/dispatchers/pageAgentDispatcher.js

@@ -0,0 +1,96 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pageAgentDispatcher_exports = {};
+__export(pageAgentDispatcher_exports, {
+  PageAgentDispatcher: () => PageAgentDispatcher
+});
+module.exports = __toCommonJS(pageAgentDispatcher_exports);
+var import_dispatcher = require("./dispatcher");
+var import_pageAgent = require("../agent/pageAgent");
+var import_instrumentation = require("../instrumentation");
+var import_context = require("../agent/context");
+class PageAgentDispatcher extends import_dispatcher.Dispatcher {
+  constructor(scope, options) {
+    super(scope, new import_instrumentation.SdkObject(scope._object, "pageAgent"), "PageAgent", { page: scope });
+    this._type_PageAgent = true;
+    this._type_EventTarget = true;
+    this._usage = { turns: 0, inputTokens: 0, outputTokens: 0 };
+    this._page = scope._object;
+    this._context = new import_context.Context(this._page, options, this._eventSupport());
+  }
+  async perform(params, progress) {
+    try {
+      await (0, import_pageAgent.pageAgentPerform)(progress, this._context, params.task, params);
+    } finally {
+      this._context.pushHistory({ type: "perform", description: params.task });
+    }
+    return { usage: this._usage };
+  }
+  async expect(params, progress) {
+    try {
+      await (0, import_pageAgent.pageAgentExpect)(progress, this._context, params.expectation, params);
+    } finally {
+      this._context.pushHistory({ type: "expect", description: params.expectation });
+    }
+    return { usage: this._usage };
+  }
+  async extract(params, progress) {
+    const result = await (0, import_pageAgent.pageAgentExtract)(progress, this._context, params.query, params.schema, params);
+    return { result, usage: this._usage };
+  }
+  async usage(params, progress) {
+    return { usage: this._usage };
+  }
+  async dispose(params, progress) {
+    progress.metadata.potentiallyClosesScope = true;
+    void this.stopPendingOperations(new Error("The agent is disposed"));
+    this._dispose();
+  }
+  _eventSupport() {
+    const self = this;
+    return {
+      onBeforeTurn(params) {
+        const userMessage = params.conversation.messages.find((m) => m.role === "user");
+        self._dispatchEvent("turn", { role: "user", message: userMessage?.content ?? "" });
+      },
+      onAfterTurn(params) {
+        const usage = { inputTokens: params.totalUsage.input, outputTokens: params.totalUsage.output };
+        const intent = params.assistantMessage.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+        self._dispatchEvent("turn", { role: "assistant", message: intent, usage });
+        if (!params.assistantMessage.content.filter((c) => c.type === "tool_call").length)
+          self._dispatchEvent("turn", { role: "assistant", message: `no tool calls`, usage });
+        self._usage = { turns: self._usage.turns + 1, inputTokens: self._usage.inputTokens + usage.inputTokens, outputTokens: self._usage.outputTokens + usage.outputTokens };
+      },
+      onBeforeToolCall(params) {
+        self._dispatchEvent("turn", { role: "assistant", message: `call tool "${params.toolCall.name}"` });
+      },
+      onAfterToolCall(params) {
+        const suffix = params.toolCall.result?.isError ? "failed" : "succeeded";
+        self._dispatchEvent("turn", { role: "user", message: `tool "${params.toolCall.name}" ${suffix}` });
+      },
+      onToolCallError(params) {
+        self._dispatchEvent("turn", { role: "user", message: `tool "${params.toolCall.name}" failed: ${params.error.message}` });
+      }
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PageAgentDispatcher
+});

package/lib/server/dispatchers/pageDispatcher.js

@@ -36,6 +36,7 @@ var import_networkDispatchers3 = require("./networkDispatchers");
 var import_webSocketRouteDispatcher = require("./webSocketRouteDispatcher");
 var import_instrumentation = require("../instrumentation");
 var import_urlMatch = require("../../utils/isomorphic/urlMatch");
+var import_pageAgentDispatcher = require("./pageAgentDispatcher");
 class PageDispatcher extends import_dispatcher.Dispatcher {
   constructor(parentScope, page) {
     const mainFrame = import_frameDispatcher.FrameDispatcher.from(parentScope, page.mainFrame());
@@ -288,6 +289,9 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
     const coverage = this._page.coverage;
     return await coverage.stopCSSCoverage();
   }
+  async agent(params, progress) {
+    return { agent: new import_pageAgentDispatcher.PageAgentDispatcher(this, params) };
+  }
   _onFrameAttached(frame) {
     this._dispatchEvent("frameAttached", { frame: import_frameDispatcher.FrameDispatcher.from(this.parentScope(), frame) });
   }

package/lib/server/dom.js

@@ -255,6 +255,7 @@ class ElementHandle extends js.JSHandle {
   async _retryAction(progress, actionName, action, options) {
     let retry = 0;
     const waitTime = [0, 20, 100, 100, 500];
+    const noAutoWaiting = options.__testHookNoAutoWaiting ?? options.noAutoWaiting;
     while (true) {
       if (retry) {
         progress.log(`retrying ${actionName} action${options.trial ? " (trial run)" : ""}`);
@@ -268,35 +269,43 @@ class ElementHandle extends js.JSHandle {
       } else {
         progress.log(`attempting ${actionName} action${options.trial ? " (trial run)" : ""}`);
       }
-      if (!options.skipActionPreChecks && !options.force)
+      if (!options.skipActionPreChecks && !options.force && !noAutoWaiting)
         await this._frame._page.performActionPreChecks(progress);
       const result = await action(retry);
       ++retry;
       if (result === "error:notvisible") {
-        if (options.force)
+        if (options.force || noAutoWaiting)
           throw new NonRecoverableDOMError("Element is not visible");
         progress.log("  element is not visible");
         continue;
       }
       if (result === "error:notinviewport") {
-        if (options.force)
+        if (options.force || noAutoWaiting)
           throw new NonRecoverableDOMError("Element is outside of the viewport");
         progress.log("  element is outside of the viewport");
         continue;
       }
       if (result === "error:optionsnotfound") {
+        if (noAutoWaiting)
+          throw new NonRecoverableDOMError("Did not find some options");
         progress.log("  did not find some options");
         continue;
       }
       if (result === "error:optionnotenabled") {
+        if (noAutoWaiting)
+          throw new NonRecoverableDOMError("Option being selected is not enabled");
         progress.log("  option being selected is not enabled");
         continue;
       }
       if (typeof result === "object" && "hitTargetDescription" in result) {
+        if (noAutoWaiting)
+          throw new NonRecoverableDOMError(`${result.hitTargetDescription} intercepts pointer events`);
         progress.log(`  ${result.hitTargetDescription} intercepts pointer events`);
         continue;
       }
       if (typeof result === "object" && "missingState" in result) {
+        if (noAutoWaiting)
+          throw new NonRecoverableDOMError(`Element is not ${result.missingState}`);
         progress.log(`  element is not ${result.missingState}`);
         continue;
       }

package/lib/server/electron/electron.js

@@ -158,8 +158,8 @@ class Electron extends import_instrumentation.SdkObject {
     let shell = false;
     if (process.platform === "win32") {
       shell = true;
-      command = `"${command}"`;
-      electronArguments = electronArguments.map((arg) => `"${arg}"`);
+      command = [command, ...electronArguments].map((arg) => `"${escapeDoubleQuotes(arg)}"`).join(" ");
+      electronArguments = [];
     }
     delete env.NODE_OPTIONS;
     const { launchedProcess, gracefullyClose, kill } = await (0, import_processLauncher.launchProcess)({
@@ -263,6 +263,9 @@ async function waitForLine(progress, process2, regex) {
     import_eventsHelper.eventsHelper.removeEventListeners(listeners);
   }
 }
+function escapeDoubleQuotes(str) {
+  return str.replace(/"/g, '\\"');
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Electron,

package/lib/server/firefox/ffBrowser.js

@@ -54,7 +54,6 @@ class FFBrowser extends import_browser.Browser {
     this.session.on("Browser.detachedFromTarget", this._onDetachedFromTarget.bind(this));
     this.session.on("Browser.downloadCreated", this._onDownloadCreated.bind(this));
     this.session.on("Browser.downloadFinished", this._onDownloadFinished.bind(this));
-    this.session.on("Browser.videoRecordingFinished", this._onVideoRecordingFinished.bind(this));
   }
   static async connect(parent, transport, options) {
     const connection = new import_ffConnection.FFConnection(transport, options.protocolLogger, options.browserLogsCollector);
@@ -141,12 +140,9 @@ class FFBrowser extends import_browser.Browser {
     const error = payload.canceled ? "canceled" : payload.error;
     this._downloadFinished(payload.uuid, error);
   }
-  _onVideoRecordingFinished(payload) {
-    this._takeVideo(payload.screencastId)?.reportFinished();
-  }
   _onDisconnect() {
     for (const video of this._idToVideo.values())
-      video.artifact.reportFinished(new import_errors.TargetClosedError());
+      video.artifact.reportFinished(new import_errors.TargetClosedError(this.closeReason()));
     this._idToVideo.clear();
     for (const ffPage of this._ffPages.values())
       ffPage.didClose();
@@ -199,15 +195,13 @@ class FFBrowserContext extends import_browserContext.BrowserContext {
       promises.push(this.doUpdateOffline());
     promises.push(this.doUpdateDefaultEmulatedMedia());
     if (this._options.recordVideo) {
-      promises.push(this._ensureVideosPath().then(() => {
-        return this._browser.session.send("Browser.setVideoRecordingOptions", {
-          // validateBrowserContextOptions ensures correct video size.
-          options: {
-            ...this._options.recordVideo.size,
-            dir: this._options.recordVideo.dir
-          },
-          browserContextId: this._browserContextId
-        });
+      promises.push(this._browser.session.send("Browser.setScreencastOptions", {
+        // validateBrowserContextOptions ensures correct video size.
+        options: {
+          ...this._options.recordVideo.size,
+          quality: 90
+        },
+        browserContextId: this._browserContextId
       }));
     }
     const proxy = this._options.proxyOverride || this._options.proxy;
@@ -379,12 +373,8 @@ class FFBrowserContext extends import_browserContext.BrowserContext {
   }
   async doClose(reason) {
     if (!this._browserContextId) {
-      if (this._options.recordVideo) {
-        await this._browser.session.send("Browser.setVideoRecordingOptions", {
-          options: void 0,
-          browserContextId: this._browserContextId
-        });
-      }
+      if (this._options.recordVideo)
+        await Promise.all(this._ffPages().map((ffPage) => ffPage._page.screencast.stopVideoRecording()));
       await this._browser.close({ reason });
     } else {
       await this._browser.session.send("Browser.removeBrowserContext", { browserContextId: this._browserContextId });

package/lib/server/firefox/ffConnection.js

@@ -90,11 +90,6 @@ class FFSession extends import_events.EventEmitter {
     this._connection = connection;
     this._sessionId = sessionId;
     this._rawSend = rawSend;
-    this.on = super.on;
-    this.addListener = super.addListener;
-    this.off = super.removeListener;
-    this.removeListener = super.removeListener;
-    this.once = super.once;
   }
   markAsCrashed() {
     this._crashed = true;

package/lib/server/firefox/ffNetworkManager.js

@@ -170,9 +170,9 @@ const causeToResourceType = {
   TYPE_FONT: "font",
   TYPE_MEDIA: "media",
   TYPE_WEBSOCKET: "websocket",
-  TYPE_CSP_REPORT: "other",
+  TYPE_CSP_REPORT: "cspreport",
   TYPE_XSLT: "other",
-  TYPE_BEACON: "other",
+  TYPE_BEACON: "beacon",
   TYPE_FETCH: "fetch",
   TYPE_IMAGESET: "image",
   TYPE_WEB_MANIFEST: "manifest"

package/lib/server/firefox/ffPage.js

@@ -41,9 +41,9 @@ var import_ffConnection = require("./ffConnection");
 var import_ffExecutionContext = require("./ffExecutionContext");
 var import_ffInput = require("./ffInput");
 var import_ffNetworkManager = require("./ffNetworkManager");
-var import_debugLogger = require("../utils/debugLogger");
 var import_stackTrace = require("../../utils/isomorphic/stackTrace");
 var import_errors = require("../errors");
+var import_debugLogger = require("../utils/debugLogger");
 const UTILITY_WORLD_NAME = "__playwright_utility_world__";
 class FFPage {
   constructor(session, browserContext, opener) {
@@ -83,13 +83,16 @@ class FFPage {
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.workerDestroyed", this._onWorkerDestroyed.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.dispatchMessageFromWorker", this._onDispatchMessageFromWorker.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.crashed", this._onCrashed.bind(this)),
-      import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.videoRecordingStarted", this._onVideoRecordingStarted.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.webSocketCreated", this._onWebSocketCreated.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.webSocketClosed", this._onWebSocketClosed.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.webSocketFrameReceived", this._onWebSocketFrameReceived.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.webSocketFrameSent", this._onWebSocketFrameSent.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.screencastFrame", this._onScreencastFrame.bind(this))
     ];
+    const screencast = this._page.screencast;
+    const videoOptions = screencast.launchVideoRecorder();
+    if (videoOptions)
+      screencast.startVideoRecording(videoOptions).catch((e) => import_debugLogger.debugLogger.log("error", e));
     this._session.once("Page.ready", () => {
       if (this._reportedAsNew)
         return;
@@ -272,11 +275,8 @@ class FFPage {
     this._session.markAsCrashed();
     this._page._didCrash();
   }
-  _onVideoRecordingStarted(event) {
-    this._browserContext._browser._videoStarted(this._browserContext, event.screencastId, event.file, this._page.waitForInitializedOrError());
-  }
   didClose() {
-    this._markAsError(new import_errors.TargetClosedError());
+    this._markAsError(new import_errors.TargetClosedError(this._page.closeReason()));
     this._session.dispose();
     import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
     this._networkManager.dispose();
@@ -417,24 +417,21 @@ class FFPage {
       throw e;
     });
   }
-  async setScreencastOptions(options) {
-    if (options) {
-      const { screencastId } = await this._session.send("Page.startScreencast", options);
-      this._screencastId = screencastId;
-    } else {
-      await this._session.send("Page.stopScreencast");
-    }
+  async startScreencast(options) {
+    await this._session.send("Page.startScreencast", options);
+  }
+  async stopScreencast() {
+    await this._session.sendMayFail("Page.stopScreencast");
   }
   _onScreencastFrame(event) {
-    if (!this._screencastId)
-      return;
-    const screencastId = this._screencastId;
-    this._page.throttleScreencastFrameAck(() => {
-      this._session.send("Page.screencastFrameAck", { screencastId }).catch((e) => import_debugLogger.debugLogger.log("error", e));
+    this._page.screencast.throttleFrameAck(() => {
+      this._session.sendMayFail("Page.screencastFrameAck");
     });
     const buffer = Buffer.from(event.data, "base64");
     this._page.emit(import_page2.Page.Events.ScreencastFrame, {
       buffer,
+      frameSwapWallTime: event.timestamp * 1e3,
+      // timestamp is in seconds, we need to convert to milliseconds.
       width: event.deviceWidth,
       height: event.deviceHeight
     });

package/lib/server/firefox/firefox.js

@@ -56,15 +56,13 @@ class Firefox extends import_browserType.BrowserType {
   connectToTransport(transport, options) {
     return import_ffBrowser.FFBrowser.connect(this.attribution.playwright, transport, options);
   }
-  doRewriteStartupLog(error) {
-    if (!error.logs)
-      return error;
-    if (error.logs.includes(`as root in a regular user's session is not supported.`))
-      error.logs = "\n" + (0, import_ascii.wrapInASCIIBox)(`Firefox is unable to launch if the $HOME folder isn't owned by the current user.
+  doRewriteStartupLog(logs) {
+    if (logs.includes(`as root in a regular user's session is not supported.`))
+      logs = "\n" + (0, import_ascii.wrapInASCIIBox)(`Firefox is unable to launch if the $HOME folder isn't owned by the current user.
 Workaround: Set the HOME=/root environment variable${process.env.GITHUB_ACTION ? " in your GitHub Actions workflow file" : ""} when running Playwright.`, 1);
-    if (error.logs.includes("no DISPLAY environment variable specified"))
-      error.logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
-    return error;
+    if (logs.includes("no DISPLAY environment variable specified"))
+      logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
+    return logs;
   }
   amendEnvironment(env) {
     if (!import_path.default.isAbsolute(import_os.default.homedir()))

package/lib/server/frameSelectors.js

@@ -50,7 +50,9 @@ class FrameSelectors {
     if (!resolved)
       throw new Error(`Failed to find frame for selector "${selector}"`);
     return await resolved.injected.evaluateHandle((injected, { info, scope: scope2 }) => {
-      return injected.querySelectorAll(info.parsed, scope2 || document);
+      const elements = injected.querySelectorAll(info.parsed, scope2 || document);
+      injected.checkDeprecatedSelectorUsage(info.parsed, elements);
+      return elements;
     }, { info: resolved.info, scope: resolved.scope });
   }
   async queryCount(selector, options) {
@@ -59,7 +61,9 @@ class FrameSelectors {
       throw new Error(`Failed to find frame for selector "${selector}"`);
     await options.__testHookBeforeQuery?.();
     return await resolved.injected.evaluate((injected, { info }) => {
-      return injected.querySelectorAll(info.parsed, document).length;
+      const elements = injected.querySelectorAll(info.parsed, document);
+      injected.checkDeprecatedSelectorUsage(info.parsed, elements);
+      return elements.length;
     }, { info: resolved.info });
   }
   async queryAll(selector, scope) {
@@ -67,7 +71,9 @@ class FrameSelectors {
     if (!resolved)
       return [];
     const arrayHandle = await resolved.injected.evaluateHandle((injected, { info, scope: scope2 }) => {
-      return injected.querySelectorAll(info.parsed, scope2 || document);
+      const elements = injected.querySelectorAll(info.parsed, scope2 || document);
+      injected.checkDeprecatedSelectorUsage(info.parsed, elements);
+      return elements;
     }, { info: resolved.info, scope: resolved.scope });
     const properties = await arrayHandle.getProperties();
     arrayHandle.dispose();

package/lib/server/frames.js

@@ -350,6 +350,11 @@ class FrameManager {
     frame.emit(Frame.Events.InternalNavigation, event);
   }
 }
+const FrameEvent = {
+  InternalNavigation: "internalnavigation",
+  AddLifecycle: "addlifecycle",
+  RemoveLifecycle: "removelifecycle"
+};
 class Frame extends import_instrumentation.SdkObject {
   constructor(page, id, parentFrame) {
     super(page, "frame");
@@ -382,11 +387,7 @@ class Frame extends import_instrumentation.SdkObject {
       this._startNetworkIdleTimer();
   }
   static {
-    this.Events = {
-      InternalNavigation: "internalnavigation",
-      AddLifecycle: "addlifecycle",
-      RemoveLifecycle: "removelifecycle"
-    };
+    this.Events = FrameEvent;
   }
   isDetached() {
     return this._detachedScope.isClosed();
@@ -569,7 +570,7 @@ class Frame extends import_instrumentation.SdkObject {
     const request = navigationEvent.newDocument ? navigationEvent.newDocument.request : void 0;
     return request ? progress.race(request._finalRequest().response()) : null;
   }
-  async _waitForLoadState(progress, state) {
+  async waitForLoadState(progress, state) {
     const waitUntil = verifyLifecycle("state", state);
     if (!this._firedLifecycleEvents.has(waitUntil))
       await import_helper.helper.waitForEvent(progress, this, Frame.Events.AddLifecycle, (e) => e === waitUntil).promise;
@@ -640,6 +641,7 @@ class Frame extends import_instrumentation.SdkObject {
         } else if (element2) {
           log2 = `  locator resolved to ${visible2 ? "visible" : "hidden"} ${injected.previewNode(element2)}`;
         }
+        injected.checkDeprecatedSelectorUsage(info.parsed, elements);
         return { log: log2, element: element2, visible: visible2, attached: !!element2 };
       }, { info: resolved.info, root: resolved.frame === this ? scope : void 0 }));
       const { log, visible, attached } = await progress.race(result.evaluate((r) => ({ log: r.log, visible: r.visible, attached: r.attached })));
@@ -735,7 +737,7 @@ class Frame extends import_instrumentation.SdkObject {
         this._onClearLifecycle();
         tagPromise.resolve();
       });
-      const lifecyclePromise = progress.race(tagPromise).then(() => this._waitForLoadState(progress, waitUntil));
+      const lifecyclePromise = progress.race(tagPromise).then(() => this.waitForLoadState(progress, waitUntil));
       const contentPromise = progress.race(context.evaluate(({ html: html2, tag: tag2 }) => {
         document.open();
         console.debug(tag2);
@@ -905,14 +907,19 @@ class Frame extends import_instrumentation.SdkObject {
       return true;
     return false;
   }
-  async _retryWithProgressIfNotConnected(progress, selector, strict, performActionPreChecks, action) {
+  async _retryWithProgressIfNotConnected(progress, selector, options, action) {
     progress.log(`waiting for ${this._asLocator(selector)}`);
+    const noAutoWaiting = options.__testHookNoAutoWaiting ?? options.noAutoWaiting;
+    const performActionPreChecks = (options.performActionPreChecks ?? !options.force) && !noAutoWaiting;
     return this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async (continuePolling) => {
       if (performActionPreChecks)
         await this._page.performActionPreChecks(progress);
-      const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, { strict }));
-      if (!resolved)
+      const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, { strict: options.strict }));
+      if (!resolved) {
+        if (noAutoWaiting)
+          throw new dom.NonRecoverableDOMError("Element(s) not found");
         return continuePolling;
+      }
       const result = await progress.race(resolved.injected.evaluateHandle((injected, { info, callId }) => {
         const elements = injected.querySelectorAll(info.parsed, document);
         if (callId)
@@ -926,12 +933,15 @@ class Frame extends import_instrumentation.SdkObject {
         } else if (element2) {
           log2 = `  locator resolved to ${injected.previewNode(element2)}`;
         }
+        injected.checkDeprecatedSelectorUsage(info.parsed, elements);
         return { log: log2, success: !!element2, element: element2 };
       }, { info: resolved.info, callId: progress.metadata.id }));
       const { log, success } = await progress.race(result.evaluate((r) => ({ log: r.log, success: r.success })));
       if (log)
         progress.log(log);
       if (!success) {
+        if (noAutoWaiting)
+          throw new dom.NonRecoverableDOMError("Element(s) not found");
         result.dispose();
         return continuePolling;
       }
@@ -940,6 +950,8 @@ class Frame extends import_instrumentation.SdkObject {
       try {
         const result2 = await action(element);
         if (result2 === "error:notconnected") {
+          if (noAutoWaiting)
+            throw new dom.NonRecoverableDOMError("Element is not attached to the DOM");
           progress.log("element was detached from the DOM, retrying");
           return continuePolling;
         }
@@ -950,19 +962,19 @@ class Frame extends import_instrumentation.SdkObject {
     });
   }
   async rafrafTimeoutScreenshotElementWithProgress(progress, selector, timeout, options) {
-    return await this._retryWithProgressIfNotConnected(progress, selector, true, true, async (handle) => {
+    return await this._retryWithProgressIfNotConnected(progress, selector, { strict: true, performActionPreChecks: true }, async (handle) => {
       await handle._frame.rafrafTimeout(progress, timeout);
       return await this._page.screenshotter.screenshotElement(progress, handle, options);
     });
   }
   async click(progress, selector, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._click(progress, { ...options, waitAfter: !options.noWaitAfter })));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._click(progress, { ...options, waitAfter: !options.noWaitAfter })));
   }
   async dblclick(progress, selector, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._dblclick(progress, options)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._dblclick(progress, options)));
   }
   async dragAndDrop(progress, source, target, options) {
-    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, source, options.strict, !options.force, async (handle) => {
+    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, source, options, async (handle) => {
       return handle._retryPointerAction(progress, "move and down", false, async (point) => {
         await this._page.mouse.move(progress, point.x, point.y);
         await this._page.mouse.down(progress);
@@ -972,7 +984,7 @@ class Frame extends import_instrumentation.SdkObject {
         position: options.sourcePosition
       });
     }));
-    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, options.strict, false, async (handle) => {
+    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, { ...options, performActionPreChecks: false }, async (handle) => {
       return handle._retryPointerAction(progress, "move and up", false, async (point) => {
         await this._page.mouse.move(progress, point.x, point.y, { steps: options.steps });
         await this._page.mouse.up(progress);
@@ -986,16 +998,16 @@ class Frame extends import_instrumentation.SdkObject {
   async tap(progress, selector, options) {
     if (!this._page.browserContext._options.hasTouch)
       throw new Error("The page does not support tap. Use hasTouch context option to enable touch support.");
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._tap(progress, options)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._tap(progress, options)));
   }
   async fill(progress, selector, value, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._fill(progress, value, options)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._fill(progress, value, options)));
   }
   async focus(progress, selector, options) {
-    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._focus(progress)));
+    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._focus(progress)));
   }
   async blur(progress, selector, options) {
-    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._blur(progress)));
+    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._blur(progress)));
   }
   async resolveSelector(progress, selector, options = {}) {
     const element = await progress.race(this.selectors.query(selector, options));
@@ -1109,35 +1121,35 @@ class Frame extends import_instrumentation.SdkObject {
     return this._elementState(progress, selector, "checked", options, scope);
   }
   async hover(progress, selector, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._hover(progress, options)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._hover(progress, options)));
   }
   async selectOption(progress, selector, elements, values, options) {
-    return await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._selectOption(progress, elements, values, options));
+    return await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._selectOption(progress, elements, values, options));
   }
   async setInputFiles(progress, selector, params) {
     const inputFileItems = await (0, import_fileUploadUtils.prepareFilesForUpload)(this, params);
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, params.strict, true, (handle) => handle._setInputFiles(progress, inputFileItems)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, params, (handle) => handle._setInputFiles(progress, inputFileItems)));
   }
   async type(progress, selector, text, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._type(progress, text, options)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._type(progress, text, options)));
   }
   async press(progress, selector, key, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._press(progress, key, options)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._press(progress, key, options)));
   }
   async check(progress, selector, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._setChecked(progress, true, options)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._setChecked(progress, true, options)));
   }
   async uncheck(progress, selector, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._setChecked(progress, false, options)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._setChecked(progress, false, options)));
   }
   async waitForTimeout(progress, timeout) {
     return progress.wait(timeout);
   }
   async ariaSnapshot(progress, selector) {
-    return await this._retryWithProgressIfNotConnected(progress, selector, true, true, (handle) => progress.race(handle.ariaSnapshot()));
+    return await this._retryWithProgressIfNotConnected(progress, selector, { strict: true, performActionPreChecks: true }, (handle) => progress.race(handle.ariaSnapshot()));
   }
-  async expect(progress, selector, options, timeout) {
-    progress.log(`${(0, import_utils.renderTitleForCall)(progress.metadata)}${timeout ? ` with timeout ${timeout}ms` : ""}`);
+  async expect(progress, selector, options) {
+    progress.log(`${(0, import_utils.renderTitleForCall)(progress.metadata)}${options.timeoutForLogs ? ` with timeout ${options.timeoutForLogs}ms` : ""}`);
     const lastIntermediateResult = { isSet: false };
     const fixupMetadataError = (result) => {
       if (result.matches === options.isNot)
@@ -1146,17 +1158,19 @@ class Frame extends import_instrumentation.SdkObject {
     try {
       if (selector)
         progress.log(`waiting for ${this._asLocator(selector)}`);
-      await this._page.performActionPreChecks(progress);
+      if (!options.noAutoWaiting)
+        await this._page.performActionPreChecks(progress);
       try {
         const resultOneShot = await this._expectInternal(progress, selector, options, lastIntermediateResult, true);
-        if (resultOneShot.matches !== options.isNot)
+        if (options.noAutoWaiting || resultOneShot.matches !== options.isNot)
           return resultOneShot;
       } catch (e) {
-        if (this.isNonRetriableError(e))
+        if (options.noAutoWaiting || this.isNonRetriableError(e))
           throw e;
       }
       const result = await this.retryWithProgressAndTimeouts(progress, [100, 250, 500, 1e3], async (continuePolling) => {
-        await this._page.performActionPreChecks(progress);
+        if (!options.noAutoWaiting)
+          await this._page.performActionPreChecks(progress);
         const { matches, received } = await this._expectInternal(progress, selector, options, lastIntermediateResult, false);
         if (matches === options.isNot) {
           return continuePolling;
@@ -1200,6 +1214,8 @@ class Frame extends import_instrumentation.SdkObject {
         throw injected2.strictModeViolationError(info2.parsed, elements);
       else if (elements.length)
         log2 = `  locator resolved to ${injected2.previewNode(elements[0])}`;
+      if (info2)
+        injected2.checkDeprecatedSelectorUsage(info2.parsed, elements);
       return { log: log2, ...await injected2.expect(elements[0], options2, elements) };
     }, { info, options, callId: progress.metadata.id }));
     if (log)

package/lib/server/instrumentation.js

@@ -33,6 +33,9 @@ class SdkObject extends import_events.EventEmitter {
     this.attribution = { ...parent.attribution };
     this.instrumentation = parent.instrumentation;
   }
+  closeReason() {
+    return this.attribution.page?._closeReason || this.attribution.context?._closeReason || this.attribution.browser?._closeReason;
+  }
 }
 function createRootSdkObject() {
   const fakeParent = { attribution: {}, instrumentation: createInstrumentation() };