patchright-core 1.56.1 → 1.58.2

package/lib/server/dispatchers/jsHandleDispatcher.js

@@ -39,11 +39,11 @@ class JSHandleDispatcher extends import_dispatcher.Dispatcher {
     return scope.connection.existingDispatcher(handle) || new JSHandleDispatcher(scope, handle);
   }
   async evaluateExpression(params, progress) {
-    const jsHandle = await progress.race(this._object.evaluateExpression(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg)));
+    const jsHandle = await progress.race(this._object.evaluateExpression(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg), params.isolatedContext));
     return { value: serializeResult(jsHandle) };
   }
   async evaluateExpressionHandle(params, progress) {
-    const jsHandle = await progress.race(this._object.evaluateExpressionHandle(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg)));
+    const jsHandle = await progress.race(this._object.evaluateExpressionHandle(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg), params.isolatedContext));
     return { handle: import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSOrElementHandle(this.parentScope(), jsHandle) };
   }
   async getProperty(params, progress) {

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());
@@ -103,19 +104,6 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
   page() {
     return this._page;
   }
-  serializeConsoleMessage(message) {
-    return {
-      type: message.type(),
-      text: message.text(),
-      args: message.args().map((a) => {
-        const elementHandle = a.asElement();
-        if (elementHandle)
-          return import_elementHandlerDispatcher.ElementHandleDispatcher.from(import_frameDispatcher.FrameDispatcher.from(this.parentScope(), elementHandle._frame), elementHandle);
-        return import_jsHandleDispatcher.JSHandleDispatcher.fromJSHandle(this, a);
-      }),
-      location: message.location()
-    };
-  }
   async exposeBinding(params, progress) {
     const binding = await this._page.exposeBinding(progress, params.name, !!params.needsHandle, (source, ...args) => {
       if (this._disposed)
@@ -237,7 +225,7 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
   }
   async consoleMessages(params, progress) {
     this._subscriptions.add("console");
-    return { messages: this._page.consoleMessages().map((message) => this.serializeConsoleMessage(message)) };
+    return { messages: this._page.consoleMessages().map((message) => this.parentScope().serializeConsoleMessage(message, this)) };
   }
   async pageErrors(params, progress) {
     return { errors: this._page.pageErrors().map((error) => (0, import_errors.serializeError)(error)) };
@@ -265,13 +253,6 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
     progress.metadata.point = { x: params.x, y: params.y };
     await this._page.touchscreen.tap(progress, params.x, params.y);
   }
-  async accessibilitySnapshot(params, progress) {
-    const rootAXNode = await progress.race(this._page.accessibility.snapshot({
-      interestingOnly: params.interestingOnly,
-      root: params.root ? params.root._elementHandle : void 0
-    }));
-    return { rootAXNode: rootAXNode || void 0 };
-  }
   async pdf(params, progress) {
     if (!this._page.pdf)
       throw new Error("PDF generation is only supported for Headless Chromium");
@@ -283,7 +264,7 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
     return { requests: this._page.networkRequests().map((request) => import_networkDispatchers.RequestDispatcher.from(this.parentScope(), request)) };
   }
   async snapshotForAI(params, progress) {
-    return { snapshot: await this._page.snapshotForAI(progress) };
+    return await this._page.snapshotForAI(progress, params);
   }
   async bringToFront(params, progress) {
     await progress.race(this._page.bringToFront());
@@ -308,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) });
   }
@@ -351,6 +335,8 @@ class WorkerDispatcher extends import_dispatcher.Dispatcher {
       url: worker.url
     });
     this._type_Worker = true;
