@mutineerjs/mutineer 0.6.0 → 0.8.0

package/dist/runner/shared/mutant-paths.d.ts

@@ -1,6 +1,23 @@
 /**
  * Shared utilities for managing mutant file paths.
  */
+/**
+ * Generate a file path for the schema file in the __mutineer__ directory.
+ * The schema file embeds all mutation variants for a source file.
+ *
+ * @param originalFile - Path to the original source file
+ * @returns Path where the schema file should be written (dir may not exist)
+ */
+export declare function getSchemaFilePath(originalFile: string): string;
+/**
+ * Generate the path for a worker's active-mutant-ID file.
+ * Each worker writes the active mutant ID here so test forks can read it.
+ *
+ * @param workerId - Unique worker identifier
+ * @param cwd - Project working directory
+ * @returns Absolute path for the active ID file
+ */
+export declare function getActiveIdFilePath(workerId: string, cwd: string): string;
 /**
  * Generate a file path for a mutant file in the __mutineer__ directory.
  *

package/dist/runner/shared/mutant-paths.js

@@ -3,6 +3,30 @@
  */
 import path from 'node:path';
 import fs from 'node:fs';
+/**
+ * Generate a file path for the schema file in the __mutineer__ directory.
+ * The schema file embeds all mutation variants for a source file.
+ *
+ * @param originalFile - Path to the original source file
+ * @returns Path where the schema file should be written (dir may not exist)
+ */
+export function getSchemaFilePath(originalFile) {
+    const dir = path.dirname(originalFile);
+    const ext = path.extname(originalFile);
+    const basename = path.basename(originalFile, ext);
+    return path.join(dir, '__mutineer__', `${basename}_schema${ext}`);
+}
+/**
+ * Generate the path for a worker's active-mutant-ID file.
+ * Each worker writes the active mutant ID here so test forks can read it.
+ *
+ * @param workerId - Unique worker identifier
+ * @param cwd - Project working directory
+ * @returns Absolute path for the active ID file
+ */
+export function getActiveIdFilePath(workerId, cwd) {
+    return path.join(cwd, '__mutineer__', `active_id_${workerId}.txt`);
+}
 /**
  * Generate a file path for a mutant file in the __mutineer__ directory.
  *

package/dist/runner/ts-checker-worker.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Worker thread entry point for parallel TypeScript type checking.
+ * Receives one file group, runs baseline + per-variant diagnose, posts results.
+ */
+export {};

package/dist/runner/ts-checker-worker.js

@@ -0,0 +1,66 @@
+/**
+ * Worker thread entry point for parallel TypeScript type checking.
+ * Receives one file group, runs baseline + per-variant diagnose, posts results.
+ */
+import { workerData, parentPort } from 'worker_threads';
+import ts from 'typescript';
+import path from 'node:path';
+import fs from 'node:fs';
+/** Stable fingerprint for a diagnostic. */
+function diagnosticKey(d) {
+    return `${d.code}:${d.start ?? -1}`;
+}
+/** Create a compiler host that serves `code` for `targetPath`. */
+function makeHost(options, targetPath, code) {
+    const host = ts.createCompilerHost(options);
+    const orig = host.getSourceFile.bind(host);
+    host.getSourceFile = (fileName, langOrOpts) => {
+        if (path.resolve(fileName) === targetPath) {
+            return ts.createSourceFile(fileName, code, langOrOpts);
+        }
+        return orig(fileName, langOrOpts);
+    };
+    return host;
+}
+/** Run semantic diagnostics for `code` in `targetPath`. */
+function diagnose(options, targetPath, code, oldProgram) {
+    const host = makeHost(options, targetPath, code);
+    const program = ts.createProgram({
+        rootNames: [targetPath],
+        options,
+        host,
+        oldProgram,
+    });
+    const sourceFile = program.getSourceFile(targetPath) ??
+        program.getSourceFile(path.relative(process.cwd(), targetPath));
+    if (!sourceFile) {
+        return { program, keys: new Set() };
+    }
+    const keys = new Set(program.getSemanticDiagnostics(sourceFile).map(diagnosticKey));
+    return { program, keys };
+}
+const { options, filePath, variants } = workerData;
+const resolvedPath = path.resolve(filePath);
+let originalCode = '';
+try {
+    originalCode = fs.readFileSync(resolvedPath, 'utf8');
+}
+catch {
+    // empty baseline — all mutant errors count as new
+}
+const { program: baseProgram, keys: baselineKeys } = diagnose(options, resolvedPath, originalCode, undefined);
+let prevProgram = baseProgram;
+const compileErrorIds = [];
+for (const variant of variants) {
+    const { program: mutProgram, keys: mutantKeys } = diagnose(options, resolvedPath, variant.code, prevProgram);
+    prevProgram = mutProgram;
+    let newErrors = 0;
+    for (const key of mutantKeys) {
+        if (!baselineKeys.has(key))
+            newErrors++;
+    }
+    if (newErrors > 0) {
+        compileErrorIds.push(variant.id);
+    }
+}
+parentPort.postMessage({ compileErrorIds });

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

