@mutineerjs/mutineer 0.5.0 → 0.6.0

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/config.js

@@ -19,7 +19,7 @@ const log = createLogger('config');
 async function loadModule(filePath) {
     const moduleUrl = pathToFileURL(filePath).href;
     const mod = await import(moduleUrl);
-    return mod.default ?? mod;
+    return 'default' in mod ? mod.default : mod;
 }
 /**
  * Validate that the loaded configuration has the expected shape.

package/dist/runner/discover.js

@@ -84,15 +84,24 @@ async function createViteResolver(rootAbs, exts) {
     // Load Vue plugin if needed
     let plugins = [];
     if (exts.has('.vue')) {
-        try {
-            const mod = await import(
-            /* @vite-ignore */ '@vitejs/plugin-vue');
-            const vue = mod.default ?? mod;
-            plugins = typeof vue === 'function' ? [vue()] : [];
-        }
-        catch (err) {
-            const detail = err instanceof Error ? err.message : String(err);
-            log.warn(`Unable to load @vitejs/plugin-vue; Vue SFC imports may fail to resolve (${detail})`);
+        const vueFiles = await fg(['**/*.vue'], {
+            cwd: rootAbs,
+            onlyFiles: true,
+            ignore: ['**/node_modules/**'],
+            deep: 5,
+        });
+        if (vueFiles.length > 0) {
+            try {
+                const mod = await import(
+                /* @vite-ignore */ '@vitejs/plugin-vue');
+                const vue = mod.default ?? mod;
+                plugins =
+                    typeof vue === 'function' ? [vue()] : [];
+            }
+            catch (err) {
+                const detail = err instanceof Error ? err.message : String(err);
+                log.warn(`Unable to load @vitejs/plugin-vue; Vue SFC imports may fail to resolve (${detail})`);
+            }
         }
     }
     const quietLogger = {
@@ -280,12 +289,12 @@ export async function autoDiscoverTargetsAndTests(root, cfg) {
         }
     }
     try {
-        for (const testAbs of tests) {
+        await Promise.all(tests.map(async (testAbs) => {
             const seen = new Set();
             // prime with the test's own direct imports
             const code = safeRead(testAbs);
             if (!code)
-                continue;
+                return;
             const firstHop = [];
             for (const spec of extractImportSpecs(code)) {
                 if (!spec)
@@ -302,7 +311,7 @@ export async function autoDiscoverTargetsAndTests(root, cfg) {
             for (const abs of firstHop) {
                 await crawl(abs, 0, seen, testAbs);
             }
-        }
+        }));
         return { targets: Array.from(targets.values()), testMap, directTestMap };
     }
     finally {

package/dist/runner/jest/__tests__/pool.spec.js

@@ -1,4 +1,5 @@
 import { describe, it, expect, vi } from 'vitest';
+import { EventEmitter } from 'node:events';
 import { JestPool, runWithJestPool } from '../pool.js';
 // We'll use the createWorker option to inject mock workers instead of forking processes
 function makeMockWorker(id) {
@@ -110,6 +111,46 @@ describe('JestPool', () => {
         // After shutdown, initialised is set to false, so "not initialised" check fires first
         await expect(pool.run(dummyMutant, ['test.ts'])).rejects.toThrow('Pool not initialised');
     });
+    it('does not give a dead worker to a waiting task after timeout', async () => {
+        let callCount = 0;
+        const allWorkers = [];
+        const pool = new JestPool({
+            cwd: '/tmp',
+            concurrency: 1,
+            createWorker: (id) => {
+                callCount++;
+                const workerNum = callCount;
+                const worker = new EventEmitter();
+                worker.id = id;
+                worker._ready = true;
+                worker.start = vi.fn().mockResolvedValue(undefined);
+                worker.isReady = vi.fn(() => worker._ready);
+                worker.isBusy = vi.fn().mockReturnValue(false);
+                worker.run = vi.fn().mockImplementation(async () => {
+                    if (workerNum === 1) {
+                        worker._ready = false;
+                        Promise.resolve().then(() => worker.emit('exit'));
+                        return { killed: false, durationMs: 5000, error: 'timeout' };
+                    }
+                    return { killed: true, durationMs: 42 };
+                });
+                worker.shutdown = vi.fn().mockResolvedValue(undefined);
+                worker.kill = vi.fn();
+                allWorkers.push(worker);
+                return worker;
+            },
+        });
+        await pool.init();
+        const [result1, result2] = await Promise.all([
+            pool.run(dummyMutant, ['a.spec.ts']),
+            pool.run({ ...dummyMutant, id: 'test#2' }, ['b.spec.ts']),
+        ]);
+        expect(result1).toMatchObject({ error: 'timeout' });
+        expect(result2).toMatchObject({ killed: true });
+        expect(allWorkers).toHaveLength(2);
+        expect(allWorkers[1].run).toHaveBeenCalled();
+        await pool.shutdown();
+    });
     it('does not double-shutdown', async () => {
         const workers = [];
         const pool = new JestPool({

package/dist/runner/jest/pool.js

@@ -239,14 +239,14 @@ export class JestPool {
         });
     }
     releaseWorker(worker) {
+        if (!worker.isReady())
+            return;
         const waiting = this.waitingTasks.shift();
         if (waiting) {
             waiting(worker);
             return;
         }
-        if (worker.isReady()) {
-            this.availableWorkers.push(worker);
-        }
+        this.availableWorkers.push(worker);
     }
     async run(mutant, tests) {
         if (!this.initialised) {

package/dist/runner/orchestrator.js

@@ -43,7 +43,7 @@ export async function runOrchestrator(cliArgs, cwd) {
     const adapter = (opts.runner === 'jest' ? createJestAdapter : createVitestAdapter)({
         cwd,
         concurrency: opts.concurrency,
-        timeoutMs: MUTANT_TIMEOUT_MS,
+        timeoutMs: opts.timeout ?? cfg.timeout ?? MUTANT_TIMEOUT_MS,
         config: cfg,
         cliArgs,
     });
@@ -88,6 +88,21 @@ export async function runOrchestrator(cliArgs, cwd) {
         }
     }
     const baselineTests = Array.from(allTestFiles);
+    if (opts.wantsChangedWithDeps) {
+        let uncoveredCount = 0;
+        for (const target of targets) {
+            const absFile = normalizePath(path.isAbsolute(getTargetFile(target))
+                ? getTargetFile(target)
+                : path.join(cwd, getTargetFile(target)));
+            if (changedAbs?.has(absFile) &&
+                !testMap.get(normalizePath(absFile))?.size) {
+                uncoveredCount++;
+            }
+        }
+        if (uncoveredCount > 0) {
+            log.info(`${uncoveredCount} target(s) from --changed-with-deps have no covering tests and will be skipped`);
+        }
+    }
     if (!baselineTests.length) {
         log.info('No tests found for targets. Exiting.');
         return;

package/dist/runner/pool-executor.js

@@ -64,6 +64,7 @@ export async function executePool(opts) {
     const poolDurationMs = Date.now() - poolStart;
     log.info(`\u2713 Worker pool ready (${poolDurationMs}ms)`);
     progress.start();
+    const fileCache = new Map();
     let nextIdx = 0;
     async function processTask(task) {
         const { v, tests, key, directTests } = task;
@@ -98,7 +99,12 @@ export async function executePool(opts) {
         let mutatedSnippet;
         if (status === 'escaped') {
             try {
-                const originalLines = fs.readFileSync(v.file, 'utf8').split('\n');
+                let fileContent = fileCache.get(v.file);
+                if (fileContent === undefined) {
+                    fileContent = fs.readFileSync(v.file, 'utf8');
+                    fileCache.set(v.file, fileContent);
+                }
+                const originalLines = fileContent.split('\n');
                 const mutatedLines = v.code.split('\n');
                 const lineIdx = v.line - 1;
                 const orig = originalLines[lineIdx]?.trim();

package/dist/runner/vitest/__tests__/adapter.spec.js

@@ -103,6 +103,25 @@ describe('Vitest adapter', () => {
         expect(args.join(' ')).toContain('--coverage.enabled=true');
         expect(args.join(' ')).toContain('--coverage.perTest=true');
     });
+    it('disables coverage thresholds in baseline-with-coverage to prevent threshold failures', async () => {
+        const adapter = makeAdapter({ cliArgs: [] });
+        spawnMock.mockImplementationOnce(() => ({
+            on: (evt, cb) => {
+                if (evt === 'exit')
+                    cb(0);
+            },
+        }));
+        await adapter.runBaseline(['test-a'], {
+            collectCoverage: true,
+            perTestCoverage: false,
+        });
+        const args = spawnMock.mock.calls[0][1];
+        const argStr = args.join(' ');
+        expect(argStr).toContain('--coverage.thresholds.lines=0');
+        expect(argStr).toContain('--coverage.thresholds.functions=0');
+        expect(argStr).toContain('--coverage.thresholds.branches=0');
+        expect(argStr).toContain('--coverage.thresholds.statements=0');
+    });
     it('detects coverage config from vitest config file', async () => {
         const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-vitest-'));
         const cfgPath = path.join(tmp, 'vitest.config.ts');

package/dist/runner/vitest/__tests__/pool.spec.js

@@ -88,6 +88,63 @@ describe('VitestPool', () => {
         expect(result).toEqual({ status: 'escaped', durationMs: 7 });
         expect(mockPool.run).toHaveBeenCalledWith(mutant, ['bar.spec.ts']);
     });
+    it('does not give a dead worker to a waiting task after timeout', async () => {
+        let callCount = 0;
+        const allWorkers = [];
+        const pool = new VitestPool({
+            cwd: process.cwd(),
+            concurrency: 1,
+            timeoutMs: 5000,
+            createWorker: (id) => {
+                callCount++;
+                const workerNum = callCount;
+                const worker = new EventEmitter();
+                worker.id = id;
+                worker._ready = true;
+                worker.start = vi.fn().mockResolvedValue(undefined);
+                worker.isReady = vi.fn(() => worker._ready);
+                worker.isBusy = vi.fn().mockReturnValue(false);
+                worker.run = vi.fn().mockImplementation(async () => {
+                    if (workerNum === 1) {
+                        worker._ready = false;
+                        Promise.resolve().then(() => worker.emit('exit'));
+                        return { killed: false, durationMs: 5000, error: 'timeout' };
+                    }
+                    return { killed: true, durationMs: 42 };
+                });
+                worker.shutdown = vi.fn().mockResolvedValue(undefined);
+                worker.kill = vi.fn();
+                allWorkers.push(worker);
+                return worker;
+            },
+        });
+        await pool.init();
+        const mutant1 = {
+            id: '1',
+            name: 'm1',
+            file: 'a.ts',
+            code: 'x',
+            line: 1,
+            col: 1,
+        };
+        const mutant2 = {
+            id: '2',
+            name: 'm2',
+            file: 'b.ts',
+            code: 'y',
+            line: 1,
+            col: 1,
+        };
+        const [result1, result2] = await Promise.all([
+            pool.run(mutant1, ['a.spec.ts']),
+            pool.run(mutant2, ['b.spec.ts']),
+        ]);
+        expect(result1).toMatchObject({ error: 'timeout' });
+        expect(result2).toMatchObject({ killed: true });
+        expect(allWorkers).toHaveLength(2);
+        expect(allWorkers[1].run).toHaveBeenCalled();
+        await pool.shutdown();
+    });
     it('maps runWithPool errors to error status', async () => {
         const mockPool = {
             run: vi.fn().mockRejectedValue(new Error('boom')),

package/dist/runner/vitest/adapter.js

@@ -96,6 +96,9 @@ function buildVitestArgs(args, mode) {
         if (!result.some((a) => a.startsWith('--coverage.perTest='))) {
             result.push('--coverage.perTest=true');
         }
+        // Disable coverage thresholds so baseline doesn't fail when a broader
+        // test set (e.g. from --changed-with-deps) lowers aggregate coverage
+        result.push('--coverage.thresholds.lines=0', '--coverage.thresholds.functions=0', '--coverage.thresholds.branches=0', '--coverage.thresholds.statements=0');
     }
     return result;
 }

package/dist/runner/vitest/pool.js

@@ -301,6 +301,8 @@ export class VitestPool {
         });
     }
     releaseWorker(worker) {
+        if (!worker.isReady())
+            return;
         // If someone is waiting, give them the worker directly
         const waiting = this.waitingTasks.shift();
         if (waiting) {
@@ -308,9 +310,7 @@ export class VitestPool {
             return;
         }
         // Otherwise return to the pool
-        if (worker.isReady()) {
-            this.availableWorkers.push(worker);
-        }
+        this.availableWorkers.push(worker);
     }
     async run(mutant, tests) {
         if (!this.initialised) {

package/dist/types/config.d.ts

@@ -38,4 +38,6 @@ export interface MutineerConfig {
      * Requires Vitest coverage with perTest support.
      */
     readonly perTestCoverage?: boolean;
+    /** Per-mutant test timeout in milliseconds (default: 30000) */
+    readonly timeout?: number;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mutineerjs/mutineer",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "A fast, targeted mutation testing framework for JavaScript and TypeScript",
   "type": "module",
   "private": false,