oxmutate 1.1.0 → 1.2.1

package/README.md

@@ -189,7 +189,7 @@ setting a value inside the worker that already has the tests loaded.
 | Re-parse | Every instrumented file is parsed again before it runs; one that does not parse stops the run (exit 3) instead of scoring a broken file |
 | Canary | The unmutated test must still pass after mutants run in a context, with its `beforeEach`/`afterEach` hooks re-run around every run, file-level ones included; if a mutant left a cache, a registry or a fixture behind, the context restarts and the suspect verdicts run again. A kill that follows unchecked runs is checked at once and decided again from clean state, so no kill rests on another mutant's leftovers |
 | Survivor confirmation | A survivor is re-run with the mutant armed across its covering tests in one file, as Stryker arms it, so a mutant that only fails across tests is killed |
-| Watchdog | A synchronous runaway is stopped and its server replaced; the stop is re-run at 3x the budget before it is reported as a timeout |
+| Watchdog | A synchronous runaway is stopped and its server replaced; the stop is re-run at 3x the budget before it is reported as a timeout. A stop whose worker was idle inside a test body (its event loop still turning, by a heartbeat, and its server under 25% of a core) is a hang, not a slow test: it is a Timeout as it stands, the way Stryker scores it, with no 3x re-run |
 | Static mutants | Code that runs at import is decided in a live worker: the mutant is armed, the module registry reset and the test file collected again, against the files that load it. A file whose collection changes globals, `process.env` or a built-in prototype, or a mutant that leaves a trace, goes back to a fresh worker per mutant (`OXMUTATE_ISOLATE_STATIC=1` sends all of them there) |
 | Flaky tests | Tests that behave differently across two dry runs have their mutants re-run; a verdict that changes is reported `flaky` |
 | No orphans | Every Vitest server exits when its run does, killed or not |
