playwright 1.55.0-alpha-2025-08-14 → 1.55.0-alpha-2025-08-15

package/README.md

@@ -1,6 +1,6 @@
 # 🎭 Playwright
 
-[![npm version](https://img.shields.io/npm/v/playwright.svg)](https://www.npmjs.com/package/playwright) <!-- GEN:chromium-version-badge -->[![Chromium version](https://img.shields.io/badge/chromium-140.0.7339.5-blue.svg?logo=google-chrome)](https://www.chromium.org/Home)<!-- GEN:stop --> <!-- GEN:firefox-version-badge -->[![Firefox version](https://img.shields.io/badge/firefox-141.0-blue.svg?logo=firefoxbrowser)](https://www.mozilla.org/en-US/firefox/new/)<!-- GEN:stop --> <!-- GEN:webkit-version-badge -->[![WebKit version](https://img.shields.io/badge/webkit-26.0-blue.svg?logo=safari)](https://webkit.org/)<!-- GEN:stop --> [![Join Discord](https://img.shields.io/badge/join-discord-informational)](https://aka.ms/playwright/discord)
+[![npm version](https://img.shields.io/npm/v/playwright.svg)](https://www.npmjs.com/package/playwright) <!-- GEN:chromium-version-badge -->[![Chromium version](https://img.shields.io/badge/chromium-140.0.7339.16-blue.svg?logo=google-chrome)](https://www.chromium.org/Home)<!-- GEN:stop --> <!-- GEN:firefox-version-badge -->[![Firefox version](https://img.shields.io/badge/firefox-141.0-blue.svg?logo=firefoxbrowser)](https://www.mozilla.org/en-US/firefox/new/)<!-- GEN:stop --> <!-- GEN:webkit-version-badge -->[![WebKit version](https://img.shields.io/badge/webkit-26.0-blue.svg?logo=safari)](https://webkit.org/)<!-- GEN:stop --> [![Join Discord](https://img.shields.io/badge/join-discord-informational)](https://aka.ms/playwright/discord)
 
 ## [Documentation](https://playwright.dev) | [API reference](https://playwright.dev/docs/api/class-playwright)
 
@@ -8,7 +8,7 @@ Playwright is a framework for Web Testing and Automation. It allows testing [Chr
 
 |          | Linux | macOS | Windows |
 |   :---   | :---: | :---: | :---:   |
-| Chromium <!-- GEN:chromium-version -->140.0.7339.5<!-- GEN:stop --> | :white_check_mark: | :white_check_mark: | :white_check_mark: |
+| Chromium <!-- GEN:chromium-version -->140.0.7339.16<!-- GEN:stop --> | :white_check_mark: | :white_check_mark: | :white_check_mark: |
 | WebKit <!-- GEN:webkit-version -->26.0<!-- GEN:stop --> | :white_check_mark: | :white_check_mark: | :white_check_mark: |
 | Firefox <!-- GEN:firefox-version -->141.0<!-- GEN:stop --> | :white_check_mark: | :white_check_mark: | :white_check_mark: |
 

package/lib/program.js

@@ -28,8 +28,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var program_exports = {};
 __export(program_exports, {
-  program: () => import_program2.program,
-  withRunnerAndMutedWrite: () => withRunnerAndMutedWrite
+  program: () => import_program2.program
 });
 module.exports = __toCommonJS(program_exports);
 var import_fs = __toESM(require("fs"));
@@ -43,10 +42,10 @@ var import_base = require("./reporters/base");
 var import_html = require("./reporters/html");
 var import_merge = require("./reporters/merge");
 var import_projectUtils = require("./runner/projectUtils");
-var import_runner = require("./runner/runner");
 var testServer = __toESM(require("./runner/testServer"));
 var import_watchMode = require("./runner/watchMode");
-var import_util = require("./util");
+var import_testRunner = require("./runner/testRunner");
+var import_reporters = require("./runner/reporters");
 function addTestCommand(program3) {
   const command = program3.command("test [test-filter...]");
   command.description("run tests with Playwright Test");
@@ -78,44 +77,24 @@ Examples:
   $ npx playwright test --headed
   $ npx playwright test --project=webkit`);
 }
-function addListFilesCommand(program3) {
-  const command = program3.command("list-files [file-filter...]", { hidden: true });
-  command.description("List files with Playwright Test tests");
-  command.option("-c, --config <file>", `Configuration file, or a test directory with optional "playwright.config.{m,c}?{js,ts}"`);
-  command.option("--project <project-name...>", `Only run tests from the specified list of projects, supports '*' wildcard (default: list all projects)`);
-  command.action(async (args, opts) => listTestFiles(opts));
-}
 function addClearCacheCommand(program3) {
   const command = program3.command("clear-cache");
   command.description("clears build and test caches");
   command.option("-c, --config <file>", `Configuration file, or a test directory with optional "playwright.config.{m,c}?{js,ts}"`);
   command.action(async (opts) => {
-    const config = await (0, import_configLoader.loadConfigFromFile)(opts.config);
-    const runner = new import_runner.Runner(config);
-    const { status } = await runner.clearCache();
+    const runner = new import_testRunner.TestRunner((0, import_configLoader.resolveConfigLocation)(opts.config), {});
+    const { status } = await runner.clearCache((0, import_reporters.createErrorCollectingReporter)(import_base.terminalScreen));
     const exitCode = status === "interrupted" ? 130 : status === "passed" ? 0 : 1;
     (0, import_utils.gracefullyProcessExitDoNotHang)(exitCode);
   });
 }
-function addFindRelatedTestFilesCommand(program3) {
-  const command = program3.command("find-related-test-files [source-files...]", { hidden: true });
-  command.description("Returns the list of related tests to the given files");
-  command.option("-c, --config <file>", `Configuration file, or a test directory with optional "playwright.config.{m,c}?{js,ts}"`);
-  command.action(async (files, options) => {
-    const resolvedFiles = files.map((file) => import_path.default.resolve(process.cwd(), file));
-    await withRunnerAndMutedWrite(options.config, (runner) => runner.findRelatedTestFiles(resolvedFiles));
-  });
-}
 function addDevServerCommand(program3) {
   const command = program3.command("dev-server", { hidden: true });
   command.description("start dev server");
   command.option("-c, --config <file>", `Configuration file, or a test directory with optional "playwright.config.{m,c}?{js,ts}"`);
   command.action(async (options) => {
-    const config = await (0, import_configLoader.loadConfigFromFile)(options.config);
-    const runner = new import_runner.Runner(config);
-    const { status } = await runner.runDevServer();
-    const exitCode = status === "interrupted" ? 130 : status === "passed" ? 0 : 1;
-    (0, import_utils.gracefullyProcessExitDoNotHang)(exitCode);
+    const runner = new import_testRunner.TestRunner((0, import_configLoader.resolveConfigLocation)(options.config), {});
+    await runner.startDevServer((0, import_reporters.createErrorCollectingReporter)(import_base.terminalScreen), "in-process");
   });
 }
 function addTestServerCommand(program3) {
@@ -172,7 +151,6 @@ async function runTests(args, opts) {
   config.cliProjectFilter = opts.project || void 0;
   config.cliPassWithNoTests = !!opts.passWithNoTests;
   config.cliLastFailed = !!opts.lastFailed;
-  config.cliFilterFile = opts.filter ? import_path.default.resolve(process.cwd(), opts.filter) : void 0;
   (0, import_projectUtils.filterProjects)(config.projects, config.cliProjectFilter);
   if (opts.ui || opts.uiHost || opts.uiPort) {
     if (opts.onlyChanged)
@@ -207,8 +185,7 @@ async function runTests(args, opts) {
     (0, import_utils.gracefullyProcessExitDoNotHang)(exitCode2);
     return;
   }
-  const runner = new import_runner.Runner(config);
-  const status = await runner.runAllTests();
+  const status = await (0, import_testRunner.runAllTestsWithConfig)(config);
   await (0, import_utils.stopProfiling)("runner");
   const exitCode = status === "interrupted" ? 130 : status === "passed" ? 0 : 1;
   (0, import_utils.gracefullyProcessExitDoNotHang)(exitCode);
@@ -220,29 +197,6 @@ async function runTestServer(opts) {
   const exitCode = status === "interrupted" ? 130 : status === "passed" ? 0 : 1;
   (0, import_utils.gracefullyProcessExitDoNotHang)(exitCode);
 }
-async function withRunnerAndMutedWrite(configFile, callback) {
-  const stdoutWrite = process.stdout.write.bind(process.stdout);
-  process.stdout.write = (a, b, c) => process.stderr.write(a, b, c);
-  try {
-    const config = await (0, import_configLoader.loadConfigFromFile)(configFile);
-    const runner = new import_runner.Runner(config);
-    const result = await callback(runner);
-    stdoutWrite(JSON.stringify(result, void 0, 2), () => {
-      (0, import_utils.gracefullyProcessExitDoNotHang)(0);
-    });
-  } catch (e) {
-    const error = (0, import_util.serializeError)(e);
-    error.location = (0, import_base.prepareErrorStack)(e.stack).location;
-    stdoutWrite(JSON.stringify({ error }, void 0, 2), () => {
-      (0, import_utils.gracefullyProcessExitDoNotHang)(0);
-    });
-  }
-}
-async function listTestFiles(opts) {
-  await withRunnerAndMutedWrite(opts.config, async (runner) => {
-    return await runner.listTestFiles();
-  });
-}
 async function mergeReports(reportDir, opts) {
   const configFile = opts.config;
   const config = configFile ? await (0, import_configLoader.loadConfigFromFile)(configFile) : await (0, import_configLoader.loadEmptyConfigForMergeReports)();
@@ -347,7 +301,6 @@ const testOptions = [
   ["-c, --config <file>", { description: `Configuration file, or a test directory with optional "playwright.config.{m,c}?{js,ts}"` }],
   ["--debug", { description: `Run tests with Playwright Inspector. Shortcut for "PWDEBUG=1" environment variable and "--timeout=0 --max-failures=1 --headed --workers=1" options` }],
   ["--fail-on-flaky-tests", { description: `Fail if any test is flagged as flaky (default: false)` }],
-  ["--filter <file>", { description: `Path to a test filter file. See documentation for details.` }],
   ["--forbid-only", { description: `Fail if test.only is called (default: false)` }],
   ["--fully-parallel", { description: `Run all tests in parallel (default: false)` }],
   ["--global-timeout <timeout>", { description: `Maximum time this test suite can run in milliseconds (default: unlimited)` }],
@@ -381,14 +334,11 @@ const testOptions = [
 ];
 addTestCommand(import_program.program);
 addShowReportCommand(import_program.program);
-addListFilesCommand(import_program.program);
 addMergeReportsCommand(import_program.program);
 addClearCacheCommand(import_program.program);
-addFindRelatedTestFilesCommand(import_program.program);
 addDevServerCommand(import_program.program);
 addTestServerCommand(import_program.program);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  program,
-  withRunnerAndMutedWrite
+  program
 });

package/lib/reporters/base.js

@@ -54,18 +54,20 @@ var import_utilsBundle2 = require("../utilsBundle");
 const kOutputSymbol = Symbol("output");
 const DEFAULT_TTY_WIDTH = 100;
 const DEFAULT_TTY_HEIGHT = 40;
+const originalProcessStdout = process.stdout;
+const originalProcessStderr = process.stderr;
 const terminalScreen = (() => {
-  let isTTY = !!process.stdout.isTTY;
-  let ttyWidth = process.stdout.columns || 0;
-  let ttyHeight = process.stdout.rows || 0;
+  let isTTY = !!originalProcessStdout.isTTY;
+  let ttyWidth = originalProcessStdout.columns || 0;
+  let ttyHeight = originalProcessStdout.rows || 0;
   if (process.env.PLAYWRIGHT_FORCE_TTY === "false" || process.env.PLAYWRIGHT_FORCE_TTY === "0") {
     isTTY = false;
     ttyWidth = 0;
     ttyHeight = 0;
   } else if (process.env.PLAYWRIGHT_FORCE_TTY === "true" || process.env.PLAYWRIGHT_FORCE_TTY === "1") {
     isTTY = true;
-    ttyWidth = process.stdout.columns || DEFAULT_TTY_WIDTH;
-    ttyHeight = process.stdout.rows || DEFAULT_TTY_HEIGHT;
+    ttyWidth = originalProcessStdout.columns || DEFAULT_TTY_WIDTH;
+    ttyHeight = originalProcessStdout.rows || DEFAULT_TTY_HEIGHT;
   } else if (process.env.PLAYWRIGHT_FORCE_TTY) {
     isTTY = true;
     const sizeMatch = process.env.PLAYWRIGHT_FORCE_TTY.match(/^(\d+)x(\d+)$/);
@@ -92,7 +94,9 @@ const terminalScreen = (() => {
     isTTY,
     ttyWidth,
     ttyHeight,
-    colors
+    colors,
+    stdout: originalProcessStdout,
+    stderr: originalProcessStderr
   };
 })();
 const nonTerminalScreen = {
@@ -260,22 +264,22 @@ class TerminalReporter {
     this._printSummary(summaryMessage);
   }
   _printFailures(failures) {
-    console.log("");
+    this.writeLine("");
     failures.forEach((test, index) => {
-      console.log(this.formatFailure(test, index + 1));
+      this.writeLine(this.formatFailure(test, index + 1));
     });
   }
   _printSlowTests() {
     const slowTests = this.getSlowTests();
     slowTests.forEach(([file, duration]) => {
-      console.log(this.screen.colors.yellow("  Slow test file: ") + file + this.screen.colors.yellow(` (${(0, import_utilsBundle.ms)(duration)})`));
+      this.writeLine(this.screen.colors.yellow("  Slow test file: ") + file + this.screen.colors.yellow(` (${(0, import_utilsBundle.ms)(duration)})`));
     });
     if (slowTests.length)
-      console.log(this.screen.colors.yellow("  Consider running tests from slow files in parallel. See: https://playwright.dev/docs/test-parallel"));
+      this.writeLine(this.screen.colors.yellow("  Consider running tests from slow files in parallel. See: https://playwright.dev/docs/test-parallel"));
   }
   _printSummary(summary) {
     if (summary.trim())
-      console.log(summary);
+      this.writeLine(summary);
   }
   willRetry(test) {
     return test.outcome() === "unexpected" && test.results.length <= test.retries;
@@ -292,6 +296,9 @@ class TerminalReporter {
   formatError(error) {
     return formatError(this.screen, error);
   }
+  writeLine(line) {
+    this.screen.stdout?.write(line ? line + "\n" : "\n");
+  }
 }
 function formatFailure(screen, config, test, index) {
   const lines = [];

package/lib/reporters/dot.js

@@ -29,53 +29,53 @@ class DotReporter extends import_base.TerminalReporter {
   }
   onBegin(suite) {
     super.onBegin(suite);
-    console.log(this.generateStartingMessage());
+    this.writeLine(this.generateStartingMessage());
   }
   onStdOut(chunk, test, result) {
     super.onStdOut(chunk, test, result);
     if (!this.config.quiet)
-      process.stdout.write(chunk);
+      this.screen.stdout.write(chunk);
   }
   onStdErr(chunk, test, result) {
     super.onStdErr(chunk, test, result);
     if (!this.config.quiet)
-      process.stderr.write(chunk);
+      this.screen.stderr.write(chunk);
   }
   onTestEnd(test, result) {
     super.onTestEnd(test, result);
     if (this._counter === 80) {
-      process.stdout.write("\n");
+      this.screen.stdout.write("\n");
       this._counter = 0;
     }
     ++this._counter;
     if (result.status === "skipped") {
-      process.stdout.write(this.screen.colors.yellow("\xB0"));
+      this.screen.stdout.write(this.screen.colors.yellow("\xB0"));
       return;
     }
     if (this.willRetry(test)) {
-      process.stdout.write(this.screen.colors.gray("\xD7"));
+      this.screen.stdout.write(this.screen.colors.gray("\xD7"));
       return;
     }
     switch (test.outcome()) {
       case "expected":
-        process.stdout.write(this.screen.colors.green("\xB7"));
+        this.screen.stdout.write(this.screen.colors.green("\xB7"));
         break;
       case "unexpected":
-        process.stdout.write(this.screen.colors.red(result.status === "timedOut" ? "T" : "F"));
+        this.screen.stdout.write(this.screen.colors.red(result.status === "timedOut" ? "T" : "F"));
         break;
       case "flaky":
-        process.stdout.write(this.screen.colors.yellow("\xB1"));
+        this.screen.stdout.write(this.screen.colors.yellow("\xB1"));
         break;
     }
   }
   onError(error) {
     super.onError(error);
-    console.log("\n" + this.formatError(error).message);
+    this.writeLine("\n" + this.formatError(error).message);
     this._counter = 0;
   }
   async onEnd(result) {
     await super.onEnd(result);
-    process.stdout.write("\n");
+    this.screen.stdout.write("\n");
     this.epilogue(true);
   }
 }

package/lib/reporters/github.js

@@ -41,7 +41,8 @@ class GitHubLogger {
   _log(message, type = "notice", options = {}) {
     message = message.replace(/\n/g, "%0A");
     const configs = Object.entries(options).map(([key, option]) => `${key}=${option}`).join(",");
-    console.log((0, import_util.stripAnsiEscapes)(`::${type} ${configs}::${message}`));
+    process.stdout.write((0, import_util.stripAnsiEscapes)(`::${type} ${configs}::${message}
+`));
   }
   debug(message, options) {
     this._log(message, "debug", options);

package/lib/reporters/html.js

@@ -76,12 +76,12 @@ class HtmlReporter {
         if (reportedWarnings.has(key))
           continue;
         reportedWarnings.add(key);
-        console.log(import_utils2.colors.red(`Configuration Error: HTML reporter output folder clashes with the tests output folder:`));
-        console.log(`
+        writeLine(import_utils2.colors.red(`Configuration Error: HTML reporter output folder clashes with the tests output folder:`));
+        writeLine(`
     html reporter folder: ${import_utils2.colors.bold(outputFolder)}
     test results folder: ${import_utils2.colors.bold(project.outputDir)}`);
-        console.log("");
-        console.log(`HTML reporter will clear its output directory prior to being generated, which will lead to the artifact loss.
+        writeLine("");
+        writeLine(`HTML reporter will clear its output directory prior to being generated, which will lead to the artifact loss.
 `);
       }
     }
@@ -128,9 +128,9 @@ class HtmlReporter {
       const relativeReportPath = this._outputFolder === standaloneDefaultFolder() ? "" : " " + import_path.default.relative(process.cwd(), this._outputFolder);
       const hostArg = this._host ? ` --host ${this._host}` : "";
       const portArg = this._port ? ` --port ${this._port}` : "";
-      console.log("");
-      console.log("To open last HTML report run:");
-      console.log(import_utils2.colors.cyan(`
+      writeLine("");
+      writeLine("To open last HTML report run:");
+      writeLine(import_utils2.colors.cyan(`
   ${packageManagerCommand} playwright show-report${relativeReportPath}${hostArg}${portArg}
 `));
     }
@@ -145,7 +145,7 @@ function getHtmlReportOptionProcessEnv() {
   if (!htmlOpenEnv)
     return void 0;
   if (!isHtmlReportOption(htmlOpenEnv)) {
-    console.log(import_utils2.colors.red(`Configuration Error: HTML reporter Invalid value for PLAYWRIGHT_HTML_OPEN: ${htmlOpenEnv}. Valid values are: ${htmlReportOptions.join(", ")}`));
+    writeLine(import_utils2.colors.red(`Configuration Error: HTML reporter Invalid value for PLAYWRIGHT_HTML_OPEN: ${htmlOpenEnv}. Valid values are: ${htmlReportOptions.join(", ")}`));
     return void 0;
   }
   return htmlOpenEnv;
@@ -158,15 +158,15 @@ async function showHTMLReport(reportFolder, host = "localhost", port, testId) {
   try {
     (0, import_utils.assert)(import_fs.default.statSync(folder).isDirectory());
   } catch (e) {
-    console.log(import_utils2.colors.red(`No report found at "${folder}"`));
+    writeLine(import_utils2.colors.red(`No report found at "${folder}"`));
     (0, import_utils.gracefullyProcessExitDoNotHang)(1);
     return;
   }
   const server = startHtmlReportServer(folder);
   await server.start({ port, host, preferredPort: port ? void 0 : 9323 });
   let url = server.urlPrefix("human-readable");
-  console.log("");
-  console.log(import_utils2.colors.cyan(`  Serving HTML report at ${url}. Press Ctrl+C to quit.`));
+  writeLine("");
+  writeLine(import_utils2.colors.cyan(`  Serving HTML report at ${url}. Press Ctrl+C to quit.`));
   if (testId)
     url += `#?testId=${testId}`;
   url = url.replace("0.0.0.0", "localhost");
@@ -620,6 +620,9 @@ function createErrorCodeframe(message, location) {
     }
   );
 }
+function writeLine(line) {
+  process.stdout.write(line + "\n");
+}
 var html_default = HtmlReporter;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/reporters/internalReporter.js

@@ -37,10 +37,11 @@ var import_base = require("./base");
 var import_multiplexer = require("./multiplexer");
 var import_test = require("../common/test");
 var import_babelBundle = require("../transform/babelBundle");
+var import_reporterV2 = require("./reporterV2");
 class InternalReporter {
   constructor(reporters) {
     this._didBegin = false;
-    this._reporter = new import_multiplexer.Multiplexer(reporters);
+    this._reporter = new import_multiplexer.Multiplexer(reporters.map(import_reporterV2.wrapReporterAsV2));
   }
   version() {
     return "v2";

package/lib/reporters/line.js

@@ -33,18 +33,18 @@ class LineReporter extends import_base.TerminalReporter {
     super.onBegin(suite);
     const startingMessage = this.generateStartingMessage();
     if (startingMessage) {
-      console.log(startingMessage);
-      console.log();
+      this.writeLine(startingMessage);
+      this.writeLine();
     }
     this._didBegin = true;
   }
   onStdOut(chunk, test, result) {
     super.onStdOut(chunk, test, result);
-    this._dumpToStdio(test, chunk, process.stdout);
+    this._dumpToStdio(test, chunk, this.screen.stdout);
   }
   onStdErr(chunk, test, result) {
     super.onStdErr(chunk, test, result);
-    this._dumpToStdio(test, chunk, process.stderr);
+    this._dumpToStdio(test, chunk, this.screen.stderr);
   }
   _dumpToStdio(test, chunk, stream) {
     if (this.config.quiet)
@@ -59,8 +59,8 @@ class LineReporter extends import_base.TerminalReporter {
     }
     stream.write(chunk);
     if (chunk[chunk.length - 1] !== "\n")
-      console.log();
-    console.log();
+      this.writeLine();
+    this.writeLine();
   }
   onTestBegin(test, result) {
     ++this._current;
@@ -78,9 +78,9 @@ class LineReporter extends import_base.TerminalReporter {
     super.onTestEnd(test, result);
     if (!this.willRetry(test) && (test.outcome() === "flaky" || test.outcome() === "unexpected" || result.status === "interrupted")) {
       if (!process.env.PW_TEST_DEBUG_REPORTERS)
-        process.stdout.write(`\x1B[1A\x1B[2K`);
-      console.log(this.formatFailure(test, ++this._failures));
-      console.log();
+        this.screen.stdout.write(`\x1B[1A\x1B[2K`);
+      this.writeLine(this.formatFailure(test, ++this._failures));
+      this.writeLine();
     }
   }
   _updateLine(test, result, step) {
@@ -89,23 +89,23 @@ class LineReporter extends import_base.TerminalReporter {
     const currentRetrySuffix = result.retry ? this.screen.colors.yellow(` (retry #${result.retry})`) : "";
     const title = this.formatTestTitle(test, step) + currentRetrySuffix;
     if (process.env.PW_TEST_DEBUG_REPORTERS)
-      process.stdout.write(`${prefix + title}
+      this.screen.stdout.write(`${prefix + title}
 `);
     else
-      process.stdout.write(`\x1B[1A\x1B[2K${prefix + this.fitToScreen(title, prefix)}
+      this.screen.stdout.write(`\x1B[1A\x1B[2K${prefix + this.fitToScreen(title, prefix)}
 `);
   }
   onError(error) {
     super.onError(error);
     const message = this.formatError(error).message + "\n";
     if (!process.env.PW_TEST_DEBUG_REPORTERS && this._didBegin)
-      process.stdout.write(`\x1B[1A\x1B[2K`);
-    process.stdout.write(message);
-    console.log();
+      this.screen.stdout.write(`\x1B[1A\x1B[2K`);
+    this.screen.stdout.write(message);
+    this.writeLine();
   }
   async onEnd(result) {
     if (!process.env.PW_TEST_DEBUG_REPORTERS && this._didBegin)
-      process.stdout.write(`\x1B[1A\x1B[2K`);
+      this.screen.stdout.write(`\x1B[1A\x1B[2K`);
     await super.onEnd(result);
     this.epilogue(false);
   }

package/lib/reporters/list.js

@@ -44,8 +44,8 @@ class ListReporter extends import_base.TerminalReporter {
     super.onBegin(suite);
     const startingMessage = this.generateStartingMessage();
     if (startingMessage) {
-      console.log(startingMessage);
-      console.log();
+      this.writeLine(startingMessage);
+      this.writeLine("");
     }
   }
   onTestBegin(test, result) {
@@ -61,11 +61,11 @@ class ListReporter extends import_base.TerminalReporter {
   }
   onStdOut(chunk, test, result) {
     super.onStdOut(chunk, test, result);
-    this._dumpToStdio(test, chunk, process.stdout);
+    this._dumpToStdio(test, chunk, this.screen.stdout);
   }
   onStdErr(chunk, test, result) {
     super.onStdErr(chunk, test, result);
-    this._dumpToStdio(test, chunk, process.stderr);
+    this._dumpToStdio(test, chunk, this.screen.stderr);
   }
   getStepIndex(testIndex, result, step) {
     if (this._stepIndex.has(step))
@@ -115,7 +115,7 @@ class ListReporter extends import_base.TerminalReporter {
   _maybeWriteNewLine() {
     if (this._needNewLine) {
       this._needNewLine = false;
-      process.stdout.write("\n");
+      this.screen.stdout.write("\n");
       ++this._lastRow;
       this._lastColumn = 0;
     }
@@ -183,10 +183,10 @@ class ListReporter extends import_base.TerminalReporter {
   _appendLine(text, prefix) {
     const line = prefix + this.fitToScreen(text, prefix);
     if (process.env.PW_TEST_DEBUG_REPORTERS) {
-      process.stdout.write("#" + this._lastRow + " : " + line + "\n");
+      this.screen.stdout.write("#" + this._lastRow + " : " + line + "\n");
     } else {
-      process.stdout.write(line);
-      process.stdout.write("\n");
+      this.screen.stdout.write(line);
+      this.screen.stdout.write("\n");
     }
     ++this._lastRow;
     this._lastColumn = 0;
@@ -194,17 +194,17 @@ class ListReporter extends import_base.TerminalReporter {
   _updateLine(row, text, prefix) {
     const line = prefix + this.fitToScreen(text, prefix);
     if (process.env.PW_TEST_DEBUG_REPORTERS)
-      process.stdout.write("#" + row + " : " + line + "\n");
+      this.screen.stdout.write("#" + row + " : " + line + "\n");
     else
       this._updateLineForTTY(row, line);
   }
   _updateLineForTTY(row, line) {
     if (row !== this._lastRow)
-      process.stdout.write(`\x1B[${this._lastRow - row}A`);
-    process.stdout.write("\x1B[2K\x1B[0G");
-    process.stdout.write(line);
+      this.screen.stdout.write(`\x1B[${this._lastRow - row}A`);
+    this.screen.stdout.write("\x1B[2K\x1B[0G");
+    this.screen.stdout.write(line);
     if (row !== this._lastRow)
-      process.stdout.write(`\x1B[${this._lastRow - row}E`);
+      this.screen.stdout.write(`\x1B[${this._lastRow - row}E`);
   }
   _testPrefix(index, statusMark) {
     const statusMarkLength = (0, import_util.stripAnsiEscapes)(statusMark).length;
@@ -219,11 +219,11 @@ class ListReporter extends import_base.TerminalReporter {
     this._maybeWriteNewLine();
     const message = this.formatError(error).message + "\n";
     this._updateLineCountAndNewLineFlagForOutput(message);
-    process.stdout.write(message);
+    this.screen.stdout.write(message);
   }
   async onEnd(result) {
     await super.onEnd(result);
-    process.stdout.write("\n");
+    this.screen.stdout.write("\n");
     this.epilogue(true);
   }
 }

package/lib/reporters/listModeReporter.js

@@ -0,0 +1,66 @@
+"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 listModeReporter_exports = {};
+__export(listModeReporter_exports, {
+  default: () => listModeReporter_default
+});
+module.exports = __toCommonJS(listModeReporter_exports);
+var import_path = __toESM(require("path"));
+var import_base = require("./base");
+class ListModeReporter {
+  constructor(options) {
+    this.screen = options?.screen ?? import_base.terminalScreen;
+  }
+  version() {
+    return "v2";
+  }
+  onConfigure(config) {
+    this.config = config;
+  }
+  onBegin(suite) {
+    this._writeLine(`Listing tests:`);
+    const tests = suite.allTests();
+    const files = /* @__PURE__ */ new Set();
+    for (const test of tests) {
+      const [, projectName, , ...titles] = test.titlePath();
+      const location = `${import_path.default.relative(this.config.rootDir, test.location.file)}:${test.location.line}:${test.location.column}`;
+      const projectTitle = projectName ? `[${projectName}] \u203A ` : "";
+      this._writeLine(`  ${projectTitle}${location} \u203A ${titles.join(" \u203A ")}`);
+      files.add(test.location.file);
+    }
+    this._writeLine(`Total: ${tests.length} ${tests.length === 1 ? "test" : "tests"} in ${files.size} ${files.size === 1 ? "file" : "files"}`);
+  }
+  onError(error) {
+    this.screen.stderr.write("\n" + (0, import_base.formatError)(import_base.terminalScreen, error).message + "\n");
+  }
+  _writeLine(line) {
+    this.screen.stdout.write(line + "\n");
+  }
+}
+var listModeReporter_default = ListModeReporter;

package/lib/runner/reporters.js

@@ -33,7 +33,6 @@ __export(reporters_exports, {
   createReporters: () => createReporters
 });
 module.exports = __toCommonJS(reporters_exports);
-var import_path = __toESM(require("path"));
 var import_utils = require("playwright-core/lib/utils");
 var import_loadUtils = require("./loadUtils");
 var import_base = require("../reporters/base");
@@ -46,13 +45,14 @@ var import_json = __toESM(require("../reporters/json"));
 var import_junit = __toESM(require("../reporters/junit"));
 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) {
   const defaultReporters = {
     blob: import_blob.BlobReporter,
-    dot: mode === "list" ? ListModeReporter : import_dot.default,
-    line: mode === "list" ? ListModeReporter : import_line.default,
-    list: mode === "list" ? ListModeReporter : import_list.default,
+    dot: mode === "list" ? import_listModeReporter.default : import_dot.default,
+    line: mode === "list" ? import_listModeReporter.default : import_line.default,
+    list: mode === "list" ? import_listModeReporter.default : import_list.default,
     github: import_github.default,
     json: import_json.default,
     junit: import_junit.default,
@@ -81,7 +81,7 @@ async function createReporters(config, mode, isTestServer, descriptions) {
   const someReporterPrintsToStdio = reporters.some((r) => r.printsToStdio ? r.printsToStdio() : true);
   if (reporters.length && !someReporterPrintsToStdio) {
     if (mode === "list")
-      reporters.unshift(new ListModeReporter());
+      reporters.unshift(new import_listModeReporter.default());
     else if (mode !== "merge")
       reporters.unshift(!process.env.CI ? new import_line.default() : new import_dot.default());
   }
@@ -93,14 +93,13 @@ async function createReporterForTestServer(file, messageSink) {
     _send: messageSink
   }));
 }
-function createErrorCollectingReporter(screen, writeToConsole) {
+function createErrorCollectingReporter(screen) {
   const errors = [];
   return {
     version: () => "v2",
     onError(error) {
       errors.push(error);
-      if (writeToConsole)
-        process.stdout.write((0, import_base.formatError)(screen, error).message + "\n");
+      screen.stderr?.write((0, import_base.formatError)(screen, error).message + "\n");
     },
     errors: () => errors
   };
@@ -130,30 +129,6 @@ function computeCommandHash(config) {
     parts.push((0, import_utils.calculateSha1)(JSON.stringify(command)).substring(0, 7));
   return parts.join("-");
 }
-class ListModeReporter {
-  version() {
-    return "v2";
-  }
-  onConfigure(config) {
-    this.config = config;
-  }
-  onBegin(suite) {
-    console.log(`Listing tests:`);
-    const tests = suite.allTests();
-    const files = /* @__PURE__ */ new Set();
-    for (const test of tests) {
-      const [, projectName, , ...titles] = test.titlePath();
-      const location = `${import_path.default.relative(this.config.rootDir, test.location.file)}:${test.location.line}:${test.location.column}`;
-      const projectTitle = projectName ? `[${projectName}] \u203A ` : "";
-      console.log(`  ${projectTitle}${location} \u203A ${titles.join(" \u203A ")}`);
-      files.add(test.location.file);
-    }
-    console.log(`Total: ${tests.length} ${tests.length === 1 ? "test" : "tests"} in ${files.size} ${files.size === 1 ? "file" : "files"}`);
-  }
-  onError(error) {
-    console.error("\n" + (0, import_base.formatError)(import_base.terminalScreen, error).message);
-  }
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createErrorCollectingReporter,

package/lib/runner/tasks.js

@@ -247,15 +247,6 @@ function createLoadTask(mode, options) {
         const changedFiles = await (0, import_vcs.detectChangedTestFiles)(testRun.config.cliOnlyChanged, testRun.config.configDir);
         testRun.config.preOnlyTestFilters.push((test) => changedFiles.has(test.location.file));
       }
-      if (testRun.config.cliFilterFile) {
-        try {
-          testRun.config.preOnlyTestFilters.push(await (0, import_util2.loadTestFilterFile)(testRun.config.cliFilterFile));
-        } catch (error) {
-          if (options.failOnLoadErrors)
-            throw error;
-          softErrors.push(error);
-        }
-      }
       testRun.rootSuite = await (0, import_loadUtils.createRootSuite)(testRun, options.failOnLoadErrors ? errors : softErrors, !!options.filterOnly);
       testRun.failureTracker.onRootSuite(testRun.rootSuite);
       if (options.failOnLoadErrors && !testRun.rootSuite.allTests().length && !testRun.config.cliPassWithNoTests && !testRun.config.config.shard && !testRun.config.cliOnlyChanged) {

package/lib/runner/testRunner.js

@@ -29,7 +29,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var testRunner_exports = {};
 __export(testRunner_exports, {
   TestRunner: () => TestRunner,
-  TestRunnerEvent: () => TestRunnerEvent
+  TestRunnerEvent: () => TestRunnerEvent,
+  runAllTestsWithConfig: () => runAllTestsWithConfig
 });
 module.exports = __toCommonJS(testRunner_exports);
 var import_events = __toESM(require("events"));
@@ -48,6 +49,7 @@ var import_compilationCache = require("../transform/compilationCache");
 var import_util = require("../util");
 var import_reporters = require("./reporters");
 var import_tasks = require("./tasks");
+var import_lastRun = require("./lastRun");
 const TestRunnerEvent = {
   TestFilesChanged: "testFilesChanged",
   RecoverFromStepError: "recoverFromStepError"
@@ -117,14 +119,15 @@ class TestRunner extends import_events.default {
     this._globalSetup = void 0;
     return { status };
   }
-  async startDevServer(userReporters) {
+  async startDevServer(userReporter, mode) {
     await this.stopDevServer();
-    const reporter = new import_internalReporter.InternalReporter(userReporters);
+    const reporter = new import_internalReporter.InternalReporter([userReporter]);
     const config = await this._loadConfigOrReportError(reporter);
     if (!config)
       return { status: "failed" };
     const { status, cleanup } = await (0, import_tasks.runTasksDeferCleanup)(new import_tasks.TestRun(config, reporter), [
-      (0, import_tasks.createLoadTask)("out-of-process", { failOnLoadErrors: true, filterOnly: false }),
+      ...(0, import_tasks.createPluginSetupTasks)(config),
+      (0, import_tasks.createLoadTask)(mode, { failOnLoadErrors: true, filterOnly: false }),
       (0, import_tasks.createStartDevServerTask)()
     ]);
     if (status !== "passed")
@@ -139,31 +142,33 @@ class TestRunner extends import_events.default {
     this._devServer = void 0;
     return { status };
   }
-  async clearCache() {
-    const reporter = new import_internalReporter.InternalReporter([]);
+  async clearCache(userReporter) {
+    const reporter = new import_internalReporter.InternalReporter(userReporter ? [userReporter] : []);
     const config = await this._loadConfigOrReportError(reporter);
     if (!config)
-      return;
-    await (0, import_tasks.runTasks)(new import_tasks.TestRun(config, reporter), [
+      return { status: "failed" };
+    const status = await (0, import_tasks.runTasks)(new import_tasks.TestRun(config, reporter), [
+      ...(0, import_tasks.createPluginSetupTasks)(config),
       (0, import_tasks.createClearCacheTask)(config)
     ]);
+    return { status };
   }
-  async listFiles(userReporters, params) {
-    const reporter = new import_internalReporter.InternalReporter(userReporters);
+  async listFiles(userReporter, projects) {
+    const reporter = new import_internalReporter.InternalReporter([userReporter]);
     const config = await this._loadConfigOrReportError(reporter);
     if (!config)
       return { status: "failed" };
-    config.cliProjectFilter = params.projects?.length ? params.projects : void 0;
+    config.cliProjectFilter = projects?.length ? projects : void 0;
     const status = await (0, import_tasks.runTasks)(new import_tasks.TestRun(config, reporter), [
       (0, import_tasks.createListFilesTask)(),
       (0, import_tasks.createReportBeginTask)()
     ]);
     return { status };
   }
-  async listTests(userReporters, params) {
+  async listTests(userReporter, params) {
     let result;
     this._queue = this._queue.then(async () => {
-      const { config, status } = await this._innerListTests(userReporters, params);
+      const { config, status } = await this._innerListTests(userReporter, params);
       if (config)
         await this._updateWatchedDirs(config);
       result = { status };
@@ -171,13 +176,13 @@ class TestRunner extends import_events.default {
     await this._queue;
     return result;
   }
-  async _innerListTests(userReporters, params) {
+  async _innerListTests(userReporter, params) {
     const overrides = {
       ...this._configCLIOverrides,
       repeatEach: 1,
       retries: 0
     };
-    const reporter = new import_internalReporter.InternalReporter(userReporters);
+    const reporter = new import_internalReporter.InternalReporter([userReporter]);
     const config = await this._loadConfigOrReportError(reporter, overrides);
     if (!config)
       return { status: "failed" };
@@ -210,10 +215,10 @@ class TestRunner extends import_events.default {
   async _updateWatcher(reportPending) {
     await this._watcher.update([...this._watchedProjectDirs, ...this._watchedTestDependencies], [...this._ignoredProjectOutputs], reportPending);
   }
-  async runTests(userReporters, params) {
+  async runTests(userReporter, params) {
     let result = { status: "passed" };
     this._queue = this._queue.then(async () => {
-      result = await this._innerRunTests(userReporters, params).catch((e) => {
+      result = await this._innerRunTests(userReporter, params).catch((e) => {
         printInternalError(e);
         return { status: "failed" };
       });
@@ -221,7 +226,7 @@ class TestRunner extends import_events.default {
     await this._queue;
     return result;
   }
-  async _innerRunTests(userReporters, params) {
+  async _innerRunTests(userReporter, params) {
     await this.stopTests();
     const overrides = {
       ...this._configCLIOverrides,
@@ -246,7 +251,7 @@ class TestRunner extends import_events.default {
       process.env.PW_LIVE_TRACE_STACKS = "1";
     else
       process.env.PW_LIVE_TRACE_STACKS = void 0;
-    const config = await this._loadConfigOrReportError(new import_internalReporter.InternalReporter(userReporters), overrides);
+    const config = await this._loadConfigOrReportError(new import_internalReporter.InternalReporter([userReporter]), overrides);
     if (!config)
       return { status: "failed" };
     config.cliListOnly = false;
@@ -261,7 +266,7 @@ class TestRunner extends import_events.default {
       config.preOnlyTestFilters.push((test) => testIdSet.has(test.id));
     }
     const configReporters = await (0, import_reporters.createReporters)(config, "test", true);
-    const reporter = new import_internalReporter.InternalReporter([...configReporters, ...userReporters]);
+    const reporter = new import_internalReporter.InternalReporter([...configReporters, userReporter]);
     const stop = new import_utils.ManualPromise();
     const tasks = [
       (0, import_tasks.createApplyRebaselinesTask)(),
@@ -295,26 +300,27 @@ class TestRunner extends import_events.default {
     if (recoveryPromise)
       recoveryPromise.resolve(params);
   }
-  async watch(params) {
+  async watch(fileNames) {
     this._watchedTestDependencies = /* @__PURE__ */ new Set();
-    for (const fileName of params.fileNames) {
+    for (const fileName of fileNames) {
       this._watchedTestDependencies.add(fileName);
       (0, import_compilationCache.dependenciesForTestFile)(fileName).forEach((file) => this._watchedTestDependencies.add(file));
     }
     await this._updateWatcher(true);
   }
-  async findRelatedTestFiles(params) {
+  async findRelatedTestFiles(files, userReporter) {
     const errorReporter = (0, import_reporters.createErrorCollectingReporter)(import_base.internalScreen);
-    const reporter = new import_internalReporter.InternalReporter([errorReporter]);
+    const reporter = new import_internalReporter.InternalReporter(userReporter ? [userReporter, errorReporter] : [errorReporter]);
     const config = await this._loadConfigOrReportError(reporter);
     if (!config)
       return { errors: errorReporter.errors(), testFiles: [] };
     const status = await (0, import_tasks.runTasks)(new import_tasks.TestRun(config, reporter), [
+      ...(0, import_tasks.createPluginSetupTasks)(config),
       (0, import_tasks.createLoadTask)("out-of-process", { failOnLoadErrors: true, filterOnly: false, populateDependencies: true })
     ]);
     if (status !== "passed")
       return { errors: errorReporter.errors(), testFiles: [] };
-    return { testFiles: (0, import_compilationCache.affectedTestFiles)(params.files) };
+    return { testFiles: (0, import_compilationCache.affectedTestFiles)(files) };
   }
   async stopTests() {
     this._testRun?.stop?.resolve();
@@ -365,8 +371,32 @@ async function resolveCtDirs(config) {
     templateDir
   };
 }
+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 lastRun = new import_lastRun.LastRunReporter(config);
+  if (config.cliLastFailed)
+    await lastRun.filterLastFailed();
+  const reporter = new import_internalReporter.InternalReporter([...reporters, lastRun]);
+  const tasks = listOnly ? [
+    (0, import_tasks.createLoadTask)("in-process", { failOnLoadErrors: true, filterOnly: false }),
+    (0, import_tasks.createReportBeginTask)()
+  ] : [
+    (0, import_tasks.createApplyRebaselinesTask)(),
+    ...(0, import_tasks.createGlobalSetupTasks)(config),
+    (0, import_tasks.createLoadTask)("in-process", { filterOnly: true, failOnLoadErrors: true }),
+    ...(0, import_tasks.createRunTestsTasks)(config)
+  ];
+  const status = await (0, import_tasks.runTasks)(new import_tasks.TestRun(config, reporter), tasks, config.config.globalTimeout);
+  await new Promise((resolve) => process.stdout.write("", () => resolve()));
+  await new Promise((resolve) => process.stderr.write("", () => resolve()));
+  return status;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   TestRunner,
-  TestRunnerEvent
+  TestRunnerEvent,
+  runAllTestsWithConfig
 });

package/lib/runner/testServer.js

@@ -134,7 +134,7 @@ class TestServerDispatcher {
   async startDevServer(params) {
     await this.stopDevServer({});
     const { reporter, report } = await this._collectingReporter();
-    const { status } = await this._testRunner.startDevServer([reporter]);
+    const { status } = await this._testRunner.startDevServer(reporter, "out-of-process");
     return { report, status };
   }
   async stopDevServer(params) {
@@ -148,27 +148,27 @@ class TestServerDispatcher {
   }
   async listFiles(params) {
     const { reporter, report } = await this._collectingReporter();
-    const { status } = await this._testRunner.listFiles([reporter], params);
+    const { status } = await this._testRunner.listFiles(reporter, params.projects);
     return { report, status };
   }
   async listTests(params) {
     const { reporter, report } = await this._collectingReporter();
-    const { status } = await this._testRunner.listTests([reporter], params);
+    const { status } = await this._testRunner.listTests(reporter, params);
     return { report, status };
   }
   async runTests(params) {
     const wireReporter = await this._wireReporter((e) => this._dispatchEvent("report", e));
-    const { status } = await this._testRunner.runTests([wireReporter], params);
+    const { status } = await this._testRunner.runTests(wireReporter, params);
     return { status };
   }
   async resumeAfterStepError(params) {
     await this._testRunner.resumeAfterStepError(params);
   }
   async watch(params) {
-    await this._testRunner.watch(params);
+    await this._testRunner.watch(params.fileNames);
   }
   async findRelatedTestFiles(params) {
-    return this._testRunner.findRelatedTestFiles(params);
+    return this._testRunner.findRelatedTestFiles(params.files);
   }
   async stopTests() {
     await this._testRunner.stopTests();
@@ -183,14 +183,16 @@ class TestServerDispatcher {
           return originalStderrWrite.apply(process.stderr, [string]);
         };
       }
-      process.stdout.write = (chunk) => {
+      const stdoutWrite = (chunk) => {
         this._dispatchEvent("stdio", chunkToPayload("stdout", chunk));
         return true;
       };
-      process.stderr.write = (chunk) => {
+      const stderrWrite = (chunk) => {
         this._dispatchEvent("stdio", chunkToPayload("stderr", chunk));
         return true;
       };
+      process.stdout.write = stdoutWrite;
+      process.stderr.write = stderrWrite;
     } else {
       import_utilsBundle.debug.log = originalDebugLog;
       process.stdout.write = originalStdoutWrite;

package/lib/transform/transform.js

@@ -40,11 +40,11 @@ __export(transform_exports, {
   wrapFunctionWithLocation: () => wrapFunctionWithLocation
 });
 module.exports = __toCommonJS(transform_exports);
-var import_crypto = __toESM(require("crypto"));
 var import_fs = __toESM(require("fs"));
 var import_module = __toESM(require("module"));
 var import_path = __toESM(require("path"));
 var import_url = __toESM(require("url"));
+var import_crypto = __toESM(require("crypto"));
 var import_tsconfig_loader = require("../third_party/tsconfig-loader");
 var import_util = require("../util");
 var import_utilsBundle = require("../utilsBundle");

package/lib/util.js

@@ -47,7 +47,6 @@ __export(util_exports, {
   formatLocation: () => formatLocation,
   getContainedPath: () => getContainedPath,
   getPackageJsonPath: () => getPackageJsonPath,
-  loadTestFilterFile: () => loadTestFilterFile,
   mergeObjects: () => mergeObjects,
   normalizeAndSaveAttachment: () => normalizeAndSaveAttachment,
   relativeFilePath: () => relativeFilePath,
@@ -373,22 +372,6 @@ const ansiRegex = new RegExp("([\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*
 function stripAnsiEscapes(str) {
   return str.replace(ansiRegex, "");
 }
-async function loadTestFilterFile(filePath) {
-  try {
-    const data = JSON.parse(await import_fs.default.promises.readFile(filePath, "utf8"));
-    if (!data || typeof data !== "object" || !Array.isArray(data.titlePath) || !data.titlePath.every((path2) => Array.isArray(path2)))
-      throw new Error(`Wrong test filter file format`);
-    const toId = (titlePath) => {
-      const [project, file, ...titles] = titlePath;
-      return `${project}${(0, import_utils.toPosixPath)(file)}${titles.join("")}`;
-    };
-    const ids = new Set(data.titlePath.map((titlePath) => toId(titlePath)));
-    return (test) => ids.has(toId(test.titlePath()));
-  } catch (error) {
-    (0, import_utils.rewriteErrorMessage)(error, `Failed to read test filter file "${filePath}": ${error.message}`);
-    throw error;
-  }
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   addSuffixToFilePath,
@@ -410,7 +393,6 @@ async function loadTestFilterFile(filePath) {
   formatLocation,
   getContainedPath,
   getPackageJsonPath,
-  loadTestFilterFile,
   mergeObjects,
   normalizeAndSaveAttachment,
   relativeFilePath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playwright",
-  "version": "1.55.0-alpha-2025-08-14",
+  "version": "1.55.0-alpha-2025-08-15",
   "description": "A high-level API to automate web browsers",
   "repository": {
     "type": "git",
@@ -28,6 +28,7 @@
     "./lib/transform/transform": "./lib/transform/transform.js",
     "./lib/internalsForTest": "./lib/internalsForTest.js",
     "./lib/plugins": "./lib/plugins/index.js",
+    "./lib/runner/testRunner": "./lib/runner/testRunner.js",
     "./jsx-runtime": {
       "import": "./jsx-runtime.mjs",
       "require": "./jsx-runtime.js",
@@ -56,7 +57,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "playwright-core": "1.55.0-alpha-2025-08-14"
+    "playwright-core": "1.55.0-alpha-2025-08-15"
   },
   "optionalDependencies": {
     "fsevents": "2.3.2"

package/lib/runner/runner.js

@@ -1,110 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var runner_exports = {};
-__export(runner_exports, {
-  Runner: () => Runner
-});
-module.exports = __toCommonJS(runner_exports);
-var import_lastRun = require("./lastRun");
-var import_projectUtils = require("./projectUtils");
-var import_reporters = require("./reporters");
-var import_tasks = require("./tasks");
-var import_gitCommitInfoPlugin = require("../plugins/gitCommitInfoPlugin");
-var import_webServerPlugin = require("../plugins/webServerPlugin");
-var import_base = require("../reporters/base");
-var import_internalReporter = require("../reporters/internalReporter");
-var import_compilationCache = require("../transform/compilationCache");
-class Runner {
-  constructor(config) {
-    this._config = config;
-  }
-  async listTestFiles(projectNames) {
-    const projects = (0, import_projectUtils.filterProjects)(this._config.projects, projectNames);
-    const report = {
-      projects: []
-    };
-    for (const project of projects) {
-      report.projects.push({
-        name: project.project.name,
-        testDir: project.project.testDir,
-        use: { testIdAttribute: project.project.use.testIdAttribute },
-        files: await (0, import_projectUtils.collectFilesForProject)(project)
-      });
-    }
-    return report;
-  }
-  async runAllTests() {
-    const config = this._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 lastRun = new import_lastRun.LastRunReporter(config);
-    if (config.cliLastFailed)
-      await lastRun.filterLastFailed();
-    const reporter = new import_internalReporter.InternalReporter([...reporters, lastRun]);
-    const tasks = listOnly ? [
-      (0, import_tasks.createLoadTask)("in-process", { failOnLoadErrors: true, filterOnly: false }),
-      (0, import_tasks.createReportBeginTask)()
-    ] : [
-      (0, import_tasks.createApplyRebaselinesTask)(),
-      ...(0, import_tasks.createGlobalSetupTasks)(config),
-      (0, import_tasks.createLoadTask)("in-process", { filterOnly: true, failOnLoadErrors: true }),
-      ...(0, import_tasks.createRunTestsTasks)(config)
-    ];
-    const status = await (0, import_tasks.runTasks)(new import_tasks.TestRun(config, reporter), tasks, config.config.globalTimeout);
-    await new Promise((resolve) => process.stdout.write("", () => resolve()));
-    await new Promise((resolve) => process.stderr.write("", () => resolve()));
-    return status;
-  }
-  async findRelatedTestFiles(files) {
-    const errorReporter = (0, import_reporters.createErrorCollectingReporter)(import_base.terminalScreen);
-    const reporter = new import_internalReporter.InternalReporter([errorReporter]);
-    const status = await (0, import_tasks.runTasks)(new import_tasks.TestRun(this._config, reporter), [
-      ...(0, import_tasks.createPluginSetupTasks)(this._config),
-      (0, import_tasks.createLoadTask)("in-process", { failOnLoadErrors: true, filterOnly: false, populateDependencies: true })
-    ]);
-    if (status !== "passed")
-      return { errors: errorReporter.errors(), testFiles: [] };
-    return { testFiles: (0, import_compilationCache.affectedTestFiles)(files) };
-  }
-  async runDevServer() {
-    const reporter = new import_internalReporter.InternalReporter([(0, import_reporters.createErrorCollectingReporter)(import_base.terminalScreen, true)]);
-    const status = await (0, import_tasks.runTasks)(new import_tasks.TestRun(this._config, reporter), [
-      ...(0, import_tasks.createPluginSetupTasks)(this._config),
-      (0, import_tasks.createLoadTask)("in-process", { failOnLoadErrors: true, filterOnly: false }),
-      (0, import_tasks.createStartDevServerTask)(),
-      { title: "wait until interrupted", setup: async () => new Promise(() => {
-      }) }
-    ]);
-    return { status };
-  }
-  async clearCache() {
-    const reporter = new import_internalReporter.InternalReporter([(0, import_reporters.createErrorCollectingReporter)(import_base.terminalScreen, true)]);
-    const status = await (0, import_tasks.runTasks)(new import_tasks.TestRun(this._config, reporter), [
-      ...(0, import_tasks.createPluginSetupTasks)(this._config),
-      (0, import_tasks.createClearCacheTask)(this._config)
-    ]);
-    return { status };
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Runner
-});