@hughescr/stryker-bun-runner 1.2.0 → 1.2.2

package/dist/index.js

@@ -4603,6 +4603,10 @@ var Scope;
   Scope2["Transient"] = "transient";
   Scope2["Singleton"] = "singleton";
 })(Scope || (Scope = {}));
+// src/bun-test-runner.ts
+import * as fsPromises2 from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path4 from "node:path";
 // node_modules/@stryker-mutator/api/dist/src/test-runner/test-status.js
 var TestStatus;
 (function(TestStatus2) {
@@ -4625,267 +4629,9 @@ var DryRunStatus;
   DryRunStatus2["Error"] = "error";
   DryRunStatus2["Timeout"] = "timeout";
 })(DryRunStatus || (DryRunStatus = {}));
-// src/process-runner.ts
-import { spawn } from "node:child_process";
-async function runBunTests(options) {
-  const args = ["test"];
-  if (options.inspectWaitPort) {
-    args.push(`--inspect=${options.inspectWaitPort}`);
-  }
-  if (options.bunfigPath) {
-    args.push(`--config=${options.bunfigPath}`);
-  }
-  if (options.preloadScript) {
-    args.push("--preload", options.preloadScript);
-  }
-  if (options.testNamePattern) {
-    args.push("--test-name-pattern", options.testNamePattern);
-  }
-  if (options.bail) {
-    args.push("--bail");
-  }
-  if (options.sequentialMode) {
-    args.push("--concurrency=1");
-  }
-  if (options.bunArgs && options.bunArgs.length > 0) {
-    args.push(...options.bunArgs);
-  }
-  if (options.testFiles && options.testFiles.length > 0) {
-    args.push(...options.testFiles);
-  }
-  const env = {
-    ...process.env,
-    ...options.env
-  };
-  if (options.activeMutant) {
-    env.__STRYKER_ACTIVE_MUTANT__ = options.activeMutant;
-  }
-  if (options.coverageFile) {
-    env.__STRYKER_COVERAGE_FILE__ = options.coverageFile;
-  }
-  if (options.syncPort) {
-    env.__STRYKER_SYNC_PORT__ = String(options.syncPort);
-  }
-  return new Promise((resolve) => {
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    let timedOut = false;
-    let processKilled = false;
-    const childProcess = spawn(options.bunPath, args, {
-      env,
-      stdio: ["ignore", "pipe", "pipe"],
-      cwd: process.cwd()
-    });
-    const timeoutHandle = setTimeout(() => {
-      timedOut = true;
-      processKilled = true;
-      childProcess.kill("SIGKILL");
-    }, options.timeout);
-    if (childProcess.stdout) {
-      childProcess.stdout.on("data", (data) => {
-        stdoutChunks.push(data);
-      });
-    }
-    let inspectorUrlExtracted = false;
-    if (childProcess.stderr) {
-      childProcess.stderr.on("data", (data) => {
-        stderrChunks.push(data);
-        if (options.inspectWaitPort && !inspectorUrlExtracted && options.onInspectorReady) {
-          const text = Buffer.concat(stderrChunks).toString();
-          const match = /Listening:[\t\v\f\r \xa0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]*\n\s*(ws:\/\/\S+)/.exec(text);
-          if (match) {
-            inspectorUrlExtracted = true;
-            options.onInspectorReady(match[1]);
-          }
-        }
-      });
-    }
-    childProcess.on("close", (code) => {
-      clearTimeout(timeoutHandle);
-      resolve({
-        stdout: Buffer.concat(stdoutChunks).toString(),
-        stderr: Buffer.concat(stderrChunks).toString(),
-        exitCode: processKilled ? null : code,
-        timedOut
-      });
-    });
-    childProcess.on("error", (error) => {
-      clearTimeout(timeoutHandle);
-      const stderrOutput = Buffer.concat(stderrChunks).toString();
-      resolve({
-        stdout: Buffer.concat(stdoutChunks).toString(),
-        stderr: `${stderrOutput}
-Process error: ${error.message}`,
-        exitCode: null,
-        timedOut
-      });
-    });
-  });
-}
-
-// src/parsers/console-parser.ts
-function parseFilePath(line) {
-  const fileMatch = /^([\w./-]+\.(?:test|spec)\.(?:ts|tsx|js|jsx|mts|mjs)):$/.exec(line);
-  return fileMatch ? fileMatch[1] : null;
-}
-function parseTestLine(line, currentFile) {
-  const passMatch = /^✓ +(\S.*?) \[([0-9.]+)ms\]$/.exec(line);
-  if (passMatch) {
-    const testName = passMatch[1].trim();
-    const fullName = currentFile ? `${currentFile} > ${testName}` : testName;
-    return {
-      test: {
-        name: fullName,
-        file: currentFile,
-        status: "passed",
-        duration: parseFloat(passMatch[2])
-      }
-    };
-  }
-  const failMatch = /^✗ +(\S.*?)(?: \[([0-9.]+)ms\])?$/.exec(line);
-  if (failMatch) {
-    const testName = failMatch[1].trim();
-    const fullName = currentFile ? `${currentFile} > ${testName}` : testName;
-    return {
-      test: {
-        name: fullName,
-        file: currentFile,
-        status: "failed",
-        duration: failMatch[2] ? parseFloat(failMatch[2]) : undefined
-      },
-      startedCollectingError: true
-    };
-  }
-  const bailFailMatch = /^\(fail\) +(\S.*?)(?: \[([0-9.]+)ms\])?$/.exec(line);
-  if (bailFailMatch) {
-    const testName = bailFailMatch[1].trim();
-    const fullName = currentFile ? `${currentFile} > ${testName}` : testName;
-    return {
-      test: {
-        name: fullName,
-        file: currentFile,
-        status: "failed",
-        duration: bailFailMatch[2] ? parseFloat(bailFailMatch[2]) : undefined
-      },
-      startedCollectingError: true
-    };
-  }
-  const skipMatch = /^⏭ +(\S.*)$/.exec(line);
-  if (skipMatch) {
-    const testName = skipMatch[1].trim();
-    const fullName = currentFile ? `${currentFile} > ${testName}` : testName;
-    return {
-      test: {
-        name: fullName,
-        file: currentFile,
-        status: "skipped"
-      }
-    };
-  }
-  return {};
-}
-function finalizeErrorMessage(currentTest, errorLines) {
-  if (currentTest && errorLines.length > 0) {
-    currentTest.failureMessage = errorLines.join(`
-`).trim();
-  }
-}
-function shouldCollectErrorLine(line) {
-  if (!line.trim()) {
-    return false;
-  }
-  return !/^\s*\d+\s+(?:pass|fail|skip)/.exec(line);
-}
-function updateCounters(test, counters, parseResult) {
-  if (test.status === "passed") {
-    counters.passed++;
-    return false;
-  } else if (test.status === "failed") {
-    counters.failed++;
-    return parseResult.startedCollectingError ?? false;
-  } else {
-    counters.skipped++;
-    return false;
-  }
-}
-function parseSummaryLines(output) {
-  const counts = { passed: 0, failed: 0, skipped: 0 };
-  const passSummary = /\s(\d+)\s+pass\b/.exec(output);
-  const failSummary = /\s(\d+)\s+fail\b/.exec(output);
-  const skipSummary = /\s(\d+)\s+skip\b/.exec(output);
-  const bailSummary = /Bailed out after (\d+) failures?/.exec(output);
-  if (passSummary) {
-    counts.passed = parseInt(passSummary[1], 10);
-  }
-  if (failSummary) {
-    counts.failed = parseInt(failSummary[1], 10);
-  }
-  if (skipSummary) {
-    counts.skipped = parseInt(skipSummary[1], 10);
-  }
-  if (bailSummary) {
-    counts.failed = Math.max(counts.failed, parseInt(bailSummary[1], 10));
-  }
-  const ranTestsSummary = /Ran\s+(\d+)\s+tests?/.exec(output);
-  if (ranTestsSummary) {
-    const totalFromRan = parseInt(ranTestsSummary[1], 10);
-    const totalParsed = counts.passed + counts.failed + counts.skipped;
-    if (totalParsed !== totalFromRan && counts.passed === 0 && counts.failed === 0) {
-      counts.passed = totalFromRan;
-    }
-  }
-  return counts;
-}
-function parseBunTestOutput(stdout, stderr) {
-  const tests = [];
-  const counters = { passed: 0, failed: 0, skipped: 0 };
-  const output = stdout + `
-` + stderr;
-  const lines = output.split(`
-`);
-  let currentTest = null;
-  let collectingError = false;
-  let errorLines = [];
-  let currentFile;
-  for (const line of lines) {
-    const filePath = parseFilePath(line);
-    if (filePath) {
-      currentFile = filePath;
-      continue;
-    }
-    const parseResult = parseTestLine(line, currentFile);
-    if (parseResult.test) {
-      if (currentTest && collectingError) {
-        finalizeErrorMessage(currentTest, errorLines);
-        errorLines = [];
-      }
-      currentTest = parseResult.test;
-      tests.push(currentTest);
-      collectingError = updateCounters(currentTest, counters, parseResult);
-      continue;
-    }
-    if (collectingError && currentTest && shouldCollectErrorLine(line)) {
-      errorLines.push(line);
-    }
-  }
-  if (currentTest && collectingError) {
-    finalizeErrorMessage(currentTest, errorLines);
-  }
-  const summaryCounts = parseSummaryLines(output);
-  counters.passed = Math.max(counters.passed, summaryCounts.passed);
-  counters.failed = Math.max(counters.failed, summaryCounts.failed);
-  counters.skipped = Math.max(counters.skipped, summaryCounts.skipped);
-  return {
-    tests,
-    totalTests: counters.passed + counters.failed + counters.skipped,
-    passed: counters.passed,
-    failed: counters.failed,
-    skipped: counters.skipped
-  };
-}
 // src/coverage/preload-generator.ts
 import { mkdir, unlink, readFile, writeFile } from "node:fs/promises";
