playwright-core 1.54.0-alpha-2025-06-20 → 1.54.0-alpha-1750421372000

package/lib/server/page.js

@@ -55,7 +55,6 @@ 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_protocolError = require("./protocolError");
 class Page extends import_instrumentation.SdkObject {
   constructor(delegate, browserContext) {
     super(browserContext, "page");
@@ -250,27 +249,30 @@ class Page extends import_instrumentation.SdkObject {
     this.emitOnContextOnceInitialized(import_browserContext.BrowserContext.Events.Console, message);
   }
   async reload(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run((progress) => this.mainFrame().raceNavigationAction(progress, options, async () => {
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    return controller.run((progress) => this.mainFrame().raceNavigationAction(progress, async () => {
       const [response] = await Promise.all([
         // Reload must be a new document, and should not be confused with a stray pushState.
         this.mainFrame()._waitForNavigation(progress, true, options),
-        this.delegate.reload()
+        progress.race(this.delegate.reload())
       ]);
       return response;
     }), options.timeout);
   }
   async goBack(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run((progress) => this.mainFrame().raceNavigationAction(progress, options, async () => {
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    return controller.run((progress) => this.mainFrame().raceNavigationAction(progress, async () => {
       let error;
       const waitPromise = this.mainFrame()._waitForNavigation(progress, false, options).catch((e) => {
         error = e;
         return null;
       });
-      const result = await this.delegate.goBack();
-      if (!result)
+      const result = await progress.race(this.delegate.goBack());
+      if (!result) {
+        waitPromise.catch(() => {
+        });
         return null;
+      }
       const response = await waitPromise;
       if (error)
         throw error;
@@ -278,16 +280,19 @@ class Page extends import_instrumentation.SdkObject {
     }), options.timeout);
   }
   async goForward(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run((progress) => this.mainFrame().raceNavigationAction(progress, options, async () => {
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    return controller.run((progress) => this.mainFrame().raceNavigationAction(progress, async () => {
       let error;
       const waitPromise = this.mainFrame()._waitForNavigation(progress, false, options).catch((e) => {
         error = e;
         return null;
       });
-      const result = await this.delegate.goForward();
-      if (!result)
+      const result = await progress.race(this.delegate.goForward());
+      if (!result) {
+        waitPromise.catch(() => {
+        });
         return null;
+      }
       const response = await waitPromise;
       if (error)
         throw error;
@@ -441,11 +446,11 @@ class Page extends import_instrumentation.SdkObject {
       return await locator.frame.rafrafTimeoutScreenshotElementWithProgress(progress, locator.selector, timeout, options || {});
     } : async (progress, timeout) => {
       await this.performActionPreChecks(progress);
-      await this.mainFrame().rafrafTimeout(timeout);
+      await this.mainFrame().rafrafTimeout(progress, timeout);
       return await this.screenshotter.screenshotPage(progress, options || {});
     };
     const comparator = (0, import_comparators.getComparator)("image/png");
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     if (!options.expected && options.isNot)
       return { errorMessage: '"not" matcher requires expected result' };
     try {
@@ -476,7 +481,6 @@ class Page extends import_instrumentation.SdkObject {
         progress.log(`  generating new stable screenshot expectation`);
       let isFirstIteration = true;
       while (true) {
-        progress.throwIfAborted();
         if (this.isClosed())
           throw new Error("The page has closed");
         const screenshotTimeout = pollIntervals.shift() ?? 1e3;
@@ -484,6 +488,8 @@ class Page extends import_instrumentation.SdkObject {
           progress.log(`waiting ${screenshotTimeout}ms before taking screenshot`);
         previous = actual;
         actual = await rafrafScreenshot(progress, screenshotTimeout).catch((e) => {
+          if (this.mainFrame().isNonRetriableError(e))
+            throw e;
           progress.log(`failed to take screenshot - ` + e.message);
           return void 0;
         });
@@ -623,10 +629,13 @@ class Page extends import_instrumentation.SdkObject {
   markAsServerSideOnly() {
     this._isServerSideOnly = true;
   }
-  async snapshotForAI(metadata) {
-    this.lastSnapshotFrameIds = [];
-    const snapshot = await snapshotFrameForAI(metadata, this.mainFrame(), 0, this.lastSnapshotFrameIds);
-    return snapshot.join("\n");
+  snapshotForAI(metadata) {
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    return controller.run(async (progress) => {
+      this.lastSnapshotFrameIds = [];
+      const snapshot = await snapshotFrameForAI(progress, this.mainFrame(), 0, this.lastSnapshotFrameIds);
+      return snapshot.join("\n");
+    });
   }
 }
 class Worker extends import_instrumentation.SdkObject {
@@ -767,28 +776,25 @@ class FrameThrottler {
     }
   }
 }
-async function snapshotFrameForAI(metadata, frame, frameOrdinal, frameIds) {
-  const controller = new import_progress.ProgressController(metadata, frame);
-  const snapshot = await controller.run((progress) => {
-    return frame.retryWithProgressAndTimeouts(progress, [1e3, 2e3, 4e3, 8e3], async (continuePolling) => {
-      try {
-        const context = await frame._utilityContext();
-        const injectedScript = await context.injectedScript();
-        const snapshotOrRetry = await injectedScript.evaluate((injected, refPrefix) => {
-          const node = injected.document.body;
-          if (!node)
-            return true;
-          return injected.ariaSnapshot(node, { forAI: true, refPrefix });
-        }, frameOrdinal ? "f" + frameOrdinal : "");
-        if (snapshotOrRetry === true)
-          return continuePolling;
-        return snapshotOrRetry;
-      } catch (e) {
-        if ((0, import_progress.isAbortError)(e) || (0, import_protocolError.isSessionClosedError)(e) || js.isJavaScriptErrorInEvaluate(e))
-          throw e;
+async function snapshotFrameForAI(progress, frame, frameOrdinal, frameIds) {
+  const snapshot = await frame.retryWithProgressAndTimeouts(progress, [1e3, 2e3, 4e3, 8e3], async (continuePolling) => {
+    try {
+      const context = await progress.race(frame._utilityContext());
+      const injectedScript = await progress.race(context.injectedScript());
+      const snapshotOrRetry = await progress.race(injectedScript.evaluate((injected, refPrefix) => {
+        const node = injected.document.body;
+        if (!node)
+          return true;
+        return injected.ariaSnapshot(node, { forAI: true, refPrefix });
+      }, frameOrdinal ? "f" + frameOrdinal : ""));
+      if (snapshotOrRetry === true)
         return continuePolling;
-      }
-    });
+      return snapshotOrRetry;
+    } catch (e) {
+      if (frame.isNonRetriableError(e))
+        throw e;
+      return continuePolling;
+    }
   });
   const lines = snapshot.split("\n");
   const result = [];
@@ -802,7 +808,7 @@ async function snapshotFrameForAI(metadata, frame, frameOrdinal, frameIds) {
     const ref = match[2];
     const frameSelector = `aria-ref=${ref} >> internal:control=enter-frame`;
     const frameBodySelector = `${frameSelector} >> body`;
-    const child = await frame.selectors.resolveFrameForSelector(frameBodySelector, { strict: true });
+    const child = await progress.race(frame.selectors.resolveFrameForSelector(frameBodySelector, { strict: true }));
     if (!child) {
       result.push(line);
       continue;
@@ -810,7 +816,7 @@ async function snapshotFrameForAI(metadata, frame, frameOrdinal, frameIds) {
     const frameOrdinal2 = frameIds.length + 1;
     frameIds.push(child.frame._id);
     try {
-      const childSnapshot = await snapshotFrameForAI(metadata, child.frame, frameOrdinal2, frameIds);
+      const childSnapshot = await snapshotFrameForAI(progress, child.frame, frameOrdinal2, frameIds);
       result.push(line + ":", ...childSnapshot.map((l) => leadingSpace + "  " + l));
     } catch {
       result.push(line);

package/lib/server/playwright.js

@@ -50,8 +50,8 @@ class Playwright extends import_instrumentation.SdkObject {
       }
     }, null);
     this.chromium = new import_chromium.Chromium(this);
-    this.bidiChromium = new import_bidiChromium.BidiChromium(this);
-    this.bidiFirefox = new import_bidiFirefox.BidiFirefox(this);
+    this._bidiChromium = new import_bidiChromium.BidiChromium(this);
+    this._bidiFirefox = new import_bidiFirefox.BidiFirefox(this);
     this.firefox = new import_firefox.Firefox(this);
     this.webkit = new import_webkit.WebKit(this);
     this.electron = new import_electron.Electron(this);

package/lib/server/recorder/recorderApp.js

@@ -127,7 +127,7 @@ class RecorderApp extends import_events.EventEmitter {
         timeout: 0
       }
     });
-    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), context._browser);
+    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), context._browser, "strict");
     await controller.run(async (progress) => {
       await context._browser._defaultContext._loadDefaultContextAsIs(progress);
     });

package/lib/server/registry/index.js

@@ -399,7 +399,8 @@ const DOWNLOAD_PATHS = {
     "win64": "builds/android/%s/android.zip"
   },
   // TODO(bidi): implement downloads.
-  "bidi": {}
+  "_bidiFirefox": {},
+  "_bidiChromium": {}
 };
 const registryDirectory = (() => {
   let result;
@@ -654,8 +655,8 @@ ${(0, import_ascii.wrapInASCIIBox)(prettyMessage, 1)}`);
     }));
     this._executables.push({
       type: "browser",
-      name: "bidi-chromium",
-      browserName: "bidi",
+      name: "_bidiChromium",
+      browserName: "_bidiChromium",
       directory: chromium.dir,
       executablePath: () => chromiumExecutable,
       executablePathOrDie: (sdkLanguage) => executablePathOrDie("chromium", chromiumExecutable, chromium.installByDefault, sdkLanguage),
@@ -775,20 +776,6 @@ ${(0, import_ascii.wrapInASCIIBox)(prettyMessage, 1)}`);
       _dependencyGroup: "tools",
       _isHermeticInstallation: true
     });
-    this._executables.push({
-      type: "browser",
-      name: "bidi",
-      browserName: "bidi",
-      directory: void 0,
-      executablePath: () => void 0,
-      executablePathOrDie: () => "",
-      installType: "none",
-      _validateHostRequirements: () => Promise.resolve(),
-      downloadURLs: [],
-      _install: () => Promise.resolve(),
-      _dependencyGroup: "tools",
-      _isHermeticInstallation: true
-    });
   }
   _createChromiumChannel(name, lookAt, install) {
     const executablePath = (sdkLanguage, shouldThrow) => {
@@ -859,7 +846,7 @@ Run "${buildPlaywrightCLICommand(sdkLanguage, "install " + name)}"` : "";
     return {
       type: "channel",
       name,
-      browserName: "bidi",
+      browserName: "_bidiFirefox",
       directory: void 0,
       executablePath: (sdkLanguage) => executablePath(sdkLanguage, false),
       executablePathOrDie: (sdkLanguage) => executablePath(sdkLanguage, true),
@@ -874,7 +861,7 @@ Run "${buildPlaywrightCLICommand(sdkLanguage, "install " + name)}"` : "";
       const suffix = lookAt[process.platform];
       if (!suffix) {
         if (shouldThrow)
-          throw new Error(`Firefox distribution '${name}' is not supported on ${process.platform}`);
+          throw new Error(`Chromium distribution '${name}' is not supported on ${process.platform}`);
         return void 0;
       }
       const prefixes = process.platform === "win32" ? [
@@ -900,7 +887,7 @@ Run "${buildPlaywrightCLICommand(sdkLanguage, "install " + name)}"` : "";
     return {
       type: "channel",
       name,
-      browserName: "bidi",
+      browserName: "_bidiChromium",
       directory: void 0,
       executablePath: (sdkLanguage) => executablePath(sdkLanguage, false),
       executablePathOrDie: (sdkLanguage) => executablePath(sdkLanguage, true),

package/lib/server/screenshotter.js

@@ -166,7 +166,6 @@ class Screenshotter {
       progress.log("taking page screenshot");
       const viewportSize = await this._originalViewportSize(progress);
       await this._preparePageForScreenshot(progress, this._page.mainFrame(), options.style, options.caret !== "initial", options.animations === "disabled");
-      progress.throwIfAborted();
       if (options.fullPage) {
         const fullPageSize = await this._fullPageSize(progress);
         let documentRect = { x: 0, y: 0, width: fullPageSize.width, height: fullPageSize.height };
@@ -174,13 +173,11 @@ class Screenshotter {
         if (options.clip)
           documentRect = trimClipToSize(options.clip, documentRect);
         const buffer2 = await this._screenshot(progress, format, documentRect, void 0, fitsViewport, options);
-        progress.throwIfAborted();
         await this._restorePageAfterScreenshot();
         return buffer2;
       }
       const viewportRect = options.clip ? trimClipToSize(options.clip, viewportSize) : { x: 0, y: 0, ...viewportSize };
       const buffer = await this._screenshot(progress, format, void 0, viewportRect, true, options);
-      progress.throwIfAborted();
       await this._restorePageAfterScreenshot();
       return buffer;
     });
@@ -191,25 +188,21 @@ class Screenshotter {
       progress.log("taking element screenshot");
       const viewportSize = await this._originalViewportSize(progress);
       await this._preparePageForScreenshot(progress, handle._frame, options.style, options.caret !== "initial", options.animations === "disabled");
-      progress.throwIfAborted();
       await handle._waitAndScrollIntoViewIfNeeded(
         progress,
         true
         /* waitForVisible */
       );
-      progress.throwIfAborted();
-      const boundingBox = await handle.boundingBox();
+      const boundingBox = await progress.race(handle.boundingBox());
       (0, import_utils.assert)(boundingBox, "Node is either not visible or not an HTMLElement");
       (0, import_utils.assert)(boundingBox.width !== 0, "Node has 0 width.");
       (0, import_utils.assert)(boundingBox.height !== 0, "Node has 0 height.");
       const fitsViewport = boundingBox.width <= viewportSize.width && boundingBox.height <= viewportSize.height;
-      progress.throwIfAborted();
       const scrollOffset = await this._page.mainFrame().waitForFunctionValueInUtility(progress, () => ({ x: window.scrollX, y: window.scrollY }));
       const documentRect = { ...boundingBox };
       documentRect.x += scrollOffset.x;
       documentRect.y += scrollOffset.y;
       const buffer = await this._screenshot(progress, format, import_helper.helper.enclosingIntRect(documentRect), void 0, fitsViewport, options);
-      progress.throwIfAborted();
       await this._restorePageAfterScreenshot();
       return buffer;
     });
@@ -218,61 +211,54 @@ class Screenshotter {
     if (disableAnimations)
       progress.log("  disabled all CSS animations");
     const syncAnimations = this._page.delegate.shouldToggleStyleSheetToSyncAnimations();
-    await this._page.safeNonStallingEvaluateInAllFrames("(" + inPagePrepareForScreenshots.toString() + `)(${JSON.stringify(screenshotStyle)}, ${hideCaret}, ${disableAnimations}, ${syncAnimations})`, "utility");
+    progress.cleanupWhenAborted(() => this._restorePageAfterScreenshot());
+    await progress.race(this._page.safeNonStallingEvaluateInAllFrames("(" + inPagePrepareForScreenshots.toString() + `)(${JSON.stringify(screenshotStyle)}, ${hideCaret}, ${disableAnimations}, ${syncAnimations})`, "utility"));
     if (!process.env.PW_TEST_SCREENSHOT_NO_FONTS_READY) {
       progress.log("waiting for fonts to load...");
-      await frame.nonStallingEvaluateInExistingContext("document.fonts.ready", "utility").catch(() => {
-      });
+      await progress.race(frame.nonStallingEvaluateInExistingContext("document.fonts.ready", "utility").catch(() => {
+      }));
       progress.log("fonts loaded");
     }
-    progress.cleanupWhenAborted(() => this._restorePageAfterScreenshot());
   }
   async _restorePageAfterScreenshot() {
     await this._page.safeNonStallingEvaluateInAllFrames("window.__pwCleanupScreenshot && window.__pwCleanupScreenshot()", "utility");
   }
   async _maskElements(progress, options) {
+    if (!options.mask || !options.mask.length)
+      return () => Promise.resolve();
     const framesToParsedSelectors = new import_multimap.MultiMap();
     const cleanup = async () => {
       await Promise.all([...framesToParsedSelectors.keys()].map(async (frame) => {
         await frame.hideHighlight();
       }));
     };
-    if (!options.mask || !options.mask.length)
-      return cleanup;
-    await Promise.all((options.mask || []).map(async ({ frame, selector }) => {
+    progress.cleanupWhenAborted(cleanup);
+    await progress.race(Promise.all((options.mask || []).map(async ({ frame, selector }) => {
       const pair = await frame.selectors.resolveFrameForSelector(selector);
       if (pair)
         framesToParsedSelectors.set(pair.frame, pair.info.parsed);
-    }));
-    progress.throwIfAborted();
-    await Promise.all([...framesToParsedSelectors.keys()].map(async (frame) => {
+    })));
+    await progress.race(Promise.all([...framesToParsedSelectors.keys()].map(async (frame) => {
       await frame.maskSelectors(framesToParsedSelectors.get(frame), options.maskColor || "#F0F");
-    }));
-    progress.cleanupWhenAborted(cleanup);
+    })));
     return cleanup;
   }
   async _screenshot(progress, format, documentRect, viewportRect, fitsViewport, options) {
     if (options.__testHookBeforeScreenshot)
-      await options.__testHookBeforeScreenshot();
-    progress.throwIfAborted();
+      await progress.race(options.__testHookBeforeScreenshot());
     const shouldSetDefaultBackground = options.omitBackground && format === "png";
     if (shouldSetDefaultBackground) {
-      await this._page.delegate.setBackgroundColor({ r: 0, g: 0, b: 0, a: 0 });
       progress.cleanupWhenAborted(() => this._page.delegate.setBackgroundColor());
+      await progress.race(this._page.delegate.setBackgroundColor({ r: 0, g: 0, b: 0, a: 0 }));
     }
-    progress.throwIfAborted();
     const cleanupHighlight = await this._maskElements(progress, options);
-    progress.throwIfAborted();
     const quality = format === "jpeg" ? options.quality ?? 80 : void 0;
-    const buffer = await this._page.delegate.takeScreenshot(progress, format, documentRect, viewportRect, quality, fitsViewport, options.scale || "device");
-    progress.throwIfAborted();
+    const buffer = await progress.race(this._page.delegate.takeScreenshot(progress, format, documentRect, viewportRect, quality, fitsViewport, options.scale || "device"));
     await cleanupHighlight();
-    progress.throwIfAborted();
     if (shouldSetDefaultBackground)
-      await this._page.delegate.setBackgroundColor();
-    progress.throwIfAborted();
+      await progress.race(this._page.delegate.setBackgroundColor());
     if (options.__testHookAfterScreenshot)
-      await options.__testHookAfterScreenshot();
+      await progress.race(options.__testHookAfterScreenshot());
     return buffer;
   }
 }

package/lib/server/socksClientCertificatesInterceptor.js

@@ -261,9 +261,13 @@ class ClientCertificatesProxy {
       }
     }
   }
-  async listen() {
-    const port = await this._socksProxy.listen(0, "127.0.0.1");
-    return { server: `socks5://127.0.0.1:${port}` };
+  static async create(contextOptions) {
+    const proxy = new ClientCertificatesProxy(contextOptions);
+    await proxy._socksProxy.listen(0, "127.0.0.1");
+    return proxy;
+  }
+  proxySettings() {
+    return { server: `socks5://127.0.0.1:${this._socksProxy.port()}` };
   }
   async close() {
     await this._socksProxy.close();

package/lib/server/trace/viewer/traceViewer.js

@@ -158,7 +158,7 @@ async function openTraceViewerApp(url, browserName, options) {
       timeout: 0
     }
   });
-  const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), context._browser);
+  const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), context._browser, "strict");
   await controller.run(async (progress) => {
     await context._browser._defaultContext._loadDefaultContextAsIs(progress);
   });

package/lib/server/transport.js

@@ -99,12 +99,8 @@ class WebSocketTransport {
     const logUrl = stripQueryParams(url);
     progress?.log(`<ws connecting> ${logUrl}`);
     const transport = new WebSocketTransport(progress, url, logUrl, { ...options, followRedirects: !!options.followRedirects && hadRedirects });
-    let success = false;
-    progress?.cleanupWhenAborted(async () => {
-      if (!success)
-        await transport.closeAndWait().catch((e) => null);
-    });
-    const result = await new Promise((fulfill, reject) => {
+    progress?.cleanupWhenAborted(() => transport.closeAndWait());
+    const resultPromise = new Promise((fulfill, reject) => {
       transport._ws.on("open", async () => {
         progress?.log(`<ws connected> ${logUrl}`);
         fulfill({ transport });
@@ -136,6 +132,7 @@ ${Buffer.concat(chunks)}` : errorPrefix;
         });
       });
     });
+    const result = progress ? await progress.race(resultPromise) : await resultPromise;
     if (result.redirect) {
       const newHeaders = Object.fromEntries(Object.entries(options.headers || {}).filter(([name]) => {
         return !name.includes("access-key") && name.toLowerCase() !== "authorization";
@@ -148,7 +145,6 @@ ${Buffer.concat(chunks)}` : errorPrefix;
         /* hadRedirects */
       );
     }
-    success = true;
     return transport;
   }
   send(message) {

package/lib/server/utils/processLauncher.js

@@ -132,7 +132,7 @@ async function launchProcess(options) {
     spawnedProcess.once("error", (error) => {
       failed(new Error("Failed to launch: " + error));
     });
-    return cleanup().then(() => failedPromise).then((e) => Promise.reject(e));
+    return failedPromise.then((e) => Promise.reject(e));
   }
   options.log(`<launched> pid=${spawnedProcess.pid}`);
   const stdout = readline.createInterface({ input: spawnedProcess.stdout });