@mutineerjs/mutineer 0.9.0 → 0.11.0

package/README.md

@@ -9,16 +9,16 @@
        === ~> !== · && ~> || · + ~> -
 ```
 
-Mutineer is a fast, targeted mutation testing framework for JavaScript and TypeScript. Mutineer introduces small code changes (mutations) into your source files and runs your existing tests to see if they catch the defect. If a test fails, the mutant is "killed" -- meaning your tests are doing their job. If all tests pass, the mutant "escaped" -- revealing a gap in your test coverage.
+Mutineer is a fast, targeted mutation testing framework for JavaScript and TypeScript. Mutineer introduces small code changes (mutations) into your source files and runs your existing tests to see if they catch the defect. If a test fails, the mutant is "killed" - meaning your tests are doing their job. If all tests pass, the mutant "escaped" - revealing a gap in your test coverage.
 
 Built for **Vitest** with first-class **Jest** support. Other test runners can be added via the adapter interface.
 
 ## How It Works
 
-1. **Baseline** -- runs your test suite to make sure everything passes before mutating
-2. **Mutate** -- applies AST-safe operator replacements to your source files (not your tests)
-3. **Test** -- re-runs only the tests that import the mutated file; compile errors are detected via parallel TypeScript workers and surfaced in an interactive UI
-4. **Report** -- prints a summary with kill rate, escaped mutants, and per-file breakdowns
+1. **Baseline** - runs your test suite to make sure everything passes before mutating
+2. **Mutate** - applies AST-safe operator replacements to your source files (not your tests)
+3. **Test** - re-runs only the tests that import the mutated file; compile errors are detected via parallel TypeScript workers
+4. **Report** - prints a summary with kill rate, escaped mutants, and per-file breakdowns
 
 Mutations are applied using Babel AST analysis, so operators inside strings and comments are never touched. Mutated code is written to a temporary `__mutineer__` directory next to each source file, then loaded at runtime via Vite plugins (Vitest) or custom resolvers (Jest).
 
@@ -93,23 +93,26 @@ npm run mutineer
 
 ### CLI Options (for `mutineer run`)
 
-| Flag                     | Description                                                     | Default       |
-| ------------------------ | --------------------------------------------------------------- | ------------- |
-| `--runner <type>`        | Test runner: `vitest` or `jest`                                 | `vitest`      |
-| `--config`, `-c`         | Path to config file                                             | auto-detected |
-| `--concurrency <n>`      | Parallel workers (min 1)                                        | CPUs - 1      |
-| `--changed`              | Only mutate files changed vs base branch                        | --            |
-| `--changed-with-deps`    | Include dependents of changed files                             | --            |
-| `--full`                 | Mutate full codebase, skipping confirmation prompt              | --            |
-| `--only-covered-lines`   | Skip mutations on uncovered lines                               | --            |
-| `--per-test-coverage`    | Run only tests that cover the mutated line                      | --            |
-| `--coverage-file <path>` | Path to Istanbul coverage JSON                                  | auto-detected |
-| `--min-kill-percent <n>` | Fail if kill rate is below threshold                            | --            |
-| `--progress <mode>`      | Display mode: `bar`, `list`, or `quiet`                         | `bar`         |
-| `--timeout <ms>`         | Per-mutant test timeout                                         | `30000`       |
-| `--report <format>`      | Output format: `text` or `json` (writes `mutineer-report.json`) | `text`        |
-| `--shard <n>/<total>`    | Run a slice of mutants (e.g. `--shard 1/4`)                     | --            |
-| `--skip-baseline`        | Skip the baseline test run                                      | --            |
+| Flag                      | Description                                                                          | Default       |
+| ------------------------- | ------------------------------------------------------------------------------------ | ------------- |
+| `--runner <type>`         | Test runner: `vitest` or `jest`                                                      | `vitest`      |
+| `--config`, `-c`          | Path to config file                                                                  | auto-detected |
+| `--concurrency <n>`       | Parallel workers (min 1)                                                             | CPUs - 1      |
+| `--changed`               | Only mutate files changed vs base branch                                             | --            |
+| `--changed-with-imports`  | Include local imports of changed files                                               | --            |
+| `--full`                  | Mutate full codebase, skipping confirmation prompt                                   | --            |
+| `--only-covered-lines`    | Skip mutations on uncovered lines                                                    | --            |
+| `--per-test-coverage`     | Run only tests that cover the mutated line                                           | --            |
+| `--coverage-file <path>`  | Path to Istanbul coverage JSON                                                       | auto-detected |
+| `--min-kill-percent <n>`  | Fail if kill rate is below threshold                                                 | --            |
+| `--progress <mode>`       | Display mode: `bar`, `list`, or `quiet`                                              | `bar`         |
+| `--timeout <ms>`          | Per-mutant test timeout                                                              | `30000`       |
+| `--report <format>`       | Output format: `text` or `json` (writes `mutineer-report.json`)                      | `text`        |
+| `--shard <n>/<total>`     | Run a slice of mutants (e.g. `--shard 1/4`)                                          | --            |
+| `--skip-baseline`         | Skip the baseline test run                                                           | --            |
+| `--vitest-project <name>` | Filter mutations to a specific Vitest workspace project (requires `test.projects`)   | --            |
+| `--typescript`            | Enable TypeScript type-check pre-filtering (skips mutants that cause compile errors) | auto          |
+| `--no-typescript`         | Disable TypeScript type-check pre-filtering                                          | --            |
 
 ### Examples
 
@@ -149,53 +152,55 @@ export default defineMutineerConfig({
 
 ### Config Options
 
-| Option              | Type                 | Description                                      |
-| ------------------- | -------------------- | ------------------------------------------------ |
-| `source`            | `string \| string[]` | Glob patterns for source files to mutate         |
-| `targets`           | `MutateTarget[]`     | Explicit list of files to mutate                 |
-| `runner`            | `'vitest' \| 'jest'` | Test runner to use                               |
-| `vitestConfig`      | `string`             | Path to vitest config                            |
-| `jestConfig`        | `string`             | Path to jest config                              |
-| `include`           | `string[]`           | Only run these mutators                          |
-| `exclude`           | `string[]`           | Skip these mutators                              |
-| `excludePaths`      | `string[]`           | Glob patterns for paths to skip                  |
-| `maxMutantsPerFile` | `number`             | Cap mutations per file                           |
-| `minKillPercent`    | `number`             | Fail if kill rate is below this                  |
-| `onlyCoveredLines`  | `boolean`            | Only mutate lines covered by tests               |
-| `perTestCoverage`   | `boolean`            | Use per-test coverage to select tests            |
-| `baseRef`           | `string`             | Git ref for `--changed` (default: `origin/main`) |
-| `testPatterns`      | `string[]`           | Globs for test file discovery                    |
-| `extensions`        | `string[]`           | File extensions to consider                      |
+| Option              | Type                               | Description                                                                  |
+| ------------------- | ---------------------------------- | ---------------------------------------------------------------------------- |
+| `source`            | `string \| string[]`               | Glob patterns for source files to mutate                                     |
+| `targets`           | `MutateTarget[]`                   | Explicit list of files to mutate                                             |
+| `runner`            | `'vitest' \| 'jest'`               | Test runner to use                                                           |
+| `vitestConfig`      | `string`                           | Path to vitest config                                                        |
+| `jestConfig`        | `string`                           | Path to jest config                                                          |
+| `include`           | `string[]`                         | Only run these mutators                                                      |
+| `exclude`           | `string[]`                         | Skip these mutators                                                          |
+| `excludePaths`      | `string[]`                         | Glob patterns for paths to skip                                              |
+| `maxMutantsPerFile` | `number`                           | Cap mutations per file                                                       |
+| `minKillPercent`    | `number`                           | Fail if kill rate is below this                                              |
+| `onlyCoveredLines`  | `boolean`                          | Only mutate lines covered by tests                                           |
+| `perTestCoverage`   | `boolean`                          | Use per-test coverage to select tests                                        |
+| `baseRef`           | `string`                           | Git ref for `--changed` (default: `origin/main`)                             |
+| `testPatterns`      | `string[]`                         | Globs for test file discovery                                                |
+| `extensions`        | `string[]`                         | File extensions to consider                                                  |
+| `vitestProject`     | `string \| string[]`               | Filter to a specific Vitest workspace project                                |
+| `typescript`        | `boolean \| { tsconfig?: string }` | Enable TS type-check pre-filtering; auto-detected if `tsconfig.json` present |
 
 ## Recommended Workflow
 
 Large repos can generate thousands of mutations. These strategies keep runs fast and incremental.
 
-When you run `mutineer run` without `--changed`, `--changed-with-deps`, or `--full` on an interactive terminal, mutineer warns you and lets you narrow scope before starting:
+When you run `mutineer run` without `--changed`, `--changed-with-imports`, or `--full` on an interactive terminal, mutineer warns you and lets you narrow scope before starting:
 
 ```
 Warning: Running on the full codebase may take a while.
 
   [1] Continue (full codebase)
   [2] --changed          (git-changed files only)
