@mutineerjs/mutineer 0.2.3 → 0.3.2

package/dist/runner/shared/__tests__/redirect-state.spec.js

@@ -0,0 +1,56 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { initialiseRedirectState, setRedirect, getRedirect, clearRedirect, } from '../redirect-state.js';
+describe('redirect-state', () => {
+    beforeEach(() => {
+        initialiseRedirectState();
+    });
+    describe('initialiseRedirectState', () => {
+        it('sets global redirect to null/null', () => {
+            expect(globalThis.__mutineer_redirect__).toEqual({
+                from: null,
+                to: null,
+            });
+        });
+    });
+    describe('setRedirect', () => {
+        it('sets the redirect config', () => {
+            setRedirect({ from: '/src/foo.ts', to: '/tmp/mutant.ts' });
+            expect(globalThis.__mutineer_redirect__).toEqual({
+                from: '/src/foo.ts',
+                to: '/tmp/mutant.ts',
+            });
+        });
+    });
+    describe('getRedirect', () => {
+        it('returns null when no redirect is set', () => {
+            expect(getRedirect()).toBeNull();
+        });
+        it('returns the redirect config when set', () => {
+            setRedirect({ from: '/src/foo.ts', to: '/tmp/mutant.ts' });
+            const redirect = getRedirect();
+            expect(redirect).toEqual({
+                from: '/src/foo.ts',
+                to: '/tmp/mutant.ts',
+            });
+        });
+        it('returns null when from is null', () => {
+            globalThis.__mutineer_redirect__ = { from: null, to: '/tmp/mutant.ts' };
+            expect(getRedirect()).toBeNull();
+        });
+        it('returns null when to is null', () => {
+            globalThis.__mutineer_redirect__ = { from: '/src/foo.ts', to: null };
+            expect(getRedirect()).toBeNull();
+        });
+    });
+    describe('clearRedirect', () => {
+        it('resets the redirect to null/null', () => {
+            setRedirect({ from: '/src/foo.ts', to: '/tmp/mutant.ts' });
+            clearRedirect();
+            expect(getRedirect()).toBeNull();
+            expect(globalThis.__mutineer_redirect__).toEqual({
+                from: null,
+                to: null,
+            });
+        });
+    });
+});

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

@@ -5,5 +5,5 @@
  * including mutant file path generation and redirect state management.
  */
 export { getMutantFilePath } from './mutant-paths.js';
-export { setRedirect, getRedirect, clearRedirect, initializeRedirectState, } from './redirect-state.js';
+export { setRedirect, getRedirect, clearRedirect, initialiseRedirectState, } from './redirect-state.js';
 export type { RedirectConfig } from './redirect-state.js';

package/dist/runner/shared/index.js

@@ -5,4 +5,4 @@
  * including mutant file path generation and redirect state management.
  */
 export { getMutantFilePath } from './mutant-paths.js';
-export { setRedirect, getRedirect, clearRedirect, initializeRedirectState, } from './redirect-state.js';
+export { setRedirect, getRedirect, clearRedirect, initialiseRedirectState, } from './redirect-state.js';

package/dist/runner/shared/redirect-state.d.ts

@@ -23,10 +23,10 @@ export interface RedirectConfig {
     readonly to: string;
 }
 /**
- * Initialize the global redirect state.
+ * Initialise the global redirect state.
  * Must be called once at module load time.
  */
-export declare function initializeRedirectState(): void;
+export declare function initialiseRedirectState(): void;
 /**
  * Set the active redirect configuration.
  *

package/dist/runner/shared/redirect-state.js

@@ -8,10 +8,10 @@
  * test execution.
  */
 /**
- * Initialize the global redirect state.
+ * Initialise the global redirect state.
  * Must be called once at module load time.
  */
