@mutineerjs/mutineer 0.2.4 → 0.4.0

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

@@ -1,309 +0,0 @@
-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

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

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

@@ -1,60 +0,0 @@
-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

@@ -1,18 +0,0 @@
-/**
- * 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

@@ -1,60 +0,0 @@
-/**
- * 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

@@ -1,18 +0,0 @@
-/**
- * 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

@@ -1,60 +0,0 @@
-/**
- * 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

@@ -1,19 +0,0 @@
-/**
- * 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>;

package/dist/runner/pool/pool-redirect-loader.js

@@ -1,116 +0,0 @@
-/**
- * Dynamic ESM loader for persistent Vitest workers.
- *
- * Reads redirect targets from globalThis.__mutineer_redirect__ on each resolution
- * so workers can swap files without restarting.
- */
-import { register, builtinModules } from 'node:module';
-import { pathToFileURL, fileURLToPath } from 'node:url';
-import path from 'node:path';
-import fs from 'node:fs';
-// Register this file as the loader hooks module
-register(import.meta.url, {
-    parentURL: import.meta.url,
-    data: { debug: process.env.MUTINEER_DEBUG === '1' }
-});
-let DEBUG = process.env.MUTINEER_DEBUG === '1';
-export function initialize(data) {
-    if (data?.debug !== undefined) {
-        DEBUG = data.debug;
-    }
-}
-/**
- * Try to resolve a .js import to a .ts or .tsx file (TypeScript ESM convention)
- */
-function tryResolveTsExtension(specifier, parentURL) {
-    if (!specifier.endsWith('.js') || !specifier.startsWith('.')) {
-        return null;
-    }
-    let parentPath;
-    try {
-        parentPath = fileURLToPath(parentURL ?? '');
-    }
-    catch {
-        return null;
-    }
-    const parentDir = path.dirname(parentPath);
-    // If the parent is in a __mutineer__ directory, also try the parent's parent
-    const dirsToTry = [parentDir];
-    if (path.basename(parentDir) === '__mutineer__') {
-        dirsToTry.push(path.dirname(parentDir));
-    }
-    const tsSpecifier = specifier.slice(0, -3) + '.ts';
-    const tsxSpecifier = specifier.slice(0, -3) + '.tsx';
-    for (const dir of dirsToTry) {
-        const tsPath = path.resolve(dir, tsSpecifier);
-        if (fs.existsSync(tsPath)) {
-            return pathToFileURL(tsPath).href;
-        }
-        const tsxPath = path.resolve(dir, tsxSpecifier);
-        if (fs.existsSync(tsxPath)) {
-            return pathToFileURL(tsxPath).href;
-        }
-    }
-    return null;
-}
-function getRedirect() {
-    const redirect = globalThis.__mutineer_redirect__;
-    if (!redirect?.from || !redirect?.to) {
-        return null;
-    }
-    return {
-        from: path.resolve(redirect.from),
-        fromUrl: pathToFileURL(path.resolve(redirect.from)).href,
-        to: redirect.to,
-    };
-}
-export async function resolve(specifier, context, nextResolve) {
-    const redirect = getRedirect();
-    const isBuiltin = specifier.startsWith('node:') || builtinModules.includes(specifier);
-    const isNodeModulesSpec = specifier.includes('node_modules');
-    const shouldLog = DEBUG && !isBuiltin && !isNodeModulesSpec;
-    if (shouldLog) {
-        console.error(`[pool-loader] resolve: ${specifier}`);
-        if (redirect) {
-            console.error(`[pool-loader] active redirect: ${redirect.from} -> ${redirect.to}`);
-        }
-    }
-    // Try to resolve .js -> .ts for TypeScript ESM imports
-    const tsResolved = tryResolveTsExtension(specifier, context.parentURL);
-    if (tsResolved) {
-        if (shouldLog)
-            console.error(`[pool-loader] .js -> .ts: ${specifier} -> ${tsResolved}`);
-        // Check if this is our redirect target
-        if (redirect && tsResolved === redirect.fromUrl) {
-            if (DEBUG)
-                console.error(`[pool-loader] REDIRECTING ${tsResolved} -> ${pathToFileURL(redirect.to).href}`);
-            return {
-                url: pathToFileURL(redirect.to).href,
-                shortCircuit: true
-            };
-        }
-        return {
-            url: tsResolved,
-            shortCircuit: true
-        };
-    }
-    const resolved = await nextResolve(specifier, context);
-    const resolvedInNodeModules = resolved?.url?.includes('/node_modules/');
-    const resolvedBuiltin = resolved?.url?.startsWith('node:');
-    if (shouldLog && !resolvedInNodeModules && !resolvedBuiltin)
-        console.error(`[pool-loader] resolved ${specifier} to ${resolved.url}`);
-    // Check if this resolves to our redirect target
-    if (redirect && resolved.url === redirect.fromUrl) {
-        if (DEBUG)
-            console.error(`[pool-loader] REDIRECTING ${resolved.url} -> ${pathToFileURL(redirect.to).href}`);
-        return {
-            ...resolved,
-            url: pathToFileURL(redirect.to).href,
-            shortCircuit: true
-        };
-    }
-    return resolved;
-}
-export async function load(url, context, nextLoad) {
-    return nextLoad(url, context);
-}