@mutineerjs/mutineer 0.9.0 → 0.11.0

package/dist/mutators/operator.js

@@ -6,6 +6,13 @@
  * replaced by its counterpart.
  */
 import { collectOperatorTargets, buildParseContext } from './utils.js';
+function targetsToOutputs(src, targets, toOp) {
+    return targets.map((target) => ({
+        line: target.line,
+        col: target.col1,
+        code: src.slice(0, target.start) + toOp + src.slice(target.end),
+    }));
+}
 /**
  * Factory to build an operator mutator using AST traversal and token analysis.
  *
@@ -15,21 +22,14 @@ import { collectOperatorTargets, buildParseContext } from './utils.js';
  * @param toOp - The operator to replace it with (e.g., '||')
  */
 function makeOperatorMutator(name, description, fromOp, toOp) {
-    function targetsToOutputs(src, targets) {
-        return targets.map((target) => ({
-            line: target.line,
-            col: target.col1,
-            code: src.slice(0, target.start) + toOp + src.slice(target.end),
-        }));
-    }
     return {
         name,
         description,
         apply(src) {
-            return targetsToOutputs(src, collectOperatorTargets(src, fromOp));
+            return targetsToOutputs(src, collectOperatorTargets(src, fromOp), toOp);
         },
         applyWithContext(src, ctx) {
-            return targetsToOutputs(src, ctx.preCollected.operatorTargets.get(fromOp) ?? []);
+            return targetsToOutputs(src, ctx.preCollected.operatorTargets.get(fromOp) ?? [], toOp);
         },
     };
 }