-export function initializeRedirectState() {
+export function initialiseRedirectState() {
     globalThis.__mutineer_redirect__ = { from: null, to: null };
 }
 /**
@@ -46,5 +46,5 @@ export function getRedirect() {
 export function clearRedirect() {
     globalThis.__mutineer_redirect__ = { from: null, to: null };
 }
-// Initialize on module load
-initializeRedirectState();
+// Initialise on module load
+initialiseRedirectState();

package/dist/runner/tasks.d.ts

@@ -0,0 +1,12 @@
+import type { Variant } from '../types/mutant.js';
+import type { PerTestCoverageMap } from '../utils/coverage.js';
+export interface MutantTask {
+    v: Variant;
+    tests: string[];
+    key: string;
+}
+/**
+ * Prepare mutant tasks from variants by pruning tests via per-test coverage,
+ * sorting tests deterministically, and computing cache keys.
+ */
+export declare function prepareTasks(variants: readonly Variant[], perTestCoverage: PerTestCoverageMap | null): MutantTask[];

package/dist/runner/tasks.js

@@ -0,0 +1,25 @@
+import { filterTestsByCoverage } from './variants.js';
+import { hash, keyForTests } from './cache.js';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('tasks');
+/**
+ * Prepare mutant tasks from variants by pruning tests via per-test coverage,
+ * sorting tests deterministically, and computing cache keys.
+ */
+export function prepareTasks(variants, perTestCoverage) {
+    return variants.map((v) => {
+        let tests = Array.from(v.tests);
+        if (perTestCoverage && tests.length) {
+            const before = tests.length;
+            tests = filterTestsByCoverage(perTestCoverage, tests, v.file, v.line);
+            if (tests.length !== before) {
+                log.debug(`Pruned tests ${before} -> ${tests.length} for mutant ${v.name} via per-test coverage`);
+            }
+        }
+        tests.sort();
+        const testSig = hash(keyForTests(tests));
+        const codeSig = hash(v.code);
+        const key = `${testSig}:${codeSig}`;
+        return { v, tests, key };
+    });
+}

package/dist/runner/types.d.ts

@@ -41,7 +41,7 @@ export interface TestRunnerAdapter {
      */
     readonly name: string;
     /**
-     * Initialize the adapter (start worker pools, etc.).
+     * Initialise the adapter (start worker pools, etc.).
      * Must be called before running tests.
      */
     init(concurrencyOverride?: number): Promise<void>;

package/dist/runner/variants.d.ts

@@ -4,8 +4,10 @@
  * Functions for enumerating mutation variants from source files.
  * Handles both regular modules and Vue SFC files.
  */
-import type { MutateTarget } from '../types/config.js';
-import type { MutantPayload } from '../types/mutant.js';
+import type { MutateTarget, MutineerConfig } from '../types/config.js';
+import type { MutantPayload, Variant } from '../types/mutant.js';
+import { type CoverageData } from '../utils/coverage.js';
+import type { TestMap } from './discover.js';
 /**
  * Get file path from target (handles both string and object forms).
  */
@@ -18,4 +20,17 @@ export declare function enumerateVariantsForTarget(root: string, t: MutateTarget
  * Filter tests to only those that cover a specific line in a file.
  */
 export declare function filterTestsByCoverage(perTest: Map<string, Map<string, Set<number>>>, tests: readonly string[], filePath: string, line: number): string[];
+export interface EnumerateAllParams {
+    cwd: string;
+    targets: readonly MutateTarget[];
+    testMap: TestMap;
+    changedFiles: Set<string> | null;
+    coverageData: CoverageData | null;
+    config: MutineerConfig;
+}
+/**
+ * Enumerate variants for all targets, filtering by changed files and coverage.
+ * Links each variant to its relevant test files via the testMap.
+ */
+export declare function enumerateAllVariants(params: EnumerateAllParams): Promise<Variant[]>;
 export type { Variant } from '../types/mutant.js';

package/dist/runner/variants.js

@@ -8,6 +8,8 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { mutateVueSfcScriptSetup } from '../core/sfc.js';
 import { mutateModuleSource } from '../core/module.js';
+import { normalizePath } from '../utils/normalizePath.js';
+import { isLineCovered } from '../utils/coverage.js';
 import { createLogger } from '../utils/logger.js';
 const log = createLogger('variants');
 /**
@@ -64,3 +66,34 @@ export function filterTestsByCoverage(perTest, tests, filePath, line) {
         return lines.has(line);
     });
 }
+/**
+ * Enumerate variants for all targets, filtering by changed files and coverage.
+ * Links each variant to its relevant test files via the testMap.
+ */
+export async function enumerateAllVariants(params) {
+    const { cwd, targets, testMap, changedFiles, coverageData, config } = params;
+    const enumerated = await Promise.all(targets.map(async (target) => {
+        const file = getTargetFile(target);
+        const absFile = normalizePath(path.isAbsolute(file) ? file : path.join(cwd, file));
+        if (changedFiles && !changedFiles.has(absFile))
+            return [];
+        log.debug('Target file: ' + absFile);
+        const files = await enumerateVariantsForTarget(cwd, target, config.include, config.exclude, config.maxMutantsPerFile);
+        const testsAbs = testMap.get(normalizePath(absFile));
+        const tests = testsAbs ? Array.from(testsAbs) : [];
+        log.debug(`  found ${files.length} variants, linked to ${tests.length} tests`);
+        // Filter by coverage if enabled
+        let filtered = files;
+        if (coverageData) {
+            filtered = files.filter((v) => isLineCovered(coverageData, absFile, v.line));
+            if (filtered.length !== files.length) {
+                log.debug(`  filtered ${files.length} -> ${filtered.length} variants by coverage`);
+            }
+        }
+        return filtered.map((v) => ({ ...v, tests }));
+    }));
+    const variants = [];
+    for (const list of enumerated)
+        variants.push(...list);
+    return variants;
+}

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

@@ -41,7 +41,7 @@ describe('Vitest adapter', () => {
     afterEach(() => {
         vi.useRealTimers();
     });
-    it('initializes pool with override concurrency', async () => {
+    it('initialises pool with override concurrency', async () => {
         const adapter = makeAdapter();
         await adapter.init(5);
         expect(poolInstance?.init).toHaveBeenCalledTimes(1);

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

@@ -40,7 +40,7 @@ describe('VitestPool', () => {
             cwd: process.cwd(),
             concurrency: 1,
             timeoutMs: 5000,
-            createWorker: (id, opts) => {
+            createWorker: (id) => {
                 const worker = new EventEmitter();
                 worker.id = id;
                 worker.start = vi.fn().mockResolvedValue(undefined);

package/dist/runner/vitest/__tests__/redirect-loader.spec.js

@@ -3,11 +3,16 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 import { pathToFileURL } from 'node:url';
-import { resolve as poolResolve } from '../redirect-loader.js';
+vi.mock('node:module', async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, register: vi.fn() };
+});
+import { resolve as poolResolve, initialise } from '../redirect-loader.js';
 describe('pool-redirect-loader resolve', () => {
     afterEach(() => {
         ;
         globalThis.__mutineer_redirect__ = undefined;
+        delete process.env.MUTINEER_DEBUG;
         vi.restoreAllMocks();
     });
     it('resolves .js to .ts in the same directory', async () => {
@@ -84,4 +89,85 @@ describe('pool-redirect-loader resolve', () => {
             await fs.rm(tmpDir, { recursive: true, force: true });
         }
     });
+    it('passes through non-.js specifiers to nextResolve', async () => {
+        const nextResolve = vi.fn().mockResolvedValue({
+            url: 'file:///some/module.ts',
+            shortCircuit: false,
+        });
+        const result = await poolResolve('./module', { parentURL: 'file:///src/index.ts' }, nextResolve);
+        expect(nextResolve).toHaveBeenCalled();
+        expect(result.url).toBe('file:///some/module.ts');
+    });
+    it('passes through builtin modules to nextResolve', async () => {
+        const nextResolve = vi.fn().mockResolvedValue({
+            url: 'node:fs',
+            shortCircuit: true,
+        });
+        const result = await poolResolve('node:fs', { parentURL: 'file:///src/index.ts' }, nextResolve);
+        expect(nextResolve).toHaveBeenCalled();
+        expect(result.url).toBe('node:fs');
+    });
+    it('skips .js->ts resolution for non-relative specifiers', async () => {
+        const nextResolve = vi.fn().mockResolvedValue({
+            url: 'file:///node_modules/pkg/index.js',
+            shortCircuit: false,
+        });
+        const result = await poolResolve('some-package/foo.js', { parentURL: 'file:///src/index.ts' }, nextResolve);
+        expect(nextResolve).toHaveBeenCalled();
+        expect(result.url).toBe('file:///node_modules/pkg/index.js');
+    });
+    it('resolves .js to .tsx when .ts does not exist', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-pool-loader-'));
+        const parentFile = path.join(tmpDir, 'src', 'index.ts');
+        const tsxFile = path.join(tmpDir, 'src', 'comp.tsx');
+        await fs.mkdir(path.dirname(parentFile), { recursive: true });
+        await fs.writeFile(parentFile, 'export {}', 'utf8');
+        await fs.writeFile(tsxFile, 'export const Comp = () => null', 'utf8');
+        try {
+            const nextResolve = vi.fn();
+            const result = await poolResolve('./comp.js', { parentURL: pathToFileURL(parentFile).href }, nextResolve);
+            expect(nextResolve).not.toHaveBeenCalled();
+            expect(result.shortCircuit).toBe(true);
+            expect(result.url).toBe(pathToFileURL(tsxFile).href);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('tries parent of __mutineer__ directory for ts resolution', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-pool-loader-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const mutineerDir = path.join(srcDir, '__mutineer__');
+        await fs.mkdir(mutineerDir, { recursive: true });
+        const parentFile = path.join(mutineerDir, 'mutant.ts');
+        const tsFile = path.join(srcDir, 'sibling.ts');
+        await fs.writeFile(parentFile, 'export {}', 'utf8');
+        await fs.writeFile(tsFile, 'export const x = 1', 'utf8');
+        try {
+            const nextResolve = vi.fn();
+            const result = await poolResolve('./sibling.js', { parentURL: pathToFileURL(parentFile).href }, nextResolve);
+            expect(nextResolve).not.toHaveBeenCalled();
+            expect(result.shortCircuit).toBe(true);
+            expect(result.url).toBe(pathToFileURL(tsFile).href);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('initialise sets debug mode', () => {
+        // Should not throw
+        initialise({ debug: true });
+        initialise({ debug: false });
+        initialise(undefined);
+    });
+    it('returns null from tryResolveTsExtension when parentURL is invalid', async () => {
+        const nextResolve = vi.fn().mockResolvedValue({
+            url: 'file:///fallback.js',
+            shortCircuit: false,
+        });
+        // parentURL is not a valid file URL, so tryResolveTsExtension should return null
+        await poolResolve('./foo.js', { parentURL: 'not-a-valid-url' }, nextResolve);
+        // Falls through to nextResolve
+        expect(nextResolve).toHaveBeenCalled();
+    });
 });

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

@@ -55,6 +55,90 @@ describe('VitestWorkerRuntime', () => {
         expect(fs.existsSync(path.join(tmp, 'src', '__mutineer__'))).toBe(false);
         await runtime.shutdown();
     });
+    it('throws when run is called before init', async () => {
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({
+            workerId: 'w-noinit',
+            cwd: tmp,
+        });
+        await expect(runtime.run({
+            id: 'mut#err',
+            name: 'm',
+            file: path.join(tmp, 'src.ts'),
+            code: 'export const x=1',
+            line: 1,
+            col: 1,
+        }, [path.join(tmp, 'test.ts')])).rejects.toThrow('Vitest runtime not initialised');
+    });
+    it('shutdown is a no-op when not initialised', async () => {
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({
+            workerId: 'w-noinit2',
+            cwd: tmp,
+        });
+        // Should not throw
+        await runtime.shutdown();
+        expect(closeFn).not.toHaveBeenCalled();
+    });
+    it('passes vitestConfigPath option to createVitest', async () => {
+        const { createVitest } = await import('vitest/node');
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({
+            workerId: 'w-config',
+            cwd: tmp,
+            vitestConfigPath: '/custom/vitest.config.ts',
+        });
+        await runtime.init();
+        expect(createVitest).toHaveBeenCalledWith('test', expect.objectContaining({ config: '/custom/vitest.config.ts' }), expect.any(Object));
+        await runtime.shutdown();
+    });
+    it('handles non-Error thrown during run', async () => {
+        runSpecsFn.mockRejectedValue('string error');
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({
+            workerId: 'w-strerr',
+            cwd: tmp,
+        });
+        await runtime.init();
+        const result = await runtime.run({
+            id: 'mut#3',
+            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(true);
+        expect(result.error).toBe('string error');
+        await runtime.shutdown();
+    });
+    it('falls back to all testModules when no relevant modules match', async () => {
+        runSpecsFn.mockResolvedValue({
+            testModules: [{ moduleId: 'unknown-module', ok: () => true }],
+        });
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({
+            workerId: 'w-fallback',
+            cwd: tmp,
+        });
+        await runtime.init();
+        const result = await runtime.run({
+            id: 'mut#4',
+            name: 'm',
+            file: path.join(tmp, 'src.ts'),
+            code: 'export const x=1',
+            line: 1,
+            col: 1,
+        }, [path.join(tmp, 'test.ts')]);
+        // Falls back to all testModules; 'unknown-module' reports ok() = true
+        expect(result.killed).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-'));

package/dist/runner/vitest/adapter.js

@@ -154,7 +154,7 @@ export class VitestAdapter {
     }
     async runMutant(mutant, tests) {
         if (!this.pool) {
-            throw new Error('VitestAdapter not initialized. Call init() first.');
+            throw new Error('VitestAdapter not initialised. Call init() first.');
         }
         try {
             const result = await this.pool.run(mutant, [...tests]);

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

@@ -7,5 +7,4 @@
 export { VitestAdapter, createVitestAdapter, isCoverageRequestedInArgs, } from './adapter.js';
 export { VitestPool, runWithPool, type VitestPoolOptions } from './pool.js';
 export { poolMutineerPlugin } from './plugin.js';
-export { resolve as poolRedirectResolve } from './redirect-loader.js';
 export type { MutantPayload, MutantRunResult, MutantRunSummary, } from '../../types/mutant.js';

package/dist/runner/vitest/index.js

@@ -7,4 +7,3 @@
 export { VitestAdapter, createVitestAdapter, isCoverageRequestedInArgs, } from './adapter.js';
 export { VitestPool, runWithPool } from './pool.js';
 export { poolMutineerPlugin } from './plugin.js';
-export { resolve as poolRedirectResolve } from './redirect-loader.js';

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

@@ -47,7 +47,7 @@ export declare class VitestPool {
     private availableWorkers;
     private waitingTasks;
     private readonly options;
-    private initialized;
+    private initialised;
     private shuttingDown;
     constructor(options: VitestPoolOptions);
     init(): Promise<void>;

package/dist/runner/vitest/pool.js

@@ -221,7 +221,7 @@ export class VitestPool {
         this.workers = [];
         this.availableWorkers = [];
         this.waitingTasks = [];
-        this.initialized = false;
+        this.initialised = false;
         this.shuttingDown = false;
         this.options = {
             cwd: options.cwd,
@@ -232,7 +232,7 @@ export class VitestPool {
         };
     }
     async init() {
-        if (this.initialized)
+        if (this.initialised)
             return;
         poolLog.debug(`Initializing pool with ${this.options.concurrency} workers`);
         const startPromises = [];
@@ -254,8 +254,8 @@ export class VitestPool {
             }));
         }
         await Promise.all(startPromises);
-        this.initialized = true;
-        poolLog.debug('Pool initialized');
+        this.initialised = true;
+        poolLog.debug('Pool initialised');
     }
     handleWorkerExit(worker) {
         // Remove from available list
@@ -313,8 +313,8 @@ export class VitestPool {
         }
     }
     async run(mutant, tests) {
-        if (!this.initialized) {
-            throw new Error('Pool not initialized. Call init() first.');
+        if (!this.initialised) {
+            throw new Error('Pool not initialised. Call init() first.');
         }
         if (this.shuttingDown) {
             throw new Error('Pool is shutting down');
@@ -336,7 +336,7 @@ export class VitestPool {
         await Promise.all(this.workers.map((w) => w.shutdown()));
         this.workers = [];
         this.availableWorkers = [];
-        this.initialized = false;
+        this.initialised = false;
         poolLog.debug('Pool shut down');
     }
 }

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

@@ -13,7 +13,7 @@ declare global {
         to: string | null;
     } | undefined;
 }
-export declare function initialize(data: {
+export declare function initialise(data: {
     debug?: boolean;
 } | undefined): void;
 export declare function resolve(specifier: string, context: {

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

@@ -17,7 +17,7 @@ register(import.meta.url, {
     data: { debug: process.env.MUTINEER_DEBUG === '1' },
 });
 let DEBUG = process.env.MUTINEER_DEBUG === '1';
-export function initialize(data) {
+export function initialise(data) {
     if (data?.debug !== undefined) {
         DEBUG = data.debug;
     }

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

@@ -25,10 +25,10 @@ export class VitestWorkerRuntime {
                 plugins: [poolMutineerPlugin()],
             });
             await this.vitest.init();
-            log.debug(`Vitest initialized for worker ${this.options.workerId}`);
+            log.debug(`Vitest initialised for worker ${this.options.workerId}`);
         }
         catch (err) {
-            log.error(`Failed to initialize Vitest: ${err}`);
+            log.error(`Failed to initialise Vitest: ${err}`);
             throw err;
         }
     }
@@ -40,7 +40,7 @@ export class VitestWorkerRuntime {
     }
     async run(mutant, tests) {
         if (!this.vitest) {
-            throw new Error('Vitest runtime not initialized');
+            throw new Error('Vitest runtime not initialised');
         }
         const start = Date.now();
         try {

package/dist/runner/vitest/worker.mjs

@@ -36,7 +36,7 @@ async function main() {
         await runtime.init();
     }
     catch (err) {
-        log.error(`Failed to initialize Vitest: ${err}`);
+        log.error(`Failed to initialise Vitest: ${err}`);
         process.exit(1);
     }
     // Signal ready