@mutineerjs/mutineer 0.7.0 → 0.8.0

package/dist/runner/ts-checker.js

@@ -0,0 +1,210 @@
+/**
+ * TypeScript Type Checker for Mutants
+ *
+ * Pre-filters mutants that produce TypeScript compile errors before running
+ * them against tests. This avoids running mutations that would be trivially
+ * detected by the type system, saving significant test execution time.
+ *
+ * Strategy: noLib + noResolve (zero I/O) + baseline comparison
+ * -  noLib: true      → don't load lib.d.ts (huge, causes hangs)
+ * -  noResolve: true  → don't follow user imports (avoids loading project files)
+ * -  Baseline check   → type-check original file first; only flag mutants that
+ *                       introduce NEW errors not present in the original. This
+ *                       eliminates false positives from missing lib/import types.
+ */
+import ts from 'typescript';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { Worker } from 'worker_threads';
+import { fileURLToPath } from 'node:url';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('ts-checker');
+/**
+ * Compiler options used for all type checks: fully isolated, zero I/O.
+ * We read strict/noImplicitAny/etc from the user's tsconfig (to catch the
+ * same errors they care about), but always override lib/resolve settings.
+ */
+function resolveCompilerOptions(tsconfig, cwd) {
+    const base = {
+        noEmit: true,
+        skipLibCheck: true,
+        strict: false,
+        noLib: true, // Never load lib.d.ts — huge, causes hangs
+        noResolve: true, // Never follow user imports — avoids loading project files
+    };
+    const searchDir = tsconfig ? path.dirname(path.resolve(cwd, tsconfig)) : cwd;
+    const configPath = ts.findConfigFile(searchDir, ts.sys.fileExists) ?? undefined;
+    if (!configPath)
+        return base;
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+    if (configFile.error) {
+        log.debug(`Failed to read tsconfig at ${configPath}: ${ts.flattenDiagnosticMessageText(configFile.error.messageText, '\n')}`);
+        return base;
+    }
+    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath));
+    // Take user's strictness settings (strict, noImplicitAny, exactOptionalPropertyTypes,
+    // etc.) so we catch the same class of errors they care about, but always override
+    // the I/O settings to keep checks fast and isolated.
+    return {
+        ...parsed.options,
+        noEmit: true,
+        skipLibCheck: true,
+        noLib: true,
+        noResolve: true,
+    };
+}
+/** Stable fingerprint for a diagnostic — used to diff baseline vs mutant errors. */
+function diagnosticKey(d) {
+    return `${d.code}:${d.start ?? -1}`;
+}
+/** Create a compiler host that serves `code` for `targetPath`, real fs for everything else. */
+function makeHost(options, targetPath, code) {
+    const host = ts.createCompilerHost(options);
+    const orig = host.getSourceFile.bind(host);
+    host.getSourceFile = (fileName, langOrOpts) => {
+        if (path.resolve(fileName) === targetPath) {
+            return ts.createSourceFile(fileName, code, langOrOpts);
+        }
+        return orig(fileName, langOrOpts);
+    };
+    return host;
+}
+/** Run semantic diagnostics for `code` in `targetPath`, reusing `oldProgram` if provided. */
+function diagnose(options, targetPath, code, oldProgram) {
+    const host = makeHost(options, targetPath, code);
+    const program = ts.createProgram({
+        rootNames: [targetPath],
+        options,
+        host,
+        oldProgram,
+    });
+    const sourceFile = program.getSourceFile(targetPath) ??
+        program.getSourceFile(path.relative(process.cwd(), targetPath));
+    if (!sourceFile) {
+        return { program, keys: new Set() };
+    }
+    const keys = new Set(program.getSemanticDiagnostics(sourceFile).map(diagnosticKey));
+    return { program, keys };
+}
+/**
+ * Run type checks for one file group synchronously. Used both by the sync
+ * fallback (test/dev environments) and by the worker thread.
+ */
+export function checkFileSync(options, filePath, fileVariants) {
+    const resolvedPath = path.resolve(filePath);
+    const compileErrorIds = [];
+    let originalCode = '';
+    try {
+        originalCode = fs.readFileSync(resolvedPath, 'utf8');
+    }
+    catch {
+        log.debug(`Cannot read ${filePath} for baseline — using empty baseline`);
+    }
+    const { program: baseProgram, keys: baselineKeys } = diagnose(options, resolvedPath, originalCode, undefined);
+    log.debug(`Baseline for ${filePath}: ${baselineKeys.size} error(s)`);
+    let prevProgram = baseProgram;
+    for (const variant of fileVariants) {
+        const { program: mutProgram, keys: mutantKeys } = diagnose(options, resolvedPath, variant.code, prevProgram);
+        prevProgram = mutProgram;
+        let newErrors = 0;
+        for (const key of mutantKeys) {
+            if (!baselineKeys.has(key))
+                newErrors++;
+        }
+        if (newErrors > 0) {
+            compileErrorIds.push(variant.id);
+            log.debug(`Compile error in ${variant.id}: ${newErrors} new error(s)`);
+        }
+    }
+    return compileErrorIds;
+}
+/** Spawn a worker for one file group and resolve with the compile-error IDs. */
+function runWorker(workerPath, options, filePath, variants) {
+    return new Promise((resolve, reject) => {
+        const worker = new Worker(workerPath, {
+            workerData: {
+                options,
+                filePath,
+                variants: variants.map((v) => ({ id: v.id, code: v.code })),
+            },
+        });
+        worker.once('message', (msg) => {
+            resolve(msg.compileErrorIds);
+        });
+        worker.once('error', reject);
+        worker.once('exit', (code) => {
+            if (code !== 0)
+                reject(new Error(`ts-checker worker exited with code ${code}`));
+        });
+    });
+}
+/**
+ * Check TypeScript types for mutated variants.
+ * Returns a Set of variant IDs that introduce NEW compile errors vs the original.
+ */
+export async function checkTypes(variants, tsconfig, cwd) {
+    const compileErrors = new Set();
+    if (variants.length === 0)
+        return compileErrors;
+    const options = resolveCompilerOptions(tsconfig, cwd);
+    // Group variants by source file
+    const byFile = new Map();
+    for (const v of variants) {
+        const list = byFile.get(v.file);
+        if (list)
+            list.push(v);
+        else
+            byFile.set(v.file, [v]);
+    }
+    // In test/dev environments import.meta.url ends in .ts — Node can't load .ts
+    // workers, so fall back to the synchronous path.
+    const isTsSource = import.meta.url.endsWith('.ts');
+    if (isTsSource) {
+        for (const [filePath, fileVariants] of byFile) {
+            for (const id of checkFileSync(options, filePath, fileVariants)) {
+                compileErrors.add(id);
+            }
+        }
+        return compileErrors;
+    }
+    // Parallel worker dispatch
+    const workerPath = fileURLToPath(new URL('./ts-checker-worker.js', import.meta.url));
+    const maxConcurrency = Math.max(os.cpus().length - 1, 1);
+    const entries = Array.from(byFile.entries());
+    for (let i = 0; i < entries.length; i += maxConcurrency) {
+        const batch = entries.slice(i, i + maxConcurrency);
+        const results = await Promise.all(batch.map(([filePath, fileVariants]) => runWorker(workerPath, options, filePath, fileVariants)));
+        for (const ids of results) {
+            for (const id of ids)
+                compileErrors.add(id);
+        }
+    }
+    return compileErrors;
+}
+/**
+ * Determine whether TypeScript type checking should run for this invocation.
+ * Precedence: CLI flag > config field > auto-detect (tsconfig.json presence).
+ */
+export function resolveTypescriptEnabled(cliFlag, config, cwd) {
+    if (cliFlag === true)
+        return true;
+    if (cliFlag === false)
+        return false;
+    const cfgTs = config.typescript;
+    if (cfgTs === false)
+        return false;
+    if (cfgTs !== undefined)
+        return true;
+    // Auto-detect: enable if tsconfig.json exists in cwd
+    return ts.findConfigFile(cwd, ts.sys.fileExists) !== undefined;
+}
+/**
+ * Extract the tsconfig path from the MutineerConfig typescript option.
+ */
+export function resolveTsconfigPath(config) {
+    if (typeof config.typescript === 'object' && config.typescript !== null) {
+        return config.typescript.tsconfig;
+    }
+    return undefined;
+}