-import { join, dirname as dirname2, resolve as resolve3 } from "node:path";
+import path from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // node_modules/tinyglobby/dist/index.mjs
@@ -5722,7 +5468,7 @@ async function resolveEagerModulesFromGlobs(mutateGlobs, cwd = process.cwd()) {
     if (p.startsWith("!")) {
       negativePatterns.push(p.slice(1));
     } else {
-      positivePatterns.push(p.replace(/:[0-9].*$/, ""));
+      positivePatterns.push(p.replace(/:\d.*$/, ""));
     }
   }
   if (positivePatterns.length === 0) {
@@ -5737,21 +5483,21 @@ async function resolveEagerModulesFromGlobs(mutateGlobs, cwd = process.cwd()) {
   const sourceFileRe = /\.(?:tsx?|[cm]?js)$/;
   const dtsRe = /\.d\.[cm]?ts$/;
   const filtered = paths.filter((p) => sourceFileRe.test(p) && !dtsRe.test(p));
-  const resolved = filtered.map((p) => resolve3(p));
-  resolved.sort();
+  const resolved = filtered.map((p) => path.resolve(p));
+  resolved.sort((a, b) => a.localeCompare(b));
   return resolved;
 }
 async function generatePreloadScript(options) {
-  const preloadPath = join(options.tempDir, `stryker-coverage-preload-${process.pid}.ts`);
+  const preloadPath = path.join(options.tempDir, `stryker-coverage-preload-${process.pid}.ts`);
   await mkdir(options.tempDir, { recursive: true });
-  const __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+  const __dirname2 = path.dirname(fileURLToPath2(import.meta.url));
   const isBundled = __dirname2.endsWith("dist") || __dirname2.includes("dist/");
-  const templatePath = isBundled ? join(__dirname2, "templates/coverage-preload.ts") : join(__dirname2, "../templates/coverage-preload.ts");
-  const template = await readFile(templatePath, "utf-8");
-  const preloadLogicPath = isBundled ? join(__dirname2, "coverage/preload-logic.js") : join(__dirname2, "preload-logic.ts");
+  const templatePath = isBundled ? path.join(__dirname2, "templates/coverage-preload.ts") : path.join(__dirname2, "../templates/coverage-preload.ts");
+  const template = await readFile(templatePath, "utf8");
+  const preloadLogicPath = isBundled ? path.join(__dirname2, "coverage/preload-logic.js") : path.join(__dirname2, "preload-logic.ts");
   const eagerModules = options.eagerModules ?? [];
   const content = template.replace("__PRELOAD_LOGIC_PATH__", preloadLogicPath).replace("__EAGER_MODULES__", JSON.stringify(eagerModules));
-  await writeFile(preloadPath, content, "utf-8");
+  await writeFile(preloadPath, content, "utf8");
   return preloadPath;
 }
 async function cleanupPreloadScript(preloadPath) {
@@ -5759,6 +5505,7 @@ async function cleanupPreloadScript(preloadPath) {
     await unlink(preloadPath);
   } catch {}
 }
+
 // src/coverage/collector.ts
 import { readFile as readFile2, unlink as unlink2 } from "node:fs/promises";
 function arrayToCoverageData(mutantIds) {
@@ -5776,26 +5523,26 @@ function mergeCoverageData(dataList) {
   const staticSet = new Set;
   for (const data of dataList) {
     for (const [testId, mutantIds] of Object.entries(data.perTest)) {
-      if (!merged.perTest[testId]) {
-        merged.perTest[testId] = mutantIds;
-      } else {
+      if (testId in merged.perTest) {
         const existingSet = new Set(merged.perTest[testId]);
         for (const mutantId of mutantIds) {
           existingSet.add(mutantId);
         }
-        merged.perTest[testId] = Array.from(existingSet);
+        merged.perTest[testId] = [...existingSet];
+      } else {
+        merged.perTest[testId] = mutantIds;
       }
     }
     for (const mutantId of data.static) {
       staticSet.add(mutantId);
     }
   }
-  merged.static = Array.from(staticSet);
+  merged.static = [...staticSet];
   return merged;
 }
 async function collectCoverage(coverageFile, logger) {
   try {
-    const content = await readFile2(coverageFile, "utf-8");
+    const content = await readFile2(coverageFile, "utf8");
     const trimmed = content.trim();
     const lines = trimmed.split(`
 `).filter((line) => line.length > 0);
@@ -5831,6 +5578,7 @@ async function cleanupCoverageFile(coverageFile) {
     await unlink2(coverageFile);
   } catch {}
 }
+
 // src/utils/test-name.ts
 function normalizeTestFilePath(url) {
   if (!url) {
@@ -5843,7 +5591,10 @@ function normalizeTestFilePath(url) {
   return url;
 }
 function normalizeTestName(testName) {
-  return testName.replace(/[\x00-\x1F\x7F]/g, "_").trim();
+  return testName.replaceAll(/\p{Cc}/gu, "_").trim();
+}
+function buildProjectFileTestName(filePrefix, fullName) {
+  return normalizeTestName(`${filePrefix} > ${fullName}`);
 }
 function buildUniqueTestName(fullName, url) {
   const normalizedPath = normalizeTestFilePath(url);
@@ -5856,46 +5607,36 @@ function buildUniqueTestName(fullName, url) {
 // src/coverage/coverage-mapper.ts
 function mapCoverageToInspectorIds(rawCoverage, executionOrder, testHierarchy, logger) {
   if (!rawCoverage?.perTest || Object.keys(rawCoverage.perTest).length === 0) {
-    return rawCoverage;
+    return { coverage: rawCoverage ?? undefined, inspectorIdToProjectFile: new Map };
   }
   const firstKey = Object.keys(rawCoverage.perTest)[0];
-  if (/@@test-\d+$/.exec(firstKey)) {
+  if (/@@test-\d+$/.test(firstKey)) {
     return mapFilePrefixedCounterKeys(rawCoverage, executionOrder, testHierarchy, logger);
   }
-  if (/^test-\d+$/.exec(firstKey)) {
-    return mapLegacyCounterKeys(rawCoverage, executionOrder, testHierarchy, logger);
+  if (/^test-\d+$/.test(firstKey)) {
+    return { coverage: mapLegacyCounterKeys(rawCoverage, executionOrder, testHierarchy, logger), inspectorIdToProjectFile: new Map };
   }
-  return rawCoverage;
+  return { coverage: rawCoverage, inspectorIdToProjectFile: new Map };
 }
-function stabilizeCoverage(coverage) {
-  const perTestEntries = Object.entries(coverage.perTest ?? {});
-  if (perTestEntries.length === 0) {
-    return coverage;
-  }
-  const perTestAppearances = new Map;
+function countPerTestAppearances(perTestEntries) {
+  const appearances = new Map;
   for (const [, counts] of perTestEntries) {
     for (const mutantId of Object.keys(counts)) {
-      perTestAppearances.set(mutantId, (perTestAppearances.get(mutantId) ?? 0) + 1);
+      appearances.set(mutantId, (appearances.get(mutantId) ?? 0) + 1);
     }
   }
-  const promoteToStatic = new Set(Object.keys(coverage.static ?? {}));
+  return appearances;
+}
+function buildPromoteToStaticSet(existingStaticKeys, perTestAppearances) {
+  const promoteToStatic = new Set(existingStaticKeys);
   for (const [mutantId, count] of perTestAppearances) {
     if (count > 1) {
       promoteToStatic.add(mutantId);
     }
   }
-  const existingStatic = new Set(Object.keys(coverage.static ?? {}));
-  const hasNewPromotions = [...promoteToStatic].some((id) => !existingStatic.has(id));
-  const hasPerTestContamination = perTestEntries.some(([, counts]) => Object.keys(counts).some((id) => promoteToStatic.has(id)));
-  if (!hasNewPromotions && !hasPerTestContamination) {
-    return coverage;
-  }
-  const newStatic = { ...coverage.static ?? {} };
-  for (const mutantId of promoteToStatic) {
-    if (!(mutantId in newStatic)) {
-      newStatic[mutantId] = 1;
-    }
-  }
+  return promoteToStatic;
+}
+function buildFilteredPerTest(perTestEntries, promoteToStatic) {
   const newPerTest = {};
   for (const [testId, counts] of perTestEntries) {
     const filteredCounts = {};
@@ -5908,76 +5649,168 @@ function stabilizeCoverage(coverage) {
       newPerTest[testId] = filteredCounts;
     }
   }
-  return { static: newStatic, perTest: newPerTest };
+  return newPerTest;
 }
-function mapFilePrefixedCounterKeys(rawCoverage, executionOrder, testHierarchy, logger) {
-  const fileToInspectorIds = new Map;
-  for (const inspectorId of executionOrder) {
-    const testInfo = testHierarchy.get(inspectorId);
-    if (!testInfo) {
-      continue;
-    }
-    const relFile = normalizeTestFilePath(testInfo.url) ?? "";
-    const bucket = fileToInspectorIds.get(relFile);
-    if (bucket) {
-      bucket.push(inspectorId);
-    } else {
-      fileToInspectorIds.set(relFile, [inspectorId]);
+function stabilizeCoverage(coverage) {
+  const perTestEntries = Object.entries(coverage.perTest);
+  if (perTestEntries.length === 0) {
+    return coverage;
+  }
+  const existingStaticKeys = Object.keys(coverage.static);
+  const perTestAppearances = countPerTestAppearances(perTestEntries);
+  const promoteToStatic = buildPromoteToStaticSet(existingStaticKeys, perTestAppearances);
+  const existingStatic = new Set(existingStaticKeys);
+  const hasNewPromotions = [...promoteToStatic].some((id) => !existingStatic.has(id));
+  const hasPerTestContamination = perTestEntries.some(([, counts]) => Object.keys(counts).some((id) => promoteToStatic.has(id)));
+  if (!hasNewPromotions && !hasPerTestContamination) {
+    return coverage;
+  }
+  const newStatic = { ...coverage.static };
+  for (const mutantId of promoteToStatic) {
+    if (!(mutantId in newStatic)) {
+      newStatic[mutantId] = 1;
     }
   }
-  const counterIds = Object.keys(rawCoverage.perTest).sort((a, b) => {
-    const nA = parseInt(a.split("@@test-")[1] ?? "0", 10);
-    const nB = parseInt(b.split("@@test-")[1] ?? "0", 10);
-    return nA - nB;
+  const newPerTest = buildFilteredPerTest(perTestEntries, promoteToStatic);
+  return { static: newStatic, perTest: newPerTest };
+}
+function pairKeysWithInspectorIds(globallyOrderedPerTestKeys, executionOrder, testHierarchy, logger) {
+  const nonSkipped = executionOrder.filter((id) => {
+    const status = testHierarchy.get(id)?.status;
+    return status !== "skip" && status !== "todo";
   });
-  const testNames = [];
-  const resolvedInfos = [];
-  for (const key of counterIds) {
+  if (globallyOrderedPerTestKeys.length < nonSkipped.length) {
+    logger?.warn("Coverage/execution count mismatch: %s coverage entries vs %s non-skipped executed tests. " + "Performing partial mapping for %s tests.", globallyOrderedPerTestKeys.length, nonSkipped.length, Math.min(globallyOrderedPerTestKeys.length, nonSkipped.length));
+  }
+  const pairCount = Math.min(globallyOrderedPerTestKeys.length, nonSkipped.length);
+  const pairs = [];
+  for (let i = 0;i < pairCount; i++) {
+    const key = globallyOrderedPerTestKeys[i];
+    const sepIdx = key.indexOf("@@");
+    const filePrefix = sepIdx === -1 ? key : key.slice(0, sepIdx);
+    pairs.push({ filePrefix, inspectorId: nonSkipped[i] });
+  }
+  return pairs;
+}
+function resolveCounterKeys(counterIds, fileToInspectorIds, testHierarchy, logger) {
+  return counterIds.map((key) => {
     const sepIdx = key.indexOf("@@");
     const filePrefix = key.slice(0, sepIdx);
     const counterStr = key.slice(sepIdx + 2 + "test-".length);
-    const n = parseInt(counterStr, 10);
+    const n = Number.parseInt(counterStr, 10);
     const fileIds = fileToInspectorIds.get(filePrefix);
-    const inspectorId = fileIds?.[n - 1];
-    const testInfo = inspectorId !== undefined ? testHierarchy.get(inspectorId) : undefined;
+    const clampedIdx = fileIds ? Math.min(n - 1, fileIds.length - 1) : undefined;
+    const inspectorId = clampedIdx === undefined ? undefined : fileIds?.[clampedIdx];
+    const testInfo = inspectorId === undefined ? undefined : testHierarchy.get(inspectorId);
     if (testInfo) {
-      testNames.push(buildUniqueTestName(testInfo.fullName, testInfo.url));
-      resolvedInfos.push(testInfo);
-    } else {
-      logger?.warn('Coverage key %s: no inspector test found for file "%s" at position %s ' + "(file has %s tests in execution order). Skipping this test in coverage mapping.", key, filePrefix, n, fileToInspectorIds.get(filePrefix)?.length ?? 0);
-      testNames.push(`unknown-${key}`);
-      resolvedInfos.push(null);
+      const testName = buildProjectFileTestName(filePrefix, testInfo.fullName);
+      return { name: testName, testInfo, inspectorId };
     }
+    logger?.warn('Coverage key %s: no inspector test found for file "%s" at position %s ' + "(file has %s tests in execution order). Skipping this test in coverage mapping.", key, filePrefix, n, fileToInspectorIds.get(filePrefix)?.length ?? 0);
+    return { name: `unknown-${key}`, testInfo: null, inspectorId: undefined };
+  });
+}
+function buildNameInspectorIds(resolved) {
+  const nameInspectorIds = new Map;
+  for (const { name, inspectorId, testInfo } of resolved) {
+    if (!testInfo) {
+      continue;
+    }
+    let ids = nameInspectorIds.get(name);
+    if (!ids) {
+      ids = new Set;
+      nameInspectorIds.set(name, ids);
+    }
+    ids.add(inspectorId);
   }
-  const nameCounts = new Map;
-  for (const name of testNames) {
-    nameCounts.set(name, (nameCounts.get(name) ?? 0) + 1);
-  }
+  return nameInspectorIds;
+}
+function resolveEachTestName(baseName, inspectorId, nameInspectorIds, nameIndexes) {
+  const distinctIds = nameInspectorIds.get(baseName);
+  if ((distinctIds?.size ?? 1) <= 1) {
+    return baseName;
+  }
+  const key_ = `${inspectorId}/${baseName}`;
+  const existingIndex = nameIndexes.get(key_);
+  if (existingIndex === undefined) {
+    const nextIndex = nameIndexes.get(baseName) ?? 0;
+    nameIndexes.set(key_, nextIndex);
+    nameIndexes.set(baseName, nextIndex + 1);
+    return `${baseName} [${nextIndex}]`;
+  }
+  return `${baseName} [${existingIndex}]`;
+}
+function buildRemappedPerTest(counterIds, resolved, rawPerTest) {
+  const nameInspectorIds = buildNameInspectorIds(resolved);
   const remappedPerTest = {};
   const nameIndexes = new Map;
-  for (let i = 0;i < counterIds.length; i++) {
-    const key = counterIds[i];
-    const testInfo = resolvedInfos[i];
+  for (const [i, key] of counterIds.entries()) {
+    const { name: baseName, testInfo, inspectorId } = resolved[i];
     if (!testInfo) {
       continue;
     }
-    const baseName = testNames[i];
-    const count = nameCounts.get(baseName) ?? 1;
-    let finalName = baseName;
-    if (count > 1) {
-      const index = nameIndexes.get(baseName) ?? 0;
-      finalName = `${baseName} [${index}]`;
-      nameIndexes.set(baseName, index + 1);
+    const finalName = resolveEachTestName(baseName, inspectorId, nameInspectorIds, nameIndexes);
+    const incoming = rawPerTest[key];
+    const existing = remappedPerTest[finalName];
+    if (existing) {
+      for (const [mutantId, count_] of Object.entries(incoming)) {
+        existing[mutantId] = (existing[mutantId] ?? 0) + count_;
+      }
+    } else {
+      remappedPerTest[finalName] = { ...incoming };
     }
-    remappedPerTest[finalName] = rawCoverage.perTest[key];
   }
-  return stabilizeCoverage({
+  return remappedPerTest;
+}
+function warnInteriorGapIfPresent(pairs, testHierarchy, logger) {
+  const warnedFiles = new Set;
+  for (const { filePrefix, inspectorId } of pairs) {
+    const testUrl = testHierarchy.get(inspectorId)?.url;
+    if (!testUrl) {
+      continue;
+    }
+    const inspectorFile = normalizeTestFilePath(testUrl);
+    if (!inspectorFile || testUrl.includes("node_modules")) {
+      continue;
+    }
+    if (filePrefix !== inspectorFile && !warnedFiles.has(filePrefix)) {
+      warnedFiles.add(filePrefix);
+      logger?.warn('Interior coverage gap detected for "%s": coverage key paired with inspector test from "%s". ' + "Some tests may have been aborted mid-run (e.g. beforeAll failure). Coverage mapping may be inaccurate.", filePrefix, inspectorFile);
+    }
+  }
+}
+function mapFilePrefixedCounterKeys(rawCoverage, executionOrder, testHierarchy, logger) {
+  const globallyOrderedKeys = Object.keys(rawCoverage.perTest);
+  const pairs = pairKeysWithInspectorIds(globallyOrderedKeys, executionOrder, testHierarchy, logger);
+  const fileToInspectorIds = new Map;
+  const inspectorIdToProjectFile = new Map;
+  for (const { filePrefix, inspectorId } of pairs) {
+    const bucket = fileToInspectorIds.get(filePrefix);
+    if (bucket) {
+      bucket.push(inspectorId);
+    } else {
+      fileToInspectorIds.set(filePrefix, [inspectorId]);
+    }
+    inspectorIdToProjectFile.set(inspectorId, filePrefix);
+  }
+  if (globallyOrderedKeys.length === pairs.length) {
+    warnInteriorGapIfPresent(pairs, testHierarchy, logger);
+  }
+  const counterIds = globallyOrderedKeys.toSorted((a, b) => {
+    const nA = Number.parseInt(a.split("@@test-")[1] ?? "0", 10);
+    const nB = Number.parseInt(b.split("@@test-")[1] ?? "0", 10);
+    return nA - nB;
+  });
+  const resolved = resolveCounterKeys(counterIds, fileToInspectorIds, testHierarchy, logger);
+  const remappedPerTest = buildRemappedPerTest(counterIds, resolved, rawCoverage.perTest);
+  const coverage = stabilizeCoverage({
     static: rawCoverage.static,
     perTest: remappedPerTest
   });
+  return { coverage, inspectorIdToProjectFile };
 }
 function mapLegacyCounterKeys(rawCoverage, executionOrder, testHierarchy, logger) {
-  const counterIds = Object.keys(rawCoverage.perTest).sort((a, b) => parseInt(a.split("-")[1], 10) - parseInt(b.split("-")[1], 10));
+  const counterIds = Object.keys(rawCoverage.perTest).toSorted((a, b) => Number.parseInt(a.split("-")[1] ?? "0", 10) - Number.parseInt(b.split("-")[1] ?? "0", 10));
   if (counterIds.length !== executionOrder.length) {
     logger?.warn("Coverage/execution count mismatch: %s coverage entries vs %s executed tests. " + "Performing partial mapping for %s tests.", counterIds.length, executionOrder.length, Math.min(counterIds.length, executionOrder.length));
   }
@@ -6021,10 +5854,6 @@ function mapLegacyCounterKeys(rawCoverage, executionOrder, testHierarchy, logger
     perTest: remappedPerTest
   });
 }
-// src/bun-test-runner.ts
-import { tmpdir } from "node:os";
-import { join as join3 } from "node:path";
-import * as fsPromises2 from "node:fs/promises";
 
 // node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -6086,7 +5915,7 @@ class InspectorClient {
     if (this.ws) {
       throw new Error("Already connected");
     }
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve3, reject) => {
       const timeoutTimer = setTimeout(() => {
         if (this.ws) {
           this.ws.close();
@@ -6098,7 +5927,7 @@ class InspectorClient {
       this.ws = ws;
       ws.addEventListener("open", () => {
         clearTimeout(timeoutTimer);
-        resolve4();
+        resolve3();
       });
       ws.addEventListener("error", () => {
         clearTimeout(timeoutTimer);
@@ -6120,12 +5949,12 @@ class InspectorClient {
     }
     const id = ++this.messageId;
     const message = { id, method, params };
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve3, reject) => {
       const timer = setTimeout(() => {
         this.pendingRequests.delete(id);
         reject(new InspectorTimeoutError(`Request timeout after ${this.state.requestTimeout}ms: ${method}`));
       }, this.state.requestTimeout);
-      this.pendingRequests.set(id, { resolve: resolve4, reject, timer });
+      this.pendingRequests.set(id, { resolve: resolve3, reject, timer });
       try {
         this.ws.send(JSON.stringify(message));
       } catch (error) {
@@ -6141,7 +5970,7 @@ class InspectorClient {
     }
     this.isClosing = true;
     const error = new InspectorConnectionError("Connection closed");
-    for (const pending of Array.from(this.pendingRequests.values())) {
+    for (const pending of this.pendingRequests.values()) {
       clearTimeout(pending.timer);
       pending.reject(error);
     }
@@ -6152,7 +5981,7 @@ class InspectorClient {
     this.ws = null;
   }
   getTests() {
-    return Array.from(this.testHierarchy.values());
+    return [...this.testHierarchy.values()];
   }
   getExecutionOrder() {
     return [...this.executionOrder];
@@ -6240,7 +6069,7 @@ class InspectorClient {
     let currentId = parentId;
     while (currentId !== undefined) {
       if (visited.has(currentId)) {
-        this.handleError(new Error(`Circular reference detected in test hierarchy: ${Array.from(visited).join(" -> ")} -> ${currentId}`));
+        this.handleError(new Error(`Circular reference detected in test hierarchy: ${[...visited].join(" -> ")} -> ${currentId}`));
         break;
       }
       visited.add(currentId);
@@ -6258,7 +6087,7 @@ class InspectorClient {
       return;
     }
     const error = new InspectorConnectionError("Connection closed unexpectedly");
-    for (const pending of Array.from(this.pendingRequests.values())) {
+    for (const pending of this.pendingRequests.values()) {
       clearTimeout(pending.timer);
       pending.reject(error);
     }
@@ -6271,10 +6100,281 @@ class InspectorClient {
     }
   }
 }
+// src/parsers/console-parser.ts
+function parseFilePath(line) {
+  const fileMatch = /^([\w./-]+\.(?:test|spec)\.(?:ts|tsx|js|jsx|mts|mjs)):$/.exec(line);
+  return fileMatch ? fileMatch[1] : null;
+}
+function buildTestName(testName, currentFile) {
+  return currentFile ? `${currentFile} > ${testName}` : testName;
+}
+function parseTestLine(line, currentFile) {
+  const passMatch = /^✓ +(\S.*?) \[([0-9.]+)ms\]$/.exec(line);
+  if (passMatch) {
+    return {
+      test: {
+        name: buildTestName(passMatch[1].trim(), currentFile),
+        file: currentFile,
+        status: "passed",
+        duration: Number.parseFloat(passMatch[2])
+      }
+    };
+  }
+  const failMatch = /^✗ +(\S.*?)(?: \[([0-9.]+)ms\])?$/.exec(line);
+  if (failMatch) {
+    return {
+      test: {
+        name: buildTestName(failMatch[1].trim(), currentFile),
+        file: currentFile,
+        status: "failed",
+        duration: failMatch[2] ? Number.parseFloat(failMatch[2]) : undefined
+      },
+      startedCollectingError: true
+    };
+  }
+  const bailFailMatch = /^\(fail\) +(\S.*?)(?: \[([0-9.]+)ms\])?$/.exec(line);
+  if (bailFailMatch) {
+    return {
+      test: {
+        name: buildTestName(bailFailMatch[1].trim(), currentFile),
+        file: currentFile,
+        status: "failed",
+        duration: bailFailMatch[2] ? Number.parseFloat(bailFailMatch[2]) : undefined
+      },
+      startedCollectingError: true
+    };
+  }
+  const skipMatch = /^⏭ +(\S.*)$/.exec(line);
+  if (skipMatch) {
+    return {
+      test: {
+        name: buildTestName(skipMatch[1].trim(), currentFile),
+        file: currentFile,
+        status: "skipped"
+      }
+    };
+  }
+  return {};
+}
+function finalizeErrorMessage(currentTest, errorLines) {
+  if (currentTest && errorLines.length > 0) {
+    currentTest.failureMessage = errorLines.join(`
+`).trim();
+  }
+}
+function shouldCollectErrorLine(line) {
+  if (!line.trim()) {
+    return false;
+  }
+  return !/^\s*\d+\s+(?:pass|fail|skip)/.test(line);
+}
+function updateCounters(test, counters, parseResult) {
+  if (test.status === "passed") {
+    counters.passed++;
+    return false;
+  } else if (test.status === "failed") {
+    counters.failed++;
+    return parseResult.startedCollectingError ?? false;
+  } else {
+    counters.skipped++;
+    return false;
+  }
+}
+function parseSummaryLines(output) {
+  const counts = { passed: 0, failed: 0, skipped: 0 };
+  const passSummary = /\s(\d+)\s+pass\b/.exec(output);
+  const failSummary = /\s(\d+)\s+fail\b/.exec(output);
+  const skipSummary = /\s(\d+)\s+skip\b/.exec(output);
+  const bailSummary = /Bailed out after (\d+) failures?/.exec(output);
+  if (passSummary) {
+    counts.passed = Number.parseInt(passSummary[1], 10);
+  }
+  if (failSummary) {
+    counts.failed = Number.parseInt(failSummary[1], 10);
+  }
+  if (skipSummary) {
+    counts.skipped = Number.parseInt(skipSummary[1], 10);
+  }
+  if (bailSummary) {
+    counts.failed = Math.max(counts.failed, Number.parseInt(bailSummary[1], 10));
+  }
+  const ranTestsSummary = /Ran\s+(\d+)\s+tests?/.exec(output);
+  if (ranTestsSummary) {
+    const totalFromRan = Number.parseInt(ranTestsSummary[1], 10);
+    const totalParsed = counts.passed + counts.failed + counts.skipped;
+    if (totalParsed !== totalFromRan && counts.passed === 0 && counts.failed === 0) {
+      counts.passed = totalFromRan;
+    }
+  }
+  return counts;
+}
+function parseBunTestOutput(stdout, stderr) {
+  const tests = [];
+  const counters = { passed: 0, failed: 0, skipped: 0 };
+  const output = `${stdout}
+${stderr}`;
+  const lines = output.split(`
+`);
+  let currentTest = null;
+  let collectingError = false;
+  let errorLines = [];
+  let currentFile;
+  for (const line of lines) {
+    const filePath = parseFilePath(line);
+    if (filePath) {
+      currentFile = filePath;
+      continue;
+    }
+    const parseResult = parseTestLine(line, currentFile);
+    if (parseResult.test) {
+      if (currentTest && collectingError) {
+        finalizeErrorMessage(currentTest, errorLines);
+        errorLines = [];
+      }
+      currentTest = parseResult.test;
+      tests.push(currentTest);
+      collectingError = updateCounters(currentTest, counters, parseResult);
+      continue;
+    }
+    if (collectingError && currentTest && shouldCollectErrorLine(line)) {
+      errorLines.push(line);
+    }
+  }
+  if (currentTest && collectingError) {
+    finalizeErrorMessage(currentTest, errorLines);
+  }
+  const summaryCounts = parseSummaryLines(output);
+  counters.passed = Math.max(counters.passed, summaryCounts.passed);
+  counters.failed = Math.max(counters.failed, summaryCounts.failed);
+  counters.skipped = Math.max(counters.skipped, summaryCounts.skipped);
+  return {
+    tests,
+    totalTests: counters.passed + counters.failed + counters.skipped,
+    passed: counters.passed,
+    failed: counters.failed,
+    skipped: counters.skipped
+  };
+}
+
+// src/process-runner.ts
+import { spawn } from "node:child_process";
+async function runBunTests(options) {
+  const args = ["test"];
+  if (options.inspectWaitPort) {
+    args.push(`--inspect=${options.inspectWaitPort}`);
+  }
+  if (options.bunfigPath) {
+    args.push(`--config=${options.bunfigPath}`);
+  }
+  if (options.preloadScript) {
+    args.push("--preload", options.preloadScript);
+  }
+  if (options.testNamePattern) {
+    args.push("--test-name-pattern", options.testNamePattern);
+  }
+  if (options.bail) {
+    args.push("--bail");
+  }
+  if (options.sequentialMode) {
+    args.push("--concurrency=1");
+  }
+  if (options.bunArgs && options.bunArgs.length > 0) {
+    args.push(...options.bunArgs);
+  }
+  if (options.testFiles && options.testFiles.length > 0) {
+    args.push(...options.testFiles);
+  }
+  const env = {
+    ...process.env,
+    ...options.env
+  };
+  if (options.activeMutant) {
+    env.__STRYKER_ACTIVE_MUTANT__ = options.activeMutant;
+  }
+  if (options.coverageFile) {
+    env.__STRYKER_COVERAGE_FILE__ = options.coverageFile;
+  }
+  if (options.syncPort) {
+    env.__STRYKER_SYNC_PORT__ = String(options.syncPort);
+  }
+  return new Promise((resolve3) => {
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let timedOut = false;
+    let processKilled = false;
+    if (options.signal?.aborted) {
+      resolve3({ stdout: "", stderr: "", exitCode: null, timedOut: true });
+      return;
+    }
+    const spawnOpts = {
+      env,
+      stdio: ["ignore", "pipe", "pipe"],
+      cwd: process.cwd()
+    };
+    const childProcess = spawn(options.bunPath, args, spawnOpts);
+    const timeoutHandle = setTimeout(() => {
+      timedOut = true;
+      processKilled = true;
+      childProcess.kill("SIGKILL");
+    }, options.timeout);
+    if (options.signal) {
+      const onAbort = () => {
+        clearTimeout(timeoutHandle);
+        processKilled = true;
+        timedOut = true;
+        childProcess.kill("SIGTERM");
+        setTimeout(() => {
+          childProcess.kill("SIGKILL");
+        }, 500);
+      };
+      options.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    if (childProcess.stdout) {
+      childProcess.stdout.on("data", (data) => {
+        stdoutChunks.push(data);
+      });
+    }
+    let inspectorUrlExtracted = false;
+    if (childProcess.stderr) {
+      childProcess.stderr.on("data", (data) => {
+        stderrChunks.push(data);
+        if (options.inspectWaitPort && !inspectorUrlExtracted && options.onInspectorReady) {
+          const text = Buffer.concat(stderrChunks).toString();
+          const match = /Listening:[\t\v\f\r \u00A0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]*\n\s*(ws:\/\/\S+)/.exec(text);
+          if (match) {
+            inspectorUrlExtracted = true;
+            options.onInspectorReady(match[1]);
+          }
+        }
+      });
+    }
+    childProcess.on("close", (code) => {
+      clearTimeout(timeoutHandle);
+      resolve3({
+        stdout: Buffer.concat(stdoutChunks).toString(),
+        stderr: Buffer.concat(stderrChunks).toString(),
+        exitCode: processKilled ? null : code,
+        timedOut
+      });
+    });
+    childProcess.on("error", (error) => {
+      clearTimeout(timeoutHandle);
+      const stderrOutput = Buffer.concat(stderrChunks).toString();
+      resolve3({
+        stdout: Buffer.concat(stdoutChunks).toString(),
+        stderr: `${stderrOutput}
+Process error: ${error.message}`,
+        exitCode: null,
+        timedOut
+      });
+    });
+  });
+}
+
 // src/utils/port.ts
-import { createServer } from "net";
+import { createServer } from "node:net";
 async function getAvailablePort() {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve3, reject) => {
     const server = createServer();
     server.on("error", (err) => {
       reject(new Error(`Failed to get available port: ${err.message}`));
@@ -6292,7 +6392,7 @@ async function getAvailablePort() {
           reject(new Error(`Failed to close server: ${err.message}`));
           return;
         }
-        resolve4(port);
+        resolve3(port);
       });
     });
   });
@@ -6303,6 +6403,7 @@ class SyncServer {
   httpServer = null;
   wss = null;
   clients = new Set;
+  readyLatched = false;
   port;
   createHttpServer;
   WebSocketServerClass;
@@ -6314,15 +6415,15 @@ class SyncServer {
     this.webSocketOpenState = options.webSocketOpenState ?? import_websocket.default.OPEN;
   }
   async start() {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve3, reject) => {
       try {
         this.httpServer = this.createHttpServer((req, res) => {
-          if (req.url !== "/sync") {
-            res.writeHead(404);
-            res.end("Not found");
-          } else {
+          if (req.url === "/sync") {
             res.writeHead(400);
             res.end("WebSocket upgrade failed");
+          } else {
+            res.writeHead(404);
+            res.end("Not found");
           }
         });
         this.wss = new this.WebSocketServerClass({
@@ -6331,6 +6432,11 @@ class SyncServer {
         });
         this.wss.on("connection", (ws) => {
           this.clients.add(ws);
+          if (this.readyLatched && ws.readyState === this.webSocketOpenState) {
+            try {
+              ws.send("ready");
+            } catch {}
+          }
           ws.on("close", () => {
             this.clients.delete(ws);
           });
@@ -6338,7 +6444,7 @@ class SyncServer {
         });
         this.httpServer.on("error", reject);
         this.httpServer.listen(this.port, () => {
-          resolve4();
+          resolve3();
         });
       } catch (error) {
         reject(error instanceof Error ? error : new Error(String(error)));
@@ -6346,6 +6452,7 @@ class SyncServer {
     });
   }
   signalReady() {
+    this.readyLatched = true;
     for (const client of this.clients) {
       try {
         if (client.readyState === this.webSocketOpenState) {
@@ -6355,6 +6462,7 @@ class SyncServer {
     }
   }
   async close() {
+    this.readyLatched = false;
     for (const client of this.clients) {
       try {
         client.close();
@@ -6362,13 +6470,15 @@ class SyncServer {
     }
     this.clients.clear();
     if (this.wss) {
-      this.wss.close();
+      await new Promise((resolve3) => {
+        this.wss.close(() => resolve3());
+      });
       this.wss = null;
     }
     if (this.httpServer) {
-      await new Promise((resolve4) => {
+      await new Promise((resolve3) => {
         this.httpServer.close(() => {
-          resolve4();
+          resolve3();
         });
       });
       this.httpServer = null;
@@ -6380,7 +6490,7 @@ class SyncServer {
 }
 // src/utils/bunfig-sanitizer.ts
 import { readFile as readFile3, unlink as unlink3, writeFile as writeFile2, mkdir as mkdir2 } from "node:fs/promises";
-import path from "node:path";
+import path2 from "node:path";
 
 // node_modules/smol-toml/dist/error.js
 /*!
@@ -7490,7 +7600,7 @@ function absolutizePath(value, projectCwd) {
   if (typeof value !== "string") {
     return value;
   }
-  return path.isAbsolute(value) ? value : path.resolve(projectCwd, value);
+  return path2.isAbsolute(value) ? value : path2.resolve(projectCwd, value);
 }
 function absolutizePathValue(value, projectCwd) {
   if (Array.isArray(value)) {
@@ -7501,7 +7611,7 @@ function absolutizePathValue(value, projectCwd) {
 async function generateSanitizedBunfig(projectCwd, tmpDir) {
   await mkdir2(tmpDir, { recursive: true });
   let rawConfig = {};
-  const bunfigPath = path.join(projectCwd, "bunfig.toml");
+  const bunfigPath = path2.join(projectCwd, "bunfig.toml");
   try {
     const content = await readFile3(bunfigPath, "utf8");
     rawConfig = parse(content);
@@ -7525,7 +7635,7 @@ async function generateSanitizedBunfig(projectCwd, tmpDir) {
   sanitizedTest.onlyFailures = false;
   sanitized.test = sanitizedTest;
   const serialized = stringify(sanitized);
-  const outPath = path.join(tmpDir, `stryker-bun-runner-bunfig-${process.pid}-${Date.now()}.toml`);
+  const outPath = path2.join(tmpDir, `stryker-bun-runner-bunfig-${process.pid}-${Date.now()}.toml`);
   await writeFile2(outPath, serialized, "utf8");
   return outPath;
 }
@@ -7545,20 +7655,14 @@ function buildTestNamePattern(testFilter) {
   }
   const fileExtRe = /\.(?:test|spec)\.(?:[jt]sx?|m[jt]s)$/;
   const dedupSuffixRe = / \[\d+\]$/;
-  const hierarchySepRe = / > /g;
-  const metaRe = /[.*+?^${}()|[\]\\\/]/g;
+  const metaRe = /[.*+?^${}()|[\]\\/]/g;
   const alternatives = new Set;
   for (const id of testFilter) {
     const firstSepIdx = id.indexOf(" > ");
-    let name;
-    if (firstSepIdx !== -1 && fileExtRe.test(id.slice(0, firstSepIdx))) {
-      name = id.slice(firstSepIdx + 3);
-    } else {
-      name = id;
-    }
+    let name = firstSepIdx !== -1 && fileExtRe.test(id.slice(0, firstSepIdx)) ? id.slice(firstSepIdx + 3) : id;
     name = name.replace(dedupSuffixRe, "");
-    name = name.replace(hierarchySepRe, " ");
-    name = name.replace(metaRe, "\\$&");
+    name = name.replaceAll(" > ", " ");
+    name = name.replaceAll(metaRe, String.raw`\$&`);
     if (name.length > 0) {
       alternatives.add(name);
     }
@@ -7566,27 +7670,85 @@ function buildTestNamePattern(testFilter) {
   if (alternatives.size === 0) {
     return;
   }
-  return `^(?:${Array.from(alternatives).join("|")})$`;
+  return `^(?:${[...alternatives].join("|")})$`;
 }
 // src/utils/test-file-discovery.ts
-import { join as join2, relative as relative2 } from "node:path";
 import * as fsPromises from "node:fs/promises";
+import path3 from "node:path";
+var testFileRe = /\.(?:test|spec)\.(?:[jt]sx?|m[jt]s)$/;
+var excludedDirs = new Set(["node_modules", ".stryker-tmp", "dist", "build", ".git"]);
+function hasExcludedAncestor(absolutePath) {
+  return absolutePath.split("/").some((seg) => excludedDirs.has(seg));
+}
+async function tryRealpath(p) {
+  try {
+    return await fsPromises.realpath(p);
+  } catch {
+    return;
+  }
+}
+async function tryStat(p) {
+  try {
+    return await fsPromises.stat(p);
+  } catch {
+    return;
+  }
+}
+async function handleSymlinkDir(fullPath, entryName, ctx) {
+  if (excludedDirs.has(entryName)) {
+    return;
+  }
+  const resolvedTarget = await tryRealpath(fullPath);
+  if (!resolvedTarget) {
+    return;
+  }
+  if (hasExcludedAncestor(resolvedTarget)) {
+    ctx.logger?.debug("discoverTestFiles: symlink %s resolves to excluded path %s; skipping", fullPath, resolvedTarget);
+  } else {
+    await ctx.walk(fullPath);
+  }
+}
+async function handleSymlinkFile(fullPath, entryName, ctx) {
+  if (!testFileRe.test(entryName)) {
+    return;
+  }
+  const resolvedTarget = await tryRealpath(fullPath);
+  if (resolvedTarget && !hasExcludedAncestor(resolvedTarget)) {
+    ctx.results.push(path3.relative(ctx.cwd, fullPath));
+  }
+}
+async function handleSymlink(fullPath, entryName, ctx) {
+  const stat3 = await tryStat(fullPath);
+  if (!stat3) {
+    ctx.logger?.debug("discoverTestFiles: broken symlink at %s; skipping", fullPath);
+    return;
+  }
+  if (stat3.isDirectory()) {
+    await handleSymlinkDir(fullPath, entryName, ctx);
+  } else if (stat3.isFile()) {
+    await handleSymlinkFile(fullPath, entryName, ctx);
+  }
+}
+async function processEntry(entry, dir, ctx) {
+  const fullPath = path3.join(dir, entry.name);
+  if (entry.isDirectory()) {
+    if (!excludedDirs.has(entry.name)) {
+      await ctx.walk(fullPath);
+    }
+  } else if (entry.isSymbolicLink()) {
+    await handleSymlink(fullPath, entry.name, ctx);
+  } else if (entry.isFile() && testFileRe.test(entry.name)) {
+    ctx.results.push(path3.relative(ctx.cwd, fullPath));
+  }
+}
 async function discoverTestFiles(cwd = process.cwd(), logger) {
-  const testFileRe = /\.(?:test|spec)\.(?:[jt]sx?|m[jt]s)$/;
-  const excludedDirs = new Set(["node_modules", ".stryker-tmp", "dist", "build", ".git"]);
-  const hasExcludedAncestor = (absolutePath) => {
-    return absolutePath.split("/").some((seg) => excludedDirs.has(seg));
-  };
   const results = [];
   const visitedRealPaths = new Set;
-  const walk = async (dir) => {
-    let realDir;
-    try {
-      realDir = await fsPromises.realpath(dir);
-    } catch {
-      if (logger) {
-        logger.debug("discoverTestFiles: could not resolve real path of %s; skipping", dir);
-      }
+  const ctx = { cwd, results, visitedRealPaths, logger, walk };
+  async function walk(dir) {
+    const realDir = await tryRealpath(dir);
+    if (!realDir) {
+      logger?.debug("discoverTestFiles: could not resolve real path of %s; skipping", dir);
       return;
     }
     if (visitedRealPaths.has(realDir)) {
@@ -7599,69 +7761,27 @@ async function discoverTestFiles(cwd = process.cwd(), logger) {
     } catch {
       return;
     }
-    entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      const fullPath = join2(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (!excludedDirs.has(entry.name)) {
-          await walk(fullPath);
-        }
-      } else if (entry.isSymbolicLink()) {
-        let stat3;
-        try {
-          stat3 = await fsPromises.stat(fullPath);
-        } catch {
-          if (logger) {
-            logger.debug("discoverTestFiles: broken symlink at %s; skipping", fullPath);
-          }
-          continue;
-        }
-        if (stat3.isDirectory()) {
-          if (!excludedDirs.has(entry.name)) {
-            let resolvedTarget;
-            try {
-              resolvedTarget = await fsPromises.realpath(fullPath);
-            } catch {
-              continue;
-            }
-            if (hasExcludedAncestor(resolvedTarget)) {
-              if (logger) {
-                logger.debug("discoverTestFiles: symlink %s resolves to excluded path %s; skipping", fullPath, resolvedTarget);
-              }
-            } else {
-              await walk(fullPath);
-            }
-          }
-        } else if (stat3.isFile() && testFileRe.test(entry.name)) {
-          let resolvedTarget;
-          try {
-            resolvedTarget = await fsPromises.realpath(fullPath);
-          } catch {
-            continue;
-          }
-          if (!hasExcludedAncestor(resolvedTarget)) {
-            results.push(relative2(cwd, fullPath));
-          }
-        }
-      } else if (entry.isFile() && testFileRe.test(entry.name)) {
-        results.push(relative2(cwd, fullPath));
-      }
+      await processEntry(entry, dir, ctx);
     }
-  };
+  }
   await walk(cwd);
   if (results.length === 0) {
-    if (logger) {
-      logger.warn("discoverTestFiles: no test files found in %s; falling back to Bun discovery", cwd);
-    }
+    logger?.warn("discoverTestFiles: no test files found in %s; falling back to Bun discovery", cwd);
     return;
   }
-  results.sort();
-  if (logger) {
-    logger.debug("discoverTestFiles: found %d test files in %s", results.length, cwd);
-  }
+  results.sort((a, b) => a.localeCompare(b));
+  logger?.debug("discoverTestFiles: found %d test files in %s", results.length, cwd);
   return results;
 }
 // src/bun-test-runner.ts
+function sleep(ms) {
+  return new Promise((resolve3) => {
+    setTimeout(resolve3, ms);
+  });
+}
+
 class BunTestRunner {
   logger;
   static inject = tokens(commonTokens.logger, commonTokens.options);
@@ -7670,6 +7790,7 @@ class BunTestRunner {
   inspectorTimeout;
   env;
   bunArgs;
+  testFilesOverride;
   mutateGlobs;
   preloadScriptPath;
   coverageFilePath;
@@ -7679,7 +7800,9 @@ class BunTestRunner {
   cachedTestNames;
   baseNameIndex;
   cachedTestFiles;
+  cachedTestFilesCwd;
   cachedEagerModules;
+  cachedEagerModulesCwd;
   lastRegistryTmpPath;
   constructor(logger, options) {
     this.logger = logger;
@@ -7689,6 +7812,12 @@ class BunTestRunner {
     this.inspectorTimeout = bunOptions.inspectorTimeout ?? 5000;
     this.env = bunOptions.env;
     this.bunArgs = bunOptions.bunArgs;
+    if (bunOptions.testFiles?.length === 0) {
+      this.logger.warn("bun.testFiles was set to an empty array — treating as undefined and falling back to auto-discovery");
+      this.testFilesOverride = undefined;
+    } else {
+      this.testFilesOverride = bunOptions.testFiles;
+    }
     this.mutateGlobs = options.mutate ?? [];
     this.logger.debug("BunTestRunner initialized with options: %o", {
       bunPath: this.bunPath,
@@ -7697,26 +7826,68 @@ class BunTestRunner {
       env: this.env,
       bunArgs: this.bunArgs
     });
+    if (this.testFilesOverride?.some((p) => path4.isAbsolute(p))) {
+      const isSandbox = process.cwd().includes(".stryker-tmp/sandbox-");
+      if (isSandbox) {
+        this.logger.warn("bun.testFiles contains absolute path(s) and the current working directory appears to be a Stryker sandbox (%s). " + "Absolute paths point at the ORIGINAL (unmutated) source files — mutations will be silently bypassed. " + "Use relative paths so that Bun resolves them against the sandbox copy.", process.cwd());
+      }
+    }
   }
   get registryPath() {
-    return join3(process.cwd(), ".stryker-bun-runner-registry.json");
+    return path4.join(process.cwd(), ".stryker-bun-runner-registry.json");
   }
   get registryTmpPath() {
-    return this.registryPath + ".tmp";
+    return `${this.registryPath}.tmp`;
   }
   capabilities() {
     return {
       reloadEnvironment: true
     };
   }
+  async getOrDiscoverTestFiles() {
+    if (this.testFilesOverride !== undefined) {
+      return this.testFilesOverride;
+    }
+    const cwd = process.cwd();
+    if (this.cachedTestFiles !== undefined && this.cachedTestFilesCwd === cwd) {
+      return this.cachedTestFiles;
+    }
+    this.cachedTestFiles = await discoverTestFiles(cwd, this.logger);
+    this.cachedTestFilesCwd = cwd;
+    return this.cachedTestFiles;
+  }
+  testFilesCacheHit(cwd) {
+    if (this.testFilesOverride !== undefined) {
+      return this.testFilesOverride;
+    }
+    return this.cachedTestFiles !== undefined && this.cachedTestFilesCwd === cwd ? this.cachedTestFiles : null;
+  }
   async init() {
     this.logger.debug("BunTestRunner init starting...");
-    const tempDir = join3(tmpdir(), "stryker-bun-runner");
+    if (this.preloadScriptPath) {
+      try {
+        await cleanupPreloadScript(this.preloadScriptPath);
+      } catch (error) {
+        this.logger.debug("Failed to clean up previous preload script on re-init: %s", error instanceof Error ? error.message : String(error));
+      }
+      this.preloadScriptPath = undefined;
+    }
+    if (this.coverageFilePath) {
+      try {
+        await cleanupCoverageFile(this.coverageFilePath);
+      } catch (error) {
+        this.logger.debug("Failed to clean up previous coverage file on re-init: %s", error instanceof Error ? error.message : String(error));
+      }
+      this.coverageFilePath = undefined;
+    }
+    const tempDir = path4.join(tmpdir(), "stryker-bun-runner");
     this.tempDir = tempDir;
-    this.coverageFilePath = join3(tempDir, `coverage-${Date.now()}.json`);
+    this.coverageFilePath = path4.join(tempDir, `coverage-${Date.now()}.json`);
     this.logger.debug("Generating coverage preload script...");
-    if (!this.cachedEagerModules) {
+    const eagerCwd = process.cwd();
+    if (this.cachedEagerModules === undefined || this.cachedEagerModulesCwd !== eagerCwd) {
       this.cachedEagerModules = await resolveEagerModulesFromGlobs(this.mutateGlobs);
+      this.cachedEagerModulesCwd = eagerCwd;
       this.logger.debug("Resolved %d eager modules from mutate globs", this.cachedEagerModules.length);
     }
     this.preloadScriptPath = await generatePreloadScript({
@@ -7726,7 +7897,7 @@ class BunTestRunner {
     });
     this.logger.debug("Preload script generated at: %s", this.preloadScriptPath);
     await this.ensureSanitizedBunfig();
-    this.cachedTestFiles = await discoverTestFiles(process.cwd(), this.logger);
+    this.cachedTestFiles = await this.getOrDiscoverTestFiles();
   }
   async ensureSanitizedBunfig() {
     const cwd = process.cwd();
@@ -7736,7 +7907,7 @@ class BunTestRunner {
     if (this.sanitizedBunfigPath) {
       await cleanupSanitizedBunfig(this.sanitizedBunfigPath);
     }
-    const tempDir = this.tempDir ?? join3(tmpdir(), "stryker-bun-runner");
+    const tempDir = this.tempDir ?? path4.join(tmpdir(), "stryker-bun-runner");
     this.sanitizedBunfigPath = await generateSanitizedBunfig(cwd, tempDir);
     this.sanitizedBunfigCwd = cwd;
     this.logger.debug("Sanitized bunfig (re)generated at: %s for cwd: %s", this.sanitizedBunfigPath, cwd);
@@ -7745,7 +7916,7 @@ class BunTestRunner {
   async loadRegistryFile() {
     const registryPath = this.registryPath;
     try {
-      const raw = await fsPromises2.readFile(registryPath, "utf-8");
+      const raw = await fsPromises2.readFile(registryPath, "utf8");
       const parsed = JSON.parse(raw);
       if (parsed.version !== 1) {
         this.logger.warn("dryRun registry file has unexpected version %s; skipping", String(parsed.version));
@@ -7759,15 +7930,15 @@ class BunTestRunner {
       this.baseNameIndex = new Map(parsed.baseNameIndex);
       this.logger.debug("Loaded dryRun registry from %s (%d entries)", registryPath, this.cachedTestNames.size);
     } catch (err) {
-      const code = err?.code;
+      const code = err.code;
       if (code === "ENOENT") {
-        this.logger.warn("dryRun registry file not found at %s; killedBy names for static-coverage mutants may be unresolved", registryPath);
+        this.logger.debug("dryRun registry file not found at %s; this worker has no static-coverage registry (expected on non-dryRun workers)", registryPath);
       } else {
         this.logger.warn("Failed to load dryRun registry from %s: %s", registryPath, err instanceof Error ? err.message : String(err));
       }
     }
   }
-  buildTestsFromInspector(testHierarchy, executionOrder, parsed, totalElapsedMs) {
+  buildTestsFromInspector(testHierarchy, executionOrder, parsed, totalElapsedMs, inspectorIdToProjectFile) {
     if (executionOrder.length === 0) {
       return parsed.tests.map((t) => {
         const normalizedName = normalizeTestName(t.name);
@@ -7811,16 +7982,19 @@ class BunTestRunner {
           timeSpentMs: timePerTest
         };
       }
-      const uniqueName = buildUniqueTestName(testInfo.fullName, testInfo.url);
+      const projectFile = inspectorIdToProjectFile?.get(inspectorId);
+      const uniqueName = projectFile ? buildProjectFileTestName(projectFile, testInfo.fullName) : buildUniqueTestName(testInfo.fullName, testInfo.url);
+      const fileName = projectFile ?? normalizeTestFilePath(testInfo.url);
       const status = testInfo.status;
-      const elapsed = testInfo.elapsed !== undefined ? Math.round(testInfo.elapsed / 1e6) : timePerTest;
+      const elapsed = testInfo.elapsed === undefined ? timePerTest : Math.round(testInfo.elapsed / 1e6);
+      const startPosition = testInfo.line === undefined ? undefined : { line: testInfo.line, column: 0 };
       if (status === "fail") {
         const parsedTest = parsed.tests.find((t) => t.name.includes(testInfo.name));
         return {
           id: uniqueName,
           name: uniqueName,
-          fileName: normalizeTestFilePath(testInfo.url),
-          startPosition: testInfo.line !== undefined ? { line: testInfo.line, column: 0 } : undefined,
+          fileName,
+          startPosition,
           status: TestStatus.Failed,
           failureMessage: parsedTest?.failureMessage ?? testInfo.error?.message ?? "Test failed",
           timeSpentMs: elapsed
@@ -7830,8 +8004,8 @@ class BunTestRunner {
         return {
           id: uniqueName,
           name: uniqueName,
-          fileName: normalizeTestFilePath(testInfo.url),
-          startPosition: testInfo.line !== undefined ? { line: testInfo.line, column: 0 } : undefined,
+          fileName,
+          startPosition,
           status: TestStatus.Skipped,
           timeSpentMs: elapsed
         };
@@ -7839,8 +8013,8 @@ class BunTestRunner {
       return {
         id: uniqueName,
         name: uniqueName,
-        fileName: normalizeTestFilePath(testInfo.url),
-        startPosition: testInfo.line !== undefined ? { line: testInfo.line, column: 0 } : undefined,
+        fileName,
+        startPosition,
         status: TestStatus.Success,
         timeSpentMs: elapsed
       };
@@ -7866,8 +8040,7 @@ class BunTestRunner {
         const lineB = "startPosition" in b && b.startPosition ? b.startPosition.line : Infinity;
         return lineA - lineB;
       });
-      for (let i = 0;i < group.length; i++) {
-        const test = group[i];
+      for (const [i, test] of group.entries()) {
         const uniqueName = `${test.name} [${i}]`;
         test.id = uniqueName;
         test.name = uniqueName;
@@ -7877,6 +8050,7 @@ class BunTestRunner {
   }
   async dryRun() {
     this.logger.debug("Running dry run with inspector-based coverage collection...");
+    const abortController = new AbortController;
     const inspectPort = await getAvailablePort();
     const syncPort = await getAvailablePort();
     this.logger.debug("Using inspector port: %d, sync port: %d", inspectPort, syncPort);
@@ -7893,109 +8067,104 @@ class BunTestRunner {
       };
     }
     const startTime = Date.now();
-    let inspector = null;
     let inspectorUrl = null;
-    const cwd = process.cwd();
-    const bunfigPath = this.sanitizedBunfigPath && this.sanitizedBunfigCwd === cwd ? this.sanitizedBunfigPath : await this.ensureSanitizedBunfig();
-    if (!this.cachedTestFiles) {
-      this.cachedTestFiles = await discoverTestFiles(process.cwd(), this.logger);
-    }
-    const testProcess = runBunTests({
-      bunPath: this.bunPath,
-      timeout: this.timeout,
-      env: this.env,
-      bunArgs: this.bunArgs,
-      bunfigPath,
-      preloadScript: this.preloadScriptPath,
-      coverageFile: this.coverageFilePath,
-      inspectWaitPort: inspectPort,
-      sequentialMode: true,
-      syncPort,
-      testFiles: this.cachedTestFiles,
-      onInspectorReady: (url) => {
-        inspectorUrl = url;
-      }
-    });
-    const waitStart = Date.now();
-    while (!inspectorUrl && Date.now() - waitStart < this.inspectorTimeout) {
-      await new Promise((resolve4) => setTimeout(resolve4, 50));
-    }
-    if (!inspectorUrl) {
-      const diagnosticResult = await testProcess;
-      const stdoutPreview = (diagnosticResult.stdout ?? "").slice(0, 1000);
-      const stderrPreview = (diagnosticResult.stderr ?? "").slice(0, 1000);
-      this.logger.error(`Failed to get inspector URL within timeout (%dms).
+    try {
+      const cwd = process.cwd();
+      const bunfigPath = this.sanitizedBunfigPath && this.sanitizedBunfigCwd === cwd ? this.sanitizedBunfigPath : await this.ensureSanitizedBunfig();
+      const testFilesCached = this.testFilesCacheHit(cwd);
+      const testFiles = testFilesCached === null ? await this.getOrDiscoverTestFiles() : testFilesCached;
+      const testProcess = runBunTests({
+        bunPath: this.bunPath,
+        timeout: this.timeout,
+        env: this.env,
+        bunArgs: this.bunArgs,
+        bunfigPath,
+        preloadScript: this.preloadScriptPath,
+        coverageFile: this.coverageFilePath,
+        inspectWaitPort: inspectPort,
+        sequentialMode: true,
+        syncPort,
+        testFiles,
+        signal: abortController.signal,
+        onInspectorReady: (url) => {
+          inspectorUrl = url;
+        }
+      });
+      const waitStart = Date.now();
+      while (!inspectorUrl && Date.now() - waitStart < this.inspectorTimeout) {
+        await sleep(50);
+      }
+      if (!inspectorUrl) {
+        const diagnosticResult = await testProcess;
+        const stdoutPreview = diagnosticResult.stdout.slice(0, 1000);
+        const stderrPreview = diagnosticResult.stderr.slice(0, 1000);
+        this.logger.error(`Failed to get inspector URL within timeout (%dms).
 exit=%s timedOut=%s
 ` + `--- STDOUT (first 1000 chars) ---
 %s
 ` + `--- STDERR (first 1000 chars) ---
 %s`, this.inspectorTimeout, String(diagnosticResult.exitCode), String(diagnosticResult.timedOut), stdoutPreview || "(empty)", stderrPreview || "(empty)");
-      await syncServer.close();
-      return {
-        status: DryRunStatus.Error,
-        errorMessage: "Timeout waiting for inspector URL"
-      };
-    }
-    this.logger.debug("Inspector URL: %s", inspectorUrl);
-    inspector = new InspectorClient({
-      url: inspectorUrl,
-      connectionTimeout: this.inspectorTimeout,
-      requestTimeout: this.inspectorTimeout,
-      handlers: {}
-    });
-    try {
-      await inspector.connect();
-      await inspector.send("TestReporter.enable", {});
-      this.logger.debug("Inspector connected and TestReporter enabled");
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      this.logger.error("Failed to connect inspector: %s", errorMsg);
+        return {
+          status: DryRunStatus.Error,
+          errorMessage: "Timeout waiting for inspector URL"
+        };
+      }
+      this.logger.debug("Inspector URL: %s", inspectorUrl);
+      const inspector = new InspectorClient({
+        url: inspectorUrl,
+        connectionTimeout: this.inspectorTimeout,
+        requestTimeout: this.inspectorTimeout,
+        handlers: {}
+      });
+      try {
+        await inspector.connect();
+        await inspector.send("TestReporter.enable", {});
+        this.logger.debug("Inspector connected and TestReporter enabled");
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        this.logger.error("Failed to connect inspector: %s", errorMsg);
+        abortController.abort();
+        await inspector.close();
+        return {
+          status: DryRunStatus.Error,
+          errorMessage: `Failed to connect to Bun inspector: ${errorMsg}`
+        };
+      }
+      syncServer.signalReady();
+      this.logger.debug("Signaled preload script to proceed");
+      const result = await testProcess;
+      const totalElapsedMs = Date.now() - startTime;
+      const testHierarchy = inspector.getTests();
+      const executionOrder = inspector.getExecutionOrder();
       await inspector.close();
-      await syncServer.close();
-      return {
-        status: DryRunStatus.Error,
-        errorMessage: `Failed to connect to Bun inspector: ${errorMsg}`
-      };
-    }
-    syncServer.signalReady();
-    this.logger.debug("Signaled preload script to proceed");
-    const result = await testProcess;
-    const totalElapsedMs = Date.now() - startTime;
-    const testHierarchy = inspector.getTests();
-    const executionOrder = inspector.getExecutionOrder();
-    await inspector.close();
-    await syncServer.close();
-    this.logger.debug("Inspector collected %d tests in hierarchy, %d in execution order", testHierarchy.length, executionOrder.length);
-    if (result.timedOut) {
-      this.logger.warn("Dry run timed out");
-      return { status: DryRunStatus.Timeout };
-    }
-    const parsed = parseBunTestOutput(result.stdout, result.stderr);
-    if (result.exitCode !== 0 && parsed.failed === 0) {
+      this.logger.debug("Inspector collected %d tests in hierarchy, %d in execution order", testHierarchy.length, executionOrder.length);
+      const parsed = parseBunTestOutput(result.stdout, result.stderr);
+      const earlyResult = this.checkDryRunProcessResult(result, parsed);
+      if (earlyResult) {
+        return earlyResult;
+      }
+      const { coverage: mutantCoverage, inspectorIdToProjectFile } = await this.collectAndRemapCoverage(testHierarchy, executionOrder);
+      const tests = this.buildTestsFromInspector(testHierarchy, executionOrder, parsed, totalElapsedMs, inspectorIdToProjectFile);
+      tests.sort((a, b) => a.name.localeCompare(b.name));
+      await this.buildAndPersistTestRegistry(tests);
       return {
-        status: DryRunStatus.Error,
-        errorMessage: `Bun test process failed with exit code ${result.exitCode}
-${result.stderr}`
+        status: DryRunStatus.Complete,
+        tests,
+        mutantCoverage
       };
+    } finally {
+      abortController.abort();
+      await syncServer.close();
     }
-    let mutantCoverage;
-    if (this.coverageFilePath) {
-      mutantCoverage = await collectCoverage(this.coverageFilePath, this.logger);
-      await cleanupCoverageFile(this.coverageFilePath);
-    }
-    if (mutantCoverage) {
-      const testMap = new Map(testHierarchy.map((t) => [t.id, t]));
-      mutantCoverage = mapCoverageToInspectorIds(mutantCoverage, executionOrder, testMap, this.logger);
-    }
-    const tests = this.buildTestsFromInspector(testHierarchy, executionOrder, parsed, totalElapsedMs);
-    tests.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  async buildAndPersistTestRegistry(tests) {
     this.cachedTestNames = new Set(tests.map((t) => t.name));
     if (tests.length !== this.cachedTestNames.size) {
       const nameCount = new Map;
       for (const test of tests) {
         nameCount.set(test.name, (nameCount.get(test.name) ?? 0) + 1);
       }
-      const duplicates = Array.from(nameCount.entries()).filter(([_, count]) => count > 1).map(([name, count]) => `"${name}" (${count}x)`);
+      const duplicates = [...nameCount.entries()].filter(([_, count]) => count > 1).map(([name, count]) => `"${name}" (${count}x)`);
       this.logger.warn("Found %d duplicate test names (total: %d, unique: %d): %s", tests.length - this.cachedTestNames.size, tests.length, this.cachedTestNames.size, duplicates.join(", "));
     }
     this.baseNameIndex = new Map;
@@ -8019,49 +8188,29 @@ ${result.stderr}`
       const registryData = JSON.stringify({
         version: 1,
         writtenAt: Date.now(),
-        cachedTestNames: Array.from(this.cachedTestNames),
-        baseNameIndex: Array.from(this.baseNameIndex.entries())
+        cachedTestNames: [...this.cachedTestNames],
+        baseNameIndex: [...this.baseNameIndex.entries()]
       });
-      await fsPromises2.writeFile(tmpPath, registryData, "utf-8");
+      await fsPromises2.writeFile(tmpPath, registryData, "utf8");
       this.lastRegistryTmpPath = tmpPath;
       await fsPromises2.rename(tmpPath, registryPath);
+      this.lastRegistryTmpPath = undefined;
       this.logger.debug("Wrote dryRun registry to %s (%d entries)", registryPath, this.cachedTestNames.size);
-    } catch (registryErr) {
-      this.logger.warn("Failed to write dryRun registry file: %s", registryErr instanceof Error ? registryErr.message : String(registryErr));
+    } catch (error) {
+      this.logger.warn("Failed to write dryRun registry file: %s", error instanceof Error ? error.message : String(error));
     }
-    return {
-      status: DryRunStatus.Complete,
-      tests,
-      mutantCoverage
-    };
   }
   async mutantRun(options) {
     this.logger.debug("Running mutant run for mutant %s", options.activeMutant.id);
     const testNamePattern = buildTestNamePattern(options.testFilter ?? []);
     const localTestFilter = options.testFilter ?? [];
-    const localRegistry = new Set(localTestFilter);
-    const localSuffixRe = / \[\d+\]$/;
-    const localBaseIndex = new Map;
-    for (const id of localRegistry) {
-      const base = localSuffixRe.test(id) ? id.replace(localSuffixRe, "") : id;
-      const bucket = localBaseIndex.get(base);
-      if (bucket) {
-        bucket.push(id);
-      } else {
-        localBaseIndex.set(base, [id]);
-      }
-      if (base !== id) {
-        localBaseIndex.set(id, [id]);
-      }
-    }
+    const { localRegistry, localBaseIndex } = this.buildLocalTestFilterIndex(localTestFilter);
     if (!this.cachedTestNames) {
       await this.loadRegistryFile();
     }
     const mutantCwd = process.cwd();
     const bunfigPath = this.sanitizedBunfigPath && this.sanitizedBunfigCwd === mutantCwd ? this.sanitizedBunfigPath : await this.ensureSanitizedBunfig();
-    if (!this.cachedTestFiles) {
-      this.cachedTestFiles = await discoverTestFiles(process.cwd(), this.logger);
-    }
+    this.cachedTestFiles = await this.getOrDiscoverTestFiles();
     const result = await runBunTests({
       bunPath: this.bunPath,
       timeout: this.timeout,
@@ -8089,72 +8238,128 @@ ${result.stderr}`
       exitCode: result.exitCode
     });
     if (result.exitCode !== 0) {
-      const rawFailedNames = parsed.tests.filter((test) => test.status === "failed").map((test) => normalizeTestName(test.name));
-      if (rawFailedNames.length === 0 && parsed.tests.length === 0) {
-        const stderr = result.stderr ?? "";
-        const isRuntimeError = stderr.includes("Unhandled error") || stderr.includes("Cannot find module") || stderr.includes("SyntaxError") || stderr.includes("TypeError") || stderr.includes("ReferenceError") || stderr.includes("is not defined") || stderr.includes("Unexpected token");
-        if (isRuntimeError) {
-          this.logger.debug("Mutant %s caused runtime error (tests could not run): %s", options.activeMutant.id, stderr.slice(0, 200));
-          return {
-            status: MutantRunStatus.Error,
-            errorMessage: stderr.slice(0, 500) || `Runtime error with exit code ${result.exitCode}`
-          };
-        }
-      }
-      const killedBySet = new Set;
-      for (const name of rawFailedNames) {
-        if (localRegistry.has(name)) {
-          killedBySet.add(name);
-          continue;
-        }
-        const localBucket = localBaseIndex.get(name);
-        if (localBucket) {
-          this.logger.debug('Expanded killedBy base name "%s" → %d local registry IDs for mutant %s', name, localBucket.length, options.activeMutant.id);
-          for (const id of localBucket) {
-            killedBySet.add(id);
-          }
-          continue;
-        }
-        if (this.cachedTestNames?.has(name)) {
-          killedBySet.add(name);
-          continue;
-        }
-        const instanceBucket = this.baseNameIndex?.get(name);
-        if (instanceBucket) {
-          this.logger.debug('Expanded killedBy base name "%s" → %d instance registry IDs for mutant %s', name, instanceBucket.length, options.activeMutant.id);
-          for (const id of instanceBucket) {
-            killedBySet.add(id);
-          }
-          continue;
-        }
-        this.logger.warn('killedBy name "%s" for mutant %s not found in test registry; ' + "including as-is (may break incremental cache)", name, options.activeMutant.id);
-        killedBySet.add(name);
+      return this.buildMutantKilledResult(result, parsed, localRegistry, localBaseIndex, options.activeMutant.id);
+    }
+    return {
+      status: MutantRunStatus.Survived,
+      nrOfTests: parsed.totalTests
+    };
+  }
+  buildMutantKilledResult(result, parsed, localRegistry, localBaseIndex, mutantId) {
+    const rawFailedNames = parsed.tests.filter((test) => test.status === "failed").map((test) => normalizeTestName(test.name));
+    if (rawFailedNames.length === 0 && parsed.tests.length === 0) {
+      const runtimeResult = this.checkRuntimeError(result, mutantId);
+      if (runtimeResult) {
+        return runtimeResult;
       }
-      const killedBy = Array.from(killedBySet);
-      if (killedBy.length === 0) {
-        const stdoutPreview = (result.stdout ?? "").slice(0, 600);
-        const stderrPreview = (result.stderr ?? "").slice(0, 600);
-        this.logger.warn("No failed tests identified for mutant %s — Bun output could not be parsed; " + `using "unknown" fallback (breaks incremental cache)
+    }
+    const killedBy = this.resolveKilledBy(rawFailedNames, localRegistry, localBaseIndex, mutantId);
+    if (killedBy.length === 0) {
+      this.logger.warn("No failed tests identified for mutant %s — Bun output could not be parsed; " + `using "unknown" fallback (breaks incremental cache)
 ` + `exit=%s
 --- STDOUT (first 600 chars) ---
 %s
 ` + `--- STDERR (first 600 chars) ---
-%s`, options.activeMutant.id, String(result.exitCode), stdoutPreview || "(empty)", stderrPreview || "(empty)");
-        killedBy.push("unknown");
-      }
-      return {
-        status: MutantRunStatus.Killed,
-        killedBy,
-        failureMessage: parsed.tests.filter((test) => test.status === "failed").map((test) => test.failureMessage).filter((msg) => !!msg).join(`
+%s`, mutantId, String(result.exitCode), result.stdout.slice(0, 600) || "(empty)", result.stderr.slice(0, 600) || "(empty)");
+      killedBy.push("unknown");
+    }
+    return {
+      status: MutantRunStatus.Killed,
+      killedBy,
+      failureMessage: parsed.tests.filter((test) => test.status === "failed").map((test) => test.failureMessage).filter((msg) => !!msg).join(`
 
 `) || `Tests failed with exit code ${result.exitCode}`,
-        nrOfTests: parsed.totalTests || 1
+      nrOfTests: parsed.totalTests || 1
+    };
+  }
+  checkRuntimeError(result, mutantId) {
+    const stderr = result.stderr;
+    const isRuntimeError = stderr.includes("Unhandled error") || stderr.includes("Cannot find module") || stderr.includes("SyntaxError") || stderr.includes("TypeError") || stderr.includes("ReferenceError") || stderr.includes("is not defined") || stderr.includes("Unexpected token");
+    if (isRuntimeError) {
+      this.logger.debug("Mutant %s caused runtime error (tests could not run): %s", mutantId, stderr.slice(0, 200));
+      return {
+        status: MutantRunStatus.Error,
+        errorMessage: stderr.slice(0, 500) || `Runtime error with exit code ${result.exitCode}`
       };
     }
-    return {
-      status: MutantRunStatus.Survived,
-      nrOfTests: parsed.totalTests
-    };
+    return null;
+  }
+  checkDryRunProcessResult(result, parsed) {
+    if (result.timedOut) {
+      this.logger.warn("Dry run timed out");
+      return { status: DryRunStatus.Timeout };
+    }
+    if (result.exitCode !== 0 && parsed.failed === 0) {
+      return {
+        status: DryRunStatus.Error,
+        errorMessage: `Bun test process failed with exit code ${result.exitCode}
+${result.stderr}`
+      };
+    }
+    return null;
+  }
+  async collectAndRemapCoverage(testHierarchy, executionOrder) {
+    const testMap = new Map(testHierarchy.map((t) => [t.id, t]));
+    if (!this.coverageFilePath) {
+      return { coverage: undefined, inspectorIdToProjectFile: new Map };
+    }
+    const rawCoverage = await collectCoverage(this.coverageFilePath, this.logger);
+    await cleanupCoverageFile(this.coverageFilePath);
+    if (!rawCoverage) {
+      return { coverage: undefined, inspectorIdToProjectFile: new Map };
+    }
+    const { coverage, inspectorIdToProjectFile } = mapCoverageToInspectorIds(rawCoverage, executionOrder, testMap, this.logger);
+    return { coverage, inspectorIdToProjectFile };
+  }
+  buildLocalTestFilterIndex(testFilter) {
+    const localRegistry = new Set(testFilter);
+    const localSuffixRe = / \[\d+\]$/;
+    const localBaseIndex = new Map;
+    for (const id of localRegistry) {
+      const base = localSuffixRe.test(id) ? id.replace(localSuffixRe, "") : id;
+      const bucket = localBaseIndex.get(base);
+      if (bucket) {
+        bucket.push(id);
+      } else {
+        localBaseIndex.set(base, [id]);
+      }
+      if (base !== id) {
+        localBaseIndex.set(id, [id]);
+      }
+    }
+    return { localRegistry, localBaseIndex };
+  }
+  resolveKilledBy(rawFailedNames, localRegistry, localBaseIndex, mutantId) {
+    const killedBySet = new Set;
+    for (const name of rawFailedNames) {
+      if (localRegistry.has(name)) {
+        killedBySet.add(name);
+        continue;
+      }
+      const localBucket = localBaseIndex.get(name);
+      if (localBucket) {
+        this.logger.debug('Expanded killedBy base name "%s" → %d local registry IDs for mutant %s', name, localBucket.length, mutantId);
+        for (const id of localBucket) {
+          killedBySet.add(id);
+        }
+        continue;
+      }
+      if (this.cachedTestNames?.has(name)) {
+        killedBySet.add(name);
+        continue;
+      }
+      const instanceBucket = this.baseNameIndex?.get(name);
+      if (instanceBucket) {
+        this.logger.debug('Expanded killedBy base name "%s" → %d instance registry IDs for mutant %s', name, instanceBucket.length, mutantId);
+        for (const id of instanceBucket) {
+          killedBySet.add(id);
+        }
+        continue;
+      }
+      this.logger.debug('killedBy name "%s" for mutant %s not found in test registry; including as-is', name, mutantId);
+      killedBySet.add(name);
+    }
+    return [...killedBySet];
   }
   async dispose() {
     this.logger.debug("Disposing BunTestRunner");
@@ -8202,7 +8407,7 @@ var strykerValidationSchema = {
         timeout: {
           type: "number",
           minimum: 0,
-          description: "Timeout per test in milliseconds (default: 10000)",
+          description: "Child-process timeout in milliseconds (default: 10000). Controls how long the entire bun test subprocess may run before being killed. Independent from the per-test timeout in bunfig.toml [test].timeout, which Bun uses to declare individual tests timed out.",
           default: 1e4
         },
         inspectorTimeout: {
@@ -8224,6 +8429,14 @@ var strykerValidationSchema = {
           items: {
             type: "string"
           }
+        },
+        testFiles: {
+          type: "array",
+          description: "Explicit list of test file paths (relative paths preferred in Stryker context — absolute paths bypass the sandbox copy and will NOT be mutated). When provided, skips auto-discovery and uses this list verbatim. Relative paths resolve against the bun subprocess's cwd. An empty array is invalid (use undefined/omit to enable auto-discovery).",
+          minItems: 1,
+          items: {
+            type: "string"
+          }
         }
       },
       additionalProperties: false