@mutineerjs/mutineer 0.7.0 → 0.8.0

package/dist/runner/vitest/plugin.js

@@ -7,22 +7,41 @@
  *
  * The worker process sets globalThis.__mutineer_redirect__ before each test run,
  * and this plugin intercepts module loading to return the mutated code.
+ *
+ * For schema-eligible variants, the plugin serves a pre-built schema file that
+ * embeds all mutations as ternary chains keyed by globalThis.__mutineer_active_id__.
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { getRedirect } from '../shared/index.js';
+import { getRedirect, getSchemaFilePath } from '../shared/index.js';
 import { createLogger } from '../../utils/logger.js';
 const log = createLogger('mutineer:swap');
 export function poolMutineerPlugin() {
+    // Cache schema file contents keyed by normalised source path.
+    // null = checked and no schema exists; string = schema code.
+    // Schema files are written once before the pool starts and never change,
+    // so this cache is always valid for the lifetime of the plugin.
+    const schemaCache = new Map();
     return {
         name: 'mutineer:swap',
         enforce: 'pre',
-        load(id) {
-            const redirect = getRedirect();
-            if (!redirect) {
+        config(config) {
+            const activeIdFile = process.env.MUTINEER_ACTIVE_ID_FILE;
+            if (!activeIdFile || !path.isAbsolute(activeIdFile))
                 return null;
-            }
-            // Normalize the module ID, handling query strings
+            const setupFile = path.join(path.dirname(activeIdFile), 'setup.mjs');
+            const testConfig = config.test;
+            const existing = testConfig?.setupFiles;
+            const existingArr = Array.isArray(existing)
+                ? existing
+                : existing
+                    ? [existing]
+                    : [];
+            return {
+                test: { setupFiles: [...existingArr, setupFile] },
+            };
+        },
+        load(id) {
             const cleanId = id.split('?')[0];
             let normalizedId;
             try {
@@ -31,18 +50,37 @@ export function poolMutineerPlugin() {
             catch {
                 return null;
             }
-            // Check if this is the file we're redirecting
-            if (normalizedId === path.resolve(redirect.from)) {
-                // Read the mutated code from the temp file
+            // Redirect takes priority: fallback mutations use setRedirect + invalidateFile.
+            // Must check redirect first so the schema file (which exists for this source)
+            // does not shadow the mutant code during fallback runs.
+            const redirect = getRedirect();
+            if (redirect && normalizedId === path.resolve(redirect.from)) {
                 try {
-                    const mutatedCode = fs.readFileSync(redirect.to, 'utf8');
-                    return mutatedCode;
+                    return fs.readFileSync(redirect.to, 'utf8');
                 }
                 catch (err) {
                     log.error(`Failed to read mutant file: ${redirect.to} ${err}`);
                     return null;
                 }
             }
+            // Schema path: serves pre-built schema file for schema-eligible variants.
+            // Use cache to avoid existsSync + readFileSync on every module import.
+            const cached = schemaCache.get(normalizedId);
+            if (cached !== undefined) {
+                return cached;
+            }
+            const schemaPath = getSchemaFilePath(normalizedId);
+            try {
+                if (fs.existsSync(schemaPath)) {
+                    const code = fs.readFileSync(schemaPath, 'utf8');
+                    schemaCache.set(normalizedId, code);
+                    return code;
+                }
+            }
+            catch {
+                // fall through
+            }
+            schemaCache.set(normalizedId, null);
             return null;
         },
     };

package/dist/runner/vitest/pool.d.ts

@@ -16,13 +16,14 @@ import type { MutantPayload, MutantRunResult, MutantRunSummary } from '../../typ
 declare class VitestWorker extends EventEmitter {
     private readonly cwd;
     private readonly vitestConfig?;
+    private readonly vitestProject?;
     readonly id: string;
     private process;
     private rl;
     private pendingTask;
     private ready;
     private shuttingDown;
-    constructor(id: string, cwd: string, vitestConfig?: string | undefined);
+    constructor(id: string, cwd: string, vitestConfig?: string | undefined, vitestProject?: string | undefined);
     start(): Promise<void>;
     private handleMessage;
     private handleExit;
@@ -36,10 +37,12 @@ export interface VitestPoolOptions {
     cwd: string;
     concurrency: number;
     vitestConfig?: string;
+    vitestProject?: string;
     timeoutMs?: number;
     createWorker?: (id: string, opts: {
         cwd: string;
         vitestConfig?: string;
+        vitestProject?: string;
     }) => VitestWorker;
 }
 export declare class VitestPool {

package/dist/runner/vitest/pool.js

@@ -17,15 +17,17 @@ import * as readline from 'node:readline';
 import * as fs from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { EventEmitter } from 'node:events';
+import { getActiveIdFilePath } from '../shared/index.js';
 import { createLogger, DEBUG } from '../../utils/logger.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const workerLog = createLogger('VitestWorker');
 const poolLog = createLogger('VitestPool');
 class VitestWorker extends EventEmitter {
-    constructor(id, cwd, vitestConfig) {
+    constructor(id, cwd, vitestConfig, vitestProject) {
         super();
         this.cwd = cwd;
         this.vitestConfig = vitestConfig;
+        this.vitestProject = vitestProject;
         this.process = null;
         this.rl = null;
         this.pendingTask = null;
@@ -54,9 +56,13 @@ class VitestWorker extends EventEmitter {
             ...process.env,
             MUTINEER_WORKER_ID: this.id,
             MUTINEER_CWD: this.cwd,
+            MUTINEER_ACTIVE_ID_FILE: getActiveIdFilePath(this.id, this.cwd),
             ...(this.vitestConfig
                 ? { MUTINEER_VITEST_CONFIG: this.vitestConfig }
                 : {}),
+            ...(this.vitestProject
+                ? { MUTINEER_VITEST_PROJECT: this.vitestProject }
+                : {}),
             ...(DEBUG ? { MUTINEER_DEBUG: '1' } : {}),
         };
         workerLog.debug(`[${this.id}] Starting worker process`);
@@ -71,6 +77,10 @@ class VitestWorker extends EventEmitter {
             cwd: this.cwd,
             env,
             stdio: ['pipe', 'pipe', 'pipe'],
+            // Create own process group so killing this process also kills its
+            // children (Vitest inner forks). Without this, SIGKILL to worker.mjs
+            // orphans the Vitest fork workers.
+            detached: true,
         });
         // Handle stderr (debug/error output)
         this.process.stderr?.on('data', (data) => {
@@ -205,8 +215,16 @@ class VitestWorker extends EventEmitter {
     }
     kill() {
         if (this.process) {
+            const pid = this.process.pid;
             try {
-                this.process.kill('SIGKILL');
+                if (pid !== undefined) {
+                    // Kill the entire process group (negative PID) so Vitest inner fork
+                    // workers die alongside worker.mjs instead of becoming orphans.
+                    process.kill(-pid, 'SIGKILL');
+                }
+                else {
+                    this.process.kill('SIGKILL');
+                }
             }
             catch {
                 // Ignore
@@ -227,6 +245,7 @@ export class VitestPool {
             cwd: options.cwd,
             concurrency: options.concurrency,
             vitestConfig: options.vitestConfig,
+            vitestProject: options.vitestProject,
             timeoutMs: options.timeoutMs ?? 10_000,
             createWorker: options.createWorker,
         };
@@ -240,8 +259,9 @@ export class VitestPool {
             const worker = this.options.createWorker?.(`w${i}`, {
                 cwd: this.options.cwd,
                 vitestConfig: this.options.vitestConfig,
+                vitestProject: this.options.vitestProject,
             }) ??
-                new VitestWorker(`w${i}`, this.options.cwd, this.options.vitestConfig);
+                new VitestWorker(`w${i}`, this.options.cwd, this.options.vitestConfig, this.options.vitestProject);
             worker.on('exit', () => {
                 if (!this.shuttingDown) {
                     this.handleWorkerExit(worker);
@@ -268,8 +288,9 @@ export class VitestPool {
         const newWorker = this.options.createWorker?.(worker.id, {
             cwd: this.options.cwd,
             vitestConfig: this.options.vitestConfig,
+            vitestProject: this.options.vitestProject,
         }) ??
-            new VitestWorker(worker.id, this.options.cwd, this.options.vitestConfig);
+            new VitestWorker(worker.id, this.options.cwd, this.options.vitestConfig, this.options.vitestProject);
         const idx = this.workers.indexOf(worker);
         if (idx >= 0) {
             this.workers[idx] = newWorker;

package/dist/runner/vitest/worker-runtime.d.ts

@@ -4,6 +4,7 @@ export interface VitestWorkerRuntimeOptions {
     workerId: string;
     cwd: string;
     vitestConfigPath?: string;
+    vitestProject?: string;
 }
 export declare class VitestWorkerRuntime {
     private readonly options;

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

@@ -5,6 +5,14 @@ import { poolMutineerPlugin } from './plugin.js';
 import { getMutantFilePath, setRedirect, clearRedirect, } from '../shared/index.js';
 import { createLogger } from '../../utils/logger.js';
 const log = createLogger('vitest-runtime');
+const SETUP_MJS_CONTENT = `import { beforeAll } from 'vitest'
+import { readFileSync } from 'node:fs'
+const _f = process.env.MUTINEER_ACTIVE_ID_FILE
+beforeAll(() => {
+  try { globalThis.__mutineer_active_id__ = readFileSync(_f, 'utf8').trim() || null }
+  catch { globalThis.__mutineer_active_id__ = null }
+})
+`;
 export class VitestWorkerRuntime {
     constructor(options) {
         this.options = options;
@@ -12,12 +20,24 @@ export class VitestWorkerRuntime {
     }
     async init() {
         try {
+            // Write setup.mjs before creating Vitest so the config hook can find it
+            const activeIdFile = process.env.MUTINEER_ACTIVE_ID_FILE;
+            if (activeIdFile && path.isAbsolute(activeIdFile)) {
+                const mutineerDir = path.dirname(activeIdFile);
+                fs.mkdirSync(mutineerDir, { recursive: true });
+                fs.writeFileSync(path.join(mutineerDir, 'setup.mjs'), SETUP_MJS_CONTENT, 'utf8');
+            }
             this.vitest = await createVitest('test', {
-                watch: true,
+                watch: false,
                 reporters: ['dot'],
                 silent: true,
                 pool: 'forks',
                 bail: 1,
+                // Limit to 1 inner fork so bail:1 stops after the first failure
+                // without spawning additional fork processes. The single fork is
+                // persistent (reused across mutant runs), eliminating per-mutant
+                // fork startup overhead.
+                maxWorkers: 1,
                 ...(this.options.vitestConfigPath
                     ? { config: this.options.vitestConfigPath }
                     : {}),
@@ -43,20 +63,29 @@ export class VitestWorkerRuntime {
             throw new Error('Vitest runtime not initialised');
         }
         const start = Date.now();
+        const activeIdFile = process.env.MUTINEER_ACTIVE_ID_FILE;
+        const useSchema = !mutant.isFallback && !!activeIdFile;
         try {
-            const mutantPath = getMutantFilePath(mutant.file, mutant.id);
-            fs.writeFileSync(mutantPath, mutant.code, 'utf8');
-            log.debug(`Wrote mutant to ${mutantPath}`);
-            setRedirect({
-                from: path.resolve(mutant.file),
-                to: mutantPath,
-            });
-            this.vitest.invalidateFile(mutant.file);
-            log.debug(`Invalidated ${mutant.file}`);
+            if (useSchema) {
+                fs.writeFileSync(activeIdFile, mutant.id, 'utf8');
+                log.debug(`Schema path: wrote active ID ${mutant.id}`);
+            }
+            else {
+                const mutantPath = getMutantFilePath(mutant.file, mutant.id);
+                fs.writeFileSync(mutantPath, mutant.code, 'utf8');
+                log.debug(`Wrote mutant to ${mutantPath}`);
+                setRedirect({
+                    from: path.resolve(mutant.file),
+                    to: mutantPath,
+                });
+                this.vitest.invalidateFile(mutant.file);
+                log.debug(`Invalidated ${mutant.file}`);
+            }
             const specs = [];
+            const projectName = this.options.vitestProject ?? '';
             for (const testFile of tests) {
                 const spec = this.vitest
-                    .getProjectByName('')
+                    .getProjectByName(projectName)
                     ?.createSpecification(testFile);
                 if (spec)
                     specs.push(spec);
@@ -68,6 +97,7 @@ export class VitestWorkerRuntime {
                 };
             }
             log.debug(`Running ${specs.length} test specs`);
+            this.vitest.state?.filesMap?.clear();
             const results = await this.vitest.runTestSpecifications(specs);
             const requestedModules = new Set(specs.map((s) => s.moduleId));
             const relevantModules = results.testModules.filter((mod) => requestedModules.has(mod.moduleId));
@@ -88,14 +118,23 @@ export class VitestWorkerRuntime {
             };
         }
         finally {
-            // Clear redirect and clean up temp file
-            const mutantPath = getMutantFilePath(mutant.file, mutant.id);
-            clearRedirect();
-            try {
-                fs.rmSync(mutantPath, { force: true });
+            if (useSchema) {
+                try {
+                    fs.writeFileSync(activeIdFile, '', 'utf8');
+                }
+                catch {
+                    // ignore
+                }
             }
-            catch {
-                // ignore
+            else {
+                clearRedirect();
+                const mutantPath = getMutantFilePath(mutant.file, mutant.id);
+                try {
+                    fs.rmSync(mutantPath, { force: true });
+                }
+                catch {
+                    // ignore
+                }
             }
         }
     }

package/dist/runner/vitest/worker.mjs

@@ -26,11 +26,13 @@ async function main() {
     const workerId = process.env.MUTINEER_WORKER_ID ?? 'unknown';
     const cwd = process.env.MUTINEER_CWD ?? process.cwd();
     const vitestConfigPath = process.env.MUTINEER_VITEST_CONFIG;
+    const vitestProject = process.env.MUTINEER_VITEST_PROJECT;
     log.debug(`Starting worker ${workerId} in ${cwd}`);
     const runtime = createVitestWorkerRuntime({
         workerId,
         cwd,
         vitestConfigPath,
+        vitestProject,
     });
     try {
         await runtime.init();
@@ -41,6 +43,14 @@ async function main() {
     }
     // Signal ready
     send({ type: 'ready', workerId });
+    // Graceful SIGTERM handler: clean up Vitest inner forks before exiting.
+    // This runs when the parent kills the process group with SIGTERM (e.g.
+    // future graceful shutdown path). Vitest forks are in the same process
+    // group so they also receive the signal, but calling close() ensures the
+    // Vitest instance is torn down cleanly.
+    process.on('SIGTERM', () => {
+        void runtime.shutdown().finally(() => process.exit(0));
+    });
     // Process requests from stdin
     const rl = readline.createInterface({
         input: process.stdin,

package/dist/types/config.d.ts

@@ -42,4 +42,18 @@ export interface MutineerConfig {
     readonly timeout?: number;
     /** Output report format: 'text' (default) or 'json' (writes mutineer-report.json) */
     readonly report?: 'text' | 'json';
+    /**
+     * Enable TypeScript type checking to pre-filter mutants that produce compile errors.
+     * true = enable (requires tsconfig.json), false = disable,
+     * object = enable with optional custom tsconfig path.
+     * Defaults to auto-detect (enabled if tsconfig.json found in cwd).
+     */
+    readonly typescript?: boolean | {
+        readonly tsconfig?: string;
+    };
+    /**
+     * Filter mutations to a specific Vitest workspace project.
+     * Requires a vitest.config.ts with test.projects configured.
+     */
+    readonly vitestProject?: string | readonly string[];
 }

package/dist/types/mutant.d.ts

@@ -4,7 +4,7 @@
  * Centralises the shapes used across the runner and adapters so we
  * don't duplicate unions or object shapes in multiple modules.
  */
-export type MutantStatus = 'killed' | 'escaped' | 'skipped' | 'error' | 'timeout';
+export type MutantStatus = 'killed' | 'escaped' | 'skipped' | 'error' | 'timeout' | 'compile-error';
 export type MutantRunStatus = MutantStatus;
 export interface MutantLocation {
     readonly file: string;
@@ -17,7 +17,10 @@ export interface MutantDescriptor extends MutantLocation {
     readonly code: string;
 }
 /** Payload passed to workers/pools for execution. */
-export type MutantPayload = MutantDescriptor;
+export interface MutantPayload extends MutantDescriptor {
+    /** When true, this mutant must use the legacy redirect path instead of the schema path. */
+    readonly isFallback?: boolean;
+}
 /** Variant with attached test files. */
 export interface Variant extends MutantDescriptor {
     readonly tests: readonly string[];

package/dist/utils/CompileErrors.d.ts

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,24 @@
+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

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

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

@@ -0,0 +1,96 @@
+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();
+    });
+});

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

@@ -18,13 +18,16 @@ describe('summary', () => {
             a: makeEntry({ status: 'killed' }),
             b: makeEntry({ status: 'escaped' }),
             c: makeEntry({ status: 'skipped' }),
+            d: makeEntry({ status: 'timeout' }),
         };
         const s = computeSummary(cache);
         expect(s).toEqual({
-            total: 3,
+            total: 4,
             killed: 1,
             escaped: 1,
             skipped: 1,
+            timeouts: 1,
+            compileErrors: 0,
             evaluated: 2,
             killRate: 50,
         });
@@ -43,6 +46,40 @@ describe('summary', () => {
         expect(lines.some((l) => l.includes('Duration: 1.50s'))).toBe(true);
         logSpy.mockRestore();
     });
+    it('prints Timed Out Mutants section when timeouts exist', () => {
+        const cache = {
+            a: makeEntry({ status: 'timeout', file: '/tmp/a.ts', mutator: 'flip' }),
+        };
+        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('Timed Out Mutants'))).toBe(true);
+        logSpy.mockRestore();
+    });
+    it('shows Timeouts count in stat line when timeouts > 0', () => {
+        const cache = {
+            a: makeEntry({ status: 'timeout', file: '/tmp/a.ts' }),
+            b: makeEntry({ status: 'killed', file: '/tmp/b.ts' }),
+        };
+        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('Timeouts: 1'))).toBe(true);
+        logSpy.mockRestore();
+    });
+    it('shows Timeouts: 0 in stat line when timeouts is zero', () => {
+        const cache = {
+            a: makeEntry({ status: 'killed', file: '/tmp/a.ts' }),
+        };
+        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('Timeouts: 0'))).toBe(true);
+        logSpy.mockRestore();
+    });
     it('prints diff lines for escaped mutant with snippets', () => {
         const cache = {
             a: makeEntry({
@@ -139,6 +176,51 @@ 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',
+            }),
+        };
+        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);
+        logSpy.mockRestore();
+    });
     it('summarise returns summary and prints', () => {
         const cache = { a: makeEntry({ status: 'killed' }) };
         const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });