@mutineerjs/mutineer 0.2.3 → 0.2.4

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

@@ -1,6 +1,69 @@
 import { describe, it, expect } from 'vitest';
-describe('Module', () => {
-    it('should pass a basic test', () => {
-        expect(true).toBe(true);
+import { mutateModuleSource } from '../module.js';
+describe('mutateModuleSource', () => {
+    it('returns empty array for code with no mutable patterns', () => {
+        const result = mutateModuleSource('const x = 1');
+        expect(result).toEqual([]);
+    });
+    it('generates mutations for equality operators', () => {
+        const code = 'if (a === b) {}';
+        const result = mutateModuleSource(code);
+        expect(result.length).toBeGreaterThan(0);
+        expect(result.some((v) => v.name === 'flipStrictEQ')).toBe(true);
+    });
+    it('generates mutations for logical operators', () => {
+        const code = 'const x = a && b';
+        const result = mutateModuleSource(code);
+        expect(result.some((v) => v.name === 'andToOr')).toBe(true);
+    });
+    it('generates mutations for arithmetic operators', () => {
+        const code = 'const x = a + b';
+        const result = mutateModuleSource(code);
+        expect(result.some((v) => v.name === 'addToSub')).toBe(true);
+    });
+    it('deduplicates identical mutations', () => {
+        const code = 'if (a === b) {}';
+        const result = mutateModuleSource(code);
+        const codes = result.map((v) => v.code);
+        expect(new Set(codes).size).toBe(codes.length);
+    });
+    it('respects include filter', () => {
+        const code = 'if (a === b && c || d) {}';
+        const result = mutateModuleSource(code, ['andToOr']);
+        expect(result.every((v) => v.name === 'andToOr')).toBe(true);
+    });
+    it('respects exclude filter', () => {
+        const code = 'if (a === b && c || d) {}';
+        const result = mutateModuleSource(code, undefined, ['flipStrictEQ']);
+        expect(result.every((v) => v.name !== 'flipStrictEQ')).toBe(true);
+    });
+    it('respects max limit', () => {
+        const code = 'if (a === b && c || d) {}';
+        const all = mutateModuleSource(code);
+        expect(all.length).toBeGreaterThan(1);
+        const limited = mutateModuleSource(code, undefined, undefined, 1);
+        expect(limited).toHaveLength(1);
+    });
+    it('throws when max is 0', () => {
+        expect(() => mutateModuleSource('code', undefined, undefined, 0)).toThrow('max must be a positive number');
+    });
+    it('throws when max is negative', () => {
+        expect(() => mutateModuleSource('code', undefined, undefined, -1)).toThrow('max must be a positive number');
+    });
+    it('includes line and col in variants', () => {
+        const code = 'const x = a + b';
+        const result = mutateModuleSource(code);
+        for (const v of result) {
+            expect(typeof v.line).toBe('number');
+            expect(typeof v.col).toBe('number');
+        }
+    });
+    it('produces valid mutated code strings', () => {
+        const code = 'const x = a <= b';
+        const result = mutateModuleSource(code);
+        for (const v of result) {
+            expect(typeof v.code).toBe('string');
+            expect(v.code).not.toBe(code);
+        }
     });
 });

package/dist/core/__tests__/sfc.spec.d.ts

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

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

@@ -0,0 +1,76 @@
+import { describe, it, expect, vi } from 'vitest';
+import { mutateVueSfcScriptSetup } from '../sfc.js';
+// Mock @vue/compiler-sfc
+vi.mock('@vue/compiler-sfc', () => ({
+    parse: (code, _opts) => {
+        // Simple mock that extracts content between <script setup> tags
+        const startTag = '<script setup>';
+        const endTag = '</script>';
+        const startIdx = code.indexOf(startTag);
+        if (startIdx === -1) {
+            return { descriptor: { scriptSetup: null } };
+        }
+        const contentStart = startIdx + startTag.length;
+        const contentEnd = code.indexOf(endTag, contentStart);
+        return {
+            descriptor: {
+                scriptSetup: {
+                    loc: {
+                        start: { offset: contentStart },
+                        end: { offset: contentEnd },
+                    },
+                },
+            },
+        };
+    },
+}));
+describe('mutateVueSfcScriptSetup', () => {
+    it('returns empty array when there is no script setup block', async () => {
+        const code = '<template><div>hello</div></template>';
+        const result = await mutateVueSfcScriptSetup('test.vue', code);
+        expect(result).toEqual([]);
+    });
+    it('throws when max is 0', async () => {
+        await expect(mutateVueSfcScriptSetup('test.vue', '<script setup></script>', [], [], 0)).rejects.toThrow('max must be a positive number, got: 0');
+    });
+    it('throws when max is negative', async () => {
+        await expect(mutateVueSfcScriptSetup('test.vue', '<script setup></script>', [], [], -1)).rejects.toThrow('max must be a positive number, got: -1');
+    });
+    it('generates mutations for script setup content', async () => {
+        const code = '<script setup>\nconst x = a && b\n</script>';
+        const result = await mutateVueSfcScriptSetup('test.vue', code);
+        // Should find at least the andToOr mutation
+        expect(result.length).toBeGreaterThan(0);
+        // Every result should have the full SFC code (containing template tags)
+        for (const v of result) {
+            expect(v.code).toContain('<script setup>');
+            expect(v.code).toContain('</script>');
+        }
+    });
+    it('deduplicates identical mutations', async () => {
+        const code = '<script setup>\nconst x = a && b\n</script>';
+        const result = await mutateVueSfcScriptSetup('test.vue', code);
+        const outputs = result.map((v) => v.code);
+        const unique = new Set(outputs);
+        expect(outputs.length).toBe(unique.size);
+    });
+    it('respects max limit', async () => {
+        const code = '<script setup>\nconst x = a && b\nconst y = c || d\n</script>';
+        const result = await mutateVueSfcScriptSetup('test.vue', code, undefined, undefined, 1);
+        expect(result.length).toBeLessThanOrEqual(1);
+    });
+    it('filters mutators with include', async () => {
+        const code = '<script setup>\nconst x = a && b\n</script>';
+        const result = await mutateVueSfcScriptSetup('test.vue', code, ['andToOr']);
+        for (const v of result) {
+            expect(v.name).toBe('andToOr');
+        }
+    });
+    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']);
+        for (const v of result) {
+            expect(v.name).not.toBe('andToOr');
+        }
+    });
+});

package/dist/core/__tests__/variant-utils.spec.d.ts

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

package/dist/core/__tests__/variant-utils.spec.js

@@ -0,0 +1,93 @@
+import { describe, it, expect } from 'vitest';
+import { generateMutationVariants, getFilteredRegistry } from '../variant-utils.js';
+function makeMutator(name, mutations) {
+    return {
+        name,
+        description: name,
+        apply: () => mutations,
+    };
+}
+describe('generateMutationVariants', () => {
+    it('returns empty array for empty registry', () => {
+        expect(generateMutationVariants([], 'const x = 1')).toEqual([]);
+    });
+    it('generates variants from a single mutator', () => {
+        const mutator = makeMutator('flip', [
+            { code: 'const x = 2', line: 1, col: 0 },
+        ]);
+        const result = generateMutationVariants([mutator], 'const x = 1');
+        expect(result).toEqual([
+            { name: 'flip', code: 'const x = 2', line: 1, col: 0 },
+        ]);
+    });
+    it('generates variants from multiple mutators', () => {
+        const m1 = makeMutator('a', [{ code: 'code_a', line: 1, col: 0 }]);
+        const m2 = makeMutator('b', [{ code: 'code_b', line: 2, col: 5 }]);
+        const result = generateMutationVariants([m1, m2], 'original');
+        expect(result).toHaveLength(2);
+        expect(result[0].name).toBe('a');
+        expect(result[1].name).toBe('b');
+    });
+    it('deduplicates identical mutation outputs', () => {
+        const m1 = makeMutator('a', [{ code: 'same', line: 1, col: 0 }]);
+        const m2 = makeMutator('b', [{ code: 'same', line: 2, col: 0 }]);
+        const result = generateMutationVariants([m1, m2], 'original');
+        expect(result).toHaveLength(1);
+        expect(result[0].name).toBe('a');
+    });
+    it('throws when max is 0', () => {
+        expect(() => generateMutationVariants([], 'code', { max: 0 })).toThrow('max must be a positive number, got: 0');
+    });
+    it('throws when max is negative', () => {
+        expect(() => generateMutationVariants([], 'code', { max: -5 })).toThrow('max must be a positive number, got: -5');
+    });
+    it('respects max limit', () => {
+        const mutator = makeMutator('m', [
+            { code: 'v1', line: 1, col: 0 },
+            { code: 'v2', line: 2, col: 0 },
+            { code: 'v3', line: 3, col: 0 },
+        ]);
+        const result = generateMutationVariants([mutator], 'code', { max: 2 });
+        expect(result).toHaveLength(2);
+    });
+    it('stops iterating mutators once max is reached via inner return', () => {
+        const m1 = makeMutator('a', [
+            { code: 'v1', line: 1, col: 0 },
+            { code: 'v2', line: 2, col: 0 },
+        ]);
+        const m2 = makeMutator('b', [{ code: 'v3', line: 3, col: 0 }]);
+        const result = generateMutationVariants([m1, m2], 'code', { max: 2 });
+        expect(result).toHaveLength(2);
+        expect(result.every((v) => v.name === 'a')).toBe(true);
+    });
+    // NOTE: The outer loop `break` (variant-utils.ts line 42) is dead code.
+    // The inner loop always `return`s immediately when max is reached after adding
+    // a new unique variant, so the outer loop check can never fire.
+    // Same applies to sfc.ts line 43.
+    it('works with undefined max', () => {
+        const mutator = makeMutator('m', [
+            { code: 'v1', line: 1, col: 0 },
+            { code: 'v2', line: 2, col: 0 },
+        ]);
+        const result = generateMutationVariants([mutator], 'code', {});
+        expect(result).toHaveLength(2);
+    });
+});
+describe('getFilteredRegistry', () => {
+    it('returns the full registry when no filters', () => {
+        const result = getFilteredRegistry();
+        expect(result.length).toBeGreaterThan(0);
+        expect(result[0]).toHaveProperty('name');
+        expect(result[0]).toHaveProperty('apply');
+    });
+    it('filters by include', () => {
+        const result = getFilteredRegistry(['flipEQ', 'andToOr']);
+        expect(result.map((r) => r.name)).toEqual(['andToOr', 'flipEQ']);
+    });
+    it('filters by exclude', () => {
+        const all = getFilteredRegistry();
+        const result = getFilteredRegistry(undefined, ['flipEQ']);
+        expect(result.length).toBe(all.length - 1);
+        expect(result.find((r) => r.name === 'flipEQ')).toBeUndefined();
+    });
+});

package/dist/runner/__tests__/args.spec.d.ts

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

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

@@ -0,0 +1,225 @@
+import { describe, it, expect } from 'vitest';
+import { parseFlagNumber, readNumberFlag, readStringFlag, validatePercent, parseConcurrency, parseProgressMode, parseCliOptions, extractConfigPath, } from '../args.js';
+describe('parseFlagNumber', () => {
+    it('parses valid integers', () => {
+        expect(parseFlagNumber('42', '--flag')).toBe(42);
+    });
+    it('parses valid floats', () => {
+        expect(parseFlagNumber('3.14', '--flag')).toBe(3.14);
+    });
+    it('parses zero', () => {
+        expect(parseFlagNumber('0', '--flag')).toBe(0);
+    });
+    it('parses negative numbers', () => {
+        expect(parseFlagNumber('-5', '--flag')).toBe(-5);
+    });
+    it('throws on non-numeric strings', () => {
+        expect(() => parseFlagNumber('abc', '--flag')).toThrow('Invalid value for --flag: abc');
+    });
+    it('parses empty string as 0', () => {
+        // Number('') === 0, which is finite
+        expect(parseFlagNumber('', '--flag')).toBe(0);
+    });
+    it('throws on NaN-producing values', () => {
+        expect(() => parseFlagNumber('not-a-number', '--flag')).toThrow('Invalid value for --flag: not-a-number');
+    });
+    it('throws on Infinity', () => {
+        expect(() => parseFlagNumber('Infinity', '--flag')).toThrow('Invalid value for --flag: Infinity');
+    });
+});
+describe('readNumberFlag', () => {
+    it('reads flag with separate value', () => {
+        expect(readNumberFlag(['--count', '5'], '--count')).toBe(5);
+    });
+    it('reads flag with = syntax', () => {
+        expect(readNumberFlag(['--count=10'], '--count')).toBe(10);
+    });
+    it('returns undefined when flag is not present', () => {
+        expect(readNumberFlag(['--other', '5'], '--count')).toBeUndefined();
+    });
+    it('throws when no value follows flag', () => {
+        expect(() => readNumberFlag(['--count'], '--count')).toThrow('Expected a numeric value after --count');
+    });
+    it('throws when value is not a number', () => {
+        expect(() => readNumberFlag(['--count', 'abc'], '--count')).toThrow('Invalid value for --count: abc');
+    });
+});
+describe('readStringFlag', () => {
+    it('reads flag with separate value', () => {
+        expect(readStringFlag(['--config', 'path.ts'], '--config')).toBe('path.ts');
+    });
+    it('reads flag with = syntax', () => {
+        expect(readStringFlag(['--config=path.ts'], '--config')).toBe('path.ts');
+    });
+    it('reads alias', () => {
+        expect(readStringFlag(['-c', 'path.ts'], '--config', '-c')).toBe('path.ts');
+    });
+    it('reads alias with = syntax', () => {
+        expect(readStringFlag(['-c=path.ts'], '--config', '-c')).toBe('path.ts');
+    });
+    it('returns undefined when flag is not present', () => {
+        expect(readStringFlag(['--other', 'val'], '--config')).toBeUndefined();
+    });
+    it('throws when no value follows flag', () => {
+        expect(() => readStringFlag(['--config'], '--config')).toThrow('Expected a value after --config');
+    });
+    it('throws when no value follows alias', () => {
+        expect(() => readStringFlag(['-c'], '--config', '-c')).toThrow('Expected a value after -c');
+    });
+});
+describe('validatePercent', () => {
+    it('returns undefined for undefined', () => {
+        expect(validatePercent(undefined, 'test')).toBeUndefined();
+    });
+    it('returns the value for valid percentages', () => {
+        expect(validatePercent(0, 'test')).toBe(0);
+        expect(validatePercent(50, 'test')).toBe(50);
+        expect(validatePercent(100, 'test')).toBe(100);
+    });
+    it('throws for negative values', () => {
+        expect(() => validatePercent(-1, 'test')).toThrow('Invalid test: expected value between 0 and 100 (received -1)');
+    });
+    it('throws for values over 100', () => {
+        expect(() => validatePercent(101, 'test')).toThrow('Invalid test: expected value between 0 and 100 (received 101)');
+    });
+    it('throws for non-finite values', () => {
+        expect(() => validatePercent(NaN, 'test')).toThrow('Invalid test: expected a number between 0 and 100');
+        expect(() => validatePercent(Infinity, 'test')).toThrow('Invalid test: expected a number between 0 and 100');
+    });
+});
+describe('parseConcurrency', () => {
+    it('returns default when flag not present', () => {
+        const result = parseConcurrency([]);
+        expect(result).toBeGreaterThanOrEqual(1);
+    });
+    it('parses explicit concurrency', () => {
+        expect(parseConcurrency(['--concurrency', '4'])).toBe(4);
+    });
+    it('clamps to minimum of 1', () => {
+        expect(parseConcurrency(['--concurrency', '0'])).toBeGreaterThanOrEqual(1);
+    });
+    it('handles invalid concurrency value gracefully', () => {
+        const result = parseConcurrency(['--concurrency', 'abc']);
+        expect(result).toBeGreaterThanOrEqual(1);
+    });
+});
+describe('parseProgressMode', () => {
+    it('returns bar by default', () => {
+        expect(parseProgressMode([])).toBe('bar');
+    });
+    it('returns list when specified', () => {
+        expect(parseProgressMode(['--progress', 'list'])).toBe('list');
+    });
+    it('returns quiet when specified', () => {
+        expect(parseProgressMode(['--progress', 'quiet'])).toBe('quiet');
+    });
+    it('returns bar for unknown values', () => {
+        expect(parseProgressMode(['--progress', 'unknown'])).toBe('bar');
+    });
+    it('defaults to bar when --progress has no following value', () => {
+        expect(parseProgressMode(['--progress'])).toBe('bar');
+    });
+});
+describe('parseCliOptions', () => {
+    const emptyCfg = {};
+    it('parses --changed flag', () => {
+        const opts = parseCliOptions(['--changed'], emptyCfg);
+        expect(opts.wantsChanged).toBe(true);
+        expect(opts.wantsChangedWithDeps).toBe(false);
+    });
+    it('parses --changed-with-deps flag', () => {
+        const opts = parseCliOptions(['--changed-with-deps'], emptyCfg);
+        expect(opts.wantsChangedWithDeps).toBe(true);
+    });
+    it('parses --only-covered-lines flag', () => {
+        const opts = parseCliOptions(['--only-covered-lines'], emptyCfg);
+        expect(opts.wantsOnlyCoveredLines).toBe(true);
+    });
+    it('reads onlyCoveredLines from config', () => {
+        const opts = parseCliOptions([], { onlyCoveredLines: true });
+        expect(opts.wantsOnlyCoveredLines).toBe(true);
+    });
+    it('parses --per-test-coverage flag', () => {
+        const opts = parseCliOptions(['--per-test-coverage'], emptyCfg);
+        expect(opts.wantsPerTestCoverage).toBe(true);
+    });
+    it('reads perTestCoverage from config', () => {
+        const opts = parseCliOptions([], { perTestCoverage: true });
+        expect(opts.wantsPerTestCoverage).toBe(true);
+    });
+    it('parses --coverage-file flag', () => {
+        const opts = parseCliOptions(['--coverage-file', 'coverage.json'], emptyCfg);
+        expect(opts.coverageFilePath).toBe('coverage.json');
+    });
+    it('reads coverageFile from config', () => {
+        const opts = parseCliOptions([], { coverageFile: 'cov.json' });
+        expect(opts.coverageFilePath).toBe('cov.json');
+    });
+    it('CLI coverage-file takes precedence over config', () => {
+        const opts = parseCliOptions(['--coverage-file', 'cli.json'], {
+            coverageFile: 'config.json',
+        });
+        expect(opts.coverageFilePath).toBe('cli.json');
+    });
+    it('parses --runner vitest', () => {
+        const opts = parseCliOptions(['--runner', 'vitest'], emptyCfg);
+        expect(opts.runner).toBe('vitest');
+    });
+    it('parses --runner jest', () => {
+        const opts = parseCliOptions(['--runner', 'jest'], emptyCfg);
+        expect(opts.runner).toBe('jest');
+    });
+    it('falls back to config runner', () => {
+        const opts = parseCliOptions([], { runner: 'jest' });
+        expect(opts.runner).toBe('jest');
+    });
+    it('defaults to vitest', () => {
+        const opts = parseCliOptions([], emptyCfg);
+        expect(opts.runner).toBe('vitest');
+    });
+    it('parses --config flag', () => {
+        const opts = parseCliOptions(['--config', 'my.config.ts'], emptyCfg);
+        expect(opts.configPath).toBe('my.config.ts');
+    });
+    it('parses -c alias', () => {
+        const opts = parseCliOptions(['-c', 'my.config.ts'], emptyCfg);
+        expect(opts.configPath).toBe('my.config.ts');
+    });
+    it('parses --min-kill-percent from CLI', () => {
+        const opts = parseCliOptions(['--min-kill-percent', '80'], emptyCfg);
+        expect(opts.minKillPercent).toBe(80);
+    });
+    it('reads minKillPercent from config', () => {
+        const opts = parseCliOptions([], { minKillPercent: 75 });
+        expect(opts.minKillPercent).toBe(75);
+    });
+    it('CLI min-kill-percent takes precedence over config', () => {
+        const opts = parseCliOptions(['--min-kill-percent', '90'], {
+            minKillPercent: 75,
+        });
+        expect(opts.minKillPercent).toBe(90);
+    });
+    it('rejects invalid --min-kill-percent', () => {
+        expect(() => parseCliOptions(['--min-kill-percent', '150'], emptyCfg)).toThrow('expected value between 0 and 100');
+    });
+});
+describe('extractConfigPath', () => {
+    it('extracts --config with separate value', () => {
+        expect(extractConfigPath(['--config', 'my.config.ts'])).toBe('my.config.ts');
+    });
+    it('extracts --config with = syntax', () => {
+        expect(extractConfigPath(['--config=my.config.ts'])).toBe('my.config.ts');
+    });
+    it('extracts -c alias with separate value', () => {
+        expect(extractConfigPath(['-c', 'my.config.ts'])).toBe('my.config.ts');
+    });
+    it('extracts -c alias with = syntax', () => {
+        expect(extractConfigPath(['-c=my.config.ts'])).toBe('my.config.ts');
+    });
+    it('returns undefined when no config flag is present', () => {
+        expect(extractConfigPath(['--changed', '--runner', 'vitest'])).toBeUndefined();
+    });
+    it('returns undefined for empty args', () => {
+        expect(extractConfigPath([])).toBeUndefined();
+    });
+});

package/dist/runner/__tests__/cache.spec.d.ts

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

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

@@ -0,0 +1,180 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { clearCacheOnStart, saveCacheAtomic, decodeCacheKey, keyForTests, hash, readMutantCache, } from '../cache.js';
+let tmpDir;
+beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-cache-'));
+});
+afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+});
+describe('clearCacheOnStart', () => {
+    it('removes the cache file if it exists', async () => {
+        const cacheFile = path.join(tmpDir, '.mutate-cache.json');
+        await fs.writeFile(cacheFile, '{}');
+        await clearCacheOnStart(tmpDir);
+        await expect(fs.access(cacheFile)).rejects.toThrow();
+    });
+    it('does not throw if cache file does not exist', async () => {
+        await expect(clearCacheOnStart(tmpDir)).resolves.toBeUndefined();
+    });
+});
+describe('saveCacheAtomic', () => {
+    it('writes cache data to the file', async () => {
+        const cache = {
+            key1: {
+                status: 'killed',
+                file: 'foo.ts',
+                line: 1,
+                col: 0,
+                mutator: 'flipEQ',
+            },
+        };
+        await saveCacheAtomic(tmpDir, cache);
+        const content = await fs.readFile(path.join(tmpDir, '.mutate-cache.json'), 'utf8');
+        expect(JSON.parse(content)).toEqual(cache);
+    });
+    it('overwrites existing cache', async () => {
+        await saveCacheAtomic(tmpDir, { old: {} });
+        const newCache = {
+            new: {
+                status: 'escaped',
+                file: 'bar.ts',
+                line: 2,
+                col: 3,
+                mutator: 'andToOr',
+            },
+        };
+        await saveCacheAtomic(tmpDir, newCache);
+        const content = await fs.readFile(path.join(tmpDir, '.mutate-cache.json'), 'utf8');
+        expect(JSON.parse(content)).toEqual(newCache);
+    });
+});
+describe('decodeCacheKey', () => {
+    it('decodes a full cache key', () => {
+        const key = 'testsig:codesig:src/foo.ts:10,5:flipEQ';
+        const decoded = decodeCacheKey(key);
+        expect(decoded.file).toBe('src/foo.ts');
+        expect(decoded.line).toBe(10);
+        expect(decoded.col).toBe(5);
+        expect(decoded.mutator).toBe('flipEQ');
+    });
+    it('handles key with no colons', () => {
+        const decoded = decodeCacheKey('nodelimiters');
+        expect(decoded.mutator).toBe('unknown');
+    });
+    it('handles key with only one colon', () => {
+        const decoded = decodeCacheKey('only:one');
+        expect(decoded.mutator).toBe('one');
+    });
+    it('handles malformed position', () => {
+        const key = 'a:b:file:badpos:mutator';
+        const decoded = decodeCacheKey(key);
+        expect(decoded.mutator).toBe('mutator');
+    });
+    it('handles key with exactly two colons (no firstColon in rest)', () => {
+        // Key: "pos:mutator" after splitting last colon → rest = "pos", no colon in rest
+        // Full key: "10,5:mutator" → lastColon splits mutator, positionColon splits pos
+        // rest becomes empty string before positionColon
+        const decoded = decodeCacheKey('10,5:mutator');
+        expect(decoded.mutator).toBe('mutator');
+        expect(decoded.line).toBe(0); // positionColon = -1, returns early
+    });
+    it('handles key with exactly three colons (firstColon but no secondColon)', () => {
+        // "sig:10,5:mutator" → mutator='mutator', posRaw='10,5', rest='sig'
+        // firstColon in 'sig' = -1, returns early at line 70
+        const decoded = decodeCacheKey('sig:10,5:mutator');
+        expect(decoded.mutator).toBe('mutator');
+        expect(decoded.line).toBe(10);
+        expect(decoded.col).toBe(5);
+    });
+    it('handles key with four colons (firstColon but no secondColon in restAfterFirst)', () => {
+        // "tsig:csig:10,5:mutator" → mutator='mutator', posRaw='10,5', rest='tsig:csig'
+        // firstColon=4, restAfterFirst='csig', secondColon in 'csig' = -1, returns at line 73
+        const decoded = decodeCacheKey('tsig:csig:10,5:mutator');
+        expect(decoded.mutator).toBe('mutator');
+        expect(decoded.line).toBe(10);
+        expect(decoded.col).toBe(5);
+    });
+});
+describe('keyForTests', () => {
+    it('produces deterministic keys regardless of input order', () => {
+        const key1 = keyForTests(['b.test.ts', 'a.test.ts']);
+        const key2 = keyForTests(['a.test.ts', 'b.test.ts']);
+        expect(key1).toBe(key2);
+    });
+    it('produces different keys for different test sets', () => {
+        const key1 = keyForTests(['a.test.ts']);
+        const key2 = keyForTests(['b.test.ts']);
+        expect(key1).not.toBe(key2);
+    });
+});
+describe('hash', () => {
+    it('returns a 12 character hex string', () => {
+        const h = hash('test');
+        expect(h).toMatch(/^[0-9a-f]{12}$/);
+    });
+    it('returns the same hash for the same input', () => {
+        expect(hash('hello')).toBe(hash('hello'));
+    });
+    it('returns different hashes for different inputs', () => {
+        expect(hash('a')).not.toBe(hash('b'));
+    });
+});
+describe('readMutantCache', () => {
+    it('returns empty object when no cache file exists', async () => {
+        const result = await readMutantCache(tmpDir);
+        expect(result).toEqual({});
+    });
+    it('reads and normalizes object-format cache entries', async () => {
+        const cache = {
+            'testsig:codesig:file.ts:1,0:flip': {
+                status: 'killed',
+                file: 'file.ts',
+                line: 1,
+                col: 0,
+                mutator: 'flip',
+            },
+        };
+        await fs.writeFile(path.join(tmpDir, '.mutate-cache.json'), JSON.stringify(cache));
+        const result = await readMutantCache(tmpDir);
+        expect(result['testsig:codesig:file.ts:1,0:flip']).toEqual({
+            status: 'killed',
+            file: 'file.ts',
+            line: 1,
+            col: 0,
+            mutator: 'flip',
+        });
+    });
+    it('reads and normalizes old string-format cache entries', async () => {
+        const cache = {
+            'testsig:codesig:file.ts:1,0:flip': 'killed',
+        };
+        await fs.writeFile(path.join(tmpDir, '.mutate-cache.json'), JSON.stringify(cache));
+        const result = await readMutantCache(tmpDir);
+        const entry = result['testsig:codesig:file.ts:1,0:flip'];
+        expect(entry.status).toBe('killed');
+        expect(entry.mutator).toBe('flip');
+    });
+    it('returns empty object for invalid JSON', async () => {
+        await fs.writeFile(path.join(tmpDir, '.mutate-cache.json'), 'not json');
+        const result = await readMutantCache(tmpDir);
+        expect(result).toEqual({});
+    });
+    it('normalizes partial object entries with decoded fallbacks', async () => {
+        const cache = {
+            'testsig:codesig:file.ts:5,3:mut': {
+                status: 'escaped',
+            },
+        };
+        await fs.writeFile(path.join(tmpDir, '.mutate-cache.json'), JSON.stringify(cache));
+        const result = await readMutantCache(tmpDir);
+        const entry = result['testsig:codesig:file.ts:5,3:mut'];
+        expect(entry.status).toBe('escaped');
+        expect(entry.line).toBe(5);
+        expect(entry.col).toBe(3);
+        expect(entry.mutator).toBe('mut');
+    });
+});

package/dist/runner/__tests__/changed.spec.d.ts

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