@systemfsoftware/stryker-js 15.0.0 → 16.0.0

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @systemfsoftware/stryker-js
 
+## 16.0.0
+
+### Major Changes
+
+- Mutation testing is now incremental by default: `incremental` defaults to `true`, so an unchanged mutant whose covering tests are unchanged is re-used instead of re-run. `--full` (aliasing the old `--force`) re-verifies every mutant, ignoring the cache and the persisted dry run. The `verdict` stream event records `incrementalMode` (`incremental` or `full`). A run with no reusable cache falls back to a full run as before.
+
+- The incremental report and its checkpoints now record a `costs` entry for every mutant: the predicted milliseconds from the measured dry-run times of its covering tests plus the run's fixed overhead, the wall time of its last executed run, and its covering-test count. A verdict reused from an earlier run carries its recorded `actualMs` forward instead of losing it. The incremental cache layout moves to version `3`, so a report written by an earlier release is discarded rather than reused.
+
+- A mutation run now starts only on main CI. The `run` command, the programmatic run entry point, and every other surface that begins a mutation run refuse to start unless the process runs under GitHub Actions (`GITHUB_ACTIONS=true`); anything else — a developer machine, a fork, or another CI — exits non-zero instead of running mutants. A refused run ends the machine-readable output with a new `refused` event whose `rule` is `mutation-runs-on-main-ci`, and the machine-stream schema version is now `3.0`. Dry runs (`--dryRunOnly`), `--version`, and config and help commands are unaffected.
+
+- The old report-merge command becomes `merge`, which now reads the shard plan and the per-shard report directories and combines them into one mutation report and a per-project incremental report. A merge fails, naming the mutants, when a planned mutant is missing from its shard report or reported by two shards. A new shard mode runs exactly the mutants of one shard, spawning a child run per project the shard lists, so a plan can be executed across parallel jobs and merged afterwards; mutants outside a shard are neither run nor reported.
+
+- The TypeScript checker now applies Trivial Compiler Equivalence (Papadakis et al., ICSE 2015). Each mutant of a file is emitted to JavaScript from the project's own TypeScript configuration in transpile-only mode, normalized, and compared with the original file's emit and with the mutants already emitted at the same site. A mutant whose emit equals the original's is dropped as `Ignored` with reason `equivalent-to-original: tce`; one that equals an earlier same-site mutant's is dropped with `duplicate-at-site: tce`; every mutant whose emit differs is kept, so the check never removes a mutant that changes the program. Checkers gain an `ignored` result variant carrying the suppression reason, and a run publishes the new `tce` machine-stream event with the `equivalentToOriginal` and `duplicateAtSite` counts. Verdict semantics move to version 3.
+
+- Every mutation and incremental run now records a `budget` of predicted and actual seconds on its machine verdict line and in its mutation and incremental reports, derived from the measured cost of the mutants it scheduled and the wall time the run took. `stryker gate` takes `--budget-baseline <file>`, an optional `--budget-tolerance` (default 0.25), and `--update-budget-baseline`; it fails with exit 1 when the finished run's actual seconds exceed the committed baseline by more than the tolerance, naming both numbers, and rewrites the baseline with the current run when updating.
+
+### Minor Changes
+
+- A new `stryker plan` subcommand discovers each project's mutants without running tests, decides reuse against that project's incremental report, costs every scheduled mutant, and packs them into deterministically LPT-scheduled shards. It takes `--target-seconds`, optional `--max-shards`, `--projects`, `--out`, and `--full`, writes a `ShardPlan`, and emits a `plan` stream event.
+
+- Every test-runner and checker process boot now publishes a `worker` line on the machine stream carrying its role, boot ordinal and measured start-up time, so the once-per-worker start-up cost is observable instead of hidden behind the first mutant's per-run overhead. The stream schema version is now `6.0`.
+
+### Patch Changes
+
+- The README now has an upgrade note for 13.x users. 14.0.0 made `'default'` the default `mutator.mutantSetPolicy`, so scores graded under 13.x and later releases cover different mutant sets and are not comparable. The note names where each run records its policy, and states that `mutator: { mutantSetPolicy: 'full' }` keeps the 13.x mutant set.
+
+- A cached incremental report that cannot be decoded now names the decode failure in the run log, so a cache written by an older release says which field the reader refused instead of only that the file could not be parsed.
+
+- Repeating an incremental run in a workspace that builds with Turbo now reuses the pending dry-run coverage and the cached verdicts again. A package's `.turbo` task logs are generated by each build and record that build, so they no longer count as project files the run must watch: a rebuild no longer invalidates coverage whose inputs did not change.
+
+- Mutants no test covers are now verified by the configured checkers before they are reported `NoCoverage`. A checker that rejects such a mutant reports it `CompileError`, with the checker's reason, instead of `NoCoverage`; uncovered mutants that pass every checker are still reported `NoCoverage`. Previously the checkers never saw uncovered mutants, so a non-compiling mutant no test reaches counted as an undetected survivor.
+
+- The incremental report and its checkpoints are now written atomically: the bytes go to a temporary file in the same directory and are renamed over the target, so an interrupted or killed run (a job-cap timeout, or a process stopped while the report is being saved) can no longer leave a truncated incremental file behind. A run that finds a cache written this way decodes it and reuses it instead of discarding the whole mutation history. The mutation report, summary, and incremental report that `stryker merge` writes are saved the same way.
+
+## 15.0.1
+
+### Patch Changes
+
+- `cleanTempDir` now decides from how the run ended. With the default (`true`), a successful run removes its `.stryker-tmp/sandbox-*` directory and a failed run keeps it; previously every sandbox was kept, so `.stryker-tmp` grew with each run. `cleanTempDir: false` now keeps the sandbox after every run instead of deleting it. `'always'` still removes it after every run.
+
+- A test runner, checker, or reporter process that stops responding no longer hangs the mutation run forever. When such a process does not exit within 5 seconds of being asked to stop, Stryker force-kills it, so the run ends with an error instead of waiting until something kills it from outside.
+
+- A test runner, checker, or reporter process that starts but never accepts its connection no longer hangs the mutation run forever. Stryker gives each plugin worker 30 seconds to accept the connection on `STRYKER_SOCKET`; a worker that misses that window fails the run with a boot error naming its process id, and the process is stopped. The window does not depend on `dryRunTimeoutMinutes`. A worker that has already connected still reconnects after a dropped connection, as before.
+
 ## 15.0.0
 
 ### Major Changes

package/README.md

@@ -153,14 +153,14 @@ pnpm exec stryker run --mutant <id,...>
 # Re-test only surviving mutants from prior run
 pnpm exec stryker run --survivors
 
-# Enable incremental caching
-pnpm exec stryker run --incremental
+# Incremental caching is on by default; re-verify every mutant instead
+pnpm exec stryker run --full
 
 # Run with specific concurrency
 pnpm exec stryker run --concurrency 4
 
 # Merge partial mutation reports from parallel CI shards