+    this._type_EventTarget = true;
+    this._subscriptions = /* @__PURE__ */ new Set();
     this.addObjectListener(import_page.Worker.Events.Close, () => this._dispatchEvent("close"));
   }
   static fromNullable(scope, worker) {
@@ -365,6 +351,12 @@ class WorkerDispatcher extends import_dispatcher.Dispatcher {
   async evaluateExpressionHandle(params, progress) {
     return { handle: import_jsHandleDispatcher.JSHandleDispatcher.fromJSHandle(this, await progress.race(this._object.evaluateExpressionHandle(params.expression, params.isFunction, (0, import_jsHandleDispatcher.parseArgument)(params.arg)))) };
   }
+  async updateSubscription(params, progress) {
+    if (params.enabled)
+      this._subscriptions.add(params.event);
+    else
+      this._subscriptions.delete(params.event);
+  }
 }
 class BindingCallDispatcher extends import_dispatcher.Dispatcher {
   constructor(scope, name, needsHandle, source, args) {

package/lib/server/dispatchers/playwrightDispatcher.js

@@ -39,15 +39,11 @@ class PlaywrightDispatcher extends import_dispatcher.Dispatcher {
     const chromium = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.chromium, denyLaunch);
     const firefox = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.firefox, denyLaunch);
     const webkit = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.webkit, denyLaunch);
-    const _bidiChromium = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright._bidiChromium, denyLaunch);
-    const _bidiFirefox = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright._bidiFirefox, denyLaunch);
     const android = new import_androidDispatcher.AndroidDispatcher(scope, playwright.android);
     const initializer = {
       chromium,
       firefox,
       webkit,
-      _bidiChromium,
-      _bidiFirefox,
       android,
       electron: new import_electronDispatcher.ElectronDispatcher(scope, playwright.electron, denyLaunch),
       utils: playwright.options.isServer ? void 0 : new import_localUtilsDispatcher.LocalUtilsDispatcher(scope, playwright),

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

@@ -97,7 +97,7 @@ class ElectronApplication extends import_instrumentation.SdkObject {
     if (!this._nodeExecutionContext)
       return;
     const args = event.args.map((arg) => (0, import_crExecutionContext.createHandle)(this._nodeExecutionContext, arg));
-    const message = new import_console.ConsoleMessage(null, event.type, void 0, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event.stackTrace));
+    const message = new import_console.ConsoleMessage(null, null, event.type, void 0, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event.stackTrace));
     this.emit(ElectronApplication.Events.Console, message);
   }
   async initialize() {
@@ -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

@@ -37,14 +37,13 @@ var dialog = __toESM(require("../dialog"));
 var dom = __toESM(require("../dom"));
 var import_page = require("../page");
 var import_page2 = require("../page");
-var import_ffAccessibility = require("./ffAccessibility");
 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) {
@@ -84,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;
@@ -201,7 +203,7 @@ class FFPage {
     const context = this._contextIdToContext.get(executionContextId);
     if (!context)
       return;
-    this._page.addConsoleMessage(type === "warn" ? "warning" : type, args.map((arg) => (0, import_ffExecutionContext.createHandle)(context, arg)), location);
+    this._page.addConsoleMessage(null, type === "warn" ? "warning" : type, args.map((arg) => (0, import_ffExecutionContext.createHandle)(context, arg)), location);
   }
   _onDialogOpened(params) {
     this._page.browserContext.dialogManager.dialogDidOpen(new dialog.Dialog(
@@ -246,11 +248,12 @@ class FFPage {
     this._page.addWorker(workerId, worker);
     workerSession.once("Runtime.executionContextCreated", (event2) => {
       worker.createExecutionContext(new import_ffExecutionContext.FFExecutionContext(workerSession, event2.executionContextId));
+      worker.workerScriptLoaded();
     });
     workerSession.on("Runtime.console", (event2) => {
       const { type, args, location } = event2;
       const context = worker.existingExecutionContext;
-      this._page.addConsoleMessage(type, args.map((arg) => (0, import_ffExecutionContext.createHandle)(context, arg)), location);
+      this._page.addConsoleMessage(worker, type, args.map((arg) => (0, import_ffExecutionContext.createHandle)(context, arg)), location);
     });
   }
   _onWorkerDestroyed(event) {
@@ -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
     });
@@ -468,9 +465,6 @@ class FFPage {
       throw new Error(dom.kUnableToAdoptErrorMessage);
     return (0, import_ffExecutionContext.createHandle)(to, result.remoteObject);
   }
-  async getAccessibilityTree(needle) {
-    return (0, import_ffAccessibility.getAccessibilityTree)(this._session, needle);
-  }
   async inputActionEpilogue() {
   }
   async resetForReuse(progress) {

package/lib/server/firefox/firefox.js

@@ -39,21 +39,30 @@ var import_ascii = require("../utils/ascii");
 var import_browserType = require("../browserType");
 var import_manualPromise = require("../../utils/isomorphic/manualPromise");
 class Firefox extends import_browserType.BrowserType {
-  constructor(parent) {
+  constructor(parent, bidiFirefox) {
     super(parent, "firefox");
+    this._bidiFirefox = bidiFirefox;
+  }
+  launch(progress, options, protocolLogger) {
+    if (options.channel?.startsWith("moz-"))
+      return this._bidiFirefox.launch(progress, options, protocolLogger);
+    return super.launch(progress, options, protocolLogger);
+  }
+  async launchPersistentContext(progress, userDataDir, options) {
+    if (options.channel?.startsWith("moz-"))
+      return this._bidiFirefox.launchPersistentContext(progress, userDataDir, options);
+    return super.launchPersistentContext(progress, userDataDir, options);
   }
   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

@@ -51,7 +51,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) {
@@ -60,7 +62,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) {
@@ -68,7 +72,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();
@@ -90,10 +96,8 @@ class FrameSelectors {
     const match = body.match(/^f(\d+)e\d+$/);
     if (!match)
       return frame;
-    const frameIndex = +match[1];
-    const page = this.frame._page;
-    const frameId = page.lastSnapshotFrameIds[frameIndex - 1];
-    const jumptToFrame = frameId ? page.frameManager.frame(frameId) : null;
+    const frameSeq = +match[1];
+    const jumptToFrame = this.frame._page.frameManager.frames().find((frame2) => frame2.seq === frameSeq);
     if (!jumptToFrame)
       throw new import_selectorParser.InvalidSelectorError(`Invalid frame in aria-ref selector "${selector}"`);
     return jumptToFrame;
@@ -160,6 +164,7 @@ class FrameSelectors {
     if (!resolved)
       return;
     const context = await resolved.frame._context(options?.mainWorld ? "main" : resolved.info.world);
+    if (!context) throw new Error("Frame was detached");
     const injected = await context.injectedScript();
     return { injected, info: resolved.info, frame: resolved.frame, scope: resolved.scope };
   }
@@ -289,7 +294,7 @@ class FrameSelectors {
     }
     for (const child of queryingElement.children || []) {
       const childrenNodeIndex = queryingElement.children.indexOf(child);
-      const childIndex = this._findElementPositionInDomTree(element, child, documentScope, currentIndex + childrenNodeIndex.toString());
+      const childIndex = this._findElementPositionInDomTree(element, child, documentScope, currentIndex + "." + childrenNodeIndex.toString());
       if (childIndex !== null) return childIndex;
     }
     if (queryingElement.shadowRoots && Array.isArray(queryingElement.shadowRoots)) {
@@ -299,6 +304,11 @@ class FrameSelectors {
           const childIndex = this._findElementPositionInDomTree(element, shadowRootHandle, documentScope, currentIndex);
           if (childIndex !== null) return childIndex;
         }
+        for (const shadowChild of shadowRoot.children || []) {
+          const shadowChildIndex = (shadowRoot.children || []).indexOf(shadowChild);
+          const childIndex = this._findElementPositionInDomTree(element, shadowChild, documentScope, currentIndex + "." + shadowChildIndex.toString());
+          if (childIndex !== null) return childIndex;
+        }
       }
     }
     return null;