@mutineerjs/mutineer 0.6.0 → 0.8.0

package/dist/runner/args.js

@@ -105,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.
  */
@@ -127,6 +149,16 @@ export function parseCliOptions(args, cfg) {
     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);
+    const typescriptCheck = args.includes('--typescript')
+        ? true
+        : args.includes('--no-typescript')
+            ? false
+            : undefined;
+    const vitestProject = readStringFlag(args, '--vitest-project');
+    const skipBaseline = args.includes('--skip-baseline');
     return {
         configPath,
         wantsChanged,
@@ -139,5 +171,10 @@ export function parseCliOptions(args, cfg) {
         minKillPercent,
         runner,
         timeout,
+        reportFormat,
+        shard,
+        typescriptCheck,
+        vitestProject,
+        skipBaseline,
     };
 }

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/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>;

package/dist/runner/cleanup.js

@@ -2,9 +2,9 @@ import fs from 'node:fs/promises';
 /**
  * Clean up all __mutineer__ temp directories created during mutation testing.
  */
-export async function cleanupMutineerDirs(cwd) {
+export async function cleanupMutineerDirs(cwd, opts = {}) {
     const glob = await import('fast-glob');
-    const dirs = await glob.default('**/__mutineer__', {
+    const dirs = await glob.default(['__mutineer__', '**/__mutineer__'], {
         cwd,
         onlyDirectories: true,
         absolute: true,
@@ -18,4 +18,21 @@ export async function cleanupMutineerDirs(cwd) {
             // Ignore cleanup errors
         }
     }
+    if (opts.includeCacheFiles) {
+        // Remove cache files (new name + legacy .mutate-cache* for migration)
+        const cacheFiles = await glob.default([
+            '.mutineer-cache*.json',
+            '.mutineer-cache*.json.tmp',
+            '.mutate-cache*.json',
+            '.mutate-cache*.json.tmp',
+        ], { cwd, absolute: true });
+        for (const f of cacheFiles) {
+            try {
+                await fs.unlink(f);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    }
 }

package/dist/runner/coverage-resolver.js

@@ -15,7 +15,7 @@ export async function resolveCoverageConfig(opts, cfg, adapter, cliArgs) {
         ? true
         : coveragePreference === false
             ? false
-            : isCoverageRequestedInArgs([...cliArgs]) || coverageConfig.coverageEnabled;
+            : isCoverageRequestedInArgs([...cliArgs]);
     // Load pre-existing coverage data if provided
     let coverageData = null;
     if (opts.coverageFilePath) {

package/dist/runner/discover.d.ts

@@ -5,4 +5,4 @@ export interface DiscoveryResult {
     readonly testMap: TestMap;
     readonly directTestMap: TestMap;
 }
-export declare function autoDiscoverTargetsAndTests(root: string, cfg: MutineerConfig): Promise<DiscoveryResult>;
+export declare function autoDiscoverTargetsAndTests(root: string, cfg: MutineerConfig, onProgress?: (msg: string) => void): Promise<DiscoveryResult>;

package/dist/runner/discover.js

@@ -200,7 +200,7 @@ async function createResolver(rootAbs, exts) {
         return createNodeResolver();
     }
 }
-export async function autoDiscoverTargetsAndTests(root, cfg) {
+export async function autoDiscoverTargetsAndTests(root, cfg, onProgress) {
     const rootAbs = path.resolve(root);
     const sourceRoots = toArray(cfg.source ?? 'src').map((s) => path.resolve(rootAbs, s));
     const exts = new Set(toArray(cfg.extensions ?? EXT_DEFAULT));
@@ -219,6 +219,7 @@ export async function autoDiscoverTargetsAndTests(root, cfg) {
     if (!tests.length)
         return { targets: [], testMap: new Map(), directTestMap: new Map() };
     const testSet = new Set(tests.map((t) => normalizePath(t)));
+    onProgress?.(`Found ${tests.length} test file(s), resolving imports...`);
     // 2) Create resolver (Vite if available, otherwise Node-based fallback)
     const { resolve, cleanup } = await createResolver(rootAbs, exts);
     const targets = new Map();
@@ -226,6 +227,7 @@ export async function autoDiscoverTargetsAndTests(root, cfg) {
     const directTestMap = new Map();
     const contentCache = new Map();
     const resolveCache = new Map(); // key: importer\0spec -> resolved id
+    const childrenCache = new Map(); // key: normalized file -> resolved child abs paths
     async function crawl(absFile, depth, seen, currentTestAbs) {
         if (depth > MAX_CRAWL_DEPTH)
             return; // sane guard for huge graphs
@@ -266,27 +268,34 @@ export async function autoDiscoverTargetsAndTests(root, cfg) {
         }
         if (!code)
             return;
-        // find import specs and resolve relative to absFile
-        for (const spec of extractImportSpecs(code)) {
-            if (!spec)
-                continue;
-            const cacheKey = `${absFile}\0${spec}`;
-            let resolved = resolveCache.get(cacheKey);
-            if (!resolved) {
-                resolved = await resolve(spec, absFile);
-                resolveCache.set(cacheKey, resolved);
+        // find import specs and resolve relative to absFile, memoized per file
+        let children = childrenCache.get(key);
+        if (children === undefined) {
+            const resolved = [];
+            for (const spec of extractImportSpecs(code)) {
+                if (!spec)
+                    continue;
+                const cacheKey = `${absFile}\0${spec}`;
+                let resolvedId = resolveCache.get(cacheKey);
+                if (!resolvedId) {
+                    resolvedId = await resolve(spec, absFile);
+                    resolveCache.set(cacheKey, resolvedId);
+                }
+                // vite ids could be URLs; ensure we turn into absolute disk path when possible
+                const next = path.isAbsolute(resolvedId)
+                    ? resolvedId
+                    : normalizePath(path.resolve(rootAbs, resolvedId));
+                // skip node_modules and virtual ids
+                if (next.includes('/node_modules/'))
+                    continue;
+                if (!path.isAbsolute(next))
+                    continue;
+                resolved.push(next);
             }
-            // vite ids could be URLs; ensure we turn into absolute disk path when possible
-            const next = path.isAbsolute(resolved)
-                ? resolved
-                : normalizePath(path.resolve(rootAbs, resolved));
-            // skip node_modules and virtual ids
-            if (next.includes('/node_modules/'))
-                continue;
-            if (!path.isAbsolute(next))
-                continue;
-            await crawl(next, depth + 1, seen, currentTestAbs);
+            childrenCache.set(key, resolved);
+            children = resolved;
         }
+        await Promise.all(children.map((next) => crawl(next, depth + 1, seen, currentTestAbs)));
     }
     try {
         await Promise.all(tests.map(async (testAbs) => {
@@ -312,6 +321,7 @@ export async function autoDiscoverTargetsAndTests(root, cfg) {
                 await crawl(abs, 0, seen, testAbs);
             }
         }));
+        onProgress?.(`Discovery complete: ${targets.size} source file(s), ${tests.length} test file(s)`);
         return { targets: Array.from(targets.values()), testMap, directTestMap };
     }
     finally {

package/dist/runner/orchestrator.d.ts

@@ -9,5 +9,6 @@
  * 5. Execute mutants via worker pool
  * 6. Report results
  */
+export declare function parseMutantTimeoutMs(raw: string | undefined): number;
 export { readMutantCache } from './cache.js';
 export declare function runOrchestrator(cliArgs: string[], cwd: string): Promise<void>;

package/dist/runner/orchestrator.js

@@ -10,8 +10,12 @@
  * 6. Report results
  */
 import path from 'node:path';
+import fs from 'node:fs';
 import os from 'node:os';
+import { render } from 'ink';
+import { createElement } from 'react';
 import { normalizePath } from '../utils/normalizePath.js';
+import { PoolSpinner } from '../utils/PoolSpinner.js';
 import { autoDiscoverTargetsAndTests } from './discover.js';
 import { listChangedFiles } from './changed.js';
 import { loadMutineerConfig } from './config.js';
@@ -21,16 +25,19 @@ import { createLogger } from '../utils/logger.js';
 import { extractConfigPath, parseCliOptions } from './args.js';
 import { clearCacheOnStart, readMutantCache } from './cache.js';
 import { getTargetFile, enumerateAllVariants } from './variants.js';
+import { generateSchema } from '../core/schemata.js';
+import { getSchemaFilePath } from './shared/mutant-paths.js';
 import { resolveCoverageConfig, loadCoverageAfterBaseline, } from './coverage-resolver.js';
 import { prepareTasks } from './tasks.js';
 import { executePool } from './pool-executor.js';
+import { checkTypes, resolveTypescriptEnabled, resolveTsconfigPath, } from './ts-checker.js';
 const log = createLogger('orchestrator');
 // Per-mutant test timeout (ms). Can be overridden with env MUTINEER_MUTANT_TIMEOUT_MS
-const MUTANT_TIMEOUT_MS = (() => {
-    const raw = process.env.MUTINEER_MUTANT_TIMEOUT_MS;
+export function parseMutantTimeoutMs(raw) {
     const n = raw ? Number(raw) : NaN;
     return Number.isFinite(n) && n > 0 ? n : 30_000;
-})();
+}
+const MUTANT_TIMEOUT_MS = parseMutantTimeoutMs(process.env.MUTINEER_MUTANT_TIMEOUT_MS);
 // Re-export readMutantCache for external use
 export { readMutantCache } from './cache.js';
 export async function runOrchestrator(cliArgs, cwd) {
@@ -38,14 +45,17 @@ export async function runOrchestrator(cliArgs, cwd) {
     const cfgPath = extractConfigPath(cliArgs);
     const cfg = await loadMutineerConfig(cwd, cfgPath);
     const opts = parseCliOptions(cliArgs, cfg);
-    await clearCacheOnStart(cwd);
+    await clearCacheOnStart(cwd, opts.shard);
     // Create test runner adapter
+    const vitestProject = opts.vitestProject ??
+        (typeof cfg.vitestProject === 'string' ? cfg.vitestProject : undefined);
     const adapter = (opts.runner === 'jest' ? createJestAdapter : createVitestAdapter)({
         cwd,
         concurrency: opts.concurrency,
         timeoutMs: opts.timeout ?? cfg.timeout ?? MUTANT_TIMEOUT_MS,
         config: cfg,
         cliArgs,
+        vitestProject,
     });
     // 2. Resolve coverage configuration
     const coverage = await resolveCoverageConfig(opts, cfg, adapter, cliArgs);
@@ -66,8 +76,9 @@ export async function runOrchestrator(cliArgs, cwd) {
         }))
         : null;
     // 4. Discover targets and tests
-    const cache = await readMutantCache(cwd);
-    const discovered = await autoDiscoverTargetsAndTests(cwd, cfg);
+    const cache = await readMutantCache(cwd, opts.shard);
+    log.info('Discovering tests...');
+    const discovered = await autoDiscoverTargetsAndTests(cwd, cfg, (msg) => log.info(msg));
     const { testMap, directTestMap } = discovered;
     const targets = cfg.targets?.length
         ? [...cfg.targets]
@@ -104,24 +115,30 @@ export async function runOrchestrator(cliArgs, cwd) {
         }
     }
     if (!baselineTests.length) {
-        log.info('No tests found for targets. Exiting.');
+        log.error('No tests found for the selected targets. Ensure your source files are covered by at least one test file.');
+        process.exitCode = 1;
         return;
     }
     // 5. Run baseline tests (with coverage if needed for filtering)
-    log.info(`Running ${baselineTests.length} baseline tests${coverage.enableCoverageForBaseline ? ' (collecting coverage)' : ''}\u2026`);
-    const baselineOk = await adapter.runBaseline(baselineTests, {
-        collectCoverage: coverage.enableCoverageForBaseline,
-        perTestCoverage: coverage.wantsPerTestCoverage,
-    });
-    if (!baselineOk) {
-        process.exitCode = 1;
-        return;
+    if (opts.skipBaseline) {
+        log.info('Skipping baseline tests (--skip-baseline)');
+    }
+    else {
+        log.info(`Running ${baselineTests.length} baseline tests${coverage.enableCoverageForBaseline ? ' (collecting coverage)' : ''}\u2026`);
+        const baselineOk = await adapter.runBaseline(baselineTests, {
+            collectCoverage: coverage.enableCoverageForBaseline,
+            perTestCoverage: coverage.wantsPerTestCoverage,
+        });
+        if (!baselineOk) {
+            process.exitCode = 1;
+            return;
+        }
+        log.info('\u2713 Baseline tests complete');
     }
-    log.info('\u2713 Baseline tests complete');
     // 6. Load coverage from baseline if we generated it
     const updatedCoverage = await loadCoverageAfterBaseline(coverage, cwd);
     // 7. Enumerate mutation variants
-    const variants = await enumerateAllVariants({
+    let variants = await enumerateAllVariants({
         cwd,
         targets,
         testMap,
@@ -136,8 +153,83 @@ export async function runOrchestrator(cliArgs, cwd) {
         log.info(msg);
         return;
     }
-    // 8. Prepare tasks and execute via worker pool
-    const tasks = prepareTasks(variants, updatedCoverage.perTestCoverage, directTestMap);
+    // Apply shard filter before type-checking so each shard only processes its own mutants
+    if (opts.shard) {
+        const { index, total } = opts.shard;
+        variants = variants.filter((_, i) => i % total === index - 1);
+        log.info(`Shard ${index}/${total}: scoped to ${variants.length} variant(s)`);
+        if (!variants.length) {
+            log.info('No mutants in this shard. Exiting.');
+            return;
+        }
+    }
+    // TypeScript pre-filtering (filter mutants that produce compile errors)
+    const tsEnabled = resolveTypescriptEnabled(opts.typescriptCheck, cfg, cwd);
+    let runnableVariants = variants;
+    if (tsEnabled) {
+        // Only return-value mutants change the expression type — operator mutants
+        // (equality, arithmetic, logical, etc.) always preserve the type.
+        const returnValueVariants = variants.filter((v) => v.name.startsWith('return'));
+        log.info(`Running TypeScript type checks on ${returnValueVariants.length} return-value mutant(s)...`);
+        const tsconfig = resolveTsconfigPath(cfg);
+        let tsSpinner = null;
+        if (process.stderr.isTTY) {
+            tsSpinner = render(createElement(PoolSpinner, {
+                message: `Type checking ${returnValueVariants.length} return-value mutant(s)...`,
+            }), { stdout: process.stderr, stderr: process.stderr });
+        }
+        let compileErrorIds;
+        try {
+            compileErrorIds = await checkTypes(returnValueVariants, tsconfig, cwd);
+        }
+        finally {
+            tsSpinner?.unmount();
+        }
+        if (compileErrorIds.size > 0) {
+            log.info(`\u2713 TypeScript: filtered ${compileErrorIds.size} mutant(s) with compile errors`);
+            runnableVariants = variants.filter((v) => !compileErrorIds.has(v.id));
+            // Pre-populate cache for compile-error mutants so they appear in summary
+            const compileErrorVariants = variants.filter((v) => compileErrorIds.has(v.id));
+            const compileErrorTasks = prepareTasks(compileErrorVariants, updatedCoverage.perTestCoverage, directTestMap);
+            for (const task of compileErrorTasks) {
+                cache[task.key] = {
+                    status: 'compile-error',
+                    file: task.v.file,
+                    line: task.v.line,
+                    col: task.v.col,
+                    mutator: task.v.name,
+                };
+            }
+        }
+    }
+    // 9. Generate schema files for each source file
+    const fallbackIds = new Set();
+    const variantsByFile = new Map();
+    for (const v of runnableVariants) {
+        const arr = variantsByFile.get(v.file) ?? [];
+        arr.push(v);
+        variantsByFile.set(v.file, arr);
+    }
+    const results = await Promise.all([...variantsByFile.entries()].map(async ([file, fileVariants]) => {
+        try {
+            const originalCode = await fs.promises.readFile(file, 'utf8');
+            const schemaPath = getSchemaFilePath(file);
+            await fs.promises.mkdir(path.dirname(schemaPath), { recursive: true });
+            const { schemaCode, fallbackIds: fileFallbacks } = generateSchema(originalCode, fileVariants);
+            await fs.promises.writeFile(schemaPath, schemaCode, 'utf8');
+            return fileFallbacks;
+        }
+        catch {
+            return new Set(fileVariants.map((v) => v.id));
+        }
+    }));
+    for (const ids of results) {
+        for (const id of ids)
+            fallbackIds.add(id);
+    }
+    log.debug(`Schema: ${runnableVariants.length - fallbackIds.size} embedded, ${fallbackIds.size} fallback`);
+    // 10. Prepare tasks and execute via worker pool
+    let tasks = prepareTasks(runnableVariants, updatedCoverage.perTestCoverage, directTestMap);
     await executePool({
         tasks,
         adapter,
@@ -145,6 +237,9 @@ export async function runOrchestrator(cliArgs, cwd) {
         concurrency: opts.concurrency,
         progressMode: opts.progressMode,
         minKillPercent: opts.minKillPercent,
+        reportFormat: opts.reportFormat,
         cwd,
+        shard: opts.shard,
+        fallbackIds,
     });
 }

package/dist/runner/pool-executor.d.ts

@@ -8,7 +8,14 @@ export interface PoolExecutionOptions {
     concurrency: number;
     progressMode: 'bar' | 'list' | 'quiet';
     minKillPercent?: number;
+    reportFormat?: 'text' | 'json';
     cwd: string;
+    shard?: {
+        index: number;
+        total: number;
+    };
+    /** IDs of variants that must use the legacy redirect path (overlapping diff ranges). */
+    fallbackIds?: Set<string>;
 }
 /**
  * Execute all mutant tasks through the worker pool.

package/dist/runner/pool-executor.js

@@ -1,11 +1,13 @@
 import fs from 'node:fs';
+import path from 'node:path';
 import { render } from 'ink';
 import { createElement } from 'react';
 import { Progress } from '../utils/progress.js';
-import { computeSummary, printSummary } from '../utils/summary.js';
+import { computeSummary, printSummary, buildJsonReport, } from '../utils/summary.js';
 import { saveCacheAtomic } from './cache.js';
 import { cleanupMutineerDirs } from './cleanup.js';
 import { PoolSpinner } from '../utils/PoolSpinner.js';
+import { CompileErrors } from '../utils/CompileErrors.js';
 import { createLogger } from '../utils/logger.js';
 const log = createLogger('pool-executor');
 /**
@@ -22,14 +24,33 @@ export async function executePool(opts) {
     const mutationStartTime = Date.now();
     // Ensure we only finish once
     let finished = false;
-    const finishOnce = () => {
+    const finishOnce = async (interactive = true) => {
         if (finished)
             return;
         finished = true;
         const durationMs = Date.now() - mutationStartTime;
         progress.finish();
         const summary = computeSummary(cache);
-        printSummary(summary, cache, durationMs);
+        if (opts.reportFormat === 'json') {
+            const report = buildJsonReport(summary, cache, durationMs);
+            const shardSuffix = opts.shard
+                ? `-shard-${opts.shard.index}-of-${opts.shard.total}`
+                : '';
+            const outPath = path.join(opts.cwd, `mutineer-report${shardSuffix}.json`);
+            fs.writeFileSync(outPath, JSON.stringify(report, null, 2));
+            log.info(`JSON report written to ${path.relative(process.cwd(), outPath)}`);
+        }
+        else {
+            const compileErrorEntries = Object.values(cache).filter((e) => e.status === 'compile-error');
+            const useInteractive = interactive && process.stdout.isTTY && compileErrorEntries.length > 0;
+            printSummary(summary, cache, durationMs, {
+                skipCompileErrors: useInteractive,
+            });
+            if (useInteractive) {
+                const { waitUntilExit } = render(createElement(CompileErrors, { entries: compileErrorEntries, cwd }));
+                await waitUntilExit();
+            }
+        }
         if (opts.minKillPercent !== undefined) {
             const killRateString = summary.killRate.toFixed(2);
             const thresholdString = opts.minKillPercent.toFixed(2);
@@ -68,7 +89,7 @@ export async function executePool(opts) {
     let nextIdx = 0;
     async function processTask(task) {
         const { v, tests, key, directTests } = task;
-        log.debug('Cache ' + JSON.stringify(cache));
+        const { fallbackIds } = opts;
         const cached = cache[key];
         if (cached) {
             progress.update(cached.status);
@@ -93,6 +114,7 @@ export async function executePool(opts) {
             code: v.code,
             line: v.line,
             col: v.col,
+            isFallback: !fallbackIds || fallbackIds.has(v.id),
         }, tests);
         const status = result.status;
         let originalSnippet;
@@ -148,7 +170,7 @@ export async function executePool(opts) {
             return;
         signalCleanedUp = true;
         log.info(`\nReceived ${signal}, cleaning up...`);
-        finishOnce();
+        await finishOnce(false);
         await adapter.shutdown();
         await cleanupMutineerDirs(cwd);
         process.exit(1);
@@ -159,13 +181,13 @@ export async function executePool(opts) {
         for (let i = 0; i < workerCount; i++)
             workers.push(worker());
         await Promise.all(workers);
-        await saveCacheAtomic(cwd, cache);
+        await saveCacheAtomic(cwd, cache, opts.shard);
     }
     finally {
         process.removeAllListeners('SIGINT');
         process.removeAllListeners('SIGTERM');
         if (!signalCleanedUp) {
-            finishOnce();
+            await finishOnce();
             await adapter.shutdown();
             await cleanupMutineerDirs(cwd);
         }

package/dist/runner/shared/__tests__/mutant-paths.spec.js

@@ -2,7 +2,7 @@ import { describe, it, expect, afterEach } from 'vitest';
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { getMutantFilePath } from '../mutant-paths.js';
+import { getMutantFilePath, getSchemaFilePath, getActiveIdFilePath, } from '../mutant-paths.js';
 let createdDirs = [];
 afterEach(() => {
     // Clean up any __mutineer__ directories we created
@@ -64,3 +64,32 @@ describe('getMutantFilePath', () => {
         expect(result).toBe(path.join(mutineerDir, 'foo_1.ts'));
     });
 });
+describe('getSchemaFilePath', () => {
+    it('returns path with _schema suffix and correct extension', () => {
+        const result = getSchemaFilePath('/src/foo.ts');
+        expect(result).toBe('/src/__mutineer__/foo_schema.ts');
+    });
+    it('preserves the original extension', () => {
+        const result = getSchemaFilePath('/src/component.vue');
+        expect(result).toBe('/src/__mutineer__/component_schema.vue');
+    });
+    it('does not create the __mutineer__ directory', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-schema-'));
+        createdDirs.push(tmpDir);
+        const srcFile = path.join(tmpDir, 'bar.ts');
+        const mutineerDir = path.join(tmpDir, '__mutineer__');
+        getSchemaFilePath(srcFile);
+        expect(fs.existsSync(mutineerDir)).toBe(false);
+    });
+});
+describe('getActiveIdFilePath', () => {
+    it('returns path under cwd/__mutineer__ keyed by workerId', () => {
+        const result = getActiveIdFilePath('w0', '/project');
+        expect(result).toBe('/project/__mutineer__/active_id_w0.txt');
+    });
+    it('produces distinct paths for different worker IDs', () => {
+        const a = getActiveIdFilePath('w0', '/cwd');
+        const b = getActiveIdFilePath('w1', '/cwd');
+        expect(a).not.toBe(b);
+    });
+});

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

@@ -4,6 +4,6 @@
  * This module provides common functionality used by both Jest and Vitest adapters,
  * including mutant file path generation and redirect state management.
  */
-export { getMutantFilePath } from './mutant-paths.js';
+export { getMutantFilePath, getSchemaFilePath, getActiveIdFilePath, } from './mutant-paths.js';
 export { setRedirect, getRedirect, clearRedirect, initialiseRedirectState, } from './redirect-state.js';
 export type { RedirectConfig } from './redirect-state.js';

package/dist/runner/shared/index.js

@@ -4,5 +4,5 @@
  * This module provides common functionality used by both Jest and Vitest adapters,
  * including mutant file path generation and redirect state management.
  */
-export { getMutantFilePath } from './mutant-paths.js';
+export { getMutantFilePath, getSchemaFilePath, getActiveIdFilePath, } from './mutant-paths.js';
 export { setRedirect, getRedirect, clearRedirect, initialiseRedirectState, } from './redirect-state.js';