@mutineerjs/mutineer 0.1.0

package/dist/plugin/withVitest.d.ts

@@ -0,0 +1,13 @@
+import type { ViteUserConfig } from 'vitest/config';
+/**
+ * Wraps a Vite/Vitest configuration to integrate Mutineer mutation testing.
+ *
+ * When running under mutation testing (MUTATE_ACTIVE=1), this function:
+ * - Injects the Mutineer Vite plugin to intercept and replace module code
+ * - Enables global test functions (it, test, describe) for convenience
+ *
+ * @param user - User's Vitest configuration (optional)
+ * @returns Enhanced Vitest configuration with Mutineer integration
+ * @throws Error if plugins is not an array-like structure
+ */
+export declare function withMutineerSetup(user?: ViteUserConfig): ViteUserConfig;

package/dist/plugin/withVitest.js

@@ -0,0 +1,30 @@
+import { viteMutineerPlugin } from './viteMutate.js';
+/** Flag that indicates whether a mutation is currently active. */
+const MUTATION_ACTIVE_FLAG = '1';
+/**
+ * Wraps a Vite/Vitest configuration to integrate Mutineer mutation testing.
+ *
+ * When running under mutation testing (MUTATE_ACTIVE=1), this function:
+ * - Injects the Mutineer Vite plugin to intercept and replace module code
+ * - Enables global test functions (it, test, describe) for convenience
+ *
+ * @param user - User's Vitest configuration (optional)
+ * @returns Enhanced Vitest configuration with Mutineer integration
+ * @throws Error if plugins is not an array-like structure
+ */
+export function withMutineerSetup(user = {}) {
+    const isMutating = process.env.MUTATE_ACTIVE === MUTATION_ACTIVE_FLAG;
+    // Build plugin list: user plugins + mutineer plugin (if mutating)
+    const userPlugins = Array.isArray(user.plugins) ? user.plugins : (user.plugins ? [user.plugins] : []);
+    const plugins = isMutating
+        ? [...userPlugins, viteMutineerPlugin()]
+        : userPlugins;
+    return {
+        ...user,
+        plugins,
+        test: {
+            ...(user.test ?? {}),
+            globals: user.test?.globals ?? true, // default to true for convenience
+        }
+    };
+}

package/dist/runner/__tests__/discover.spec.d.ts

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

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

