@piwitests/reporter 0.53.0 → 0.55.0

package/dist/cli/index.js

@@ -453,9 +453,9 @@ var path6 = __toESM(require("path"));
 function defaultDesktopConfigPath() {
   return path6.join(os.homedir(), ".piwi", "desktop.json");
 }
-function readDesktopConfig(filePath) {
+function readDesktopConfig(filePath2) {
   try {
-    const parsed = JSON.parse(fs3.readFileSync(filePath, "utf8"));
+    const parsed = JSON.parse(fs3.readFileSync(filePath2, "utf8"));
     const url = parsed?.url;
     const token = parsed?.token;
     if (typeof url !== "string" || !url) return null;
@@ -708,9 +708,9 @@ function realFolder(dir) {
   return path7.join(fs4.realpathSync(current), ...rest);
 }
 function folderInRepository(root, dir) {
-  const relative6 = path7.relative(realFolder(root), realFolder(dir));
-  if (relative6.startsWith("..") || path7.isAbsolute(relative6)) return void 0;
-  return relative6.split(path7.sep).join("/");
+  const relative8 = path7.relative(realFolder(root), realFolder(dir));
+  if (relative8.startsWith("..") || path7.isAbsolute(relative8)) return void 0;
+  return relative8.split(path7.sep).join("/");
 }
 function fileFilter(file) {
   const escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -735,12 +735,12 @@ function runPlaywright(file, cwd, id, env) {
     cwd,
     env: childEnv
   });
-  return new Promise((resolve8) => {
+  return new Promise((resolve10) => {
     child.on("error", (err) => {
       console.error(`piwi bug: could not start Playwright \u2014 ${err.message}`);
-      resolve8(EXIT_ERROR2);
+      resolve10(EXIT_ERROR2);
     });
-    child.on("exit", (code) => resolve8(code ?? EXIT_ERROR2));
+    child.on("exit", (code) => resolve10(code ?? EXIT_ERROR2));
   });
 }
 async function runBug(argv, env = process.env, cwd = process.cwd()) {
@@ -2285,43 +2285,43 @@ var Checker = class {
   constructor() {
     this.errors = [];
   }
-  fail(path19, message) {
-    if (this.errors.length < 20) this.errors.push(`${path19}: ${message}`);
+  fail(path23, message) {
+    if (this.errors.length < 20) this.errors.push(`${path23}: ${message}`);
   }
-  text(v, path19, max, nullable) {
+  text(v, path23, max, nullable) {
     if (v == null) {
-      if (!nullable) this.fail(path19, "is required");
+      if (!nullable) this.fail(path23, "is required");
       return null;
     }
     if (typeof v !== "string") {
-      this.fail(path19, "must be a string");
+      this.fail(path23, "must be a string");
       return null;
     }
-    if (v.length > max) this.fail(path19, `is longer than ${max} characters`);
+    if (v.length > max) this.fail(path23, `is longer than ${max} characters`);
     return v;
   }
-  number(v, path19) {
+  number(v, path23) {
     if (typeof v !== "number" || !Number.isFinite(v)) {
-      this.fail(path19, "must be a number");
+      this.fail(path23, "must be a number");
       return 0;
     }
     return v;
   }
 };
-function checkTarget(c, v, path19) {
+function checkTarget(c, v, path23) {
   if (v == null) return null;
   if (!isObject(v)) {
-    c.fail(path19, "must be an object");
+    c.fail(path23, "must be an object");
     return null;
   }
   const alternativesIn = v.alternatives ?? [];
   const alternatives = [];
-  if (!Array.isArray(alternativesIn)) c.fail(`${path19}.alternatives`, "must be a list");
+  if (!Array.isArray(alternativesIn)) c.fail(`${path23}.alternatives`, "must be a list");
   else if (alternativesIn.length > STEPS_LIMITS.alternatives)
-    c.fail(`${path19}.alternatives`, `holds more than ${STEPS_LIMITS.alternatives}`);
+    c.fail(`${path23}.alternatives`, `holds more than ${STEPS_LIMITS.alternatives}`);
   else {
     alternativesIn.forEach((alt, i) => {
-      const at = `${path19}.alternatives[${i}]`;
+      const at = `${path23}.alternatives[${i}]`;
       if (!isObject(alt)) return c.fail(at, "must be an object");
       const locator = c.text(alt.locator, `${at}.locator`, STEPS_LIMITS.textLength, false);
       const safe = locator ? safeLocator(locator) : null;
@@ -2335,31 +2335,31 @@ function checkTarget(c, v, path19) {
     });
   }
   return {
-    tagName: c.text(v.tagName, `${path19}.tagName`, 64, false) ?? "",
-    role: c.text(v.role, `${path19}.role`, 64, true),
-    accessibleName: c.text(v.accessibleName, `${path19}.accessibleName`, STEPS_LIMITS.textLength, true),
-    testId: c.text(v.testId, `${path19}.testId`, STEPS_LIMITS.textLength, true),
-    text: c.text(v.text, `${path19}.text`, STEPS_LIMITS.textLength, true),
+    tagName: c.text(v.tagName, `${path23}.tagName`, 64, false) ?? "",
+    role: c.text(v.role, `${path23}.role`, 64, true),
+    accessibleName: c.text(v.accessibleName, `${path23}.accessibleName`, STEPS_LIMITS.textLength, true),
+    testId: c.text(v.testId, `${path23}.testId`, STEPS_LIMITS.textLength, true),
+    text: c.text(v.text, `${path23}.text`, STEPS_LIMITS.textLength, true),
     alternatives
   };
 }
-function checkAssertion(c, v, path19) {
+function checkAssertion(c, v, path23) {
   if (!isObject(v)) {
-    c.fail(path19, "is required on an assert step");
+    c.fail(path23, "is required on an assert step");
     return void 0;
   }
   const matcher = v.matcher;
   if (!ASSERTION_MATCHERS.includes(matcher)) {
-    c.fail(`${path19}.matcher`, `must be one of ${ASSERTION_MATCHERS.join(", ")}`);
+    c.fail(`${path23}.matcher`, `must be one of ${ASSERTION_MATCHERS.join(", ")}`);
     return void 0;
   }
-  const expected = c.text(v.expected, `${path19}.expected`, STEPS_LIMITS.valueLength, !VALUE_MATCHERS.has(matcher));
+  const expected = c.text(v.expected, `${path23}.expected`, STEPS_LIMITS.valueLength, !VALUE_MATCHERS.has(matcher));
   return {
     matcher,
     expected: VALUE_MATCHERS.has(matcher) ? expected : null,
-    actual: c.text(v.actual, `${path19}.actual`, STEPS_LIMITS.valueLength, true),
+    actual: c.text(v.actual, `${path23}.actual`, STEPS_LIMITS.valueLength, true),
     negated: v.negated === true,
-    note: c.text(v.note, `${path19}.note`, STEPS_LIMITS.valueLength, true)
+    note: c.text(v.note, `${path23}.note`, STEPS_LIMITS.valueLength, true)
   };
 }
 function checkViewports(c, v, stepCount) {
@@ -2400,40 +2400,40 @@ function checkViewports(c, v, stepCount) {
   });
   return out;
 }
-function checkStep(c, v, path19) {
+function checkStep(c, v, path23) {
   if (!isObject(v)) {
-    c.fail(path19, "must be an object");
+    c.fail(path23, "must be an object");
     return null;
   }
   const action = v.action;
   if (!ACTIONS.has(action)) {
-    c.fail(`${path19}.action`, "is not a known action");
+    c.fail(`${path23}.action`, "is not a known action");
     return null;
   }
   const step = {
     action: action === "assertVisible" ? "assert" : action,
-    target: checkTarget(c, v.target, `${path19}.target`),
-    value: c.text(v.value, `${path19}.value`, STEPS_LIMITS.valueLength, true),
+    target: checkTarget(c, v.target, `${path23}.target`),
+    value: c.text(v.value, `${path23}.value`, STEPS_LIMITS.valueLength, true),
     redacted: v.redacted === true,
-    pageUrl: c.text(v.pageUrl, `${path19}.pageUrl`, STEPS_LIMITS.valueLength, false) ?? "",
-    timestamp: v.timestamp == null ? 0 : c.number(v.timestamp, `${path19}.timestamp`)
+    pageUrl: c.text(v.pageUrl, `${path23}.pageUrl`, STEPS_LIMITS.valueLength, false) ?? "",
+    timestamp: v.timestamp == null ? 0 : c.number(v.timestamp, `${path23}.timestamp`)
   };
   if (step.redacted) step.value = null;
   if (action === "hover" || action === "dblclick") {
     step.value = null;
-    if (!step.target) c.fail(`${path19}.target`, `is required on a ${action} step`);
+    if (!step.target) c.fail(`${path23}.target`, `is required on a ${action} step`);
   }
-  if (action === "setInputFiles" && !step.target) c.fail(`${path19}.target`, "is required on a setInputFiles step");
+  if (action === "setInputFiles" && !step.target) c.fail(`${path23}.target`, "is required on a setInputFiles step");
   if (action === "dragTo") {
     step.value = null;
-    if (!step.target) c.fail(`${path19}.target`, "is required on a dragTo step");
-    step.dropTarget = checkTarget(c, v.dropTarget, `${path19}.dropTarget`);
-    if (!step.dropTarget) c.fail(`${path19}.dropTarget`, "is required on a dragTo step");
+    if (!step.target) c.fail(`${path23}.target`, "is required on a dragTo step");
+    step.dropTarget = checkTarget(c, v.dropTarget, `${path23}.dropTarget`);
+    if (!step.dropTarget) c.fail(`${path23}.dropTarget`, "is required on a dragTo step");
   }
   if (action === "assertVisible") {
     step.assertion = { matcher: "toBeVisible", expected: null, actual: null, negated: false, note: null };
   } else if (action === "assert") {
-    step.assertion = checkAssertion(c, v.assertion, `${path19}.assertion`);
+    step.assertion = checkAssertion(c, v.assertion, `${path23}.assertion`);
   }
   return step;
 }
@@ -2779,12 +2779,1142 @@ ${USAGE3}`);
   return EXIT_OK3;
 }
 
-// src/cli/flake.ts
+// src/cli/coverage.ts
+var path12 = __toESM(require("path"));
+
+// ../core/src/codeowners.ts
+function patternParts(pattern) {
+  let source = pattern;
+  const anchored = source.startsWith("/");
+  if (anchored) source = source.slice(1);
+  if (source.endsWith("/")) source = source.slice(0, -1);
+  const segments = source.split("/").filter((segment, i, all) => segment !== "**" || all[i - 1] !== "**");
+  return { segments, floating: !anchored && !source.includes("/") };
+}
+function segmentMatches(pattern, segment) {
+  let p = 0;
+  let s = 0;
+  let afterStar = -1;
+  let starTook = 0;
+  while (s < segment.length) {
+    const char = pattern[p];
+    if (char === "*") {
+      afterStar = ++p;
+      starTook = s;
+    } else if (char !== void 0 && (char === "?" || char === segment[s])) {
+      p++;
+      s++;
+    } else if (afterStar >= 0) {
+      p = afterStar;
+      s = ++starTook;
+    } else {
+      return false;
+    }
+  }
+  while (pattern[p] === "*") p++;
+  return p === pattern.length;
+}
+function pathPatternMatcher(pattern) {
+  const { segments, floating } = patternParts(pattern);
+  if (floating) {
+    const only = segments[0];
+    return (path23) => path23.split("/").some((part) => segmentMatches(only, part));
+  }
+  return (path23) => {
+    const parts = path23.split("/");
+    let at = new Uint8Array(parts.length);
+    at[0] = 1;
+    for (let i = 0; i < segments.length; i++) {
+      const segment = segments[i];
+      const isLast = i === segments.length - 1;
+      if (segment === "**") {
+        if (isLast) return at.includes(1);
+        for (let j = 1; j < parts.length; j++) if (at[j - 1] && parts[j - 1] !== "") at[j] = 1;
+        continue;
+      }
+      const next = new Uint8Array(parts.length);
+      for (let j = 0; j < parts.length; j++) {
+        if (!at[j] || !segmentMatches(segment, parts[j])) continue;
+        if (isLast) return true;
+        if (j + 1 < parts.length) next[j + 1] = 1;
+      }
+      at = next;
+    }
+    return false;
+  };
+}
+
+// ../core/src/coverage-scope.ts
+var DEFAULT_COVERAGE_EXCLUDES = [
+  "*.test.*",
+  "*.spec.*",
+  "tests/",
+  "test/",
+  "__tests__/",
+  "*Tests/",
+  "*.Tests/",
+  "obj/",
+  "bin/",
+  "node_modules/",
+  "*.g.cs",
+  "*.Designer.cs",
+  "*.generated.*"
+];
+var DEFAULT_COVERAGE_SCOPE = { include: [], exclude: [...DEFAULT_COVERAGE_EXCLUDES] };
+var MAX_SCOPE_PATTERNS = 200;
+var MAX_PATTERN_LENGTH = 300;
+var MAX_PATTERN_WILDCARDS = 20;
+function patterns(raw) {
+  if (!Array.isArray(raw)) return null;
+  const out = [];
+  for (const item of raw) {
+    if (typeof item !== "string") return null;
+    const pattern = item.trim();
+    if (!pattern || pattern.startsWith("#")) continue;
+    const tooLarge = pattern.length > MAX_PATTERN_LENGTH || pattern.split("*").length - 1 > MAX_PATTERN_WILDCARDS;
+    if (tooLarge || pattern.startsWith("!")) return null;
+    if (!out.includes(pattern)) out.push(pattern);
+  }
+  return out.length > MAX_SCOPE_PATTERNS ? null : out;
+}
+function parseCoverageScope(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null;
+  const record = raw;
+  const include = record.include === void 0 ? [] : patterns(record.include);
+  const exclude = record.exclude === void 0 ? [] : patterns(record.exclude);
+  return include && exclude ? { include, exclude } : null;
+}
+function compileCoverageScope(scope) {
+  const include = scope.include.map(pathPatternMatcher);
+  const exclude = scope.exclude.map(pathPatternMatcher);
+  return (path23) => {
+    const file = path23.replace(/\\/g, "/").replace(/^\.?\//, "");
+    if (include.length > 0 && !include.some((matches) => matches(file))) return false;
+    return !exclude.some((matches) => matches(file));
+  };
+}
+
+// src/internal/collect/metadata-collector.ts
+var import_node_child_process3 = require("child_process");
+
+// src/internal/support/errors.ts
+function errorMessage(error) {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
+// src/internal/collect/metadata-collector.ts
+var DETACHED_HEAD = "HEAD";
+function resolveScmBranch(env, gitBranch) {
+  const pick = (...names) => {
+    for (const name of names) {
+      const value = env[name]?.trim();
+      if (value) return value;
+    }
+    return void 0;
+  };
+  const override = env.PIWI_BRANCH?.trim();
+  if (override) return override;
+  let provider;
+  if (env.JENKINS_URL) provider = pick("CHANGE_BRANCH", "BRANCH_NAME");
+  else if (env.GITHUB_ACTIONS) provider = pick("GITHUB_HEAD_REF", "GITHUB_REF_NAME");
+  else if (env.GITLAB_CI) provider = pick("CI_MERGE_REQUEST_SOURCE_BRANCH_NAME", "CI_COMMIT_REF_NAME");
+  else if (env.CIRCLECI) provider = pick("CIRCLE_BRANCH");
+  else if (env.TRAVIS) provider = pick("TRAVIS_PULL_REQUEST_BRANCH", "TRAVIS_BRANCH");
+  else if (env.TF_BUILD) provider = pick("SYSTEM_PULLREQUEST_SOURCEBRANCH", "BUILD_SOURCEBRANCHNAME");
+  else if (env.BITBUCKET_BUILD_NUMBER) provider = pick("BITBUCKET_BRANCH");
+  if (provider) return normalizeRef(provider);
+  const trimmed = gitBranch?.trim();
+  if (trimmed && trimmed !== DETACHED_HEAD) return trimmed;
+  return void 0;
+}
+function normalizeRef(ref) {
+  return ref.replace(/^refs\/heads\//, "");
+}
+
+// src/internal/coverage-upload/git-inventory.ts
+var import_node_child_process5 = require("child_process");
+var fs7 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
+
+// src/internal/collect/blob-ids.ts
 var import_node_child_process4 = require("child_process");
+var crypto2 = __toESM(require("crypto"));
+var fs6 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
+function gitHashObjects(root, paths) {
+  return new Promise((resolve10) => {
+    const child = (0, import_node_child_process4.execFile)(
+      "git",
+      ["hash-object", "--stdin-paths"],
+      { cwd: root, encoding: "utf8", timeout: 3e4, windowsHide: true },
+      (error, stdout) => {
+        const ids = error ? [] : stdout.split("\n").filter(Boolean);
+        resolve10(ids.length === paths.length ? ids : null);
+      }
+    );
+    child.stdin?.on("error", () => {
+    });
+    child.stdin?.end(`${paths.join("\n")}
+`);
+  });
+}
+
+// src/internal/coverage-upload/git-inventory.ts
+var MAX_GIT_OUTPUT = 512 * 1024 * 1024;
+var GIT_BATCH = 500;
+function git(cwd, args) {
+  return new Promise((resolve10, reject) => {
+    (0, import_node_child_process5.execFile)(
+      "git",
+      args,
+      { cwd, encoding: "utf8", maxBuffer: MAX_GIT_OUTPUT, timeout: 12e4, windowsHide: true },
+      (error, stdout) => error ? reject(error) : resolve10(stdout)
+    );
+  });
+}
+async function readCheckout(cwd) {
+  let root;
+  try {
+    root = (await git(cwd, ["rev-parse", "--show-toplevel"])).trim();
+  } catch {
+    throw new Error(`${cwd} is not inside a git checkout: coverage is uploaded from the checkout the tests ran in`);
+  }
+  const commit = (await git(root, ["rev-parse", "HEAD"])).trim().toLowerCase();
+  const branch = (await git(root, ["rev-parse", "--abbrev-ref", "HEAD"]).catch(() => "")).trim();
+  return { root, commit, ...branch && branch !== "HEAD" ? { gitBranch: branch } : {} };
+}
+async function hashPaths(root, paths) {
+  const ids = /* @__PURE__ */ new Map();
+  for (let start = 0; start < paths.length; start += GIT_BATCH) {
+    const batch = paths.slice(start, start + GIT_BATCH);
+    const hashed = await gitHashObjects(root, batch);
+    batch.forEach((file, i) => {
+      const id = hashed?.[i];
+      if (id) ids.set(file, id);
+    });
+  }
+  return ids;
+}
+async function readInventory(root, warn = () => {
+}) {
+  const inventory = /* @__PURE__ */ new Map();
+  for (const entry of (await git(root, ["ls-tree", "-r", "-z", "--full-tree", "HEAD"])).split("\0")) {
+    const tab = entry.indexOf("	");
+    if (tab < 0) continue;
+    const [, type, id] = entry.slice(0, tab).split(" ");
+    if (type === "blob" && id) inventory.set(entry.slice(tab + 1), id);
+  }
+  const changed = [];
+  for (const file of (await git(root, ["diff", "--name-only", "-z", "HEAD"]).catch(() => "")).split("\0")) {
+    if (!file || !inventory.has(file)) continue;
+    if (fs7.existsSync(path10.join(root, file))) changed.push(file);
+    else inventory.delete(file);
+  }
+  const ids = await hashPaths(root, changed);
+  for (const file of changed) {
+    const id = ids.get(file);
+    if (id) inventory.set(file, id);
+    else inventory.delete(file);
+  }
+  const unhashed = changed.length - ids.size;
+  if (unhashed > 0) {
+    warn(
+      `git hash-object failed on ${unhashed} changed file${unhashed === 1 ? "" : "s"}: left out of the commit's inventory`
+    );
+  }
+  return inventory;
+}
+
+// src/internal/coverage-upload/report-files.ts
 var fs8 = __toESM(require("fs"));
-var os2 = __toESM(require("os"));
 var path11 = __toESM(require("path"));
 
+// ../core/src/coverage.ts
+var MAX_LINE = 1e6;
+function isLine(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= MAX_LINE;
+}
+function validRanges(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    if (!Array.isArray(item) || item.length !== 2) continue;
+    const [start, end] = item;
+    if (isLine(start) && isLine(end) && start <= end) out.push([start, end]);
+  }
+  return out.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+}
+function normalizeLineRanges(ranges) {
+  const out = [];
+  for (const range of validRanges(ranges)) {
+    const last = out[out.length - 1];
+    if (last && range[0] <= last[1] + 1) last[1] = Math.max(last[1], range[1]);
+    else out.push(range);
+  }
+  return out;
+}
+function normalizeFunctionRanges(ranges) {
+  const out = [];
+  for (const range of validRanges(ranges)) {
+    const last = out[out.length - 1];
+    if (!last || last[0] !== range[0] || last[1] !== range[1]) out.push(range);
+  }
+  return out;
+}
+
+// ../core/src/coverage-formats.ts
+var MAX_LINE2 = 1e6;
+var MAX_PENDING = 1024 * 1024;
+var EXECUTABLE = 1;
+var RAN = 2;
+var GREATER_THAN = 62;
+var DOUBLE_QUOTE = 34;
+var SINGLE_QUOTE = 39;
+function detectCoverageFormat(head) {
+  const text = head.replace(/^/, "").trimStart();
+  if (text.startsWith("{")) return /"files"\s*:/.test(text) ? "piwi" : null;
+  if (text.startsWith("<"))
+    return /<coverage[\s>]/.test(text) || !/<\w/.test(text.replace(/<[?!][^>]*>/g, "")) ? "cobertura" : null;
+  return /^(?:TN|SF):/m.test(text) ? "lcov" : null;
+}
+var FileLines = class {
+  constructor() {
+    this.flags = new Uint8Array(64);
+    this.length = 0;
+    this.functions = /* @__PURE__ */ new Map();
+  }
+  line(number, hits) {
+    if (!Number.isInteger(number) || number < 1 || number > MAX_LINE2) return;
+    if (number >= this.flags.length) {
+      const grown = new Uint8Array(Math.min(MAX_LINE2 + 1, Math.max(number + 1, this.flags.length * 2)));
+      grown.set(this.flags);
+      this.flags = grown;
+    }
+    this.flags[number] |= hits > 0 ? EXECUTABLE | RAN : EXECUTABLE;
+    if (number >= this.length) this.length = number + 1;
+  }
+  /** A function by a key unique in the file; a later entry for the same key widens it and keeps it run. */
+  fn(key, start, end, ran) {
+    if (!(start >= 1 && start <= MAX_LINE2)) return;
+    const last = end >= start && end <= MAX_LINE2 ? end : start;
+    const known = this.functions.get(key);
+    if (known) {
+      known.start = Math.min(known.start, start);
+      known.end = Math.max(known.end, last);
+      known.ran ||= ran;
+    } else {
+      this.functions.set(key, { start, end: last, ran });
+    }
+  }
+  toFile(path23) {
+    const executable = [];
+    const lines = [];
+    const push = (ranges, line) => {
+      const last = ranges[ranges.length - 1];
+      if (last && last[1] === line - 1) last[1] = line;
+      else ranges.push([line, line]);
+    };
+    for (let line = 1; line < this.length; line++) {
+      const flags = this.flags[line];
+      if (flags & EXECUTABLE) push(executable, line);
+      if (flags & RAN) push(lines, line);
+    }
+    const all = [];
+    const ran = [];
+    for (const { start, end, ran: didRun } of this.functions.values()) {
+      all.push([start, end]);
+      if (didRun) ran.push([start, end]);
+    }
+    return {
+      path: path23,
+      executable,
+      lines,
+      functions: normalizeFunctionRanges(ran),
+      allFunctions: normalizeFunctionRanges(all)
+    };
+  }
+};
+var ReportFiles = class {
+  constructor() {
+    this.byPath = /* @__PURE__ */ new Map();
+  }
+  of(path23) {
+    let file = this.byPath.get(path23);
+    if (!file) {
+      file = new FileLines();
+      this.byPath.set(path23, file);
+    }
+    return file;
+  }
+  toFiles() {
+    return [...this.byPath].map(([path23, file]) => file.toFile(path23));
+  }
+};
+var XML_ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+function decodeXml(text) {
+  return text.replace(/&(#x[0-9a-f]+|#\d+|amp|lt|gt|quot|apos);/gi, (whole, name) => {
+    if (name[0] !== "#") return XML_ENTITIES[name.toLowerCase()] ?? whole;
+    const code = name[1] === "x" || name[1] === "X" ? parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);
+    return Number.isInteger(code) && code > 0 && code <= 1114111 ? String.fromCodePoint(code) : whole;
+  });
+}
+function attributesOf(text) {
+  const out = {};
+  const pattern = /([\w:.-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+  for (let match = pattern.exec(text); match; match = pattern.exec(text)) {
+    out[match[1]] = decodeXml(match[2] ?? match[3] ?? "");
+  }
+  return out;
+}
+var NUMBER_ATTRIBUTE = /\snumber\s*=\s*(?:"([^"]*)"|'([^']*)')/;
+var HITS_ATTRIBUTE = /\shits\s*=\s*(?:"([^"]*)"|'([^']*)')/;
+function attributeValue(markup, pattern) {
+  const match = pattern.exec(markup);
+  return match ? match[1] ?? match[2] : void 0;
+}
+function integer(value) {
+  if (value === void 0) return Number.NaN;
+  const number = Number(value.trim());
+  return Number.isFinite(number) ? Math.trunc(number) : Number.NaN;
+}
+var CoberturaReader = class {
+  constructor() {
+    /** The text not read yet: empty, or the markup still open, from its `<`. */
+    this.pending = "";
+    /** How many characters of that markup are scanned, and the quote open after them (0 when none). */
+    this.scanned = 0;
+    this.quote = 0;
+    this.files = new ReportFiles();
+    this.sources = [];
+    /** The text inside the `<source>` being read, or null outside one. */
+    this.sourceText = null;
+    this.file = null;
+    this.methodCount = 0;
+    /** The method being read: its lines' extent and whether one ran. */
+    this.method = null;
+  }
+  write(chunk) {
+    let text = this.pending + chunk;
+    let at = 0;
+    for (; ; ) {
+      const open = text.indexOf("<", at);
+      if (open < 0) {
+        if (this.sourceText !== null) this.sourceText += text.slice(at);
+        at = text.length;
+        break;
+      }
+      if (this.sourceText !== null) this.sourceText += text.slice(at, open);
+      const close = this.tagEnd(text, open);
+      if (close < 0) {
+        at = open;
+        break;
+      }
+      this.tag(text.slice(open, close + 1));
+      at = close + 1;
+    }
+    text = text.slice(at);
+    if (text.length > MAX_PENDING) throw new Error("The Cobertura report has a tag longer than 1 MB.");
+    this.pending = text;
+  }
+  end() {
+    this.write("");
+    return { format: "cobertura", sources: this.sources, files: this.files.toFiles() };
+  }
+  /**
+   * Where the markup starting at `open` ends: its `>`, past comments, CDATA and quoted attribute values; -1 if not
+   * yet read. The text is scanned once, forward: an unfinished markup keeps how far it is scanned and its open quote
+   * for the next chunk.
+   */
+  tagEnd(text, open) {
+    const head = text.slice(open, open + 9);
+    if (head.length < 9 && ("<!--".startsWith(head) || "<![CDATA[".startsWith(head))) return -1;
+    if (head.startsWith("<!--")) return this.through(text, open, "-->", 4);
+    if (head.startsWith("<![CDATA[")) return this.through(text, open, "]]>", 9);
+    let quote4 = this.quote;
+    for (let at = open + Math.max(1, this.scanned); at < text.length; at++) {
+      const char = text.charCodeAt(at);
+      if (quote4 !== 0) {
+        if (char === quote4) quote4 = 0;
+      } else if (char === GREATER_THAN) {
+        this.scanned = 0;
+        this.quote = 0;
+        return at;
+      } else if (char === DOUBLE_QUOTE || char === SINGLE_QUOTE) {
+        quote4 = char;
+      }
+    }
+    this.scanned = text.length - open;
+    this.quote = quote4;
+    return -1;
+  }
+  /** Where a comment or CDATA section starting at `open` ends: the last character of `end`; -1 if not yet read. */
+  through(text, open, end, start) {
+    const at = text.indexOf(end, open + Math.max(start, this.scanned));
+    if (at < 0) {
+      this.scanned = Math.max(start, text.length - open - end.length + 1);
+      return -1;
+    }
+    this.scanned = 0;
+    return at + end.length - 1;
+  }
+  tag(markup) {
+    if (markup.startsWith("<line ") || markup.startsWith("<line	") || markup.startsWith("<line\n")) {
+      this.line(integer(attributeValue(markup, NUMBER_ATTRIBUTE)), integer(attributeValue(markup, HITS_ATTRIBUTE)));
+      return;
+    }
+    if (markup.startsWith("<![CDATA[")) {
+      if (this.sourceText !== null) this.sourceText += markup.slice(9, -3);
+      return;
+    }
+    if (markup.startsWith("<!") || markup.startsWith("<?")) return;
+    const closing = markup[1] === "/";
+    const match = /^<\/?([\w:.-]+)/.exec(markup);
+    if (!match) return;
+    const name = match[1].toLowerCase();
+    const selfClosing = markup.endsWith("/>");
+    if (closing) {
+      this.closeTag(name);
+      return;
+    }
+    const attributes = attributesOf(markup.slice(match[0].length));
+    switch (name) {
+      case "source":
+        if (!selfClosing) this.sourceText = "";
+        break;
+      case "class":
+        this.file = attributes.filename ? this.files.of(attributes.filename) : null;
+        this.method = null;
+        if (selfClosing) this.file = null;
+        break;
+      case "method":
+        if (this.file) {
+          const line = integer(attributes.line);
+          this.method = { start: line, end: line, ran: false, key: `m${this.methodCount++}` };
+          if (selfClosing) this.closeTag("method");
+        }
+        break;
+    }
+  }
+  line(number, hits) {
+    if (!Number.isInteger(number)) return;
+    const { method } = this;
+    if (method) {
+      method.start = Number.isInteger(method.start) ? Math.min(method.start, number) : number;
+      method.end = Number.isInteger(method.end) ? Math.max(method.end, number) : number;
+      if (hits > 0) method.ran = true;
+    } else if (this.file) {
+      this.file.line(number, Number.isInteger(hits) ? hits : 0);
+    }
+  }
+  closeTag(name) {
+    if (name === "source" && this.sourceText !== null) {
+      const source = decodeXml(this.sourceText).trim();
+      if (source) this.sources.push(source);
+      this.sourceText = null;
+    } else if (name === "method" && this.method) {
+      const { start, end, ran, key } = this.method;
+      if (this.file && Number.isInteger(start)) this.file.fn(key, start, end, ran);
+      this.method = null;
+    } else if (name === "class") {
+      this.file = null;
+      this.method = null;
+    }
+  }
+};
+var LcovReader = class {
+  constructor() {
+    this.pending = "";
+    this.files = new ReportFiles();
+    this.file = null;
+    /**
+     * The functions of the current record by name (`FN`/`FNDA`), each name's in the order its `FN`s come, with how
+     * many `FNDA`s of the name are read; and by index (`FNL`/`FNA`).
+     */
+    this.byName = /* @__PURE__ */ new Map();
+    this.namesRun = /* @__PURE__ */ new Map();
+    this.byIndex = /* @__PURE__ */ new Map();
+    this.record = 0;
+  }
+  write(chunk) {
+    const text = this.pending + chunk;
+    const lines = text.split(/\r?\n/);
+    this.pending = lines.pop() ?? "";
+    if (this.pending.length > MAX_PENDING) throw new Error("The LCOV report has a line longer than 1 MB.");
+    for (const line of lines) this.line(line);
+  }
+  end() {
+    if (this.pending) this.line(this.pending);
+    this.pending = "";
+    this.endRecord();
+    return { format: "lcov", sources: [], files: this.files.toFiles() };
+  }
+  line(raw) {
+    const line = raw.trim();
+    const colon = line.indexOf(":");
+    const key = colon < 0 ? line : line.slice(0, colon);
+    const value = colon < 0 ? "" : line.slice(colon + 1);
+    switch (key) {
+      case "SF":
+        this.endRecord();
+        this.file = value ? this.files.of(value) : null;
+        this.record++;
+        break;
+      case "DA": {
+        const [number, hits] = value.split(",");
+        this.file?.line(integer(number), Math.max(0, integer(hits) || 0));
+        break;
+      }
+      case "FN": {
+        const parts = value.split(",");
+        const start = integer(parts[0]);
+        const withEnd = parts.length >= 3 && /^\s*\d+\s*$/.test(parts[1]);
+        const end = withEnd ? integer(parts[1]) : start;
+        const name = parts.slice(withEnd ? 2 : 1).join(",");
+        if (this.file && Number.isInteger(start)) {
+          const named = this.byName.get(name) ?? [];
+          this.byName.set(name, named);
+          named.push({ start, end });
+          this.file.fn(`${this.record}:n:${named.length - 1}:${name}`, start, end, false);
+        }
+        break;
+      }
+      case "FNDA": {
+        const comma = value.indexOf(",");
+        const hits = integer(value.slice(0, comma));
+        const name = value.slice(comma + 1);
+        const nth = this.namesRun.get(name) ?? 0;
+        this.namesRun.set(name, nth + 1);
+        const known = this.byName.get(name)?.[nth];
+        if (this.file && known && hits > 0) {
+          this.file.fn(`${this.record}:n:${nth}:${name}`, known.start, known.end, true);
+        }
+        break;
+      }
+      case "FNL": {
+        const [index, start, end] = value.split(",");
+        const first = integer(start);
+        if (this.file && index !== void 0 && Number.isInteger(first)) {
+          const last = end === void 0 ? first : integer(end);
+          this.byIndex.set(index, { start: first, end: last });
+          this.file.fn(`${this.record}:i:${index}`, first, last, false);
+        }
+        break;
+      }
+      case "FNA": {
+        const [index, hits] = value.split(",");
+        const known = index === void 0 ? void 0 : this.byIndex.get(index);
+        if (this.file && known && integer(hits) > 0) {
+          this.file.fn(`${this.record}:i:${index}`, known.start, known.end, true);
+        }
+        break;
+      }
+      case "end_of_record":
+        this.endRecord();
+        break;
+    }
+  }
+  endRecord() {
+    this.file = null;
+    this.byName = /* @__PURE__ */ new Map();
+    this.namesRun = /* @__PURE__ */ new Map();
+    this.byIndex = /* @__PURE__ */ new Map();
+  }
+};
+var MAX_PIWI_REPORT = 512 * 1024 * 1024;
+var PiwiReader = class {
+  constructor() {
+    this.chunks = [];
+    this.length = 0;
+  }
+  write(chunk) {
+    this.length += chunk.length;
+    if (this.length > MAX_PIWI_REPORT) throw new Error("The Piwi coverage report is larger than 512 MB.");
+    this.chunks.push(chunk);
+  }
+  end() {
+    let parsed;
+    try {
+      parsed = JSON.parse(this.chunks.join("").replace(/^/, ""));
+    } catch {
+      throw new Error("The Piwi coverage report is not JSON.");
+    }
+    const files = parsed?.files;
+    if (!Array.isArray(files)) throw new Error('The Piwi coverage report has no "files" array.');
+    const byPath = /* @__PURE__ */ new Map();
+    for (const item of files) {
+      if (typeof item?.path !== "string" || !item.path) continue;
+      const file = {
+        path: item.path,
+        executable: normalizeLineRanges(item.executable),
+        lines: normalizeLineRanges(item.lines),
+        functions: normalizeFunctionRanges(item.functions),
+        allFunctions: normalizeFunctionRanges(item.allFunctions)
+      };
+      const known = byPath.get(file.path);
+      byPath.set(file.path, known ? mergeReportedFiles(known, file) : file);
+    }
+    return { format: "piwi", sources: [], files: [...byPath.values()] };
+  }
+};
+var CoverageReportReader = class {
+  constructor(format) {
+    this.format = format;
+    this.reader = format === "cobertura" ? new CoberturaReader() : format === "lcov" ? new LcovReader() : new PiwiReader();
+  }
+  /** Adds the next chunk of the report's text. Throws on a tag or a line longer than 1 MB. */
+  write(chunk) {
+    this.reader.write(chunk);
+  }
+  /** The report read; its files merged by path and sorted in the order the report first names them. */
+  end() {
+    return this.reader.end();
+  }
+};
+function normalizeSlashPath(raw) {
+  const absolute = raw.startsWith("/");
+  const drive = /^[A-Za-z]:\//.exec(raw)?.[0] ?? "";
+  const rest = drive ? raw.slice(drive.length) : absolute ? raw.slice(1) : raw;
+  const out = [];
+  for (const part of rest.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") {
+      if (out.length === 0) return null;
+      out.pop();
+    } else {
+      out.push(part);
+    }
+  }
+  return (drive || (absolute ? "/" : "")) + out.join("/");
+}
+function isAbsolutePath(path23) {
+  return path23.startsWith("/") || /^[A-Za-z]:\//.test(path23);
+}
+function relativeTo(path23, root) {
+  const drive = /^[A-Za-z]:/.test(root);
+  const base = root.endsWith("/") ? root : `${root}/`;
+  const head = path23.slice(0, base.length);
+  const inside = drive ? head.toLowerCase() === base.toLowerCase() : head === base;
+  if (!inside) return null;
+  const relative8 = path23.slice(base.length);
+  return relative8 || null;
+}
+function reportPathCandidates(raw, { repoRoot, bases }) {
+  const slash = (value) => value.replace(/\\/g, "/");
+  const root = normalizeSlashPath(slash(repoRoot));
+  const path23 = slash(raw.trim());
+  if (!root || !path23 || path23.includes("\0")) return [];
+  const out = [];
+  const add = (absolute) => {
+    const normalized = normalizeSlashPath(absolute);
+    if (!normalized) return;
+    const relative8 = normalized.startsWith("/_/") ? normalized.slice(3) : relativeTo(normalized, root);
+    if (relative8 && !out.includes(relative8)) out.push(relative8);
+  };
+  if (isAbsolutePath(path23)) {
+    add(path23);
+  } else {
+    for (const base of bases) {
+      const dir = slash(base);
+      if (isAbsolutePath(dir)) add(`${dir}/${path23}`);
+    }
+  }
+  return out;
+}
+function mergeReportedFiles(a, b) {
+  return {
+    path: a.path,
+    executable: normalizeLineRanges([...a.executable, ...b.executable]),
+    lines: normalizeLineRanges([...a.lines, ...b.lines]),
+    functions: normalizeFunctionRanges([...a.functions, ...b.functions]),
+    allFunctions: normalizeFunctionRanges([...a.allFunctions, ...b.allFunctions])
+  };
+}
+
+// src/internal/coverage-upload/report-files.ts
+var SKIPPED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git"]);
+function globSegmentRegExp(segment) {
+  const source = segment.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]");
+  return new RegExp(`^${source}$`);
+}
+function expandPattern(pattern, cwd) {
+  const normalized = pattern.replace(/\\/g, "/");
+  if (!/[*?]/.test(normalized)) {
+    const file = path11.resolve(cwd, normalized);
+    return fs8.existsSync(file) && fs8.statSync(file).isFile() ? [file] : [];
+  }
+  const absolute = path11.isAbsolute(normalized) || /^[A-Za-z]:\//.test(normalized);
+  const segments = normalized.split("/");
+  const firstWild = segments.findIndex((s) => /[*?]/.test(s));
+  const baseParts = segments.slice(0, firstWild);
+  const base = absolute ? baseParts.join("/") || "/" : path11.resolve(cwd, ...baseParts);
+  const rest = segments.slice(firstWild).filter((s) => s !== "");
+  const out = [];
+  const walk = (dir, at) => {
+    if (at >= rest.length) return;
+    const segment = rest[at];
+    let entries;
+    try {
+      entries = fs8.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    if (segment === "**") {
+      walk(dir, at + 1);
+      for (const entry of entries) {
+        if (entry.isDirectory() && !SKIPPED_DIRS.has(entry.name)) walk(path11.join(dir, entry.name), at);
+      }
+      return;
+    }
+    const match = globSegmentRegExp(segment);
+    const last = at === rest.length - 1;
+    for (const entry of entries) {
+      if (!match.test(entry.name)) continue;
+      const full = path11.join(dir, entry.name);
+      if (last && entry.isFile()) out.push(full);
+      else if (!last && entry.isDirectory() && (!SKIPPED_DIRS.has(entry.name) || segment === entry.name)) {
+        walk(full, at + 1);
+      }
+    }
+  };
+  walk(base, 0);
+  return [...new Set(out)].sort();
+}
+async function readReport(file, format) {
+  let reader = format ? new CoverageReportReader(format) : null;
+  let head = "";
+  for await (const chunk of fs8.createReadStream(file, { encoding: "utf8", highWaterMark: 1024 * 1024 })) {
+    if (!reader) {
+      head += chunk;
+      if (head.length < 4096) continue;
+      const detected = detectCoverageFormat(head);
+      if (!detected) throw new Error(`${file} is not a Cobertura, LCOV or Piwi coverage report`);
+      reader = new CoverageReportReader(detected);
+      reader.write(head);
+      head = "";
+      continue;
+    }
+    reader.write(chunk);
+  }
+  if (!reader) {
+    const detected = detectCoverageFormat(head);
+    if (!detected) throw new Error(`${file} is not a Cobertura, LCOV or Piwi coverage report`);
+    reader = new CoverageReportReader(detected);
+    reader.write(head);
+  }
+  return reader.end();
+}
+function reportBases(report, reportFile, options) {
+  if (options.root) return [path11.resolve(options.cwd, options.root)];
+  const dir = path11.dirname(path11.resolve(reportFile));
+  const sources = report.sources.map(
+    (source) => path11.isAbsolute(source) || /^[A-Za-z]:[\\/]/.test(source) ? source : path11.resolve(dir, source)
+  );
+  return [...sources, options.cwd, dir, path11.dirname(dir), options.repoRoot];
+}
+function resolveReport(report, reportFile, options, into) {
+  const bases = reportBases(report, reportFile, options);
+  for (const file of report.files) {
+    const candidates = reportPathCandidates(file.path, { repoRoot: options.repoRoot, bases });
+    const match = candidates.find((candidate) => options.inventory.has(candidate)) ?? candidates.find((candidate) => fs8.existsSync(path11.join(options.repoRoot, candidate)));
+    if (!match) {
+      into.unmatched.push(file.path);
+      continue;
+    }
+    if (!options.inScope(match)) {
+      into.outOfScope++;
+      continue;
+    }
+    const known = into.files.get(match);
+    into.files.set(match, known ? mergeReportedFiles(known, file) : { ...file, path: match });
+  }
+}
+
+// src/cli/coverage.ts
+var EXIT_OK4 = 0;
+var EXIT_NOTHING = 1;
+var EXIT_ERROR4 = 2;
+var FILES_PER_REQUEST = 5e3;
+var BYTES_PER_REQUEST = 8 * 1024 * 1024;
+var INVENTORY_PER_REQUEST = 5e4;
+var SUITE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+var USAGE4 = `
+piwi coverage upload \u2014 send a coverage report of a suite to the dashboard
+
+Usage:
+  npx @piwitests/reporter coverage upload <file or pattern>... --suite <name> [options]
+
+Reports:
+  <file or pattern>        Cobertura, LCOV or Piwi report files; quote patterns ("**/coverage.cobertura.xml")
+  --format <format>        cobertura, lcov or piwi; detected from the content when absent
+  --root <dir>             The directory the reports' relative paths start from; tried
+                           against each report's <source>, the current directory, the
+                           report's directory and its parent, and the repository root otherwise
+
+Suite:
+  --suite <name>           The suite the report covers, e.g. unit-back or unit-front
+  --kind <kind>            unit (the default) or e2e
+
+Connection:
+  --project <name|id>      Project                 (env PIWI_PROJECT_NAME)
+  --server-url <url>       Dashboard URL           (env PIWI_DASHBOARD_URL)
+  --api-key <key>          API key                 (env PIWI_API_KEY)
+  --branch <name>          The branch              (env PIWI_BRANCH, the CI's, else git's)
+
+Other:
+  --dry-run                Read and resolve the reports, print the summary, send nothing
+  --json                   Print the summary as JSON
+  -h, --help               Show this help
+
+Exit codes: 0 uploaded, 1 nothing to upload, 2 the upload could not be made.
+`.trim();
+var VALUE_OPTIONS = /* @__PURE__ */ new Set([
+  "--suite",
+  "--kind",
+  "--format",
+  "--root",
+  "--project",
+  "--server-url",
+  "--api-key",
+  "--branch"
+]);
+function parseCoverageUploadArgs(argv, env) {
+  const values = /* @__PURE__ */ new Map();
+  const patterns2 = [];
+  const flags = /* @__PURE__ */ new Set();
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const eq = arg.indexOf("=");
+    const name = arg.startsWith("--") && eq > 0 ? arg.slice(0, eq) : arg;
+    if (VALUE_OPTIONS.has(name)) {
+      const value = eq > 0 && arg.startsWith("--") ? arg.slice(eq + 1) : argv[++i];
+      if (value === void 0 || value === "") throw new Error(`${name} expects a value`);
+      values.set(name, value);
+    } else if (arg.startsWith("--")) {
+      flags.add(arg);
+    } else {
+      patterns2.push(arg);
+    }
+  }
+  const unknown = [...flags].filter((flag) => flag !== "--dry-run" && flag !== "--json");
+  if (unknown.length > 0) throw new Error(`Unknown option ${unknown[0]}`);
+  if (patterns2.length === 0) throw new Error("No report \u2014 name the Cobertura, LCOV or Piwi report files to upload");
+  const suite = values.get("--suite") ?? "";
+  if (!SUITE.test(suite)) {
+    throw new Error('--suite names the suite: 1 to 64 letters, digits, ".", "_" or "-", e.g. unit-back');
+  }
+  const kind = values.get("--kind") ?? "unit";
+  if (kind !== "unit" && kind !== "e2e") throw new Error("--kind is unit or e2e");
+  const format = values.get("--format");
+  if (format !== void 0 && format !== "cobertura" && format !== "lcov" && format !== "piwi") {
+    throw new Error("--format is cobertura, lcov or piwi");
+  }
+  const serverUrl = (values.get("--server-url") ?? env.PIWI_DASHBOARD_URL ?? "").replace(/\/+$/, "");
+  const dryRun = flags.has("--dry-run");
+  if (!serverUrl && !dryRun) throw new Error("No dashboard URL \u2014 pass --server-url or set PIWI_DASHBOARD_URL");
+  const project = values.get("--project") ?? env.PIWI_PROJECT_NAME ?? "";
+  if (!project && !dryRun) throw new Error("No project \u2014 pass --project or set PIWI_PROJECT_NAME");
+  return {
+    patterns: patterns2,
+    suite,
+    kind,
+    ...format ? { format } : {},
+    ...values.get("--root") ? { root: values.get("--root") } : {},
+    project,
+    serverUrl,
+    apiKey: values.get("--api-key") ?? env.PIWI_API_KEY ?? null,
+    ...values.get("--branch") ? { branch: values.get("--branch") } : {},
+    dryRun,
+    json: flags.has("--json")
+  };
+}
+function jsonBytes(item) {
+  return Buffer.byteLength(JSON.stringify(item)) + 1;
+}
+function splitUpload(head, files, inventory) {
+  const parts = [];
+  let nextFile = 0;
+  let nextEntry = 0;
+  do {
+    const partFiles = [];
+    const partInventory = [];
+    let bytes = 0;
+    const fits = (item) => {
+      const size = jsonBytes(item);
+      if (bytes > 0 && bytes + size > BYTES_PER_REQUEST) return false;
+      bytes += size;
+      return true;
+    };
+    while (nextFile < files.length && partFiles.length < FILES_PER_REQUEST && fits(files[nextFile])) {
+      partFiles.push(files[nextFile++]);
+    }
+    while (nextEntry < inventory.length && partInventory.length < INVENTORY_PER_REQUEST && fits(inventory[nextEntry])) {
+      partInventory.push(inventory[nextEntry++]);
+    }
+    parts.push({ ...head, ...partInventory.length > 0 ? { inventory: partInventory } : {}, files: partFiles });
+  } while (nextFile < files.length || nextEntry < inventory.length);
+  return parts;
+}
+function formatSummary(summary, dryRun) {
+  const lines = [
+    `${dryRun ? "Would upload" : "Uploaded"} ${summary.suite} for ${summary.commit.slice(0, 7)}${summary.branch ? ` (${summary.branch})` : ""}: ${summary.files} file${summary.files === 1 ? "" : "s"} from ${summary.reports.length} report${summary.reports.length === 1 ? "" : "s"}, ${summary.inventoryFiles} tracked files in scope.`
+  ];
+  if (summary.reportFiles !== void 0 && summary.reportFiles !== summary.files) {
+    lines.push(`The dashboard's report of this commit and suite now covers ${summary.reportFiles} files.`);
+  }
+  if (summary.unmatched > 0) {
+    lines.push(
+      `${summary.unmatched} path${summary.unmatched === 1 ? "" : "s"} matched no file in the checkout: check --root.`
+    );
+  }
+  if (summary.outOfScope > 0) lines.push(`${summary.outOfScope} files are outside the project's coverage scope.`);
+  if (summary.supersededBy !== void 0) {
+    const by = summary.supersededBy ? ` ${summary.supersededBy.slice(0, 7)}` : " a newer commit";
+    lines.push(
+      `${summary.commit.slice(0, 7)} was superseded by${by} on its branch: the dashboard keeps its totals as they were and drops this upload.`
+    );
+  }
+  return lines.join("\n");
+}
+function authHeaders3(apiKey) {
+  return apiKey ? { "X-API-Key": apiKey } : {};
+}
+async function fetchScope(args, projectId) {
+  const res = await fetch(`${args.serverUrl}/api/projects/${projectId}`, { headers: authHeaders3(args.apiKey) });
+  if (!res.ok) throw new Error(`Could not read the project (dashboard returned ${res.status})`);
+  const body = await res.json();
+  const raw = body.coverageScope ?? body.project?.coverageScope;
+  return (raw ? parseCoverageScope(raw) : null) ?? DEFAULT_COVERAGE_SCOPE;
+}
+function warnOnStderr(message) {
+  console.error(`piwi coverage upload: warning: ${message}`);
+}
+async function uploadCoverage(args, env, cwd, warn = warnOnStderr) {
+  const checkout = await readCheckout(cwd);
+  const projectId = args.dryRun ? null : await resolveProjectId({ serverUrl: args.serverUrl, apiKey: args.apiKey, project: args.project, key: "" });
+  const scope = projectId === null ? DEFAULT_COVERAGE_SCOPE : await fetchScope(args, projectId);
+  const inScope = compileCoverageScope(scope);
+  const branch = args.branch ?? resolveScmBranch(env, checkout.gitBranch) ?? null;
+  const reports = [...new Set(args.patterns.flatMap((pattern) => expandPattern(pattern, cwd)))];
+  const inventory = await readInventory(checkout.root, warn);
+  const resolved = { files: /* @__PURE__ */ new Map(), unmatched: [], outOfScope: 0 };
+  const formats = /* @__PURE__ */ new Set();
+  for (const report of reports) {
+    const read = await readReport(report, args.format);
+    formats.add(read.format);
+    resolveReport(read, report, { repoRoot: checkout.root, cwd, root: args.root, inventory, inScope }, resolved);
+  }
+  const untracked = [...resolved.files.keys()].filter((file) => !inventory.has(file));
+  const hashed = await hashPaths(checkout.root, untracked);
+  if (hashed.size < untracked.length) {
+    const unhashed = untracked.length - hashed.size;
+    warn(
+      `git hash-object failed on ${unhashed} untracked file${unhashed === 1 ? "" : "s"} the reports name: sent without a blob id`
+    );
+  }
+  const files = [...resolved.files.values()].sort((a, b) => a.path < b.path ? -1 : 1).map((file) => {
+    const blob = inventory.get(file.path) ?? hashed.get(file.path);
+    return {
+      path: file.path,
+      ...blob ? { blob } : {},
+      executable: file.executable,
+      lines: file.lines,
+      ...file.functions.length > 0 ? { functions: file.functions } : {},
+      ...file.allFunctions.length > 0 ? { allFunctions: file.allFunctions } : {}
+    };
+  });
+  const inScopeInventory = [...inventory].filter(([file]) => inScope(file)).sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+  const parts = splitUpload(
+    {
+      v: 1,
+      commit: checkout.commit,
+      ...branch ? { branch } : {},
+      suite: args.suite,
+      kind: args.kind,
+      tool: [...formats].sort().join("+") || "unknown",
+      ...resolved.unmatched.length > 0 ? { incomplete: true } : {}
+    },
+    files,
+    inScopeInventory
+  );
+  const summary = {
+    commit: checkout.commit,
+    branch,
+    suite: args.suite,
+    reports: reports.map((report) => path12.relative(cwd, report) || report),
+    files: files.length,
+    unmatched: resolved.unmatched.length,
+    outOfScope: resolved.outOfScope,
+    inventoryFiles: inScopeInventory.length,
+    requests: parts.length
+  };
+  if (reports.length === 0 || files.length === 0 || args.dryRun || projectId === null) {
+    return { summary, code: reports.length === 0 || files.length === 0 ? EXIT_NOTHING : EXIT_OK4 };
+  }
+  for (const part of parts) {
+    const res = await fetch(`${args.serverUrl}/api/projects/${projectId}/coverage-reports`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...authHeaders3(args.apiKey) },
+      body: JSON.stringify(part)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`The dashboard refused the upload (${res.status})${text ? `: ${text.slice(0, 400)}` : ""}`);
+    }
+    const answer = await res.json();
+    if (typeof answer.report?.files === "number") summary.reportFiles = answer.report.files;
+    if (answer.superseded) summary.supersededBy = answer.superseded.by ?? null;
+  }
+  return { summary, code: EXIT_OK4 };
+}
+function failureMessage(error, args) {
+  const cause = error instanceof TypeError ? error.cause : void 0;
+  if (cause) {
+    return `Could not reach the dashboard at ${args.serverUrl}: ${cause.message || cause.code || errorMessage(error)}`;
+  }
+  return errorMessage(error);
+}
+async function runCoverage(argv, env = process.env, cwd = process.cwd()) {
+  const [subcommand, ...rest] = argv;
+  if (subcommand === void 0 || subcommand === "-h" || subcommand === "--help" || rest.includes("--help") || rest.includes("-h")) {
+    console.log(USAGE4);
+    return subcommand === void 0 ? EXIT_ERROR4 : EXIT_OK4;
+  }
+  if (subcommand !== "upload") {
+    console.error(`piwi coverage: unknown subcommand "${subcommand}"
+
+${USAGE4}`);
+    return EXIT_ERROR4;
+  }
+  let args;
+  try {
+    args = parseCoverageUploadArgs(rest, env);
+  } catch (error) {
+    console.error(`piwi coverage upload: ${errorMessage(error)}`);
+    return EXIT_ERROR4;
+  }
+  try {
+    const { summary, code } = await uploadCoverage(args, env, cwd);
+    if (args.json) console.log(JSON.stringify(summary, null, 2));
+    else if (summary.reports.length === 0) console.error("piwi coverage upload: no report matched the files named");
+    else if (summary.files === 0) {
+      console.error(
+        `piwi coverage upload: none of the ${summary.unmatched + summary.outOfScope} files the reports name is a file of the checkout in the coverage scope: check --root`
+      );
+    } else console.log(formatSummary(summary, args.dryRun));
+    return code;
+  } catch (error) {
+    console.error(`piwi coverage upload: ${failureMessage(error, args)}`);
+    return EXIT_ERROR4;
+  }
+}
+
+// src/cli/flake.ts
+var import_node_child_process7 = require("child_process");
+var fs11 = __toESM(require("fs"));
+var os2 = __toESM(require("os"));
+var path15 = __toESM(require("path"));
+
 // ../core/src/error-parse.ts
 var ANSI_RE = new RegExp("\\u001B\\[[0-9;]*m", "g");
 var CHAIN_LINK_METHODS = /* @__PURE__ */ new Set([
@@ -2951,7 +4081,7 @@ function verifyVerdict(arm, reproducedRate) {
 }
 var EXIT_REPRODUCED = 0;
 var EXIT_NOT_REPRODUCED = 1;
-var EXIT_ERROR4 = 2;
+var EXIT_ERROR5 = 2;
 var EXIT_BISECT_SKIP = 125;
 function exitCodeFor(verdict) {
   return verdict === "reproduced" || verdict === "verified" ? EXIT_REPRODUCED : EXIT_NOT_REPRODUCED;
@@ -2984,8 +4114,8 @@ function withinBudget(startedAt, now, budgetMs) {
 }
 
 // src/internal/support/connection.ts
-var fs6 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
+var fs9 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 
 // ../core/src/dotenv.ts
 function parseDotEnv(text) {
@@ -3026,7 +4156,7 @@ function resolveCliConnection(flags, env, dirs) {
   let dotEnv = {};
   for (const dir of dirs) {
     try {
-      dotEnv = { ...parseDotEnv(fs6.readFileSync(path9.join(dir, ".env"), "utf-8")), ...dotEnv };
+      dotEnv = { ...parseDotEnv(fs9.readFileSync(path13.join(dir, ".env"), "utf-8")), ...dotEnv };
     } catch {
     }
   }
@@ -3039,12 +4169,12 @@ function resolveCliConnection(flags, env, dirs) {
 }
 
 // src/internal/support/playwright-spawn.ts
-var import_node_child_process3 = require("child_process");
-var fs7 = __toESM(require("fs"));
+var import_node_child_process6 = require("child_process");
+var fs10 = __toESM(require("fs"));
 var import_node_module2 = require("module");
-var path10 = __toESM(require("path"));
+var path14 = __toESM(require("path"));
 function resolvePlaywrightCli2(cwd = process.cwd()) {
-  const require2 = (0, import_node_module2.createRequire)(path10.join(cwd, "noop.js"));
+  const require2 = (0, import_node_module2.createRequire)(path14.join(cwd, "noop.js"));
   for (const id of ["playwright/cli", "@playwright/test/cli", "playwright/lib/cli/cli"]) {
     try {
       return require2.resolve(id);
@@ -3055,18 +4185,18 @@ function resolvePlaywrightCli2(cwd = process.cwd()) {
 }
 function spawnPlaywright(playwrightArgs2, env, options = {}) {
   const output = options.output ?? "inherit";
-  let fd = output === "inherit" ? null : fs7.openSync(output.file, "a");
+  let fd = output === "inherit" ? null : fs10.openSync(output.file, "a");
   const stdio = fd === null ? "inherit" : ["ignore", fd, fd];
   const cli = resolvePlaywrightCli2();
-  const child = cli ? (0, import_node_child_process3.spawn)(process.execPath, [cli, "test", ...playwrightArgs2], { stdio, env }) : (0, import_node_child_process3.spawn)(process.platform === "win32" ? "npx.cmd" : "npx", ["playwright", "test", ...playwrightArgs2], {
+  const child = cli ? (0, import_node_child_process6.spawn)(process.execPath, [cli, "test", ...playwrightArgs2], { stdio, env }) : (0, import_node_child_process6.spawn)(process.platform === "win32" ? "npx.cmd" : "npx", ["playwright", "test", ...playwrightArgs2], {
     stdio,
     env
   });
-  return new Promise((resolve8) => {
+  return new Promise((resolve10) => {
     const done = (code) => {
-      if (fd !== null) fs7.closeSync(fd);
+      if (fd !== null) fs10.closeSync(fd);
       fd = null;
-      resolve8(code);
+      resolve10(code);
     };
     child.on("error", (err) => {
       console.error(`${options.command ?? "piwi"}: could not start Playwright \u2014 ${err.message}`);
@@ -3077,7 +4207,7 @@ function spawnPlaywright(playwrightArgs2, env, options = {}) {
 }
 
 // src/cli/flake.ts
-var USAGE4 = `
+var USAGE5 = `
 piwi flake \u2014 make a flaky test fail on demand, then prove the fix
 
 Usage:
@@ -3221,7 +4351,7 @@ function parseFlakeArgs(argv) {
 }
 function gitHead() {
   try {
-    return (0, import_node_child_process4.execFileSync)("git", ["rev-parse", "HEAD"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    return (0, import_node_child_process7.execFileSync)("git", ["rev-parse", "HEAD"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
   } catch {
     return null;
   }
@@ -3265,9 +4395,9 @@ function playwrightRunner(dir, log) {
   return {
     now: () => Date.now(),
     async runBatch(plan, arm, repeat, batch) {
-      const planFile = path11.join(dir, `${arm.id}.plan.json`);
-      if (!fs8.existsSync(planFile)) {
-        fs8.writeFileSync(
+      const planFile = path15.join(dir, `${arm.id}.plan.json`);
+      if (!fs11.existsSync(planFile)) {
+        fs11.writeFileSync(
           planFile,
           JSON.stringify({
             version: FLAKE_PLAN_VERSION,
@@ -3278,15 +4408,15 @@ function playwrightRunner(dir, log) {
           })
         );
       }
-      const resultsFile = path11.join(dir, `${arm.id}.${batch}.jsonl`);
-      fs8.writeFileSync(resultsFile, "");
+      const resultsFile = path15.join(dir, `${arm.id}.${batch}.jsonl`);
+      fs11.writeFileSync(resultsFile, "");
       const env = {
         ...process.env,
         [PIWI_FLAKE_ENV.plan]: planFile,
         [PIWI_FLAKE_ENV.results]: resultsFile
       };
       delete env[PIWI_PROBE_ENV.flag];
-      fs8.appendFileSync(log, `
+      fs11.appendFileSync(log, `
 \u2500\u2500 ${arm.id} batch ${batch} \u2500\u2500
 `);
       await spawnPlaywright(playwrightArgs(plan.test, arm, repeat), env, {
@@ -3299,7 +4429,7 @@ function playwrightRunner(dir, log) {
 }
 function readResults(file) {
   const lines = [];
-  for (const line of fs8.readFileSync(file, "utf8").split("\n")) {
+  for (const line of fs11.readFileSync(file, "utf8").split("\n")) {
     if (!line.trim()) continue;
     try {
       lines.push(JSON.parse(line));
@@ -3463,7 +4593,7 @@ function printHeader(plan, commit, estimate, budgetMs) {
 async function loadPlan(args, commit) {
   if (args.planFile) {
     try {
-      const raw = JSON.parse(fs8.readFileSync(args.planFile, "utf8"));
+      const raw = JSON.parse(fs11.readFileSync(args.planFile, "utf8"));
       const plan = "plan" in raw && raw.plan ? raw.plan : raw;
       if (plan.version !== 1 || !plan.control || !Array.isArray(plan.arms)) throw new Error("not a flake-lab plan");
       if (args.verify !== (plan.kind === "verify")) {
@@ -3523,11 +4653,11 @@ async function runFlake(argv, runner) {
   } catch (error) {
     console.error(`piwi flake: ${error.message}
 `);
-    console.error(USAGE4);
-    return EXIT_ERROR4;
+    console.error(USAGE5);
+    return EXIT_ERROR5;
   }
   if (args.help) {
-    console.log(USAGE4);
+    console.log(USAGE5);
     return 0;
   }
   const commit = gitHead();
@@ -3537,11 +4667,11 @@ async function runFlake(argv, runner) {
     ({ plan, http } = await loadPlan(args, commit));
   } catch (error) {
     console.error(`piwi flake: ${error.message}`);
-    return EXIT_ERROR4;
+    return EXIT_ERROR5;
   }
   if (args.suspect != null && !plan.arms.some((a) => a.rank === args.suspect)) {
     console.error(`piwi flake: suspect ${args.suspect} has no arm (${plan.arms.length} arm(s) in the plan).`);
-    return EXIT_ERROR4;
+    return EXIT_ERROR5;
   }
   if (plan.kind === "reproduce" && plan.arms.length === 0) {
     if (!args.json) printHeader(plan, commit, null, args.budgetMs);
@@ -3557,8 +4687,8 @@ async function runFlake(argv, runner) {
   if (!args.json) {
     printHeader(plan, commit, estimate, args.budgetMs);
   }
-  const dir = fs8.mkdtempSync(path11.join(os2.tmpdir(), "piwi-flake-"));
-  const log = path11.join(dir, "playwright.log");
+  const dir = fs11.mkdtempSync(path15.join(os2.tmpdir(), "piwi-flake-"));
+  const log = path15.join(dir, "playwright.log");
   let session;
   try {
     session = await runSession(runner ?? playwrightRunner(dir, log), plan, args, (result) => {
@@ -3566,8 +4696,8 @@ async function runFlake(argv, runner) {
     });
   } catch (error) {
     console.error(`piwi flake: ${error.message}`);
-    if (fs8.existsSync(log)) {
-      const tail = fs8.readFileSync(log, "utf8").trimEnd().split("\n").slice(-LOG_TAIL_LINES).join("\n");
+    if (fs11.existsSync(log)) {
+      const tail = fs11.readFileSync(log, "utf8").trimEnd().split("\n").slice(-LOG_TAIL_LINES).join("\n");
       console.error(`
 Playwright's output (${log}):
 ${tail}`);
@@ -3576,7 +4706,7 @@ ${tail}`);
       console.log("Bisect step: skip (this commit could not run the arm)");
       return EXIT_BISECT_SKIP;
     }
-    return EXIT_ERROR4;
+    return EXIT_ERROR5;
   }
   const { verdict, reproducingArm } = sessionVerdict(plan.kind, session.arms);
   const ran = [session.control, ...session.arms.filter((a) => !a.skipped)];
@@ -3640,7 +4770,7 @@ ${tail}`);
     verifyCommand: plan.kind === "reproduce" && verdict === "reproduced" ? verifyCommand : null,
     exitCode: code
   };
-  fs8.rmSync(dir, { recursive: true, force: true });
+  fs11.rmSync(dir, { recursive: true, force: true });
   if (args.json) {
     console.log(JSON.stringify(report, null, 2));
     return code;
@@ -3655,7 +4785,7 @@ ${tail}`);
 }
 
 // src/cli/gate.ts
-var fs9 = __toESM(require("fs"));
+var fs12 = __toESM(require("fs"));
 
 // ../core/src/gate.ts
 function formatGateResult(result) {
@@ -3684,11 +4814,11 @@ function formatGateResult(result) {
 }
 
 // src/cli/gate.ts
-var EXIT_OK4 = 0;
+var EXIT_OK5 = 0;
 var EXIT_VIOLATED = 1;
-var EXIT_ERROR5 = 2;
+var EXIT_ERROR6 = 2;
 var EXIT_INCONCLUSIVE = 3;
-var USAGE5 = `
+var USAGE6 = `
 piwi gate \u2014 fail a CI job on the dashboard's analysis of a run
 
 Usage:
@@ -3718,6 +4848,7 @@ Policy (at least one is required):
 
 Warn-only (reported, never fails the build):
   --max-uncovered-changes <n>  Warn when more than n changed files have no observed test reach
+  --min-patch-coverage <percent>  Warn when fewer of the changed lines ran, in the commit's combined coverage
 
 Other:
   --json                   Print the raw result as JSON instead of a summary
@@ -3733,6 +4864,14 @@ function readOption4(argv, name) {
   const value = argv[index + 1];
   return value && !value.startsWith("--") ? value : void 0;
 }
+function readPercent(argv, name) {
+  const raw = readOption4(argv, name)?.replace(/%$/, "");
+  if (raw === void 0) return void 0;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n < 0 || n > 100)
+    throw new Error(`${name} expects a percentage from 0 to 100, got "${raw}"`);
+  return n;
+}
 function readCount(argv, name) {
   const raw = readOption4(argv, name);
   if (raw === void 0) return void 0;
@@ -3740,9 +4879,9 @@ function readCount(argv, name) {
   if (!Number.isFinite(n) || n < 0) throw new Error(`${name} expects a non-negative number, got "${raw}"`);
   return Math.floor(n);
 }
-function readRunIdFromFile(path19) {
+function readRunIdFromFile(path23) {
   try {
-    const parsed = JSON.parse(fs9.readFileSync(path19, "utf-8"));
+    const parsed = JSON.parse(fs12.readFileSync(path23, "utf-8"));
     const runId = Number(parsed.runId);
     return Number.isFinite(runId) && runId > 0 ? runId : null;
   } catch {
@@ -3780,7 +4919,8 @@ function parseGateArgs(argv, env) {
     apiKey: readOption4(argv, "--api-key") ?? env.PIWI_API_KEY ?? null,
     runId,
     policy,
-    maxUncoveredChanges: readCount(argv, "--max-uncovered-changes")
+    maxUncoveredChanges: readCount(argv, "--max-uncovered-changes"),
+    minPatchCoverage: readPercent(argv, "--min-patch-coverage")
   };
 }
 async function requestGate(args) {
@@ -3789,7 +4929,11 @@ async function requestGate(args) {
   const res = await fetch(`${args.serverUrl}/api/test-runs/${args.runId}/gate`, {
     method: "POST",
     headers,
-    body: JSON.stringify({ ...args.policy, maxUncoveredChanges: args.maxUncoveredChanges })
+    body: JSON.stringify({
+      ...args.policy,
+      maxUncoveredChanges: args.maxUncoveredChanges,
+      minPatchCoverage: args.minPatchCoverage
+    })
   });
   if (!res.ok) {
     const body = await res.json().catch(() => ({}));
@@ -3799,8 +4943,8 @@ async function requestGate(args) {
 }
 async function runGate(argv, env = process.env) {
   if (argv.includes("-h") || argv.includes("--help")) {
-    console.log(USAGE5);
-    return EXIT_OK4;
+    console.log(USAGE6);
+    return EXIT_OK5;
   }
   let args;
   try {
@@ -3808,15 +4952,15 @@ async function runGate(argv, env = process.env) {
   } catch (e) {
     console.error(`piwi gate: ${e.message}
 `);
-    console.error(USAGE5);
-    return EXIT_ERROR5;
+    console.error(USAGE6);
+    return EXIT_ERROR6;
   }
   let result;
   try {
     result = await requestGate(args);
   } catch (e) {
     console.error(`piwi gate: ${e.message}`);
-    return EXIT_ERROR5;
+    return EXIT_ERROR6;
   }
   if (argv.includes("--json")) {
     console.log(JSON.stringify(result, null, 2));
@@ -3824,13 +4968,13 @@ async function runGate(argv, env = process.env) {
     console.log(formatGateResult(result));
   }
   if (result.verdict === "inconclusive") return EXIT_INCONCLUSIVE;
-  return result.passed ? EXIT_OK4 : EXIT_VIOLATED;
+  return result.passed ? EXIT_OK5 : EXIT_VIOLATED;
 }
 
 // src/cli/init.ts
-var fs12 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
-var import_node_child_process5 = require("child_process");
+var fs15 = __toESM(require("fs"));
+var path18 = __toESM(require("path"));
+var import_node_child_process8 = require("child_process");
 
 // src/cli/report.ts
 var STATUS_MARK = {
@@ -3847,8 +4991,8 @@ function formatStep(result) {
 }
 
 // src/cli/detect.ts
-var fs10 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
 var CONFIG_NAMES = [
   "playwright.config.ts",
   "playwright.config.mts",
@@ -3866,9 +5010,9 @@ var LOCKFILES = [
 ];
 var REPORTER_PACKAGE = "@piwitests/reporter";
 function readPackageJson(root) {
-  const pkgPath = path12.join(root, "package.json");
+  const pkgPath = path16.join(root, "package.json");
   try {
-    return { pkg: JSON.parse(fs10.readFileSync(pkgPath, "utf-8")), pkgPath };
+    return { pkg: JSON.parse(fs13.readFileSync(pkgPath, "utf-8")), pkgPath };
   } catch {
     return { pkg: null, pkgPath: null };
   }
@@ -3877,14 +5021,14 @@ function detectPackageManager(root, pkg) {
   const declared = pkg?.packageManager?.split("@")[0];
   if (declared === "pnpm" || declared === "yarn" || declared === "bun" || declared === "npm") return declared;
   for (const [file, manager] of LOCKFILES) {
-    if (fs10.existsSync(path12.join(root, file))) return manager;
+    if (fs13.existsSync(path16.join(root, file))) return manager;
   }
   return "npm";
 }
 function findConfig(root) {
   for (const name of CONFIG_NAMES) {
-    const candidate = path12.join(root, name);
-    if (fs10.existsSync(candidate)) return candidate;
+    const candidate = path16.join(root, name);
+    if (fs13.existsSync(candidate)) return candidate;
   }
   return null;
 }
@@ -3894,14 +5038,14 @@ function langOf(configPath) {
 }
 function suggestProjectName(root, pkg) {
   const fromPkg = pkg?.name?.replace(/^@[^/]+\//, "").trim();
-  return fromPkg || path12.basename(root) || "default-project";
+  return fromPkg || path16.basename(root) || "default-project";
 }
 function hasReporter(pkg) {
   if (!pkg) return false;
   return Boolean(pkg.dependencies?.[REPORTER_PACKAGE] || pkg.devDependencies?.[REPORTER_PACKAGE]);
 }
 function detectProject(root) {
-  const absRoot = path12.resolve(root);
+  const absRoot = path16.resolve(root);
   const { pkg, pkgPath } = readPackageJson(absRoot);
   const configPath = findConfig(absRoot);
   return {
@@ -4043,8 +5187,8 @@ function ensureGitignoreEntry(existing, entry = ".env") {
 }
 
 // src/cli/skills.ts
-var fs11 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
 
 // ../core/src/skill-stamp.ts
 var SKILL_VERSION_KEY = "piwi-version";
@@ -4107,16 +5251,16 @@ var WORKFLOW_SKILLS = [
   "fix-a-reported-bug"
 ];
 var ALL_SKILLS = [SETUP_SKILL, ...WORKFLOW_SKILLS];
-var DEFAULT_SKILLS_DIR = path13.join(".claude", "skills");
+var DEFAULT_SKILLS_DIR = path17.join(".claude", "skills");
 function findTemplatesDir(fromDir) {
   let dir = fromDir;
   for (let i = 0; i < 6; i++) {
-    if (fs11.existsSync(path13.join(dir, "templates", "skills"))) return path13.join(dir, "templates");
-    const parent = path13.dirname(dir);
+    if (fs14.existsSync(path17.join(dir, "templates", "skills"))) return path17.join(dir, "templates");
+    const parent = path17.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path13.resolve(fromDir, "..", "..", "templates");
+  return path17.resolve(fromDir, "..", "..", "templates");
 }
 function readFrontMatter(markdown) {
   const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(markdown);
@@ -4130,21 +5274,21 @@ function readFrontMatter(markdown) {
 }
 function readTemplatesVersion(templatesDir) {
   try {
-    const pkg = JSON.parse(fs11.readFileSync(path13.join(templatesDir, "..", "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs14.readFileSync(path17.join(templatesDir, "..", "package.json"), "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : "0.0.0";
   } catch {
     return "0.0.0";
   }
 }
 function templatePath(templatesDir, slug) {
-  return path13.join(templatesDir, "skills", slug, "SKILL.md");
+  return path17.join(templatesDir, "skills", slug, "SKILL.md");
 }
 function listSkills(templatesDir, slugs = ALL_SKILLS) {
   const infos = [];
   for (const slug of slugs) {
     const file = templatePath(templatesDir, slug);
-    if (!fs11.existsSync(file)) continue;
-    const front = readFrontMatter(fs11.readFileSync(file, "utf-8"));
+    if (!fs14.existsSync(file)) continue;
+    const front = readFrontMatter(fs14.readFileSync(file, "utf-8"));
     infos.push({ slug, name: front.name ?? slug, description: front.description ?? "" });
   }
   return infos;
@@ -4154,18 +5298,18 @@ function installSkills(opts) {
   for (const slug of opts.slugs) {
     const step = `skill:${slug}`;
     const source = templatePath(opts.templatesDir, slug);
-    const relDest = path13.join(opts.skillsDir, slug, "SKILL.md");
-    const dest = path13.join(opts.root, relDest);
-    if (!fs11.existsSync(source)) {
+    const relDest = path17.join(opts.skillsDir, slug, "SKILL.md");
+    const dest = path17.join(opts.root, relDest);
+    if (!fs14.existsSync(source)) {
       results.push({ step, status: "error", detail: `no template found for "${slug}"` });
       continue;
     }
     const version = opts.version ?? readTemplatesVersion(opts.templatesDir);
-    const contents = stampSkill(fs11.readFileSync(source, "utf-8"), version);
-    const exists = fs11.existsSync(dest);
+    const contents = stampSkill(fs14.readFileSync(source, "utf-8"), version);
+    const exists = fs14.existsSync(dest);
     let detail = "installed skill";
     if (exists) {
-      const installed = fs11.readFileSync(dest, "utf-8");
+      const installed = fs14.readFileSync(dest, "utf-8");
       const state = classifyInstalledSkill(installed, contents);
       const from = readSkillStamp(installed).version;
       if (state === "current") {
@@ -4187,14 +5331,14 @@ function installSkills(opts) {
       }
     }
     if (!opts.dryRun) {
-      fs11.mkdirSync(path13.dirname(dest), { recursive: true });
-      fs11.writeFileSync(dest, contents);
+      fs14.mkdirSync(path17.dirname(dest), { recursive: true });
+      fs14.writeFileSync(dest, contents);
     }
     results.push({ step, file: relDest, status: exists ? "updated" : "created", detail });
   }
   return results;
 }
-var USAGE6 = `
+var USAGE7 = `
 piwi skills \u2014 install the Piwi agent skills into this project
 
 Usage:
@@ -4234,7 +5378,7 @@ function positionalSlugs(argv) {
 function runSkills(argv, templatesDir, cwd = process.cwd()) {
   const [sub, ...rest] = argv;
   if (sub === void 0 || sub === "-h" || sub === "--help") {
-    console.log(USAGE6);
+    console.log(USAGE7);
     return 0;
   }
   if (sub === "list") {
@@ -4255,12 +5399,12 @@ function runSkills(argv, templatesDir, cwd = process.cwd()) {
     if (unknown.length) {
       console.error(`piwi skills: unknown skill(s): ${unknown.join(", ")}
 `);
-      console.error(USAGE6);
+      console.error(USAGE7);
       return 2;
     }
     const results = installSkills({
       templatesDir,
-      root: path13.resolve(readOption5(rest, "--cwd") ?? cwd),
+      root: path17.resolve(readOption5(rest, "--cwd") ?? cwd),
       skillsDir: readOption5(rest, "--dir") ?? DEFAULT_SKILLS_DIR,
       slugs: requested.length ? requested : ALL_SKILLS,
       force: rest.includes("--force"),
@@ -4276,13 +5420,13 @@ function runSkills(argv, templatesDir, cwd = process.cwd()) {
   }
   console.error(`piwi skills: unknown command "${sub}"
 `);
-  console.error(USAGE6);
+  console.error(USAGE7);
   return 2;
 }
 
 // src/cli/init.ts
 var DEFAULT_SERVER_URL = "http://localhost:3000";
-var USAGE7 = `
+var USAGE8 = `
 piwi init \u2014 wire a Playwright project up to a Piwi Dashboard
 
 Usage:
@@ -4331,7 +5475,7 @@ function resolveSkillSlugs(raw) {
   return raw.split(",").map((slug) => slug.trim()).filter(Boolean);
 }
 function parseInitArgs(argv, env, cwd) {
-  const root = path14.resolve(readOption6(argv, "--cwd") ?? cwd);
+  const root = path18.resolve(readOption6(argv, "--cwd") ?? cwd);
   const detected = detectProject(root);
   return {
     root,
@@ -4350,7 +5494,7 @@ function parseInitArgs(argv, env, cwd) {
 }
 function readFileOr(file, fallback) {
   try {
-    return fs12.readFileSync(file, "utf-8");
+    return fs15.readFileSync(file, "utf-8");
   } catch {
     return fallback;
   }
@@ -4380,7 +5524,7 @@ function stepInstallReporter(project, opts) {
   if (opts.dryRun || !opts.install)
     return { step, status: "manual", detail: `Run \`${installCommand(project.packageManager)}\`` };
   const [command, args] = installArgv(project.packageManager);
-  const result = (0, import_node_child_process5.spawnSync)(command, args, { cwd: opts.root, stdio: "inherit" });
+  const result = (0, import_node_child_process8.spawnSync)(command, args, { cwd: opts.root, stdio: "inherit" });
   if (result.status === 0) return { step, status: "updated", detail: `Installed ${REPORTER_PACKAGE}` };
   return {
     step,
@@ -4396,19 +5540,19 @@ function stepConfig(project, opts) {
       status: "manual",
       detail: "No playwright.config found \u2014 create one, then re-run `npx @piwitests/reporter init`"
     };
-  const rel = path14.relative(project.root, project.configPath) || path14.basename(project.configPath);
+  const rel = path18.relative(project.root, project.configPath) || path18.basename(project.configPath);
   const edit = wrapPlaywrightConfig(readFileOr(project.configPath, ""), {
     serverUrl: opts.serverUrl,
     projectName: opts.projectName
   });
-  if (edit.status === "updated" && !opts.dryRun) fs12.writeFileSync(project.configPath, edit.text);
+  if (edit.status === "updated" && !opts.dryRun) fs15.writeFileSync(project.configPath, edit.text);
   return { step, file: rel, status: edit.status, detail: edit.detail };
 }
 function stepFixtures(project, opts) {
   const step = "fixtures";
-  const rel = path14.join("tests", project.configLang === "js" ? "fixtures.js" : "fixtures.ts");
-  const dest = path14.join(project.root, rel);
-  if (fs12.existsSync(dest)) {
+  const rel = path18.join("tests", project.configLang === "js" ? "fixtures.js" : "fixtures.ts");
+  const dest = path18.join(project.root, rel);
+  if (fs15.existsSync(dest)) {
     const current = readFileOr(dest, "");
     if (/piwiFixtures/.test(current))
       return { step, file: rel, status: "already", detail: "capture fixtures already set up" };
@@ -4420,8 +5564,8 @@ function stepFixtures(project, opts) {
     };
   }
   if (!opts.dryRun) {
-    fs12.mkdirSync(path14.dirname(dest), { recursive: true });
-    fs12.writeFileSync(dest, fixturesContents());
+    fs15.mkdirSync(path18.dirname(dest), { recursive: true });
+    fs15.writeFileSync(dest, fixturesContents());
   }
   return {
     step,
@@ -4432,12 +5576,12 @@ function stepFixtures(project, opts) {
 }
 function stepEnv(project, opts) {
   const results = [];
-  const examplePath = path14.join(project.root, ".env.example");
+  const examplePath = path18.join(project.root, ".env.example");
   const example = upsertEnvKeys(readFileOr(examplePath, ""), [
     ["PIWI_DASHBOARD_URL", opts.serverUrl],
     ["PIWI_API_KEY", ""]
   ]);
-  if (example.added.length && !opts.dryRun) fs12.writeFileSync(examplePath, example.text);
+  if (example.added.length && !opts.dryRun) fs15.writeFileSync(examplePath, example.text);
   results.push({
     step: "env",
     file: ".env.example",
@@ -4445,21 +5589,21 @@ function stepEnv(project, opts) {
     detail: example.added.length ? `Recorded ${example.added.join(", ")}` : "connection template already present"
   });
   if (opts.apiKey) {
-    const envPath = path14.join(project.root, ".env");
+    const envPath = path18.join(project.root, ".env");
     const env = upsertEnvKeys(readFileOr(envPath, ""), [
       ["PIWI_DASHBOARD_URL", opts.serverUrl],
       ["PIWI_API_KEY", opts.apiKey]
     ]);
-    if (env.added.length && !opts.dryRun) fs12.writeFileSync(envPath, env.text);
+    if (env.added.length && !opts.dryRun) fs15.writeFileSync(envPath, env.text);
     results.push({
       step: "env",
       file: ".env",
       status: env.added.length ? "updated" : "already",
       detail: env.added.length ? `Wrote ${env.added.join(", ")} (keep .env out of git)` : "already set"
     });
-    const gitignorePath = path14.join(project.root, ".gitignore");
+    const gitignorePath = path18.join(project.root, ".gitignore");
     const gitignore = ensureGitignoreEntry(readFileOr(gitignorePath, ""));
-    if (gitignore.added && !opts.dryRun) fs12.writeFileSync(gitignorePath, gitignore.text);
+    if (gitignore.added && !opts.dryRun) fs15.writeFileSync(gitignorePath, gitignore.text);
     results.push({
       step: "gitignore",
       file: ".gitignore",
@@ -4488,7 +5632,7 @@ function nextSteps(opts, steps) {
 }
 async function runInit(argv, env = process.env, cwd = process.cwd()) {
   if (argv.includes("-h") || argv.includes("--help")) {
-    console.log(USAGE7);
+    console.log(USAGE8);
     return 0;
   }
   const opts = parseInitArgs(argv, env, cwd);
@@ -4521,7 +5665,7 @@ async function runInit(argv, env = process.env, cwd = process.cwd()) {
           project: {
             root: project.root,
             packageManager: project.packageManager,
-            configPath: project.configPath ? path14.relative(project.root, project.configPath) : null,
+            configPath: project.configPath ? path18.relative(project.root, project.configPath) : null,
             projectName: opts.projectName,
             serverUrl: opts.serverUrl
           },
@@ -4545,14 +5689,14 @@ Piwi setup${opts.dryRun ? " (dry run \u2014 nothing written)" : ""} for "${opts.
 }
 
 // src/cli/select.ts
-var fs14 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
-var import_node_child_process6 = require("child_process");
+var fs17 = __toESM(require("fs"));
+var path20 = __toESM(require("path"));
+var import_node_child_process9 = require("child_process");
 var import_node_module4 = require("module");
 
 // src/cli/add-reporter.ts
-var fs13 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
+var path19 = __toESM(require("path"));
 var import_node_module3 = require("module");
 var REPORTER_PACKAGE2 = "@piwitests/reporter";
 var ADD_REPORTER_FLAG = "--add-reporter";
@@ -4585,9 +5729,9 @@ function resolveConfigPath(cwd, playwrightArgs2) {
     const arg = playwrightArgs2[i];
     if (arg === "--config" || arg === "-c") {
       const next = playwrightArgs2[i + 1];
-      if (next) return path15.resolve(cwd, next);
+      if (next) return path19.resolve(cwd, next);
     } else if (arg.startsWith("--config=")) {
-      return path15.resolve(cwd, arg.slice("--config=".length));
+      return path19.resolve(cwd, arg.slice("--config=".length));
     }
   }
   return detectProject(cwd).configPath;
@@ -4595,14 +5739,14 @@ function resolveConfigPath(cwd, playwrightArgs2) {
 function readConfigSource(configPath) {
   if (!configPath) return null;
   try {
-    return fs13.readFileSync(configPath, "utf-8");
+    return fs16.readFileSync(configPath, "utf-8");
   } catch {
     return null;
   }
 }
 function readInstalledPlaywrightVersion(cwd) {
   try {
-    const require2 = (0, import_node_module3.createRequire)(path15.join(cwd, "noop.js"));
+    const require2 = (0, import_node_module3.createRequire)(path19.join(cwd, "noop.js"));
     for (const id of ["@playwright/test/package.json", "playwright/package.json"]) {
       try {
         return require2(id).version ?? null;
@@ -4619,9 +5763,9 @@ function computeAddReporterArgs(cwd, playwrightArgs2) {
 }
 
 // src/cli/select.ts
-var EXIT_OK5 = 0;
-var EXIT_ERROR6 = 2;
-var USAGE8 = `
+var EXIT_OK6 = 0;
+var EXIT_ERROR7 = 2;
+var USAGE9 = `
 piwi select / piwi run \u2014 run a saved selection of tests
 
 Usage:
@@ -4722,13 +5866,13 @@ function parseSelectArgs(argv, env) {
     extra
   };
 }
-var CACHE_FILE = path16.join(".piwi", "selection-cache.json");
+var CACHE_FILE = path20.join(".piwi", "selection-cache.json");
 function cacheKey(args) {
   return `${args.project.toLowerCase()}:${args.key}:${args.format}:${args.budgetMs ?? 0}:${args.shard ?? ""}:${args.order ?? ""}`;
 }
 function readCache(args) {
   try {
-    const store = JSON.parse(fs14.readFileSync(CACHE_FILE, "utf-8"));
+    const store = JSON.parse(fs17.readFileSync(CACHE_FILE, "utf-8"));
     return store[cacheKey(args)] ?? null;
   } catch {
     return null;
@@ -4738,12 +5882,12 @@ function writeCache(args, resolution) {
   try {
     let store = {};
     try {
-      store = JSON.parse(fs14.readFileSync(CACHE_FILE, "utf-8"));
+      store = JSON.parse(fs17.readFileSync(CACHE_FILE, "utf-8"));
     } catch {
     }
     store[cacheKey(args)] = resolution;
-    fs14.mkdirSync(path16.dirname(CACHE_FILE), { recursive: true });
-    fs14.writeFileSync(CACHE_FILE, JSON.stringify(store, null, 2));
+    fs17.mkdirSync(path20.dirname(CACHE_FILE), { recursive: true });
+    fs17.writeFileSync(CACHE_FILE, JSON.stringify(store, null, 2));
   } catch {
   }
 }
@@ -4767,7 +5911,7 @@ function printWarnings(resolution) {
   for (const w of resolution.warnings) console.error(`piwi: warning [${w.code}] ${w.message}`);
 }
 function gitChangedFiles(base) {
-  const out = (0, import_node_child_process6.execFileSync)("git", ["diff", "--name-only", base], {
+  const out = (0, import_node_child_process9.execFileSync)("git", ["diff", "--name-only", base], {
     encoding: "utf-8",
     stdio: ["ignore", "pipe", "ignore"]
   });
@@ -4788,7 +5932,7 @@ async function runSelectImpact(args) {
     impact = await loadImpact(args, projectId);
   } catch (e) {
     console.error(`piwi select: ${e.message}`);
-    return EXIT_ERROR6;
+    return EXIT_ERROR7;
   }
   printWarnings(impact);
   console.error(
@@ -4796,15 +5940,15 @@ async function runSelectImpact(args) {
   );
   if (args.json) {
     console.log(JSON.stringify(impact, null, 2));
-    return EXIT_OK5;
+    return EXIT_OK6;
   }
   console.log(impact.impact.widened ? "" : impact.materialization.args.join(" "));
-  return EXIT_OK5;
+  return EXIT_OK6;
 }
 async function runSelect(argv, env = process.env) {
   if (argv.includes("-h") || argv.includes("--help")) {
-    console.log(USAGE8);
-    return EXIT_OK5;
+    console.log(USAGE9);
+    return EXIT_OK6;
   }
   let args;
   try {
@@ -4812,13 +5956,13 @@ async function runSelect(argv, env = process.env) {
   } catch (e) {
     console.error(`piwi select: ${e.message}
 `);
-    console.error(USAGE8);
-    return EXIT_ERROR6;
+    console.error(USAGE9);
+    return EXIT_ERROR7;
   }
   if (args.key === IMPACT_KEY) {
     if (!args.base) {
       console.error("piwi select: impact needs a base ref \u2014 pass --base <ref> (e.g. --base origin/main)");
-      return EXIT_ERROR6;
+      return EXIT_ERROR7;
     }
     return runSelectImpact(args);
   }
@@ -4828,19 +5972,19 @@ async function runSelect(argv, env = process.env) {
     resolution = await fetchResolution(args, projectId);
   } catch (e) {
     console.error(`piwi select: ${e.message}`);
-    return EXIT_ERROR6;
+    return EXIT_ERROR7;
   }
   printWarnings(resolution);
   if (resolution.estimate.count === 0) {
     console.error(`piwi select: "${args.key}" resolved to 0 tests`);
-    return EXIT_ERROR6;
+    return EXIT_ERROR7;
   }
   if (args.json) console.log(JSON.stringify(resolution, null, 2));
   else console.log(resolution.materialization.args.join(" "));
-  return EXIT_OK5;
+  return EXIT_OK6;
 }
 function resolvePlaywrightCli3() {
-  const require2 = (0, import_node_module4.createRequire)(path16.join(process.cwd(), "noop.js"));
+  const require2 = (0, import_node_module4.createRequire)(path20.join(process.cwd(), "noop.js"));
   for (const id of ["playwright/cli", "@playwright/test/cli", "playwright/lib/cli/cli"]) {
     try {
       return require2.resolve(id);
@@ -4851,16 +5995,16 @@ function resolvePlaywrightCli3() {
 }
 function spawnPlaywright2(pkgRunner, playwrightArgs2, env) {
   const cli = resolvePlaywrightCli3();
-  const child = cli ? (0, import_node_child_process6.spawn)(process.execPath, [cli, "test", ...playwrightArgs2], { stdio: "inherit", env }) : (0, import_node_child_process6.spawn)(process.platform === "win32" ? `${pkgRunner}.cmd` : pkgRunner, ["playwright", "test", ...playwrightArgs2], {
+  const child = cli ? (0, import_node_child_process9.spawn)(process.execPath, [cli, "test", ...playwrightArgs2], { stdio: "inherit", env }) : (0, import_node_child_process9.spawn)(process.platform === "win32" ? `${pkgRunner}.cmd` : pkgRunner, ["playwright", "test", ...playwrightArgs2], {
     stdio: "inherit",
     env
   });
-  return new Promise((resolve8) => {
+  return new Promise((resolve10) => {
     child.on("error", (err) => {
       console.error(`piwi run: could not start Playwright \u2014 ${err.message}`);
-      resolve8(EXIT_ERROR6);
+      resolve10(EXIT_ERROR7);
     });
-    child.on("exit", (code) => resolve8(code ?? EXIT_ERROR6));
+    child.on("exit", (code) => resolve10(code ?? EXIT_ERROR7));
   });
 }
 function spawnPlaywrightForRun(pkgRunner, playwrightArgs2, env) {
@@ -4878,7 +6022,7 @@ async function runRunImpact(args, env) {
   } catch (e) {
     if (args.strict) {
       console.error(`piwi run: ${e.message}`);
-      return EXIT_ERROR6;
+      return EXIT_ERROR7;
     }
     console.error(`piwi run: ${e.message} \u2014 running the full suite`);
     return spawnPlaywrightForRun(args.pkgRunner, args.extra, env);
@@ -4889,7 +6033,7 @@ async function runRunImpact(args, env) {
   } catch (e) {
     if (args.strict) {
       console.error(`piwi run: ${e.message}`);
-      return EXIT_ERROR6;
+      return EXIT_ERROR7;
     }
     console.error(`piwi run: ${e.message} \u2014 running the full suite`);
     return spawnPlaywrightForRun(args.pkgRunner, args.extra, env);
@@ -4903,7 +6047,7 @@ async function runRunImpact(args, env) {
   }
   if (impact.estimate.count === 0) {
     console.error(`piwi run: no tests impacted by ${impact.impact.changedFiles} changed file(s) \u2014 nothing to run`);
-    return EXIT_OK5;
+    return EXIT_OK6;
   }
   const runEnv = {
     ...env,
@@ -4918,8 +6062,8 @@ async function runRunImpact(args, env) {
 }
 async function runRun(argv, env = process.env) {
   if (argv.includes("-h") || argv.includes("--help")) {
-    console.log(USAGE8);
-    return EXIT_OK5;
+    console.log(USAGE9);
+    return EXIT_OK6;
   }
   let args;
   try {
@@ -4927,17 +6071,17 @@ async function runRun(argv, env = process.env) {
   } catch (e) {
     console.error(`piwi run: ${e.message}
 `);
-    console.error(USAGE8);
-    return EXIT_ERROR6;
+    console.error(USAGE9);
+    return EXIT_ERROR7;
   }
   if (args.format === "json") {
     console.error("piwi run: --format json cannot be run; use args, grep or files");
-    return EXIT_ERROR6;
+    return EXIT_ERROR7;
   }
   if (args.key === IMPACT_KEY) {
     if (!args.base) {
       console.error("piwi run: impact needs a base ref \u2014 pass --base <ref> (e.g. --base origin/main)");
-      return EXIT_ERROR6;
+      return EXIT_ERROR7;
     }
     return runRunImpact(args, env);
   }
@@ -4946,7 +6090,7 @@ async function runRun(argv, env = process.env) {
     outcome = await resolveWithCache(args);
   } catch (e) {
     console.error(`piwi run: ${e.message}`);
-    return EXIT_ERROR6;
+    return EXIT_ERROR7;
   }
   if ("error" in outcome) {
     console.error(`piwi run: ${outcome.error.message} \u2014 no cached resolution, running the full suite`);
@@ -4956,7 +6100,7 @@ async function runRun(argv, env = process.env) {
   printWarnings(resolution);
   if (resolution.estimate.count === 0) {
     console.error(`piwi run: "${args.key}" resolved to 0 tests`);
-    return EXIT_ERROR6;
+    return EXIT_ERROR7;
   }
   const runEnv = {
     ...env,
@@ -4973,16 +6117,16 @@ async function runRun(argv, env = process.env) {
 }
 
 // src/cli/preflight.ts
-var fs15 = __toESM(require("fs"));
-var path17 = __toESM(require("path"));
-var import_node_child_process7 = require("child_process");
+var fs18 = __toESM(require("fs"));
+var path21 = __toESM(require("path"));
+var import_node_child_process10 = require("child_process");
 
 // ../core/src/diff-anchors.ts
 var RENAME_FROM = `rename from `;
 var RENAME_TO = "rename to ";
 var HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
-function stripPrefix(path19) {
-  const unquoted = path19.startsWith('"') && path19.endsWith('"') ? path19.slice(1, -1) : path19;
+function stripPrefix(path23) {
+  const unquoted = path23.startsWith('"') && path23.endsWith('"') ? path23.slice(1, -1) : path23;
   return unquoted.replace(/^[ab]\//, "");
 }
 function parseUnifiedDiff(text) {
@@ -5092,8 +6236,8 @@ function pathGlobToRegExp(glob) {
   });
   return new RegExp(`^(?:${parts.join("|")})$`);
 }
-function isTranslationFile(path19, globs = DEFAULT_TRANSLATION_GLOBS) {
-  const posix = path19.replace(/\\/g, "/");
+function isTranslationFile(path23, globs = DEFAULT_TRANSLATION_GLOBS) {
+  const posix = path23.replace(/\\/g, "/");
   if (!TRANSLATION_EXTENSIONS.test(posix)) return false;
   return globs.some((g) => pathGlobToRegExp(g).test(posix));
 }
@@ -5230,16 +6374,16 @@ function unquoteYaml(raw) {
   }
   return v.replace(/\s+#.*$/, "");
 }
-function decodeXml(text) {
+function decodeXml2(text) {
   return text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
 }
-function parseTranslationFile(path19, content) {
+function parseTranslationFile(path23, content) {
   const lines = content.split(/\r?\n/);
   const out = [];
-  const ext = /\.([a-z]+)$/i.exec(path19)?.[1]?.toLowerCase();
+  const ext = /\.([a-z]+)$/i.exec(path23)?.[1]?.toLowerCase();
   if (ext === "json") {
     const stack = [];
-    const path20 = (key) => [...stack.map((f) => f.key), key].join(".");
+    const path24 = (key) => [...stack.map((f) => f.key), key].join(".");
     lines.forEach((text, i) => {
       const t = text.trim();
       const top = stack[stack.length - 1];
@@ -5248,14 +6392,14 @@ function parseTranslationFile(path19, content) {
         const key = JSON.parse(`"${pair[1]}"`);
         const rest = pair[2];
         const str = /^"((?:[^"\\]|\\.)*)"/.exec(rest);
-        if (str) out.push({ key: path20(key), value: JSON.parse(`"${str[1]}"`), line: i + 1 });
+        if (str) out.push({ key: path24(key), value: JSON.parse(`"${str[1]}"`), line: i + 1 });
         else if (/^[[{]\s*$/.test(rest)) stack.push({ key, array: rest.startsWith("["), next: 0 });
         return;
       }
       if (top?.array) {
         const str = /^"((?:[^"\\]|\\.)*)"\s*,?$/.exec(t);
         if (str) {
-          out.push({ key: path20(top.next++), value: JSON.parse(`"${str[1]}"`), line: i + 1 });
+          out.push({ key: path24(top.next++), value: JSON.parse(`"${str[1]}"`), line: i + 1 });
           return;
         }
         if (/^[[{]\s*$/.test(t)) {
@@ -5308,10 +6452,10 @@ function parseTranslationFile(path19, content) {
     let name = null;
     lines.forEach((text, i) => {
       const data = /<data\s+name="([^"]+)"/.exec(text);
-      if (data) name = decodeXml(data[1]);
+      if (data) name = decodeXml2(data[1]);
       const value = /<value>(.*)<\/value>/.exec(text);
       if (value && name) {
-        out.push({ key: name, value: decodeXml(value[1]), line: i + 1 });
+        out.push({ key: name, value: decodeXml2(value[1]), line: i + 1 });
         name = null;
       }
     });
@@ -5319,8 +6463,8 @@ function parseTranslationFile(path19, content) {
   }
   return out;
 }
-function translationLineToken(path19, text, line) {
-  const ext = /\.([a-z]+)$/i.exec(path19)?.[1]?.toLowerCase();
+function translationLineToken(path23, text, line) {
+  const ext = /\.([a-z]+)$/i.exec(path23)?.[1]?.toLowerCase();
   let key;
   let value;
   if (ext === "json") {
@@ -5352,14 +6496,14 @@ function translationLineToken(path19, text, line) {
     }
   } else if (ext === "resx") {
     const m = /<value>(.*)<\/value>/.exec(text);
-    if (m) value = decodeXml(m[1]);
+    if (m) value = decodeXml2(m[1]);
   }
   if (value === void 0 || !keepable(value)) return null;
   return { kind: "translation", group: `translation:${key ?? ""}`, value, key, line };
 }
-function lineTokens(path19, text, line, side, attributes, options) {
+function lineTokens(path23, text, line, side, attributes, options) {
   const spans = [];
-  const markup = MARKUP_FILE.test(path19);
+  const markup = MARKUP_FILE.test(path23);
   return [
     ...attributeTokens(text, attributes, line, spans),
     ...translationRefTokens(text, line, side, options.translations, spans),
@@ -5367,10 +6511,10 @@ function lineTokens(path19, text, line, side, attributes, options) {
     ...textTokens(text, line, markup)
   ];
 }
-function keysByLine(path19, side, options) {
-  const content = options.readFile?.(path19, side);
+function keysByLine(path23, side, options) {
+  const content = options.readFile?.(path23, side);
   if (content === void 0) return null;
-  return new Map(parseTranslationFile(path19, content).map((e) => [e.line, e.key]));
+  return new Map(parseTranslationFile(path23, content).map((e) => [e.line, e.key]));
 }
 function tokenId(t) {
   return `${t.group}\0${t.value}`;
@@ -5670,9 +6814,10 @@ function slotMatches(slot, text) {
       return textMatches(slot.value, slot.exact, text);
   }
 }
+var filePath = (path23) => path23.replace(/\\/g, "/").replace(/^\.\//, "");
 function sameFilePath(a, b) {
-  const x = a.replace(/\\/g, "/").replace(/^\.\//, "");
-  const y = b.replace(/\\/g, "/").replace(/^\.\//, "");
+  const x = filePath(a);
+  const y = filePath(b);
   return x === y || x.endsWith("/" + y) || y.endsWith("/" + x);
 }
 function reachOfIndex(index) {
@@ -5801,11 +6946,11 @@ function buildLiteralEdit(sourceLine, oldValue, newValue) {
 }
 
 // src/cli/preflight.ts
-var EXIT_OK6 = 0;
+var EXIT_OK7 = 0;
 var EXIT_BREAKS = 1;
-var EXIT_ERROR7 = 2;
+var EXIT_ERROR8 = 2;
 var MAX_LISTED = 20;
-var USAGE9 = `
+var USAGE10 = `
 piwi preflight \u2014 the test locators a change breaks, before it runs
 
 Usage:
@@ -5884,16 +7029,16 @@ function parsePreflightArgs(argv) {
 }
 var CONFIG_NAMES2 = ["playwright.config.ts", "playwright.config.js", "playwright.config.mjs", "playwright.config.cjs"];
 function findPlaywrightRoot(from) {
-  let dir = path17.resolve(from);
+  let dir = path21.resolve(from);
   for (; ; ) {
-    if (CONFIG_NAMES2.some((name) => fs15.existsSync(path17.join(dir, name)))) return dir;
-    const parent = path17.dirname(dir);
+    if (CONFIG_NAMES2.some((name) => fs18.existsSync(path21.join(dir, name)))) return dir;
+    const parent = path21.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
-function git(cwd, args) {
-  return (0, import_node_child_process7.execFileSync)("git", args, {
+function git2(cwd, args) {
+  return (0, import_node_child_process10.execFileSync)("git", args, {
     cwd,
     encoding: "utf-8",
     stdio: ["ignore", "pipe", "pipe"],
@@ -5902,7 +7047,7 @@ function git(cwd, args) {
 }
 function tryGit(cwd, args) {
   try {
-    return git(cwd, args);
+    return git2(cwd, args);
   } catch {
     return void 0;
   }
@@ -5917,7 +7062,7 @@ function translationLookup(repoRoot, base, locale) {
   const build = (side) => {
     const map = /* @__PURE__ */ new Map();
     for (const file of files) {
-      const content = side === "new" ? readText(path17.join(repoRoot, file)) : tryGit(repoRoot, ["show", `${base}:${file}`]);
+      const content = side === "new" ? readText(path21.join(repoRoot, file)) : tryGit(repoRoot, ["show", `${base}:${file}`]);
       if (content === void 0) continue;
       for (const entry of parseTranslationFile(file, content)) {
         if (!map.has(entry.key)) map.set(entry.key, entry.value);
@@ -5936,34 +7081,34 @@ function prefersLocale(file, locale) {
 }
 function readText(file) {
   try {
-    return fs15.readFileSync(file, "utf-8");
+    return fs18.readFileSync(file, "utf-8");
   } catch {
     return void 0;
   }
 }
-var CACHE_FILE2 = path17.join(".piwi", "locator-index.json");
+var CACHE_FILE2 = path21.join(".piwi", "locator-index.json");
 function cacheKey2(connection, branch) {
   return `${connection.serverUrl}|${connection.project}|${branch ?? ""}`;
 }
 function readCache2(root, key) {
   try {
-    const store = JSON.parse(fs15.readFileSync(path17.join(root, CACHE_FILE2), "utf-8"));
+    const store = JSON.parse(fs18.readFileSync(path21.join(root, CACHE_FILE2), "utf-8"));
     return store[key] ?? null;
   } catch {
     return null;
   }
 }
 function writeCache2(root, key, index) {
-  const file = path17.join(root, CACHE_FILE2);
+  const file = path21.join(root, CACHE_FILE2);
   try {
     let store = {};
     try {
-      store = JSON.parse(fs15.readFileSync(file, "utf-8"));
+      store = JSON.parse(fs18.readFileSync(file, "utf-8"));
     } catch {
     }
     store[key] = { savedAt: (/* @__PURE__ */ new Date()).toISOString(), index };
-    fs15.mkdirSync(path17.dirname(file), { recursive: true });
-    fs15.writeFileSync(file, JSON.stringify(store));
+    fs18.mkdirSync(path21.dirname(file), { recursive: true });
+    fs18.writeFileSync(file, JSON.stringify(store));
   } catch {
   }
 }
@@ -5979,7 +7124,7 @@ function planSites(b, testRoot) {
   const sites = [...new Set(b.uses.flatMap((u) => u.callSites))];
   return sites.map((callSite) => {
     if (!b.rewrite || !b.replacements?.length) return { callSite, action: "none" };
-    const file = path17.resolve(testRoot, callSiteFile(callSite));
+    const file = path21.resolve(testRoot, callSiteFile(callSite));
     const lineNo = callSiteLine(callSite);
     const text = readText(file);
     if (text === void 0 || lineNo === null) return { callSite, action: "elsewhere" };
@@ -6022,7 +7167,7 @@ function applyEdits(breaks, replacementsOf) {
   }
   const edited = [];
   for (const [file, edits] of byFile) {
-    const text = fs15.readFileSync(file, "utf-8");
+    const text = fs18.readFileSync(file, "utf-8");
     const eol = text.includes("\r\n") ? "\r\n" : "\n";
     const lines = text.split(/\r?\n/);
     for (const e of edits) {
@@ -6032,7 +7177,7 @@ function applyEdits(breaks, replacementsOf) {
     }
     const next = lines.join(eol);
     if (next !== text) {
-      fs15.writeFileSync(file, next);
+      fs18.writeFileSync(file, next);
       edited.push(file);
     }
   }
@@ -6126,8 +7271,8 @@ function renderPreflight(result, cwdToRoot = (f) => f) {
 }
 async function runPreflight(argv, env = process.env, cwd = process.cwd()) {
   if (argv.includes("-h") || argv.includes("--help")) {
-    console.log(USAGE9);
-    return EXIT_OK6;
+    console.log(USAGE10);
+    return EXIT_OK7;
   }
   let args;
   try {
@@ -6135,26 +7280,26 @@ async function runPreflight(argv, env = process.env, cwd = process.cwd()) {
   } catch (e) {
     console.error(`piwi preflight: ${e.message}
 `);
-    console.error(USAGE9);
-    return EXIT_ERROR7;
+    console.error(USAGE10);
+    return EXIT_ERROR8;
   }
   const repoRoot = tryGit(cwd, ["rev-parse", "--show-toplevel"])?.trim();
   if (!repoRoot) {
     console.error("piwi preflight: not inside a git repository");
-    return EXIT_ERROR7;
+    return EXIT_ERROR8;
   }
-  const testRoot = path17.resolve(cwd, args.testRoot ?? findPlaywrightRoot(cwd) ?? cwd);
+  const testRoot = path21.resolve(cwd, args.testRoot ?? findPlaywrightRoot(cwd) ?? cwd);
   let files;
   try {
-    files = parseUnifiedDiff(git(repoRoot, ["diff", "--unified=0", "--no-color", "--no-ext-diff", args.base, "--"]));
+    files = parseUnifiedDiff(git2(repoRoot, ["diff", "--unified=0", "--no-color", "--no-ext-diff", args.base, "--"]));
   } catch (e) {
     console.error(`piwi preflight: could not diff against ${args.base} \u2014 ${e.message.split("\n")[0]}`);
-    return EXIT_ERROR7;
+    return EXIT_ERROR8;
   }
   const connection = resolveConnection(args, env, [.../* @__PURE__ */ new Set([testRoot, cwd, repoRoot])]);
   if (!connection) {
     console.error("piwi preflight: no dashboard URL \u2014 pass --server-url, set PIWI_DASHBOARD_URL, or run piwi init");
-    return EXIT_ERROR7;
+    return EXIT_ERROR8;
   }
   const key = cacheKey2(connection, args.branch);
   let index;
@@ -6168,7 +7313,7 @@ async function runPreflight(argv, env = process.env, cwd = process.cwd()) {
     const cached = readCache2(testRoot, key);
     if (!cached) {
       console.error(`piwi preflight: ${e.message}, and there is no cached index`);
-      return EXIT_ERROR7;
+      return EXIT_ERROR8;
     }
     console.error(
       `piwi preflight: dashboard unreachable, using the index cached ${cached.savedAt} \u2014 ${e.message}`
@@ -6180,7 +7325,7 @@ async function runPreflight(argv, env = process.env, cwd = process.cwd()) {
     testIdAttributes: index.testIdAttributes ?? void 0,
     isTestFile: (file) => TEST_FILE.test(file),
     translations: translationLookup(repoRoot, args.base, args.locale),
-    readFile: (file, side) => side === "new" ? readText(path17.join(repoRoot, file)) : tryGit(repoRoot, ["show", `${args.base}:${file}`])
+    readFile: (file, side) => side === "new" ? readText(path21.join(repoRoot, file)) : tryGit(repoRoot, ["show", `${args.base}:${file}`])
   });
   const found = predictLocatorBreaks(anchors, index, { reach: await loadReach(connection, projectId, args.branch) });
   const replacementsOf = /* @__PURE__ */ new Map();
@@ -6225,13 +7370,13 @@ async function runPreflight(argv, env = process.env, cwd = process.cwd()) {
   if (args.json) console.log(JSON.stringify(result, null, 2));
   else {
     const rel = (file) => {
-      const abs = path17.isAbsolute(file) ? file : path17.resolve(testRoot, file);
-      const r = path17.relative(cwd, abs).split(path17.sep).join("/");
+      const abs = path21.isAbsolute(file) ? file : path21.resolve(testRoot, file);
+      const r = path21.relative(cwd, abs).split(path21.sep).join("/");
       return r.startsWith("..") ? file : r || file;
     };
     console.log(renderPreflight(result, rel));
   }
-  let code = EXIT_OK6;
+  let code = EXIT_OK7;
   const editedSet = new Set(edited);
   const fixed = (s) => s.action === "applied" || s.action === "edit" && !!s.edit && editedSet.has(s.edit.file);
   const unfixed = breaks.some((b) => b.confidence === "likely" && !(b.sites.length && b.sites.every(fixed)));
@@ -6256,12 +7401,12 @@ async function runPreflight(argv, env = process.env, cwd = process.cwd()) {
 }
 
 // src/cli/probe.ts
-var fs16 = __toESM(require("fs"));
+var fs19 = __toESM(require("fs"));
 var os3 = __toESM(require("os"));
-var path18 = __toESM(require("path"));
-var EXIT_OK7 = 0;
-var EXIT_ERROR8 = 2;
-var USAGE10 = `
+var path22 = __toESM(require("path"));
+var EXIT_OK8 = 0;
+var EXIT_ERROR9 = 2;
+var USAGE11 = `
 piwi probe \u2014 run the dashboard's probe plan and record what the suite noticed
 
 Usage:
@@ -6283,18 +7428,18 @@ function escapeRegex2(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 async function runProbe(argv) {
-  const sep5 = argv.indexOf("--");
-  const own = sep5 < 0 ? argv : argv.slice(0, sep5);
-  const playwrightArgs2 = sep5 < 0 ? [] : argv.slice(sep5 + 1);
+  const sep6 = argv.indexOf("--");
+  const own = sep6 < 0 ? argv : argv.slice(0, sep6);
+  const playwrightArgs2 = sep6 < 0 ? [] : argv.slice(sep6 + 1);
   if (own.includes("-h") || own.includes("--help")) {
-    console.log(USAGE10);
-    return EXIT_OK7;
+    console.log(USAGE11);
+    return EXIT_OK8;
   }
   const env = process.env;
   const serverUrl = (readOption9(own, "--server-url") ?? env.PIWI_DASHBOARD_URL ?? "").replace(/\/$/, "");
   if (!serverUrl) {
     console.error("piwi probe: no dashboard URL \u2014 pass --server-url or set PIWI_DASHBOARD_URL");
-    return EXIT_ERROR8;
+    return EXIT_ERROR9;
   }
   const apiKey = readOption9(own, "--api-key") ?? env.PIWI_API_KEY ?? null;
   const project = readOption9(own, "--project") ?? env.PIWI_PROJECT_NAME ?? "";
@@ -6304,30 +7449,30 @@ async function runProbe(argv) {
     projectId = await resolveProjectId({ serverUrl, apiKey, project, key: "" });
   } catch (e) {
     console.error(`piwi probe: ${e.message}`);
-    return EXIT_ERROR8;
+    return EXIT_ERROR9;
   }
-  const authHeaders3 = apiKey ? { "X-API-Key": apiKey } : {};
+  const authHeaders4 = apiKey ? { "X-API-Key": apiKey } : {};
   const planUrl = `${serverUrl}/api/projects/${projectId}/probes/plan${budget ? `?budget=${encodeURIComponent(budget)}` : ""}`;
   let plan;
   try {
-    const res = await fetch(planUrl, { headers: authHeaders3 });
+    const res = await fetch(planUrl, { headers: authHeaders4 });
     if (!res.ok) throw new Error(`dashboard returned ${res.status}`);
     plan = await res.json();
   } catch (e) {
     console.error(`piwi probe: could not fetch the probe plan \u2014 ${e.message}`);
-    return EXIT_ERROR8;
+    return EXIT_ERROR9;
   }
   if (!plan.items || plan.items.length === 0) {
     console.error("piwi probe: nothing to probe \u2014 the plan is empty.");
-    return EXIT_OK7;
+    return EXIT_OK8;
   }
   console.error(`piwi probe: ${plan.items.length} pair(s) to probe (budget ${plan.budget}).`);
-  const dir = fs16.mkdtempSync(path18.join(os3.tmpdir(), "piwi-probe-"));
-  const planFile = path18.join(dir, "plan.json");
-  const resultsFile = path18.join(dir, "results.jsonl");
-  const runOutputFile = path18.join(dir, "run.json");
-  fs16.writeFileSync(planFile, JSON.stringify(plan));
-  fs16.writeFileSync(resultsFile, "");
+  const dir = fs19.mkdtempSync(path22.join(os3.tmpdir(), "piwi-probe-"));
+  const planFile = path22.join(dir, "plan.json");
+  const resultsFile = path22.join(dir, "results.jsonl");
+  const runOutputFile = path22.join(dir, "run.json");
+  fs19.writeFileSync(planFile, JSON.stringify(plan));
+  fs19.writeFileSync(resultsFile, "");
   const grep = plan.items.map((i) => i.testTitle).filter(Boolean).map(escapeRegex2).join("|");
   const pwArgs = [...playwrightArgs2];
   if (grep && !playwrightArgs2.includes("--grep") && !playwrightArgs2.includes("-g")) pwArgs.push("--grep", grep);
@@ -6341,7 +7486,7 @@ async function runProbe(argv) {
     [PIWI_ENV_KEYS.outputFile]: runOutputFile
   };
   await spawnPlaywright(pwArgs, childEnv, { command: "piwi probe" });
-  const lines = fs16.readFileSync(resultsFile, "utf8").split("\n").filter(Boolean);
+  const lines = fs19.readFileSync(resultsFile, "utf8").split("\n").filter(Boolean);
   const results = [];
   for (const line of lines) {
     try {
@@ -6351,18 +7496,18 @@ async function runProbe(argv) {
   }
   if (results.length === 0) {
     console.error("piwi probe: no probe outcomes were recorded (are the Piwi capture fixtures active?).");
-    return EXIT_OK7;
+    return EXIT_OK8;
   }
   let runId = null;
   try {
-    const out = JSON.parse(fs16.readFileSync(runOutputFile, "utf8"));
+    const out = JSON.parse(fs19.readFileSync(runOutputFile, "utf8"));
     if (typeof out.runId === "number") runId = out.runId;
   } catch {
   }
   try {
     const res = await fetch(`${serverUrl}/api/projects/${projectId}/probes/results`, {
       method: "POST",
-      headers: { "Content-Type": "application/json", ...authHeaders3 },
+      headers: { "Content-Type": "application/json", ...authHeaders4 },
       body: JSON.stringify({ runId, results })
     });
     if (!res.ok) throw new Error(`dashboard returned ${res.status}`);
@@ -6374,19 +7519,19 @@ async function runProbe(argv) {
     );
   } catch (e) {
     console.error(`piwi probe: could not post probe results \u2014 ${e.message}`);
-    return EXIT_ERROR8;
+    return EXIT_ERROR9;
   }
-  return EXIT_OK7;
+  return EXIT_OK8;
 }
 
 // src/cli/quality-report.ts
-var fs17 = __toESM(require("fs"));
-var EXIT_OK8 = 0;
+var fs20 = __toESM(require("fs"));
+var EXIT_OK9 = 0;
 var EXIT_VERDICT = 1;
-var EXIT_ERROR9 = 2;
+var EXIT_ERROR10 = 2;
 var FORMATS = ["md", "json", "html", "pdf", "csv"];
 var DASHBOARDS = ["executive", "engineering", "overview"];
-var USAGE11 = `
+var USAGE12 = `
 piwi report \u2014 print a quality report from the dashboard
 
 Usage:
@@ -6489,8 +7634,8 @@ async function fetchReport(args, query) {
 }
 async function runQualityReport(argv) {
   if (argv.includes("-h") || argv.includes("--help")) {
-    console.log(USAGE11);
-    return EXIT_OK8;
+    console.log(USAGE12);
+    return EXIT_OK9;
   }
   try {
     const args = parseReportArgs(argv, process.env);
@@ -6500,23 +7645,23 @@ async function runQualityReport(argv) {
     }
     const res = await fetchReport(args, reportQuery(args, projectIds, args.format));
     const bytes = new Uint8Array(await res.arrayBuffer());
-    if (args.output) fs17.writeFileSync(args.output, bytes);
+    if (args.output) fs20.writeFileSync(args.output, bytes);
     else process.stdout.write(bytes);
-    if (!args.failOn) return EXIT_OK8;
+    if (!args.failOn) return EXIT_OK9;
     const bundle = args.format === "json" ? JSON.parse(new TextDecoder().decode(bytes)) : await (await fetchReport(args, reportQuery(args, projectIds, "json"))).json();
     if (failsOn(bundle.verdict.tone, args.failOn)) {
       console.error(`piwi report: the verdict is ${bundle.verdict.tone}`);
       return EXIT_VERDICT;
     }
-    return EXIT_OK8;
+    return EXIT_OK9;
   } catch (e) {
     console.error(`piwi report: ${e.message}`);
-    return EXIT_ERROR9;
+    return EXIT_ERROR10;
   }
 }
 
 // src/cli/index.ts
-var USAGE12 = `
+var USAGE13 = `
 piwi \u2014 companion commands for the Piwi Dashboard reporter
 
 Usage:
@@ -6527,6 +7672,7 @@ Commands:
   skills    Install the Piwi agent skills into this project
   gate      Fail a CI job on the dashboard's analysis of a run
   report    Print a quality report (Markdown, PDF, HTML, CSV or JSON)
+  coverage  Upload a unit-test (or other) coverage report of a commit (coverage upload)
   select    Print the Playwright args for a saved test selection
   run       Run a saved test selection with playwright test
   probe     Run the dashboard's probe plan and record what the suite noticed
@@ -6551,6 +7697,8 @@ async function main() {
       return runGate(rest);
     case "report":
       return runQualityReport(rest);
+    case "coverage":
+      return runCoverage(rest);
     case "select":
       return runSelect(rest);
     case "run":
@@ -6570,12 +7718,12 @@ async function main() {
     case void 0:
     case "-h":
     case "--help":
-      console.log(USAGE12);
+      console.log(USAGE13);
       return 0;
     default:
       console.error(`piwi: unknown command "${command}"
 `);
-      console.error(USAGE12);
+      console.error(USAGE13);
       return 2;
   }
 }