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

package/lib/server/codegen/javascript.js

@@ -90,7 +90,7 @@ class JavaScriptLanguageGenerator {
       case "fill":
         return `await ${subject}.${this._asLocator(action.selector)}.fill(${quote(action.text)});`;
       case "setInputFiles":
-        return `await ${subject}.${this._asLocator(action.selector)}.setInputFiles(${formatObject(action.files.length === 1 ? action.files[0] : action.files)});`;
+        return `await ${subject}.${this._asLocator(action.selector)}.setInputFiles(${(0, import_utils.formatObject)(action.files.length === 1 ? action.files[0] : action.files)});`;
       case "press": {
         const modifiers = (0, import_language.toKeyboardModifiers)(action.modifiers);
         const shortcut = [...modifiers, action.key].join("+");
@@ -99,7 +99,7 @@ class JavaScriptLanguageGenerator {
       case "navigate":
         return `await ${subject}.goto(${quote(action.url)});`;
       case "select":
-        return `await ${subject}.${this._asLocator(action.selector)}.selectOption(${formatObject(action.options.length === 1 ? action.options[0] : action.options)});`;
+        return `await ${subject}.${this._asLocator(action.selector)}.selectOption(${(0, import_utils.formatObject)(action.options.length === 1 ? action.options[0] : action.options)});`;
       case "assertText":
         return `${this._isTest ? "" : "// "}await expect(${subject}.${this._asLocator(action.selector)}).${action.substring ? "toContainText" : "toHaveText"}(${quote(action.text)});`;
       case "assertChecked":
@@ -151,7 +151,7 @@ ${useText ? "\ntest.use(" + useText + ");\n" : ""}
       const { ${options.browserName}${options.deviceName ? ", devices" : ""} } = require('playwright');
 
       (async () => {
-        const browser = await ${options.browserName}.launch(${formatObjectOrVoid(options.launchOptions)});
+        const browser = await ${options.browserName}.launch(${(0, import_utils.formatObjectOrVoid)(options.launchOptions)});
         const context = await browser.newContext(${formatContextOptions(options.contextOptions, options.deviceName, false)});`);
     if (options.contextOptions.recordHar)
       formatter.add(`        await context.routeFromHAR(${quote(options.contextOptions.recordHar.path)});`);
@@ -171,37 +171,14 @@ function formatOptions(value, hasArguments) {
   const keys = Object.keys(value).filter((key) => value[key] !== void 0);
   if (!keys.length)
     return "";
-  return (hasArguments ? ", " : "") + formatObject(value);
-}
-function formatObject(value, indent = "  ") {
-  if (typeof value === "string")
-    return quote(value);
-  if (Array.isArray(value))
-    return `[${value.map((o) => formatObject(o)).join(", ")}]`;
-  if (typeof value === "object") {
-    const keys = Object.keys(value).filter((key) => value[key] !== void 0).sort();
-    if (!keys.length)
-      return "{}";
-    const tokens = [];
-    for (const key of keys)
-      tokens.push(`${key}: ${formatObject(value[key])}`);
-    return `{
-${indent}${tokens.join(`,
-${indent}`)}
-}`;
-  }
-  return String(value);
-}
-function formatObjectOrVoid(value, indent = "  ") {
-  const result = formatObject(value, indent);
-  return result === "{}" ? "" : result;
+  return (hasArguments ? ", " : "") + (0, import_utils.formatObject)(value);
 }
 function formatContextOptions(options, deviceName, isTest) {
   const device = deviceName && import_deviceDescriptors.deviceDescriptors[deviceName];
   options = { ...options, recordHar: void 0 };
   if (!device)
-    return formatObjectOrVoid(options);
-  let serializedObject = formatObjectOrVoid((0, import_language.sanitizeDeviceOptions)(device, options));
+    return (0, import_utils.formatObjectOrVoid)(options);
+  let serializedObject = (0, import_utils.formatObjectOrVoid)((0, import_language.sanitizeDeviceOptions)(device, options));
   if (!serializedObject)
     serializedObject = "{\n}";
   const lines = serializedObject.split("\n");

package/lib/server/dispatchers/dispatcher.js

@@ -106,7 +106,7 @@ class Dispatcher extends import_events.EventEmitter {
     this.connection.sendEvent(this, method, params);
   }
   _dispose(reason) {
-    this._disposeRecursively(new import_errors.TargetClosedError());
+    this._disposeRecursively(new import_errors.TargetClosedError(this._object.closeReason()));
     this.connection.sendDispose(this, reason);
   }
   _onDispose() {
@@ -257,7 +257,7 @@ class DispatcherConnection {
     const { id, guid, method, params, metadata } = message;
     const dispatcher = this._dispatcherByGuid.get(guid);
     if (!dispatcher) {
-      this.onmessage({ id, error: (0, import_errors.serializeError)(new import_errors.TargetClosedError()) });
+      this.onmessage({ id, error: (0, import_errors.serializeError)(new import_errors.TargetClosedError(void 0)) });
       return;
     }
     let validParams;
@@ -325,19 +325,19 @@ class DispatcherConnection {
     const response = { id };
     try {
       if (this._dispatcherByGuid.get(guid) !== dispatcher)
-        throw new import_errors.TargetClosedError(closeReason(sdkObject));
+        throw new import_errors.TargetClosedError(sdkObject.closeReason());
       const result = await dispatcher._runCommand(callMetadata, method, validParams);
       const validator = (0, import_validator.findValidator)(dispatcher._type, method, "Result");
       response.result = validator(result, "", this._validatorToWireContext());
       callMetadata.result = result;
     } catch (e) {
       if ((0, import_errors.isTargetClosedError)(e)) {
-        const reason = closeReason(sdkObject);
+        const reason = sdkObject.closeReason();
         if (reason)
           (0, import_utils.rewriteErrorMessage)(e, reason);
       } else if ((0, import_protocolError.isProtocolError)(e)) {
         if (e.type === "closed")
-          e = new import_errors.TargetClosedError(closeReason(sdkObject), e.browserLogMessage());
+          e = new import_errors.TargetClosedError(sdkObject.closeReason(), e.browserLogMessage());
         else if (e.type === "crashed")
           (0, import_utils.rewriteErrorMessage)(e, "Target crashed " + e.browserLogMessage());
       }
@@ -359,9 +359,6 @@ class DispatcherConnection {
       await new Promise((f) => setTimeout(f, slowMo));
   }
 }
-function closeReason(sdkObject) {
-  return sdkObject.attribution.page?.closeReason || sdkObject.attribution.context?._closeReason || sdkObject.attribution.browser?._closeReason;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Dispatcher,

package/lib/server/dispatchers/pageDispatcher.js

@@ -260,10 +260,11 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
     return { pdf: buffer };
   }
   async perform(params, progress) {
-    await (0, import_agent.pagePerform)(progress, this._page, params);
+    return await (0, import_agent.pagePerform)(progress, this._page, params);
   }
   async extract(params, progress) {
-    return { result: await (0, import_agent.pageExtract)(progress, this._page, params) };
+    const { result, usage } = await (0, import_agent.pageExtract)(progress, this._page, params);
+    return { result, ...usage };
   }
   async requests(params, progress) {
     this._subscriptions.add("request");

package/lib/server/firefox/ffBrowser.js

@@ -146,7 +146,7 @@ class FFBrowser extends import_browser.Browser {
   }
   _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();

package/lib/server/firefox/ffPage.js

@@ -276,7 +276,7 @@ class FFPage {
     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();

package/lib/server/instrumentation.js

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

package/lib/server/page.js

@@ -163,7 +163,7 @@ class Page extends import_instrumentation.SdkObject {
     this.emit(Page.Events.Close);
     this._closedPromise.resolve();
     this.instrumentation.onPageClose(this);
-    this.openScope.close(new import_errors.TargetClosedError());
+    this.openScope.close(new import_errors.TargetClosedError(this.closeReason()));
   }
   _didCrash() {
     this.frameManager.dispose();
@@ -577,7 +577,7 @@ class Page extends import_instrumentation.SdkObject {
     if (this._closedState === "closed")
       return;
     if (options.reason)
-      this.closeReason = options.reason;
+      this._closeReason = options.reason;
     const runBeforeUnload = !!options.runBeforeUnload;
     if (this._closedState !== "closing") {
       if (!runBeforeUnload)

package/lib/server/progress.js

@@ -68,6 +68,8 @@ class ProgressController {
     if (timeout) {
       const timeoutError = new import_errors.TimeoutError(`Timeout ${timeout}ms exceeded.`);
       timer = setTimeout(() => {
+        if (this.metadata.pauseStartTime && !this.metadata.pauseEndTime)
+          return;
         if (this._state === "running") {
           timeoutError[kAbortErrorSymbol] = true;
           this._state = { error: timeoutError };

package/lib/server/screencast.js

@@ -40,11 +40,12 @@ var import_registry = require("./registry");
 class Screencast {
   constructor(page) {
     this._videoRecorder = null;
-    this._screencastId = null;
+    this._videoId = 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._frameListener = null;
     this._page = page;
   }
   stopFrameThrottler() {
@@ -60,29 +61,31 @@ class Screencast {
   temporarilyDisableThrottling() {
     this._frameThrottler.recharge();
   }
-  async initializeVideoRecorder() {
+  launchVideoRecorder() {
     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 = {
+    (0, import_utils.assert)(!this._videoId);
+    this._videoId = (0, import_utils.createGuid)();
+    const outputFile = import_path.default.join(recordVideo.dir, this._videoId + ".webm");
+    const videoOptions = {
       // 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);
+    const ffmpegPath = import_registry.registry.findExecutable("ffmpeg").executablePathOrDie(this._page.browserContext._browser.sdkLanguage());
+    this._videoRecorder = new import_videoRecorder.VideoRecorder(ffmpegPath, videoOptions);
+    this._frameListener = import_utils.eventsHelper.addEventListener(this._page, import_page.Page.Events.ScreencastFrame, (frame) => this._videoRecorder.writeFrame(frame.buffer, frame.frameSwapWallTime / 1e3));
     this._page.waitForInitializedOrError().then((p) => {
       if (p instanceof Error)
         this.stopVideoRecording().catch(() => {
         });
     });
-    return screencastOptions;
+    return videoOptions;
   }
   async startVideoRecording(options) {
-    const screencastId = this._screencastId;
-    (0, import_utils.assert)(screencastId);
+    const videoId = this._videoId;
+    (0, import_utils.assert)(videoId);
     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));
@@ -92,20 +95,22 @@ class Screencast {
       height: options.height
     });
     gotFirstFrame.then(() => {
-      this._page.browserContext._browser._videoStarted(this._page.browserContext, screencastId, options.outputFile, this._page.waitForInitializedOrError());
+      this._page.browserContext._browser._videoStarted(this._page.browserContext, videoId, options.outputFile, this._page.waitForInitializedOrError());
     });
   }
   async stopVideoRecording() {
-    if (!this._screencastId)
+    if (!this._videoId)
       return;
-    const screencastId = this._screencastId;
-    this._screencastId = null;
-    const recorder = this._videoRecorder;
+    if (this._frameListener)
+      import_utils.eventsHelper.removeEventListeners([this._frameListener]);
+    this._frameListener = null;
+    const videoId = this._videoId;
+    this._videoId = null;
+    const videoRecorder = this._videoRecorder;
     this._videoRecorder = null;
-    await this._stopScreencast(recorder);
-    await recorder.stop().catch(() => {
-    });
-    const video = this._page.browserContext._browser._takeVideo(screencastId);
+    await this._stopScreencast(videoRecorder);
+    await videoRecorder.stop();
+    const video = this._page.browserContext._browser._takeVideo(videoId);
     video?.reportFinished();
   }
   async _setOptions(options) {
@@ -129,12 +134,6 @@ class Screencast {
     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) {

package/lib/server/videoRecorder.js

@@ -22,11 +22,10 @@ __export(videoRecorder_exports, {
 });
 module.exports = __toCommonJS(videoRecorder_exports);
 var import_utils = require("../utils");
-var import_page = require("./page");
 var import_processLauncher = require("./utils/processLauncher");
 const fps = 25;
 class VideoRecorder {
-  constructor(page, ffmpegPath) {
+  constructor(ffmpegPath, options) {
     this._process = null;
     this._gracefullyClose = null;
     this._lastWritePromise = Promise.resolve();
@@ -36,16 +35,12 @@ class VideoRecorder {
     this._frameQueue = [];
     this._isStopped = false;
     this._ffmpegPath = ffmpegPath;
-    page.on(import_page.Page.Events.ScreencastFrame, (frame) => this.writeFrame(frame.buffer, frame.frameSwapWallTime / 1e3));
-  }
-  static async launch(page, ffmpegPath, options) {
     if (!options.outputFile.endsWith(".webm"))
       throw new Error("File must have .webm extension");
-    const recorder = new VideoRecorder(page, ffmpegPath);
-    await recorder._launch(options);
-    return recorder;
+    this._launchPromise = this._launch(options).catch((e) => e);
   }
   async _launch(options) {
+    await (0, import_utils.mkdirIfNeeded)(options.outputFile);
     const w = options.width;
     const h = options.height;
     const args = `-loglevel error -f image2pipe -avioflags direct -fpsprobesize 0 -probesize 32 -analyzeduration 0 -c:v mjpeg -i pipe:0 -y -an -r ${fps} -c:v vp8 -qmin 0 -qmax 50 -crf 8 -deadline realtime -speed 8 -b:v 1M -threads 1 -vf pad=${w}:${h}:0:0:gray,crop=${w}:${h}:0:0`.split(" ");
@@ -74,6 +69,13 @@ class VideoRecorder {
     this._gracefullyClose = gracefullyClose;
   }
   writeFrame(frame, timestamp) {
+    this._launchPromise.then((error) => {
+      if (error)
+        return;
+      this._writeFrame(frame, timestamp);
+    });
+  }
+  _writeFrame(frame, timestamp) {
     (0, import_utils.assert)(this._process);
     if (this._isStopped)
       return;
@@ -100,13 +102,20 @@ class VideoRecorder {
     });
   }
   async stop() {
+    const error = await this._launchPromise;
+    if (error)
+      throw error;
     if (this._isStopped || !this._lastFrame)
       return;
     const addTime = Math.max(((0, import_utils.monotonicTime)() - this._lastWriteNodeTime) / 1e3, 1);
-    this.writeFrame(Buffer.from([]), this._lastFrame.timestamp + addTime);
+    this._writeFrame(Buffer.from([]), this._lastFrame.timestamp + addTime);
     this._isStopped = true;
-    await this._lastWritePromise;
-    await this._gracefullyClose();
+    try {
+      await this._lastWritePromise;
+      await this._gracefullyClose();
+    } catch (e) {
+      import_utils.debugLogger.log("error", `ffmpeg failed to stop: ${String(e)}`);
+    }
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/server/webkit/wkBrowser.js

@@ -79,7 +79,7 @@ class WKBrowser extends import_browser.Browser {
       wkPage.didClose();
     this._wkPages.clear();
     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();
     this._didClose();
   }

package/lib/server/webkit/wkPage.js

@@ -245,7 +245,7 @@ class WKPage {
       this._provisionalPage.dispose();
       this._provisionalPage = null;
     }
-    this._firstNonInitialNavigationCommittedReject(new import_errors.TargetClosedError());
+    this._firstNonInitialNavigationCommittedReject(new import_errors.TargetClosedError(this._page.closeReason()));
     this._page._didClose();
   }
   dispatchMessageToSession(message) {
@@ -441,7 +441,7 @@ class WKPage {
   }
   async navigateFrame(frame, url, referrer) {
     if (this._pageProxySession.isDisposed())
-      throw new import_errors.TargetClosedError();
+      throw new import_errors.TargetClosedError(this._page.closeReason());
     const pageProxyId = this._pageProxySession.sessionId;
     const result = await this._pageProxySession.connection.browserSession.send("Playwright.navigate", { url, pageProxyId, frameId: frame._id, referrer });
     return { newDocumentId: result.loaderId };
@@ -750,9 +750,10 @@ class WKPage {
     return 0;
   }
   async _initializeVideoRecording() {
-    const screencastOptions = await this._page.screencast.initializeVideoRecorder();
-    if (screencastOptions)
-      await this._page.screencast.startVideoRecording(screencastOptions);
+    const screencast = this._page.screencast;
+    const videoOptions = screencast.launchVideoRecorder();
+    if (videoOptions)
+      await screencast.startVideoRecording(videoOptions);
   }
   validateScreenshotDimension(side, omitDeviceScaleFactor) {
     if (process.platform === "darwin")
@@ -840,8 +841,7 @@ class WKPage {
     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.
+      frameSwapWallTime: event.timestamp ? event.timestamp * 1e3 : Date.now(),
       width: event.deviceWidth,
       height: event.deviceHeight
     });

package/lib/utils/isomorphic/stringUtils.js

@@ -26,6 +26,8 @@ __export(stringUtils_exports, {
   escapeRegExp: () => escapeRegExp,
   escapeTemplateString: () => escapeTemplateString,
   escapeWithQuotes: () => escapeWithQuotes,
+  formatObject: () => formatObject,
+  formatObjectOrVoid: () => formatObjectOrVoid,
   isString: () => isString,
   longestCommonSubstring: () => longestCommonSubstring,
   normalizeEscapedRegexQuotes: () => normalizeEscapedRegexQuotes,
@@ -60,6 +62,31 @@ function toTitleCase(name) {
 function toSnakeCase(name) {
   return name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase();
 }
+function formatObject(value, indent = "  ", mode = "multiline") {
+  if (typeof value === "string")
+    return escapeWithQuotes(value, "'");
+  if (Array.isArray(value))
+    return `[${value.map((o) => formatObject(o)).join(", ")}]`;
+  if (typeof value === "object") {
+    const keys = Object.keys(value).filter((key) => value[key] !== void 0).sort();
+    if (!keys.length)
+      return "{}";
+    const tokens = [];
+    for (const key of keys)
+      tokens.push(`${key}: ${formatObject(value[key])}`);
+    if (mode === "multiline")
+      return `{
+${tokens.join(`,
+${indent}`)}
+}`;
+    return `{ ${tokens.join(", ")} }`;
+  }
+  return String(value);
+}
+function formatObjectOrVoid(value, indent = "  ") {
+  const result = formatObject(value, indent);
+  return result === "{}" ? "" : result;
+}
 function quoteCSSAttributeValue(text) {
   return `"${text.replace(/["\\]/g, (char) => "\\" + char)}"`;
 }
@@ -143,6 +170,8 @@ function longestCommonSubstring(s1, s2) {
   escapeRegExp,
   escapeTemplateString,
   escapeWithQuotes,
+  formatObject,
+  formatObjectOrVoid,
   isString,
   longestCommonSubstring,
   normalizeEscapedRegexQuotes,