@withbuddi/buddi 0.1.0-pre.51 → 0.1.0-pre.52

package/node_modules/playwright/lib/runner/index.js

@@ -52,7 +52,7 @@ __export(testRunner_exports, {
   TestRunnerEvent: () => TestRunnerEvent,
   runAllTestsWithConfig: () => runAllTestsWithConfig
 });
-var import_events2 = __toESM(require("events"));
+var import_events3 = __toESM(require("events"));
 var import_coreBundle3 = require("playwright-core/lib/coreBundle");
 var import_common10 = require("../common");
 
@@ -569,6 +569,7 @@ var baseFullConfig = {
   metadata: {},
   preserveOutput: "always",
   projects: [],
+  filteredProjects: [],
   reporter: [[process.env.CI ? "dot" : "list"]],
   reportSlowTests: {
     max: 5,
@@ -580,7 +581,7 @@ var baseFullConfig = {
   quiet: false,
   shard: null,
   tags: [],
-  updateSnapshots: "missing",
+  updateSnapshots: "default",
   updateSourceMethod: "patch",
   version: "",
   workers: 0,
@@ -642,7 +643,6 @@ function asFullConfig(config2) {
 
 // packages/playwright/src/plugins/gitCommitInfoPlugin.ts
 var fs = __toESM(require("fs"));
-var { monotonicTime } = require("playwright-core/lib/coreBundle").iso;
 var { spawnAsync } = require("playwright-core/lib/coreBundle").utils;
 var GIT_OPERATIONS_TIMEOUT_MS = 3e3;
 var addGitCommitInfoPlugin = (fullConfig) => {
@@ -791,13 +791,13 @@ async function gitDiff(gitDir, ci) {
 }
 async function runGit(args, cwd) {
   debug(`running "git ${args.join(" ")}"`);
-  const start = monotonicTime();
-  const result = await spawnAsync(
-    "git",
-    args,
-    { stdio: "pipe", cwd, timeout: GIT_OPERATIONS_TIMEOUT_MS }
-  );
-  if (monotonicTime() - start > GIT_OPERATIONS_TIMEOUT_MS) {
+  const result = await spawnAsync("git", ["-c", "credential.interactive=false", ...args], {
+    stdio: "pipe",
+    cwd,
+    timeout: GIT_OPERATIONS_TIMEOUT_MS,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+  });
+  if (result.timedOut) {
     print(`timeout of ${GIT_OPERATIONS_TIMEOUT_MS}ms exceeded while running "git ${args.join(" ")}"`);
     return;
   }
@@ -817,7 +817,7 @@ var import_util = require("util");
 var colors = require("playwright-core/lib/utilsBundle").colors;
 var debug2 = require("playwright-core/lib/utilsBundle").debug;
 var { ManualPromise } = require("playwright-core/lib/coreBundle").iso;
-var { monotonicTime: monotonicTime2 } = require("playwright-core/lib/coreBundle").iso;
+var { monotonicTime } = require("playwright-core/lib/coreBundle").iso;
 var { raceAgainstDeadline } = require("playwright-core/lib/coreBundle").iso;
 var { isURLAvailable } = require("playwright-core/lib/coreBundle").utils;
 var { launchProcess } = require("playwright-core/lib/coreBundle").utils;
@@ -942,7 +942,7 @@ var WebServerPlugin = class {
     debugWebServer(`Waiting for availability...`);
     const launchTimeout = this._options.timeout || 60 * 1e3;
     const cancellationToken = { canceled: false };
-    const deadline = monotonicTime2() + launchTimeout;
+    const deadline = monotonicTime() + launchTimeout;
     const racingPromises = [this._processExitedPromise];
     if (this._isAvailableCallback)
       racingPromises.push(raceAgainstDeadline(() => waitFor(this._isAvailableCallback, cancellationToken), deadline));
@@ -1181,9 +1181,10 @@ var TerminalReporter = class {
   generateStartingMessage() {
     const jobs = this.config.metadata.actualWorkers ?? this.config.workers;
     const shardDetails = this.config.shard ? `, shard ${this.config.shard.current} of ${this.config.shard.total}` : "";
+    const shuffleDetails = this.config.metadata.shuffleSeed ? `, shuffle seed ${this.config.metadata.shuffleSeed}` : "";
     if (!this.totalTestCount)
       return "";
-    return "\n" + this.screen.colors.dim("Running ") + this.totalTestCount + this.screen.colors.dim(` test${this.totalTestCount !== 1 ? "s" : ""} using `) + jobs + this.screen.colors.dim(` worker${jobs !== 1 ? "s" : ""}${shardDetails}`);
+    return "\n" + this.screen.colors.dim("Running ") + this.totalTestCount + this.screen.colors.dim(` test${this.totalTestCount !== 1 ? "s" : ""} using `) + jobs + this.screen.colors.dim(` worker${jobs !== 1 ? "s" : ""}${shardDetails}${shuffleDetails}`);
   }
   getSlowTests() {
     if (!this.config.reportSlowTests)
@@ -1328,7 +1329,8 @@ function formatResultErrors(screen, test, result) {
 function formatFailure(screen, config2, test, index, options) {
   const lines = [];
   let printedHeader = false;
-  for (const result of test.results) {
+  const results = options?.lastResult ? test.results.slice(-1) : test.results;
+  for (const result of results) {
     const resultLines = [];
     const errors = formatResultFailure(screen, test, result, "    ");
     if (!errors.length)
@@ -1407,10 +1409,10 @@ function formatRetry(screen, result) {
   }
   return retryLines;
 }
-function quotePathIfNeeded(path20) {
-  if (/\s/.test(path20))
-    return `"${path20}"`;
-  return path20;
+function quotePathIfNeeded(path21) {
+  if (/\s/.test(path21))
+    return `"${path21}"`;
+  return path21;
 }
 var kReportedSymbol = /* @__PURE__ */ Symbol("reported");
 function markErrorsAsReported(result) {
@@ -1774,7 +1776,7 @@ var ReporterV2Wrapper = class {
 };
 
 // packages/playwright/src/reporters/internalReporter.ts
-var { monotonicTime: monotonicTime3 } = require("playwright-core/lib/coreBundle").iso;
+var { monotonicTime: monotonicTime2 } = require("playwright-core/lib/coreBundle").iso;
 var InternalReporter = class {
   constructor(reporters) {
     this._didBegin = false;
@@ -1789,7 +1791,7 @@ var InternalReporter = class {
   onConfigure(config2) {
     this._config = config2;
     this._startTime = /* @__PURE__ */ new Date();
-    this._monotonicStartTime = monotonicTime3();
+    this._monotonicStartTime = monotonicTime2();
     this._reporter.onConfigure?.(config2);
   }
   async preprocess(params) {
@@ -1823,7 +1825,7 @@ var InternalReporter = class {
     return await this._reporter.onEnd?.({
       ...result,
       startTime: this._startTime,
-      duration: monotonicTime3() - this._monotonicStartTime
+      duration: monotonicTime2() - this._monotonicStartTime
     });
   }
   async onExit() {
@@ -1875,7 +1877,7 @@ function addLocationAndSnippetToError(config2, error, file) {
 }
 
 // packages/playwright/src/runner/testRunner.ts
-var import_util16 = require("../util");
+var import_util17 = require("../util");
 
 // packages/playwright/src/runner/reporters.ts
 var reporters_exports = {};
@@ -1883,7 +1885,7 @@ __export(reporters_exports, {
   createErrorCollectingReporter: () => createErrorCollectingReporter,
   createReporters: () => createReporters
 });
-var import_fs9 = __toESM(require("fs"));
+var import_fs10 = __toESM(require("fs"));
 
 // packages/playwright/src/runner/loadUtils.ts
 var import_path4 = __toESM(require("path"));
@@ -1894,8 +1896,9 @@ var import_child_process = __toESM(require("child_process"));
 var import_events = require("events");
 var debug3 = require("playwright-core/lib/utilsBundle").debug;
 var { assert } = require("playwright-core/lib/coreBundle").iso;
-var { monotonicTime: monotonicTime4, timeOrigin } = require("playwright-core/lib/coreBundle").iso;
+var { monotonicTime: monotonicTime3, timeOrigin } = require("playwright-core/lib/coreBundle").iso;
 var { raceAgainstDeadline: raceAgainstDeadline2 } = require("playwright-core/lib/coreBundle").iso;
+var { killProcessTree } = require("playwright-core/lib/coreBundle").utils;
 var ProcessHost = class extends import_events.EventEmitter {
   constructor(entryScript, processName, env) {
     super();
@@ -1984,7 +1987,6 @@ var ProcessHost = class extends import_events.EventEmitter {
     if (error)
       return error;
     const processParams = {
-      processName: this._processName,
       timeOrigin: timeOrigin()
     };
     this.send({
@@ -2023,15 +2025,15 @@ 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);
-    let lastHeartbeat = monotonicTime4();
-    const onHeartbeat = () => lastHeartbeat = monotonicTime4();
+    let lastHeartbeat = monotonicTime3();
+    const onHeartbeat = () => lastHeartbeat = monotonicTime3();
     this.on("__heartbeat__", onHeartbeat);
     try {
       while (true) {
         const result = await raceAgainstDeadline2(() => exitPromise, lastHeartbeat + timeout);
         if (!result.timedOut)
           return;
-        if (monotonicTime4() < lastHeartbeat + timeout)
+        if (monotonicTime3() < lastHeartbeat + timeout)
           continue;
         this.emit("processError", { message: `Error: ${this._processName} process did not exit within ${timeout}ms after stop, force-killed it` });
         this._forceKill();
@@ -2043,16 +2045,8 @@ var ProcessHost = class extends import_events.EventEmitter {
     }
   }
   _forceKill() {
-    const pid = this.process?.pid;
-    if (!pid)
-      return;
-    try {
-      if (process.platform === "win32")
-        import_child_process.default.spawnSync(`taskkill /pid ${pid} /T /F`, { shell: true });
-      else
-        process.kill(pid, "SIGKILL");
-    } catch {
-    }
+    if (this.process?.pid)
+      killProcessTree(this.process.pid);
   }
   didSendStop() {
     return this._didSendStop;
@@ -2137,9 +2131,9 @@ var readDirAsync = (0, import_util4.promisify)(import_fs2.default.readdir);
 function wildcardPatternToRegExp(pattern) {
   return new RegExp("^" + pattern.split("*").map(escapeRegExp).join(".*") + "$", "ig");
 }
-function filterProjects(projects, projectNames) {
+function filterProjects(projects, projectNames, includeNonDefault) {
   if (!projectNames)
-    return [...projects];
+    return projects.filter((project) => includeNonDefault || project.default);
   const projectNamesToFind = /* @__PURE__ */ new Set();
   const unmatchedProjectNames = /* @__PURE__ */ new Map();
   const patterns = /* @__PURE__ */ new Set();
@@ -2381,6 +2375,7 @@ var ReporterTestRunImpl = class {
 };
 
 // packages/playwright/src/runner/testGroups.ts
+var { calculateSha1 } = require("playwright-core/lib/coreBundle").utils;
 function createTestGroups(projectSuite, expectedParallelism) {
   const groups = /* @__PURE__ */ new Map();
   const createGroup = (test) => {
@@ -2460,14 +2455,18 @@ function createTestGroups(projectSuite, expectedParallelism) {
   }
   return result;
 }
+function shuffleTestGroups(testGroups, seed) {
+  const keys = new Map(testGroups.map((group) => [group, calculateSha1(seed + "" + group.tests[0].id)]));
+  testGroups.sort((a, b) => keys.get(a).localeCompare(keys.get(b)));
+}
 function filterForShard(shard, weights, testGroups) {
   weights ??= Array.from({ length: shard.total }, () => 1);
   if (weights.length !== shard.total)
     throw new Error(`PWTEST_SHARD_WEIGHTS number of weights must match the shard total of ${shard.total}`);
   const totalWeight = weights.reduce((a, b) => a + b, 0);
-  let shardableTotal = 0;
-  for (const group of testGroups)
-    shardableTotal += group.tests.length;
+  const activeSizes = testGroups.map((group) => group.tests.filter((test) => test.expectedStatus !== "skipped").length);
+  const groupSizes = activeSizes.some(Boolean) ? activeSizes : testGroups.map((group) => group.tests.length);
+  const shardableTotal = groupSizes.reduce((a, b) => a + b, 0);
   const shardSizes = weights.map((w) => Math.floor(w * shardableTotal / totalWeight));
   const remainder = shardableTotal - shardSizes.reduce((a, b) => a + b, 0);
   for (let i = 0; i < remainder; i++) {
@@ -2479,11 +2478,12 @@ function filterForShard(shard, weights, testGroups) {
   const to = from + shardSizes[shard.current - 1];
   let current = 0;
   const result = /* @__PURE__ */ new Set();
-  for (const group of testGroups) {
-    if (current >= from && current < to)
+  testGroups.forEach((group, index) => {
+    const position = groupSizes[index] ? current : Math.max(current - 1, 0);
+    if (position >= from && position < to)
       result.add(group);
-    current += group.tests.length;
-  }
+    current += groupSizes[index];
+  });
   return result;
 }
 
@@ -3081,7 +3081,7 @@ var TeleReporterEmitter = class {
 var mime = require("playwright-core/lib/utilsBundle").mime;
 var yazl = require("playwright-core/lib/utilsBundle").yazl;
 var { ManualPromise: ManualPromise2 } = require("playwright-core/lib/coreBundle").iso;
-var { calculateSha1, createGuid: createGuid2 } = require("playwright-core/lib/coreBundle").utils;
+var { calculateSha1: calculateSha12, createGuid: createGuid2 } = require("playwright-core/lib/coreBundle").utils;
 var { removeFolders, sanitizeForFilePath } = require("playwright-core/lib/coreBundle").utils;
 var currentBlobReportVersion = 2;
 var BlobReporter = class extends TeleReporterEmitter {
@@ -3162,7 +3162,7 @@ var BlobReporter = class extends TeleReporterEmitter {
     return super._serializeAttachments(attachments).map((attachment) => {
       if (!attachment.path)
         return attachment;
-      const sha1 = calculateSha1(attachment.path + this._salt);
+      const sha1 = calculateSha12(attachment.path + this._salt);
       const extension = mime.getExtension(attachment.contentType) || "dat";
       const newPath = `resources/${sha1}.${extension}`;
       this._attachments.push({ originalPath: attachment.path, zipEntryPath: newPath });
@@ -3174,6 +3174,181 @@ var BlobReporter = class extends TeleReporterEmitter {
   }
 };
 
+// packages/playwright/src/reporters/coverage.ts
+var import_fs5 = __toESM(require("fs"));
+var import_path7 = __toESM(require("path"));
+var import_util7 = require("../util");
+var { mergeIstanbulCoverage, sortedIstanbulCoverage } = require("playwright-core/lib/coreBundle").iso;
+var { ZipFile } = require("playwright-core/lib/coreBundle").utils;
+var CoverageReporter = class {
+  constructor(options) {
+    this._traceFiles = /* @__PURE__ */ new Set();
+    this._options = options;
+  }
+  version() {
+    return "v2";
+  }
+  printsToStdio() {
+    return false;
+  }
+  onTestEnd(test, result) {
+    for (const attachment of result.attachments) {
+      if (attachment.name === "trace" && attachment.path)
+        this._traceFiles.add(attachment.path);
+    }
+  }
+  async onEnd() {
+    const coverage = /* @__PURE__ */ new Map();
+    const traceFiles = [...this._traceFiles];
+    while (traceFiles.length) {
+      const batch = traceFiles.splice(0, 16).map(async (traceFile) => {
+        const zipFile = new ZipFile(traceFile);
+        try {
+          const entries = (await zipFile.entries()).filter((entry) => entry.match(/(^|-)trace\.coverage$/));
+          return await Promise.all(entries.map((entry) => zipFile.read(entry)));
+        } catch {
+          return [];
+        } finally {
+          zipFile.close();
+        }
+      });
+      for (const buffers of await Promise.all(batch)) {
+        for (const buffer of buffers) {
+          try {
+            mergeIstanbulCoverage(coverage, JSON.parse(buffer.toString("utf8")));
+          } catch {
+          }
+        }
+      }
+    }
+    if (!coverage.size) {
+      writeLine([
+        `
+No code coverage was collected.`,
+        `Make sure the application under test is built with istanbul instrumentation`,
+        `(e.g. vite-plugin-istanbul or babel-plugin-istanbul) so that pages expose window.__coverage__,`,
+        `and that tracing is configured with coverage, e.g. trace: { mode: 'on', coverage: true }.`,
+        `Coverage is aggregated from the tests whose traces are kept.`
+      ].join("\n"));
+      return;
+    }
+    const outputDir = (0, import_util7.resolveReporterOutputPath)("coverage", this._options.configDir, this._options.outputDir);
+    await import_fs5.default.promises.mkdir(outputDir, { recursive: true });
+    const mergedJson = sortedIstanbulCoverage(coverage);
+    await import_fs5.default.promises.writeFile(import_path7.default.join(outputDir, "coverage-final.json"), JSON.stringify(mergedJson));
+    await import_fs5.default.promises.writeFile(import_path7.default.join(outputDir, "lcov.info"), lcovReport(mergedJson));
+    const hasHtml = this._tryWriteHtmlReport(mergedJson, outputDir);
+    const summary = computeSummary(mergedJson);
+    const lines = [
+      ``,
+      `Code coverage (${coverage.size} files):`,
+      `  statements: ${formatMetric(summary.statements)}`,
+      `  branches:   ${formatMetric(summary.branches)}`,
+      `  functions:  ${formatMetric(summary.functions)}`,
+      `  lines:      ${formatMetric(summary.lines)}`,
+      `Coverage report written to ${import_path7.default.relative(process.cwd(), outputDir)}`
+    ];
+    if (!hasHtml)
+      lines.push(`For an HTML report, install istanbul-lib-coverage, istanbul-lib-report and istanbul-reports, or run 'npx nyc report --temp-dir=${import_path7.default.relative(process.cwd(), outputDir)} --reporter=html'.`);
+    writeLine(lines.join("\n"));
+  }
+  // Istanbul report libraries are not shipped with Playwright, use the project's if any.
+  _tryWriteHtmlReport(mergedJson, outputDir) {
+    try {
+      const resolveFrom = (name) => require.resolve(name, { paths: [this._options.configDir] });
+      const libCoverage = require(resolveFrom("istanbul-lib-coverage"));
+      const libReport = require(resolveFrom("istanbul-lib-report"));
+      const reports = require(resolveFrom("istanbul-reports"));
+      const context = libReport.createContext({
+        dir: outputDir,
+        coverageMap: libCoverage.createCoverageMap(mergedJson)
+      });
+      reports.create("html").execute(context);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+function computeSummary(mergedJson) {
+  const statements = { covered: 0, total: 0 };
+  const branches = { covered: 0, total: 0 };
+  const functions = { covered: 0, total: 0 };
+  const lines = { covered: 0, total: 0 };
+  for (const fileCov of Object.values(mergedJson)) {
+    countHits(statements, Object.values(fileCov.s));
+    countHits(functions, Object.values(fileCov.f));
+    for (const counts of Object.values(fileCov.b))
+      countHits(branches, counts);
+    countHits(lines, lineCoverage(fileCov).values());
+  }
+  return { statements, branches, functions, lines };
+}
+function countHits(metric, counts) {
+  for (const count of counts) {
+    ++metric.total;
+    if (count > 0)
+      ++metric.covered;
+  }
+}
+function lineCoverage(fileCov) {
+  const lines = /* @__PURE__ */ new Map();
+  for (const [key, statement] of Object.entries(fileCov.statementMap)) {
+    const line = statement.start.line;
+    const count = fileCov.s[key] || 0;
+    lines.set(line, Math.max(lines.get(line) || 0, count));
+  }
+  return lines;
+}
+function formatMetric(metric) {
+  const percent = metric.total ? (metric.covered / metric.total * 100).toFixed(2) : "100.00";
+  return `${percent}% (${metric.covered}/${metric.total})`;
+}
+function lcovReport(mergedJson) {
+  const out = [];
+  for (const [file, fileCov] of Object.entries(mergedJson)) {
+    out.push(`SF:${file}`);
+    let functionsCovered = 0;
+    for (const [key, fn] of Object.entries(fileCov.fnMap)) {
+      out.push(`FN:${fn.decl.start.line},${fn.name}`);
+      out.push(`FNDA:${fileCov.f[key] || 0},${fn.name}`);
+      if (fileCov.f[key] > 0)
+        ++functionsCovered;
+    }
+    out.push(`FNF:${Object.keys(fileCov.fnMap).length}`);
+    out.push(`FNH:${functionsCovered}`);
+    let branchesFound = 0;
+    let branchesCovered = 0;
+    for (const [key, branch] of Object.entries(fileCov.branchMap)) {
+      const counts = fileCov.b[key] || [];
+      branch.locations.forEach((location, i) => {
+        const count = counts[i] || 0;
+        out.push(`BRDA:${location.start.line ?? branch.loc.start.line},${key},${i},${count}`);
+        ++branchesFound;
+        if (count > 0)
+          ++branchesCovered;
+      });
+    }
+    out.push(`BRF:${branchesFound}`);
+    out.push(`BRH:${branchesCovered}`);
+    const lines = lineCoverage(fileCov);
+    let linesCovered = 0;
+    for (const [line, count] of [...lines.entries()].sort((a, b) => a[0] - b[0])) {
+      out.push(`DA:${line},${count}`);
+      if (count > 0)
+        ++linesCovered;
+    }
+    out.push(`LF:${lines.size}`);
+    out.push(`LH:${linesCovered}`);
+    out.push(`end_of_record`);
+  }
+  return out.join("\n") + "\n";
+}
+function writeLine(line) {
+  terminalScreen.stdout.write(line + "\n");
+}
+var coverage_default = CoverageReporter;
+
 // packages/playwright/src/reporters/dot.ts
 var { getAsBooleanFromENV } = require("playwright-core/lib/coreBundle").utils;
 var DotReporter = class extends TerminalReporter {
@@ -3264,8 +3439,8 @@ var EmptyReporter = class {
 var empty_default = EmptyReporter;
 
 // packages/playwright/src/reporters/github.ts
-var import_path7 = __toESM(require("path"));
-var import_util7 = require("../util");
+var import_path8 = __toESM(require("path"));
+var import_util8 = 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;
@@ -3276,7 +3451,7 @@ var GitHubLogger = class {
   _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_util7.stripAnsiEscapes)(`::${type} ${configs}::${message}
+    process.stdout.write((0, import_util8.stripAnsiEscapes)(`::${type} ${configs}::${message}
 `));
   }
   debug(message, options) {
@@ -3340,7 +3515,7 @@ var GitHubReporter = class extends TerminalReporter {
   }
   _printSlowTestAnnotations() {
     this.getSlowTests().forEach(([file, duration]) => {
-      const filePath = workspaceRelativePath(import_path7.default.join(process.cwd(), file));
+      const filePath = workspaceRelativePath(import_path8.default.join(process.cwd(), file));
       this.githubLogger.warning(`${filePath} took ${msToString2(duration)}`, {
         title: "Slow Test",
         file: filePath
@@ -3371,7 +3546,7 @@ var GitHubReporter = class extends TerminalReporter {
   }
 };
 function workspaceRelativePath(filePath) {
-  return import_path7.default.relative(process.env["GITHUB_WORKSPACE"] ?? "", filePath);
+  return import_path8.default.relative(process.env["GITHUB_WORKSPACE"] ?? "", filePath);
 }
 var github_default = GitHubReporter;
 
@@ -3381,18 +3556,18 @@ __export(html_exports, {
   default: () => html_default,
   showHTMLReport: () => showHTMLReport
 });
-var import_fs5 = __toESM(require("fs"));
+var import_fs6 = __toESM(require("fs"));
 var import_os = __toESM(require("os"));
-var import_path8 = __toESM(require("path"));
+var import_path9 = __toESM(require("path"));
 var import_stream3 = require("stream");
 var babel2 = __toESM(require("../transform/babelBundle"));
-var import_util8 = require("../util");
+var import_util9 = 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;
 var yazl2 = require("playwright-core/lib/utilsBundle").yazl;
 var { MultiMap } = require("playwright-core/lib/coreBundle").iso;
-var { calculateSha1: calculateSha12 } = require("playwright-core/lib/coreBundle").utils;
+var { calculateSha1: calculateSha13 } = require("playwright-core/lib/coreBundle").utils;
 var { copyFileAndMakeWritable, removeFolders: removeFolders2, sanitizeForFilePath: sanitizeForFilePath2, toPosixPath: toPosixPath2 } = require("playwright-core/lib/coreBundle").utils;
 var { getPackageManagerExecCommand: getPackageManagerExecCommand2, isCodingAgent } = require("playwright-core/lib/coreBundle").utils;
 var { HttpServer, serveFolder } = require("playwright-core/lib/coreBundle").utils;
@@ -3432,19 +3607,19 @@ var HtmlReporter = class {
         if (reportedWarnings.has(key))
           continue;
         reportedWarnings.add(key);
-        writeLine(colors2.red(`Configuration Error: HTML reporter output folder clashes with the tests output folder:`));
-        writeLine(`
+        writeLine2(colors2.red(`Configuration Error: HTML reporter output folder clashes with the tests output folder:`));
+        writeLine2(`
     html reporter folder: ${colors2.bold(outputFolder)}
     test results folder: ${colors2.bold(project.outputDir)}`);
-        writeLine("");
-        writeLine(`HTML reporter will clear its output directory prior to being generated, which will lead to the artifact loss.
+        writeLine2("");
+        writeLine2(`HTML reporter will clear its output directory prior to being generated, which will lead to the artifact loss.
 `);
       }
     }
     this.suite = suite;
   }
   _resolveOptions() {
-    const outputFolder = reportFolderFromEnv() ?? (0, import_util8.resolveReporterOutputPath)("playwright-report", this._options.configDir, this._options.outputFolder);
+    const outputFolder = reportFolderFromEnv() ?? (0, import_util9.resolveReporterOutputPath)("playwright-report", this._options.configDir, this._options.outputFolder);
     return {
       outputFolder,
       open: getHtmlReportOptionProcessEnv() || this._options.open || "on-failure",
@@ -3454,8 +3629,8 @@ var HtmlReporter = class {
     };
   }
   _isSubdirectory(parentDir, dir) {
-    const relativePath = import_path8.default.relative(parentDir, dir);
-    return !!relativePath && !relativePath.startsWith("..") && !import_path8.default.isAbsolute(relativePath);
+    const relativePath = import_path9.default.relative(parentDir, dir);
+    return !!relativePath && !relativePath.startsWith("..") && !import_path9.default.isAbsolute(relativePath);
   }
   onError(error) {
     this._topLevelErrors.push(error);
@@ -3492,12 +3667,14 @@ var HtmlReporter = class {
       await showHTMLReport(this._outputFolder, this._host, this._port, singleTestId);
     } else if (this._options._mode === "test" && !!process.stdin.isTTY) {
       const packageManagerCommand = getPackageManagerExecCommand2();
-      const relativeReportPath = this._outputFolder === standaloneDefaultFolder() ? "" : " " + import_path8.default.relative(process.cwd(), this._outputFolder);
+      const invocationDir = process.env.INIT_CWD || process.cwd();
+      const isDefaultFolder = invocationDir === process.cwd() && this._outputFolder === standaloneDefaultFolder();
+      const relativeReportPath = isDefaultFolder ? "" : " " + (import_path9.default.relative(invocationDir, this._outputFolder) || ".");
       const hostArg = this._host ? ` --host ${this._host}` : "";
       const portArg = this._port ? ` --port ${this._port}` : "";
-      writeLine("");
-      writeLine("To open last HTML report run:");
-      writeLine(colors2.cyan(`
+      writeLine2("");
+      writeLine2("To open last HTML report run:");
+      writeLine2(colors2.cyan(`
   ${packageManagerCommand} playwright show-report${relativeReportPath}${hostArg}${portArg}
 `));
     }
@@ -3505,14 +3682,14 @@ var HtmlReporter = class {
 };
 function reportFolderFromEnv() {
   const envValue = process.env.PLAYWRIGHT_HTML_OUTPUT_DIR || process.env.PLAYWRIGHT_HTML_REPORT;
-  return envValue ? import_path8.default.resolve(envValue) : void 0;
+  return envValue ? import_path9.default.resolve(envValue) : void 0;
 }
 function getHtmlReportOptionProcessEnv() {
   const htmlOpenEnv = process.env.PLAYWRIGHT_HTML_OPEN || process.env.PW_TEST_HTML_REPORT_OPEN;
   if (!htmlOpenEnv)
     return void 0;
   if (!isHtmlReportOption(htmlOpenEnv)) {
-    writeLine(colors2.red(`Configuration Error: HTML reporter Invalid value for PLAYWRIGHT_HTML_OPEN: ${htmlOpenEnv}. Valid values are: ${htmlReportOptions.join(", ")}`));
+    writeLine2(colors2.red(`Configuration Error: HTML reporter Invalid value for PLAYWRIGHT_HTML_OPEN: ${htmlOpenEnv}. Valid values are: ${htmlReportOptions.join(", ")}`));
     return void 0;
   }
   return htmlOpenEnv;
@@ -3526,10 +3703,10 @@ function parseBooleanEnvVar(name) {
   return void 0;
 }
 function standaloneDefaultFolder() {
-  return reportFolderFromEnv() ?? (0, import_util8.resolveReporterOutputPath)("playwright-report", process.cwd(), void 0);
+  return reportFolderFromEnv() ?? (0, import_util9.resolveReporterOutputPath)("playwright-report", process.cwd(), void 0);
 }
 async function resolveReportFolder(reportPath) {
-  const stat = await import_fs5.default.promises.stat(reportPath).catch(() => null);
+  const stat = await import_fs6.default.promises.stat(reportPath).catch(() => null);
   if (!stat)
     throw new Error(`No report found at "${reportPath}"`);
   if (stat.isDirectory())
@@ -3539,10 +3716,10 @@ async function resolveReportFolder(reportPath) {
   throw new Error(`No report found at "${reportPath}"`);
 }
 async function extractReportZip(zipPath) {
-  const tempDir = await import_fs5.default.promises.mkdtemp(import_path8.default.join(import_os.default.tmpdir(), "playwright-show-report-"));
+  const tempDir = await import_fs6.default.promises.mkdtemp(import_path9.default.join(import_os.default.tmpdir(), "playwright-show-report-"));
   const cleanup = () => {
     try {
-      import_fs5.default.rmSync(tempDir, { recursive: true, force: true });
+      import_fs6.default.rmSync(tempDir, { recursive: true, force: true });
     } catch {
     }
   };
@@ -3553,7 +3730,7 @@ async function extractReportZip(zipPath) {
     cleanup();
     throw new Error(`Failed to extract report from "${zipPath}": ${e.message}`);
   }
-  const hasIndex = await import_fs5.default.promises.access(import_path8.default.join(tempDir, "index.html")).then(() => true, () => false);
+  const hasIndex = await import_fs6.default.promises.access(import_path9.default.join(tempDir, "index.html")).then(() => true, () => false);
   if (!hasIndex) {
     cleanup();
     throw new Error(`No "index.html" found at the top level of "${zipPath}"`);
@@ -3566,15 +3743,15 @@ async function showHTMLReport(reportFolder, host = "localhost", port, testId) {
   try {
     folder = await resolveReportFolder(requestedPath);
   } catch (e) {
-    writeLine(colors2.red(e.message));
+    writeLine2(colors2.red(e.message));
     gracefullyProcessExitDoNotHang(1);
     return;
   }
   const server = false ? await serveHtmlReportWithHMR(folder) : serveFolder(folder);
   await server.start({ port, host, preferredPort: port ? void 0 : 9323 });
   let url = server.urlPrefix("human-readable");
-  writeLine("");
-  writeLine(colors2.cyan(`  Serving HTML report at ${url}. Press Ctrl+C to quit.`));
+  writeLine2("");
+  writeLine2(colors2.cyan(`  Serving HTML report at ${url}. Press Ctrl+C to quit.`));
   if (testId)
     url += `#?testId=${testId}`;
   url = url.replace("0.0.0.0", "localhost");
@@ -3593,7 +3770,7 @@ var HtmlBuilder = class {
     this._reportFolder = outputDir;
     this._options = options;
     this._doNotInlineAssets = doNotInlineAssets;
-    import_fs5.default.mkdirSync(this._reportFolder, { recursive: true });
+    import_fs6.default.mkdirSync(this._reportFolder, { recursive: true });
     this._attachmentsBaseURL = attachmentsBaseURL;
   }
   async build(metadata, projectSuites, result, topLevelErrors, machines) {
@@ -3661,60 +3838,60 @@ var HtmlBuilder = class {
     }
     const reportIndexFile = await this._writeStaticAssets();
     if (this._hasTraces) {
-      const traceViewerFolder = import_path8.default.join(require.resolve("playwright-core"), "..", "lib", "vite", "traceViewer");
-      const traceViewerTargetFolder = import_path8.default.join(this._reportFolder, "trace");
-      const traceViewerAssetsTargetFolder = import_path8.default.join(traceViewerTargetFolder, "assets");
-      import_fs5.default.mkdirSync(traceViewerAssetsTargetFolder, { recursive: true });
-      for (const file of import_fs5.default.readdirSync(traceViewerFolder)) {
+      const traceViewerFolder = import_path9.default.join(require.resolve("playwright-core"), "..", "lib", "vite", "traceViewer");
+      const traceViewerTargetFolder = import_path9.default.join(this._reportFolder, "trace");
+      const traceViewerAssetsTargetFolder = import_path9.default.join(traceViewerTargetFolder, "assets");
+      import_fs6.default.mkdirSync(traceViewerAssetsTargetFolder, { recursive: true });
+      for (const file of import_fs6.default.readdirSync(traceViewerFolder)) {
         if (file.endsWith(".map") || file.includes("watch") || file.includes("assets"))
           continue;
-        await copyFileAndMakeWritable(import_path8.default.join(traceViewerFolder, file), import_path8.default.join(traceViewerTargetFolder, file));
+        await copyFileAndMakeWritable(import_path9.default.join(traceViewerFolder, file), import_path9.default.join(traceViewerTargetFolder, file));
       }
-      for (const file of import_fs5.default.readdirSync(import_path8.default.join(traceViewerFolder, "assets"))) {
+      for (const file of import_fs6.default.readdirSync(import_path9.default.join(traceViewerFolder, "assets"))) {
         if (file.endsWith(".map") || file.includes("xtermModule"))
           continue;
-        await copyFileAndMakeWritable(import_path8.default.join(traceViewerFolder, "assets", file), import_path8.default.join(traceViewerAssetsTargetFolder, file));
+        await copyFileAndMakeWritable(import_path9.default.join(traceViewerFolder, "assets", file), import_path9.default.join(traceViewerAssetsTargetFolder, file));
       }
     }
     await this._writeReportData(reportIndexFile);
     return { ok, singleTestId };
   }
   async _writeStaticAssets() {
-    const appFolder = import_path8.default.join(require.resolve("playwright-core"), "..", "lib", "vite", "htmlReport");
-    const reportIndexFile = import_path8.default.join(this._reportFolder, "index.html");
+    const appFolder = import_path9.default.join(require.resolve("playwright-core"), "..", "lib", "vite", "htmlReport");
+    const reportIndexFile = import_path9.default.join(this._reportFolder, "index.html");
     if (this._doNotInlineAssets) {
-      const html = await import_fs5.default.promises.readFile(import_path8.default.join(appFolder, "index.html"), "utf-8");
+      const html = await import_fs6.default.promises.readFile(import_path9.default.join(appFolder, "index.html"), "utf-8");
       await Promise.all([
-        import_fs5.default.promises.writeFile(reportIndexFile, html),
-        import_fs5.default.promises.copyFile(import_path8.default.join(appFolder, "report.js"), import_path8.default.join(this._reportFolder, "report.js")),
-        import_fs5.default.promises.copyFile(import_path8.default.join(appFolder, "report.css"), import_path8.default.join(this._reportFolder, "report.css"))
+        import_fs6.default.promises.writeFile(reportIndexFile, html),
+        import_fs6.default.promises.copyFile(import_path9.default.join(appFolder, "report.js"), import_path9.default.join(this._reportFolder, "report.js")),
+        import_fs6.default.promises.copyFile(import_path9.default.join(appFolder, "report.css"), import_path9.default.join(this._reportFolder, "report.css"))
       ]);
     } else {
-      let html = await import_fs5.default.promises.readFile(import_path8.default.join(appFolder, "index.html"), "utf-8");
+      let html = await import_fs6.default.promises.readFile(import_path9.default.join(appFolder, "index.html"), "utf-8");
       const [js, css] = await Promise.all([
-        import_fs5.default.promises.readFile(import_path8.default.join(appFolder, "report.js"), "utf-8"),
-        import_fs5.default.promises.readFile(import_path8.default.join(appFolder, "report.css"), "utf-8")
+        import_fs6.default.promises.readFile(import_path9.default.join(appFolder, "report.js"), "utf-8"),
+        import_fs6.default.promises.readFile(import_path9.default.join(appFolder, "report.css"), "utf-8")
       ]);
       html = html.replace(/<script type="module"[^>]*><\/script>/, () => `<script type="module">${js}</script>`);
       html = html.replace(/<link rel="stylesheet"[^>]*>/, () => `<style type='text/css'>${css}</style>`);
-      await import_fs5.default.promises.writeFile(reportIndexFile, html);
+      await import_fs6.default.promises.writeFile(reportIndexFile, html);
     }
     return reportIndexFile;
   }
   async _writeReportData(filePath) {
-    import_fs5.default.appendFileSync(filePath, '<template id="playwrightReportBase64">data:application/zip;base64,');
+    import_fs6.default.appendFileSync(filePath, '<template id="playwrightReportBase64">data:application/zip;base64,');
     await new Promise((resolve, reject) => {
       this._dataZipFile.end(void 0, () => {
-        this._dataZipFile.outputStream.pipe(new Base64Encoder()).pipe(import_fs5.default.createWriteStream(filePath, { flags: "a" })).on("close", resolve).on("error", reject);
+        this._dataZipFile.outputStream.pipe(new Base64Encoder()).pipe(import_fs6.default.createWriteStream(filePath, { flags: "a" })).on("close", resolve).on("error", reject);
       });
     });
-    import_fs5.default.appendFileSync(filePath, "</template>");
+    import_fs6.default.appendFileSync(filePath, "</template>");
   }
   _addDataFile(fileName, data) {
     this._dataZipFile.addBuffer(Buffer.from(JSON.stringify(data)), fileName);
   }
   _createEntryForSuite(data, projectName, suite, fileName, deep) {
-    const fileId = calculateSha12(fileName).slice(0, 20);
+    const fileId = calculateSha13(fileName).slice(0, 20);
     let fileEntry = data.get(fileId);
     if (!fileEntry) {
       fileEntry = {
@@ -3731,8 +3908,8 @@ var HtmlBuilder = class {
       testFileSummary.tests.push(test.testCaseSummary);
     }
   }
-  _processSuite(suite, projectName, path20, deep, outTests) {
-    const newPath = [...path20, suite.title];
+  _processSuite(suite, projectName, path21, deep, outTests) {
+    const newPath = [...path21, suite.title];
     suite.entries().forEach((e) => {
       if (e.type === "test")
         outTests.push(this._createTestEntry(e, projectName, newPath));
@@ -3740,10 +3917,10 @@ var HtmlBuilder = class {
         this._processSuite(e, projectName, newPath, deep, outTests);
     });
   }
-  _createTestEntry(test, projectName, path20) {
+  _createTestEntry(test, projectName, path21) {
     const duration = test.results.reduce((a, r) => a + r.duration, 0);
     const location = this._relativeLocation(test.location);
-    path20 = path20.slice(1).filter((path21) => path21.length > 0);
+    path21 = path21.slice(1).filter((path22) => path22.length > 0);
     const results = test.results.map((r) => this._createTestResult(test, r));
     return {
       testCase: {
@@ -3755,7 +3932,7 @@ var HtmlBuilder = class {
         annotations: this._serializeAnnotations(test.annotations),
         tags: [...new Set(test.tags)],
         outcome: test.outcome(),
-        path: path20,
+        path: path21,
         results,
         repeatEachIndex: test.repeatEachIndex || void 0,
         // Do not include zero.
@@ -3770,7 +3947,7 @@ var HtmlBuilder = class {
         annotations: this._serializeAnnotations(test.annotations),
         tags: [...new Set(test.tags)],
         outcome: test.outcome(),
-        path: path20,
+        path: path21,
         ok: test.outcome() === "expected" || test.outcome() === "flaky",
         repeatEachIndex: test.repeatEachIndex || void 0,
         // Do not include zero.
@@ -3791,21 +3968,21 @@ 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_util8.stripAnsiEscapes)(a.body);
+          lastAttachment.body += (0, import_util9.stripAnsiEscapes)(a.body);
           return null;
         }
-        a.body = (0, import_util8.stripAnsiEscapes)(a.body);
+        a.body = (0, import_util9.stripAnsiEscapes)(a.body);
         lastAttachment = a;
         return a;
       }
       if (a.path) {
         let fileName = a.path;
         try {
-          const buffer = import_fs5.default.readFileSync(a.path);
-          const sha1 = calculateSha12(buffer) + import_path8.default.extname(a.path);
+          const buffer = import_fs6.default.readFileSync(a.path);
+          const sha1 = calculateSha13(buffer) + import_path9.default.extname(a.path);
           fileName = this._attachmentsBaseURL + sha1;
-          import_fs5.default.mkdirSync(import_path8.default.join(this._reportFolder, "data"), { recursive: true });
-          import_fs5.default.writeFileSync(import_path8.default.join(this._reportFolder, "data", sha1), buffer);
+          import_fs6.default.mkdirSync(import_path9.default.join(this._reportFolder, "data"), { recursive: true });
+          import_fs6.default.writeFileSync(import_path9.default.join(this._reportFolder, "data", sha1), buffer);
         } catch (e) {
         }
         return {
@@ -3828,10 +4005,10 @@ var HtmlBuilder = class {
           } catch (e) {
           }
         }
-        import_fs5.default.mkdirSync(import_path8.default.join(this._reportFolder, "data"), { recursive: true });
-        const extension = sanitizeForFilePath2(import_path8.default.extname(a.name).replace(/^\./, "")) || mime2.getExtension(a.contentType) || "dat";
-        const sha1 = calculateSha12(a.body) + "." + extension;
-        import_fs5.default.writeFileSync(import_path8.default.join(this._reportFolder, "data", sha1), a.body);
+        import_fs6.default.mkdirSync(import_path9.default.join(this._reportFolder, "data"), { recursive: true });
+        const extension = sanitizeForFilePath2(import_path9.default.extname(a.name).replace(/^\./, "")) || mime2.getExtension(a.contentType) || "dat";
+        const sha1 = calculateSha13(a.body) + "." + extension;
+        import_fs6.default.writeFileSync(import_path9.default.join(this._reportFolder, "data", sha1), a.body);
         return {
           name: a.name,
           contentType: a.contentType,
@@ -3908,7 +4085,7 @@ var HtmlBuilder = class {
   _relativeLocation(location) {
     if (!location)
       return void 0;
-    const file = toPosixPath2(import_path8.default.relative(this._config.rootDir, location.file));
+    const file = toPosixPath2(import_path9.default.relative(this._config.rootDir, location.file));
     return {
       file,
       line: location.line,
@@ -3988,7 +4165,7 @@ function createSnippets(stepsInFile) {
   for (const file of stepsInFile.keys()) {
     let source;
     try {
-      source = import_fs5.default.readFileSync(file, "utf-8") + "\n//";
+      source = import_fs6.default.readFileSync(file, "utf-8") + "\n//";
     } catch (e) {
       continue;
     }
@@ -4010,7 +4187,7 @@ function createSnippets(stepsInFile) {
 function createErrorCodeframe(message, location) {
   let source;
   try {
-    source = import_fs5.default.readFileSync(location.file, "utf-8") + "\n//";
+    source = import_fs6.default.readFileSync(location.file, "utf-8") + "\n//";
   } catch (e) {
     return;
   }
@@ -4026,18 +4203,18 @@ function createErrorCodeframe(message, location) {
       highlightCode: false,
       linesAbove: 100,
       linesBelow: 100,
-      message: (0, import_util8.stripAnsiEscapes)(message).split("\n")[0] || void 0
+      message: (0, import_util9.stripAnsiEscapes)(message).split("\n")[0] || void 0
     }
   );
 }
-function writeLine(line) {
+function writeLine2(line) {
   process.stdout.write(line + "\n");
 }
 var html_default = HtmlReporter;
 
 // packages/playwright/src/reporters/json.ts
-var import_fs6 = __toESM(require("fs"));
-var import_path9 = __toESM(require("path"));
+var import_fs7 = __toESM(require("fs"));
+var import_path10 = __toESM(require("path"));
 var import_common5 = require("../common");
 var { MultiMap: MultiMap2 } = require("playwright-core/lib/coreBundle").iso;
 var { toPosixPath: toPosixPath3 } = require("playwright-core/lib/coreBundle").utils;
@@ -4130,7 +4307,7 @@ var JSONReporter = class {
     if (!location)
       return { file: "", line: 0, column: 0 };
     return {
-      file: toPosixPath3(import_path9.default.relative(this.config.rootDir, location.file)),
+      file: toPosixPath3(import_path10.default.relative(this.config.rootDir, location.file)),
       line: location.line,
       column: location.column
     };
@@ -4150,7 +4327,7 @@ var JSONReporter = class {
       }
     }
     for (const spec of from.specs || []) {
-      const toSpec = to.specs.find((s) => s.title === spec.title && s.file === toPosixPath3(import_path9.default.relative(this.config.rootDir, spec.file)) && s.line === spec.line && s.column === spec.column);
+      const toSpec = to.specs.find((s) => s.title === spec.title && s.file === toPosixPath3(import_path10.default.relative(this.config.rootDir, spec.file)) && s.line === spec.line && s.column === spec.column);
       if (toSpec)
         toSpec.tests.push(...spec.tests);
       else
@@ -4233,8 +4410,8 @@ var JSONReporter = class {
 async function outputReport(report, resolvedOutputFile) {
   const reportString = JSON.stringify(report, void 0, 2);
   if (resolvedOutputFile) {
-    await import_fs6.default.promises.mkdir(import_path9.default.dirname(resolvedOutputFile), { recursive: true });
-    await import_fs6.default.promises.writeFile(resolvedOutputFile, reportString);
+    await import_fs7.default.promises.mkdir(import_path10.default.dirname(resolvedOutputFile), { recursive: true });
+    await import_fs7.default.promises.writeFile(resolvedOutputFile, reportString);
   } else {
     console.log(reportString);
   }
@@ -4255,9 +4432,9 @@ function serializePatterns(patterns) {
 var json_default = JSONReporter;
 
 // packages/playwright/src/reporters/junit.ts
-var import_fs7 = __toESM(require("fs"));
-var import_path10 = __toESM(require("path"));
-var import_util9 = require("../util");
+var import_fs8 = __toESM(require("fs"));
+var import_path11 = __toESM(require("path"));
+var import_util10 = require("../util");
 var { getAsBooleanFromENV: getAsBooleanFromENV3 } = require("playwright-core/lib/coreBundle").utils;
 var JUnitReporter = class {
   constructor(options) {
@@ -4313,8 +4490,8 @@ var JUnitReporter = class {
     serializeXML(root, tokens, this.stripANSIControlSequences);
     const reportString = tokens.join("\n");
     if (this.resolvedOutputFile) {
-      await import_fs7.default.promises.mkdir(import_path10.default.dirname(this.resolvedOutputFile), { recursive: true });
-      await import_fs7.default.promises.writeFile(this.resolvedOutputFile, reportString);
+      await import_fs8.default.promises.mkdir(import_path11.default.dirname(this.resolvedOutputFile), { recursive: true });
+      await import_fs8.default.promises.writeFile(this.resolvedOutputFile, reportString);
     } else {
       console.log(reportString);
     }
@@ -4425,17 +4602,17 @@ 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, void 0, { omitTags: this.omitTags }))
+        text: (0, import_util10.stripAnsiEscapes)(formatFailure(nonTerminalScreen, this.config, test, void 0, { omitTags: this.omitTags }))
       });
       return errorInfo.elementName;
     }
     entry.children.push({
       name: "failure",
       attributes: {
-        message: `${import_path10.default.basename(test.location.file)}:${test.location.line}:${test.location.column} ${test.title}`,
+        message: `${import_path11.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, void 0, { omitTags: this.omitTags }))
+      text: (0, import_util10.stripAnsiEscapes)(formatFailure(nonTerminalScreen, this.config, test, void 0, { omitTags: this.omitTags }))
     });
     return "failure";
   }
@@ -4450,16 +4627,16 @@ var JUnitReporter = class {
       for (const attachment of result.attachments) {
         if (!attachment.path)
           continue;
-        let attachmentPath = import_path10.default.relative(this.configDir, attachment.path);
+        let attachmentPath = import_path11.default.relative(this.configDir, attachment.path);
         try {
           if (this.resolvedOutputFile)
-            attachmentPath = import_path10.default.relative(import_path10.default.dirname(this.resolvedOutputFile), attachment.path);
+            attachmentPath = import_path11.default.relative(import_path11.default.dirname(this.resolvedOutputFile), attachment.path);
         } catch {
           systemOut.push(`
 Warning: Unable to make attachment path ${attachment.path} relative to report output file ${this.resolvedOutputFile}`);
         }
         try {
-          await import_fs7.default.promises.access(attachment.path);
+          await import_fs8.default.promises.access(attachment.path);
           systemOut.push(`
 [[ATTACHMENT|${attachmentPath}]]
 `);
@@ -4482,7 +4659,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_util9.stripAnsiEscapes)(stackTrace) });
+    entry.children.push({ name: "stackTrace", text: (0, import_util10.stripAnsiEscapes)(stackTrace) });
     await this._appendStdIO(entry, [result]);
     return entry;
   }
@@ -4491,7 +4668,7 @@ function classifyResultError(result) {
   const error = result.error;
   if (!error)
     return null;
-  const rawMessage = (0, import_util9.stripAnsiEscapes)(error.message || error.value || "");
+  const rawMessage = (0, import_util10.stripAnsiEscapes)(error.message || error.value || "");
   const nameMatch = rawMessage.match(/^(\w+): /);
   const errorName = nameMatch ? nameMatch[1] : "";
   const messageBody = nameMatch ? rawMessage.slice(nameMatch[0].length) : rawMessage;
@@ -4533,7 +4710,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_util9.stripAnsiEscapes)(text);
+    text = (0, import_util10.stripAnsiEscapes)(text);
   if (isCharacterData) {
     text = "<![CDATA[" + text.replace(/]]>/g, "]]&gt;") + "]]>";
   } else {
@@ -4656,7 +4833,7 @@ var LineReporter = class extends TerminalReporter {
 var line_default = LineReporter;
 
 // packages/playwright/src/reporters/list.ts
-var import_util10 = require("../util");
+var import_util11 = require("../util");
 var { msToString: msToString3 } = require("playwright-core/lib/coreBundle").iso;
 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;
@@ -4664,7 +4841,8 @@ 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, omitTags: getAsBooleanFromENV5("PLAYWRIGHT_LIST_OMIT_TAGS", options?.omitTags) });
+    const printFailuresInline = getAsBooleanFromENV5("PLAYWRIGHT_LIST_PRINT_FAILURES_INLINE", options?.printFailuresInline);
+    super({ ...options, omitTags: getAsBooleanFromENV5("PLAYWRIGHT_LIST_OMIT_TAGS", options?.omitTags), lastResult: printFailuresInline });
     this._lastRow = 0;
     this._lastColumn = 0;
     this._testRows = /* @__PURE__ */ new Map();
@@ -4672,10 +4850,10 @@ var ListReporter = class extends TerminalReporter {
     this._resultIndex = /* @__PURE__ */ new Map();
     this._stepIndex = /* @__PURE__ */ new Map();
     this._needNewLine = false;
-    this._failureIndex = 0;
+    this._failureIndex = /* @__PURE__ */ new Map();
     this._paused = /* @__PURE__ */ new Set();
     this._printSteps = getAsBooleanFromENV5("PLAYWRIGHT_LIST_PRINT_STEPS", options?.printSteps);
-    this._printFailuresInline = getAsBooleanFromENV5("PLAYWRIGHT_LIST_PRINT_FAILURES_INLINE", options?.printFailuresInline);
+    this._printFailuresInline = printFailuresInline;
   }
   onBegin(suite) {
     super.onBegin(suite);
@@ -4808,7 +4986,12 @@ var ListReporter = class extends TerminalReporter {
   }
   _printFailure(test) {
     this._maybeWriteNewLine();
-    const message = "\n" + this.formatFailure(test, ++this._failureIndex) + "\n";
+    let index = this._failureIndex.get(test);
+    if (index === void 0) {
+      index = this._failureIndex.size + 1;
+      this._failureIndex.set(test, index);
+    }
+    const message = "\n" + this.formatFailure(test, index) + "\n";
     this._updateLineCountAndNewLineFlagForOutput(message);
     this.screen.stdout.write(message);
   }
@@ -4874,7 +5057,7 @@ var ListReporter = class extends TerminalReporter {
       this.screen.stdout.write(`\x1B[${this._lastRow - row}E`);
   }
   _testPrefix(index, statusMark) {
-    const statusMarkLength = (0, import_util10.stripAnsiEscapes)(statusMark).length;
+    const statusMarkLength = (0, import_util11.stripAnsiEscapes)(statusMark).length;
     const indexLength = Math.ceil(Math.log10(this.totalTestCount + 1));
     return "  " + statusMark + " ".repeat(3 - statusMarkLength) + this.screen.colors.dim(index.padStart(indexLength) + " ");
   }
@@ -4898,7 +5081,7 @@ var lastStepOrdinalSymbol = /* @__PURE__ */ Symbol("lastStepOrdinal");
 var list_default = ListReporter;
 
 // packages/playwright/src/reporters/listModeReporter.ts
-var import_path11 = __toESM(require("path"));
+var import_path12 = __toESM(require("path"));
 var ListModeReporter = class {
   constructor(options = {}) {
     this._options = options;
@@ -4916,7 +5099,7 @@ var ListModeReporter = class {
     const files = /* @__PURE__ */ new Set();
     for (const test of tests) {
       const [, projectName, , ...titles] = test.titlePath();
-      const location = `${import_path11.default.relative(this.config.rootDir, test.location.file)}:${test.location.line}:${test.location.column}`;
+      const location = `${import_path12.default.relative(this.config.rootDir, test.location.file)}:${test.location.line}:${test.location.column}`;
       const testId = this._options.includeTestId ? `[id=${test.id}] ` : "";
       const projectLabel = this._options.includeTestId ? `project=` : "";
       const projectTitle = projectName ? `[${projectLabel}${projectName}] \u203A ` : "";
@@ -4935,11 +5118,12 @@ 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_events2 = require("events");
+var import_fs9 = __toESM(require("fs"));
+var import_path13 = __toESM(require("path"));
 var import_zlib = __toESM(require("zlib"));
 var import_coreBundle2 = require("playwright-core/lib/coreBundle");
-var import_util11 = require("../util");
+var import_util12 = require("../util");
 var { toPosixPath: toPosixPath4 } = require("playwright-core/lib/coreBundle").utils;
 var kStatusColors = {
   passed: "good",
@@ -5107,10 +5291,10 @@ var PerfettoReporter = class {
     return `${this._relativePath(location.file)}:${location.line}:${location.column}`;
   }
   _formatError(error) {
-    return (0, import_util11.stripAnsiEscapes)(formatError(nonTerminalScreen, error).message);
+    return (0, import_util12.stripAnsiEscapes)(formatError(nonTerminalScreen, error).message);
   }
   _relativePath(file) {
-    return toPosixPath4(import_path12.default.relative(this._config.rootDir, file));
+    return toPosixPath4(import_path13.default.relative(this._config.rootDir, file));
   }
   async _writeReport(result) {
     let timeOrigin2 = result.startTime.getTime();
@@ -5136,7 +5320,7 @@ var PerfettoReporter = class {
       "duration": result.duration,
       "status": result.status
     };
-    await import_fs8.default.promises.mkdir(import_path12.default.dirname(this._resolvedOutputFile), { recursive: true });
+    await import_fs9.default.promises.mkdir(import_path13.default.dirname(this._resolvedOutputFile), { recursive: true });
     const writer = new ChunkWriter(this._resolvedOutputFile);
     await writer.write('{"traceEvents":[');
     let separator2 = "";
@@ -5152,10 +5336,12 @@ var PerfettoReporter = class {
 };
 var ChunkWriter = class {
   constructor(file) {
-    const fileStream = import_fs8.default.createWriteStream(file);
+    const fileStream = import_fs9.default.createWriteStream(file);
     const gzip = file.endsWith(".gz") ? import_zlib.default.createGzip() : void 0;
     gzip?.pipe(fileStream);
     this._stream = gzip ?? fileStream;
+    if (gzip)
+      fileStream.on("error", (error) => gzip.destroy(error));
     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);
@@ -5164,7 +5350,7 @@ var ChunkWriter = class {
     if (this._error)
       throw this._error;
     if (!this._stream.write(chunk))
-      await new Promise((resolve) => this._stream.once("drain", () => resolve()));
+      await (0, import_events2.once)(this._stream, "drain");
   }
   async close() {
     this._stream.end();
@@ -5191,7 +5377,7 @@ function concatChunks(chunks) {
 var perfetto_default = PerfettoReporter;
 
 // packages/playwright/src/runner/reporters.ts
-var { calculateSha1: calculateSha13 } = require("playwright-core/lib/coreBundle").utils;
+var { calculateSha1: calculateSha14 } = require("playwright-core/lib/coreBundle").utils;
 async function createReporters(config2, mode, descriptions, runOptions) {
   const defaultReporters = {
     "blob": BlobReporter,
@@ -5203,7 +5389,8 @@ async function createReporters(config2, mode, descriptions, runOptions) {
     "json": json_default,
     "junit": junit_default,
     "null": empty_default,
-    "html": html_default
+    "html": html_default,
+    "coverage": coverage_default
   };
   const reporters = [];
   descriptions ??= config2.config.reporter;
@@ -5270,22 +5457,22 @@ function computeCommandHash(config2, runOptions) {
   if (config2.config.tags.length)
     command.tags = config2.config.tags.join(" ");
   if (runOptions?.testList)
-    command.testList = calculateSha13(import_fs9.default.readFileSync(runOptions.testList));
+    command.testList = calculateSha14(import_fs10.default.readFileSync(runOptions.testList));
   if (runOptions?.testListInvert)
-    command.testListInvert = calculateSha13(import_fs9.default.readFileSync(runOptions.testListInvert));
+    command.testListInvert = calculateSha14(import_fs10.default.readFileSync(runOptions.testListInvert));
   if (Object.keys(command).length)
-    parts.push(calculateSha13(JSON.stringify(command)).substring(0, 7));
+    parts.push(calculateSha14(JSON.stringify(command)).substring(0, 7));
   return parts.join("-");
 }
 
 // packages/playwright/src/runner/tasks.ts
-var import_fs12 = __toESM(require("fs"));
-var import_path16 = __toESM(require("path"));
-var import_util14 = require("util");
+var import_fs13 = __toESM(require("fs"));
+var import_path17 = __toESM(require("path"));
+var import_util15 = require("util");
 
 // packages/playwright/src/runner/rebase.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 babel3 = __toESM(require("../transform/babelBundle"));
 var colors3 = require("playwright-core/lib/utilsBundle").colors;
 var diff = require("playwright-core/lib/utilsBundle").diff;
@@ -5309,16 +5496,16 @@ async function applySuggestedRebaselines(config2, reporter, filteredProjects) {
   const patches = [];
   const files = [];
   const gitCache = /* @__PURE__ */ new Map();
-  const patchFile = import_path13.default.join(project.project.outputDir, "rebaselines.patch");
+  const patchFile = import_path14.default.join(project.project.outputDir, "rebaselines.patch");
   for (const fileName of [...suggestedRebaselines.keys()].sort()) {
-    const source = await import_fs10.default.promises.readFile(fileName, "utf8");
+    const source = await import_fs11.default.promises.readFile(fileName, "utf8");
     const lines = source.split("\n");
     const replacements = suggestedRebaselines.get(fileName);
     const fileNode = babel3.babelParse(source, fileName, true);
     const ranges = [];
     babel3.traverse(fileNode, {
-      CallExpression: (path20) => {
-        const node = path20.node;
+      CallExpression: (path21) => {
+        const node = path21.node;
         if (node.arguments.length < 1)
           return;
         if (!t.isMemberExpression(node.callee))
@@ -5345,15 +5532,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_path13.default.relative(process.cwd(), fileName);
+    const relativeName = import_path14.default.relative(process.cwd(), fileName);
     files.push(relativeName);
     if (config2.config.updateSourceMethod === "overwrite") {
-      await import_fs10.default.promises.writeFile(fileName, result);
+      await import_fs11.default.promises.writeFile(fileName, result);
     } else if (config2.config.updateSourceMethod === "3way") {
-      await import_fs10.default.promises.writeFile(fileName, applyPatchWithConflictMarkers(source, result));
+      await import_fs11.default.promises.writeFile(fileName, applyPatchWithConflictMarkers(source, result));
     } else {
-      const gitFolder = findGitRoot(import_path13.default.dirname(fileName), gitCache);
-      const relativeToGit = import_path13.default.relative(gitFolder || process.cwd(), fileName);
+      const gitFolder = findGitRoot(import_path14.default.dirname(fileName), gitCache);
+      const relativeToGit = import_path14.default.relative(gitFolder || process.cwd(), fileName);
       patches.push(createPatch(relativeToGit, source, result));
     }
   }
@@ -5364,10 +5551,10 @@ New baselines created for:
 ${fileList}
 `);
   if (config2.config.updateSourceMethod === "patch") {
-    await import_fs10.default.promises.mkdir(import_path13.default.dirname(patchFile), { recursive: true });
-    await import_fs10.default.promises.writeFile(patchFile, patches.join("\n"));
+    await import_fs11.default.promises.mkdir(import_path14.default.dirname(patchFile), { recursive: true });
+    await import_fs11.default.promises.writeFile(patchFile, patches.join("\n"));
     reporter.onStdErr(`
-  ` + colors3.cyan("git apply " + import_path13.default.relative(process.cwd(), patchFile)) + "\n");
+  ` + colors3.cyan("git apply " + import_path14.default.relative(process.cwd(), patchFile)) + "\n");
   }
 }
 function createPatch(fileName, before, after) {
@@ -5384,12 +5571,12 @@ function findGitRoot(dir, cache) {
   const result = cache.get(dir);
   if (result !== void 0)
     return result;
-  const gitPath = import_path13.default.join(dir, ".git");
-  if (import_fs10.default.existsSync(gitPath) && import_fs10.default.lstatSync(gitPath).isDirectory()) {
+  const gitPath = import_path14.default.join(dir, ".git");
+  if (import_fs11.default.existsSync(gitPath) && import_fs11.default.lstatSync(gitPath).isDirectory()) {
     cache.set(dir, dir);
     return dir;
   }
-  const parentDir = import_path13.default.dirname(dir);
+  const parentDir = import_path14.default.dirname(dir);
   if (dir === parentDir) {
     cache.set(dir, null);
     return null;
@@ -5433,8 +5620,8 @@ function applyPatchWithConflictMarkers(oldText, newText) {
 }
 
 // packages/playwright/src/runner/workerHost.ts
-var import_fs11 = __toESM(require("fs"));
-var import_path14 = __toESM(require("path"));
+var import_fs12 = __toESM(require("fs"));
+var import_path15 = __toESM(require("path"));
 var import_common6 = require("../common");
 
 // packages/playwright/src/isomorphic/folders.ts
@@ -5463,13 +5650,13 @@ var WorkerHost = class extends ProcessHost {
       repeatEachIndex: testGroup.repeatEachIndex,
       projectId: testGroup.projectId,
       config: options.config,
-      artifactsDir: import_path14.default.join(options.outputDir, artifactsFolderName(workerIndex)),
+      artifactsDir: import_path15.default.join(options.outputDir, artifactsFolderName(workerIndex)),
       pauseOnError: options.pauseOnError,
       pauseAtEnd: options.pauseAtEnd
     };
   }
   async start() {
-    await import_fs11.default.promises.mkdir(this._params.artifactsDir, { recursive: true });
+    await import_fs12.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))
@@ -5505,7 +5692,7 @@ var WorkerHost = class extends ProcessHost {
 
 // packages/playwright/src/runner/dispatcher.ts
 var import_common7 = require("../common");
-var import_util12 = require("../util");
+var import_util13 = 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;
@@ -5994,7 +6181,7 @@ var JobDispatcher = class {
           addLocationAndSnippetToError(this._testRun.config.config, response.error);
         return response;
       } catch (e) {
-        const error = (0, import_util12.serializeError)(e);
+        const error = (0, import_util13.serializeError)(e);
         addLocationAndSnippetToError(this._testRun.config.config, error);
         return { response: void 0, error };
       }
@@ -6113,11 +6300,11 @@ var FixedNodeSIGINTHandler = class {
 };
 
 // packages/playwright/src/runner/taskRunner.ts
-var import_util13 = require("../util");
+var import_util14 = 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;
-var { monotonicTime: monotonicTime5 } = require("playwright-core/lib/coreBundle").iso;
+var { monotonicTime: monotonicTime4 } = require("playwright-core/lib/coreBundle").iso;
 var TaskRunner = class _TaskRunner {
   constructor(reporter, globalTimeoutForError) {
     this._tasks = [];
@@ -6154,7 +6341,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_util13.serializeError)(e));
+          errors.push((0, import_util14.serializeError)(e));
         } finally {
           for (const error of [...softErrors, ...errors])
             this._reporter.onError?.(error);
@@ -6196,7 +6383,7 @@ var TimeoutWatcher = class {
     this.promise = new ManualPromise4();
     if (!deadline)
       return;
-    if (deadline - monotonicTime5() <= 0) {
+    if (deadline - monotonicTime4() <= 0) {
       this._timedOut = true;
       this.promise.resolve();
       return;
@@ -6204,7 +6391,7 @@ var TimeoutWatcher = class {
     this._timer = setTimeout(() => {
       this._timedOut = true;
       this.promise.resolve();
-    }, deadline - monotonicTime5());
+    }, deadline - monotonicTime4());
   }
   timedOut() {
     return this._timedOut;
@@ -6216,7 +6403,7 @@ var TimeoutWatcher = class {
 
 // packages/playwright/src/runner/vcs.ts
 var import_child_process2 = __toESM(require("child_process"));
-var import_path15 = __toESM(require("path"));
+var import_path16 = __toESM(require("path"));
 var import_common8 = require("../common");
 async function detectChangedTestFiles(baseCommit, configDir) {
   function gitFileList(args) {
@@ -6246,20 +6433,20 @@ async function detectChangedTestFiles(baseCommit, configDir) {
       ].join("\n"));
     }
   }
-  const untrackedFiles = gitFileList(["ls-files", "--others", "--exclude-standard"]).map((file) => import_path15.default.join(configDir, file));
+  const untrackedFiles = gitFileList(["ls-files", "--others", "--exclude-standard"]).map((file) => import_path16.default.join(configDir, file));
   const [gitRoot] = gitFileList(["rev-parse", "--show-toplevel"]);
-  const trackedFilesWithChanges = gitFileList(["diff", baseCommit, "--name-only"]).map((file) => import_path15.default.join(gitRoot, file));
+  const trackedFilesWithChanges = gitFileList(["diff", baseCommit, "--name-only"]).map((file) => import_path16.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_util15 = require("../util");
+var import_util16 = 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 { monotonicTime: monotonicTime5 } = require("playwright-core/lib/coreBundle").iso;
 var { removeFolders: removeFolders4 } = require("playwright-core/lib/coreBundle").utils;
-var readDirAsync2 = (0, import_util14.promisify)(import_fs12.default.readdir);
+var readDirAsync2 = (0, import_util15.promisify)(import_fs13.default.readdir);
 var TestRun = class {
   constructor(config2, reporter, options) {
     this.rootSuite = void 0;
@@ -6275,7 +6462,8 @@ var TestRun = class {
     this.config = config2;
     this.options = options ?? {};
     this.reporter = reporter;
-    this.filteredProjects = filterProjects(config2.projects, this.options.projectFilter);
+    this.filteredProjects = filterProjects(config2.projects, this.options.projectFilter, this.options.includeNonDefaultProjects);
+    config2.config.filteredProjects = this.filteredProjects.map((p) => p.project);
   }
   onTestPaused(params) {
     this.options.onTestPaused?.(params);
@@ -6291,7 +6479,7 @@ var TestRun = class {
   }
 };
 async function runTasks(testRun, tasks, globalTimeout, cancelPromise) {
-  const deadline = globalTimeout ? monotonicTime6() + globalTimeout : 0;
+  const deadline = globalTimeout ? monotonicTime5() + globalTimeout : 0;
   const taskRunner = new TaskRunner(testRun.reporter, globalTimeout || 0);
   for (const task of tasks)
     taskRunner.addTask(task);
@@ -6337,7 +6525,7 @@ function createClearCacheTask(config2) {
   return {
     title: "clear cache",
     setup: async () => {
-      await (0, import_util15.removeDirAndLogToConsole)(import_common9.cc.cacheDir);
+      await (0, import_util16.removeDirAndLogToConsole)(import_common9.cc.cacheDir);
     }
   };
 }
@@ -6408,7 +6596,7 @@ function createRemoveOutputDirsTask() {
           return;
         if (error.code === "EBUSY") {
           const entries = await readDirAsync2(outputDir).catch((e) => []);
-          await Promise.all(entries.map((entry) => removeFolders4([import_path16.default.join(outputDir, entry)])));
+          await Promise.all(entries.map((entry) => removeFolders4([import_path17.default.join(outputDir, entry)])));
         } else {
           throw error;
         }
@@ -6427,7 +6615,7 @@ function createListFilesTask() {
         projectSuite._fullProject = project;
         testRun.rootSuite._addSuite(projectSuite);
         const suites = files.map((file) => {
-          const title = import_path16.default.relative(testRun.config.config.rootDir, file);
+          const title = import_path17.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 +6645,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_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;
+        const grepMatcher = testRun.options.grep ? (0, import_util16.createTitleMatcher)((0, import_util16.forceRegExp)(testRun.options.grep)) : () => true;
+        const grepInvertMatcher = testRun.options.grepInvert ? (0, import_util16.createTitleMatcher)((0, import_util16.forceRegExp)(testRun.options.grepInvert)) : () => false;
         testRun.preOnlyTestFilters.push((test) => {
           const grepTitle = test._grepTitleWithTags();
           return !grepInvertMatcher(grepTitle) && grepMatcher(grepTitle);
@@ -6545,6 +6733,8 @@ function createPhasesTask() {
         }
       }
       testRun.config.config.metadata.actualWorkers = Math.min(testRun.config.config.workers, maxConcurrentTestGroups);
+      if (testRun.config.configCLIOverrides.shuffle)
+        testRun.config.config.metadata.shuffleSeed = testRun.config.configCLIOverrides.shuffle;
     }
   };
 }
@@ -6568,6 +6758,8 @@ function createRunTestsTask() {
           if (!hasFailedDeps)
             phaseTestGroups.push(...testGroups);
         }
+        if (testRun.config.configCLIOverrides.shuffle)
+          shuffleTestGroups(phaseTestGroups, testRun.config.configCLIOverrides.shuffle);
         if (phaseTestGroups.length) {
           await dispatcher.run(phaseTestGroups, extraEnvByProjectId);
           await dispatcher.stop();
@@ -6593,8 +6785,8 @@ function createRunTestsTask() {
 }
 
 // packages/playwright/src/runner/lastRun.ts
-var import_fs13 = __toESM(require("fs"));
-var import_path17 = __toESM(require("path"));
+var import_fs14 = __toESM(require("fs"));
+var import_path18 = __toESM(require("path"));
 function didNotRun(test) {
   if (test.outcome() !== "skipped")
     return false;
@@ -6607,18 +6799,18 @@ var LastRunReporter = class {
     this._listMode = !!listMode;
     const override = lastFailedFileOverride ?? process.env.PLAYWRIGHT_LAST_RUN_OUTPUT_FILE;
     if (override) {
-      this._lastRunFile = import_path17.default.resolve(process.cwd(), override);
+      this._lastRunFile = import_path18.default.resolve(process.cwd(), override);
     } else {
       const [project] = filteredProjects;
       if (project)
-        this._lastRunFile = import_path17.default.join(project.project.outputDir, ".last-run.json");
+        this._lastRunFile = import_path18.default.join(project.project.outputDir, ".last-run.json");
     }
   }
   async filterLastFailed() {
     if (!this._lastRunFile)
       return void 0;
     try {
-      const lastRunInfo = JSON.parse(await import_fs13.default.promises.readFile(this._lastRunFile, "utf8"));
+      const lastRunInfo = JSON.parse(await import_fs14.default.promises.readFile(this._lastRunFile, "utf8"));
       return lastRunInfo.failedTests;
     } catch {
       return void 0;
@@ -6640,8 +6832,8 @@ var LastRunReporter = class {
       status: result.status,
       failedTests: this._suite?.allTests().filter((t2) => !t2.ok() || didNotRun(t2)).map((t2) => t2.id) || []
     };
-    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));
+    await import_fs14.default.promises.mkdir(import_path18.default.dirname(this._lastRunFile), { recursive: true });
+    await import_fs14.default.promises.writeFile(this._lastRunFile, JSON.stringify(lastRunInfo, void 0, 2));
   }
 };
 
@@ -6653,7 +6845,7 @@ var TestRunnerEvent = {
   TestFilesChanged: "testFilesChanged",
   TestPaused: "testPaused"
 };
-var TestRunner = class extends import_events2.default {
+var TestRunner = class extends import_events3.default {
   constructor(configLocation, configCLIOverrides) {
     super();
     this._watchedProjectDirs = /* @__PURE__ */ new Set();
@@ -6742,7 +6934,7 @@ var TestRunner = class extends import_events2.default {
     const config2 = await this._loadConfigOrReportError(reporter);
     if (!config2)
       return { status: "failed" };
-    const options = { projectFilter: projects?.length ? projects : void 0 };
+    const options = { projectFilter: projects?.length ? projects : void 0, includeNonDefaultProjects: true };
     const status = await runTasks(new TestRun(config2, reporter, options), [
       createListFilesTask(),
       createReportBeginTask()
@@ -6775,6 +6967,8 @@ var TestRunner = class extends import_events2.default {
       grep: params.grep,
       grepInvert: params.grepInvert,
       projectFilter: params.projects?.length ? params.projects : void 0,
+      // Non-default projects are listed so that they can be selected by name.
+      includeNonDefaultProjects: true,
       onlyChanged: params.onlyChanged ? "HEAD" : void 0,
       listMode: true
     };
@@ -6910,7 +7104,7 @@ var TestRunner = class extends import_events2.default {
       this._lastLoadedConfig = config2;
       return { config: config2 };
     } catch (e) {
-      return { config: null, error: (0, import_util16.serializeError)(e) };
+      return { config: null, error: (0, import_util17.serializeError)(e) };
     }
   }
   lastLoadedConfig() {
@@ -6966,7 +7160,7 @@ __export(testServer_exports, {
   runTestServer: () => runTestServer,
   runUIMode: () => runUIMode
 });
-var import_util17 = __toESM(require("util"));
+var import_util18 = __toESM(require("util"));
 var import_coreBundle4 = require("playwright-core/lib/coreBundle");
 var import_common11 = require("../common");
 
@@ -7126,7 +7320,7 @@ var TestServerDispatcher = class {
     if (interceptStdio) {
       if (debug6.log === originalDebugLog) {
         debug6.log = (...args) => {
-          const string = import_util17.default.format(...args) + "\n";
+          const string = import_util18.default.format(...args) + "\n";
           return originalStderrWrite.apply(process.stderr, [string]);
         };
       }
@@ -7219,9 +7413,9 @@ var watchMode_exports = {};
 __export(watchMode_exports, {
   runWatchModeLoop: () => runWatchModeLoop
 });
-var import_path18 = __toESM(require("path"));
+var import_path19 = __toESM(require("path"));
 var import_readline = __toESM(require("readline"));
-var import_events3 = require("events");
+var import_events4 = require("events");
 var import_coreBundle5 = require("playwright-core/lib/coreBundle");
 
 // packages/playwright/src/isomorphic/testTree.ts
@@ -7568,7 +7762,7 @@ var { ManualPromise: ManualPromise8 } = require("playwright-core/lib/coreBundle"
 var { createGuid: createGuid3 } = require("playwright-core/lib/coreBundle").utils;
 var { getPackageManagerExecCommand: getPackageManagerExecCommand3 } = require("playwright-core/lib/coreBundle").utils;
 var { eventsHelper: eventsHelper2 } = require("playwright-core/lib/coreBundle").utils;
-var InMemoryTransport = class extends import_events3.EventEmitter {
+var InMemoryTransport = class extends import_events4.EventEmitter {
   constructor(send) {
     super();
     this._send = send;
@@ -7611,7 +7805,7 @@ async function runWatchModeLoop(configLocation, initialOptions) {
   };
   const testServerConnection = new TestServerConnection(transport);
   transport.emit("open");
-  const teleSuiteUpdater = new TeleSuiteUpdater({ pathSeparator: import_path18.default.sep, onUpdate() {
+  const teleSuiteUpdater = new TeleSuiteUpdater({ pathSeparator: import_path19.default.sep, onUpdate() {
   } });
   const dirtyTestFiles = /* @__PURE__ */ new Set();
   const dirtyTestIds = /* @__PURE__ */ new Set();
@@ -7887,7 +8081,7 @@ function printBufferPrompt(dirtyTestFiles, rootDir) {
 
 `);
   for (const file of dirtyTestFiles)
-    process.stdout.write(` \xB7 ${import_path18.default.relative(rootDir, file)}
+    process.stdout.write(` \xB7 ${import_path19.default.relative(rootDir, file)}
 `);
   process.stdout.write(`
 ${colors6.dim(`Press`)} ${colors6.bold("enter")} ${colors6.dim("to run")}, ${colors6.bold("q")} ${colors6.dim("to quit or")} ${colors6.bold("h")} ${colors6.dim("for more options.")}
@@ -7921,8 +8115,8 @@ var merge_exports = {};
 __export(merge_exports, {
   createMergedReport: () => createMergedReport
 });
-var import_fs14 = __toESM(require("fs"));
-var import_path19 = __toESM(require("path"));
+var import_fs15 = __toESM(require("fs"));
+var import_path20 = __toESM(require("path"));
 
 // packages/playwright/src/isomorphic/stringInternPool.ts
 var StringInternPool = class {
@@ -7967,9 +8161,9 @@ var JsonStringInternalizer = class {
 };
 
 // packages/playwright/src/reporters/merge.ts
-var import_util18 = require("../util");
+var import_util19 = require("../util");
 var { isPathInside } = require("playwright-core/lib/coreBundle").utils;
-var { ZipFile } = require("playwright-core/lib/coreBundle").utils;
+var { ZipFile: ZipFile2 } = require("playwright-core/lib/coreBundle").utils;
 async function createMergedReport(config2, dir, reporterDescriptions, rootDirOverride) {
   const reporters = await createReporters(config2, "merge", reporterDescriptions);
   const multiplexer = new Multiplexer(reporters);
@@ -7984,8 +8178,8 @@ async function createMergedReport(config2, dir, reporterDescriptions, rootDirOve
   if (shardFiles.length === 0)
     throw new Error(`No report files found in ${dir}`);
   const eventData = await mergeEvents(dir, shardFiles, stringPool, printStatus, rootDirOverride);
-  const pathSeparator = rootDirOverride ? import_path19.default.sep : eventData.pathSeparatorFromMetadata ?? import_path19.default.sep;
-  const pathPackage = pathSeparator === "/" ? import_path19.default.posix : import_path19.default.win32;
+  const pathSeparator = rootDirOverride ? import_path20.default.sep : eventData.pathSeparatorFromMetadata ?? import_path20.default.sep;
+  const pathPackage = pathSeparator === "/" ? import_path20.default.posix : import_path20.default.win32;
   const receiver = new TeleReporterReceiver(multiplexer, {
     mergeProjects: false,
     mergeTestCases: false,
@@ -8013,7 +8207,7 @@ async function createMergedReport(config2, dir, reporterDescriptions, rootDirOve
       reportPath: zipFile,
       config: asFullConfig(config3)
     });
-    const reportJsonl = await import_fs14.default.promises.readFile(reportFile);
+    const reportJsonl = await import_fs15.default.promises.readFile(reportFile);
     const events = parseTestEvents(reportJsonl);
     new JsonStringInternalizer(stringPool).traverse(events);
     eventPatchers.patchers.push(new AttachmentPathPatcher(dir));
@@ -8059,15 +8253,15 @@ function splitBufferLines(buffer) {
 }
 async function extractAndParseReports(dir, shardFiles, internalizer, printStatus) {
   const shardEvents = [];
-  await import_fs14.default.promises.mkdir(import_path19.default.join(dir, "resources"), { recursive: true });
+  await import_fs15.default.promises.mkdir(import_path20.default.join(dir, "resources"), { recursive: true });
   const reportNames = new UniqueFileNameGenerator();
   for (const file of shardFiles) {
-    const absolutePath = import_path19.default.join(dir, file);
-    printStatus(`extracting: ${(0, import_util18.relativeFilePath)(absolutePath)}`);
-    const zipFile = new ZipFile(absolutePath);
+    const absolutePath = import_path20.default.join(dir, file);
+    printStatus(`extracting: ${(0, import_util19.relativeFilePath)(absolutePath)}`);
+    const zipFile = new ZipFile2(absolutePath);
     const entryNames = await zipFile.entries();
     for (const entryName of entryNames.sort()) {
-      let reportFile = import_path19.default.join(dir, entryName);
+      let reportFile = import_path20.default.join(dir, entryName);
       const content = await zipFile.read(entryName);
       if (entryName.endsWith(".jsonl")) {
         reportFile = reportNames.makeUnique(reportFile);
@@ -8082,7 +8276,7 @@ async function extractAndParseReports(dir, shardFiles, internalizer, printStatus
           parsedEvents
         });
       }
-      await import_fs14.default.promises.writeFile(reportFile, content);
+      await import_fs15.default.promises.writeFile(reportFile, content);
     }
     zipFile.close();
   }
@@ -8249,7 +8443,7 @@ function mergeEndEvents(endEvents) {
   };
 }
 async function sortedShardFiles(dir) {
-  const files = await import_fs14.default.promises.readdir(dir);
+  const files = await import_fs15.default.promises.readdir(dir);
   return files.filter((file) => file.endsWith(".zip")).sort();
 }
 function printStatusToStdout(message) {
@@ -8265,7 +8459,7 @@ var UniqueFileNameGenerator = class {
       this._usedNames.add(name);
       return name;
     }
-    const extension = import_path19.default.extname(name);
+    const extension = import_path20.default.extname(name);
     name = name.substring(0, name.length - extension.length);
     let index = 0;
     while (true) {
@@ -8348,11 +8542,11 @@ var AttachmentPathPatcher = class {
       this._patchAttachments(event.params.result.attachments ?? []);
   }
   _patchAttachments(attachments) {
-    const resourceRoot = import_path19.default.resolve(this._resourceDir);
+    const resourceRoot = import_path20.default.resolve(this._resourceDir);
     for (const attachment of attachments) {
       if (!attachment.path)
         continue;
-      const joined = import_path19.default.resolve(resourceRoot, attachment.path);
+      const joined = import_path20.default.resolve(resourceRoot, attachment.path);
       if (!isPathInside(resourceRoot, joined)) {
         attachment.path = void 0;
         continue;
@@ -8363,8 +8557,8 @@ var AttachmentPathPatcher = class {
 };
 var PathSeparatorPatcher = class {
   constructor(from) {
-    this._from = from ?? (import_path19.default.sep === "/" ? "\\" : "/");
-    this._to = import_path19.default.sep;
+    this._from = from ?? (import_path20.default.sep === "/" ? "\\" : "/");
+    this._to = import_path20.default.sep;
   }
   patchEvent(jsonEvent) {
     if (this._from === this._to)