@mutineerjs/mutineer 0.6.0 → 0.8.0

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

@@ -1,4 +1,14 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+const { mockLogDebug } = vi.hoisted(() => ({ mockLogDebug: vi.fn() }));
+vi.mock('../../utils/logger.js', () => ({
+    createLogger: () => ({
+        debug: mockLogDebug,
+        info: (...args) => console.log(...args),
+        warn: (...args) => console.warn(...args),
+        error: (...args) => console.error(...args),
+    }),
+    DEBUG: true,
+}));
 // Mock all heavy dependencies before importing orchestrator
 vi.mock('../config.js', () => ({
     loadMutineerConfig: vi.fn(),
@@ -34,11 +44,43 @@ vi.mock('../discover.js', () => ({
 vi.mock('../changed.js', () => ({
     listChangedFiles: vi.fn().mockReturnValue([]),
 }));
-import { runOrchestrator } from '../orchestrator.js';
+vi.mock('../pool-executor.js', () => ({
+    executePool: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock('../variants.js', () => ({
+    enumerateAllVariants: vi.fn().mockResolvedValue([]),
+    getTargetFile: vi
+        .fn()
+        .mockImplementation((t) => typeof t === 'string' ? t : t.file),
+}));
+vi.mock('../tasks.js', () => ({
+    prepareTasks: vi.fn().mockReturnValue([]),
+}));
+vi.mock('../ts-checker.js', () => ({
+    checkTypes: vi.fn().mockResolvedValue(new Set()),
+    resolveTypescriptEnabled: vi.fn().mockReturnValue(false),
+    resolveTsconfigPath: vi.fn().mockReturnValue(undefined),
+}));
+vi.mock('../../core/schemata.js', () => ({
+    generateSchema: vi
+        .fn()
+        .mockReturnValue({
+        schemaCode: '// @ts-nocheck\n',
+        fallbackIds: new Set(),
+    }),
+}));
+import { runOrchestrator, parseMutantTimeoutMs } from '../orchestrator.js';
 import { loadMutineerConfig } from '../config.js';
 import { createVitestAdapter } from '../vitest/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 { generateSchema } from '../../core/schemata.js';
+import os from 'node:os';
+import fssync from 'node:fs';
+import path from 'node:path';
 const mockAdapter = {
     name: 'vitest',
     init: vi.fn().mockResolvedValue(undefined),
@@ -54,6 +96,95 @@ beforeEach(() => {
     vi.clearAllMocks();
     vi.mocked(createVitestAdapter).mockReturnValue(mockAdapter);
 });
+describe('parseMutantTimeoutMs', () => {
+    it('returns the parsed value for a valid positive number', () => {
+        expect(parseMutantTimeoutMs('5000')).toBe(5000);
+    });
+    it('returns 30_000 for undefined', () => {
+        expect(parseMutantTimeoutMs(undefined)).toBe(30_000);
+    });
+    it('returns 30_000 for zero (kills tightenGT: n>=0 would return 0)', () => {
+        expect(parseMutantTimeoutMs('0')).toBe(30_000);
+    });
+    it('returns 30_000 for Infinity (kills andToOr: || would return Infinity)', () => {
+        expect(parseMutantTimeoutMs('Infinity')).toBe(30_000);
+    });
+    it('returns 30_000 for negative values', () => {
+        expect(parseMutantTimeoutMs('-1')).toBe(30_000);
+    });
+    it('returns 30_000 for non-numeric strings', () => {
+        expect(parseMutantTimeoutMs('abc')).toBe(30_000);
+    });
+});
+describe('runOrchestrator no tests found', () => {
+    afterEach(() => {
+        process.exitCode = undefined;
+    });
+    it('sets exitCode=1 when no tests are found for targets', async () => {
+        process.exitCode = undefined;
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [],
+            testMap: new Map(),
+            directTestMap: new Map(),
+        });
+        await runOrchestrator([], '/cwd');
+        expect(process.exitCode).toBe(1);
+    });
+    it('logs error message when no tests are found for targets', async () => {
+        process.exitCode = undefined;
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [],
+            testMap: new Map(),
+            directTestMap: new Map(),
+        });
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        await runOrchestrator([], '/cwd');
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('No tests found for the selected targets'));
+    });
+    it('does not run baseline when no tests are found', async () => {
+        process.exitCode = undefined;
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [],
+            testMap: new Map(),
+            directTestMap: new Map(),
+        });
+        await runOrchestrator([], '/cwd');
+        expect(mockAdapter.runBaseline).not.toHaveBeenCalled();
+    });
+});
+describe('runOrchestrator discovery logging', () => {
+    afterEach(() => {
+        process.exitCode = undefined;
+    });
+    it('logs "Discovering tests..." before calling autoDiscoverTargetsAndTests', async () => {
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        const consoleSpy = vi.spyOn(console, 'log');
+        await runOrchestrator([], '/cwd');
+        const calls = consoleSpy.mock.calls.map((c) => c[0]);
+        const discoveringIdx = calls.findIndex((m) => m === 'Discovering tests...');
+        expect(discoveringIdx).toBeGreaterThanOrEqual(0);
+    });
+    it('passes an onProgress callback to autoDiscoverTargetsAndTests', async () => {
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        await runOrchestrator([], '/cwd');
+        const [, , onProgress] = vi.mocked(autoDiscoverTargetsAndTests).mock
+            .calls[0];
+        expect(typeof onProgress).toBe('function');
+    });
+    it('logs progress messages emitted by autoDiscoverTargetsAndTests', async () => {
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        vi.mocked(autoDiscoverTargetsAndTests).mockImplementationOnce(async (_root, _cfg, onProgress) => {
+            onProgress?.('Discovery complete: 3 source file(s), 2 test file(s)');
+            return { targets: [], testMap: new Map(), directTestMap: new Map() };
+        });
+        const consoleSpy = vi.spyOn(console, 'log');
+        await runOrchestrator([], '/cwd');
+        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 () => {
         const cfg = {};
@@ -139,3 +270,202 @@ describe('runOrchestrator timeout precedence', () => {
         expect(Number.isFinite(call.timeoutMs)).toBe(true);
     });
 });
+describe('runOrchestrator shard filtering', () => {
+    const targetFile = '/cwd/src/foo.ts';
+    const testFile = '/cwd/src/__tests__/foo.spec.ts';
+    function makeVariant(id) {
+        return {
+            id,
+            name: 'flipEQ',
+            file: targetFile,
+            code: '',
+            line: 1,
+            col: 0,
+            tests: [testFile],
+        };
+    }
+    function makeTask(key) {
+        return {
+            key,
+            v: makeVariant(key),
+            tests: [testFile],
+        };
+    }
+    beforeEach(() => {
+        vi.clearAllMocks();
+        process.exitCode = undefined;
+        vi.mocked(createVitestAdapter).mockReturnValue(mockAdapter);
+        vi.mocked(loadMutineerConfig).mockResolvedValue({
+            targets: [targetFile],
+        });
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [targetFile],
+            testMap: new Map([[targetFile, new Set([testFile])]]),
+            directTestMap: new Map(),
+        });
+        vi.mocked(mockAdapter.runBaseline).mockResolvedValue(true);
+        // Return 4 variants so shard filtering can split them across shards
+        vi.mocked(enumerateAllVariants).mockResolvedValue(['k0', 'k1', 'k2', 'k3'].map(makeVariant));
+        // Map each variant to a task by its id
+        vi.mocked(prepareTasks).mockImplementation((variants) => variants.map((v) => makeTask(v.id)));
+    });
+    afterEach(() => {
+        process.exitCode = undefined;
+    });
+    it('shard 1/2 assigns even-indexed variants', async () => {
+        await runOrchestrator(['--shard', '1/2'], '/cwd');
+        const call = vi.mocked(executePool).mock.calls[0][0];
+        expect(call.tasks.map((t) => t.key)).toEqual(['k0', 'k2']);
+    });
+    it('shard 2/2 assigns odd-indexed variants', async () => {
+        await runOrchestrator(['--shard', '2/2'], '/cwd');
+        const call = vi.mocked(executePool).mock.calls[0][0];
+        expect(call.tasks.map((t) => t.key)).toEqual(['k1', 'k3']);
+    });
+    it('does not call executePool when shard has no variants', async () => {
+        // Only 1 variant total; shard 2/2 gets nothing
+        vi.mocked(enumerateAllVariants).mockResolvedValue([makeVariant('only')]);
+        await runOrchestrator(['--shard', '2/2'], '/cwd');
+        expect(executePool).not.toHaveBeenCalled();
+    });
+    it('propagates shard to executePool', async () => {
+        await runOrchestrator(['--shard', '1/4'], '/cwd');
+        const call = vi.mocked(executePool).mock.calls[0][0];
+        expect(call.shard).toEqual({ index: 1, total: 4 });
+    });
+});
+describe('runOrchestrator --skip-baseline', () => {
+    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('does not call adapter.runBaseline when --skip-baseline is passed', async () => {
+        await runOrchestrator(['--skip-baseline'], '/cwd');
+        expect(mockAdapter.runBaseline).not.toHaveBeenCalled();
+    });
+    it('logs skip message when --skip-baseline is passed', async () => {
+        const consoleSpy = vi.spyOn(console, 'log');
+        await runOrchestrator(['--skip-baseline'], '/cwd');
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Skipping baseline tests (--skip-baseline)'));
+    });
+    it('still calls adapter.runBaseline when --skip-baseline is absent', async () => {
+        vi.mocked(mockAdapter.runBaseline).mockResolvedValue(true);
+        await runOrchestrator([], '/cwd');
+        expect(mockAdapter.runBaseline).toHaveBeenCalledOnce();
+    });
+});
+describe('runOrchestrator schema generation', () => {
+    let tmpDir;
+    const testFile = '/cwd/src/__tests__/foo.spec.ts';
+    beforeEach(() => {
+        tmpDir = fssync.mkdtempSync(path.join(os.tmpdir(), 'mutineer-orch-schema-'));
+        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('calls generateSchema and passes fallbackIds to executePool', async () => {
+        const sourceFile = path.join(tmpDir, 'source.ts');
+        fssync.writeFileSync(sourceFile, 'const x = 1 + 2', 'utf8');
+        const variant = {
+            id: 'source.ts#0',
+            name: 'flipArith',
+            file: sourceFile,
+            code: 'const x = 1 - 2',
+            line: 1,
+            col: 10,
+            tests: [testFile],
+        };
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [sourceFile],
+            testMap: new Map([[sourceFile, new Set([testFile])]]),
+            directTestMap: new Map(),
+        });
+        vi.mocked(enumerateAllVariants).mockResolvedValue([variant]);
+        vi.mocked(prepareTasks).mockReturnValue([
+            {
+                key: 'schema-test-key',
+                v: variant,
+                tests: [testFile],
+            },
+        ]);
+        const mockFallbacks = new Set(['source.ts#0']);
+        vi.mocked(generateSchema).mockReturnValue({
+            schemaCode: '// @ts-nocheck\nconst x = 1',
+            fallbackIds: mockFallbacks,
+        });
+        await runOrchestrator([], tmpDir);
+        expect(generateSchema).toHaveBeenCalledWith(expect.any(String), [variant]);
+        const call = vi.mocked(executePool).mock.calls[0][0];
+        expect(call.fallbackIds).toStrictEqual(mockFallbacks);
+    });
+    it('treats all variants as fallback when source file read fails', async () => {
+        const missingFile = path.join(tmpDir, 'nonexistent.ts');
+        const variant = {
+            id: 'nonexistent.ts#0',
+            name: 'test',
+            file: missingFile,
+            code: 'x',
+            line: 1,
+            col: 0,
+            tests: [testFile],
+        };
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [missingFile],
+            testMap: new Map([[missingFile, new Set([testFile])]]),
+            directTestMap: new Map(),
+        });
+        vi.mocked(enumerateAllVariants).mockResolvedValue([variant]);
+        vi.mocked(prepareTasks).mockReturnValue([
+            { key: 'fallback-key', v: variant, tests: [testFile] },
+        ]);
+        await runOrchestrator([], tmpDir);
+        const call = vi.mocked(executePool).mock.calls[0][0];
+        expect(call.fallbackIds?.has('nonexistent.ts#0')).toBe(true);
+    });
+    it('logs embedded and fallback schema counts', async () => {
+        const sourceFile = path.join(tmpDir, 'source.ts');
+        fssync.writeFileSync(sourceFile, 'const x = 1 + 2', 'utf8');
+        const variant = {
+            id: 'source.ts#0',
+            name: 'flipArith',
+            file: sourceFile,
+            code: 'const x = 1 - 2',
+            line: 1,
+            col: 10,
+            tests: [testFile],
+        };
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [sourceFile],
+            testMap: new Map([[sourceFile, new Set([testFile])]]),
+            directTestMap: new Map(),
+        });
+        vi.mocked(enumerateAllVariants).mockResolvedValue([variant]);
+        vi.mocked(prepareTasks).mockReturnValue([
+            { key: 'log-test-key', v: variant, tests: [testFile] },
+        ]);
+        vi.mocked(generateSchema).mockReturnValue({
+            schemaCode: '// @ts-nocheck\n',
+            fallbackIds: new Set(),
+        });
+        await runOrchestrator([], tmpDir);
+        expect(mockLogDebug).toHaveBeenCalledWith(expect.stringMatching(/Schema: 1 embedded, 0 fallback/));
+    });
+});

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