@@ -0,0 +1,59 @@
+import { describe, it, expect, vi } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import fssync from 'node:fs';
+import { normalizePath } from 'vite';
+import { autoDiscoverTargetsAndTests } from '../discover.js';
+// Mock Vite server creation to avoid opening a real port during tests
+vi.mock('vite', async () => {
+    const actual = await vi.importActual('vite');
+    return {
+        ...actual,
+        // Stub createServer to avoid binding ports in tests
+        createServer: vi.fn(async (options) => {
+            const root = options?.root ?? process.cwd();
+            return {
+                pluginContainer: {
+                    resolveId: async (spec, importer) => {
+                        if (path.isAbsolute(spec))
+                            return spec;
+                        const base = importer ? path.dirname(importer) : root;
+                        const candidate = path.resolve(base, spec);
+                        if (fssync.existsSync(candidate))
+                            return candidate;
+                        if (fssync.existsSync(`${candidate}.ts`))
+                            return `${candidate}.ts`;
+                        if (fssync.existsSync(`${candidate}.js`))
+                            return `${candidate}.js`;
+                        return candidate;
+                    },
+                },
+                close: async () => { },
+            };
+        }),
+    };
+});
+describe('autoDiscoverTargetsAndTests', () => {
+    it('ignores test files when collecting mutate targets', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const moduleFile = path.join(srcDir, 'foo.ts');
+        const testFile = path.join(srcDir, 'foo.test.ts');
+        await fs.mkdir(srcDir, { recursive: true });
+        await fs.writeFile(moduleFile, 'export const foo = 1\n', 'utf8');
+        const importLine = ['im', 'port { foo } from "./foo"'].join('');
+        await fs.writeFile(testFile, `${importLine}\nconsole.log(foo)\n`, 'utf8');
+        try {
+            const { targets } = await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+            });
+            const targetFiles = targets.map((t) => normalizePath(typeof t === 'string' ? t : t.file));
+            expect(targetFiles).toContain(normalizePath(moduleFile));
+            expect(targetFiles).not.toContain(normalizePath(testFile));
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/runner/__tests__/orchestrator.spec.d.ts

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

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

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { readMutantCache } from '../orchestrator.js';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+describe('Orchestrator', () => {
+    describe.skip('readMutantCache', () => {
+        it('should return empty object when cache file does not exist', async () => {
+            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-test-'));
+            try {
+                const cache = await readMutantCache(tmpDir);
+                expect(cache).toEqual({});
+            }
+            finally {
+                await fs.rm(tmpDir, { recursive: true, force: true });
+            }
+        });
+        it('should parse valid cache file', async () => {
+            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-test-'));
+            const cacheFile = path.join(tmpDir, '.mutate-cache.json');
+            try {
+                const cacheData = {
+                    'test:hash:file.ts:1,0:mutator': 'killed',
+                    'other:hash:file2.ts:2,5:flipStrictEQ': {
+                        status: 'escaped',
+                        file: '/path/to/file2.ts',
+                        line: 2,
+                        col: 5,
+                        mutator: 'flipStrictEQ'
+                    }
+                };
+                await fs.writeFile(cacheFile, JSON.stringify(cacheData), 'utf8');
+                const cache = await readMutantCache(tmpDir);
+                expect(cache).toBeDefined();
+                expect(Object.keys(cache).length).toBeGreaterThan(0);
+                expect(cache['test:hash:file.ts:1,0:mutator']).toBeDefined();
+            }
+            finally {
+                await fs.rm(tmpDir, { recursive: true, force: true });
+            }
+        });
+        it('should handle malformed JSON gracefully', async () => {
+            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-test-'));
+            const cacheFile = path.join(tmpDir, '.mutate-cache.json');
+            try {
+                await fs.writeFile(cacheFile, 'invalid json {', 'utf8');
+                const cache = await readMutantCache(tmpDir);
+                expect(cache).toEqual({});
+            }
+            finally {
+                await fs.rm(tmpDir, { recursive: true, force: true });
+            }
+        });
+    });
+});

package/dist/runner/adapters/__tests__/jest.spec.d.ts

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

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

@@ -0,0 +1,88 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import { createJestAdapter } from '../jest.js';
+// Mock JestPool to avoid real processes
+let poolInstance = null;
+let poolCtorOpts = null;
+vi.mock('../../pool/jest-pool.js', () => {
+    class MockPool {
+        constructor(opts) {
+            this.init = vi.fn();
+            this.run = vi.fn();
+            this.shutdown = vi.fn();
+            poolCtorOpts = opts;
+            poolInstance = this;
+        }
+    }
+    return { JestPool: MockPool };
+});
+// Mock runCLI from jest
+const runCLIMock = vi.fn();
+vi.mock('@jest/core', () => ({
+    runCLI: runCLIMock,
+}));
+function makeAdapter(opts = {}) {
+    return createJestAdapter({
+        cwd: opts.cwd ?? process.cwd(),
+        concurrency: opts.concurrency ?? 2,
+        timeoutMs: opts.timeoutMs ?? 1000,
+        debug: opts.debug ?? false,
+        config: opts.config ?? { jestConfig: undefined },
+        cliArgs: opts.cliArgs ?? ['--changed'],
+    });
+}
+describe('Jest adapter', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('initializes pool with override concurrency', async () => {
+        const adapter = makeAdapter();
+        await adapter.init(4);
+        expect(poolInstance?.init).toHaveBeenCalledTimes(1);
+        expect(poolCtorOpts.concurrency).toBe(4);
+    });
+    it('runs baseline via runCLI with coverage when requested', async () => {
+        const adapter = makeAdapter({ config: { jestConfig: 'jest.config.ts' } });
+        runCLIMock.mockResolvedValueOnce({ results: { success: true } });
+        const ok = await adapter.runBaseline(['test-a'], { collectCoverage: true, perTestCoverage: false });
+        expect(ok).toBe(true);
+        expect(runCLIMock).toHaveBeenCalledTimes(1);
+        const args = runCLIMock.mock.calls[0][0];
+        expect(args.collectCoverage).toBe(true);
+        expect(args.coverageProvider).toBe('v8');
+        expect(args.config).toBe('jest.config.ts');
+    });
+    it('maps pool result to mutant status', async () => {
+        const adapter = makeAdapter();
+        await adapter.init();
+        poolInstance.run.mockResolvedValueOnce({ killed: true, durationMs: 10 });
+        const res = await adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
+        expect(res).toEqual({ status: 'killed', durationMs: 10, error: undefined });
+    });
+    it('maps pool errors to error status', async () => {
+        const adapter = makeAdapter();
+        await adapter.init();
+        poolInstance.run.mockResolvedValueOnce({ killed: true, durationMs: 12, error: 'crash' });
+        const res = await adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
+        expect(res).toEqual({ status: 'error', durationMs: 12, error: 'crash' });
+    });
+    it('detects coverage config from jest config file', async () => {
+        const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-jest-'));
+        const cfgPath = path.join(tmp, 'jest.config.ts');
+        await fs.writeFile(cfgPath, 'module.exports = { collectCoverage: true }');
+        try {
+            const adapter = makeAdapter({ cwd: tmp, config: { jestConfig: 'jest.config.ts' } });
+            const coverage = await adapter.detectCoverageConfig();
+            expect(coverage.coverageEnabled).toBe(true);
+            expect(coverage.perTestEnabled).toBe(false);
+        }
+        finally {
+            await fs.rm(tmp, { recursive: true, force: true });
+        }
+    });
+});

package/dist/runner/adapters/__tests__/vitest-worker-runtime.spec.d.ts

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

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

@@ -0,0 +1,59 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { createVitestWorkerRuntime } from '../vitest-worker-runtime.js';
+const initFn = vi.fn();
+const closeFn = vi.fn();
+const runSpecsFn = vi.fn();
+const invalidateFn = vi.fn();
+const getProjectByNameFn = vi.fn();
+vi.mock('vitest/node', () => ({
+    createVitest: vi.fn(async () => ({
+        init: initFn,
+        close: closeFn,
+        runTestSpecifications: runSpecsFn,
+        invalidateFile: invalidateFn,
+        getProjectByName: getProjectByNameFn,
+    }))
+}));
+describe('VitestWorkerRuntime', () => {
+    const tmpFiles = [];
+    beforeEach(() => {
+        vi.clearAllMocks();
+        getProjectByNameFn.mockReturnValue({
+            createSpecification: (file) => ({ moduleId: file })
+        });
+        runSpecsFn.mockResolvedValue({ testModules: [{ moduleId: 'a', ok: () => false }] });
+    });
+    afterEach(() => {
+        for (const f of tmpFiles.splice(0)) {
+            try {
+                fs.rmSync(f, { recursive: true, force: true });
+            }
+            catch { }
+        }
+    });
+    it('runs specs and reports kill based on results', async () => {
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({ workerId: 'w1', cwd: tmp });
+        await runtime.init();
+        const result = await runtime.run({ id: 'mut#1', name: 'm', file: path.join(tmp, 'src.ts'), code: 'export const x=1', line: 1, col: 1 }, [path.join(tmp, 'test.ts')]);
+        expect(initFn).toHaveBeenCalled();
+        expect(runSpecsFn).toHaveBeenCalled();
+        expect(result.killed).toBe(true);
+        expect(fs.existsSync(path.join(tmp, 'src', '__mutineer__'))).toBe(false);
+        await runtime.shutdown();
+    });
+    it('returns escaped when no specs produced', async () => {
+        getProjectByNameFn.mockReturnValue({ createSpecification: () => null });
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({ workerId: 'w2', cwd: tmp });
+        await runtime.init();
+        const result = await runtime.run({ id: 'mut#2', name: 'm', file: path.join(tmp, 'src.ts'), code: 'export const x=1', line: 1, col: 1 }, [path.join(tmp, 'test.ts')]);
+        expect(result.killed).toBe(false);
+        await runtime.shutdown();
+    });
+});

package/dist/runner/adapters/__tests__/vitest.spec.d.ts

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

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

@@ -0,0 +1,118 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import { createVitestAdapter, isCoverageRequestedInArgs } from '../vitest.js';
+// Mock VitestPool to avoid spinning processes
+var poolInstance = null;
+var poolCtorOpts = null;
+vi.mock('../../pool/index.js', () => {
+    class MockPool {
+        constructor(opts) {
+            this.init = vi.fn();
+            this.run = vi.fn();
+            this.shutdown = vi.fn();
+            poolCtorOpts = opts;
+            poolInstance = this;
+        }
+    }
+    return { VitestPool: MockPool };
+});
+// Mock spawn for baseline runs
+var spawnMock;
+vi.mock('node:child_process', async () => {
+    const actual = await vi.importActual('node:child_process');
+    spawnMock = vi.fn();
+    return { ...actual, spawn: spawnMock };
+});
+function makeAdapter(opts = {}) {
+    return createVitestAdapter({
+        cwd: opts.cwd ?? process.cwd(),
+        concurrency: opts.concurrency ?? 2,
+        timeoutMs: opts.timeoutMs ?? 1000,
+        debug: opts.debug ?? false,
+        config: opts.config ?? { vitestConfig: undefined },
+        cliArgs: opts.cliArgs ?? ['--changed']
+    });
+}
+describe('Vitest adapter', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('initializes pool with override concurrency', async () => {
+        const adapter = makeAdapter();
+        await adapter.init(5);
+        expect(poolInstance?.init).toHaveBeenCalledTimes(1);
+        expect(poolCtorOpts.concurrency).toBe(5);
+    });
+    it('maps pool result to mutant status', async () => {
+        poolInstance = null;
+        poolCtorOpts = null;
+        const adapter = makeAdapter();
+        await adapter.init();
+        poolInstance.run.mockResolvedValueOnce({ killed: true, durationMs: 10 });
+        const res = await adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
+        expect(res).toEqual({ status: 'killed', durationMs: 10, error: undefined });
+    });
+    it('maps pool timeout errors to timeout status', async () => {
+        const adapter = makeAdapter();
+        await adapter.init();
+        poolInstance.run.mockResolvedValueOnce({ killed: true, durationMs: 15, error: 'timeout' });
+        const res = await adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
+        expect(res).toEqual({ status: 'timeout', durationMs: 15, error: 'timeout' });
+    });
+    it('maps pool errors to error status', async () => {
+        const adapter = makeAdapter();
+        await adapter.init();
+        poolInstance.run.mockResolvedValueOnce({ killed: true, durationMs: 12, error: 'crash' });
+        const res = await adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
+        expect(res).toEqual({ status: 'error', durationMs: 12, error: 'crash' });
+    });
+    it('returns error status on pool throw', async () => {
+        const adapter = makeAdapter();
+        await adapter.init();
+        poolInstance.run.mockRejectedValueOnce(new Error('boom'));
+        const res = await adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
+        expect(res.status).toBe('error');
+    });
+    it('includes coverage args for baseline when requested', async () => {
+        const adapter = makeAdapter({ cliArgs: [] });
+        spawnMock.mockImplementationOnce(() => ({
+            on: (evt, cb) => {
+                if (evt === 'exit')
+                    cb(0);
+            }
+        }));
+        const ok = await adapter.runBaseline(['test-a'], { collectCoverage: true, perTestCoverage: true });
+        expect(ok).toBe(true);
+        const call = spawnMock.mock.calls[0];
+        const args = call[1];
+        expect(args.join(' ')).toContain('--coverage.enabled=true');
+        expect(args.join(' ')).toContain('--coverage.perTest=true');
+    });
+    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');
+        await fs.writeFile(cfgPath, 'export default { coverage: { enabled: true }, test: { coverage: { perTest: true } } }');
+        try {
+            const adapter = makeAdapter({ cwd: tmp, config: { vitestConfig: 'vitest.config.ts' } });
+            const coverage = await adapter.detectCoverageConfig();
+            expect(coverage.coverageEnabled).toBe(true);
+            expect(coverage.perTestEnabled).toBe(true);
+        }
+        finally {
+            await fs.rm(tmp, { recursive: true, force: true });
+        }
+    });
+});
+describe('isCoverageRequestedInArgs', () => {
+    it('detects enabled coverage flags', () => {
+        expect(isCoverageRequestedInArgs(['--coverage'])).toBe(true);
+        expect(isCoverageRequestedInArgs(['--coverage.enabled=true'])).toBe(true);
+        expect(isCoverageRequestedInArgs(['--coverage.enabled=false'])).toBe(false);
+        expect(isCoverageRequestedInArgs(['--no-coverage'])).toBe(false);
+    });
+});

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

