@mutineerjs/mutineer 0.2.3 → 0.3.2

package/dist/runner/orchestrator.js

@@ -12,51 +12,31 @@
 import path from 'node:path';
 import os from 'node:os';
 import { normalizePath } from '../utils/normalizePath.js';
-import { render } from 'ink';
-import { createElement } from 'react';
 import { autoDiscoverTargetsAndTests } from './discover.js';
 import { listChangedFiles } from './changed.js';
 import { loadMutineerConfig } from './config.js';
-import { Progress } from '../utils/progress.js';
-import { computeSummary, printSummary } from '../utils/summary.js';
-import { loadCoverageData, loadPerTestCoverageData, isLineCovered, } from '../utils/coverage.js';
-import { createVitestAdapter, isCoverageRequestedInArgs, } from './vitest/index.js';
+import { createVitestAdapter } from './vitest/index.js';
 import { createJestAdapter } from './jest/index.js';
 import { createLogger } from '../utils/logger.js';
-import { PoolSpinner } from '../utils/PoolSpinner.js';
-// CLI argument parsing
-import { parseCliOptions } from './args.js';
-// Cache management
-import { clearCacheOnStart, saveCacheAtomic, readMutantCache, keyForTests, hash, } from './cache.js';
-// Variant enumeration
-import { enumerateVariantsForTarget, filterTestsByCoverage, getTargetFile, } from './variants.js';
+import { extractConfigPath, parseCliOptions } from './args.js';
+import { clearCacheOnStart, readMutantCache } from './cache.js';
+import { getTargetFile, enumerateAllVariants } from './variants.js';
+import { resolveCoverageConfig, loadCoverageAfterBaseline, } from './coverage-resolver.js';
+import { prepareTasks } from './tasks.js';
+import { executePool } from './pool-executor.js';
 const log = createLogger('orchestrator');
-let testMap;
 // 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;
     const n = raw ? Number(raw) : NaN;
     return Number.isFinite(n) && n > 0 ? n : 30_000;
 })();
-import { cleanupMutineerDirs } from './cleanup.js';
 // Re-export readMutantCache for external use
 export { readMutantCache } from './cache.js';
 export async function runOrchestrator(cliArgs, cwd) {
-    // Load configuration
-    const configPath = cliArgs.find((arg, i) => arg === '--config' || arg === '-c'
-        ? cliArgs[i + 1]
-        : arg.startsWith('--config=') || arg.startsWith('-c='));
-    const cfgPath = configPath?.startsWith('--config=')
-        ? configPath.slice(9)
-        : configPath?.startsWith('-c=')
-            ? configPath.slice(3)
-            : cliArgs.includes('--config')
-                ? cliArgs[cliArgs.indexOf('--config') + 1]
-                : cliArgs.includes('-c')
-                    ? cliArgs[cliArgs.indexOf('-c') + 1]
-                    : undefined;
+    // 1. Parse CLI arguments and load configuration
+    const cfgPath = extractConfigPath(cliArgs);
     const cfg = await loadMutineerConfig(cwd, cfgPath);
-    // Parse CLI options
     const opts = parseCliOptions(cliArgs, cfg);
     await clearCacheOnStart(cwd);
     // Create test runner adapter
@@ -67,56 +47,17 @@ export async function runOrchestrator(cliArgs, cwd) {
         config: cfg,
         cliArgs,
     });