@@ -261,7 +261,8 @@ head-to-head runs (`bench/burgee-pair.mts`, concurrency 4, one tool after the ot
 
 The ceiling depends on the suite as much as the tool: controlroom's own `vitest run` takes ~8 s and
 every fresh worker imports React and Ink, so even zero overhead would make it ~6x. The figures to
-publish will come from the `oxmutate-bench.yml` lane on a runner nothing else shares.
+publish come from `bench/burgee-pair.mts`, run locally on a quiet machine: no mutation run happens
+in GitHub Actions (`D-20261101-no-mutation-in-gha`).
 
 ## Benchmarks
 

package/dist/bin.js

@@ -2,4 +2,3 @@
 import { run } from 'burgee';
 import { program } from './cli.js';
 await run(program);
-//# sourceMappingURL=bin.js.map

package/dist/checker.js

@@ -1,46 +1,22 @@
-/**
- * The type checker (Stryker's `checkers: ['typescript']`): a surviving mutant that does not
- * type-check is a CompileError, not a survivor. A survivor is what someone writes a test for, and
- * a test cannot kill a program the compiler refuses; Stryker's TypeScript checker exists for the
- * same reason.
- *
- * It checks survivors only, where Stryker checks every mutant before running it. A killed mutant
- * that would not have compiled changes nothing anyone acts on, and a full project type check per
- * mutant is the costliest step there is. The difference: such a mutant is Killed here where Stryker
- * would score it CompileError, which can move a score that enables the checker by its share.
- *
- * The project's own compiler, `tsgo` when installed and `tsc` otherwise, over its own tsconfig.
- * Survivors are checked in batches with at most one mutant per file, and each error is laid at the
- * mutant in the file it names. An error in a file no mutant of the batch touched (a type that
- * flowed across files) sends that batch back one mutant at a time, so no verdict is a guess.
- */
 import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { ambientRuntime, isWindows, run as spawn } from 'bellpull';
 import { makeSandbox } from './command-runner.js';
 const OUTPUT_TAIL = 1500;
-/**
- * `src/a.ts(3,7): error TS2322: …` — tsc's and tsgo's `--pretty false` shape. No anchors: the lazy
- * first group already makes the leftmost match start the line, and the greedy last one ends it.
- */
 const DIAGNOSTIC = /(.+?)\((\d+),(\d+)\): error (TS\d+: .*)/;
-/** The source with one mutant applied. Columns are UTF-16 and 1-based, as JavaScript counts. */
 export function applyMutant(source, m) {
     const starts = [0];
     for (let i = source.indexOf('\n'); i !== -1; i = source.indexOf('\n', i + 1))
         starts.push(i + 1);
-    // Stryker disable next-line NumericLiteral: `starts` holds every line the checker reports, so the fallback never runs
     const at = (p) => (starts[p.line - 1] ?? 0) + p.column - 1;
     return source.slice(0, at(m.start)) + m.replacement + source.slice(at(m.end));
 }
-/** Errors per file (repository-relative), from the compiler's output. */
 export function parseDiagnostics(output, cwd) {
     const errors = new Map();
     for (const line of output.split('\n')) {
         const hit = DIAGNOSTIC.exec(line.trim());
         if (!hit)
             continue;
-        // Stryker disable next-line StringLiteral: all four groups take part in every match, so the defaults are never used; they are there for the type
         const [, name = '', lineNo = '', , message = ''] = hit;
         const file = path.relative(cwd, path.resolve(cwd, name)).split(path.sep).join('/');
         if (!errors.has(file))
@@ -48,7 +24,6 @@ export function parseDiagnostics(output, cwd) {
     }
     return errors;
 }
-/** Batches of survivors with at most one per file, so each error names its mutant. */
 export function batches(items) {
     const out = [];
     for (const m of items) {
@@ -60,7 +35,6 @@ export function batches(items) {
     }
     return out;
 }
-/** npm's .bin entry for tsgo: `tsgo.cmd` on Windows, where the extensionless file beside it is a shell script. */
 export const tsgoBin = (windows) => (windows ? 'tsgo.cmd' : 'tsgo');
 function compiler(o) {
     if (o.command)
@@ -68,12 +42,10 @@ function compiler(o) {
     const tsgo = path.join(o.root, 'node_modules', '.bin', tsgoBin(isWindows(ambientRuntime())));
     return existsSync(tsgo) ? [tsgo] : ['npx', 'tsc'];
 }
-/** The undetected mutants that do not type-check, each with the compiler's first error in its file. */
 export async function checkSurvivors(o, survivors) {
     const failing = new Map();
     if (survivors.length === 0)
         return failing;
-    // Stryker disable next-line StringLiteral: compiler() never returns an empty list, so the default is never taken; it is there for the type
     const [command = '', ...prefix] = compiler(o);
     const args = [...prefix, '--noEmit', '--pretty', 'false', '-p', o.tsconfig];
     const sandboxes = Array.from({ length: Math.max(1, Math.min(o.concurrency, survivors.length)) }, () => makeSandbox(o.root));
@@ -82,7 +54,6 @@ export async function checkSurvivors(o, survivors) {
             const r = await spawn(command, args, { cwd: sandbox, runtime: ambientRuntime() });
             return { ok: r.ok, errors: parseDiagnostics(`${r.stdout}\n${r.stderr}`, sandbox), output: `${r.stdout}${r.stderr}` };
         };
-        // Stryker disable next-line StringLiteral: there is always at least one sandbox, so the fallback is never used; it is there for the type
         const base = await check(sandboxes[0] ?? '');
         if (!base.ok)
             throw new Error(`the project does not type-check with no mutant applied (\`${[command, ...args].join(' ')}\`): ${base.output.trim().slice(-OUTPUT_TAIL)}. fix: make the type check pass first, or drop checkers`);
@@ -98,7 +69,7 @@ export async function checkSurvivors(o, survivors) {
             const touched = new Set(batch.map((m) => m.file));
             if (batch.length > 1 && [...r.errors.keys()].some((f) => !touched.has(f))) {
                 for (const m of batch)
-                    await run(sandbox, [m]); // an error that crossed files: one at a time
+                    await run(sandbox, [m]);
                 return;
             }
             for (const m of batch) {
@@ -115,9 +86,7 @@ export async function checkSurvivors(o, survivors) {
         return failing;
     }
     finally {
-        // No `force`: each sandbox was made above and nothing else removes it.
         for (const s of sandboxes)
             rmSync(s, { recursive: true });
     }
 }
-//# sourceMappingURL=checker.js.map

package/dist/child.js

@@ -1,24 +1,14 @@
-/**
- * A Vitest server in its own process. It starts the project's Vitest once and then runs work
- * units sent by the coordinator over IPC, re-running the same instance (~0.2 s a run against
- * ~1.5 s for a fresh Vitest). The coordinator kills the process when a mutant loops
- * synchronously, a hang that no in-worker timeout and no `cancelCurrentRun()` can interrupt
- * (both measured, 2026-10-26), and hands the rest of the unit to another server.
- *
- *   node child.js <server.json>     IPC: ← { type: 'run', unit }   → { type: 'ready' | 'done' }
- *
- * Vitest is resolved from the project being tested, like Stryker's vitest-runner does, so the
- * project's own Vitest version and config run its tests.
- */
 import { readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { ExitCode } from 'burgee';
+import { BEAT_ENV, beatFile, CPU_SAMPLE_MS } from './heartbeat.js';
 import { resolveEsm } from './resolve.js';
-import { ACTIVE_MUTANT_ENV, argv, env, exit } from './runtime.js';
+import { ACTIVE_MUTANT_ENV, argv, env, exit, pid } from './runtime.js';
 import { instrumentedSources } from './vite-plugin.js';
 const config = JSON.parse(readFileSync(argv[2] ?? '', 'utf8'));
 env['NODE_ENV'] ??= 'test';
+env[BEAT_ENV] = beatFile(path.dirname(config.instrumentedMap), pid);
 const vitestNode = (await import(resolveEsm('vitest/node', config.root)));
 const runner = fileURLToPath(new URL('./runner.js', import.meta.url));
 const silent = { onInit() { }, onFinished() { } };
@@ -34,25 +24,13 @@ const vitest = await vitestNode.createVitest('test', {
     reporters: env['OXMUTATE_DEBUG_VITEST'] ? ['default'] : [silent],
     coverage: { enabled: false },
     passWithNoTests: true,
-    // Bail is ours (per mutant); Vitest must run every test it is handed.
     bail: 0,
-    // Vitest 5's persistent module cache keys on the file on disk, not on what a plugin serves,
-    // so it served a previous run's instrumentation: every mutant whose id had changed since got
-    // no coverage (burgee/paratext, 2026-10-27: 6% agreement until this was off). Off under both
-    // spellings (top-level in Vitest 5, `experimental` in 4.x).
     fsModuleCache: false,
     experimental: { fsModuleCache: false },
     ...(config.inlineDeps && { server: { deps: { inline: true } } }),
-}, 
-// A private Vite cache per run, so no cache outside this run can answer for a mutated file.
-{ plugins: [instrumentedSources(config.instrumentedMap)], cacheDir: path.join(path.dirname(config.instrumentedMap), 'vite-cache') });
-// A config with `projects` resolves each project's `runner` and `isolate` from its own inline
-// config, never from these options, so its tests ran without oxmutate's runner and the dry run
-// recorded none (burgee, weekly run 40783405734, 2026-10-28). Each project keeps its own pool:
-// burgee's run in forks, and its process.env lock fails under threads.
+}, { plugins: [instrumentedSources(config.instrumentedMap)], cacheDir: path.join(path.dirname(config.instrumentedMap), 'vite-cache') });
 for (const project of vitest.projects)
     Object.assign(project.config, { runner, isolate: true });
-/** Has the runner recorded a kill for this mutant in this unit's results yet? */
 function killed(results, id) {
     let text = '';
     try {
@@ -63,17 +41,11 @@ function killed(results, id) {
     }
     return text.split('\n').some((line) => line.includes(`"id":"${id}"`) && line.includes('"killed":true'));
 }
-/** An `isolated` unit: its mutants armed one after another, each across its files. */
 async function runIsolated(unit) {
-    // Stop a file at its first failing test: one failure kills the mutant, and the rest of the
-    // file is wasted time (burgee/paratext hyperlinks.test.ts: 2.3 s a run, the first failure
-    // typically in its first tests). Read per start, so dry and warm runs still run everything
-    // (measured on Vitest 4.1, 2026-10-27).
     vitest.config.bail = 1;
     try {
         for (const item of unit.batch ?? []) {
             env[ACTIVE_MUTANT_ENV] = item.id;
-            // The runaway guard warm runs have: a loop the mutant causes stops at the limit, not the watchdog.
             if (item.hitLimit)
                 env['OXMUTATE_HIT_LIMIT'] = String(item.hitLimit);
             else
@@ -83,8 +55,6 @@ async function runIsolated(unit) {
             else
                 delete env['OXMUTATE_ONLY_TESTS'];
             writeFileSync(unit.progress, `${item.id} ${String(Date.now())}\n`);
-            // One file at a time, cheapest first (the coordinator orders them), stopping at the first
-            // file that kills the mutant: Stryker runs every file for every isolated mutant.
             for (const file of item.files) {
                 await vitest.start([file]);
                 if (killed(unit.results, item.id))
@@ -101,8 +71,6 @@ async function runIsolated(unit) {
     writeFileSync(unit.progress, '');
 }
 async function runUnit(unit) {
-    // Workers copy the environment when they start, so each run sees the unit's settings
-    // (verified across re-runs of one instance, 2026-10-26).
     env['OXMUTATE_MODE'] = unit.mode;
     env['OXMUTATE_RESULTS'] = unit.results;
     env['OXMUTATE_PROGRESS'] = unit.progress;
@@ -120,27 +88,26 @@ async function runUnit(unit) {
     if (unit.mode === 'isolated')
         await runIsolated(unit);
     else {
-        // A dry run names itself in the progress file, so the watchdog holds it to its budget.
         if (unit.mode === 'dry')
             writeFileSync(unit.progress, `dry ${String(Date.now())}\n`);
         await vitest.start(unit.files.length ? unit.files : undefined);
     }
 }
-/** How long `close` waits for `vitest.close()` before the server exits regardless. */
 const CLOSE_GRACE_MS = 2000;
 process.on('message', (msg) => {
     if (msg.type === 'run' && msg.unit) {
         runUnit(msg.unit).then(() => process.send?.({ type: 'done' }), (error) => process.send?.({ type: 'done', error: error instanceof Error ? error.message : String(error) }));
     }
     else if (msg.type === 'close') {
-        // A worker thread stuck in a runaway mutant never lets `vitest.close()` settle: exit anyway.
         setTimeout(() => exit(ExitCode.OK), CLOSE_GRACE_MS).unref();
         void vitest.close().finally(() => exit(ExitCode.OK));
     }
 });
-// The coordinator is gone (finished, crashed or killed): nothing will read this server's results,
-// and a worker thread may still be looping in a mutant. Two such servers were found spinning at
-// 100% CPU 11 hours after their run ended, and slowed the next run 50x (2026-10-27).
 process.on('disconnect', () => exit(ExitCode.OK));
+const sendCpu = () => {
+    const { user, system } = process.cpuUsage();
+    process.send?.({ type: 'cpu', at: Date.now(), us: user + system });
+};
+sendCpu();
+setInterval(sendCpu, CPU_SAMPLE_MS).unref();
 process.send?.({ type: 'ready' });
-//# sourceMappingURL=child.js.map

package/dist/cli.js

@@ -1,9 +1,3 @@
-/**
- * oxmutate's command line, declared once on burgee: help, `--json`, `--schema`, `--format=agent`,
- * completions and the MCP server are projected from this declaration (spec R17). Handlers return
- * data; the text a person reads rides along under burgee's text symbol, so the agent surfaces
- * carry exactly the data.
- */
 import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { defineCommand, defineProgram, ExitCode } from 'burgee';
@@ -31,7 +25,6 @@ function survivorRecord(m) {
 function summaryData(r, written) {
     const count = (s) => r.mutants.filter((m) => m.status === s).length;
     const data = {
-        // burgee N7: an idempotent command says whether it changed anything (reports were written).
         changed: written.length > 0,
         version: VERSION,
         score: Number(r.score.mutationScore.toFixed(2)),
@@ -50,8 +43,6 @@ function summaryData(r, written) {
     data[TEXT] = () => textSummary(r);
     return data;
 }
-/** The `run` flags that override a config key, as the `Partial<Options>` loadOptions applies last. */
-/** How many weakened mutants the error line names; the JSON report has them all. */
 const WEAKENED_SHOWN = 3;
 function overridesFrom(o, root) {
     const overrides = {};
@@ -162,4 +153,3 @@ export const program = defineProgram({
     description: 'Mutation testing on the oxc engine: Stryker-compatible, built for CI and coding agents',
     commands: [runCommand, survivorsCommand],
 });
-//# sourceMappingURL=cli.js.map

package/dist/command-runner.js

@@ -1,27 +1,9 @@
-/**
- * The command runner (Stryker's `testRunner: 'command'`): any test command, one process per
- * mutant, the escape hatch for a suite that is not Vitest. A non-zero exit kills the mutant, a run
- * past its budget is a timeout, and a zero exit is a survivor. There is no coverage, so every
- * mutant runs the whole command, as with Stryker's.
- *
- * An arbitrary command cannot be served sources from memory, so this is the one path with a
- * sandbox: a copy of the project under `<root>/.oxmutate-tmp/`, with the instrumented files
- * written into it. Inside the project, as Stryker's `.stryker-tmp` is, so module resolution walks
- * up to the same `node_modules` (a monorepo's hoisted ones included). The armed mutant reaches the
- * instrumented code through `__OXMUTATE_ACTIVE_MUTANT__`, which the runtime header reads.
- */
 import { cpSync, mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { ambientRuntime, run as spawn } from 'bellpull';
 import { ACTIVE_MUTANT_ENV, env } from './runtime.js';
 const SANDBOX_DIR = '.oxmutate-tmp';
-/** Stryker's default `ignorePatterns`, plus this sandbox. */
 const SKIP = new Set(['node_modules', '.git', 'reports', 'coverage', '.stryker-tmp', SANDBOX_DIR]);
-/**
- * A copy of the project under `<root>/.oxmutate-tmp/`, for the paths that need files on disk (the
- * command runner, the type checker). Inside the project so module resolution walks up to the same
- * `node_modules`; entry by entry, since a directory cannot be copied into itself.
- */
 export function makeSandbox(root) {
     const parent = path.join(root, SANDBOX_DIR);
     mkdirSync(parent, { recursive: true });
@@ -32,21 +14,13 @@ export function makeSandbox(root) {
     return sandbox;
 }
 const MS_PER_MINUTE = 60_000;
-/** How much of a failing dry run's output the error keeps. */
 const OUTPUT_TAIL = 1500;
-/**
- * The least slack a process-per-mutant run gets: Stryker's own default `timeoutMS`. oxmutate's
- * 500 ms default is sized for a warm in-process run; a fresh process's start-up varies by seconds
- * on a loaded machine, and at 500 ms the e2e fixture read false timeouts (2026-10-27).
- */
 const PROCESS_SLACK_MS = 5000;
-/** Runs the command over every mutant not already decided; returns the dry run's time. */
 export async function runCommandMutants(o, mutants) {
     const sandbox = makeSandbox(o.root);
     try {
         for (const [file, code] of Object.entries(o.codeMap))
             writeFileSync(path.join(sandbox, path.relative(o.root, file)), code);
-        // Stryker splits the command on spaces and runs it without a shell; so does this.
         const [command = '', ...args] = o.command.trim().split(/\s+/);
         const once = (timeout, id) => spawn(command, args, { cwd: sandbox, runtime: ambientRuntime(), timeout, env: id ? { ...env, [ACTIVE_MUTANT_ENV]: id } : { ...env } });
         const dryBudget = o.dryRunTimeoutMinutes * MS_PER_MINUTE;
@@ -80,4 +54,3 @@ export async function runCommandMutants(o, mutants) {
         rmSync(sandbox, { recursive: true, force: true });
     }
 }
-//# sourceMappingURL=command-runner.js.map

package/dist/config.js

@@ -1,16 +1,8 @@
-/**
- * Options, read from `stryker.config.*` as it stands (migration is a no-op: the file Stryker reads
- * is the file oxmutate reads) and from `oxmutate.config.*`, which wins where both set a key.
- * Every key Stryker documents that oxmutate does not use is reported, never silently dropped
- * (spec R15).
- */
 import { existsSync, readFileSync } from 'node:fs';
 import { availableParallelism } from 'node:os';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import {} from './native.js';
 import { resolveEsm } from './resolve.js';
-import {} from './spec-oracle.js';
 const NOT_NEEDED = {
     inPlace: 'oxmutate never copies or rewrites the project; instrumented sources are served from memory',
     tempDirName: 'no sandbox directory exists',
@@ -35,10 +27,6 @@ const NOT_NEEDED = {
     force: 'use --no-incremental',
     checkerNodeArgs: 'not implemented',
 };
-/**
- * Defaults where the config sets nothing. Stryker's, except the per-mutant slack: Stryker's
- * `timeoutMS` is 5000, and a warm run needs far less (cli.ts `--mutant-timeout`).
- */
 const MAX_DEFAULT_CONCURRENCY = 8;
 const DEFAULT_TIMEOUT_MS = 500;
 const DEFAULT_TIMEOUT_FACTOR = 1.5;
@@ -48,7 +36,6 @@ const DEFAULT_DRY_RUN_MINUTES = 5;
 const USED = new Set(['mutate', 'vitest', 'concurrency', 'timeoutMS', 'timeoutFactor', 'thresholds', 'ignoreStatic', 'reporters', 'jsonReporter', 'htmlReporter', 'incremental', 'incrementalFile', '$schema', 'mutator', 'dryRunOnly', 'dryRunTimeoutMinutes', 'buildCommand', 'testRunnerNodeArgs', 'allowEmpty', 'warnings', 'testRunner', 'commandRunner', 'checkers', 'tsconfigFile']);
 async function loadFile(file) {
     if (file.endsWith('.json')) {
-        // Stryker disable next-line StringLiteral: without an encoding readFileSync returns a Buffer, which JSON.parse reads as UTF-8 text all the same
         return JSON.parse(readFileSync(file, 'utf8'));
     }
     const mod = (await import(pathToFileURL(file).href));
@@ -63,17 +50,9 @@ function find(root, base) {
     }
     return undefined;
 }
-/** The Vite (and Vite+) config files, in the order Vite and Vitest look for them. */
 const VITE_CONFIGS = ['vite.config', 'vitest.config'].flatMap((base) => ['.ts', '.mts', '.cts', '.js', '.mjs', '.cjs'].map((ext) => `${base}${ext}`));
-/**
- * The `mutate` block of the project's Vite config — the Vite+ shape, one file for test, lint, fmt
- * and mutate. Loaded with the project's own Vite (`loadConfigFromFile`), so a TypeScript config and
- * its imports work as Vite sees them. Inside the block the file list is `include`, as Vitest names
- * it; Stryker's `mutate` is accepted too. No Vite installed, or no block: nothing.
- */
 async function fromViteConfig(root) {
     const file = VITE_CONFIGS.map((f) => path.join(root, f)).find((f) => existsSync(f));
-    // Stryker disable next-line ConditionalExpression: without the guard Vite searches the root for the same names, finds none, and returns null, which returns undefined below
     if (!file)
         return undefined;
     let vite;
@@ -83,14 +62,11 @@ async function fromViteConfig(root) {
     catch {
         return undefined;
     }
-    // Stryker disable next-line StringLiteral: the log level only decides whether Vite prints, and a config that loads prints nothing at any level
     const level = 'silent';
     const loaded = await vite.loadConfigFromFile({ command: 'serve', mode: 'test' }, file, root, level);
-    // Stryker disable next-line OptionalChaining: given a file that exists, Vite returns a config or throws; null is its answer only when it found no file
     const block = loaded?.config['mutate'];
     if (!block || typeof block !== 'object')
         return undefined;
-    // `include` is the Vitest spelling; Stryker's `mutate`, when given too, is spread over it.
     const { include, ...rest } = block;
     return { file, block: { mutate: include, ...rest } };
 }
@@ -140,7 +116,6 @@ export async function loadOptions(root, overrides = {}, configFile) {
         allowEmpty: raw['allowEmpty'] === true,
         specOracles: raw['specOracles'] ?? [],
         ignore: raw['ignore'] ?? [],
-        // Stryker disable next-line ArrayDeclaration: a placeholder element is not 'typescript' either, so includes() is false as for an empty list
         typeCheck: (raw['checkers'] ?? []).includes('typescript'),
         tsconfigFile: raw['tsconfigFile'] ?? 'tsconfig.json',
         typeChecker: typeof raw['typeChecker'] === 'string' ? raw['typeChecker'] : undefined,
@@ -149,17 +124,14 @@ export async function loadOptions(root, overrides = {}, configFile) {
         ...overrides,
     };
 }
-// One `\s` after next-line is enough: the list's class takes any further whitespace, and is trimmed.
 const DIRECTIVE = /\/\/\s*(?:Stryker|oxmutate)\s+disable\s+next-line\s([\w,\s]+?|all)\s*:\s*(.*)/i;
 const NO_REASON = /\/\/\s*(?:Stryker|oxmutate)\s+disable\s+next-line\s([\w,\s]+?|all)\s*$/i;
-/** Disable directives in a file. A directive without a reason is an error (burgee's own rule). */
 export function disables(source, file) {
     const out = [];
     const errors = [];
     source.split('\n').forEach((line, i) => {
         const m = DIRECTIVE.exec(line);
         if (m) {
-            // Stryker disable next-line StringLiteral: both groups take part in every match, so the fallback is never used; it is there for the type
             const [list, reason] = [(m[1] ?? '').trim(), (m[2] ?? '').trim()];
             out.push({ line: i + 2, mutators: list.toLowerCase() === 'all' ? 'all' : list.split(',').map((s) => s.trim()).filter(Boolean), reason });
         }
@@ -169,4 +141,3 @@ export function disables(source, file) {
     });
     return { disables: out, errors };
 }
-//# sourceMappingURL=config.js.map

package/dist/coordinator.d.ts

@@ -36,10 +36,16 @@ export interface RunStats {
     instrumentMs: number;
     dryRunMs: number;
     mutationMs: number;
+    /** Static mutants decided in live workers (section 5b), between the warm and the isolated phases. */
+    staticMs: number;
+    /** Unarmed re-collections in that phase, the guard each live static verdict waits on (runner.ts). */
+    staticRecollections: number;
     isolatedMs: number;
     wallMs: number;
     testExecutions: number;
     watchdogKills: number;
+    /** Of `watchdogKills`, the stops whose worker was idle, waiting (heartbeat.ts). In an isolated run each is a Timeout as it stands. */
+    idleStalls: number;
     crashes: number;
     canaryFiles: number;
     /** Contexts restarted because a mutant left state behind (the per-execution canary fired). */