@mutineerjs/mutineer 0.10.0 → 0.11.0

package/dist/runner/vitest/__tests__/redirect-loader.spec.js

@@ -7,7 +7,7 @@ vi.mock('node:module', async (importOriginal) => {
     const actual = await importOriginal();
     return { ...actual, register: vi.fn() };
 });
-import { resolve as poolResolve, initialise } from '../redirect-loader.js';
+import { resolve as poolResolve, initialise, load } from '../redirect-loader.js';
 describe('pool-redirect-loader resolve', () => {
     afterEach(() => {
         ;
@@ -170,4 +170,119 @@ describe('pool-redirect-loader resolve', () => {
         // Falls through to nextResolve
         expect(nextResolve).toHaveBeenCalled();
     });
+    it('returns null from tryResolveTsExtension when parentURL is absent', async () => {
+        const nextResolve = vi.fn().mockResolvedValue({
+            url: 'file:///fallback.js',
+            shortCircuit: false,
+        });
+        await poolResolve('./foo.js', {}, nextResolve);
+        // Falls through to nextResolve
+        expect(nextResolve).toHaveBeenCalled();
+    });
+    it('falls through to nextResolve when neither .ts nor .tsx exists', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-pool-loader-'));
+        const parentFile = path.join(tmpDir, 'src', 'index.ts');
+        await fs.mkdir(path.dirname(parentFile), { recursive: true });
+        await fs.writeFile(parentFile, 'export {}', 'utf8');
+        // foo.ts and foo.tsx do NOT exist — tryResolveTsExtension returns null at end of loop
+        const nextResolve = vi.fn().mockResolvedValue({
+            url: 'file:///fallback.js',
+            shortCircuit: false,
+        });
+        try {
+            await poolResolve('./foo.js', { parentURL: pathToFileURL(parentFile).href }, nextResolve);
+            expect(nextResolve).toHaveBeenCalled();
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('logs debug info when DEBUG is enabled', async () => {
+        initialise({ debug: true });
+        const errSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const nextResolve = vi.fn().mockResolvedValue({
+            url: 'file:///some.ts',
+            shortCircuit: false,
+        });
+        await poolResolve('./something', { parentURL: 'file:///src/index.ts' }, nextResolve);
+        expect(errSpy).toHaveBeenCalled();
+        errSpy.mockRestore();
+    });
+    it('logs active redirect and REDIRECTING when DEBUG is enabled and redirect matches after nextResolve', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-pool-loader-'));
+        const fromPath = path.join(tmpDir, 'target.ts');
+        const mutatedPath = path.join(tmpDir, 'mutated.ts');
+        await fs.writeFile(fromPath, 'export {}', 'utf8');
+        await fs.writeFile(mutatedPath, 'export {}', 'utf8');
+        initialise({ debug: true });
+        globalThis.__mutineer_redirect__ = {
+            from: fromPath,
+            to: mutatedPath,
+        };
+        const errSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const nextResolve = vi.fn().mockResolvedValue({
+            url: pathToFileURL(fromPath).href,
+            shortCircuit: false,
+        });
+        try {
+            const result = await poolResolve('./target', { parentURL: 'file:///src/index.ts' }, nextResolve);
+            expect(result.url).toBe(pathToFileURL(mutatedPath).href);
+            expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('REDIRECTING'));
+        }
+        finally {
+            errSpy.mockRestore();
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('logs .js -> .ts redirect info when DEBUG is enabled and ts file exists', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-pool-loader-'));
+        const parentFile = path.join(tmpDir, 'src', 'index.ts');
+        const tsFile = path.join(tmpDir, 'src', 'foo.ts');
+        await fs.mkdir(path.dirname(parentFile), { recursive: true });
+        await fs.writeFile(parentFile, 'export {}', 'utf8');
+        await fs.writeFile(tsFile, 'export const foo = 1', 'utf8');
+        initialise({ debug: true });
+        const errSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const nextResolve = vi.fn();
+        try {
+            await poolResolve('./foo.js', { parentURL: pathToFileURL(parentFile).href }, nextResolve);
+            expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('.js -> .ts'));
+        }
+        finally {
+            errSpy.mockRestore();
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('logs REDIRECTING when DEBUG is enabled and .ts resolved file matches redirect', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-pool-loader-'));
+        const parentFile = path.join(tmpDir, 'src', 'index.ts');
+        const fromPath = path.join(tmpDir, 'src', 'target.ts');
+        const mutatedPath = path.join(tmpDir, 'mutated.ts');
+        await fs.mkdir(path.dirname(parentFile), { recursive: true });
+        await fs.writeFile(parentFile, 'export {}', 'utf8');
+        await fs.writeFile(fromPath, 'export {}', 'utf8');
+        await fs.writeFile(mutatedPath, 'export {}', 'utf8');
+        initialise({ debug: true });
+        globalThis.__mutineer_redirect__ = {
+            from: fromPath,
+            to: mutatedPath,
+        };
+        const errSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const nextResolve = vi.fn();
+        try {
+            const result = await poolResolve('./target.js', { parentURL: pathToFileURL(parentFile).href }, nextResolve);
+            expect(result.url).toBe(pathToFileURL(mutatedPath).href);
+            expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('REDIRECTING'));
+        }
+        finally {
+            errSpy.mockRestore();
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('load() passes through to nextLoad', async () => {
+        const nextLoad = vi.fn().mockResolvedValue({ source: '// code' });
+        const result = await load('file:///foo.ts', {}, nextLoad);
+        expect(nextLoad).toHaveBeenCalledWith('file:///foo.ts', {});
+        expect(result).toEqual({ source: '// code' });
+    });
 });

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

@@ -312,6 +312,27 @@ describe('VitestWorkerRuntime', () => {
             }
         }
     });
+    it('logs error and rethrows when vitest.init() throws', async () => {
+        const { createVitest } = await import('vitest/node');
+        const initError = new Error('init failed');
+        vi.mocked(createVitest).mockResolvedValueOnce({
+            init: vi.fn().mockRejectedValue(initError),
+            close: closeFn,
+            runTestSpecifications: runSpecsFn,
+            invalidateFile: invalidateFn,
+            getProjectByName: getProjectByNameFn,
+        });
+        const spy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-initerr-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({
+            workerId: 'w-initerr',
+            cwd: tmp,
+        });
+        await expect(runtime.init()).rejects.toThrow('init failed');
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('Failed to initialise Vitest'));
+        spy.mockRestore();
+    });
     it('clears state.filesMap before each run to prevent memory accumulation', async () => {
         const { createVitest } = await import('vitest/node');
         const clearFn = vi.fn();

package/dist/runner/vitest/adapter.js

@@ -11,6 +11,8 @@ import { spawn } from 'node:child_process';
 import { createRequire } from 'node:module';
 import { VitestPool } from './pool.js';
 import { createLogger } from '../../utils/logger.js';
+import { stripMutineerArgs } from '../shared/index.js';
+import { toErrorMessage } from '../../utils/errors.js';
 const require = createRequire(import.meta.url);
 const log = createLogger('vitest-adapter');
 /**
@@ -25,49 +27,6 @@ function resolveVitestPath() {
         return path.join(path.dirname(pkgJson), 'vitest.mjs');
     }
 }
-/**
- * Strip mutineer-specific CLI args that shouldn't be passed to Vitest.
- */
-function stripMutineerArgs(args) {
-    const out = [];
-    const consumeNext = new Set([
-        '--concurrency',
-        '--progress',
-        '--min-kill-percent',
-        '--config',
-        '-c',
-        '--coverage-file',
-        '--shard',
-        '--report',
-    ]);
-    const dropExact = new Set([
-        '-m',
-        '--mutate',
-        '--changed',
-        '--changed-with-deps',
-        '--full',
-        '--only-covered-lines',
-        '--per-test-coverage',
-        '--perTestCoverage',
-    ]);
-    for (let i = 0; i < args.length; i++) {
-        const a = args[i];
-        if (dropExact.has(a))
-            continue;
-        if (consumeNext.has(a)) {
-            i++;
-            continue;
-        }
-        if (a.startsWith('--min-kill-percent='))
-            continue;
-        if (a.startsWith('--config=') || a.startsWith('-c='))
-            continue;
-        if (a.startsWith('--shard='))
-            continue;
-        out.push(a);
-    }
-    return out;
-}
 /**
  * Ensure the Vitest config arg is included if specified.
  */
@@ -102,7 +61,7 @@ function buildVitestArgs(args, mode) {
             result.push('--coverage.perTest=true');
         }
         // Disable coverage thresholds so baseline doesn't fail when a broader
-        // test set (e.g. from --changed-with-deps) lowers aggregate coverage
+        // test set (e.g. from --changed-with-imports) lowers aggregate coverage
         result.push('--coverage.thresholds.lines=0', '--coverage.thresholds.functions=0', '--coverage.thresholds.branches=0', '--coverage.thresholds.statements=0');
     }
     return result;
@@ -123,7 +82,10 @@ export class VitestAdapter {
             throw new Error("Cannot find 'vitest'. Install it with: npm i -D vitest");
         }
         // Prepare base args by stripping mutineer-specific flags
-        const stripped = stripMutineerArgs(options.cliArgs);
+        const stripped = stripMutineerArgs(options.cliArgs, {
+            extraConsumeNext: ['--shard'],
+            extraPrefixes: ['--shard='],
+        });
         this.baseArgs = ensureConfigArg(stripped, options.config.vitestConfig, options.cwd);
     }
     async init(concurrencyOverride) {
@@ -206,7 +168,7 @@ export class VitestAdapter {
             return {
                 status: 'error',
                 durationMs: 0,
-                error: err instanceof Error ? err.message : String(err),
+                error: toErrorMessage(err),
             };
         }
     }

package/dist/runner/vitest/plugin.js

@@ -43,13 +43,7 @@ export function poolMutineerPlugin() {
         },
         load(id) {
             const cleanId = id.split('?')[0];
-            let normalizedId;
-            try {
-                normalizedId = path.resolve(cleanId);
-            }
-            catch {
-                return null;
-            }
+            const normalizedId = path.resolve(cleanId);
             // 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.

package/dist/runner/vitest/pool.js

@@ -14,11 +14,11 @@
 import { spawn } from 'node:child_process';
 import * as path from 'node:path';
 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 { getActiveIdFilePath, resolveWorkerScript, } from '../shared/index.js';
 import { createLogger, DEBUG } from '../../utils/logger.js';
+import { toErrorMessage } from '../../utils/errors.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const workerLog = createLogger('VitestWorker');
 const poolLog = createLogger('VitestPool');
@@ -36,22 +36,8 @@ class VitestWorker extends EventEmitter {
         this.id = id;
     }
     async start() {
-        const workerJs = path.join(__dirname, 'worker.js');
-        const workerMts = path.join(__dirname, 'worker.mjs');
-        const workerTs = path.join(__dirname, 'worker.mts');
-        const workerScript = fs.existsSync(workerJs)
-            ? workerJs
-            : fs.existsSync(workerMts)
-                ? workerMts
-                : workerTs;
-        const loaderJs = path.join(__dirname, 'redirect-loader.js');
-        const loaderMjs = path.join(__dirname, 'redirect-loader.mjs');
-        const loaderTs = path.join(__dirname, 'redirect-loader.ts');
-        const loaderScript = fs.existsSync(loaderJs)
-            ? loaderJs
-            : fs.existsSync(loaderMjs)
-                ? loaderMjs
-                : loaderTs;
+        const workerScript = resolveWorkerScript(__dirname, 'worker');
+        const loaderScript = resolveWorkerScript(__dirname, 'redirect-loader');
         const env = {
             ...process.env,
             MUTINEER_WORKER_ID: this.id,
@@ -392,7 +378,7 @@ export async function runWithPool(pool, mutant, tests) {
         return {
             status: 'error',
             durationMs: 0,
-            error: err instanceof Error ? err.message : String(err),
+            error: toErrorMessage(err),
         };
     }
 }

package/dist/runner/vitest/redirect-loader.js

@@ -29,9 +29,11 @@ function tryResolveTsExtension(specifier, parentURL) {
     if (!specifier.endsWith('.js') || !specifier.startsWith('.')) {
         return null;
     }
+    if (!parentURL)
+        return null;
     let parentPath;
     try {
-        parentPath = fileURLToPath(parentURL ?? '');
+        parentPath = fileURLToPath(parentURL);
     }
     catch {
         return null;

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

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { poolMutineerPlugin } from './plugin.js';
 import { getMutantFilePath, setRedirect, clearRedirect, } from '../shared/index.js';
 import { createLogger } from '../../utils/logger.js';
+import { toErrorMessage } from '../../utils/errors.js';
 const log = createLogger('vitest-runtime');
 const SETUP_MJS_CONTENT = `import { beforeAll } from 'vitest'
 import { readFileSync } from 'node:fs'
@@ -128,7 +129,7 @@ export class VitestWorkerRuntime {
             return {
                 killed: true,
                 durationMs: Date.now() - start,
-                error: err instanceof Error ? err.message : String(err),
+                error: toErrorMessage(err),
             };
         }
         finally {

package/dist/types/config.d.ts

@@ -24,8 +24,8 @@ export interface MutineerConfig {
     readonly runner?: 'vitest' | 'jest';
     readonly vitestConfig?: string;
     readonly jestConfig?: string;
-    /** Max depth for dependency resolution with --changed-with-deps (default: 1) */
-    readonly dependencyDepth?: number;
+    /** Max depth for import resolution with --changed-with-imports (default: 1) */
+    readonly importDepth?: number;
     /** Path to coverage JSON file (Istanbul format, e.g., coverage/coverage-final.json) */
     readonly coverageFile?: string;
     /** Only mutate lines that are covered by tests (requires coverageFile) */

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

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

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

@@ -0,0 +1,15 @@
+import { describe, it, expect, vi } from 'vitest';
+vi.mock('ink', () => ({
+    Box: ({ children }) => children,
+    Text: ({ children }) => children,
+}));
+vi.mock('ink-spinner', () => ({
+    default: () => null,
+}));
+describe('PoolSpinner', () => {
+    it('renders without throwing', async () => {
+        const { PoolSpinner } = await import('../PoolSpinner.js');
+        const result = PoolSpinner({ message: 'initializing...' });
+        expect(result).toBeDefined();
+    });
+});

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

@@ -188,6 +188,95 @@ describe('coverage utilities', () => {
             await fs.rm(tmpDir, { recursive: true, force: true });
         }
     });
+    it('skips non-JSON files in coverage tmp dir', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
+        const covDir = path.join(tmpDir, 'coverage');
+        const tmpSubDir = path.join(covDir, 'tmp');
+        await fs.mkdir(tmpSubDir, { recursive: true });
+        await fs.writeFile(path.join(tmpSubDir, 'data.txt'), 'some text', 'utf8');
+        try {
+            const map = await loadPerTestCoverageData(covDir, tmpDir);
+            expect(map).toBeNull();
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('skips invalid JSON files in coverage tmp dir', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
+        const covDir = path.join(tmpDir, 'coverage');
+        const tmpSubDir = path.join(covDir, 'tmp');
+        await fs.mkdir(tmpSubDir, { recursive: true });
+        await fs.writeFile(path.join(tmpSubDir, 'bad.json'), 'not valid json', 'utf8');
+        try {
+            const map = await loadPerTestCoverageData(covDir, tmpDir);
+            expect(map).toBeNull();
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('skips format A entries with malformed detail (no lines key)', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
+        const reportsDir = path.join(tmpDir, 'coverage');
+        await fs.mkdir(reportsDir, { recursive: true });
+        const data = {
+            tests: {
+                '/test/a.spec.ts': {
+                    files: {
+                        '/src/a.ts': { noLines: 'wrong' }, // missing 'lines' key
+                    },
+                },
+            },
+        };
+        await fs.writeFile(path.join(reportsDir, 'per-test-coverage.json'), JSON.stringify(data), 'utf8');
+        try {
+            const map = await loadPerTestCoverageData(reportsDir, tmpDir);
+            // Test entry exists but no file lines were added for the malformed detail
+            expect(map).not.toBeNull();
+            const fileMap = map.get('/test/a.spec.ts');
+            expect(fileMap).toBeDefined();
+            expect(fileMap.has('/src/a.ts')).toBe(false);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('skips format B entries with non-array lines value', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
+        const reportsDir = path.join(tmpDir, 'coverage');
+        await fs.mkdir(reportsDir, { recursive: true });
+        const data = {
+            '/test/a.spec.ts': {
+                '/src/a.ts': 'not-an-array', // non-array value
+            },
+        };
+        await fs.writeFile(path.join(reportsDir, 'per-test-coverage.json'), JSON.stringify(data), 'utf8');
+        try {
+            const map = await loadPerTestCoverageData(reportsDir, tmpDir);
+            // Test entry exists but no file lines were added for the non-array value
+            expect(map).not.toBeNull();
+            const fileMap = map.get('/test/a.spec.ts');
+            expect(fileMap).toBeDefined();
+            expect(fileMap.has('/src/a.ts')).toBe(false);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('gracefully handles null JSON in per-test coverage file', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
+        const covDir = path.join(tmpDir, 'coverage');
+        await fs.mkdir(covDir, { recursive: true });
+        await fs.writeFile(path.join(covDir, 'per-test-coverage.json'), 'null', 'utf8');
+        try {
+            const map = await loadPerTestCoverageData(covDir, tmpDir);
+            expect(map).toBeNull();
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
     it('uses relative reportsDir when not absolute', async () => {
         const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
         const reportsDir = path.join(tmpDir, 'reports');

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

@@ -58,4 +58,13 @@ describe('logger', () => {
             expect(spy).toHaveBeenCalledWith(expect.stringContaining('[custom-tag]'));
         }
     });
+    it('debug calls console.error when MUTINEER_DEBUG=1', async () => {
+        process.env.MUTINEER_DEBUG = '1';
+        vi.resetModules();
+        const spy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const { createLogger } = await import('../logger.js');
+        const log = createLogger('dbg-tag');
+        log.debug('debug msg');
+        expect(spy).toHaveBeenCalledWith('[dbg-tag] debug msg');
+    });
 });

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

@@ -114,6 +114,44 @@ describe('Progress', () => {
             });
         }
     });
+    it('defaults to bar mode when no opts provided', () => {
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const progress = new Progress(2);
+        progress.start();
+        // Non-TTY path: logs via console
+        expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('running 2 mutants'));
+        progress.finish();
+        logSpy.mockRestore();
+    });
+    it('uses 80 column fallback when stream.columns is undefined', () => {
+        const writeSpy = vi.fn();
+        const fakeStream = {
+            isTTY: true,
+            write: writeSpy,
+            columns: undefined,
+        };
+        const origStderr = process.stderr;
+        Object.defineProperty(process, 'stderr', {
+            value: fakeStream,
+            writable: true,
+            configurable: true,
+        });
+        try {
+            vi.spyOn(console, 'log').mockImplementation(() => { });
+            const progress = new Progress(3, { mode: 'bar' });
+            progress.start();
+            // Should not throw; bar rendered with 80 column fallback
+            expect(writeSpy).toHaveBeenCalled();
+            progress.finish();
+        }
+        finally {
+            Object.defineProperty(process, 'stderr', {
+                value: origStderr,
+                writable: true,
+                configurable: true,
+            });
+        }
+    });
     it('handles zero total in bar mode', () => {
         const writeSpy = vi.fn();
         const fakeStream = {

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

@@ -123,6 +123,23 @@ describe('summary', () => {
         expect(lines.some((l) => l.includes('foo.spec.ts'))).toBe(true);
         logSpy.mockRestore();
     });
+    it('handles printSummary with no cache argument when total > 0', () => {
+        const summary = {
+            total: 1,
+            killed: 1,
+            escaped: 0,
+            skipped: 0,
+            timeouts: 0,
+            compileErrors: 0,
+            evaluated: 1,
+            killRate: 100,
+        };
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        // No cache passed: allEntries=[], maxPathLen=25 (|| 25), maxMutatorLen=10 (|| 10)
+        printSummary(summary);
+        expect(logSpy).toHaveBeenCalled();
+        logSpy.mockRestore();
+    });
     it('buildJsonReport includes passingTests when present', () => {
         const cache = {
             a: makeEntry({
@@ -212,4 +229,43 @@ describe('summary', () => {
         expect(logSpy).toHaveBeenCalled();
         logSpy.mockRestore();
     });
+    it('counts compile-error status in compileErrors field', () => {
+        const cache = { a: makeEntry({ status: 'compile-error' }) };
+        const s = computeSummary(cache);
+        expect(s.compileErrors).toBe(1);
+        expect(s.killed).toBe(0);
+    });
+    it('categorizes compile-error entries without throwing in printSummary', () => {
+        const cache = {
+            a: makeEntry({ status: 'compile-error', file: '/tmp/a.ts' }),
+        };
+        const summary = computeSummary(cache);
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        printSummary(summary, cache);
+        expect(summary.compileErrors).toBe(1);
+        logSpy.mockRestore();
+    });
+    it('formats duration in minutes when duration >= 60s', () => {
+        const cache = { a: makeEntry({ status: 'killed' }) };
+        const summary = computeSummary(cache);
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        printSummary(summary, cache, 90000); // 90 seconds = 1m 30.0s
+        const lines = logSpy.mock.calls.map((c) => stripAnsi(c.join(' ')));
+        expect(lines.some((l) => l.includes('1m 30.0s'))).toBe(true);
+        logSpy.mockRestore();
+    });
+    it('prints +N more when escaped mutant has more than 2 covering tests', () => {
+        const cache = {
+            a: makeEntry({
+                status: 'escaped',
+                coveringTests: ['/t1.spec.ts', '/t2.spec.ts', '/t3.spec.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('+1 more'))).toBe(true);
+        logSpy.mockRestore();
+    });
 });

package/dist/utils/coverage.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { toErrorMessage } from './errors.js';
 /**
  * Load and parse Istanbul-format coverage JSON file.
  * Supports both coverage-final.json (from Istanbul) and Vitest's coverage output.
@@ -17,16 +18,14 @@ export async function loadCoverageData(coverageFile, cwd) {
         raw = await fs.readFile(absPath, 'utf8');
     }
     catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        throw new Error(`Failed to read coverage file "${absPath}": ${msg}`);
+        throw new Error(`Failed to read coverage file "${absPath}": ${toErrorMessage(err)}`);
     }
     let data;
     try {
         data = JSON.parse(raw);
     }
     catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        throw new Error(`Failed to parse coverage file "${absPath}" as JSON: ${msg}`);
+        throw new Error(`Failed to parse coverage file "${absPath}" as JSON: ${toErrorMessage(err)}`);
     }
     const coveredLines = new Map();
     for (const [filePath, fileCoverage] of Object.entries(data)) {

package/dist/utils/errors.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Error message extraction utility.
+ */
+export declare function toErrorMessage(err: unknown): string;

package/dist/utils/errors.js

@@ -0,0 +1,6 @@
+/**
+ * Error message extraction utility.
+ */
+export function toErrorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/package.json

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