-    // Detect coverage configuration from the adapter
-    const coverageConfig = await adapter.detectCoverageConfig();
-    const wantsPerTestCoverageFromConfig = coverageConfig.perTestEnabled;
-    const coveragePreference = cfg.coverage;
-    const wantsCoverageRun = coveragePreference === true
-        ? true
-        : coveragePreference === false
-            ? false
-            : isCoverageRequestedInArgs(cliArgs) || coverageConfig.coverageEnabled;
-    // Load pre-existing coverage data if provided
-    let coverageData = null;
-    let perTestCoverage = null;
-    if (opts.coverageFilePath) {
-        log.info(`Loading coverage data from ${opts.coverageFilePath}...`);
-        coverageData = await loadCoverageData(opts.coverageFilePath, cwd);
-        log.info(`Loaded coverage for ${coverageData.coveredLines.size} files`);
-    }
-    // If --only-covered-lines but no coverage file, we'll generate it during baseline
-    const needsCoverageFromBaseline = opts.wantsOnlyCoveredLines && !coverageData;
-    const hasCoverageProviderInstalled = adapter.hasCoverageProvider();
-    const rawPerTestCoverage = opts.wantsPerTestCoverage ||
-        wantsPerTestCoverageFromConfig ||
-        (opts.wantsOnlyCoveredLines && hasCoverageProviderInstalled);
-    const wantsPerTestCoverage = opts.runner === 'jest' ? false : rawPerTestCoverage;
-    if (opts.runner === 'jest' && rawPerTestCoverage) {
-        log.warn('Per-test coverage is not supported for Jest; continuing without per-test coverage.');
-    }
-    if (needsCoverageFromBaseline && !hasCoverageProviderInstalled) {
-        log.warn('The "onlyCoveredLines" option requires a coverage provider to generate coverage data.');
-        log.warn('Please install the appropriate coverage package (or disable onlyCoveredLines).');
-        process.exitCode = 1;
-        return;
-    }
-    if (opts.wantsOnlyCoveredLines &&
-        coverageData &&
-        !hasCoverageProviderInstalled) {
-        log.warn('The "onlyCoveredLines" option is enabled, but no coverage provider is installed.');
-        log.warn('Running baseline tests without injecting per-test coverage; existing coverageFile will be used for filtering.');
-    }
+    // 2. Resolve coverage configuration
+    const coverage = await resolveCoverageConfig(opts, cfg, adapter, cliArgs);
+    if (process.exitCode)
+        return; // resolveCoverageConfig sets exitCode on fatal errors
     log.info(`Mutineer starting in ${opts.wantsChangedWithDeps
         ? 'changed files with dependencies'
         : opts.wantsChanged
             ? 'changed files only'
             : 'full'} mode${opts.wantsOnlyCoveredLines ? ' (only covered lines)' : ''}...`);
     log.info(`Using concurrency=${opts.concurrency} (cpus=${os.cpus().length})`);