@@ -0,0 +1,36 @@
+/**
+ * TypeScript Type Checker for Mutants
+ *
+ * Pre-filters mutants that produce TypeScript compile errors before running
+ * them against tests. This avoids running mutations that would be trivially
+ * detected by the type system, saving significant test execution time.
+ *
+ * Strategy: noLib + noResolve (zero I/O) + baseline comparison
+ * -  noLib: true      → don't load lib.d.ts (huge, causes hangs)
+ * -  noResolve: true  → don't follow user imports (avoids loading project files)
+ * -  Baseline check   → type-check original file first; only flag mutants that
+ *                       introduce NEW errors not present in the original. This
+ *                       eliminates false positives from missing lib/import types.
+ */
+import ts from 'typescript';
+import type { MutineerConfig } from '../types/config.js';
+import type { Variant } from '../types/mutant.js';
+/**
+ * Run type checks for one file group synchronously. Used both by the sync
+ * fallback (test/dev environments) and by the worker thread.
+ */
+export declare function checkFileSync(options: ts.CompilerOptions, filePath: string, fileVariants: readonly Variant[]): string[];
+/**
+ * Check TypeScript types for mutated variants.
+ * Returns a Set of variant IDs that introduce NEW compile errors vs the original.
+ */
+export declare function checkTypes(variants: readonly Variant[], tsconfig: string | undefined, cwd: string): Promise<Set<string>>;
+/**
+ * Determine whether TypeScript type checking should run for this invocation.
+ * Precedence: CLI flag > config field > auto-detect (tsconfig.json presence).
+ */
+export declare function resolveTypescriptEnabled(cliFlag: boolean | undefined, config: MutineerConfig, cwd: string): boolean;
+/**
+ * Extract the tsconfig path from the MutineerConfig typescript option.
+ */
+export declare function resolveTsconfigPath(config: MutineerConfig): string | undefined;

package/dist/runner/ts-checker.js

