@mutineerjs/mutineer 0.1.0

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

@@ -0,0 +1,52 @@
+import { EventEmitter } from 'node:events';
+import type { MutantPayload, MutantRunResult, MutantRunSummary } from '../../types/mutant.js';
+declare class JestWorker extends EventEmitter {
+    private readonly cwd;
+    private readonly jestConfig?;
+    private readonly debug;
+    readonly id: string;
+    private process;
+    private pendingTask;
+    private ready;
+    private shuttingDown;
+    constructor(id: string, cwd: string, jestConfig?: string | undefined, debug?: boolean);
+    start(): Promise<void>;
+    private handleMessage;
+    private handleExit;
+    isReady(): boolean;
+    isBusy(): boolean;
+    run(mutant: MutantPayload, tests: string[], timeoutMs?: number): Promise<MutantRunSummary>;
+    shutdown(): Promise<void>;
+    kill(): void;
+    private log;
+}
+export interface JestPoolOptions {
+    cwd: string;
+    concurrency: number;
+    jestConfig?: string;
+    timeoutMs?: number;
+    debug?: boolean;
+    createWorker?: (id: string, opts: {
+        cwd: string;
+        jestConfig?: string;
+        debug: boolean;
+    }) => JestWorker;
+}
+export declare class JestPool {
+    private workers;
+    private availableWorkers;
+    private waitingTasks;
+    private readonly options;
+    private initialized;
+    private shuttingDown;
+    constructor(options: JestPoolOptions);
+    init(): Promise<void>;
+    private handleWorkerExit;
+    private acquireWorker;
+    private releaseWorker;
+    run(mutant: MutantPayload, tests: string[]): Promise<MutantRunSummary>;
+    shutdown(): Promise<void>;
+    private log;
+}
+export declare function runWithJestPool(pool: JestPool, mutant: MutantPayload, tests: readonly string[]): Promise<MutantRunResult>;
+export type { MutantPayload, MutantRunResult, MutantRunSummary } from '../../types/mutant.js';

package/dist/runner/pool/jest-pool.js

