@mutineerjs/mutineer 0.2.4 → 0.3.2

package/dist/runner/jest/worker.mjs

@@ -16,7 +16,7 @@ async function main() {
         await runtime.init();
     }
     catch (err) {
-        log.error(`Failed to initialize: ${err}`);
+        log.error(`Failed to initialise: ${err}`);
         process.exit(1);
     }
     process.send?.({ type: 'ready', workerId });

package/dist/runner/pool-executor.js

@@ -42,7 +42,7 @@ export async function executePool(opts) {
             }
         }
     };
-    // Initialize worker pool
+    // Initialise worker pool
     const workerLogSuffix = workerCount < concurrency ? ` (requested ${concurrency})` : '';
     log.info(`Initializing ${adapter.name} worker pool with ${workerCount} workers...${workerLogSuffix}`);
     const poolStart = Date.now();

package/dist/runner/shared/__tests__/redirect-state.spec.js

@@ -1,10 +1,10 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { initializeRedirectState, setRedirect, getRedirect, clearRedirect, } from '../redirect-state.js';
+import { initialiseRedirectState, setRedirect, getRedirect, clearRedirect, } from '../redirect-state.js';
 describe('redirect-state', () => {
     beforeEach(() => {
-        initializeRedirectState();
+        initialiseRedirectState();
     });
-    describe('initializeRedirectState', () => {
+    describe('initialiseRedirectState', () => {
         it('sets global redirect to null/null', () => {
             expect(globalThis.__mutineer_redirect__).toEqual({
                 from: null,

package/dist/runner/shared/index.d.ts

@@ -5,5 +5,5 @@
  * including mutant file path generation and redirect state management.
  */
 export { getMutantFilePath } from './mutant-paths.js';
-export { setRedirect, getRedirect, clearRedirect, initializeRedirectState, } from './redirect-state.js';
+export { setRedirect, getRedirect, clearRedirect, initialiseRedirectState, } from './redirect-state.js';
 export type { RedirectConfig } from './redirect-state.js';

package/dist/runner/shared/index.js

@@ -5,4 +5,4 @@
  * including mutant file path generation and redirect state management.
  */
 export { getMutantFilePath } from './mutant-paths.js';
-export { setRedirect, getRedirect, clearRedirect, initializeRedirectState, } from './redirect-state.js';
+export { setRedirect, getRedirect, clearRedirect, initialiseRedirectState, } from './redirect-state.js';

package/dist/runner/shared/redirect-state.d.ts

@@ -23,10 +23,10 @@ export interface RedirectConfig {
     readonly to: string;
 }
 /**
- * Initialize the global redirect state.
+ * Initialise the global redirect state.
  * Must be called once at module load time.
  */
-export declare function initializeRedirectState(): void;
+export declare function initialiseRedirectState(): void;
 /**
  * Set the active redirect configuration.
  *

package/dist/runner/shared/redirect-state.js

@@ -8,10 +8,10 @@
  * test execution.
  */
 /**
- * Initialize the global redirect state.
+ * Initialise the global redirect state.
  * Must be called once at module load time.
  */
-export function initializeRedirectState() {
+export function initialiseRedirectState() {
     globalThis.__mutineer_redirect__ = { from: null, to: null };
 }
 /**
@@ -46,5 +46,5 @@ export function getRedirect() {
 export function clearRedirect() {
     globalThis.__mutineer_redirect__ = { from: null, to: null };
 }
-// Initialize on module load
-initializeRedirectState();
+// Initialise on module load
+initialiseRedirectState();

package/dist/runner/types.d.ts

@@ -41,7 +41,7 @@ export interface TestRunnerAdapter {
      */
     readonly name: string;
     /**
-     * Initialize the adapter (start worker pools, etc.).
+     * Initialise the adapter (start worker pools, etc.).
      * Must be called before running tests.
      */
     init(concurrencyOverride?: number): Promise<void>;

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

@@ -41,7 +41,7 @@ describe('Vitest adapter', () => {
     afterEach(() => {
         vi.useRealTimers();
     });
-    it('initializes pool with override concurrency', async () => {
+    it('initialises pool with override concurrency', async () => {
         const adapter = makeAdapter();
         await adapter.init(5);
         expect(poolInstance?.init).toHaveBeenCalledTimes(1);

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

@@ -40,7 +40,7 @@ describe('VitestPool', () => {
             cwd: process.cwd(),
             concurrency: 1,
             timeoutMs: 5000,
-            createWorker: (id, opts) => {
+            createWorker: (id) => {
                 const worker = new EventEmitter();
                 worker.id = id;
                 worker.start = vi.fn().mockResolvedValue(undefined);

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

@@ -7,11 +7,12 @@ vi.mock('node:module', async (importOriginal) => {
     const actual = await importOriginal();
     return { ...actual, register: vi.fn() };
 });
-import { resolve as poolResolve } from '../redirect-loader.js';
+import { resolve as poolResolve, initialise } from '../redirect-loader.js';
 describe('pool-redirect-loader resolve', () => {
     afterEach(() => {
         ;
         globalThis.__mutineer_redirect__ = undefined;
+        delete process.env.MUTINEER_DEBUG;
         vi.restoreAllMocks();
     });
     it('resolves .js to .ts in the same directory', async () => {
@@ -88,4 +89,85 @@ describe('pool-redirect-loader resolve', () => {
             await fs.rm(tmpDir, { recursive: true, force: true });
         }
     });
+    it('passes through non-.js specifiers to nextResolve', async () => {
+        const nextResolve = vi.fn().mockResolvedValue({
+            url: 'file:///some/module.ts',
+            shortCircuit: false,
+        });
+        const result = await poolResolve('./module', { parentURL: 'file:///src/index.ts' }, nextResolve);
+        expect(nextResolve).toHaveBeenCalled();
+        expect(result.url).toBe('file:///some/module.ts');
+    });
+    it('passes through builtin modules to nextResolve', async () => {
+        const nextResolve = vi.fn().mockResolvedValue({
+            url: 'node:fs',
+            shortCircuit: true,
+        });
+        const result = await poolResolve('node:fs', { parentURL: 'file:///src/index.ts' }, nextResolve);
+        expect(nextResolve).toHaveBeenCalled();
+        expect(result.url).toBe('node:fs');
+    });
+    it('skips .js->ts resolution for non-relative specifiers', async () => {
+        const nextResolve = vi.fn().mockResolvedValue({
+            url: 'file:///node_modules/pkg/index.js',
+            shortCircuit: false,
+        });
+        const result = await poolResolve('some-package/foo.js', { parentURL: 'file:///src/index.ts' }, nextResolve);
+        expect(nextResolve).toHaveBeenCalled();
+        expect(result.url).toBe('file:///node_modules/pkg/index.js');
+    });
+    it('resolves .js to .tsx when .ts does not exist', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-pool-loader-'));
+        const parentFile = path.join(tmpDir, 'src', 'index.ts');
+        const tsxFile = path.join(tmpDir, 'src', 'comp.tsx');
+        await fs.mkdir(path.dirname(parentFile), { recursive: true });
+        await fs.writeFile(parentFile, 'export {}', 'utf8');
+        await fs.writeFile(tsxFile, 'export const Comp = () => null', 'utf8');
+        try {
+            const nextResolve = vi.fn();
+            const result = await poolResolve('./comp.js', { parentURL: pathToFileURL(parentFile).href }, nextResolve);
+            expect(nextResolve).not.toHaveBeenCalled();
+            expect(result.shortCircuit).toBe(true);
+            expect(result.url).toBe(pathToFileURL(tsxFile).href);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('tries parent of __mutineer__ directory for ts resolution', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-pool-loader-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const mutineerDir = path.join(srcDir, '__mutineer__');
+        await fs.mkdir(mutineerDir, { recursive: true });
+        const parentFile = path.join(mutineerDir, 'mutant.ts');
+        const tsFile = path.join(srcDir, 'sibling.ts');
+        await fs.writeFile(parentFile, 'export {}', 'utf8');
+        await fs.writeFile(tsFile, 'export const x = 1', 'utf8');
+        try {
+            const nextResolve = vi.fn();
+            const result = await poolResolve('./sibling.js', { parentURL: pathToFileURL(parentFile).href }, nextResolve);
+            expect(nextResolve).not.toHaveBeenCalled();
+            expect(result.shortCircuit).toBe(true);
+            expect(result.url).toBe(pathToFileURL(tsFile).href);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('initialise sets debug mode', () => {
+        // Should not throw
+        initialise({ debug: true });
+        initialise({ debug: false });
+        initialise(undefined);
+    });
+    it('returns null from tryResolveTsExtension when parentURL is invalid', async () => {
+        const nextResolve = vi.fn().mockResolvedValue({
+            url: 'file:///fallback.js',
+            shortCircuit: false,
+        });
+        // parentURL is not a valid file URL, so tryResolveTsExtension should return null
+        await poolResolve('./foo.js', { parentURL: 'not-a-valid-url' }, nextResolve);
+        // Falls through to nextResolve
+        expect(nextResolve).toHaveBeenCalled();
+    });
 });

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

@@ -55,6 +55,90 @@ describe('VitestWorkerRuntime', () => {
         expect(fs.existsSync(path.join(tmp, 'src', '__mutineer__'))).toBe(false);
         await runtime.shutdown();
     });
+    it('throws when run is called before init', async () => {
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({
+            workerId: 'w-noinit',
+            cwd: tmp,
+        });
+        await expect(runtime.run({
+            id: 'mut#err',
+            name: 'm',
+            file: path.join(tmp, 'src.ts'),
+            code: 'export const x=1',
+            line: 1,
+            col: 1,
+        }, [path.join(tmp, 'test.ts')])).rejects.toThrow('Vitest runtime not initialised');
+    });
+    it('shutdown is a no-op when not initialised', async () => {
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({
+            workerId: 'w-noinit2',
+            cwd: tmp,
+        });
+        // Should not throw
+        await runtime.shutdown();
+        expect(closeFn).not.toHaveBeenCalled();
+    });
+    it('passes vitestConfigPath option to createVitest', async () => {
+        const { createVitest } = await import('vitest/node');
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({
+            workerId: 'w-config',
+            cwd: tmp,
+            vitestConfigPath: '/custom/vitest.config.ts',
+        });
+        await runtime.init();
+        expect(createVitest).toHaveBeenCalledWith('test', expect.objectContaining({ config: '/custom/vitest.config.ts' }), expect.any(Object));
+        await runtime.shutdown();
+    });
+    it('handles non-Error thrown during run', async () => {
+        runSpecsFn.mockRejectedValue('string error');
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({
+            workerId: 'w-strerr',
+            cwd: tmp,
+        });
+        await runtime.init();
+        const result = await runtime.run({
+            id: 'mut#3',
+            name: 'm',
+            file: path.join(tmp, 'src.ts'),
+            code: 'export const x=1',
+            line: 1,
+            col: 1,
+        }, [path.join(tmp, 'test.ts')]);
+        expect(result.killed).toBe(true);
+        expect(result.error).toBe('string error');
+        await runtime.shutdown();
+    });
+    it('falls back to all testModules when no relevant modules match', async () => {
+        runSpecsFn.mockResolvedValue({
+            testModules: [{ moduleId: 'unknown-module', ok: () => true }],
+        });
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({
+            workerId: 'w-fallback',
+            cwd: tmp,
+        });
+        await runtime.init();
+        const result = await runtime.run({
+            id: 'mut#4',
+            name: 'm',
+            file: path.join(tmp, 'src.ts'),
+            code: 'export const x=1',
+            line: 1,
+            col: 1,
+        }, [path.join(tmp, 'test.ts')]);
+        // Falls back to all testModules; 'unknown-module' reports ok() = true
+        expect(result.killed).toBe(false);
+        await runtime.shutdown();
+    });
     it('returns escaped when no specs produced', async () => {
         getProjectByNameFn.mockReturnValue({ createSpecification: () => null });
         const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));

package/dist/runner/vitest/adapter.js

@@ -154,7 +154,7 @@ export class VitestAdapter {
     }
     async runMutant(mutant, tests) {
         if (!this.pool) {
-            throw new Error('VitestAdapter not initialized. Call init() first.');
+            throw new Error('VitestAdapter not initialised. Call init() first.');
         }
         try {
             const result = await this.pool.run(mutant, [...tests]);

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

@@ -7,5 +7,4 @@
 export { VitestAdapter, createVitestAdapter, isCoverageRequestedInArgs, } from './adapter.js';
 export { VitestPool, runWithPool, type VitestPoolOptions } from './pool.js';
 export { poolMutineerPlugin } from './plugin.js';
-export { resolve as poolRedirectResolve } from './redirect-loader.js';
 export type { MutantPayload, MutantRunResult, MutantRunSummary, } from '../../types/mutant.js';

package/dist/runner/vitest/index.js

@@ -7,4 +7,3 @@
 export { VitestAdapter, createVitestAdapter, isCoverageRequestedInArgs, } from './adapter.js';
 export { VitestPool, runWithPool } from './pool.js';
 export { poolMutineerPlugin } from './plugin.js';
-export { resolve as poolRedirectResolve } from './redirect-loader.js';

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

@@ -47,7 +47,7 @@ export declare class VitestPool {
     private availableWorkers;
     private waitingTasks;
     private readonly options;
-    private initialized;
+    private initialised;
     private shuttingDown;
     constructor(options: VitestPoolOptions);
     init(): Promise<void>;

package/dist/runner/vitest/pool.js

@@ -221,7 +221,7 @@ export class VitestPool {
         this.workers = [];
         this.availableWorkers = [];
         this.waitingTasks = [];
-        this.initialized = false;
+        this.initialised = false;
         this.shuttingDown = false;
         this.options = {
             cwd: options.cwd,
@@ -232,7 +232,7 @@ export class VitestPool {
         };
     }
     async init() {
-        if (this.initialized)
+        if (this.initialised)
             return;
         poolLog.debug(`Initializing pool with ${this.options.concurrency} workers`);
         const startPromises = [];
@@ -254,8 +254,8 @@ export class VitestPool {
             }));
         }
         await Promise.all(startPromises);
-        this.initialized = true;
-        poolLog.debug('Pool initialized');
+        this.initialised = true;
+        poolLog.debug('Pool initialised');
     }
     handleWorkerExit(worker) {
         // Remove from available list
@@ -313,8 +313,8 @@ export class VitestPool {
         }
     }
     async run(mutant, tests) {
-        if (!this.initialized) {
-            throw new Error('Pool not initialized. Call init() first.');
+        if (!this.initialised) {
+            throw new Error('Pool not initialised. Call init() first.');
         }
         if (this.shuttingDown) {
             throw new Error('Pool is shutting down');
@@ -336,7 +336,7 @@ export class VitestPool {
         await Promise.all(this.workers.map((w) => w.shutdown()));
         this.workers = [];
         this.availableWorkers = [];
-        this.initialized = false;
+        this.initialised = false;
         poolLog.debug('Pool shut down');
     }
 }

package/dist/runner/vitest/redirect-loader.d.ts

@@ -13,7 +13,7 @@ declare global {
         to: string | null;
     } | undefined;
 }
-export declare function initialize(data: {
+export declare function initialise(data: {
     debug?: boolean;
 } | undefined): void;
 export declare function resolve(specifier: string, context: {

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

@@ -17,7 +17,7 @@ register(import.meta.url, {
     data: { debug: process.env.MUTINEER_DEBUG === '1' },
 });
 let DEBUG = process.env.MUTINEER_DEBUG === '1';
-export function initialize(data) {
+export function initialise(data) {
     if (data?.debug !== undefined) {
         DEBUG = data.debug;
     }

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

@@ -25,10 +25,10 @@ export class VitestWorkerRuntime {
                 plugins: [poolMutineerPlugin()],
             });
             await this.vitest.init();
-            log.debug(`Vitest initialized for worker ${this.options.workerId}`);
+            log.debug(`Vitest initialised for worker ${this.options.workerId}`);
         }
         catch (err) {
-            log.error(`Failed to initialize Vitest: ${err}`);
+            log.error(`Failed to initialise Vitest: ${err}`);
             throw err;
         }
     }
@@ -40,7 +40,7 @@ export class VitestWorkerRuntime {
     }
     async run(mutant, tests) {
         if (!this.vitest) {
-            throw new Error('Vitest runtime not initialized');
+            throw new Error('Vitest runtime not initialised');
         }
         const start = Date.now();
         try {

package/dist/runner/vitest/worker.mjs

@@ -36,7 +36,7 @@ async function main() {
         await runtime.init();
     }
     catch (err) {
-        log.error(`Failed to initialize Vitest: ${err}`);
+        log.error(`Failed to initialise Vitest: ${err}`);
         process.exit(1);
     }
     // Signal ready

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

@@ -38,6 +38,173 @@ describe('coverage utilities', () => {
         const coverage = { coveredLines: new Map() };
         expect(getFileCoverageStats(coverage, '/nope.ts')).toBeNull();
     });
+    it('loads coverage from a relative path', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
+        const filePath = '/src/file.ts';
+        const data = {
+            [filePath]: {
+                path: filePath,
+                statementMap: {
+                    '0': { start: { line: 1, column: 0 }, end: { line: 1, column: 10 } },
+                },
+                s: { '0': 1 },
+            },
+        };
+        await fs.writeFile(path.join(tmpDir, 'cov.json'), JSON.stringify(data), 'utf8');
+        try {
+            const coverage = await loadCoverageData('cov.json', tmpDir);
+            expect(coverage.coveredLines.size).toBeGreaterThan(0);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('throws on missing coverage file', async () => {
+        await expect(loadCoverageData('/nonexistent/path.json', '/tmp')).rejects.toThrow('Failed to read coverage file');
+    });
+    it('throws on invalid JSON in coverage file', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
+        await fs.writeFile(path.join(tmpDir, 'bad.json'), 'not json', 'utf8');
+        try {
+            await expect(loadCoverageData(path.join(tmpDir, 'bad.json'), tmpDir)).rejects.toThrow('Failed to parse coverage file');
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('skips files with missing statementMap or s', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
+        const data = {
+            '/src/nomap.ts': { path: '/src/nomap.ts' },
+            '/src/nos.ts': {
+                path: '/src/nos.ts',
+                statementMap: {
+                    '0': { start: { line: 1, column: 0 }, end: { line: 1, column: 10 } },
+                },
+            },
+        };
+        await fs.writeFile(path.join(tmpDir, 'cov.json'), JSON.stringify(data), 'utf8');
+        try {
+            const coverage = await loadCoverageData(path.join(tmpDir, 'cov.json'), tmpDir);
+            expect(coverage.coveredLines.size).toBe(0);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('normalizes relative file paths in coverage data', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
+        const data = {
+            'src/relative.ts': {
+                path: 'src/relative.ts',
+                statementMap: {
+                    '0': { start: { line: 1, column: 0 }, end: { line: 1, column: 10 } },
+                },
+                s: { '0': 1 },
+            },
+        };
+        await fs.writeFile(path.join(tmpDir, 'cov.json'), JSON.stringify(data), 'utf8');
+        try {
+            const coverage = await loadCoverageData(path.join(tmpDir, 'cov.json'), tmpDir);
+            // Should have resolved relative path
+            const absPath = path.join(tmpDir, 'src/relative.ts');
+            expect(coverage.coveredLines.has(absPath)).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('skips files where all statements have zero hits', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
+        const data = {
+            '/src/uncovered.ts': {
+                path: '/src/uncovered.ts',
+                statementMap: {
+                    '0': { start: { line: 1, column: 0 }, end: { line: 1, column: 10 } },
+                },
+                s: { '0': 0 },
+            },
+        };
+        await fs.writeFile(path.join(tmpDir, 'cov.json'), JSON.stringify(data), 'utf8');
+        try {
+            const coverage = await loadCoverageData(path.join(tmpDir, 'cov.json'), tmpDir);
+            expect(coverage.coveredLines.size).toBe(0);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('isLineCovered returns false for uncovered file', () => {
+        const coverage = { coveredLines: new Map() };
+        expect(isLineCovered(coverage, '/nonexistent.ts', 1)).toBe(false);
+    });
+    it('returns null for per-test coverage when no files found', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
+        await fs.mkdir(path.join(tmpDir, 'empty-reports'), { recursive: true });
+        try {
+            const map = await loadPerTestCoverageData(path.join(tmpDir, 'empty-reports'), tmpDir);
+            expect(map).toBeNull();
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('loads per-test coverage in format B (direct arrays)', 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 formatB = {
+            '/test/a.spec.ts': {
+                '/src/a.ts': [1, 2, 3],
+            },
+        };
+        await fs.writeFile(path.join(reportsDir, 'per-test-coverage.json'), JSON.stringify(formatB), 'utf8');
+        try {
+            const map = await loadPerTestCoverageData(reportsDir, tmpDir);
+            expect(map).not.toBeNull();
+            const lines = map.get('/test/a.spec.ts').get('/src/a.ts');
+            expect(lines.has(1)).toBe(true);
+            expect(lines.has(3)).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('handles per-test coverage with non-object/null values gracefully', 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': null,
+            '/test/b.spec.ts': 'not-an-object',
+        };
+        await fs.writeFile(path.join(reportsDir, 'per-test-coverage.json'), JSON.stringify(data), 'utf8');
+        try {
+            const map = await loadPerTestCoverageData(reportsDir, tmpDir);
+            // No valid entries, should return null
+            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');
+        await fs.mkdir(reportsDir, { recursive: true });
+        const data = {
+            '/test/a.spec.ts': { '/src/a.ts': [1] },
+        };
+        await fs.writeFile(path.join(reportsDir, 'per-test-coverage.json'), JSON.stringify(data), 'utf8');
+        try {
+            // Pass relative path
+            const map = await loadPerTestCoverageData('reports', tmpDir);
+            expect(map).not.toBeNull();
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
     it('loads per-test coverage data from various shapes', async () => {
         const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
         const reportsDir = path.join(tmpDir, 'coverage');