@mutineerjs/mutineer 0.10.0 → 0.11.0

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

@@ -60,6 +60,52 @@ describe('createViteResolver Vue plugin gating', () => {
             await fs.rm(tmpDir, { recursive: true, force: true });
         }
     });
+    it('successfully loads @vitejs/plugin-vue when available and .vue files exist', async () => {
+        vi.doMock('@vitejs/plugin-vue', () => ({
+            default: () => ({}),
+        }));
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-vueok-'));
+        const srcDir = path.join(tmpDir, 'src');
+        await fs.mkdir(srcDir, { recursive: true });
+        await fs.writeFile(path.join(srcDir, 'Comp.vue'), '<template><div/></template>\n', 'utf8');
+        await fs.writeFile(path.join(srcDir, 'a.ts'), 'export const a = 1\n', 'utf8');
+        const importLine = ['im', 'port { a } from "./a"'].join('');
+        await fs.writeFile(path.join(srcDir, 'a.test.ts'), `${importLine}\n`, 'utf8');
+        try {
+            await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+                extensions: ['.vue', '.ts'],
+            });
+            // Should not warn about plugin-vue
+            const pluginVueWarnings = warnSpy.mock.calls.filter((args) => String(args[0]).includes('plugin-vue'));
+            expect(pluginVueWarnings).toHaveLength(0);
+        }
+        finally {
+            vi.doUnmock('@vitejs/plugin-vue');
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('does not load @vitejs/plugin-vue when extensions excludes .vue', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-novueext-'));
+        const srcDir = path.join(tmpDir, 'src');
+        await fs.mkdir(srcDir, { recursive: true });
+        await fs.writeFile(path.join(srcDir, 'a.ts'), 'export const a = 1\n', 'utf8');
+        const importLine = ['im', 'port { a } from "./a"'].join('');
+        await fs.writeFile(path.join(srcDir, 'a.test.ts'), `${importLine}\n`, 'utf8');
+        try {
+            const result = await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+                extensions: ['.ts'],
+            });
+            // Plugin-vue code is skipped entirely; no warnings
+            const pluginVueWarnings = warnSpy.mock.calls.filter((args) => String(args[0]).includes('plugin-vue'));
+            expect(pluginVueWarnings).toHaveLength(0);
+            expect(result.targets.length).toBeGreaterThan(0);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
     it('warns when .vue files exist but @vitejs/plugin-vue fails to load', async () => {
         vi.doMock('@vitejs/plugin-vue', () => {
             throw new Error('Cannot find module @vitejs/plugin-vue');
@@ -86,6 +132,20 @@ describe('createViteResolver Vue plugin gating', () => {
     });
 });
 describe('autoDiscoverTargetsAndTests', () => {
+    it('returns empty result when no test files found', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-notests-'));
+        try {
+            const result = await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+            });
+            expect(result.targets).toHaveLength(0);
+            expect(result.testMap.size).toBe(0);
+            expect(result.directTestMap.size).toBe(0);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
     it('directTestMap only includes direct importers', async () => {
         const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-direct-'));
         const srcDir = path.join(tmpDir, 'src');
@@ -242,6 +302,125 @@ describe('autoDiscoverTargetsAndTests', () => {
             await fs.rm(tmpDir, { recursive: true, force: true });
         }
     });
+    it('excludes files matching excludePaths prefix', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-exclude-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const adminDir = path.join(srcDir, 'admin');
+        const adminFile = path.join(adminDir, 'restricted.ts');
+        const publicFile = path.join(srcDir, 'public.ts');
+        const testFile = path.join(srcDir, 'a.test.ts');
+        await fs.mkdir(adminDir, { recursive: true });
+        await fs.writeFile(adminFile, 'export const restricted = 1\n', 'utf8');
+        await fs.writeFile(publicFile, 'export const pub = 2\n', 'utf8');
+        const importLine = [
+            ['im', 'port { pub } from "./public"'].join(''),
+            ['im', 'port { restricted } from "./admin/restricted"'].join(''),
+        ].join('\n');
+        await fs.writeFile(testFile, `${importLine}\n`, 'utf8');
+        try {
+            const { targets } = await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+                excludePaths: ['src/admin'],
+            });
+            const targetFiles = targets.map((t) => normalizePath(typeof t === 'string' ? t : t.file));
+            expect(targetFiles.some((f) => f.includes('restricted.ts'))).toBe(false);
+            expect(targetFiles.some((f) => f.includes('public.ts'))).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('excludes files matching excludePaths glob pattern', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-excludeglob-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const adminDir = path.join(srcDir, 'admin');
+        const adminFile = path.join(adminDir, 'restricted.ts');
+        const publicFile = path.join(srcDir, 'public.ts');
+        const testFile = path.join(srcDir, 'a.test.ts');
+        await fs.mkdir(adminDir, { recursive: true });
+        await fs.writeFile(adminFile, 'export const restricted = 1\n', 'utf8');
+        await fs.writeFile(publicFile, 'export const pub = 2\n', 'utf8');
+        const importLine = [
+            ['im', 'port { pub } from "./public"'].join(''),
+            ['im', 'port { restricted } from "./admin/restricted"'].join(''),
+        ].join('\n');
+        await fs.writeFile(testFile, `${importLine}\n`, 'utf8');
+        try {
+            const { targets } = await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+                excludePaths: ['src/admin/**'],
+            });
+            const targetFiles = targets.map((t) => normalizePath(typeof t === 'string' ? t : t.file));
+            expect(targetFiles.some((f) => f.includes('restricted.ts'))).toBe(false);
+            expect(targetFiles.some((f) => f.includes('public.ts'))).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('handles unreadable dependency gracefully', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-unreadable-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const sourceFile = path.join(srcDir, 'source.ts');
+        const testFile = path.join(srcDir, 'source.test.ts');
+        await fs.mkdir(srcDir, { recursive: true });
+        // source.ts imports ./ghost which doesn't exist on disk
+        const ghostImport = ['im', 'port { x } from "./ghost"'].join('');
+        await fs.writeFile(sourceFile, `${ghostImport}\nexport const y = 1\n`, 'utf8');
+        const importLine = ['im', 'port { y } from "./source"'].join('');
+        await fs.writeFile(testFile, `${importLine}\n`, 'utf8');
+        try {
+            const { targets } = await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+            });
+            const targetFiles = targets.map((t) => normalizePath(typeof t === 'string' ? t : t.file));
+            expect(targetFiles.some((f) => f.includes('source.ts'))).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('uses default testPatterns when cfg.testPatterns is not set', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-defaultpat-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const moduleFile = path.join(srcDir, 'foo.ts');
+        const testFile = path.join(srcDir, 'foo.spec.ts');
+        await fs.mkdir(srcDir, { recursive: true });
+        await fs.writeFile(moduleFile, 'export const foo = 1\n', 'utf8');
+        const importLine = ['im', 'port { foo } from "./foo"'].join('');
+        await fs.writeFile(testFile, `${importLine}\n`, 'utf8');
+        try {
+            // No testPatterns → uses TEST_PATTERNS_DEFAULT which includes **/*.spec.[jt]s?(x)
+            const { targets } = await autoDiscoverTargetsAndTests(tmpDir, {});
+            const targetFiles = targets.map((t) => normalizePath(typeof t === 'string' ? t : t.file));
+            expect(targetFiles).toContain(normalizePath(moduleFile));
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('assigns vue:script-setup kind to .vue source files', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-vuekind-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const vueFile = path.join(srcDir, 'Comp.vue');
+        const testFile = path.join(srcDir, 'Comp.test.ts');
+        await fs.mkdir(srcDir, { recursive: true });
+        await fs.writeFile(vueFile, '<script setup>\nconst x = 1\n</script>\n', 'utf8');
+        const importLine = ['im', `port Comp from "./Comp.vue"`].join('');
+        await fs.writeFile(testFile, `${importLine}\n`, 'utf8');
+        try {
+            const { targets } = await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+                extensions: ['.vue', '.ts'],
+            });
+            const vueTarget = targets.find((t) => typeof t !== 'string' && normalizePath(t.file).endsWith('Comp.vue'));
+            expect(vueTarget).toBeDefined();
+            expect(typeof vueTarget !== 'string' && vueTarget?.kind).toBe('vue:script-setup');
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
     it('ignores test files when collecting mutate targets', async () => {
         const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-'));
         const srcDir = path.join(tmpDir, 'src');

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

@@ -70,11 +70,14 @@ vi.mock('../../core/schemata.js', () => ({
 import { runOrchestrator, parseMutantTimeoutMs } from '../orchestrator.js';
 import { loadMutineerConfig } from '../config.js';
 import { createVitestAdapter } from '../vitest/index.js';
+import { createJestAdapter } from '../jest/index.js';
 import { autoDiscoverTargetsAndTests } from '../discover.js';
 import { listChangedFiles } from '../changed.js';
 import { executePool } from '../pool-executor.js';
 import { prepareTasks } from '../tasks.js';
-import { enumerateAllVariants } from '../variants.js';
+import { enumerateAllVariants, getTargetFile } from '../variants.js';
+import { resolveTypescriptEnabled, checkTypes } from '../ts-checker.js';
+import { resolveCoverageConfig, loadCoverageAfterBaseline, } from '../coverage-resolver.js';
 import { generateSchema } from '../../core/schemata.js';
 import os from 'node:os';
 import fssync from 'node:fs';
@@ -183,8 +186,8 @@ describe('runOrchestrator discovery logging', () => {
         expect(consoleSpy).toHaveBeenCalledWith('Discovery complete: 3 source file(s), 2 test file(s)');
     });
 });
-describe('runOrchestrator --changed-with-deps diagnostic', () => {
-    it('logs uncovered targets when wantsChangedWithDeps is true', async () => {
+describe('runOrchestrator --changed-with-imports diagnostic', () => {
+    it('logs uncovered targets when wantsChangedWithImports is true', async () => {
         const cfg = {};
         vi.mocked(loadMutineerConfig).mockResolvedValue(cfg);
         const depFile = '/cwd/src/dep.ts';
@@ -195,10 +198,10 @@ describe('runOrchestrator --changed-with-deps diagnostic', () => {
             directTestMap: new Map(),
         });
         const consoleSpy = vi.spyOn(console, 'log');
-        await runOrchestrator(['--changed-with-deps'], '/cwd');
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('1 target(s) from --changed-with-deps have no covering tests and will be skipped'));
+        await runOrchestrator(['--changed-with-imports'], '/cwd');
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('1 target(s) from --changed-with-imports have no covering tests and will be skipped'));
     });
-    it('does not log when all changed-with-deps targets have covering tests', async () => {
+    it('does not log when all changed-with-imports targets have covering tests', async () => {
         const cfg = {};
         vi.mocked(loadMutineerConfig).mockResolvedValue(cfg);
         const depFile = '/cwd/src/dep.ts';
@@ -211,11 +214,11 @@ describe('runOrchestrator --changed-with-deps diagnostic', () => {
         });
         vi.mocked(mockAdapter.runBaseline).mockResolvedValue(true);
         const consoleSpy = vi.spyOn(console, 'log');
-        await runOrchestrator(['--changed-with-deps'], '/cwd');
+        await runOrchestrator(['--changed-with-imports'], '/cwd');
         const diagnosticCalls = consoleSpy.mock.calls.filter(([msg]) => typeof msg === 'string' && msg.includes('have no covering tests'));
         expect(diagnosticCalls).toHaveLength(0);
     });
-    it('does not log diagnostic when wantsChangedWithDeps is false', async () => {
+    it('does not log diagnostic when wantsChangedWithImports is false', async () => {
         const cfg = {};
         vi.mocked(loadMutineerConfig).mockResolvedValue(cfg);
         const depFile = '/cwd/src/dep.ts';
@@ -501,3 +504,293 @@ describe('runOrchestrator schema generation', () => {
         expect(mockLogDebug).toHaveBeenCalledWith(expect.stringMatching(/Schema: 1 embedded, 0 fallback/));
     });
 });
+describe('runOrchestrator jest runner', () => {
+    const targetFile = '/cwd/src/foo.ts';
+    const testFile = '/cwd/src/__tests__/foo.spec.ts';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        process.exitCode = undefined;
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [targetFile],
+            testMap: new Map([[targetFile, new Set([testFile])]]),
+            directTestMap: new Map(),
+        });
+        vi.mocked(createJestAdapter).mockReturnValue(mockAdapter);
+        vi.mocked(mockAdapter.runBaseline).mockResolvedValue(true);
+    });
+    afterEach(() => {
+        process.exitCode = undefined;
+    });
+    it('uses jest adapter when --runner jest is passed', async () => {
+        await runOrchestrator(['--runner', 'jest'], '/cwd');
+        expect(createJestAdapter).toHaveBeenCalled();
+        expect(createVitestAdapter).not.toHaveBeenCalled();
+    });
+});
+describe('runOrchestrator vitestProject', () => {
+    const targetFile = '/cwd/src/foo.ts';
+    const testFile = '/cwd/src/__tests__/foo.spec.ts';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        process.exitCode = undefined;
+        vi.mocked(createVitestAdapter).mockReturnValue(mockAdapter);
+        vi.mocked(mockAdapter.runBaseline).mockResolvedValue(true);
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [targetFile],
+            testMap: new Map([[targetFile, new Set([testFile])]]),
+            directTestMap: new Map(),
+        });
+    });
+    afterEach(() => {
+        process.exitCode = undefined;
+    });
+    it('passes vitestProject from config to adapter', async () => {
+        vi.mocked(loadMutineerConfig).mockResolvedValue({
+            vitestProject: 'my-project',
+        });
+        await runOrchestrator([], '/cwd');
+        expect(createVitestAdapter).toHaveBeenCalledWith(expect.objectContaining({ vitestProject: 'my-project' }));
+    });
+});
+describe('runOrchestrator --changed filter', () => {
+    afterEach(() => {
+        process.exitCode = undefined;
+    });
+    it('skips target not in changedAbs and exits with no tests error', async () => {
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        const targetFile = '/cwd/src/foo.ts';
+        const unchangedFile = '/cwd/src/bar.ts';
+        vi.mocked(listChangedFiles).mockReturnValue([targetFile]); // only targetFile is changed
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [unchangedFile], // bar.ts is not changed -> filtered out
+            testMap: new Map([
+                [unchangedFile, new Set(['/cwd/src/__tests__/bar.spec.ts'])],
+            ]),
+            directTestMap: new Map(),
+        });
+        await runOrchestrator(['--changed'], '/cwd');
+        // With no tests because bar.ts was filtered, should hit the no-tests error
+        expect(process.exitCode).toBe(1);
+    });
+});
+describe('runOrchestrator baseline failure', () => {
+    const targetFile = '/cwd/src/foo.ts';
+    const testFile = '/cwd/src/__tests__/foo.spec.ts';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        process.exitCode = undefined;
+        vi.mocked(createVitestAdapter).mockReturnValue(mockAdapter);
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [targetFile],
+            testMap: new Map([[targetFile, new Set([testFile])]]),
+            directTestMap: new Map(),
+        });
+    });
+    afterEach(() => {
+        process.exitCode = undefined;
+    });
+    it('sets exitCode=1 and returns when baseline fails', async () => {
+        vi.mocked(mockAdapter.runBaseline).mockResolvedValue(false);
+        await runOrchestrator([], '/cwd');
+        expect(process.exitCode).toBe(1);
+        expect(enumerateAllVariants).not.toHaveBeenCalled();
+    });
+});
+describe('runOrchestrator TypeScript checking', () => {
+    let tmpDir;
+    const testFile = '/cwd/src/__tests__/foo.spec.ts';
+    function makeVariant(id, file) {
+        return {
+            id,
+            name: 'returnNull',
+            file,
+            code: 'return null',
+            line: 1,
+            col: 0,
+            tests: [testFile],
+        };
+    }
+    beforeEach(() => {
+        tmpDir = fssync.mkdtempSync(path.join(os.tmpdir(), 'mutineer-orch-ts-'));
+        vi.clearAllMocks();
+        process.exitCode = undefined;
+        vi.mocked(createVitestAdapter).mockReturnValue(mockAdapter);
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        vi.mocked(mockAdapter.runBaseline).mockResolvedValue(true);
+    });
+    afterEach(() => {
+        process.exitCode = undefined;
+        fssync.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('filters compile-error variants and populates cache when TS enabled', async () => {
+        const sourceFile = path.join(tmpDir, 'source.ts');
+        fssync.writeFileSync(sourceFile, 'const x = 1', 'utf8');
+        const goodVariant = makeVariant('source.ts#0', sourceFile);
+        const badVariant = makeVariant('source.ts#1', sourceFile);
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [sourceFile],
+            testMap: new Map([[sourceFile, new Set([testFile])]]),
+            directTestMap: new Map(),
+        });
+        vi.mocked(enumerateAllVariants).mockResolvedValue([goodVariant, badVariant]);
+        vi.mocked(resolveTypescriptEnabled).mockReturnValue(true);
+        vi.mocked(checkTypes).mockResolvedValue(new Set(['source.ts#1']));
+        vi.mocked(prepareTasks)
+            .mockReturnValueOnce([
+            { key: 'source.ts#1', v: badVariant, tests: [testFile] },
+        ]) // compile-error tasks
+            .mockReturnValueOnce([
+            { key: 'source.ts#0', v: goodVariant, tests: [testFile] },
+        ]); // runnable tasks
+        await runOrchestrator([], tmpDir);
+        // executePool should only receive the good variant
+        const poolCall = vi.mocked(executePool).mock.calls[0][0];
+        expect(poolCall.tasks.map((t) => t.key)).toEqual(['source.ts#0']);
+    });
+    it('logs filtered compile-error count when TS enabled', async () => {
+        const sourceFile = path.join(tmpDir, 'source.ts');
+        fssync.writeFileSync(sourceFile, 'const x = 1', 'utf8');
+        const badVariant = makeVariant('source.ts#0', sourceFile);
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [sourceFile],
+            testMap: new Map([[sourceFile, new Set([testFile])]]),
+            directTestMap: new Map(),
+        });
+        vi.mocked(enumerateAllVariants).mockResolvedValue([badVariant]);
+        vi.mocked(resolveTypescriptEnabled).mockReturnValue(true);
+        vi.mocked(checkTypes).mockResolvedValue(new Set(['source.ts#0']));
+        vi.mocked(prepareTasks).mockReturnValue([
+            { key: 'source.ts#0', v: badVariant, tests: [testFile] },
+        ]);
+        const consoleSpy = vi.spyOn(console, 'log');
+        await runOrchestrator([], tmpDir);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('TypeScript: filtered 1 mutant(s) with compile errors'));
+    });
+    it('calls executePool with empty tasks when all variants are compile errors', async () => {
+        const sourceFile = path.join(tmpDir, 'source.ts');
+        fssync.writeFileSync(sourceFile, 'const x = 1', 'utf8');
+        const badVariant = makeVariant('source.ts#0', sourceFile);
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [sourceFile],
+            testMap: new Map([[sourceFile, new Set([testFile])]]),
+            directTestMap: new Map(),
+        });
+        vi.mocked(enumerateAllVariants).mockResolvedValue([badVariant]);
+        vi.mocked(resolveTypescriptEnabled).mockReturnValue(true);
+        vi.mocked(checkTypes).mockResolvedValue(new Set(['source.ts#0']));
+        // First call: compile-error cache population; second call: runnable variants (empty)
+        vi.mocked(prepareTasks)
+            .mockReturnValueOnce([
+            { key: 'source.ts#0', v: badVariant, tests: [testFile] },
+        ])
+            .mockReturnValueOnce([]);
+        await runOrchestrator([], tmpDir);
+        // executePool is still called, but with empty tasks
+        const poolCall = vi.mocked(executePool).mock.calls[0][0];
+        expect(poolCall.tasks).toEqual([]);
+    });
+    it('runs TS checking but skips filtering when no compile errors found', async () => {
+        const sourceFile = path.join(tmpDir, 'source.ts');
+        fssync.writeFileSync(sourceFile, 'const x = 1', 'utf8');
+        const goodVariant = makeVariant('source.ts#0', sourceFile);
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [sourceFile],
+            testMap: new Map([[sourceFile, new Set([testFile])]]),
+            directTestMap: new Map(),
+        });
+        vi.mocked(enumerateAllVariants).mockResolvedValue([goodVariant]);
+        vi.mocked(resolveTypescriptEnabled).mockReturnValue(true);
+        vi.mocked(checkTypes).mockResolvedValue(new Set()); // no compile errors
+        vi.mocked(prepareTasks).mockReturnValue([
+            { key: 'source.ts#0', v: goodVariant, tests: [testFile] },
+        ]);
+        await runOrchestrator([], tmpDir);
+        // All variants are runnable; executePool receives the full task list
+        const poolCall = vi.mocked(executePool).mock.calls[0][0];
+        expect(poolCall.tasks.map((t) => t.key)).toEqual(['source.ts#0']);
+    });
+});
+describe('runOrchestrator misc branches', () => {
+    const targetFile = '/cwd/src/foo.ts';
+    const testFile = '/cwd/src/__tests__/foo.spec.ts';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        process.exitCode = undefined;
+        vi.mocked(createVitestAdapter).mockReturnValue(mockAdapter);
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [targetFile],
+            testMap: new Map([[targetFile, new Set([testFile])]]),
+            directTestMap: new Map(),
+        });
+        vi.mocked(mockAdapter.runBaseline).mockResolvedValue(true);
+        // Reset mocks that may carry over from other describe blocks
+        vi.mocked(resolveCoverageConfig).mockResolvedValue({
+            enableCoverageForBaseline: false,
+            wantsPerTestCoverage: false,
+            coverageData: null,
+        });
+        vi.mocked(loadCoverageAfterBaseline).mockResolvedValue({
+            coverageData: null,
+            perTestCoverage: null,
+        });
+        vi.mocked(resolveTypescriptEnabled).mockReturnValue(false);
+        vi.mocked(checkTypes).mockResolvedValue(new Set());
+        vi.mocked(enumerateAllVariants).mockResolvedValue([]);
+        vi.mocked(prepareTasks).mockReturnValue([]);
+        vi.mocked(getTargetFile).mockImplementation((t) => typeof t === 'string' ? t : t.file);
+    });
+    afterEach(() => {
+        process.exitCode = undefined;
+    });
+    it('logs "only covered lines" when --only-covered-lines is passed', async () => {
+        const consoleSpy = vi.spyOn(console, 'log');
+        await runOrchestrator(['--only-covered-lines'], '/cwd');
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('only covered lines'));
+    });
+    it('uses autoDiscover=false to return empty targets when no cfg.targets set', async () => {
+        vi.mocked(loadMutineerConfig).mockResolvedValue({ autoDiscover: false });
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [targetFile],
+            testMap: new Map(),
+            directTestMap: new Map(),
+        });
+        await runOrchestrator([], '/cwd');
+        // With autoDiscover=false and no cfg.targets, targets is [], no tests found, exit=1
+        expect(process.exitCode).toBe(1);
+    });
+    it('logs coverage collection message when enableCoverageForBaseline is true', async () => {
+        vi.mocked(resolveCoverageConfig).mockResolvedValue({
+            enableCoverageForBaseline: true,
+            wantsPerTestCoverage: false,
+            coverageData: null,
+        });
+        const consoleSpy = vi.spyOn(console, 'log');
+        await runOrchestrator([], '/cwd');
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('collecting coverage'));
+    });
+    it('logs "no mutants" with coverage note when coverageData is non-null', async () => {
+        vi.mocked(loadCoverageAfterBaseline).mockResolvedValue({
+            coverageData: new Map(), // non-null
+            perTestCoverage: null,
+        });
+        const consoleSpy = vi.spyOn(console, 'log');
+        await runOrchestrator([], '/cwd');
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('uncovered lines'));
+    });
+    it('collects test files for relative target path', async () => {
+        const relTarget = 'src/foo.ts';
+        vi.mocked(getTargetFile).mockImplementation((t) => typeof t === 'string' ? relTarget : t.file);
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [relTarget],
+            testMap: new Map([[targetFile, new Set([testFile])]]),
+            directTestMap: new Map(),
+        });
+        // Relative path gets joined with cwd — should match the testMap key
+        await runOrchestrator([], '/cwd');
+        // runBaseline should be called since test was found via relative path join
+        expect(mockAdapter.runBaseline).toHaveBeenCalled();
+    });
+});

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

