@cldmv/vitest-runner 1.1.0 → 1.4.2

package/bin/vitest-runner.mjs

@@ -1,95 +1,1559 @@
 #!/usr/bin/env node
-/**
- * @fileoverview CLI entry point for the vitest-runner binary.
- * @module vitest-runner/bin/vitest-runner
- *
- * Mirrors its own output to a log file when --coverage-quiet or --log-file is set, then
- * delegates all logic to `src/runner.mjs` via the programmatic `run()` API.
- */
-
-import { createWriteStream, mkdirSync } from "node:fs";
-import path from "node:path";
-import { parseArguments } from "../src/cli/args.mjs";
-import { showHelp } from "../src/cli/help.mjs";
-import { run } from "../src/runner.mjs";
-import { stripAnsi } from "../src/utils/ansi.mjs";
-
-const args = parseArguments(process.argv.slice(2));
 
-if (args.help) {
-	showHelp();
-	process.exit(0);
+// src/bin/vitest-runner.mjs
+import { createWriteStream, mkdirSync } from "fs";
+import path6 from "path";
+
+// src/cli/args.mjs
+var RUNNER_FLAGS = /* @__PURE__ */ new Set([
+  "--test-list",
+  "--no-error-details",
+  "--coverage-quiet",
+  "--log-file",
+  "--suppress-file-output",
+  "--suppress-passing-files",
+  "--no-top-summary",
+  "--json",
+  "--blobs-dir",
+  "--no-merge-reports",
+  "--workers",
+  "--solo-pattern",
+  "--file-pattern",
+  "--keep-tmp",
+  "--scratch-dir",
+  "--help",
+  "-h"
+]);
+function parseArguments(args2) {
+  const vitestPassthroughArgs = [];
+  const testPatterns = [];
+  const soloPatterns = [];
+  let testListFile;
+  let showErrorDetails = true;
+  let coverageQuiet = false;
+  let logFile;
+  let suppressFileOutput = false;
+  let suppressPassingFiles = false;
+  let topSummary = true;
+  let json = false;
+  let blobsDir;
+  let mergeReports = true;
+  let workers;
+  let help = false;
+  let testFilePattern;
+  let keepTmp = false;
+  let scratchDir;
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "--test-list") {
+      testListFile = args2[++i];
+    } else if (arg.startsWith("--test-list=")) {
+      testListFile = arg.slice("--test-list=".length);
+    } else if (arg === "--no-error-details") {
+      showErrorDetails = false;
+    } else if (arg === "--coverage-quiet") {
+      coverageQuiet = true;
+    } else if (arg === "--log-file") {
+      logFile = args2[++i];
+    } else if (arg.startsWith("--log-file=")) {
+      logFile = arg.slice("--log-file=".length);
+    } else if (arg === "--suppress-file-output") {
+      suppressFileOutput = true;
+    } else if (arg === "--suppress-passing-files") {
+      suppressPassingFiles = true;
+    } else if (arg === "--no-top-summary") {
+      topSummary = false;
+    } else if (arg === "--json") {
+      json = true;
+    } else if (arg === "--blobs-dir") {
+      blobsDir = args2[++i];
+    } else if (arg.startsWith("--blobs-dir=")) {
+      blobsDir = arg.slice("--blobs-dir=".length);
+    } else if (arg === "--no-merge-reports") {
+      mergeReports = false;
+    } else if (arg === "--workers") {
+      workers = parseInt(args2[++i], 10);
+    } else if (arg.startsWith("--workers=")) {
+      workers = parseInt(arg.slice("--workers=".length), 10);
+    } else if (arg === "--solo-pattern") {
+      soloPatterns.push(args2[++i]);
+    } else if (arg.startsWith("--solo-pattern=")) {
+      soloPatterns.push(arg.slice("--solo-pattern=".length));
+    } else if (arg === "--file-pattern") {
+      testFilePattern = new RegExp(args2[++i], "i");
+    } else if (arg.startsWith("--file-pattern=")) {
+      testFilePattern = new RegExp(arg.slice("--file-pattern=".length), "i");
+    } else if (arg === "--keep-tmp") {
+      keepTmp = true;
+    } else if (arg === "--scratch-dir") {
+      scratchDir = args2[++i];
+    } else if (arg.startsWith("--scratch-dir=")) {
+      scratchDir = arg.slice("--scratch-dir=".length);
+    } else if (arg === "--help" || arg === "-h") {
+      help = true;
+    } else if ((arg.startsWith("--") || arg.startsWith("-")) && !RUNNER_FLAGS.has(arg)) {
+      vitestPassthroughArgs.push(arg);
+      if (i + 1 < args2.length && !args2[i + 1].startsWith("-")) {
+        vitestPassthroughArgs.push(args2[++i]);
+      }
+    } else {
+      testPatterns.push(arg);
+    }
+  }
+  return {
+    testListFile,
+    showErrorDetails,
+    coverageQuiet,
+    logFile,
+    suppressFileOutput,
+    suppressPassingFiles,
+    topSummary,
+    json,
+    blobsDir,
+    mergeReports,
+    help,
+    workers,
+    soloPatterns,
+    testFilePattern,
+    vitestPassthroughArgs,
+    testPatterns,
+    keepTmp,
+    scratchDir
+  };
+}
+
+// src/cli/help.mjs
+import chalk from "chalk";
+function showHelp() {
+  console.log(`
+${chalk.bold("Vitest Sequential Runner")}
+Runs each test file in its own Vitest process to avoid OOM issues.
+
+${chalk.bold("USAGE:")}
+  vitest-runner [OPTIONS] [PATTERNS]
+
+${chalk.bold("SPECIAL FLAGS:")}
+  --test-list <file>      Run only the files listed in a JSON array file
+  --file-pattern <regex>  Override the file discovery regex (default: \\.test\\.vitest\\.(?:js|mjs|cjs)$)
+  --workers <n>           Number of parallel workers (default: 4 or VITEST_WORKERS)
+  --solo-pattern <pat>    Run files matching this path substring solo first (repeatable)
+  --no-error-details      Hide detailed error output (show only counts)
+  --coverage-quiet        Implies --coverage; show progress bar + final summaries only
+  --log-file <path>       Path for mirrored runner output (default: coverage/coverage-run.log with --coverage-quiet)
+  --suppress-file-output  Suppress per-file runner output blocks
+  --suppress-passing-files  Hide the PASSED TEST FILES section in the final summary
+  --no-top-summary        Hide TOP MEMORY USERS and TOP DURATION sections
+  --json                  Emit JSON summary output instead of text logs
+  --blobs-dir <path>      Directory for per-file coverage blobs (default: .vitest-coverage-blobs)
+  --no-merge-reports      Leave coverage blobs in --blobs-dir without merging (for an external merge)
+  --keep-tmp              Keep this run's scratch directory instead of removing it on completion
+  --scratch-dir <path>    Per-run scratch root, relative to cwd (default: tmp/vitest-runner)
+  --help, -h              Show this help message
+
+${chalk.bold("TEST PATTERNS:")}
+  [file]                  Run a specific test file (supports partial paths)
+  [folder]                Run all tests in a folder
+
+  Examples:
+    src/tests/config/background.test.vitest.mjs
+    src/tests/metadata
+    background.test.vitest.mjs
+
+${chalk.bold("VITEST FLAGS:")}
+  All standard Vitest CLI flags are supported and passed through:
+  -t, --testNamePattern   Filter tests by name pattern (regex)
+  --reporter              Change reporter (verbose, dot, json, etc.)
+  --coverage              Run full-suite coverage (blob-per-file + mergeReports)
+  --bail                  Stop on first failure
+
+  See the Vitest documentation for the full list.
+
+${chalk.bold("ENVIRONMENT VARIABLES:")}
+  VITEST_HEAP_MB         Set max heap size per test (default: Node.js default)
+  VITEST_WORKERS         Number of parallel workers (default: 4, overridden by --workers)
+  VITEST_RUNNER_TMP      Set by the runner in each child \u2014 this run's per-file scratch
+                         directory. Use makeRunTmpDir(label) from a test file instead
+                         of reading it directly when you want a fresh subdirectory.
+  # Run all tests
+  vitest-runner
+
+  # Run a specific file (partial path ok)
+  vitest-runner src/tests/config/background.test.vitest.mjs
+
+  # Run only the files listed in a JSON file
+  vitest-runner --test-list my-tests.json
+
+  # Filter by test name
+  vitest-runner src/tests/metadata -t "lazy materialization"
+
+  # Run with 2 workers
+  vitest-runner --workers 2
+
+  # Run files matching a pattern solo first, then the rest in parallel
+  vitest-runner --solo-pattern listener-cleanup/ --solo-pattern heavy/
+
+  # Hide detailed errors
+  vitest-runner --no-error-details
+
+  # Coverage with quiet output + progress bar
+  vitest-runner --coverage --coverage-quiet
+
+  # Custom heap and workers
+  VITEST_HEAP_MB=8192 vitest-runner --workers 2 src/tests/heavy
+`);
 }
 
