playwright-core 1.58.0-alpha-2025-12-07 → 1.58.0-alpha-2025-12-09

package/lib/server/agent/tools.js

@@ -0,0 +1,229 @@
+"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 tools_exports = {};
+__export(tools_exports, {
+  default: () => tools_default
+});
+module.exports = __toCommonJS(tools_exports);
+var import_mcpBundle = require("../../mcpBundle");
+function defineTool(tool) {
+  return tool;
+}
+const snapshot = defineTool({
+  schema: {
+    name: "browser_snapshot",
+    title: "Page snapshot",
+    description: "Capture accessibility snapshot of the current page, this is better than screenshot",
+    inputSchema: import_mcpBundle.z.object({})
+  },
+  handle: async (context, params) => {
+    return await context.snapshotResult();
+  }
+});
+const elementSchema = import_mcpBundle.z.object({
+  element: import_mcpBundle.z.string().describe("Human-readable element description used to obtain permission to interact with the element"),
+  ref: import_mcpBundle.z.string().describe("Exact target element reference from the page snapshot")
+});
+const clickSchema = elementSchema.extend({
+  doubleClick: import_mcpBundle.z.boolean().optional().describe("Whether to perform a double click instead of a single click"),
+  button: import_mcpBundle.z.enum(["left", "right", "middle"]).optional().describe("Button to click, defaults to left"),
+  modifiers: import_mcpBundle.z.array(import_mcpBundle.z.enum(["Alt", "Control", "ControlOrMeta", "Meta", "Shift"])).optional().describe("Modifier keys to press")
+});
+const click = defineTool({
+  schema: {
+    name: "browser_click",
+    title: "Click",
+    description: "Perform click on a web page",
+    inputSchema: clickSchema
+  },
+  handle: async (context, params) => {
+    const [selector] = await context.refSelectors([params]);
+    return await context.runActionAndWait({
+      method: "click",
+      selector,
+      options: {
+        button: params.button,
+        modifiers: params.modifiers,
+        clickCount: params.doubleClick ? 2 : void 0
+      }
+    });
+  }
+});
+const drag = defineTool({
+  schema: {
+    name: "browser_drag",
+    title: "Drag mouse",
+    description: "Perform drag and drop between two elements",
+    inputSchema: import_mcpBundle.z.object({
+      startElement: import_mcpBundle.z.string().describe("Human-readable source element description used to obtain the permission to interact with the element"),
+      startRef: import_mcpBundle.z.string().describe("Exact source element reference from the page snapshot"),
+      endElement: import_mcpBundle.z.string().describe("Human-readable target element description used to obtain the permission to interact with the element"),
+      endRef: import_mcpBundle.z.string().describe("Exact target element reference from the page snapshot")
+    })
+  },
+  handle: async (context, params) => {
+    const [sourceSelector, targetSelector] = await context.refSelectors([
+      { ref: params.startRef, element: params.startElement },
+      { ref: params.endRef, element: params.endElement }
+    ]);
+    return await context.runActionAndWait({
+      method: "drag",
+      sourceSelector,
+      targetSelector
+    });
+  }
+});
+const hoverSchema = elementSchema.extend({
+  modifiers: import_mcpBundle.z.array(import_mcpBundle.z.enum(["Alt", "Control", "ControlOrMeta", "Meta", "Shift"])).optional().describe("Modifier keys to press")
+});
+const hover = defineTool({
+  schema: {
+    name: "browser_hover",
+    title: "Hover mouse",
+    description: "Hover over element on page",
+    inputSchema: hoverSchema
+  },
+  handle: async (context, params) => {
+    const [selector] = await context.refSelectors([params]);
+    return await context.runActionAndWait({
+      method: "hover",
+      selector,
+      options: {
+        modifiers: params.modifiers
+      }
+    });
+  }
+});
+const selectOptionSchema = elementSchema.extend({
+  values: import_mcpBundle.z.array(import_mcpBundle.z.string()).describe("Array of values to select in the dropdown. This can be a single value or multiple values.")
+});
+const selectOption = defineTool({
+  schema: {
+    name: "browser_select_option",
+    title: "Select option",
+    description: "Select an option in a dropdown",
+    inputSchema: selectOptionSchema
+  },
+  handle: async (context, params) => {
+    const [selector] = await context.refSelectors([params]);
+    return await context.runActionAndWait({
+      method: "selectOption",
+      selector,
+      labels: params.values
+    });
+  }
+});
+const pressKey = defineTool({
+  schema: {
+    name: "browser_press_key",
+    title: "Press a key",
+    description: "Press a key on the keyboard",
+    inputSchema: import_mcpBundle.z.object({
+      key: import_mcpBundle.z.string().describe("Name of the key to press or a character to generate, such as `ArrowLeft` or `a`")
+    })
+  },
+  handle: async (context, params) => {
+    return await context.runActionAndWait({
+      method: "pressKey",
+      key: params.key
+    });
+  }
+});
+const typeSchema = elementSchema.extend({
+  text: import_mcpBundle.z.string().describe("Text to type into the element"),
+  submit: import_mcpBundle.z.boolean().optional().describe("Whether to submit entered text (press Enter after)"),
+  slowly: import_mcpBundle.z.boolean().optional().describe("Whether to type one character at a time. Useful for triggering key handlers in the page. By default entire text is filled in at once.")
+});
+const type = defineTool({
+  schema: {
+    name: "browser_type",
+    title: "Type text",
+    description: "Type text into editable element",
+    inputSchema: typeSchema
+  },
+  handle: async (context, params) => {
+    const [selector] = await context.refSelectors([params]);
+    if (params.slowly) {
+      return await context.runActionAndWait({
+        method: "pressSequentially",
+        selector,
+        text: params.text,
+        submit: params.submit
+      });
+    } else {
+      return await context.runActionAndWait({
+        method: "fill",
+        selector,
+        text: params.text,
+        submit: params.submit
+      });
+    }
+  }
+});
+const fillForm = defineTool({
+  schema: {
+    name: "browser_fill_form",
+    title: "Fill form",
+    description: "Fill multiple form fields",
+    inputSchema: import_mcpBundle.z.object({
+      fields: import_mcpBundle.z.array(import_mcpBundle.z.object({
+        name: import_mcpBundle.z.string().describe("Human-readable field name"),
+        type: import_mcpBundle.z.enum(["textbox", "checkbox", "radio", "combobox", "slider"]).describe("Type of the field"),
+        ref: import_mcpBundle.z.string().describe("Exact target field reference from the page snapshot"),
+        value: import_mcpBundle.z.string().describe("Value to fill in the field. If the field is a checkbox, the value should be `true` or `false`. If the field is a combobox, the value should be the text of the option.")
+      })).describe("Fields to fill in")
+    })
+  },
+  handle: async (context, params) => {
+    const actions = [];
+    for (const field of params.fields) {
+      const [selector] = await context.refSelectors([{ ref: field.ref, element: field.name }]);
+      if (field.type === "textbox" || field.type === "slider") {
+        actions.push({
+          method: "fill",
+          selector,
+          text: field.value
+        });
+      } else if (field.type === "checkbox" || field.type === "radio") {
+        actions.push({
+          method: "setChecked",
+          selector,
+          checked: field.value === "true"
+        });
+      } else if (field.type === "combobox") {
+        actions.push({
+          method: "selectOption",
+          selector,
+          labels: [field.value]
+        });
+      }
+    }
+    return await context.runActionsAndWait(actions);
+  }
+});
+var tools_default = [
+  snapshot,
+  click,
+  drag,
+  hover,
+  selectOption,
+  pressKey,
+  type,
+  fillForm
+];

