oxmutate 2.1.0 → 2.3.0

package/dist/child.js

@@ -83,6 +83,10 @@ async function runUnit(unit) {
         env['OXMUTATE_STATIC'] = JSON.stringify(unit.staticIds);
     else
         delete env['OXMUTATE_STATIC'];
+    if (unit.staticGroups)
+        env['OXMUTATE_STATIC_GROUPS'] = JSON.stringify(unit.staticGroups);
+    else
+        delete env['OXMUTATE_STATIC_GROUPS'];
     if (unit.hitLimits)
         env['OXMUTATE_HIT_LIMITS'] = JSON.stringify(unit.hitLimits);
     else

package/dist/cli.js

@@ -60,6 +60,10 @@ function overridesFrom(o, root) {
         overrides.strykerCompat = true;
     if (o['ignoreStatic'] === true)
         overrides.ignoreStatic = true;
+    if (typeof o['staticGroup'] === 'number')
+        overrides.staticGroup = Math.max(1, Math.floor(o['staticGroup']));
+    if (typeof o['staticBudget'] === 'number' && o['staticBudget'] >= 1)
+        overrides.staticBudgetMs = Math.floor(o['staticBudget']);
     if (o['incremental'] === true)
         overrides.incremental = true;
     if (typeof o['flakyReruns'] === 'number')
@@ -90,6 +94,8 @@ const runCommand = defineCommand({
         mutantTimeout: { type: 'number', description: 'absolute slack per mutant, ms (default 500; Stryker 5000)' },
         strykerCompat: { type: 'boolean', description: 'reproduce Stryker 10.0.0 skips (no mutants inside `as` casts or enums)' },
         ignoreStatic: { type: 'boolean', description: 'skip static mutants (module-level code): faster, and the score leaves them out' },
+        staticGroup: { type: 'number', description: 'arm this many static mutants together in a file that is not their first (default 1; a heuristic, audited)' },
+        staticBudget: { type: 'number', description: 'the most the static phase may take, ms; static mutants still undecided then are left out of the score' },
         incremental: { type: 'boolean', description: 'reuse verdicts whose source and covering tests did not change' },
         flakyReruns: { type: 'number', description: 're-runs for verdicts with nondeterministic tests (default 2; 0 disables)' },
         reporter: { type: 'string', description: 'comma-separated: clear-text, json, sarif, html (default clear-text,json)' },
@@ -123,6 +129,10 @@ const runCommand = defineCommand({
             stderr.write(`oxmutate: the change weakened its tests: ${String(weakened.length)} mutant(s) the tests at ${result.frozen?.base ?? ''} detect now survive (${weakened.slice(0, WEAKENED_SHOWN).map((w) => `${w.file}:${String(w.line)} ${w.mutatorName}`).join('; ')}). fix: restore the assertions the change removed, or replace them with ones that kill these mutants\n`);
             data['exitCode'] = ExitCode.RUNTIME;
         }
+        if (result.stats.staticAuditDisagreed > 0) {
+            stderr.write(`oxmutate: ${String(result.stats.staticAuditDisagreed)} mutant(s) reported as survivors by a group were killed when run alone; they are reported Killed. fix: run without static.group (--static-group 1); two of this file's mutants hide each other when armed together\n`);
+            data['exitCode'] = ExitCode.RUNTIME;
+        }
         const floor = options_.thresholds.break;
         if (floor !== null && result.score.mutationScore < floor) {
             stderr.write(`oxmutate: mutation score ${result.score.mutationScore.toFixed(2)}% is below the break threshold ${String(floor)}%. fix: kill the survivors listed above, or lower thresholds.break deliberately\n`);

package/dist/config.d.ts

@@ -6,6 +6,8 @@ export interface Thresholds {
     /** Fail the run (exit 1) below this score. `null`: never fail on score. */
     break: number | null;
 }
+/** Why a static mutant is Ignored when `static.budgetMs` ran out before it was decided; the summary counts them by it. */
+export declare const STATIC_BUDGET_REASON = "static mutant (static budget spent)";
 /** Why a static mutant is Ignored under `ignoreStatic`; the summary counts them by it. */
 export declare const IGNORE_STATIC_REASON = "static mutant (ignoreStatic)";
 export interface Options {
@@ -19,6 +21,18 @@ export interface Options {
     excludedMutations: string[];
     /** Score static mutants (Stryker skips them with `ignoreStatic`). */
     ignoreStatic: boolean;
+    /**
+     * How many static mutants are armed together in a test file that is not their first (`static.group`).
+     * 1, the default, arms each alone. A larger group is faster where most of them survive, and is a
+     * heuristic: two mutants can hide each other, so one in twenty group survivors is run again alone.
+     */
+    staticGroup: number;
+    /**
+     * The most the static phase may take, in milliseconds (`static.budgetMs`). No new static unit
+     * starts once it is spent; a static mutant still undecided then is Ignored, with a reason, and
+     * left out of the score. A kill found before that stands. Unset: no limit.
+     */
+    staticBudgetMs?: number | undefined;
     strykerCompat: boolean;
     reporters: string[];
     jsonReport: string;
@@ -97,6 +111,9 @@ export interface MutateConfig {
         excludedMutations?: string[];
     };
     ignoreStatic?: boolean;
+    static?: {
+        group?: number;
+    };
     reporters?: ('clear-text' | 'json' | 'html' | 'sarif' | 'progress' | 'progress-append-only' | 'ci' | 'dots')[];
     jsonReporter?: {
         fileName?: string;

package/dist/config.js

@@ -3,6 +3,15 @@ import { availableParallelism } from 'node:os';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { resolveEsm } from './resolve.js';
+function staticGroupOf(group) {
+    const asked = Math.floor(Number(group));
+    return asked >= 2 ? asked : 1;
+}
+function staticBudgetOf(ms) {
+    const asked = Math.floor(Number(ms));
+    return asked >= 1 ? asked : undefined;
+}
+export const STATIC_BUDGET_REASON = 'static mutant (static budget spent)';
 export const IGNORE_STATIC_REASON = 'static mutant (ignoreStatic)';
 const NOT_NEEDED = {
     inPlace: 'oxmutate never copies or rewrites the project; instrumented sources are served from memory',
@@ -34,7 +43,7 @@ const DEFAULT_TIMEOUT_FACTOR = 1.5;
 const DEFAULT_THRESHOLD_HIGH = 80;
 const DEFAULT_THRESHOLD_LOW = 60;
 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']);
+const USED = new Set(['mutate', 'vitest', 'concurrency', 'timeoutMS', 'timeoutFactor', 'thresholds', 'ignoreStatic', 'static', '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')) {
         return JSON.parse(readFileSync(file, 'utf8'));
@@ -100,6 +109,8 @@ export async function loadOptions(root, overrides = {}, configFile) {
         thresholds: { high: thresholds.high ?? DEFAULT_THRESHOLD_HIGH, low: thresholds.low ?? DEFAULT_THRESHOLD_LOW, break: thresholds.break ?? null },
         excludedMutations: mutator.excludedMutations ?? [],
         ignoreStatic: raw['ignoreStatic'] === true,
+        staticGroup: staticGroupOf(raw['static']?.group),
+        staticBudgetMs: staticBudgetOf(raw['static']?.budgetMs),
         strykerCompat: raw['strykerCompat'] === true,
         reporters: raw['reporters'] ?? ['clear-text', 'json'],
         jsonReport: path.resolve(root, json.fileName ?? 'reports/mutation/mutation.json'),

package/dist/coordinator.d.ts

@@ -42,6 +42,12 @@ export interface RunStats {
     staticMs: number;
     /** Unarmed re-collections in that phase, the guard each live static verdict waits on (runner.ts). */
     staticRecollections: number;
+    /** Groups of static mutants armed together (`static.group`), and how many had to be split. */
+    staticGroupRuns: number;
+    staticGroupSplits: number;
+    /** Group survivors run again alone, and those that failed alone: kills a group hid, reported Killed. */
+    staticAuditSampled: number;
+    staticAuditDisagreed: number;
     isolatedMs: number;
     wallMs: number;
     testExecutions: number;
@@ -70,6 +76,8 @@ export interface RunStats {
     pollutionRestarts: number;
     /** Units after which the project on disk had changed (diskguard.ts): put back, and their verdicts and those of the units running beside them re-run. */
     diskWrites: number;
+    /** The first few paths those writes touched, so a suite's own scratch in a tracked folder can be told from a mutant's write. */
+    diskWritePaths: string[];
     /** Survivors of the warm run that a whole-file re-run killed (cross-test effects). */
     survivorsOverturned: number;
     /** Watchdog timeouts that finished when re-run with 3x the budget: the machine was slow, not the mutant. */
@@ -108,6 +116,12 @@ export interface RunResult {
 }
 export declare class InstrumentFault extends Error {
 }
+/**
+ * Mutants as groups of at most `size`. Only value mutants are grouped (GROUPABLE), and no two in a
+ * group touch the same source text. First fit, in the order given; every other mutant is a group of
+ * one.
+ */
+export declare function disjointGroups(mutants: readonly MutantResult[], size: number): string[][];
 /**
  * No single test execution is waited on past this (owner, 2026-11-04: "we should not wait longer than
  * that"). Every watchdog budget is capped at it per test the run executes, the 3x re-run of a busy stop

package/dist/coordinator.js

@@ -1,11 +1,11 @@
 import { createHash } from 'node:crypto';
-import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { ambientRuntime, run as spawn } from 'bellpull';
 import { checkSurvivors } from './checker.js';
 import { runCommandMutants } from './command-runner.js';
-import { IGNORE_STATIC_REASON, disables } from './config.js';
+import { IGNORE_STATIC_REASON, STATIC_BUDGET_REASON, disables } from './config.js';
 import { rangeDisables } from './directives.js';
 import { guardDisk, isClean } from './diskguard.js';
 import { globToRegExp, matchFiles } from './files.js';
@@ -17,6 +17,7 @@ import { FILE_KEY, env, stderr } from './runtime.js';
 import { createPool } from './scheduler.js';
 import { summarizeSpec, tracesFor } from './spec-oracle.js';
 import { SPEC_TRACES_ENV } from './spec.js';
+import { removeWorkDir } from './work-dir.js';
 export class InstrumentFault extends Error {
 }
 function readRecords(file) {
@@ -41,6 +42,8 @@ const verdictOptions = (o) => ({
     timeoutFactor: o.timeoutFactor,
     excludedMutations: [...o.excludedMutations].sort(),
     ignoreStatic: o.ignoreStatic,
+    staticGroup: o.staticGroup,
+    staticBudgetMs: o.staticBudgetMs,
     strykerCompat: o.strykerCompat,
     testOverrides: o.testOverrides,
     vitestConfig: o.vitestConfig && existsSync(o.vitestConfig) ? sha(readFileSync(o.vitestConfig, 'utf8')) : null,
@@ -59,6 +62,22 @@ function timeoutReason(v) {
     return 'stopped by the watchdog twice, the second time with 3x the budget';
 }
 const slowKill = (v) => v?.status === 'Killed' && v.slow === true;
+const before = (x, y) => x.line < y.line || (x.line === y.line && x.column < y.column);
+function overlap(a, b) {
+    return a.file === b.file && before(a.start, b.end) && before(b.start, a.end);
+}
+const GROUPABLE = new Set(['StringLiteral', 'NumericLiteral', 'Regex']);
+export function disjointGroups(mutants, size) {
+    const groups = [];
+    for (const m of mutants) {
+        const home = GROUPABLE.has(m.mutatorName) ? groups.find((g) => g.length < size && GROUPABLE.has(g[0]?.mutatorName ?? '') && !g.some((other) => overlap(m, other))) : undefined;
+        if (home)
+            home.push(m);
+        else
+            groups.push([m]);
+    }
+    return groups.map((g) => g.map((m) => m.id));
+}
 const RERUN_SLACK = 3;
 export const MAX_TEST_MS = 5000;
 const MS_PER_MINUTE = 60_000;
@@ -76,8 +95,8 @@ export async function run(options) {
     const { root } = options;
     const work = mkdtempSync(path.join(tmpdir(), 'oxmutate-'));
     const stats = {
-        files: 0, mutants: 0, instrumentMs: 0, dryRunMs: 0, mutationMs: 0, staticMs: 0, staticRecollections: 0, isolatedMs: 0, wallMs: 0, testExecutions: 0, warmUnitMs: 0, warmArmedMs: 0, isolatedByCause: { static: 0, stopped: 0, unfinished: 0, rerun: 0, confirm: 0, flaky: 0 },
-        watchdogKills: 0, idleStalls: 0, deadlocks: 0, crashes: 0, canaryFiles: 0, pollutionRestarts: 0, diskWrites: 0, auditSampled: 0, auditDisagreed: 0, survivorsOverturned: 0, timeoutsOverturned: 0, compileErrors: 0, isolatedRuns: 0, reused: 0, flakyTests: 0, flakyMutants: 0, units: 0, serversSpawned: 0,
+        files: 0, mutants: 0, instrumentMs: 0, dryRunMs: 0, mutationMs: 0, staticMs: 0, staticRecollections: 0, staticGroupRuns: 0, staticGroupSplits: 0, staticAuditSampled: 0, staticAuditDisagreed: 0, isolatedMs: 0, wallMs: 0, testExecutions: 0, warmUnitMs: 0, warmArmedMs: 0, isolatedByCause: { static: 0, stopped: 0, unfinished: 0, rerun: 0, confirm: 0, flaky: 0 },
+        watchdogKills: 0, idleStalls: 0, deadlocks: 0, crashes: 0, canaryFiles: 0, pollutionRestarts: 0, diskWrites: 0, diskWritePaths: [], auditSampled: 0, auditDisagreed: 0, survivorsOverturned: 0, timeoutsOverturned: 0, compileErrors: 0, isolatedRuns: 0, reused: 0, flakyTests: 0, flakyMutants: 0, units: 0, serversSpawned: 0,
     };
     let unitSeq = 0;
     const fileFor = (kind, ext) => path.join(work, `${kind}-${String(unitSeq++)}.${ext}`);
@@ -378,6 +397,9 @@ export async function run(options) {
             const dirty = change !== undefined && !isClean(change);
             if (dirty) {
                 stats.diskWrites++;
+                for (const p of [...change.changed, ...change.added, ...change.removed])
+                    if (stats.diskWritePaths.length < 5 && !stats.diskWritePaths.includes(p))
+                        stats.diskWritePaths.push(p);
                 if (!disk?.restore(change)) {
                     throw new InstrumentFault(`a mutant wrote outside the sandbox and the project could not be put back: ${[...change.changed, ...change.added, ...change.removed].join(', ')}. fix: restore them (git checkout / git clean), and see which test writes into the project`);
                 }
@@ -572,15 +594,19 @@ export async function run(options) {
             if (items.length === 0)
                 return [];
             const STATIC_BATCH = 25;
-            const unitsFor = (filesOf) => {
+            const unitsFor = (filesOf, grouped = false) => {
                 const byFile = new Map();
                 for (const m of items)
                     for (const f of filesOf(m))
                         (byFile.get(f) ?? byFile.set(f, []).get(f))?.push(m.id);
-                return [...byFile].flatMap(([file, ids]) => Array.from({ length: Math.ceil(ids.length / STATIC_BATCH) }, (_, i) => ({
-                    mode: 'static', files: [file], results: fileFor('static', 'jsonl'), progress: fileFor('static', 'progress'), staticIds: ids.slice(i * STATIC_BATCH, (i + 1) * STATIC_BATCH),
-                    hitLimits: Object.fromEntries(ids.slice(i * STATIC_BATCH, (i + 1) * STATIC_BATCH).map((id) => [id, hitLimitOf(id)])),
-                })));
+                return [...byFile].flatMap(([file, ids]) => Array.from({ length: Math.ceil(ids.length / STATIC_BATCH) }, (_, i) => {
+                    const mine = ids.slice(i * STATIC_BATCH, (i + 1) * STATIC_BATCH);
+                    return {
+                        mode: 'static', files: [file], results: fileFor('static', 'jsonl'), progress: fileFor('static', 'progress'), staticIds: mine,
+                        ...(grouped && options.staticGroup > 1 ? { staticGroups: disjointGroups(mine.map((id) => byId.get(id)), options.staticGroup) } : {}),
+                        hitLimits: Object.fromEntries(mine.map((id) => [id, hitLimitOf(id)])),
+                    };
+                }));
             };
             const killed = new Map();
             const timedOut = new Set();
@@ -594,6 +620,16 @@ export async function run(options) {
                 for (const r of readRecords(unit.results)) {
                     if (r.type === 'recollection')
                         stats.staticRecollections++;
+                    if (r.type === 'static-group') {
+                        stats.staticGroupRuns++;
+                        if (r.passed !== true)
+                            stats.staticGroupSplits++;
+                    }
+                    if (r.type === 'static-audit') {
+                        stats.staticAuditSampled++;
+                        if (r.disagreed === true)
+                            stats.staticAuditDisagreed++;
+                    }
                     if (r.type === 'static-fallback')
                         for (const id of r.ids ?? [])
                             back.add(id);
@@ -614,14 +650,20 @@ export async function run(options) {
                             back.add(id);
                 return [];
             };
+            const deadline = options.staticBudgetMs === undefined ? Infinity : performance.now() + options.staticBudgetMs;
+            const spent = () => performance.now() >= deadline;
             const keepUndecided = (unit) => {
+                if (spent())
+                    return false;
                 unit.staticIds = (unit.staticIds ?? []).filter((id) => !killed.has(id) && !back.has(id));
+                if (unit.staticGroups)
+                    unit.staticGroups = unit.staticGroups.map((g) => g.filter((id) => !killed.has(id) && !back.has(id))).filter((g) => g.length > 0);
                 return unit.staticIds.length > 0;
             };
             const open = (m) => !killed.has(m.id) && !back.has(m.id);
             const rounds = [(m) => filesFor(m).slice(0, 1), (m) => (open(m) ? filesFor(m).slice(1) : [])];
-            for (const round of rounds)
-                await staticPool.drain(unitsFor(round), (_, id) => isolatedCapped(id, 2), afterStatic, keepUndecided);
+            for (const [i, round] of rounds.entries())
+                await staticPool.drain(unitsFor(round, i > 0), (_, id) => isolatedCapped(id, 2), afterStatic, keepUndecided);
             const undecided = [];
             for (const m of items) {
                 const k = killed.get(m.id);
@@ -634,6 +676,10 @@ export async function run(options) {
                     m.status = 'Survived';
                     m.testsCompleted = ran.get(m.id) ?? 0;
                 }
+                else if (spent()) {
+                    m.status = 'Ignored';
+                    m.statusReason = STATIC_BUDGET_REASON;
+                }
                 else
                     undecided.push(m);
             }
@@ -819,6 +865,6 @@ export async function run(options) {
         if (env['OXMUTATE_KEEP'])
             stderr.write(`oxmutate: work directory kept at ${work}\n`);
         else
-            rmSync(work, { recursive: true, force: true });
+            stderr.write(removeWorkDir(work) ?? '');
     }
 }

package/dist/diskguard.js

@@ -7,7 +7,7 @@ async function git(cwd, args) {
     const r = await run('git', args, { cwd, runtime: ambientRuntime() }).catch(() => undefined);
     return r?.ok ? r.stdout : undefined;
 }
-export async function guardDisk(root, maxSnapshotBytes = MAX_SNAPSHOT_BYTES) {
+export async function guardDisk(root, maxSnapshotBytes = MAX_SNAPSHOT_BYTES, stillThere = existsSync) {
     const listed = await git(root, ['ls-files', '-z', '--cached', '--', '.']);
     if (listed === undefined)
         return undefined;
@@ -69,7 +69,7 @@ export async function guardDisk(root, maxSnapshotBytes = MAX_SNAPSHOT_BYTES) {
                         fresh.push(path.join(dir, name));
             }
             const skip = await ignored(fresh);
-            return { changed, added: fresh.filter((rel) => !skip.has(rel)), removed };
+            return { changed, added: fresh.filter((rel) => !skip.has(rel) && stillThere(path.join(root, rel))), removed };
         },
         restore(change) {
             if (!restorable)

package/dist/reports.js

@@ -1,7 +1,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import path from 'node:path';
-import { IGNORE_STATIC_REASON } from './config.js';
+import { IGNORE_STATIC_REASON, STATIC_BUDGET_REASON } from './config.js';
 export const VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
 const REPLACEMENT_WIDTH = 60;
 const ELLIPSIS = '...';
@@ -97,12 +97,13 @@ function corrections(s) {
     return [
         s.watchdogKills && `${String(s.watchdogKills)} runaway(s) stopped`,
         s.deadlocks && `${String(s.deadlocks)} deadlock(s) called by their worker`,
-        s.diskWrites && `${String(s.diskWrites)} write(s) outside the sandbox put back, their units re-run`,
+        s.diskWrites && `${String(s.diskWrites)} write(s) outside the sandbox put back, their units re-run${s.diskWritePaths.length ? ` (${s.diskWritePaths.join(', ')}; if the tests themselves write there, have git ignore it)` : ''}`,
         s.pollutionRestarts && `${String(s.pollutionRestarts)} polluted context(s) restarted (in ${String(s.canaryFiles)} file(s))`,
         s.flakyMutants && `${String(s.flakyMutants)} flaky verdict(s)`,
         s.survivorsOverturned && `${String(s.survivorsOverturned)} survivor(s) killed by a whole-file re-run`,
         s.timeoutsOverturned && `${String(s.timeoutsOverturned)} timeout(s) that finished given 3x the time`,
         s.compileErrors && `${String(s.compileErrors)} survivor(s) that do not type-check, out of the score`,
+        s.staticAuditDisagreed && `${String(s.staticAuditDisagreed)} kill(s) a static group hid, found by the audit`,
         s.reused && `${String(s.reused)} verdict(s) reused${s.auditSampled ? ` (${String(s.auditSampled)} audited, ${String(s.auditDisagreed)} disagreeing)` : ''}`,
         s.crashes && `${String(s.crashes)} worker crash(es)`,
     ].filter((c) => Boolean(c));
@@ -127,6 +128,9 @@ function staticLine(r) {
     if (ignored > 0)
         return [`  static mutants: ${String(ignored)} ignored (ignoreStatic), not scored`];
     const share = r.stats.wallMs > 0 ? r.stats.staticMs / r.stats.wallMs : 0;
+    const unspent = statics.filter((m) => m.statusReason === STATIC_BUDGET_REASON).length;
+    if (unspent > 0)
+        return [`  static mutants: ${String(statics.length - unspent)} decided in ${(r.stats.staticMs / MS_PER_S).toFixed(1)} s, ${String(unspent)} left undecided when the static budget ran out, not scored`];
     const hint = share >= STATIC_SHARE_WORTH_SAYING ? '; --ignore-static skips them, and the score then leaves them out' : '';
     return [`  static mutants: ${String(statics.length)} decided in ${(r.stats.staticMs / MS_PER_S).toFixed(1)} s, ${(share * PERCENT).toFixed(0)}% of the run${hint}`];
 }

package/dist/runner.js

@@ -48,6 +48,10 @@ const specTests = new Set(plan.specTests ?? []);
 const decidedBySpec = new Set();
 const only = mode === 'isolated' && env['OXMUTATE_ONLY_TESTS'] ? new Set(JSON.parse(env['OXMUTATE_ONLY_TESTS'])) : undefined;
 const staticIds = mode === 'static' && env['OXMUTATE_STATIC'] ? JSON.parse(env['OXMUTATE_STATIC']) : [];
+const staticGroups = mode === 'static' && env['OXMUTATE_STATIC_GROUPS'] ? JSON.parse(env['OXMUTATE_STATIC_GROUPS']) : [];
+const GROUP_AUDIT_EVERY = 20;
+const auditAll = env['OXMUTATE_STATIC_AUDIT'] === 'all';
+const audited = (id) => auditAll || [...id].reduce((sum, c) => sum + (c.codePointAt(0) ?? 0), 0) % GROUP_AUDIT_EVERY === 0;
 const staticLimits = mode === 'static' && env['OXMUTATE_HIT_LIMITS'] ? JSON.parse(env['OXMUTATE_HIT_LIMITS']) : {};
 if (mode === 'isolated' && env['OXMUTATE_HIT_LIMIT']) {
     ns.hitCount = 0;
@@ -500,8 +504,10 @@ export default class OxmutateRunner extends Base {
         const { vi } = vitest;
         if (!collectTests || !vi)
             return fallback('this Vitest has no public collect');
-        const evaluate = async (armed) => {
+        const evaluate = async (arm) => {
+            const armed = typeof arm === 'string' ? arm : undefined;
             ns.activeMutant = armed;
+            ns.activeGroup = arm !== undefined && typeof arm !== 'string' ? Object.fromEntries(arm.map((id) => [id, true])) : undefined;
             ns.hitCount = armed ? 0 : undefined;
             ns.hitLimit = armed ? (staticLimits[armed] ?? Number.MAX_SAFE_INTEGER) : undefined;
             deadlocked = false;
@@ -517,6 +523,7 @@ export default class OxmutateRunner extends Base {
             }
             finally {
                 ns.activeMutant = undefined;
+                ns.activeGroup = undefined;
                 ns.hitCount = undefined;
                 ns.hitLimit = undefined;
             }
@@ -528,16 +535,51 @@ export default class OxmutateRunner extends Base {
             held = [];
             fallback(reason, keys);
         };
-        while (rest.length) {
-            const id = rest.shift();
+        const auditMember = async (member, ran) => {
+            const passed = { failed: [], ran, timeout: false };
+            if (!audited(member))
+                return passed;
+            const alone = await evaluate(member);
+            if (alone.deadlock)
+                return undefined;
+            const hid = alone.failed.length > 0 || alone.timeout;
+            emit({ type: 'static-audit', id: member, disagreed: hid });
+            return hid ? alone : passed;
+        };
+        const queue = staticGroups.length ? staticGroups.map((g) => [...g]) : rest.map((id) => [id]);
+        const decided = (ids) => {
+            for (const id of ids)
+                rest.splice(rest.indexOf(id), 1);
+        };
+        while (queue.length) {
+            const group = queue.shift();
+            const [id = ''] = group;
             mark(`${id} ${String(realNow())}\n`);
-            held.push({ id, verdict: await evaluate(id) });
-            if (held.at(-1)?.verdict.deadlock)
+            const verdict = await evaluate(group.length === 1 ? id : group);
+            if (verdict.deadlock)
                 return back('torn down: a deadlocked run is still pending in this worker');
             const left = snapshotDiff(before, snapshot());
             if (left.length)
                 return back('the mutant left a trace', left);
-            if (held.length < every && rest.length)
+            if (group.length > 1) {
+                emit({ type: 'static-group', size: group.length, passed: verdict.failed.length === 0 && !verdict.timeout });
+                if (verdict.failed.length > 0 || verdict.timeout) {
+                    const half = Math.ceil(group.length / 2);
+                    queue.unshift(group.slice(0, half), group.slice(half));
+                    continue;
+                }
+                for (const member of group) {
+                    const own = await auditMember(member, verdict.ran);
+                    if (own === undefined)
+                        return back('torn down: a deadlocked run is still pending in this worker');
+                    held.push({ id: member, verdict: own });
+                }
+            }
+            else {
+                held.push({ id, verdict });
+            }
+            decided(group);
+            if (held.length < every && queue.length)
                 continue;
             const unarmed = await evaluate(undefined);
             emit({ type: 'recollection' });
@@ -546,8 +588,8 @@ export default class OxmutateRunner extends Base {
             const after = snapshotDiff(before, snapshot());
             if (after.length)
                 return back('the unarmed re-collection left a trace', after);
-            for (const { id: done, verdict } of held)
-                emit({ type: 'isolated', id: done, killed: verdict.failed.length > 0 && !verdict.timeout, failed: verdict.failed, ran: verdict.ran, ...(verdict.timeout && { timeout: true }), ...(verdict.deadlock && { deadlock: true }) });
+            for (const { id: done, verdict: v } of held)
+                emit({ type: 'isolated', id: done, killed: v.failed.length > 0 && !v.timeout, failed: v.failed, ran: v.ran, ...(v.timeout && { timeout: true }), ...(v.deadlock && { deadlock: true }) });
             held = [];
             every = Math.min(STATIC_CANARY_MAX, every * 2);
         }

package/dist/work-dir.js

@@ -0,0 +1,12 @@
+import { rmSync } from 'node:fs';
+const RETRIES = 10;
+const RETRY_DELAY_MS = 100;
+export function removeWorkDir(dir, remove = rmSync) {
+    try {
+        remove(dir, { recursive: true, force: true, maxRetries: RETRIES, retryDelay: RETRY_DELAY_MS });
+        return undefined;
+    }
+    catch (error) {
+        return `oxmutate: the work directory ${dir} could not be removed (${error instanceof Error ? error.message : String(error)}). The run's results are not affected. fix: remove it by hand\n`;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxmutate",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "Mutation testing for JavaScript and TypeScript on the oxc engine, run warm inside the project's own Vitest, with CI lanes, SARIF and an agent surface. No dependency outside the burgee family. A Stryker migration path.",
   "license": "MIT",
   "author": "Ofri Peretz <ofriperetzdev@gmail.com>",