@mutineerjs/mutineer 0.8.0 → 0.10.0

package/README.md

@@ -15,10 +15,10 @@ Built for **Vitest** with first-class **Jest** support. Other test runners can b
 
 ## How It Works
 
-1. **Baseline** -- runs your test suite to make sure everything passes before mutating
-2. **Mutate** -- applies AST-safe operator replacements to your source files (not your tests)
-3. **Test** -- re-runs only the tests that import the mutated file; compile errors are detected via parallel TypeScript workers and surfaced in an interactive UI
-4. **Report** -- prints a summary with kill rate, escaped mutants, and per-file breakdowns
+1. **Baseline** - runs your test suite to make sure everything passes before mutating
+2. **Mutate** - applies AST-safe operator replacements to your source files (not your tests)
+3. **Test** - re-runs only the tests that import the mutated file; compile errors are detected via parallel TypeScript workers
+4. **Report** - prints a summary with kill rate, escaped mutants, and per-file breakdowns
 
 Mutations are applied using Babel AST analysis, so operators inside strings and comments are never touched. Mutated code is written to a temporary `__mutineer__` directory next to each source file, then loaded at runtime via Vite plugins (Vitest) or custom resolvers (Jest).
 
@@ -93,22 +93,26 @@ npm run mutineer
 
 ### CLI Options (for `mutineer run`)
 
-| Flag                     | Description                                                     | Default       |
-| ------------------------ | --------------------------------------------------------------- | ------------- |
-| `--runner <type>`        | Test runner: `vitest` or `jest`                                 | `vitest`      |
-| `--config`, `-c`         | Path to config file                                             | auto-detected |
-| `--concurrency <n>`      | Parallel workers (min 1)                                        | CPUs - 1      |
-| `--changed`              | Only mutate files changed vs base branch                        | --            |
-| `--changed-with-deps`    | Include dependents of changed files                             | --            |
-| `--only-covered-lines`   | Skip mutations on uncovered lines                               | --            |
-| `--per-test-coverage`    | Run only tests that cover the mutated line                      | --            |
-| `--coverage-file <path>` | Path to Istanbul coverage JSON                                  | auto-detected |
-| `--min-kill-percent <n>` | Fail if kill rate is below threshold                            | --            |
-| `--progress <mode>`      | Display mode: `bar`, `list`, or `quiet`                         | `bar`         |
-| `--timeout <ms>`         | Per-mutant test timeout                                         | `30000`       |
-| `--report <format>`      | Output format: `text` or `json` (writes `mutineer-report.json`) | `text`        |
-| `--shard <n>/<total>`    | Run a slice of mutants (e.g. `--shard 1/4`)                     | --            |
-| `--skip-baseline`        | Skip the baseline test run                                      | --            |
+| Flag                      | Description                                                                          | Default       |
+| ------------------------- | ------------------------------------------------------------------------------------ | ------------- |
+| `--runner <type>`         | Test runner: `vitest` or `jest`                                                      | `vitest`      |
+| `--config`, `-c`          | Path to config file                                                                  | auto-detected |
+| `--concurrency <n>`       | Parallel workers (min 1)                                                             | CPUs - 1      |
+| `--changed`               | Only mutate files changed vs base branch                                             | --            |
+| `--changed-with-deps`     | Include dependents of changed files                                                  | --            |
+| `--full`                  | Mutate full codebase, skipping confirmation prompt                                   | --            |
+| `--only-covered-lines`    | Skip mutations on uncovered lines                                                    | --            |
+| `--per-test-coverage`     | Run only tests that cover the mutated line                                           | --            |
+| `--coverage-file <path>`  | Path to Istanbul coverage JSON                                                       | auto-detected |
+| `--min-kill-percent <n>`  | Fail if kill rate is below threshold                                                 | --            |
+| `--progress <mode>`       | Display mode: `bar`, `list`, or `quiet`                                              | `bar`         |
+| `--timeout <ms>`          | Per-mutant test timeout                                                              | `30000`       |
+| `--report <format>`       | Output format: `text` or `json` (writes `mutineer-report.json`)                      | `text`        |
+| `--shard <n>/<total>`     | Run a slice of mutants (e.g. `--shard 1/4`)                                          | --            |
+| `--skip-baseline`         | Skip the baseline test run                                                           | --            |
+| `--vitest-project <name>` | Filter mutations to a specific Vitest workspace project (requires `test.projects`)   | --            |
+| `--typescript`            | Enable TypeScript type-check pre-filtering (skips mutants that cause compile errors) | auto          |
+| `--no-typescript`         | Disable TypeScript type-check pre-filtering                                          | --            |
 
 ### Examples
 
