@mutineerjs/mutineer 0.5.1 → 0.7.0

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

@@ -2,7 +2,7 @@ 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';
+import { clearCacheOnStart, saveCacheAtomic, decodeCacheKey, keyForTests, hash, readMutantCache, getCacheFilename, } from '../cache.js';
 let tmpDir;
 beforeEach(async () => {
     tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-cache-'));
@@ -10,9 +10,19 @@ beforeEach(async () => {
 afterEach(async () => {
     await fs.rm(tmpDir, { recursive: true, force: true });
 });
+describe('getCacheFilename', () => {
+    it('returns default filename when no shard', () => {
+        expect(getCacheFilename()).toBe('.mutineer-cache.json');
+        expect(getCacheFilename(undefined)).toBe('.mutineer-cache.json');
+    });
+    it('returns shard-namespaced filename when shard provided', () => {
+        expect(getCacheFilename({ index: 1, total: 2 })).toBe('.mutineer-cache-shard-1-of-2.json');
+        expect(getCacheFilename({ index: 3, total: 4 })).toBe('.mutineer-cache-shard-3-of-4.json');
+    });
+});
 describe('clearCacheOnStart', () => {
     it('removes the cache file if it exists', async () => {
-        const cacheFile = path.join(tmpDir, '.mutate-cache.json');
+        const cacheFile = path.join(tmpDir, '.mutineer-cache.json');
         await fs.writeFile(cacheFile, '{}');
         await clearCacheOnStart(tmpDir);
         await expect(fs.access(cacheFile)).rejects.toThrow();
@@ -20,6 +30,19 @@ describe('clearCacheOnStart', () => {
     it('does not throw if cache file does not exist', async () => {
         await expect(clearCacheOnStart(tmpDir)).resolves.toBeUndefined();
     });
+    it('removes shard-specific cache file', async () => {
+        const shardFile = path.join(tmpDir, '.mutineer-cache-shard-1-of-2.json');
+        await fs.writeFile(shardFile, '{}');
+        await clearCacheOnStart(tmpDir, { index: 1, total: 2 });
+        await expect(fs.access(shardFile)).rejects.toThrow();
+    });
+    it('does not remove default cache when shard is specified', async () => {
+        const defaultFile = path.join(tmpDir, '.mutineer-cache.json');
+        await fs.writeFile(defaultFile, '{}');
+        await clearCacheOnStart(tmpDir, { index: 1, total: 2 });
+        // default file should still exist
+        await expect(fs.access(defaultFile)).resolves.toBeUndefined();
+    });
 });
 describe('saveCacheAtomic', () => {
     it('writes cache data to the file', async () => {
@@ -33,7 +56,7 @@ describe('saveCacheAtomic', () => {
             },
         };
         await saveCacheAtomic(tmpDir, cache);
-        const content = await fs.readFile(path.join(tmpDir, '.mutate-cache.json'), 'utf8');
+        const content = await fs.readFile(path.join(tmpDir, '.mutineer-cache.json'), 'utf8');
         expect(JSON.parse(content)).toEqual(cache);
     });
     it('overwrites existing cache', async () => {
@@ -48,9 +71,25 @@ describe('saveCacheAtomic', () => {
             },
         };
         await saveCacheAtomic(tmpDir, newCache);
-        const content = await fs.readFile(path.join(tmpDir, '.mutate-cache.json'), 'utf8');
+        const content = await fs.readFile(path.join(tmpDir, '.mutineer-cache.json'), 'utf8');
         expect(JSON.parse(content)).toEqual(newCache);
     });
+    it('writes to shard-named file when shard is provided', async () => {
+        const cache = {
+            k: {
+                status: 'killed',
+                file: 'x.ts',
+                line: 1,
+                col: 0,
+                mutator: 'm',
+            },
+        };
+        await saveCacheAtomic(tmpDir, cache, { index: 2, total: 3 });
+        const content = await fs.readFile(path.join(tmpDir, '.mutineer-cache-shard-2-of-3.json'), 'utf8');
+        expect(JSON.parse(content)).toEqual(cache);
+        // default file should NOT exist
+        await expect(fs.access(path.join(tmpDir, '.mutineer-cache.json'))).rejects.toThrow();
+    });
 });
 describe('decodeCacheKey', () => {
     it('decodes a full cache key', () => {
@@ -128,6 +167,24 @@ describe('readMutantCache', () => {
         const result = await readMutantCache(tmpDir);
         expect(result).toEqual({});
     });
+    it('reads from shard-named file when shard is provided', async () => {
+        const cache = {
+            'k:v:f.ts:1,0:m': {
+                status: 'killed',
+                file: 'f.ts',
+                line: 1,
+                col: 0,
+                mutator: 'm',
+            },
+        };
+        await fs.writeFile(path.join(tmpDir, '.mutineer-cache-shard-1-of-2.json'), JSON.stringify(cache));
+        const result = await readMutantCache(tmpDir, { index: 1, total: 2 });
+        expect(result['k:v:f.ts:1,0:m'].status).toBe('killed');
+    });
+    it('returns empty object when shard file does not exist', async () => {
+        const result = await readMutantCache(tmpDir, { index: 2, total: 4 });
+        expect(result).toEqual({});
+    });
     it('reads and normalizes object-format cache entries', async () => {
         const cache = {
             'testsig:codesig:file.ts:1,0:flip': {
@@ -138,7 +195,7 @@ describe('readMutantCache', () => {
                 mutator: 'flip',
             },
         };
-        await fs.writeFile(path.join(tmpDir, '.mutate-cache.json'), JSON.stringify(cache));
+        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']).toEqual({
             status: 'killed',
@@ -152,14 +209,14 @@ describe('readMutantCache', () => {
         const cache = {
             'testsig:codesig:file.ts:1,0:flip': 'killed',
         };
-        await fs.writeFile(path.join(tmpDir, '.mutate-cache.json'), JSON.stringify(cache));
+        await fs.writeFile(path.join(tmpDir, '.mutineer-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');
+        await fs.writeFile(path.join(tmpDir, '.mutineer-cache.json'), 'not json');
         const result = await readMutantCache(tmpDir);
         expect(result).toEqual({});
     });
@@ -169,7 +226,7 @@ describe('readMutantCache', () => {
                 status: 'escaped',
             },
         };
-        await fs.writeFile(path.join(tmpDir, '.mutate-cache.json'), JSON.stringify(cache));
+        await fs.writeFile(path.join(tmpDir, '.mutineer-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');

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

@@ -145,11 +145,94 @@ describe('listChangedFiles', () => {
             }
             return { status: 0, stdout: '' };
         });
-        // File with imports - the import resolution will fail (no real files)
-        // but it exercises the parsing code paths
         readFileSyncMock.mockReturnValue('import { bar } from "./bar"\nexport { baz } from "./baz"\nconst x = require("./qux")');
+        existsSyncMock.mockImplementation((p) => {
+            // Changed file and .ts variants of deps exist
+            return [
+                '/repo/src/foo.ts',
+                '/repo/src/bar.ts',
+                '/repo/src/baz.ts',
+                '/repo/src/qux.ts',
+            ].includes(p);
+        });
         const result = listChangedFiles('/repo', { includeDeps: true });
         expect(result).toContain('/repo/src/foo.ts');
+        expect(result).toContain('/repo/src/bar.ts');
+        expect(result).toContain('/repo/src/baz.ts');
+        expect(result).toContain('/repo/src/qux.ts');
+    });
+    it('resolves dep with .ts extension when imported without extension', () => {
+        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: '' };
+        });
+        readFileSyncMock.mockReturnValue('import { x } from "./utils"');
+        existsSyncMock.mockImplementation((p) => {
+            return ['/repo/src/foo.ts', '/repo/src/utils.ts'].includes(p);
+        });
+        const result = listChangedFiles('/repo', { includeDeps: true });
+        expect(result).toContain('/repo/src/utils.ts');
+    });
+    it('excludes deps outside cwd', () => {
+        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: '' };
+        });
+        readFileSyncMock.mockReturnValue('import { x } from "../../outside/dep"');
+        existsSyncMock.mockImplementation((p) => {
+            return ['/repo/src/foo.ts', '/outside/dep.ts'].includes(p);
+        });
+        const result = listChangedFiles('/repo', { includeDeps: true });
+        expect(result).not.toContain('/outside/dep.ts');
+        expect(result).toHaveLength(1);
+    });
+    it('excludes deps inside node_modules', () => {
+        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: '' };
+        });
+        readFileSyncMock.mockReturnValue('import { x } from "./node_modules/pkg/index"');
+        existsSyncMock.mockImplementation((p) => {
+            return p === '/repo/src/foo.ts' || p.includes('node_modules');
+        });
+        const result = listChangedFiles('/repo', { includeDeps: true });
+        expect(result.some((p) => p.includes('node_modules'))).toBe(false);
+    });
+    it('resolves direct dep but not transitive dep at maxDepth=1', () => {
+        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: '' };
+        });
+        readFileSyncMock.mockImplementation((p) => {
+            if (p === '/repo/src/foo.ts')
+                return 'import { x } from "./bar"';
+            if (p === '/repo/src/bar.ts')
+                return 'import { y } from "./baz"';
+            return '';
+        });
+        existsSyncMock.mockImplementation((p) => {
+            return [
+                '/repo/src/foo.ts',
+                '/repo/src/bar.ts',
+                '/repo/src/baz.ts',
+            ].includes(p);
+        });
+        const result = listChangedFiles('/repo', { includeDeps: true, maxDepth: 1 });
+        expect(result).toContain('/repo/src/foo.ts');
+        expect(result).toContain('/repo/src/bar.ts');
+        expect(result).not.toContain('/repo/src/baz.ts');
     });
     it('skips non-local imports in dependency resolution', () => {
         spawnSyncMock.mockImplementation((_cmd, args) => {

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

@@ -38,4 +38,34 @@ describe('cleanupMutineerDirs', () => {
         const stat = await fs.stat(srcDir);
         expect(stat.isDirectory()).toBe(true);
     });
+    it('does not remove cache files by default', async () => {
+        const cacheFile = path.join(tmpDir, '.mutineer-cache.json');
+        await fs.writeFile(cacheFile, '{}');
+        await cleanupMutineerDirs(tmpDir);
+        await expect(fs.access(cacheFile)).resolves.toBeUndefined();
+    });
+    it('removes .mutineer-cache*.json files when includeCacheFiles is true', async () => {
+        const cacheFile = path.join(tmpDir, '.mutineer-cache.json');
+        const shardFile = path.join(tmpDir, '.mutineer-cache-shard-1-of-2.json');
+        await fs.writeFile(cacheFile, '{}');
+        await fs.writeFile(shardFile, '{}');
+        await cleanupMutineerDirs(tmpDir, { includeCacheFiles: true });
+        await expect(fs.access(cacheFile)).rejects.toThrow();
+        await expect(fs.access(shardFile)).rejects.toThrow();
+    });
+    it('removes legacy .mutate-cache*.json files for migration when includeCacheFiles is true', async () => {
+        const legacyCache = path.join(tmpDir, '.mutate-cache.json');
+        const legacyShard = path.join(tmpDir, '.mutate-cache-shard-2-of-4.json');
+        await fs.writeFile(legacyCache, '{}');
+        await fs.writeFile(legacyShard, '{}');
+        await cleanupMutineerDirs(tmpDir, { includeCacheFiles: true });
+        await expect(fs.access(legacyCache)).rejects.toThrow();
+        await expect(fs.access(legacyShard)).rejects.toThrow();
+    });
+    it('removes .mutineer-cache*.json.tmp temp files when includeCacheFiles is true', async () => {
+        const tmpFile = path.join(tmpDir, '.mutineer-cache.json.tmp');
+        await fs.writeFile(tmpFile, '{}');
+        await cleanupMutineerDirs(tmpDir, { includeCacheFiles: true });
+        await expect(fs.access(tmpFile)).rejects.toThrow();
+    });
 });

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

@@ -52,20 +52,9 @@ describe('loadMutineerConfig', () => {
         await fs.writeFile(configFile, '??? not valid javascript ???');
         await expect(loadMutineerConfig(tmpDir)).rejects.toThrow(/Failed to load config from/);
     });
-    // BUG: Two bugs compound here:
-    // 1. validateConfig uses `&&` instead of `||`: `typeof config !== 'object' && config === null`
-    //    Since typeof null === 'object', this condition is always false, so null passes validation.
-    // 2. loadModule uses `||` instead of `??`: `mod.default || mod`
-    //    When default export is null (falsy), it falls back to the module namespace object.
-    // Together: null configs pass validation AND get returned as the module namespace.
-    it('BUG: null config passes validation due to && vs || logic error', async () => {
+    it('throws when config exports null', async () => {
         const configFile = path.join(tmpDir, 'mutineer.config.mjs');
         await fs.writeFile(configFile, 'export default null');
-        // This SHOULD throw but doesn't because of the validateConfig bug.
-        // Additionally, loadModule returns { default: null } instead of null
-        // because it uses || (which treats null as falsy) instead of ??
-        const config = await loadMutineerConfig(tmpDir);
-        // Bug: returns the module namespace object instead of throwing
-        expect(config).toHaveProperty('default', null);
+        await expect(loadMutineerConfig(tmpDir)).rejects.toThrow('does not export a valid configuration object');
     });
 });

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

@@ -15,6 +15,9 @@ function makeOpts(overrides = {}) {
         progressMode: 'bar',
         minKillPercent: undefined,
         runner: 'vitest',
+        timeout: undefined,
+        reportFormat: 'text',
+        shard: undefined,
         ...overrides,
     };
 }
@@ -62,7 +65,9 @@ describe('resolveCoverageConfig', () => {
     });
     it('sets exitCode when onlyCoveredLines is set but no coverage provider', async () => {
         const opts = makeOpts({ wantsOnlyCoveredLines: true });
-        const adapter = makeAdapter({ hasCoverageProvider: vi.fn().mockReturnValue(false) });
+        const adapter = makeAdapter({
+            hasCoverageProvider: vi.fn().mockReturnValue(false),
+        });
         await resolveCoverageConfig(opts, {}, adapter, []);
         expect(process.exitCode).toBe(1);
     });
@@ -129,7 +134,9 @@ describe('loadCoverageAfterBaseline', () => {
         const coverageJson = {
             '/src/foo.ts': {
                 path: '/src/foo.ts',
-                statementMap: { '0': { start: { line: 1, column: 0 }, end: { line: 1, column: 10 } } },
+                statementMap: {
+                    '0': { start: { line: 1, column: 0 }, end: { line: 1, column: 10 } },
+                },
                 s: { '0': 1 },
             },
         };

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

@@ -114,6 +114,134 @@ describe('autoDiscoverTargetsAndTests', () => {
             await fs.rm(tmpDir, { recursive: true, force: true });
         }
     });
+    it('calls onProgress at least twice with informational messages', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-progress-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const moduleFile = path.join(srcDir, 'foo.ts');
+        const testFile = path.join(srcDir, 'foo.test.ts');
+        await fs.mkdir(srcDir, { recursive: true });
+        await fs.writeFile(moduleFile, 'export const foo = 1\n', 'utf8');
+        const importLine = ['im', 'port { foo } from "./foo"'].join('');
+        await fs.writeFile(testFile, `${importLine}\nconsole.log(foo)\n`, 'utf8');
+        const messages = [];
+        try {
+            await autoDiscoverTargetsAndTests(tmpDir, { testPatterns: ['**/*.test.ts'] }, (msg) => messages.push(msg));
+            expect(messages.length).toBeGreaterThanOrEqual(2);
+            expect(messages.some((m) => m.includes('test file'))).toBe(true);
+            expect(messages.some((m) => m.includes('Discovery complete'))).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('shared dep imported by 2 tests appears in testMap for both', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-shared-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const sharedDep = path.join(srcDir, 'shared.ts');
+        const test1 = path.join(srcDir, 'a.test.ts');
+        const test2 = path.join(srcDir, 'b.test.ts');
+        await fs.mkdir(srcDir, { recursive: true });
+        await fs.writeFile(sharedDep, 'export const shared = 1\n', 'utf8');
+        const importShared = ['im', 'port { shared } from "./shared"'].join('');
+        await fs.writeFile(test1, `${importShared}\n`, 'utf8');
+        await fs.writeFile(test2, `${importShared}\n`, 'utf8');
+        try {
+            const { testMap } = await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+            });
+            const sharedAbs = normalizePath(sharedDep);
+            const test1Abs = normalizePath(test1);
+            const test2Abs = normalizePath(test2);
+            expect(testMap.get(sharedAbs)?.has(test1Abs)).toBe(true);
+            expect(testMap.get(sharedAbs)?.has(test2Abs)).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('diamond graph: shared grandchild discovered with no duplicates', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-diamond-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const fileA = path.join(srcDir, 'A.ts');
+        const fileB = path.join(srcDir, 'B.ts');
+        const fileC = path.join(srcDir, 'C.ts');
+        const fileD = path.join(srcDir, 'D.ts');
+        const testFile = path.join(srcDir, 'test.test.ts');
+        await fs.mkdir(srcDir, { recursive: true });
+        await fs.writeFile(fileD, 'export const d = 4\n', 'utf8');
+        const importD = ['im', 'port { d } from "./D"'].join('');
+        await fs.writeFile(fileB, `${importD}\nexport const b = 2\n`, 'utf8');
+        await fs.writeFile(fileC, `${importD}\nexport const c = 3\n`, 'utf8');
+        const importB = ['im', 'port { b } from "./B"'].join('');
+        const importC = ['im', 'port { c } from "./C"'].join('');
+        await fs.writeFile(fileA, `${importB}\n${importC}\nexport const a = 1\n`, 'utf8');
+        const importA = ['im', 'port { a } from "./A"'].join('');
+        await fs.writeFile(testFile, `${importA}\n`, 'utf8');
+        try {
+            const { testMap } = await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+            });
+            const dAbs = normalizePath(fileD);
+            const testAbs = normalizePath(testFile);
+            expect(testMap.get(dAbs)?.has(testAbs)).toBe(true);
+            // D should only be in testMap once (Set ensures no duplicates)
+            expect(testMap.get(dAbs)?.size).toBe(1);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('deep chain: deepest file is discovered correctly', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-deep-'));
+        const srcDir = path.join(tmpDir, 'src');
+        await fs.mkdir(srcDir, { recursive: true });
+        // chain: test -> f1 -> f2 -> f3 -> f4 -> f5
+        const files = Array.from({ length: 5 }, (_, i) => path.join(srcDir, `f${i + 1}.ts`));
+        const testFile = path.join(srcDir, 'chain.test.ts');
+        await fs.writeFile(files[4], 'export const f5 = 5\n', 'utf8');
+        for (let i = 3; i >= 0; i--) {
+            const importNext = ['im', `port { f${i + 2} } from "./f${i + 2}"`].join('');
+            await fs.writeFile(files[i], `${importNext}\nexport const f${i + 1} = ${i + 1}\n`, 'utf8');
+        }
+        const importF1 = ['im', 'port { f1 } from "./f1"'].join('');
+        await fs.writeFile(testFile, `${importF1}\n`, 'utf8');
+        try {
+            const { testMap } = await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+            });
+            const f5Abs = normalizePath(files[4]);
+            const testAbs = normalizePath(testFile);
+            expect(testMap.get(f5Abs)?.has(testAbs)).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('2 tests directly importing same file both appear in directTestMap', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-direct2-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const sharedDep = path.join(srcDir, 'shared.ts');
+        const test1 = path.join(srcDir, 'a.test.ts');
+        const test2 = path.join(srcDir, 'b.test.ts');
+        await fs.mkdir(srcDir, { recursive: true });
+        await fs.writeFile(sharedDep, 'export const shared = 1\n', 'utf8');
+        const importShared = ['im', 'port { shared } from "./shared"'].join('');
+        await fs.writeFile(test1, `${importShared}\n`, 'utf8');
+        await fs.writeFile(test2, `${importShared}\n`, 'utf8');
+        try {
+            const { directTestMap } = await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+            });
+            const sharedAbs = normalizePath(sharedDep);
+            const test1Abs = normalizePath(test1);
+            const test2Abs = normalizePath(test2);
+            expect(directTestMap.get(sharedAbs)?.has(test1Abs)).toBe(true);
+            expect(directTestMap.get(sharedAbs)?.has(test2Abs)).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
     it('ignores test files when collecting mutate targets', async () => {
         const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-'));
         const srcDir = path.join(tmpDir, 'src');

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

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