@@ -189,10 +189,47 @@ describe('executePool', () => {
             progressMode: 'list',
             cwd: tmpDir,
         });
-        const cacheFile = path.join(tmpDir, '.mutate-cache.json');
+        const cacheFile = path.join(tmpDir, '.mutineer-cache.json');
         const content = JSON.parse(await fs.readFile(cacheFile, 'utf8'));
         expect(content['persist-key']).toBeDefined();
     });
+    it('saves to shard-named cache file when shard is provided', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        await executePool({
+            tasks: [makeTask({ key: 'shard-key' })],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+            shard: { index: 2, total: 4 },
+        });
+        const shardFile = path.join(tmpDir, '.mutineer-cache-shard-2-of-4.json');
+        const content = JSON.parse(await fs.readFile(shardFile, 'utf8'));
+        expect(content['shard-key']).toBeDefined();
+        // default file should NOT exist
+        await expect(fs.access(path.join(tmpDir, '.mutineer-cache.json'))).rejects.toThrow();
+    });
+    it('writes shard-suffixed JSON report when shard and reportFormat=json are set', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        await executePool({
+            tasks: [makeTask({ key: 'shard-report-key' })],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+            reportFormat: 'json',
+            shard: { index: 1, total: 2 },
+        });
+        const reportFile = path.join(tmpDir, 'mutineer-report-shard-1-of-2.json');
+        const content = JSON.parse(await fs.readFile(reportFile, 'utf8'));
+        expect(content.schemaVersion).toBe(1);
+        // default report should NOT exist
+        await expect(fs.access(path.join(tmpDir, 'mutineer-report.json'))).rejects.toThrow();
+    });
     it('escaped mutant stores snippets when lines differ', async () => {
         const tmpFile = path.join(tmpDir, 'source.ts');
         await fs.writeFile(tmpFile, 'const x = a + b\n');
@@ -370,6 +407,53 @@ describe('executePool', () => {
         });
         expect(cache['killed-covering-key'].coveringTests).toBeUndefined();
     });