-  [3] --changed-with-deps (changed + their local deps)
+  [3] --changed-with-imports (changed + their local imports)
   [4] Abort
 ```
 
-### 1. PR-scoped runs (CI) — `--changed-with-deps`
+### 1. PR-scoped runs (CI) — `--changed-with-imports`
 
-Run only on files changed in the branch plus their direct dependents:
+Run only on files changed in the branch plus their local imports:
 
 ```bash
-mutineer run --changed-with-deps
+mutineer run --changed-with-imports
 ```
 
-- Tune the dependency graph depth with `dependencyDepth` in config (default: `1`)
+- Tune the import resolution depth with `importDepth` in config (default: `1`)
 - Add `--per-test-coverage` to only run tests that cover the mutated line
 - Recommended `package.json` script:
 
 ```json
-"mutineer:ci": "mutineer run --changed-with-deps --per-test-coverage"
+"mutineer:ci": "mutineer run --changed-with-imports --per-test-coverage"
 ```
 
 ### 2. Split configs by domain
@@ -215,7 +220,7 @@ Each config sets its own `source` glob and `minKillPercent`. Good for monorepos
 - Combine for maximum focus:
 
 ```bash
-mutineer run --changed-with-deps --only-covered-lines --per-test-coverage
+mutineer run --changed-with-imports --only-covered-lines --per-test-coverage
 ```
 
 ## File Support

package/dist/__tests__/index.spec.js

@@ -0,0 +1,8 @@
+import { describe, it, expect } from 'vitest';
+import { defineMutineerConfig } from '../index.js';
+describe('defineMutineerConfig', () => {
+    it('returns the config object unchanged', () => {
+        const cfg = { runner: 'vitest' };
+        expect(defineMutineerConfig(cfg)).toBe(cfg);
+    });
+});

package/dist/bin/__tests__/mutineer.spec.js

@@ -10,7 +10,7 @@ describe('HELP_TEXT', () => {
         '--runner',
         '--progress',
         '--changed',
-        '--changed-with-deps',
+        '--changed-with-imports',
         '--full',
         '--only-covered-lines',
         '--per-test-coverage',
@@ -29,8 +29,8 @@ describe('HELP_TEXT', () => {
         expect(HELP_TEXT).toContain('run');
         expect(HELP_TEXT).toContain('clean');
     });
-    it('--changed-with-deps description mentions local dependencies', () => {
-        expect(HELP_TEXT).toContain('local dependencies');
+    it('--changed-with-imports description mentions local imports', () => {
+        expect(HELP_TEXT).toContain('local imports');
     });
 });
 describe('confirmFullRun()', () => {
@@ -57,9 +57,9 @@ describe('confirmFullRun()', () => {
         const args = ['--changed', '--concurrency', '4'];
         expect(await confirmFullRun(args)).toBe(args);
     });
-    it('returns args unchanged when --changed-with-deps is present', async () => {
+    it('returns args unchanged when --changed-with-imports is present', async () => {
         mockTTY(true);
-        const args = ['--changed-with-deps'];
+        const args = ['--changed-with-imports'];
         expect(await confirmFullRun(args)).toBe(args);
     });
     it('returns args unchanged when --full is present, skipping prompt', async () => {
@@ -93,10 +93,10 @@ describe('confirmFullRun()', () => {
         mockReadline(['2']);
         expect(await confirmFullRun([])).toEqual(['--changed']);
     });
-    it('choice 3 appends --changed-with-deps', async () => {
+    it('choice 3 appends --changed-with-imports', async () => {
         mockTTY(true);
         mockReadline(['3']);
-        expect(await confirmFullRun([])).toEqual(['--changed-with-deps']);
+        expect(await confirmFullRun([])).toEqual(['--changed-with-imports']);
     });
     it('invalid input re-prompts, then accepts valid choice', async () => {
         mockTTY(true);

package/dist/bin/mutineer.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-export declare const HELP_TEXT = "Usage: mutineer <command> [options]\n\nCommands:\n  init       Create a mutineer.config.ts template\n  run        Run mutation testing\n  clean      Remove __mutineer__ temp directories\n\nOptions (run):\n  --config, -c <path>       Config file path\n  --concurrency <n>         Worker count (default: CPU count - 1)\n  --runner <vitest|jest>    Test runner (default: vitest)\n  --progress <bar|list|quiet>  Progress display (default: bar)\n  --changed                 Mutate only git-changed files\n  --changed-with-deps       Mutate changed files + their local dependencies\n  --full                    Mutate full codebase, skipping confirmation prompt\n  --only-covered-lines      Mutate only lines covered by tests\n  --per-test-coverage       Collect per-test coverage data\n  --coverage-file <path>    Path to coverage JSON\n  --min-kill-percent <n>    Minimum kill % threshold (0\u2013100)\n  --timeout <ms>            Per-mutant test timeout in ms (default: 30000)\n  --report <text|json>      Output format: text (default) or json (writes mutineer-report.json)\n  --shard <n>/<total>       Run a shard of mutants (e.g. --shard 1/4)\n  --skip-baseline           Skip the baseline test run\n\n  --help, -h                Show this help\n  --version, -V             Show version\n";
+export declare const HELP_TEXT = "Usage: mutineer <command> [options]\n\nCommands:\n  init       Create a mutineer.config.ts template\n  run        Run mutation testing\n  clean      Remove __mutineer__ temp directories\n\nOptions (run):\n  --config, -c <path>       Config file path\n  --concurrency <n>         Worker count (default: CPU count - 1)\n  --runner <vitest|jest>    Test runner (default: vitest)\n  --progress <bar|list|quiet>  Progress display (default: bar)\n  --changed                 Mutate only git-changed files\n  --changed-with-imports    Mutate changed files + their local imports\n  --full                    Mutate full codebase, skipping confirmation prompt\n  --only-covered-lines      Mutate only lines covered by tests\n  --per-test-coverage       Collect per-test coverage data\n  --coverage-file <path>    Path to coverage JSON\n  --min-kill-percent <n>    Minimum kill % threshold (0\u2013100)\n  --timeout <ms>            Per-mutant test timeout in ms (default: 30000)\n  --report <text|json>      Output format: text (default) or json (writes mutineer-report.json)\n  --shard <n>/<total>       Run a shard of mutants (e.g. --shard 1/4)\n  --skip-baseline           Skip the baseline test run\n  --vitest-project <name>   Filter to a specific Vitest workspace project\n  --typescript              Enable TS type-check pre-filtering\n  --no-typescript           Disable TS type-check pre-filtering\n\n  --help, -h                Show this help\n  --version, -V             Show version\n";
 export declare function getVersion(): string;
 /**
  * When running in full-codebase mode on an interactive TTY, warn the user and

package/dist/bin/mutineer.js

@@ -23,7 +23,7 @@ Options (run):
   --runner <vitest|jest>    Test runner (default: vitest)
   --progress <bar|list|quiet>  Progress display (default: bar)
   --changed                 Mutate only git-changed files
-  --changed-with-deps       Mutate changed files + their local dependencies
+  --changed-with-imports    Mutate changed files + their local imports
   --full                    Mutate full codebase, skipping confirmation prompt
   --only-covered-lines      Mutate only lines covered by tests
   --per-test-coverage       Collect per-test coverage data
@@ -33,6 +33,9 @@ Options (run):
   --report <text|json>      Output format: text (default) or json (writes mutineer-report.json)
   --shard <n>/<total>       Run a shard of mutants (e.g. --shard 1/4)
   --skip-baseline           Skip the baseline test run
+  --vitest-project <name>   Filter to a specific Vitest workspace project
+  --typescript              Enable TS type-check pre-filtering
+  --no-typescript           Disable TS type-check pre-filtering
 
   --help, -h                Show this help
   --version, -V             Show version
@@ -53,7 +56,7 @@ Warning: Running on the full codebase may take a while.
 
   [1] Continue (full codebase)
   [2] --changed          (git-changed files only)
-  [3] --changed-with-deps (changed + their local deps)
+  [3] --changed-with-imports (changed + their local imports)
   [4] Abort
 
 `;