@@ -0,0 +1,210 @@
+/**
+ * TypeScript Type Checker for Mutants
+ *
+ * Pre-filters mutants that produce TypeScript compile errors before running
+ * them against tests. This avoids running mutations that would be trivially
+ * detected by the type system, saving significant test execution time.
+ *
+ * Strategy: noLib + noResolve (zero I/O) + baseline comparison
+ * -  noLib: true      → don't load lib.d.ts (huge, causes hangs)
+ * -  noResolve: true  → don't follow user imports (avoids loading project files)
+ * -  Baseline check   → type-check original file first; only flag mutants that
+ *                       introduce NEW errors not present in the original. This
+ *                       eliminates false positives from missing lib/import types.
+ */
+import ts from 'typescript';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { Worker } from 'worker_threads';
+import { fileURLToPath } from 'node:url';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('ts-checker');
+/**
+ * Compiler options used for all type checks: fully isolated, zero I/O.
+ * We read strict/noImplicitAny/etc from the user's tsconfig (to catch the
+ * same errors they care about), but always override lib/resolve settings.
+ */
+function resolveCompilerOptions(tsconfig, cwd) {
+    const base = {
+        noEmit: true,
+        skipLibCheck: true,
+        strict: false,
+        noLib: true, // Never load lib.d.ts — huge, causes hangs
+        noResolve: true, // Never follow user imports — avoids loading project files
+    };
+    const searchDir = tsconfig ? path.dirname(path.resolve(cwd, tsconfig)) : cwd;
+    const configPath = ts.findConfigFile(searchDir, ts.sys.fileExists) ?? undefined;
+    if (!configPath)
+        return base;
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+    if (configFile.error) {
+        log.debug(`Failed to read tsconfig at ${configPath}: ${ts.flattenDiagnosticMessageText(configFile.error.messageText, '\n')}`);
+        return base;
+    }
+    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath));
+    // Take user's strictness settings (strict, noImplicitAny, exactOptionalPropertyTypes,
+    // etc.) so we catch the same class of errors they care about, but always override
+    // the I/O settings to keep checks fast and isolated.
+    return {
+        ...parsed.options,
+        noEmit: true,
+        skipLibCheck: true,
+        noLib: true,
+        noResolve: true,
+    };
+}
+/** Stable fingerprint for a diagnostic — used to diff baseline vs mutant errors. */
+function diagnosticKey(d) {
+    return `${d.code}:${d.start ?? -1}`;
+}
+/** Create a compiler host that serves `code` for `targetPath`, real fs for everything else. */
+function makeHost(options, targetPath, code) {
+    const host = ts.createCompilerHost(options);
+    const orig = host.getSourceFile.bind(host);
+    host.getSourceFile = (fileName, langOrOpts) => {
+        if (path.resolve(fileName) === targetPath) {
+            return ts.createSourceFile(fileName, code, langOrOpts);
+        }
+        return orig(fileName, langOrOpts);
+    };
+    return host;
+}
+/** Run semantic diagnostics for `code` in `targetPath`, reusing `oldProgram` if provided. */
+function diagnose(options, targetPath, code, oldProgram) {
+    const host = makeHost(options, targetPath, code);
+    const program = ts.createProgram({
+        rootNames: [targetPath],
+        options,
+        host,
+        oldProgram,
+    });
+    const sourceFile = program.getSourceFile(targetPath) ??
+        program.getSourceFile(path.relative(process.cwd(), targetPath));
+    if (!sourceFile) {
+        return { program, keys: new Set() };
+    }
+    const keys = new Set(program.getSemanticDiagnostics(sourceFile).map(diagnosticKey));
+    return { program, keys };
+}
+/**
+ * Run type checks for one file group synchronously. Used both by the sync
+ * fallback (test/dev environments) and by the worker thread.
+ */
+export function checkFileSync(options, filePath, fileVariants) {
+    const resolvedPath = path.resolve(filePath);
+    const compileErrorIds = [];
+    let originalCode = '';
+    try {
+        originalCode = fs.readFileSync(resolvedPath, 'utf8');
+    }
+    catch {
+        log.debug(`Cannot read ${filePath} for baseline — using empty baseline`);
+    }
+    const { program: baseProgram, keys: baselineKeys } = diagnose(options, resolvedPath, originalCode, undefined);
+    log.debug(`Baseline for ${filePath}: ${baselineKeys.size} error(s)`);
+    let prevProgram = baseProgram;
+    for (const variant of fileVariants) {
+        const { program: mutProgram, keys: mutantKeys } = diagnose(options, resolvedPath, variant.code, prevProgram);
+        prevProgram = mutProgram;
+        let newErrors = 0;
+        for (const key of mutantKeys) {
+            if (!baselineKeys.has(key))
+                newErrors++;
+        }
+        if (newErrors > 0) {
+            compileErrorIds.push(variant.id);
+            log.debug(`Compile error in ${variant.id}: ${newErrors} new error(s)`);
+        }
+    }
+    return compileErrorIds;
+}
+/** Spawn a worker for one file group and resolve with the compile-error IDs. */
+function runWorker(workerPath, options, filePath, variants) {
+    return new Promise((resolve, reject) => {
+        const worker = new Worker(workerPath, {
+            workerData: {
+                options,
+                filePath,
+                variants: variants.map((v) => ({ id: v.id, code: v.code })),
+            },
+        });
+        worker.once('message', (msg) => {
+            resolve(msg.compileErrorIds);
+        });
+        worker.once('error', reject);
+        worker.once('exit', (code) => {
+            if (code !== 0)
+                reject(new Error(`ts-checker worker exited with code ${code}`));
+        });
+    });
+}
+/**
+ * Check TypeScript types for mutated variants.
+ * Returns a Set of variant IDs that introduce NEW compile errors vs the original.
+ */
+export async function checkTypes(variants, tsconfig, cwd) {
+    const compileErrors = new Set();
+    if (variants.length === 0)
+        return compileErrors;
+    const options = resolveCompilerOptions(tsconfig, cwd);
+    // Group variants by source file
+    const byFile = new Map();
+    for (const v of variants) {
+        const list = byFile.get(v.file);
+        if (list)
+            list.push(v);
+        else
+            byFile.set(v.file, [v]);
+    }
+    // In test/dev environments import.meta.url ends in .ts — Node can't load .ts
+    // workers, so fall back to the synchronous path.
+    const isTsSource = import.meta.url.endsWith('.ts');
+    if (isTsSource) {
+        for (const [filePath, fileVariants] of byFile) {
+            for (const id of checkFileSync(options, filePath, fileVariants)) {
+                compileErrors.add(id);
+            }
+        }
+        return compileErrors;
+    }
+    // Parallel worker dispatch
+    const workerPath = fileURLToPath(new URL('./ts-checker-worker.js', import.meta.url));
+    const maxConcurrency = Math.max(os.cpus().length - 1, 1);
+    const entries = Array.from(byFile.entries());
+    for (let i = 0; i < entries.length; i += maxConcurrency) {
+        const batch = entries.slice(i, i + maxConcurrency);
+        const results = await Promise.all(batch.map(([filePath, fileVariants]) => runWorker(workerPath, options, filePath, fileVariants)));
+        for (const ids of results) {
+            for (const id of ids)
+                compileErrors.add(id);
+        }
+    }
+    return compileErrors;
+}
+/**
+ * Determine whether TypeScript type checking should run for this invocation.
+ * Precedence: CLI flag > config field > auto-detect (tsconfig.json presence).
+ */
+export function resolveTypescriptEnabled(cliFlag, config, cwd) {
+    if (cliFlag === true)
+        return true;
+    if (cliFlag === false)
+        return false;
+    const cfgTs = config.typescript;
+    if (cfgTs === false)
+        return false;
+    if (cfgTs !== undefined)
+        return true;
+    // Auto-detect: enable if tsconfig.json exists in cwd
+    return ts.findConfigFile(cwd, ts.sys.fileExists) !== undefined;
+}
+/**
+ * Extract the tsconfig path from the MutineerConfig typescript option.
+ */
+export function resolveTsconfigPath(config) {
+    if (typeof config.typescript === 'object' && config.typescript !== null) {
+        return config.typescript.tsconfig;
+    }
+    return undefined;
+}