+    it('sets isFallback=true when mutant id is in fallbackIds', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        const task = makeTask({ key: 'fb-key' });
+        const fallbackIds = new Set(['file.ts#0']);
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+            fallbackIds,
+        });
+        expect(adapter.runMutant).toHaveBeenCalledWith(expect.objectContaining({ isFallback: true }), expect.any(Array));
+    });
+    it('sets isFallback=false when mutant id is not in fallbackIds', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        const task = makeTask({ key: 'schema-key' });
+        const fallbackIds = new Set(); // empty — no fallbacks
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+            fallbackIds,
+        });
+        expect(adapter.runMutant).toHaveBeenCalledWith(expect.objectContaining({ isFallback: false }), expect.any(Array));
+    });
+    it('defaults isFallback=true when fallbackIds is not provided', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        const task = makeTask({ key: 'no-fallback-ids-key' });
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+            // no fallbackIds
+        });
+        expect(adapter.runMutant).toHaveBeenCalledWith(expect.objectContaining({ isFallback: true }), expect.any(Array));
+    });
     it('correctly stores snippets for multiple escaped mutants from the same file', async () => {
         const tmpFile = path.join(tmpDir, 'shared.ts');
         await fs.writeFile(tmpFile, 'const x = a + b\n');
@@ -410,6 +494,28 @@ describe('executePool', () => {
         expect(cache['cache-key-3'].originalSnippet).toBe('const x = a + b');
         expect(cache['cache-key-3'].mutatedSnippet).toBe('const x = a / b');
     });
+    it('does not eagerly JSON.stringify cache on every task (only once for save)', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        const stringifySpy = vi.spyOn(JSON, 'stringify');
+        // 3 tasks — if stringify(cache) ran per-task it would be called 3 times with cache
+        await executePool({
+            tasks: [
+                makeTask({ key: 'k1' }),
+                makeTask({ key: 'k2' }),
+                makeTask({ key: 'k3' }),
+            ],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        // saveCacheAtomic calls stringify(cache) exactly once; per-task eager call was removed
+        const cacheStringifyCalls = stringifySpy.mock.calls.filter((args) => args[0] === cache);
+        expect(cacheStringifyCalls.length).toBe(1);
+        stringifySpy.mockRestore();
+    });
     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.spec.d.ts

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

package/dist/runner/__tests__/ts-checker.spec.js

@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'vitest';
+import path from 'node:path';
+import { resolveTypescriptEnabled, resolveTsconfigPath, checkTypes, } from '../ts-checker.js';
+// Directory with a real tsconfig.json (the project root, 3 levels up from __tests__)
+const CWD_WITH_TSCONFIG = path.resolve(import.meta.dirname, '../../../');
+// A temp-like directory unlikely to have tsconfig.json
+const CWD_WITHOUT_TSCONFIG = '/tmp';
+function makeVariant(overrides = {}) {
+    return {
+        id: 'foo.ts#0',
+        name: 'flipEQ',
+        file: '/nonexistent/foo.ts',
+        code: 'const x: number = 1',
+        line: 1,
+        col: 0,
+        tests: [],
+        ...overrides,
+    };
+}
+describe('resolveTsconfigPath', () => {
+    it('returns undefined for boolean true', () => {
+        expect(resolveTsconfigPath({ typescript: true })).toBeUndefined();
+    });
+    it('returns undefined for boolean false', () => {
+        expect(resolveTsconfigPath({ typescript: false })).toBeUndefined();
+    });
+    it('returns tsconfig path from object config', () => {
+        expect(resolveTsconfigPath({ typescript: { tsconfig: './tsconfig.app.json' } })).toBe('./tsconfig.app.json');
+    });
+    it('returns undefined when object config has no tsconfig property', () => {
+        expect(resolveTsconfigPath({ typescript: {} })).toBeUndefined();
+    });
+    it('returns undefined when no typescript config key', () => {
+        expect(resolveTsconfigPath({})).toBeUndefined();
+    });
+});
+describe('resolveTypescriptEnabled', () => {
+    it('CLI false overrides everything', () => {
+        expect(resolveTypescriptEnabled(false, { typescript: true }, CWD_WITH_TSCONFIG)).toBe(false);
+    });
+    it('CLI true overrides everything', () => {
+        expect(resolveTypescriptEnabled(true, { typescript: false }, CWD_WITH_TSCONFIG)).toBe(true);
+    });
+    it('config false disables checking', () => {
+        expect(resolveTypescriptEnabled(undefined, { typescript: false }, CWD_WITH_TSCONFIG)).toBe(false);
+    });
+    it('config true enables checking', () => {
+        expect(resolveTypescriptEnabled(undefined, { typescript: true }, CWD_WITHOUT_TSCONFIG)).toBe(true);
+    });
+    it('config object enables checking', () => {
+        expect(resolveTypescriptEnabled(undefined, { typescript: { tsconfig: './tsconfig.json' } }, CWD_WITHOUT_TSCONFIG)).toBe(true);
+    });
+    it('auto-detects: enabled when tsconfig.json is present in cwd', () => {
+        // The project root has a tsconfig.json
+        expect(resolveTypescriptEnabled(undefined, {}, CWD_WITH_TSCONFIG)).toBe(true);
+    });
+    it('auto-detects: disabled when no tsconfig.json in cwd', () => {
+        // /tmp should not have a tsconfig.json
+        expect(resolveTypescriptEnabled(undefined, {}, CWD_WITHOUT_TSCONFIG)).toBe(false);
+    });
+});
+describe('checkTypes', () => {
+    it('returns empty set for empty variants array', async () => {
+        const result = await checkTypes([], undefined, CWD_WITHOUT_TSCONFIG);
+        expect(result.size).toBe(0);
+    });
+    it('does not flag valid TypeScript code', async () => {
+        const variant = makeVariant({
+            id: 'valid.ts#0',
+            file: '/nonexistent/valid.ts',
+            code: 'const x: number = 42; export default x',
+        });
+        const result = await checkTypes([variant], undefined, CWD_WITHOUT_TSCONFIG);
+        expect(result.has('valid.ts#0')).toBe(false);
+    }, 15000);
+    it('flags TypeScript type mismatch as compile error', async () => {
+        const variant = makeVariant({
+            id: 'bad.ts#0',
+            file: '/nonexistent/bad.ts',
+            code: 'const x: number = "this is not a number"',
+        });
+        const result = await checkTypes([variant], undefined, CWD_WITHOUT_TSCONFIG);
+        expect(result.has('bad.ts#0')).toBe(true);
+    }, 15000);
+    it('checks multiple variants for same file independently', async () => {
+        const valid = makeVariant({
+            id: 'multi.ts#0',
+            file: '/nonexistent/multi.ts',
+            code: 'const x: number = 1',
+        });
+        const invalid = makeVariant({
+            id: 'multi.ts#1',
+            file: '/nonexistent/multi.ts',
+            code: 'const x: number = "bad"',
+        });
+        const result = await checkTypes([valid, invalid], undefined, CWD_WITHOUT_TSCONFIG);
+        expect(result.has('multi.ts#0')).toBe(false);
+        expect(result.has('multi.ts#1')).toBe(true);
+    }, 15000);
+    it('checks variants from different files independently', async () => {
+        const validA = makeVariant({
+            id: 'a.ts#0',
+            file: '/nonexistent/a.ts',
+            code: 'const x: number = 1',
+        });
+        const invalidB = makeVariant({
+            id: 'b.ts#0',
+            file: '/nonexistent/b.ts',
+            code: 'const y: string = 999',
+        });
+        const result = await checkTypes([validA, invalidB], undefined, CWD_WITHOUT_TSCONFIG);
+        expect(result.has('a.ts#0')).toBe(false);
+        expect(result.has('b.ts#0')).toBe(true);
+    }, 15000);
+});

package/dist/runner/args.d.ts

@@ -20,6 +20,16 @@ export interface ParsedCliOptions {
     readonly minKillPercent: number | undefined;
     readonly runner: 'vitest' | 'jest';
     readonly timeout: number | undefined;
+    readonly reportFormat: 'text' | 'json';
+    readonly shard: {
+        index: number;
+        total: number;
+    } | undefined;
+    /** undefined = use config/auto-detect, true = force enable, false = force disable */
+    readonly typescriptCheck: boolean | undefined;
+    /** Vitest workspace project name(s) to filter mutations to */
+    readonly vitestProject: string | undefined;
+    readonly skipBaseline: boolean;
 }
 /**
  * Parse a numeric CLI flag value.
@@ -54,6 +64,14 @@ export declare function parseProgressMode(args: readonly string[]): 'bar' | 'lis
  * Handles --config=path, -c=path, --config path, and -c path.
  */
 export declare function extractConfigPath(args: readonly string[]): string | undefined;
+/**
+ * Parse the --shard <n>/<total> option.
+ * Throws on bad format or out-of-range values.
+ */
+export declare function parseShardOption(args: readonly string[]): {
+    index: number;
+    total: number;
+} | undefined;
 /**
  * Parse all CLI options.
  */