@mutineerjs/mutineer 0.2.3 → 0.2.4

package/dist/runner/__tests__/pool-executor.spec.js

@@ -0,0 +1,213 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { executePool } from '../pool-executor.js';
+function makeAdapter(overrides = {}) {
+    return {
+        name: 'vitest',
+        init: vi.fn().mockResolvedValue(undefined),
+        runBaseline: vi.fn().mockResolvedValue(true),
+        runMutant: vi
+            .fn()
+            .mockResolvedValue({ status: 'killed', durationMs: 10 }),
+        shutdown: vi.fn().mockResolvedValue(undefined),
+        hasCoverageProvider: vi.fn().mockReturnValue(false),
+        detectCoverageConfig: vi
+            .fn()
+            .mockResolvedValue({ perTestEnabled: false, coverageEnabled: false }),
+        ...overrides,
+    };
+}
+function makeTask(overrides = {}) {
+    return {
+        v: {
+            id: 'file.ts#0',
+            name: 'flipStrictEQ',
+            file: '/src/file.ts',
+            code: 'const x = a !== b',
+            line: 1,
+            col: 10,
+            tests: ['/tests/file.test.ts'],
+        },
+        tests: ['/tests/file.test.ts'],
+        key: 'test-key-1',
+        ...overrides,
+    };
+}
+describe('executePool', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-pool-'));
+        process.exitCode = undefined;
+    });
+    afterEach(async () => {
+        process.exitCode = undefined;
+        await fs.rm(tmpDir, { recursive: true, force: true });
+    });
+    it('initializes adapter with correct worker count', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        const tasks = [makeTask()];
+        await executePool({
+            tasks,
+            adapter,
+            cache,
+            concurrency: 4,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        // workerCount = min(concurrency, tasks.length) = min(4, 1) = 1
+        expect(adapter.init).toHaveBeenCalledWith(1);
+    });
+    it('runs mutants through the adapter and populates cache', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        const task = makeTask({ key: 'unique-key' });
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(adapter.runMutant).toHaveBeenCalledTimes(1);
+        expect(cache['unique-key']).toBeDefined();
+        expect(cache['unique-key'].status).toBe('killed');
+    });
+    it('skips cached tasks without calling runMutant', async () => {
+        const adapter = makeAdapter();
+        const cache = {
+            'cached-key': {
+                status: 'killed',
+                file: '/src/file.ts',
+                line: 1,
+                col: 10,
+                mutator: 'flipStrictEQ',
+            },
+        };
+        await executePool({
+            tasks: [makeTask({ key: 'cached-key' })],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(adapter.runMutant).not.toHaveBeenCalled();
+    });
+    it('marks tasks with no tests as skipped', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        const task = makeTask({ tests: [], key: 'no-tests-key' });
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(adapter.runMutant).not.toHaveBeenCalled();
+        expect(cache['no-tests-key'].status).toBe('skipped');
+    });
+    it('processes multiple tasks', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        const tasks = [
+            makeTask({ key: 'key-1' }),
+            makeTask({ key: 'key-2' }),
+            makeTask({ key: 'key-3' }),
+        ];
+        await executePool({
+            tasks,
+            adapter,
+            cache,
+            concurrency: 2,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(adapter.runMutant).toHaveBeenCalledTimes(3);
+        expect(Object.keys(cache)).toHaveLength(3);
+    });
+    it('shuts down adapter after completion', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        await executePool({
+            tasks: [makeTask()],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(adapter.shutdown).toHaveBeenCalledTimes(1);
+    });
+    it('sets exitCode when kill rate is below threshold', async () => {
+        const adapter = makeAdapter({
+            runMutant: vi
+                .fn()
+                .mockResolvedValue({ status: 'escaped', durationMs: 10 }),
+        });
+        const cache = {};
+        await executePool({
+            tasks: [makeTask()],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            minKillPercent: 80,
+            cwd: tmpDir,
+        });
+        expect(process.exitCode).toBe(1);
+    });
+    it('does not set exitCode when kill rate meets threshold', async () => {
+        const adapter = makeAdapter({
+            runMutant: vi
+                .fn()
+                .mockResolvedValue({ status: 'killed', durationMs: 10 }),
+        });
+        const cache = {};
+        await executePool({
+            tasks: [makeTask()],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            minKillPercent: 80,
+            cwd: tmpDir,
+        });
+        expect(process.exitCode).toBeUndefined();
+    });
+    it('saves cache to disk after completion', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        await executePool({
+            tasks: [makeTask({ key: 'persist-key' })],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        const cacheFile = path.join(tmpDir, '.mutate-cache.json');
+        const content = JSON.parse(await fs.readFile(cacheFile, 'utf8'));
+        expect(content['persist-key']).toBeDefined();
+    });
+    it('handles adapter errors gracefully and still shuts down', async () => {
+        const adapter = makeAdapter({
+            runMutant: vi.fn().mockRejectedValue(new Error('adapter failure')),
+        });
+        const cache = {};
+        await expect(executePool({
+            tasks: [makeTask()],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        })).rejects.toThrow('adapter failure');
+        expect(adapter.shutdown).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/runner/__tests__/tasks.spec.d.ts

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

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

@@ -0,0 +1,95 @@
+import { describe, it, expect } from 'vitest';
+import { prepareTasks } from '../tasks.js';
+import { hash, keyForTests } from '../cache.js';
+function makeVariant(overrides = {}) {
+    return {
+        id: 'file.ts#0',
+        name: 'flipStrictEQ',
+        file: '/src/file.ts',
+        code: 'const x = a !== b',
+        line: 1,
+        col: 10,
+        tests: ['/tests/file.test.ts'],
+        ...overrides,
+    };
+}
+describe('prepareTasks', () => {
+    it('creates tasks with sorted tests and computed cache keys', () => {
+        const v = makeVariant({
+            tests: ['/tests/b.test.ts', '/tests/a.test.ts'],
+        });
+        const tasks = prepareTasks([v], null);
+        expect(tasks).toHaveLength(1);
+        expect(tasks[0].tests).toEqual(['/tests/a.test.ts', '/tests/b.test.ts']);
+        expect(tasks[0].v).toBe(v);
+        // Key should be testSig:codeSig
+        const expectedTestSig = hash(keyForTests(['/tests/a.test.ts', '/tests/b.test.ts']));
+        const expectedCodeSig = hash(v.code);
+        expect(tasks[0].key).toBe(`${expectedTestSig}:${expectedCodeSig}`);
+    });
+    it('produces deterministic keys regardless of test order', () => {
+        const v1 = makeVariant({
+            tests: ['/tests/b.test.ts', '/tests/a.test.ts'],
+        });
+        const v2 = makeVariant({
+            tests: ['/tests/a.test.ts', '/tests/b.test.ts'],
+        });
+        const tasks1 = prepareTasks([v1], null);
+        const tasks2 = prepareTasks([v2], null);
+        expect(tasks1[0].key).toBe(tasks2[0].key);
+    });
+    it('produces different keys for different code', () => {
+        const v1 = makeVariant({ code: 'const x = a !== b' });
+        const v2 = makeVariant({ code: 'const x = a === b' });
+        const tasks = prepareTasks([v1, v2], null);
+        expect(tasks[0].key).not.toBe(tasks[1].key);
+    });
+    it('produces different keys for different test sets', () => {
+        const v1 = makeVariant({ tests: ['/tests/a.test.ts'] });
+        const v2 = makeVariant({ tests: ['/tests/b.test.ts'] });
+        const tasks = prepareTasks([v1, v2], null);
+        expect(tasks[0].key).not.toBe(tasks[1].key);
+    });
+    it('handles variants with no tests', () => {
+        const v = makeVariant({ tests: [] });
+        const tasks = prepareTasks([v], null);
+        expect(tasks).toHaveLength(1);
+        expect(tasks[0].tests).toEqual([]);
+    });
+    it('prunes tests via per-test coverage', () => {
+        const v = makeVariant({
+            file: '/src/file.ts',
+            line: 5,
+            tests: ['/tests/a.test.ts', '/tests/b.test.ts'],
+        });
+        // Only test-a covers line 5 of /src/file.ts
+        const perTestCoverage = new Map();
+        const aCoverage = new Map();
+        aCoverage.set('/src/file.ts', new Set([5, 6, 7]));
+        perTestCoverage.set('/tests/a.test.ts', aCoverage);
+        const bCoverage = new Map();
+        bCoverage.set('/src/file.ts', new Set([10, 11]));
+        perTestCoverage.set('/tests/b.test.ts', bCoverage);
+        const tasks = prepareTasks([v], perTestCoverage);
+        expect(tasks[0].tests).toEqual(['/tests/a.test.ts']);
+    });
+    it('does not prune when perTestCoverage is null', () => {
+        const v = makeVariant({
+            tests: ['/tests/a.test.ts', '/tests/b.test.ts'],
+        });
+        const tasks = prepareTasks([v], null);
+        expect(tasks[0].tests).toHaveLength(2);
+    });
+    it('handles multiple variants', () => {
+        const variants = [
+            makeVariant({ id: 'file.ts#0', code: 'code1' }),
+            makeVariant({ id: 'file.ts#1', code: 'code2' }),
+            makeVariant({ id: 'file.ts#2', code: 'code3' }),
+        ];
+        const tasks = prepareTasks(variants, null);
+        expect(tasks).toHaveLength(3);
+        expect(tasks[0].v.id).toBe('file.ts#0');
+        expect(tasks[1].v.id).toBe('file.ts#1');
+        expect(tasks[2].v.id).toBe('file.ts#2');
+    });
+});

package/dist/runner/__tests__/variants.spec.d.ts

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

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

@@ -0,0 +1,259 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { getTargetFile, enumerateVariantsForTarget, filterTestsByCoverage, enumerateAllVariants, } from '../variants.js';
+import { normalizePath } from '../../utils/normalizePath.js';
+describe('getTargetFile', () => {
+    it('returns the string directly for string targets', () => {
+        expect(getTargetFile('src/foo.ts')).toBe('src/foo.ts');
+    });
+    it('returns the file property for object targets', () => {
+        expect(getTargetFile({ file: 'src/bar.ts', kind: 'module' })).toBe('src/bar.ts');
+    });
+    it('returns the file property without kind', () => {
+        expect(getTargetFile({ file: 'src/baz.ts' })).toBe('src/baz.ts');
+    });
+});
+describe('enumerateVariantsForTarget', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-variants-'));
+    });
+    afterEach(async () => {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+    });
+    it('enumerates variants for a module file with mutable code', async () => {
+        const srcFile = path.join(tmpDir, 'foo.ts');
+        await fs.writeFile(srcFile, 'const x = a === b');
+        const result = await enumerateVariantsForTarget(tmpDir, 'foo.ts');
+        expect(result.length).toBeGreaterThan(0);
+        expect(result[0].id).toBe('foo.ts#0');
+        expect(result[0].file).toBe(srcFile);
+        expect(typeof result[0].name).toBe('string');
+    });
+    it('auto-detects Vue files as vue:script-setup kind', async () => {
+        const vueFile = path.join(tmpDir, 'App.vue');
+        // Write a minimal Vue SFC - the sfc mutator needs @vue/compiler-sfc
+        // which may not be available, so this may return empty (caught error)
+        await fs.writeFile(vueFile, '<script setup>\nconst x = a === b\n</script>');
+        const result = await enumerateVariantsForTarget(tmpDir, 'App.vue');
+        // Either we get results (if @vue/compiler-sfc is available) or empty array (graceful)
+        expect(Array.isArray(result)).toBe(true);
+    });
+    it('uses explicit kind=module for a .vue file', async () => {
+        const vueFile = path.join(tmpDir, 'App.vue');
+        await fs.writeFile(vueFile, 'const x = a && b');
+        const result = await enumerateVariantsForTarget(tmpDir, {
+            file: 'App.vue',
+            kind: 'module',
+        });
+        // Should treat the whole file as a module and find the && mutation
+        expect(result.some((v) => v.name === 'andToOr')).toBe(true);
+    });
+    it('handles absolute paths', async () => {
+        const absFile = path.join(tmpDir, 'abs.ts');
+        await fs.writeFile(absFile, 'const x = a + b');
+        const result = await enumerateVariantsForTarget(tmpDir, absFile);
+        expect(result.length).toBeGreaterThan(0);
+        expect(result[0].file).toBe(absFile);
+    });
+    it('passes include/exclude/max correctly', async () => {
+        const srcFile = path.join(tmpDir, 'multi.ts');
+        await fs.writeFile(srcFile, 'const x = a === b && c || d');
+        const all = await enumerateVariantsForTarget(tmpDir, 'multi.ts');
+        expect(all.length).toBeGreaterThan(1);
+        const limited = await enumerateVariantsForTarget(tmpDir, 'multi.ts', undefined, undefined, 1);
+        expect(limited).toHaveLength(1);
+    });
+    it('filters by include', async () => {
+        const srcFile = path.join(tmpDir, 'inc.ts');
+        await fs.writeFile(srcFile, 'const x = a === b && c || d');
+        const result = await enumerateVariantsForTarget(tmpDir, 'inc.ts', ['andToOr']);
+        expect(result.every((v) => v.name === 'andToOr')).toBe(true);
+    });
+    it('filters by exclude', async () => {
+        const srcFile = path.join(tmpDir, 'exc.ts');
+        await fs.writeFile(srcFile, 'const x = a === b && c');
+        const result = await enumerateVariantsForTarget(tmpDir, 'exc.ts', undefined, ['flipStrictEQ']);
+        expect(result.every((v) => v.name !== 'flipStrictEQ')).toBe(true);
+    });
+    it('returns empty array when file does not exist', async () => {
+        const result = await enumerateVariantsForTarget(tmpDir, 'nonexistent.ts');
+        expect(result).toEqual([]);
+    });
+    it('returns empty for code with no mutable patterns', async () => {
+        const srcFile = path.join(tmpDir, 'clean.ts');
+        await fs.writeFile(srcFile, 'const x = 1');
+        const result = await enumerateVariantsForTarget(tmpDir, 'clean.ts');
+        expect(result).toEqual([]);
+    });
+    it('generates correct id format', async () => {
+        const srcFile = path.join(tmpDir, 'ids.ts');
+        await fs.writeFile(srcFile, 'const x = a + b');
+        const result = await enumerateVariantsForTarget(tmpDir, 'ids.ts');
+        for (let i = 0; i < result.length; i++) {
+            expect(result[i].id).toBe(`ids.ts#${i}`);
+        }
+    });
+});
+describe('filterTestsByCoverage', () => {
+    it('keeps tests that cover the specified line', () => {
+        const perTest = new Map();
+        const fileCoverage = new Map();
+        fileCoverage.set('src/foo.ts', new Set([1, 2, 3]));
+        perTest.set('test-a.ts', fileCoverage);
+        const result = filterTestsByCoverage(perTest, ['test-a.ts'], 'src/foo.ts', 2);
+        expect(result).toEqual(['test-a.ts']);
+    });
+    it('excludes tests that do not cover the specified line', () => {
+        const perTest = new Map();
+        const fileCoverage = new Map();
+        fileCoverage.set('src/foo.ts', new Set([1, 2, 3]));
+        perTest.set('test-a.ts', fileCoverage);
+        const result = filterTestsByCoverage(perTest, ['test-a.ts'], 'src/foo.ts', 99);
+        expect(result).toEqual([]);
+    });
+    it('includes tests that have no coverage data (conservative)', () => {
+        const perTest = new Map();
+        const result = filterTestsByCoverage(perTest, ['test-a.ts'], 'src/foo.ts', 1);
+        expect(result).toEqual(['test-a.ts']);
+    });
+    it('includes tests whose coverage does not track the file (conservative)', () => {
+        const perTest = new Map();
+        perTest.set('test-a.ts', new Map());
+        const result = filterTestsByCoverage(perTest, ['test-a.ts'], 'src/foo.ts', 1);
+        expect(result).toEqual(['test-a.ts']);
+    });
+    it('filters multiple tests correctly', () => {
+        const perTest = new Map();
+        const coverageA = new Map();
+        coverageA.set('src/foo.ts', new Set([1, 2]));
+        perTest.set('test-a.ts', coverageA);
+        const coverageB = new Map();
+        coverageB.set('src/foo.ts', new Set([3, 4]));
+        perTest.set('test-b.ts', coverageB);
+        const result = filterTestsByCoverage(perTest, ['test-a.ts', 'test-b.ts'], 'src/foo.ts', 2);
+        expect(result).toEqual(['test-a.ts']);
+    });
+});
+describe('enumerateAllVariants', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-enumall-'));
+    });
+    afterEach(async () => {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+    });
+    it('enumerates variants for multiple targets and attaches tests', async () => {
+        const fileA = path.join(tmpDir, 'a.ts');
+        const fileB = path.join(tmpDir, 'b.ts');
+        await fs.writeFile(fileA, 'const x = a === b');
+        await fs.writeFile(fileB, 'const y = c + d');
+        const testMap = new Map();
+        testMap.set(normalizePath(fileA), new Set(['/tests/a.test.ts']));
+        testMap.set(normalizePath(fileB), new Set(['/tests/b.test.ts']));
+        const result = await enumerateAllVariants({
+            cwd: tmpDir,
+            targets: ['a.ts', 'b.ts'],
+            testMap,
+            changedFiles: null,
+            coverageData: null,
+            config: {},
+        });
+        expect(result.length).toBeGreaterThan(0);
+        const filesInResult = new Set(result.map((v) => path.basename(v.file)));
+        expect(filesInResult.has('a.ts')).toBe(true);
+        expect(filesInResult.has('b.ts')).toBe(true);
+        // Each variant should have its tests attached
+        for (const v of result) {
+            expect(Array.isArray(v.tests)).toBe(true);
+        }
+    });
+    it('skips targets not in changedFiles set', async () => {
+        const fileA = path.join(tmpDir, 'a.ts');
+        const fileB = path.join(tmpDir, 'b.ts');
+        await fs.writeFile(fileA, 'const x = a === b');
+        await fs.writeFile(fileB, 'const y = c + d');
+        const testMap = new Map();
+        testMap.set(normalizePath(fileA), new Set(['/tests/a.test.ts']));
+        testMap.set(normalizePath(fileB), new Set(['/tests/b.test.ts']));
+        // Only fileA is in changedFiles
+        const changedFiles = new Set([normalizePath(fileA)]);
+        const result = await enumerateAllVariants({
+            cwd: tmpDir,
+            targets: ['a.ts', 'b.ts'],
+            testMap,
+            changedFiles,
+            coverageData: null,
+            config: {},
+        });
+        // All variants should be from a.ts only
+        for (const v of result) {
+            expect(path.basename(v.file)).toBe('a.ts');
+        }
+    });
+    it('filters variants by coverage data', async () => {
+        const fileA = path.join(tmpDir, 'cov.ts');
+        // Write code that produces mutations on different lines
+        await fs.writeFile(fileA, 'const x = a === b\nconst y = c === d');
+        const testMap = new Map();
+        testMap.set(normalizePath(fileA), new Set(['/tests/cov.test.ts']));
+        // Only line 1 is covered
+        const coverageData = {
+            coveredLines: new Map([[normalizePath(fileA), new Set([1])]]),
+        };
+        const all = await enumerateAllVariants({
+            cwd: tmpDir,
+            targets: ['cov.ts'],
+            testMap,
+            changedFiles: null,
+            coverageData: null,
+            config: {},
+        });
+        const filtered = await enumerateAllVariants({
+            cwd: tmpDir,
+            targets: ['cov.ts'],
+            testMap,
+            changedFiles: null,
+            coverageData,
+            config: {},
+        });
+        expect(filtered.length).toBeLessThanOrEqual(all.length);
+        // All filtered variants should be on line 1
+        for (const v of filtered) {
+            expect(v.line).toBe(1);
+        }
+    });
+    it('returns empty array when no targets produce variants', async () => {
+        const fileA = path.join(tmpDir, 'clean.ts');
+        await fs.writeFile(fileA, 'const x = 1');
+        const testMap = new Map();
+        const result = await enumerateAllVariants({
+            cwd: tmpDir,
+            targets: ['clean.ts'],
+            testMap,
+            changedFiles: null,
+            coverageData: null,
+            config: {},
+        });
+        expect(result).toEqual([]);
+    });
+    it('attaches empty tests array when testMap has no entry for target', async () => {
+        const fileA = path.join(tmpDir, 'orphan.ts');
+        await fs.writeFile(fileA, 'const x = a === b');
+        const testMap = new Map(); // no entries
+        const result = await enumerateAllVariants({
+            cwd: tmpDir,
+            targets: ['orphan.ts'],
+            testMap,
+            changedFiles: null,
+            coverageData: null,
+            config: {},
+        });
+        expect(result.length).toBeGreaterThan(0);
+        for (const v of result) {
+            expect(v.tests).toEqual([]);
+        }
+    });
+});

