oxmutate 0.0.0 → 1.0.0

package/dist/child.js

@@ -0,0 +1,125 @@
+/**
+ * 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 { resolveEsm } from './resolve.js';
+import { ACTIVE_MUTANT_ENV, argv, env, exit } from './runtime.js';
+import { instrumentedSources } from './vite-plugin.js';
+const config = JSON.parse(readFileSync(argv[2] ?? '', 'utf8'));
+env['NODE_ENV'] ??= 'test';
+const vitestNode = (await import(resolveEsm('vitest/node', config.root)));
+const runner = fileURLToPath(new URL('./runner.js', import.meta.url));
+const silent = { onInit() { }, onFinished() { } };
+const vitest = await vitestNode.createVitest('test', {
+    root: config.root,
+    config: config.vitestConfig,
+    watch: false,
+    run: true,
+    pool: 'threads',
+    maxWorkers: config.workers,
+    isolate: true,
+    runner,
+    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 },
+}, 
+// 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') });
+/** Has the runner recorded a kill for this mutant in this unit's results yet? */
+function killed(results, id) {
+    let text = '';
+    try {
+        text = readFileSync(results, 'utf8');
+    }
+    catch {
+        return false;
+    }
+    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;
+            if (item.tests)
+                env['OXMUTATE_ONLY_TESTS'] = JSON.stringify(item.tests);
+            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))
+                    break;
+            }
+        }
+        delete env[ACTIVE_MUTANT_ENV];
+        delete env['OXMUTATE_ONLY_TESTS'];
+    }
+    finally {
+        vitest.config.bail = 0;
+    }
+    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;
+    if (unit.plan)
+        env['OXMUTATE_PLAN'] = unit.plan;
+    delete env[ACTIVE_MUTANT_ENV];
+    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));
+process.send?.({ type: 'ready' });
+//# sourceMappingURL=child.js.map

package/dist/cli.js