@@ -62,7 +65,7 @@ Warning: Running on the full codebase may take a while.
  * let them narrow scope or abort. Returns args (possibly with a flag appended).
  */
 export async function confirmFullRun(args) {
-    const isFullRun = !args.includes('--changed') && !args.includes('--changed-with-deps');
+    const isFullRun = !args.includes('--changed') && !args.includes('--changed-with-imports');
     if (!isFullRun || !process.stdin.isTTY || args.includes('--full'))
         return args;
     process.stdout.write(FULL_RUN_WARNING);
@@ -84,7 +87,7 @@ export async function confirmFullRun(args) {
                 }
                 else if (choice === '3') {
                     rl.close();
-                    resolve([...args, '--changed-with-deps']);
+                    resolve([...args, '--changed-with-imports']);
                 }
                 else if (choice === '4') {
                     rl.close();

package/dist/core/__tests__/schemata.spec.js

@@ -162,4 +162,66 @@ describe('generateSchema', () => {
         expect(schemaCode).toContain("'f#0'");
         expect(schemaCode).toContain("'f#1'");
     });
+    it('finds the smallest enclosing expression when operator is nested inside a call', () => {
+        // CallExpression 'foo(x + y)' and BinaryExpression 'x + y' both contain the '+'
+        // offset. Walk visits outer (CallExpression) first — !best true — then inner
+        // (BinaryExpression) — !best false, span < best span — so best is updated to inner.
+        const original = 'foo(x + y)';
+        const { schemaCode, fallbackIds } = generateSchema(original, [
+            makeVariant('f#0', 'foo(x - y)'),
+        ]);
+        expect(fallbackIds.size).toBe(0);
+        expect(schemaCode).toContain('x - y');
+        expect(schemaCode).toContain('x + y');
+    });
+    it('handles sparse array elements (null entries in Babel AST arrays) without crashing', () => {
+        // '[1,,a+b]' produces an ArrayExpression with a null element for the elision.
+        // The walk must skip the null entry and still find the BinaryExpression 'a+b'.
+        const original = '[1,,a+b]';
+        const { schemaCode, fallbackIds } = generateSchema(original, [
+            makeVariant('f#0', '[1,,a-b]'),
+        ]);
+        expect(fallbackIds.size).toBe(0);
+        expect(schemaCode).toContain('a-b');
+        expect(schemaCode).toContain('a+b');
+    });
+    it('marks operator variant as fallback when original code cannot be parsed', () => {
+        // Unterminated brace causes Babel parse error → parseForSchema returns null
+        const original = 'const x = {';
+        const v = makeVariant('f#0', 'const x = |');
+        const { fallbackIds } = generateSchema(original, [v]);
+        expect(fallbackIds.has('f#0')).toBe(true);
+    });
+    it('marks operator variant as fallback when operator is inside a comment (no enclosing expression)', () => {
+        // parseForSchema succeeds but findSmallestEnclosingExpression returns null
+        // because position 3 is inside a comment, not any AST expression node
+        const original = '// +\nconst x = 1';
+        const v = makeVariant('f#0', '// -\nconst x = 1');
+        const { fallbackIds } = generateSchema(original, [v]);
+        expect(fallbackIds.has('f#0')).toBe(true);
+    });
+    it('marks outer site as fallback when inner site is fully contained within it', () => {
+        // '&&' maps to outer BinaryExpression [0,12]; '+' maps to inner 'b + c' [6,11]
+        // b.origEnd=11 <= a.origEnd=12 → outer marked fallback, inner kept
+        const original = 'a && (b + c)';
+        const vOuter = makeVariant('f#0', 'a || (b + c)'); // && → ||
+        const vInner = makeVariant('f#1', 'a && (b - c)'); // + → -
+        const { schemaCode, fallbackIds } = generateSchema(original, [
+            vOuter,
+            vInner,
+        ]);
+        expect(fallbackIds.has('f#0')).toBe(true);
+        expect(fallbackIds.has('f#1')).toBe(false);
+        expect(schemaCode).not.toContain("'f#0'");
+        expect(schemaCode).toContain("'f#1'");
+    });
+    it('marks both sites as fallback when they partially overlap', () => {
+        // Sites [0:3] and [2:5] partially overlap (neither fully contains the other)
+        const original = 'a>b>c';
+        const v0 = makeVariant('f#0', 'X>Y>c'); // changes [0:3] (a>b → X>Y)
+        const v1 = makeVariant('f#1', 'a>B>C'); // changes [2:5] (b>c → B>C)
+        const { fallbackIds } = generateSchema(original, [v0, v1]);
+        expect(fallbackIds.has('f#0')).toBe(true);
+        expect(fallbackIds.has('f#1')).toBe(true);
+    });
 });