@@ -0,0 +1,10 @@
+/**
+ * Test Runner Adapters
+ *
+ * This module exports the adapter interface and available implementations.
+ * Currently supports Vitest and Jest, with the architecture ready for additional
+ * test runners (Mocha, etc.).
+ */
+export type { TestRunnerAdapter, TestRunnerAdapterOptions, TestRunnerAdapterFactory, MutantPayload, MutantRunResult, BaselineOptions, CoverageConfig, } from './types.js';
+export { VitestAdapter, createVitestAdapter, isCoverageRequestedInArgs } from './vitest/index.js';
+export { JestAdapter, createJestAdapter } from './jest/index.js';

package/dist/runner/adapters/index.js

@@ -0,0 +1,9 @@
+/**
+ * Test Runner Adapters
+ *
+ * This module exports the adapter interface and available implementations.
+ * Currently supports Vitest and Jest, with the architecture ready for additional
+ * test runners (Mocha, etc.).
+ */
+export { VitestAdapter, createVitestAdapter, isCoverageRequestedInArgs } from './vitest/index.js';
+export { JestAdapter, createJestAdapter } from './jest/index.js';

package/dist/runner/adapters/jest/__tests__/index.spec.d.ts

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

package/dist/runner/adapters/jest/__tests__/index.spec.js