package/dist/runner/types.d.ts

@@ -16,6 +16,8 @@ export interface TestRunnerAdapterOptions {
     readonly timeoutMs: number;
     readonly config: MutineerConfig;
     readonly cliArgs: string[];
+    /** Vitest workspace project name to target (from --vitest-project or config) */
+    readonly vitestProject?: string;
 }
 /**
  * Coverage-related configuration detected from the test runner.

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

@@ -1,5 +1,6 @@
 import { describe, it, expect, afterEach } from 'vitest';
 import fs from 'node:fs/promises';
+import fssync from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { poolMutineerPlugin } from '../plugin.js';
@@ -13,10 +14,21 @@ function getLoadFn() {
     }
     return undefined;
 }
+function getConfigFn() {
+    const plugin = poolMutineerPlugin();
+    if (Array.isArray(plugin)) {
+        return plugin[0]?.config;
+    }
+    if (plugin && typeof plugin === 'object' && 'config' in plugin) {
+        return plugin.config;
+    }
+    return undefined;
+}
 describe('poolMutineerPlugin', () => {
     afterEach(() => {
         ;
         globalThis.__mutineer_redirect__ = undefined;
+        delete process.env.MUTINEER_ACTIVE_ID_FILE;
     });
     it('returns null when no redirect is configured', () => {
         const load = getLoadFn();
@@ -62,4 +74,143 @@ describe('poolMutineerPlugin', () => {
             await fs.rm(tmpDir, { recursive: true, force: true });
         }
     });
+    it('returns schema code when a schema file exists for the source path', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-schema-plugin-'));
+        const sourcePath = path.join(tmpDir, 'source.ts');
+        const mutineerDir = path.join(tmpDir, '__mutineer__');
+        const schemaPath = path.join(mutineerDir, 'source_schema.ts');
+        await fs.mkdir(mutineerDir);
+        await fs.writeFile(schemaPath, '// @ts-nocheck\nconst x = 1', 'utf8');
+        try {
+            const load = getLoadFn();
+            const result = load?.(sourcePath);
+            expect(result).toBe('// @ts-nocheck\nconst x = 1');
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('caches schema content so subsequent loads skip filesystem I/O', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-schema-cache-'));
+        const sourcePath = path.join(tmpDir, 'source.ts');
+        const mutineerDir = path.join(tmpDir, '__mutineer__');
+        const schemaPath = path.join(mutineerDir, 'source_schema.ts');
+        await fs.mkdir(mutineerDir);
+        await fs.writeFile(schemaPath, '// cached schema', 'utf8');
+        // Use the same plugin instance for both calls (shared cache)
+        const plugin = poolMutineerPlugin();
+        const load = plugin?.load?.bind(plugin);
+        try {
+            const first = load?.(sourcePath);
+            expect(first).toBe('// cached schema');
+            // Remove schema file - second call must still return cached content
+            await fs.rm(tmpDir, { recursive: true, force: true });
+            const second = load?.(sourcePath);
+            expect(second).toBe('// cached schema');
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => { });
+        }
+    });
+    it('caches null for paths with no schema to avoid repeated existsSync calls', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-schema-nocache-'));
+        const sourcePath = path.join(tmpDir, 'no-schema.ts');
+        try {
+            const plugin = poolMutineerPlugin();
+            const load = plugin?.load?.bind(plugin);
+            const first = load?.(sourcePath);
+            expect(first).toBeNull();
+            // Create schema file after first call - second call must return null (cached)
+            const mutineerDir = path.join(tmpDir, '__mutineer__');
+            await fs.mkdir(mutineerDir, { recursive: true });
+            await fs.writeFile(path.join(mutineerDir, 'no-schema_schema.ts'), '// late schema', 'utf8');
+            const second = load?.(sourcePath);
+            expect(second).toBeNull();
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('prefers redirect over schema when both are present (fallback mutation path)', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-schema-redirect-'));
+        const sourcePath = path.join(tmpDir, 'source.ts');
+        const mutineerDir = path.join(tmpDir, '__mutineer__');
+        const schemaPath = path.join(mutineerDir, 'source_schema.ts');
+        const mutatedPath = path.join(mutineerDir, 'source_0.ts');
+        await fs.mkdir(mutineerDir);
+        await fs.writeFile(schemaPath, '// schema', 'utf8');
+        await fs.writeFile(mutatedPath, '// mutated', 'utf8');
+        try {
+            ;
+            globalThis.__mutineer_redirect__ = {
+                from: sourcePath,
+                to: mutatedPath,
+            };
+            const load = getLoadFn();
+            const result = load?.(sourcePath);
+            // Redirect wins: fallback mutations use setRedirect + invalidateFile.
+            // The schema must not shadow the mutant code during fallback runs.
+            expect(result).toBe('// mutated');
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    describe('config hook', () => {
+        it('returns null when MUTINEER_ACTIVE_ID_FILE is not set', () => {
+            const config = getConfigFn();
+            const result = config?.({ test: { setupFiles: ['/existing/setup.ts'] } });
+            expect(result).toBeNull();
+        });
+        it('appends setup.mjs to setupFiles when MUTINEER_ACTIVE_ID_FILE is set', () => {
+            const tmpDir = fssync.mkdtempSync(path.join(os.tmpdir(), 'mutineer-config-'));
+            const activeIdFile = path.join(tmpDir, '__mutineer__', 'active_id_w0.txt');
+            process.env.MUTINEER_ACTIVE_ID_FILE = activeIdFile;
+            try {
+                const config = getConfigFn();
+                const result = config?.({
+                    test: { setupFiles: ['/existing/setup.ts'] },
+                });
+                const setupFiles = result?.test?.setupFiles;
+                expect(setupFiles).toContain('/existing/setup.ts');
+                expect(setupFiles.some((f) => f.endsWith('setup.mjs'))).toBe(true);
+            }
+            finally {
+                fssync.rmSync(tmpDir, { recursive: true, force: true });
+                delete process.env.MUTINEER_ACTIVE_ID_FILE;
+            }
+        });
+        it('creates setupFiles array from string value', () => {
+            const tmpDir = fssync.mkdtempSync(path.join(os.tmpdir(), 'mutineer-config2-'));
+            const activeIdFile = path.join(tmpDir, '__mutineer__', 'active_id_w0.txt');
+            process.env.MUTINEER_ACTIVE_ID_FILE = activeIdFile;
+            try {
+                const config = getConfigFn();
+                const result = config?.({ test: { setupFiles: '/single/setup.ts' } });
+                const setupFiles = result?.test?.setupFiles;
+                expect(setupFiles).toContain('/single/setup.ts');
+                expect(setupFiles.length).toBe(2);
+            }
+            finally {
+                fssync.rmSync(tmpDir, { recursive: true, force: true });
+                delete process.env.MUTINEER_ACTIVE_ID_FILE;
+            }
+        });
+        it('creates setupFiles from empty config when no existing setupFiles', () => {
+            const tmpDir = fssync.mkdtempSync(path.join(os.tmpdir(), 'mutineer-config3-'));
+            const activeIdFile = path.join(tmpDir, '__mutineer__', 'active_id_w0.txt');
+            process.env.MUTINEER_ACTIVE_ID_FILE = activeIdFile;
+            try {
+                const config = getConfigFn();
+                const result = config?.({});
+                const setupFiles = result?.test?.setupFiles;
+                expect(setupFiles.length).toBe(1);
+                expect(setupFiles[0]).toMatch(/setup\.mjs$/);
+            }
+            finally {
+                fssync.rmSync(tmpDir, { recursive: true, force: true });
+                delete process.env.MUTINEER_ACTIVE_ID_FILE;
+            }
+        });
+    });
 });

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

@@ -160,4 +160,89 @@ describe('VitestPool', () => {
         const result = await runWithPool(mockPool, mutant, []);
         expect(result.status).toBe('error');
     });
+    it('passes MUTINEER_ACTIVE_ID_FILE env var to worker process', async () => {
+        let capturedEnv;
+        vi.mocked(childProcess.spawn).mockImplementationOnce((_cmd, _args, options) => {
+            capturedEnv = options?.env;
+            const proc = new EventEmitter();
+            proc.stdout = new EventEmitter();
+            proc.stderr = new EventEmitter();
+            proc.stdin = { writes: [], write: vi.fn() };
+            proc.kill = vi.fn();
+            return proc;
+        });
+        const rl = new EventEmitter();
+        vi.mocked(readline.createInterface).mockImplementationOnce(() => rl);
+        const cwd = '/my/project';
+        const pool = new VitestPool({ cwd, concurrency: 1 });
+        // Start init — synchronous part (spawn + createInterface) runs immediately
+        const initPromise = pool.init();
+        // Give event loop one tick so the async suspend in worker.start() is reached
+        await new Promise((resolve) => setImmediate(resolve));
+        // Verify env var was passed to spawn before completing init
+        expect(capturedEnv?.MUTINEER_ACTIVE_ID_FILE).toBe('/my/project/__mutineer__/active_id_w0.txt');
+        // Emit ready to unblock initPromise
+        rl.emit('line', JSON.stringify({ type: 'ready', workerId: 'w0' }));
+        await initPromise;
+        // Shutdown: emit the shutdown response so worker.shutdown() resolves
+        const shutdownPromise = pool.shutdown();
+        await new Promise((resolve) => setImmediate(resolve));
+        rl.emit('line', JSON.stringify({ type: 'shutdown', ok: true }));
+        await shutdownPromise;
+    });
+    it('spawns workers with detached: true for process group isolation', async () => {
+        let capturedOptions;
+        vi.mocked(childProcess.spawn).mockImplementationOnce((_cmd, _args, options) => {
+            capturedOptions = options;
+            const proc = new EventEmitter();
+            proc.stdout = new EventEmitter();
+            proc.stderr = new EventEmitter();
+            proc.stdin = { writes: [], write: vi.fn() };
+            proc.kill = vi.fn();
+            return proc;
+        });
+        const rl = new EventEmitter();
+        vi.mocked(readline.createInterface).mockImplementationOnce(() => rl);
+        const pool = new VitestPool({ cwd: '/test', concurrency: 1 });
+        const initPromise = pool.init();
+        await new Promise((r) => setImmediate(r));
+        expect(capturedOptions?.detached).toBe(true);
+        rl.emit('line', JSON.stringify({ type: 'ready', workerId: 'w0' }));
+        await initPromise;
+        const shutdownPromise = pool.shutdown();
+        await new Promise((r) => setImmediate(r));
+        rl.emit('line', JSON.stringify({ type: 'shutdown', ok: true }));
+        await shutdownPromise;
+    });
+    it('kills entire process group (negative PID) on mutant run timeout', async () => {
+        const mockProc = new EventEmitter();
+        mockProc.stdout = new EventEmitter();
+        mockProc.stderr = new EventEmitter();
+        mockProc.stdin = { writes: [], write: vi.fn() };
+        mockProc.kill = vi.fn();
+        mockProc.pid = 42000;
+        vi.mocked(childProcess.spawn).mockReturnValueOnce(mockProc);
+        const rl = new EventEmitter();
+        vi.mocked(readline.createInterface).mockReturnValueOnce(rl);
+        const killSpy = vi.spyOn(process, 'kill').mockReturnValue(true);
+        // Use a very short timeoutMs so the test doesn't wait long
+        const pool = new VitestPool({ cwd: '/test', concurrency: 1, timeoutMs: 50 });
+        const initPromise = pool.init();
+        await new Promise((r) => setImmediate(r));
+        rl.emit('line', JSON.stringify({ type: 'ready', workerId: 'w0' }));
+        await initPromise;
+        const mutant = {
+            id: 't1',
+            name: 'test',
+            file: 'a.ts',
+            code: 'x',
+            line: 1,
+            col: 1,
+        };
+        // Don't emit a 'result' line — let the 50ms timeout fire and call kill()
+        const result = await pool.run(mutant, ['a.spec.ts']);
+        expect(result).toMatchObject({ error: 'timeout' });
+        expect(killSpy).toHaveBeenCalledWith(-42000, 'SIGKILL');
+        killSpy.mockRestore();
+    });
 });

package/dist/runner/vitest/__tests__/worker-runtime.spec.js

@@ -95,6 +95,15 @@ describe('VitestWorkerRuntime', () => {
         expect(createVitest).toHaveBeenCalledWith('test', expect.objectContaining({ config: '/custom/vitest.config.ts' }), expect.any(Object));
         await runtime.shutdown();
     });
+    it('passes maxWorkers: 1 and watch: false to createVitest to prevent fork resource contention and FS watcher re-runs', async () => {
+        const { createVitest } = await import('vitest/node');
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({ workerId: 'w-mw', cwd: tmp });
+        await runtime.init();
+        expect(createVitest).toHaveBeenCalledWith('test', expect.objectContaining({ maxWorkers: 1, watch: false }), expect.any(Object));
+        await runtime.shutdown();
+    });
     it('handles non-Error thrown during run', async () => {
         runSpecsFn.mockRejectedValue('string error');
         const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));
@@ -156,4 +165,121 @@ describe('VitestWorkerRuntime', () => {
         expect(result.killed).toBe(false);
         await runtime.shutdown();
     });
+    it('writes setup.mjs when MUTINEER_ACTIVE_ID_FILE is set', async () => {
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-setup-'));
+        tmpFiles.push(tmp);
+        const activeIdFile = path.join(tmp, '__mutineer__', 'active_id_wx.txt');
+        const origEnv = process.env.MUTINEER_ACTIVE_ID_FILE;
+        process.env.MUTINEER_ACTIVE_ID_FILE = activeIdFile;
+        try {
+            const runtime = createVitestWorkerRuntime({ workerId: 'wx', cwd: tmp });
+            await runtime.init();
+            const setupFile = path.join(tmp, '__mutineer__', 'setup.mjs');
+            expect(fs.existsSync(setupFile)).toBe(true);
+            expect(fs.readFileSync(setupFile, 'utf8')).toContain('beforeAll');
+            await runtime.shutdown();
+        }
+        finally {
+            if (origEnv === undefined) {
+                delete process.env.MUTINEER_ACTIVE_ID_FILE;
+            }
+            else {
+                process.env.MUTINEER_ACTIVE_ID_FILE = origEnv;
+            }
+        }
+    });
+    it('uses schema path when isFallback is false and MUTINEER_ACTIVE_ID_FILE is set', async () => {
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-schema-'));
+        tmpFiles.push(tmp);
+        const activeIdFile = path.join(tmp, '__mutineer__', 'active_id_ws.txt');
+        const origEnv = process.env.MUTINEER_ACTIVE_ID_FILE;
+        process.env.MUTINEER_ACTIVE_ID_FILE = activeIdFile;
+        try {
+            const runtime = createVitestWorkerRuntime({ workerId: 'ws', cwd: tmp });
+            await runtime.init();
+            await runtime.run({
+                id: 'mut#schema',
+                name: 'm',
+                file: path.join(tmp, 'src.ts'),
+                code: 'export const x=1',
+                line: 1,
+                col: 1,
+                isFallback: false,
+            }, [path.join(tmp, 'test.ts')]);
+            // invalidateFile should NOT be called for schema path
+            expect(invalidateFn).not.toHaveBeenCalled();
+            // Active ID file should be cleared after run
+            expect(fs.readFileSync(activeIdFile, 'utf8')).toBe('');
+            await runtime.shutdown();
+        }
+        finally {
+            if (origEnv === undefined) {
+                delete process.env.MUTINEER_ACTIVE_ID_FILE;
+            }
+            else {
+                process.env.MUTINEER_ACTIVE_ID_FILE = origEnv;
+            }
+        }
+    });
+    it('uses fallback path when isFallback is true even if MUTINEER_ACTIVE_ID_FILE is set', async () => {
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-fb-'));
+        tmpFiles.push(tmp);
+        const activeIdFile = path.join(tmp, '__mutineer__', 'active_id_wf.txt');
+        const origEnv = process.env.MUTINEER_ACTIVE_ID_FILE;
+        process.env.MUTINEER_ACTIVE_ID_FILE = activeIdFile;
+        try {
+            const runtime = createVitestWorkerRuntime({ workerId: 'wf', cwd: tmp });
+            await runtime.init();
+            await runtime.run({
+                id: 'mut#fb',
+                name: 'm',
+                file: path.join(tmp, 'src.ts'),
+                code: 'export const x=1',
+                line: 1,
+                col: 1,
+                isFallback: true,
+            }, [path.join(tmp, 'test.ts')]);
+            // invalidateFile SHOULD be called for fallback path
+            expect(invalidateFn).toHaveBeenCalledWith(path.join(tmp, 'src.ts'));
+            await runtime.shutdown();
+        }
+        finally {
+            if (origEnv === undefined) {
+                delete process.env.MUTINEER_ACTIVE_ID_FILE;
+            }
+            else {
+                process.env.MUTINEER_ACTIVE_ID_FILE = origEnv;
+            }
+        }
+    });
+    it('clears state.filesMap before each run to prevent memory accumulation', async () => {
+        const { createVitest } = await import('vitest/node');
+        const clearFn = vi.fn();
+        vi.mocked(createVitest).mockResolvedValueOnce({
+            init: initFn,
+            close: closeFn,
+            runTestSpecifications: runSpecsFn,
+            invalidateFile: invalidateFn,
+            getProjectByName: getProjectByNameFn,
+            state: { filesMap: { clear: clearFn } },
+        });
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-state-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({ workerId: 'w-state', cwd: tmp });
+        await runtime.init();
+        const mutant = {
+            id: 'mut#state',
+            name: 'm',
+            file: path.join(tmp, 'src.ts'),
+            code: 'export const x=1',
+            line: 1,
+            col: 1,
+        };
+        await runtime.run(mutant, [path.join(tmp, 'test.ts')]);
+        await runtime.run({ ...mutant, id: 'mut#state2' }, [
+            path.join(tmp, 'test.ts'),
+        ]);
+        expect(clearFn).toHaveBeenCalledTimes(2);
+        await runtime.shutdown();
+    });
 });

package/dist/runner/vitest/adapter.js

@@ -130,6 +130,7 @@ export class VitestAdapter {
             cwd: this.options.cwd,
             concurrency: workerCount,
             vitestConfig: this.options.config.vitestConfig,
+            vitestProject: this.options.vitestProject,
             timeoutMs: this.options.timeoutMs,
         });
         await this.pool.init();

package/dist/runner/vitest/plugin.d.ts

@@ -7,6 +7,9 @@
  *
  * The worker process sets globalThis.__mutineer_redirect__ before each test run,
  * and this plugin intercepts module loading to return the mutated code.
+ *
+ * For schema-eligible variants, the plugin serves a pre-built schema file that
+ * embeds all mutations as ternary chains keyed by globalThis.__mutineer_active_id__.
  */
 import type { PluginOption } from 'vite';
 export declare function poolMutineerPlugin(): PluginOption;