-    const enableCoverageForBaseline = needsCoverageFromBaseline ||
-        wantsPerTestCoverage ||
-        wantsCoverageRun ||
-        (opts.wantsOnlyCoveredLines && hasCoverageProviderInstalled);
-    // Enumerate changed files if requested
+    // 3. Enumerate changed files if requested
     const changedAbs = opts.wantsChanged || opts.wantsChangedWithDeps
         ? new Set(listChangedFiles(cwd, {
             includeDeps: opts.wantsChangedWithDeps,
@@ -124,12 +65,10 @@ export async function runOrchestrator(cliArgs, cwd) {
             maxDepth: cfg.dependencyDepth,
         }))
         : null;
-    const variants = [];
+    // 4. Discover targets and tests
     const cache = await readMutantCache(cwd);
-    // Always run discovery to build testMap (maps source files → test files)
     const discovered = await autoDiscoverTargetsAndTests(cwd, cfg);
-    testMap = discovered.testMap;
-    // Use explicit targets if provided, otherwise use discovered targets
+    const testMap = discovered.testMap;
     const targets = cfg.targets?.length
         ? [...cfg.targets]
         : (cfg.autoDiscover ?? true)
@@ -142,7 +81,7 @@ export async function runOrchestrator(cliArgs, cwd) {
         const absFile = normalizePath(path.isAbsolute(file) ? file : path.join(cwd, file));
         if (changedAbs && !changedAbs.has(absFile))
             continue;
-        const testsAbs = testMap?.get(normalizePath(absFile));
+        const testsAbs = testMap.get(normalizePath(absFile));
         if (testsAbs) {
             for (const t of testsAbs)
                 allTestFiles.add(t);
@@ -153,235 +92,44 @@ export async function runOrchestrator(cliArgs, cwd) {
         log.info('No tests found for targets. Exiting.');
         return;
     }
-    // Run baseline tests first (with coverage if needed for filtering)
-    log.info(`Running ${baselineTests.length} baseline tests${enableCoverageForBaseline ? ' (collecting coverage)' : ''}\u2026`);
+    // 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: enableCoverageForBaseline ?? false,
-        perTestCoverage: wantsPerTestCoverage ?? false,
+        collectCoverage: coverage.enableCoverageForBaseline,
+        perTestCoverage: coverage.wantsPerTestCoverage,
     });
     if (!baselineOk) {
         process.exitCode = 1;
         return;
     }
     log.info('\u2713 Baseline tests complete');
-    // Load coverage from baseline if we generated it
-    if (needsCoverageFromBaseline) {
-        const defaultCoveragePath = path.join(cwd, 'coverage', 'coverage-final.json');
-        log.info(`Loading coverage data from ${defaultCoveragePath}...`);
-        try {
-            coverageData = await loadCoverageData(defaultCoveragePath, cwd);
-            log.info(`Loaded coverage for ${coverageData.coveredLines.size} files`);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            log.warn(`Warning: Could not load coverage data: ${msg}`);
-            log.warn('Continuing without coverage filtering.');
-        }
-    }
-    // Load per-test coverage if requested
-    if (wantsPerTestCoverage) {
-        const reportsDir = path.join(cwd, 'coverage');
-        log.info('Loading per-test coverage data...');
-        perTestCoverage = await loadPerTestCoverageData(reportsDir, cwd);
-        if (!perTestCoverage) {
-            log.warn('Per-test coverage data not found. Continuing without per-test test pruning.');
-        }
-        else {
-            log.info(`Loaded per-test coverage for ${perTestCoverage.size} tests`);
-        }
-    }
-    // Enumerate variants for targets in parallel. Keep order deterministic by mapping then flattening.
-    const enumerated = await Promise.all(targets.map(async (target) => {
-        const file = getTargetFile(target);
-        const absFile = normalizePath(path.isAbsolute(file) ? file : path.join(cwd, file));
-        if (changedAbs && !changedAbs.has(absFile))
-            return [];
-        log.debug('Target file: ' + absFile);
-        const files = await enumerateVariantsForTarget(cwd, target, cfg.include, cfg.exclude, cfg.maxMutantsPerFile);
-        const testsAbs = testMap?.get(normalizePath(absFile));
-        const tests = testsAbs ? Array.from(testsAbs) : [];
-        log.debug(`  found ${files.length} variants, linked to ${tests.length} tests`);
-        // Filter by coverage if enabled
-        let filtered = files;
-        if (coverageData) {
-            filtered = files.filter((v) => isLineCovered(coverageData, absFile, v.line));
-            if (filtered.length !== files.length) {
-                log.debug(`  filtered ${files.length} -> ${filtered.length} variants by coverage`);
-            }
-        }
-        return filtered.map((v) => ({ ...v, tests }));
-    }));
-    for (const list of enumerated)
-        variants.push(...list);
+    // 6. Load coverage from baseline if we generated it
+    const updatedCoverage = await loadCoverageAfterBaseline(coverage, cwd);
+    // 7. Enumerate mutation variants
+    const variants = await enumerateAllVariants({
+        cwd,
+        targets,
+        testMap,
+        changedFiles: changedAbs,
+        coverageData: updatedCoverage.coverageData,
+        config: cfg,
+    });
     if (!variants.length) {
-        const msg = coverageData
+        const msg = updatedCoverage.coverageData
             ? 'No mutants to test (all mutations are on uncovered lines). Exiting.'
             : 'No mutants to test. Exiting.';
         log.info(msg);
         return;
     }
-    const progress = new Progress(variants.length, {
-        mode: opts.progressMode === 'bar' ? 'bar' : 'list',
-        stream: 'stderr',
-    });
-    // Track mutation testing duration
-    const mutationStartTime = Date.now();
-    // Precompute task metadata for faster worker loops (sort tests, compute keys once)
-    const tasks = variants.map((v) => {
-        let tests = Array.from(v.tests);
-        if (perTestCoverage && tests.length) {
-            const before = tests.length;
-            tests = filterTestsByCoverage(perTestCoverage, tests, v.file, v.line);
-            if (tests.length !== before) {
-                log.debug(`Pruned tests ${before} -> ${tests.length} for mutant ${v.name} via per-test coverage`);
-            }
-        }
-        tests.sort();
-        const testSig = hash(keyForTests(tests));
-        const codeSig = hash(v.code);
-        const key = `${testSig}:${codeSig}`;
-        return { v, tests, key };
+    // 8. Prepare tasks and execute via worker pool
+    const tasks = prepareTasks(variants, updatedCoverage.perTestCoverage);
+    await executePool({
+        tasks,
+        adapter,
+        cache,
+        concurrency: opts.concurrency,
+        progressMode: opts.progressMode,
+        minKillPercent: opts.minKillPercent,
+        cwd,
     });
-    const workerCount = Math.max(1, Math.min(opts.concurrency, tasks.length));
-    // Ensure we only finish once
-    let finished = false;
-    const finishOnce = () => {
-        if (finished)
-            return;
-        finished = true;
-        const durationMs = Date.now() - mutationStartTime;
-        // Finish progress display first
-        progress.finish();
-        // Compute and print a human-friendly summary
-        const summary = computeSummary(cache);
-        printSummary(summary, cache, durationMs);
-        if (opts.minKillPercent !== undefined) {
-            const killRateString = summary.killRate.toFixed(2);
-            const thresholdString = opts.minKillPercent.toFixed(2);
-            if (summary.killRate < opts.minKillPercent) {
-                const note = summary.evaluated === 0 ? ' No mutants were executed.' : '';
-                log.error(`Mutation kill rate ${killRateString}% did not meet required ${thresholdString}% threshold.${note}`);
-                // Set exit code and let caller/CLI decide if it should terminate abruptly
-                process.exitCode = 1;
-            }
-            else {
-                log.info(`Mutation kill rate ${killRateString}% meets required ${thresholdString}% threshold`);
-            }
-        }
-    };
-    // Initialize test runner adapter
-    const workerLogSuffix = workerCount < opts.concurrency ? ` (requested ${opts.concurrency})` : '';
-    log.info(`Initializing ${adapter.name} worker pool with ${workerCount} workers...${workerLogSuffix}`);
-    const poolStart = Date.now();
-    // Ink spinner on stderr while workers start up
-    let spinnerInstance = null;
-    if (process.stderr.isTTY) {
-        spinnerInstance = render(createElement(PoolSpinner, { message: 'Starting pool...' }), { stdout: process.stderr, stderr: process.stderr });
-    }
-    try {
-        await adapter.init(workerCount);
-    }
-    finally {
-        if (spinnerInstance) {
-            spinnerInstance.unmount();
-            spinnerInstance = null;
-        }
-    }
-    const poolDurationMs = Date.now() - poolStart;
-    log.info(`\u2713 Worker pool ready (${poolDurationMs}ms)`);
-    progress.start();
-    let nextIdx = 0;
-    /**
-     * Process a single mutant task: check cache, run tests if needed, update cache and progress.
-     * This function is designed to be called by multiple workers concurrently.
-     */
-    async function processTask(task) {
-        const { v, tests, key } = task;
-        log.debug('Cache ' + JSON.stringify(cache));
-        // Check if already cached
-        const cached = cache[key];
-        if (cached) {
-            progress.update(cached.status);
-            return;
-        }
-        // Skip if no tests import this file
-        if (tests.length === 0) {
-            cache[key] = {
-                status: 'skipped',
-                file: v.file,
-                line: v.line,
-                col: v.col,
-                mutator: v.name,
-            };
-            progress.update('skipped');
-            return;
-        }
-        log.debug(`Running tests for mutant ${v.name} ${JSON.stringify(tests)}`);
-        // Run mutant via test runner adapter
-        const result = await adapter.runMutant({
-            id: v.id,
-            name: v.name,
-            file: v.file,
-            code: v.code,
-            line: v.line,
-            col: v.col,
-        }, tests);
-        const status = result.status;
-        cache[key] = {
-            status,
-            file: v.file,
-            line: v.line,
-            col: v.col,
-            mutator: v.name,
-        };
-        progress.update(status);
-    }
-    /**
-     * Worker coroutine: process mutant tasks from the queue until exhausted.
-     * Multiple workers run concurrently, sharing the task queue.
-     */
-    async function worker() {
-        while (true) {
-            const i = nextIdx++;
-            if (i >= tasks.length)
-                break;
-            await processTask(tasks[i]);
-        }
-    }
-    const workers = [];
-    // Register signal handlers so Ctrl+C / SIGTERM still triggers cleanup
-    let signalCleanedUp = false;
-    const signalHandler = async (signal) => {
-        if (signalCleanedUp)
-            return;
-        signalCleanedUp = true;
-        log.info(`\nReceived ${signal}, cleaning up...`);
-        finishOnce();
-        await adapter.shutdown();
-        await cleanupMutineerDirs(cwd);
-        process.exit(1);
-    };
-    process.on('SIGINT', () => void signalHandler('SIGINT'));
-    process.on('SIGTERM', () => void signalHandler('SIGTERM'));
-    try {
-        // Spawn worker coroutines
-        for (let i = 0; i < workerCount; i++)
-            workers.push(worker());
-        // Wait for all workers to complete
-        await Promise.all(workers);
-        // Persist results to disk
-        await saveCacheAtomic(cwd, cache);
-    }
-    finally {
-        // Remove signal handlers to avoid double cleanup
-        process.removeAllListeners('SIGINT');
-        process.removeAllListeners('SIGTERM');
-        if (!signalCleanedUp) {
-            finishOnce();
-            // Shutdown adapter
-            await adapter.shutdown();
-            // Clean up all __mutineer__ temp directories
-            await cleanupMutineerDirs(cwd);
-        }
-    }
 }

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

@@ -0,0 +1,17 @@
+import type { MutantCacheEntry } from '../types/mutant.js';
+import type { TestRunnerAdapter } from './types.js';
+import type { MutantTask } from './tasks.js';
+export interface PoolExecutionOptions {
+    tasks: MutantTask[];
+    adapter: TestRunnerAdapter;
+    cache: Record<string, MutantCacheEntry>;
+    concurrency: number;
+    progressMode: 'bar' | 'list' | 'quiet';
+    minKillPercent?: number;
+    cwd: string;
+}
+/**
+ * Execute all mutant tasks through the worker pool.
+ * Handles worker init, progress display, signal handling, and cleanup.
+ */
+export declare function executePool(opts: PoolExecutionOptions): Promise<void>;

package/dist/runner/pool-executor.js

@@ -0,0 +1,143 @@
+import { render } from 'ink';
+import { createElement } from 'react';
+import { Progress } from '../utils/progress.js';
+import { computeSummary, printSummary } from '../utils/summary.js';
+import { saveCacheAtomic } from './cache.js';
+import { cleanupMutineerDirs } from './cleanup.js';
+import { PoolSpinner } from '../utils/PoolSpinner.js';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('pool-executor');
+/**
+ * Execute all mutant tasks through the worker pool.
+ * Handles worker init, progress display, signal handling, and cleanup.
+ */
+export async function executePool(opts) {
+    const { tasks, adapter, cache, concurrency, cwd } = opts;
+    const workerCount = Math.max(1, Math.min(concurrency, tasks.length));
+    const progress = new Progress(tasks.length, {
+        mode: opts.progressMode === 'bar' ? 'bar' : 'list',
+        stream: 'stderr',
+    });
+    const mutationStartTime = Date.now();
+    // Ensure we only finish once
+    let finished = false;
+    const finishOnce = () => {
+        if (finished)
+            return;
+        finished = true;
+        const durationMs = Date.now() - mutationStartTime;
+        progress.finish();
+        const summary = computeSummary(cache);
+        printSummary(summary, cache, durationMs);
+        if (opts.minKillPercent !== undefined) {
+            const killRateString = summary.killRate.toFixed(2);
+            const thresholdString = opts.minKillPercent.toFixed(2);
+            if (summary.killRate < opts.minKillPercent) {
+                const note = summary.evaluated === 0 ? ' No mutants were executed.' : '';
+                log.error(`Mutation kill rate ${killRateString}% did not meet required ${thresholdString}% threshold.${note}`);
+                process.exitCode = 1;
+            }
+            else {
+                log.info(`Mutation kill rate ${killRateString}% meets required ${thresholdString}% threshold`);
+            }
+        }
+    };
+    // Initialise worker pool
+    const workerLogSuffix = workerCount < concurrency ? ` (requested ${concurrency})` : '';
+    log.info(`Initializing ${adapter.name} worker pool with ${workerCount} workers...${workerLogSuffix}`);
+    const poolStart = Date.now();
+    // Ink spinner on stderr while workers start up
+    let spinnerInstance = null;
+    if (process.stderr.isTTY) {
+        spinnerInstance = render(createElement(PoolSpinner, { message: 'Starting pool...' }), { stdout: process.stderr, stderr: process.stderr });
+    }
+    try {
+        await adapter.init(workerCount);
+    }
+    finally {
+        if (spinnerInstance) {
+            spinnerInstance.unmount();
+            spinnerInstance = null;
+        }
+    }
+    const poolDurationMs = Date.now() - poolStart;
+    log.info(`\u2713 Worker pool ready (${poolDurationMs}ms)`);
+    progress.start();
+    let nextIdx = 0;
+    async function processTask(task) {
+        const { v, tests, key } = task;
+        log.debug('Cache ' + JSON.stringify(cache));
+        const cached = cache[key];
+        if (cached) {
+            progress.update(cached.status);
+            return;
+        }
+        if (tests.length === 0) {
+            cache[key] = {
+                status: 'skipped',
+                file: v.file,
+                line: v.line,
+                col: v.col,
+                mutator: v.name,
+            };
+            progress.update('skipped');
+            return;
+        }
+        log.debug(`Running tests for mutant ${v.name} ${JSON.stringify(tests)}`);
+        const result = await adapter.runMutant({
+            id: v.id,
+            name: v.name,
+            file: v.file,
+            code: v.code,
+            line: v.line,
+            col: v.col,
+        }, tests);
+        const status = result.status;
+        cache[key] = {
+            status,
+            file: v.file,
+            line: v.line,
+            col: v.col,
+            mutator: v.name,
+        };
+        progress.update(status);
+    }
+    async function worker() {
+        while (true) {
+            const i = nextIdx++;
+            if (i >= tasks.length)
+                break;
+            await processTask(tasks[i]);
+        }
+    }
+    const workers = [];
+    // Register signal handlers so Ctrl+C / SIGTERM still triggers cleanup
+    let signalCleanedUp = false;
+    const signalHandler = async (signal) => {
+        if (signalCleanedUp)
+            return;
+        signalCleanedUp = true;
+        log.info(`\nReceived ${signal}, cleaning up...`);
+        finishOnce();
+        await adapter.shutdown();
+        await cleanupMutineerDirs(cwd);
+        process.exit(1);
+    };
+    process.on('SIGINT', () => void signalHandler('SIGINT'));
+    process.on('SIGTERM', () => void signalHandler('SIGTERM'));
+    try {
+        for (let i = 0; i < workerCount; i++)
+            workers.push(worker());
+        await Promise.all(workers);
+        await saveCacheAtomic(cwd, cache);
+    }
+    finally {
+        process.removeAllListeners('SIGINT');
+        process.removeAllListeners('SIGTERM');
+        if (!signalCleanedUp) {
+            finishOnce();
+            await adapter.shutdown();
+            await cleanupMutineerDirs(cwd);
+        }
+    }
+}

package/dist/runner/shared/__tests__/mutant-paths.spec.d.ts

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

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

@@ -0,0 +1,66 @@
+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';
+let createdDirs = [];
+afterEach(() => {
+    // Clean up any __mutineer__ directories we created
+    for (const dir of createdDirs) {
+        try {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+        catch {
+            // ignore
+        }
+    }
+    createdDirs = [];
+});
+describe('getMutantFilePath', () => {
+    it('creates a mutant file path with numeric ID suffix', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-paths-'));
+        const srcFile = path.join(tmpDir, 'foo.ts');
+        fs.writeFileSync(srcFile, '');
+        const result = getMutantFilePath(srcFile, 'foo.ts#42');
+        createdDirs.push(path.join(tmpDir, '__mutineer__'));
+        expect(result).toBe(path.join(tmpDir, '__mutineer__', 'foo_42.ts'));
+    });
+    it('creates __mutineer__ directory if it does not exist', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-paths-'));
+        const srcFile = path.join(tmpDir, 'bar.ts');
+        fs.writeFileSync(srcFile, '');
+        const mutineerDir = path.join(tmpDir, '__mutineer__');
+        createdDirs.push(mutineerDir);
+        getMutantFilePath(srcFile, 'bar.ts#1');
+        expect(fs.existsSync(mutineerDir)).toBe(true);
+    });
+    it('handles non-numeric mutant IDs', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-paths-'));
+        const srcFile = path.join(tmpDir, 'baz.ts');
+        fs.writeFileSync(srcFile, '');
+        createdDirs.push(path.join(tmpDir, '__mutineer__'));
+        const result = getMutantFilePath(srcFile, 'some-weird-id');
+        expect(path.basename(result)).toMatch(/^baz_/);
+        expect(result).toMatch(/\.ts$/);
+    });
+    it('preserves file extension', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-paths-'));
+        const srcFile = path.join(tmpDir, 'component.vue');
+        fs.writeFileSync(srcFile, '');
+        createdDirs.push(path.join(tmpDir, '__mutineer__'));
+        const result = getMutantFilePath(srcFile, 'component.vue#5');
+        expect(result).toMatch(/\.vue$/);
+        expect(path.basename(result)).toBe('component_5.vue');
+    });
+    it('reuses existing __mutineer__ directory', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-paths-'));
+        const srcFile = path.join(tmpDir, 'foo.ts');
+        fs.writeFileSync(srcFile, '');
+        const mutineerDir = path.join(tmpDir, '__mutineer__');
+        fs.mkdirSync(mutineerDir);
+        createdDirs.push(mutineerDir);
+        // Should not throw
+        const result = getMutantFilePath(srcFile, 'foo.ts#1');
+        expect(result).toBe(path.join(mutineerDir, 'foo_1.ts'));
+    });
+});

package/dist/runner/shared/__tests__/redirect-state.spec.d.ts

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