@mutineerjs/mutineer 0.5.1 → 0.7.0

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

@@ -0,0 +1,306 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+// Mock all heavy dependencies before importing orchestrator
+vi.mock('../config.js', () => ({
+    loadMutineerConfig: vi.fn(),
+}));
+vi.mock('../cache.js', () => ({
+    clearCacheOnStart: vi.fn().mockResolvedValue(undefined),
+    readMutantCache: vi.fn().mockResolvedValue({}),
+}));
+vi.mock('../vitest/index.js', () => ({
+    createVitestAdapter: vi.fn(),
+}));
+vi.mock('../jest/index.js', () => ({
+    createJestAdapter: vi.fn(),
+}));
+vi.mock('../coverage-resolver.js', () => ({
+    resolveCoverageConfig: vi.fn().mockResolvedValue({
+        enableCoverageForBaseline: false,
+        wantsPerTestCoverage: false,
+        coverageData: null,
+    }),
+    loadCoverageAfterBaseline: vi.fn().mockResolvedValue({
+        coverageData: null,
+        perTestCoverage: null,
+    }),
+}));
+vi.mock('../discover.js', () => ({
+    autoDiscoverTargetsAndTests: vi.fn().mockResolvedValue({
+        targets: [],
+        testMap: new Map(),
+        directTestMap: new Map(),
+    }),
+}));
+vi.mock('../changed.js', () => ({
+    listChangedFiles: vi.fn().mockReturnValue([]),
+}));
+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([]),
+}));
+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';
+const mockAdapter = {
+    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 }),
+};
+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 = {};
+        vi.mocked(loadMutineerConfig).mockResolvedValue(cfg);
+        const depFile = '/cwd/src/dep.ts';
+        vi.mocked(listChangedFiles).mockReturnValue([depFile]);
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [depFile],
+            testMap: new Map(), // dep has no covering tests
+            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'));
+    });
+    it('does not log when all changed-with-deps targets have covering tests', async () => {
+        const cfg = {};
+        vi.mocked(loadMutineerConfig).mockResolvedValue(cfg);
+        const depFile = '/cwd/src/dep.ts';
+        const testFile = '/cwd/src/__tests__/dep.spec.ts';
+        vi.mocked(listChangedFiles).mockReturnValue([depFile]);
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [depFile],
+            testMap: new Map([[depFile, new Set([testFile])]]),
+            directTestMap: new Map(),
+        });
+        vi.mocked(mockAdapter.runBaseline).mockResolvedValue(true);
+        const consoleSpy = vi.spyOn(console, 'log');
+        await runOrchestrator(['--changed-with-deps'], '/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 () => {
+        const cfg = {};
+        vi.mocked(loadMutineerConfig).mockResolvedValue(cfg);
+        const depFile = '/cwd/src/dep.ts';
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [depFile],
+            testMap: new Map(),
+            directTestMap: new Map(),
+        });
+        const consoleSpy = vi.spyOn(console, 'log');
+        await runOrchestrator([], '/cwd');
+        const diagnosticCalls = consoleSpy.mock.calls.filter(([msg]) => typeof msg === 'string' && msg.includes('have no covering tests'));
+        expect(diagnosticCalls).toHaveLength(0);
+    });
+});
+describe('runOrchestrator timeout precedence', () => {
+    it('uses CLI --timeout when provided', async () => {
+        const cfg = {};
+        vi.mocked(loadMutineerConfig).mockResolvedValue(cfg);
+        await runOrchestrator(['--timeout', '5000'], '/cwd');
+        expect(createVitestAdapter).toHaveBeenCalledWith(expect.objectContaining({ timeoutMs: 5000 }));
+    });
+    it('uses config timeout when CLI flag is absent', async () => {
+        const cfg = { timeout: 10000 };
+        vi.mocked(loadMutineerConfig).mockResolvedValue(cfg);
+        await runOrchestrator([], '/cwd');
+        expect(createVitestAdapter).toHaveBeenCalledWith(expect.objectContaining({ timeoutMs: 10000 }));
+    });
+    it('CLI --timeout takes precedence over config timeout', async () => {
+        const cfg = { timeout: 10000 };
+        vi.mocked(loadMutineerConfig).mockResolvedValue(cfg);
+        await runOrchestrator(['--timeout', '2000'], '/cwd');
+        expect(createVitestAdapter).toHaveBeenCalledWith(expect.objectContaining({ timeoutMs: 2000 }));
+    });
+    it('falls back to MUTANT_TIMEOUT_MS default when neither CLI nor config timeout set', async () => {
+        const cfg = {};
+        vi.mocked(loadMutineerConfig).mockResolvedValue(cfg);
+        await runOrchestrator([], '/cwd');
+        expect(createVitestAdapter).toHaveBeenCalledWith(expect.objectContaining({ timeoutMs: 30_000 }));
+    });
+    it('env var MUTINEER_MUTANT_TIMEOUT_MS affects default when no CLI/config timeout', async () => {
+        const cfg = {};
+        vi.mocked(loadMutineerConfig).mockResolvedValue(cfg);
+        const orig = process.env.MUTINEER_MUTANT_TIMEOUT_MS;
+        // env var is read at module load time, so we can only verify the default
+        // is used when no cli/config override is present
+        process.env.MUTINEER_MUTANT_TIMEOUT_MS = orig;
+        await runOrchestrator([], '/cwd');
+        const call = vi.mocked(createVitestAdapter).mock.calls[0][0];
+        expect(call.timeoutMs).toBeGreaterThan(0);
+        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 makeTask(key) {
+        return {
+            key,
+            v: {
+                id: `${key}`,
+                name: 'flipEQ',
+                file: targetFile,
+                code: '',
+                line: 1,
+                col: 0,
+                tests: [testFile],
+            },
+            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 a non-empty variants array so orchestrator doesn't exit early
+        vi.mocked(enumerateAllVariants).mockResolvedValue([{}]);
+        const tasks = ['k0', 'k1', 'k2', 'k3'].map(makeTask);
+        vi.mocked(prepareTasks).mockReturnValue(tasks);
+    });
+    afterEach(() => {
+        process.exitCode = undefined;
+    });
+    it('shard 1/2 assigns even-indexed tasks', 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 tasks', 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 tasks', async () => {
+        // Only 1 task total; shard 2/2 gets nothing
+        vi.mocked(prepareTasks).mockReturnValue([makeTask('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 });
+    });
+});

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');
@@ -410,6 +447,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/args.d.ts

@@ -19,6 +19,12 @@ export interface ParsedCliOptions {
     readonly progressMode: 'bar' | 'list' | 'quiet';
     readonly minKillPercent: number | undefined;
     readonly runner: 'vitest' | 'jest';
+    readonly timeout: number | undefined;
+    readonly reportFormat: 'text' | 'json';
+    readonly shard: {
+        index: number;
+        total: number;
+    } | undefined;
 }
 /**
  * Parse a numeric CLI flag value.
@@ -36,6 +42,10 @@ export declare function readStringFlag(args: readonly string[], flag: string, al
  * Validate a percentage value (0-100).
  */
 export declare function validatePercent(value: number | undefined, source: string): number | undefined;
+/**
+ * Validate a timeout value (must be a positive finite number).
+ */
+export declare function validatePositiveMs(value: number | undefined, source: string): number | undefined;
 /**
  * Parse concurrency from CLI args or use default.
  */
@@ -49,6 +59,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.
  */

package/dist/runner/args.js

@@ -70,6 +70,17 @@ export function validatePercent(value, source) {
     }
     return value;
 }
+/**
+ * Validate a timeout value (must be a positive finite number).
+ */
+export function validatePositiveMs(value, source) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error(`Invalid ${source}: expected a positive number (received ${value})`);
+    }
+    return value;
+}
 /**
  * Parse concurrency from CLI args or use default.
  */
@@ -94,6 +105,28 @@ export function parseProgressMode(args) {
 export function extractConfigPath(args) {
     return readStringFlag(args, '--config', '-c');
 }
+/**
+ * Parse the --shard <n>/<total> option.
+ * Throws on bad format or out-of-range values.
+ */
+export function parseShardOption(args) {
+    const raw = readStringFlag(args, '--shard');
+    if (raw === undefined)
+        return undefined;
+    const match = /^(\d+)\/(\d+)$/.exec(raw);
+    if (!match) {
+        throw new Error(`Invalid --shard format: expected <n>/<total>, got "${raw}"`);
+    }
+    const index = parseInt(match[1], 10);
+    const total = parseInt(match[2], 10);
+    if (total < 1) {
+        throw new Error(`Invalid --shard: total must be >= 1 (got ${total})`);
+    }
+    if (index < 1 || index > total) {
+        throw new Error(`Invalid --shard: index must be between 1 and ${total} (got ${index})`);
+    }
+    return { index, total };
+}
 /**
  * Parse all CLI options.
  */
@@ -115,6 +148,10 @@ export function parseCliOptions(args, cfg) {
     const cliKillPercent = validatePercent(readNumberFlag(args, '--min-kill-percent'), '--min-kill-percent');
     const configKillPercent = validatePercent(cfg.minKillPercent, 'mutineer.config minKillPercent');
     const minKillPercent = cliKillPercent ?? configKillPercent;
+    const timeout = validatePositiveMs(readNumberFlag(args, '--timeout'), '--timeout');
+    const reportFlag = readStringFlag(args, '--report');
+    const reportFormat = reportFlag === 'json' || cfg.report === 'json' ? 'json' : 'text';
+    const shard = parseShardOption(args);
     return {
         configPath,
         wantsChanged,
@@ -126,5 +163,8 @@ export function parseCliOptions(args, cfg) {
         progressMode,
         minKillPercent,
         runner,
+        timeout,
+        reportFormat,
+        shard,
     };
 }

package/dist/runner/cache.d.ts

@@ -5,14 +5,27 @@
  * Handles reading, writing, and decoding cache entries.
  */
 import type { MutantCacheEntry } from '../types/mutant.js';
+/**
+ * Get the cache filename for a given shard (or the default if none).
+ */
+export declare function getCacheFilename(shard?: {
+    index: number;
+    total: number;
+}): string;
 /**
  * Clear the cache file at the start of a run.
  */
-export declare function clearCacheOnStart(cwd: string): Promise<void>;
+export declare function clearCacheOnStart(cwd: string, shard?: {
+    index: number;
+    total: number;
+}): Promise<void>;
 /**
  * Save cache atomically using a temp file + rename.
  */
-export declare function saveCacheAtomic(cwd: string, cache: Record<string, MutantCacheEntry>): Promise<void>;
+export declare function saveCacheAtomic(cwd: string, cache: Record<string, MutantCacheEntry>, shard?: {
+    index: number;
+    total: number;
+}): Promise<void>;
 /**
  * Decode a cache key into its component parts.
  * Cache keys have the format: testSig:codeSig:file:line,col:mutator
@@ -35,4 +48,7 @@ export declare function hash(s: string): string;
  * Read the mutant cache from disk.
  * Normalizes both old (string status) and new (object) formats.
  */
-export declare function readMutantCache(cwd: string): Promise<Record<string, MutantCacheEntry>>;
+export declare function readMutantCache(cwd: string, shard?: {
+    index: number;
+    total: number;
+}): Promise<Record<string, MutantCacheEntry>>;

package/dist/runner/cache.js

@@ -7,12 +7,19 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import crypto from 'node:crypto';
-const CACHE_FILENAME = '.mutate-cache.json';
+/**
+ * Get the cache filename for a given shard (or the default if none).
+ */
+export function getCacheFilename(shard) {
+    if (!shard)
+        return '.mutineer-cache.json';
+    return `.mutineer-cache-shard-${shard.index}-of-${shard.total}.json`;
+}
 /**
  * Clear the cache file at the start of a run.
  */
-export async function clearCacheOnStart(cwd) {
-    const p = path.join(cwd, CACHE_FILENAME);
+export async function clearCacheOnStart(cwd, shard) {
+    const p = path.join(cwd, getCacheFilename(shard));
     try {
         await fs.unlink(p);
     }
@@ -23,8 +30,8 @@ export async function clearCacheOnStart(cwd) {
 /**
  * Save cache atomically using a temp file + rename.
  */
-export async function saveCacheAtomic(cwd, cache) {
-    const p = path.join(cwd, CACHE_FILENAME);
+export async function saveCacheAtomic(cwd, cache, shard) {
+    const p = path.join(cwd, getCacheFilename(shard));
     const tmp = p + '.tmp';
     const json = JSON.stringify(cache, null, 2);
     await fs.writeFile(tmp, json, 'utf8');
@@ -87,8 +94,8 @@ export function hash(s) {
  * Read the mutant cache from disk.
  * Normalizes both old (string status) and new (object) formats.
  */
-export async function readMutantCache(cwd) {
-    const p = path.join(cwd, CACHE_FILENAME);
+export async function readMutantCache(cwd, shard) {
+    const p = path.join(cwd, getCacheFilename(shard));
     try {
         const data = await fs.readFile(p, 'utf8');
         const raw = JSON.parse(data);

package/dist/runner/changed.js

@@ -1,7 +1,6 @@
 import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 import fs from 'node:fs';
-import { createRequire } from 'node:module';
 import { normalizePath } from '../utils/normalizePath.js';
 import { createLogger } from '../utils/logger.js';
 const log = createLogger('changed');
@@ -50,52 +49,25 @@ function resolveLocalDependencies(file, cwd, seen = new Set(), maxDepth = 1, cur
             const dep = match[1];
             if (!dep.startsWith('.'))
                 continue;
-            try {
-                const require = createRequire(file);
-                let resolvedPath;
-                // Try direct resolution first
-                try {
-                    resolvedPath = require.resolve(dep);
-                }
-                catch {
-                    // Try different extensions if direct resolution fails
-                    for (const ext of SUPPORTED_EXTENSIONS) {
-                        try {
-                            // Try replacing existing extension
-                            resolvedPath = require.resolve(dep.replace(/\.(js|ts|vue)$/, ext));
-                            break;
-                        }
-                        catch {
-                            try {
-                                // Try adding extension
-                                resolvedPath = require.resolve(dep + ext);
-                                break;
-                            }
-                            catch {
-                                continue;
-                            }
-                        }
-                    }
-                }
-                if (!resolvedPath) {
-                    log.warn(`Could not resolve path for dependency ${dep} in ${file}`);
+            const dir = path.dirname(file);
+            const base = dep.replace(/\.(js|ts|mjs|cjs|vue)$/, '');
+            const candidates = [dep, ...SUPPORTED_EXTENSIONS.map((ext) => base + ext)];
+            let resolvedPath;
+            for (const candidate of candidates) {
+                const abs = normalizePath(path.resolve(dir, candidate));
+                if (abs.includes('node_modules') || !abs.startsWith(cwd))
                     continue;
+                if (fs.existsSync(abs)) {
+                    resolvedPath = abs;
+                    break;
                 }
-                // Skip anything outside the repo/cwd, node_modules, tests, or missing
-                if (!resolvedPath.startsWith(cwd) ||
-                    resolvedPath.includes('node_modules'))
-                    continue;
-                if (TEST_FILE_PATTERN.test(resolvedPath))
-                    continue;
-                if (!fs.existsSync(resolvedPath))
-                    continue;
-                deps.push(normalizePath(resolvedPath));
-                deps.push(...resolveLocalDependencies(resolvedPath, cwd, seen, maxDepth, currentDepth + 1));
             }
-            catch (err) {
-                log.warn(`Failed to resolve dependency ${dep} in ${file}: ${err}`);
+            if (!resolvedPath)
                 continue;
-            }
+            if (TEST_FILE_PATTERN.test(resolvedPath))
+                continue;
+            deps.push(resolvedPath);
+            deps.push(...resolveLocalDependencies(resolvedPath, cwd, seen, maxDepth, currentDepth + 1));
         }
     }
     return [...new Set(deps)];

package/dist/runner/cleanup.d.ts

@@ -1,4 +1,6 @@
 /**
  * Clean up all __mutineer__ temp directories created during mutation testing.
  */
-export declare function cleanupMutineerDirs(cwd: string): Promise<void>;
+export declare function cleanupMutineerDirs(cwd: string, opts?: {
+    includeCacheFiles?: boolean;
+}): Promise<void>;