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

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) => {

package/lib/server/{chromium/videoRecorder.js → videoRecorder.js}

@@ -21,9 +21,9 @@ __export(videoRecorder_exports, {
   VideoRecorder: () => VideoRecorder
 });
 module.exports = __toCommonJS(videoRecorder_exports);
-var import_utils = require("../../utils");
-var import_page = require("../page");
-var import_processLauncher = require("../utils/processLauncher");
+var import_utils = require("../utils");
+var import_page = require("./page");
+var import_processLauncher = require("./utils/processLauncher");
 const fps = 25;
 class VideoRecorder {
   constructor(page, ffmpegPath) {

package/lib/server/webkit/wkBrowser.js

@@ -315,7 +315,7 @@ class WKBrowserContext extends import_browserContext.BrowserContext {
   }
   async doClose(reason) {
     if (!this._browserContextId) {
-      await Promise.all(this._wkPages().map((wkPage) => wkPage._stopVideo()));
+      await Promise.all(this._wkPages().map((wkPage) => wkPage._page.screencast.stopVideoRecording()));
       await this._browser.close({ reason });
     } else {
       await this._browser._browserSession.send("Playwright.deleteContext", { browserContextId: this._browserContextId });

package/lib/server/webkit/wkInterceptableRequest.js

@@ -54,7 +54,7 @@ class WKInterceptableRequest {
   constructor(session, frame, event, redirectedFrom, documentId) {
     this._session = session;
     this._requestId = event.requestId;
-    const resourceType = event.type ? event.type.toLowerCase() : redirectedFrom ? redirectedFrom.request.resourceType() : "other";
+    const resourceType = event.type ? toResourceType(event.type) : redirectedFrom ? redirectedFrom.request.resourceType() : "other";
     let postDataBuffer = null;
     this._timestamp = event.timestamp;
     this._wallTime = event.walltime * 1e3;
@@ -162,6 +162,34 @@ function wkMillisToRoundishMillis(value) {
   }
   return (value * 1e3 | 0) / 1e3;
 }
+function toResourceType(type) {
+  switch (type) {
+    case "Document":
+      return "document";
+    case "StyleSheet":
+      return "stylesheet";
+    case "Image":
+      return "image";
+    case "Font":
+      return "font";
+    case "Script":
+      return "script";
+    case "XHR":
+      return "xhr";
+    case "Fetch":
+      return "fetch";
+    case "Ping":
+      return "ping";
+    case "Beacon":
+      return "beacon";
+    case "WebSocket":
+      return "websocket";
+    case "EventSource":
+      return "eventsource";
+    default:
+      return "other";
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   WKInterceptableRequest,

package/lib/server/webkit/wkPage.js

@@ -31,10 +31,8 @@ __export(wkPage_exports, {
   WKPage: () => WKPage
 });
 module.exports = __toCommonJS(wkPage_exports);
-var import_path = __toESM(require("path"));
 var import_utils = require("../../utils");
 var import_headers = require("../../utils/isomorphic/headers");
-var import_crypto = require("../utils/crypto");
 var import_eventsHelper = require("../utils/eventsHelper");
 var import_hostPlatform = require("../utils/hostPlatform");
 var import_stackTrace = require("../../utils/isomorphic/stackTrace");
@@ -66,7 +64,6 @@ class WKPage {
     };
     this._lastConsoleMessage = null;
     this._requestIdToResponseReceivedPayloadEvent = /* @__PURE__ */ new Map();
-    this._recordingVideoFile = null;
     this._screencastGeneration = 0;
     this._pageProxySession = pageProxySession;
     this._opener = opener;
@@ -116,16 +113,7 @@ class WKPage {
       for (const [key, value] of this._browserContext._permissions)
         promises.push(this._grantPermissions(key, value));
     }
-    if (this._browserContext._options.recordVideo) {
-      const outputFile = import_path.default.join(this._browserContext._options.recordVideo.dir, (0, import_crypto.createGuid)() + ".webm");
-      promises.push(this._browserContext._ensureVideosPath().then(() => {
-        return this._startVideo({
-          // validateBrowserContextOptions ensures correct video size.
-          ...this._browserContext._options.recordVideo.size,
-          outputFile
-        });
-      }));
-    }
+    promises.push(this._initializeVideoRecording());
     await Promise.all(promises);
   }
   _setSession(session) {
@@ -748,7 +736,6 @@ class WKPage {
     await this._updateState("Page.setBootstrapScript", { source: this._calculateBootstrapScript() });
   }
   async closePage(runBeforeUnload) {
-    await this._stopVideo();
     await this._pageProxySession.sendMayFail("Target.close", {
       targetId: this._session.sessionId,
       runBeforeUnload
@@ -762,22 +749,10 @@ class WKPage {
       return import_hostPlatform.hostPlatform === "mac10.15" ? 55 : 59;
     return 0;
   }
-  async _startVideo(options) {
-    (0, import_utils.assert)(!this._recordingVideoFile);
-    const { screencastId } = await this._pageProxySession.send("Screencast.startVideo", {
-      file: this._browserContext._browser.options.channel === "webkit-wsl" ? await (0, import_webkit.translatePathToWSL)(options.outputFile) : options.outputFile,
-      width: options.width,
-      height: options.height,
-      toolbarHeight: this._toolbarHeight()
-    });
-    this._recordingVideoFile = options.outputFile;
-    this._browserContext._browser._videoStarted(this._browserContext, screencastId, options.outputFile, this._page.waitForInitializedOrError());
-  }
-  async _stopVideo() {
-    if (!this._recordingVideoFile)
-      return;
-    await this._pageProxySession.sendMayFail("Screencast.stopVideo");
-    this._recordingVideoFile = null;
+  async _initializeVideoRecording() {
+    const screencastOptions = await this._page.screencast.initializeVideoRecorder();
+    if (screencastOptions)
+      await this._page.screencast.startVideoRecording(screencastOptions);
   }
   validateScreenshotDimension(side, omitDeviceScaleFactor) {
     if (process.platform === "darwin")
@@ -845,23 +820,28 @@ class WKPage {
       throw e;
     });
   }
-  async setScreencastOptions(options) {
-    if (options) {
-      const so = { ...options, toolbarHeight: this._toolbarHeight() };
-      const { generation } = await this._pageProxySession.send("Screencast.startScreencast", so);
-      this._screencastGeneration = generation;
-    } else {
-      await this._pageProxySession.send("Screencast.stopScreencast");
-    }
+  async startScreencast(options) {
+    const { generation } = await this._pageProxySession.send("Screencast.startScreencast", {
+      quality: options.quality,
+      width: options.width,
+      height: options.height,
+      toolbarHeight: this._toolbarHeight()
+    });
+    this._screencastGeneration = generation;
+  }
+  async stopScreencast() {
+    await this._pageProxySession.sendMayFail("Screencast.stopScreencast");
   }
   _onScreencastFrame(event) {
     const generation = this._screencastGeneration;
-    this._page.throttleScreencastFrameAck(() => {
+    this._page.screencast.throttleFrameAck(() => {
       this._pageProxySession.send("Screencast.screencastFrameAck", { generation }).catch((e) => import_debugLogger.debugLogger.log("error", e));
     });
     const buffer = Buffer.from(event.data, "base64");
     this._page.emit(import_page.Page.Events.ScreencastFrame, {
       buffer,
+      frameSwapWallTime: event.timestamp * 1e3,
+      // timestamp is in seconds, we need to convert to milliseconds.
       width: event.deviceWidth,
       height: event.deviceHeight
     });
@@ -886,7 +866,7 @@ class WKPage {
     const pageProxyId = this._pageProxySession.sessionId;
     const objectId = handle._objectId;
     if (this._browserContext._browser?.options.channel === "webkit-wsl")
-      paths = await Promise.all(paths.map((path2) => (0, import_webkit.translatePathToWSL)(path2)));
+      paths = await Promise.all(paths.map((path) => (0, import_webkit.translatePathToWSL)(path)));
     await Promise.all([
       this._pageProxySession.connection.browserSession.send("Playwright.grantFileReadAccess", { pageProxyId, paths }),
       this._session.send("DOM.setInputFiles", { objectId, paths })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playwright-core",
-  "version": "1.58.0-alpha-2025-12-08",
+  "version": "1.58.0-alpha-2025-12-09",
   "description": "A high-level API to automate web browsers",
   "repository": {
     "type": "git",