@@ -38,22 +38,15 @@ function makeOperatorMutator(name, description, fromOp, toOp) {
  * mapKey distinguishes prefix vs postfix: 'pre++', 'post++', 'pre--', 'post--'
  */
 function makeUpdateMutator(name, description, mapKey, toOp) {
-    function targetsToOutputs(src, targets) {
-        return targets.map((target) => ({
-            line: target.line,
-            col: target.col1,
-            code: src.slice(0, target.start) + toOp + src.slice(target.end),
-        }));
-    }
     return {
         name,
         description,
         apply(src) {
             const ctx = buildParseContext(src);
-            return targetsToOutputs(src, ctx.preCollected.updateTargets.get(mapKey) ?? []);
+            return targetsToOutputs(src, ctx.preCollected.updateTargets.get(mapKey) ?? [], toOp);
         },
         applyWithContext(src, ctx) {
-            return targetsToOutputs(src, ctx.preCollected.updateTargets.get(mapKey) ?? []);
+            return targetsToOutputs(src, ctx.preCollected.updateTargets.get(mapKey) ?? [], toOp);
         },
     };
 }
@@ -61,22 +54,15 @@ function makeUpdateMutator(name, description, mapKey, toOp) {
  * Factory for AssignmentExpression mutators (+=, -=, *=, /=).
  */
 function makeAssignmentMutator(name, description, fromOp, toOp) {
-    function targetsToOutputs(src, targets) {
-        return targets.map((target) => ({
-            line: target.line,
-            col: target.col1,
-            code: src.slice(0, target.start) + toOp + src.slice(target.end),
-        }));
-    }
     return {
         name,
         description,
         apply(src) {
             const ctx = buildParseContext(src);
-            return targetsToOutputs(src, ctx.preCollected.assignmentTargets.get(fromOp) ?? []);
+            return targetsToOutputs(src, ctx.preCollected.assignmentTargets.get(fromOp) ?? [], toOp);
         },
         applyWithContext(src, ctx) {
-            return targetsToOutputs(src, ctx.preCollected.assignmentTargets.get(fromOp) ?? []);
+            return targetsToOutputs(src, ctx.preCollected.assignmentTargets.get(fromOp) ?? [], toOp);
         },
     };
 }

package/dist/mutators/return-value.js

@@ -27,9 +27,7 @@ function collectReturnMutations(src, ast, ignoreLines, replacer) {
             const node = path.node;
             if (!node.argument)
                 return; // bare return; — nothing to replace
-            const line = node.loc?.start.line;
-            if (line === undefined)
-                return;
+            const line = node.loc.start.line;
             if (ignoreLines.has(line))
                 return;
             const replacement = replacer(node.argument);
@@ -37,9 +35,7 @@ function collectReturnMutations(src, ast, ignoreLines, replacer) {
                 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 col = getVisualColumn(src, node.start);
             const code = src.slice(0, argStart) + replacement + src.slice(argEnd);
             outputs.push({ line, col, code });
         },
@@ -53,7 +49,7 @@ function makeReturnMutator(name, description, replacer) {
         apply(src) {
             const ast = parseSource(src);
             const fileAst = ast;
-            const ignoreLines = buildIgnoreLines(fileAst.comments ?? []);
+            const ignoreLines = buildIgnoreLines(fileAst.comments);
             return collectReturnMutations(src, ast, ignoreLines, replacer);
         },
         applyWithContext(src, ctx) {

package/dist/mutators/utils.d.ts

@@ -112,9 +112,9 @@ export declare function collectAllTargets(src: string, ast: t.File & {
 export declare function buildParseContext(src: string): ParseContext;
 /**
  * Collect operator targets from a pre-built ParseContext.
- * Avoids re-parsing; use when processing multiple operators on the same source.
+ * Reads directly from preCollected targets; no additional traversal needed.
  */
-export declare function collectOperatorTargetsFromContext(src: string, ctx: ParseContext, opValue: string): OperatorTarget[];
+export declare function collectOperatorTargetsFromContext(_src: string, ctx: ParseContext, opValue: string): OperatorTarget[];
 /**
  * Collect the operator tokens for a given operator and return their exact locations.
  * Uses AST traversal to find BinaryExpression/LogicalExpression nodes, then maps them

package/dist/mutators/utils.js

@@ -131,77 +131,71 @@ export function collectAllTargets(src, ast, tokens, ignoreLines) {
     const updateTargets = new Map();
     const assignmentTargets = new Map();
     function handleBinaryOrLogical(n) {
-        const nodeStart = n.start ?? 0;
-        const nodeEnd = n.end ?? 0;
+        const nodeStart = n.start;
+        const nodeEnd = n.end;
         const opValue = n.operator;
         const tok = tokens.find((tk) => tk.start >= nodeStart && tk.end <= nodeEnd && tk.value === opValue);
-        if (tok) {
-            const line = tok.loc.start.line;
-            if (ignoreLines.has(line))
-                return;
-            const visualCol = getVisualColumn(src, tok.start);
-            let arr = operatorTargets.get(opValue);
-            if (!arr) {
-                arr = [];
-                operatorTargets.set(opValue, arr);
-            }
-            arr.push({
-                start: tok.start,
-                end: tok.end,
-                line,
-                col1: visualCol,
-                op: opValue,
-            });
+        const line = tok.loc.start.line;
+        if (ignoreLines.has(line))
+            return;
+        const visualCol = getVisualColumn(src, tok.start);
+        let arr = operatorTargets.get(opValue);
+        if (!arr) {
+            arr = [];
+            operatorTargets.set(opValue, arr);
         }
+        arr.push({
+            start: tok.start,
+            end: tok.end,
+            line,
+            col1: visualCol,
+            op: opValue,
+        });
     }
     function handleUpdate(n) {
-        const nodeStart = n.start ?? 0;
-        const nodeEnd = n.end ?? 0;
+        const nodeStart = n.start;
+        const nodeEnd = n.end;
         const opValue = n.operator;
         const tok = tokens.find((tk) => tk.start >= nodeStart && tk.end <= nodeEnd && tk.value === opValue);
-        if (tok) {
-            const line = tok.loc.start.line;
-            if (ignoreLines.has(line))
-                return;
-            const visualCol = getVisualColumn(src, tok.start);
-            const mapKey = (n.prefix ? 'pre' : 'post') + opValue;
-            let arr = updateTargets.get(mapKey);
-            if (!arr) {
-                arr = [];
-                updateTargets.set(mapKey, arr);
-            }
-            arr.push({
-                start: tok.start,
-                end: tok.end,
-                line,
-                col1: visualCol,
-                op: opValue,
-            });
+        const line = tok.loc.start.line;
+        if (ignoreLines.has(line))
+            return;
+        const visualCol = getVisualColumn(src, tok.start);
+        const mapKey = (n.prefix ? 'pre' : 'post') + opValue;
+        let arr = updateTargets.get(mapKey);
+        if (!arr) {
+            arr = [];
+            updateTargets.set(mapKey, arr);
         }
+        arr.push({
+            start: tok.start,
+            end: tok.end,
+            line,
+            col1: visualCol,
+            op: opValue,
+        });
     }
     function handleAssignment(n) {
-        const nodeStart = n.start ?? 0;
-        const nodeEnd = n.end ?? 0;
+        const nodeStart = n.start;
+        const nodeEnd = n.end;
         const opValue = n.operator;
         const tok = tokens.find((tk) => tk.start >= nodeStart && tk.end <= nodeEnd && tk.value === opValue);
-        if (tok) {
-            const line = tok.loc.start.line;
-            if (ignoreLines.has(line))
-                return;
-            const visualCol = getVisualColumn(src, tok.start);
-            let arr = assignmentTargets.get(opValue);
-            if (!arr) {
-                arr = [];
-                assignmentTargets.set(opValue, arr);
-            }
-            arr.push({
-                start: tok.start,
-                end: tok.end,
-                line,
-                col1: visualCol,
-                op: opValue,
-            });
+        const line = tok.loc.start.line;
+        if (ignoreLines.has(line))
+            return;
+        const visualCol = getVisualColumn(src, tok.start);
+        let arr = assignmentTargets.get(opValue);
+        if (!arr) {
+            arr = [];
+            assignmentTargets.set(opValue, arr);
         }
+        arr.push({
+            start: tok.start,
+            end: tok.end,
+            line,
+            col1: visualCol,
+            op: opValue,
+        });
     }
     traverse(ast, {
         BinaryExpression(p) {
@@ -220,16 +214,12 @@ export function collectAllTargets(src, ast, tokens, ignoreLines) {
             const node = p.node;
             if (!node.argument)
                 return;
-            const line = node.loc?.start.line;
-            if (line === undefined)
-                return;
+            const line = node.loc.start.line;
             if (ignoreLines.has(line))
                 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 col = getVisualColumn(src, node.start);
             returnStatements.push({
                 line,
                 col,
@@ -247,44 +237,17 @@ export function collectAllTargets(src, ast, tokens, ignoreLines) {
  */
 export function buildParseContext(src) {
     const ast = parseSource(src);
-    const tokens = ast.tokens ?? [];
-    const ignoreLines = buildIgnoreLines(ast.comments ?? []);
+    const tokens = ast.tokens;
+    const ignoreLines = buildIgnoreLines(ast.comments);
     const preCollected = collectAllTargets(src, ast, tokens, ignoreLines);
     return { ast, tokens, ignoreLines, preCollected };
 }
 /**
  * Collect operator targets from a pre-built ParseContext.
- * Avoids re-parsing; use when processing multiple operators on the same source.
+ * Reads directly from preCollected targets; no additional traversal needed.
  */
-export function collectOperatorTargetsFromContext(src, ctx, opValue) {
-    const { ast, tokens, ignoreLines } = ctx;
-    const out = [];
-    traverse(ast, {
-        enter(p) {
-            if (!isBinaryOrLogical(p.node))
-                return;
-            const n = p.node;
-            if (n.operator !== opValue)
-                return;
-            const nodeStart = n.start ?? 0;
-            const nodeEnd = n.end ?? 0;
-            const tok = tokens.find((tk) => tk.start >= nodeStart && tk.end <= nodeEnd && tk.value === opValue);
-            if (tok) {
-                const line = tok.loc.start.line;
-                if (ignoreLines.has(line))
-                    return;
-                const visualCol = getVisualColumn(src, tok.start);
-                out.push({
-                    start: tok.start,
-                    end: tok.end,
-                    line,
-                    col1: visualCol,
-                    op: opValue,
-                });
-            }
-        },
-    });
-    return out;
+export function collectOperatorTargetsFromContext(_src, ctx, opValue) {
+    return ctx.preCollected.operatorTargets.get(opValue) ?? [];
 }
 /**
  * Collect the operator tokens for a given operator and return their exact locations.

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

@@ -102,6 +102,10 @@ describe('parseConcurrency', () => {
         const result = parseConcurrency(['--concurrency', 'abc']);
         expect(result).toBeGreaterThanOrEqual(1);
     });
+    it('handles --concurrency flag with no following value', () => {
+        const result = parseConcurrency(['--concurrency']);
+        expect(result).toBeGreaterThanOrEqual(1);
+    });
 });
 describe('parseProgressMode', () => {
     it('returns bar by default', () => {
@@ -125,11 +129,11 @@ describe('parseCliOptions', () => {
     it('parses --changed flag', () => {
         const opts = parseCliOptions(['--changed'], emptyCfg);
         expect(opts.wantsChanged).toBe(true);
-        expect(opts.wantsChangedWithDeps).toBe(false);
+        expect(opts.wantsChangedWithImports).toBe(false);
     });
-    it('parses --changed-with-deps flag', () => {
-        const opts = parseCliOptions(['--changed-with-deps'], emptyCfg);
-        expect(opts.wantsChangedWithDeps).toBe(true);
+    it('parses --changed-with-imports flag', () => {
+        const opts = parseCliOptions(['--changed-with-imports'], emptyCfg);
+        expect(opts.wantsChangedWithImports).toBe(true);
     });
     it('parses --full flag', () => {
         const opts = parseCliOptions(['--full'], emptyCfg);

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

@@ -137,6 +137,13 @@ describe('decodeCacheKey', () => {
         expect(decoded.line).toBe(10);
         expect(decoded.col).toBe(5);
     });
+    it('falls back to full key when file segment is empty', () => {
+        // a:b::1,0:mutator → after parsing, restAfterFirst.slice(secondColon+1) = '' → falls back to key
+        const key = 'a:b::1,0:mutator';
+        const decoded = decodeCacheKey(key);
+        expect(decoded.file).toBe(key);
+        expect(decoded.mutator).toBe('mutator');
+    });
 });
 describe('keyForTests', () => {
     it('produces deterministic keys regardless of input order', () => {
@@ -220,6 +227,23 @@ describe('readMutantCache', () => {
         const result = await readMutantCache(tmpDir);
         expect(result).toEqual({});
     });
+    it('skips object-format entries without a status field', async () => {
+        const cache = {
+            'testsig:codesig:file.ts:1,0:flip': { someOtherField: 'foo' },
+        };
+        await fs.writeFile(path.join(tmpDir, '.mutineer-cache.json'), JSON.stringify(cache));
+        const result = await readMutantCache(tmpDir);
+        // Entry has no status, so it is skipped entirely
+        expect(result['testsig:codesig:file.ts:1,0:flip']).toBeUndefined();
+    });
+    it('defaults status to skipped when status is null in object entry', async () => {
+        const cache = {
+            'testsig:codesig:file.ts:1,0:flip': { status: null },
+        };
+        await fs.writeFile(path.join(tmpDir, '.mutineer-cache.json'), JSON.stringify(cache));
+        const result = await readMutantCache(tmpDir);
+        expect(result['testsig:codesig:file.ts:1,0:flip'].status).toBe('skipped');
+    });
     it('normalizes partial object entries with decoded fallbacks', async () => {
         const cache = {
             'testsig:codesig:file.ts:5,3:mut': {

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

@@ -274,6 +274,24 @@ describe('listChangedFiles', () => {
         const result = listChangedFiles('/repo', { includeDeps: true });
         expect(result).toContain('/repo/src/foo.ts');
     });
+    it('handles readFileSync throwing during dep resolution', () => {
+        spawnSyncMock.mockImplementation((_cmd, args) => {
+            if (args.includes('--show-toplevel')) {
+                return { status: 0, stdout: '/repo\n' };
+            }
+            if (args.includes('main...HEAD')) {
+                return { status: 0, stdout: 'src/foo.ts\0' };
+            }
+            return { status: 0, stdout: '' };
+        });
+        // existsSync always returns true so we get past the existsSync check in resolveLocalDeps
+        existsSyncMock.mockReturnValue(true);
+        readFileSyncMock.mockImplementation(() => {
+            throw new Error('ENOENT');
+        });
+        const result = listChangedFiles('/repo', { includeDeps: true });
+        expect(result).toContain('/repo/src/foo.ts');
+    });
     it('respects maxDepth option', () => {
         spawnSyncMock.mockImplementation((_cmd, args) => {
             if (args.includes('--show-toplevel')) {
@@ -292,6 +310,63 @@ describe('listChangedFiles', () => {
         // maxDepth=0 means no recursion into deps
         expect(result).toContain('/repo/src/foo.ts');
     });
+    it('logs warning when no git repo found and quiet is not set', () => {
+        spawnSyncMock.mockReturnValue({ status: 1, stdout: '' });
+        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const result = listChangedFiles('/not-a-repo');
+        expect(result).toEqual([]);
+        expect(warnSpy).toHaveBeenCalled();
+        warnSpy.mockRestore();
+    });
+    it('handles circular dependencies without infinite recursion', () => {
+        spawnSyncMock.mockImplementation((_cmd, args) => {
+            if (args.includes('--show-toplevel'))
+                return { status: 0, stdout: '/repo\n' };
+            if (args.includes('main...HEAD'))
+                return { status: 0, stdout: 'src/a.ts\0' };
+            return { status: 0, stdout: '' };
+        });
+        readFileSyncMock.mockImplementation((p) => {
+            if (p === '/repo/src/a.ts')
+                return 'import { b } from "./b"';
+            if (p === '/repo/src/b.ts')
+                return 'import { a } from "./a"';
+            return '';
+        });
+        existsSyncMock.mockImplementation((p) => ['/repo/src/a.ts', '/repo/src/b.ts'].includes(p));
+        const result = listChangedFiles('/repo', { includeDeps: true, maxDepth: 3 });
+        expect(result).toContain('/repo/src/a.ts');
+        expect(result).toContain('/repo/src/b.ts');
+    });
+    it('skips test file dependencies', () => {
+        spawnSyncMock.mockImplementation((_cmd, args) => {
+            if (args.includes('--show-toplevel'))
+                return { status: 0, stdout: '/repo\n' };
+            if (args.includes('main...HEAD'))
+                return { status: 0, stdout: 'src/a.ts\0' };
+            return { status: 0, stdout: '' };
+        });
+        readFileSyncMock.mockReturnValue('import { x } from "./a.spec"');
+        existsSyncMock.mockImplementation((p) => ['/repo/src/a.ts', '/repo/src/a.spec.ts'].includes(p));
+        const result = listChangedFiles('/repo', { includeDeps: true });
+        expect(result).not.toContain('/repo/src/a.spec.ts');
+    });
+    it('handles absolute paths returned by git', () => {
+        // The code strips one leading slash via replace(/^\.?\//,'').
+        // A double-slash path like '//repo/src/abs.ts' still resolves as absolute after that strip.
+        spawnSyncMock.mockImplementation((_cmd, args) => {
+            if (args.includes('--show-toplevel')) {
+                return { status: 0, stdout: '/repo\n' };
+            }
+            if (args.includes('main...HEAD')) {
+                return { status: 0, stdout: '//repo/src/abs.ts\0' };
+            }
+            return { status: 0, stdout: '' };
+        });
+        existsSyncMock.mockImplementation((p) => p === '/repo/src/abs.ts');
+        const result = listChangedFiles('/repo');
+        expect(result).toContain('/repo/src/abs.ts');
+    });
     it('only processes source files for dependency resolution', () => {
         spawnSyncMock.mockImplementation((_cmd, args) => {
             if (args.includes('--show-toplevel')) {

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

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
@@ -57,4 +57,53 @@ describe('loadMutineerConfig', () => {
         await fs.writeFile(configFile, 'export default null');
         await expect(loadMutineerConfig(tmpDir)).rejects.toThrow('does not export a valid configuration object');
     });
+    it('loads a .ts config file via vite', async () => {
+        const configFile = path.join(tmpDir, 'mutineer.config.ts');
+        await fs.writeFile(configFile, 'export default { runner: "vitest" }\n');
+        const config = await loadMutineerConfig(tmpDir);
+        expect(config).toEqual({ runner: 'vitest' });
+    });
+    it('throws with helpful message when TypeScript config fails to load', async () => {
+        vi.doMock('vite', () => ({
+            loadConfigFromFile: vi
+                .fn()
+                .mockRejectedValue(new Error('vite not available')),
+        }));
+        vi.resetModules();
+        const { loadMutineerConfig: loadConfig } = await import('../config.js');
+        const configFile = path.join(tmpDir, 'mutineer.config.ts');
+        await fs.writeFile(configFile, 'export default { runner: "vitest" }');
+        await expect(loadConfig(tmpDir)).rejects.toThrow('Cannot load TypeScript config');
+        vi.doUnmock('vite');
+    });
+    it('loads a module with named exports only (no default export)', async () => {
+        const configFile = path.join(tmpDir, 'mutineer.config.mjs');
+        // No `export default` — exercises the `mod` fallback in loadModule
+        await fs.writeFile(configFile, 'export const runner = "vitest"');
+        const config = await loadMutineerConfig(tmpDir);
+        expect(config.runner).toBe('vitest');
+    });
+    it('returns empty config when Vite loadConfigFromFile returns null', async () => {
+        vi.doMock('vite', () => ({
+            loadConfigFromFile: vi.fn().mockResolvedValue(null),
+        }));
+        vi.resetModules();
+        const { loadMutineerConfig: loadConfig } = await import('../config.js');
+        const configFile = path.join(tmpDir, 'mutineer.config.ts');
+        await fs.writeFile(configFile, 'export default {}');
+        const config = await loadConfig(tmpDir);
+        expect(config).toEqual({});
+        vi.doUnmock('vite');
+    });
+    it('stringifies non-Error thrown by loadConfigFromFile', async () => {
+        vi.doMock('vite', () => ({
+            loadConfigFromFile: vi.fn().mockRejectedValue('plain string error'),
+        }));
+        vi.resetModules();
+        const { loadMutineerConfig: loadConfig } = await import('../config.js');
+        const configFile = path.join(tmpDir, 'mutineer.config.ts');
+        await fs.writeFile(configFile, 'export default {}');
+        await expect(loadConfig(tmpDir)).rejects.toThrow('plain string error');
+        vi.doUnmock('vite');
+    });
 });

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

@@ -7,7 +7,7 @@ function makeOpts(overrides = {}) {
     return {
         configPath: undefined,
         wantsChanged: false,
-        wantsChangedWithDeps: false,
+        wantsChangedWithImports: false,
         wantsFull: false,
         wantsOnlyCoveredLines: false,
         wantsPerTestCoverage: false,
@@ -112,6 +112,59 @@ describe('resolveCoverageConfig', () => {
         expect(result.needsCoverageFromBaseline).toBe(true);
         expect(result.enableCoverageForBaseline).toBe(true);
     });
+    it('loads coverage data when coverageFilePath is provided', async () => {
+        const coverageJson = {
+            '/src/foo.ts': {
+                path: '/src/foo.ts',
+                statementMap: {
+                    '0': { start: { line: 1, column: 0 }, end: { line: 1, column: 10 } },
+                },
+                s: { '0': 1 },
+            },
+        };
+        const covDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-cov-file-'));
+        const covFile = path.join(covDir, 'coverage-final.json');
+        await fs.writeFile(covFile, JSON.stringify(coverageJson));
+        try {
+            const opts = makeOpts({ coverageFilePath: covFile });
+            const result = await resolveCoverageConfig(opts, {}, makeAdapter(), []);
+            expect(result.coverageData).not.toBeNull();
+            expect(result.coverageData.coveredLines.size).toBeGreaterThan(0);
+        }
+        finally {
+            await fs.rm(covDir, { recursive: true, force: true });
+        }
+    });
+    it('logs warning when onlyCoveredLines + coverageData + no coverage provider', async () => {
+        const coverageJson = {
+            '/src/foo.ts': {
+                path: '/src/foo.ts',
+                statementMap: {
+                    '0': { start: { line: 1, column: 0 }, end: { line: 1, column: 10 } },
+                },
+                s: { '0': 1 },
+            },
+        };
+        const covDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-cov-warn-'));
+        const covFile = path.join(covDir, 'coverage-final.json');
+        await fs.writeFile(covFile, JSON.stringify(coverageJson));
+        try {
+            const opts = makeOpts({
+                wantsOnlyCoveredLines: true,
+                coverageFilePath: covFile,
+            });
+            const adapter = makeAdapter({
+                hasCoverageProvider: vi.fn().mockReturnValue(false),
+            });
+            const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+            await resolveCoverageConfig(opts, {}, adapter, []);
+            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('onlyCoveredLines'));
+            warnSpy.mockRestore();
+        }
+        finally {
+            await fs.rm(covDir, { recursive: true, force: true });
+        }
+    });
 });
 describe('loadCoverageAfterBaseline', () => {
     let tmpDir;
@@ -179,4 +232,38 @@ describe('loadCoverageAfterBaseline', () => {
         const result = await loadCoverageAfterBaseline(resolution, tmpDir);
         expect(result.perTestCoverage).toBeNull();
     });
+    it('loads per-test coverage when wantsPerTestCoverage is true', async () => {
+        const coverageDir = path.join(tmpDir, 'coverage');
+        await fs.mkdir(coverageDir, { recursive: true });
+        const testFile = '/test/foo.spec.ts';
+        const srcFile = '/src/foo.ts';
+        const perTestData = {
+            [testFile]: { [srcFile]: [1, 2, 3] },
+        };
+        await fs.writeFile(path.join(coverageDir, 'per-test-coverage.json'), JSON.stringify(perTestData));
+        const resolution = {
+            coverageData: null,
+            perTestCoverage: null,
+            enableCoverageForBaseline: true,
+            wantsPerTestCoverage: true,
+            needsCoverageFromBaseline: false,
+        };
+        const result = await loadCoverageAfterBaseline(resolution, tmpDir);
+        expect(result.perTestCoverage).not.toBeNull();
+        expect(result.perTestCoverage.size).toBeGreaterThan(0);
+    });
+    it('logs warning when per-test coverage data is not found', async () => {
+        const resolution = {
+            coverageData: null,
+            perTestCoverage: null,
+            enableCoverageForBaseline: true,
+            wantsPerTestCoverage: true,
+            needsCoverageFromBaseline: false,
+        };
+        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const result = await loadCoverageAfterBaseline(resolution, tmpDir);
+        expect(result.perTestCoverage).toBeNull();
+        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Per-test coverage data not found'));
+        warnSpy.mockRestore();
+    });
 });