@@ -211,6 +211,22 @@ describe('executePool', () => {
         // default file should NOT exist
         await expect(fs.access(path.join(tmpDir, '.mutineer-cache.json'))).rejects.toThrow();
     });
+    it('writes mutineer-report.json when reportFormat=json without shard', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        await executePool({
+            tasks: [makeTask({ key: 'json-no-shard-key' })],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+            reportFormat: 'json',
+        });
+        const reportFile = path.join(tmpDir, 'mutineer-report.json');
+        const content = JSON.parse(await fs.readFile(reportFile, 'utf8'));
+        expect(content.schemaVersion).toBe(1);
+    });
     it('writes shard-suffixed JSON report when shard and reportFormat=json are set', async () => {
         const adapter = makeAdapter();
         const cache = {};
@@ -516,6 +532,67 @@ describe('executePool', () => {
         expect(cacheStringifyCalls.length).toBe(1);
         stringifySpy.mockRestore();
     });
+    it('uses bar mode for Progress when progressMode is bar', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        // Should not throw, and bar mode writes to stderr (no isTTY in tests so uses console.log)
+        await executePool({
+            tasks: [makeTask({ key: 'bar-mode-key' })],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'bar',
+            cwd: tmpDir,
+        });
+        expect(cache['bar-mode-key'].status).toBe('killed');
+    });
+    it('stores passingTests when result contains passingTests', async () => {
+        const tmpFile = path.join(tmpDir, 'passing.ts');
+        await fs.writeFile(tmpFile, 'const x = a + b\n');
+        const adapter = makeAdapter({
+            runMutant: vi.fn().mockResolvedValue({
+                status: 'escaped',
+                durationMs: 1,
+                passingTests: ['/tests/foo.spec.ts'],
+            }),
+        });
+        const cache = {};
+        const task = makeTask({
+            key: 'passing-key',
+            v: {
+                id: 'passing.ts#0',
+                name: 'flipArith',
+                file: tmpFile,
+                code: 'const x = a - b\n',
+                line: 1,
+                col: 10,
+                tests: ['/tests/foo.spec.ts'],
+            },
+        });
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(cache['passing-key'].passingTests).toEqual(['/tests/foo.spec.ts']);
+    });
+    it('sets exitCode and logs no-mutants note when minKillPercent is set but no mutants evaluated', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        await executePool({
+            tasks: [],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            minKillPercent: 80,
+            cwd: tmpDir,
+        });
+        expect(process.exitCode).toBe(1);
+    });
     it('handles adapter errors gracefully and still shuts down', async () => {
         const adapter = makeAdapter({
             runMutant: vi.fn().mockRejectedValue(new Error('adapter failure')),

package/dist/runner/__tests__/ts-checker-worker.spec.d.ts

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