@mutineerjs/mutineer 0.2.4 → 0.4.0

package/dist/mutators/operator.js

@@ -0,0 +1,50 @@
+/**
+ * Operator mutators.
+ *
+ * Each mutator finds every occurrence of a specific binary/logical operator
+ * using AST traversal and produces a mutated source string with that operator
+ * replaced by its counterpart.
+ */
+import { collectOperatorTargets } from './utils.js';
+/**
+ * Factory to build an operator mutator using AST traversal and token analysis.
+ *
+ * @param name - Mutator name used in the registry and config include/exclude
+ * @param description - Human-readable description shown in reports
+ * @param fromOp - The operator to find (e.g., '&&')
+ * @param toOp - The operator to replace it with (e.g., '||')
+ */
+function makeOperatorMutator(name, description, fromOp, toOp) {
+    return {
+        name,
+        description,
+        apply(src) {
+            return collectOperatorTargets(src, fromOp).map((target) => ({
+                line: target.line,
+                col: target.col1,
+                code: src.slice(0, target.start) + toOp + src.slice(target.end),
+            }));
+        },
+    };
+}
+/* === Boundary mutators === */
+export const relaxLE = makeOperatorMutator('relaxLE', "Change '<=' to '<' (relax boundary)", '<=', '<');
+export const relaxGE = makeOperatorMutator('relaxGE', "Change '>=' to '>' (relax boundary)", '>=', '>');
+export const tightenLT = makeOperatorMutator('tightenLT', "Change '<' to '<=' (tighten boundary)", '<', '<=');
+export const tightenGT = makeOperatorMutator('tightenGT', "Change '>' to '>=' (tighten boundary)", '>', '>=');
+/* === Logical mutators === */
+export const andToOr = makeOperatorMutator('andToOr', "Change '&&' to '||'", '&&', '||');
+export const orToAnd = makeOperatorMutator('orToAnd', "Change '||' to '&&'", '||', '&&');
+export const nullishToOr = makeOperatorMutator('nullishToOr', "Change '??' to '||'", '??', '||');
+/* === Equality mutators === */
+export const flipEQ = makeOperatorMutator('flipEQ', "Change '==' to '!='", '==', '!=');
+export const flipNEQ = makeOperatorMutator('flipNEQ', "Change '!=' to '=='", '!=', '==');
+export const flipStrictEQ = makeOperatorMutator('flipStrictEQ', "Change '===' to '!=='", '===', '!==');
+export const flipStrictNEQ = makeOperatorMutator('flipStrictNEQ', "Change '!==' to '==='", '!==', '===');
+/* === Arithmetic mutators === */
+export const addToSub = makeOperatorMutator('addToSub', "Change '+' to '-'", '+', '-');
+export const subToAdd = makeOperatorMutator('subToAdd', "Change '-' to '+'", '-', '+');
+export const mulToDiv = makeOperatorMutator('mulToDiv', "Change '*' to '/'", '*', '/');
+export const divToMul = makeOperatorMutator('divToMul', "Change '/' to '*'", '/', '*');
+export const modToMul = makeOperatorMutator('modToMul', "Change '%' to '*'", '%', '*');
+export const powerToMul = makeOperatorMutator('powerToMul', "Change '**' to '*'", '**', '*');

package/dist/mutators/registry.d.ts

@@ -1,37 +1,15 @@
 /**
- * Mutator registry and factory.
+ * Mutator registry.
  *
- * Provides functions to create operator mutators and retrieve registered mutators
- * with optional include/exclude filtering.
+ * Aggregates all mutators and exposes `getRegistry` for filtered access.
  */
 import type { ASTMutator } from './types.js';
-export declare const relaxLE: ASTMutator;
-export declare const relaxGE: ASTMutator;
-export declare const tightenLT: ASTMutator;
-export declare const tightenGT: ASTMutator;
-export declare const andToOr: ASTMutator;
-export declare const orToAnd: ASTMutator;
-export declare const nullishToOr: ASTMutator;
-export declare const flipEQ: ASTMutator;
-export declare const flipNEQ: ASTMutator;
-export declare const flipStrictEQ: ASTMutator;
-export declare const flipStrictNEQ: ASTMutator;
-export declare const addToSub: ASTMutator;
-export declare const subToAdd: ASTMutator;
-export declare const mulToDiv: ASTMutator;
-export declare const divToMul: ASTMutator;
-export declare const modToMul: ASTMutator;
-export declare const powerToMul: ASTMutator;
 /**
- * Get a filtered registry of mutators based on include/exclude options.
+ * Get a filtered list of mutators.
  *
- * If include list provided, only those mutators are returned.
- * If exclude list provided, those mutators are filtered out.
- * Include list takes precedence over exclude list.
- *
- * @param include - Optional list of mutator names to include
- * @param exclude - Optional list of mutator names to exclude
- * @returns Filtered array of mutators
+ * If `include` is provided, only those mutators are returned.
+ * If `exclude` is provided, those mutators are removed.
+ * `include` takes precedence over `exclude`.
  */
 export declare function getRegistry(include?: readonly string[], exclude?: readonly string[]): ASTMutator[];
 export type { ASTMutator, AnyMutator, MutationOutput } from './types.js';

