@mutineerjs/mutineer 0.7.0 → 0.9.0

package/dist/core/schemata.js

@@ -0,0 +1,236 @@
+import MagicString from 'magic-string';
+import { parse } from '@babel/parser';
+import * as t from '@babel/types';
+import { parserOptsTs } from '../mutators/utils.js';
+const isWordChar = (s, i) => i >= 0 && i < s.length && /[a-zA-Z0-9_]/.test(s[i]);
+function findSingleDiff(original, mutated) {
+    let start = 0;
+    const minLen = Math.min(original.length, mutated.length);
+    while (start < minLen && original[start] === mutated[start]) {
+        start++;
+    }
+    let origEnd = original.length;
+    let mutEnd = mutated.length;
+    while (origEnd > start &&
+        mutEnd > start &&
+        original[origEnd - 1] === mutated[mutEnd - 1]) {
+        origEnd--;
+        mutEnd--;
+    }
+    // Extend to word boundaries so we never produce partial-token ternary branches.
+    // e.g. 'true'→'false' has minimal diff 'tru'→'fals' (shared 'e' suffix), but
+    // 'tru' alone is not a valid expression — extend forward to include the 'e'.
+    while (start > 0 &&
+        isWordChar(original, start - 1) &&
+        isWordChar(original, start)) {
+        start--;
+    }
+    while (isWordChar(original, origEnd - 1) && isWordChar(original, origEnd)) {
+        origEnd++;
+        mutEnd++;
+    }
+    return { origStart: start, origEnd, mutEnd };
+}
+function escapeId(id) {
+    return id.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+/**
+ * Returns true if the string is usable as a standalone JS expression fragment.
+ * Operator-only strings (e.g. '+', '!', '===') are not valid standalone expressions
+ * and cannot appear as ternary branches in generated schema code.
+ */
+function isExpressionFragment(s) {
+    return /[a-zA-Z0-9_]/.test(s);
+}
+/**
+ * Parse source code for AST-based span detection.
+ * Returns null if parsing fails (e.g. syntax errors in the file).
+ */
+function parseForSchema(code) {
+    try {
+        return parse(code, { ...parserOptsTs, tokens: false });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Find the smallest AST Expression node whose span contains `offset`.
+ * Used to expand operator-only char diffs (e.g. '+') to the full enclosing
+ * expression (e.g. 'x + y') so the ternary branch is a valid JS expression.
+ */
+function findSmallestEnclosingExpression(root, offset) {
+    let best = null;
+    function walk(node) {
+        if (!node ||
+            typeof node.start !== 'number' ||
+            typeof node.end !== 'number') {
+            return;
+        }
+        if (offset < node.start || offset >= node.end)
+            return;
+        if (t.isExpression(node)) {
+            const span = node.end - node.start;
+            if (!best || span < best.end - best.start) {
+                best = { start: node.start, end: node.end };
+            }
+        }
+        for (const key of Object.keys(node)) {
+            if (key === 'type' ||
+                key === 'start' ||
+                key === 'end' ||
+                key === 'loc' ||
+                key === 'range' ||
+                key === 'errors' ||
+                key === 'operator') {
+                continue;
+            }
+            const child = node[key];
+            if (!child || typeof child !== 'object')
+                continue;
+            if (Array.isArray(child)) {
+                for (const item of child) {
+                    if (item &&
+                        typeof item === 'object' &&
+                        typeof item.start === 'number') {
+                        walk(item);
+                    }
+                }
+            }
+            else if (typeof child.start === 'number') {
+                walk(child);
+            }
+        }
+    }
+    walk(root);
+    return best;
+}
+/**
+ * Generate a schema file that embeds all mutation variants as a ternary chain.
+ *
+ * The schema uses `globalThis.__mutineer_active_id__` at call time to select
+ * which mutant is active, avoiding per-mutant module reloads.
+ *
+ * For value mutations (true→false, null→undefined), a character-level diff with
+ * word-boundary extension finds the span. For operator mutations (+→-, ===→!==),
+ * the Babel AST is used to find the enclosing expression (x + y, x === y) so
+ * the ternary branch is a valid JS expression.
+ *
+ * @param originalCode - The original source file contents
+ * @param variants - All variants to embed (must all be from the same source file)
+ * @returns schemaCode (the embedded schema) and fallbackIds (variants that
+ *   couldn't be embedded due to overlapping diff ranges or parse errors)
+ */
+export function generateSchema(originalCode, variants) {
+    const fallbackIds = new Set();
+    const siteMap = new Map();
+    // Lazily parsed AST — only needed for operator mutations
+    let ast = undefined;
+    function getAst() {
+        if (ast === undefined)
+            ast = parseForSchema(originalCode);
+        return ast;
+    }
+    for (const variant of variants) {
+        const { origStart, origEnd, mutEnd } = findSingleDiff(originalCode, variant.code);
+        // Skip variants with empty diffs (identical to original)
+        if (origStart >= origEnd && origStart >= mutEnd) {
+            fallbackIds.add(variant.id);
+            continue;
+        }
+        const origSpan = originalCode.slice(origStart, origEnd);
+        const repSpan = variant.code.slice(origStart, mutEnd);
+        let siteStart;
+        let siteEnd;
+        let replacement;
+        if (isExpressionFragment(origSpan) && isExpressionFragment(repSpan)) {
+            // Value mutation (true→false, null→undefined, 0→1 etc.): char diff is usable
+            siteStart = origStart;
+            siteEnd = origEnd;
+            replacement = repSpan;
+        }
+        else {
+            // Operator mutation (+→-, ===→!==, &&→|| etc.): char diff produces an
+            // operator-only span that isn't a valid standalone expression.
+            // Use the Babel AST to find the smallest enclosing Expression node
+            // (e.g. the BinaryExpression x + y) so the ternary branches are valid JS.
+            const parsedAst = getAst();
+            if (!parsedAst) {
+                fallbackIds.add(variant.id);
+                continue;
+            }
+            const enclosing = findSmallestEnclosingExpression(parsedAst, origStart);
+            if (!enclosing) {
+                fallbackIds.add(variant.id);
+                continue;
+            }
+            siteStart = enclosing.start;
+            siteEnd = enclosing.end;
+            // The enclosing node end is from the original AST. For variable-length
+            // operators (e.g. '>' → '>=', '+=' → '-='), the variant code is longer or
+            // 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)) {
+            siteMap.set(key, { origStart: siteStart, origEnd: siteEnd, variants: [] });
+        }
+        siteMap.get(key).variants.push({ id: variant.id, replacement });
+    }
+    const sites = Array.from(siteMap.values()).sort((a, b) => a.origStart - b.origStart);
+    // Detect overlapping sites.
+    // When one site is fully contained within another (nested expressions), keep
+    // the inner (smaller) site and mark the outer one as fallback. For partial
+    // overlaps, mark both as fallback.
+    const overlappingSiteKeys = new Set();
+    for (let i = 0; i < sites.length; i++) {
+        for (let j = i + 1; j < sites.length; j++) {
+            const a = sites[i];
+            const b = sites[j];
+            if (b.origStart >= a.origEnd)
+                break; // sorted by start, no further overlap
+            const keyA = `${a.origStart}:${a.origEnd}`;
+            const keyB = `${b.origStart}:${b.origEnd}`;
+            if (b.origEnd <= a.origEnd) {
+                // b fully contained within a → keep b (inner), mark a (outer) as fallback
+                overlappingSiteKeys.add(keyA);
+            }
+            else if (a.origStart === b.origStart) {
+                // Same start, b is larger → b contains a → mark b (outer) as fallback
+                overlappingSiteKeys.add(keyB);
+            }
+            else {
+                // Partial overlap → mark both as fallback
+                overlappingSiteKeys.add(keyA);
+                overlappingSiteKeys.add(keyB);
+            }
+        }
+    }
+    const s = new MagicString(originalCode);
+    // Apply sites in descending order to preserve character positions
+    const sortedDesc = [...sites].sort((a, b) => b.origStart - a.origStart);
+    for (const site of sortedDesc) {
+        const key = `${site.origStart}:${site.origEnd}`;
+        if (overlappingSiteKeys.has(key)) {
+            for (const v of site.variants)
+                fallbackIds.add(v.id);
+            continue;
+        }
+        const originalSpan = originalCode.slice(site.origStart, site.origEnd);
+        // Build ternary chain: iterate from last variant inward, wrapping originalSpan
+        let chain = originalSpan;
+        for (let i = site.variants.length - 1; i >= 0; i--) {
+            const v = site.variants[i];
+            chain = `(globalThis.__mutineer_active_id__ === '${escapeId(v.id)}' ? (${v.replacement}) : ${chain})`;
+        }
+        s.overwrite(site.origStart, site.origEnd, chain);
+    }
+    const schemaCode = `// @ts-nocheck\n` + s.toString();
+    return { schemaCode, fallbackIds };
+}

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

@@ -131,6 +131,14 @@ describe('parseCliOptions', () => {
         const opts = parseCliOptions(['--changed-with-deps'], emptyCfg);
         expect(opts.wantsChangedWithDeps).toBe(true);
     });
+    it('parses --full flag', () => {
+        const opts = parseCliOptions(['--full'], emptyCfg);
+        expect(opts.wantsFull).toBe(true);
+    });
+    it('wantsFull defaults to false', () => {
+        const opts = parseCliOptions([], emptyCfg);
+        expect(opts.wantsFull).toBe(false);
+    });
     it('parses --only-covered-lines flag', () => {
         const opts = parseCliOptions(['--only-covered-lines'], emptyCfg);
         expect(opts.wantsOnlyCoveredLines).toBe(true);
@@ -245,6 +253,38 @@ describe('parseCliOptions', () => {
         });
         expect(opts.reportFormat).toBe('json');
     });
+    it('parses --typescript flag', () => {
+        const opts = parseCliOptions(['--typescript'], emptyCfg);
+        expect(opts.typescriptCheck).toBe(true);
+    });
+    it('parses --no-typescript flag', () => {
+        const opts = parseCliOptions(['--no-typescript'], emptyCfg);
+        expect(opts.typescriptCheck).toBe(false);
+    });
+    it('defaults typescriptCheck to undefined', () => {
+        const opts = parseCliOptions([], emptyCfg);
+        expect(opts.typescriptCheck).toBeUndefined();
+    });
+    it('--typescript takes precedence over --no-typescript (first one wins)', () => {
+        const opts = parseCliOptions(['--typescript', '--no-typescript'], emptyCfg);
+        expect(opts.typescriptCheck).toBe(true);
+    });
+    it('parses --vitest-project flag', () => {
+        const opts = parseCliOptions(['--vitest-project', 'my-pkg'], emptyCfg);
+        expect(opts.vitestProject).toBe('my-pkg');
+    });
+    it('defaults vitestProject to undefined', () => {
+        const opts = parseCliOptions([], emptyCfg);
+        expect(opts.vitestProject).toBeUndefined();
+    });
+    it('parses --skip-baseline flag', () => {
+        const opts = parseCliOptions(['--skip-baseline'], emptyCfg);
+        expect(opts.skipBaseline).toBe(true);
+    });
+    it('defaults skipBaseline to false', () => {
+        const opts = parseCliOptions([], emptyCfg);
+        expect(opts.skipBaseline).toBe(false);
+    });
 });
 describe('validatePositiveMs', () => {
     it('returns undefined for undefined', () => {

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

@@ -18,6 +18,13 @@ describe('cleanupMutineerDirs', () => {
         await cleanupMutineerDirs(tmpDir);
         await expect(fs.access(mutDir)).rejects.toThrow();
     });
+    it('removes root-level __mutineer__ directory', async () => {
+        const rootMutDir = path.join(tmpDir, '__mutineer__');
+        await fs.mkdir(rootMutDir, { recursive: true });
+        await fs.writeFile(path.join(rootMutDir, 'setup.mjs'), 'content');
+        await cleanupMutineerDirs(tmpDir);
+        await expect(fs.access(rootMutDir)).rejects.toThrow();
+    });
     it('removes nested __mutineer__ directories', async () => {
         const dir1 = path.join(tmpDir, 'src', 'a', '__mutineer__');
         const dir2 = path.join(tmpDir, 'src', 'b', '__mutineer__');

package/dist/runner/__tests__/coverage-resolver.spec.js

@@ -8,6 +8,7 @@ function makeOpts(overrides = {}) {
         configPath: undefined,
         wantsChanged: false,
         wantsChangedWithDeps: false,
+        wantsFull: false,
         wantsOnlyCoveredLines: false,
         wantsPerTestCoverage: false,
         coverageFilePath: undefined,
@@ -18,6 +19,9 @@ function makeOpts(overrides = {}) {
         timeout: undefined,
         reportFormat: 'text',
         shard: undefined,
+        typescriptCheck: undefined,
+        vitestProject: undefined,
+        skipBaseline: false,
         ...overrides,
     };
 }

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

@@ -1,4 +1,14 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+const { mockLogDebug } = vi.hoisted(() => ({ mockLogDebug: vi.fn() }));
+vi.mock('../../utils/logger.js', () => ({
+    createLogger: () => ({
+        debug: mockLogDebug,
+        info: (...args) => console.log(...args),
+        warn: (...args) => console.warn(...args),
+        error: (...args) => console.error(...args),
+    }),
+    DEBUG: true,
+}));
 // Mock all heavy dependencies before importing orchestrator
 vi.mock('../config.js', () => ({
     loadMutineerConfig: vi.fn(),
@@ -46,6 +56,19 @@ vi.mock('../variants.js', () => ({
 vi.mock('../tasks.js', () => ({
     prepareTasks: vi.fn().mockReturnValue([]),
 }));
+vi.mock('../ts-checker.js', () => ({
+    checkTypes: vi.fn().mockResolvedValue(new Set()),
+    resolveTypescriptEnabled: vi.fn().mockReturnValue(false),
+    resolveTsconfigPath: vi.fn().mockReturnValue(undefined),
+}));
+vi.mock('../../core/schemata.js', () => ({
+    generateSchema: vi
+        .fn()
+        .mockReturnValue({
+        schemaCode: '// @ts-nocheck\n',
+        fallbackIds: new Set(),
+    }),
+}));
 import { runOrchestrator, parseMutantTimeoutMs } from '../orchestrator.js';
 import { loadMutineerConfig } from '../config.js';
 import { createVitestAdapter } from '../vitest/index.js';
@@ -54,6 +77,10 @@ import { listChangedFiles } from '../changed.js';
 import { executePool } from '../pool-executor.js';
 import { prepareTasks } from '../tasks.js';
 import { enumerateAllVariants } from '../variants.js';
+import { generateSchema } from '../../core/schemata.js';
+import os from 'node:os';
+import fssync from 'node:fs';
+import path from 'node:path';
 const mockAdapter = {
     name: 'vitest',
     init: vi.fn().mockResolvedValue(undefined),
@@ -246,18 +273,21 @@ describe('runOrchestrator timeout precedence', () => {
 describe('runOrchestrator shard filtering', () => {
     const targetFile = '/cwd/src/foo.ts';
     const testFile = '/cwd/src/__tests__/foo.spec.ts';
+    function makeVariant(id) {
+        return {
+            id,
+            name: 'flipEQ',
+            file: targetFile,
+            code: '',
+            line: 1,
+            col: 0,
+            tests: [testFile],
+        };
+    }
     function makeTask(key) {
         return {
             key,
-            v: {
-                id: `${key}`,
-                name: 'flipEQ',
-                file: targetFile,
-                code: '',
-                line: 1,
-                col: 0,
-                tests: [testFile],
-            },
+            v: makeVariant(key),
             tests: [testFile],
         };
     }
@@ -274,27 +304,27 @@ describe('runOrchestrator shard filtering', () => {
             directTestMap: new Map(),
         });
         vi.mocked(mockAdapter.runBaseline).mockResolvedValue(true);
-        // Return a non-empty variants array so orchestrator doesn't exit early
-        vi.mocked(enumerateAllVariants).mockResolvedValue([{}]);
-        const tasks = ['k0', 'k1', 'k2', 'k3'].map(makeTask);
-        vi.mocked(prepareTasks).mockReturnValue(tasks);
+        // Return 4 variants so shard filtering can split them across shards
+        vi.mocked(enumerateAllVariants).mockResolvedValue(['k0', 'k1', 'k2', 'k3'].map(makeVariant));
+        // Map each variant to a task by its id
+        vi.mocked(prepareTasks).mockImplementation((variants) => variants.map((v) => makeTask(v.id)));
     });
     afterEach(() => {
         process.exitCode = undefined;
     });
-    it('shard 1/2 assigns even-indexed tasks', async () => {
+    it('shard 1/2 assigns even-indexed variants', async () => {
         await runOrchestrator(['--shard', '1/2'], '/cwd');
         const call = vi.mocked(executePool).mock.calls[0][0];
         expect(call.tasks.map((t) => t.key)).toEqual(['k0', 'k2']);
     });
-    it('shard 2/2 assigns odd-indexed tasks', async () => {
+    it('shard 2/2 assigns odd-indexed variants', async () => {
         await runOrchestrator(['--shard', '2/2'], '/cwd');
         const call = vi.mocked(executePool).mock.calls[0][0];
         expect(call.tasks.map((t) => t.key)).toEqual(['k1', 'k3']);
     });
-    it('does not call executePool when shard has no tasks', async () => {
-        // Only 1 task total; shard 2/2 gets nothing
-        vi.mocked(prepareTasks).mockReturnValue([makeTask('only')]);
+    it('does not call executePool when shard has no variants', async () => {
+        // Only 1 variant total; shard 2/2 gets nothing
+        vi.mocked(enumerateAllVariants).mockResolvedValue([makeVariant('only')]);
         await runOrchestrator(['--shard', '2/2'], '/cwd');
         expect(executePool).not.toHaveBeenCalled();
     });
@@ -304,3 +334,138 @@ describe('runOrchestrator shard filtering', () => {
         expect(call.shard).toEqual({ index: 1, total: 4 });
     });
 });
+describe('runOrchestrator --skip-baseline', () => {
+    const targetFile = '/cwd/src/foo.ts';
+    const testFile = '/cwd/src/__tests__/foo.spec.ts';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        process.exitCode = undefined;
+        vi.mocked(createVitestAdapter).mockReturnValue(mockAdapter);
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [targetFile],
+            testMap: new Map([[targetFile, new Set([testFile])]]),
+            directTestMap: new Map(),
+        });
+    });
+    afterEach(() => {
+        process.exitCode = undefined;
+    });
+    it('does not call adapter.runBaseline when --skip-baseline is passed', async () => {
+        await runOrchestrator(['--skip-baseline'], '/cwd');
+        expect(mockAdapter.runBaseline).not.toHaveBeenCalled();
+    });
+    it('logs skip message when --skip-baseline is passed', async () => {
+        const consoleSpy = vi.spyOn(console, 'log');
+        await runOrchestrator(['--skip-baseline'], '/cwd');
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Skipping baseline tests (--skip-baseline)'));
+    });
+    it('still calls adapter.runBaseline when --skip-baseline is absent', async () => {
+        vi.mocked(mockAdapter.runBaseline).mockResolvedValue(true);
+        await runOrchestrator([], '/cwd');
+        expect(mockAdapter.runBaseline).toHaveBeenCalledOnce();
+    });
+});
+describe('runOrchestrator schema generation', () => {
+    let tmpDir;
+    const testFile = '/cwd/src/__tests__/foo.spec.ts';
+    beforeEach(() => {
+        tmpDir = fssync.mkdtempSync(path.join(os.tmpdir(), 'mutineer-orch-schema-'));
+        vi.clearAllMocks();
+        process.exitCode = undefined;
+        vi.mocked(createVitestAdapter).mockReturnValue(mockAdapter);
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        vi.mocked(mockAdapter.runBaseline).mockResolvedValue(true);
+    });
+    afterEach(() => {
+        process.exitCode = undefined;
+        fssync.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('calls generateSchema and passes fallbackIds to executePool', async () => {
+        const sourceFile = path.join(tmpDir, 'source.ts');
+        fssync.writeFileSync(sourceFile, 'const x = 1 + 2', 'utf8');
+        const variant = {
+            id: 'source.ts#0',
+            name: 'flipArith',
+            file: sourceFile,
+            code: 'const x = 1 - 2',
+            line: 1,
+            col: 10,
+            tests: [testFile],
+        };
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [sourceFile],
+            testMap: new Map([[sourceFile, new Set([testFile])]]),
+            directTestMap: new Map(),
+        });
+        vi.mocked(enumerateAllVariants).mockResolvedValue([variant]);
+        vi.mocked(prepareTasks).mockReturnValue([
+            {
+                key: 'schema-test-key',
+                v: variant,
+                tests: [testFile],
+            },
+        ]);
+        const mockFallbacks = new Set(['source.ts#0']);
+        vi.mocked(generateSchema).mockReturnValue({
+            schemaCode: '// @ts-nocheck\nconst x = 1',
+            fallbackIds: mockFallbacks,
+        });
+        await runOrchestrator([], tmpDir);
+        expect(generateSchema).toHaveBeenCalledWith(expect.any(String), [variant]);
+        const call = vi.mocked(executePool).mock.calls[0][0];
+        expect(call.fallbackIds).toStrictEqual(mockFallbacks);
+    });
+    it('treats all variants as fallback when source file read fails', async () => {
+        const missingFile = path.join(tmpDir, 'nonexistent.ts');
+        const variant = {
+            id: 'nonexistent.ts#0',
+            name: 'test',
+            file: missingFile,
+            code: 'x',
+            line: 1,
+            col: 0,
+            tests: [testFile],
+        };
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [missingFile],
+            testMap: new Map([[missingFile, new Set([testFile])]]),
+            directTestMap: new Map(),
+        });
+        vi.mocked(enumerateAllVariants).mockResolvedValue([variant]);
+        vi.mocked(prepareTasks).mockReturnValue([
+            { key: 'fallback-key', v: variant, tests: [testFile] },
+        ]);
+        await runOrchestrator([], tmpDir);
+        const call = vi.mocked(executePool).mock.calls[0][0];
+        expect(call.fallbackIds?.has('nonexistent.ts#0')).toBe(true);
+    });
+    it('logs embedded and fallback schema counts', async () => {
+        const sourceFile = path.join(tmpDir, 'source.ts');
+        fssync.writeFileSync(sourceFile, 'const x = 1 + 2', 'utf8');
+        const variant = {
+            id: 'source.ts#0',
+            name: 'flipArith',
+            file: sourceFile,
+            code: 'const x = 1 - 2',
+            line: 1,
+            col: 10,
+            tests: [testFile],
+        };
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [sourceFile],
+            testMap: new Map([[sourceFile, new Set([testFile])]]),
+            directTestMap: new Map(),
+        });
+        vi.mocked(enumerateAllVariants).mockResolvedValue([variant]);
+        vi.mocked(prepareTasks).mockReturnValue([
+            { key: 'log-test-key', v: variant, tests: [testFile] },
+        ]);
+        vi.mocked(generateSchema).mockReturnValue({
+            schemaCode: '// @ts-nocheck\n',
+            fallbackIds: new Set(),
+        });
+        await runOrchestrator([], tmpDir);
+        expect(mockLogDebug).toHaveBeenCalledWith(expect.stringMatching(/Schema: 1 embedded, 0 fallback/));
+    });
+});

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

@@ -407,6 +407,53 @@ describe('executePool', () => {
         });
         expect(cache['killed-covering-key'].coveringTests).toBeUndefined();
     });
+    it('sets isFallback=true when mutant id is in fallbackIds', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        const task = makeTask({ key: 'fb-key' });
+        const fallbackIds = new Set(['file.ts#0']);
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+            fallbackIds,
+        });
+        expect(adapter.runMutant).toHaveBeenCalledWith(expect.objectContaining({ isFallback: true }), expect.any(Array));
+    });
+    it('sets isFallback=false when mutant id is not in fallbackIds', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        const task = makeTask({ key: 'schema-key' });
+        const fallbackIds = new Set(); // empty — no fallbacks
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+            fallbackIds,
+        });
+        expect(adapter.runMutant).toHaveBeenCalledWith(expect.objectContaining({ isFallback: false }), expect.any(Array));
+    });
+    it('defaults isFallback=true when fallbackIds is not provided', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        const task = makeTask({ key: 'no-fallback-ids-key' });
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+            // no fallbackIds
+        });
+        expect(adapter.runMutant).toHaveBeenCalledWith(expect.objectContaining({ isFallback: true }), expect.any(Array));
+    });
     it('correctly stores snippets for multiple escaped mutants from the same file', async () => {
         const tmpFile = path.join(tmpDir, 'shared.ts');
         await fs.writeFile(tmpFile, 'const x = a + b\n');

package/dist/runner/__tests__/ts-checker.spec.d.ts

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