-pnpm exec stryker merge-reports --parts reports/shards --out reports/mutation
+pnpm exec stryker merge --plan plan.json reports/shards/1 reports/shards/2 --out reports/mutation
 
 # Fail on survivors absent from a committed baseline
 pnpm exec stryker gate --baseline .stryker-baseline.json
@@ -177,7 +177,9 @@ pnpm exec stryker serve stdio
 pnpm exec stryker mcp
 ```
 
-`stryker run --since <ref>` takes the merge base of `<ref>` and the working tree, diffs it at `--unified=0`, and intersects the changed lines with `mutate`; it falls back to a full run when the Stryker config, a test-runner config, `package.json`, or the lockfile changed. `stryker run --mutant <id,...>` admits each id against the previous report (`reports/mutation/mutation.json`), restricts the run to those mutants' files, and emits each one's status, covering tests, killing test, and a `stryker run --mutant <id>` reproducer. `stryker gate` exits non-zero on survivors missing from its baseline, `stryker compare` exits `1` on a status mismatch after subtracting a `--noise` file, and `stryker annotate` prints GitHub workflow commands at each surfaced survivor. `stryker serve stdio|socket` speaks the Mutation Server Protocol and `stryker mcp` serves MCP over stdio.
+`stryker run --since <ref>` takes the merge base of `<ref>` and the working tree, diffs it at `--unified=0`, and intersects the changed lines with `mutate`; it falls back to a full run when the Stryker config, a test-runner config, `package.json`, or the lockfile changed. `stryker run --mutant <id,...>` admits each id against the previous report (`reports/mutation/mutation.json`), restricts the run to those mutants' files, and emits each one's status, covering tests, killing test, and a `stryker run --mutant <id>` reproducer. `stryker gate` exits non-zero on survivors missing from its baseline, `stryker compare` exits `1` on a status mismatch after subtracting a `--noise` file, and `stryker annotate` prints GitHub workflow commands at each surfaced survivor.
+
+A mutation run only starts on main CI. `stryker run` — and the programmatic `run`/`strykerCell` entry, the MSP `mutationTest` request, and the MCP `rerun_mutant` tool — refuses to start unless `GITHUB_ACTIONS` is `true`. A refused run exits non-zero and ends the machine stream with a `refused` event naming the rule (`mutation-runs-on-main-ci`). Dry runs (`--dryRunOnly`), `--version`, config and help commands, the MSP `discover` request, and the read-only MCP tools are unaffected. `stryker serve stdio|socket` speaks the Mutation Server Protocol and `stryker mcp` serves MCP over stdio.
 
 ## Output Modes
 
@@ -188,16 +190,20 @@ pnpm exec stryker run --json                # wire records on stdout, diagnostic
 STRYKER_MODE=machine pnpm exec stryker run  # the same, named by environment
 ```
 
-`--format text` names the human format explicitly; `--json` together with `--format text` is a usage error (exit 2). Under `--json`, `stdout` carries wire records and nothing else — progress lines and log output stay on `stderr`. Every run also writes the same records to `reports/mutation-stream.jsonl` (`--progressStreamFile`) in both modes, which is the artifact `stryker merge-reports` rebuilds a shard's partial report from.
+`--format text` names the human format explicitly; `--json` together with `--format text` is a usage error (exit 2). Under `--json`, `stdout` carries wire records and nothing else — progress lines and log output stay on `stderr`. Every run also writes the same records to `reports/mutation-stream.jsonl` (`--progressStreamFile`) in both modes, which is the artifact `stryker merge` rebuilds a shard's partial report from.
 
 ## Reporters, Sidecars, and Verdict Reuse
 
 `reporters` defaults to `['clear-text', 'progress', 'html']`. Add `sarif` to also write `reports/mutation/mutation.sarif` (SARIF 2.1.0, named from `jsonReporter.fileName`): each survivor is a `warning` result, each no-coverage mutant a `note`, the fingerprint is the mutant's content id, and the log is capped at 5,000 results. Every run writes `reports/mutation/reproducers.json`: one entry per mutant in the report, holding its mutated-lines diff and the `stryker run --mutant <id>` command that reproduces it.
 
-The incremental cache is keyed by content: a mutant's id, the import-closure digest of its covering tests, the run inputs, the verdict-semantics version, and the mutant-set policy. Nothing in the key names a shard, branch, report path, or machine, so verdicts from different runs union and are reused wherever their inputs match. `incrementalSources` accepts globs of further incremental reports to union beside `incrementalFile`, which is how a sharded CI workspace reuses the reports it restored from other shards. Each run's stream carries a `reuse` line with the reused, ran, and per-reason refused counts, and an unchanged project reuses its persisted initial test run instead of repeating it.
+Incremental reuse is on by default: an unchanged mutant whose covering tests are unchanged is re-used and the verdict records its `incrementalMode` (`incremental` or `full`). Pass `--full` to re-verify every mutant, ignoring the cache and the persisted dry run. The incremental cache is keyed by content: a mutant's id, the import-closure digest of its covering tests, the run inputs, the verdict-semantics version, and the mutant-set policy. Nothing in the key names a shard, branch, report path, or machine, so verdicts from different runs union and are reused wherever their inputs match. `incrementalSources` accepts globs of further incremental reports to union beside `incrementalFile`, which is how a sharded CI workspace reuses the reports it restored from other shards. Each run's stream carries a `reuse` line with the reused, ran, and per-reason refused counts, and an unchanged project reuses its persisted initial test run instead of repeating it.
 
 `mutator.mutantSetPolicy` defaults to `'default'`, which suppresses the mutants a rule proves redundant — a relational replacement outside the sufficient set, a conditional that collapses to a literal, a replacement equal to the original code, or a duplicate already planted at the site — and records the rule id in the mutant's report entry. Set `mutator: { mutantSetPolicy: 'full' }` to keep every variant. `surfacing` (`{ perLine: 1, perFile: 7 }`) caps how many survivors reach the review surfaces and SARIF, without changing what the engine computes.
 