@@ -0,0 +1,88 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import { createJestAdapter } from '../index.js';
+// Mock JestPool to avoid real processes
+let poolInstance = null;
+let poolCtorOpts = null;
+vi.mock('../../../pool/jest/pool.js', () => {
+    class MockPool {
+        constructor(opts) {
+            this.init = vi.fn();
+            this.run = vi.fn();
+            this.shutdown = vi.fn();
+            poolCtorOpts = opts;
+            poolInstance = this;
+        }
+    }
+    return { JestPool: MockPool };
+});
+// Mock runCLI from jest
+const runCLIMock = vi.fn();
+vi.mock('@jest/core', () => ({
+    runCLI: runCLIMock,
+}));
+function makeAdapter(opts = {}) {
+    return createJestAdapter({
+        cwd: opts.cwd ?? process.cwd(),
+        concurrency: opts.concurrency ?? 2,
+        timeoutMs: opts.timeoutMs ?? 1000,
+        debug: opts.debug ?? false,
+        config: opts.config ?? { jestConfig: undefined },
+        cliArgs: opts.cliArgs ?? ['--changed'],
+    });
+}
+describe('Jest adapter', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('initializes pool with override concurrency', async () => {
+        const adapter = makeAdapter();
+        await adapter.init(4);
+        expect(poolInstance?.init).toHaveBeenCalledTimes(1);
+        expect(poolCtorOpts.concurrency).toBe(4);
+    });
+    it('runs baseline via runCLI with coverage when requested', async () => {
+        const adapter = makeAdapter({ config: { jestConfig: 'jest.config.ts' } });
+        runCLIMock.mockResolvedValueOnce({ results: { success: true } });
+        const ok = await adapter.runBaseline(['test-a'], { collectCoverage: true, perTestCoverage: false });
+        expect(ok).toBe(true);
+        expect(runCLIMock).toHaveBeenCalledTimes(1);
+        const args = runCLIMock.mock.calls[0][0];
+        expect(args.collectCoverage).toBe(true);
+        expect(args.coverageProvider).toBe('v8');
+        expect(args.config).toBe('jest.config.ts');
+    });
+    it('maps pool result to mutant status', async () => {
+        const adapter = makeAdapter();
+        await adapter.init();
+        poolInstance.run.mockResolvedValueOnce({ killed: true, durationMs: 10 });
+        const res = await adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
+        expect(res).toEqual({ status: 'killed', durationMs: 10, error: undefined });
+    });
+    it('maps pool errors to error status', async () => {
+        const adapter = makeAdapter();
+        await adapter.init();
+        poolInstance.run.mockResolvedValueOnce({ killed: true, durationMs: 12, error: 'crash' });
+        const res = await adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
+        expect(res).toEqual({ status: 'error', durationMs: 12, error: 'crash' });
+    });
+    it('detects coverage config from jest config file', async () => {
+        const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-jest-'));
+        const cfgPath = path.join(tmp, 'jest.config.ts');
+        await fs.writeFile(cfgPath, 'module.exports = { collectCoverage: true }');
+        try {
+            const adapter = makeAdapter({ cwd: tmp, config: { jestConfig: 'jest.config.ts' } });
+            const coverage = await adapter.detectCoverageConfig();
+            expect(coverage.coverageEnabled).toBe(true);
+            expect(coverage.perTestEnabled).toBe(false);
+        }
+        finally {
+            await fs.rm(tmp, { recursive: true, force: true });
+        }
+    });
+});