package/dist/runner/types.d.ts

@@ -16,6 +16,8 @@ export interface TestRunnerAdapterOptions {
     readonly timeoutMs: number;
     readonly config: MutineerConfig;
     readonly cliArgs: string[];
+    /** Vitest workspace project name to target (from --vitest-project or config) */
+    readonly vitestProject?: string;
 }
 /**
  * Coverage-related configuration detected from the test runner.

package/dist/runner/vitest/__tests__/adapter.spec.js

@@ -122,6 +122,21 @@ describe('Vitest adapter', () => {
         expect(argStr).toContain('--coverage.thresholds.branches=0');
         expect(argStr).toContain('--coverage.thresholds.statements=0');
     });
+    it('strips --shard= flag from vitest args', async () => {
+        const adapter = makeAdapter({ cliArgs: ['--shard=1/4'] });
+        spawnMock.mockImplementationOnce(() => ({
+            on: (evt, cb) => {
+                if (evt === 'exit')
+                    cb(0);
+            },
+        }));
+        await adapter.runBaseline(['test-a'], {
+            collectCoverage: false,
+            perTestCoverage: false,
+        });
+        const args = spawnMock.mock.calls[0][1];
+        expect(args.join(' ')).not.toContain('--shard');
+    });
     it('detects coverage config from vitest config file', async () => {
         const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-vitest-'));
         const cfgPath = path.join(tmp, 'vitest.config.ts');
@@ -140,6 +155,32 @@ describe('Vitest adapter', () => {
         }
     });
 });
+describe('hasCoverageProvider', () => {
+    it('returns true when @vitest/coverage-v8 is resolvable', () => {
+        const adapter = makeAdapter({ cwd: process.cwd() });
+        // coverage-v8 is installed as a devDependency, so this must resolve
+        expect(adapter.hasCoverageProvider()).toBe(true);
+    });
+    it('returns false when neither provider is resolvable', () => {
+        const adapter = makeAdapter({ cwd: '/tmp' });
+        expect(adapter.hasCoverageProvider()).toBe(false);
+    });
+    it('returns true when @vitest/coverage-istanbul is resolvable', () => {
+        const adapter = makeAdapter({ cwd: process.cwd() });
+        const origResolve = require.resolve;
+        const resolveStub = vi
+            .spyOn(require, 'resolve')
+            .mockImplementation((id, opts) => {
+            if (String(id).includes('coverage-v8'))
+                throw new Error('not found');
+            if (String(id).includes('coverage-istanbul'))
+                return '/fake/path';
+            return origResolve(id, opts);
+        });
+        expect(adapter.hasCoverageProvider()).toBe(true);
+        resolveStub.mockRestore();
+    });
+});
 describe('isCoverageRequestedInArgs', () => {
     it('detects enabled coverage flags', () => {
         expect(isCoverageRequestedInArgs(['--coverage'])).toBe(true);

package/dist/runner/vitest/__tests__/plugin.spec.js

@@ -1,5 +1,6 @@
 import { describe, it, expect, afterEach } from 'vitest';
 import fs from 'node:fs/promises';
+import fssync from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { poolMutineerPlugin } from '../plugin.js';
@@ -13,10 +14,21 @@ function getLoadFn() {
     }
     return undefined;
 }
+function getConfigFn() {
+    const plugin = poolMutineerPlugin();
+    if (Array.isArray(plugin)) {
+        return plugin[0]?.config;
+    }
+    if (plugin && typeof plugin === 'object' && 'config' in plugin) {
+        return plugin.config;
+    }
+    return undefined;
+}
 describe('poolMutineerPlugin', () => {
     afterEach(() => {
         ;
         globalThis.__mutineer_redirect__ = undefined;
+        delete process.env.MUTINEER_ACTIVE_ID_FILE;
     });
     it('returns null when no redirect is configured', () => {
         const load = getLoadFn();
@@ -62,4 +74,143 @@ describe('poolMutineerPlugin', () => {
             await fs.rm(tmpDir, { recursive: true, force: true });
         }
     });
+    it('returns schema code when a schema file exists for the source path', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-schema-plugin-'));
+        const sourcePath = path.join(tmpDir, 'source.ts');
+        const mutineerDir = path.join(tmpDir, '__mutineer__');
+        const schemaPath = path.join(mutineerDir, 'source_schema.ts');
+        await fs.mkdir(mutineerDir);
+        await fs.writeFile(schemaPath, '// @ts-nocheck\nconst x = 1', 'utf8');
+        try {
+            const load = getLoadFn();
+            const result = load?.(sourcePath);
+            expect(result).toBe('// @ts-nocheck\nconst x = 1');
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('caches schema content so subsequent loads skip filesystem I/O', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-schema-cache-'));
+        const sourcePath = path.join(tmpDir, 'source.ts');
+        const mutineerDir = path.join(tmpDir, '__mutineer__');
+        const schemaPath = path.join(mutineerDir, 'source_schema.ts');
+        await fs.mkdir(mutineerDir);
+        await fs.writeFile(schemaPath, '// cached schema', 'utf8');
+        // Use the same plugin instance for both calls (shared cache)
+        const plugin = poolMutineerPlugin();
+        const load = plugin?.load?.bind(plugin);
+        try {
+            const first = load?.(sourcePath);
+            expect(first).toBe('// cached schema');
+            // Remove schema file - second call must still return cached content
+            await fs.rm(tmpDir, { recursive: true, force: true });
+            const second = load?.(sourcePath);
+            expect(second).toBe('// cached schema');
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => { });
+        }
+    });
+    it('caches null for paths with no schema to avoid repeated existsSync calls', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-schema-nocache-'));
+        const sourcePath = path.join(tmpDir, 'no-schema.ts');
+        try {
+            const plugin = poolMutineerPlugin();
+            const load = plugin?.load?.bind(plugin);
+            const first = load?.(sourcePath);
+            expect(first).toBeNull();
+            // Create schema file after first call - second call must return null (cached)
+            const mutineerDir = path.join(tmpDir, '__mutineer__');
+            await fs.mkdir(mutineerDir, { recursive: true });
+            await fs.writeFile(path.join(mutineerDir, 'no-schema_schema.ts'), '// late schema', 'utf8');
+            const second = load?.(sourcePath);
+            expect(second).toBeNull();
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('prefers redirect over schema when both are present (fallback mutation path)', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-schema-redirect-'));
+        const sourcePath = path.join(tmpDir, 'source.ts');
+        const mutineerDir = path.join(tmpDir, '__mutineer__');
+        const schemaPath = path.join(mutineerDir, 'source_schema.ts');
+        const mutatedPath = path.join(mutineerDir, 'source_0.ts');
+        await fs.mkdir(mutineerDir);
+        await fs.writeFile(schemaPath, '// schema', 'utf8');
+        await fs.writeFile(mutatedPath, '// mutated', 'utf8');
+        try {
+            ;
+            globalThis.__mutineer_redirect__ = {
+                from: sourcePath,
+                to: mutatedPath,
+            };
+            const load = getLoadFn();
+            const result = load?.(sourcePath);
+            // Redirect wins: fallback mutations use setRedirect + invalidateFile.
+            // The schema must not shadow the mutant code during fallback runs.
+            expect(result).toBe('// mutated');
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    describe('config hook', () => {
+        it('returns null when MUTINEER_ACTIVE_ID_FILE is not set', () => {
+            const config = getConfigFn();
+            const result = config?.({ test: { setupFiles: ['/existing/setup.ts'] } });
+            expect(result).toBeNull();
+        });
+        it('appends setup.mjs to setupFiles when MUTINEER_ACTIVE_ID_FILE is set', () => {
+            const tmpDir = fssync.mkdtempSync(path.join(os.tmpdir(), 'mutineer-config-'));
+            const activeIdFile = path.join(tmpDir, '__mutineer__', 'active_id_w0.txt');
+            process.env.MUTINEER_ACTIVE_ID_FILE = activeIdFile;
+            try {
+                const config = getConfigFn();
+                const result = config?.({
+                    test: { setupFiles: ['/existing/setup.ts'] },
+                });
+                const setupFiles = result?.test?.setupFiles;
+                expect(setupFiles).toContain('/existing/setup.ts');
+                expect(setupFiles.some((f) => f.endsWith('setup.mjs'))).toBe(true);
+            }
+            finally {
+                fssync.rmSync(tmpDir, { recursive: true, force: true });
+                delete process.env.MUTINEER_ACTIVE_ID_FILE;
+            }
+        });
+        it('creates setupFiles array from string value', () => {
+            const tmpDir = fssync.mkdtempSync(path.join(os.tmpdir(), 'mutineer-config2-'));
+            const activeIdFile = path.join(tmpDir, '__mutineer__', 'active_id_w0.txt');
+            process.env.MUTINEER_ACTIVE_ID_FILE = activeIdFile;
+            try {
+                const config = getConfigFn();
+                const result = config?.({ test: { setupFiles: '/single/setup.ts' } });
+                const setupFiles = result?.test?.setupFiles;
+                expect(setupFiles).toContain('/single/setup.ts');
+                expect(setupFiles.length).toBe(2);
+            }
+            finally {
+                fssync.rmSync(tmpDir, { recursive: true, force: true });
+                delete process.env.MUTINEER_ACTIVE_ID_FILE;
+            }
+        });
+        it('creates setupFiles from empty config when no existing setupFiles', () => {
+            const tmpDir = fssync.mkdtempSync(path.join(os.tmpdir(), 'mutineer-config3-'));
+            const activeIdFile = path.join(tmpDir, '__mutineer__', 'active_id_w0.txt');
+            process.env.MUTINEER_ACTIVE_ID_FILE = activeIdFile;
+            try {
+                const config = getConfigFn();
+                const result = config?.({});
+                const setupFiles = result?.test?.setupFiles;
+                expect(setupFiles.length).toBe(1);
+                expect(setupFiles[0]).toMatch(/setup\.mjs$/);
+            }
+            finally {
+                fssync.rmSync(tmpDir, { recursive: true, force: true });
+                delete process.env.MUTINEER_ACTIVE_ID_FILE;
+            }
+        });
+    });
 });