@mutineerjs/mutineer 0.9.0 → 0.11.0

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

@@ -1,6 +1,8 @@
-import { describe, it, expect, vi } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { EventEmitter } from 'node:events';
+import * as childProcess from 'node:child_process';
 import { JestPool, runWithJestPool } from '../pool.js';
+vi.mock('node:child_process', () => ({ fork: vi.fn() }));
 // We'll use the createWorker option to inject mock workers instead of forking processes
 function makeMockWorker(id) {
     const worker = {
@@ -30,6 +32,226 @@ const dummyMutant = {
     line: 1,
     col: 0,
 };
+describe('JestWorker via JestPool (real fork mock)', () => {
+    const mockProcesses = [];
+    beforeEach(() => {
+        mockProcesses.length = 0;
+        vi.mocked(childProcess.fork).mockImplementation(() => {
+            const proc = new EventEmitter();
+            proc.stderr = new EventEmitter();
+            proc.send = vi.fn();
+            proc.kill = vi.fn();
+            proc.pid = 12345;
+            mockProcesses.push(proc);
+            return proc;
+        });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    async function initWorkerPool(opts = {}) {
+        const pool = new JestPool({
+            cwd: opts.cwd ?? '/test',
+            concurrency: 1,
+            jestConfig: opts.jestConfig,
+        });
+        const initP = pool.init();
+        await new Promise((r) => setImmediate(r));
+        mockProcesses[0].emit('message', { type: 'ready' });
+        await initP;
+        return pool;
+    }
+    async function shutdownWorkerPool(pool) {
+        const p = pool.shutdown();
+        await new Promise((r) => setImmediate(r));
+        mockProcesses[mockProcesses.length - 1].emit('message', {
+            type: 'shutdown',
+        });
+        await p;
+    }
+    it('starts worker and emits ready via IPC', async () => {
+        const pool = await initWorkerPool();
+        expect(mockProcesses).toHaveLength(1);
+        expect(mockProcesses[0].send).toBeDefined();
+        await shutdownWorkerPool(pool);
+    });
+    it('passes jestConfig to env', async () => {
+        let capturedEnv;
+        vi.mocked(childProcess.fork).mockImplementationOnce((_script, _args, opts) => {
+            capturedEnv = opts?.env;
+            const proc = new EventEmitter();
+            proc.stderr = new EventEmitter();
+            proc.send = vi.fn();
+            proc.kill = vi.fn();
+            proc.pid = 99;
+            mockProcesses.push(proc);
+            return proc;
+        });
+        const pool = new JestPool({
+            cwd: '/proj',
+            concurrency: 1,
+            jestConfig: 'jest.config.ts',
+        });
+        const initP = pool.init();
+        await new Promise((r) => setImmediate(r));
+        expect(capturedEnv?.MUTINEER_JEST_CONFIG).toBe('jest.config.ts');
+        mockProcesses[0].emit('message', { type: 'ready' });
+        await initP;
+        await shutdownWorkerPool(pool);
+    });
+    it('handleMessage: result with pending task resolves run()', async () => {
+        const pool = await initWorkerPool();
+        const runP = pool.run(dummyMutant, ['t']);
+        await new Promise((r) => setImmediate(r));
+        mockProcesses[0].emit('message', {
+            type: 'result',
+            killed: true,
+            durationMs: 42,
+        });
+        const result = await runP;
+        expect(result.killed).toBe(true);
+        expect(result.durationMs).toBe(42);
+        await shutdownWorkerPool(pool);
+    });
+    it('handleMessage: result with nullish killed/durationMs uses defaults', async () => {
+        const pool = await initWorkerPool();
+        const runP = pool.run(dummyMutant, ['t']);
+        await new Promise((r) => setImmediate(r));
+        mockProcesses[0].emit('message', { type: 'result' });
+        const result = await runP;
+        expect(result.killed).toBe(true); // ?? true default
+        expect(result.durationMs).toBe(0); // ?? 0 default
+        await shutdownWorkerPool(pool);
+    });
+    it('handleMessage: result when no pending task is silently ignored', async () => {
+        const pool = await initWorkerPool();
+        mockProcesses[0].emit('message', {
+            type: 'result',
+            killed: true,
+            durationMs: 5,
+        });
+        expect(true).toBe(true);
+        await shutdownWorkerPool(pool);
+    });
+    it('handleMessage: shutdown type triggers shutdown resolution', async () => {
+        const pool = await initWorkerPool();
+        const shutdownP = pool.shutdown();
+        await new Promise((r) => setImmediate(r));
+        mockProcesses[0].emit('message', { type: 'shutdown' });
+        await shutdownP;
+        expect(true).toBe(true);
+    });
+    it('process error event triggers handleExit and rejects pending run', async () => {
+        const pool = await initWorkerPool();
+        const runP = pool.run(dummyMutant, ['t']);
+        await new Promise((r) => setImmediate(r));
+        mockProcesses[0].emit('error', new Error('ENOENT'));
+        await expect(runP).rejects.toThrow('Worker exited unexpectedly');
+    });
+    it('process exit event with code triggers handleExit', async () => {
+        const pool = await initWorkerPool();
+        const runP = pool.run(dummyMutant, ['t']);
+        await new Promise((r) => setImmediate(r));
+        mockProcesses[0].emit('exit', 1);
+        await expect(runP).rejects.toThrow('Worker exited unexpectedly with code 1');
+    });
+    it('process exit with null code uses ?? 1 fallback', async () => {
+        const pool = await initWorkerPool();
+        const runP = pool.run(dummyMutant, ['t']);
+        await new Promise((r) => setImmediate(r));
+        mockProcesses[0].emit('exit', null);
+        await expect(runP).rejects.toThrow('Worker exited unexpectedly with code 1');
+    });
+    it('handleExit during shutdown skips pending rejection', async () => {
+        const pool = await initWorkerPool();
+        const shutdownP = pool.shutdown();
+        await new Promise((r) => setImmediate(r));
+        // emit exit while shutting down — handleExit called with shuttingDown=true
+        mockProcesses[0].emit('exit', 0);
+        // emit shutdown to resolve
+        mockProcesses[0].emit('message', { type: 'shutdown' });
+        await shutdownP;
+        expect(true).toBe(true);
+    });
+    it('pool.run() throws when pool is shutting down', async () => {
+        const pool = await initWorkerPool();
+        pool.shutdown(); // don't await
+        await expect(pool.run(dummyMutant, ['t'])).rejects.toThrow('Pool is shutting down');
+    });
+    it('acquireWorker queues second run when single worker is busy', async () => {
+        const pool = await initWorkerPool();
+        const [run1, run2] = [
+            pool.run(dummyMutant, ['t']),
+            pool.run({ ...dummyMutant, id: '2' }, ['t']),
+        ];
+        await new Promise((r) => setImmediate(r));
+        // resolve first run
+        mockProcesses[0].emit('message', {
+            type: 'result',
+            killed: true,
+            durationMs: 5,
+        });
+        await new Promise((r) => setImmediate(r));
+        // resolve second run
+        mockProcesses[0].emit('message', {
+            type: 'result',
+            killed: false,
+            durationMs: 3,
+        });
+        const [r1, r2] = await Promise.all([run1, run2]);
+        expect(r1.killed).toBe(true);
+        expect(r2.killed).toBe(false);
+        await shutdownWorkerPool(pool);
+    });
+    it('releaseWorker skips non-ready worker', async () => {
+        // Use createWorker mock where worker becomes not-ready after run
+        let workerReady = true;
+        const pool = new JestPool({
+            cwd: '/test',
+            concurrency: 1,
+            createWorker: (id) => {
+                const w = new EventEmitter();
+                w.id = id;
+                w.start = vi.fn().mockResolvedValue(undefined);
+                w.isReady = vi.fn(() => workerReady);
+                w.isBusy = vi.fn().mockReturnValue(false);
+                w.run = vi.fn().mockImplementation(async () => {
+                    workerReady = false;
+                    return { killed: true, durationMs: 1 };
+                });
+                w.shutdown = vi.fn().mockResolvedValue(undefined);
+                w.kill = vi.fn();
+                return w;
+            },
+        });
+        await pool.init();
+        const result = await pool.run(dummyMutant, ['t']);
+        expect(result.killed).toBe(true);
+        await pool.shutdown();
+    });
+    it('runWithJestPool maps non-Error exception to error status', async () => {
+        const pool = new JestPool({
+            cwd: '/test',
+            concurrency: 1,
+            createWorker: (id) => {
+                const w = new EventEmitter();
+                w.id = id;
+                w.start = vi.fn().mockResolvedValue(undefined);
+                w.isReady = vi.fn().mockReturnValue(true);
+                w.isBusy = vi.fn().mockReturnValue(false);
+                w.run = vi.fn().mockRejectedValue('string error');
+                w.shutdown = vi.fn().mockResolvedValue(undefined);
+                w.kill = vi.fn();
+                return w;
+            },
+        });
+        await pool.init();
+        const result = await runWithJestPool(pool, dummyMutant, ['t']);
+        expect(result.status).toBe('error');
+        expect(result.error).toBe('string error');
+        await pool.shutdown();
+    });
+});
 describe('JestPool', () => {
     it('throws if run is called before init', async () => {
         const pool = new JestPool({ cwd: '/tmp', concurrency: 1 });

package/dist/runner/jest/adapter.js

@@ -9,51 +9,11 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { createRequire } from 'node:module';
-// import os from 'node:os'
 import { JestPool } from './pool.js';
 import { createLogger } from '../../utils/logger.js';
+import { toErrorMessage } from '../../utils/errors.js';
 const require = createRequire(import.meta.url);
 const log = createLogger('jest-adapter');
-/**
- * Strip mutineer-specific CLI args that shouldn't be passed to Jest.
- */
-function stripMutineerArgs(args) {
-    const out = [];
-    const consumeNext = new Set([
-        '--concurrency',
-        '--progress',
-        '--min-kill-percent',
-        '--config',
-        '-c',
-        '--coverage-file',
-        '--runner',
-    ]);
-    const dropExact = new Set([
-        '-m',
-        '--mutate',
-        '--changed',
-        '--changed-with-deps',
-        '--full',
-        '--only-covered-lines',
-        '--per-test-coverage',
-        '--perTestCoverage',
-    ]);
-    for (let i = 0; i < args.length; i++) {
-        const a = args[i];
-        if (dropExact.has(a))
-            continue;
-        if (consumeNext.has(a)) {
-            i++;
-            continue;
-        }
-        if (a.startsWith('--min-kill-percent='))
-            continue;
-        if (a.startsWith('--config=') || a.startsWith('-c='))
-            continue;
-        out.push(a);
-    }
-    return out;
-}
 async function loadRunCLI(requireFromCwd) {
     try {
         return requireFromCwd('@jest/core');
@@ -91,7 +51,6 @@ export class JestAdapter {
         this.pool = null;
         this.options = options;
         this.jestConfigPath = options.config.jestConfig;
-        stripMutineerArgs(options.cliArgs);
         this.requireFromCwd = createRequire(path.join(options.cwd, 'package.json'));
     }
     async init(concurrencyOverride) {
@@ -132,8 +91,7 @@ export class JestAdapter {
             success = results.success;
         }
         catch (err) {
-            log.debug('Failed to run Jest baseline: ' +
-                (err instanceof Error ? err.message : String(err)));
+            log.debug('Failed to run Jest baseline: ' + toErrorMessage(err));
         }
         finally {
             process.stdout.write = origStdoutWrite;
@@ -176,7 +134,7 @@ export class JestAdapter {
             return {
                 status: 'error',
                 durationMs: 0,
-                error: err instanceof Error ? err.message : String(err),
+                error: toErrorMessage(err),
             };
         }
     }

package/dist/runner/jest/pool.js

@@ -1,9 +1,10 @@
 import { fork } from 'node:child_process';
 import * as path from 'node:path';
-import * as fs from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { EventEmitter } from 'node:events';
 import { createLogger, DEBUG } from '../../utils/logger.js';
+import { resolveWorkerScript } from '../shared/index.js';
+import { toErrorMessage } from '../../utils/errors.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const workerLog = createLogger('JestWorker');
 const poolLog = createLogger('JestPool');
@@ -19,14 +20,7 @@ class JestWorker extends EventEmitter {
         this.id = id;
     }
     async start() {
-        const workerJs = path.join(__dirname, 'worker.js');
-        const workerMts = path.join(__dirname, 'worker.mjs');
-        const workerTs = path.join(__dirname, 'worker.mts');
-        const workerScript = fs.existsSync(workerJs)
-            ? workerJs
-            : fs.existsSync(workerMts)
-                ? workerMts
-                : workerTs;
+        const workerScript = resolveWorkerScript(__dirname, 'worker');
         const env = {
             ...process.env,
             MUTINEER_WORKER_ID: this.id,
@@ -301,7 +295,7 @@ export async function runWithJestPool(pool, mutant, tests) {
         return {
             status: 'error',
             durationMs: 0,
-            error: err instanceof Error ? err.message : String(err),
+            error: toErrorMessage(err),
         };
     }
 }

package/dist/runner/jest/worker-runtime.js

@@ -4,6 +4,7 @@ import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
 import { getMutantFilePath, setRedirect, clearRedirect, } from '../shared/index.js';
 import { createLogger } from '../../utils/logger.js';
+import { toErrorMessage } from '../../utils/errors.js';
 const log = createLogger('jest-runtime');
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -76,7 +77,7 @@ export class JestWorkerRuntime {
             return {
                 killed: true,
                 durationMs: Date.now() - start,
-                error: err instanceof Error ? err.message : String(err),
+                error: toErrorMessage(err),
             };
         }
         finally {

package/dist/runner/orchestrator.js

@@ -61,18 +61,18 @@ export async function runOrchestrator(cliArgs, cwd) {
     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'
+    log.info(`Mutineer starting in ${opts.wantsChangedWithImports
+        ? 'changed files with imports'
         : opts.wantsChanged
             ? 'changed files only'
             : 'full'} mode${opts.wantsOnlyCoveredLines ? ' (only covered lines)' : ''}...`);
     log.info(`Using concurrency=${opts.concurrency} (cpus=${os.cpus().length})`);
     // 3. Enumerate changed files if requested
-    const changedAbs = opts.wantsChanged || opts.wantsChangedWithDeps
+    const changedAbs = opts.wantsChanged || opts.wantsChangedWithImports
         ? new Set(listChangedFiles(cwd, {
-            includeDeps: opts.wantsChangedWithDeps,
+            includeDeps: opts.wantsChangedWithImports,
             baseRef: cfg.baseRef,
-            maxDepth: cfg.dependencyDepth,
+            maxDepth: cfg.importDepth,
         }))
         : null;
     // 4. Discover targets and tests
@@ -85,6 +85,7 @@ export async function runOrchestrator(cliArgs, cwd) {
         : (cfg.autoDiscover ?? true)
             ? discovered.targets
             : [];
+    targets.sort((a, b) => getTargetFile(a).localeCompare(getTargetFile(b)));
     // Collect all test files for baseline run
     const allTestFiles = new Set();
     for (const target of targets) {
@@ -99,7 +100,7 @@ export async function runOrchestrator(cliArgs, cwd) {
         }
     }
     const baselineTests = Array.from(allTestFiles);
-    if (opts.wantsChangedWithDeps) {
+    if (opts.wantsChangedWithImports) {
         let uncoveredCount = 0;
         for (const target of targets) {
             const absFile = normalizePath(path.isAbsolute(getTargetFile(target))
@@ -111,7 +112,7 @@ export async function runOrchestrator(cliArgs, cwd) {
             }
         }
         if (uncoveredCount > 0) {
-            log.info(`${uncoveredCount} target(s) from --changed-with-deps have no covering tests and will be skipped`);
+            log.info(`${uncoveredCount} target(s) from --changed-with-imports have no covering tests and will be skipped`);
         }
     }
     if (!baselineTests.length) {

package/dist/runner/pool-executor.js

@@ -7,7 +7,6 @@ import { computeSummary, printSummary, buildJsonReport, } from '../utils/summary
 import { saveCacheAtomic } from './cache.js';
 import { cleanupMutineerDirs } from './cleanup.js';
 import { PoolSpinner } from '../utils/PoolSpinner.js';
-import { CompileErrors } from '../utils/CompileErrors.js';
 import { createLogger } from '../utils/logger.js';
 const log = createLogger('pool-executor');
 /**
@@ -24,7 +23,7 @@ export async function executePool(opts) {
     const mutationStartTime = Date.now();
     // Ensure we only finish once
     let finished = false;
-    const finishOnce = async (interactive = true) => {
+    const finishOnce = async () => {
         if (finished)
             return;
         finished = true;
@@ -41,15 +40,7 @@ export async function executePool(opts) {
             log.info(`JSON report written to ${path.relative(process.cwd(), outPath)}`);
         }
         else {
-            const compileErrorEntries = Object.values(cache).filter((e) => e.status === 'compile-error');
-            const useInteractive = interactive && process.stdout.isTTY && compileErrorEntries.length > 0;
-            printSummary(summary, cache, durationMs, {
-                skipCompileErrors: useInteractive,
-            });
-            if (useInteractive) {
-                const { waitUntilExit } = render(createElement(CompileErrors, { entries: compileErrorEntries, cwd }));
-                await waitUntilExit();
-            }
+            printSummary(summary, cache, durationMs);
         }
         if (opts.minKillPercent !== undefined) {
             const killRateString = summary.killRate.toFixed(2);
@@ -151,6 +142,10 @@ export async function executePool(opts) {
                 (directTests ?? tests).length > 0 && {
                 coveringTests: directTests ?? tests,
             }),
+            ...(status === 'escaped' &&
+                result.passingTests?.length && {
+                passingTests: result.passingTests,
+            }),
         };
         progress.update(status);
     }
@@ -170,7 +165,7 @@ export async function executePool(opts) {
             return;
         signalCleanedUp = true;
         log.info(`\nReceived ${signal}, cleaning up...`);
-        await finishOnce(false);
+        await finishOnce();
         await adapter.shutdown();
         await cleanupMutineerDirs(cwd);
         process.exit(1);

package/dist/runner/shared/__tests__/strip-mutineer-args.spec.d.ts

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

package/dist/runner/shared/__tests__/strip-mutineer-args.spec.js

@@ -0,0 +1,104 @@
+import { describe, it, expect } from 'vitest';
+import { stripMutineerArgs } from '../strip-mutineer-args.js';
+describe('stripMutineerArgs', () => {
+    describe('dropExact flags', () => {
+        it('drops -m', () => {
+            expect(stripMutineerArgs(['-m', '--verbose'])).toEqual(['--verbose']);
+        });
+        it('drops --mutate', () => {
+            expect(stripMutineerArgs(['--mutate', '--verbose'])).toEqual([
+                '--verbose',
+            ]);
+        });
+        it('drops --changed', () => {
+            expect(stripMutineerArgs(['--changed'])).toEqual([]);
+        });
+        it('drops --changed-with-imports', () => {
+            expect(stripMutineerArgs(['--changed-with-imports'])).toEqual([]);
+        });
+        it('drops --full', () => {
+            expect(stripMutineerArgs(['--full'])).toEqual([]);
+        });
+        it('drops --only-covered-lines', () => {
+            expect(stripMutineerArgs(['--only-covered-lines'])).toEqual([]);
+        });
+        it('drops --per-test-coverage', () => {
+            expect(stripMutineerArgs(['--per-test-coverage'])).toEqual([]);
+        });
+        it('drops --perTestCoverage', () => {
+            expect(stripMutineerArgs(['--perTestCoverage'])).toEqual([]);
+        });
+    });
+    describe('consumeNext flags (drops flag and its value)', () => {
+        it('drops --concurrency and next token', () => {
+            expect(stripMutineerArgs(['--concurrency', '4', '--verbose'])).toEqual([
+                '--verbose',
+            ]);
+        });
+        it('drops --progress and next token', () => {
+            expect(stripMutineerArgs(['--progress', 'list'])).toEqual([]);
+        });
+        it('drops --min-kill-percent and next token', () => {
+            expect(stripMutineerArgs(['--min-kill-percent', '80', '--verbose'])).toEqual(['--verbose']);
+        });
+        it('drops --config and next token', () => {
+            expect(stripMutineerArgs(['--config', 'vitest.config.ts', '--verbose'])).toEqual(['--verbose']);
+        });
+        it('drops -c and next token', () => {
+            expect(stripMutineerArgs(['-c', 'vitest.config.ts'])).toEqual([]);
+        });
+        it('drops --coverage-file and next token', () => {
+            expect(stripMutineerArgs(['--coverage-file', 'cov.json'])).toEqual([]);
+        });
+        it('drops --report and next token', () => {
+            expect(stripMutineerArgs(['--report', 'json', '--verbose'])).toEqual([
+                '--verbose',
+            ]);
+        });
+    });
+    describe('prefix-based drops', () => {
+        it('drops --min-kill-percent=N', () => {
+            expect(stripMutineerArgs(['--min-kill-percent=80', '--verbose'])).toEqual(['--verbose']);
+        });
+        it('drops --config=path', () => {
+            expect(stripMutineerArgs(['--config=vitest.config.ts', '--verbose'])).toEqual(['--verbose']);
+        });
+        it('drops -c=path', () => {
+            expect(stripMutineerArgs(['-c=vitest.config.ts'])).toEqual([]);
+        });
+    });
+    describe('pass-through', () => {
+        it('keeps unrecognised args unchanged', () => {
+            expect(stripMutineerArgs(['--reporter=verbose', '--bail=1'])).toEqual([
+                '--reporter=verbose',
+                '--bail=1',
+            ]);
+        });
+        it('returns empty array for empty input', () => {
+            expect(stripMutineerArgs([])).toEqual([]);
+        });
+    });
+    describe('extraConsumeNext option', () => {
+        it('drops extra consume-next flag and its value', () => {
+            expect(stripMutineerArgs(['--runner', 'jest', '--verbose'], {
+                extraConsumeNext: ['--runner'],
+            })).toEqual(['--verbose']);
+        });
+        it('drops extra consume-next at end of array without panicking', () => {
+            expect(stripMutineerArgs(['--runner'], { extraConsumeNext: ['--runner'] })).toEqual([]);
+        });
+    });
+    describe('extraPrefixes option', () => {
+        it('drops args matching an extra prefix', () => {
+            expect(stripMutineerArgs(['--shard=1/4', '--verbose'], {
+                extraPrefixes: ['--shard='],
+            })).toEqual(['--verbose']);
+        });
+        it('drops consume-next and prefix for same runner-specific flag', () => {
+            expect(stripMutineerArgs(['--shard', '1/4', '--shard=1/4', '--verbose'], {
+                extraConsumeNext: ['--shard'],
+                extraPrefixes: ['--shard='],
+            })).toEqual(['--verbose']);
+        });
+    });
+});

package/dist/runner/shared/__tests__/worker-script.spec.d.ts

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

package/dist/runner/shared/__tests__/worker-script.spec.js

@@ -0,0 +1,32 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import path from 'node:path';
+vi.mock('node:fs');
+import fs from 'node:fs';
+import { resolveWorkerScript } from '../worker-script.js';
+const existsSync = vi.mocked(fs.existsSync);
+beforeEach(() => {
+    existsSync.mockReset();
+});
+describe('resolveWorkerScript', () => {
+    const dir = '/some/dir';
+    it('returns .js path when .js exists', () => {
+        existsSync.mockImplementation((p) => p === path.join(dir, 'worker.js'));
+        expect(resolveWorkerScript(dir, 'worker')).toBe(path.join(dir, 'worker.js'));
+    });
+    it('returns .mjs path when .js absent but .mjs exists', () => {
+        existsSync.mockImplementation((p) => p === path.join(dir, 'worker.mjs'));
+        expect(resolveWorkerScript(dir, 'worker')).toBe(path.join(dir, 'worker.mjs'));
+    });
+    it('falls back to .ts path when neither .js nor .mjs exist', () => {
+        existsSync.mockReturnValue(false);
+        expect(resolveWorkerScript(dir, 'worker')).toBe(path.join(dir, 'worker.ts'));
+    });
+    it('checks .js before .mjs', () => {
+        existsSync.mockReturnValue(true);
+        expect(resolveWorkerScript(dir, 'worker')).toBe(path.join(dir, 'worker.js'));
+    });
+    it('uses the provided basename', () => {
+        existsSync.mockReturnValue(false);
+        expect(resolveWorkerScript(dir, 'redirect-loader')).toBe(path.join(dir, 'redirect-loader.ts'));
+    });
+});

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

@@ -7,3 +7,7 @@
 export { getMutantFilePath, getSchemaFilePath, getActiveIdFilePath, } from './mutant-paths.js';
 export { setRedirect, getRedirect, clearRedirect, initialiseRedirectState, } from './redirect-state.js';
 export type { RedirectConfig } from './redirect-state.js';
+export { stripMutineerArgs } from './strip-mutineer-args.js';
+export type { StripMutineerArgsOptions } from './strip-mutineer-args.js';
+export { resolveWorkerScript } from './worker-script.js';
+export type { PendingTask } from './pending-task.js';

package/dist/runner/shared/index.js

@@ -6,3 +6,5 @@
  */
 export { getMutantFilePath, getSchemaFilePath, getActiveIdFilePath, } from './mutant-paths.js';
 export { setRedirect, getRedirect, clearRedirect, initialiseRedirectState, } from './redirect-state.js';
+export { stripMutineerArgs } from './strip-mutineer-args.js';
+export { resolveWorkerScript } from './worker-script.js';

package/dist/runner/shared/pending-task.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Represents a pending async task in a worker pool.
+ * Shared by Vitest and Jest pool implementations.
+ */
+export interface PendingTask<TResult> {
+    resolve: (result: TResult) => void;
+    reject: (error: Error) => void;
+    timeoutHandle: NodeJS.Timeout | null;
+}

package/dist/runner/shared/pending-task.js

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

package/dist/runner/shared/strip-mutineer-args.d.ts

@@ -0,0 +1,11 @@
+export interface StripMutineerArgsOptions {
+    /** Runner-specific args that consume the next token and should be dropped. */
+    extraConsumeNext?: Iterable<string>;
+    /** Runner-specific prefixes whose matching args should be dropped. */
+    extraPrefixes?: string[];
+}
+/**
+ * Strip mutineer-specific CLI args that shouldn't be passed to the underlying
+ * test runner. Callers may supply runner-specific extras via options.
+ */
+export declare function stripMutineerArgs(args: string[], options?: StripMutineerArgsOptions): string[];