playwright 1.57.0-alpha-2025-10-29 → 1.57.0-alpha-2025-10-31

package/lib/matchers/expect.js

@@ -190,6 +190,8 @@ class ExpectMetaInfoProxyHandler {
     this._prefix = prefix;
   }
   get(target, matcherName, receiver) {
+    if (matcherName === "toThrowError")
+      matcherName = "toThrow";
     let matcher = Reflect.get(target, matcherName, receiver);
     if (typeof matcherName !== "string")
       return matcher;

package/lib/mcp/sdk/server.js

@@ -156,7 +156,12 @@ function firstRootPath(clientInfo) {
     return void 0;
   const firstRootUri = clientInfo.roots[0]?.uri;
   const url = firstRootUri ? new URL(firstRootUri) : void 0;
-  return url ? (0, import_url.fileURLToPath)(url) : void 0;
+  try {
+    return url ? (0, import_url.fileURLToPath)(url) : void 0;
+  } catch (error) {
+    serverDebug(error);
+    return void 0;
+  }
 }
 function mergeTextParts(result) {
   const content = [];

package/lib/mcp/test/streams.js

@@ -22,14 +22,16 @@ __export(streams_exports, {
 });
 module.exports = __toCommonJS(streams_exports);
 var import_stream = require("stream");
+var import_util = require("../../util");
 class StringWriteStream extends import_stream.Writable {
-  constructor(progress) {
+  constructor(progress, stdio) {
     super();
     this._progress = progress;
+    this._prefix = stdio === "stdout" ? "" : "[err] ";
   }
   _write(chunk, encoding, callback) {
-    const text = chunk.toString();
-    this._progress({ message: text.endsWith("\n") ? text.slice(0, -1) : text });
+    const text = (0, import_util.stripAnsiEscapes)(chunk.toString());
+    this._progress({ message: `${this._prefix}${text.endsWith("\n") ? text.slice(0, -1) : text}` });
     callback();
   }
 }

package/lib/mcp/test/testContext.js

@@ -29,7 +29,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var testContext_exports = {};
 __export(testContext_exports, {
   GeneratorJournal: () => GeneratorJournal,
-  TestContext: () => TestContext
+  TestContext: () => TestContext,
+  createScreen: () => createScreen
 });
 module.exports = __toCommonJS(testContext_exports);
 var import_fs = __toESM(require("fs"));
@@ -124,39 +125,77 @@ class TestContext {
     };
   }
   async runSeedTest(seedFile, projectName, progress) {
-    const { screen } = this.createScreen(progress);
+    await this.runWithGlobalSetup(async (testRunner, reporter) => {
+      const result = await testRunner.runTests(reporter, {
+        headed: !this.options?.headless,
+        locations: ["/" + (0, import_utils.escapeRegExp)(seedFile) + "/"],
+        projects: [projectName],
+        timeout: 0,
+        workers: 1,
+        pauseAtEnd: true,
+        disableConfigReporters: true,
+        failOnLoadErrors: true
+      });
+      if (result.status === "passed" && !reporter.suite?.allTests().length)
+        throw new Error("seed test not found.");
+      if (result.status !== "passed")
+        throw new Error("Errors while running the seed test.");
+    }, progress);
+  }
+  async runWithGlobalSetup(callback, progress) {
+    const { screen, claimStdio, releaseStdio } = createScreen(progress);
     const configDir = this.configLocation.configDir;
-    const reporter = new import_list.default({ configDir, screen });
     const testRunner = await this.createTestRunner();
-    const result = await testRunner.runTests(reporter, {
-      headed: !this.options?.headless,
-      locations: ["/" + (0, import_utils.escapeRegExp)(seedFile) + "/"],
-      projects: [projectName],
-      timeout: 0,
-      workers: 1,
-      pauseAtEnd: true,
-      disableConfigReporters: true,
-      failOnLoadErrors: true
-    });
-    if (result.status === "passed" && !reporter.suite?.allTests().length)
-      throw new Error("seed test not found.");
-    if (result.status !== "passed")
-      throw new Error("Errors while running the seed test.");
-  }
-  createScreen(progress) {
-    const stream = new import_streams.StringWriteStream(progress);
-    const screen = {
-      ...import_base.terminalScreen,
-      isTTY: false,
-      colors: import_utils.noColors,
-      stdout: stream,
-      stderr: stream
-    };
-    return { screen, stream };
+    claimStdio();
+    try {
+      const setupReporter = new import_list.default({ configDir, screen, includeTestId: true });
+      const { status } = await testRunner.runGlobalSetup([setupReporter]);
+      if (status !== "passed")
+        throw new Error("Failed to run global setup");
+    } finally {
+      releaseStdio();
+    }
+    try {
+      const reporter = new import_list.default({ configDir, screen, includeTestId: true });
+      return await callback(testRunner, reporter);
+    } finally {
+      claimStdio();
+      await testRunner.runGlobalTeardown().finally(() => {
+        releaseStdio();
+      });
+    }
   }
   async close() {
   }
 }
+function createScreen(progress) {
+  const stdout = new import_streams.StringWriteStream(progress, "stdout");
+  const stderr = new import_streams.StringWriteStream(progress, "stderr");
+  const screen = {
+    ...import_base.terminalScreen,
+    isTTY: false,
+    colors: import_utils.noColors,
+    stdout,
+    stderr
+  };
+  const originalStdoutWrite = process.stdout.write;
+  const originalStderrWrite = process.stderr.write;
+  const claimStdio = () => {
+    process.stdout.write = (chunk) => {
+      stdout.write(chunk);
+      return true;
+    };
+    process.stderr.write = (chunk) => {
+      stderr.write(chunk);
+      return true;
+    };
+  };
+  const releaseStdio = () => {
+    process.stdout.write = originalStdoutWrite;
+    process.stderr.write = originalStderrWrite;
+  };
+  return { screen, claimStdio, releaseStdio };
+}
 const bestPracticesMarkdown = `
 # Best practices
 - Do not improvise, do not add directives that were not asked for
@@ -172,5 +211,6 @@ const bestPracticesMarkdown = `
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   GeneratorJournal,
-  TestContext
+  TestContext,
+  createScreen
 });

