@mutineerjs/mutineer 0.9.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

@@ -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 }],
@@ -252,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,48 +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',
-    ]);
-    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.
  */
@@ -101,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;
@@ -122,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) {
@@ -190,17 +153,22 @@ 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) {
             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,
@@ -150,6 +136,7 @@ class VitestWorker extends EventEmitter {
                     killed: msg.killed ?? true,
                     durationMs: msg.durationMs ?? 0,
                     error: msg.error,
+                    ...(msg.passingTests && { passingTests: msg.passingTests }),
                 });
             }
             return;
@@ -391,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'
@@ -105,16 +106,30 @@ 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) {
             return {
                 killed: true,
                 durationMs: Date.now() - start,
-                error: err instanceof Error ? err.message : String(err),
+                error: toErrorMessage(err),
             };
         }
         finally {

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/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/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__/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 = {