-// Mirror all output (excluding progress bar lines) to a log file
-// when running in --coverage-quiet mode (or when --log-file is set).
+// src/runner.mjs
+import fs5 from "fs/promises";
+import path5 from "path";
+import chalk4 from "chalk";
+
+// src/utils/resolve.mjs
+import { createRequire } from "module";
+import path from "path";
+import fs from "fs/promises";
+import { pathToFileURL } from "url";
+function resolveBin(cwd2, pkgName, binName = pkgName) {
+  const require2 = createRequire(pathToFileURL(path.join(cwd2, "package.json")));
+  const pkgJsonPath = require2.resolve(`${pkgName}/package.json`);
+  const pkg = require2(pkgJsonPath);
+  const rel = pkg.bin?.[binName] ?? pkg.bin;
+  if (!rel) throw new Error(`No bin "${binName}" found in ${pkgName}/package.json`);
+  return path.join(path.dirname(pkgJsonPath), rel);
+}
+var DEFAULT_CONFIG_NAMES = Object.freeze([
+  "vitest.config.ts",
+  "vitest.config.mts",
+  "vitest.config.cts",
+  "vitest.config.mjs",
+  "vitest.config.js",
+  "vitest.config.cjs",
+  "vite.config.ts",
+  "vite.config.mts",
+  "vite.config.mjs",
+  "vite.config.js"
+]);
+async function resolveVitestConfig(cwd2, configPath) {
+  if (configPath) {
+    return path.isAbsolute(configPath) ? configPath : path.resolve(cwd2, configPath);
+  }
+  for (const name of DEFAULT_CONFIG_NAMES) {
+    const candidate = path.join(cwd2, name);
+    try {
+      await fs.access(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return void 0;
+}
+
+// src/core/discover.mjs
+import fs2 from "fs/promises";
+import path2 from "path";
+var DEFAULT_TEST_FILE_PATTERN = /\.test\.vitest\.(?:js|mjs|cjs)$/i;
+async function discoverFilesInDir(dir, cwd2, pattern = DEFAULT_TEST_FILE_PATTERN) {
+  const queue = [dir];
+  const files = [];
+  while (queue.length) {
+    const current = queue.pop();
+    let entries;
+    try {
+      entries = await fs2.readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+        queue.push(path2.join(current, entry.name));
+        continue;
+      }
+      if (entry.isFile() && pattern.test(entry.name)) {
+        files.push(path2.relative(cwd2, path2.join(current, entry.name)));
+      }
+    }
+  }
+  return files;
+}
+function sortWithPriority(files, earlyRunPatterns = []) {
+  const early = [];
+  const rest = [];
+  for (const file of files) {
+    const normalized = file.replace(/\\/g, "/");
+    const priorityIndex = earlyRunPatterns.findIndex((pat) => normalized.includes(pat));
+    if (priorityIndex !== -1) {
+      early.push({ file, priorityIndex });
+    } else {
+      rest.push(file);
+    }
+  }
+  early.sort((a, b) => a.priorityIndex - b.priorityIndex || a.file.localeCompare(b.file));
+  rest.sort((a, b) => a.localeCompare(b));
+  return [...early.map((e) => e.file), ...rest];
+}
+function computeFilterConflicts(files) {
+  const normalized = files.map((f) => f.replace(/\\/g, "/"));
+  const conflicts = /* @__PURE__ */ new Map();
+  for (let i = 0; i < files.length; i++) {
+    const matches = [];
+    for (let j = 0; j < files.length; j++) {
+      if (i === j) continue;
+      if (normalized[j].includes(normalized[i])) matches.push(files[j]);
+    }
+    conflicts.set(files[i], matches);
+  }
+  return conflicts;
+}
+async function discoverVitestFiles(opts) {
+  const { cwd: cwd2, testDir, testPatterns = [], testListFile, testFilePattern = DEFAULT_TEST_FILE_PATTERN, earlyRunPatterns = [] } = opts;
+  const resolvedTestDir = testDir ? path2.isAbsolute(testDir) ? testDir : path2.resolve(cwd2, testDir) : cwd2;
+  if (testListFile) {
+    const resolvedListPath = path2.isAbsolute(testListFile) ? testListFile : path2.resolve(cwd2, testListFile);
+    let testList;
+    try {
+      const content = await fs2.readFile(resolvedListPath, "utf8");
+      testList = JSON.parse(content);
+    } catch (err) {
+      throw new Error(`Failed to read test list file "${resolvedListPath}": ${err.message}`, { cause: err });
+    }
+    if (!Array.isArray(testList)) {
+      throw new Error(`Test list file "${resolvedListPath}" must contain a JSON array of test file paths`);
+    }
+    console.log(`\u{1F4CB} Loading test list from: ${path2.relative(cwd2, resolvedListPath)}`);
+    return sortWithPriority(testList, earlyRunPatterns);
+  }
+  if (testPatterns.length === 0) {
+    const files2 = await discoverFilesInDir(resolvedTestDir, cwd2, testFilePattern);
+    return sortWithPriority(files2, earlyRunPatterns);
+  }
+  const files = [];
+  for (const pattern of testPatterns) {
+    const absPath = path2.isAbsolute(pattern) ? pattern : path2.resolve(cwd2, pattern);
+    let stat = null;
+    try {
+      stat = await fs2.stat(absPath);
+    } catch {
+    }
+    if (stat?.isFile()) {
+      if (testFilePattern.test(absPath)) {
+        files.push(path2.relative(cwd2, absPath));
+      }
+    } else if (stat?.isDirectory()) {
+      files.push(...await discoverFilesInDir(absPath, cwd2, testFilePattern));
+    } else {
+      const allFiles = await discoverFilesInDir(resolvedTestDir, cwd2, testFilePattern);
+      const matched = allFiles.filter((f) => f.replace(/\\/g, "/").includes(pattern.replace(/\\/g, "/")));
+      if (matched.length > 0) {
+        files.push(...matched);
+      } else {
+        console.warn(`\u26A0\uFE0F  No matches found for: ${pattern}`);
+      }
+    }
+  }
+  return sortWithPriority([...new Set(files)], earlyRunPatterns);
+}
+
+// src/core/spawn.mjs
+import { spawn } from "child_process";
+
+// src/utils/ansi.mjs
+function stripAnsi(text) {
+  return text.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
+}
+function colourPct(chalk5, pct) {
+  const str = pct.toFixed(2).padStart(6);
+  if (pct >= 80) return chalk5.green(str);
+  if (pct >= 50) return chalk5.yellow(str);
+  return chalk5.red(str);
+}
+
+// src/core/parse.mjs
+function parseVitestOutput(output) {
+  const cleanOutput = stripAnsi(output);
+  const result = {
+    testFilesPass: 0,
+    testFilesFail: 0,
+    testsPass: 0,
+    testsFail: 0,
+    testsSkip: 0,
+    duration: 0,
+    heapMb: null,
+    errors: []
+  };
+  const testFilesLineMatch = cleanOutput.match(/Test Files\s+(.+)/);
+  if (testFilesLineMatch) {
+    const line = testFilesLineMatch[1];
+    const passMatch = line.match(/(\d+)\s+passed/);
+    const failMatch = line.match(/(\d+)\s+failed/);
+    if (passMatch) result.testFilesPass = parseInt(passMatch[1], 10);
+    if (failMatch) result.testFilesFail = parseInt(failMatch[1], 10);
+  }
+  const testsLineMatch = cleanOutput.match(/^\s*Tests\s+(.+)$/m);
+  if (testsLineMatch) {
+    const line = testsLineMatch[1];
+    const passMatch = line.match(/(\d+)\s+passed/);
+    const failMatch = line.match(/(\d+)\s+failed/);
+    const skipMatch = line.match(/(\d+)\s+skipped/);
+    if (passMatch) result.testsPass = parseInt(passMatch[1], 10);
+    if (failMatch) result.testsFail = parseInt(failMatch[1], 10);
+    if (skipMatch) result.testsSkip = parseInt(skipMatch[1], 10);
+  }
+  const durationMatch = cleanOutput.match(/Duration\s+([\d.]+)s/);
+  if (durationMatch) {
+    result.duration = parseFloat(durationMatch[1]) * 1e3;
+  }
+  const heapMatch = cleanOutput.match(/(\d+)\s*MB\s+heap\s+used/i);
+  if (heapMatch) {
+    result.heapMb = parseInt(heapMatch[1], 10);
+  }
+  const failedSectionStart = output.indexOf("Failed Tests");
+  if (failedSectionStart !== -1) {
+    const failedSectionEnd = output.indexOf("\n Test Files", failedSectionStart);
+    const errorSection = failedSectionEnd !== -1 ? output.substring(failedSectionStart, failedSectionEnd) : output.substring(failedSectionStart);
+    const failPattern = /FAIL\s*(?:\x1B\[[0-9;]*[a-zA-Z]|\s)*tests\//g;
+    const matches = [...errorSection.matchAll(failPattern)];
+    for (let i = 0; i < matches.length; i++) {
+      const matchPos = matches[i].index;
+      const lineStart = errorSection.lastIndexOf("\n", matchPos);
+      const actualStart = lineStart === -1 ? 0 : lineStart;
+      const matchEnd = i < matches.length - 1 ? matches[i + 1].index : errorSection.length;
+      const nextLineStart = errorSection.lastIndexOf("\n", matchEnd);
+      const actualEnd = nextLineStart === -1 ? matchEnd : nextLineStart;
+      const errorBlock = errorSection.substring(actualStart, actualEnd).trim();
+      if (errorBlock) result.errors.push(errorBlock);
+    }
+  }
+  return result;
+}
+function deduplicateErrors(errors) {
+  const fullText = errors.join("\n");
+  const lines = fullText.split("\n");
+  const failLineMap = /* @__PURE__ */ new Map();
+  const lineIndices = /* @__PURE__ */ new Map();
+  lines.forEach((line, idx) => {
+    if (line.includes("FAIL") && line.includes("Config:")) {
+      lineIndices.set(line, idx);
+      const cleaned = stripAnsi(line);
+      const match = cleaned.match(/^(.+Config:\s+)'*([^'>]+)'*(.+)$/);
+      if (match) {
+        const [, before, config, after] = match;
+        const pattern = `${before.trim()}|||${after.trim()}`;
+        if (!failLineMap.has(pattern)) {
+          failLineMap.set(pattern, { lines: [], configs: [] });
+        }
+        failLineMap.get(pattern).lines.push(line);
+        failLineMap.get(pattern).configs.push(config.replace(/'/g, ""));
+      }
+    }
+  });
+  const skipIndices = /* @__PURE__ */ new Set();
+  for (const [, data] of failLineMap.entries()) {
+    if (data.configs.length > 1) {
+      for (let i = 1; i < data.lines.length; i++) {
+        const idx = lineIndices.get(data.lines[i]);
+        skipIndices.add(idx);
+      }
+      const firstLine = data.lines[0];
+      const configArray = `[${data.configs.map((c) => `'${c}'`).join(",")}]`;
+      const consolidated = stripAnsi(firstLine).replace(/(Config:\s+)'*[^'>]+'*/, `$1${configArray}`);
+      const firstIdx = lineIndices.get(firstLine);
+      lines[firstIdx] = consolidated;
+    }
+  }
+  return lines.filter((_, idx) => !skipIndices.has(idx)).join("\n");
+}
+
+// src/utils/env.mjs
+function buildNodeOptions({ maxOldSpaceMb, conditions = [], base = process.env.NODE_OPTIONS ?? "" }) {
+  let opts = base;
+  for (const cond of conditions) {
+    const flag = `--conditions=${cond}`;
+    if (!opts.includes(flag)) {
+      opts = opts ? `${opts} ${flag}` : flag;
+    }
+  }
+  if (maxOldSpaceMb && !opts.includes("--max-old-space-size")) {
+    const flag = `--max-old-space-size=${maxOldSpaceMb}`;
+    opts = opts ? `${opts} ${flag}` : flag;
+  }
+  return opts.trim();
+}
+
+// src/core/spawn.mjs
+function buildEnv({ maxOldSpaceMb, conditions = [], nodeEnv = "development", extraEnv = {} }) {
+  const env = { ...process.env };
+  if (!env.NODE_ENV) env.NODE_ENV = nodeEnv;
+  const nodeOptions = buildNodeOptions({ maxOldSpaceMb, conditions, base: env.NODE_OPTIONS ?? "" });
+  if (nodeOptions) env.NODE_OPTIONS = nodeOptions;
+  Object.assign(env, extraEnv);
+  return env;
+}
+function buildBaseArgs(vitestBin, vitestConfig) {
+  const configArgs = vitestConfig ? ["--config", vitestConfig] : [];
+  return [vitestBin, ...configArgs, "run"];
+}
+function runSingleFile(filePath, opts) {
+  const {
+    cwd: cwd2,
+    vitestBin,
+    vitestConfig,
+    maxOldSpaceMb,
+    conditions = [],
+    nodeEnv = "development",
+    vitestArgs: vitestArgs2 = [],
+    streamOutput = true,
+    // Other discovered files whose path would spuriously also match Vitest's
+    // own substring filter on `filePath` (see discover.mjs computeFilterConflicts).
+    // Excluded explicitly so this invocation runs exactly `filePath`.
+    excludePaths = [],
+    // Extra env vars for the child (e.g. VITEST_RUNNER_TMP — see core/scratch.mjs).
+    extraEnv = {}
+  } = opts;
+  return new Promise((resolve) => {
+    const startTime = Date.now();
+    const excludeArgs = excludePaths.flatMap((p) => ["--exclude", p]);
+    const args2 = [...buildBaseArgs(vitestBin, vitestConfig), ...vitestArgs2, ...excludeArgs, filePath];
+    const env = buildEnv({ maxOldSpaceMb, conditions, nodeEnv, extraEnv });
+    const child = spawn(process.execPath, args2, { cwd: cwd2, stdio: ["ignore", "pipe", "pipe"], env });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+      if (streamOutput) process.stdout.write(data);
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+      if (streamOutput) process.stderr.write(data);
+    });
+    child.on("close", (code) => {
+      const spawnDuration = Date.now() - startTime;
+      const output = `${stdout}
+${stderr}`;
+      const parsed = parseVitestOutput(output);
+      resolve({
+        file: filePath,
+        code: code ?? 1,
+        // c8 ignore next -- false branch verified manually; V8 ternary probe mismatch inside object literal
+        duration: parsed.duration > 0 ? parsed.duration : spawnDuration,
+        testFilesPass: parsed.testFilesPass,
+        testFilesFail: parsed.testFilesFail,
+        testsPass: parsed.testsPass,
+        testsFail: parsed.testsFail,
+        testsSkip: parsed.testsSkip,
+        heapMb: parsed.heapMb,
+        errors: parsed.errors,
+        rawOutput: output
+      });
+    });
+    child.on("error", (err) => {
+      resolve({
+        file: filePath,
+        code: 1,
+        duration: Date.now() - startTime,
+        testFilesPass: 0,
+        testFilesFail: 1,
+        testsPass: 0,
+        testsFail: 0,
+        testsSkip: 0,
+        heapMb: null,
+        errors: [err.message],
+        rawOutput: err.toString()
+      });
+    });
+  });
+}
+function runMergeReports(blobsDir, opts) {
+  const {
+    cwd: cwd2,
+    vitestBin,
+    vitestConfig,
+    maxOldSpaceMb,
+    conditions = [],
+    nodeEnv = "development",
+    extraCoverageArgs = [],
+    quietOutput = false
+  } = opts;
+  return new Promise((resolve) => {
+    const configArgs = vitestConfig ? ["--config", vitestConfig] : [];
+    const mergeReporterArgs = quietOutput ? ["--color"] : [];
+    const args2 = [vitestBin, ...configArgs, "--mergeReports", blobsDir, "--run", "--coverage", ...mergeReporterArgs, ...extraCoverageArgs];
+    const env = buildEnv({ maxOldSpaceMb, conditions, nodeEnv });
+    const child = spawn(process.execPath, args2, {
+      cwd: cwd2,
+      stdio: quietOutput ? ["ignore", "pipe", "pipe"] : "inherit",
+      env
+    });
+    let stdout = "";
+    let stderr = "";
+    if (quietOutput) {
+      child.stdout?.on("data", (data) => stdout += data.toString());
+      child.stderr?.on("data", (data) => stderr += data.toString());
+    }
+    child.on("close", (code) => resolve({ exitCode: code ?? 1, output: `${stdout}
+${stderr}` }));
+    child.on("error", () => resolve({ exitCode: 1, output: "" }));
+  });
+}
+
+// src/core/progress.mjs
+import chalk2 from "chalk";
+
+// src/utils/duration.mjs
+function formatDuration(ms) {
+  const totalSeconds = Math.max(0, Math.floor(ms / 1e3));
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) {
+    return `${hours}:${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+  }
+  return `${minutes}:${seconds.toString().padStart(2, "0")}`;
+}
+
+// src/core/progress.mjs
+function createCoverageProgressTracker(total) {
+  const isTTY = Boolean(process.stdout.isTTY);
+  const spinnerFrames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  const barWidth = 26;
+  const startTime = Date.now();
+  let completed = 0;
+  let active = 0;
+  let failed = 0;
+  let frameIndex = 0;
+  let maxLineLength = 0;
+  let lastPlainLog = 0;
+  let spinnerTimer = null;
+  function buildLine() {
+    const percent = total === 0 ? 100 : completed / total * 100;
+    const elapsedMs = Date.now() - startTime;
+    const avgPerFile = completed > 0 ? elapsedMs / completed : 0;
+    const etaMs = avgPerFile * Math.max(total - completed, 0);
+    const filled = Math.round(percent / 100 * barWidth);
+    const spinner = spinnerFrames[frameIndex % spinnerFrames.length];
+    const bar = `[${"=".repeat(filled)}${"-".repeat(Math.max(0, barWidth - filled))}]`;
+    let _percent = percent.toFixed(1).padStart(5);
+    if (percent < 30) {
+      _percent = chalk2.red(_percent + "%");
+    } else if (percent < 70) {
+      _percent = chalk2.rgb(255, 136, 0)(_percent + "%");
+    } else if (percent > 99) {
+      _percent = chalk2.green(_percent + "%");
+    } else {
+      _percent = chalk2.yellow(_percent + "%");
+    }
+    if (isTTY) {
+      return `${chalk2.green(spinner)} ${chalk2.green(bar)} ${chalk2.bold(_percent)} ${completed}/${total} | active ${active} | failed ${failed} | ETA ${formatDuration(etaMs)} | elapsed ${formatDuration(elapsedMs)}`;
+    }
+    return `progress ${percent.toFixed(1)}% ${completed}/${total} | active ${active} | failed ${failed} | eta ${formatDuration(etaMs)} | elapsed ${formatDuration(elapsedMs)}`;
+  }
+  function render(forcePlainLog = false) {
+    const line = buildLine();
+    frameIndex++;
+    if (isTTY) {
+      const visibleLength = line.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "").length;
+      maxLineLength = Math.max(maxLineLength, visibleLength);
+      process.stdout.write(`\r${line.padEnd(maxLineLength, " ")}`);
+      return;
+    }
+    const now = Date.now();
+    if (forcePlainLog || now - lastPlainLog >= 2e3) {
+      console.log(line);
+      lastPlainLog = now;
+    }
+  }
+  function startSpinnerLoop() {
+    if (!isTTY || spinnerTimer) return;
+    spinnerTimer = setInterval(() => {
+      if (completed >= total && active === 0) return;
+      render();
+    }, 120);
+    spinnerTimer.unref?.();
+  }
+  function stopSpinnerLoop() {
+    if (!spinnerTimer) return;
+    clearInterval(spinnerTimer);
+    spinnerTimer = null;
+  }
+  render(true);
+  startSpinnerLoop();
+  return {
+    /**
+     * Call when a file run starts (increments active count).
+     * @returns {void}
+     */
+    onStart() {
+      active++;
+      render();
+    },
+    /**
+     * Call when a file run completes.
+     * @param {boolean} failedRun - Whether the run exited with a non-zero code.
+     * @returns {void}
+     */
+    onComplete(failedRun) {
+      active = Math.max(0, active - 1);
+      completed++;
+      if (failedRun) failed++;
+      render(true);
+    },
+    /**
+     * Stop the spinner and print the final progress line.
+     * @returns {void}
+     */
+    finish() {
+      stopSpinnerLoop();
+      render(true);
+      if (isTTY) process.stdout.write("\n");
+    }
+  };
+}
+var noopProgressTracker = {
+  /** @returns {void} */
+  onStart() {
+  },
+  /** @param {boolean} ___failedRun @returns {void} */
+  onComplete(___failedRun) {
+  },
+  /** @returns {void} */
+  finish() {
+  }
+};
+
+// src/core/report.mjs
+import fs3 from "fs/promises";
+import path3 from "path";
+import chalk3 from "chalk";
+function printQuietCoverageFailureDetails(failedResults) {
+  if (failedResults.length === 0) return;
+  console.log(`
+${"=".repeat(80)}`);
+  console.log(chalk3.bold.red("\u2716 FAILED TEST FILES (VERBOSE OUTPUT)"));
+  console.log("=".repeat(80));
+  for (const r of failedResults) {
+    console.log(`
+${chalk3.red("\u2716")} ${chalk3.red(r.file)} ${chalk3.dim(`(exit ${r.code})`)}`);
+    if (r.rawOutput?.trim()) {
+      console.log(r.rawOutput.trimEnd());
+    } else {
+      console.log(chalk3.dim("(no child output captured)"));
+    }
+  }
+  console.log(`
+${"=".repeat(80)}`);
+}
+function printMergeOutput(exitCode, output) {
+  if (exitCode === 0) {
+    const marker = "% Coverage report from v8";
+    const rawLines = output.split("\n");
+    const markerLineIndex = rawLines.findIndex((line) => stripAnsi(line).includes(marker));
+    if (markerLineIndex >= 0) {
+      let endLineIndex = rawLines.length;
+      for (let i = markerLineIndex + 1; i < rawLines.length; i++) {
+        const line = stripAnsi(rawLines[i]).trimStart();
+        if (line.startsWith("stderr |") || line.startsWith("stdout |")) {
+          endLineIndex = i;
+          break;
+        }
+      }
+      const coverageBody = rawLines.slice(markerLineIndex + 1, endLineIndex).join("\n").trimEnd();
+      if (coverageBody) {
+        const fullBlock = rawLines.slice(markerLineIndex, endLineIndex).join("\n").trimEnd();
+        console.log(`
+${fullBlock}
+`);
+      }
+    }
+  } else {
+    const trimmed = output.trimEnd();
+    if (trimmed) console.error(trimmed);
+  }
+}
+function computeSummaryFromFinal(finalData) {
+  const pct = (covered, total) => total === 0 ? 100 : parseFloat((covered / total * 100).toFixed(2));
+  const summary = {
+    total: {
+      statements: { total: 0, covered: 0, pct: 0 },
+      branches: { total: 0, covered: 0, pct: 0 },
+      functions: { total: 0, covered: 0, pct: 0 },
+      lines: { total: 0, covered: 0, pct: 0 }
+    }
+  };
+  for (const [filePath, data] of Object.entries(finalData)) {
+    const sKeys = Object.keys(data.s ?? {});
+    const stmtTotal = sKeys.length;
+    const stmtCovered = sKeys.filter((k) => data.s[k] > 0).length;
+    const fKeys = Object.keys(data.f ?? {});
+    const fnTotal = fKeys.length;
+    const fnCovered = fKeys.filter((k) => data.f[k] > 0).length;
+    let branchTotal = 0, branchCovered = 0;
+    for (const counts of Object.values(data.b ?? {})) {
+      branchTotal += counts.length;
+      branchCovered += counts.filter((c) => c > 0).length;
+    }
+    const coveredLines = /* @__PURE__ */ new Set();
+    const totalLines = /* @__PURE__ */ new Set();
+    for (const [sid, loc] of Object.entries(data.statementMap ?? {})) {
+      const line = loc?.start?.line;
+      if (line == null) continue;
+      totalLines.add(line);
+      if ((data.s ?? {})[sid] > 0) coveredLines.add(line);
+    }
+    const fileStats = {
+      statements: { total: stmtTotal, covered: stmtCovered, pct: pct(stmtCovered, stmtTotal) },
+      branches: { total: branchTotal, covered: branchCovered, pct: pct(branchCovered, branchTotal) },
+      functions: { total: fnTotal, covered: fnCovered, pct: pct(fnCovered, fnTotal) },
+      lines: { total: totalLines.size, covered: coveredLines.size, pct: pct(coveredLines.size, totalLines.size) }
+    };
+    summary[filePath] = fileStats;
+    for (const key of ["statements", "branches", "functions", "lines"]) {
+      summary.total[key].total += fileStats[key].total;
+      summary.total[key].covered += fileStats[key].covered;
+    }
+  }
+  for (const key of ["statements", "branches", "functions", "lines"]) {
+    const { total, covered } = summary.total[key];
+    summary.total[key].pct = pct(covered, total);
+  }
+  return summary;
+}
+async function printCoverageSummary(cwd2, extraCoverageArgs, worstCount = 10, options = {}) {
+  const { silent = false } = options;
+  let coverageDir = path3.resolve(cwd2, "coverage");
+  const repoDirArg = extraCoverageArgs.find((a) => a.startsWith("--coverage.reportsDirectory="));
+  if (repoDirArg) {
+    const raw = repoDirArg.split("=").slice(1).join("=");
+    coverageDir = path3.isAbsolute(raw) ? raw : path3.resolve(cwd2, raw);
+  }
+  let summary;
+  try {
+    const content = await fs3.readFile(path3.join(coverageDir, "coverage-summary.json"), "utf8");
+    summary = JSON.parse(content);
+  } catch {
+    try {
+      const content = await fs3.readFile(path3.join(coverageDir, "coverage-final.json"), "utf8");
+      summary = computeSummaryFromFinal(JSON.parse(content));
+    } catch {
+      if (!silent) console.log(chalk3.dim("  (no coverage JSON found \u2014 skipping summary)"));
+      return null;
+    }
+  }
+  const { total, ...fileSummaries } = summary;
+  if (worstCount > 0) {
+    const fileRows = Object.entries(fileSummaries).map(([absFile, data]) => ({
+      file: path3.relative(cwd2, absFile),
+      lines: data.lines?.pct ?? 0,
+      stmts: data.statements?.pct ?? 0,
+      fns: data.functions?.pct ?? 0,
+      branches: data.branches?.pct ?? 0
+    })).filter((r) => Math.min(r.lines, r.stmts, r.fns, r.branches) < 100).sort((a, b) => Math.min(a.lines, a.stmts, a.fns, a.branches) - Math.min(b.lines, b.stmts, b.fns, b.branches));
+    const rowsToShow = fileRows.slice(0, worstCount);
+    if (!silent) {
+      console.log("\n" + chalk3.bold("\u{1F4C9} WORST COVERAGE FILES (lowest metric)"));
+      console.log("-".repeat(80));
+      rowsToShow.forEach(({ file, lines, stmts, fns, branches }) => {
+        const worst = Math.min(lines, stmts, fns, branches);
+        const extras = chalk3.dim(
+          `lines ${lines.toFixed(0)}% | stmts ${stmts.toFixed(0)}% | fns ${fns.toFixed(0)}% | branches ${branches.toFixed(0)}%`
+        );
+        console.log(`  ${colourPct(chalk3, worst)}%  ${chalk3.dim(file)}  ${extras}`);
+      });
+      if (fileRows.length > worstCount) {
+        console.log(chalk3.dim(`  ... and ${fileRows.length - worstCount} more files`));
+      }
+    }
+    const tl2 = total.lines?.pct ?? 0;
+    const ts2 = total.statements?.pct ?? 0;
+    const tf2 = total.functions?.pct ?? 0;
+    const tb2 = total.branches?.pct ?? 0;
+    if (!silent) {
+      console.log(
+        `
+  ${chalk3.bold("Coverage")}  ${colourPct(chalk3, tl2)}% lines ${chalk3.dim("|")} ${colourPct(chalk3, ts2)}% statements ${chalk3.dim("|")} ${colourPct(chalk3, tf2)}% functions ${chalk3.dim("|")} ${colourPct(chalk3, tb2)}% branches`
+      );
+    }
+    return {
+      coverageDir,
+      total,
+      worstFiles: rowsToShow,
+      worstFilesShown: rowsToShow.length,
+      worstFilesTotal: fileRows.length,
+      summary
+    };
+  }
+  const tl = total.lines?.pct ?? 0;
+  const ts = total.statements?.pct ?? 0;
+  const tf = total.functions?.pct ?? 0;
+  const tb = total.branches?.pct ?? 0;
+  if (!silent) {
+    console.log(
+      `
+  ${chalk3.bold("Coverage")}  ${colourPct(chalk3, tl)}% lines ${chalk3.dim("|")} ${colourPct(chalk3, ts)}% statements ${chalk3.dim("|")} ${colourPct(chalk3, tf)}% functions ${chalk3.dim("|")} ${colourPct(chalk3, tb)}% branches`
+    );
+  }
+  return {
+    coverageDir,
+    total,
+    worstFiles: [],
+    worstFilesShown: 0,
+    worstFilesTotal: 0,
+    summary
+  };
+}
+
+// src/core/scratch.mjs
+import fs4 from "fs/promises";
+import fsSync from "fs";
+import path4 from "path";
+var DEFAULT_SCRATCH_DIR = "tmp/vitest-runner";
+var RUN_ROOT_NAME_PATTERN = /^(\d+)-\d+$/;
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code !== "ESRCH";
+  }
+}
+async function sweepStaleScratchRoots(cwd2, scratchDir) {
+  const base = path4.resolve(cwd2, scratchDir);
+  let entries;
+  try {
+    entries = await fs4.readdir(base, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const match = entry.name.match(RUN_ROOT_NAME_PATTERN);
+    if (!match) continue;
+    const pid = parseInt(match[1], 10);
+    if (isPidAlive(pid)) continue;
+    await fs4.rm(path4.join(base, entry.name), { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function createRunScratchRoot(cwd2, scratchDir) {
+  const base = path4.resolve(cwd2, scratchDir);
+  const root = path4.join(base, `${process.pid}-${Date.now()}`);
+  await fs4.mkdir(root, { recursive: true });
+  return root;
+}
+async function createFileScratchDir(runRoot, index) {
+  const dir = path4.join(runRoot, `worker-${index}`);
+  await fs4.mkdir(dir, { recursive: true });
+  return dir;
+}
+async function removeScratchRoot(root) {
+  await fs4.rm(root, { recursive: true, force: true }).catch(() => {
+  });
+}
+function removeScratchRootSync(root) {
+  try {
+    fsSync.rmSync(root, { recursive: true, force: true });
+  } catch {
+  }
+}
+
+// src/runner.mjs
+function getHeapForFile(filePath, globalMaxMb, overrides) {
+  const normalized = filePath.replace(/\\/g, "/");
+  let perFileMb;
+  for (const { pattern, heapMb } of overrides) {
+    if (normalized.includes(pattern)) {
+      perFileMb = heapMb;
+      break;
+    }
+  }
+  if (perFileMb === void 0 && globalMaxMb === void 0) return void 0;
+  if (perFileMb === void 0) return globalMaxMb;
+  if (globalMaxMb === void 0) return perFileMb;
+  return Math.max(perFileMb, globalMaxMb);
+}
+async function run(opts) {
+  const cwd2 = opts.cwd ?? process.cwd();
+  const scratchDirOpt = opts.scratchDir ?? DEFAULT_SCRATCH_DIR;
+  const keepTmp = opts.keepTmp ?? false;
+  await sweepStaleScratchRoots(cwd2, scratchDirOpt);
+  const scratchRoot = await createRunScratchRoot(cwd2, scratchDirOpt);
+  const onSignal = () => {
+    removeScratchRootSync(scratchRoot);
+    process.exitCode = 130;
+    process.exit();
+  };
+  if (!keepTmp) {
+    process.once("SIGINT", onSignal);
+    process.once("SIGTERM", onSignal);
+  }
+  try {
+    return await runImpl(opts, scratchRoot);
+  } finally {
+    process.removeListener("SIGINT", onSignal);
+    process.removeListener("SIGTERM", onSignal);
+    if (!keepTmp) await removeScratchRoot(scratchRoot);
+  }
+}
+async function runImpl(opts, scratchRoot) {
+  const {
+    cwd: cwd2 = process.cwd(),
+    testDir,
+    testPatterns = [],
+    testListFile,
+    testFilePattern,
+    vitestArgs: rawVitestArgs = [],
+    showErrorDetails = true,
+    coverageQuiet = false,
+    suppressFileOutput = false,
+    suppressPassingFiles = false,
+    topSummary = true,
+    json = false,
+    workers = parseInt(process.env.VITEST_WORKERS ?? "4", 10),
+    worstCoverageCount = 10,
+    blobsDir: blobsDirOpt,
+    mergeReports = true,
+    earlyRunPatterns = [],
+    perFileHeapOverrides = [],
+    conditions = [],
+    nodeEnv = "development",
+    /** @internal Inject pre-built results to bypass discovery and spawn (for testing final-report render paths). */
+    _testResultsOverride = null
+  } = opts;
+  let fileScratchIndex = 0;
+  const maxOldSpaceMb = opts.maxOldSpaceMb ?? (process.env.VITEST_HEAP_MB ? parseInt(process.env.VITEST_HEAP_MB, 10) : void 0);
+  const emitTextOutput = !json;
+  const vitestBin = resolveBin(cwd2, "vitest", "vitest");
+  const vitestConfig = await resolveVitestConfig(cwd2, opts.vitestConfig);
+  const spawnBase = { cwd: cwd2, vitestBin, vitestConfig, conditions, nodeEnv };
+  const vitestArgs2 = [...rawVitestArgs];
+  if (coverageQuiet && !vitestArgs2.some((a) => a === "--coverage" || a.startsWith("--coverage."))) {
+    vitestArgs2.unshift("--coverage");
+  }
+  const hasCoverage = vitestArgs2.some((a) => a === "--coverage" || a.startsWith("--coverage."));
+  if (hasCoverage) {
+    const blobsDir = path5.resolve(cwd2, blobsDirOpt ?? ".vitest-coverage-blobs");
+    const coverageTmpBase = path5.resolve(cwd2, ".vitest-coverage-tmp");
+    await Promise.all([fs5.rm(blobsDir, { recursive: true, force: true }), fs5.rm(coverageTmpBase, { recursive: true, force: true })]);
+    await Promise.all([fs5.mkdir(blobsDir, { recursive: true }), fs5.mkdir(coverageTmpBase, { recursive: true })]);
+    const allTestFiles = await discoverVitestFiles({ cwd: cwd2, testDir, testPatterns, testListFile, testFilePattern, earlyRunPatterns });
+    const filterConflicts2 = computeFilterConflicts(allTestFiles);
+    if (allTestFiles.length === 0) {
+      const noTestsMessage = testPatterns.length > 0 ? `\u274C No Vitest test files found matching: ${testPatterns.join(", ")}` : "\u274C No Vitest test files found";
+      if (emitTextOutput) console.log(noTestsMessage);
+      if (json) {
+        return {
+          exitCode: 1,
+          mode: "coverage",
+          message: noTestsMessage,
+          options: {
+            cwd: cwd2,
+            testDir,
+            testPatterns,
+            testListFile,
+            workers,
+            coverageQuiet,
+            suppressFileOutput,
+            suppressPassingFiles,
+            topSummary,
+            vitestArgs: vitestArgs2
+          }
+        };
+      }
+      return 1;
+    }
+    const extraCoverageArgs = vitestArgs2.filter((a) => a !== "--coverage" && a.startsWith("--coverage."));
+    const nonCoveragePassthrough = vitestArgs2.filter((a) => a !== "--coverage" && !a.startsWith("--coverage."));
+    const soloFiles2 = allTestFiles.filter((f) => earlyRunPatterns.some((p) => f.replace(/\\/g, "/").includes(p)));
+    const parallelFiles2 = allTestFiles.filter((f) => !earlyRunPatterns.some((p) => f.replace(/\\/g, "/").includes(p)));
+    const suppressPerFileCoverageOutput = coverageQuiet || suppressFileOutput || json;
+    const showCoverageProgress = coverageQuiet && !json;
+    if (!coverageQuiet && !suppressFileOutput && emitTextOutput) {
+      console.log(`
+\u{1F9EA} Running ${allTestFiles.length} test files for coverage (blob + merge mode)`);
+      console.log(`\u2699\uFE0F  Workers: ${workers} (${soloFiles2.length} solo first, then parallel)`);
+      if (maxOldSpaceMb) console.log(`\u{1F9E0} Heap limit: ${maxOldSpaceMb} MB`);
+      console.log("");
+    }
+    const progress = showCoverageProgress ? createCoverageProgressTracker(allTestFiles.length) : noopProgressTracker;
+    const coverageResults = [];
+    let blobIndex = 0;
+    const runCoverageFile = async (filePath) => {
+      const blobPath = path5.join(blobsDir, `run-${blobIndex}.blob`);
+      blobIndex++;
+      if (!suppressPerFileCoverageOutput && emitTextOutput) {
+        console.log(`
+${"=".repeat(80)}`);
+        console.log(`\u25B6\uFE0F  ${filePath}`);
+        console.log("=".repeat(80));
+      }
+      progress.onStart();
+      const tmpCoverageDir = path5.join(coverageTmpBase, `run-${blobIndex}`);
+      const blobArgs = [
+        ...nonCoveragePassthrough,
+        "--coverage",
+        `--coverage.reportsDirectory=${tmpCoverageDir}`,
+        "--reporter=default",
+        "--reporter=blob",
+        `--outputFile=${blobPath}`
+      ];
+      const scratchDir = await createFileScratchDir(scratchRoot, fileScratchIndex++);
+      const result = await runSingleFile(filePath, {
+        ...spawnBase,
+        maxOldSpaceMb: getHeapForFile(filePath, maxOldSpaceMb, perFileHeapOverrides),
+        vitestArgs: blobArgs,
+        streamOutput: !suppressPerFileCoverageOutput,
+        excludePaths: filterConflicts2.get(filePath),
+        extraEnv: { VITEST_RUNNER_TMP: scratchDir }
+      });
+      coverageResults.push(result);
+      progress.onComplete(result.code !== 0);
+      if (!suppressPerFileCoverageOutput && emitTextOutput) {
+        const durationSec = (result.duration / 1e3).toFixed(2);
+        if (result.code === 0) {
+          const heapInfo = result.heapMb ? ` | ${result.heapMb} MB heap` : "";
+          console.log(`
+\u2705 PASSED (${durationSec}s${heapInfo})
+`);
+        } else {
+          console.log(`
+\u274C FAILED (exit code ${result.code}, ${durationSec}s)
+`);
+        }
+      }
+    };
+    for (const filePath of soloFiles2) {
+      await runCoverageFile(filePath).catch((err) => {
+        if (emitTextOutput) console.error(`Error running ${filePath}:`, err);
+      });
+    }
+    let coverageFileIndex = 0;
+    const coverageActivePromises = /* @__PURE__ */ new Set();
+    while (coverageFileIndex < parallelFiles2.length || coverageActivePromises.size > 0) {
+      while (coverageFileIndex < parallelFiles2.length && coverageActivePromises.size < workers) {
+        const filePath = parallelFiles2[coverageFileIndex++];
+        const promise = runCoverageFile(filePath).catch((err) => {
+          if (emitTextOutput) console.error(`Error running ${filePath}:`, err);
+        }).finally(() => coverageActivePromises.delete(promise));
+        coverageActivePromises.add(promise);
+      }
+      if (coverageActivePromises.size > 0) await Promise.race(coverageActivePromises);
+    }
+    progress.finish();
+    const blobFiles = (await fs5.readdir(blobsDir).catch(() => [])).filter((f) => f.endsWith(".blob"));
+    if (blobFiles.length === 0) {
+      const message = "\u274C No coverage blobs were generated \u2014 coverage report cannot be produced";
+      if (emitTextOutput) console.error(message);
+      if (json) {
+        return {
+          exitCode: 1,
+          mode: "coverage",
+          message,
+          options: {
+            cwd: cwd2,
+            testDir,
+            testPatterns,
+            testListFile,
+            workers,
+            coverageQuiet,
+            suppressFileOutput,
+            suppressPassingFiles,
+            topSummary,
+            showErrorDetails,
+            worstCoverageCount,
+            vitestArgs: vitestArgs2
+          },
+          totals: {
+            testFiles: allTestFiles.length,
+            failedFiles: coverageResults.filter((r) => r.code !== 0).length,
+            passedFiles: coverageResults.filter((r) => r.code === 0).length
+          },
+          results: {
+            all: coverageResults,
+            failed: coverageResults.filter((r) => r.code !== 0)
+          },
+          merge: {
+            blobFiles: 0,
+            exitCode: 1,
+            output: ""
+          },
+          coverageSummary: null
+        };
+      }
+      return 1;
+    }
+    let mergeExitCode = 0;
+    let mergeOutput = "";
+    let coverageSummary = null;
+    if (mergeReports) {
+      if (!coverageQuiet && !suppressFileOutput && emitTextOutput) {
+        console.log(`
+${"=".repeat(80)}`);
+        console.log(`\u{1F4CA} Merging ${blobFiles.length} coverage blobs into final report...`);
+        console.log("=".repeat(80));
+      }
+      ({ exitCode: mergeExitCode, output: mergeOutput } = await runMergeReports(blobsDir, {
+        ...spawnBase,
+        maxOldSpaceMb,
+        extraCoverageArgs,
+        quietOutput: coverageQuiet || json
+      }));
+      if (coverageQuiet && emitTextOutput) {
+        printMergeOutput(mergeExitCode, mergeOutput);
+      }
+      coverageSummary = await printCoverageSummary(cwd2, extraCoverageArgs, worstCoverageCount, { silent: json });
+    }
+    await Promise.all([
+      ...mergeReports ? [fs5.rm(blobsDir, { recursive: true, force: true }).catch(() => {
+      })] : [],
+      fs5.rm(coverageTmpBase, { recursive: true, force: true }).catch(() => {
+      })
+    ]);
+    const coverageFailed = coverageResults.filter((r) => r.code !== 0);
+    if (coverageQuiet && emitTextOutput) printQuietCoverageFailureDetails(coverageFailed);
+    const exitCode2 = coverageFailed.length > 0 ? 1 : mergeExitCode;
+    if (json) {
+      const coverageWithHeap = coverageResults.filter((r) => r.heapMb !== null);
+      return {
+        exitCode: exitCode2,
+        mode: "coverage",
+        options: {
+          cwd: cwd2,
+          testDir,
+          testPatterns,
+          testListFile,
+          workers,
+          coverageQuiet,
+          suppressFileOutput,
+          suppressPassingFiles,
+          topSummary,
+          showErrorDetails,
+          worstCoverageCount,
+          vitestArgs: vitestArgs2
+        },
+        totals: {
+          testFiles: allTestFiles.length,
+          failedFiles: coverageFailed.length,
+          passedFiles: coverageResults.length - coverageFailed.length
+        },
+        results: {
+          all: coverageResults,
+          failed: coverageFailed
+        },
+        merge: {
+          blobFiles: blobFiles.length,
+          exitCode: mergeExitCode,
+          output: mergeOutput
+        },
+        coverageSummary,
+        ...topSummary ? {
+          topMemoryUsers: [...coverageWithHeap].sort((a, b) => b.heapMb - a.heapMb).slice(0, 10),
+          topDuration: [...coverageResults].sort((a, b) => b.duration - a.duration).slice(0, 10)
+        } : {}
+      };
+    }
+    return exitCode2;
+  }
+  const testFiles = await discoverVitestFiles({ cwd: cwd2, testDir, testPatterns, testListFile, testFilePattern, earlyRunPatterns });
+  const filterConflicts = computeFilterConflicts(testFiles);
+  if (testFiles.length === 0) {
+    const noTestsMessage = testPatterns.length > 0 ? `\u274C No Vitest test files found matching: ${testPatterns.join(", ")}` : "\u274C No Vitest test files found";
+    if (emitTextOutput) console.log(noTestsMessage);
+    if (json) {
+      return {
+        exitCode: 1,
+        mode: "standard",
+        message: noTestsMessage,
+        options: {
+          cwd: cwd2,
+          testDir,
+          testPatterns,
+          testListFile,
+          workers,
+          coverageQuiet,
+          suppressFileOutput,
+          suppressPassingFiles,
+          topSummary,
+          vitestArgs: vitestArgs2
+        }
+      };
+    }
+    return 1;
+  }
+  const soloFiles = testFiles.filter((f) => earlyRunPatterns.some((p) => f.replace(/\\/g, "/").includes(p)));
+  const parallelFiles = testFiles.filter((f) => !earlyRunPatterns.some((p) => f.replace(/\\/g, "/").includes(p)));
+  const scriptStartTime = Date.now();
+  const scriptStartTimeFormatted = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+  if (emitTextOutput && !suppressFileOutput && testPatterns.length > 0) {
+    console.log(`
+\u{1F9EA} Running ${testFiles.length} test files matching: ${testPatterns.join(", ")}`);
+  } else if (emitTextOutput && !suppressFileOutput) {
+    console.log(`
+\u{1F9EA} Running ${testFiles.length} test files (${soloFiles.length} solo first, then parallel)`);
+  }
+  if (emitTextOutput && !suppressFileOutput) {
+    console.log(`\u2699\uFE0F  Workers: ${workers}`);
+    if (maxOldSpaceMb) console.log(`\u{1F9E0} Heap limit: ${maxOldSpaceMb} MB`);
+    if (vitestArgs2.length > 0) console.log(`\u{1F527} Vitest args: ${vitestArgs2.join(" ")}`);
+    console.log("");
+  }
+  const results = [..._testResultsOverride ?? []];
+  const runTestFile = async (filePath) => {
+    if (!suppressFileOutput && emitTextOutput) {
+      console.log(`
+${"=".repeat(80)}`);
+      console.log(`\u25B6\uFE0F  ${filePath}`);
+      console.log("=".repeat(80));
+    }
+    const scratchDir = await createFileScratchDir(scratchRoot, fileScratchIndex++);
+    const result = await runSingleFile(filePath, {
+      ...spawnBase,
+      maxOldSpaceMb: getHeapForFile(filePath, maxOldSpaceMb, perFileHeapOverrides),
+      vitestArgs: vitestArgs2,
+      streamOutput: !suppressFileOutput && !json,
+      excludePaths: filterConflicts.get(filePath),
+      extraEnv: { VITEST_RUNNER_TMP: scratchDir }
+    });
+    if (!suppressFileOutput && emitTextOutput) {
+      const durationSec = (result.duration / 1e3).toFixed(2);
+      if (result.code === 0) {
+        const heapInfo = result.heapMb ? ` | ${result.heapMb} MB heap` : "";
+        console.log(`
+\u2705 PASSED (${durationSec}s${heapInfo})
+`);
+      } else {
+        console.log(`
+\u274C FAILED (exit code ${result.code}, ${durationSec}s)
+`);
+      }
+    }
+    return result;
+  };
+  if (!_testResultsOverride) {
+    for (const filePath of soloFiles) {
+      const result = await runTestFile(filePath).catch((err) => {
+        if (emitTextOutput) console.error(`Error running ${filePath}:`, err);
+        return null;
+      });
+      if (result) results.push(result);
+    }
+    let index = 0;
+    const activePromises = /* @__PURE__ */ new Set();
+    while (index < parallelFiles.length || activePromises.size > 0) {
+      while (index < parallelFiles.length && activePromises.size < workers) {
+        const filePath = parallelFiles[index++];
+        const promise = runTestFile(filePath).then((result) => results.push(result)).catch((err) => {
+          if (emitTextOutput) console.error(`Error running ${filePath}:`, err);
+        }).finally(() => activePromises.delete(promise));
+        activePromises.add(promise);
+      }
+      if (activePromises.size > 0) await Promise.race(activePromises);
+    }
+  }
+  const totalTestFilesPass = results.reduce((s, r) => s + r.testFilesPass, 0);
+  const totalTestFilesFail = results.reduce((s, r) => s + r.testFilesFail, 0);
+  const totalTestsPass = results.reduce((s, r) => s + r.testsPass, 0);
+  const totalTestsFail = results.reduce((s, r) => s + r.testsFail, 0);
+  const totalTestsSkip = results.reduce((s, r) => s + (r.testsSkip || 0), 0);
+  const totalDuration = results.reduce((s, r) => s + r.duration, 0);
+  const failedFiles = results.filter((r) => r.code !== 0);
+  const passedFiles = results.filter((r) => r.code === 0);
+  const exitCode = failedFiles.length > 0 ? 1 : 0;
+  const scriptMemory = process.memoryUsage();
+  const scriptHeapMb = Math.round(scriptMemory.heapUsed / 1024 / 1024);
+  const scriptRssMb = Math.round(scriptMemory.rss / 1024 / 1024);
+  const withHeap = results.filter((r) => r.heapMb !== null);
+  const actualDurationSec = ((Date.now() - scriptStartTime) / 1e3).toFixed(2);
+  const testsDurationSec = (totalDuration / 1e3).toFixed(2);
+  if (json) {
+    return {
+      exitCode,
+      mode: "standard",
+      options: {
+        cwd: cwd2,
+        testDir,
+        testPatterns,
+        testListFile,
+        workers,
+        coverageQuiet,
+        suppressFileOutput,
+        suppressPassingFiles,
+        topSummary,
+        showErrorDetails,
+        worstCoverageCount,
+        vitestArgs: vitestArgs2
+      },
+      totals: {
+        testFilesPass: totalTestFilesPass,
+        testFilesFail: totalTestFilesFail,
+        testsPass: totalTestsPass,
+        testsFail: totalTestsFail,
+        testsSkip: totalTestsSkip,
+        totalTests: totalTestsPass + totalTestsFail + totalTestsSkip
+      },
+      timing: {
+        startAt: scriptStartTimeFormatted,
+        wallClockSeconds: Number(actualDurationSec),
+        testsSeconds: Number(testsDurationSec)
+      },
+      heap: {
+        scriptHeapMb,
+        scriptRssMb,
+        maxHeapMb: withHeap.length > 0 ? Math.max(...withHeap.map((r) => r.heapMb)) : null,
+        avgHeapMb: withHeap.length > 0 ? Number((withHeap.reduce((sum, r) => sum + r.heapMb, 0) / withHeap.length).toFixed(0)) : null
+      },
+      results: {
+        all: results,
+        passed: passedFiles,
+        failed: failedFiles
+      },
+      ...topSummary ? {
+        topMemoryUsers: [...withHeap].sort((a, b) => b.heapMb - a.heapMb).slice(0, 10),
+        topDuration: [...results].sort((a, b) => b.duration - a.duration).slice(0, 10)
+      } : {}
+    };
+  }
+  console.log("\n" + "=".repeat(80));
+  if (topSummary && withHeap.length > 0) {
+    console.log("\n" + chalk4.bold("\u{1F9E0} TOP MEMORY USERS"));
+    console.log("-".repeat(80));
+    [...withHeap].sort((a, b) => b.heapMb - a.heapMb).slice(0, 10).forEach((r) => {
+      console.log(`  ${String(r.heapMb).padStart(4)} MB  ${chalk4.dim(r.file)}`);
+    });
+  }
+  if (topSummary && results.length > 0) {
+    console.log("\n" + chalk4.bold("\u23F1\uFE0F  TOP DURATION"));
+    console.log("-".repeat(80));
+    [...results].sort((a, b) => b.duration - a.duration).slice(0, 10).forEach((r) => {
+      const sec = (r.duration / 1e3).toFixed(2);
+      console.log(`  ${(sec + "s").padStart(8)}  ${chalk4.dim(r.file)}`);
+    });
+  }
+  if (passedFiles.length > 0 && !suppressPassingFiles) {
+    console.log("\n" + "=".repeat(80));
+    console.log(chalk4.bold.green("\u2713 PASSED TEST FILES"));
+    console.log("=".repeat(80));
+    passedFiles.forEach((r) => {
+      const durationSec = (r.duration / 1e3).toFixed(2);
+      const statsInfo = [...r.heapMb ? [`${r.heapMb} MB`] : [], `${durationSec}s`];
+      const testInfo = r.testsPass > 0 ? ` - ${r.testsPass} tests` : "";
+      console.log(chalk4.green(`\u2713 ${r.file}${testInfo}`) + chalk4.dim(` (${statsInfo.join(", ")})`));
+    });
+  }
+  console.log("\n" + chalk4.bold("=".repeat(80)));
+  if (failedFiles.length > 0) {
+    console.log(`
+\u274C ${failedFiles.length} test file(s) failed`);
+    console.log(chalk4.bold.red("\nFailed Test Files:"));
+    failedFiles.forEach((r) => {
+      const durationSec = (r.duration / 1e3).toFixed(2);
+      const testCounts = [
+        ...r.testsFail > 0 ? [chalk4.red(`${r.testsFail} failed`)] : [],
+        ...r.testsPass > 0 ? [chalk4.green(`${r.testsPass} passed`)] : [],
+        ...r.testsSkip > 0 ? [chalk4.yellow(`${r.testsSkip} skipped`)] : []
+      ];
+      const statsInfo = [...r.heapMb ? [`${r.heapMb} MB`] : [], `${durationSec}s`];
+      const countStr = testCounts.length > 0 ? ` (${testCounts.join(", ")})` : "";
+      console.log(`  ${chalk4.red("\u2716")} ${r.file}${countStr}` + chalk4.dim(` [${statsInfo.join(", ")}]`));
+      if (showErrorDetails && r.errors.length > 0) {
+        const deduped = deduplicateErrors(r.errors).split("\n").map((line) => line.trim() ? `    ${line}` : "").join("\n");
+        console.log(deduped);
+        console.log("");
+      }
+    });
+    console.log("");
+  }
+  console.log(chalk4.bold("=".repeat(80)));
+  if (totalTestFilesFail > 0 && totalTestFilesPass > 0) {
+    console.log(
+      ` ${chalk4.bold("Test Files")}  ${chalk4.red(`${totalTestFilesFail} failed`)} ${chalk4.dim("|")} ${chalk4.green(`${totalTestFilesPass} passed`)} ${chalk4.dim(`(${totalTestFilesPass + totalTestFilesFail})`)}`
+    );
+  } else if (totalTestFilesFail > 0) {
+    console.log(` ${chalk4.bold("Test Files")}  ${chalk4.red(`${totalTestFilesFail} failed`)} ${chalk4.dim(`(${totalTestFilesFail})`)}`);
+  } else {
+    console.log(` ${chalk4.bold("Test Files")}  ${chalk4.green(`${totalTestFilesPass} passed`)} ${chalk4.dim(`(${totalTestFilesPass})`)}`);
+  }
+  const totalTests = totalTestsPass + totalTestsFail + totalTestsSkip;
+  const testsParts = [
+    ...totalTestsFail > 0 ? [chalk4.red(`${totalTestsFail} failed`)] : [],
+    ...totalTestsPass > 0 ? [chalk4.green(`${totalTestsPass} passed`)] : [],
+    ...totalTestsSkip > 0 ? [chalk4.yellow(`${totalTestsSkip} skipped`)] : []
+  ];
+  console.log(`      ${chalk4.bold("Tests")}  ${testsParts.join(` ${chalk4.dim("|")} `)} ${chalk4.dim(`(${totalTests})`)}`);
+  console.log(`   ${chalk4.bold("Start at")}  ${scriptStartTimeFormatted}`);
+  console.log(`   ${chalk4.bold("Duration")}  ${actualDurationSec}s ${chalk4.dim(`(tests ${testsDurationSec}s)`)}`);
+  if (withHeap.length > 0) {
+    const maxHeap = Math.max(...withHeap.map((r) => r.heapMb));
+    const avgHeap = (withHeap.reduce((s, r) => s + r.heapMb, 0) / withHeap.length).toFixed(0);
+    console.log(`       ${chalk4.bold("Heap")}  max ${maxHeap} MB | avg ${avgHeap} MB | script ${scriptHeapMb} MB (RSS ${scriptRssMb} MB)`);
+  } else {
+    console.log(`       ${chalk4.bold("Heap")}  script ${scriptHeapMb} MB (RSS ${scriptRssMb} MB)`);
+  }
+  if (failedFiles.length > 0) return 1;
+  console.log(`
+\u2705 All ${passedFiles.length} test files passed
+`);
+  return 0;
+}
+
+// src/bin/vitest-runner.mjs
+var args = parseArguments(process.argv.slice(2));
+if (args.help) {
+  showHelp();
+  process.exit(0);
+}
 if ((args.coverageQuiet || args.logFile) && !args.json) {
-	const cwd = process.cwd();
-	const resolvedLogFile = args.logFile
-		? path.isAbsolute(args.logFile)
-			? args.logFile
-			: path.resolve(cwd, args.logFile)
-		: path.join(cwd, "coverage", "coverage-run.log");
-	mkdirSync(path.dirname(resolvedLogFile), { recursive: true });
-	const logStream = createWriteStream(resolvedLogFile, { flags: "a" });
-	const origStdoutWrite = process.stdout.write.bind(process.stdout);
-	const origStderrWrite = process.stderr.write.bind(process.stderr);
-
-	/**
-	 * Determine if a chunk is a progress-bar write that should be excluded from the log.
-	 * TTY mode uses `\r` to overwrite in place; non-TTY prints "progress N.N% ..." lines.
-	 * @param {Buffer|string} chunk
-	 * @returns {boolean}
-	 */
-	function isProgressChunk(chunk) {
-		const str = chunk.toString();
-		return str.startsWith("\r") || /^progress \d+\.\d+%/.test(str);
-	}
-
-	process.stdout.write = (chunk, enc, cb) => {
-		if (!isProgressChunk(chunk)) logStream.write(stripAnsi(chunk.toString()));
-		return origStdoutWrite(chunk, enc, cb);
-	};
-
-	process.stderr.write = (chunk, enc, cb) => {
-		if (!isProgressChunk(chunk)) logStream.write(stripAnsi(chunk.toString()));
-		return origStderrWrite(chunk, enc, cb);
-	};
-
-	process.on("exit", () => logStream.end());
-}
-
-const cwd = process.cwd();
-
-const vitestArgs = [...args.vitestPassthroughArgs];
+  let isProgressChunk = function(chunk) {
+    const str = chunk.toString();
+    return str.startsWith("\r") || /^progress \d+\.\d+%/.test(str);
+  };
+  const cwd2 = process.cwd();
+  const resolvedLogFile = args.logFile ? path6.isAbsolute(args.logFile) ? args.logFile : path6.resolve(cwd2, args.logFile) : path6.join(cwd2, "coverage", "coverage-run.log");
+  mkdirSync(path6.dirname(resolvedLogFile), { recursive: true });
+  const logStream = createWriteStream(resolvedLogFile, { flags: "a" });
+  const origStdoutWrite = process.stdout.write.bind(process.stdout);
+  const origStderrWrite = process.stderr.write.bind(process.stderr);
+  process.stdout.write = (chunk, enc, cb) => {
+    if (!isProgressChunk(chunk)) logStream.write(stripAnsi(chunk.toString()));
+    return origStdoutWrite(chunk, enc, cb);
+  };
+  process.stderr.write = (chunk, enc, cb) => {
+    if (!isProgressChunk(chunk)) logStream.write(stripAnsi(chunk.toString()));
+    return origStderrWrite(chunk, enc, cb);
+  };
+  process.on("exit", () => logStream.end());
+}
+var cwd = process.cwd();
+var vitestArgs = [...args.vitestPassthroughArgs];
 if (args.coverageQuiet && !vitestArgs.some((a) => a === "--coverage" || a.startsWith("--coverage."))) {
-	vitestArgs.unshift("--coverage");
+  vitestArgs.unshift("--coverage");
 }
-
 try {
-	const runResult = await run({
-		cwd,
-		testPatterns: args.testPatterns,
-		testListFile: args.testListFile,
-		testFilePattern: args.testFilePattern,
-		vitestArgs,
-		showErrorDetails: args.showErrorDetails,
-		coverageQuiet: args.coverageQuiet,
-		suppressFileOutput: args.suppressFileOutput,
-		suppressPassingFiles: args.suppressPassingFiles,
-		topSummary: args.topSummary,
-		json: args.json,
-		...(args.workers !== undefined && { workers: args.workers }),
-		...(args.soloPatterns.length > 0 && { earlyRunPatterns: args.soloPatterns })
-	});
-
-	if (args.json) {
-		process.stdout.write(`${JSON.stringify(runResult, null, 2)}\n`);
-		process.exit(typeof runResult === "object" && runResult !== null && "exitCode" in runResult ? runResult.exitCode : 1);
-	}
-
-	process.exit(typeof runResult === "number" ? runResult : 1);
+  const runResult = await run({
+    cwd,
+    testPatterns: args.testPatterns,
+    testListFile: args.testListFile,
+    testFilePattern: args.testFilePattern,
+    vitestArgs,
+    showErrorDetails: args.showErrorDetails,
+    coverageQuiet: args.coverageQuiet,
+    suppressFileOutput: args.suppressFileOutput,
+    suppressPassingFiles: args.suppressPassingFiles,
+    topSummary: args.topSummary,
+    json: args.json,
+    mergeReports: args.mergeReports,
+    keepTmp: args.keepTmp,
+    ...args.blobsDir !== void 0 && { blobsDir: args.blobsDir },
+    ...args.workers !== void 0 && { workers: args.workers },
+    ...args.soloPatterns.length > 0 && { earlyRunPatterns: args.soloPatterns },
+    ...args.scratchDir !== void 0 && { scratchDir: args.scratchDir }
+  });
+  if (args.json) {
+    process.stdout.write(`${JSON.stringify(runResult, null, 2)}
+`);
+    process.exit(typeof runResult === "object" && runResult !== null && "exitCode" in runResult ? runResult.exitCode : 1);
+  }
+  process.exit(typeof runResult === "number" ? runResult : 1);
 } catch (err) {
-	console.error("Fatal error:", err);
-	process.exit(1);
+  console.error("Fatal error:", err);
+  process.exit(1);
 }
+//# sourceMappingURL=vitest-runner.mjs.map