package/dist/mutators/registry.js

@@ -1,62 +1,10 @@
 /**
- * Mutator registry and factory.
+ * Mutator registry.
  *
- * Provides functions to create operator mutators and retrieve registered mutators
- * with optional include/exclude filtering.
- */
-import { collectOperatorTargets } from './utils.js';
-/**
- * Factory to build an operator mutator using AST traversal and token analysis.
- * Creates a reusable mutator that finds and replaces a specific operator throughout the code.
- *
- * @param name - Name of the mutator (e.g., 'andToOr')
- * @param description - Human-readable description
- * @param fromOp - The operator to find (e.g., '&&')
- * @param toOp - The operator to replace it with (e.g., '||')
- * @returns An ASTMutator that applies this transformation
- */
-function makeOperatorMutator(name, description, fromOp, toOp) {
-    return {
-        name,
-        description,
-        apply(src) {
-            // 1) Collect exact operator token locations from matching nodes
-            const targets = collectOperatorTargets(src, fromOp);
-            // 2) For each occurrence, produce a mutated version of the programme
-            const outputs = [];
-            for (const target of targets) {
-                const code = src.slice(0, target.start) + toOp + src.slice(target.end);
-                outputs.push({
-                    line: target.line,
-                    col: target.col1,
-                    code,
-                });
-            }
-            return outputs;
-        },
-    };
-}
-/* === Concrete mutators (AST-safe) === */
-export const relaxLE = makeOperatorMutator('relaxLE', "Change '<=' to '<' (relax boundary)", '<=', '<');
-export const relaxGE = makeOperatorMutator('relaxGE', "Change '>=' to '>' (relax boundary)", '>=', '>');
-export const tightenLT = makeOperatorMutator('tightenLT', "Change '<' to '<=' (tighten boundary)", '<', '<=');
-export const tightenGT = makeOperatorMutator('tightenGT', "Change '>' to '>=' (tighten boundary)", '>', '>=');
-export const andToOr = makeOperatorMutator('andToOr', "Change '&&' to '||' in boolean expressions", '&&', '||');
-export const orToAnd = makeOperatorMutator('orToAnd', "Change '||' to '&&' in boolean expressions", '||', '&&');
-export const nullishToOr = makeOperatorMutator('nullishToOr', "Change '??' to '||' to prefer boolean fallback", '??', '||');
-export const flipEQ = makeOperatorMutator('flipEQ', "Change '==' to '!='", '==', '!=');
-export const flipNEQ = makeOperatorMutator('flipNEQ', "Change '!=' to '=='", '!=', '==');
-export const flipStrictEQ = makeOperatorMutator('flipStrictEQ', "Change '===' to '!=='", '===', '!==');
-export const flipStrictNEQ = makeOperatorMutator('flipStrictNEQ', "Change '!==' to '==='", '!==', '===');
-export const addToSub = makeOperatorMutator('addToSub', "Change '+' to '-' in arithmetic expressions", '+', '-');
-export const subToAdd = makeOperatorMutator('subToAdd', "Change '-' to '+' in arithmetic expressions", '-', '+');
-export const mulToDiv = makeOperatorMutator('mulToDiv', "Change '*' to '/' in arithmetic expressions", '*', '/');
-export const divToMul = makeOperatorMutator('divToMul', "Change '/' to '*' in arithmetic expressions", '/', '*');
-export const modToMul = makeOperatorMutator('modToMul', "Change '%' to '*' in arithmetic expressions", '%', '*');
-export const powerToMul = makeOperatorMutator('powerToMul', "Change '**' to '*' in arithmetic expressions", '**', '*');
-/**
- * All registered mutators in order of precedence.
+ * Aggregates all mutators and exposes `getRegistry` for filtered access.
  */
