@hughescr/stryker-bun-runner 1.2.0 → 1.2.1

package/README.md

@@ -77,6 +77,7 @@ This approach provides reliable test-to-mutant correlation, even with multiple t
 | `bun.inspectorTimeout` | `number` | `5000` | Timeout for Inspector WebSocket connection in milliseconds |
 | `bun.env` | `object` | `undefined` | Additional environment variables to pass to bun test |
 | `bun.bunArgs` | `string[]` | `undefined` | Additional bun test flags (e.g., `['--bail']`) |
+| `bun.testFiles` | `string[]` | `undefined` | Explicit list of test file paths (absolute or relative to cwd). When provided, skips auto-discovery and uses this list verbatim. Relative paths resolve against the bun subprocess's cwd. Useful for restricting mutation testing to a subset of test files. |
 
 ### Example with all options
 

package/dist/coverage/preload-logic.js

@@ -38,8 +38,8 @@ function formatCoverageData(mutantCoverage, counterToName) {
   };
 }
 function writeCoverageToFile(coverageFile, data) {
-  appendFileSync(coverageFile, JSON.stringify(data) + `
-`, "utf-8");
+  appendFileSync(coverageFile, `${JSON.stringify(data)}
+`, "utf8");
 }
 export {
   writeCoverageToFile,

package/dist/index.d.ts

@@ -19,6 +19,7 @@ export declare class BunTestRunner implements TestRunner {
 	private readonly inspectorTimeout;
 	private readonly env?;
 	private readonly bunArgs?;
+	private readonly testFilesOverride?;
 	private readonly mutateGlobs;
 	private preloadScriptPath?;
 	private coverageFilePath?;
@@ -28,7 +29,9 @@ export declare class BunTestRunner implements TestRunner {
 	private cachedTestNames?;
 	private baseNameIndex?;
 	private cachedTestFiles?;
+	private cachedTestFilesCwd?;
 	private cachedEagerModules?;
+	private cachedEagerModulesCwd?;
 	private lastRegistryTmpPath?;
 	constructor(logger: Logger, options: StrykerOptions);
 	/**
@@ -44,6 +47,21 @@ export declare class BunTestRunner implements TestRunner {
    */
 	capabilities(): TestRunnerCapabilities;
 	/**
+   * Return the test file list to use for this run.
+   * When `bun.testFiles` was provided it is returned verbatim and
+   * auto-discovery is skipped entirely.  Otherwise the result is cached after
+   * the first real discovery call so that subsequent callers (dryRun, mutantRun)
+   * do not re-glob the filesystem.
+   */
+	private getOrDiscoverTestFiles;
+	/**
+   * Test-file cache hit for a given cwd.
+   * Returns the cached list synchronously when available, or undefined to
+   * signal that async re-discovery is needed (cwd changed or first call).
+   * Used by dryRun() to avoid introducing a microtask yield on the hot path.
+   */
+	private testFilesCacheHit;
+	/**
    * Initialize the test runner
    */
 	init(): Promise<void>;
@@ -73,10 +91,62 @@ export declare class BunTestRunner implements TestRunner {
    */
 	dryRun(): Promise<DryRunResult>;
 	/**
+   * Build the in-memory test name cache and base-name index, then atomically
+   * persist them to a well-known file so other worker processes can lazy-load
+   * them when handling static-coverage mutants (testFilter is empty for those).
+   *
+   * Writing to a .tmp path then renaming is atomic on POSIX: readers always see
+   * either the previous complete file or the new one — never a partial write.
+   */
+	private buildAndPersistTestRegistry;
+	/**
    * Run tests with an active mutant
    */
 	mutantRun(options: MutantRunOptions): Promise<MutantRunResult>;
 	/**
+   * Build the MutantRunResult for a killed mutant (non-zero exit code).
+   * Handles runtime error detection and killedBy resolution.
+   */
+	private buildMutantKilledResult;
+	/**
+   * Check if the process failed due to a runtime error (no tests ran).
+   * Returns a MutantRunResult if this is a runtime error, or null to continue.
+   */
+	private checkRuntimeError;
+	/**
+   * Check for dry run process failures (timeout or non-zero exit).
+   * Returns a DryRunResult to short-circuit if the process failed, or null to proceed.
+   */
+	private checkDryRunProcessResult;
+	/**
+   * Collect coverage from the coverage file and remap counter-based IDs to
+   * full test names using the inspector's execution order.
+   */
+	private collectAndRemapCoverage;
+	/**
+   * Build local index structures from testFilter for killedBy resolution.
+   *
+   * testFilter carries the full registry IDs Stryker wants us to run, including
+   * any " [N]" dedup suffixes. Building the index here means all workers behave
+   * identically on the first shot, eliminating incremental drift caused by workers
+   * that never ran dryRun falling through to raw names.
+   */
+	private buildLocalTestFilterIndex;
+	/**
+   * Resolve raw failed test names from console output against the test registry.
+   *
+   * Console-parser output lacks the [N] dedup suffix that dryRun appends when
+   * multiple tests share the same base name (e.g. it.each with %s).
+   *
+   * Fallback chain — stops at the FIRST successful resolution for each name:
+   *   1. Exact match in localRegistry (built from testFilter)
+   *   2. Base-name match in localBaseIndex (built from testFilter)
+   *   3. Exact match in this.cachedTestNames (instance registry from dryRun)
+   *   4. Base-name match in this.baseNameIndex (instance registry from dryRun)
+   *   5. Raw name as-is with a warn log — last resort if nothing resolves.
+   */
+	private resolveKilledBy;
+	/**
    * Cleanup resources
    */
 	dispose(): Promise<void>;
@@ -91,8 +161,14 @@ export interface BunTestRunnerOptions {
    */
 	bunPath?: string;
 	/**
-   * Timeout per test in milliseconds
+   * Child-process timeout in milliseconds — the maximum wall-clock time that the
+   * entire `bun test` subprocess is allowed to run before it is killed.
    * @default 10000
+   *
+   * Note: this is distinct from Bun's per-test timeout configured via
+   * `[test].timeout` in `bunfig.toml`.  The two are independent: `bunfig.toml`
+   * controls when Bun itself declares a single test timed out; this option
+   * controls when the Stryker runner forcibly kills the whole child process.
    */
 	timeout?: number;
 	/**
@@ -109,6 +185,25 @@ export interface BunTestRunnerOptions {
    * @example ['--bail', '--only']
    */
 	bunArgs?: string[];
+	/**
+   * Explicit list of test file paths (must be non-empty when provided).
+   * When provided, BunTestRunner skips auto-discovery (which globs
+   * `**\/*.test.ts` from the current working directory) and uses exactly this
+   * list. Useful for restricting mutation testing to a subset, or for callers
+   * that run outside Stryker's sandboxed cwd and need to point at a specific
+   * file set. Relative paths resolve against the bun subprocess's cwd.
+   *
+   * IMPORTANT: In a Stryker mutation-testing run, each worker's cwd is set to
+   * a sandbox directory (`.stryker-tmp/sandbox-XYZ/`) containing sandbox copies
+   * of the project files. Relative paths are resolved against that sandbox cwd
+   * and therefore point at the mutated copies. Absolute paths bypass the sandbox
+   * and always point at the ORIGINAL (unmutated) files — mutations will be
+   * silently ignored. Always prefer relative paths in Stryker context.
+   *
+   * An empty array (`[]`) is invalid — use `undefined` or omit the option to
+   * fall back to auto-discovery.
+   */
+	testFiles?: string[];
 }
 /**
  * Extended Stryker options with Bun-specific configuration
@@ -168,6 +263,14 @@ export declare const strykerValidationSchema: {
 						type: string;
 					};
 				};
+				testFiles: {
+					type: string;
+					description: string;
+					minItems: number;
+					items: {
+						type: string;
+					};
+				};
 			};
 			additionalProperties: boolean;
 		};