@@ -148,29 +152,31 @@ export default defineMutineerConfig({
 
 ### Config Options
 
-| Option              | Type                 | Description                                      |
-| ------------------- | -------------------- | ------------------------------------------------ |
-| `source`            | `string \| string[]` | Glob patterns for source files to mutate         |
-| `targets`           | `MutateTarget[]`     | Explicit list of files to mutate                 |
-| `runner`            | `'vitest' \| 'jest'` | Test runner to use                               |
-| `vitestConfig`      | `string`             | Path to vitest config                            |
-| `jestConfig`        | `string`             | Path to jest config                              |
-| `include`           | `string[]`           | Only run these mutators                          |
-| `exclude`           | `string[]`           | Skip these mutators                              |
-| `excludePaths`      | `string[]`           | Glob patterns for paths to skip                  |
-| `maxMutantsPerFile` | `number`             | Cap mutations per file                           |
-| `minKillPercent`    | `number`             | Fail if kill rate is below this                  |
-| `onlyCoveredLines`  | `boolean`            | Only mutate lines covered by tests               |
-| `perTestCoverage`   | `boolean`            | Use per-test coverage to select tests            |
-| `baseRef`           | `string`             | Git ref for `--changed` (default: `origin/main`) |
-| `testPatterns`      | `string[]`           | Globs for test file discovery                    |
-| `extensions`        | `string[]`           | File extensions to consider                      |
+| Option              | Type                               | Description                                                                  |
+| ------------------- | ---------------------------------- | ---------------------------------------------------------------------------- |
+| `source`            | `string \| string[]`               | Glob patterns for source files to mutate                                     |
+| `targets`           | `MutateTarget[]`                   | Explicit list of files to mutate                                             |
+| `runner`            | `'vitest' \| 'jest'`               | Test runner to use                                                           |
+| `vitestConfig`      | `string`                           | Path to vitest config                                                        |
+| `jestConfig`        | `string`                           | Path to jest config                                                          |
+| `include`           | `string[]`                         | Only run these mutators                                                      |
+| `exclude`           | `string[]`                         | Skip these mutators                                                          |
+| `excludePaths`      | `string[]`                         | Glob patterns for paths to skip                                              |
+| `maxMutantsPerFile` | `number`                           | Cap mutations per file                                                       |
+| `minKillPercent`    | `number`                           | Fail if kill rate is below this                                              |
+| `onlyCoveredLines`  | `boolean`                          | Only mutate lines covered by tests                                           |
+| `perTestCoverage`   | `boolean`                          | Use per-test coverage to select tests                                        |
+| `baseRef`           | `string`                           | Git ref for `--changed` (default: `origin/main`)                             |
+| `testPatterns`      | `string[]`                         | Globs for test file discovery                                                |
+| `extensions`        | `string[]`                         | File extensions to consider                                                  |
+| `vitestProject`     | `string \| string[]`               | Filter to a specific Vitest workspace project                                |
+| `typescript`        | `boolean \| { tsconfig?: string }` | Enable TS type-check pre-filtering; auto-detected if `tsconfig.json` present |
 
 ## Recommended Workflow
 
 Large repos can generate thousands of mutations. These strategies keep runs fast and incremental.
 
-When you run `mutineer run` without `--changed` or `--changed-with-deps` on an interactive terminal, mutineer warns you and lets you narrow scope before starting:
+When you run `mutineer run` without `--changed`, `--changed-with-deps`, or `--full` on an interactive terminal, mutineer warns you and lets you narrow scope before starting:
 
 ```
 Warning: Running on the full codebase may take a while.

package/dist/bin/__tests__/mutineer.spec.js

@@ -11,6 +11,7 @@ describe('HELP_TEXT', () => {
         '--progress',
         '--changed',
         '--changed-with-deps',
+        '--full',
         '--only-covered-lines',
         '--per-test-coverage',
         '--coverage-file',
@@ -61,6 +62,13 @@ describe('confirmFullRun()', () => {
         const args = ['--changed-with-deps'];
         expect(await confirmFullRun(args)).toBe(args);
     });
+    it('returns args unchanged when --full is present, skipping prompt', async () => {
+        mockTTY(true);
+        const createSpy = vi.spyOn(readline, 'createInterface');
+        const args = ['--full'];
+        expect(await confirmFullRun(args)).toBe(args);
+        expect(createSpy).not.toHaveBeenCalled();
+    });
     it('skips prompt and returns args unchanged when stdin is not a TTY', async () => {
         mockTTY(false);
         const createSpy = vi.spyOn(readline, 'createInterface');

package/dist/bin/mutineer.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-export declare const HELP_TEXT = "Usage: mutineer <command> [options]\n\nCommands:\n  init       Create a mutineer.config.ts template\n  run        Run mutation testing\n  clean      Remove __mutineer__ temp directories\n\nOptions (run):\n  --config, -c <path>       Config file path\n  --concurrency <n>         Worker count (default: CPU count - 1)\n  --runner <vitest|jest>    Test runner (default: vitest)\n  --progress <bar|list|quiet>  Progress display (default: bar)\n  --changed                 Mutate only git-changed files\n  --changed-with-deps       Mutate changed files + their local dependencies\n  --only-covered-lines      Mutate only lines covered by tests\n  --per-test-coverage       Collect per-test coverage data\n  --coverage-file <path>    Path to coverage JSON\n  --min-kill-percent <n>    Minimum kill % threshold (0\u2013100)\n  --timeout <ms>            Per-mutant test timeout in ms (default: 30000)\n  --report <text|json>      Output format: text (default) or json (writes mutineer-report.json)\n  --shard <n>/<total>       Run a shard of mutants (e.g. --shard 1/4)\n  --skip-baseline           Skip the baseline test run\n\n  --help, -h                Show this help\n  --version, -V             Show version\n";
+export declare const HELP_TEXT = "Usage: mutineer <command> [options]\n\nCommands:\n  init       Create a mutineer.config.ts template\n  run        Run mutation testing\n  clean      Remove __mutineer__ temp directories\n\nOptions (run):\n  --config, -c <path>       Config file path\n  --concurrency <n>         Worker count (default: CPU count - 1)\n  --runner <vitest|jest>    Test runner (default: vitest)\n  --progress <bar|list|quiet>  Progress display (default: bar)\n  --changed                 Mutate only git-changed files\n  --changed-with-deps       Mutate changed files + their local dependencies\n  --full                    Mutate full codebase, skipping confirmation prompt\n  --only-covered-lines      Mutate only lines covered by tests\n  --per-test-coverage       Collect per-test coverage data\n  --coverage-file <path>    Path to coverage JSON\n  --min-kill-percent <n>    Minimum kill % threshold (0\u2013100)\n  --timeout <ms>            Per-mutant test timeout in ms (default: 30000)\n  --report <text|json>      Output format: text (default) or json (writes mutineer-report.json)\n  --shard <n>/<total>       Run a shard of mutants (e.g. --shard 1/4)\n  --skip-baseline           Skip the baseline test run\n  --vitest-project <name>   Filter to a specific Vitest workspace project\n  --typescript              Enable TS type-check pre-filtering\n  --no-typescript           Disable TS type-check pre-filtering\n\n  --help, -h                Show this help\n  --version, -V             Show version\n";
 export declare function getVersion(): string;
 /**
  * When running in full-codebase mode on an interactive TTY, warn the user and

package/dist/bin/mutineer.js

@@ -24,6 +24,7 @@ Options (run):
   --progress <bar|list|quiet>  Progress display (default: bar)
   --changed                 Mutate only git-changed files
   --changed-with-deps       Mutate changed files + their local dependencies
+  --full                    Mutate full codebase, skipping confirmation prompt
   --only-covered-lines      Mutate only lines covered by tests
   --per-test-coverage       Collect per-test coverage data
   --coverage-file <path>    Path to coverage JSON
@@ -32,6 +33,9 @@ Options (run):
   --report <text|json>      Output format: text (default) or json (writes mutineer-report.json)
   --shard <n>/<total>       Run a shard of mutants (e.g. --shard 1/4)
   --skip-baseline           Skip the baseline test run
+  --vitest-project <name>   Filter to a specific Vitest workspace project
+  --typescript              Enable TS type-check pre-filtering
+  --no-typescript           Disable TS type-check pre-filtering
 
   --help, -h                Show this help
   --version, -V             Show version
@@ -62,7 +66,7 @@ Warning: Running on the full codebase may take a while.
  */
 export async function confirmFullRun(args) {
     const isFullRun = !args.includes('--changed') && !args.includes('--changed-with-deps');
-    if (!isFullRun || !process.stdin.isTTY)
+    if (!isFullRun || !process.stdin.isTTY || args.includes('--full'))
         return args;
     process.stdout.write(FULL_RUN_WARNING);
     const rl = readline.createInterface({

package/dist/runner/__tests__/args.spec.js

@@ -131,6 +131,14 @@ describe('parseCliOptions', () => {
         const opts = parseCliOptions(['--changed-with-deps'], emptyCfg);
         expect(opts.wantsChangedWithDeps).toBe(true);
     });
+    it('parses --full flag', () => {
+        const opts = parseCliOptions(['--full'], emptyCfg);
+        expect(opts.wantsFull).toBe(true);
+    });
+    it('wantsFull defaults to false', () => {
+        const opts = parseCliOptions([], emptyCfg);
+        expect(opts.wantsFull).toBe(false);
+    });
     it('parses --only-covered-lines flag', () => {
         const opts = parseCliOptions(['--only-covered-lines'], emptyCfg);
         expect(opts.wantsOnlyCoveredLines).toBe(true);

package/dist/runner/__tests__/coverage-resolver.spec.js

@@ -8,6 +8,7 @@ function makeOpts(overrides = {}) {
         configPath: undefined,
         wantsChanged: false,
         wantsChangedWithDeps: false,
+        wantsFull: false,
         wantsOnlyCoveredLines: false,
         wantsPerTestCoverage: false,
         coverageFilePath: undefined,

package/dist/runner/__tests__/orchestrator.spec.js

@@ -62,9 +62,7 @@ vi.mock('../ts-checker.js', () => ({
     resolveTsconfigPath: vi.fn().mockReturnValue(undefined),
 }));
 vi.mock('../../core/schemata.js', () => ({
-    generateSchema: vi
-        .fn()
-        .mockReturnValue({
+    generateSchema: vi.fn().mockReturnValue({
         schemaCode: '// @ts-nocheck\n',
         fallbackIds: new Set(),
     }),
@@ -334,6 +332,40 @@ describe('runOrchestrator shard filtering', () => {
         expect(call.shard).toEqual({ index: 1, total: 4 });
     });
 });
+describe('runOrchestrator target ordering', () => {
+    const testFile = '/cwd/src/__tests__/foo.spec.ts';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        process.exitCode = undefined;
+        vi.mocked(createVitestAdapter).mockReturnValue(mockAdapter);
+        // No explicit targets -- use auto-discovery
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        vi.mocked(mockAdapter.runBaseline).mockResolvedValue(true);
+        vi.mocked(enumerateAllVariants).mockResolvedValue([]);
+        vi.mocked(prepareTasks).mockReturnValue([]);
+    });
+    afterEach(() => {
+        process.exitCode = undefined;
+    });
+    it('sorts auto-discovered targets alphabetically before enumeration', async () => {
+        const fileA = '/cwd/src/aaa.ts';
+        const fileB = '/cwd/src/bbb.ts';
+        const fileC = '/cwd/src/ccc.ts';
+        // Return targets in reverse-alphabetical order (simulating non-deterministic fs)
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [fileC, fileA, fileB],
+            testMap: new Map([
+                [fileA, new Set([testFile])],
+                [fileB, new Set([testFile])],
+                [fileC, new Set([testFile])],
+            ]),
+            directTestMap: new Map(),
+        });
+        await runOrchestrator([], '/cwd');
+        const call = vi.mocked(enumerateAllVariants).mock.calls[0][0];
+        expect(call.targets).toEqual([fileA, fileB, fileC]);
+    });
+});
 describe('runOrchestrator --skip-baseline', () => {
     const targetFile = '/cwd/src/foo.ts';
     const testFile = '/cwd/src/__tests__/foo.spec.ts';

package/dist/runner/args.d.ts

@@ -12,6 +12,7 @@ export interface ParsedCliOptions {
     readonly configPath: string | undefined;
     readonly wantsChanged: boolean;
     readonly wantsChangedWithDeps: boolean;
+    readonly wantsFull: boolean;
     readonly wantsOnlyCoveredLines: boolean;
     readonly wantsPerTestCoverage: boolean;
     readonly coverageFilePath: string | undefined;

package/dist/runner/args.js

@@ -134,6 +134,7 @@ export function parseCliOptions(args, cfg) {
     const configPath = readStringFlag(args, '--config', '-c');
     const wantsChanged = args.includes('--changed');
     const wantsChangedWithDeps = args.includes('--changed-with-deps');
+    const wantsFull = args.includes('--full');
     const wantsOnlyCoveredLines = args.includes('--only-covered-lines') || cfg.onlyCoveredLines === true;
     const wantsPerTestCoverage = args.includes('--per-test-coverage') || cfg.perTestCoverage === true;
     const coverageFilePath = readStringFlag(args, '--coverage-file') ?? cfg.coverageFile;
@@ -163,6 +164,7 @@ export function parseCliOptions(args, cfg) {
         configPath,
         wantsChanged,
         wantsChangedWithDeps,
+        wantsFull,
         wantsOnlyCoveredLines,
         wantsPerTestCoverage,
         coverageFilePath,

package/dist/runner/jest/__tests__/adapter.spec.js

@@ -61,6 +61,55 @@ describe('Jest adapter', () => {
         expect(args.coverageProvider).toBe('v8');
         expect(args.config).toBe('jest.config.ts');
     });
+    it('does not write captured output to stdout/stderr on success', async () => {
+        const adapter = makeAdapter();
+        const stdoutWrite = vi.spyOn(process.stdout, 'write').mockReturnValue(true);
+        const stderrWrite = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
+        runCLIMock.mockResolvedValueOnce({ results: { success: true } });
+        const ok = await adapter.runBaseline(['test-a'], {
+            collectCoverage: false,
+            perTestCoverage: false,
+        });
+        expect(ok).toBe(true);
+        // No output should be replayed on success
+        expect(stdoutWrite).not.toHaveBeenCalled();
+        expect(stderrWrite).not.toHaveBeenCalled();
+        stdoutWrite.mockRestore();
+        stderrWrite.mockRestore();
+    });
+    it('replays captured output to stdout/stderr on failure', async () => {
+        const adapter = makeAdapter();
+        // Spy before runBaseline so adapter's origStdoutWrite/origStderrWrite bind to the spy.
+        // runCLI writes during capture are suppressed; the spy sees only the replay after restore.
+        const writtenStdout = [];
+        const writtenStderr = [];
+        const stdoutSpy = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation((chunk) => {
+            writtenStdout.push(Buffer.isBuffer(chunk) ? chunk.toString() : String(chunk));
+            return true;
+        });
+        const stderrSpy = vi
+            .spyOn(process.stderr, 'write')
+            .mockImplementation((chunk) => {
+            writtenStderr.push(Buffer.isBuffer(chunk) ? chunk.toString() : String(chunk));
+            return true;
+        });
+        runCLIMock.mockImplementationOnce(async () => {
+            process.stdout.write('jest stdout output');
+            process.stderr.write('jest stderr output');
+            return { results: { success: false } };
+        });
+        const ok = await adapter.runBaseline(['test-a'], {
+            collectCoverage: false,
+            perTestCoverage: false,
+        });
+        expect(ok).toBe(false);
+        expect(writtenStdout.join('')).toContain('jest stdout output');
+        expect(writtenStderr.join('')).toContain('jest stderr output');
+        stdoutSpy.mockRestore();
+        stderrSpy.mockRestore();
+    });
     it('maps pool result to mutant status', async () => {
         const adapter = makeAdapter();
         await adapter.init();

package/dist/runner/jest/adapter.js

@@ -27,12 +27,14 @@ function stripMutineerArgs(args) {
         '-c',
         '--coverage-file',
         '--runner',
+        '--report',
     ]);
     const dropExact = new Set([
         '-m',
         '--mutate',
         '--changed',
         '--changed-with-deps',
+        '--full',
         '--only-covered-lines',
         '--per-test-coverage',
         '--perTestCoverage',
@@ -108,16 +110,43 @@ export class JestAdapter {
             ? 'baseline-with-coverage'
             : 'baseline';
         const cliOptions = buildJestCliOptions(tests, mode, this.jestConfigPath);
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        const origStdoutWrite = process.stdout.write.bind(process.stdout);
+        const origStderrWrite = process.stderr.write.bind(process.stderr);
+        // Temporarily capture stdout/stderr so Jest output is suppressed during baseline;
+        // captured output is replayed below on failure.
+        const makeCapture = (chunks) => function (chunk, encodingOrCb, cb) {
+            chunks.push(Buffer.isBuffer(chunk)
+                ? Buffer.from(chunk)
+                : Buffer.from(chunk));
+            const callback = (typeof encodingOrCb === 'function' ? encodingOrCb : cb);
+            callback?.();
+            return true;
+        };
+        process.stdout.write = makeCapture(stdoutChunks);
+        process.stderr.write = makeCapture(stderrChunks);
+        let success = false;
         try {
             const { runCLI } = await loadRunCLI(this.requireFromCwd);
             const { results } = await runCLI(cliOptions, [this.options.cwd]);
-            return results.success;
+            success = results.success;
         }
         catch (err) {
             log.debug('Failed to run Jest baseline: ' +
                 (err instanceof Error ? err.message : String(err)));
-            return false;
         }
+        finally {
+            process.stdout.write = origStdoutWrite;
+            process.stderr.write = origStderrWrite;
+        }
+        if (!success) {
+            if (stdoutChunks.length)
+                process.stdout.write(Buffer.concat(stdoutChunks));
+            if (stderrChunks.length)
+                process.stderr.write(Buffer.concat(stderrChunks));
+        }
+        return success;
     }
     async runMutant(mutant, tests) {
         if (!this.pool) {

package/dist/runner/orchestrator.js

@@ -85,6 +85,7 @@ export async function runOrchestrator(cliArgs, cwd) {
         : (cfg.autoDiscover ?? true)
             ? discovered.targets
             : [];
+    targets.sort((a, b) => getTargetFile(a).localeCompare(getTargetFile(b)));
     // Collect all test files for baseline run
     const allTestFiles = new Set();
     for (const target of targets) {
@@ -124,11 +125,24 @@ export async function runOrchestrator(cliArgs, cwd) {
         log.info('Skipping baseline tests (--skip-baseline)');
     }
     else {
-        log.info(`Running ${baselineTests.length} baseline tests${coverage.enableCoverageForBaseline ? ' (collecting coverage)' : ''}\u2026`);
-        const baselineOk = await adapter.runBaseline(baselineTests, {
-            collectCoverage: coverage.enableCoverageForBaseline,
-            perTestCoverage: coverage.wantsPerTestCoverage,
-        });
+        const baselineMsg = `Running ${baselineTests.length} baseline tests${coverage.enableCoverageForBaseline ? ' (collecting coverage)' : ''}\u2026`;
+        let baselineSpinner = null;
+        if (process.stderr.isTTY) {
+            baselineSpinner = render(createElement(PoolSpinner, { message: baselineMsg }), { stdout: process.stderr, stderr: process.stderr });
+        }
+        else {
+            log.info(baselineMsg);
+        }
+        let baselineOk;
+        try {
+            baselineOk = await adapter.runBaseline(baselineTests, {
+                collectCoverage: coverage.enableCoverageForBaseline,
+                perTestCoverage: coverage.wantsPerTestCoverage,
+            });
+        }
+        finally {
+            baselineSpinner?.unmount();
+        }
         if (!baselineOk) {
             process.exitCode = 1;
             return;

package/dist/runner/pool-executor.js

@@ -7,7 +7,6 @@ import { computeSummary, printSummary, buildJsonReport, } from '../utils/summary
 import { saveCacheAtomic } from './cache.js';
 import { cleanupMutineerDirs } from './cleanup.js';
 import { PoolSpinner } from '../utils/PoolSpinner.js';
-import { CompileErrors } from '../utils/CompileErrors.js';
 import { createLogger } from '../utils/logger.js';
 const log = createLogger('pool-executor');
 /**
@@ -24,7 +23,7 @@ export async function executePool(opts) {
     const mutationStartTime = Date.now();
     // Ensure we only finish once
     let finished = false;
-    const finishOnce = async (interactive = true) => {
+    const finishOnce = async () => {
         if (finished)
             return;
         finished = true;
@@ -41,15 +40,7 @@ export async function executePool(opts) {
             log.info(`JSON report written to ${path.relative(process.cwd(), outPath)}`);
         }
         else {
-            const compileErrorEntries = Object.values(cache).filter((e) => e.status === 'compile-error');
-            const useInteractive = interactive && process.stdout.isTTY && compileErrorEntries.length > 0;
-            printSummary(summary, cache, durationMs, {
-                skipCompileErrors: useInteractive,
-            });
-            if (useInteractive) {
-                const { waitUntilExit } = render(createElement(CompileErrors, { entries: compileErrorEntries, cwd }));
-                await waitUntilExit();
-            }
+            printSummary(summary, cache, durationMs);
         }
         if (opts.minKillPercent !== undefined) {
             const killRateString = summary.killRate.toFixed(2);
@@ -151,6 +142,10 @@ export async function executePool(opts) {
                 (directTests ?? tests).length > 0 && {
                 coveringTests: directTests ?? tests,
             }),
+            ...(status === 'escaped' &&
+                result.passingTests?.length && {
+                passingTests: result.passingTests,
+            }),
         };
         progress.update(status);
     }
@@ -170,7 +165,7 @@ export async function executePool(opts) {
             return;
         signalCleanedUp = true;
         log.info(`\nReceived ${signal}, cleaning up...`);
-        await finishOnce(false);
+        await finishOnce();
         await adapter.shutdown();
         await cleanupMutineerDirs(cwd);
         process.exit(1);

package/dist/runner/vitest/__tests__/adapter.spec.js

@@ -56,6 +56,30 @@ describe('Vitest adapter', () => {
         const res = await adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
         expect(res).toEqual({ status: 'killed', durationMs: 10, error: undefined });
     });
+    it('includes passingTests in escaped result', async () => {
+        const adapter = makeAdapter();
+        await adapter.init();
+        poolInstance.run.mockResolvedValueOnce({
+            killed: false,
+            durationMs: 8,
+            passingTests: ['Suite > test one', 'Suite > test two'],
+        });
+        const res = await adapter.runMutant({ id: '2', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
+        expect(res.status).toBe('escaped');
+        expect(res.passingTests).toEqual(['Suite > test one', 'Suite > test two']);
+    });
+    it('omits passingTests for killed mutants', async () => {
+        const adapter = makeAdapter();
+        await adapter.init();
+        poolInstance.run.mockResolvedValueOnce({
+            killed: true,
+            durationMs: 5,
+            passingTests: ['should not appear'],
+        });
+        const res = await adapter.runMutant({ id: '3', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
+        expect(res.status).toBe('killed');
+        expect(res.passingTests).toBeUndefined();
+    });
     it('maps pool timeout errors to timeout status', async () => {
         const adapter = makeAdapter();
         await adapter.init();
@@ -137,6 +161,92 @@ describe('Vitest adapter', () => {
         const args = spawnMock.mock.calls[0][1];
         expect(args.join(' ')).not.toContain('--shard');
     });
+    it('strips --report flag and value from vitest args', async () => {
+        const adapter = makeAdapter({ cliArgs: ['--report', 'json'] });
+        spawnMock.mockImplementationOnce(() => ({
+            on: (evt, cb) => {
+                if (evt === 'exit')
+                    cb(0);
+            },
+        }));
+        await adapter.runBaseline(['test-a'], {
+            collectCoverage: false,
+            perTestCoverage: false,
+        });
+        const args = spawnMock.mock.calls[0][1];
+        expect(args.join(' ')).not.toContain('--report');
+        expect(args.join(' ')).not.toContain('json');
+    });
+    it('does not write captured output to stdout/stderr on success', async () => {
+        const adapter = makeAdapter({ cliArgs: [] });
+        const stdoutWrite = vi.spyOn(process.stdout, 'write').mockReturnValue(true);
+        const stderrWrite = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
+        const listeners = {};
+        spawnMock.mockImplementationOnce(() => ({
+            stdout: {
+                on: (evt, cb) => {
+                    ;
+                    (listeners[`stdout:${evt}`] ??= []).push(cb);
+                },
+            },
+            stderr: {
+                on: (evt, cb) => {
+                    ;
+                    (listeners[`stderr:${evt}`] ??= []).push(cb);
+                },
+            },
+            on: (evt, cb) => {
+                if (evt === 'exit')
+                    cb(0);
+            },
+        }));
+        const ok = await adapter.runBaseline(['test-a'], {
+            collectCoverage: false,
+            perTestCoverage: false,
+        });
+        expect(ok).toBe(true);
+        expect(stdoutWrite).not.toHaveBeenCalled();
+        expect(stderrWrite).not.toHaveBeenCalled();
+        stdoutWrite.mockRestore();
+        stderrWrite.mockRestore();
+    });
+    it('replays captured output to stdout/stderr on failure', async () => {
+        const adapter = makeAdapter({ cliArgs: [] });
+        const stdoutWrite = vi.spyOn(process.stdout, 'write').mockReturnValue(true);
+        const stderrWrite = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
+        const stdoutListeners = [];
+        const stderrListeners = [];
+        spawnMock.mockImplementationOnce(() => ({
+            stdout: {
+                on: (evt, cb) => {
+                    if (evt === 'data')
+                        stdoutListeners.push(cb);
+                },
+            },
+            stderr: {
+                on: (evt, cb) => {
+                    if (evt === 'data')
+                        stderrListeners.push(cb);
+                },
+            },
+            on: (evt, cb) => {
+                if (evt === 'exit') {
+                    stdoutListeners.forEach((l) => l(Buffer.from('stdout output')));
+                    stderrListeners.forEach((l) => l(Buffer.from('stderr output')));
+                    cb(1);
+                }
+            },
+        }));
+        const ok = await adapter.runBaseline(['test-a'], {
+            collectCoverage: false,
+            perTestCoverage: false,
+        });
+        expect(ok).toBe(false);
+        expect(stdoutWrite).toHaveBeenCalledWith(Buffer.from('stdout output'));
+        expect(stderrWrite).toHaveBeenCalledWith(Buffer.from('stderr output'));
+        stdoutWrite.mockRestore();
+        stderrWrite.mockRestore();
+    });
     it('detects coverage config from vitest config file', async () => {
         const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-vitest-'));
         const cfgPath = path.join(tmp, 'vitest.config.ts');

package/dist/runner/vitest/__tests__/pool.spec.js

@@ -245,4 +245,41 @@ describe('VitestPool', () => {
         expect(killSpy).toHaveBeenCalledWith(-42000, 'SIGKILL');
         killSpy.mockRestore();
     });
+    it('threads passingTests from WorkerMessage through to MutantRunSummary', async () => {
+        const pool = new VitestPool({
+            cwd: process.cwd(),
+            concurrency: 1,
+            timeoutMs: 5000,
+            createWorker: (id) => {
+                const worker = new EventEmitter();
+                worker.id = id;
+                worker.start = vi.fn().mockResolvedValue(undefined);
+                worker.isReady = vi.fn().mockReturnValue(true);
+                worker.isBusy = vi.fn().mockReturnValue(false);
+                worker.run = vi.fn().mockResolvedValue({
+                    killed: false,
+                    durationMs: 10,
+                    passingTests: ['Suite > test one', 'Suite > test two'],
+                });
+                worker.shutdown = vi.fn().mockResolvedValue(undefined);
+                worker.kill = vi.fn();
+                return worker;
+            },
+        });
+        await pool.init();
+        const mutant = {
+            id: 'pt1',
+            name: 'mutant',
+            file: 'foo.ts',
+            code: 'x',
+            line: 1,
+            col: 1,
+        };
+        const result = await pool.run(mutant, ['foo.spec.ts']);
+        expect(result.passingTests).toEqual([
+            'Suite > test one',
+            'Suite > test two',
+        ]);
+        await pool.shutdown();
+    });
 });

package/dist/runner/vitest/__tests__/worker-runtime.spec.js

@@ -125,6 +125,66 @@ describe('VitestWorkerRuntime', () => {
         expect(result.error).toBe('string error');
         await runtime.shutdown();
     });
+    it('collects passingTests fullNames from modules when mutant escapes', async () => {
+        const makeModule = (moduleId, names) => ({
+            moduleId,
+            ok: () => true,
+            children: {
+                allTests: (_state) => names.map((n) => ({ fullName: n })),
+            },
+        });
+        runSpecsFn.mockResolvedValue({
+            testModules: [
+                makeModule(path.join(os.tmpdir(), 'test.ts'), [
+                    'Math > adds',
+                    'Math > subtracts',
+                ]),
+            ],
+        });
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-pt-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({ workerId: 'w-pt', cwd: tmp });
+        await runtime.init();
+        const result = await runtime.run({
+            id: 'mut#pt',
+            name: 'm',
+            file: path.join(tmp, 'src.ts'),
+            code: 'export const x=1',
+            line: 1,
+            col: 1,
+        }, [path.join(os.tmpdir(), 'test.ts')]);
+        expect(result.killed).toBe(false);
+        expect(result.passingTests).toEqual(['Math > adds', 'Math > subtracts']);
+        await runtime.shutdown();
+    });
+    it('omits passingTests when mutant is killed', async () => {
+        runSpecsFn.mockResolvedValue({
+            testModules: [
+                {
+                    moduleId: path.join(os.tmpdir(), 'test.ts'),
+                    ok: () => false,
+                    children: {
+                        allTests: (_state) => [{ fullName: 'Math > adds' }],
+                    },
+                },
+            ],
+        });
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-kpt-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({ workerId: 'w-kpt', cwd: tmp });
+        await runtime.init();
+        const result = await runtime.run({
+            id: 'mut#kpt',
+            name: 'm',
+            file: path.join(tmp, 'src.ts'),
+            code: 'export const x=1',
+            line: 1,
+            col: 1,
+        }, [path.join(os.tmpdir(), 'test.ts')]);
+        expect(result.killed).toBe(true);
+        expect(result.passingTests).toBeUndefined();
+        await runtime.shutdown();
+    });
     it('falls back to all testModules when no relevant modules match', async () => {
         runSpecsFn.mockResolvedValue({
             testModules: [{ moduleId: 'unknown-module', ok: () => true }],

package/dist/runner/vitest/adapter.js

@@ -38,12 +38,14 @@ function stripMutineerArgs(args) {
         '-c',
         '--coverage-file',
         '--shard',
+        '--report',
     ]);
     const dropExact = new Set([
         '-m',
         '--mutate',
         '--changed',
         '--changed-with-deps',
+        '--full',
         '--only-covered-lines',
         '--per-test-coverage',
         '--perTestCoverage',
@@ -147,14 +149,24 @@ export class VitestAdapter {
                 env.CI = '1';
             const child = spawn(process.execPath, [this.vitestPath, ...args, ...tests], {
                 cwd: this.options.cwd,
-                stdio: ['ignore', 'inherit', 'inherit'],
+                stdio: ['ignore', 'pipe', 'pipe'],
                 env,
             });
+            const stdoutChunks = [];
+            const stderrChunks = [];
+            child.stdout?.on('data', (chunk) => stdoutChunks.push(chunk));
+            child.stderr?.on('data', (chunk) => stderrChunks.push(chunk));
             child.on('error', (err) => {
                 log.debug('Failed to spawn vitest process: ' + err.message);
                 resolve(false);
             });
             child.on('exit', (code) => {
+                if (code !== 0) {
+                    if (stdoutChunks.length)
+                        process.stdout.write(Buffer.concat(stdoutChunks));
+                    if (stderrChunks.length)
+                        process.stderr.write(Buffer.concat(stderrChunks));
+                }
                 resolve(code === 0);
             });
         });
@@ -179,10 +191,15 @@ export class VitestAdapter {
                     error: result.error,
                 };
             }
+            const status = result.killed ? 'killed' : 'escaped';
             return {
-                status: result.killed ? 'killed' : 'escaped',
+                status,
                 durationMs: result.durationMs,
                 error: result.error,
+                ...(!result.killed &&
+                    result.passingTests && {
+                    passingTests: result.passingTests,
+                }),
             };
         }
         catch (err) {

package/dist/runner/vitest/pool.js

@@ -150,6 +150,7 @@ class VitestWorker extends EventEmitter {
                     killed: msg.killed ?? true,
                     durationMs: msg.durationMs ?? 0,
                     error: msg.error,
+                    ...(msg.passingTests && { passingTests: msg.passingTests }),
                 });
             }
             return;

package/dist/runner/vitest/worker-runtime.js

@@ -105,9 +105,23 @@ export class VitestWorkerRuntime {
                 ? relevantModules
                 : results.testModules;
             const killed = modulesForDecision.some((mod) => !mod.ok());
+            const passingTests = [];
+            if (!killed) {
+                for (const mod of modulesForDecision) {
+                    try {
+                        for (const tc of mod.children?.allTests('passed') ?? []) {
+                            passingTests.push(tc.fullName);
+                        }
+                    }
+                    catch {
+                        // allTests API unavailable in this Vitest version
+                    }
+                }
+            }
             return {
                 killed,
                 durationMs: Date.now() - start,
+                ...(passingTests.length > 0 && { passingTests }),
             };
         }
         catch (err) {

package/dist/runner/vitest/worker.mjs

@@ -82,6 +82,7 @@ async function main() {
                     killed: result.killed,
                     durationMs: result.durationMs,
                     error: result.error,
+                    ...(result.passingTests && { passingTests: result.passingTests }),
                 });
             }
             catch (err) {

package/dist/types/mutant.d.ts

@@ -31,6 +31,7 @@ export interface MutantCacheEntry extends MutantLocation {
     readonly originalSnippet?: string;
     readonly mutatedSnippet?: string;
     readonly coveringTests?: readonly string[];
+    readonly passingTests?: readonly string[];
 }
 export interface MutantResult extends MutantCacheEntry {
     readonly id: string;
@@ -41,10 +42,12 @@ export interface MutantRunSummary {
     readonly killed: boolean;
     readonly durationMs: number;
     readonly error?: string;
+    readonly passingTests?: readonly string[];
 }
 /** Normalised result returned by adapters/orchestrator. */
 export interface MutantRunResult {
     readonly status: MutantRunStatus;
     readonly durationMs: number;
     readonly error?: string;
+    readonly passingTests?: readonly string[];
 }

package/dist/utils/__tests__/summary.spec.js

@@ -123,6 +123,25 @@ describe('summary', () => {
         expect(lines.some((l) => l.includes('foo.spec.ts'))).toBe(true);
         logSpy.mockRestore();
     });
+    it('buildJsonReport includes passingTests when present', () => {
+        const cache = {
+            a: makeEntry({
+                status: 'escaped',
+                file: '/tmp/a.ts',
+                mutator: 'flip',
+                passingTests: ['Suite > test one'],
+            }),
+        };
+        const summary = computeSummary(cache);
+        const report = buildJsonReport(summary, cache);
+        expect(report.mutants[0].passingTests).toEqual(['Suite > test one']);
+    });
+    it('buildJsonReport omits passingTests when absent', () => {
+        const cache = { a: makeEntry({ status: 'escaped' }) };
+        const summary = computeSummary(cache);
+        const report = buildJsonReport(summary, cache);
+        expect('passingTests' in report.mutants[0]).toBe(false);
+    });
     it('does not print covering tests when array is absent', () => {
         const cache = {
             a: makeEntry({ status: 'escaped' }),
@@ -176,49 +195,13 @@ describe('summary', () => {
         expect('originalSnippet' in report.mutants[0]).toBe(false);
         expect('coveringTests' in report.mutants[0]).toBe(false);
     });
-    it('prints compile error mutants section by default', () => {
-        const cache = {
-            a: makeEntry({
-                status: 'compile-error',
-                file: '/tmp/a.ts',
-                mutator: 'returnToNull',
-            }),
-        };
+    it('prints report hint line', () => {
+        const cache = { a: makeEntry({ status: 'killed' }) };
         const summary = computeSummary(cache);
         const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
         printSummary(summary, cache);
         const lines = logSpy.mock.calls.map((c) => stripAnsi(c.join(' ')));
-        expect(lines.some((l) => l.includes('Compile Error Mutants'))).toBe(true);
-        logSpy.mockRestore();
-    });
-    it('skips compile error section when skipCompileErrors is true', () => {
-        const cache = {
-            a: makeEntry({
-                status: 'compile-error',
-                file: '/tmp/a.ts',
-                mutator: 'returnToNull',
-            }),
-        };
-        const summary = computeSummary(cache);
-        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-        printSummary(summary, cache, undefined, { skipCompileErrors: true });
-        const lines = logSpy.mock.calls.map((c) => stripAnsi(c.join(' ')));
-        expect(lines.some((l) => l.includes('Compile Error Mutants'))).toBe(false);
-        logSpy.mockRestore();
-    });
-    it('shows compile error section when skipCompileErrors is false', () => {
-        const cache = {
-            a: makeEntry({
-                status: 'compile-error',
-                file: '/tmp/a.ts',
-                mutator: 'returnToNull',
-            }),
-        };
-        const summary = computeSummary(cache);
-        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-        printSummary(summary, cache, undefined, { skipCompileErrors: false });
-        const lines = logSpy.mock.calls.map((c) => stripAnsi(c.join(' ')));
-        expect(lines.some((l) => l.includes('Compile Error Mutants'))).toBe(true);
+        expect(lines.some((l) => l.includes('Run with --report json to see full mutation details.'))).toBe(true);
         logSpy.mockRestore();
     });
     it('summarise returns summary and prints', () => {

package/dist/utils/summary.d.ts

@@ -10,9 +10,7 @@ export interface Summary {
     readonly killRate: number;
 }
 export declare function computeSummary(cache: Readonly<Record<string, MutantCacheEntry>>): Summary;
-export declare function printSummary(summary: Summary, cache?: Readonly<Record<string, MutantCacheEntry>>, durationMs?: number, opts?: {
-    skipCompileErrors?: boolean;
-}): void;
+export declare function printSummary(summary: Summary, cache?: Readonly<Record<string, MutantCacheEntry>>, durationMs?: number): void;
 export interface JsonMutant {
     readonly file: string;
     readonly line: number;
@@ -22,6 +20,7 @@ export interface JsonMutant {
     readonly originalSnippet?: string;
     readonly mutatedSnippet?: string;
     readonly coveringTests?: readonly string[];
+    readonly passingTests?: readonly string[];
 }
 export interface JsonReport {
     readonly schemaVersion: 1;

package/dist/utils/summary.js

@@ -44,7 +44,7 @@ function formatDuration(ms) {
     const remainingSeconds = seconds % 60;
     return `${minutes}m ${remainingSeconds.toFixed(1)}s`;
 }
-export function printSummary(summary, cache, durationMs, opts) {
+export function printSummary(summary, cache, durationMs) {
     console.log('\n' + chalk.dim(SEPARATOR));
     console.log(chalk.bold(' Mutineer Test Suite Summary'));
     console.log(chalk.dim(SEPARATOR));
@@ -113,11 +113,6 @@ export function printSummary(summary, cache, durationMs, opts) {
             }
         }
     }
-    if (entriesByStatus.compileErrors.length && !opts?.skipCompileErrors) {
-        console.log('\n' + chalk.dim('Compile Error Mutants (type-filtered):'));
-        for (const entry of entriesByStatus.compileErrors)
-            console.log('  ' + formatRow(entry));
-    }
     if (entriesByStatus.timeouts.length) {
         console.log('\n' + chalk.yellow.bold('Timed Out Mutants:'));
         for (const entry of entriesByStatus.timeouts)
@@ -148,6 +143,7 @@ export function printSummary(summary, cache, durationMs, opts) {
     if (durationMs !== undefined) {
         console.log(`Duration: ${chalk.cyan(formatDuration(durationMs))}`);
     }
+    console.log(chalk.dim('Run with --report json to see full mutation details.'));
     console.log(chalk.dim(SEPARATOR) + '\n');
 }
 export function buildJsonReport(summary, cache, durationMs) {
@@ -166,6 +162,9 @@ export function buildJsonReport(summary, cache, durationMs) {
         ...(entry.coveringTests !== undefined && {
             coveringTests: entry.coveringTests,
         }),
+        ...(entry.passingTests !== undefined && {
+            passingTests: entry.passingTests,
+        }),
     }));
     return {
         schemaVersion: 1,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mutineerjs/mutineer",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "A fast, targeted mutation testing framework for JavaScript and TypeScript",
   "type": "module",
   "private": false,

package/dist/utils/CompileErrors.d.ts

@@ -1,7 +0,0 @@
-import type { MutantCacheEntry } from '../types/mutant.js';
-interface Props {
-    entries: MutantCacheEntry[];
-    cwd: string;
-}
-export declare function CompileErrors({ entries, cwd }: Props): import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/utils/CompileErrors.js

@@ -1,24 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import path from 'node:path';
-import { Box, Text, useInput, useApp } from 'ink';
-import { useState, useEffect } from 'react';
-export function CompileErrors({ entries, cwd }) {
-    const { exit } = useApp();
-    const [expanded, setExpanded] = useState(false);
-    useEffect(() => {
-        if (expanded)
-            exit();
-    }, [expanded, exit]);
-    useInput((input, key) => {
-        if (input === 'e') {
-            setExpanded(true);
-        }
-        else if (key.return || input === 'q') {
-            exit();
-        }
-    });
-    if (expanded) {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Compile Error Mutants (type-filtered):" }), entries.map((entry, i) => (_jsxs(Text, { dimColor: true, children: ['  \u2022 ', path.relative(cwd, entry.file), "@", entry.line, ",", entry.col, '  ', entry.mutator] }, i)))] }));
-    }
-    return (_jsxs(Box, { gap: 2, children: [_jsxs(Text, { dimColor: true, children: ["Compile Error Mutants (type-filtered): ", entries.length] }), _jsx(Text, { dimColor: true, children: "e expand  return skip" })] }));
-}

package/dist/utils/__tests__/CompileErrors.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/__tests__/CompileErrors.spec.js

@@ -1,96 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-const mockExit = vi.fn();
-const mockSetExpanded = vi.fn();
-let inputHandler;
-let effectCallback;
-vi.mock('ink', () => ({
-    Box: ({ children }) => children,
-    Text: ({ children }) => children,
-    useInput: vi.fn((fn) => {
-        inputHandler = fn;
-    }),
-    useApp: () => ({ exit: mockExit }),
-}));
-vi.mock('react', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        useState: vi.fn((init) => [init, mockSetExpanded]),
-        useEffect: vi.fn((fn) => {
-            effectCallback = fn;
-        }),
-    };
-});
-import { CompileErrors } from '../CompileErrors.js';
-import { useState } from 'react';
-const entries = [
-    {
-        status: 'compile-error',
-        file: '/cwd/src/foo.ts',
-        line: 10,
-        col: 5,
-        mutator: 'returnToNull',
-    },
-    {
-        status: 'compile-error',
-        file: '/cwd/src/bar.ts',
-        line: 20,
-        col: 3,
-        mutator: 'returnFlipBool',
-    },
-];
-describe('CompileErrors', () => {
-    beforeEach(() => {
-        mockExit.mockClear();
-        mockSetExpanded.mockClear();
-        inputHandler = undefined;
-        effectCallback = undefined;
-        vi.mocked(useState).mockImplementation(((init) => [
-            init,
-            mockSetExpanded,
-        ]));
-    });
-    it('registers a useInput handler on render', () => {
-        CompileErrors({ entries, cwd: '/cwd' });
-        expect(inputHandler).toBeDefined();
-    });
-    it('calls setExpanded(true) when "e" is pressed', () => {
-        CompileErrors({ entries, cwd: '/cwd' });
-        inputHandler('e', { return: false });
-        expect(mockSetExpanded).toHaveBeenCalledWith(true);
-    });
-    it('calls exit() when return is pressed', () => {
-        CompileErrors({ entries, cwd: '/cwd' });
-        inputHandler('', { return: true });
-        expect(mockExit).toHaveBeenCalled();
-    });
-    it('calls exit() when "q" is pressed', () => {
-        CompileErrors({ entries, cwd: '/cwd' });
-        inputHandler('q', { return: false });
-        expect(mockExit).toHaveBeenCalled();
-    });
-    it('does not call exit() or setExpanded for other keys', () => {
-        CompileErrors({ entries, cwd: '/cwd' });
-        inputHandler('x', { return: false });
-        expect(mockExit).not.toHaveBeenCalled();
-        expect(mockSetExpanded).not.toHaveBeenCalled();
-    });
-    it('registers a useEffect handler on render', () => {
-        CompileErrors({ entries, cwd: '/cwd' });
-        expect(effectCallback).toBeDefined();
-    });
-    it('useEffect calls exit() when expanded is true', () => {
-        vi.mocked(useState).mockReturnValueOnce([
-            true,
-            mockSetExpanded,
-        ]);
-        CompileErrors({ entries, cwd: '/cwd' });
-        effectCallback();
-        expect(mockExit).toHaveBeenCalled();
-    });
-    it('useEffect does not call exit() when expanded is false', () => {
-        CompileErrors({ entries, cwd: '/cwd' });
-        effectCallback();
-        expect(mockExit).not.toHaveBeenCalled();
-    });
-});