@mutineerjs/mutineer 0.2.4 → 0.4.0

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

@@ -2,7 +2,6 @@ import { describe, it, expect, vi } from 'vitest';
 import { JestPool, runWithJestPool } from '../pool.js';
 // We'll use the createWorker option to inject mock workers instead of forking processes
 function makeMockWorker(id) {
-    let readyResolve = null;
     const worker = {
         id,
         _ready: true,
@@ -33,9 +32,9 @@ const dummyMutant = {
 describe('JestPool', () => {
     it('throws if run is called before init', async () => {
         const pool = new JestPool({ cwd: '/tmp', concurrency: 1 });
-        await expect(pool.run(dummyMutant, ['test.ts'])).rejects.toThrow('Pool not initialized');
+        await expect(pool.run(dummyMutant, ['test.ts'])).rejects.toThrow('Pool not initialised');
     });
-    it('initializes with the specified concurrency', async () => {
+    it('initialises with the specified concurrency', async () => {
         const workers = [];
         const pool = new JestPool({
             cwd: '/tmp',
@@ -51,7 +50,7 @@ describe('JestPool', () => {
         expect(workers[0].start).toHaveBeenCalled();
         expect(workers[1].start).toHaveBeenCalled();
     });
-    it('does not re-initialize if already initialized', async () => {
+    it('does not re-initialise if already initialised', async () => {
         const workers = [];
         const pool = new JestPool({
             cwd: '/tmp',
@@ -108,8 +107,8 @@ describe('JestPool', () => {
         });
         await pool.init();
         await pool.shutdown();
-        // After shutdown, initialized is set to false, so "not initialized" check fires first
-        await expect(pool.run(dummyMutant, ['test.ts'])).rejects.toThrow('Pool not initialized');
+        // After shutdown, initialised is set to false, so "not initialised" check fires first
+        await expect(pool.run(dummyMutant, ['test.ts'])).rejects.toThrow('Pool not initialised');
     });
     it('does not double-shutdown', async () => {
         const workers = [];

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

@@ -1,8 +1,8 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { JestWorkerRuntime, createJestWorkerRuntime } from '../worker-runtime.js';
+import { JestWorkerRuntime, createJestWorkerRuntime, } from '../worker-runtime.js';
 // Mock the shared utilities
 vi.mock('../../shared/index.js', () => ({
-    getMutantFilePath: vi.fn((file, id) => `/tmp/__mutineer__/mutant_${id}.ts`),
+    getMutantFilePath: vi.fn((id) => `/tmp/__mutineer__/mutant_${id}.ts`),
     setRedirect: vi.fn(),
     clearRedirect: vi.fn(),
 }));

package/dist/runner/jest/adapter.js

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

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

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

package/dist/runner/jest/pool.js

@@ -170,7 +170,7 @@ export class JestPool {
         this.workers = [];
         this.availableWorkers = [];
         this.waitingTasks = [];
-        this.initialized = false;
+        this.initialised = false;
         this.shuttingDown = false;
         this.options = {
             cwd: options.cwd,
@@ -181,7 +181,7 @@ export class JestPool {
         };
     }
     async init() {
-        if (this.initialized)
+        if (this.initialised)
             return;
         const startPromises = [];
         for (let i = 0; i < this.options.concurrency; i++) {
@@ -200,7 +200,7 @@ export class JestPool {
             }));
         }
         await Promise.all(startPromises);
-        this.initialized = true;
+        this.initialised = true;
     }
     handleWorkerExit(worker) {
         const availIdx = this.availableWorkers.indexOf(worker);
@@ -249,8 +249,8 @@ export class JestPool {
         }
     }
     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');
@@ -272,7 +272,7 @@ export class JestPool {
         await Promise.all(this.workers.map((w) => w.shutdown()));
         this.workers = [];
         this.availableWorkers = [];
-        this.initialized = false;
+        this.initialised = false;
     }
 }
 export async function runWithJestPool(pool, mutant, tests) {

package/dist/runner/jest/worker.mjs

@@ -16,7 +16,7 @@ async function main() {
         await runtime.init();
     }
     catch (err) {
-        log.error(`Failed to initialize: ${err}`);
+        log.error(`Failed to initialise: ${err}`);
         process.exit(1);
     }
     process.send?.({ type: 'ready', workerId });

package/dist/runner/pool-executor.js

@@ -1,3 +1,4 @@
+import fs from 'node:fs';
 import { render } from 'ink';
 import { createElement } from 'react';
 import { Progress } from '../utils/progress.js';
@@ -42,7 +43,7 @@ export async function executePool(opts) {
             }
         }
     };
-    // Initialize worker pool
+    // Initialise worker pool
     const workerLogSuffix = workerCount < concurrency ? ` (requested ${concurrency})` : '';
     log.info(`Initializing ${adapter.name} worker pool with ${workerCount} workers...${workerLogSuffix}`);
     const poolStart = Date.now();
@@ -93,12 +94,31 @@ export async function executePool(opts) {
             col: v.col,
         }, tests);
         const status = result.status;
+        let originalSnippet;
+        let mutatedSnippet;
+        if (status === 'escaped') {
+            try {
+                const originalLines = fs.readFileSync(v.file, 'utf8').split('\n');
+                const mutatedLines = v.code.split('\n');
+                const lineIdx = v.line - 1;
+                const orig = originalLines[lineIdx]?.trim();
+                const mutated = mutatedLines[lineIdx]?.trim();
+                if (orig !== undefined && mutated !== undefined && orig !== mutated) {
+                    originalSnippet = orig;
+                    mutatedSnippet = mutated;
+                }
+            }
+            catch {
+                // best-effort
+            }
+        }
         cache[key] = {
             status,
             file: v.file,
             line: v.line,
             col: v.col,
             mutator: v.name,
+            ...(originalSnippet !== undefined && { originalSnippet, mutatedSnippet }),
         };
         progress.update(status);
     }

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

@@ -1,10 +1,10 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { initializeRedirectState, setRedirect, getRedirect, clearRedirect, } from '../redirect-state.js';
+import { initialiseRedirectState, setRedirect, getRedirect, clearRedirect, } from '../redirect-state.js';
 describe('redirect-state', () => {
     beforeEach(() => {
-        initializeRedirectState();
+        initialiseRedirectState();
     });
-    describe('initializeRedirectState', () => {
+    describe('initialiseRedirectState', () => {
         it('sets global redirect to null/null', () => {
             expect(globalThis.__mutineer_redirect__).toEqual({
                 from: 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/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/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

@@ -7,11 +7,12 @@ vi.mock('node:module', async (importOriginal) => {
     const actual = await importOriginal();
     return { ...actual, register: vi.fn() };
 });
-import { resolve as poolResolve } from '../redirect-loader.js';
+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 () => {
@@ -88,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

package/dist/types/mutant.d.ts

@@ -25,6 +25,8 @@ export interface Variant extends MutantDescriptor {
 export interface MutantCacheEntry extends MutantLocation {
     readonly status: MutantStatus;
     readonly mutator: string;
+    readonly originalSnippet?: string;
+    readonly mutatedSnippet?: string;
 }
 export interface MutantResult extends MutantCacheEntry {
     readonly id: string;