@smoothdeploy/playwright 1.62.1 → 1.63.0

package/lib/runner/index.js

@@ -53,9 +53,7 @@ __export(testRunner_exports, {
   runAllTestsWithConfig: () => runAllTestsWithConfig
 });
 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_coreBundle3 = require("playwright-core/lib/coreBundle");
 var import_common10 = require("../common");
 
 // packages/playwright/src/runner/fsWatcher.ts
@@ -81,14 +79,21 @@ var FSWatcher = class {
     this._throttleTimer = void 0;
     if (!this._watchedPaths.length)
       return;
-    const ignored = [...this._ignoredFolders, "**/node_modules/**"];
+    const ignoredPrefixes = this._ignoredFolders.map((folder) => folder.replace(/\\/g, "/") + "/");
+    const ignored = (file) => {
+      if (file.split("/").includes("node_modules"))
+        return true;
+      return ignoredPrefixes.some((prefix) => (file + "/").startsWith(prefix));
+    };
     this._fsWatcher = chokidar.watch(watchedPaths, { ignoreInitial: true, ignored }).on("all", async (event, file) => {
+      if (event !== "add" && event !== "addDir" && event !== "change" && event !== "unlink" && event !== "unlinkDir")
+        return;
       if (this._throttleTimer)
         clearTimeout(this._throttleTimer);
       this._collector.push({ event, file });
       this._throttleTimer = setTimeout(() => this._reportEventsIfAny(), 250);
     });
-    await new Promise((resolve, reject) => this._fsWatcher.once("ready", resolve).once("error", reject));
+    await new Promise((resolve, reject) => this._fsWatcher.once("ready", () => resolve()).once("error", reject));
   }
   async close() {
     await this._fsWatcher?.close();
@@ -498,7 +503,9 @@ var TeleTestStep = class {
     this.steps = [];
     this._startTime = 0;
     this.title = payload.title;
+    this.subtitle = payload.subtitle;
     this.category = payload.category;
+    this.params = payload.params;
     this.location = location;
     this.parent = parentStep;
     this._startTime = payload.startTime;
@@ -597,7 +604,7 @@ function parseRegexPatterns(patterns) {
 }
 function computeTestCaseOutcome(test) {
   let skipped = 0;
-  let didNotRun = 0;
+  let didNotRun2 = 0;
   let expected = 0;
   let interrupted = 0;
   let unexpected = 0;
@@ -607,7 +614,7 @@ function computeTestCaseOutcome(test) {
     } else if (result.status === "skipped" && test.expectedStatus === "skipped") {
       ++skipped;
     } else if (result.status === "skipped") {
-      ++didNotRun;
+      ++didNotRun2;
     } else if (result.status === test.expectedStatus) {
       ++expected;
     } else {
@@ -759,7 +766,14 @@ async function gitCommitInfo(gitDir) {
 async function gitDiff(gitDir, ci) {
   const diffLimit = 1e5;
   if (ci?.prBaseHash) {
-    await runGit(["fetch", "origin", ci.prBaseHash, "--depth=1", "--no-auto-maintenance", "--no-auto-gc", "--no-tags", "--no-recurse-submodules"], gitDir);
+    const hasBaseCommit = await runGit(["cat-file", "-e", `${ci.prBaseHash}^{commit}`], gitDir) !== void 0;
+    if (!hasBaseCommit) {
+      const isShallow = await runGit(["rev-parse", "--is-shallow-repository"], gitDir) === "true";
+      const fetchArgs = ["fetch", "origin", ci.prBaseHash, "--no-auto-maintenance", "--no-auto-gc", "--no-tags", "--no-recurse-submodules"];
+      if (isShallow)
+        fetchArgs.push("--depth=1");
+      await runGit(fetchArgs, gitDir);
+    }
     const diff3 = await runGit(["diff", ci.prBaseHash, "HEAD"], gitDir);
     if (diff3)
       return diff3.substring(0, diffLimit);
@@ -1180,7 +1194,7 @@ var TerminalReporter = class {
     const threshold = this.config.reportSlowTests.threshold;
     return fileDurations.filter(([, duration]) => duration > threshold).slice(0, count);
   }
-  generateSummaryMessage({ didNotRun, skipped, expected, interrupted, unexpected, flaky, fatalErrors }) {
+  generateSummaryMessage({ didNotRun: didNotRun2, skipped, expected, interrupted, unexpected, flaky, fatalErrors }) {
     const tokens = [];
     if (unexpected.length) {
       tokens.push(this.screen.colors.red(`  ${unexpected.length} failed`));
@@ -1199,8 +1213,8 @@ var TerminalReporter = class {
     }
     if (skipped)
       tokens.push(this.screen.colors.yellow(`  ${skipped} skipped`));
-    if (didNotRun)
-      tokens.push(this.screen.colors.yellow(`  ${didNotRun} did not run`));
+    if (didNotRun2)
+      tokens.push(this.screen.colors.yellow(`  ${didNotRun2} did not run`));
     if (expected)
       tokens.push(this.screen.colors.green(`  ${expected} passed`) + this.screen.colors.dim(` (${msToString(this.result.duration)})`));
     if (fatalErrors.length && expected + unexpected.length + interrupted.length + flaky.length > 0)
@@ -1208,7 +1222,7 @@ var TerminalReporter = class {
     return tokens.join("\n");
   }
   generateSummary() {
-    let didNotRun = 0;
+    let didNotRun2 = 0;
     let skipped = 0;
     let expected = 0;
     const interrupted = [];
@@ -1223,7 +1237,7 @@ var TerminalReporter = class {
               interruptedToPrint.push(test);
             interrupted.push(test);
           } else if (!test.results.length || test.expectedStatus !== "skipped") {
-            ++didNotRun;
+            ++didNotRun2;
           } else {
             ++skipped;
           }
@@ -1242,7 +1256,7 @@ var TerminalReporter = class {
     });
     const failuresToPrint = [...unexpected, ...flaky, ...interruptedToPrint];
     return {
-      didNotRun,
+      didNotRun: didNotRun2,
       skipped,
       expected,
       interrupted,
@@ -1285,7 +1299,7 @@ var TerminalReporter = class {
     return formatTestTitle(this.screen, this.config, test, step, this._options);
   }
   formatTestHeader(test, options = {}) {
-    return formatTestHeader(this.screen, this.config, test, { ...options, includeTestId: this._options.includeTestId });
+    return formatTestHeader(this.screen, this.config, test, { ...options, includeTestId: this._options.includeTestId, omitTags: this._options.omitTags });
   }
   formatFailure(test, index) {
     return formatFailure(this.screen, this.config, test, index, this._options);
@@ -1320,7 +1334,7 @@ function formatFailure(screen, config2, test, index, options) {
     if (!errors.length)
       continue;
     if (!printedHeader) {
-      const header = formatTestHeader(screen, config2, test, { indent: "  ", index, mode: "error", includeTestId: options?.includeTestId });
+      const header = formatTestHeader(screen, config2, test, { indent: "  ", index, mode: "error", includeTestId: options?.includeTestId, omitTags: options?.omitTags });
       lines.push(screen.colors.red(header));
       printedHeader = true;
     }
@@ -1433,7 +1447,9 @@ function relativeTestPath(screen, config2, test) {
   return relativeFilePath(screen, config2, test.location.file);
 }
 function stepSuffix(step) {
-  const stepTitles = step ? step.titlePath() : [];
+  const stepTitles = [];
+  for (let current = step; current; current = current.parent)
+    stepTitles.unshift(current.subtitle ? `${current.title} ${current.subtitle}` : current.title);
   return stepTitles.map((t2) => t2.split("\n")[0]).map((t2) => " \u203A " + t2).join("");
 }
 function formatTestTitle(screen, config2, test, step, options = {}) {
@@ -1443,7 +1459,7 @@ function formatTestTitle(screen, config2, test, step, options = {}) {
   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((t2) => !testTitle.includes(t2) && !config2.tags.includes(t2));
+  const extraTags = options.omitTags ? [] : test.tags.filter((t2) => !testTitle.includes(t2) && !config2.tags.includes(t2));
   return `${testTitle}${stepSuffix(step)}${extraTags.length ? " " + extraTags.join(" ") : ""}`;
 }
 function formatTestHeader(screen, config2, test, options = {}) {
@@ -1859,7 +1875,7 @@ function addLocationAndSnippetToError(config2, error, file) {
 }
 
 // packages/playwright/src/runner/testRunner.ts
-var import_util15 = require("../util");
+var import_util16 = require("../util");
 
 // packages/playwright/src/runner/reporters.ts
 var reporters_exports = {};
@@ -1867,7 +1883,7 @@ __export(reporters_exports, {
   createErrorCollectingReporter: () => createErrorCollectingReporter,
   createReporters: () => createReporters
 });
-var import_fs8 = __toESM(require("fs"));
+var import_fs9 = __toESM(require("fs"));
 
 // packages/playwright/src/runner/loadUtils.ts
 var import_path4 = __toESM(require("path"));
@@ -2007,11 +2023,23 @@ var ProcessHost = class extends import_events.EventEmitter {
       return;
     const exitPromise = new Promise((f) => this.once("exit", () => f()));
     const timeout = +(process.env.PWTEST_CHILD_PROCESS_TIMEOUT || 5 * 60 * 1e3);
-    const result = await raceAgainstDeadline2(() => exitPromise, monotonicTime4() + timeout);
-    if (result.timedOut) {
-      this.emit("processError", { message: `Error: ${this._processName} process did not exit within ${timeout}ms after stop, force-killed it` });
-      this._forceKill();
-      await exitPromise;
+    let lastHeartbeat = monotonicTime4();
+    const onHeartbeat = () => lastHeartbeat = monotonicTime4();
+    this.on("__heartbeat__", onHeartbeat);
+    try {
+      while (true) {
+        const result = await raceAgainstDeadline2(() => exitPromise, lastHeartbeat + timeout);
+        if (!result.timedOut)
+          return;
+        if (monotonicTime4() < lastHeartbeat + timeout)
+          continue;
+        this.emit("processError", { message: `Error: ${this._processName} process did not exit within ${timeout}ms after stop, force-killed it` });
+        this._forceKill();
+        await exitPromise;
+        return;
+      }
+    } finally {
+      this.off("__heartbeat__", onHeartbeat);
     }
   }
   _forceKill() {
@@ -2361,7 +2389,8 @@ function createTestGroups(projectSuite, expectedParallelism) {
       requireFile: test._requireFile,
       repeatEachIndex: test.repeatEachIndex,
       projectId: test._projectId,
-      tests: []
+      tests: [],
+      locks: []
     };
   };
   for (const test of projectSuite.allTests()) {
@@ -2421,6 +2450,14 @@ function createTestGroups(projectSuite, expectedParallelism) {
       }
     }
   }
+  for (const group of result) {
+    const locks = /* @__PURE__ */ new Set();
+    for (const test of group.tests) {
+      for (const lock of test._locks)
+        locks.add(lock);
+    }
+    group.locks = [...locks];
+  }
   return result;
 }
 function filterForShard(shard, weights, testGroups) {
@@ -3003,7 +3040,9 @@ var TeleReporterEmitter = class {
       id: step[this._idSymbol],
       parentStepId: step.parent?.[this._idSymbol],
       title: step.title,
+      subtitle: step.subtitle,
       category: step.category,
+      params: step.params,
       startTime: +step.startTime,
       location: this._relativeLocation(step.location)
     };
@@ -3136,9 +3175,10 @@ var BlobReporter = class extends TeleReporterEmitter {
 };
 
 // packages/playwright/src/reporters/dot.ts
+var { getAsBooleanFromENV } = require("playwright-core/lib/coreBundle").utils;
 var DotReporter = class extends TerminalReporter {
-  constructor() {
-    super(...arguments);
+  constructor(options) {
+    super({ ...options, omitTags: getAsBooleanFromENV("PLAYWRIGHT_DOT_OMIT_TAGS", options?.omitTags) });
     this._counter = 0;
   }
   onBegin(suite) {
@@ -3228,6 +3268,7 @@ var import_path7 = __toESM(require("path"));
 var import_util7 = require("../util");
 var { noColors: noColors2 } = require("playwright-core/lib/coreBundle").iso;
 var { msToString: msToString2 } = require("playwright-core/lib/coreBundle").iso;
+var { getAsBooleanFromENV: getAsBooleanFromENV2 } = require("playwright-core/lib/coreBundle").utils;
 var GitHubLogger = class {
   newLine() {
     process.stdout.write("\n");
@@ -3253,7 +3294,7 @@ var GitHubLogger = class {
 };
 var GitHubReporter = class extends TerminalReporter {
   constructor(options = {}) {
-    super(options);
+    super({ ...options, omitTags: getAsBooleanFromENV2("PLAYWRIGHT_GITHUB_OMIT_TAGS", options.omitTags) });
     this.githubLogger = new GitHubLogger();
     this._failedTestCount = 0;
     this.screen = { ...this.screen, colors: noColors2 };
@@ -3845,6 +3886,7 @@ var HtmlBuilder = class {
       title = `${title} (skipped${skipped.description ? ": " + skipped.description : ""})`;
     const testStep = {
       title,
+      subtitle: step.subtitle,
       startTime: step.startTime.toISOString(),
       duration,
       steps: dedupeSteps(step.steps).map((s) => this._createTestStep(s, result)),
@@ -3930,7 +3972,7 @@ function dedupeSteps(steps) {
   for (const step of steps) {
     const canDedupe = !step.error && step.duration >= 0 && step.location?.file && !step.steps.length;
     const lastStep = lastResult?.step;
-    if (canDedupe && lastResult && lastStep && step.category === lastStep.category && step.title === lastStep.title && step.location?.file === lastStep.location?.file && step.location?.line === lastStep.location?.line && step.location?.column === lastStep.location?.column) {
+    if (canDedupe && lastResult && lastStep && step.category === lastStep.category && step.title === lastStep.title && step.subtitle === lastStep.subtitle && step.location?.file === lastStep.location?.file && step.location?.line === lastStep.location?.line && step.location?.column === lastStep.location?.column) {
       ++lastResult.count;
       lastResult.duration += step.duration;
       continue;
@@ -4181,6 +4223,7 @@ var JSONReporter = class {
     const steps = step.steps.filter((s) => s.category === "test.step");
     return {
       title: step.title,
+      subtitle: step.subtitle,
       duration: step.duration,
       error: step.error,
       steps: steps.length ? steps.map((s) => this._serializeTestStep(s)) : void 0
@@ -4215,7 +4258,7 @@ var json_default = JSONReporter;
 var import_fs7 = __toESM(require("fs"));
 var import_path10 = __toESM(require("path"));
 var import_util9 = require("../util");
-var { getAsBooleanFromENV } = require("playwright-core/lib/coreBundle").utils;
+var { getAsBooleanFromENV: getAsBooleanFromENV3 } = require("playwright-core/lib/coreBundle").utils;
 var JUnitReporter = class {
   constructor(options) {
     this.totalTests = 0;
@@ -4225,9 +4268,11 @@ var JUnitReporter = class {
     this.stripANSIControlSequences = false;
     this.includeProjectInTestName = false;
     this.includeRetries = false;
-    this.stripANSIControlSequences = getAsBooleanFromENV("PLAYWRIGHT_JUNIT_STRIP_ANSI", !!options.stripANSIControlSequences);
-    this.includeProjectInTestName = getAsBooleanFromENV("PLAYWRIGHT_JUNIT_INCLUDE_PROJECT_IN_TEST_NAME", !!options.includeProjectInTestName);
-    this.includeRetries = getAsBooleanFromENV("PLAYWRIGHT_JUNIT_INCLUDE_RETRIES", !!options.includeRetries);
+    this.omitTags = false;
+    this.stripANSIControlSequences = getAsBooleanFromENV3("PLAYWRIGHT_JUNIT_STRIP_ANSI", !!options.stripANSIControlSequences);
+    this.includeProjectInTestName = getAsBooleanFromENV3("PLAYWRIGHT_JUNIT_INCLUDE_PROJECT_IN_TEST_NAME", !!options.includeProjectInTestName);
+    this.includeRetries = getAsBooleanFromENV3("PLAYWRIGHT_JUNIT_INCLUDE_RETRIES", !!options.includeRetries);
+    this.omitTags = getAsBooleanFromENV3("PLAYWRIGHT_JUNIT_OMIT_TAGS", !!options.omitTags);
     this.configDir = options.configDir;
     this.resolvedOutputFile = resolveOutputFile("JUNIT", options)?.outputFile;
   }
@@ -4380,7 +4425,7 @@ var JUnitReporter = class {
       entry.children.push({
         name: errorInfo.elementName,
         attributes: { message: errorInfo.message, type: errorInfo.type },
-        text: (0, import_util9.stripAnsiEscapes)(formatFailure(nonTerminalScreen, this.config, test))
+        text: (0, import_util9.stripAnsiEscapes)(formatFailure(nonTerminalScreen, this.config, test, void 0, { omitTags: this.omitTags }))
       });
       return errorInfo.elementName;
     }
@@ -4390,7 +4435,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_util9.stripAnsiEscapes)(formatFailure(nonTerminalScreen, this.config, test))
+      text: (0, import_util9.stripAnsiEscapes)(formatFailure(nonTerminalScreen, this.config, test, void 0, { omitTags: this.omitTags }))
     });
     return "failure";
   }
@@ -4501,9 +4546,10 @@ function escape(text, stripANSIControlSequences, isCharacterData) {
 var junit_default = JUnitReporter;
 
 // packages/playwright/src/reporters/line.ts
+var { getAsBooleanFromENV: getAsBooleanFromENV4 } = require("playwright-core/lib/coreBundle").utils;
 var LineReporter = class extends TerminalReporter {
-  constructor() {
-    super(...arguments);
+  constructor(options) {
+    super({ ...options, omitTags: getAsBooleanFromENV4("PLAYWRIGHT_LINE_OMIT_TAGS", options?.omitTags) });
     this._current = 0;
     this._failures = 0;
     this._didBegin = false;
@@ -4612,13 +4658,13 @@ var line_default = LineReporter;
 // packages/playwright/src/reporters/list.ts
 var import_util10 = require("../util");
 var { msToString: msToString3 } = require("playwright-core/lib/coreBundle").iso;
-var { getAsBooleanFromENV: getAsBooleanFromENV2 } = require("playwright-core/lib/coreBundle").utils;
+var { getAsBooleanFromENV: getAsBooleanFromENV5 } = 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;
 var POSITIVE_STATUS_MARK = DOES_NOT_SUPPORT_UTF8_IN_TERMINAL ? "ok" : "\u2713";
 var NEGATIVE_STATUS_MARK = DOES_NOT_SUPPORT_UTF8_IN_TERMINAL ? "x" : "\u2718";
 var ListReporter = class extends TerminalReporter {
   constructor(options) {
-    super(options);
+    super({ ...options, omitTags: getAsBooleanFromENV5("PLAYWRIGHT_LIST_OMIT_TAGS", options?.omitTags) });
     this._lastRow = 0;
     this._lastColumn = 0;
     this._testRows = /* @__PURE__ */ new Map();
@@ -4628,8 +4674,8 @@ var ListReporter = class extends TerminalReporter {
     this._needNewLine = false;
     this._failureIndex = 0;
     this._paused = /* @__PURE__ */ new Set();
-    this._printSteps = getAsBooleanFromENV2("PLAYWRIGHT_LIST_PRINT_STEPS", options?.printSteps);
-    this._printFailuresInline = getAsBooleanFromENV2("PLAYWRIGHT_LIST_PRINT_FAILURES_INLINE", options?.printFailuresInline);
+    this._printSteps = getAsBooleanFromENV5("PLAYWRIGHT_LIST_PRINT_STEPS", options?.printSteps);
+    this._printFailuresInline = getAsBooleanFromENV5("PLAYWRIGHT_LIST_PRINT_FAILURES_INLINE", options?.printFailuresInline);
   }
   onBegin(suite) {
     super.onBegin(suite);
@@ -4888,29 +4934,383 @@ var ListModeReporter = class {
 };
 var listModeReporter_default = ListModeReporter;
 
+// packages/playwright/src/reporters/perfetto.ts
+var import_fs8 = __toESM(require("fs"));
+var import_path12 = __toESM(require("path"));
+var import_zlib = __toESM(require("zlib"));
+var import_coreBundle2 = require("playwright-core/lib/coreBundle");
+var import_util11 = require("../util");
+var { toPosixPath: toPosixPath4 } = require("playwright-core/lib/coreBundle").utils;
+var kStatusColors = {
+  passed: "good",
+  failed: "bad",
+  timedOut: "terrible",
+  interrupted: "yellow",
+  skipped: "grey"
+};
+var kProcessId = 1;
+var kRunThreadId = 0;
+var PerfettoReporter = class {
+  constructor(options) {
+    this._events = [];
+    this._laneEndTime = /* @__PURE__ */ new Map();
+    this._globalErrors = [];
+    this._resolvedOutputFile = resolveOutputFile("PERFETTO", {
+      ...options,
+      default: {
+        fileName: "perfetto.json",
+        outputDir: "test-results"
+      }
+    }).outputFile;
+  }
+  version() {
+    return "v2";
+  }
+  printsToStdio() {
+    return false;
+  }
+  onConfigure(config2) {
+    this._config = config2;
+  }
+  onBegin(suite) {
+    this._suite = suite;
+  }
+  onError(error) {
+    this._globalErrors.push({ error, timestamp: Date.now() });
+  }
+  async onEnd(result) {
+    const entries = [];
+    for (const test of this._suite?.allTests() ?? []) {
+      for (const testResult of test.results)
+        entries.push({ test, result: testResult });
+    }
+    entries.sort((a, b) => a.result.startTime.getTime() - b.result.startTime.getTime());
+    for (const entry of entries)
+      this._appendTestResult(entry.test, entry.result);
+    for (const { error, timestamp } of this._globalErrors) {
+      this._events.push({
+        name: "error",
+        cat: "error",
+        ph: "i",
+        s: "g",
+        ts: timestamp,
+        pid: kProcessId,
+        tid: kRunThreadId,
+        cname: "bad",
+        args: { error: this._formatError(error) }
+      });
+    }
+    await this._writeReport(result);
+  }
+  _appendTestResult(test, result) {
+    const startMs = result.startTime.getTime();
+    let endMs = startMs + Math.max(0, result.duration);
+    for (const step of result.steps)
+      endMs = Math.max(endMs, stepEndTime(step));
+    const lane = this._allocateLane(result.parallelIndex, startMs);
+    this._laneEndTime.set(lane, endMs);
+    const tid = lane + 1;
+    this._events.push({
+      name: test.title,
+      cat: "test",
+      ph: "X",
+      ts: startMs,
+      dur: endMs - startMs,
+      pid: kProcessId,
+      tid,
+      cname: kStatusColors[result.status],
+      args: this._testArgs(test, result)
+    });
+    for (const step of result.steps)
+      this._appendStep(step, tid, startMs, endMs);
+  }
+  _allocateLane(preferredLane, startMs) {
+    const preferred = Math.max(0, preferredLane);
+    if (!(this._laneEndTime.get(preferred) > startMs))
+      return preferred;
+    for (let lane = 0; ; ++lane) {
+      if (!(this._laneEndTime.get(lane) > startMs))
+        return lane;
+    }
+  }
+  _appendStep(step, tid, parentStart, parentEnd) {
+    const stepStart = step.startTime.getTime();
+    const startMs = clamp(stepStart, parentStart, parentEnd);
+    const endMs = clamp(step.duration >= 0 ? stepStart + step.duration : parentEnd, startMs, parentEnd);
+    this._events.push({
+      name: step.subtitle ? `${step.title} ${step.subtitle}` : step.title,
+      cat: step.category,
+      ph: "X",
+      ts: startMs,
+      dur: endMs - startMs,
+      pid: kProcessId,
+      tid,
+      cname: step.error ? "bad" : void 0,
+      args: this._stepArgs(step)
+    });
+    for (const child of step.steps)
+      this._appendStep(child, tid, startMs, endMs);
+  }
+  _testArgs(test, result) {
+    const [, projectName, , ...titles] = test.titlePath();
+    const args = {
+      status: result.status,
+      expectedStatus: test.expectedStatus,
+      testId: test.id,
+      workerIndex: result.workerIndex,
+      parallelIndex: result.parallelIndex,
+      timeout: test.timeout,
+      location: this._formatLocation(test.location)
+    };
+    if (titles.length > 1)
+      args.title = titles.join(" \u203A ");
+    if (projectName)
+      args.project = projectName;
+    if (result.retry)
+      args.retry = result.retry;
+    if (test.tags.length)
+      args.tags = test.tags.join(" ");
+    if (result.annotations.length)
+      args.annotations = result.annotations.map((annotation) => formatAnnotation(annotation));
+    if (result.attachments.length)
+      args.attachments = result.attachments.map((attachment) => this._formatAttachment(attachment));
+    if (result.errors.length)
+      args.errors = result.errors.map((error) => this._formatError(error));
+    const stdout = concatChunks(result.stdout);
+    if (stdout)
+      args.stdout = stdout;
+    const stderr = concatChunks(result.stderr);
+    if (stderr)
+      args.stderr = stderr;
+    return args;
+  }
+  _stepArgs(step) {
+    const args = {};
+    if (step.params)
+      args.params = step.params;
+    if (step.location)
+      args.location = this._formatLocation(step.location);
+    if (step.annotations.length)
+      args.annotations = step.annotations.map((annotation) => formatAnnotation(annotation));
+    if (step.attachments.length)
+      args.attachments = step.attachments.map((attachment) => this._formatAttachment(attachment));
+    if (step.error)
+      args.error = this._formatError(step.error);
+    return Object.keys(args).length ? args : void 0;
+  }
+  _formatAttachment(attachment) {
+    return attachment.path ? this._relativePath(attachment.path) : attachment.name;
+  }
+  _formatLocation(location) {
+    if (!location)
+      return void 0;
+    return `${this._relativePath(location.file)}:${location.line}:${location.column}`;
+  }
+  _formatError(error) {
+    return (0, import_util11.stripAnsiEscapes)(formatError(nonTerminalScreen, error).message);
+  }
+  _relativePath(file) {
+    return toPosixPath4(import_path12.default.relative(this._config.rootDir, file));
+  }
+  async _writeReport(result) {
+    let timeOrigin2 = result.startTime.getTime();
+    for (const event of this._events)
+      timeOrigin2 = Math.min(timeOrigin2, event.ts);
+    const metadataEvents = [
+      { name: "process_name", cat: "__metadata", ph: "M", ts: 0, pid: kProcessId, tid: kRunThreadId, args: { name: "Playwright Test" } },
+      { name: "process_sort_index", cat: "__metadata", ph: "M", ts: 0, pid: kProcessId, tid: kRunThreadId, args: { sort_index: 0 } }
+    ];
+    for (const lane of [...this._laneEndTime.keys()].sort((a, b) => a - b)) {
+      metadataEvents.push({ name: "thread_name", cat: "__metadata", ph: "M", ts: 0, pid: kProcessId, tid: lane + 1, args: { name: `Worker ${lane}` } });
+      metadataEvents.push({ name: "thread_sort_index", cat: "__metadata", ph: "M", ts: 0, pid: kProcessId, tid: lane + 1, args: { sort_index: lane + 1 } });
+    }
+    this._events.sort((a, b) => a.ts - b.ts);
+    for (const event of this._events) {
+      event.ts = Math.round((event.ts - timeOrigin2) * 1e3);
+      if (event.dur !== void 0)
+        event.dur = Math.round(event.dur * 1e3);
+    }
+    const metadata = {
+      "playwright-version": (0, import_coreBundle2.getPlaywrightVersion)(),
+      "start-time": result.startTime.toISOString(),
+      "duration": result.duration,
+      "status": result.status
+    };
+    await import_fs8.default.promises.mkdir(import_path12.default.dirname(this._resolvedOutputFile), { recursive: true });
+    const writer = new ChunkWriter(this._resolvedOutputFile);
+    await writer.write('{"traceEvents":[');
+    let separator2 = "";
+    for (const events of [metadataEvents, this._events]) {
+      for (const event of events) {
+        await writer.write(separator2 + JSON.stringify(event));
+        separator2 = ",";
+      }
+    }
+    await writer.write(`],"displayTimeUnit":"ms","metadata":${JSON.stringify(metadata)}}`);
+    await writer.close();
+  }
+};
+var ChunkWriter = class {
+  constructor(file) {
+    const fileStream = import_fs8.default.createWriteStream(file);
+    const gzip = file.endsWith(".gz") ? import_zlib.default.createGzip() : void 0;
+    gzip?.pipe(fileStream);
+    this._stream = gzip ?? fileStream;
+    this._closed = new Promise((resolve) => fileStream.on("close", resolve));
+    for (const stream of /* @__PURE__ */ new Set([this._stream, fileStream]))
+      stream.on("error", (error) => this._error ??= error);
+  }
+  async write(chunk) {
+    if (this._error)
+      throw this._error;
+    if (!this._stream.write(chunk))
+      await new Promise((resolve) => this._stream.once("drain", () => resolve()));
+  }
+  async close() {
+    this._stream.end();
+    await this._closed;
+    if (this._error)
+      throw this._error;
+  }
+};
+function stepEndTime(step) {
+  let end = step.startTime.getTime() + Math.max(0, step.duration);
+  for (const child of step.steps)
+    end = Math.max(end, stepEndTime(child));
+  return end;
+}
+function formatAnnotation(annotation) {
+  return annotation.description ? `${annotation.type}: ${annotation.description}` : annotation.type;
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function concatChunks(chunks) {
+  return chunks.map((chunk) => typeof chunk === "string" ? chunk : chunk.toString("utf8")).join("");
+}
+var perfetto_default = PerfettoReporter;
+
+// packages/playwright/src/reporters/smoothdeploy.ts
+var fs10 = __toESM(require("fs"));
+var path13 = __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 fs9 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+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";
   }
@@ -4918,55 +5318,46 @@ var SmoothDeployReporter = class {
     return false;
   }
   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);
-  }
-  _emit(event) {
-    process.stdout.write(`[SMOOTHDEPLOY_EVENT]${JSON.stringify(event)}
+    this._configDir = config2.configFile ? path13.dirname(config2.configFile) : config2.rootDir;
+    const manifestPath = path13.join(this._configDir, ".smoothdeploy-manifest.json");
+    if (fs10.existsSync(manifestPath))
+      this._manifest = JSON.parse(fs10.readFileSync(manifestPath, "utf-8"));
+  }
+  _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();
-    const relFile = path12.relative(this._configDir, test.location.file);
+    const relFile = path13.relative(this._configDir, test.location.file);
     const fileManifest = this._manifest.files[relFile];
     if (!fileManifest)
       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) {
@@ -4976,15 +5367,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 };
@@ -4993,13 +5382,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",
@@ -5008,11 +5393,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,
@@ -5022,29 +5432,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,
@@ -5052,97 +5510,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);
-          }
+    const outputDir = path13.join(process.cwd(), ".smoothdeploy-output");
+    const screenshotsDir = path13.join(outputDir, "screenshots");
+    for (const [safePwTestId] of this._testIdMap) {
+      const testDir = path13.join(screenshotsDir, safePwTestId);
+      if (!fs10.existsSync(testDir))
+        continue;
+      for (const [safePwStepId, safeManifestStepId] of this._stepIdMap) {
+        for (const suffix of ["-page.png", "-element.png"]) {
+          const src = path13.join(testDir, `${safePwStepId}${suffix}`);
+          if (fs10.existsSync(src))
+            fs10.renameSync(src, path13.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 = path13.join(screenshotsDir, safePwTestId);
+      const dst = path13.join(screenshotsDir, safeManifestTestId);
+      if (src !== dst && fs10.existsSync(src)) {
+        if (fs10.existsSync(dst))
+          fs10.rmSync(dst, { recursive: true });
+        fs10.renameSync(src, dst);
       }
     }
     const remapScreenshotPaths = (steps) => {
@@ -5160,24 +5627,17 @@ var SmoothDeployReporter = class {
       if (!resolved)
         continue;
       remapScreenshotPaths(steps);
-      const safeManifestTestId = resolved.manifestTest.id.replace(/[^a-zA-Z0-9_-]/g, "-");
-      const failurePath = path12.join(screenshotsDir, safeManifestTestId, "failure.png");
-      const failureScreenshot = fs9.existsSync(failurePath) ? `.smoothdeploy-output/screenshots/${safeManifestTestId}/failure.png` : null;
+      const safeManifestTestId = safeId(resolved.manifestTest.id);
+      const failurePath = path13.join(screenshotsDir, safeManifestTestId, "failure.png");
+      const failureScreenshot = fs10.existsSync(failurePath) ? `.smoothdeploy-output/screenshots/${safeManifestTestId}/failure.png` : null;
       const key = resolved.manifestTest.id;
       if (!manifest[key])
         manifest[key] = [];
       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()
-    });
+    fs10.mkdirSync(outputDir, { recursive: true });
+    fs10.writeFileSync(path13.join(outputDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+    this._emit({ event: "runEnd", status: result.status, timestamp: Date.now() });
   }
   _remapPath(screenshotPath) {
     let result = screenshotPath;
@@ -5194,21 +5654,20 @@ var smoothdeploy_default = SmoothDeployReporter;
 var { calculateSha1: calculateSha13 } = require("playwright-core/lib/coreBundle").utils;
 async function createReporters(config2, mode, descriptions, runOptions) {
   const defaultReporters = {
-    blob: BlobReporter,
-    dot: mode === "list" ? listModeReporter_default : dot_default,
-    line: mode === "list" ? listModeReporter_default : line_default,
-    list: mode === "list" ? listModeReporter_default : list_default,
-    github: github_default,
-    json: json_default,
-    junit: junit_default,
-    null: empty_default,
-    html: html_default,
-    smoothdeploy: smoothdeploy_default
+    "blob": BlobReporter,
+    "perfetto": perfetto_default,
+    "dot": mode === "list" ? listModeReporter_default : dot_default,
+    "line": mode === "list" ? listModeReporter_default : line_default,
+    "list": mode === "list" ? listModeReporter_default : list_default,
+    "github": github_default,
+    "json": json_default,
+    "junit": junit_default,
+    "null": empty_default,
+    "html": html_default,
+    "smoothdeploy": smoothdeploy_default
   };
   const reporters = [];
   descriptions ??= config2.config.reporter;
-  if (runOptions?.additionalReporters)
-    descriptions = [...descriptions, ...runOptions.additionalReporters];
   const reportOptions = reporterCommandOptions(config2, mode, runOptions);
   for (const r of descriptions) {
     const [name, arg] = r;
@@ -5272,22 +5731,22 @@ function computeCommandHash(config2, runOptions) {
   if (config2.config.tags.length)
     command.tags = config2.config.tags.join(" ");
   if (runOptions?.testList)
-    command.testList = calculateSha13(import_fs8.default.readFileSync(runOptions.testList));
+    command.testList = calculateSha13(import_fs9.default.readFileSync(runOptions.testList));
   if (runOptions?.testListInvert)
-    command.testListInvert = calculateSha13(import_fs8.default.readFileSync(runOptions.testListInvert));
+    command.testListInvert = calculateSha13(import_fs9.default.readFileSync(runOptions.testListInvert));
   if (Object.keys(command).length)
     parts.push(calculateSha13(JSON.stringify(command)).substring(0, 7));
   return parts.join("-");
 }
 
 // packages/playwright/src/runner/tasks.ts
-var import_fs11 = __toESM(require("fs"));
-var import_path15 = __toESM(require("path"));
-var import_util13 = require("util");
+var import_fs12 = __toESM(require("fs"));
+var import_path16 = __toESM(require("path"));
+var import_util14 = require("util");
 
 // packages/playwright/src/runner/rebase.ts
-var import_fs9 = __toESM(require("fs"));
-var import_path12 = __toESM(require("path"));
+var import_fs10 = __toESM(require("fs"));
+var import_path13 = __toESM(require("path"));
 var babel3 = __toESM(require("../transform/babelBundle"));
 var colors3 = require("playwright-core/lib/utilsBundle").colors;
 var diff = require("playwright-core/lib/utilsBundle").diff;
@@ -5311,9 +5770,9 @@ async function applySuggestedRebaselines(config2, reporter, filteredProjects) {
   const patches = [];
   const files = [];
   const gitCache = /* @__PURE__ */ new Map();
-  const patchFile = import_path12.default.join(project.project.outputDir, "rebaselines.patch");
+  const patchFile = import_path13.default.join(project.project.outputDir, "rebaselines.patch");
   for (const fileName of [...suggestedRebaselines.keys()].sort()) {
-    const source = await import_fs9.default.promises.readFile(fileName, "utf8");
+    const source = await import_fs10.default.promises.readFile(fileName, "utf8");
     const lines = source.split("\n");
     const replacements = suggestedRebaselines.get(fileName);
     const fileNode = babel3.babelParse(source, fileName, true);
@@ -5347,15 +5806,15 @@ async function applySuggestedRebaselines(config2, reporter, filteredProjects) {
     let result = source;
     for (const range of ranges)
       result = result.substring(0, range.start) + range.newText + result.substring(range.end);
-    const relativeName = import_path12.default.relative(process.cwd(), fileName);
+    const relativeName = import_path13.default.relative(process.cwd(), fileName);
     files.push(relativeName);
     if (config2.config.updateSourceMethod === "overwrite") {
-      await import_fs9.default.promises.writeFile(fileName, result);
+      await import_fs10.default.promises.writeFile(fileName, result);
     } else if (config2.config.updateSourceMethod === "3way") {
-      await import_fs9.default.promises.writeFile(fileName, applyPatchWithConflictMarkers(source, result));
+      await import_fs10.default.promises.writeFile(fileName, applyPatchWithConflictMarkers(source, result));
     } else {
-      const gitFolder = findGitRoot(import_path12.default.dirname(fileName), gitCache);
-      const relativeToGit = import_path12.default.relative(gitFolder || process.cwd(), fileName);
+      const gitFolder = findGitRoot(import_path13.default.dirname(fileName), gitCache);
+      const relativeToGit = import_path13.default.relative(gitFolder || process.cwd(), fileName);
       patches.push(createPatch(relativeToGit, source, result));
     }
   }
@@ -5366,10 +5825,10 @@ New baselines created for:
 ${fileList}
 `);
   if (config2.config.updateSourceMethod === "patch") {
-    await import_fs9.default.promises.mkdir(import_path12.default.dirname(patchFile), { recursive: true });
-    await import_fs9.default.promises.writeFile(patchFile, patches.join("\n"));
+    await import_fs10.default.promises.mkdir(import_path13.default.dirname(patchFile), { recursive: true });
+    await import_fs10.default.promises.writeFile(patchFile, patches.join("\n"));
     reporter.onStdErr(`
-  ` + colors3.cyan("git apply " + import_path12.default.relative(process.cwd(), patchFile)) + "\n");
+  ` + colors3.cyan("git apply " + import_path13.default.relative(process.cwd(), patchFile)) + "\n");
   }
 }
 function createPatch(fileName, before, after) {
@@ -5386,12 +5845,12 @@ function findGitRoot(dir, cache) {
   const result = cache.get(dir);
   if (result !== void 0)
     return result;
-  const gitPath = import_path12.default.join(dir, ".git");
-  if (import_fs9.default.existsSync(gitPath) && import_fs9.default.lstatSync(gitPath).isDirectory()) {
+  const gitPath = import_path13.default.join(dir, ".git");
+  if (import_fs10.default.existsSync(gitPath) && import_fs10.default.lstatSync(gitPath).isDirectory()) {
     cache.set(dir, dir);
     return dir;
   }
-  const parentDir = import_path12.default.dirname(dir);
+  const parentDir = import_path13.default.dirname(dir);
   if (dir === parentDir) {
     cache.set(dir, null);
     return null;
@@ -5435,8 +5894,8 @@ function applyPatchWithConflictMarkers(oldText, newText) {
 }
 
 // packages/playwright/src/runner/workerHost.ts
-var import_fs10 = __toESM(require("fs"));
-var import_path13 = __toESM(require("path"));
+var import_fs11 = __toESM(require("fs"));
+var import_path14 = __toESM(require("path"));
 var import_common6 = require("../common");
 
 // packages/playwright/src/isomorphic/folders.ts
@@ -5465,13 +5924,13 @@ var WorkerHost = class extends ProcessHost {
       repeatEachIndex: testGroup.repeatEachIndex,
       projectId: testGroup.projectId,
       config: options.config,
-      artifactsDir: import_path13.default.join(options.outputDir, artifactsFolderName(workerIndex)),
+      artifactsDir: import_path14.default.join(options.outputDir, artifactsFolderName(workerIndex)),
       pauseOnError: options.pauseOnError,
       pauseAtEnd: options.pauseAtEnd
     };
   }
   async start() {
-    await import_fs10.default.promises.mkdir(this._params.artifactsDir, { recursive: true });
+    await import_fs11.default.promises.mkdir(this._params.artifactsDir, { recursive: true });
     return await this.startRunner(this._params, {
       onStdOut: (chunk) => this.emit("stdOut", import_common6.ipc.stdioChunkToParams(chunk)),
       onStdErr: (chunk) => this.emit("stdErr", import_common6.ipc.stdioChunkToParams(chunk))
@@ -5507,7 +5966,7 @@ var WorkerHost = class extends ProcessHost {
 
 // packages/playwright/src/runner/dispatcher.ts
 var import_common7 = require("../common");
-var import_util11 = require("../util");
+var import_util12 = 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;
@@ -5530,11 +5989,22 @@ var Dispatcher = class {
         this._workerLimitPerProjectId.set(project.id, project.workers);
     }
   }
+  _heldLocks() {
+    const heldLocks = /* @__PURE__ */ new Set();
+    for (const slot of this._workerSlots) {
+      for (const lock of slot.jobDispatcher?.job.locks || [])
+        heldLocks.add(lock);
+    }
+    return heldLocks;
+  }
   _findFirstJobToRun() {
+    const heldLocks = this._heldLocks();
     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;
+      if (job.locks.some((lock) => heldLocks.has(lock)))
+        continue;
       const projectIdWorkerLimit = this._workerLimitPerProjectId.get(job.projectId);
       if (!projectIdWorkerLimit)
         return index;
@@ -5544,18 +6014,22 @@ var Dispatcher = class {
     }
     return -1;
   }
+  _scheduleJobs() {
+    while (this._scheduleJob()) {
+    }
+  }
   _scheduleJob() {
-    if (this._isStopped)
-      return;
+    if (this._isStopped || !this._workerSlots.some((w) => !w.jobDispatcher))
+      return false;
     const jobIndex = this._findFirstJobToRun();
     if (jobIndex === -1)
-      return;
+      return false;
     const job = this._queue[jobIndex];
     let workerIndex = this._workerSlots.findIndex((w) => !w.jobDispatcher && w.worker && w.worker.hash() === job.workerHash && !w.worker.didSendStop());
     if (workerIndex === -1)
       workerIndex = this._workerSlots.findIndex((w) => !w.jobDispatcher);
     if (workerIndex === -1) {
-      return;
+      return false;
     }
     this._queue.splice(jobIndex, 1);
     const jobDispatcher = new JobDispatcher(job, this._testRun, this._ignoreMaxFailures ? void 0 : () => this.stop().catch(() => {
@@ -5564,8 +6038,9 @@ var Dispatcher = class {
     void this._runJobInWorker(workerIndex, jobDispatcher).then(() => {
       this._workerSlots[workerIndex].jobDispatcher = void 0;
       this._checkFinished();
-      this._scheduleJob();
+      this._scheduleJobs();
     });
+    return true;
   }
   async _runJobInWorker(index, jobDispatcher) {
     const job = jobDispatcher.job;
@@ -5643,8 +6118,7 @@ var Dispatcher = class {
       void this.stop();
     for (let i = 0; i < this._testRun.config.config.workers; i++)
       this._workerSlots.push({});
-    for (let i = 0; i < this._workerSlots.length; i++)
-      this._scheduleJob();
+    this._scheduleJobs();
     this._checkFinished();
     await this._finished;
   }
@@ -5786,19 +6260,23 @@ var JobDispatcher = class {
     const parentStep = params.parentStepId ? steps.get(params.parentStepId) : void 0;
     const step = {
       title: params.title,
+      subtitle: params.subtitle,
       titlePath: () => {
         const parentPath = parentStep?.titlePath() || [];
         return [...parentPath, params.title];
       },
       parent: parentStep,
       category: params.category,
+      params: params.params,
       startTime: new Date(params.wallTime),
       duration: -1,
       steps: [],
       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);
@@ -5980,7 +6458,7 @@ var JobDispatcher = class {
           addLocationAndSnippetToError(this._testRun.config.config, response.error);
         return response;
       } catch (e) {
-        const error = (0, import_util11.serializeError)(e);
+        const error = (0, import_util12.serializeError)(e);
         addLocationAndSnippetToError(this._testRun.config.config, error);
         return { response: void 0, error };
       }
@@ -6099,7 +6577,7 @@ var FixedNodeSIGINTHandler = class {
 };
 
 // packages/playwright/src/runner/taskRunner.ts
-var import_util12 = require("../util");
+var import_util13 = 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;
@@ -6140,7 +6618,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_util12.serializeError)(e));
+          errors.push((0, import_util13.serializeError)(e));
         } finally {
           for (const error of [...softErrors, ...errors])
             this._reporter.onError?.(error);
@@ -6202,7 +6680,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_path15 = __toESM(require("path"));
 var import_common8 = require("../common");
 async function detectChangedTestFiles(baseCommit, configDir) {
   function gitFileList(args) {
@@ -6232,20 +6710,20 @@ async function detectChangedTestFiles(baseCommit, configDir) {
       ].join("\n"));
     }
   }
-  const untrackedFiles = gitFileList(["ls-files", "--others", "--exclude-standard"]).map((file) => import_path14.default.join(configDir, file));
+  const untrackedFiles = gitFileList(["ls-files", "--others", "--exclude-standard"]).map((file) => import_path15.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));
+  const trackedFilesWithChanges = gitFileList(["diff", baseCommit, "--name-only"]).map((file) => import_path15.default.join(gitRoot, file));
   return new Set(import_common8.cc.affectedTestFiles([...untrackedFiles, ...trackedFilesWithChanges]));
 }
 
 // packages/playwright/src/runner/tasks.ts
 var import_common9 = require("../common");
-var import_util14 = require("../util");
+var import_util15 = 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_util13.promisify)(import_fs11.default.readdir);
+var readDirAsync2 = (0, import_util14.promisify)(import_fs12.default.readdir);
 var TestRun = class {
   constructor(config2, reporter, options) {
     this.rootSuite = void 0;
@@ -6316,7 +6794,6 @@ function createRunTestsTasks(config2) {
   return [
     createPhasesTask(),
     createReportBeginTask(),
-    ...config2.plugins.map((plugin) => createPluginBeginTask(plugin)),
     createRunTestsTask()
   ];
 }
@@ -6324,9 +6801,7 @@ function createClearCacheTask(config2) {
   return {
     title: "clear cache",
     setup: async () => {
-      await (0, import_util14.removeDirAndLogToConsole)(import_common9.cc.cacheDir);
-      for (const plugin of config2.plugins)
-        await plugin.instance?.clearCache?.();
+      await (0, import_util15.removeDirAndLogToConsole)(import_common9.cc.cacheDir);
     }
   };
 }
@@ -6355,17 +6830,6 @@ function createPluginSetupTasks(config2) {
     }
   }));
 }
-function createPluginBeginTask(plugin) {
-  return {
-    title: "plugin begin",
-    setup: async (testRun) => {
-      await plugin.instance?.begin?.(testRun.rootSuite);
-    },
-    teardown: async () => {
-      await plugin.instance?.end?.();
-    }
-  };
-}
 function createGlobalSetupTask(file, config2) {
   let title = "global setup";
   if (config2.globalSetups.length > 1)
@@ -6408,7 +6872,7 @@ function createRemoveOutputDirsTask() {
           return;
         if (error.code === "EBUSY") {
           const entries = await readDirAsync2(outputDir).catch((e) => []);
-          await Promise.all(entries.map((entry) => removeFolders4([import_path15.default.join(outputDir, entry)])));
+          await Promise.all(entries.map((entry) => removeFolders4([import_path16.default.join(outputDir, entry)])));
         } else {
           throw error;
         }
@@ -6427,7 +6891,7 @@ function createListFilesTask() {
         projectSuite._fullProject = project;
         testRun.rootSuite._addSuite(projectSuite);
         const suites = files.map((file) => {
-          const title = import_path15.default.relative(testRun.config.config.rootDir, file);
+          const title = import_path16.default.relative(testRun.config.config.rootDir, file);
           const suite = new import_common9.test.Suite(title, "file");
           suite.location = { file, line: 0, column: 0 };
           projectSuite._addSuite(suite);
@@ -6457,8 +6921,8 @@ function createLoadTask(mode, options) {
         testRun.preOnlyTestFilters.push((test) => !testFilter(test));
       }
       if (testRun.options.grep || testRun.options.grepInvert) {
-        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;
+        const grepMatcher = testRun.options.grep ? (0, import_util15.createTitleMatcher)((0, import_util15.forceRegExp)(testRun.options.grep)) : () => true;
+        const grepInvertMatcher = testRun.options.grepInvert ? (0, import_util15.createTitleMatcher)((0, import_util15.forceRegExp)(testRun.options.grepInvert)) : () => false;
         testRun.preOnlyTestFilters.push((test) => {
           const grepTitle = test._grepTitleWithTags();
           return !grepInvertMatcher(grepTitle) && grepMatcher(grepTitle);
@@ -6470,10 +6934,6 @@ function createLoadTask(mode, options) {
       }
       await collectProjectsAndTestFiles(testRun, !!options.doNotRunDepsOutsideProjectFilter);
       await loadFileSuites(testRun, mode, options.failOnLoadErrors ? errors : softErrors);
-      if (testRun.options.onlyChanged || options.populateDependencies) {
-        for (const plugin of testRun.config.plugins)
-          await plugin.instance?.populateDependencies?.();
-      }
       if (testRun.options.onlyChanged) {
         const changedFiles = await detectChangedTestFiles(testRun.options.onlyChanged, testRun.config.configDir);
         testRun.preOnlyTestFilters.push((test) => changedFiles.has(test.location.file));
@@ -6597,25 +7057,32 @@ function createRunTestsTask() {
 }
 
 // packages/playwright/src/runner/lastRun.ts
-var import_fs12 = __toESM(require("fs"));
-var import_path16 = __toESM(require("path"));
+var import_fs13 = __toESM(require("fs"));
+var import_path17 = __toESM(require("path"));
+function didNotRun(test) {
+  if (test.outcome() !== "skipped")
+    return false;
+  if (test.results.some((result) => result.status === "interrupted"))
+    return false;
+  return !test.results.length || test.expectedStatus !== "skipped";
+}
 var LastRunReporter = class {
   constructor(filteredProjects, listMode, lastFailedFileOverride) {
     this._listMode = !!listMode;
     const override = lastFailedFileOverride ?? process.env.PLAYWRIGHT_LAST_RUN_OUTPUT_FILE;
     if (override) {
-      this._lastRunFile = import_path16.default.resolve(process.cwd(), override);
+      this._lastRunFile = import_path17.default.resolve(process.cwd(), override);
     } else {
       const [project] = filteredProjects;
       if (project)
-        this._lastRunFile = import_path16.default.join(project.project.outputDir, ".last-run.json");
+        this._lastRunFile = import_path17.default.join(project.project.outputDir, ".last-run.json");
     }
   }
   async filterLastFailed() {
     if (!this._lastRunFile)
       return void 0;
     try {
-      const lastRunInfo = JSON.parse(await import_fs12.default.promises.readFile(this._lastRunFile, "utf8"));
+      const lastRunInfo = JSON.parse(await import_fs13.default.promises.readFile(this._lastRunFile, "utf8"));
       return lastRunInfo.failedTests;
     } catch {
       return void 0;
@@ -6635,10 +7102,10 @@ var LastRunReporter = class {
       return;
     const lastRunInfo = {
       status: result.status,
-      failedTests: this._suite?.allTests().filter((t2) => !t2.ok()).map((t2) => t2.id) || []
+      failedTests: this._suite?.allTests().filter((t2) => !t2.ok() || didNotRun(t2)).map((t2) => t2.id) || []
     };
-    await import_fs12.default.promises.mkdir(import_path16.default.dirname(this._lastRunFile), { recursive: true });
-    await import_fs12.default.promises.writeFile(this._lastRunFile, JSON.stringify(lastRunInfo, void 0, 2));
+    await import_fs13.default.promises.mkdir(import_path17.default.dirname(this._lastRunFile), { recursive: true });
+    await import_fs13.default.promises.writeFile(this._lastRunFile, JSON.stringify(lastRunInfo, void 0, 2));
   }
 };
 
@@ -6658,7 +7125,6 @@ var TestRunner = class extends import_events2.default {
     this._watchedTestDependencies = /* @__PURE__ */ new Set();
     this._queue = Promise.resolve();
     this._watchTestDirs = false;
-    this._populateDependenciesOnList = false;
     this._startingEnv = {};
     this.configLocation = configLocation;
     this._configCLIOverrides = configCLIOverrides;
@@ -6671,7 +7137,6 @@ var TestRunner = class extends import_events2.default {
   async initialize(params) {
     setPlaywrightTestProcessEnv();
     this._watchTestDirs = !!params.watchTestDirs;
-    this._populateDependenciesOnList = !!params.populateDependenciesOnList;
     this._startingEnv = { ...process.env };
   }
   resizeTerminal(params) {
@@ -6683,7 +7148,7 @@ var TestRunner = class extends import_events2.default {
   hasSomeBrowsers() {
     for (const browserName of ["chromium", "webkit", "firefox"]) {
       try {
-        import_coreBundle2.registry.registry.findExecutable(browserName).executablePathOrDie("javascript");
+        import_coreBundle3.registry.registry.findExecutable(browserName).executablePathOrDie("javascript");
         return true;
       } catch {
       }
@@ -6691,8 +7156,8 @@ var TestRunner = class extends import_events2.default {
     return false;
   }
   async installBrowsers() {
-    const executables = import_coreBundle2.registry.registry.defaultExecutables();
-    await import_coreBundle2.registry.registry.install(executables);
+    const executables = import_coreBundle3.registry.registry.defaultExecutables();
+    await import_coreBundle3.registry.registry.install(executables);
   }
   async loadConfig() {
     const { config: config2, error } = await this._loadConfig(this._configCLIOverrides);
@@ -6732,7 +7197,6 @@ var TestRunner = class extends import_events2.default {
     if (!config2)
       return { status: "failed" };
     const status = await runTasks(new TestRun(config2, reporter), [
-      ...createPluginSetupTasks(config2),
       createClearCacheTask(config2)
     ]);
     return { status };
@@ -6779,7 +7243,7 @@ var TestRunner = class extends import_events2.default {
       listMode: true
     };
     const status = await runTasks(new TestRun(config2, reporter, options), [
-      createLoadTask("out-of-process", { failOnLoadErrors: false, filterOnly: false, populateDependencies: this._populateDependenciesOnList }),
+      createLoadTask("out-of-process", { failOnLoadErrors: false, filterOnly: false }),
       createReportBeginTask()
     ]);
     return { config: config2, status };
@@ -6791,11 +7255,6 @@ var TestRunner = class extends import_events2.default {
       this._watchedProjectDirs.add(p.project.testDir);
       this._ignoredProjectOutputs.add(p.project.outputDir);
     }
-    const result = await resolveCtDirs(config2);
-    if (result) {
-      this._watchedProjectDirs.add(result.templateDir);
-      this._ignoredProjectOutputs.add(result.outDir);
-    }
     if (this._watchTestDirs)
       await this._updateWatcher(false);
   }
@@ -6886,7 +7345,7 @@ var TestRunner = class extends import_events2.default {
       return { errors: errorReporter.errors(), testFiles: [] };
     const status = await runTasks(new TestRun(config2, reporter), [
       ...createPluginSetupTasks(config2),
-      createLoadTask("out-of-process", { failOnLoadErrors: true, filterOnly: false, populateDependencies: true })
+      createLoadTask("out-of-process", { failOnLoadErrors: true, filterOnly: false })
     ]);
     if (status !== "passed")
       return { errors: errorReporter.errors(), testFiles: [] };
@@ -6915,7 +7374,7 @@ var TestRunner = class extends import_events2.default {
       this._lastLoadedConfig = config2;
       return { config: config2 };
     } catch (e) {
-      return { config: null, error: (0, import_util15.serializeError)(e) };
+      return { config: null, error: (0, import_util16.serializeError)(e) };
     }
   }
   lastLoadedConfig() {
@@ -6935,18 +7394,6 @@ var TestRunner = class extends import_events2.default {
 function printInternalError(e) {
   console.error("Internal error:", e);
 }
-async function resolveCtDirs(config2) {
-  const use = config2.config.projects[0].use;
-  const relativeTemplateDir = use.ctTemplateDir || "playwright";
-  const templateDir = await import_fs13.default.promises.realpath(import_path17.default.normalize(import_path17.default.join(config2.configDir, relativeTemplateDir))).catch(() => void 0);
-  if (!templateDir)
-    return null;
-  const outDir = use.ctCacheDir ? import_path17.default.resolve(config2.configDir, use.ctCacheDir) : import_path17.default.resolve(templateDir, ".cache");
-  return {
-    outDir,
-    templateDir
-  };
-}
 async function runAllTestsWithConfig(config2, options) {
   setPlaywrightTestProcessEnv();
   addGitCommitInfoPlugin(config2);
@@ -6983,8 +7430,8 @@ __export(testServer_exports, {
   runTestServer: () => runTestServer,
   runUIMode: () => runUIMode
 });
-var import_util16 = __toESM(require("util"));
-var import_coreBundle3 = require("playwright-core/lib/coreBundle");
+var import_util17 = __toESM(require("util"));
+var import_coreBundle4 = require("playwright-core/lib/coreBundle");
 var import_common11 = require("../common");
 
 // packages/playwright/src/runner/uiModeReporter.ts
@@ -7013,7 +7460,7 @@ var TestServer = class {
   }
   async start(options) {
     this._dispatcher = new TestServerDispatcher(this._configLocation, this._configCLIOverrides);
-    return await import_coreBundle3.server.startTraceViewerServer({
+    return await import_coreBundle4.server.startTraceViewerServer({
       host: options.host,
       port: options.port,
       allowedFileRoots: () => this._allowedFileRoots(),
@@ -7143,7 +7590,7 @@ var TestServerDispatcher = class {
     if (interceptStdio) {
       if (debug6.log === originalDebugLog) {
         debug6.log = (...args) => {
-          const string = import_util16.default.format(...args) + "\n";
+          const string = import_util17.default.format(...args) + "\n";
           return originalStderrWrite.apply(process.stderr, [string]);
         };
       }
@@ -7169,12 +7616,12 @@ var TestServerDispatcher = class {
 async function runUIMode(configFile, configCLIOverrides, options) {
   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" });
+    await import_coreBundle4.server.installRootRedirect(server, void 0, { ...options, webApp: "uiMode.html" });
     if (options.host !== void 0 || options.port !== void 0) {
-      await import_coreBundle3.server.openTraceInBrowser(server.urlPrefix("human-readable"));
+      await import_coreBundle4.server.openTraceInBrowser(server.urlPrefix("human-readable"));
     } else {
       const channel = await installedChromiumChannelForUI(configLocation, configCLIOverrides);
-      const page = await import_coreBundle3.server.openTraceViewerApp(server.urlPrefix("precise"), "chromium", {
+      const page = await import_coreBundle4.server.openTraceViewerApp(server.urlPrefix("precise"), "chromium", {
         headless: isUnderTest() && process.env.PWTEST_HEADED_FOR_TEST !== "1",
         persistentContextOptions: {
           handleSIGINT: false,
@@ -7239,7 +7686,7 @@ __export(watchMode_exports, {
 var import_path18 = __toESM(require("path"));
 var import_readline = __toESM(require("readline"));
 var import_events3 = require("events");
-var import_coreBundle4 = require("playwright-core/lib/coreBundle");
+var import_coreBundle5 = require("playwright-core/lib/coreBundle");
 
 // packages/playwright/src/isomorphic/testTree.ts
 var statusEx = /* @__PURE__ */ Symbol("statusEx");
@@ -7658,8 +8105,7 @@ async function runWatchModeLoop(configLocation, initialOptions) {
   testServerConnection.onReport((report2) => teleSuiteUpdater.processTestReportEvent(report2));
   await testServerConnection.initialize({
     interceptStdio: false,
-    watchTestDirs: true,
-    populateDependenciesOnList: true
+    watchTestDirs: true
   });
   await testServerConnection.runGlobalSetup({});
   const { report } = await testServerConnection.listTests({});
@@ -7921,7 +8367,7 @@ ${colors6.dim("Waiting for file changes. Press")} ${colors6.bold("enter")} ${col
 }
 async function toggleShowBrowser() {
   if (!showBrowserServer) {
-    showBrowserServer = new import_coreBundle4.remote.PlaywrightServer({ mode: "extension", path: "/" + createGuid3(), maxConnections: 1 });
+    showBrowserServer = new import_coreBundle5.remote.PlaywrightServer({ mode: "extension", path: "/" + createGuid3(), maxConnections: 1 });
     connectWsEndpoint = await showBrowserServer.listen();
     process.stdout.write(`${colors6.dim("Show & reuse browser:")} ${colors6.bold("on")}
 `);
@@ -7985,7 +8431,7 @@ var JsonStringInternalizer = class {
 };
 
 // packages/playwright/src/reporters/merge.ts
-var import_util17 = require("../util");
+var import_util18 = 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) {
@@ -8081,7 +8527,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_util17.relativeFilePath)(absolutePath)}`);
+    printStatus(`extracting: ${(0, import_util18.relativeFilePath)(absolutePath)}`);
     const zipFile = new ZipFile(absolutePath);
     const entryNames = await zipFile.entries();
     for (const entryName of entryNames.sort()) {