package/lib/mcp/test/testTools.js

@@ -34,9 +34,9 @@ __export(testTools_exports, {
 });
 module.exports = __toCommonJS(testTools_exports);
 var import_bundle = require("../sdk/bundle");
-var import_list = __toESM(require("../../reporters/list"));
 var import_listModeReporter = __toESM(require("../../reporters/listModeReporter"));
 var import_testTool = require("./testTool");
+var import_testContext = require("./testContext");
 const listTests = (0, import_testTool.defineTestTool)({
   schema: {
     name: "test_list",
@@ -46,7 +46,7 @@ const listTests = (0, import_testTool.defineTestTool)({
     type: "readOnly"
   },
   handle: async (context, _, progress) => {
-    const { screen } = context.createScreen(progress);
+    const { screen } = (0, import_testContext.createScreen)(progress);
     const reporter = new import_listModeReporter.default({ screen, includeTestId: true });
     const testRunner = await context.createTestRunner();
     await testRunner.listTests(reporter, {});
@@ -65,15 +65,13 @@ const runTests = (0, import_testTool.defineTestTool)({
     type: "readOnly"
   },
   handle: async (context, params, progress) => {
-    const { screen } = context.createScreen(progress);
-    const configDir = context.configLocation.configDir;
-    const reporter = new import_list.default({ configDir, screen, includeTestId: true, prefixStdio: "out" });
-    const testRunner = await context.createTestRunner();
-    await testRunner.runTests(reporter, {
-      locations: params.locations,
-      projects: params.projects,
-      disableConfigReporters: true
-    });
+    await context.runWithGlobalSetup(async (testRunner, reporter) => {
+      await testRunner.runTests(reporter, {
+        locations: params.locations,
+        projects: params.projects,
+        disableConfigReporters: true
+      });
+    }, progress);
     return { content: [] };
   }
 });
@@ -91,19 +89,17 @@ const debugTest = (0, import_testTool.defineTestTool)({
     type: "readOnly"
   },
   handle: async (context, params, progress) => {
-    const { screen } = context.createScreen(progress);
-    const configDir = context.configLocation.configDir;
-    const reporter = new import_list.default({ configDir, screen, includeTestId: true, prefixStdio: "out" });
-    const testRunner = await context.createTestRunner();
-    await testRunner.runTests(reporter, {
-      headed: !context.options?.headless,
-      testIds: [params.test.id],
-      // For automatic recovery
-      timeout: 0,
-      workers: 1,
-      pauseOnError: true,
-      disableConfigReporters: true
-    });
+    await context.runWithGlobalSetup(async (testRunner, reporter) => {
+      await testRunner.runTests(reporter, {
+        headed: !context.options?.headless,
+        testIds: [params.test.id],
+        // For automatic recovery
+        timeout: 0,
+        workers: 1,
+        pauseOnError: true,
+        disableConfigReporters: true
+      });
+    }, progress);
     return { content: [] };
   }
 });

package/lib/plugins/webServerPlugin.js

@@ -115,17 +115,38 @@ class WebServerPlugin {
     });
     this._killProcess = gracefullyClose;
     debugWebServer(`Process started`);
+    if (this._options.wait?.stdout || this._options.wait?.stderr)
+      this._waitForStdioPromise = new import_utils.ManualPromise();
+    let stdoutWaitCollector = this._options.wait?.stdout ? "" : void 0;
+    let stderrWaitCollector = this._options.wait?.stderr ? "" : void 0;
+    const resolveStdioPromise = () => {
+      stderrWaitCollector = void 0;
+      stdoutWaitCollector = void 0;
+      this._waitForStdioPromise?.resolve();
+    };
     launchedProcess.stderr.on("data", (data) => {
+      if (stderrWaitCollector !== void 0) {
+        stderrWaitCollector += data.toString();
+        if (this._options.wait?.stderr?.test(stderrWaitCollector))
+          resolveStdioPromise();
+      }
       if (debugWebServer.enabled || (this._options.stderr === "pipe" || !this._options.stderr))
         this._reporter.onStdErr?.(prefixOutputLines(data.toString(), this._options.name));
     });
     launchedProcess.stdout.on("data", (data) => {
+      if (stdoutWaitCollector !== void 0) {
+        stdoutWaitCollector += data.toString();
+        if (this._options.wait?.stdout?.test(stdoutWaitCollector))
+          resolveStdioPromise();
+      }
       if (debugWebServer.enabled || this._options.stdout === "pipe")
         this._reporter.onStdOut?.(prefixOutputLines(data.toString(), this._options.name));
     });
   }
   async _waitForProcess() {
-    if (!this._isAvailableCallback) {
+    if (this._options.wait?.time)
+      await new Promise((resolve) => setTimeout(resolve, this._options.wait.time));
+    if (!this._isAvailableCallback && !this._waitForStdioPromise) {
       this._processExitedPromise.catch(() => {
       });
       return;
@@ -133,10 +154,13 @@ class WebServerPlugin {
     debugWebServer(`Waiting for availability...`);
     const launchTimeout = this._options.timeout || 60 * 1e3;
     const cancellationToken = { canceled: false };
-    const { timedOut } = await Promise.race([
-      (0, import_utils.raceAgainstDeadline)(() => waitFor(this._isAvailableCallback, cancellationToken), (0, import_utils.monotonicTime)() + launchTimeout),
-      this._processExitedPromise
-    ]);
+    const deadline = (0, import_utils.monotonicTime)() + launchTimeout;
+    const racingPromises = [this._processExitedPromise];
+    if (this._isAvailableCallback)
+      racingPromises.push((0, import_utils.raceAgainstDeadline)(() => waitFor(this._isAvailableCallback, cancellationToken), deadline));
+    if (this._waitForStdioPromise)
+      racingPromises.push((0, import_utils.raceAgainstDeadline)(() => this._waitForStdioPromise, deadline));
+    const { timedOut } = await Promise.race(racingPromises);
     cancellationToken.canceled = true;
     if (timedOut)
       throw new Error(`Timed out waiting ${launchTimeout}ms from config.webServer.`);

package/lib/reporters/html.js

@@ -130,10 +130,10 @@ class HtmlReporter {
     if (process.env.CI || !this._buildResult)
       return;
     const { ok, singleTestId } = this._buildResult;
-    const shouldOpen = !this._options._isTestServer && (this._open === "always" || !ok && this._open === "on-failure");
+    const shouldOpen = !!process.stdin.isTTY && (this._open === "always" || !ok && this._open === "on-failure");
     if (shouldOpen) {
       await showHTMLReport(this._outputFolder, this._host, this._port, singleTestId);
-    } else if (this._options._mode === "test" && !this._options._isTestServer) {
+    } else if (this._options._mode === "test" && !!process.stdin.isTTY) {
       const packageManagerCommand = (0, import_utils.getPackageManagerExecCommand)();
       const relativeReportPath = this._outputFolder === standaloneDefaultFolder() ? "" : " " + import_path.default.relative(process.cwd(), this._outputFolder);
       const hostArg = this._host ? ` --host ${this._host}` : "";

package/lib/reporters/list.js

@@ -39,7 +39,6 @@ class ListReporter extends import_base.TerminalReporter {
     this._stepIndex = /* @__PURE__ */ new Map();
     this._needNewLine = false;
     this._printSteps = (0, import_utils.getAsBooleanFromENV)("PLAYWRIGHT_LIST_PRINT_STEPS", options?.printSteps);
-    this._prefixStdio = options?.prefixStdio;
   }
   onBegin(suite) {
     super.onBegin(suite);
@@ -143,10 +142,7 @@ class ListReporter extends import_base.TerminalReporter {
       return;
     const text = chunk.toString("utf-8");
     this._updateLineCountAndNewLineFlagForOutput(text);
-    if (this._prefixStdio)
-      stream.write(`[${stdio}] ${chunk}`);
-    else
-      stream.write(chunk);
+    stream.write(chunk);
   }
   onTestEnd(test, result) {
     super.onTestEnd(test, result);

package/lib/reporters/merge.js

@@ -41,7 +41,7 @@ var import_teleReceiver = require("../isomorphic/teleReceiver");
 var import_reporters = require("../runner/reporters");
 var import_util = require("../util");
 async function createMergedReport(config, dir, reporterDescriptions, rootDirOverride) {
-  const reporters = await (0, import_reporters.createReporters)(config, "merge", false, reporterDescriptions);
+  const reporters = await (0, import_reporters.createReporters)(config, "merge", reporterDescriptions);
   const multiplexer = new import_multiplexer.Multiplexer(reporters);
   const stringPool = new import_stringInternPool.StringInternPool();
   let printStatus = () => {

package/lib/runner/reporters.js

@@ -47,7 +47,7 @@ var import_line = __toESM(require("../reporters/line"));
 var import_list = __toESM(require("../reporters/list"));
 var import_listModeReporter = __toESM(require("../reporters/listModeReporter"));
 var import_reporterV2 = require("../reporters/reporterV2");
-async function createReporters(config, mode, isTestServer, descriptions) {
+async function createReporters(config, mode, descriptions) {
   const defaultReporters = {
     blob: import_blob.BlobReporter,
     dot: mode === "list" ? import_listModeReporter.default : import_dot.default,
@@ -63,7 +63,7 @@ async function createReporters(config, mode, isTestServer, descriptions) {
   descriptions ??= config.config.reporter;
   if (config.configCLIOverrides.additionalReporters)
     descriptions = [...descriptions, ...config.configCLIOverrides.additionalReporters];
-  const runOptions = reporterOptions(config, mode, isTestServer);
+  const runOptions = reporterOptions(config, mode);
   for (const r of descriptions) {
     const [name, arg] = r;
     const options = { ...runOptions, ...arg };
@@ -104,11 +104,10 @@ function createErrorCollectingReporter(screen) {
     errors: () => errors
   };
 }
-function reporterOptions(config, mode, isTestServer) {
+function reporterOptions(config, mode) {
   return {
     configDir: config.configDir,
     _mode: mode,
-    _isTestServer: isTestServer,
     _commandHash: computeCommandHash(config)
   };
 }

package/lib/runner/testRunner.js

@@ -269,7 +269,7 @@ class TestRunner extends import_events.default {
       const testIdSet = new Set(params.testIds);
       config.preOnlyTestFilters.push((test) => testIdSet.has(test.id));
     }
-    const configReporters = params.disableConfigReporters ? [] : await (0, import_reporters.createReporters)(config, "test", true);
+    const configReporters = params.disableConfigReporters ? [] : await (0, import_reporters.createReporters)(config, "test");
     const reporter = new import_internalReporter.InternalReporter([...configReporters, userReporter]);
     const stop = new import_utils.ManualPromise();
     const tasks = [
@@ -363,7 +363,7 @@ async function runAllTestsWithConfig(config) {
   const listOnly = config.cliListOnly;
   (0, import_gitCommitInfoPlugin.addGitCommitInfoPlugin)(config);
   (0, import_webServerPlugin.webServerPluginsForConfig)(config).forEach((p) => config.plugins.push({ factory: p }));
-  const reporters = await (0, import_reporters.createReporters)(config, listOnly ? "list" : "test", false);
+  const reporters = await (0, import_reporters.createReporters)(config, listOnly ? "list" : "test");
   const lastRun = new import_lastRun.LastRunReporter(config);
   if (config.cliLastFailed)
     await lastRun.filterLastFailed();

package/lib/runner/testServer.js

@@ -45,6 +45,7 @@ var import_testRunner = require("./testRunner");
 const originalDebugLog = import_utilsBundle.debug.log;
 const originalStdoutWrite = process.stdout.write;
 const originalStderrWrite = process.stderr.write;
+const originalStdinIsTTY = process.stdin.isTTY;
 class TestServer {
   constructor(configLocation, configCLIOverrides) {
     this._configLocation = configLocation;
@@ -191,10 +192,12 @@ class TestServerDispatcher {
       };
       process.stdout.write = stdoutWrite;
       process.stderr.write = stderrWrite;
+      process.stdin.isTTY = void 0;
     } else {
       import_utilsBundle.debug.log = originalDebugLog;
       process.stdout.write = originalStdoutWrite;
       process.stderr.write = originalStderrWrite;
+      process.stdin.isTTY = originalStdinIsTTY;
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playwright",
-  "version": "1.57.0-alpha-2025-10-29",
+  "version": "1.57.0-alpha-2025-10-31",
   "description": "A high-level API to automate web browsers",
   "repository": {
     "type": "git",
@@ -64,7 +64,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "playwright-core": "1.57.0-alpha-2025-10-29"
+    "playwright-core": "1.57.0-alpha-2025-10-31"
   },
   "optionalDependencies": {
     "fsevents": "2.3.2"

package/types/test.d.ts

@@ -7728,6 +7728,27 @@ interface AsymmetricMatchers {
    * @param expected Expected array that is a subset of the received value.
    */
   arrayContaining(sample: Array<unknown>): AsymmetricMatcher;
+  /**
+   * `expect.arrayOf()` matches array of objects created from the
+   * [`constructor`](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-array-of-option-constructor)
+   * or a corresponding primitive type. Use it inside
+   * [expect(value).toEqual(expected)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-to-equal)
+   * to perform pattern matching.
+   *
+   * **Usage**
+   *
+   * ```js
+   * // Match instance of a class.
+   * class Example {}
+   * expect([new Example(), new Example()]).toEqual(expect.arrayOf(Example));
+   *
+   * // Match any string.
+   * expect(['a', 'b', 'c']).toEqual(expect.arrayOf(String));
+   * ```
+   *
+   * @param constructor Constructor of the expected object like `ExampleClass`, or a primitive boxed type like `Number`.
+   */
+  arrayOf(sample: unknown): AsymmetricMatcher;
   /**
    * Compares floating point numbers for approximate equality. Use this method inside
    * [expect(value).toEqual(expected)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-to-equal)
@@ -8111,6 +8132,7 @@ interface GenericAssertions<R> {
    * - [expect(value).any(constructor)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-any)
    * - [expect(value).anything()](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-anything)
    * - [expect(value).arrayContaining(expected)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-array-containing)
+   * - [expect(value).arrayOf(constructor)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-array-of)
    * - [expect(value).closeTo(expected[, numDigits])](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-close-to)
    * - [expect(value).objectContaining(expected)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-object-containing)
    * - [expect(value).stringContaining(expected)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-string-containing)
@@ -10170,6 +10192,17 @@ interface TestConfigWebServer {
    */
   stdout?: "pipe"|"ignore";
 
+  /**
+   * Consider command started only when given output has been produced or a time in milliseconds has passed.
+   */
+  wait?: {
+    stdout?: RegExp;
+
+    stderr?: RegExp;
+
+    time?: number;
+  };
+
   /**
    * How long to wait for the process to start up and be available in milliseconds. Defaults to 60000.
    */