+### Upgrading from 13.x: the mutant set changed in 14.0.0
+
+14.0.0 made `'default'` the default `mutator.mutantSetPolicy`; 13.x generated what `'full'` generates now. A score produced under one policy grades a different mutant set from a score under the other, so the two are not comparable: removing a killed mutant lowers the score, removing a survivor raises it. Every run records its policy (the stream's `verdict.mutantSetPolicy` and the incremental report), and a cached verdict from the other policy is refused with `policyChanged`. To compare against a 13.x baseline, or to keep grading the 13.x mutant set, set `mutator: { mutantSetPolicy: 'full' }`.
+
 ## Programmatic API
 
 ### Effect 4 Native Interface

package/dist/{Run.schema-B1HZugu9.d.mts → Run.schema-CgcTsB1w.d.mts}

@@ -1,4 +1,4 @@
-import { a as mod_d_exports$6 } from "./index-Cf9G6kA8.mjs";
+import { a as mod_d_exports$6 } from "./index-DEphx668.mjs";
 import * as S from "effect/Schema";
 //#region src/Run.schema.d.ts
 declare const TypeId: '~stryker/mutation-run/StageError';

package/dist/{RunEnvironment.service-B1bsWOQ9.d.mts → RunEnvironment.service-F8LgeCqh.d.mts}

@@ -1,5 +1,5 @@
-import { a as mod_d_exports$6, c as mod_d_exports$9, d as Program$2, f as Statement, i as mod_d_exports$5, l as Ignorer$1, n as mod_d_exports$2$1, o as mod_d_exports$7, r as mod_d_exports$4, s as mod_d_exports$8, t as mod_d_exports$3 } from "./index-Cf9G6kA8.mjs";
-import "./Run.schema-B1HZugu9.mjs";
+import { a as mod_d_exports$6, c as mod_d_exports$9, d as Program$2, f as Statement, i as mod_d_exports$5, l as Ignorer$1, n as mod_d_exports$2$1, o as mod_d_exports$7, r as mod_d_exports$4, s as mod_d_exports$8, t as mod_d_exports$3 } from "./index-DEphx668.mjs";
+import "./Run.schema-CgcTsB1w.mjs";
 import { Cell, Handle, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
 import * as S from "effect/Schema";
 import * as Option$1 from "effect/Option";
@@ -144,7 +144,7 @@ type RunPhase = typeof RunPhase.Type;
 declare const RunId: S.brand<S.String, "RunId">;
 type RunId = typeof RunId.Type;
 declare const RunStarted_base: S.Class<RunStarted, S.TaggedStruct<"stream", {
-  readonly schemaVersion: S.Literal<"2.0">;
+  readonly schemaVersion: S.Literal<"6.0">;
   readonly runId: S.brand<S.String, "RunId">;
   readonly mode: S.Literals<readonly ["human", "machine"]>;
   readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
@@ -157,8 +157,36 @@ declare const PhaseEntered_base: S.Class<PhaseEntered, S.TaggedStruct<"phase", {
 declare class PhaseEntered extends PhaseEntered_base {}
 declare const PlanKnown_base: S.Class<PlanKnown, S.TaggedStruct<"plan", {
   readonly total: S.Int;
+  readonly shardPlan: S.NullOr<S.Struct<{
+    readonly version: S.Literal<1>;
+    readonly targetSeconds: S.Finite;
+    readonly shards: S.$Array<S.Struct<{
+      readonly index: S.Int;
+      readonly count: S.Int;
+      readonly predictedSeconds: S.Finite;
+      readonly projects: S.$Array<S.Struct<{
+        readonly project: S.String;
+        readonly mutants: S.$Array<S.String>;
+      }>>;
+    }>>;
+    readonly matrix: S.Struct<{
+      readonly include: S.$Array<S.Struct<{
+        readonly shard: S.String;
+        readonly predictedSeconds: S.Finite;
+      }>>;
+    }>;
+  }>>;
 }>, {}>;
 declare class PlanKnown extends PlanKnown_base {}
+declare const WorkerRole: S.Literals<readonly ["testRunner", "checker"]>;
+type WorkerRole = typeof WorkerRole.Type;
+declare const WorkerReported_base: S.Class<WorkerReported, S.TaggedStruct<"worker", {
+  readonly schemaVersion: S.Literal<"6.0">;
+  readonly role: S.Literals<readonly ["testRunner", "checker"]>;
+  readonly index: S.Int;
+  readonly startupMs: S.Finite;
+}>, {}>;
+declare class WorkerReported extends WorkerReported_base {}
 declare const MutantCost: S.Struct<{
   readonly fixedOverheadMs: S.Finite;
   readonly testBodyMs: S.Finite;
@@ -309,6 +337,8 @@ declare const RunScope: S.Literals<readonly ["full", "diff"]>;
 type RunScope = typeof RunScope.Type;
 declare const MutantSetPolicy: S.Literals<readonly ["default", "full"]>;
 type MutantSetPolicy = typeof MutantSetPolicy.Type;
+declare const IncrementalMode: S.Literals<readonly ["incremental", "full"]>;
+type IncrementalMode = typeof IncrementalMode.Type;
 declare const PhaseDurations: S.Struct<{
   readonly prepare: S.Finite;
   readonly instrument: S.Finite;
@@ -321,8 +351,13 @@ declare const StaticVerdict: S.Struct<{
   readonly costMs: S.Finite;
 }>;
 type StaticVerdict = typeof StaticVerdict.Type;
+declare const Budget: S.Struct<{
+  readonly predictedSeconds: S.Finite;
+  readonly actualSeconds: S.Finite;
+}>;
+type Budget = typeof Budget.Type;
 declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdict", {
-  readonly schemaVersion: S.Literal<"2.0">;
+  readonly schemaVersion: S.Literal<"6.0">;
   readonly runId: S.brand<S.String, "RunId">;
   readonly mode: S.Literals<readonly ["human", "machine"]>;
   readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
@@ -353,6 +388,7 @@ declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdi
   }>>;
   readonly scope: S.Literals<readonly ["full", "diff"]>;
   readonly mutantSetPolicy: S.Literals<readonly ["default", "full"]>;
+  readonly incrementalMode: S.optionalKey<S.Literals<readonly ["incremental", "full"]>>;
   readonly phaseDurations: S.NullOr<S.Struct<{
     readonly prepare: S.Finite;
     readonly instrument: S.Finite;
@@ -363,6 +399,10 @@ declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdi
     readonly count: S.Int;
     readonly costMs: S.Finite;
   }>>;
+  readonly budget: S.Struct<{
+    readonly predictedSeconds: S.Finite;
+    readonly actualSeconds: S.Finite;
+  }>;
 }>, {}>;
 declare class VerdictReached extends VerdictReached_base {}
 declare const FrameworkContributionRow: S.Struct<{
@@ -456,6 +496,11 @@ declare const ReuseReported_base: S.Class<ReuseReported, S.TaggedStruct<"reuse",
   }>;
 }>, {}>;
 declare class ReuseReported extends ReuseReported_base {}
+declare const TceReported_base: S.Class<TceReported, S.TaggedStruct<"tce", {
+  readonly equivalentToOriginal: S.Int;
+  readonly duplicateAtSite: S.Int;
+}>, {}>;
+declare class TceReported extends TceReported_base {}
 declare const MutantDetailReported_base: S.Class<MutantDetailReported, S.TaggedStruct<"mutant-detail", {
   readonly id: S.brand<S.String, "MutantId">;
   readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
@@ -473,7 +518,7 @@ declare const FeedbackReported_base: S.Class<FeedbackReported, S.TaggedStruct<"f
 }>, {}>;
 declare class FeedbackReported extends FeedbackReported_base {}
 declare const RunFailed_base: S.Class<RunFailed, S.TaggedStruct<"error", {
-  readonly schemaVersion: S.Literal<"2.0">;
+  readonly schemaVersion: S.Literal<"6.0">;
   readonly code: S.Int;
   readonly error: S.String;
   readonly remediation: S.String;
@@ -492,12 +537,20 @@ declare const RunFailed_base: S.Class<RunFailed, S.TaggedStruct<"error", {
 }>, {}>;
 declare class RunFailed extends RunFailed_base {}
 declare const HelpRendered_base: S.Class<HelpRendered, S.TaggedStruct<"help", {
-  readonly schemaVersion: S.Literal<"2.0">;
+  readonly schemaVersion: S.Literal<"6.0">;
   readonly code: S.Literals<readonly [0]>;
   readonly help: S.String;
 }>, {}>;
 declare class HelpRendered extends HelpRendered_base {}
-declare const RunEvent: S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, S.Codec<RunMutantTestedEvent, {
+declare const RefusalRule: S.Literal<"mutation-runs-on-main-ci">;
+type RefusalRule = typeof RefusalRule.Type;
+declare const Refused_base: S.Class<Refused, S.TaggedStruct<"refused", {
+  readonly schemaVersion: S.Literal<"6.0">;
+  readonly rule: S.Literal<"mutation-runs-on-main-ci">;
+  readonly message: S.String;
+}>, {}>;
+declare class Refused extends Refused_base {}
+declare const RunEvent: S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, typeof WorkerReported, S.Codec<RunMutantTestedEvent, {
   readonly _tag: "mutant";
   readonly id: string;
   readonly status: "CompileError" | "Ignored" | "Killed" | "NoCoverage" | "Pending" | "RuntimeError" | "Survived" | "Timeout";
@@ -523,14 +576,14 @@ declare const RunEvent: S.Union<readonly [typeof RunStarted, typeof PhaseEntered
     readonly testsExecuted: number;
     readonly shared: boolean;
   } | null;
-}, never, never>, typeof Heartbeat, typeof PluginsReported, typeof FormatRegistryResolved, typeof SkippedReported, typeof ReuseReported, typeof MutantDetailReported, typeof FeedbackReported, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]> & {
+}, never, never>, typeof Heartbeat, typeof PluginsReported, typeof FormatRegistryResolved, typeof SkippedReported, typeof ReuseReported, typeof TceReported, typeof MutantDetailReported, typeof FeedbackReported, typeof VerdictReached, typeof RunFailed, typeof HelpRendered, typeof Refused]> & {
   QUEUE_BOUND: number;
 };
 type RunEvent = typeof RunEvent.Type;
-type RunTerminalEvent = VerdictReached | RunFailed | HelpRendered;
+type RunTerminalEvent = VerdictReached | RunFailed | HelpRendered | Refused;
 //#endregion
 //#region src/run-event-wire.schema.d.ts
-declare const RunEventWireLine: S.decodeTo<S.fromJsonString<S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, S.Codec<RunMutantTestedEvent, {
+declare const RunEventWireLine: S.decodeTo<S.fromJsonString<S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, typeof WorkerReported, S.Codec<RunMutantTestedEvent, {
   readonly _tag: "mutant";
   readonly id: string;
   readonly status: "CompileError" | "Ignored" | "Killed" | "NoCoverage" | "Pending" | "RuntimeError" | "Survived" | "Timeout";
@@ -556,16 +609,16 @@ declare const RunEventWireLine: S.decodeTo<S.fromJsonString<S.Union<readonly [ty
     readonly testsExecuted: number;
     readonly shared: boolean;
   } | null;
-}, never, never>, typeof Heartbeat, typeof PluginsReported, typeof FormatRegistryResolved, typeof SkippedReported, typeof ReuseReported, typeof MutantDetailReported, typeof FeedbackReported, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]> & {
+}, never, never>, typeof Heartbeat, typeof PluginsReported, typeof FormatRegistryResolved, typeof SkippedReported, typeof ReuseReported, typeof TceReported, typeof MutantDetailReported, typeof FeedbackReported, typeof VerdictReached, typeof RunFailed, typeof HelpRendered, typeof Refused]> & {
   QUEUE_BOUND: number;
 }>, S.String, never, never>;
 type RunEventWireLine = typeof RunEventWireLine.Type;
 //#endregion
 //#region src/stream-version.schema.d.ts
-declare const StreamSchemaVersion: S.Literal<"2.0">;
+declare const StreamSchemaVersion: S.Literal<"6.0">;
 type StreamSchemaVersion = typeof StreamSchemaVersion.Type;
 declare namespace mod_d_exports$1$1 {
-  export { FeedbackJudgment, FeedbackReported, FormatClaimShadowingRow, FormatRegistryResolved, FormatRegistryRow, FrameworkContributionRow, FrameworkModuleRow, Heartbeat, HelpRendered, MutantCost, MutantDetailReported, MutantSetPolicy, PhaseDurations, PhaseEntered, PlanKnown, PluginLoadFailureReason, PluginsReported, ReuseRefusals, ReuseReported, RunEvent, RunEventWireLine, RunFailed, RunId, RunMutantTested, RunMutantTestedEvent, RunPhase, RunScope, RunStarted, RunTerminalEvent, SkippedFileRow, SkippedReported, StaticVerdict, StreamSchemaVersion, VerdictCounts, VerdictLocation, VerdictMutant, VerdictReached, VerdictThresholds };
+  export { Budget, FeedbackJudgment, FeedbackReported, FormatClaimShadowingRow, FormatRegistryResolved, FormatRegistryRow, FrameworkContributionRow, FrameworkModuleRow, Heartbeat, HelpRendered, IncrementalMode, MutantCost, MutantDetailReported, MutantSetPolicy, PhaseDurations, PhaseEntered, PlanKnown, PluginLoadFailureReason, PluginsReported, RefusalRule, Refused, ReuseRefusals, ReuseReported, RunEvent, RunEventWireLine, RunFailed, RunId, RunMutantTested, RunMutantTestedEvent, RunPhase, RunScope, RunStarted, RunTerminalEvent, SkippedFileRow, SkippedReported, StaticVerdict, StreamSchemaVersion, TceReported, VerdictCounts, VerdictLocation, VerdictMutant, VerdictReached, VerdictThresholds, WorkerReported, WorkerRole };
 }
 //#endregion
 //#region src/run/phase-clock.service.d.ts
@@ -619,7 +672,7 @@ declare const makeRunEventStream: (resolved: {
   readonly mode: "human" | "machine";
   readonly signal: "agent" | "env" | "flag" | "tool" | "tty";
 }) => Effect$1.Effect<{
-  queue: Queue.Queue<mod_d_exports$1$1.FeedbackReported | mod_d_exports$1$1.FormatRegistryResolved | mod_d_exports$1$1.Heartbeat | mod_d_exports$1$1.HelpRendered | mod_d_exports$1$1.MutantDetailReported | mod_d_exports$1$1.PhaseEntered | mod_d_exports$1$1.PlanKnown | mod_d_exports$1$1.PluginsReported | mod_d_exports$1$1.ReuseReported | mod_d_exports$1$1.RunFailed | mod_d_exports$1$1.RunMutantTestedEvent | mod_d_exports$1$1.RunStarted | mod_d_exports$1$1.SkippedReported | mod_d_exports$1$1.VerdictReached, Cause.Done<void>>;
+  queue: Queue.Queue<mod_d_exports$1$1.FeedbackReported | mod_d_exports$1$1.FormatRegistryResolved | mod_d_exports$1$1.Heartbeat | mod_d_exports$1$1.HelpRendered | mod_d_exports$1$1.MutantDetailReported | mod_d_exports$1$1.PhaseEntered | mod_d_exports$1$1.PlanKnown | mod_d_exports$1$1.PluginsReported | mod_d_exports$1$1.Refused | mod_d_exports$1$1.ReuseReported | mod_d_exports$1$1.RunFailed | mod_d_exports$1$1.RunMutantTestedEvent | mod_d_exports$1$1.RunStarted | mod_d_exports$1$1.SkippedReported | mod_d_exports$1$1.TceReported | mod_d_exports$1$1.VerdictReached | mod_d_exports$1$1.WorkerReported, Cause.Done<void>>;
   runId: string & import("effect/Brand").Brand<"RunId">;
   startedAt: number;
   isOpen: Effect$1.Effect<boolean, never, never>;
@@ -629,7 +682,7 @@ declare const makeRunEventStream: (resolved: {
 }, never, RunEventDrain | Stdio.Stdio>;
 //#endregion
 //#region src/run-events.service.d.ts
-declare const RunEvents_base: Context.ServiceClass<RunEvents, "@systemfsoftware/stryker-js/run-events.service/RunEvents", Queue.Queue<mod_d_exports$1$1.FeedbackReported | mod_d_exports$1$1.FormatRegistryResolved | mod_d_exports$1$1.Heartbeat | mod_d_exports$1$1.HelpRendered | mod_d_exports$1$1.MutantDetailReported | mod_d_exports$1$1.PhaseEntered | mod_d_exports$1$1.PlanKnown | mod_d_exports$1$1.PluginsReported | mod_d_exports$1$1.ReuseReported | mod_d_exports$1$1.RunFailed | mod_d_exports$1$1.RunMutantTestedEvent | mod_d_exports$1$1.RunStarted | mod_d_exports$1$1.SkippedReported | mod_d_exports$1$1.VerdictReached, Cause.Done<void>>>;
+declare const RunEvents_base: Context.ServiceClass<RunEvents, "@systemfsoftware/stryker-js/run-events.service/RunEvents", Queue.Queue<mod_d_exports$1$1.FeedbackReported | mod_d_exports$1$1.FormatRegistryResolved | mod_d_exports$1$1.Heartbeat | mod_d_exports$1$1.HelpRendered | mod_d_exports$1$1.MutantDetailReported | mod_d_exports$1$1.PhaseEntered | mod_d_exports$1$1.PlanKnown | mod_d_exports$1$1.PluginsReported | mod_d_exports$1$1.Refused | mod_d_exports$1$1.ReuseReported | mod_d_exports$1$1.RunFailed | mod_d_exports$1$1.RunMutantTestedEvent | mod_d_exports$1$1.RunStarted | mod_d_exports$1$1.SkippedReported | mod_d_exports$1$1.TceReported | mod_d_exports$1$1.VerdictReached | mod_d_exports$1$1.WorkerReported, Cause.Done<void>>>;
 declare class RunEvents extends RunEvents_base {}
 interface RunIdentityShape {
   readonly runId: string;
@@ -637,6 +690,11 @@ interface RunIdentityShape {
 }
 declare const RunIdentity_base: Context.ServiceClass<RunIdentity, "@systemfsoftware/stryker-js/run-events.service/RunIdentity", RunIdentityShape>;
 declare class RunIdentity extends RunIdentity_base {}
+interface WorkerReportsShape {
+  readonly report: (role: mod_d_exports$1$1.WorkerRole, startupMs: number) => Effect$1.Effect<void>;
+}
+declare const WorkerReports_base: Context.ServiceClass<WorkerReports, "@systemfsoftware/stryker-js/run-events.service/WorkerReports", WorkerReportsShape>;
+declare class WorkerReports extends WorkerReports_base {}
 declare namespace git_diff_schema_d_exports {
   export { DiffHunk, DiffScopeCommand, DiffScopeDecision, DiffScoped, FullScope, GitCommandFailed, GitDiffError, GitDiffResult, GitRefUnresolved };
 }
@@ -2516,6 +2574,11 @@ declare const IncrementalReportSchema: S.StructWithRest<S.Struct<{
       readonly ownerVersion: S.String;
     }>>;
   }>>;
+  readonly costs: S.$Record<S.brand<S.String, "MutantId">, S.Struct<{
+    readonly predictedMs: S.Finite;
+    readonly actualMs: S.NullOr<S.Finite>;
+    readonly coveringTests: S.Int;
+  }>>;
   readonly testFiles: S.optional<S.$Record<S.String, S.Struct<{
     readonly source: S.optional<S.String>;
     readonly tests: S.$Array<S.Struct<{
@@ -2551,6 +2614,10 @@ declare const IncrementalReportSchema: S.StructWithRest<S.Struct<{
       }>, never, never>>;
     }>>;
   }>>>;
+  readonly budget: S.optional<S.Struct<{
+    readonly predictedSeconds: S.Finite;
+    readonly actualSeconds: S.Finite;
+  }>>;
   readonly dryRunCoverage: S.optionalKey<S.Unknown>;
 }>, readonly [S.$Record<S.String, S.Unknown>]>;
 type IncrementalReport = S.Schema.Type<typeof IncrementalReportSchema>;
@@ -2868,11 +2935,16 @@ interface MutationReportingInput {
   readonly basePath: string;
   readonly reporterStage: ReporterStage;
   readonly formatRegistry: mod_d_exports$1.FormatRegistry;
+  readonly timeOverheadMs: number;
   readonly closureDigestsByMutantId?: Readonly<Record<string, string>>;
   readonly timeoutEvidenceByMutantId?: Readonly<Record<string, TimeoutEvidence>>;
+  readonly concurrency: number;
+  readonly runStartedAt: number;
 }
 interface MutationReportingService {
-  readonly reportCheckFailure: (mutant: mod_d_exports$2$1.MutantTestCoverage, result: Exclude<mod_d_exports$3.CheckResult, mod_d_exports$3.PassedCheckResult>) => Effect$1.Effect<mod_d_exports$2$1.RunMutantResult>;
+  readonly reportCheckFailure: (mutant: mod_d_exports$2$1.MutantTestCoverage, result: mod_d_exports$3.FailedCheckResult) => Effect$1.Effect<mod_d_exports$2$1.RunMutantResult>;
+  readonly reportIgnored: (mutant: mod_d_exports$2$1.MutantTestCoverage, result: mod_d_exports$3.IgnoredCheckResult) => Effect$1.Effect<mod_d_exports$2$1.RunMutantResult>;
+  readonly reportNoCoverage: (mutant: mod_d_exports$2$1.MutantTestCoverage) => Effect$1.Effect<mod_d_exports$2$1.RunMutantResult>;
   readonly reportMutantRunResult: (mutant: mod_d_exports$2$1.MutantTestCoverage, result: mod_d_exports$9.MutantRunResult) => Effect$1.Effect<mod_d_exports$2$1.RunMutantResult>;
   readonly reportAll: (input: MutationReportingInput) => Effect$1.Effect<MutationTestDone, PlatformError>;
   readonly checkpoint: (input: MutationReportingInput, plannedMutants: readonly mod_d_exports$2$1.Mutant[]) => Effect$1.Effect<void, PlatformError>;
@@ -2892,9 +2964,9 @@ declare class IdGenerator extends IdGenerator_base {
 }
 //#endregion
 //#region src/run/StageServices.service.d.ts
-type StageServices = ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | GitDiff | IdGenerator | MutationReporting | Path.Path | PhaseClock | ProjectFiles | Reporter | RunEnvironment | RunEvents | Scope.Scope | Stdio.Stdio | WorkerLauncher;
+type StageServices = ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | GitDiff | IdGenerator | MutationReporting | Path.Path | PhaseClock | ProjectFiles | Reporter | RunEnvironment | RunEvents | WorkerReports | Scope.Scope | Stdio.Stdio | WorkerLauncher;
 type EnginePorts = ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | GitDiff | Path.Path | Stdio.Stdio | WorkerLauncher;
-type RunStageServices = ProjectFiles | Reporter | RunEnvironment | RunEvents | IdGenerator | MutationReporting | PhaseClock | Scope.Scope;
+type RunStageServices = ProjectFiles | Reporter | RunEnvironment | RunEvents | WorkerReports | IdGenerator | MutationReporting | PhaseClock | Scope.Scope;
 type WiredRunLayer = Layer.Layer<RunStageServices | EnginePorts, never, never>;
 //#endregion
 //#region src/run/RunEnvironment.service.d.ts

package/dist/config.d.mts

@@ -1,5 +1,5 @@
-import { i as mod_d_exports$5 } from "./index-Cf9G6kA8.mjs";
-import { a as ImmutablePrimitive, c as StrykerConfigExport, i as Immutable, l as StrykerConfigFn, o as Primitive, r as ConfigEnv, s as StrykerConfig, t as mergeConfig } from "./merge-config-BdQdK3PM.mjs";
+import { i as mod_d_exports$5 } from "./index-DEphx668.mjs";
+import { a as ImmutablePrimitive, c as StrykerConfigExport, i as Immutable, l as StrykerConfigFn, o as Primitive, r as ConfigEnv, s as StrykerConfig, t as mergeConfig } from "./merge-config-b06M-Ccx.mjs";
 //#region src/config/define-config.d.ts
 export declare function defineConfig(config: StrykerConfig): StrykerConfig;
 export declare function defineConfig(config: Promise<StrykerConfig>): Promise<StrykerConfig>;

package/dist/config.mjs

@@ -1,4 +1,4 @@
-import { t as mergeConfig } from "./merge-config-zsGl1aWc.mjs";
+import { t as mergeConfig } from "./merge-config-BYhhPA7r.mjs";
 //#region src/config/define-config.ts
 function defineConfig(config) {
 	return config;

package/dist/events.d.mts

@@ -1,2 +1,2 @@
-import { n as StageError, t as PrepareError } from "./Run.schema-B1HZugu9.mjs";
+import { n as StageError, t as PrepareError } from "./Run.schema-CgcTsB1w.mjs";
 export { PrepareError, StageError };

package/dist/{index-Cf9G6kA8.d.mts → index-DEphx668.d.mts}

@@ -1358,8 +1358,11 @@ declare const CheckResultSchema: S.toTaggedUnion<"status", readonly [S.Struct<{
 }>, S.Struct<{
   readonly status: S.Literal<"compileError">;
   readonly reason: S.String;
+}>, S.Struct<{
+  readonly status: S.Literal<"ignored">;
+  readonly reason: S.String;
 }>]>;
-declare const CheckStatus: S.Literals<readonly ["passed", "compileError"]>;
+declare const CheckStatus: S.Literals<readonly ["passed", "compileError", "ignored"]>;
 type CheckStatus = typeof CheckStatus.Type;
 declare const CheckerFailed_base: S.Class<CheckerFailed, S.TaggedStruct<"CheckerFailed", {
   readonly cause: S.String;
@@ -1373,6 +1376,9 @@ type CheckResult = typeof CheckResultSchema.Type;
 type FailedCheckResult = Extract<CheckResult, {
   readonly status: 'compileError';
 }>;
+type IgnoredCheckResult = Extract<CheckResult, {
+  readonly status: 'ignored';
+}>;
 type PassedCheckResult = Extract<CheckResult, {
   readonly status: 'passed';
 }>;
@@ -1386,7 +1392,7 @@ interface CheckerService {
 declare const Checker_base: Context.ServiceClass<Checker, "@systemfsoftware/stryker-js-plugin-interface/Checker.service/Checker", CheckerService>;
 declare class Checker extends Checker_base {}
 declare namespace mod_d_exports {
-  export { CheckResult, CheckResultSchema, CheckStatus, Checker, CheckerFailed, CheckerMutantWire, CheckerService, FailedCheckResult, PassedCheckResult };
+  export { CheckResult, CheckResultSchema, CheckStatus, Checker, CheckerFailed, CheckerMutantWire, CheckerService, FailedCheckResult, IgnoredCheckResult, PassedCheckResult };
 }
 //#endregion
 //#region src/Mutant.schema.d.ts
@@ -2929,6 +2935,9 @@ declare const CheckerCheckResult: S.$Record<S.String, S.toTaggedUnion<"status",
 }>, S.Struct<{
   readonly status: S.Literal<"compileError">;
   readonly reason: S.String;
+}>, S.Struct<{
+  readonly status: S.Literal<"ignored">;
+  readonly reason: S.String;
 }>]>>;
 declare const CheckerGroupResult: S.$Array<S.$Array<S.String>>;
 declare const ReporterInitOptions: S.Struct<{

package/dist/index.d.mts

@@ -1,7 +1,7 @@
-import { c as mod_d_exports$9, i as mod_d_exports$5$1, l as Ignorer, n as mod_d_exports$2$1, o as mod_d_exports$7$1, t as mod_d_exports$8, u as Node_2 } from "./index-Cf9G6kA8.mjs";
-import { a as ImmutablePrimitive, i as Immutable, n as mergeConfigs, o as Primitive } from "./merge-config-BdQdK3PM.mjs";
-import { n as StageError } from "./Run.schema-B1HZugu9.mjs";
-import { $ as makeRunEventStream, A as ReporterWorkerClient, B as ProjectFile, C as PluginSource, D as TestCoverage, E as SandboxHandle, F as WorkerLauncherShape, G as git_diff_service_d_exports, H as mod_d_exports$2$11, I as WorkerSpawnParams, J as RunIdentity, K as git_diff_schema_d_exports, L as SpawnedSocketWorker, M as reporterWorkerFactory, N as spawnReporterWorker, O as REPORTER_EVENT_BATCH_BOUND, P as WorkerLauncher, Q as RunEventStream, R as make, S as PluginKind, T as WorkerPluginSource, U as Framework, V as IncrementalReportSchema, W as GitDiff, X as RunEventDrain, Y as RunIdentityShape, Z as RunEventDrainLive, _ as EvaluatorPluginDescriptor, a as StageServices, at as StrykerError, b as PluginDescriptor, c as IdGeneratorShape, ct as ConfigFileNotFoundError, d as InstrumentDone, dt as ChildProcessCrashedError, et as ResolvedModeInput, f as PrepareDone, ft as OutOfMemoryError, g as AnyWorkerPluginSource, h as AnyWorkerPluginDescriptor, ht as WorkerExit, i as RunStageServices, it as mod_d_exports$1$7, j as SpawnReporterWorkerParams, k as ReporterStage, l as MutationTestDone, lt as ConfigFileUnreadableError, m as AnyPluginDescriptor, mt as WorkerBootTimeoutError, n as RunEnvironmentShape, nt as PhaseClock, o as WiredRunLayer, ot as ConfigError, p as PrepareExecutorArgs, pt as WorkerBootError, q as RunEvents, r as EnginePorts, rt as mod_d_exports$10, s as IdGenerator, st as ConfigFileInvalidError, t as RunEnvironment, tt as ResolvedMode, u as DryRunDone, ut as ConfigFileUnsupportedError, v as EvaluatorPluginSource, w as WorkerPluginDescriptor, x as PluginDescriptorOf, y as LoadedPlugins, z as Project } from "./RunEnvironment.service-B1bsWOQ9.mjs";
+import { c as mod_d_exports$9, i as mod_d_exports$5$1, l as Ignorer, n as mod_d_exports$2$1, o as mod_d_exports$7$1, t as mod_d_exports$8, u as Node_2 } from "./index-DEphx668.mjs";
+import { a as ImmutablePrimitive, i as Immutable, n as mergeConfigs, o as Primitive } from "./merge-config-b06M-Ccx.mjs";
+import { n as StageError } from "./Run.schema-CgcTsB1w.mjs";
+import { $ as makeRunEventStream, A as ReporterWorkerClient, B as ProjectFile, C as PluginSource, D as TestCoverage, E as SandboxHandle, F as WorkerLauncherShape, G as git_diff_service_d_exports, H as mod_d_exports$2$11, I as WorkerSpawnParams, J as RunIdentity, K as git_diff_schema_d_exports, L as SpawnedSocketWorker, M as reporterWorkerFactory, N as spawnReporterWorker, O as REPORTER_EVENT_BATCH_BOUND, P as WorkerLauncher, Q as RunEventStream, R as make, S as PluginKind, T as WorkerPluginSource, U as Framework, V as IncrementalReportSchema, W as GitDiff, X as RunEventDrain, Y as RunIdentityShape, Z as RunEventDrainLive, _ as EvaluatorPluginDescriptor, a as StageServices, at as StrykerError, b as PluginDescriptor, c as IdGeneratorShape, ct as ConfigFileNotFoundError, d as InstrumentDone, dt as ChildProcessCrashedError, et as ResolvedModeInput, f as PrepareDone, ft as OutOfMemoryError, g as AnyWorkerPluginSource, h as AnyWorkerPluginDescriptor, ht as WorkerExit, i as RunStageServices, it as mod_d_exports$1$7, j as SpawnReporterWorkerParams, k as ReporterStage, l as MutationTestDone, lt as ConfigFileUnreadableError, m as AnyPluginDescriptor, mt as WorkerBootTimeoutError, n as RunEnvironmentShape, nt as PhaseClock, o as WiredRunLayer, ot as ConfigError, p as PrepareExecutorArgs, pt as WorkerBootError, q as RunEvents, r as EnginePorts, rt as mod_d_exports$10, s as IdGenerator, st as ConfigFileInvalidError, t as RunEnvironment, tt as ResolvedMode, u as DryRunDone, ut as ConfigFileUnsupportedError, v as EvaluatorPluginSource, w as WorkerPluginDescriptor, x as PluginDescriptorOf, y as LoadedPlugins, z as Project } from "./RunEnvironment.service-F8LgeCqh.mjs";
 import { Blueprint, Cell, Handle, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
 import * as S from "effect/Schema";
 import * as Option from "effect/Option";
@@ -495,7 +495,7 @@ type ValidationSchemaDocument<A = unknown> = {
 //#endregion
 //#region src/run/load-config.d.ts
 interface ConfigInvocation {
-  readonly command: 'run' | 'merge-reports';
+  readonly command: 'run' | 'merge';
   readonly mode: mod_d_exports$10.OutputMode;
 }
 declare const forkCoreSchema: import("effect/JsonSchema").JsonSchema;
@@ -1136,7 +1136,7 @@ declare const staticVerdictOf: (results: readonly mod_d_exports$2$1.RunMutantRes
 //#endregion
 //#region src/reporting/verdict-envelope.schema.d.ts
 declare const VerdictEnvelope_base: S.Class<VerdictEnvelope, S.Struct<{
-  readonly schemaVersion: S.Literal<"2.0">;
+  readonly schemaVersion: S.Literal<"6.0">;
   readonly runId: S.brand<S.String, "RunId">;
   readonly mode: S.Literals<readonly ["human", "machine"]>;
   readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
@@ -1167,6 +1167,7 @@ declare const VerdictEnvelope_base: S.Class<VerdictEnvelope, S.Struct<{
   }>>;
   readonly scope: S.Literals<readonly ["full", "diff"]>;
   readonly mutantSetPolicy: S.Literals<readonly ["default", "full"]>;
+  readonly incrementalMode: S.Literals<readonly ["incremental", "full"]>;
   readonly phaseDurations: S.NullOr<S.Struct<{
     readonly prepare: S.Finite;
     readonly instrument: S.Finite;
@@ -1177,6 +1178,10 @@ declare const VerdictEnvelope_base: S.Class<VerdictEnvelope, S.Struct<{
     readonly count: S.Int;
     readonly costMs: S.Finite;
   }>>;
+  readonly budget: S.Struct<{
+    readonly predictedSeconds: S.Finite;
+    readonly actualSeconds: S.Finite;
+  }>;
 }>, {}>;
 declare class VerdictEnvelope extends VerdictEnvelope_base {}
 //#endregion

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
-import { i as Mutant_exports, l as Report_exports, n as mergeConfigs } from "./merge-config-zsGl1aWc.mjs";
-import { $ as WorkerLauncher, A as classifyWorkerExit, At as OutOfMemoryError, B as SurvivorRef, C as nodePlatformLayer, Ct as MergeResult, D as git_diff_schema_exports, Dt as survivorsPriorReport, E as git_diff_service_exports, Et as forkOptionsSchema, F as readConfig, Ft as CheckerAnsweredUnrequested, G as generateRunId, H as RunEvents, I as RunEnvironment, It as CheckerSkippedRequested, J as metricsResultFromFiles, K as VerdictEnvelope, L as IdGenerator, M as loadConfigCell, Mt as OutputMode_exports, N as describeErrors, Nt as RunEvent_exports$1, O as ClassifyWorkerExitCommand, Ot as checkGroupedPlans, P as forkCoreSchema, Pt as SpanTaxonomy_exports, Q as makeWorkerClient, R as surfacedSurvivorsOf, S as IncrementalReportSchema, St as MergeCommand, T as GitDiff, Tt as extendsPropertySchema, U as RunIdentity, V as StrykerPackage, W as buildVerdictEnvelope, X as reporterWorkerFactory, Y as MetricsResultFromReport, Z as spawnReporterWorker, _ as isCommandRunner, _t as defaultOptions, a as MachineConsole, at as initialExtendsStepState, b as readProjectCell, bt as ExtendsStepStateSchema, c as prepareCell, ct as ExtendsStepRead, d as buildTestRunner, dt as ConfigError, et as make, f as makeChildProcessTestRunner, ft as ConfigFileInvalidError, g as vmTestRunnerConfig, gt as createDefaultOptions, h as vmRunnerPluginUrl, ht as ConfigFileUnsupportedError, i as makeRunEventStream, it as importModule, j as validateOptions, jt as WorkerBootTimeoutError, k as ClassifyWorkerExitDecision, kt as ChildProcessCrashedError, l as mutantDetailEventsOf, lt as ExtendsStepRefused, m as testRunnerConfigOf, mt as ConfigFileUnreadableError, n as RunEventDrain, nt as FileMatcher, o as HtmlReporter_exports, ot as StrykerError, p as isVmRunner, pt as ConfigFileNotFoundError, q as staticVerdictOf, r as RunEventDrainLive, rt as decideExtendsStep, s as mutationTestCell, st as ExtendsStepDone, t as strykerCell, tt as ReproducerSchema, u as instrumentCell, ut as ExtendsStepResolve, v as import_closure_cell_exports, vt as ConfigDocumentSchema, w as layerWorkerProtocol, wt as ReadConfigCommand, x as concurrencyCell, xt as ImportedModuleSchema, y as relativeNormalizedFileName, yt as ExtendsStepDocumentSchema, z as SurfacingFields } from "./run-stages-aBT_QAfO.mjs";
+import { i as Mutant_exports, l as Report_exports, n as mergeConfigs } from "./merge-config-BYhhPA7r.mjs";
+import { $ as WorkerLauncher, A as classifyWorkerExit, At as OutOfMemoryError, B as SurvivorRef, C as nodePlatformLayer, Ct as MergeResult, D as git_diff_schema_exports, Dt as survivorsPriorReport, E as git_diff_service_exports, Et as forkOptionsSchema, F as readConfig, Ft as CheckerAnsweredUnrequested, G as generateRunId, H as RunEvents, I as RunEnvironment, It as CheckerSkippedRequested, J as metricsResultFromFiles, K as VerdictEnvelope, L as IdGenerator, M as loadConfigCell, Mt as OutputMode_exports, N as describeErrors, Nt as RunEvent_exports$1, O as ClassifyWorkerExitCommand, Ot as checkGroupedPlans, P as forkCoreSchema, Pt as SpanTaxonomy_exports, Q as makeWorkerClient, R as surfacedSurvivorsOf, S as IncrementalReportSchema, St as MergeCommand, T as GitDiff, Tt as extendsPropertySchema, U as RunIdentity, V as StrykerPackage, W as buildVerdictEnvelope, X as reporterWorkerFactory, Y as MetricsResultFromReport, Z as spawnReporterWorker, _ as isCommandRunner, _t as defaultOptions, a as MachineConsole, at as initialExtendsStepState, b as readProjectCell, bt as ExtendsStepStateSchema, c as prepareCell, ct as ExtendsStepRead, d as buildTestRunner, dt as ConfigError, et as make, f as makeChildProcessTestRunner, ft as ConfigFileInvalidError, g as vmTestRunnerConfig, gt as createDefaultOptions, h as vmRunnerPluginUrl, ht as ConfigFileUnsupportedError, i as makeRunEventStream, it as importModule, j as validateOptions, jt as WorkerBootTimeoutError, k as ClassifyWorkerExitDecision, kt as ChildProcessCrashedError, l as mutantDetailEventsOf, lt as ExtendsStepRefused, m as testRunnerConfigOf, mt as ConfigFileUnreadableError, n as RunEventDrain, nt as FileMatcher, o as HtmlReporter_exports, ot as StrykerError, p as isVmRunner, pt as ConfigFileNotFoundError, q as staticVerdictOf, r as RunEventDrainLive, rt as decideExtendsStep, s as mutationTestCell, st as ExtendsStepDone, t as strykerCell, tt as ReproducerSchema, u as instrumentCell, ut as ExtendsStepResolve, v as import_closure_cell_exports, vt as ConfigDocumentSchema, w as layerWorkerProtocol, wt as ReadConfigCommand, x as concurrencyCell, xt as ImportedModuleSchema, y as relativeNormalizedFileName, yt as ExtendsStepDocumentSchema, z as SurfacingFields } from "./run-stages-k4L7ymmp.mjs";
 import { n as StageError } from "./Run.schema-DuaneDGd.mjs";
 import { Cell, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
 import * as S from "effect/Schema";
@@ -242,6 +242,7 @@ const admitMutantRerun = Workflow.make({
 const PriorReportDocument = S.Struct({
 	config: S.optional(S.Record(S.String, S.Unknown)),
 	framework: S.optional(S.Struct({ version: S.optional(S.String) })),
+	budget: S.optional(RunEvent_exports$1.Budget),
 	files: S.Record(S.String, S.Struct({
 		source: S.String,
 		mutants: S.Array(S.Struct({