package/dist/runner/args.d.ts

@@ -44,6 +44,11 @@ export declare function parseConcurrency(args: readonly string[]): number;
  * Parse progress mode from CLI args.
  */
 export declare function parseProgressMode(args: readonly string[]): 'bar' | 'list' | 'quiet';
+/**
+ * Extract the config file path from CLI args (before full option parsing).
+ * Handles --config=path, -c=path, --config path, and -c path.
+ */
+export declare function extractConfigPath(args: readonly string[]): string | undefined;
 /**
  * Parse all CLI options.
  */

package/dist/runner/args.js

@@ -87,6 +87,13 @@ export function parseProgressMode(args) {
     const modeArg = progIdx >= 0 ? args[progIdx + 1] || 'bar' : 'bar';
     return modeArg === 'list' ? 'list' : modeArg === 'quiet' ? 'quiet' : 'bar';
 }
+/**
+ * Extract the config file path from CLI args (before full option parsing).
+ * Handles --config=path, -c=path, --config path, and -c path.
+ */
+export function extractConfigPath(args) {
+    return readStringFlag(args, '--config', '-c');
+}
 /**
  * Parse all CLI options.
  */

package/dist/runner/config.js

@@ -19,7 +19,7 @@ const log = createLogger('config');
 async function loadModule(filePath) {
     const moduleUrl = pathToFileURL(filePath).href;
     const mod = await import(moduleUrl);
-    return mod.default || mod;
+    return mod.default ?? mod;
 }
 /**
  * Validate that the loaded configuration has the expected shape.
@@ -27,7 +27,7 @@ async function loadModule(filePath) {
  * the structure is an object and not some other unexpected type.
  */
 function validateConfig(config) {
-    if (typeof config !== 'object' && config === null) {
+    if (typeof config !== 'object' || config === null) {
         return false;
     }
     // Config is valid even if empty; defaults are applied elsewhere.

package/dist/runner/coverage-resolver.d.ts

@@ -0,0 +1,21 @@
+import type { ParsedCliOptions } from './args.js';
+import type { MutineerConfig } from '../types/config.js';
+import type { TestRunnerAdapter } from './types.js';
+import { type CoverageData, type PerTestCoverageMap } from '../utils/coverage.js';
+export interface CoverageResolution {
+    coverageData: CoverageData | null;
+    perTestCoverage: PerTestCoverageMap | null;
+    enableCoverageForBaseline: boolean;
+    wantsPerTestCoverage: boolean;
+    needsCoverageFromBaseline: boolean;
+}
+/**
+ * Resolve all coverage-related configuration from CLI options, config, and adapter detection.
+ * Returns a unified resolution object used by the orchestrator.
+ */
+export declare function resolveCoverageConfig(opts: ParsedCliOptions, cfg: MutineerConfig, adapter: TestRunnerAdapter, cliArgs: readonly string[]): Promise<CoverageResolution>;
+/**
+ * Load coverage data produced during the baseline run.
+ * Mutates and returns an updated CoverageResolution.
+ */
+export declare function loadCoverageAfterBaseline(resolution: CoverageResolution, cwd: string): Promise<CoverageResolution>;