playwright-core 1.58.0-alpha-2025-12-08 → 1.58.0-alpha-2025-12-10

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/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();
   }

package/lib/server/page.js

@@ -53,6 +53,7 @@ var import_manualPromise = require("../utils/isomorphic/manualPromise");
 var import_utilityScriptSerializers = require("../utils/isomorphic/utilityScriptSerializers");
 var import_callLog = require("./callLog");
 var rawBindingsControllerSource = __toESM(require("../generated/bindingsControllerSource"));
+var import_screencast = require("./screencast");
 class Page extends import_instrumentation.SdkObject {
   constructor(delegate, browserContext) {
     super(browserContext, "page");
@@ -74,9 +75,6 @@ class Page extends import_instrumentation.SdkObject {
     this._lastLocatorHandlerUid = 0;
     this._locatorHandlerRunningCounter = 0;
     this._networkRequests = [];
-    // Aiming at 25 fps by default - each frame is 40ms, but we give some slack with 35ms.
-    // When throttling for tracing, 200ms between frames, except for 10 frames around the action.
-    this._frameThrottler = new FrameThrottler(10, 35, 200);
     this.attribution.page = this;
     this.delegate = delegate;
     this.browserContext = browserContext;
@@ -85,6 +83,7 @@ class Page extends import_instrumentation.SdkObject {
     this.touchscreen = new input.Touchscreen(delegate.rawTouchscreen, this);
     this.screenshotter = new import_screenshotter.Screenshotter(this);
     this.frameManager = new frames.FrameManager(this);
+    this.screencast = new import_screencast.Screencast(this);
     if (delegate.pdf)
       this.pdf = delegate.pdf.bind(delegate);
     this.coverage = delegate.coverage ? delegate.coverage() : null;
@@ -158,7 +157,7 @@ class Page extends import_instrumentation.SdkObject {
   }
   _didClose() {
     this.frameManager.dispose();
-    this._frameThrottler.dispose();
+    this.screencast.stopFrameThrottler();
     (0, import_utils.assert)(this._closedState !== "closed", "Page closed twice");
     this._closedState = "closed";
     this.emit(Page.Events.Close);
@@ -168,7 +167,7 @@ class Page extends import_instrumentation.SdkObject {
   }
   _didCrash() {
     this.frameManager.dispose();
-    this._frameThrottler.dispose();
+    this.screencast.stopFrameThrottler();
     this.emit(Page.Events.Crash);
     this._crashed = true;
     this.instrumentation.onPageClose(this);
@@ -641,16 +640,6 @@ class Page extends import_instrumentation.SdkObject {
   getBinding(name) {
     return this._pageBindings.get(name) || this.browserContext._pageBindings.get(name);
   }
-  setScreencastOptions(options) {
-    this.delegate.setScreencastOptions(options).catch((e) => import_debugLogger.debugLogger.log("error", e));
-    this._frameThrottler.setThrottlingEnabled(!!options);
-  }
-  throttleScreencastFrameAck(ack) {
-    this._frameThrottler.ack(ack);
-  }
-  temporarilyDisableTracingScreencastThrottling() {
-    this._frameThrottler.recharge();
-  }
   async safeNonStallingEvaluateInAllFrames(expression, world, options = {}) {
     await Promise.all(this.frames().map(async (frame) => {
       try {
@@ -763,55 +752,6 @@ class InitScript {
     })();`;
   }
 }
-class FrameThrottler {
-  constructor(nonThrottledFrames, defaultInterval, throttlingInterval) {
-    this._acks = [];
-    this._throttlingEnabled = false;
-    this._nonThrottledFrames = nonThrottledFrames;
-    this._budget = nonThrottledFrames;
-    this._defaultInterval = defaultInterval;
-    this._throttlingInterval = throttlingInterval;
-    this._tick();
-  }
-  dispose() {
-    if (this._timeoutId) {
-      clearTimeout(this._timeoutId);
-      this._timeoutId = void 0;
-    }
-  }
-  setThrottlingEnabled(enabled) {
-    this._throttlingEnabled = enabled;
-  }
-  recharge() {
-    for (const ack of this._acks)
-      ack();
-    this._acks = [];
-    this._budget = this._nonThrottledFrames;
-    if (this._timeoutId) {
-      clearTimeout(this._timeoutId);
-      this._tick();
-    }
-  }
-  ack(ack) {
-    if (!this._timeoutId) {
-      ack();
-      return;
-    }
-    this._acks.push(ack);
-  }
-  _tick() {
-    const ack = this._acks.shift();
-    if (ack) {
-      --this._budget;
-      ack();
-    }
-    if (this._throttlingEnabled && this._budget <= 0) {
-      this._timeoutId = setTimeout(() => this._tick(), this._throttlingInterval);
-    } else {
-      this._timeoutId = setTimeout(() => this._tick(), this._defaultInterval);
-    }
-  }
-}
 async function snapshotFrameForAI(progress, frame, options) {
   const snapshot = await frame.retryWithProgressAndTimeouts(progress, [1e3, 2e3, 4e3, 8e3], async (continuePolling) => {
     try {

package/lib/server/progress.js

@@ -53,9 +53,10 @@ class ProgressController {
         this._onCallLog?.(message);
       },
       metadata: this.metadata,
-      race: (promise) => {
+      race: (promise, options) => {
         const promises = Array.isArray(promise) ? promise : [promise];
-        return Promise.race([...promises, this._forceAbortPromise]);
+        const timerPromise = options?.timeout ? new Promise((f) => setTimeout(f, options.timeout)) : null;
+        return Promise.race([...promises, ...timerPromise ? [timerPromise] : [], this._forceAbortPromise]);
       },
       wait: async (timeout2) => {
         let timer2;

package/lib/server/registry/index.js

@@ -1296,7 +1296,7 @@ ${e.stack}`);
         faultyArguments.push(arg);
       else
         executables.push(executable);
-      if (executable?.browserName === "chromium")
+      if (executable?.browserName)
         executables.push(this.findExecutable("ffmpeg"));
     };
     for (const alias of aliases) {

package/lib/server/screencast.js

@@ -0,0 +1,191 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var screencast_exports = {};
+__export(screencast_exports, {
+  Screencast: () => Screencast
+});
+module.exports = __toCommonJS(screencast_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("../utils");
+var import_utils2 = require("../utils");
+var import_videoRecorder = require("./videoRecorder");
+var import_page = require("./page");
+var import_registry = require("./registry");
+class Screencast {
+  constructor(page) {
+    this._videoRecorder = null;
+    this._screencastId = null;
+    this._screencastClients = /* @__PURE__ */ new Set();
+    // Aiming at 25 fps by default - each frame is 40ms, but we give some slack with 35ms.
+    // When throttling for tracing, 200ms between frames, except for 10 frames around the action.
+    this._frameThrottler = new FrameThrottler(10, 35, 200);
+    this._page = page;
+  }
+  stopFrameThrottler() {
+    this._frameThrottler.dispose();
+  }
+  setOptions(options) {
+    this._setOptions(options).catch((e) => import_utils2.debugLogger.log("error", e));
+    this._frameThrottler.setThrottlingEnabled(!!options);
+  }
+  throttleFrameAck(ack) {
+    this._frameThrottler.ack(ack);
+  }
+  temporarilyDisableThrottling() {
+    this._frameThrottler.recharge();
+  }
+  async initializeVideoRecorder() {
+    const recordVideo = this._page.browserContext._options.recordVideo;
+    if (!recordVideo)
+      return void 0;
+    const screencastId = (0, import_utils.createGuid)();
+    const outputFile = import_path.default.join(recordVideo.dir, screencastId + ".webm");
+    const screencastOptions = {
+      // validateBrowserContextOptions ensures correct video size.
+      ...recordVideo.size,
+      outputFile
+    };
+    await (0, import_utils.mkdirIfNeeded)(import_path.default.join(recordVideo.dir, "dummy"));
+    await this._createVideoRecorder(screencastId, screencastOptions);
+    this._page.waitForInitializedOrError().then((p) => {
+      if (p instanceof Error)
+        this.stopVideoRecording().catch(() => {
+        });
+    });
+    return screencastOptions;
+  }
+  async startVideoRecording(options) {
+    const screencastId = this._screencastId;
+    (0, import_utils.assert)(screencastId);
+    this._page.once(import_page.Page.Events.Close, () => this.stopVideoRecording().catch(() => {
+    }));
+    const gotFirstFrame = new Promise((f) => this._page.once(import_page.Page.Events.ScreencastFrame, f));
+    await this._startScreencast(this._videoRecorder, {
+      quality: 90,
+      width: options.width,
+      height: options.height
+    });
+    gotFirstFrame.then(() => {
+      this._page.browserContext._browser._videoStarted(this._page.browserContext, screencastId, options.outputFile, this._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._page.browserContext._browser._takeVideo(screencastId);
+    video?.reportFinished();
+  }
+  async _setOptions(options) {
+    if (options)
+      await this._startScreencast(this, options);
+    else
+      await this._stopScreencast(this);
+  }
+  async _startScreencast(client, options) {
+    this._screencastClients.add(client);
+    if (this._screencastClients.size === 1) {
+      await this._page.delegate.startScreencast({
+        width: options.width,
+        height: options.height,
+        quality: options.quality
+      });
+    }
+  }
+  async _stopScreencast(client) {
+    this._screencastClients.delete(client);
+    if (!this._screencastClients.size)
+      await this._page.delegate.stopScreencast();
+  }
+  async _createVideoRecorder(screencastId, options) {
+    (0, import_utils.assert)(!this._screencastId);
+    const ffmpegPath = import_registry.registry.findExecutable("ffmpeg").executablePathOrDie(this._page.browserContext._browser.sdkLanguage());
+    this._videoRecorder = await import_videoRecorder.VideoRecorder.launch(this._page, ffmpegPath, options);
+    this._screencastId = screencastId;
+  }
+}
+class FrameThrottler {
+  constructor(nonThrottledFrames, defaultInterval, throttlingInterval) {
+    this._acks = [];
+    this._throttlingEnabled = false;
+    this._nonThrottledFrames = nonThrottledFrames;
+    this._budget = nonThrottledFrames;
+    this._defaultInterval = defaultInterval;
+    this._throttlingInterval = throttlingInterval;
+    this._tick();
+  }
+  dispose() {
+    if (this._timeoutId) {
+      clearTimeout(this._timeoutId);
+      this._timeoutId = void 0;
+    }
+  }
+  setThrottlingEnabled(enabled) {
+    this._throttlingEnabled = enabled;
+  }
+  recharge() {
+    for (const ack of this._acks)
+      ack();
+    this._acks = [];
+    this._budget = this._nonThrottledFrames;
+    if (this._timeoutId) {
+      clearTimeout(this._timeoutId);
+      this._tick();
+    }
+  }
+  ack(ack) {
+    if (!this._timeoutId) {
+      ack();
+      return;
+    }
+    this._acks.push(ack);
+  }
+  _tick() {
+    const ack = this._acks.shift();
+    if (ack) {
+      --this._budget;
+      ack();
+    }
+    if (this._throttlingEnabled && this._budget <= 0) {
+      this._timeoutId = setTimeout(() => this._tick(), this._throttlingInterval);
+    } else {
+      this._timeoutId = setTimeout(() => this._tick(), this._defaultInterval);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Screencast
+});

package/lib/server/trace/recorder/tracing.js

@@ -222,7 +222,7 @@ class Tracing extends import_instrumentation.SdkObject {
     if (!(this._context instanceof import_browserContext.BrowserContext))
       return;
     for (const page of this._context.pages())
-      page.setScreencastOptions(null);
+      page.screencast.setOptions(null);
   }
   _allocateNewTraceFile(state) {
     const suffix = state.chunkOrdinal ? `-chunk${state.chunkOrdinal}` : ``;
@@ -341,7 +341,7 @@ class Tracing extends import_instrumentation.SdkObject {
     const event = createBeforeActionTraceEvent(metadata, this._currentGroupId());
     if (!event)
       return Promise.resolve();
-    sdkObject.attribution.page?.temporarilyDisableTracingScreencastThrottling();
+    sdkObject.attribution.page?.screencast.temporarilyDisableThrottling();
     event.beforeSnapshot = `before@${metadata.id}`;
     this._state?.callIds.add(metadata.id);
     this._appendTraceEvent(event);
@@ -353,7 +353,7 @@ class Tracing extends import_instrumentation.SdkObject {
     const event = createInputActionTraceEvent(metadata);
     if (!event)
       return Promise.resolve();
-    sdkObject.attribution.page?.temporarilyDisableTracingScreencastThrottling();
+    sdkObject.attribution.page?.screencast.temporarilyDisableThrottling();
     event.inputSnapshot = `input@${metadata.id}`;
     this._appendTraceEvent(event);
     return this._captureSnapshot(event.inputSnapshot, sdkObject, metadata);
@@ -376,7 +376,7 @@ class Tracing extends import_instrumentation.SdkObject {
     const event = createAfterActionTraceEvent(metadata);
     if (!event)
       return;
-    sdkObject.attribution.page?.temporarilyDisableTracingScreencastThrottling();
+    sdkObject.attribution.page?.screencast.temporarilyDisableThrottling();
     event.afterSnapshot = `after@${metadata.id}`;
     this._appendTraceEvent(event);
     return this._captureSnapshot(event.afterSnapshot, sdkObject, metadata);
@@ -484,7 +484,7 @@ class Tracing extends import_instrumentation.SdkObject {
     this._appendTraceEvent(event);
   }
   _startScreencastInPage(page) {
-    page.setScreencastOptions(kScreencastOptions);
+    page.screencast.setOptions(kScreencastOptions);
     const prefix = page.guid;
     this._screencastListeners.push(
       import_eventsHelper.eventsHelper.addEventListener(page, import_page.Page.Events.ScreencastFrame, (params) => {