playwright 1.55.1 → 1.56.1

package/lib/plugins/webServerPlugin.js

@@ -80,6 +80,8 @@ class WebServerPlugin {
       const port = new URL(this._options.url).port;
       throw new Error(`${this._options.url ?? `http://localhost${port ? ":" + port : ""}`} is already used, make sure that nothing is running on the port/url or set reuseExistingServer:true in config.webServer.`);
     }
+    if (!this._options.command)
+      throw new Error("config.webServer.command cannot be empty");
     debugWebServer(`Starting WebServer process ${this._options.command}...`);
     const { launchedProcess, gracefullyClose } = await (0, import_utils.launchProcess)({
       command: this._options.command,

package/lib/program.js

@@ -46,6 +46,13 @@ var testServer = __toESM(require("./runner/testServer"));
 var import_watchMode = require("./runner/watchMode");
 var import_testRunner = require("./runner/testRunner");
 var import_reporters = require("./runner/reporters");
+var import_exports = require("./mcp/sdk/exports");
+var import_testBackend = require("./mcp/test/testBackend");
+var import_seed = require("./mcp/test/seed");
+var import_program3 = require("./mcp/program");
+var import_watchdog = require("./mcp/browser/watchdog");
+var import_generateAgents = require("./agents/generateAgents");
+const packageJSON = require("../package.json");
 function addTestCommand(program3) {
   const command = program3.command("test [test-filter...]");
   command.description("run tests with Playwright Test");
@@ -139,6 +146,60 @@ Arguments [dir]:
 Examples:
   $ npx playwright merge-reports playwright-report`);
 }
+function addBrowserMCPServerCommand(program3) {
+  const command = program3.command("run-mcp-server", { hidden: true });
+  command.description("Interact with the browser over MCP");
+  (0, import_program3.decorateCommand)(command, packageJSON.version);
+}
+function addTestMCPServerCommand(program3) {
+  const command = program3.command("run-test-mcp-server", { hidden: true });
+  command.description("Interact with the test runner over MCP");
+  command.option("--headless", "run browser in headless mode, headed by default");
+  command.option("-c, --config <file>", `Configuration file, or a test directory with optional "playwright.config.{m,c}?{js,ts}"`);
+  command.option("--host <host>", "host to bind server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.");
+  command.option("--port <port>", "port to listen on for SSE transport.");
+  command.action(async (options) => {
+    (0, import_watchdog.setupExitWatchdog)();
+    const backendFactory = {
+      name: "Playwright Test Runner",
+      nameInConfig: "playwright-test-runner",
+      version: packageJSON.version,
+      create: () => new import_testBackend.TestServerBackend(options.config, { muteConsole: options.port === void 0, headless: options.headless })
+    };
+    const mdbUrl = await (0, import_exports.runMainBackend)(
+      backendFactory,
+      {
+        port: options.port === void 0 ? void 0 : +options.port
+      }
+    );
+    if (mdbUrl)
+      console.error("MCP Listening on: ", mdbUrl);
+  });
+}
+function addInitAgentsCommand(program3) {
+  const command = program3.command("init-agents");
+  command.description("Initialize repository agents");
+  const option = command.createOption("--loop <loop>", "Agentic loop provider");
+  option.choices(["vscode", "claude", "opencode"]);
+  command.addOption(option);
+  command.option("-c, --config <file>", `Configuration file to find a project to use for seed test`);
+  command.option("--project <project>", "Project to use for seed test");
+  command.action(async (opts) => {
+    if (opts.loop === "opencode") {
+      await (0, import_generateAgents.initOpencodeRepo)();
+    } else if (opts.loop === "vscode") {
+      await (0, import_generateAgents.initVSCodeRepo)();
+    } else if (opts.loop === "claude") {
+      await (0, import_generateAgents.initClaudeCodeRepo)();
+    } else {
+      command.help();
+      return;
+    }
+    const config = await (0, import_configLoader.loadConfigFromFile)(opts.config);
+    const project = (0, import_seed.seedProject)(config, opts.project);
+    await (0, import_seed.ensureSeedTest)(project, true);
+  });
+}
 async function runTests(args, opts) {
   await (0, import_utils.startProfiling)();
   const cliOverrides = overridesFromOptions(opts);
@@ -151,6 +212,8 @@ async function runTests(args, opts) {
   config.cliProjectFilter = opts.project || void 0;
   config.cliPassWithNoTests = !!opts.passWithNoTests;
   config.cliLastFailed = !!opts.lastFailed;
+  config.cliTestList = opts.testList ? import_path.default.resolve(process.cwd(), opts.testList) : void 0;
+  config.cliTestListInvert = opts.testListInvert ? import_path.default.resolve(process.cwd(), opts.testListInvert) : void 0;
   (0, import_projectUtils.filterProjects)(config.projects, config.cliProjectFilter);
   if (opts.ui || opts.uiHost || opts.uiPort) {
     if (opts.onlyChanged)
@@ -321,6 +384,8 @@ const testOptions = [
   ["--reporter <reporter>", { description: `Reporter to use, comma-separated, can be ${import_config.builtInReporters.map((name) => `"${name}"`).join(", ")} (default: "${import_config.defaultReporter}")` }],
   ["--retries <retries>", { description: `Maximum retry count for flaky tests, zero for no retries (default: no retries)` }],
   ["--shard <shard>", { description: `Shard tests and execute only the selected shard, specify in the form "current/all", 1-based, for example "3/5"` }],
+  ["--test-list <file>", { description: `Path to a file containing a list of tests to run. See https://playwright.dev/docs/test-cli for more details.` }],
+  ["--test-list-invert <file>", { description: `Path to a file containing a list of tests to skip. See https://playwright.dev/docs/test-cli for more details.` }],
   ["--timeout <timeout>", { description: `Specify test timeout threshold in milliseconds, zero for unlimited (default: ${import_config.defaultTimeout})` }],
   ["--trace <mode>", { description: `Force tracing mode`, choices: kTraceModes }],
   ["--tsconfig <path>", { description: `Path to a single tsconfig applicable to all imported files (default: look up tsconfig for each imported file separately)` }],
@@ -336,8 +401,11 @@ addTestCommand(import_program.program);
 addShowReportCommand(import_program.program);
 addMergeReportsCommand(import_program.program);
 addClearCacheCommand(import_program.program);
+addBrowserMCPServerCommand(import_program.program);
+addTestMCPServerCommand(import_program.program);
 addDevServerCommand(import_program.program);
 addTestServerCommand(import_program.program);
+addInitAgentsCommand(import_program.program);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   program

package/lib/reporters/base.js

@@ -120,7 +120,7 @@ class TerminalReporter {
     this._fatalErrors = [];
     this._failureCount = 0;
     this.screen = options.screen ?? terminalScreen;
-    this._omitFailures = options.omitFailures || false;
+    this._options = options;
   }
   version() {
     return "v2";
@@ -258,7 +258,7 @@ class TerminalReporter {
   epilogue(full) {
     const summary = this.generateSummary();
     const summaryMessage = this.generateSummaryMessage(summary);
-    if (full && summary.failuresToPrint.length && !this._omitFailures)
+    if (full && summary.failuresToPrint.length && !this._options.omitFailures)
       this._printFailures(summary.failuresToPrint);
     this._printSlowTests();
     this._printSummary(summaryMessage);
@@ -284,14 +284,14 @@ class TerminalReporter {
   willRetry(test) {
     return test.outcome() === "unexpected" && test.results.length <= test.retries;
   }
-  formatTestTitle(test, step, omitLocation = false) {
-    return formatTestTitle(this.screen, this.config, test, step, omitLocation);
+  formatTestTitle(test, step) {
+    return formatTestTitle(this.screen, this.config, test, step, this._options);
   }
   formatTestHeader(test, options = {}) {
-    return formatTestHeader(this.screen, this.config, test, options);
+    return formatTestHeader(this.screen, this.config, test, { ...options, includeTestId: this._options.includeTestId });
   }
   formatFailure(test, index) {
-    return formatFailure(this.screen, this.config, test, index);
+    return formatFailure(this.screen, this.config, test, index, this._options);
   }
   formatError(error) {
     return formatError(this.screen, error);
@@ -300,9 +300,9 @@ class TerminalReporter {
     this.screen.stdout?.write(line ? line + "\n" : "\n");
   }
 }
-function formatFailure(screen, config, test, index) {
+function formatFailure(screen, config, test, index, options) {
   const lines = [];
-  const header = formatTestHeader(screen, config, test, { indent: "  ", index, mode: "error" });
+  const header = formatTestHeader(screen, config, test, { indent: "  ", index, mode: "error", includeTestId: options?.includeTestId });
   lines.push(screen.colors.red(header));
   for (const result of test.results) {
     const resultLines = [];
@@ -416,20 +416,18 @@ function stepSuffix(step) {
   const stepTitles = step ? step.titlePath() : [];
   return stepTitles.map((t) => t.split("\n")[0]).map((t) => " \u203A " + t).join("");
 }
-function formatTestTitle(screen, config, test, step, omitLocation = false) {
+function formatTestTitle(screen, config, test, step, options = {}) {
   const [, projectName, , ...titles] = test.titlePath();
-  let location;
-  if (omitLocation)
-    location = `${relativeTestPath(screen, config, test)}`;
-  else
-    location = `${relativeTestPath(screen, config, test)}:${test.location.line}:${test.location.column}`;
-  const projectTitle = projectName ? `[${projectName}] \u203A ` : "";
-  const testTitle = `${projectTitle}${location} \u203A ${titles.join(" \u203A ")}`;
+  const location = `${relativeTestPath(screen, config, test)}:${test.location.line}:${test.location.column}`;
+  const testId = options.includeTestId ? `[id=${test.id}] ` : "";
+  const projectLabel = options.includeTestId ? `project=` : "";
+  const projectTitle = projectName ? `[${projectLabel}${projectName}] \u203A ` : "";
+  const testTitle = `${testId}${projectTitle}${location} \u203A ${titles.join(" \u203A ")}`;
   const extraTags = test.tags.filter((t) => !testTitle.includes(t));
   return `${testTitle}${stepSuffix(step)}${extraTags.length ? " " + extraTags.join(" ") : ""}`;
 }
 function formatTestHeader(screen, config, test, options = {}) {
-  const title = formatTestTitle(screen, config, test);
+  const title = formatTestTitle(screen, config, test, void 0, options);
   const header = `${options.indent || ""}${options.index ? options.index + ") " : ""}${title}`;
   let fullHeader = header;
   if (options.mode === "error") {

package/lib/reporters/html.js

@@ -113,7 +113,17 @@ class HtmlReporter {
     else if (process.env.PLAYWRIGHT_HTML_NO_SNIPPETS)
       noSnippets = true;
     noSnippets = noSnippets || this._options.noSnippets;
-    const builder = new HtmlBuilder(this.config, this._outputFolder, this._attachmentsBaseURL, process.env.PLAYWRIGHT_HTML_TITLE || this._options.title, noSnippets);
+    let noCopyPrompt;
+    if (process.env.PLAYWRIGHT_HTML_NO_COPY_PROMPT === "false" || process.env.PLAYWRIGHT_HTML_NO_COPY_PROMPT === "0")
+      noCopyPrompt = false;
+    else if (process.env.PLAYWRIGHT_HTML_NO_COPY_PROMPT)
+      noCopyPrompt = true;
+    noCopyPrompt = noCopyPrompt || this._options.noCopyPrompt;
+    const builder = new HtmlBuilder(this.config, this._outputFolder, this._attachmentsBaseURL, {
+      title: process.env.PLAYWRIGHT_HTML_TITLE || this._options.title,
+      noSnippets,
+      noCopyPrompt
+    });
     this._buildResult = await builder.build(this.config.metadata, projectSuites, result, this._topLevelErrors);
   }
   async onExit() {
@@ -197,41 +207,26 @@ function startHtmlReportServer(folder) {
   return server;
 }
 class HtmlBuilder {
-  constructor(config, outputDir, attachmentsBaseURL, title, noSnippets = false) {
+  constructor(config, outputDir, attachmentsBaseURL, options) {
     this._stepsInFile = new import_utils.MultiMap();
     this._hasTraces = false;
     this._config = config;
     this._reportFolder = outputDir;
-    this._noSnippets = noSnippets;
+    this._options = options;
     import_fs.default.mkdirSync(this._reportFolder, { recursive: true });
     this._dataZipFile = new import_zipBundle.yazl.ZipFile();
     this._attachmentsBaseURL = attachmentsBaseURL;
-    this._title = title;
   }
   async build(metadata, projectSuites, result, topLevelErrors) {
     const data = /* @__PURE__ */ new Map();
     for (const projectSuite of projectSuites) {
+      const projectName = projectSuite.project().name;
       for (const fileSuite of projectSuite.suites) {
         const fileName = this._relativeLocation(fileSuite.location).file;
-        const fileId = (0, import_utils.calculateSha1)((0, import_utils.toPosixPath)(fileName)).slice(0, 20);
-        let fileEntry = data.get(fileId);
-        if (!fileEntry) {
-          fileEntry = {
-            testFile: { fileId, fileName, tests: [] },
-            testFileSummary: { fileId, fileName, tests: [], stats: emptyStats() }
-          };
-          data.set(fileId, fileEntry);
-        }
-        const { testFile, testFileSummary } = fileEntry;
-        const testEntries = [];
-        this._processSuite(fileSuite, projectSuite.project().name, [], testEntries);
-        for (const test of testEntries) {
-          testFile.tests.push(test.testCase);
-          testFileSummary.tests.push(test.testCaseSummary);
-        }
+        this._createEntryForSuite(data, projectName, fileSuite, fileName, true);
       }
     }
-    if (!this._noSnippets)
+    if (!this._options.noSnippets)
       createSnippets(this._stepsInFile);
     let ok = true;
     for (const [fileId, { testFile, testFileSummary }] of data) {
@@ -260,13 +255,13 @@ class HtmlBuilder {
     }
     const htmlReport = {
       metadata,
-      title: this._title,
       startTime: result.startTime.getTime(),
       duration: result.duration,
       files: [...data.values()].map((e) => e.testFileSummary),
       projectNames: projectSuites.map((r) => r.project().name),
       stats: { ...[...data.values()].reduce((a, e) => addStats(a, e.testFileSummary.stats), emptyStats()) },
-      errors: topLevelErrors.map((error) => (0, import_base.formatError)(import_base.internalScreen, error).message)
+      errors: topLevelErrors.map((error) => (0, import_base.formatError)(import_base.internalScreen, error).message),
+      options: this._options
     };
     htmlReport.files.sort((f1, f2) => {
       const w1 = f1.stats.unexpected * 1e3 + f1.stats.flaky;
@@ -331,13 +326,31 @@ class HtmlBuilder {
   _addDataFile(fileName, data) {
     this._dataZipFile.addBuffer(Buffer.from(JSON.stringify(data)), fileName);
   }
-  _processSuite(suite, projectName, path2, outTests) {
+  _createEntryForSuite(data, projectName, suite, fileName, deep) {
+    const fileId = (0, import_utils.calculateSha1)(fileName).slice(0, 20);
+    let fileEntry = data.get(fileId);
+    if (!fileEntry) {
+      fileEntry = {
+        testFile: { fileId, fileName, tests: [] },
+        testFileSummary: { fileId, fileName, tests: [], stats: emptyStats() }
+      };
+      data.set(fileId, fileEntry);
+    }
+    const { testFile, testFileSummary } = fileEntry;
+    const testEntries = [];
+    this._processSuite(suite, projectName, [], deep, testEntries);
+    for (const test of testEntries) {
+      testFile.tests.push(test.testCase);
+      testFileSummary.tests.push(test.testCaseSummary);
+    }
+  }
+  _processSuite(suite, projectName, path2, deep, outTests) {
     const newPath = [...path2, suite.title];
     suite.entries().forEach((e) => {
       if (e.type === "test")
         outTests.push(this._createTestEntry(e, projectName, newPath));
-      else
-        this._processSuite(e, projectName, newPath, outTests);
+      else if (deep)
+        this._processSuite(e, projectName, newPath, deep, outTests);
     });
   }
   _createTestEntry(test, projectName, path2) {

package/lib/reporters/list.js

@@ -39,6 +39,7 @@ 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);
@@ -61,11 +62,11 @@ class ListReporter extends import_base.TerminalReporter {
   }
   onStdOut(chunk, test, result) {
     super.onStdOut(chunk, test, result);
-    this._dumpToStdio(test, chunk, this.screen.stdout);
+    this._dumpToStdio(test, chunk, this.screen.stdout, "out");
   }
   onStdErr(chunk, test, result) {
     super.onStdErr(chunk, test, result);
-    this._dumpToStdio(test, chunk, this.screen.stderr);
+    this._dumpToStdio(test, chunk, this.screen.stderr, "err");
   }
   getStepIndex(testIndex, result, step) {
     if (this._stepIndex.has(step))
@@ -137,12 +138,15 @@ class ListReporter extends import_base.TerminalReporter {
       }
     }
   }
-  _dumpToStdio(test, chunk, stream) {
+  _dumpToStdio(test, chunk, stream, stdio) {
     if (this.config.quiet)
       return;
     const text = chunk.toString("utf-8");
     this._updateLineCountAndNewLineFlagForOutput(text);
-    stream.write(chunk);
+    if (this._prefixStdio)
+      stream.write(`[${stdio}] ${chunk}`);
+    else
+      stream.write(chunk);
   }
   onTestEnd(test, result) {
     super.onTestEnd(test, result);

package/lib/reporters/listModeReporter.js

@@ -34,7 +34,8 @@ module.exports = __toCommonJS(listModeReporter_exports);
 var import_path = __toESM(require("path"));
 var import_base = require("./base");
 class ListModeReporter {
-  constructor(options) {
+  constructor(options = {}) {
+    this._options = options;
     this.screen = options?.screen ?? import_base.terminalScreen;
   }
   version() {
@@ -50,8 +51,10 @@ class ListModeReporter {
     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 ")}`);
+      const testId = this._options.includeTestId ? `[id=${test.id}] ` : "";
+      const projectLabel = this._options.includeTestId ? `project=` : "";
+      const projectTitle = projectName ? `[${projectLabel}${projectName}] \u203A ` : "";
+      this._writeLine(`  ${testId}${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"}`);

package/lib/reporters/merge.js

@@ -216,7 +216,9 @@ function mergeConfigureEvents(configureEvents, rootDirOverride) {
     metadata: {},
     rootDir: "",
     version: "",
-    workers: 0
+    workers: 0,
+    globalSetup: null,
+    globalTeardown: null
   };
   for (const event of configureEvents)
     config = mergeConfigs(config, event.params.config);

package/lib/reporters/teleEmitter.js

@@ -152,7 +152,9 @@ class TeleReporterEmitter {
       metadata: config.metadata,
       rootDir: config.rootDir,
       version: config.version,
-      workers: config.workers
+      workers: config.workers,
+      globalSetup: config.globalSetup,
+      globalTeardown: config.globalTeardown
     };
   }
   _serializeProject(suite) {

package/lib/runner/dispatcher.js

@@ -158,8 +158,14 @@ class Dispatcher {
   _createWorker(testGroup, parallelIndex, loaderData) {
     const projectConfig = this._config.projects.find((p) => p.id === testGroup.projectId);
     const outputDir = projectConfig.project.outputDir;
-    const recoverFromStepErrors = this._failureTracker.canRecoverFromStepError();
-    const worker = new import_workerHost.WorkerHost(testGroup, parallelIndex, loaderData, recoverFromStepErrors, this._extraEnvByProjectId.get(testGroup.projectId) || {}, outputDir);
+    const worker = new import_workerHost.WorkerHost(testGroup, {
+      parallelIndex,
+      config: loaderData,
+      extraEnv: this._extraEnvByProjectId.get(testGroup.projectId) || {},
+      outputDir,
+      pauseOnError: this._failureTracker.pauseOnError(),
+      pauseAtEnd: this._failureTracker.pauseAtEnd(projectConfig)
+    });
     const handleOutput = (params) => {
       const chunk = chunkFromParams(params);
       if (worker.didFail()) {
@@ -312,24 +318,6 @@ class JobDispatcher {
     steps.delete(params.stepId);
     this._reporter.onStepEnd?.(test, result, step);
   }
-  _onStepRecoverFromError(resumeAfterStepError, params) {
-    const data = this._dataByTestId.get(params.testId);
-    if (!data) {
-      resumeAfterStepError({ stepId: params.stepId, status: "failed" });
-      return;
-    }
-    const { steps } = data;
-    const step = steps.get(params.stepId);
-    if (!step) {
-      resumeAfterStepError({ stepId: params.stepId, status: "failed" });
-      return;
-    }
-    const testError = {
-      ...params.error,
-      location: step.location
-    };
-    this._failureTracker.recoverFromStepError(params.stepId, testError, resumeAfterStepError);
-  }
   _onAttach(params) {
     const data = this._dataByTestId.get(params.testId);
     if (!data) {
@@ -382,7 +370,7 @@ class JobDispatcher {
     }
   }
   _onDone(params) {
-    if (!this._remainingByTestId.size && !this._failedTests.size && !params.fatalErrors.length && !params.skipTestsDueToSetupFailure.length && !params.fatalUnknownTestIds && !params.unexpectedExitError) {
+    if (!this._remainingByTestId.size && !this._failedTests.size && !params.fatalErrors.length && !params.skipTestsDueToSetupFailure.length && !params.fatalUnknownTestIds && !params.unexpectedExitError && !params.stoppedDueToUnhandledErrorInTestFail) {
       this._finished({ didFail: false });
       return;
     }
@@ -455,13 +443,11 @@ class JobDispatcher {
       })
     };
     worker.runTestGroup(runPayload);
-    const resumeAfterStepError = worker.resumeAfterStepError.bind(worker);
     this._listeners = [
       import_utils.eventsHelper.addEventListener(worker, "testBegin", this._onTestBegin.bind(this)),
       import_utils.eventsHelper.addEventListener(worker, "testEnd", this._onTestEnd.bind(this)),
       import_utils.eventsHelper.addEventListener(worker, "stepBegin", this._onStepBegin.bind(this)),
       import_utils.eventsHelper.addEventListener(worker, "stepEnd", this._onStepEnd.bind(this)),
-      import_utils.eventsHelper.addEventListener(worker, "stepRecoverFromError", this._onStepRecoverFromError.bind(this, resumeAfterStepError)),
       import_utils.eventsHelper.addEventListener(worker, "attach", this._onAttach.bind(this)),
       import_utils.eventsHelper.addEventListener(worker, "done", this._onDone.bind(this)),
       import_utils.eventsHelper.addEventListener(worker, "exit", this.onExit.bind(this))

package/lib/runner/failureTracker.js

@@ -22,35 +22,31 @@ __export(failureTracker_exports, {
 });
 module.exports = __toCommonJS(failureTracker_exports);
 class FailureTracker {
-  constructor(_config) {
+  constructor(_config, options) {
     this._config = _config;
     this._failureCount = 0;
     this._hasWorkerErrors = false;
+    this._topLevelProjects = [];
+    this._pauseOnError = options?.pauseOnError ?? false;
+    this._pauseAtEnd = options?.pauseAtEnd ?? false;
   }
-  canRecoverFromStepError() {
-    return !!this._recoverFromStepErrorHandler;
-  }
-  setRecoverFromStepErrorHandler(recoverFromStepErrorHandler) {
-    this._recoverFromStepErrorHandler = recoverFromStepErrorHandler;
-  }
-  onRootSuite(rootSuite) {
+  onRootSuite(rootSuite, topLevelProjects) {
     this._rootSuite = rootSuite;
+    this._topLevelProjects = topLevelProjects;
   }
   onTestEnd(test, result) {
     if (test.outcome() === "unexpected" && test.results.length > test.retries)
       ++this._failureCount;
   }
-  recoverFromStepError(stepId, error, resumeAfterStepError) {
-    if (!this._recoverFromStepErrorHandler) {
-      resumeAfterStepError({ stepId, status: "failed" });
-      return;
-    }
-    void this._recoverFromStepErrorHandler(stepId, error).then(resumeAfterStepError).catch(() => {
-    });
-  }
   onWorkerError() {
     this._hasWorkerErrors = true;
   }
+  pauseOnError() {
+    return this._pauseOnError;
+  }
+  pauseAtEnd(inProject) {
+    return this._pauseAtEnd && this._topLevelProjects.includes(inProject);
+  }
   hasReachedMaxFailures() {
     return this.maxFailures() > 0 && this._failureCount >= this.maxFailures();
   }

package/lib/runner/loadUtils.js

@@ -32,10 +32,13 @@ __export(loadUtils_exports, {
   createRootSuite: () => createRootSuite,
   loadFileSuites: () => loadFileSuites,
   loadGlobalHook: () => loadGlobalHook,
-  loadReporter: () => loadReporter
+  loadReporter: () => loadReporter,
+  loadTestList: () => loadTestList
 });
 module.exports = __toCommonJS(loadUtils_exports);
 var import_path = __toESM(require("path"));
+var import_fs = __toESM(require("fs"));
+var import_utils = require("playwright-core/lib/utils");
 var import_loaderHost = require("./loaderHost");
 var import_util = require("../util");
 var import_projectUtils = require("./projectUtils");
@@ -168,14 +171,17 @@ async function createRootSuite(testRun, errors, shouldFilterOnly) {
   }
   if (config.postShardTestFilters.length)
     (0, import_suiteUtils.filterTestsRemoveEmptySuites)(rootSuite, (test) => config.postShardTestFilters.every((filter) => filter(test)));
+  const topLevelProjects = [];
   {
     const projectClosure2 = new Map((0, import_projectUtils.buildProjectsClosure)(rootSuite.suites.map((suite) => suite._fullProject)));
     for (const [project, level] of projectClosure2.entries()) {
       if (level === "dependency")
         rootSuite._prependSuite(buildProjectSuite(project, projectSuites.get(project)));
+      else
+        topLevelProjects.push(project);
     }
   }
-  return rootSuite;
+  return { rootSuite, topLevelProjects };
 }
 function createProjectSuite(project, fileSuites) {
   const projectSuite = new import_test.Suite(project.project.name, "project");
@@ -287,11 +293,41 @@ function sourceMapSources(file, cache) {
     return sources;
   }
 }
+async function loadTestList(config, filePath) {
+  try {
+    const content = await import_fs.default.promises.readFile(filePath, "utf-8");
+    const lines = content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+    const descriptions = lines.map((line) => {
+      const delimiter = line.includes("\u203A") ? "\u203A" : ">";
+      const tokens = line.split(delimiter).map((token) => token.trim());
+      let project;
+      if (tokens[0].startsWith("[")) {
+        if (!tokens[0].endsWith("]"))
+          throw new Error(`Malformed test description: ${line}`);
+        project = tokens[0].substring(1, tokens[0].length - 1);
+        tokens.shift();
+      }
+      return { project, file: (0, import_utils.toPosixPath)((0, import_util.parseLocationArg)(tokens[0]).file), titlePath: tokens.slice(1) };
+    });
+    return (test) => descriptions.some((d) => {
+      const [projectName, , ...titles] = test.titlePath();
+      if (d.project !== void 0 && d.project !== projectName)
+        return false;
+      const relativeFile = (0, import_utils.toPosixPath)(import_path.default.relative(config.config.rootDir, test.location.file));
+      if (relativeFile !== d.file)
+        return false;
+      return d.titlePath.length === titles.length && d.titlePath.every((_, index) => titles[index] === d.titlePath[index]);
+    });
+  } catch (e) {
+    throw (0, import_util.errorWithFile)(filePath, "Cannot read test list file: " + e.message);
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   collectProjectsAndTestFiles,
   createRootSuite,
   loadFileSuites,
   loadGlobalHook,
-  loadReporter
+  loadReporter,
+  loadTestList
 });

package/lib/runner/projectUtils.js

@@ -32,7 +32,8 @@ __export(projectUtils_exports, {
   buildProjectsClosure: () => buildProjectsClosure,
   buildTeardownToSetupsMap: () => buildTeardownToSetupsMap,
   collectFilesForProject: () => collectFilesForProject,
-  filterProjects: () => filterProjects
+  filterProjects: () => filterProjects,
+  findTopLevelProjects: () => findTopLevelProjects
 });
 module.exports = __toCommonJS(projectUtils_exports);
 var import_fs = __toESM(require("fs"));
@@ -116,6 +117,10 @@ function buildProjectsClosure(projects, hasTests) {
     visit(0, p);
   return result;
 }
+function findTopLevelProjects(config) {
+  const closure = buildProjectsClosure(config.projects);
+  return [...closure].filter((entry) => entry[1] === "top-level").map((entry) => entry[0]);
+}
 function buildDependentProjects(forProjects, projects) {
   const reverseDeps = new Map(projects.map((p) => [p, []]));
   for (const project of projects) {
@@ -231,5 +236,6 @@ async function collectFiles(testDir, respectGitIgnore) {
   buildProjectsClosure,
   buildTeardownToSetupsMap,
   collectFilesForProject,
-  filterProjects
+  filterProjects,
+  findTopLevelProjects
 });