@@ -0,0 +1,165 @@
+/**
+ * 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';
+import { loadOptions } from './config.js';
+import { InstrumentFault, run } from './coordinator.js';
+import { frozenOracle } from './frozen.js';
+import { parseShard } from './lanes.js';
+import { describe, textSummary, VERSION, writeReports } from './reports.js';
+import { cwd, stderr } from './runtime.js';
+const TEXT = Symbol.for('burgee.text');
+function survivorRecord(m) {
+    return {
+        id: m.id,
+        file: m.file,
+        line: m.start.line,
+        column: m.start.column,
+        mutator: m.mutatorName,
+        replacement: m.replacement,
+        status: m.status,
+        coveredBy: m.coveredBy.length,
+        flaky: m.flaky ?? false,
+        fix: describe(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)),
+        coveredScore: Number(r.score.covered.toFixed(2)),
+        mutants: r.mutants.length,
+        killed: count('Killed'),
+        timeout: count('Timeout'),
+        survived: count('Survived'),
+        noCoverage: count('NoCoverage'),
+        ignored: count('Ignored'),
+        errors: count('RuntimeError') + count('CompileError'),
+        stats: r.stats,
+        reports: written.map((w) => path.relative(r.root, w)),
+        survivors: r.mutants.filter((m) => m.status === 'Survived' || m.status === 'NoCoverage').map(survivorRecord),
+    };
+    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 = {};
+    if (typeof o['since'] === 'string')
+        overrides.since = o['since'];
+    if (typeof o['frozenOracle'] === 'string')
+        overrides.frozenOracle = o['frozenOracle'];
+    if (typeof o['shard'] === 'string')
+        overrides.shard = parseShard(o['shard']);
+    if (typeof o['concurrency'] === 'number')
+        overrides.concurrency = o['concurrency'];
+    if (typeof o['mutantTimeout'] === 'number')
+        overrides.timeoutMS = o['mutantTimeout'];
+    if (o['strykerCompat'] === true)
+        overrides.strykerCompat = true;
+    if (o['incremental'] === true)
+        overrides.incremental = true;
+    if (typeof o['flakyReruns'] === 'number')
+        overrides.flakyReruns = o['flakyReruns'];
+    if (typeof o['reporter'] === 'string')
+        overrides.reporters = o['reporter'].split(',').map((s) => s.trim());
+    if (typeof o['reportDir'] === 'string') {
+        overrides.jsonReport = path.resolve(root, o['reportDir'], 'mutation.json');
+        overrides.sarifReport = path.resolve(root, o['reportDir'], 'mutation.sarif');
+        overrides.htmlReport = path.resolve(root, o['reportDir'], 'mutation.html');
+    }
+    return overrides;
+}
+const runCommand = defineCommand({
+    name: 'run',
+    description: 'Mutation-test the project in the current directory',
+    effects: 'idempotent',
+    examples: [
+        { command: 'oxmutate run', description: 'every mutant, with the Stryker config if there is one' },
+        { command: 'oxmutate run --since origin/main --reporter sarif', description: 'the PR lane: only lines the change touched, annotated in code scanning' },
+        { command: 'oxmutate run --shard 2/8 --json', description: 'one cell of a CI matrix, as the --json envelope' },
+    ],
+    options: {
+        since: { type: 'string', description: 'only mutants on lines changed since this git ref (the PR lane)' },
+        frozenOracle: { type: 'string', description: "also score against this ref's tests; exit 1 if the change weakened them" },
+        shard: { type: 'string', description: 'run one deterministic share, i/n, for a CI matrix' },
+        concurrency: { type: 'number', description: 'worker processes (default: cores - 1, at most 8)' },
+        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)' },
+        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)' },
+        break: { type: 'number', description: 'exit 1 when the mutation score is below this' },
+        reportDir: { type: 'string', description: 'write mutation.json, mutation.sarif and mutation.html here instead of the configured paths' },
+        config: { type: 'string', description: 'an oxmutate config file (JSON or JS) instead of oxmutate.config.*' },
+    },
+    run: async ({ options, exit }) => {
+        const root = cwd();
+        const o = options;
+        const options_ = await loadOptions(root, overridesFrom(o, root), typeof o['config'] === 'string' ? o['config'] : undefined);
+        if (typeof o['break'] === 'number')
+            options_.thresholds.break = o['break'];
+        let result;
+        try {
+            result = await run(options_);
+            if (options_.frozenOracle)
+                result.frozen = await frozenOracle(result, options_.frozenOracle);
+        }
+        catch (e) {
+            if (e instanceof InstrumentFault) {
+                stderr.write(`oxmutate: ${e.message}\n`);
+                exit(ExitCode.CONFIG);
+            }
+            throw e;
+        }
+        const written = writeReports(result);
+        const data = summaryData(result, written);
+        const weakened = result.frozen?.weakened ?? [];
+        if (weakened.length) {
+            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;
+        }
+        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`);
+            data['exitCode'] = ExitCode.RUNTIME;
+        }
+        return data;
+    },
+});
+const survivorsCommand = defineCommand({
+    name: 'survivors',
+    description: 'List the survivors of the last run, one record per mutant, each with a fix line',
+    effects: 'read_only',
+    examples: [{ command: 'oxmutate survivors --json', description: 'the list an agent writes killing tests from' }],
+    options: { report: { type: 'string', description: 'the JSON report to read (default reports/mutation/mutation.json)' } },
+    run: async ({ options }) => {
+        const file = path.resolve(String(options['report'] ?? 'reports/mutation/mutation.json'));
+        if (!existsSync(file))
+            throw new Error(`no report at ${file}. fix: run \`oxmutate run\` first`);
+        const report = JSON.parse(readFileSync(file, 'utf8'));
+        const out = Object.entries(report.files).flatMap(([f, x]) => x.mutants
+            .filter((m) => m.status === 'Survived' || m.status === 'NoCoverage')
+            .map((m) => survivorRecord({ ...m, file: f, start: m.location.start, end: m.location.end, coveredBy: m.coveredBy ?? [] })));
+        const data = { survivors: out };
+        data[TEXT] = () => (out.length ? out.map((s) => `${String(s.file)}:${String(s.line)}  ${String(s.fix)}`).join('\n') : 'no survivors');
+        return data;
+    },
+});
+export const program = defineProgram({
+    name: 'oxmutate',
+    version: VERSION,
+    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

@@ -0,0 +1,83 @@
+/**
+ * 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 });
+    const sandbox = mkdtempSync(path.join(parent, 'sandbox-'));
+    for (const entry of readdirSync(root))
+        if (!SKIP.has(entry))
+            cpSync(path.join(root, entry), path.join(sandbox, entry), { recursive: true });
+    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;
+        const dry = await once(dryBudget);
+        if (!dry.ok) {
+            const why = dry.duration >= dryBudget ? `took longer than dryRunTimeoutMinutes (${String(o.dryRunTimeoutMinutes)})` : `exited ${String(dry.code)}`;
+            throw new Error(`the command \`${o.command}\` ${why} with no mutant active: ${(dry.stderr || dry.stdout).trim().slice(-OUTPUT_TAIL)}. fix: make the command pass on the unmutated project first`);
+        }
+        const budget = Math.max(o.timeoutMS, PROCESS_SLACK_MS) + o.timeoutFactor * dry.duration;
+        const queue = mutants.filter((m) => m.status !== 'Ignored');
+        let executions = 0;
+        const worker = async () => {
+            for (let m = queue.shift(); m; m = queue.shift()) {
+                const r = await once(budget, m.id);
+                executions++;
+                m.testsCompleted = 1;
+                if (r.ok)
+                    m.status = 'Survived';
+                else if (r.signal !== null && r.duration >= budget) {
+                    m.status = 'Timeout';
+                    m.statusReason = `the command ran past ${String(Math.round(budget))} ms`;
+                }
+                else
+                    m.status = 'Killed';
+            }
+        };
+        await Promise.all(Array.from({ length: Math.max(1, o.concurrency) }, worker));
+        return { dryMs: dry.duration, executions };
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=command-runner.js.map

package/dist/config.d.ts

@@ -0,0 +1,141 @@
+import { type IgnoreRule } from './native.js';
+import { type SpecOracle } from './spec-oracle.js';
+export interface Thresholds {
+    high: number;
+    low: number;
+    /** Fail the run (exit 1) below this score. `null`: never fail on score. */
+    break: number | null;
+}
+export interface Options {
+    root: string;
+    mutate: string[];
+    vitestConfig?: string | undefined;
+    concurrency: number;
+    timeoutMS: number;
+    timeoutFactor: number;
+    thresholds: Thresholds;
+    excludedMutations: string[];
+    /** Score static mutants (Stryker skips them with `ignoreStatic`). */
+    ignoreStatic: boolean;
+    strykerCompat: boolean;
+    reporters: string[];
+    jsonReport: string;
+    sarifReport: string;
+    htmlReport: string;
+    incremental: boolean;
+    incrementalFile: string;
+    /** Re-run a verdict whose covering tests behaved differently across two dry runs. */
+    flakyReruns: number;
+    shard?: {
+        index: number;
+        count: number;
+    };
+    /** Only mutants on lines changed since this git ref (the PR lane). */
+    since?: string | undefined;
+    /** Config keys read but not used, with the reason. */
+    unused: {
+        key: string;
+        why: string;
+    }[];
+    configFile?: string | undefined;
+    /** Stop after the dry run: proves the test setup runs under oxmutate (Stryker's `dryRunOnly`). */
+    dryRunOnly: boolean;
+    /** Budget for one dry run, in minutes (Stryker's default: 5). Over it, the run stops with exit 3. */
+    dryRunTimeoutMinutes: number;
+    /** Run once before the dry run, split on spaces with no shell, as Stryker runs it. */
+    buildCommand?: string | undefined;
+    /** Node flags for every Vitest server (Stryker's `testRunnerNodeArgs`). */
+    testRunnerNodeArgs: string[];
+    /** A dry run that finds no tests scores nothing instead of failing (Stryker's `allowEmpty`). */
+    allowEmpty: boolean;
+    /** `false` hides the line listing config keys oxmutate does not use (Stryker's `warnings`). */
+    warnUnused: boolean;
+    /** Also score the mutants against this ref's versions of the test files the change edited (R14). */
+    frozenOracle?: string | undefined;
+    /** Test file contents served in place of the files on disk (absolute path → source). */
+    testOverrides?: Record<string, string> | undefined;
+    /**
+     * Calls whose subtrees are not mutated: Stryker's `ignorers`, as data instead of plugins
+     * (`{ "call": "console.*", "reason": "log text is not behaviour" }`; `*` stops at a dot, `**` does not).
+     */
+    ignore: IgnoreRule[];
+    /** Type-check survivors with the project's compiler (Stryker's `checkers: ['typescript']`; checker.ts). */
+    typeCheck: boolean;
+    /** The tsconfig the checker uses (Stryker's `tsconfigFile`). */
+    tsconfigFile: string;
+    /** The compiler command (default: the project's tsgo, else `npx tsc`). */
+    typeChecker?: string | undefined;
+    /** Formal models whose traces are replayed against each mutant (spec-oracle.ts). */
+    specOracles: SpecOracle[];
+    /** `testRunner: 'command'`: run this command per mutant instead of the warm Vitest runner. */
+    commandRunner?: string | undefined;
+}
+/**
+ * The `mutate` block of a Vite / Vite+ config, and the shape of `oxmutate.config.*`: Stryker's own
+ * option names where Stryker has one, so a config moves across unchanged.
+ */
+export interface MutateConfig {
+    /** Files to mutate (globs; `!` excludes). Stryker's `mutate`. Default: src, minus tests and .d.ts. */
+    include?: string[];
+    /** Stryker's spelling of `include`. */
+    mutate?: string[];
+    vitest?: {
+        configFile?: string;
+    };
+    concurrency?: number;
+    /** Absolute slack per mutant, ms (default 500; Stryker's is 5000). */
+    timeoutMS?: number;
+    timeoutFactor?: number;
+    thresholds?: {
+        high?: number;
+        low?: number;
+        break?: number | null;
+    };
+    mutator?: {
+        excludedMutations?: string[];
+    };
+    ignoreStatic?: boolean;
+    reporters?: ('clear-text' | 'json' | 'html' | 'sarif' | 'progress' | 'progress-append-only' | 'ci' | 'dots')[];
+    jsonReporter?: {
+        fileName?: string;
+    };
+    htmlReporter?: {
+        fileName?: string;
+    };
+    sarifReport?: string;
+    incremental?: boolean;
+    incrementalFile?: string;
+    flakyReruns?: number;
+    dryRunOnly?: boolean;
+    dryRunTimeoutMinutes?: number;
+    buildCommand?: string;
+    testRunnerNodeArgs?: string[];
+    allowEmpty?: boolean;
+    warnings?: boolean | {
+        unknownOptions?: boolean;
+    };
+    testRunner?: 'vitest' | 'command';
+    commandRunner?: {
+        command?: string;
+    };
+    checkers?: 'typescript'[];
+    tsconfigFile?: string;
+    typeChecker?: string;
+    /** Calls whose subtrees are not mutated: `{ call: 'console.*', reason }`. */
+    ignore?: IgnoreRule[];
+    /** Formal models replayed against each mutant (`quint` or `itf` traces). */
+    specOracles?: SpecOracle[];
+    strykerCompat?: boolean;
+}
+export declare function loadOptions(root: string, overrides?: Partial<Options>, configFile?: string): Promise<Options>;
+/** Stryker's `disable next-line` directive, `Mutator[,Mutator]: <reason>` after it (also spelled `oxmutate disable`). */
+export interface Disable {
+    line: number;
+    mutators: string[] | 'all';
+    reason: string;
+}
+/** Disable directives in a file. A directive without a reason is an error (burgee's own rule). */
+export declare function disables(source: string, file: string): {
+    disables: Disable[];
+    errors: string[];
+};