package/lib/server/bidi/bidiNetworkManager.js

@@ -342,7 +342,7 @@ function resourceTypeFromBidi(requestDestination, requestInitiatorType, eventIni
     case "image":
       return "image";
     case "object":
-      return "object";
+      return "other";
     case "paintworklet":
       return "script";
     case "script":

package/lib/server/bidi/bidiPage.js

@@ -482,7 +482,9 @@ ${params.stackTrace?.callFrames.map((f) => {
       throw e;
     });
   }
-  async setScreencastOptions(options) {
+  async startScreencast(options) {
+  }
+  async stopScreencast() {
   }
   rafCountForStablePosition() {
     return 1;

package/lib/server/browserContext.js

@@ -145,7 +145,7 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
     return true;
   }
   static reusableContextHash(params) {
-    const paramsCopy = { ...params, agent: void 0 };
+    const paramsCopy = { ...params };
     if (paramsCopy.selectorEngines?.length === 0)
       delete paramsCopy.selectorEngines;
     for (const k of Object.keys(paramsCopy)) {
@@ -322,7 +322,7 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
     const pageOrError = await progress.race(page.waitForInitializedOrError());
     if (pageOrError instanceof Error)
       throw pageOrError;
-    await page.mainFrame()._waitForLoadState(progress, "load");
+    await page.mainFrame().waitForLoadState(progress, "load");
     return page;
   }
   async _loadDefaultContext(progress) {

package/lib/server/chromium/chromium.js

@@ -279,9 +279,7 @@ class Chromium extends import_browserType.BrowserType {
     if (args.find((arg) => !arg.startsWith("-")))
       throw new Error("Arguments can not specify page to be opened");
     const chromeArguments = [...(0, import_chromiumSwitches.chromiumSwitches)(options.assistantMode, options.channel)];
-    if (import_os.default.platform() === "darwin") {
-      chromeArguments.push("--enable-unsafe-swiftshader");
-    }
+    chromeArguments.push("--enable-unsafe-swiftshader");
     if (options.headless) {
       chromeArguments.push("--headless");
       chromeArguments.push(

package/lib/server/chromium/chromiumSwitches.js

@@ -22,8 +22,6 @@ __export(chromiumSwitches_exports, {
 });
 module.exports = __toCommonJS(chromiumSwitches_exports);
 const disabledFeatures = (assistantMode) => [
-  // See https://github.com/microsoft/playwright/pull/10380
-  "AcceptCHFrame",
   // See https://github.com/microsoft/playwright/issues/14047
   "AvoidUnnecessaryBeforeUnloadCheckSync",
   "DestroyProfileOnBrowserClose",

package/lib/server/chromium/crBrowser.js

@@ -470,7 +470,7 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
     }
   }
   async stopVideoRecording() {
-    await Promise.all(this._crPages().map((crPage) => crPage._mainFrameSession._stopVideoRecording()));
+    await Promise.all(this._crPages().map((crPage) => crPage._page.screencast.stopVideoRecording()));
   }
   onClosePersistent() {
   }

package/lib/server/chromium/crNetworkManager.js

@@ -482,12 +482,11 @@ class InterceptableRequest {
       url,
       postDataEntries = null
     } = requestPausedEvent ? requestPausedEvent.request : requestWillBeSentEvent.request;
-    const type = (requestWillBeSentEvent.type || "").toLowerCase();
     let postDataBuffer = null;
     const entries = postDataEntries?.filter((entry) => entry.bytes);
     if (entries && entries.length)
       postDataBuffer = Buffer.concat(entries.map((entry) => Buffer.from(entry.bytes, "base64")));
-    this.request = new network.Request(context, frame, serviceWorker, redirectedFrom?.request || null, documentId, url, type, method, postDataBuffer, headersOverride || (0, import_utils.headersObjectToArray)(headers));
+    this.request = new network.Request(context, frame, serviceWorker, redirectedFrom?.request || null, documentId, url, toResourceType(requestWillBeSentEvent.type || "Other"), method, postDataBuffer, headersOverride || (0, import_utils.headersObjectToArray)(headers));
   }
 }
 class RouteImpl {
@@ -660,6 +659,44 @@ class ResponseExtraInfoTracker {
     this._requests.delete(requestId);
   }
 }
+function toResourceType(type) {
+  switch (type) {
+    case "Document":
+      return "document";
+    case "Stylesheet":
+      return "stylesheet";
+    case "Image":
+      return "image";
+    case "Media":
+      return "media";
+    case "Font":
+      return "font";
+    case "Script":
+      return "script";
+    case "TextTrack":
+      return "texttrack";
+    case "XHR":
+      return "xhr";
+    case "Fetch":
+      return "fetch";
+    case "EventSource":
+      return "eventsource";
+    case "WebSocket":
+      return "websocket";
+    case "Manifest":
+      return "manifest";
+    case "Ping":
+      return "ping";
+    case "CSPViolationReport":
+      return "cspreport";
+    case "Prefetch":
+    case "SignedExchange":
+    case "Preflight":
+    case "FedCM":
+    default:
+      return "other";
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CRNetworkManager

package/lib/server/chromium/crPage.js

@@ -31,9 +31,7 @@ __export(crPage_exports, {
   CRPage: () => CRPage
 });
 module.exports = __toCommonJS(crPage_exports);
-var import_path = __toESM(require("path"));
 var import_assert = require("../../utils/isomorphic/assert");
-var import_crypto = require("../utils/crypto");
 var import_eventsHelper = require("../utils/eventsHelper");
 var import_stackTrace = require("../../utils/isomorphic/stackTrace");
 var dialog = __toESM(require("../dialog"));
@@ -42,7 +40,6 @@ var frames = __toESM(require("../frames"));
 var import_helper = require("../helper");
 var network = __toESM(require("../network"));
 var import_page = require("../page");
-var import_registry = require("../registry");
 var import_crCoverage = require("./crCoverage");
 var import_crDragDrop = require("./crDragDrop");
 var import_crExecutionContext = require("./crExecutionContext");
@@ -51,7 +48,6 @@ var import_crNetworkManager = require("./crNetworkManager");
 var import_crPdf = require("./crPdf");
 var import_crProtocolHelper = require("./crProtocolHelper");
 var import_defaultFontFamilies = require("./defaultFontFamilies");
-var import_videoRecorder = require("./videoRecorder");
 var import_errors = require("../errors");
 var import_protocolError = require("../protocolError");
 class CRPage {
@@ -236,17 +232,16 @@ class CRPage {
   async scrollRectIntoViewIfNeeded(handle, rect) {
     return this._sessionForHandle(handle)._scrollRectIntoViewIfNeeded(handle, rect);
   }
-  async setScreencastOptions(options) {
-    if (options) {
-      await this._mainFrameSession._startScreencast(this, {
-        format: "jpeg",
-        quality: options.quality,
-        maxWidth: options.width,
-        maxHeight: options.height
-      });
-    } else {
-      await this._mainFrameSession._stopScreencast(this);
-    }
+  async startScreencast(options) {
+    await this._mainFrameSession._client.send("Page.startScreencast", {
+      format: "jpeg",
+      quality: options.quality,
+      maxWidth: options.width,
+      maxHeight: options.height
+    });
+  }
+  async stopScreencast() {
+    await this._mainFrameSession._client._sendMayFail("Page.stopScreencast");
   }
   rafCountForStablePosition() {
     return 1;
@@ -311,9 +306,6 @@ class FrameSession {
     // Marks the oopif session that remote -> local transition has happened in the parent.
     // See Target.detachedFromTarget handler for details.
     this._swappedIn = false;
-    this._videoRecorder = null;
-    this._screencastId = null;
-    this._screencastClients = /* @__PURE__ */ new Set();
     this._workerSessions = /* @__PURE__ */ new Map();
     this._initScriptIds = /* @__PURE__ */ new Map();
     this._client = client;
@@ -366,22 +358,8 @@ class FrameSession {
       this._windowId = windowId;
     }
     let screencastOptions;
-    if (!this._page.isStorageStatePage && this._isMainFrame() && this._crPage._browserContext._options.recordVideo && hasUIWindow) {
-      const screencastId = (0, import_crypto.createGuid)();
-      const outputFile = import_path.default.join(this._crPage._browserContext._options.recordVideo.dir, screencastId + ".webm");
-      screencastOptions = {
-        // validateBrowserContextOptions ensures correct video size.
-        ...this._crPage._browserContext._options.recordVideo.size,
-        outputFile
-      };
-      await this._crPage._browserContext._ensureVideosPath();
-      await this._createVideoRecorder(screencastId, screencastOptions);
-      this._crPage._page.waitForInitializedOrError().then((p) => {
-        if (p instanceof Error)
-          this._stopVideoRecording().catch(() => {
-          });
-      });
-    }
+    if (!this._page.isStorageStatePage && this._isMainFrame() && hasUIWindow)
+      screencastOptions = await this._crPage._page.screencast.initializeVideoRecorder();
     let lifecycleEventsEnabled;
     if (!this._isMainFrame())
       this._addRendererListeners();
@@ -462,7 +440,7 @@ class FrameSession {
           /* runImmediately */
         ));
       if (screencastOptions)
-        promises.push(this._startVideoRecording(screencastOptions));
+        promises.push(this._crPage._page.screencast.startVideoRecording(screencastOptions));
     }
     promises.push(this._client.send("Runtime.runIfWaitingForDebugger"));
     promises.push(this._firstNonInitialNavigationCommittedPromise);
@@ -730,7 +708,7 @@ class FrameSession {
     }
   }
   _onScreencastFrame(payload) {
-    this._page.throttleScreencastFrameAck(() => {
+    this._page.screencast.throttleFrameAck(() => {
       this._client.send("Page.screencastFrameAck", { sessionId: payload.sessionId }).catch(() => {
       });
     });
@@ -742,51 +720,6 @@ class FrameSession {
       height: payload.metadata.deviceHeight
     });
   }
-  async _createVideoRecorder(screencastId, options) {
-    (0, import_assert.assert)(!this._screencastId);
-    const ffmpegPath = import_registry.registry.findExecutable("ffmpeg").executablePathOrDie(this._page.browserContext._browser.sdkLanguage());
-    this._videoRecorder = await import_videoRecorder.VideoRecorder.launch(this._crPage._page, ffmpegPath, options);
-    this._screencastId = screencastId;
-  }
-  async _startVideoRecording(options) {
-    const screencastId = this._screencastId;
-    (0, import_assert.assert)(screencastId);
-    this._page.once(import_page.Page.Events.Close, () => this._stopVideoRecording().catch(() => {
-    }));
-    const gotFirstFrame = new Promise((f) => this._client.once("Page.screencastFrame", f));
-    await this._startScreencast(this._videoRecorder, {
-      format: "jpeg",
-      quality: 90,
-      maxWidth: options.width,
-      maxHeight: options.height
-    });
-    gotFirstFrame.then(() => {
-      this._crPage._browserContext._browser._videoStarted(this._crPage._browserContext, screencastId, options.outputFile, this._crPage._page.waitForInitializedOrError());
-    });
-  }
-  async _stopVideoRecording() {
-    if (!this._screencastId)
-      return;
-    const screencastId = this._screencastId;
-    this._screencastId = null;
-    const recorder = this._videoRecorder;
-    this._videoRecorder = null;
-    await this._stopScreencast(recorder);
-    await recorder.stop().catch(() => {
-    });
-    const video = this._crPage._browserContext._browser._takeVideo(screencastId);
-    video?.reportFinished();
-  }
-  async _startScreencast(client, options = {}) {
-    this._screencastClients.add(client);
-    if (this._screencastClients.size === 1)
-      await this._client.send("Page.startScreencast", options);
-  }
-  async _stopScreencast(client) {
-    this._screencastClients.delete(client);
-    if (!this._screencastClients.size)
-      await this._client._sendMayFail("Page.stopScreencast");
-  }
   async _updateGeolocation(initial) {
     const geolocation = this._crPage._browserContext._options.geolocation;
     if (!initial || geolocation)

package/lib/server/deviceDescriptorsSource.json

@@ -1702,7 +1702,7 @@
     "defaultBrowserType": "chromium"
   },
   "Desktop Firefox HiDPI": {
-    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:145.0.1) Gecko/20100101 Firefox/145.0.1",
+    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:145.0.2) Gecko/20100101 Firefox/145.0.2",
     "screen": {
       "width": 1792,
       "height": 1120
@@ -1762,7 +1762,7 @@
     "defaultBrowserType": "chromium"
   },
   "Desktop Firefox": {
-    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:145.0.1) Gecko/20100101 Firefox/145.0.1",
+    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:145.0.2) Gecko/20100101 Firefox/145.0.2",
     "screen": {
       "width": 1920,
       "height": 1080

package/lib/server/dispatchers/browserDispatcher.js

@@ -62,6 +62,7 @@ class BrowserDispatcher extends import_dispatcher.Dispatcher {
     return { context: contextDispatcher };
   }
   async newContextForReuse(params, progress) {
+    delete params.agent;
     const context = await this._object.newContextForReuse(progress, params);
     const contextDispatcher = import_browserContextDispatcher.BrowserContextDispatcher.from(this, context);
     this._dispatchEvent("context", { context: contextDispatcher });

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_agent = require("../agent/agent");
 class PageDispatcher extends import_dispatcher.Dispatcher {
   constructor(parentScope, page) {
     const mainFrame = import_frameDispatcher.FrameDispatcher.from(parentScope, page.mainFrame());
@@ -258,6 +259,12 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
     const buffer = await progress.race(this._page.pdf(params));
     return { pdf: buffer };
   }
+  async perform(params, progress) {
+    await (0, import_agent.pagePerform)(progress, this._page, params);
+  }
+  async extract(params, progress) {
+    return { result: await (0, import_agent.pageExtract)(progress, this._page, params) };
+  }
   async requests(params, progress) {
     this._subscriptions.add("request");
     return { requests: this._page.networkRequests().map((request) => import_networkDispatchers.RequestDispatcher.from(this.parentScope(), request)) };

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

@@ -417,24 +417,25 @@ 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) {
+    const { screencastId } = await this._session.send("Page.startScreencast", options);
+    this._screencastId = screencastId;
+  }
+  async stopScreencast() {
+    await this._session.send("Page.stopScreencast");
   }
   _onScreencastFrame(event) {
     if (!this._screencastId)
       return;
     const screencastId = this._screencastId;
-    this._page.throttleScreencastFrameAck(() => {
+    this._page.screencast.throttleFrameAck(() => {
       this._session.send("Page.screencastFrameAck", { screencastId }).catch((e) => import_debugLogger.debugLogger.log("error", e));
     });
     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/frames.js

@@ -569,7 +569,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;
@@ -736,7 +736,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);

package/lib/server/network.js

@@ -436,6 +436,9 @@ class Response extends import_instrumentation.SdkObject {
   request() {
     return this._request;
   }
+  finished() {
+    return this._finishedPromise;
+  }
   frame() {
     return this._request.frame();
   }