+import { relaxLE, relaxGE, tightenLT, tightenGT, andToOr, orToAnd, nullishToOr, flipEQ, flipNEQ, flipStrictEQ, flipStrictNEQ, addToSub, subToAdd, mulToDiv, divToMul, modToMul, powerToMul, } from './operator.js';
+import { returnToNull, returnToUndefined, returnFlipBool, returnZero, returnEmptyStr, returnEmptyArr, } from './return-value.js';
 const ALL = [
     relaxLE,
     relaxGE,
@@ -75,25 +23,25 @@ const ALL = [
     divToMul,
     modToMul,
     powerToMul,
+    returnToNull,
+    returnToUndefined,
+    returnFlipBool,
+    returnZero,
+    returnEmptyStr,
+    returnEmptyArr,
 ];
 /**
- * Get a filtered registry of mutators based on include/exclude options.
- *
- * If include list provided, only those mutators are returned.
- * If exclude list provided, those mutators are filtered out.
- * Include list takes precedence over exclude list.
+ * Get a filtered list of mutators.
  *
- * @param include - Optional list of mutator names to include
- * @param exclude - Optional list of mutator names to exclude
- * @returns Filtered array of mutators
+ * If `include` is provided, only those mutators are returned.
+ * If `exclude` is provided, those mutators are removed.
+ * `include` takes precedence over `exclude`.
  */
 export function getRegistry(include, exclude) {
     let list = ALL;
-    // If include list provided, filter to only those mutators
     if (include?.length) {
         list = list.filter((m) => include.includes(m.name));
     }
-    // If exclude list provided, remove those mutators
     if (exclude?.length) {
         list = list.filter((m) => !exclude.includes(m.name));
     }

package/dist/mutators/return-value.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Return value mutators.
+ *
+ * These mutators target `return` statements and replace the returned expression
+ * with a simpler or opposite value. They catch a different class of test gap
+ * from operator mutators: they reveal when callers never check what a function
+ * returns (e.g. no null-check, no assertion on the return value).
+ */
+import type { ASTMutator } from './types.js';
+/**
+ * Replace any non-null return value with `null`.
+ * Reveals callers that never check for null returns.
+ */
+export declare const returnToNull: ASTMutator;
+/**
+ * Replace any non-undefined return value with `undefined`.
+ * Reveals callers that never guard against undefined returns.
+ */
+export declare const returnToUndefined: ASTMutator;
+/**
+ * Flip `return true` ↔ `return false`.
+ * Catches missing assertions on boolean-returning functions.
+ */
+export declare const returnFlipBool: ASTMutator;
+/**
+ * Replace a non-zero numeric return with `0`.
+ * Catches callers that never check the numeric return value.
+ */
+export declare const returnZero: ASTMutator;
+/**
+ * Replace a non-empty string return with `''`.
+ * Catches callers that never check the string return value.
+ */
+export declare const returnEmptyStr: ASTMutator;
+/**
+ * Replace an array expression return with `[]`.
+ * Catches callers that never check for an empty array.
+ */
+export declare const returnEmptyArr: ASTMutator;

package/dist/mutators/return-value.js

@@ -0,0 +1,104 @@
+/**
+ * Return value mutators.
+ *
+ * These mutators target `return` statements and replace the returned expression
+ * with a simpler or opposite value. They catch a different class of test gap
+ * from operator mutators: they reveal when callers never check what a function
+ * returns (e.g. no null-check, no assertion on the return value).
+ */
+import * as t from '@babel/types';
+import { traverse, getVisualColumn, parseSource, buildIgnoreLines, } from './utils.js';
+/**
+ * Factory for return-value mutators.
+ *
+ * Traverses all `ReturnStatement` nodes in the source. For each node that has
+ * an argument (i.e. not a bare `return;`), calls `replacer` with the argument
+ * AST node. If `replacer` returns a non-null string, emits a mutation that
+ * splices that string in place of the original argument.
+ *
+ * @param name - Mutator name used in the registry and config include/exclude
+ * @param description - Human-readable description shown in reports
+ * @param replacer - Returns the replacement source text, or null to skip
+ */
+function makeReturnMutator(name, description, replacer) {
+    return {
+        name,
+        description,
+        apply(src) {
+            const ast = parseSource(src);
+            const fileAst = ast;
+            const ignoreLines = buildIgnoreLines(fileAst.comments ?? []);
+            const outputs = [];
+            traverse(ast, {
+                ReturnStatement(path) {
+                    const node = path.node;
+                    if (!node.argument)
+                        return; // bare return; — nothing to replace
+                    const line = node.loc?.start.line;
+                    if (line === undefined)
+                        return;
+                    if (ignoreLines.has(line))
+                        return;
+                    const replacement = replacer(node.argument);
+                    if (replacement === null)
+                        return;
+                    const argStart = node.argument.start;
+                    const argEnd = node.argument.end;
+                    if (argStart == null || argEnd == null)
+                        return;
+                    const col = getVisualColumn(src, node.start ?? 0);
+                    const code = src.slice(0, argStart) + replacement + src.slice(argEnd);
+                    outputs.push({ line, col, code });
+                },
+            });
+            return outputs;
+        },
+    };
+}
+/* === Concrete return-value mutators === */
+/**
+ * Replace any non-null return value with `null`.
+ * Reveals callers that never check for null returns.
+ */
+export const returnToNull = makeReturnMutator('returnToNull', 'Replace return value with null', (node) => (t.isNullLiteral(node) ? null : 'null'));
+/**
+ * Replace any non-undefined return value with `undefined`.
+ * Reveals callers that never guard against undefined returns.
+ */
+export const returnToUndefined = makeReturnMutator('returnToUndefined', 'Replace return value with undefined', (node) => (t.isIdentifier(node, { name: 'undefined' }) ? null : 'undefined'));
+/**
+ * Flip `return true` ↔ `return false`.
+ * Catches missing assertions on boolean-returning functions.
+ */
+export const returnFlipBool = makeReturnMutator('returnFlipBool', 'Flip boolean return value (true ↔ false)', (node) => {
+    if (!t.isBooleanLiteral(node))
+        return null;
+    return node.value ? 'false' : 'true';
+});
+/**
+ * Replace a non-zero numeric return with `0`.
+ * Catches callers that never check the numeric return value.
+ */
+export const returnZero = makeReturnMutator('returnZero', 'Replace numeric return value with 0', (node) => {
+    if (!t.isNumericLiteral(node))
+        return null;
+    return node.value === 0 ? null : '0';
+});
+/**
+ * Replace a non-empty string return with `''`.
+ * Catches callers that never check the string return value.
+ */
+export const returnEmptyStr = makeReturnMutator('returnEmptyStr', "Replace string return value with ''", (node) => {
+    if (!t.isStringLiteral(node))
+        return null;
+    return node.value === '' ? null : "''";
+});
+/**
+ * Replace an array expression return with `[]`.
+ * Catches callers that never check for an empty array.
+ */
+export const returnEmptyArr = makeReturnMutator('returnEmptyArr', 'Replace array return value with []', (node) => {
+    if (!t.isArrayExpression(node))
+        return null;
+    return node.elements.length === 0 ? null : '[]';
+});

package/dist/mutators/utils.d.ts

@@ -4,9 +4,16 @@
  * Provides functions for parsing, traversing, and analyzing code ASTs.
  * These utilities are used by operator mutators to locate and replace operators.
  */
+import { type ParserOptions } from '@babel/parser';
 import * as t from '@babel/types';
 import type { OperatorTarget } from './types.js';
 export declare const traverse: typeof import('@babel/traverse').default;
+/**
+ * Parser configuration for Babel.
+ * Enables support for TypeScript, JSX, decorators, and modern JavaScript features.
+ */
+export declare const parserOptsTs: ParserOptions;
+export declare const parserOptsFlow: ParserOptions;
 /**
  * Tab width used for converting character columns to visual columns.
  * This helps report correct column positions for terminals that render tabs.
@@ -21,6 +28,20 @@ export declare const TAB_WIDTH = 4;
  * @returns The visual column (1-based)
  */
 export declare function getVisualColumn(src: string, charOffset: number): number;
+/**
+ * Build a set of line numbers that should be ignored for mutation based on
+ * disable comments (`mutineer-disable`, `mutineer-disable-line`,
+ * `mutineer-disable-next-line`).
+ *
+ * @param comments - The comment nodes from the parsed AST
+ * @returns Set of 1-based line numbers that should not be mutated
+ */
+export declare function buildIgnoreLines(comments: readonly t.Comment[]): Set<number>;
+/**
+ * Parse source with the TypeScript Babel plugin, falling back to the Flow
+ * plugin for Flow-typed React files that fail TS parsing.
+ */
+export declare function parseSource(src: string): import("@babel/parser").ParseResult<t.File>;
 /**
  * Type guard to check if a node is a BinaryExpression or LogicalExpression.
  */

package/dist/mutators/utils.js

@@ -13,7 +13,7 @@ export const traverse = traverseModuleNormalized.default ?? traverseModuleNormal
  * Parser configuration for Babel.
  * Enables support for TypeScript, JSX, decorators, and modern JavaScript features.
  */
-const parserOptsTs = {
+export const parserOptsTs = {
     sourceType: 'unambiguous',
     plugins: [
         'typescript',
@@ -28,7 +28,7 @@ const parserOptsTs = {
     ],
     tokens: true,
 };
-const parserOptsFlow = {
+export const parserOptsFlow = {
     sourceType: 'unambiguous',
     plugins: [
         'flow',
@@ -74,33 +74,14 @@ export function getVisualColumn(src, charOffset) {
     return visualCol;
 }
 /**
- * Type guard to check if a node is a BinaryExpression or LogicalExpression.
- */
-export function isBinaryOrLogical(node) {
-    return node.type === 'BinaryExpression' || node.type === 'LogicalExpression';
-}
-/**
- * Collect the operator tokens for a given operator and return their exact locations.
- * Uses AST traversal to find BinaryExpression/LogicalExpression nodes, then maps them
- * to token positions for accurate column reporting.
+ * Build a set of line numbers that should be ignored for mutation based on
+ * disable comments (`mutineer-disable`, `mutineer-disable-line`,
+ * `mutineer-disable-next-line`).
  *
- * @param src - The source code
- * @param opValue - The operator to search for (e.g., '&&', '<=')
- * @returns Array of target locations for the operator
+ * @param comments - The comment nodes from the parsed AST
+ * @returns Set of 1-based line numbers that should not be mutated
  */
-export function collectOperatorTargets(src, opValue) {
-    let ast;
-    try {
-        ast = parse(src, parserOptsTs);
-    }
-    catch {
-        // Flow-typed React sources fail under TS parsing; fall back to Flow plugins.
-        ast = parse(src, parserOptsFlow);
-    }
-    const fileAst = ast;
-    const tokens = fileAst.tokens ?? [];
-    const comments = fileAst.comments ?? [];
-    const out = [];
+export function buildIgnoreLines(comments) {
     const ignoreLines = new Set();
     for (const comment of comments) {
         const text = comment.value.trim();
@@ -120,6 +101,42 @@ export function collectOperatorTargets(src, opValue) {
             }
         }
     }
+    return ignoreLines;
+}
+/**
+ * Parse source with the TypeScript Babel plugin, falling back to the Flow
+ * plugin for Flow-typed React files that fail TS parsing.
+ */
+export function parseSource(src) {
+    try {
+        return parse(src, parserOptsTs);
+    }
+    catch {
+        return parse(src, parserOptsFlow);
+    }
+}
+/**
+ * Type guard to check if a node is a BinaryExpression or LogicalExpression.
+ */
+export function isBinaryOrLogical(node) {
+    return node.type === 'BinaryExpression' || node.type === 'LogicalExpression';
+}
+/**
+ * Collect the operator tokens for a given operator and return their exact locations.
+ * Uses AST traversal to find BinaryExpression/LogicalExpression nodes, then maps them
+ * to token positions for accurate column reporting.
+ *
+ * @param src - The source code
+ * @param opValue - The operator to search for (e.g., '&&', '<=')
+ * @returns Array of target locations for the operator
+ */
+export function collectOperatorTargets(src, opValue) {
+    const ast = parseSource(src);
+    const fileAst = ast;
+    const tokens = fileAst.tokens ?? [];
+    const comments = fileAst.comments ?? [];
+    const out = [];
+    const ignoreLines = buildIgnoreLines(comments);
     traverse(ast, {
         enter(p) {
             if (!isBinaryOrLogical(p.node))

package/dist/runner/__tests__/pool-executor.spec.js

@@ -8,9 +8,7 @@ function makeAdapter(overrides = {}) {
         name: 'vitest',
         init: vi.fn().mockResolvedValue(undefined),
         runBaseline: vi.fn().mockResolvedValue(true),
-        runMutant: vi
-            .fn()
-            .mockResolvedValue({ status: 'killed', durationMs: 10 }),
+        runMutant: vi.fn().mockResolvedValue({ status: 'killed', durationMs: 10 }),
         shutdown: vi.fn().mockResolvedValue(undefined),
         hasCoverageProvider: vi.fn().mockReturnValue(false),
         detectCoverageConfig: vi
@@ -45,7 +43,7 @@ describe('executePool', () => {
         process.exitCode = undefined;
         await fs.rm(tmpDir, { recursive: true, force: true });
     });
-    it('initializes adapter with correct worker count', async () => {
+    it('initialises adapter with correct worker count', async () => {
         const adapter = makeAdapter();
         const cache = {};
         const tasks = [makeTask()];
@@ -195,6 +193,99 @@ describe('executePool', () => {
         const content = JSON.parse(await fs.readFile(cacheFile, 'utf8'));
         expect(content['persist-key']).toBeDefined();
     });
+    it('escaped mutant stores snippets when lines differ', async () => {
+        const tmpFile = path.join(tmpDir, 'source.ts');
+        await fs.writeFile(tmpFile, 'const x = a + b\n');
+        const adapter = makeAdapter({
+            runMutant: vi
+                .fn()
+                .mockResolvedValue({ status: 'escaped', durationMs: 1 }),
+        });
+        const cache = {};
+        const task = makeTask({
+            key: 'snippet-key',
+            v: {
+                id: 'source.ts#0',
+                name: 'flipArith',
+                file: tmpFile,
+                code: 'const x = a - b\n',
+                line: 1,
+                col: 10,
+                tests: ['/tests/file.test.ts'],
+            },
+        });
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(cache['snippet-key'].originalSnippet).toBe('const x = a + b');
+        expect(cache['snippet-key'].mutatedSnippet).toBe('const x = a - b');
+    });
+    it('escaped mutant omits snippets when original and mutated lines are identical', async () => {
+        const tmpFile = path.join(tmpDir, 'source2.ts');
+        await fs.writeFile(tmpFile, 'const x = a + b\n');
+        const adapter = makeAdapter({
+            runMutant: vi
+                .fn()
+                .mockResolvedValue({ status: 'escaped', durationMs: 1 }),
+        });
+        const cache = {};
+        const task = makeTask({
+            key: 'no-snippet-key',
+            v: {
+                id: 'source2.ts#0',
+                name: 'flipArith',
+                file: tmpFile,
+                code: 'const x = a + b\n',
+                line: 1,
+                col: 10,
+                tests: ['/tests/file.test.ts'],
+            },
+        });
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(cache['no-snippet-key'].originalSnippet).toBeUndefined();
+    });
+    it('escaped mutant omits snippets when file read fails', async () => {
+        const adapter = makeAdapter({
+            runMutant: vi
+                .fn()
+                .mockResolvedValue({ status: 'escaped', durationMs: 1 }),
+        });
+        const cache = {};
+        const task = makeTask({
+            key: 'missing-file-key',
+            v: {
+                id: 'missing.ts#0',
+                name: 'flipArith',
+                file: '/nonexistent/path/missing.ts',
+                code: 'const x = a - b\n',
+                line: 1,
+                col: 10,
+                tests: ['/tests/file.test.ts'],
+            },
+        });
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(cache['missing-file-key'].status).toBe('escaped');
+        expect(cache['missing-file-key'].originalSnippet).toBeUndefined();
+    });
     it('handles adapter errors gracefully and still shuts down', async () => {
         const adapter = makeAdapter({
             runMutant: vi.fn().mockRejectedValue(new Error('adapter failure')),

package/dist/runner/__tests__/variants.spec.js

@@ -69,7 +69,9 @@ describe('enumerateVariantsForTarget', () => {
     it('filters by include', async () => {
         const srcFile = path.join(tmpDir, 'inc.ts');
         await fs.writeFile(srcFile, 'const x = a === b && c || d');
-        const result = await enumerateVariantsForTarget(tmpDir, 'inc.ts', ['andToOr']);
+        const result = await enumerateVariantsForTarget(tmpDir, 'inc.ts', [
+            'andToOr',
+        ]);
         expect(result.every((v) => v.name === 'andToOr')).toBe(true);
     });
     it('filters by exclude', async () => {

package/dist/runner/discover.js

@@ -85,7 +85,8 @@ async function createViteResolver(rootAbs, exts) {
     let plugins = [];
     if (exts.has('.vue')) {
         try {
-            const mod = await import('@vitejs/plugin-vue');
+            const mod = await import(
+            /* @vite-ignore */ '@vitejs/plugin-vue');
             const vue = mod.default ?? mod;
             plugins = typeof vue === 'function' ? [vue()] : [];
         }

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

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