package/dist/runner/adapters/jest/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Jest Test Runner Adapter
+ *
+ * Implements the TestRunnerAdapter interface for Jest using runCLI.
+ * Baseline runs are executed directly via runCLI; mutant runs are delegated
+ * to a pool of long-lived worker processes that also use runCLI with a
+ * redirect resolver to swap in mutated code.
+ */
+import type { TestRunnerAdapter, TestRunnerAdapterOptions, MutantPayload, MutantRunResult, BaselineOptions, CoverageConfig } from '../types.js';
+export declare class JestAdapter implements TestRunnerAdapter {
+    readonly name = "jest";
+    private readonly options;
+    private jestConfigPath?;
+    private pool;
+    private readonly requireFromCwd;
+    constructor(options: TestRunnerAdapterOptions);
+    init(concurrencyOverride?: number): Promise<void>;
+    runBaseline(tests: readonly string[], options: BaselineOptions): Promise<boolean>;
+    runMutant(mutant: MutantPayload, tests: readonly string[]): Promise<MutantRunResult>;
+    shutdown(): Promise<void>;
+    hasCoverageProvider(): boolean;
+    detectCoverageConfig(): Promise<CoverageConfig>;
+}
+export declare function createJestAdapter(options: TestRunnerAdapterOptions): JestAdapter;