@@ -0,0 +1,309 @@
+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';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+class JestWorker extends EventEmitter {
+    constructor(id, cwd, jestConfig, debug = false) {
+        super();
+        this.cwd = cwd;
+        this.jestConfig = jestConfig;
+        this.debug = debug;
+        this.process = null;
+        this.pendingTask = null;
+        this.ready = false;
+        this.shuttingDown = false;
+        this.id = id;
+    }
+    async start() {
+        const workerJs = path.join(__dirname, 'jest-worker.js');
+        const workerMts = path.join(__dirname, 'jest-worker.mjs');
+        const workerTs = path.join(__dirname, 'jest-worker.mts');
+        const workerScript = fs.existsSync(workerJs)
+            ? workerJs
+            : fs.existsSync(workerMts)
+                ? workerMts
+                : workerTs;
+        const env = {
+            ...process.env,
+            MUTINEER_WORKER_ID: this.id,
+            MUTINEER_CWD: this.cwd,
+            ...(this.jestConfig ? { MUTINEER_JEST_CONFIG: this.jestConfig } : {}),
+            ...(this.debug ? { MUTINEER_DEBUG: '1' } : {}),
+        };
+        this.log('Starting Jest worker process');
+        this.process = fork(workerScript, [], {
+            cwd: this.cwd,
+            env,
+            stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+            execArgv: ['--experimental-strip-types', '--experimental-transform-types', '--no-warnings'],
+        });
+        this.process.stderr?.on('data', (data) => {
+            if (this.debug) {
+                process.stderr.write(`[jest-worker-${this.id}] ${data}`);
+            }
+        });
+        this.process.on('message', (msg) => this.handleMessage(msg));
+        this.process.on('error', (err) => {
+            this.log(`Process error: ${err.message}`);
+            this.handleExit(1);
+        });
+        this.process.on('exit', (code) => {
+            this.log(`Process exited with code ${code}`);
+            this.handleExit(code ?? 1);
+        });
+        await new Promise((resolve, reject) => {
+            const timeoutMs = 60_000;
+            const timeout = setTimeout(() => {
+                reject(new Error(`Worker ${this.id} did not become ready in time (${timeoutMs}ms)`));
+            }, timeoutMs);
+            this.once('ready', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+            this.once('error', (err) => {
+                clearTimeout(timeout);
+                reject(err);
+            });
+        });
+    }
+    handleMessage(raw) {
+        const msg = raw;
+        if (msg.type === 'ready') {
+            this.ready = true;
+            this.emit('ready');
+            return;
+        }
+        if (msg.type === 'result') {
+            if (this.pendingTask) {
+                const { resolve, timeoutHandle } = this.pendingTask;
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                this.pendingTask = null;
+                resolve({
+                    killed: msg.killed ?? true,
+                    durationMs: msg.durationMs ?? 0,
+                    error: msg.error,
+                });
+            }
+            return;
+        }
+        if (msg.type === 'shutdown') {
+            this.emit('shutdown');
+            return;
+        }
+    }
+    handleExit(code) {
+        this.ready = false;
+        if (this.pendingTask && !this.shuttingDown) {
+            const { reject, timeoutHandle } = this.pendingTask;
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            this.pendingTask = null;
+            reject(new Error(`Worker exited unexpectedly with code ${code}`));
+        }
+        this.emit('exit', code);
+    }
+    isReady() {
+        return this.ready && this.process !== null && !this.shuttingDown;
+    }
+    isBusy() {
+        return this.pendingTask !== null;
+    }
+    async run(mutant, tests, timeoutMs = 10_000) {
+        if (!this.isReady()) {
+            throw new Error(`Worker ${this.id} is not ready`);
+        }
+        if (this.isBusy()) {
+            throw new Error(`Worker ${this.id} is busy`);
+        }
+        return new Promise((resolve, reject) => {
+            const timeoutHandle = setTimeout(() => {
+                if (this.pendingTask) {
+                    this.pendingTask = null;
+                    this.kill();
+                    resolve({ killed: true, durationMs: timeoutMs, error: 'timeout' });
+                }
+            }, timeoutMs);
+            this.pendingTask = { resolve, reject, timeoutHandle };
+            this.process.send?.({ type: 'run', mutant, tests });
+        });
+    }
+    async shutdown() {
+        if (!this.process || this.shuttingDown)
+            return;
+        this.shuttingDown = true;
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                this.kill();
+                resolve();
+            }, 5000);
+            this.once('shutdown', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+            this.process.send?.({ type: 'shutdown' });
+        });
+    }
+    kill() {
+        if (this.process) {
+            try {
+                this.process.kill('SIGKILL');
+            }
+            catch {
+                // ignore
+            }
+            this.process = null;
+        }
+        this.ready = false;
+    }
+    log(msg) {
+        if (this.debug) {
+            console.error(`[JestWorker-${this.id}] ${msg}`);
+        }
+    }
+}
+export class JestPool {
+    constructor(options) {
+        this.workers = [];
+        this.availableWorkers = [];
+        this.waitingTasks = [];
+        this.initialized = false;
+        this.shuttingDown = false;
+        this.options = {
+            cwd: options.cwd,
+            concurrency: options.concurrency,
+            jestConfig: options.jestConfig,
+            timeoutMs: options.timeoutMs ?? 10_000,
+            debug: options.debug ?? false,
+            createWorker: options.createWorker,
+        };
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        const startPromises = [];
+        for (let i = 0; i < this.options.concurrency; i++) {
+            const worker = this.options.createWorker?.(`w${i}`, {
+                cwd: this.options.cwd,
+                jestConfig: this.options.jestConfig,
+                debug: this.options.debug,
+            }) ??
+                new JestWorker(`w${i}`, this.options.cwd, this.options.jestConfig, this.options.debug);
+            worker.on('exit', () => {
+                if (!this.shuttingDown) {
+                    this.handleWorkerExit(worker);
+                }
+            });
+            this.workers.push(worker);
+            startPromises.push(worker.start().then(() => {
+                this.availableWorkers.push(worker);
+            }));
+        }
+        await Promise.all(startPromises);
+        this.initialized = true;
+    }
+    handleWorkerExit(worker) {
+        const availIdx = this.availableWorkers.indexOf(worker);
+        if (availIdx >= 0) {
+            this.availableWorkers.splice(availIdx, 1);
+        }
+        const newWorker = this.options.createWorker?.(worker.id, {
+            cwd: this.options.cwd,
+            jestConfig: this.options.jestConfig,
+            debug: this.options.debug,
+        }) ??
+            new JestWorker(worker.id, this.options.cwd, this.options.jestConfig, this.options.debug);
+        const idx = this.workers.indexOf(worker);
+        if (idx >= 0) {
+            this.workers[idx] = newWorker;
+        }
+        newWorker.on('exit', () => {
+            if (!this.shuttingDown) {
+                this.handleWorkerExit(newWorker);
+            }
+        });
+        newWorker.start()
+            .then(() => {
+            this.releaseWorker(newWorker);
+        })
+            .catch((err) => {
+            this.log(`Failed to restart worker ${newWorker.id}: ${err}`);
+        });
+    }
+    async acquireWorker() {
+        const worker = this.availableWorkers.shift();
+        if (worker) {
+            return worker;
+        }
+        return new Promise((resolve) => {
+            this.waitingTasks.push(resolve);
+        });
+    }
+    releaseWorker(worker) {
+        const waiting = this.waitingTasks.shift();
+        if (waiting) {
+            waiting(worker);
+            return;
+        }
+        if (worker.isReady()) {
+            this.availableWorkers.push(worker);
+        }
+    }
+    async run(mutant, tests) {
+        if (!this.initialized) {
+            throw new Error('Pool not initialized. Call init() first.');
+        }
+        if (this.shuttingDown) {
+            throw new Error('Pool is shutting down');
+        }
+        const worker = await this.acquireWorker();
+        try {
+            const result = await worker.run(mutant, tests, this.options.timeoutMs);
+            if (this.options.debug) {
+                console.error(`[JestPool] worker ${worker.id} returned killed=${result.killed} error=${result.error ?? 'none'} duration=${result.durationMs}`);
+            }
+            return result;
+        }
+        finally {
+            this.releaseWorker(worker);
+        }
+    }
+    async shutdown() {
+        if (this.shuttingDown)
+            return;
+        this.shuttingDown = true;
+        await Promise.all(this.workers.map((w) => w.shutdown()));
+        this.workers = [];
+        this.availableWorkers = [];
+        this.initialized = false;
+    }
+    log(msg) {
+        if (this.options.debug) {
+            console.error(`[JestPool] ${msg}`);
+        }
+    }
+}
+export async function runWithJestPool(pool, mutant, tests) {
+    try {
+        const result = await pool.run(mutant, [...tests]);
+        if (result.error === 'timeout') {
+            return { status: 'timeout', durationMs: result.durationMs, error: result.error };
+        }
+        if (result.error && !result.killed) {
+            return { status: 'error', durationMs: result.durationMs, error: result.error };
+        }
+        return {
+            status: result.killed ? 'killed' : 'escaped',
+            durationMs: result.durationMs,
+        };
+    }
+    catch (err) {
+        return {
+            status: 'error',
+            durationMs: 0,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}

package/dist/runner/pool/jest-worker.d.mts

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

package/dist/runner/pool/jest-worker.mjs

@@ -0,0 +1,60 @@
+import { createJestWorkerRuntime } from '../adapters/jest-worker-runtime.js';
+globalThis.__mutineer_redirect__ = { from: null, to: null };
+function log(msg) {
+    if (process.env.MUTINEER_DEBUG !== '1')
+        return;
+    console.error(`[jest-worker] ${msg}`);
+}
+async function main() {
+    const workerId = process.env.MUTINEER_WORKER_ID ?? 'unknown';
+    const cwd = process.env.MUTINEER_CWD ?? process.cwd();
+    const jestConfigPath = process.env.MUTINEER_JEST_CONFIG;
+    const debug = process.env.MUTINEER_DEBUG === '1';
+    log(`Starting worker ${workerId} in ${cwd}`);
+    const runtime = createJestWorkerRuntime({
+        workerId,
+        cwd,
+        jestConfigPath,
+        debug,
+    });
+    try {
+        await runtime.init();
+    }
+    catch (err) {
+        console.error('[jest-worker] Failed to initialize:', err);
+        process.exit(1);
+    }
+    process.send?.({ type: 'ready', workerId });
+    process.on('message', async (raw) => {
+        if (raw.type === 'shutdown') {
+            log('Shutting down');
+            await runtime.shutdown();
+            process.send?.({ type: 'shutdown', ok: true });
+            process.exit(0);
+        }
+        if (raw.type === 'run') {
+            try {
+                const { mutant, tests } = raw;
+                const result = await runtime.run(mutant, tests);
+                process.send?.({
+                    type: 'result',
+                    killed: result.killed,
+                    durationMs: result.durationMs,
+                    error: result.error,
+                });
+            }
+            catch (err) {
+                process.send?.({
+                    type: 'result',
+                    killed: true,
+                    durationMs: 0,
+                    error: String(err),
+                });
+            }
+        }
+    });
+}
+main().catch((err) => {
+    console.error('[jest-worker] Fatal error:', err);
+    process.exit(1);
+});

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

@@ -0,0 +1,18 @@
+/**
+ * Vite plugin for persistent Vitest workers.
+ *
+ * Unlike the standard viteMutineerPlugin which reads env vars once at init,
+ * this plugin reads from a global redirect map that can be updated dynamically
+ * between test runs.
+ *
+ * The worker process sets globalThis.__mutineer_redirect__ before each test run,
+ * and this plugin intercepts module loading to return the mutated code.
+ */
+import type { PluginOption } from 'vite';
+declare global {
+    var __mutineer_redirect__: {
+        from: string | null;
+        to: string | null;
+    } | undefined;
+}
+export declare function poolMutineerPlugin(): PluginOption;

package/dist/runner/pool/plugin.js

@@ -0,0 +1,60 @@
+/**
+ * Vite plugin for persistent Vitest workers.
+ *
+ * Unlike the standard viteMutineerPlugin which reads env vars once at init,
+ * this plugin reads from a global redirect map that can be updated dynamically
+ * between test runs.
+ *
+ * The worker process sets globalThis.__mutineer_redirect__ before each test run,
+ * and this plugin intercepts module loading to return the mutated code.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/**
+ * Get the current redirect config from globalThis.
+ * Returns null if no redirect is active.
+ */
+function getRedirect() {
+    const redirect = globalThis.__mutineer_redirect__;
+    if (!redirect?.from || !redirect?.to) {
+        return null;
+    }
+    return {
+        from: path.resolve(redirect.from),
+        to: redirect.to,
+    };
+}
+export function poolMutineerPlugin() {
+    return {
+        name: 'mutineer:swap',
+        enforce: 'pre',
+        load(id) {
+            const redirect = getRedirect();
+            if (!redirect) {
+                return null;
+            }
+            // Normalize the module ID, handling query strings
+            const cleanId = id.split('?')[0];
+            let normalizedId;
+            try {
+                normalizedId = path.resolve(cleanId);
+            }
+            catch {
+                return null;
+            }
+            // Check if this is the file we're redirecting
+            if (normalizedId === redirect.from) {
+                // Read the mutated code from the temp file
+                try {
+                    const mutatedCode = fs.readFileSync(redirect.to, 'utf8');
+                    return mutatedCode;
+                }
+                catch (err) {
+                    console.error(`[mutineer:swap] Failed to read mutant file: ${redirect.to}`, err);
+                    return null;
+                }
+            }
+            return null;
+        }
+    };
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Vite plugin for persistent Vitest workers.
+ *
+ * Unlike the standard viteMutineerPlugin which reads env vars once at init,
+ * this plugin reads from a global redirect map that can be updated dynamically
+ * between test runs.
+ *
+ * The worker process sets globalThis.__mutineer_redirect__ before each test run,
+ * and this plugin intercepts module loading to return the mutated code.
+ */
+import type { PluginOption } from 'vite';
+declare global {
+    var __mutineer_redirect__: {
+        from: string | null;
+        to: string | null;
+    } | undefined;
+}
+export declare function poolMutineerPlugin(): PluginOption;

package/dist/runner/pool/pool-plugin.js

@@ -0,0 +1,60 @@
+/**
+ * Vite plugin for persistent Vitest workers.
+ *
+ * Unlike the standard viteMutineerPlugin which reads env vars once at init,
+ * this plugin reads from a global redirect map that can be updated dynamically
+ * between test runs.
+ *
+ * The worker process sets globalThis.__mutineer_redirect__ before each test run,
+ * and this plugin intercepts module loading to return the mutated code.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/**
+ * Get the current redirect config from globalThis.
+ * Returns null if no redirect is active.
+ */
+function getRedirect() {
+    const redirect = globalThis.__mutineer_redirect__;
+    if (!redirect?.from || !redirect?.to) {
+        return null;
+    }
+    return {
+        from: path.resolve(redirect.from),
+        to: redirect.to,
+    };
+}
+export function poolMutineerPlugin() {
+    return {
+        name: 'mutineer:swap',
+        enforce: 'pre',
+        load(id) {
+            const redirect = getRedirect();
+            if (!redirect) {
+                return null;
+            }
+            // Normalize the module ID, handling query strings
+            const cleanId = id.split('?')[0];
+            let normalizedId;
+            try {
+                normalizedId = path.resolve(cleanId);
+            }
+            catch {
+                return null;
+            }
+            // Check if this is the file we're redirecting
+            if (normalizedId === redirect.from) {
+                // Read the mutated code from the temp file
+                try {
+                    const mutatedCode = fs.readFileSync(redirect.to, 'utf8');
+                    return mutatedCode;
+                }
+                catch (err) {
+                    console.error(`[mutineer:swap] Failed to read mutant file: ${redirect.to}`, err);
+                    return null;
+                }
+            }
+            return null;
+        }
+    };
+}

package/dist/runner/pool/pool-redirect-loader.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Dynamic ESM loader for persistent Vitest workers.
+ *
+ * Reads redirect targets from globalThis.__mutineer_redirect__ on each resolution
+ * so workers can swap files without restarting.
+ */
+declare global {
+    var __mutineer_redirect__: {
+        from: string | null;
+        to: string | null;
+    } | undefined;
+}
+export declare function initialize(data: {
+    debug?: boolean;
+} | undefined): void;
+export declare function resolve(specifier: string, context: {
+    parentURL?: string;
+}, nextResolve: (specifier: string, context: any) => Promise<any>): Promise<any>;
+export declare function load(url: string, context: unknown, nextLoad: (u: string, c: unknown) => Promise<unknown>): Promise<unknown>;