@smoothdeploy/playwright 1.61.0 → 1.62.1-beta-1790342324000

package/lib/runner/index.js

@@ -56,7 +56,7 @@ var import_events2 = __toESM(require("events"));
 var import_fs13 = __toESM(require("fs"));
 var import_path17 = __toESM(require("path"));
 var import_coreBundle2 = require("playwright-core/lib/coreBundle");
-var import_common9 = require("../common");
+var import_common10 = require("../common");
 
 // packages/playwright/src/runner/fsWatcher.ts
 var chokidar = require("playwright-core/lib/utilsBundle").chokidar;
@@ -432,6 +432,18 @@ var TeleSuite = class {
     suite.parent = this;
     this._entries.push(suite);
   }
+  skip(_reason) {
+    throw new Error("Disposition methods are not supported on a TeleSuite (read-only).");
+  }
+  fixme(_reason) {
+    throw new Error("Disposition methods are not supported on a TeleSuite (read-only).");
+  }
+  fail(_reason) {
+    throw new Error("Disposition methods are not supported on a TeleSuite (read-only).");
+  }
+  exclude() {
+    throw new Error("Disposition methods are not supported on a TeleSuite (read-only).");
+  }
 };
 var TeleTestCase = class {
   constructor(id, title, location, repeatEachIndex) {
@@ -467,6 +479,18 @@ var TeleTestCase = class {
     this.results.push(result);
     return result;
   }
+  skip(_reason) {
+    throw new Error("Disposition methods are not supported on a TeleTestCase (read-only).");
+  }
+  fixme(_reason) {
+    throw new Error("Disposition methods are not supported on a TeleTestCase (read-only).");
+  }
+  fail(_reason) {
+    throw new Error("Disposition methods are not supported on a TeleTestCase (read-only).");
+  }
+  exclude() {
+    throw new Error("Disposition methods are not supported on a TeleTestCase (read-only).");
+  }
 };
 var TeleTestStep = class {
   constructor(payload, parentStep, location, result) {
@@ -1011,10 +1035,10 @@ var import_util2 = require("../util");
 var realColors = require("playwright-core/lib/utilsBundle").colors;
 var { noColors } = require("playwright-core/lib/coreBundle").iso;
 var { msToString } = require("playwright-core/lib/coreBundle").iso;
-var { parseErrorStack } = require("playwright-core/lib/coreBundle").iso;
+var { parseErrorStack } = require("playwright-core/lib/coreBundle").utils;
 var { getPackageManagerExecCommand } = require("playwright-core/lib/coreBundle").utils;
 var { fitToWidth } = require("playwright-core/lib/coreBundle").utils;
-var kOutputSymbol = Symbol("output");
+var kOutputSymbol = /* @__PURE__ */ Symbol("output");
 var DEFAULT_TTY_WIDTH = 100;
 var DEFAULT_TTY_HEIGHT = 40;
 var originalProcessStdout = process.stdout;
@@ -1024,8 +1048,9 @@ var StripAnsiStream = class extends import_stream.Writable {
     super();
     this._target = target;
   }
-  _write(chunk, encoding, callback) {
-    this._target.write((0, import_util2.stripAnsiEscapes)(chunk.toString()), callback);
+  write(chunk, encodingOrCallback, callback) {
+    const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+    return this._target.write((0, import_util2.stripAnsiEscapes)(chunk.toString()), cb);
   }
 };
 var terminalScreen = (() => {
@@ -1373,7 +1398,7 @@ function quotePathIfNeeded(path21) {
     return `"${path21}"`;
   return path21;
 }
-var kReportedSymbol = Symbol("reported");
+var kReportedSymbol = /* @__PURE__ */ Symbol("reported");
 function markErrorsAsReported(result) {
   result[kReportedSymbol] = result.errors.length;
 }
@@ -1482,7 +1507,7 @@ function indent(lines, tab) {
   return lines.replace(/^(?=.+$)/gm, tab);
 }
 function prepareErrorStack(stack) {
-  return parseErrorStack(stack, import_path2.default.sep, !!process.env.PWDEBUGIMPL);
+  return parseErrorStack(stack);
 }
 function resolveFromEnv(name) {
   const value = process.env[name];
@@ -1546,52 +1571,61 @@ function groupAttachments(attachments) {
 var import_fs = __toESM(require("fs"));
 
 // packages/playwright/src/reporters/multiplexer.ts
+var import_util3 = require("../util");
 var Multiplexer = class {
   constructor(reporters) {
+    this._hasReporterErrors = false;
     this._reporters = reporters;
   }
   version() {
     return "v2";
   }
+  hasReporterErrors() {
+    return this._hasReporterErrors;
+  }
   onConfigure(config2) {
     for (const reporter of this._reporters)
-      wrap(() => reporter.onConfigure?.(config2));
+      this._wrap(() => reporter.onConfigure?.(config2));
+  }
+  async preprocess(params) {
+    for (const reporter of this._reporters)
+      await reporter.preprocess?.(params);
   }
   onBegin(suite) {
     for (const reporter of this._reporters)
-      wrap(() => reporter.onBegin?.(suite));
+      this._wrap(() => reporter.onBegin?.(suite));
   }
   onTestBegin(test, result) {
     for (const reporter of this._reporters)
-      wrap(() => reporter.onTestBegin?.(test, result));
+      this._wrap(() => reporter.onTestBegin?.(test, result));
   }
   onStdOut(chunk, test, result) {
     for (const reporter of this._reporters)
-      wrap(() => reporter.onStdOut?.(chunk, test, result));
+      this._wrap(() => reporter.onStdOut?.(chunk, test, result));
   }
   onStdErr(chunk, test, result) {
     for (const reporter of this._reporters)
-      wrap(() => reporter.onStdErr?.(chunk, test, result));
+      this._wrap(() => reporter.onStdErr?.(chunk, test, result));
   }
   async onTestPaused(test, result) {
     for (const reporter of this._reporters)
-      await wrapAsync(() => reporter.onTestPaused?.(test, result));
+      await this._wrapAsync(() => reporter.onTestPaused?.(test, result));
   }
   onTestEnd(test, result) {
     for (const reporter of this._reporters)
-      wrap(() => reporter.onTestEnd?.(test, result));
+      this._wrap(() => reporter.onTestEnd?.(test, result));
   }
   onReportConfigure(params) {
     for (const reporter of this._reporters)
-      wrap(() => reporter.onReportConfigure?.(params));
+      this._wrap(() => reporter.onReportConfigure?.(params));
   }
   onReportEnd(params) {
     for (const reporter of this._reporters)
-      wrap(() => reporter.onReportEnd?.(params));
+      this._wrap(() => reporter.onReportEnd?.(params));
   }
   async onEnd(result) {
     for (const reporter of this._reporters) {
-      const outResult = await wrapAsync(() => reporter.onEnd?.(result));
+      const outResult = await this._wrapAsync(() => reporter.onEnd?.(result));
       if (outResult?.status)
         result.status = outResult.status;
     }
@@ -1599,42 +1633,45 @@ var Multiplexer = class {
   }
   async onExit() {
     for (const reporter of this._reporters)
-      await wrapAsync(() => reporter.onExit?.());
+      await this._wrapAsync(() => reporter.onExit?.());
   }
   onError(error, workerInfo) {
     for (const reporter of this._reporters)
-      wrap(() => reporter.onError?.(error, workerInfo));
+      this._wrap(() => reporter.onError?.(error, workerInfo), false);
   }
   onStepBegin(test, result, step) {
     for (const reporter of this._reporters)
-      wrap(() => reporter.onStepBegin?.(test, result, step));
+      this._wrap(() => reporter.onStepBegin?.(test, result, step));
   }
   onStepEnd(test, result, step) {
     for (const reporter of this._reporters)
-      wrap(() => reporter.onStepEnd?.(test, result, step));
+      this._wrap(() => reporter.onStepEnd?.(test, result, step));
   }
   printsToStdio() {
     return this._reporters.some((r) => {
       let prints = false;
-      wrap(() => prints = r.printsToStdio ? r.printsToStdio() : true);
+      this._wrap(() => prints = r.printsToStdio ? r.printsToStdio() : true, false);
       return prints;
     });
   }
-};
-async function wrapAsync(callback) {
-  try {
-    return await callback();
-  } catch (e) {
-    console.error("Error in reporter", e);
+  _wrap(callback, redispatch = true) {
+    try {
+      callback();
+    } catch (e) {
+      this._hasReporterErrors = true;
+      if (redispatch)
+        this.onError((0, import_util3.serializeError)(e));
+    }
   }
-}
-function wrap(callback) {
-  try {
-    callback();
-  } catch (e) {
-    console.error("Error in reporter", e);
+  async _wrapAsync(callback) {
+    try {
+      return await callback();
+    } catch (e) {
+      this._hasReporterErrors = true;
+      this.onError((0, import_util3.serializeError)(e));
+    }
   }
-}
+};
 
 // packages/playwright/src/reporters/internalReporter.ts
 var import_common = require("../common");
@@ -1660,6 +1697,9 @@ var ReporterV2Wrapper = class {
   onConfigure(config2) {
     this._config = config2;
   }
+  preprocess(params) {
+    return this._reporter.preprocess?.(params);
+  }
   onBegin(suite) {
     this._reporter.onBegin?.(this._config, suite);
     const deferred = this._deferred;
@@ -1727,12 +1767,18 @@ var InternalReporter = class {
   version() {
     return "v2";
   }
+  hasReporterErrors() {
+    return this._reporter.hasReporterErrors();
+  }
   onConfigure(config2) {
     this._config = config2;
     this._startTime = /* @__PURE__ */ new Date();
     this._monotonicStartTime = monotonicTime3();
     this._reporter.onConfigure?.(config2);
   }
+  async preprocess(params) {
+    await this._reporter.preprocess(params);
+  }
   onBegin(suite) {
     this._didBegin = true;
     this._reporter.onBegin?.(suite);
@@ -1779,7 +1825,7 @@ var InternalReporter = class {
     this._reporter.onStepEnd?.(test, result, step);
   }
   printsToStdio() {
-    return this._reporter.printsToStdio ? this._reporter.printsToStdio() : true;
+    return this._reporter.printsToStdio?.() ?? true;
   }
   _addSnippetToTestErrors(test, result) {
     for (const error of result.errors)
@@ -1813,7 +1859,7 @@ function addLocationAndSnippetToError(config2, error, file) {
 }
 
 // packages/playwright/src/runner/testRunner.ts
-var import_util14 = require("../util");
+var import_util15 = require("../util");
 
 // packages/playwright/src/runner/reporters.ts
 var reporters_exports = {};
@@ -2040,7 +2086,7 @@ var OutOfProcessLoaderHost = class {
 };
 
 // packages/playwright/src/runner/loadUtils.ts
-var import_util5 = require("../util");
+var import_util6 = require("../util");
 
 // packages/playwright/src/runner/projectUtils.ts
 var projectUtils_exports = {};
@@ -2054,12 +2100,12 @@ __export(projectUtils_exports, {
 });
 var import_fs2 = __toESM(require("fs"));
 var import_path3 = __toESM(require("path"));
-var import_util3 = require("util");
-var import_util4 = require("../util");
-var minimatch = require("playwright-core/lib/utilsBundle").minimatch;
+var import_util4 = require("util");
+var import_util5 = require("../util");
+var { minimatch } = require("playwright-core/lib/utilsBundle");
 var { escapeRegExp } = require("playwright-core/lib/coreBundle").iso;
-var readFileAsync = (0, import_util3.promisify)(import_fs2.default.readFile);
-var readDirAsync = (0, import_util3.promisify)(import_fs2.default.readdir);
+var readFileAsync = (0, import_util4.promisify)(import_fs2.default.readFile);
+var readDirAsync = (0, import_util4.promisify)(import_fs2.default.readdir);
 function wildcardPatternToRegExp(pattern) {
   return new RegExp("^" + pattern.split("*").map(escapeRegExp).join(".*") + "$", "ig");
 }
@@ -2164,8 +2210,8 @@ async function collectFilesForProject(project, fsCache = /* @__PURE__ */ new Map
   const extensions = /* @__PURE__ */ new Set([".js", ".ts", ".mjs", ".mts", ".cjs", ".cts", ".jsx", ".tsx", ".mjsx", ".mtsx", ".cjsx", ".ctsx"]);
   const testFileExtension = (file) => extensions.has(import_path3.default.extname(file));
   const allFiles = await cachedCollectFiles(project.project.testDir, project.respectGitIgnore, fsCache);
-  const testMatch = (0, import_util4.createFileMatcher)(project.project.testMatch);
-  const testIgnore = (0, import_util4.createFileMatcher)(project.project.testIgnore);
+  const testMatch = (0, import_util5.createFileMatcher)(project.project.testMatch);
+  const testIgnore = (0, import_util5.createFileMatcher)(project.project.testIgnore);
   const testFiles = allFiles.filter((file) => {
     if (!testFileExtension(file))
       return false;
@@ -2247,6 +2293,65 @@ async function collectFiles(testDir, respectGitIgnore) {
   return files;
 }
 
+// packages/playwright/src/runner/reporterTestRun.ts
+var import_common3 = require("../common");
+var ReporterTestRunImpl = class {
+  constructor(_rootSuite, _readonlyProjectSuites) {
+    this._rootSuite = _rootSuite;
+    this._readonlyProjectSuites = _readonlyProjectSuites;
+    this._active = true;
+    this._skipSharding = false;
+    this.skip = import_common3.transform.wrapFunctionWithLocation((location, target, reason) => this._modifier("skip", location, target, reason));
+    this.fixme = import_common3.transform.wrapFunctionWithLocation((location, target, reason) => this._modifier("fixme", location, target, reason));
+    this.fail = import_common3.transform.wrapFunctionWithLocation((location, target, reason) => this._modifier("fail", location, target, reason));
+  }
+  close() {
+    this._active = false;
+  }
+  shouldSkipSharding() {
+    return this._skipSharding;
+  }
+  skipSharding() {
+    if (!this._active)
+      throw new Error(`TestRun.skipSharding() can only be called from Reporter.preprocess().`);
+    if (this._skipSharding)
+      throw new Error(`Multiple reporters called 'skipSharding'. Only one reporter may handle sharding.`);
+    this._skipSharding = true;
+  }
+  exclude(target) {
+    if (!this._active)
+      throw new Error(`TestRun.exclude() can only be called from Reporter.preprocess().`);
+    const internalTarget = target;
+    this._checkTarget("exclude", internalTarget);
+    internalTarget.parent._detach(internalTarget);
+  }
+  _modifier(type, location, _target, reason) {
+    if (!this._active)
+      throw new Error(`TestRun.${type}() can only be called from Reporter.preprocess().`);
+    const target = _target;
+    this._checkTarget(type, target);
+    const annotation = { type, description: reason, location };
+    if (target instanceof import_common3.test.Suite) {
+      for (const test of target.allTests())
+        test._applyPlanAnnotation(annotation);
+    } else {
+      target._applyPlanAnnotation(annotation);
+    }
+  }
+  _checkTarget(method, target) {
+    if (target === this._rootSuite)
+      throw new Error(`TestRun.${method}() cannot be called on the root suite.`);
+    let suite = target instanceof import_common3.test.Suite ? target : target.parent;
+    while (suite) {
+      if (this._readonlyProjectSuites.has(suite)) {
+        const targetType = target instanceof import_common3.test.TestCase ? " test" : "";
+        throw new Error(`TestRun.${method}() cannot be called on a setup or teardown project${targetType}; these always run in full.`);
+      }
+      suite = suite.parent;
+    }
+  }
+};
+
 // packages/playwright/src/runner/testGroups.ts
 function createTestGroups(projectSuite, expectedParallelism) {
   const groups = /* @__PURE__ */ new Map();
@@ -2346,7 +2451,7 @@ function filterForShard(shard, weights, testGroups) {
 }
 
 // packages/playwright/src/runner/loadUtils.ts
-var import_common3 = require("../common");
+var import_common4 = require("../common");
 var sourceMapSupport = require("playwright-core/lib/utilsBundle").sourceMapSupport;
 var { toPosixPath } = require("playwright-core/lib/coreBundle").utils;
 async function collectProjectsAndTestFiles(testRun, doNotRunTestsOutsideProjectFilter) {
@@ -2399,7 +2504,7 @@ async function loadFileSuites(testRun, mode, errors) {
     await loaderHost.stop();
   }
   for (const file of allTestFiles) {
-    for (const dependency of import_common3.cc.dependenciesForTestFile(file)) {
+    for (const dependency of import_common4.cc.dependenciesForTestFile(file)) {
       if (allTestFiles.has(dependency)) {
         const importer = import_path4.default.relative(config2.config.rootDir, file);
         const importee = import_path4.default.relative(config2.config.rootDir, dependency);
@@ -2417,7 +2522,7 @@ async function loadFileSuites(testRun, mode, errors) {
 }
 async function createRootSuite(testRun, errors, shouldFilterOnly) {
   const config2 = testRun.config;
-  const rootSuite = new import_common3.test.Suite("", "root");
+  const rootSuite = new import_common4.test.Suite("", "root");
   const projectSuites = /* @__PURE__ */ new Map();
   const filteredProjectSuites = /* @__PURE__ */ new Map();
   {
@@ -2429,10 +2534,10 @@ async function createRootSuite(testRun, errors, shouldFilterOnly) {
     }
   }
   if (shouldFilterOnly) {
-    const filteredRoot = new import_common3.test.Suite("", "root");
+    const filteredRoot = new import_common4.test.Suite("", "root");
     for (const filteredProjectSuite of filteredProjectSuites.values())
       filteredRoot._addSuite(filteredProjectSuite);
-    import_common3.suiteUtils.filterOnly(filteredRoot);
+    import_common4.suiteUtils.filterOnly(filteredRoot);
     for (const [project, filteredProjectSuite] of filteredProjectSuites) {
       if (!filteredRoot.suites.includes(filteredProjectSuite))
         filteredProjectSuites.delete(project);
@@ -2452,7 +2557,24 @@ async function createRootSuite(testRun, errors, shouldFilterOnly) {
       errors.push(...createForbidOnlyErrors(onlyTestsAndSuites, config2.configCLIOverrides.forbidOnly, configFilePath));
     }
   }
-  if (config2.config.shard) {
+  const dependencySuites = /* @__PURE__ */ new Map();
+  for (const [project, type] of projectClosure) {
+    if (type !== "dependency")
+      continue;
+    const dependencySuite = buildProjectSuite(project, projectSuites.get(project));
+    dependencySuites.set(project, dependencySuite);
+    rootSuite._prependSuite(dependencySuite);
+  }
+  const reporterTestRun = new ReporterTestRunImpl(rootSuite, new Set(dependencySuites.values()));
+  await testRun.reporter.preprocess({
+    config: config2.config,
+    suite: rootSuite,
+    testRun: reporterTestRun
+  });
+  reporterTestRun.close();
+  for (const dependencySuite of dependencySuites.values())
+    rootSuite._detach(dependencySuite);
+  if (config2.config.shard && !reporterTestRun.shouldSkipSharding()) {
     const testGroups = [];
     for (const projectSuite of rootSuite.suites) {
       for (const group of createTestGroups(projectSuite, config2.config.shard.total))
@@ -2464,30 +2586,31 @@ async function createRootSuite(testRun, errors, shouldFilterOnly) {
       for (const test of group.tests)
         testsInThisShard.add(test);
     }
-    import_common3.suiteUtils.filterTestsRemoveEmptySuites(rootSuite, (test) => testsInThisShard.has(test));
+    import_common4.suiteUtils.filterTestsRemoveEmptySuites(rootSuite, (test) => testsInThisShard.has(test));
   }
   if (testRun.postShardTestFilters.length)
-    import_common3.suiteUtils.filterTestsRemoveEmptySuites(rootSuite, (test) => testRun.postShardTestFilters.every((filter) => filter(test)));
+    import_common4.suiteUtils.filterTestsRemoveEmptySuites(rootSuite, (test) => testRun.postShardTestFilters.every((filter) => filter(test)));
   const topLevelProjects = [];
   {
-    const projectClosure2 = new Map(buildProjectsClosure(rootSuite.suites.map((suite) => suite._fullProject)));
-    for (const [project, level] of projectClosure2.entries()) {
-      if (level === "dependency")
-        rootSuite._prependSuite(buildProjectSuite(project, projectSuites.get(project)));
+    const finalProjectClosure = buildProjectsClosure(rootSuite.suites.map((suite) => suite._fullProject));
+    for (const [project, type] of finalProjectClosure) {
+      if (type === "dependency")
+        rootSuite._addSuite(dependencySuites.get(project));
       else
         topLevelProjects.push(project);
     }
   }
+  rootSuite._entries.sort((a, b) => config2.projects.indexOf(a._fullProject) - config2.projects.indexOf(b._fullProject));
   testRun.rootSuite = rootSuite;
   testRun.topLevelProjects = topLevelProjects;
 }
 function createProjectSuite(project, fileSuites) {
-  const projectSuite = new import_common3.test.Suite(project.project.name, "project");
+  const projectSuite = new import_common4.test.Suite(project.project.name, "project");
   for (const fileSuite of fileSuites)
-    projectSuite._addSuite(import_common3.suiteUtils.bindFileSuiteToProject(project, fileSuite));
-  const grepMatcher = (0, import_util5.createTitleMatcher)(project.project.grep);
-  const grepInvertMatcher = project.project.grepInvert ? (0, import_util5.createTitleMatcher)(project.project.grepInvert) : null;
-  import_common3.suiteUtils.filterTestsRemoveEmptySuites(projectSuite, (test) => {
+    projectSuite._addSuite(import_common4.suiteUtils.bindFileSuiteToProject(project, fileSuite));
+  const grepMatcher = (0, import_util6.createTitleMatcher)(project.project.grep);
+  const grepInvertMatcher = project.project.grepInvert ? (0, import_util6.createTitleMatcher)(project.project.grepInvert) : null;
+  import_common4.suiteUtils.filterTestsRemoveEmptySuites(projectSuite, (test) => {
     const grepTitle = test._grepTitleWithTags();
     if (grepInvertMatcher?.(grepTitle))
       return false;
@@ -2499,11 +2622,11 @@ function filterProjectSuite(projectSuite, testFilters) {
   if (!testFilters.length)
     return projectSuite;
   const result = projectSuite._deepClone();
-  import_common3.suiteUtils.filterTestsRemoveEmptySuites(result, (test) => testFilters.every((filter) => filter(test)));
+  import_common4.suiteUtils.filterTestsRemoveEmptySuites(result, (test) => testFilters.every((filter) => filter(test)));
   return result;
 }
 function buildProjectSuite(project, projectSuite) {
-  const result = new import_common3.test.Suite(project.project.name, "project");
+  const result = new import_common4.test.Suite(project.project.name, "project");
   result._fullProject = project;
   if (project.fullyParallel)
     result._parallelMode = "parallel";
@@ -2511,7 +2634,7 @@ function buildProjectSuite(project, projectSuite) {
     result._addSuite(fileSuite);
     for (let repeatEachIndex = 1; repeatEachIndex < project.project.repeatEach; repeatEachIndex++) {
       const clone = fileSuite._deepClone();
-      import_common3.suiteUtils.applyRepeatEachIndex(project, clone, repeatEachIndex);
+      import_common4.suiteUtils.applyRepeatEachIndex(project, clone, repeatEachIndex);
       result._addSuite(clone);
     }
   }
@@ -2554,11 +2677,11 @@ function buildItemLocation(rootDir, testOrSuite) {
   return `${import_path4.default.relative(rootDir, testOrSuite.location.file)}:${testOrSuite.location.line}`;
 }
 async function requireOrImportDefaultFunction(file, expectConstructor) {
-  let func = await import_common3.transform.requireOrImport(file);
+  let func = await import_common4.transform.requireOrImport(file);
   if (func && typeof func === "object" && "default" in func)
     func = func["default"];
   if (typeof func !== "function")
-    throw (0, import_util5.errorWithFile)(file, `file must export a single ${expectConstructor ? "class" : "function"}.`);
+    throw (0, import_util6.errorWithFile)(file, `file must export a single ${expectConstructor ? "class" : "function"}.`);
   return func;
 }
 function loadGlobalHook(config2, file) {
@@ -2597,7 +2720,7 @@ async function loadTestList(config2, filePath) {
         project = tokens[0].substring(1, tokens[0].length - 1);
         tokens.shift();
       }
-      return { project, file: toPosixPath((0, import_util5.parseLocationArg)(tokens[0]).file), titlePath: tokens.slice(1) };
+      return { project, file: toPosixPath((0, import_util6.parseLocationArg)(tokens[0]).file), titlePath: tokens.slice(1) };
     });
     const testFilter = (test) => descriptions.some((d) => {
       const [projectName, , ...titles] = test.titlePath();
@@ -2614,7 +2737,7 @@ async function loadTestList(config2, filePath) {
     };
     return { testFilter, fileFilter };
   } catch (e) {
-    throw (0, import_util5.errorWithFile)(filePath, "Cannot read test list file: " + e.message);
+    throw (0, import_util6.errorWithFile)(filePath, "Cannot read test list file: " + e.message);
   }
 }
 
@@ -2633,7 +2756,7 @@ var TeleReporterEmitter = class {
     this._resultKnownErrorCounts = /* @__PURE__ */ new Map();
     // In case there is blob reporter and UI mode, make sure one doesn't override
     // the id assigned by the other.
-    this._idSymbol = Symbol("id");
+    this._idSymbol = /* @__PURE__ */ Symbol("id");
     this._messageSink = messageSink;
     this._emitterOptions = options;
   }
@@ -3102,14 +3225,17 @@ var empty_default = EmptyReporter;
 
 // packages/playwright/src/reporters/github.ts
 var import_path7 = __toESM(require("path"));
-var import_util6 = require("../util");
+var import_util7 = require("../util");
 var { noColors: noColors2 } = require("playwright-core/lib/coreBundle").iso;
 var { msToString: msToString2 } = require("playwright-core/lib/coreBundle").iso;
 var GitHubLogger = class {
+  newLine() {
+    process.stdout.write("\n");
+  }
   _log(message, type = "notice", options = {}) {
     message = message.replace(/\n/g, "%0A");
     const configs = Object.entries(options).map(([key, option]) => `${key}=${option}`).join(",");
-    process.stdout.write((0, import_util6.stripAnsiEscapes)(`::${type} ${configs}::${message}
+    process.stdout.write((0, import_util7.stripAnsiEscapes)(`::${type} ${configs}::${message}
 `));
   }
   debug(message, options) {
@@ -3142,6 +3268,7 @@ var GitHubReporter = class extends TerminalReporter {
     if (!this._shouldPrintFailureAnnotations(test))
       return;
     this._failedTestCount++;
+    this.githubLogger.newLine();
     for (const r of test.results)
       this._printFailureAnnotation(test, r, this._failedTestCount);
   }
@@ -3218,7 +3345,7 @@ var import_os = __toESM(require("os"));
 var import_path8 = __toESM(require("path"));
 var import_stream3 = require("stream");
 var babel2 = __toESM(require("../transform/babelBundle"));
-var import_util7 = require("../util");
+var import_util8 = require("../util");
 var colors2 = require("playwright-core/lib/utilsBundle").colors;
 var mime2 = require("playwright-core/lib/utilsBundle").mime;
 var open = require("playwright-core/lib/utilsBundle").open;
@@ -3276,7 +3403,7 @@ var HtmlReporter = class {
     this.suite = suite;
   }
   _resolveOptions() {
-    const outputFolder = reportFolderFromEnv() ?? (0, import_util7.resolveReporterOutputPath)("playwright-report", this._options.configDir, this._options.outputFolder);
+    const outputFolder = reportFolderFromEnv() ?? (0, import_util8.resolveReporterOutputPath)("playwright-report", this._options.configDir, this._options.outputFolder);
     return {
       outputFolder,
       open: getHtmlReportOptionProcessEnv() || this._options.open || "on-failure",
@@ -3306,10 +3433,12 @@ var HtmlReporter = class {
     const noSnippets = parseBooleanEnvVar("PLAYWRIGHT_HTML_NO_SNIPPETS") ?? this._options.noSnippets;
     const noCopyPrompt = parseBooleanEnvVar("PLAYWRIGHT_HTML_NO_COPY_PROMPT") ?? this._options.noCopyPrompt;
     const doNotInlineAssets = parseBooleanEnvVar("PLAYWRIGHT_HTML_DO_NOT_INLINE_ASSETS") ?? this._options.doNotInlineAssets ?? false;
+    const mergeFiles = parseBooleanEnvVar("PLAYWRIGHT_HTML_MERGE_FILES") ?? this._options.mergeFiles;
     const builder = new HtmlBuilder(yazl2, this.config, this._outputFolder, this._attachmentsBaseURL, doNotInlineAssets, {
       title: process.env.PLAYWRIGHT_HTML_TITLE || this._options.title,
       noSnippets,
-      noCopyPrompt
+      noCopyPrompt,
+      mergeFiles
     });
     this._buildResult = await builder.build(this.config.metadata, projectSuites, result, this._topLevelErrors, this._machines);
   }
@@ -3356,7 +3485,7 @@ function parseBooleanEnvVar(name) {
   return void 0;
 }
 function standaloneDefaultFolder() {
-  return reportFolderFromEnv() ?? (0, import_util7.resolveReporterOutputPath)("playwright-report", process.cwd(), void 0);
+  return reportFolderFromEnv() ?? (0, import_util8.resolveReporterOutputPath)("playwright-report", process.cwd(), void 0);
 }
 async function resolveReportFolder(reportPath) {
   const stat = await import_fs5.default.promises.stat(reportPath).catch(() => null);
@@ -3621,10 +3750,10 @@ var HtmlBuilder = class {
         this._hasTraces = true;
       if ((a.name === "stdout" || a.name === "stderr") && a.contentType === "text/plain") {
         if (lastAttachment && lastAttachment.name === a.name && lastAttachment.contentType === a.contentType) {
-          lastAttachment.body += (0, import_util7.stripAnsiEscapes)(a.body);
+          lastAttachment.body += (0, import_util8.stripAnsiEscapes)(a.body);
           return null;
         }
-        a.body = (0, import_util7.stripAnsiEscapes)(a.body);
+        a.body = (0, import_util8.stripAnsiEscapes)(a.body);
         lastAttachment = a;
         return a;
       }
@@ -3855,7 +3984,7 @@ function createErrorCodeframe(message, location) {
       highlightCode: false,
       linesAbove: 100,
       linesBelow: 100,
-      message: (0, import_util7.stripAnsiEscapes)(message).split("\n")[0] || void 0
+      message: (0, import_util8.stripAnsiEscapes)(message).split("\n")[0] || void 0
     }
   );
 }
@@ -3867,7 +3996,7 @@ var html_default = HtmlReporter;
 // packages/playwright/src/reporters/json.ts
 var import_fs6 = __toESM(require("fs"));
 var import_path9 = __toESM(require("path"));
-var import_common4 = require("../common");
+var import_common5 = require("../common");
 var { MultiMap: MultiMap2 } = require("playwright-core/lib/coreBundle").iso;
 var { toPosixPath: toPosixPath3 } = require("playwright-core/lib/coreBundle").utils;
 var JSONReporter = class {
@@ -3904,7 +4033,7 @@ var JSONReporter = class {
             repeatEach: project.repeatEach,
             retries: project.retries,
             metadata: project.metadata,
-            id: import_common4.config.getProjectId(project),
+            id: import_common5.config.getProjectId(project),
             name: project.name,
             testDir: toPosixPath3(project.testDir),
             testIgnore: serializePatterns(project.testIgnore),
@@ -3931,7 +4060,7 @@ var JSONReporter = class {
   _mergeSuites(suites) {
     const fileSuites = new MultiMap2();
     for (const projectSuite of suites) {
-      const projectId = import_common4.config.getProjectId(projectSuite.project());
+      const projectId = import_common5.config.getProjectId(projectSuite.project());
       const projectName = projectSuite.project().name;
       for (const fileSuite of projectSuite.suites) {
         const file = fileSuite.location.file;
@@ -4085,7 +4214,7 @@ var json_default = JSONReporter;
 // packages/playwright/src/reporters/junit.ts
 var import_fs7 = __toESM(require("fs"));
 var import_path10 = __toESM(require("path"));
-var import_util8 = require("../util");
+var import_util9 = require("../util");
 var { getAsBooleanFromENV } = require("playwright-core/lib/coreBundle").utils;
 var JUnitReporter = class {
   constructor(options) {
@@ -4251,7 +4380,7 @@ var JUnitReporter = class {
       entry.children.push({
         name: errorInfo.elementName,
         attributes: { message: errorInfo.message, type: errorInfo.type },
-        text: (0, import_util8.stripAnsiEscapes)(formatFailure(nonTerminalScreen, this.config, test))
+        text: (0, import_util9.stripAnsiEscapes)(formatFailure(nonTerminalScreen, this.config, test))
       });
       return errorInfo.elementName;
     }
@@ -4261,7 +4390,7 @@ var JUnitReporter = class {
         message: `${import_path10.default.basename(test.location.file)}:${test.location.line}:${test.location.column} ${test.title}`,
         type: "FAILURE"
       },
-      text: (0, import_util8.stripAnsiEscapes)(formatFailure(nonTerminalScreen, this.config, test))
+      text: (0, import_util9.stripAnsiEscapes)(formatFailure(nonTerminalScreen, this.config, test))
     });
     return "failure";
   }
@@ -4308,7 +4437,7 @@ Warning: attachment ${attachmentPath} is missing`);
       children: []
     };
     const stackTrace = result.error?.stack || result.error?.message || result.error?.value || "";
-    entry.children.push({ name: "stackTrace", text: (0, import_util8.stripAnsiEscapes)(stackTrace) });
+    entry.children.push({ name: "stackTrace", text: (0, import_util9.stripAnsiEscapes)(stackTrace) });
     await this._appendStdIO(entry, [result]);
     return entry;
   }
@@ -4317,7 +4446,7 @@ function classifyResultError(result) {
   const error = result.error;
   if (!error)
     return null;
-  const rawMessage = (0, import_util8.stripAnsiEscapes)(error.message || error.value || "");
+  const rawMessage = (0, import_util9.stripAnsiEscapes)(error.message || error.value || "");
   const nameMatch = rawMessage.match(/^(\w+): /);
   const errorName = nameMatch ? nameMatch[1] : "";
   const messageBody = nameMatch ? rawMessage.slice(nameMatch[0].length) : rawMessage;
@@ -4359,7 +4488,7 @@ function serializeXML(entry, tokens, stripANSIControlSequences) {
 var discouragedXMLCharacters = /[\u0000-\u0008\u000b-\u000c\u000e-\u001f\u007f-\u0084\u0086-\u009f]/g;
 function escape(text, stripANSIControlSequences, isCharacterData) {
   if (stripANSIControlSequences)
-    text = (0, import_util8.stripAnsiEscapes)(text);
+    text = (0, import_util9.stripAnsiEscapes)(text);
   if (isCharacterData) {
     text = "<![CDATA[" + text.replace(/]]>/g, "]]&gt;") + "]]>";
   } else {
@@ -4481,7 +4610,7 @@ var LineReporter = class extends TerminalReporter {
 var line_default = LineReporter;
 
 // packages/playwright/src/reporters/list.ts
-var import_util9 = require("../util");
+var import_util10 = require("../util");
 var { msToString: msToString3 } = require("playwright-core/lib/coreBundle").iso;
 var { getAsBooleanFromENV: getAsBooleanFromENV2 } = require("playwright-core/lib/coreBundle").utils;
 var DOES_NOT_SUPPORT_UTF8_IN_TERMINAL = process.platform === "win32" && process.env.TERM_PROGRAM !== "vscode" && !process.env.WT_SESSION;
@@ -4699,7 +4828,7 @@ var ListReporter = class extends TerminalReporter {
       this.screen.stdout.write(`\x1B[${this._lastRow - row}E`);
   }
   _testPrefix(index, statusMark) {
-    const statusMarkLength = (0, import_util9.stripAnsiEscapes)(statusMark).length;
+    const statusMarkLength = (0, import_util10.stripAnsiEscapes)(statusMark).length;
     const indexLength = Math.ceil(Math.log10(this.totalTestCount + 1));
     return "  " + statusMark + " ".repeat(3 - statusMarkLength) + this.screen.colors.dim(index.padStart(indexLength) + " ");
   }
@@ -4719,7 +4848,7 @@ var ListReporter = class extends TerminalReporter {
     this.epilogue(!this._printFailuresInline);
   }
 };
-var lastStepOrdinalSymbol = Symbol("lastStepOrdinal");
+var lastStepOrdinalSymbol = /* @__PURE__ */ Symbol("lastStepOrdinal");
 var list_default = ListReporter;
 
 // packages/playwright/src/reporters/listModeReporter.ts
@@ -4762,26 +4891,124 @@ var listModeReporter_default = ListModeReporter;
 // packages/playwright/src/reporters/smoothdeploy.ts
 var fs9 = __toESM(require("fs"));
 var path12 = __toESM(require("path"));
+
+// packages/playwright/src/reporters/smoothdeployMatch.ts
+var ACTION_API = {
+  navigate: ["Frame.goto"],
+  click: ["Frame.click", "Frame.dblclick", "Frame.dispatchEvent"],
+  fill: ["Frame.fill"],
+  press: ["Frame.press"],
+  hover: ["Frame.hover"],
+  check: ["Frame.check"],
+  uncheck: ["Frame.uncheck"],
+  select: ["Frame.selectOption"],
+  setInputFiles: ["Frame.setInputFiles", "ElementHandle.setInputFiles"],
+  openPage: ["BrowserContext.newPage"],
+  closePage: ["Page.close"],
+  assertVisible: ["toBeVisible"],
+  assertText: ["toContainText", "toHaveText"],
+  assertValue: ["toHaveValue", "toBeEmpty"],
+  assertChecked: ["toBeChecked", "not.toBeChecked"],
+  assertSnapshot: ["toHaveScreenshot", "toMatchAriaSnapshot"]
+};
+var FILLER_API_NEVER_SKIPS_AHEAD = /* @__PURE__ */ new Set(["Frame.dispatchEvent"]);
+function stepApi(step) {
+  if (step.category === "pw:api")
+    return step.channelMethod ?? null;
+  return normalizeApiName(step.apiName);
+}
+function shortApi(step) {
+  const api = stepApi(step);
+  if (!api)
+    return null;
+  const idx = api.lastIndexOf(".");
+  return step.category === "pw:api" && idx >= 0 ? api.slice(idx + 1) : api;
+}
+function normalizeApiName(apiName) {
+  if (!apiName)
+    return null;
+  if (apiName.startsWith("expect")) {
+    if (apiName.includes(".poll") || apiName.includes(".soft"))
+      return null;
+    const matcher = apiName.slice("expect".length).replace(/^\./, "");
+    return matcher || null;
+  }
+  const idx = apiName.lastIndexOf(".");
+  return idx >= 0 ? apiName.slice(idx + 1) : apiName;
+}
+function apiMatches(step, expected) {
+  const api = stepApi(step);
+  if (!api)
+    return false;
+  const allowed = ACTION_API[expected.action];
+  return !!allowed && allowed.includes(api);
+}
+function groupMatches(step, expected) {
+  if (expected.title !== void 0)
+    return step.title === expected.title;
+  return expected.action === "group";
+}
+function stepMatches(step, expected) {
+  if (step.category === "test.step")
+    return groupMatches(step, expected);
+  if (step.category === "pw:api" || step.category === "expect")
+    return apiMatches(step, expected);
+  return false;
+}
+function matchStep(step, siblings, cursor) {
+  if (cursor < siblings.length && stepMatches(step, siblings[cursor]))
+    return cursor;
+  const api = stepApi(step);
+  const canLookAhead = step.category === "test.step" ? siblings.some((s) => s.title !== void 0) : !!api && !FILLER_API_NEVER_SKIPS_AHEAD.has(api);
+  if (!canLookAhead)
+    return -1;
+  for (let j = cursor + 1; j < siblings.length; j++) {
+    if (stepMatches(step, siblings[j]))
+      return j;
+  }
+  return -1;
+}
+var INTERNAL_STEP_TITLES = /* @__PURE__ */ new Set([
+  "Before Hooks",
+  "After Hooks",
+  "Worker Cleanup",
+  "Launch browser",
+  "Launch persistent context",
+  "Connect over CDP",
+  "Close browser",
+  "Create context",
+  "Close context",
+  "Create page",
+  "Close page",
+  "Create CDP session"
+]);
+function isToPassWrapper(step) {
+  return normalizeApiName(step.apiName) === "toPass";
+}
+function isUserStep(step) {
+  if (step.category === "hook" || step.category === "fixture" || step.category === "test.attach")
+    return false;
+  if (step.title.startsWith('Fixture "'))
+    return false;
+  return !INTERNAL_STEP_TITLES.has(step.title);
+}
+
+// packages/playwright/src/reporters/smoothdeploy.ts
+var NO_SCREENSHOT_PREFIXES = ["Navigate", "Go back", "Go forward", "Reload", "Screenshot", "Wait for", "Pause", "Evaluate"];
+var safeId = (id) => id.replace(/[^a-zA-Z0-9_-]/g, "-");
 var SmoothDeployReporter = class {
   constructor() {
     this._configDir = "";
     this._manifest = null;
-    // Resolved manifest test + paramIndex for each active pw test
     this._resolvedTests = /* @__PURE__ */ new Map();
-    // Map pw TestStep → matched manifest step
-    this._stepToManifest = /* @__PURE__ */ new WeakMap();
-    // Child counter per parent (TestStep for nested, test.id string for root-level)
-    this._childCounters = /* @__PURE__ */ new Map();
-    // Accumulate nested step data per test for output manifest
+    this._matched = /* @__PURE__ */ new WeakMap();
+    this._opaqueFiller = /* @__PURE__ */ new WeakSet();
+    this._retries = /* @__PURE__ */ new WeakMap();
+    this._rootCursors = /* @__PURE__ */ new Map();
     this._testSteps = /* @__PURE__ */ new Map();
-    // Track parent step → output StepData for nesting output
-    this._stepToOutput = /* @__PURE__ */ new WeakMap();
-    // ID remap: pw IDs → manifest IDs (sanitized). Built during execution, applied in onEnd.
     this._testIdMap = /* @__PURE__ */ new Map();
-    // safePwTestId → safeManifestTestId
     this._stepIdMap = /* @__PURE__ */ new Map();
   }
-  // safePwStepId → safeManifestStepId
   version() {
     return "v2";
   }
@@ -4790,44 +5017,36 @@ var SmoothDeployReporter = class {
   }
   onConfigure(config2) {
     this._configDir = config2.configFile ? path12.dirname(config2.configFile) : config2.rootDir;
-    this._loadManifest();
-  }
-  _loadManifest() {
     const manifestPath = path12.join(this._configDir, ".smoothdeploy-manifest.json");
-    if (!fs9.existsSync(manifestPath))
-      throw new Error(`SmoothDeploy reporter requires .smoothdeploy-manifest.json in ${this._configDir}`);
-    const raw = fs9.readFileSync(manifestPath, "utf-8");
-    this._manifest = JSON.parse(raw);
+    if (fs9.existsSync(manifestPath))
+      this._manifest = JSON.parse(fs9.readFileSync(manifestPath, "utf-8"));
   }
-  _emit(event) {
-    process.stdout.write(`[SMOOTHDEPLOY_EVENT]${JSON.stringify(event)}
+  _emit(event, step) {
+    const retry = step && this._nearestRetry(step);
+    if (retry)
+      retry.events.push(event);
+    else
+      process.stdout.write(`[SMOOTHDEPLOY_EVENT]${JSON.stringify(event)}
 `);
   }
-  _isUserStep(step) {
-    const title = step.title;
-    if (title === "Before Hooks" || title === "After Hooks" || title === "Worker Cleanup")
-      return false;
-    if (title.startsWith('Fixture "'))
-      return false;
-    const internalSteps = [
-      "Launch browser",
-      "Launch persistent context",
-      "Connect over CDP",
-      "Close browser",
-      "Create context",
-      "Close context",
-      "Create page",
-      "Close page",
-      "Create CDP session"
-    ];
-    if (internalSteps.includes(title))
-      return false;
-    return true;
+  _nearestRetry(step) {
+    for (let p = step.parent; p; p = p.parent) {
+      const retry = this._retries.get(p);
+      if (retry)
+        return retry;
+    }
+    return void 0;
   }
-  // Resolve a pw TestCase to its manifest test entry + param index.
-  // For parameterized tests: manifest title "Foo" with params=3 matches pw titles "Foo0", "Foo1", "Foo2".
-  // For non-parameterized tests: exact match, paramIndex=0.
   _resolveManifestTest(test) {
+    const manifestTest = this._findManifestTest(test);
+    if (!manifestTest)
+      return { manifestTest: { id: test.id, title: test.title, steps: [] }, paramIndex: 0, passthrough: true };
+    const single = manifestTest.manifestTest.steps.length === 1 ? manifestTest.manifestTest.steps[0] : void 0;
+    if (single && single.action === "script")
+      return { ...manifestTest, passthrough: true, passthroughRootId: single.id };
+    return { ...manifestTest, passthrough: false };
+  }
+  _findManifestTest(test) {
     if (!this._manifest)
       return null;
     const titlePath = test.titlePath();
@@ -4837,7 +5056,6 @@ var SmoothDeployReporter = class {
       return null;
     const fileIdx = titlePath.indexOf(relFile);
     const describeTitles = fileIdx >= 0 ? titlePath.slice(fileIdx + 1, -1) : [];
-    const testTitle = test.title;
     let currentSuites = fileManifest.suites;
     let currentTests = fileManifest.tests;
     for (const desc of describeTitles) {
@@ -4847,15 +5065,13 @@ var SmoothDeployReporter = class {
       currentSuites = suite.suites;
       currentTests = suite.tests;
     }
-    const exactMatch = currentTests.find((t2) => t2.title === testTitle);
+    const exactMatch = currentTests.find((t2) => t2.title === test.title);
     if (exactMatch)
       return { manifestTest: exactMatch, paramIndex: 0 };
     for (const mt of currentTests) {
-      if (!mt.params || mt.params < 1)
-        continue;
-      if (!testTitle.startsWith(mt.title))
+      if (!mt.params || mt.params < 1 || !test.title.startsWith(mt.title))
         continue;
-      const suffix = testTitle.slice(mt.title.length);
+      const suffix = test.title.slice(mt.title.length);
       const idx = parseInt(suffix, 10);
       if (String(idx) === suffix && idx >= 0 && idx < mt.params)
         return { manifestTest: mt, paramIndex: idx };
@@ -4864,13 +5080,9 @@ var SmoothDeployReporter = class {
   }
   onTestBegin(test, result) {
     const resolved = this._resolveManifestTest(test);
-    if (!resolved)
-      return;
     this._resolvedTests.set(test.id, resolved);
-    const safePw = test.id.replace(/[^a-zA-Z0-9_-]/g, "-");
-    const safeManifest = resolved.manifestTest.id.replace(/[^a-zA-Z0-9_-]/g, "-");
-    this._testIdMap.set(safePw, safeManifest);
-    this._childCounters.set(test.id, 0);
+    this._testIdMap.set(safeId(test.id), safeId(resolved.manifestTest.id));
+    this._rootCursors.set(test.id, 0);
     this._testSteps.set(test.id, []);
     this._emit({
       event: "testBegin",
@@ -4879,11 +5091,36 @@ var SmoothDeployReporter = class {
       testTitle: test.title,
       timestamp: Date.now()
     });
+    if (resolved.passthroughRootId) {
+      this._emit({
+        event: "stepBegin",
+        testId: resolved.manifestTest.id,
+        paramIndex: resolved.paramIndex,
+        id: resolved.passthroughRootId,
+        action: "script",
+        title: test.title,
+        category: "test.step",
+        timestamp: Date.now()
+      });
+    }
   }
   onTestEnd(test, result) {
     const resolved = this._resolvedTests.get(test.id);
     if (!resolved)
       return;
+    if (resolved.passthroughRootId) {
+      this._emit({
+        event: "stepEnd",
+        testId: resolved.manifestTest.id,
+        paramIndex: resolved.paramIndex,
+        id: resolved.passthroughRootId,
+        action: "script",
+        title: test.title,
+        duration: result.duration,
+        error: result.error ? { message: result.error.message } : null,
+        timestamp: Date.now()
+      });
+    }
     this._emit({
       event: "testEnd",
       testId: resolved.manifestTest.id,
@@ -4893,29 +5130,77 @@ var SmoothDeployReporter = class {
       duration: result.duration,
       timestamp: Date.now()
     });
-    this._childCounters.delete(test.id);
+    this._rootCursors.delete(test.id);
+  }
+  _nearestMatchedAncestor(step) {
+    for (let p = step.parent; p; p = p.parent) {
+      const matched = this._matched.get(p);
+      if (matched)
+        return { matched, blocked: false };
+      if (this._opaqueFiller.has(p))
+        return { blocked: true };
+    }
+    return { blocked: false };
+  }
+  _resolveStep(test, resolved, step, parent) {
+    const stepLike = { title: step.title, category: step.category, apiName: step._apiName, channelMethod: step._channelMethod };
+    if (resolved.passthrough) {
+      const index2 = parent ? parent.cursor : this._rootCursors.get(test.id) ?? 0;
+      const prefix = parent ? `${parent.manifest.id}:` : resolved.passthroughRootId ? `${resolved.passthroughRootId}:` : "";
+      if (parent)
+        parent.cursor = index2 + 1;
+      else
+        this._rootCursors.set(test.id, index2 + 1);
+      const action = step.category === "test.step" ? "group" : shortApi(stepLike) ?? step.category;
+      return { id: `${prefix}${index2}`, action, title: step.title, children: [] };
+    }
+    if (parent && parent.manifest.children.length === 0)
+      return null;
+    const siblings = parent ? parent.manifest.children : resolved.manifestTest.steps;
+    const cursor = parent ? parent.cursor : this._rootCursors.get(test.id) ?? 0;
+    let index = matchStep(stepLike, siblings, cursor);
+    const retry = this._nearestRetry(step);
+    if (index < 0 && retry && retry.parent === parent && cursor > retry.startCursor) {
+      index = matchStep(stepLike, siblings.slice(0, cursor), retry.startCursor);
+      if (index >= 0)
+        this._discardAttempt(test, retry);
+    }
+    if (index < 0)
+      return null;
+    if (parent)
+      parent.cursor = index + 1;
+    else
+      this._rootCursors.set(test.id, index + 1);
+    return siblings[index];
+  }
+  _discardAttempt(test, retry) {
+    const list = retry.parent ? retry.parent.output.children : this._testSteps.get(test.id);
+    for (const output of retry.outputs) {
+      const i = list ? list.indexOf(output) : -1;
+      if (i >= 0)
+        list.splice(i, 1);
+    }
+    retry.outputs = [];
+    retry.events = [];
   }
   onStepBegin(test, result, step) {
-    if (!this._isUserStep(step))
+    if (!isUserStep(step))
       return;
     const resolved = this._resolvedTests.get(test.id);
     if (!resolved)
       return;
-    let parentStep = step.parent;
-    while (parentStep && !this._stepToOutput.has(parentStep))
-      parentStep = parentStep.parent;
-    const parentKey = parentStep ?? test.id;
-    const parentManifest = parentStep ? this._stepToManifest.get(parentStep) : void 0;
-    const parentSteps = parentManifest ? parentManifest.children : resolved.manifestTest.steps;
-    const idx = this._childCounters.get(parentKey) ?? 0;
-    this._childCounters.set(parentKey, idx + 1);
-    const manifestStep = parentSteps?.[idx] ?? null;
-    if (manifestStep)
-      this._stepToManifest.set(step, manifestStep);
-    this._childCounters.set(step, 0);
-    const outputStep = {
-      id: manifestStep?.id,
-      action: manifestStep?.action,
+    const { matched: parent, blocked } = this._nearestMatchedAncestor(step);
+    const manifestStep = blocked ? null : this._resolveStep(test, resolved, step, parent);
+    if (!manifestStep) {
+      if (blocked || !isToPassWrapper({ title: step.title, category: step.category, apiName: step._apiName }))
+        this._opaqueFiller.add(step);
+      else
+        this._retries.set(step, { parent, startCursor: parent ? parent.cursor : this._rootCursors.get(test.id) ?? 0, events: [], outputs: [] });
+      return;
+    }
+    const output = {
+      id: manifestStep.id,
+      action: manifestStep.action,
       title: step.title,
       category: step.category,
       duration: 0,
@@ -4923,97 +5208,106 @@ var SmoothDeployReporter = class {
       screenshots: null,
       children: []
     };
-    this._stepToOutput.set(step, outputStep);
-    const parentOutput = parentStep ? this._stepToOutput.get(parentStep) : void 0;
-    if (parentOutput)
-      parentOutput.children.push(outputStep);
+    this._matched.set(step, { manifest: manifestStep, output, cursor: 0 });
+    const retry = this._nearestRetry(step);
+    if (retry && retry.parent === parent)
+      retry.outputs.push(output);
+    if (parent)
+      parent.output.children.push(output);
     else
-      this._testSteps.get(test.id)?.push(outputStep);
+      this._testSteps.get(test.id)?.push(output);
     this._emit({
       event: "stepBegin",
       testId: resolved.manifestTest.id,
       paramIndex: resolved.paramIndex,
-      id: manifestStep?.id,
-      action: manifestStep?.action,
+      id: manifestStep.id,
+      action: manifestStep.action,
       title: step.title,
       category: step.category,
       timestamp: Date.now()
-    });
+    }, step);
+  }
+  _screenshotsFor(test, step) {
+    const hasScreenshot = step.category === "pw:api" && !NO_SCREENSHOT_PREFIXES.some((prefix) => step.title.startsWith(prefix));
+    if (!hasScreenshot)
+      return null;
+    const safeStepId = safeId(step._stepId ?? step.title);
+    return {
+      safeStepId,
+      paths: {
+        page: `.smoothdeploy-output/screenshots/${safeId(test.id)}/${safeStepId}-page.png`,
+        element: `.smoothdeploy-output/screenshots/${safeId(test.id)}/${safeStepId}-element.png`
+      }
+    };
   }
   onStepEnd(test, result, step) {
-    if (!this._isUserStep(step))
+    if (!isUserStep(step))
       return;
     const resolved = this._resolvedTests.get(test.id);
     if (!resolved)
       return;
-    const manifestStep = this._stepToManifest.get(step) ?? null;
-    const outputStep = this._stepToOutput.get(step);
-    const safeTestId = test.id.replace(/[^a-zA-Z0-9_-]/g, "-");
-    const noScreenshotPrefixes = [
-      "Navigate",
-      "Go back",
-      "Go forward",
-      "Reload",
-      "Screenshot",
-      "Wait for",
-      "Pause",
-      "Evaluate"
-    ];
-    const hasScreenshot = step.category === "pw:api" && !noScreenshotPrefixes.some((prefix) => step.title.startsWith(prefix));
-    const internalStepId = step._stepId ?? step.title;
-    const safeStepId = internalStepId.replace(/[^a-zA-Z0-9_-]/g, "-");
-    const screenshots = hasScreenshot ? {
-      page: `.smoothdeploy-output/screenshots/${safeTestId}/${safeStepId}-page.png`,
-      element: `.smoothdeploy-output/screenshots/${safeTestId}/${safeStepId}-element.png`
-    } : null;
-    if (manifestStep) {
-      const safeManifestStepId = manifestStep.id.replace(/[^a-zA-Z0-9_-]/g, "-");
-      this._stepIdMap.set(safeStepId, safeManifestStepId);
-    }
-    if (outputStep) {
-      outputStep.duration = step.duration;
-      const hasDescendantError = (steps) => steps.some((c) => c.error !== null || hasDescendantError(c.children));
-      outputStep.error = step.error && !hasDescendantError(outputStep.children) ? { message: step.error.message ?? "" } : null;
-      outputStep.screenshots = screenshots;
-    }
-    this._childCounters.delete(step);
+    const retry = this._retries.get(step);
+    if (retry) {
+      this._retries.delete(step);
+      for (const event of retry.events)
+        this._emit(event, step);
+      return;
+    }
+    const matched = this._matched.get(step);
+    const screenshots = this._screenshotsFor(test, step);
+    if (!matched) {
+      const leaf = this._nearestMatchedAncestor(step).matched;
+      if (screenshots && leaf && leaf.manifest.children.length === 0 && !leaf.output.screenshots) {
+        this._stepIdMap.set(screenshots.safeStepId, safeId(leaf.manifest.id));
+        leaf.output.screenshots = screenshots.paths;
+      }
+      return;
+    }
+    if (screenshots) {
+      this._stepIdMap.set(screenshots.safeStepId, safeId(matched.manifest.id));
+      matched.output.screenshots = screenshots.paths;
+    }
+    matched.output.duration = step.duration;
+    const skipped = step.annotations.some((a) => a.type === "skip");
+    if (skipped)
+      matched.output.skipped = true;
+    const hasDescendantError = (steps) => steps.some((c) => c.error !== null || hasDescendantError(c.children));
+    matched.output.error = step.error && !hasDescendantError(matched.output.children) ? { message: step.error.message ?? "" } : null;
     this._emit({
       event: "stepEnd",
       testId: resolved.manifestTest.id,
       paramIndex: resolved.paramIndex,
-      id: manifestStep?.id,
-      action: manifestStep?.action,
+      id: matched.manifest.id,
+      action: matched.manifest.action,
       title: step.title,
       duration: step.duration,
       error: step.error ? { message: step.error.message } : null,
+      skipped,
       timestamp: Date.now()
-    });
+    }, step);
   }
   onEnd(result) {
     const outputDir = path12.join(process.cwd(), ".smoothdeploy-output");
     const screenshotsDir = path12.join(outputDir, "screenshots");
-    if (this._manifest) {
-      for (const [safePwTestId] of this._testIdMap) {
-        const testDir = path12.join(screenshotsDir, safePwTestId);
-        if (!fs9.existsSync(testDir))
-          continue;
-        for (const [safePwStepId, safeManifestStepId] of this._stepIdMap) {
-          for (const suffix of ["-page.png", "-element.png"]) {
-            const src = path12.join(testDir, `${safePwStepId}${suffix}`);
-            const dst = path12.join(testDir, `${safeManifestStepId}${suffix}`);
-            if (fs9.existsSync(src))
-              fs9.renameSync(src, dst);
-          }
+    for (const [safePwTestId] of this._testIdMap) {
+      const testDir = path12.join(screenshotsDir, safePwTestId);
+      if (!fs9.existsSync(testDir))
+        continue;
+      for (const [safePwStepId, safeManifestStepId] of this._stepIdMap) {
+        for (const suffix of ["-page.png", "-element.png"]) {
+          const src = path12.join(testDir, `${safePwStepId}${suffix}`);
+          if (fs9.existsSync(src))
+            fs9.renameSync(src, path12.join(testDir, `${safeManifestStepId}${suffix}`));
         }
       }
-      for (const [safePwTestId, safeManifestTestId] of this._testIdMap) {
-        const src = path12.join(screenshotsDir, safePwTestId);
-        const dst = path12.join(screenshotsDir, safeManifestTestId);
-        if (fs9.existsSync(src)) {
-          if (fs9.existsSync(dst))
-            fs9.rmSync(dst, { recursive: true });
-          fs9.renameSync(src, dst);
-        }
+    }
+    for (const [safePwTestId, safeManifestTestId] of this._testIdMap) {
+      const src = path12.join(screenshotsDir, safePwTestId);
+      const dst = path12.join(screenshotsDir, safeManifestTestId);
+      if (src !== dst && fs9.existsSync(src)) {
+        if (fs9.existsSync(dst))
+          fs9.rmSync(dst, { recursive: true });
+        fs9.renameSync(src, dst);
       }
     }
     const remapScreenshotPaths = (steps) => {
@@ -5031,7 +5325,7 @@ var SmoothDeployReporter = class {
       if (!resolved)
         continue;
       remapScreenshotPaths(steps);
-      const safeManifestTestId = resolved.manifestTest.id.replace(/[^a-zA-Z0-9_-]/g, "-");
+      const safeManifestTestId = safeId(resolved.manifestTest.id);
       const failurePath = path12.join(screenshotsDir, safeManifestTestId, "failure.png");
       const failureScreenshot = fs9.existsSync(failurePath) ? `.smoothdeploy-output/screenshots/${safeManifestTestId}/failure.png` : null;
       const key = resolved.manifestTest.id;
@@ -5040,15 +5334,8 @@ var SmoothDeployReporter = class {
       manifest[key].push({ paramIndex: resolved.paramIndex, steps, failureScreenshot });
     }
     fs9.mkdirSync(outputDir, { recursive: true });
-    fs9.writeFileSync(
-      path12.join(outputDir, "manifest.json"),
-      JSON.stringify(manifest, null, 2)
-    );
-    this._emit({
-      event: "runEnd",
-      status: result.status,
-      timestamp: Date.now()
-    });
+    fs9.writeFileSync(path12.join(outputDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+    this._emit({ event: "runEnd", status: result.status, timestamp: Date.now() });
   }
   _remapPath(screenshotPath) {
     let result = screenshotPath;
@@ -5154,7 +5441,7 @@ function computeCommandHash(config2, runOptions) {
 // packages/playwright/src/runner/tasks.ts
 var import_fs11 = __toESM(require("fs"));
 var import_path15 = __toESM(require("path"));
-var import_util12 = require("util");
+var import_util13 = require("util");
 
 // packages/playwright/src/runner/rebase.ts
 var import_fs9 = __toESM(require("fs"));
@@ -5308,7 +5595,7 @@ function applyPatchWithConflictMarkers(oldText, newText) {
 // packages/playwright/src/runner/workerHost.ts
 var import_fs10 = __toESM(require("fs"));
 var import_path13 = __toESM(require("path"));
-var import_common5 = require("../common");
+var import_common6 = require("../common");
 
 // packages/playwright/src/isomorphic/folders.ts
 function artifactsFolderName(workerIndex) {
@@ -5344,8 +5631,8 @@ var WorkerHost = class extends ProcessHost {
   async start() {
     await import_fs10.default.promises.mkdir(this._params.artifactsDir, { recursive: true });
     return await this.startRunner(this._params, {
-      onStdOut: (chunk) => this.emit("stdOut", import_common5.ipc.stdioChunkToParams(chunk)),
-      onStdErr: (chunk) => this.emit("stdErr", import_common5.ipc.stdioChunkToParams(chunk))
+      onStdOut: (chunk) => this.emit("stdOut", import_common6.ipc.stdioChunkToParams(chunk)),
+      onStdErr: (chunk) => this.emit("stdErr", import_common6.ipc.stdioChunkToParams(chunk))
     });
   }
   async onExit() {
@@ -5377,16 +5664,17 @@ var WorkerHost = class extends ProcessHost {
 };
 
 // packages/playwright/src/runner/dispatcher.ts
-var import_common6 = require("../common");
-var import_util10 = require("../util");
+var import_common7 = require("../common");
+var import_util11 = require("../util");
 var colors4 = require("playwright-core/lib/utilsBundle").colors;
 var { ManualPromise: ManualPromise3 } = require("playwright-core/lib/coreBundle").iso;
 var { eventsHelper } = require("playwright-core/lib/coreBundle").utils;
 var Dispatcher = class {
-  constructor(testRun) {
+  constructor(testRun, options = {}) {
     // Worker slot is claimed when it has jobDispatcher assigned.
     this._workerSlots = [];
     this._queue = [];
+    this._isolatedJobs = /* @__PURE__ */ new Set();
     this._workerLimitPerProjectId = /* @__PURE__ */ new Map();
     this._queuedOrRunningHashCount = /* @__PURE__ */ new Map();
     this._finished = new ManualPromise3();
@@ -5394,6 +5682,7 @@ var Dispatcher = class {
     this._extraEnvByProjectId = /* @__PURE__ */ new Map();
     this._producedEnvByProjectId = /* @__PURE__ */ new Map();
     this._testRun = testRun;
+    this._ignoreMaxFailures = !!options.ignoreMaxFailures;
     for (const project of testRun.config.projects) {
       if (project.workers)
         this._workerLimitPerProjectId.set(project.id, project.workers);
@@ -5402,6 +5691,8 @@ var Dispatcher = class {
   _findFirstJobToRun() {
     for (let index = 0; index < this._queue.length; index++) {
       const job = this._queue[index];
+      if (this._isolatedJobs.has(job) && this._workerSlots.some((w) => !!w.jobDispatcher))
+        continue;
       const projectIdWorkerLimit = this._workerLimitPerProjectId.get(job.projectId);
       if (!projectIdWorkerLimit)
         return index;
@@ -5425,7 +5716,7 @@ var Dispatcher = class {
       return;
     }
     this._queue.splice(jobIndex, 1);
-    const jobDispatcher = new JobDispatcher(job, this._testRun, () => this.stop().catch(() => {
+    const jobDispatcher = new JobDispatcher(job, this._testRun, this._ignoreMaxFailures ? void 0 : () => this.stop().catch(() => {
     }));
     this._workerSlots[workerIndex].jobDispatcher = jobDispatcher;
     void this._runJobInWorker(workerIndex, jobDispatcher).then(() => {
@@ -5447,7 +5738,7 @@ var Dispatcher = class {
     }
     let startError;
     if (!worker) {
-      worker = this._createWorker(job, index, import_common6.ipc.serializeConfig(this._testRun.config, true));
+      worker = this._createWorker(job, index, import_common7.ipc.serializeConfig(this._testRun.config, true));
       this._workerSlots[index].worker = worker;
       worker.on("exit", () => this._workerSlots[index].worker = void 0);
       startError = await worker.start();
@@ -5467,9 +5758,16 @@ var Dispatcher = class {
       );
     else if (this._isWorkerRedundant(worker))
       void worker.stop();
-    if (!this._isStopped && result.newJob) {
-      this._queue.unshift(result.newJob);
-      this._updateCounterForWorkerHash(result.newJob.workerHash, 1);
+    if (!this._isStopped) {
+      if (result.remainingJob) {
+        this._queue.unshift(result.remainingJob);
+        this._updateCounterForWorkerHash(result.remainingJob.workerHash, 1);
+      }
+      if (result.isolatedRetriesJob) {
+        this._isolatedJobs.add(result.isolatedRetriesJob);
+        this._queue.push(result.isolatedRetriesJob);
+        this._updateCounterForWorkerHash(result.isolatedRetriesJob.workerHash, 1);
+      }
     }
   }
   _checkFinished() {
@@ -5499,7 +5797,7 @@ var Dispatcher = class {
       this._updateCounterForWorkerHash(group.workerHash, 1);
     this._isStopped = false;
     this._workerSlots = [];
-    if (this._testRun.hasReachedMaxFailures())
+    if (!this._ignoreMaxFailures && this._testRun.hasReachedMaxFailures())
       void this.stop();
     for (let i = 0; i < this._testRun.config.config.workers; i++)
       this._workerSlots.push({});
@@ -5572,7 +5870,7 @@ var Dispatcher = class {
   }
 };
 var JobDispatcher = class {
-  constructor(job, testRun, stopCallback) {
+  constructor(job, testRun, onMaxFailuresReached) {
     this.jobResult = new ManualPromise3();
     this._listeners = [];
     this._failedTests = /* @__PURE__ */ new Set();
@@ -5583,9 +5881,12 @@ var JobDispatcher = class {
     this._workerIndex = 0;
     this.job = job;
     this._testRun = testRun;
-    this._stopCallback = stopCallback;
+    this._onMaxFailuresReached = onMaxFailuresReached;
     this._remainingByTestId = new Map(this.job.tests.map((e) => [e.id, e]));
   }
+  _isStoppedByMaxFailures() {
+    return !!this._onMaxFailuresReached && this._testRun.hasReachedMaxFailures();
+  }
   _onTestBegin(params) {
     const test = this._remainingByTestId.get(params.testId);
     if (!test) {
@@ -5600,7 +5901,7 @@ var JobDispatcher = class {
     this._currentlyRunning = { test, result };
   }
   _onTestEnd(params) {
-    if (this._testRun.hasReachedMaxFailures()) {
+    if (this._isStoppedByMaxFailures()) {
       params.status = "interrupted";
       params.errors = [];
     }
@@ -5655,7 +5956,9 @@ var JobDispatcher = class {
       attachments: [],
       annotations: [],
       location: params.location,
-      _stepId: params.stepId
+      _stepId: params.stepId,
+      _apiName: params.apiName,
+      _channelMethod: params.channelMethod
     };
     steps.set(params.stepId, step);
     (parentStep || result).steps.push(step);
@@ -5720,7 +6023,7 @@ var JobDispatcher = class {
     for (const test of this._remainingByTestId.values()) {
       if (!testIds.has(test.id))
         continue;
-      if (!this._testRun.hasReachedMaxFailures()) {
+      if (!this._isStoppedByMaxFailures()) {
         this._failTestWithErrors(test, errors);
         errors = [];
       }
@@ -5779,12 +6082,18 @@ var JobDispatcher = class {
       serialSuite.allTests().forEach((test) => retryCandidates.add(test));
     }
     const remaining = [...this._remainingByTestId.values()];
+    const isolatedRetries = [];
     for (const test of retryCandidates) {
-      if (test.results.length < test.retries + 1)
-        remaining.push(test);
+      if (test.results.length < test.retries + 1) {
+        if (this._testRun.config.retryStrategy === "immediate")
+          remaining.push(test);
+        else
+          isolatedRetries.push(test);
+      }
     }
-    const newJob = remaining.length ? { ...this.job, tests: remaining } : void 0;
-    this._finished({ didFail: true, newJob });
+    const remainingJob = remaining.length ? { ...this.job, tests: remaining } : void 0;
+    const isolatedRetriesJob = isolatedRetries.length ? { ...this.job, tests: isolatedRetries } : void 0;
+    this._finished({ didFail: true, remainingJob, isolatedRetriesJob });
   }
   onExit(data) {
     const unexpectedExitError = data.unexpectedly ? {
@@ -5802,7 +6111,7 @@ var JobDispatcher = class {
     const runPayload = {
       file: this.job.requireFile,
       entries: this.job.tests.map((test) => {
-        return { testId: test.id, retry: test.results.length };
+        return { testId: test.id, retry: test.results.length, planAnnotations: test._planAnnotations };
       })
     };
     worker.runTestGroup(runPayload);
@@ -5831,7 +6140,7 @@ var JobDispatcher = class {
           addLocationAndSnippetToError(this._testRun.config.config, response.error);
         return response;
       } catch (e) {
-        const error = (0, import_util10.serializeError)(e);
+        const error = (0, import_util11.serializeError)(e);
         addLocationAndSnippetToError(this._testRun.config.config, error);
         return { response: void 0, error };
       }
@@ -5846,7 +6155,7 @@ var JobDispatcher = class {
   }
   skipWholeJob() {
     const allTestsSkipped = this.job.tests.every((test) => test.expectedStatus === "skipped");
-    if (allTestsSkipped && !this._testRun.hasReachedMaxFailures()) {
+    if (allTestsSkipped && !this._isStoppedByMaxFailures()) {
       for (const test of this.job.tests) {
         const result = test._appendTestResult();
         this._testRun.reporter.onTestBegin?.(test, result);
@@ -5863,11 +6172,11 @@ var JobDispatcher = class {
   }
   _reportTestEnd(test, result) {
     this._testRun.reporter.onTestEnd?.(test, result);
-    const hadMaxFailures = this._testRun.hasReachedMaxFailures();
+    const hadMaxFailures = this._isStoppedByMaxFailures();
     if (test.outcome() === "unexpected" && test.results.length > test.retries)
       ++this._testRun.failedTestCount;
-    if (!hadMaxFailures && this._testRun.hasReachedMaxFailures()) {
-      this._stopCallback();
+    if (!hadMaxFailures && this._isStoppedByMaxFailures()) {
+      this._onMaxFailuresReached?.();
       this._testRun.reporter.onError?.({ message: colors4.red(`Testing stopped early after ${this._testRun.config.config.maxFailures} maximum allowed failures.`) });
     }
   }
@@ -5950,7 +6259,7 @@ var FixedNodeSIGINTHandler = class {
 };
 
 // packages/playwright/src/runner/taskRunner.ts
-var import_util11 = require("../util");
+var import_util12 = require("../util");
 var colors5 = require("playwright-core/lib/utilsBundle").colors;
 var debug4 = require("playwright-core/lib/utilsBundle").debug;
 var { ManualPromise: ManualPromise4 } = require("playwright-core/lib/coreBundle").iso;
@@ -5991,7 +6300,7 @@ var TaskRunner = class _TaskRunner {
           await task.setup?.(context, errors, softErrors);
         } catch (e) {
           debug4("pw:test:task")(`error in "${task.title}": `, e);
-          errors.push((0, import_util11.serializeError)(e));
+          errors.push((0, import_util12.serializeError)(e));
         } finally {
           for (const error of [...softErrors, ...errors])
             this._reporter.onError?.(error);
@@ -6054,7 +6363,7 @@ var TimeoutWatcher = class {
 // packages/playwright/src/runner/vcs.ts
 var import_child_process2 = __toESM(require("child_process"));
 var import_path14 = __toESM(require("path"));
-var import_common7 = require("../common");
+var import_common8 = require("../common");
 async function detectChangedTestFiles(baseCommit, configDir) {
   function gitFileList(args) {
     try {
@@ -6086,17 +6395,17 @@ async function detectChangedTestFiles(baseCommit, configDir) {
   const untrackedFiles = gitFileList(["ls-files", "--others", "--exclude-standard"]).map((file) => import_path14.default.join(configDir, file));
   const [gitRoot] = gitFileList(["rev-parse", "--show-toplevel"]);
   const trackedFilesWithChanges = gitFileList(["diff", baseCommit, "--name-only"]).map((file) => import_path14.default.join(gitRoot, file));
-  return new Set(import_common7.cc.affectedTestFiles([...untrackedFiles, ...trackedFilesWithChanges]));
+  return new Set(import_common8.cc.affectedTestFiles([...untrackedFiles, ...trackedFilesWithChanges]));
 }
 
 // packages/playwright/src/runner/tasks.ts
-var import_common8 = require("../common");
-var import_util13 = require("../util");
+var import_common9 = require("../common");
+var import_util14 = require("../util");
 var debug5 = require("playwright-core/lib/utilsBundle").debug;
 var { ManualPromise: ManualPromise5 } = require("playwright-core/lib/coreBundle").iso;
 var { monotonicTime: monotonicTime6 } = require("playwright-core/lib/coreBundle").iso;
 var { removeFolders: removeFolders4 } = require("playwright-core/lib/coreBundle").utils;
-var readDirAsync2 = (0, import_util12.promisify)(import_fs11.default.readdir);
+var readDirAsync2 = (0, import_util13.promisify)(import_fs11.default.readdir);
 var TestRun = class {
   constructor(config2, reporter, options) {
     this.rootSuite = void 0;
@@ -6124,7 +6433,7 @@ var TestRun = class {
   result() {
     const hasFailedTests = this.rootSuite?.allTests().some((test) => !test.ok());
     const hasFlakyTests = this.rootSuite?.allTests().some((test) => test.outcome() === "flaky");
-    return this.hasWorkerErrors || this.hasReachedMaxFailures() || hasFailedTests || this.config.config.failOnFlakyTests && hasFlakyTests ? "failed" : "passed";
+    return this.hasWorkerErrors || this.reporter.hasReporterErrors() || this.hasReachedMaxFailures() || hasFailedTests || this.config.config.failOnFlakyTests && hasFlakyTests ? "failed" : "passed";
   }
 };
 async function runTasks(testRun, tasks, globalTimeout, cancelPromise) {
@@ -6151,6 +6460,8 @@ async function finishTaskRun(testRun, status) {
   if (modifiedResult && modifiedResult.status)
     status = modifiedResult.status;
   await testRun.reporter.onExit();
+  if (status === "passed" && testRun.reporter.hasReporterErrors())
+    status = "failed";
   return status;
 }
 function createGlobalSetupTasks(config2) {
@@ -6173,7 +6484,7 @@ function createClearCacheTask(config2) {
   return {
     title: "clear cache",
     setup: async () => {
-      await (0, import_util13.removeDirAndLogToConsole)(import_common8.cc.cacheDir);
+      await (0, import_util14.removeDirAndLogToConsole)(import_common9.cc.cacheDir);
       for (const plugin of config2.plugins)
         await plugin.instance?.clearCache?.();
     }
@@ -6272,12 +6583,12 @@ function createListFilesTask() {
       await createRootSuite(testRun, errors, false);
       await collectProjectsAndTestFiles(testRun, false);
       for (const [project, files] of testRun.projectFiles) {
-        const projectSuite = new import_common8.test.Suite(project.project.name, "project");
+        const projectSuite = new import_common9.test.Suite(project.project.name, "project");
         projectSuite._fullProject = project;
         testRun.rootSuite._addSuite(projectSuite);
         const suites = files.map((file) => {
           const title = import_path15.default.relative(testRun.config.config.rootDir, file);
-          const suite = new import_common8.test.Suite(title, "file");
+          const suite = new import_common9.test.Suite(title, "file");
           suite.location = { file, line: 0, column: 0 };
           projectSuite._addSuite(suite);
           return suite;
@@ -6292,7 +6603,7 @@ function createLoadTask(mode, options) {
     title: "load tests",
     setup: async (testRun, errors, softErrors) => {
       if (testRun.options.locations?.length) {
-        const { testFilter, fileFilter } = import_common8.suiteUtils.createFiltersFromArguments(testRun.options.locations);
+        const { testFilter, fileFilter } = import_common9.suiteUtils.createFiltersFromArguments(testRun.options.locations);
         testRun.loadFileFilters.push(fileFilter);
         testRun.preOnlyTestFilters.push(testFilter);
       }
@@ -6306,14 +6617,14 @@ function createLoadTask(mode, options) {
         testRun.preOnlyTestFilters.push((test) => !testFilter(test));
       }
       if (testRun.options.grep || testRun.options.grepInvert) {
-        const grepMatcher = testRun.options.grep ? (0, import_util13.createTitleMatcher)((0, import_util13.forceRegExp)(testRun.options.grep)) : () => true;
-        const grepInvertMatcher = testRun.options.grepInvert ? (0, import_util13.createTitleMatcher)((0, import_util13.forceRegExp)(testRun.options.grepInvert)) : () => false;
+        const grepMatcher = testRun.options.grep ? (0, import_util14.createTitleMatcher)((0, import_util14.forceRegExp)(testRun.options.grep)) : () => true;
+        const grepInvertMatcher = testRun.options.grepInvert ? (0, import_util14.createTitleMatcher)((0, import_util14.forceRegExp)(testRun.options.grepInvert)) : () => false;
         testRun.preOnlyTestFilters.push((test) => {
           const grepTitle = test._grepTitleWithTags();
           return !grepInvertMatcher(grepTitle) && grepMatcher(grepTitle);
         });
       }
-      if (testRun.options.lastFailedTestIds?.length) {
+      if (testRun.options.lastFailedTestIds) {
         const failedTestIds = new Set(testRun.options.lastFailedTestIds);
         testRun.postShardTestFilters.push((test) => failedTestIds.has(test.id));
       }
@@ -6361,6 +6672,7 @@ function createPhasesTask() {
       const projectToSuite = new Map(testRun.rootSuite.suites.map((suite) => [suite._fullProject, suite]));
       const allProjects = [...projectToSuite.keys()];
       const teardownToSetups = buildTeardownToSetupsMap(allProjects);
+      const ignoreMaxFailuresProjectIds = new Set(testRun.config.config.maxFailures > 0 ? [...teardownToSetups.keys()].map((project) => project.id) : []);
       const teardownToSetupsDependents = /* @__PURE__ */ new Map();
       for (const [teardown, setups] of teardownToSetups) {
         const closure = buildDependentProjects(setups, allProjects);
@@ -6379,11 +6691,14 @@ function createPhasesTask() {
         }
         for (const project of phaseProjects)
           processed.add(project);
-        if (phaseProjects.length) {
+        for (const ignoreMaxFailures of [false, true]) {
+          const projects = phaseProjects.filter((project) => ignoreMaxFailuresProjectIds.has(project.id) === ignoreMaxFailures);
+          if (!projects.length)
+            continue;
           let testGroupsInPhase = 0;
-          const phase = { dispatcher: new Dispatcher(testRun), projects: [] };
+          const phase = { dispatcher: new Dispatcher(testRun, { ignoreMaxFailures }), projects: [] };
           testRun.phases.push(phase);
-          for (const project of phaseProjects) {
+          for (const project of projects) {
             const projectSuite = projectToSuite.get(project);
             const testGroups = createTestGroups(projectSuite, testRun.config.config.workers);
             phase.projects.push({ project, projectSuite, testGroups });
@@ -6458,12 +6773,12 @@ var LastRunReporter = class {
   }
   async filterLastFailed() {
     if (!this._lastRunFile)
-      return [];
+      return void 0;
     try {
       const lastRunInfo = JSON.parse(await import_fs12.default.promises.readFile(this._lastRunFile, "utf8"));
       return lastRunInfo.failedTests;
     } catch {
-      return [];
+      return void 0;
     }
   }
   version() {
@@ -6509,7 +6824,7 @@ var TestRunner = class extends import_events2.default {
     this._configCLIOverrides = configCLIOverrides;
     this._watcher = new FSWatcher((events) => {
       const collector = /* @__PURE__ */ new Set();
-      events.forEach((f) => import_common9.cc.collectAffectedTestFiles(f.file, collector));
+      events.forEach((f) => import_common10.cc.collectAffectedTestFiles(f.file, collector));
       this.emit(TestRunnerEvent.TestFilesChanged, [...collector]);
     });
   }
@@ -6719,7 +7034,7 @@ var TestRunner = class extends import_events2.default {
     this._watchedTestDependencies = /* @__PURE__ */ new Set();
     for (const fileName of fileNames) {
       this._watchedTestDependencies.add(fileName);
-      import_common9.cc.dependenciesForTestFile(fileName).forEach((file) => this._watchedTestDependencies.add(file));
+      import_common10.cc.dependenciesForTestFile(fileName).forEach((file) => this._watchedTestDependencies.add(file));
     }
     await this._updateWatcher(true);
   }
@@ -6735,7 +7050,7 @@ var TestRunner = class extends import_events2.default {
     ]);
     if (status !== "passed")
       return { errors: errorReporter.errors(), testFiles: [] };
-    return { testFiles: import_common9.cc.affectedTestFiles(files) };
+    return { testFiles: import_common10.cc.affectedTestFiles(files) };
   }
   async stopTests() {
     this._testRun?.stop?.resolve();
@@ -6749,7 +7064,7 @@ var TestRunner = class extends import_events2.default {
   }
   async _loadConfig(overrides) {
     try {
-      const config2 = await import_common9.configLoader.loadConfig(this.configLocation, overrides);
+      const config2 = await import_common10.configLoader.loadConfig(this.configLocation, overrides);
       if (!this._plugins) {
         webServerPluginsForConfig(config2).forEach((p) => config2.plugins.push({ factory: p }));
         addGitCommitInfoPlugin(config2);
@@ -6760,7 +7075,7 @@ var TestRunner = class extends import_events2.default {
       this._lastLoadedConfig = config2;
       return { config: config2 };
     } catch (e) {
-      return { config: null, error: (0, import_util14.serializeError)(e) };
+      return { config: null, error: (0, import_util15.serializeError)(e) };
     }
   }
   lastLoadedConfig() {
@@ -6801,7 +7116,7 @@ async function runAllTestsWithConfig(config2, options) {
   const lastRun = new LastRunReporter(filteredProjects, options.listMode, options.lastFailedFile);
   if (options.lastFailed) {
     const lastFailedTestIds = await lastRun.filterLastFailed();
-    if (lastFailedTestIds.length)
+    if (lastFailedTestIds)
       options = { ...options, lastFailedTestIds };
   }
   const reporter = new InternalReporter([...reporters, lastRun]);
@@ -6828,9 +7143,9 @@ __export(testServer_exports, {
   runTestServer: () => runTestServer,
   runUIMode: () => runUIMode
 });
-var import_util15 = __toESM(require("util"));
+var import_util16 = __toESM(require("util"));
 var import_coreBundle3 = require("playwright-core/lib/coreBundle");
-var import_common10 = require("../common");
+var import_common11 = require("../common");
 
 // packages/playwright/src/runner/uiModeReporter.ts
 var UIModeReporter = class extends TeleReporterEmitter {
@@ -6988,7 +7303,7 @@ var TestServerDispatcher = class {
     if (interceptStdio) {
       if (debug6.log === originalDebugLog) {
         debug6.log = (...args) => {
-          const string = import_util15.default.format(...args) + "\n";
+          const string = import_util16.default.format(...args) + "\n";
           return originalStderrWrite.apply(process.stderr, [string]);
         };
       }
@@ -7012,7 +7327,7 @@ var TestServerDispatcher = class {
   }
 };
 async function runUIMode(configFile, configCLIOverrides, options) {
-  const configLocation = import_common10.configLoader.resolveConfigLocation(configFile);
+  const configLocation = import_common11.configLoader.resolveConfigLocation(configFile);
   return await innerRunTestServer(configLocation, configCLIOverrides, options, async (server, cancelPromise) => {
     await import_coreBundle3.server.installRootRedirect(server, void 0, { ...options, webApp: "uiMode.html" });
     if (options.host !== void 0 || options.port !== void 0) {
@@ -7031,7 +7346,7 @@ async function runUIMode(configFile, configCLIOverrides, options) {
   });
 }
 async function installedChromiumChannelForUI(configLocation, configCLIOverrides) {
-  const config2 = await import_common10.configLoader.loadConfig(configLocation, configCLIOverrides).catch((e) => null);
+  const config2 = await import_common11.configLoader.loadConfig(configLocation, configCLIOverrides).catch((e) => null);
   if (!config2)
     return void 0;
   if (config2.projects.some((p) => (!p.project.use.browserName || p.project.use.browserName === "chromium") && !p.project.use.channel))
@@ -7043,7 +7358,7 @@ async function installedChromiumChannelForUI(configLocation, configCLIOverrides)
   return void 0;
 }
 async function runTestServer(configFile, configCLIOverrides, options) {
-  const configLocation = import_common10.configLoader.resolveConfigLocation(configFile);
+  const configLocation = import_common11.configLoader.resolveConfigLocation(configFile);
   return await innerRunTestServer(configLocation, configCLIOverrides, options, async (server) => {
     console.log("Listening on " + server.urlPrefix("precise").replace("http:", "ws:") + "/" + server.wsGuid());
   });
@@ -7087,7 +7402,7 @@ var import_events3 = require("events");
 var import_coreBundle4 = require("playwright-core/lib/coreBundle");
 
 // packages/playwright/src/isomorphic/testTree.ts
-var statusEx = Symbol("statusEx");
+var statusEx = /* @__PURE__ */ Symbol("statusEx");
 
 // packages/playwright/src/isomorphic/teleSuiteUpdater.ts
 var TeleSuiteUpdater = class {
@@ -7830,7 +8145,7 @@ var JsonStringInternalizer = class {
 };
 
 // packages/playwright/src/reporters/merge.ts
-var import_util16 = require("../util");
+var import_util17 = require("../util");
 var { isPathInside } = require("playwright-core/lib/coreBundle").utils;
 var { ZipFile } = require("playwright-core/lib/coreBundle").utils;
 async function createMergedReport(config2, dir, reporterDescriptions, rootDirOverride) {
@@ -7895,6 +8210,7 @@ async function createMergedReport(config2, dir, reporterDescriptions, rootDirOve
     });
   }
   await dispatchEvents(eventData.epilogue);
+  return multiplexer.hasReporterErrors() ? "failed" : "passed";
 }
 var commonEventNames = ["onBlobReportMetadata", "onConfigure", "onProject", "onBegin", "onEnd"];
 var commonEvents = new Set(commonEventNames);
@@ -7925,7 +8241,7 @@ async function extractAndParseReports(dir, shardFiles, internalizer, printStatus
   const reportNames = new UniqueFileNameGenerator();
   for (const file of shardFiles) {
     const absolutePath = import_path19.default.join(dir, file);
-    printStatus(`extracting: ${(0, import_util16.relativeFilePath)(absolutePath)}`);
+    printStatus(`extracting: ${(0, import_util17.relativeFilePath)(absolutePath)}`);
     const zipFile = new ZipFile(absolutePath);
     const entryNames = await zipFile.entries();
     for (const entryName of entryNames.sort()) {