package/dist/core/__tests__/sfc.spec.js

@@ -1,5 +1,13 @@
 import { describe, it, expect, vi } from 'vitest';
 import { mutateVueSfcScriptSetup } from '../sfc.js';
+// Allow individual tests to override getFilteredRegistry
+vi.mock('../variant-utils.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        getFilteredRegistry: vi.fn(actual.getFilteredRegistry),
+    };
+});
 // Mock @vue/compiler-sfc
 vi.mock('@vue/compiler-sfc', () => ({
     parse: (code, _opts) => {
@@ -66,9 +74,41 @@ describe('mutateVueSfcScriptSetup', () => {
             expect(v.name).toBe('andToOr');
         }
     });
+    it('uses apply() fallback when mutator has no applyWithContext', async () => {
+        const { getFilteredRegistry } = await import('../variant-utils.js');
+        const applyFn = vi.fn(() => [{ code: 'FALLBACK', line: 1, col: 0 }]);
+        vi.mocked(getFilteredRegistry).mockReturnValueOnce([
+            { name: 'noCtx', description: 'noCtx', apply: applyFn },
+        ]);
+        const code = '<script setup>\nconst x = 1\n</script>';
+        const result = await mutateVueSfcScriptSetup('test.vue', code);
+        expect(applyFn).toHaveBeenCalled();
+        expect(result.length).toBe(1);
+    });
+    it('deduplicates when two mutators produce the same full SFC output', async () => {
+        const { getFilteredRegistry } = await import('../variant-utils.js');
+        vi.mocked(getFilteredRegistry).mockReturnValueOnce([
+            {
+                name: 'A',
+                description: 'A',
+                apply: () => [{ code: 'SAME_OUTPUT', line: 1, col: 0 }],
+            },
+            {
+                name: 'B',
+                description: 'B',
+                apply: () => [{ code: 'SAME_OUTPUT', line: 1, col: 0 }],
+            },
+        ]);
+        const code = '<script setup>\nconst x = 1\n</script>';
+        const result = await mutateVueSfcScriptSetup('test.vue', code);
+        // Both mutators produce the same output; only one variant should exist
+        expect(result.length).toBe(1);
+    });
     it('filters mutators with exclude', async () => {
         const code = '<script setup>\nconst x = a && b\n</script>';
-        const result = await mutateVueSfcScriptSetup('test.vue', code, undefined, ['andToOr']);
+        const result = await mutateVueSfcScriptSetup('test.vue', code, undefined, [
+            'andToOr',
+        ]);
         for (const v of result) {
             expect(v.name).not.toBe('andToOr');
         }

package/dist/core/schemata.js

@@ -31,6 +31,15 @@ function findSingleDiff(original, mutated) {
     }
     return { origStart: start, origEnd, mutEnd };
 }
+const AST_SKIP_KEYS = new Set([
+    'type',
+    'start',
+    'end',
+    'loc',
+    'range',
+    'errors',
+    'operator', // skip operator — forces expansion to the full enclosing expression
+]);
 function escapeId(id) {
     return id.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
 }
@@ -62,13 +71,10 @@ function parseForSchema(code) {
 function findSmallestEnclosingExpression(root, offset) {
     let best = null;
     function walk(node) {
-        if (!node ||
-            typeof node.start !== 'number' ||
-            typeof node.end !== 'number') {
-            return;
-        }
+        // prune: offset is outside this node's span
         if (offset < node.start || offset >= node.end)
             return;
+        // track this node if it's an expression and smaller than current best
         if (t.isExpression(node)) {
             const span = node.end - node.start;
             if (!best || span < best.end - best.start) {
@@ -76,26 +82,19 @@ function findSmallestEnclosingExpression(root, offset) {
             }
         }
         for (const key of Object.keys(node)) {
-            if (key === 'type' ||
-                key === 'start' ||
-                key === 'end' ||
-                key === 'loc' ||
-                key === 'range' ||
-                key === 'errors' ||
-                key === 'operator') {
+            if (AST_SKIP_KEYS.has(key))
                 continue;
-            }
             const child = node[key];
             if (!child || typeof child !== 'object')
                 continue;
+            // recurse into child node arrays (e.g. function arguments)
             if (Array.isArray(child)) {
                 for (const item of child) {
-                    if (item &&
-                        typeof item === 'object' &&
-                        typeof item.start === 'number') {
+                    if (item && typeof item.start === 'number') {
                         walk(item);
                     }
                 }
+                // recurse into single child nodes (e.g. callee, left, right)
             }
             else if (typeof child.start === 'number') {
                 walk(child);
@@ -171,11 +170,6 @@ export function generateSchema(originalCode, variants) {
             // shorter by delta = mutEnd - origEnd. Adjust the slice end accordingly.
             const delta = mutEnd - origEnd;
             replacement = variant.code.slice(siteStart, siteEnd + delta);
-            // Sanity: if replacement equals original span, the mutation had no effect
-            if (replacement === originalCode.slice(siteStart, siteEnd)) {
-                fallbackIds.add(variant.id);
-                continue;
-            }
         }
         const key = `${siteStart}:${siteEnd}`;
         if (!siteMap.has(key)) {

package/dist/core/sfc.js

@@ -29,10 +29,6 @@ export async function mutateVueSfcScriptSetup(filename, code, include, exclude,
     const seenOutputs = new Set();
     const ctx = buildParseContext(originalBlock);
     for (const mutator of registry) {
-        // Early termination if limit reached
-        if (max !== undefined && variants.length >= max) {
-            break;
-        }
         const blockMutations = mutator.applyWithContext
             ? mutator.applyWithContext(originalBlock, ctx)
             : mutator.apply(originalBlock);

package/dist/core/variant-utils.js

@@ -20,10 +20,6 @@ export function generateMutationVariants(registry, code, opts = {}) {
     const seen = new Set();
     const ctx = buildParseContext(code);
     for (const mutator of registry) {
-        // Early termination if limit reached
-        if (max !== undefined && variants.length >= max) {
-            break;
-        }
         const mutations = mutator.applyWithContext
             ? mutator.applyWithContext(code, ctx)
             : mutator.apply(code);

package/dist/mutators/__tests__/utils.spec.js

@@ -1,8 +1,25 @@
 import { describe, it, expect } from 'vitest';
-import { collectOperatorTargets, collectOperatorTargetsFromContext, collectAllTargets, buildIgnoreLines, buildParseContext, parseSource, } from '../utils.js';
+import { collectOperatorTargets, collectOperatorTargetsFromContext, collectAllTargets, buildIgnoreLines, buildParseContext, parseSource, getVisualColumn, } from '../utils.js';
 // ---------------------------------------------------------------------------
 // buildIgnoreLines
 // ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// getVisualColumn
+// ---------------------------------------------------------------------------
+describe('getVisualColumn', () => {
+    it('returns 1 for offset at start of line', () => {
+        expect(getVisualColumn('abc', 0)).toBe(1);
+    });
+    it('advances to next tab stop for a tab character', () => {
+        // '\t' at column 0 (visualCol=1) advances to next stop: (floor(0/4)+1)*4+1 = 5
+        expect(getVisualColumn('\tx', 1)).toBe(5);
+    });
+    it('handles tab mid-line correctly', () => {
+        // 'ab\tc': charOffset=3 ('c'), linePrefix='ab\t'
+        // 'a' → visualCol=2, 'b' → 3, '\t' → nextStop=(floor(2/4)+1)*4+1=5 → visualCol=5
+        expect(getVisualColumn('ab\tc', 3)).toBe(5);
+    });
+});
 describe('buildIgnoreLines', () => {
     function comment(text, startLine, endLine = startLine) {
         return {
@@ -48,6 +65,19 @@ describe('buildIgnoreLines', () => {
         const lines = buildIgnoreLines([comment('just a normal comment', 1)]);
         expect(lines.size).toBe(0);
     });
+    it('skips comment with empty or whitespace-only text', () => {
+        const c = {
+            type: 'CommentLine',
+            value: '   ',
+            start: 0,
+            end: 0,
+            loc: {
+                start: { line: 1, column: 0, index: 0 },
+                end: { line: 1, column: 0, index: 0 },
+            },
+        };
+        expect(buildIgnoreLines([c]).size).toBe(0);
+    });
 });
 // ---------------------------------------------------------------------------
 // parseSource
@@ -63,6 +93,10 @@ describe('parseSource', () => {
         const ast = parseSource(`const x = 1`);
         expect(ast.type).toBe('File');
     });
+    it('falls back to Flow parser for Flow-specific nullable type syntax', () => {
+        // ?string is Flow syntax; Babel TS parser throws, falls back to Flow plugin
+        expect(() => parseSource('const x: ?string = null')).not.toThrow();
+    });
 });
 // ---------------------------------------------------------------------------
 // buildParseContext
@@ -142,6 +176,36 @@ describe('collectAllTargets', () => {
         const fromCtx = collectOperatorTargetsFromContext(src, ctx, '&&');
         expect(result.operatorTargets.get('&&')).toEqual(fromCtx);
     });
+    it('collects update expression targets', () => {
+        const src = `i++`;
+        const ctx = buildParseContext(src);
+        const result = collectAllTargets(src, ctx.ast, ctx.tokens, ctx.ignoreLines);
+        expect(result.updateTargets.size).toBeGreaterThan(0);
+    });
+    it('skips update expressions on ignored lines', () => {
+        const src = `// mutineer-disable-next-line\ni++`;
+        const ctx = buildParseContext(src);
+        const result = collectAllTargets(src, ctx.ast, ctx.tokens, ctx.ignoreLines);
+        expect(result.updateTargets.size).toBe(0);
+    });
+    it('collects assignment expression targets', () => {
+        const src = `i += 1`;
+        const ctx = buildParseContext(src);
+        const result = collectAllTargets(src, ctx.ast, ctx.tokens, ctx.ignoreLines);
+        expect(result.assignmentTargets.size).toBeGreaterThan(0);
+    });
+    it('skips assignment expressions on ignored lines', () => {
+        const src = `// mutineer-disable-next-line\ni += 1`;
+        const ctx = buildParseContext(src);
+        const result = collectAllTargets(src, ctx.ast, ctx.tokens, ctx.ignoreLines);
+        expect(result.assignmentTargets.size).toBe(0);
+    });
+    it('groups multiple assignment expressions of same operator together', () => {
+        const src = `i += 1; j += 2`;
+        const ctx = buildParseContext(src);
+        const result = collectAllTargets(src, ctx.ast, ctx.tokens, ctx.ignoreLines);
+        expect(result.assignmentTargets.get('+=')?.length).toBe(2);
+    });
 });
 // ---------------------------------------------------------------------------
 // collectOperatorTargets / collectOperatorTargetsFromContext