@systemfsoftware/stryker-js 15.0.1 → 16.0.0

package/dist/{run-stages-DdVQINP9.mjs → run-stages-k4L7ymmp.mjs}

@@ -1,5 +1,5 @@
 import { t as __exportAll$4 } from "./rolldown-runtime-8H4AJuhK.mjs";
-import { a as MutatorCatalog_exports, c as Plugin_exports, d as TestRunner_exports, f as Trace_exports$1, i as Mutant_exports, l as Report_exports, n as mergeConfigs, o as MutatorProvider_exports, r as Checker_exports, s as Options_exports, t as mergeConfig, u as Reporter_exports } from "./merge-config-zsGl1aWc.mjs";
+import { a as MutatorCatalog_exports, c as Plugin_exports, d as TestRunner_exports, f as Trace_exports$1, i as Mutant_exports, l as Report_exports, n as mergeConfigs, o as MutatorProvider_exports, r as Checker_exports, s as Options_exports, t as mergeConfig, u as Reporter_exports } from "./merge-config-BYhhPA7r.mjs";
 import { n as StageError, t as PrepareError } from "./Run.schema-DuaneDGd.mjs";
 import { Blueprint, Cell, Handle, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
 import * as S from "effect/Schema";
@@ -33,6 +33,7 @@ import * as Queue from "effect/Queue";
 import * as Scope from "effect/Scope";
 import * as HashMap from "effect/HashMap";
 import * as MutableHashMap from "effect/MutableHashMap";
+import * as Exit from "effect/Exit";
 import * as api from "@opentelemetry/api";
 import * as Headers from "effect/http/Headers";
 import * as Tracer from "effect/Tracer";
@@ -40,7 +41,6 @@ import * as RpcSerialization from "effect/rpc/RpcSerialization";
 import * as RpcServer from "effect/rpc/RpcServer";
 import * as SocketServer from "effect/socket/SocketServer";
 import * as Duration from "effect/Duration";
-import * as Exit from "effect/Exit";
 import * as Fiber from "effect/Fiber";
 import * as HashSet from "effect/HashSet";
 import * as PubSub from "effect/PubSub";
@@ -185,7 +185,32 @@ const PluginLoadFailureReason = Schema.Union([
 	Schema.TaggedStruct("InvalidContribution", { detail: Schema.String }),
 	Schema.TaggedStruct("ImportFailed", { cause: Schema.Unknown })
 ]);
-const StreamSchemaVersion = S.Literal("2.0");
+const ShardPlanVersion = S.Literal(1);
+const ShardProject = S.Struct({
+	project: S.String,
+	mutants: S.Array(S.String)
+});
+const Shard = S.Struct({
+	index: S.Int,
+	count: S.Int,
+	predictedSeconds: S.Finite,
+	projects: S.Array(ShardProject)
+});
+const labelOf = (shard) => `${shard.index}/${shard.count}`;
+const shardLabelsAreUnique = S.makeFilter((shards) => {
+	const duplicated = Mutant_exports.duplicatedValue(shards.map(labelOf));
+	return duplicated === void 0 ? void 0 : `shard plan shards share the label "${duplicated}"`;
+}, { arbitraryConstraint: { uniqueBy: labelOf } });
+const ShardPlan = S.Struct({
+	version: ShardPlanVersion,
+	targetSeconds: S.Finite,
+	shards: S.Array(Shard).check(shardLabelsAreUnique),
+	matrix: S.Struct({ include: S.Array(S.Struct({
+		shard: S.String,
+		predictedSeconds: S.Finite
+	})) })
+});
+const StreamSchemaVersion = S.Literal("6.0");
 const RunPhase = S.Literals([
 	"prepare",
 	"instrument",
@@ -203,8 +228,18 @@ var PhaseEntered = class extends S.TaggedClass()("phase", {
 	phase: RunPhase,
 	elapsedMs: Report_exports.NonNegativeFinite
 }) {};
-var PlanKnown = class extends S.TaggedClass()("plan", { total: Report_exports.NonNegativeInt }) {};
-const MutantCost = S.Struct({
+var PlanKnown = class extends S.TaggedClass()("plan", {
+	total: Report_exports.NonNegativeInt,
+	shardPlan: S.NullOr(ShardPlan)
+}) {};
+const WorkerRole = S.Literals(["testRunner", "checker"]);
+var WorkerReported = class extends S.TaggedClass()("worker", {
+	schemaVersion: StreamSchemaVersion,
+	role: WorkerRole,
+	index: Report_exports.NonNegativeInt,
+	startupMs: Report_exports.NonNegativeFinite
+}) {};
+const MutantCost$1 = S.Struct({
 	fixedOverheadMs: Report_exports.NonNegativeFinite,
 	testBodyMs: Report_exports.NonNegativeFinite,
 	testsExecuted: Report_exports.NonNegativeInt,
@@ -226,7 +261,7 @@ var RunMutantTestedEvent = class extends S.TaggedClass()("mutantTested", {
 	completed: Report_exports.NonNegativeInt,
 	total: Report_exports.NonNegativeInt,
 	static: S.Boolean,
-	cost: S.NullOr(MutantCost)
+	cost: S.NullOr(MutantCost$1)
 }) {};
 const RunMutantTested = S.TaggedStruct("mutant", {
 	id: Mutant_exports.MutantId,
@@ -238,7 +273,7 @@ const RunMutantTested = S.TaggedStruct("mutant", {
 	completed: Report_exports.NonNegativeInt,
 	total: Report_exports.NonNegativeInt,
 	static: S.Boolean,
-	cost: S.NullOr(MutantCost)
+	cost: S.NullOr(MutantCost$1)
 }).pipe(S.decodeTo(S.toType(RunMutantTestedEvent), {
 	decode: SchemaGetter.transform((line) => RunMutantTestedEvent.make({
 		id: line.id,
@@ -290,6 +325,7 @@ const VerdictMutant = S.Struct({
 });
 const RunScope = S.Literals(["full", "diff"]);
 const MutantSetPolicy = S.Literals(["default", "full"]);
+const IncrementalMode = S.Literals(["incremental", "full"]);
 const PhaseDurations = S.Struct({
 	prepare: Report_exports.NonNegativeFinite,
 	instrument: Report_exports.NonNegativeFinite,
@@ -300,6 +336,10 @@ const StaticVerdict = S.Struct({
 	count: Report_exports.NonNegativeInt,
 	costMs: Report_exports.NonNegativeFinite
 });
+const Budget = S.Struct({
+	predictedSeconds: Report_exports.NonNegativeFinite,
+	actualSeconds: Report_exports.NonNegativeFinite
+});
 var VerdictReached = class extends S.TaggedClass()("verdict", {
 	schemaVersion: StreamSchemaVersion,
 	runId: RunId,
@@ -312,8 +352,10 @@ var VerdictReached = class extends S.TaggedClass()("verdict", {
 	mutants: S.Array(VerdictMutant),
 	scope: RunScope,
 	mutantSetPolicy: MutantSetPolicy,
+	incrementalMode: S.optionalKey(IncrementalMode),
 	phaseDurations: S.NullOr(PhaseDurations),
-	static: S.NullOr(StaticVerdict)
+	static: S.NullOr(StaticVerdict),
+	budget: Budget
 }) {};
 const FrameworkContributionRow = S.Struct({
 	name: S.String,
@@ -360,6 +402,10 @@ var ReuseReported = class extends S.TaggedClass()("reuse", {
 	ran: Report_exports.NonNegativeInt,
 	refused: ReuseRefusals
 }) {};
+var TceReported = class extends S.TaggedClass()("tce", {
+	equivalentToOriginal: Report_exports.NonNegativeInt,
+	duplicateAtSite: Report_exports.NonNegativeInt
+}) {};
 var MutantDetailReported = class extends S.TaggedClass()("mutant-detail", {
 	id: Mutant_exports.MutantId,
 	status: Mutant_exports.MutantStatusSchema,
@@ -385,27 +431,37 @@ var HelpRendered = class extends S.TaggedClass()("help", {
 	code: S.Literals([0]),
 	help: S.String
 }) {};
+const RefusalRule = S.Literal("mutation-runs-on-main-ci");
+var Refused = class extends S.TaggedClass()("refused", {
+	schemaVersion: StreamSchemaVersion,
+	rule: RefusalRule,
+	message: S.String
+}) {};
 const RunEvent = Object.assign(S.Union([
 	RunStarted,
 	PhaseEntered,
 	PlanKnown,
+	WorkerReported,
 	RunMutantTested,
 	Heartbeat,
 	PluginsReported,
 	FormatRegistryResolved,
 	SkippedReported,
 	ReuseReported,
+	TceReported,
 	MutantDetailReported,
 	FeedbackReported,
 	VerdictReached,
 	RunFailed,
-	HelpRendered
+	HelpRendered,
+	Refused
 ]), { QUEUE_BOUND: 256 });
 const RunEventWireLine = S.String.pipe(S.decodeTo(S.fromJsonString(RunEvent), {
 	decode: SchemaGetter$1.transform((line) => line.replace(/\n$/, "")),
 	encode: SchemaGetter$1.transform((json) => `${json}\n`)
 }));
 var RunEvent_exports = /* @__PURE__ */ __exportAll$3({
+	Budget: () => Budget,
 	FeedbackJudgment: () => FeedbackJudgment,
 	FeedbackReported: () => FeedbackReported,
 	FormatClaimShadowingRow: () => FormatClaimShadowingRow,
@@ -415,7 +471,8 @@ var RunEvent_exports = /* @__PURE__ */ __exportAll$3({
 	FrameworkModuleRow: () => FrameworkModuleRow,
 	Heartbeat: () => Heartbeat,
 	HelpRendered: () => HelpRendered,
-	MutantCost: () => MutantCost,
+	IncrementalMode: () => IncrementalMode,
+	MutantCost: () => MutantCost$1,
 	MutantDetailReported: () => MutantDetailReported,
 	MutantSetPolicy: () => MutantSetPolicy,
 	PhaseDurations: () => PhaseDurations,
@@ -423,6 +480,8 @@ var RunEvent_exports = /* @__PURE__ */ __exportAll$3({
 	PlanKnown: () => PlanKnown,
 	PluginLoadFailureReason: () => PluginLoadFailureReason,
 	PluginsReported: () => PluginsReported,
+	RefusalRule: () => RefusalRule,
+	Refused: () => Refused,
 	ReuseRefusals: () => ReuseRefusals,
 	ReuseReported: () => ReuseReported,
 	RunEvent: () => RunEvent,
@@ -438,10 +497,13 @@ var RunEvent_exports = /* @__PURE__ */ __exportAll$3({
 	SkippedReported: () => SkippedReported,
 	StaticVerdict: () => StaticVerdict,
 	StreamSchemaVersion: () => StreamSchemaVersion,
+	TceReported: () => TceReported,
 	VerdictLocation: () => VerdictLocation,
 	VerdictMutant: () => VerdictMutant,
 	VerdictReached: () => VerdictReached,
-	VerdictThresholds: () => VerdictThresholds
+	VerdictThresholds: () => VerdictThresholds,
+	WorkerReported: () => WorkerReported,
+	WorkerRole: () => WorkerRole
 });
 const SpanName = S.String.check(S.isPattern(/^[A-Za-z][A-Za-z0-9_-]*(?:\.[A-Za-z][A-Za-z0-9_-]*)*$/u, { expected: "a dot-separated span name whose segments start with a letter, such as \"stryker.checker.check\"" })).pipe(S.brand("SpanName"));
 const SpanAttributeKey = S.String.check(S.isPattern(/^[A-Za-z][A-Za-z0-9_.-]*$/u, { expected: "an attribute key starting with a letter, such as \"stryker.checker.name\"" })).pipe(S.brand("SpanAttributeKey"));
@@ -688,74 +750,6 @@ const Spans = {
 		name: "stryker.load_config",
 		attributes: {}
 	},
-	mergeReports: {
-		name: "stryker.merge_reports",
-		attributes: {}
-	},
-	mergeReportsCollectPartDirs: {
-		name: "stryker.merge_reports.collect_part_dirs",
-		attributes: {}
-	},
-	mergeReportsDirectoryExists: {
-		name: "stryker.merge_reports.directory_exists",
-		attributes: {}
-	},
-	mergeReportsEncodeReport: {
-		name: "stryker.merge_reports.encode_report",
-		attributes: {}
-	},
-	mergeReportsFail: {
-		name: "stryker.merge_reports.fail",
-		attributes: {}
-	},
-	mergeReportsGather: {
-		name: "stryker.merge_reports.gather",
-		attributes: {}
-	},
-	mergeReportsListNames: {
-		name: "stryker.merge_reports.list_names",
-		attributes: {}
-	},
-	mergeReportsPutFile: {
-		name: "stryker.merge_reports.put_file",
-		attributes: {}
-	},
-	mergeReportsReadPart: {
-		name: "stryker.merge_reports.read_part",
-		attributes: {}
-	},
-	mergeReportsReadText: {
-		name: "stryker.merge_reports.read_text",
-		attributes: {}
-	},
-	mergeReportsRefuseCommand: {
-		name: "stryker.merge_reports.refuse_command",
-		attributes: {}
-	},
-	mergeReportsRefuseParts: {
-		name: "stryker.merge_reports.refuse_parts",
-		attributes: {}
-	},
-	mergeReportsRenderHtml: {
-		name: "stryker.merge_reports.render_html",
-		attributes: {}
-	},
-	mergeReportsWriteAbsent: {
-		name: "stryker.merge_reports.write_absent",
-		attributes: {}
-	},
-	mergeReportsWriteFiles: {
-		name: "stryker.merge_reports.write_files",
-		attributes: {}
-	},
-	mergeReportsWriteHtml: {
-		name: "stryker.merge_reports.write_html",
-		attributes: {}
-	},
-	mergeReportsWriteMerged: {
-		name: "stryker.merge_reports.write_merged",
-		attributes: {}
-	},
 	mutantRun: {
 		name: "stryker.mutant_run",
 		attributes: {}
@@ -10244,6 +10238,48 @@ const resolveConfig = Workflow.make({
 	})
 });
 //#endregion
+//#region src/atomic-write.cell.ts
+const writeFileAtomic = Effect$1.fn(SpanTaxonomy_exports.Spans.mutationReportingWriteAtomic.name)(function* (ports, file, content) {
+	const directory = ports.path.dirname(file);
+	yield* ports.fs.makeDirectory(directory, { recursive: true });
+	const temp = yield* ports.fs.makeTempFile({
+		directory,
+		prefix: `${ports.path.basename(file)}.`,
+		suffix: ".tmp"
+	});
+	yield* Effect$1.gen(function* () {
+		yield* ports.fs.writeFileString(temp, content);
+		yield* ports.fs.rename(temp, file);
+	}).pipe(Effect$1.onExit((exit) => Exit.isSuccess(exit) ? Effect$1.void : ports.fs.remove(temp).pipe(Effect$1.ignore)));
+});
+//#endregion
+//#region src/mutant-cost.ts
+const executedTestBodyMsOf = (executedTests) => executedTests.reduce((total, test) => total + test.timeSpentMs, 0);
+const testBodyMsOf = (result) => Match$1.value(result).pipe(Match$1.when({ status: "killed" }, (killed) => executedTestBodyMsOf(killed.executedTests)), Match$1.when({ status: "survived" }, (survived) => executedTestBodyMsOf(survived.executedTests)), Match$1.orElse(() => 0));
+const bodyTimeWithinWall = (elapsedMs, testBodyMs) => Math.min(testBodyMs, elapsedMs);
+const costTotalMsOf = (cost) => cost === void 0 ? void 0 : cost.fixedOverheadMs + cost.testBodyMs;
+const mutantCostOf = (input) => {
+	const testBodyMs = bodyTimeWithinWall(input.elapsedMs, input.testBodyMs);
+	return {
+		fixedOverheadMs: input.elapsedMs - testBodyMs,
+		testBodyMs,
+		testsExecuted: input.testsExecuted,
+		shared: input.shared
+	};
+};
+//#endregion
+//#region src/budget.ts
+const MILLIS_PER_SECOND = 1e3;
+const costMsOf = (result) => costTotalMsOf(result.cost) ?? 0;
+const predictedSecondsOf = (results, concurrency) => {
+	const lanes = concurrency > 0 ? concurrency : 1;
+	return Arr.reduce(results, 0, (total, result) => total + costMsOf(result)) / lanes / MILLIS_PER_SECOND;
+};
+const budgetOf$1 = (input) => ({
+	predictedSeconds: input.planPredictedSeconds ?? predictedSecondsOf(input.results, input.concurrency),
+	actualSeconds: input.actualSeconds
+});
+//#endregion
 //#region src/build-reproducers.workflow.ts
 const CONTEXT_LINES = 3;
 const maxOf$1 = (left, right) => Boolean$1$1.match(left < right, {
@@ -10315,7 +10351,7 @@ const fileNameOrder = Order.mapInput(Order.String, (reproducer) => reproducer.fi
 const idOrder$1 = Order.mapInput(Order.String, (reproducer) => reproducer.id);
 const reproducersOf = (report) => Arr.sort(Arr.flatMap(Object.entries(report.files), ([fileName, file]) => Arr.map(file.mutants, (mutant) => reproducerOf(fileName, file.source, mutant))), Order.combine(fileNameOrder, idOrder$1));
 const mutantsOf = (report) => Arr.flatMap(Object.values(report.files), (file) => file.mutants);
-const decide$23 = (command) => {
+const decide$24 = (command) => {
 	const mutants = mutantsOf(command.report);
 	return Boolean$1$1.match(mutants.length === 0, {
 		onTrue: () => NoMutantsToReproduce.make({}),
@@ -10326,7 +10362,7 @@ const buildReproducers = Workflow.make({
 	command: BuildReproducersCommand,
 	decision: BuildReproducersDecision,
 	error: S.Never,
-	decide: (command) => Result.succeed(decide$23(command))
+	decide: (command) => Result.succeed(decide$24(command))
 });
 //#endregion
 //#region src/checkpoint-mutants.workflow.ts
@@ -10350,7 +10386,7 @@ var CheckpointMutantsCommand = class extends S.TaggedClass()("CheckpointMutantsC
 };
 const settledByIdOf = (settled) => HashMap.fromIterable(settled.map((row) => [row.mutant.id, row]));
 const rowOf = (mutant, settledById) => Option$1.getOrElse(HashMap.get(settledById, mutant.id), () => CheckpointPendingMutant.make({ mutant }));
-const decide$22 = (command) => {
+const decide$23 = (command) => {
 	const settledById = settledByIdOf(command.settled);
 	return Result.succeed(command.plannedMutants.map((mutant) => rowOf(mutant, settledById)));
 };
@@ -10358,7 +10394,7 @@ const checkpointMutants = Workflow.make({
 	command: CheckpointMutantsCommand,
 	decision: S.Array(CheckpointMutantRow),
 	error: S.Never,
-	decide: decide$22
+	decide: decide$23
 });
 //#endregion
 //#region src/classify-exit.workflow.ts
@@ -10407,7 +10443,7 @@ const verdictExitClass = (score, breakingThreshold) => Match$1.valueTags(score,
 		onSome: (threshold) => Match$1.value(percentage < threshold).pipe(Match$1.when(true, () => "VerdictFail"), Match$1.when(false, () => null), Match$1.exhaustive)
 	})
 });
-const decide$21 = (command) => Option$1.match(Option$1.fromNullishOr(verdictExitClass(command.score, command.breakingThreshold)), {
+const decide$22 = (command) => Option$1.match(Option$1.fromNullishOr(verdictExitClass(command.score, command.breakingThreshold)), {
 	onNone: () => Option$1.match(precedenceOf(command.pending), {
 		onNone: () => Result.succeed(ExitPassed.make({})),
 		onSome: (exitClass) => Result.succeed(decisionOf$3(exitClass))
@@ -10418,7 +10454,7 @@ const classifyExit = Workflow.make({
 	command: ClassifyExitCommand,
 	decision: ClassifyExitDecision,
 	error: S.Never,
-	decide: decide$21
+	decide: decide$22
 });
 //#endregion
 //#region src/IncrementalDiff.schema.ts
@@ -10480,6 +10516,61 @@ const ReuseReportSchema = S.Struct({
 	testFiles: S.optional(ReuseTestFilesSchema)
 });
 //#endregion
+//#region src/MutantCost.schema.ts
+const MutantCost = S.Struct({
+	predictedMs: S.Finite,
+	actualMs: S.NullOr(S.Finite),
+	coveringTests: S.Int
+});
+const MutantCosts = S.Record(Mutant_exports.MutantId, MutantCost);
+const MutantCostSubject = S.Struct({
+	id: Mutant_exports.MutantId,
+	static: S.optional(S.Boolean)
+});
+S.Struct({
+	subject: MutantCostSubject,
+	staticCoverage: S.optional(S.Record(S.String, Report_exports.NonNegativeFinite)),
+	allTestTimesMs: S.Array(Report_exports.NonNegativeFinite),
+	coveringTestTimesMs: S.Array(Report_exports.NonNegativeFinite),
+	executedActualMs: S.optional(Report_exports.NonNegativeFinite),
+	priorActualMs: S.optional(Report_exports.NonNegativeFinite),
+	fixedOverheadMs: Report_exports.NonNegativeFinite
+});
+S.Struct({
+	subjects: S.Array(MutantCostSubject),
+	staticCoverage: S.optional(S.Record(S.String, Report_exports.NonNegativeFinite)),
+	allTestTimesMs: S.Array(Report_exports.NonNegativeFinite),
+	coveringTestTimesMsByMutantId: S.Record(S.String, S.Array(Report_exports.NonNegativeFinite)),
+	executedActualMsByMutantId: S.Record(S.String, Report_exports.NonNegativeFinite),
+	priorActualMsByMutantId: S.Record(S.String, Report_exports.NonNegativeFinite),
+	fixedOverheadMs: Report_exports.NonNegativeFinite
+});
+//#endregion
+//#region src/mutant-cost-model.ts
+const staticHitCountOf = (staticCoverage, id) => Option$1.getOrElse(Option$1.flatMap(Option$1.fromNullishOr(staticCoverage), (coverage) => Record$1.get(coverage, id)), () => 0);
+const hasStaticHit = (staticCoverage, id) => staticCoverage === void 0 || staticHitCountOf(staticCoverage, id) > 0;
+const runsWholeSuite$1 = (input) => input.subject.static === true || hasStaticHit(input.staticCoverage, input.subject.id);
+const coveringTimesOf = (input) => runsWholeSuite$1(input) ? input.allTestTimesMs : input.coveringTestTimesMs;
+const actualMsOf = (input) => Option$1.getOrElse(Option$1.firstSomeOf([Option$1.fromNullishOr(input.executedActualMs), Option$1.fromNullishOr(input.priorActualMs)]), () => null);
+const mutantCostOfCase = (input) => {
+	const coveringTimes = coveringTimesOf(input);
+	return {
+		predictedMs: input.fixedOverheadMs + coveringTimes.reduce((total, time) => total + time, 0),
+		actualMs: actualMsOf(input),
+		coveringTests: coveringTimes.length
+	};
+};
+const caseOfSubject = (input, subject) => ({
+	subject,
+	staticCoverage: input.staticCoverage,
+	allTestTimesMs: input.allTestTimesMs,
+	coveringTestTimesMs: Option$1.getOrElse(Record$1.get(input.coveringTestTimesMsByMutantId, subject.id), () => []),
+	executedActualMs: Option$1.getOrUndefined(Record$1.get(input.executedActualMsByMutantId, subject.id)),
+	priorActualMs: Option$1.getOrUndefined(Record$1.get(input.priorActualMsByMutantId, subject.id)),
+	fixedOverheadMs: input.fixedOverheadMs
+});
+const mutantCostsOf = (input) => Object.fromEntries(input.subjects.map((subject) => [subject.id, mutantCostOfCase(caseOfSubject(input, subject))]));
+//#endregion
 //#region src/mutation-reporting.schema.ts
 var ManifestUnreadable = class extends Schema.TaggedError()("ManifestUnreadable", {
 	specifier: Schema.String,
@@ -11036,21 +11127,6 @@ S.Literal("mutation-part.json");
 S.Literal("mutation-stream.jsonl");
 const ReportFileNames = S.Record(S.String, Mutant_exports.CanonicalFileName);
 //#endregion
-//#region src/mutant-cost.ts
-const executedTestBodyMsOf = (executedTests) => executedTests.reduce((total, test) => total + test.timeSpentMs, 0);
-const testBodyMsOf = (result) => Match$1.value(result).pipe(Match$1.when({ status: "killed" }, (killed) => executedTestBodyMsOf(killed.executedTests)), Match$1.when({ status: "survived" }, (survived) => executedTestBodyMsOf(survived.executedTests)), Match$1.orElse(() => 0));
-const bodyTimeWithinWall = (elapsedMs, testBodyMs) => Math.min(testBodyMs, elapsedMs);
-const costTotalMsOf = (cost) => cost === void 0 ? void 0 : cost.fixedOverheadMs + cost.testBodyMs;
-const mutantCostOf = (input) => {
-	const testBodyMs = bodyTimeWithinWall(input.elapsedMs, input.testBodyMs);
-	return {
-		fixedOverheadMs: input.elapsedMs - testBodyMs,
-		testBodyMs,
-		testsExecuted: input.testsExecuted,
-		shared: input.shared
-	};
-};
-//#endregion
 //#region src/reporting/static-verdict.ts
 const costOrZero = (cost) => Option$1.getOrElse(Option$1.fromUndefinedOr(costTotalMsOf(cost)), () => 0);
 const staticVerdictOf = (results) => {
@@ -11077,8 +11153,10 @@ var VerdictEnvelope = class extends S.Class("VerdictEnvelope")({
 	mutants: S.Array(RunEvent_exports.VerdictMutant),
 	scope: RunEvent_exports.RunScope,
 	mutantSetPolicy: RunEvent_exports.MutantSetPolicy,
+	incrementalMode: RunEvent_exports.IncrementalMode,
 	phaseDurations: S.NullOr(RunEvent_exports.PhaseDurations),
-	static: S.NullOr(RunEvent_exports.StaticVerdict)
+	static: S.NullOr(RunEvent_exports.StaticVerdict),
+	budget: RunEvent_exports.Budget
 }) {};
 //#endregion
 //#region src/reporting/verdict-envelope.ts
@@ -11117,6 +11195,11 @@ const runIdTextOf = (now) => {
 };
 const generateRunId = (now) => RunEvent_exports.RunId.make(runIdTextOf(now));
 const isActionableStatus = S.is(Mutant_exports.ActionableStatusSchema);
+const ZERO_BUDGET = RunEvent_exports.Budget.make({
+	predictedSeconds: 0,
+	actualSeconds: 0
+});
+const budgetOf = (report) => Option$1.getOrElse(Option$1.flatMap(Option$1.fromUndefinedOr(report["budget"]), (raw) => S.decodeUnknownOption(RunEvent_exports.Budget)(raw)), () => ZERO_BUDGET);
 const actionableMutants = (files) => Arr.flatMap(Object.entries(files), ([file, fileResult]) => Arr.map(Arr.filter(fileResult.mutants, (mutant) => isActionableStatus(mutant.status)), (mutant) => RunEvent_exports.VerdictMutant.make({
 	id: mutant.id,
 	file,
@@ -11125,13 +11208,17 @@ const actionableMutants = (files) => Arr.flatMap(Object.entries(files), ([file,
 	replacement: mutant.replacement ?? null,
 	status: mutant.status
 })));
+const reusesVerdicts = (config) => config.incremental === true && config.force !== true;
+const incrementalModeOf = (decoded) => Option$1.exists(decoded, reusesVerdicts) ? "incremental" : "full";
 const embeddedConfig = (report) => {
 	const JsonReporterSchema = S.Struct({ fileName: S.String });
 	const MutatorSchema = S.StructWithRest(S.Struct({ mutantSetPolicy: S.optional(RunEvent_exports.MutantSetPolicy) }), [S.Record(S.String, S.Unknown)]);
 	const EmbeddedConfigSchema = S.StructWithRest(S.Struct({
 		jsonReporter: S.optional(JsonReporterSchema),
 		mutator: S.optional(MutatorSchema),
-		since: S.optional(S.String)
+		since: S.optional(S.String),
+		incremental: S.optional(S.Boolean),
+		force: S.optional(S.Boolean)
 	}), [S.Record(S.String, S.Unknown)]);
 	const decoded = S.decodeUnknownOption(EmbeddedConfigSchema)(report.config);
 	const jsonReporter = Option$1.flatMap(decoded, (config) => Option$1.fromUndefinedOr(config.jsonReporter));
@@ -11140,12 +11227,13 @@ const embeddedConfig = (report) => {
 	return {
 		jsonReporterFileName: Option$1.getOrUndefined(Option$1.map(jsonReporter, (reporter) => reporter.fileName)),
 		mutantSetPolicy: Option$1.getOrElse(mutantSetPolicy, () => "default"),
-		scope: Option$1.isSome(since) ? "diff" : "full"
+		scope: Option$1.isSome(since) ? "diff" : "full",
+		incrementalMode: incrementalModeOf(decoded)
 	};
 };
 const buildVerdictEnvelope = dual((args) => args.length === 8, (report, mode, signal, runId, basePath, pathService, phaseDurations, staticVerdict) => {
 	const metrics = Report_exports.metricsFromMutants(Arr.flatMap(Object.values(report.files), (file) => file.mutants));
-	const { jsonReporterFileName, mutantSetPolicy, scope } = embeddedConfig(report);
+	const { jsonReporterFileName, mutantSetPolicy, scope, incrementalMode } = embeddedConfig(report);
 	return VerdictEnvelope.make({
 		schemaVersion: RunEvent_exports.StreamSchemaVersion.literal,
 		runId,
@@ -11165,14 +11253,33 @@ const buildVerdictEnvelope = dual((args) => args.length === 8, (report, mode, si
 		mutants: actionableMutants(report.files),
 		scope,
 		mutantSetPolicy,
+		incrementalMode,
 		phaseDurations: Option$1.getOrNull(phaseDurations),
-		static: staticVerdict
+		static: staticVerdict,
+		budget: budgetOf(report)
 	});
 });
 //#endregion
 //#region src/run-events.service.ts
 var RunEvents = class extends Context.Service()("@systemfsoftware/stryker-js/run-events.service/RunEvents") {};
 var RunIdentity = class extends Context.Service()("@systemfsoftware/stryker-js/run-events.service/RunIdentity") {};
+var WorkerReports = class extends Context.Service()("@systemfsoftware/stryker-js/run-events.service/WorkerReports") {};
+const WorkerReportsLive = Layer.effect(WorkerReports, Effect$1.gen(function* () {
+	const queue = yield* RunEvents;
+	const counters = {
+		testRunner: yield* Ref.make(0),
+		checker: yield* Ref.make(0)
+	};
+	return WorkerReports.of({ report: (role, startupMs) => Effect$1.gen(function* () {
+		const index = yield* Ref.getAndUpdate(counters[role], (current) => current + 1);
+		yield* Queue.offer(queue, RunEvent_exports.WorkerReported.make({
+			schemaVersion: RunEvent_exports.StreamSchemaVersion.literal,
+			role,
+			index,
+			startupMs
+		}));
+	}) });
+}));
 //#endregion
 //#region src/phase-durations.ts
 const elapsedOf = (marks, phase) => Option$1.map(Arr.findFirst(marks, (mark) => mark.phase === phase), (mark) => mark.elapsedMs);
@@ -11229,7 +11336,7 @@ const strykerOutputFilesOf = (options) => [
 ];
 //#endregion
 //#region package.json
-var version = "15.0.1";
+var version = "16.0.0";
 //#endregion
 //#region src/stryker-package.schema.ts
 var StrykerPackage = class extends S.Class("StrykerPackage")({
@@ -11377,6 +11484,8 @@ var MutationReporting = class MutationReporting extends Context.Service()("@syst
 		};
 		return MutationReporting.of({
 			reportCheckFailure: (mutant, result) => reportCheckFailure(mutant, result),
+			reportIgnored: (mutant, result) => reportIgnored(mutant, result),
+			reportNoCoverage: (mutant) => reportNoCoverage(mutant),
 			reportMutantRunResult: (mutant, result) => mapRunResult(mutant, result),
 			reportAll: (input) => reportAll(deps, input),
 			checkpoint: (input, plannedMutants) => checkpoint(deps, input, plannedMutants)
@@ -11399,6 +11508,8 @@ const reportMutant = (mutant, status, outcome = {}) => Effect$1.succeed({
 });
 const reportMutantStatus = (mutant, status, statusReason) => reportMutant(mutant, status, { statusReason: statusReason ?? mutant.statusReason });
 const reportCheckFailure = (mutant, result) => reportMutantStatus(mutant, "CompileError", result.reason);
+const reportIgnored = (mutant, result) => reportMutantStatus(mutant, "Ignored", result.reason);
+const reportNoCoverage = (mutant) => reportMutantStatus(mutant, "NoCoverage");
 const reasonedOutcomeOf = (reason) => Option$1.match(Option$1.fromNullishOr(reason), {
 	onNone: () => ({}),
 	onSome: (present) => ({ statusReason: present })
@@ -11622,6 +11733,11 @@ const mutationTestReport = Effect$1.fn(SpanTaxonomy_exports.Spans.mutationReport
 	const { files, testFiles, identities } = yield* assembleReport(deps, input, results);
 	const dependencies = yield* discoverDependencies(deps);
 	const config = yield* S.encodeEffect(S.fromJsonString(S.Unknown))(input.options).pipe(Effect$1.flatMap(S.decodeEffect(S.fromJsonString(S.Record(S.String, S.Json)))), Effect$1.orDie);
+	const budget = budgetOf$1({
+		results,
+		concurrency: input.concurrency,
+		actualSeconds: ((yield* Clock.currentTimeMillis) - input.runStartedAt) / 1e3
+	});
 	return {
 		report: {
 			files,
@@ -11633,7 +11749,8 @@ const mutationTestReport = Effect$1.fn(SpanTaxonomy_exports.Spans.mutationReport
 			framework: {
 				...STRYKER_FRAMEWORK,
 				dependencies
-			}
+			},
+			budget
 		},
 		identities
 	};
@@ -11674,27 +11791,49 @@ const emitVerdict = Effect$1.fn(SpanTaxonomy_exports.Spans.mutationReportingEmit
 		mutants: envelope.mutants,
 		scope: envelope.scope,
 		mutantSetPolicy: envelope.mutantSetPolicy,
+		incrementalMode: envelope.incrementalMode,
 		phaseDurations: envelope.phaseDurations,
-		static: envelope.static
+		static: envelope.static,
+		budget: envelope.budget
 	}));
 });
 const dryRunCoverageFieldOf = (testCoverage) => Option$1.match(Option$1.fromUndefinedOr(testCoverage.dryRunCoverage), {
 	onNone: () => ({}),
 	onSome: (dryRunCoverage) => ({ dryRunCoverage })
 });
+const testTimesOf = (tests) => Arr.map([...tests], (test) => test.timeSpentMs);
+const executedEntryOf = (result) => Option$1.match(Option$1.fromUndefinedOr(result.cost), {
+	onNone: () => [],
+	onSome: (cost) => [[result.id, costTotalMsOf(cost) ?? 0]]
+});
+const priorEntryOf = (entry) => entry[1].actualMs === null ? [] : [[entry[0], entry[1].actualMs]];
+const priorCostsOf = (report) => Option$1.getOrElse(Option$1.flatMap(Option$1.fromNullishOr(report), (present) => Option$1.fromNullishOr(present.costs)), () => ({}));
+const mutantCostModelOf = (input, results) => ({
+	subjects: Arr.map(results, (result) => ({
+		id: result.id,
+		static: result.static
+	})),
+	staticCoverage: input.testCoverage.staticCoverage,
+	allTestTimesMs: Arr.map([...input.testCoverage.testsById], ([, test]) => test.timeSpentMs),
+	coveringTestTimesMsByMutantId: Object.fromEntries([...input.testCoverage.testsByMutantId].map(([mutantId, tests]) => [mutantId, testTimesOf(tests)])),
+	executedActualMsByMutantId: Object.fromEntries(Arr.flatMap(results, executedEntryOf)),
+	priorActualMsByMutantId: Object.fromEntries(Arr.flatMap(Object.entries(priorCostsOf(input.project.incrementalReport)), priorEntryOf)),
+	fixedOverheadMs: input.timeOverheadMs
+});
+const costsOf = (input, results) => mutantCostsOf(mutantCostModelOf(input, results));
 const writeIncrementalReport = Effect$1.fn(SpanTaxonomy_exports.Spans.mutationReportingWriteIncrementalReport.name)(function* (deps, input, report, identities) {
-	yield* deps.fs.makeDirectory(deps.path.dirname(input.options.incrementalFile), { recursive: true });
 	const runInputsDigest = yield* runInputsDigestOf(deps.fs, deps.path, input.basePath, input.options);
 	const json = yield* S.encodeEffect(S.fromJsonString(S.Unknown, { space: 2 }))({
-		incrementalVersion: "2",
-		verdictSemanticsVersion: 1,
+		incrementalVersion: "3",
+		verdictSemanticsVersion: 3,
 		mutantSetPolicy: input.options.mutator.mutantSetPolicy,
 		runInputsDigest,
 		...report,
 		files: stampFileIdentities(stampClosureDigests(report.files, input.closureDigestsByMutantId), identities),
+		costs: costsOf(input, input.results),
 		...dryRunCoverageFieldOf(input.testCoverage)
 	}).pipe(Effect$1.orDie);
-	yield* deps.fs.writeFileString(input.options.incrementalFile, json);
+	yield* writeFileAtomic(deps, input.options.incrementalFile, json);
 });
 const writeReproducers = (deps, input, report) => {
 	const decision = Result.getOrThrow(buildReproducers(BuildReproducersCommand.make({ report })));
@@ -11731,24 +11870,24 @@ const reportAll = Effect$1.fn(SpanTaxonomy_exports.Spans.mutationReportingReport
 		verdict: finalVerdict
 	};
 });
-const writeAtomic = Effect$1.fn(SpanTaxonomy_exports.Spans.mutationReportingWriteAtomic.name)(function* (deps, file, content) {
-	yield* deps.fs.makeDirectory(deps.path.dirname(file), { recursive: true });
-	const tmp = `${file}.tmp`;
-	yield* deps.fs.writeFileString(tmp, content);
-	yield* deps.fs.rename(tmp, file).pipe(Effect$1.catch(() => deps.fs.copyFile(tmp, file).pipe(Effect$1.andThen(deps.fs.remove(tmp)))));
-});
 const slimIncrementalReport = Effect$1.fn(SpanTaxonomy_exports.Spans.mutationReportingSlimIncrementalReport.name)(function* (deps, input, results) {
 	const { files, testFiles, identities } = yield* assembleReport(deps, input, results);
 	const runInputsDigest = yield* runInputsDigestOf(deps.fs, deps.path, input.basePath, input.options);
 	return {
-		incrementalVersion: "2",
-		verdictSemanticsVersion: 1,
+		incrementalVersion: "3",
+		verdictSemanticsVersion: 3,
 		mutantSetPolicy: input.options.mutator.mutantSetPolicy,
 		runInputsDigest,
 		schemaVersion: Report_exports.WrittenSchemaVersion.literal,
 		thresholds: input.options.thresholds,
 		files: stampFileIdentities(stampClosureDigests(files, input.closureDigestsByMutantId), identities),
+		costs: costsOf(input, results),
 		testFiles,
+		budget: budgetOf$1({
+			results,
+			concurrency: input.concurrency,
+			actualSeconds: ((yield* Clock.currentTimeMillis) - input.runStartedAt) / 1e3
+		}),
 		...dryRunCoverageFieldOf(input.testCoverage)
 	};
 });
@@ -11782,7 +11921,7 @@ const checkpointResultsOf = (input, plannedMutants) => Result.match(checkpointMu
 const checkpointIncremental = Effect$1.fn(SpanTaxonomy_exports.Spans.mutationReportingCheckpoint.name)(function* (deps, input, plannedMutants) {
 	const report = yield* slimIncrementalReport(deps, input, checkpointResultsOf(input, plannedMutants));
 	const json = yield* S.encodeEffect(S.fromJsonString(S.Unknown))(report).pipe(Effect$1.orDie);
-	yield* writeAtomic(deps, input.options.incrementalFile, json);
+	yield* writeFileAtomic(deps, input.options.incrementalFile, json);
 });
 const checkpoint = (deps, input, plannedMutants) => Boolean$1$1.match(input.options.incremental, {
 	onTrue: () => checkpointIncremental(deps, input, plannedMutants),
@@ -12399,8 +12538,8 @@ const renderJsonReport = Workflow.make({
 });
 //#endregion
 //#region src/json-report.cell.ts
-const reportOf$2 = Filter.make((event) => Match$1.value(event).pipe(Match$1.tag("mutationTestReportReady", (ready) => Result.succeed(ready.report)), Match$1.orElse(() => Result.fail("not-ready"))));
-const readJsonReport = (input) => Effect$1.map(Stream.fromAsyncIterable(input.events, failAsJsonReporter).pipe(Stream.filterMap(reportOf$2), Stream.run(Sink.last())), (last) => ({
+const reportOf$1 = Filter.make((event) => Match$1.value(event).pipe(Match$1.tag("mutationTestReportReady", (ready) => Result.succeed(ready.report)), Match$1.orElse(() => Result.fail("not-ready"))));
+const readJsonReport = (input) => Effect$1.map(Stream.fromAsyncIterable(input.events, failAsJsonReporter).pipe(Stream.filterMap(reportOf$1), Stream.run(Sink.last())), (last) => ({
 	_tag: "JsonReportCommand",
 	reported: Option$1.getOrUndefined(last),
 	rendered: true,
@@ -12834,7 +12973,7 @@ const logOf = (command, results) => {
 		}]
 	};
 };
-const decide$20 = (command) => {
+const decide$21 = (command) => {
 	const surfaced = surfacedOf(command);
 	const results = Arr.take(surfaced, command.maxResults);
 	const log = logOf(command, results);
@@ -12850,7 +12989,7 @@ const sarifReport = Workflow.make({
 	command: SarifReportCommand,
 	decision: SarifReportDecision,
 	error: S.Never,
-	decide: (command) => Result.succeed(decide$20(command))
+	decide: (command) => Result.succeed(decide$21(command))
 });
 //#endregion
 //#region src/cap-survivors.workflow.ts
@@ -12967,7 +13106,7 @@ const linesOf = (command) => {
 		onFalse: () => Arr.flatMap(Option$1.toArray(HashMap.get(byId, ref.id)), (entry) => [lineOf(entry)])
 	}));
 };
-const decide$19 = (command) => {
+const decide$20 = (command) => {
 	const lines = linesOf(command);
 	return Boolean$1$1.match(Arr.length(lines) === 0, {
 		onTrue: () => NothingToAnnotate.make({ survivorCount: Arr.length(command.survivors) }),
@@ -12978,7 +13117,7 @@ Workflow.make({
 	command: RenderAnnotationsCommand,
 	decision: RenderAnnotationsDecision,
 	error: S.Never,
-	decide: (command) => Result.succeed(decide$19(command))
+	decide: (command) => Result.succeed(decide$20(command))
 });
 //#endregion
 //#region src/surfacing.ts
@@ -13054,8 +13193,8 @@ const failAsSarif = (cause) => Reporter_exports.ReporterFailed.make({
 	event: "mutationTestReportReady",
 	cause: Option$1.getOrElse(Option$1.map(ErrorText_exports.errorTextOf(cause), (rendered) => rendered.text), () => "")
 });
-const reportOf$1 = Filter.make((event) => Match$1.value(event).pipe(Match$1.tag("mutationTestReportReady", (ready) => Result.succeed(ready.report)), Match$1.orElse(() => Result.fail("not-ready"))));
-const readSarifReport = (events) => Effect$1.map(Stream.fromAsyncIterable(events, failAsSarif).pipe(Stream.filterMap(reportOf$1), Stream.run(Sink.last())), (last) => Option$1.getOrUndefined(last));
+const reportOf = Filter.make((event) => Match$1.value(event).pipe(Match$1.tag("mutationTestReportReady", (ready) => Result.succeed(ready.report)), Match$1.orElse(() => Result.fail("not-ready"))));
+const readSarifReport = (events) => Effect$1.map(Stream.fromAsyncIterable(events, failAsSarif).pipe(Stream.filterMap(reportOf), Stream.run(Sink.last())), (last) => Option$1.getOrUndefined(last));
 const writeSarifReport = (options, report) => Effect$1.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
@@ -13144,7 +13283,7 @@ var RunEnvironment = class extends Context.Service()("@systemfsoftware/stryker-j
 };
 const stageLayerOf = (env, events) => {
 	const eventsLayer = Match$1.value(events).pipe(Match$1.when(void 0, () => Layer.effect(RunEvents, Queue.bounded(RunEvent_exports.RunEvent.QUEUE_BOUND))), Match$1.orElse((queue) => Layer.succeed(RunEvents, queue)));
-	const stageLayer = Layer.mergeAll(Layer.succeed(RunEnvironment, env), eventsLayer, PhaseClock.layer(env.runStartedAt), IdGenerator.layer, ProjectFiles.layer, Layer.effect(Scope.Scope, Effect$1.gen(function* () {
+	const stageLayer = Layer.mergeAll(Layer.succeed(RunEnvironment, env), eventsLayer, WorkerReportsLive.pipe(Layer.provide(eventsLayer)), PhaseClock.layer(env.runStartedAt), IdGenerator.layer, ProjectFiles.layer, Layer.effect(Scope.Scope, Effect$1.gen(function* () {
 		const stageScope = yield* Scope.make();
 		yield* Effect$1.addFinalizer((exit) => Scope.close(stageScope, exit));
 		return stageScope;
@@ -13512,7 +13651,7 @@ var WorkerCrashed = class extends S.TaggedClass()("WorkerCrashed", {
 };
 const ClassifyWorkerExitDecision = S.Union([WorkerOutOfMemory, WorkerCrashed]);
 const OutOfMemoryExitCode = S.Literals([134, 137]);
-const decide$18 = (command) => Boolean$1$1.match(S.is(OutOfMemoryExitCode)(command.exitCode), {
+const decide$19 = (command) => Boolean$1$1.match(S.is(OutOfMemoryExitCode)(command.exitCode), {
 	onTrue: () => Result.succeed(WorkerOutOfMemory.make({
 		pid: command.pid,
 		exitCode: command.exitCode
@@ -13526,7 +13665,7 @@ const classifyWorkerExit = Workflow.make({
 	command: ClassifyWorkerExitCommand,
 	decision: ClassifyWorkerExitDecision,
 	error: S.Never,
-	decide: decide$18
+	decide: decide$19
 });
 //#endregion
 //#region src/git-diff.schema.ts
@@ -13858,7 +13997,9 @@ const IncrementalReportSchema = S.StructWithRest(S.Struct({
 	runInputsDigest: S.String,
 	thresholds: ThresholdsLikeSchema,
 	files: S.Record(S.String, FileResultLikeSchema),
+	costs: MutantCosts,
 	testFiles: S.optional(S.Record(S.String, TestFileLikeSchema)),
+	budget: S.optional(RunEvent_exports.Budget),
 	dryRunCoverage: S.optionalKey(S.Unknown)
 }), [S.Record(S.String, S.Unknown)]);
 //#endregion
@@ -13936,12 +14077,12 @@ const splitOf = (details, checkerCount) => Boolean$1$1.match(checkerCount > 0, {
 		announcement: details.announcement
 	})
 });
-const decide$17 = (command) => Result.succeed(splitOf(detailsOf(command.concurrency, command.availableParallelism), command.checkerCount));
+const decide$18 = (command) => Result.succeed(splitOf(detailsOf(command.concurrency, command.availableParallelism), command.checkerCount));
 const resolveConcurrency = Workflow.make({
 	command: ResolveConcurrency,
 	decision: ConcurrencySplit,
 	error: S.Never,
-	decide: decide$17
+	decide: decide$18
 });
 //#endregion
 //#region src/concurrency.cell.ts
@@ -14173,7 +14314,7 @@ const discardOf = (reason, actual, expected) => IncrementalReportDiscard.make({
 	actual,
 	expected
 });
-const decide$16 = (command) => Option$1.match(Option$1.fromUndefinedOr(command.report), {
+const decide$17 = (command) => Option$1.match(Option$1.fromUndefinedOr(command.report), {
 	onNone: () => discardOf("noPriorRecord", void 0, command.expectedIncrementalVersion),
 	onSome: (report) => Option$1.match(Option$1.firstSomeOf(identityMismatchesOf(command, report).map(mismatchOptionOf)), {
 		onNone: () => IncrementalReportKeep.make({ report }),
@@ -14184,7 +14325,7 @@ const admitIncrementalReport = Workflow.make({
 	command: AdmitIncrementalReportCommand,
 	decision: S.Union([IncrementalReportKeep, IncrementalReportDiscard]),
 	error: S.Never,
-	decide: (command) => Result.succeed(decide$16(command))
+	decide: (command) => Result.succeed(decide$17(command))
 });
 //#endregion
 //#region src/git-diff.workflow.ts
@@ -14539,11 +14680,15 @@ const ALWAYS_IGNORE = Object.freeze([
 	"/stryker.log",
 	".next",
 	".nuxt",
-	".svelte-kit"
+	".svelte-kit",
+	".turbo"
 ]);
 const CRAWL_CONCURRENCY = 256;
 const DISCARD_TEXTS = {
-	noPriorRecord: (command) => `Unable to parse incremental result file at ${command.incrementalFile}; a full mutation testing run will be performed.`,
+	noPriorRecord: (command) => `Unable to parse incremental result file at ${command.incrementalFile}${Option$1.match(Option$1.fromUndefinedOr(command.decodeError), {
+		onNone: () => "",
+		onSome: (error) => `: ${error}`
+	})}; a full mutation testing run will be performed.`,
 	cacheLayoutChanged: (command, discard) => `Incremental result file at ${command.incrementalFile} has cache layout version ${discard.actual ?? ""}, expected ${discard.expected}; a full mutation testing run will be performed.`,
 	semanticsChanged: (command, discard) => `Incremental result file at ${command.incrementalFile} has verdict semantics version ${discard.actual ?? ""}, expected ${discard.expected}; a full mutation testing run will be performed.`,
 	policyChanged: (command, discard) => `Incremental result file at ${command.incrementalFile} has mutant-set policy ${discard.actual ?? ""}, expected ${discard.expected}; a full mutation testing run will be performed.`,
@@ -14601,7 +14746,14 @@ const isEntryIncluded = (ignorePatterns, entry) => {
 };
 const resolveInputFileNames = (ignorePatterns, basePath) => crawlDirectory(ignorePatterns, basePath, basePath).pipe(Stream.runCollect, Effect$1.map((files) => [...files]));
 const parseAndDecodeIncrementalReport = Schema.decodeUnknownResult(Schema.fromJsonString(IncrementalReportSchema));
-const reportOf = (contents) => Option$1.getOrUndefined(Option$1.flatMap(Option$1.fromUndefinedOr(contents), (text) => Result.getSuccess(parseAndDecodeIncrementalReport(text))));
+const decodeFailureText = (failure) => failure.message.replace(/\s+/gu, " ").trim();
+const reportReadOf = (contents) => Option$1.match(Option$1.fromUndefinedOr(contents), {
+	onNone: () => ({}),
+	onSome: (text) => Result.match(parseAndDecodeIncrementalReport(text), {
+		onFailure: (failure) => ({ decodeError: decodeFailureText(failure) }),
+		onSuccess: (report) => ({ report })
+	})
+});
 const incrementalContentsOf = (fs, options) => Boolean$1.match(options.incremental, {
 	onFalse: () => Effect$1.succeedNone,
 	onTrue: () => fs.readFileString(options.incrementalFile).pipe(Effect$1.asSome, Effect$1.tapError((error) => Match$1.value(error.reason).pipe(Match$1.tag("NotFound", () => Effect$1.logInfo(`No incremental result file found at ${options.incrementalFile}, a full mutation testing run will be performed.`)), Match$1.orElse(() => Effect$1.void))), Effect$1.catchTag("PlatformError", (error) => Match$1.value(error.reason).pipe(Match$1.tag("NotFound", () => Effect$1.succeedNone), Match$1.orElse(() => Effect$1.fail(error)))))
@@ -14706,11 +14858,12 @@ const readProject = Effect$1.fn(SpanTaxonomy_exports.Spans.projectReadFromDisk.n
 	yield* Effect$1.forEach(testFilePatterns, (pattern) => warnUnmatchedTestPattern(inputFileNames, input.basePath, pattern), { discard: true });
 	const runInputsDigest = yield* runInputsDigestOf(fs, pathService, input.basePath, options);
 	const contents = Option$1.getOrUndefined(yield* incrementalContentsOf(fs, options));
+	const reportRead = reportReadOf(contents);
 	return {
 		_tag: "AdmitIncrementalReportCommand",
-		report: reportOf(contents),
-		expectedIncrementalVersion: "2",
-		verdictSemanticsVersion: 1,
+		report: reportRead.report,
+		expectedIncrementalVersion: "3",
+		verdictSemanticsVersion: 3,
 		mutantSetPolicy: options.mutator.mutantSetPolicy,
 		runInputsDigest,
 		options,
@@ -14719,6 +14872,7 @@ const readProject = Effect$1.fn(SpanTaxonomy_exports.Spans.projectReadFromDisk.n
 		incremental: options.incremental,
 		incrementalFile: options.incrementalFile,
 		contents,
+		decodeError: reportRead.decodeError,
 		fileDescriptions: decision.fileDescriptions,
 		testFiles: [...decision.testFiles]
 	};
@@ -14771,6 +14925,58 @@ const readProjectCell = Sandwich.named(SpanTaxonomy_exports.Spans.projectRead.na
 	}))
 });
 //#endregion
+//#region src/refuse-local-mutation.workflow.ts
+const LocalMutationDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js/LocalMutationDecision");
+var RefuseLocalMutationCommand = class extends S.TaggedClass()("RefuseLocalMutationCommand", {
+	dryRunOnly: S.Boolean,
+	githubActions: S.UndefinedOr(S.String),
+	allowLocalMutation: S.UndefinedOr(S.String)
+}) {
+	static [Workflow.InstrumentationBrand] = {};
+};
+var LocalMutationAllowed = class extends S.TaggedClass()("LocalMutationAllowed", {}) {
+	[LocalMutationDecisionTypeId] = LocalMutationDecisionTypeId;
+};
+var LocalMutationRefused = class extends S.TaggedError()("LocalMutationRefused", {
+	rule: RunEvent_exports.RefusalRule,
+	message: S.String
+}) {};
+const decide$16 = (command) => Match$1.value({
+	dryRunOnly: command.dryRunOnly,
+	githubActions: command.githubActions,
+	allowLocalMutation: command.allowLocalMutation
+}).pipe(Match$1.when({ dryRunOnly: true }, () => Result.succeed(LocalMutationAllowed.make({}))), Match$1.when({ githubActions: "true" }, () => Result.succeed(LocalMutationAllowed.make({}))), Match$1.when({ allowLocalMutation: "1" }, () => Result.succeed(LocalMutationAllowed.make({}))), Match$1.orElse(() => Result.fail(LocalMutationRefused.make({
+	rule: "mutation-runs-on-main-ci",
+	message: "mutation runs only on main CI"
+}))));
+const refuseLocalMutation = Workflow.make({
+	command: RefuseLocalMutationCommand,
+	decision: LocalMutationAllowed,
+	error: LocalMutationRefused,
+	decide: decide$16
+});
+//#endregion
+//#region src/refuse-local-mutation.cell.ts
+const envOf = (key) => Config.option(Config.String(key)).pipe(Effect$1.map(Option$1.getOrUndefined), Effect$1.orElseSucceed(() => void 0));
+const guardOf = (input) => Effect$1.gen(function* () {
+	const githubActions = yield* envOf("GITHUB_ACTIONS");
+	const allowLocalMutation = yield* envOf("ALLOW_LOCAL_MUTATION");
+	const command = RefuseLocalMutationCommand.make({
+		dryRunOnly: input.options.dryRunOnly,
+		githubActions,
+		allowLocalMutation
+	});
+	return yield* Result.match(refuseLocalMutation(command), {
+		onFailure: (refused) => Effect$1.fail(StageError.make({
+			stage: "prepare",
+			reason: refused.message,
+			cause: refused
+		})),
+		onSuccess: () => Effect$1.succeed(input)
+	});
+});
+const refuseLocalMutationCell = (input) => Cell.fromEffect(guardOf(input));
+//#endregion
 //#region src/dry-run-coverage.schema.ts
 const DryRunCoverageSchema = S.Struct({
 	tests: S.Array(TestRunner_exports.TestResultSchema),
@@ -15954,6 +16160,35 @@ const buildTestRunner = dual(2, (context, childProcessRunner) => Option$1.match(
 	onNone: () => decorateChildRunner(context, childProcessRunner)
 }));
 //#endregion
+//#region src/run/dry-run-coverage.ts
+const testsByIdOf = (result) => MutableHashMap.fromIterable(result.tests.map((test) => [test.id, test]));
+const coveredMutantIdsOf = (coverage) => Object.entries(coverage).filter(([, count]) => count > 0).map(([mutantId]) => mutantId);
+const testsByMutantIdOf = (mutantCoverage, testsById) => Object.entries(mutantCoverage.perTest).reduce((testsByMutantId, [testId, coverage]) => Option$1.match(MutableHashMap.get(testsById, testId), {
+	onNone: () => testsByMutantId,
+	onSome: (test) => coveredMutantIdsOf(coverage).reduce((acc, mutantId) => MutableHashMap.set(acc, mutantId, MutableHashSet.add(Option$1.getOrElse(MutableHashMap.get(acc, mutantId), () => MutableHashSet.empty()), test)), testsByMutantId)
+}), MutableHashMap.empty());
+const hitsByMutantIdOf = (mutantCoverage) => [mutantCoverage.static, ...Object.values(mutantCoverage.perTest)].reduce((hitsByMutantId, coverage) => Object.entries(coverage).reduce((acc, [mutantId, count]) => MutableHashMap.set(acc, mutantId, Option$1.getOrElse(MutableHashMap.get(acc, mutantId), () => 0) + count), hitsByMutantId), MutableHashMap.empty());
+const testCoverageOf = ({ result, dryRunCoverage }) => {
+	const testsById = testsByIdOf(result);
+	const mutantCoverage = Option$1.fromNullishOr(result.mutantCoverage);
+	return {
+		testsByMutantId: Option$1.match(mutantCoverage, {
+			onNone: () => MutableHashMap.empty(),
+			onSome: (coverage) => testsByMutantIdOf(coverage, testsById)
+		}),
+		testsById,
+		staticCoverage: Option$1.match(mutantCoverage, {
+			onNone: () => void 0,
+			onSome: (coverage) => coverage.static
+		}),
+		hitsByMutantId: Option$1.match(mutantCoverage, {
+			onNone: () => MutableHashMap.empty(),
+			onSome: (coverage) => hitsByMutantIdOf(coverage)
+		}),
+		dryRunCoverage
+	};
+};
+//#endregion
 //#region src/run/incremental-reuse.ts
 const absoluteSourceOf = (path, basePath, file) => path.isAbsolute(file) ? file : path.join(basePath, file);
 const matchedSourcesOf = Effect$1.fnUntraced(function* (input) {
@@ -16283,33 +16518,6 @@ const withOriginalFileName = (test, prev) => Match$1.value(test.fileName).pipe(M
 	fileName: originalFileFor(prev.sandbox, fileName)
 })), Match$1.orElse(() => test));
 const withOriginalFileNames = (tests, prev) => tests.map((test) => withOriginalFileName(test, prev));
-const testsByIdOf = (result) => MutableHashMap.fromIterable(result.tests.map((test) => [test.id, test]));
-const coveredMutantIdsOf = (coverage) => Object.entries(coverage).filter(([, count]) => count > 0).map(([mutantId]) => mutantId);
-const testsByMutantIdOf = (mutantCoverage, testsById) => Object.entries(mutantCoverage.perTest).reduce((testsByMutantId, [testId, coverage]) => Option$1.match(MutableHashMap.get(testsById, testId), {
-	onNone: () => testsByMutantId,
-	onSome: (test) => coveredMutantIdsOf(coverage).reduce((acc, mutantId) => MutableHashMap.set(acc, mutantId, MutableHashSet.add(Option$1.getOrElse(MutableHashMap.get(acc, mutantId), () => MutableHashSet.empty()), test)), testsByMutantId)
-}), MutableHashMap.empty());
-const hitsByMutantIdOf = (mutantCoverage) => [mutantCoverage.static, ...Object.values(mutantCoverage.perTest)].reduce((hitsByMutantId, coverage) => Object.entries(coverage).reduce((acc, [mutantId, count]) => MutableHashMap.set(acc, mutantId, Option$1.getOrElse(MutableHashMap.get(acc, mutantId), () => 0) + count), hitsByMutantId), MutableHashMap.empty());
-const testCoverageFrom = (result, dryRunCoverage) => {
-	const testsById = testsByIdOf(result);
-	const mutantCoverage = Option$1.fromNullishOr(result.mutantCoverage);
-	return {
-		testsByMutantId: Option$1.match(mutantCoverage, {
-			onNone: () => MutableHashMap.empty(),
-			onSome: (coverage) => testsByMutantIdOf(coverage, testsById)
-		}),
-		testsById,
-		staticCoverage: Option$1.match(mutantCoverage, {
-			onNone: () => void 0,
-			onSome: (coverage) => coverage.static
-		}),
-		hitsByMutantId: Option$1.match(mutantCoverage, {
-			onNone: () => MutableHashMap.empty(),
-			onSome: (coverage) => hitsByMutantIdOf(coverage)
-		}),
-		dryRunCoverage
-	};
-};
 const announceDryRunOutcome = (tests, prev, gross, overheadMillis) => Match$1.value(tests.length).pipe(Match$1.when(0, () => Effect$1.logInfo("No tests were found")), Match$1.orElse(() => Effect$1.logInfo(`Initial test run succeeded. Ran ${tests.length} tests in ${Duration.format(gross)} (net ${totalTestTime(tests)} ms, overhead ${overheadMillis} ms).`).pipe(Effect$1.andThen(Effect$1.when(Effect$1.logInfo("Note: running the dry-run only. No mutations will be tested."), Effect$1.succeed(prev.options.dryRunOnly))))));
 const reportDryRunCompleted = (raw, tests, overheadMillis) => offerReporterEvent(raw.prev.reporterStage, Reporter_exports.DryRunCompleted.make({
 	timing: {
@@ -16333,7 +16541,10 @@ const freshCoverageOf = (raw, dryRunResult, overheadMillis) => ({
 const dryRunDoneOf = (raw, dryRunResult, coverage) => ({
 	...raw.prev,
 	dryRunResult,
-	testCoverage: testCoverageFrom(dryRunResult, coverage),
+	testCoverage: testCoverageOf({
+		result: dryRunResult,
+		dryRunCoverage: coverage
+	}),
 	timeOverhead: Duration.millis(coverage.timeOverheadMs)
 });
 const completeFreshDryRun = Effect$1.fnUntraced(function* (raw, dryRunResult) {
@@ -16363,6 +16574,7 @@ const completeDryRunPassed = (raw) => Match$1.value(raw.rawResult).pipe(Match$1.
 }))), Match$1.exhaustive);
 const runFreshDryRun = Effect$1.fnUntraced(function* (command, idGenerator, currentTestClosureDigest, runInputsDigest) {
 	const env = yield* RunEnvironment;
+	const reports = yield* WorkerReports;
 	const { files, testFiles } = yield* resolveDryRunFiles(command);
 	const dryRunTimeout = command.options.dryRunTimeoutMinutes * 60 * 1e3;
 	const options = dryRunOptionsOf(command, files, testFiles, dryRunTimeout);
@@ -16378,6 +16590,7 @@ const runFreshDryRun = Effect$1.fnUntraced(function* (command, idGenerator, curr
 				idGenerator
 			})));
 		});
+		const startedAt = yield* Clock.currentTimeMillis;
 		const runner = yield* buildTestRunner({
 			options: command.options,
 			fileDescriptions: command.project.fileDescriptions,
@@ -16386,6 +16599,7 @@ const runFreshDryRun = Effect$1.fnUntraced(function* (command, idGenerator, curr
 			retire: Effect$1.void,
 			testFiles: testFiles ?? []
 		}, childRunnerEffect);
+		yield* reports.report("testRunner", (yield* Clock.currentTimeMillis) - startedAt);
 		const capabilities = yield* runner.capabilities.pipe(Effect$1.mapError((cause) => StageError.make({
 			stage: "dryRun",
 			reason: "Failed to get test runner capabilities",
@@ -17337,6 +17551,10 @@ const FailedCheckResultSchema = S.Struct({
 	status: S.Literal("compileError"),
 	reason: S.String
 });
+const IgnoredCheckResultSchema = S.Struct({
+	status: S.Literal("ignored"),
+	reason: S.String
+});
 var CheckedPlanPassed = class extends S.TaggedClass()("CheckedPlanPassed", {
 	mutantId: Mutant_exports.MutantId,
 	entryIndex: S.Int
@@ -17351,27 +17569,48 @@ var CheckedPlanFailed = class extends S.TaggedClass()("CheckedPlanFailed", {
 }) {
 	[CheckedPlanTypeId] = CheckedPlanTypeId;
 };
+var CheckedPlanIgnored = class extends S.TaggedClass()("CheckedPlanIgnored", {
+	mutantId: Mutant_exports.MutantId,
+	entryIndex: S.Int,
+	reason: S.String,
+	result: IgnoredCheckResultSchema
+}) {
+	[CheckedPlanTypeId] = CheckedPlanTypeId;
+};
 var PartitionCheckedPlansCommand = class extends S.TaggedClass()("PartitionCheckedPlansCommand", { checked: S.Array(S.Tuple([Mutant_exports.MutantId, Checker_exports.CheckResultSchema])) }) {
 	static [Workflow.InstrumentationBrand] = {};
 };
-const isFailed = (result) => result.status !== "passed";
+const isFailed = (result) => result.status === "compileError";
+const isIgnored = (result) => result.status === "ignored";
 const failedReasonOf = (failed) => failed.reason;
-const decideCheckedPlan = (mutantId, result, entryIndex) => Option$1.match(Option$1.liftPredicate(result, isFailed), {
-	onNone: () => CheckedPlanPassed.make({
-		mutantId,
-		entryIndex
-	}),
-	onSome: (failed) => CheckedPlanFailed.make({
+const decideCheckedPlan = (mutantId, result, entryIndex) => Option$1.match(Option$1.liftPredicate(result, isIgnored), {
+	onSome: (ignored) => CheckedPlanIgnored.make({
 		mutantId,
 		entryIndex,
-		reason: failedReasonOf(failed),
-		result: failed
+		reason: ignored.reason,
+		result: ignored
+	}),
+	onNone: () => Option$1.match(Option$1.liftPredicate(result, isFailed), {
+		onNone: () => CheckedPlanPassed.make({
+			mutantId,
+			entryIndex
+		}),
+		onSome: (failed) => CheckedPlanFailed.make({
+			mutantId,
+			entryIndex,
+			reason: failedReasonOf(failed),
+			result: failed
+		})
 	})
 });
 const decide$8 = (command) => Result.succeed(command.checked.map(([mutantId, result], entryIndex) => decideCheckedPlan(mutantId, result, entryIndex)));
 const partitionCheckedPlans = Workflow.make({
 	command: PartitionCheckedPlansCommand,
-	decision: S.Array(S.Union([CheckedPlanPassed, CheckedPlanFailed])),
+	decision: S.Array(S.Union([
+		CheckedPlanPassed,
+		CheckedPlanFailed,
+		CheckedPlanIgnored
+	])),
 	error: S.Never,
 	decide: decide$8
 });
@@ -17408,6 +17647,7 @@ const onCheckerSlot = (pool, checkerIndex, run) => Pool.use(pool, (slot) => Opti
 }));
 const noPassedPlans = [];
 const noFailedChecks = [];
+const noIgnoredChecks = [];
 const splitCheckedPlans = Effect$1.fn(SpanTaxonomy_exports.Spans.checkerPoolSplitChecked.name)(function* (checked) {
 	const decisions = yield* Effect$1.fromResult(partitionCheckedPlans(PartitionCheckedPlansCommand.make({ checked: checked.map(([plan, result]) => [plan.mutant.id, result]) })));
 	return {
@@ -17418,6 +17658,10 @@ const splitCheckedPlans = Effect$1.fn(SpanTaxonomy_exports.Spans.checkerPoolSpli
 		failedChecks: decisions.flatMap((decision) => Option$1.match(Option$1.liftPredicate(decision, S.is(CheckedPlanFailed)), {
 			onNone: () => [],
 			onSome: (failed) => Option$1.toArray(Option$1.map(Arr.get(checked, failed.entryIndex), ([plan]) => [plan, failed.result]))
+		})),
+		ignoredChecks: decisions.flatMap((decision) => Option$1.match(Option$1.liftPredicate(decision, S.is(CheckedPlanIgnored)), {
+			onNone: () => [],
+			onSome: (ignored) => Option$1.toArray(Option$1.map(Arr.get(checked, ignored.entryIndex), ([plan]) => [plan, ignored.result]))
 		}))
 	};
 });
@@ -17426,23 +17670,34 @@ const failedElement = (failedChecks) => Option$1.match(Arr.head(failedChecks), {
 	onNone: () => Stream.empty,
 	onSome: () => Stream.succeed({
 		passedPlans: noPassedPlans,
-		failedChecks
+		failedChecks,
+		ignoredChecks: noIgnoredChecks
+	})
+});
+const ignoredElement = (ignoredChecks) => Option$1.match(Arr.head(ignoredChecks), {
+	onNone: () => Stream.empty,
+	onSome: () => Stream.succeed({
+		passedPlans: noPassedPlans,
+		failedChecks: noFailedChecks,
+		ignoredChecks
 	})
 });
 const checkedGroupsFor = (pool, checkerNames, checkerIndex, plans) => Option$1.match(Arr.get(checkerNames, checkerIndex), {
 	onNone: () => Stream.succeed({
 		passedPlans: plans,
-		failedChecks: noFailedChecks
+		failedChecks: noFailedChecks,
+		ignoredChecks: noIgnoredChecks
 	}),
 	onSome: (checkerName) => Stream.unwrap(onCheckerSlot(pool, checkerIndex, (checker) => groupPlans(checker, checkerName, plans)).pipe(Effect$1.map((groups) => Stream.fromIterable(groups).pipe(Stream.mapEffect((group) => onCheckerSlot(pool, checkerIndex, (checker) => checkPlans$1(checker, checkerName, group)).pipe(Effect$1.flatMap((checked) => splitCheckedPlans(checked))), {
 		concurrency: "unbounded",
 		unordered: true
-	}), Stream.flatMap((split) => Stream.concat(failedElement(split.failedChecks), checkedGroupsFor(pool, checkerNames, checkerIndex + 1, split.passedPlans)))))))
+	}), Stream.flatMap((split) => Stream.concat(ignoredElement(split.ignoredChecks), Stream.concat(failedElement(split.failedChecks), checkedGroupsFor(pool, checkerNames, checkerIndex + 1, split.passedPlans))))))))
 });
 const checkPlansStream = dual(2, (checkerPool, plans) => Option$1.fromNullishOr(checkerPool).pipe(Option$1.match({
 	onNone: () => Stream.succeed({
 		passedPlans: plans,
-		failedChecks: noFailedChecks
+		failedChecks: noFailedChecks,
+		ignoredChecks: noIgnoredChecks
 	}),
 	onSome: (handle) => checkerNamesOf(CheckerPoolHandle.slot(handle)).pipe(Effect$1.map((checkerNames) => checkedGroupsFor(CheckerPoolHandle.slot(handle), checkerNames, 0, plans)), Stream.unwrap)
 }), Stream.withSpan(SpanTaxonomy_exports.Spans.checkerPoolCheckPlans.name)));
@@ -17450,16 +17705,23 @@ Effect$1.fnUntraced(function* (checkerPool, plans) {
 	const checkedGroups = yield* Stream.runCollect(checkPlansStream(checkerPool, plans));
 	const passedPlans = [];
 	const failedChecks = [];
+	const ignoredChecks = [];
 	for (const group of checkedGroups) {
 		passedPlans.push(...group.passedPlans);
 		failedChecks.push(...group.failedChecks);
+		ignoredChecks.push(...group.ignoredChecks);
 	}
 	return {
 		passedPlans,
-		failedChecks
+		failedChecks,
+		ignoredChecks
 	};
 });
-const runCheckedPlans = dual(2, (self, execution) => self.pipe(Stream.flatMap(({ passedPlans, failedChecks }) => Stream.fromIterable([...failedChecks.map(([plan, result]) => () => execution.settleFailure(plan, result)), ...passedPlans.map((plan) => () => execution.runPlan(plan))])), Stream.mapEffect((work) => work(), {
+const runCheckedPlans = dual(2, (self, execution) => self.pipe(Stream.flatMap(({ passedPlans, failedChecks, ignoredChecks }) => Stream.fromIterable([
+	...failedChecks.map(([plan, result]) => () => execution.settleFailure(plan, result)),
+	...ignoredChecks.map(([plan, result]) => () => execution.settleIgnored(plan, result)),
+	...passedPlans.map((plan) => () => execution.runPlan(plan))
+])), Stream.mapEffect((work) => work(), {
 	concurrency: Math.max(1, execution.concurrency),
 	unordered: true
 })));
@@ -17514,11 +17776,13 @@ const checkerWorkerSpawnOf = (loaded, configured) => Effect$1.mapError(Effect$1.
 	cause: PluginNotFoundError.make({ descriptor: missing.descriptor })
 }));
 const acquire$1 = Effect$1.fnUntraced(function* (spec) {
+	const reports = yield* WorkerReports;
 	return yield* Boolean$1$1.match(spec.options.checkers.length === 0, {
 		onTrue: () => Effect$1.as(Effect$1.void, void 0),
 		onFalse: () => Pool.make({
 			acquire: Effect$1.forEach(spec.options.checkers, (checker) => Effect$1.gen(function* () {
 				const resolved = yield* checkerWorkerSpawnOf(spec.loadedPlugins, ConfiguredPluginModulePath.make({ modulePath: checker.plugin }));
+				const startedAt = yield* Clock.currentTimeMillis;
 				const service = yield* scoped$2({
 					options: {
 						...spec.options,
@@ -17530,6 +17794,7 @@ const acquire$1 = Effect$1.fnUntraced(function* (spec) {
 					times: CHECKER_ACQUIRE_RETRIES,
 					while: isCheckerCrash
 				}));
+				yield* reports.report("checker", (yield* Clock.currentTimeMillis) - startedAt);
 				return {
 					checkerName: resolved.name,
 					checker: service
@@ -17887,7 +18152,7 @@ const readIncrementalReuseCommand = Effect$1.fn(SpanTaxonomy_exports.Spans.incre
 		previousRecords: [...previousRecords],
 		closureDigestsByMutantId: closures.digests,
 		closureAnalysisFailed: closures.failed,
-		verdictSemanticsVersion: 1,
+		verdictSemanticsVersion: 3,
 		mutantSetPolicy: input.options.mutator.mutantSetPolicy,
 		runInputsDigest,
 		force: input.force,
@@ -18070,6 +18335,7 @@ const toReportedMutant = (mutant) => Object.assign(mutant, {
 	coveredBy: mutant.coveredBy,
 	static: mutant.static
 });
+const isNoCoveragePlan = (plan) => plan.runOptions.testFilter !== void 0 && plan.runOptions.testFilter.length === 0;
 const inPlannedOrder = ({ planned, results }) => {
 	const rankById = Object.fromEntries(planned.map((mutant, index) => [mutant.id, index]));
 	return Arr.sortWith(results, (result) => rankById[result.id] ?? planned.length, Order.Number);
@@ -18107,11 +18373,14 @@ const reportingInputOf = (input) => ({
 	options: input.prev.options,
 	project: input.prev.project,
 	testCoverage: input.prev.testCoverage,
+	timeOverheadMs: Duration.toMillis(input.prev.timeOverhead),
 	runId: input.env.runId,
 	resolvedMode: input.env.resolvedMode,
 	basePath: input.env.basePath,
 	reporterStage: input.prev.reporterStage,
-	formatRegistry: input.prev.formatRegistry
+	formatRegistry: input.prev.formatRegistry,
+	concurrency: input.prev.concurrency.testRunners + input.prev.concurrency.checkers,
+	runStartedAt: input.env.runStartedAt
 });
 const preparedStreamableOf = Effect$1.fnUntraced(function* (context, result) {
 	return yield* Option$1.match(Option$1.filter(Option$1.some(result.status), isMutantStatus), {
@@ -18365,10 +18634,11 @@ const coveredByField = (coveredBy) => Option$1.match(Option$1.fromUndefinedOr(co
 	onNone: () => ({}),
 	onSome: (present) => ({ coveredBy: [...present] })
 });
-const testFilterField = (testFilter) => Option$1.match(Option$1.filter(Option$1.fromUndefinedOr(testFilter), (filter) => filter.length > 0), {
+const testFilterField = (testFilter) => Option$1.match(Option$1.fromUndefinedOr(testFilter), {
 	onNone: () => ({}),
 	onSome: (present) => ({ testFilter: [...present] })
 });
+const nonEmptyTestFilterOf = (tests) => Option$1.getOrUndefined(Option$1.filter(Option$1.fromUndefinedOr(tests), (present) => present.length > 0));
 const staticCoverageCountOf = (staticCoverage, mutantId) => Option$1.getOrElse(Option$1.flatMap(Option$1.fromNullishOr(staticCoverage), (countsByMutantId) => Record$1.get(countsByMutantId, mutantId)), () => 0);
 const hasCoverageForPlan = (staticCoverage) => Option$1.isSome(Option$1.fromUndefinedOr(staticCoverage));
 const mutantIsStatic = (command, mutantId) => staticCoverageCountOf(command.staticCoverage, mutantId) > 0;
@@ -18454,10 +18724,13 @@ const orderedTestsOf = (command, mutantId, tests) => {
 		onSome: (present) => [present, ...rest]
 	});
 };
-const runWithCoveredTests = (mutant, command, isStatic, tests, coveredBy) => toRunPlan(mutant, command, calculateTotalTimeForIds(tests, command.testTimeById), orderedTestsOf(command, mutant.id, tests), isStatic, coveredBy);
+const runWithCoveredTests = (mutant, command, isStatic, tests, coveredBy) => toRunPlan(mutant, command, calculateTotalTimeForIds(tests, command.testTimeById), nonEmptyTestFilterOf(orderedTestsOf(command, mutant.id, tests)), isStatic, coveredBy);
+const NO_COVERAGE_NET_TIME_MS = 0;
+const NO_COVERAGE_TEST_FILTER = [];
+const toNoCoverageRunPlan = (mutant, command, isStatic, coveredBy) => toRunPlan(mutant, command, NO_COVERAGE_NET_TIME_MS, NO_COVERAGE_TEST_FILTER, isStatic, coveredBy);
 const planForUncoveredStatic = (mutant, command, isStatic, coveredBy) => Boolean$1$1.match(command.options.ignoreStatic, {
 	onTrue: () => Result.succeed(toEarlyResultPlan(mutant, isStatic, "Ignored", IGNORED_STATIC_MUTANT_REASON, coveredBy)),
-	onFalse: () => toRunPlan(mutant, command, command.timeSpentAllTests, command.globalTestFilter, isStatic, coveredBy)
+	onFalse: () => toRunPlan(mutant, command, command.timeSpentAllTests, nonEmptyTestFilterOf(command.globalTestFilter), isStatic, coveredBy)
 });
 const planForStaticallyCovered = (mutant, command, isStatic) => {
 	const tests = Option$1.getOrElse(Record$1.get(command.testsByMutantId, mutant.id), () => []);
@@ -18486,10 +18759,10 @@ const decidePlanForMutant = (mutant, command) => {
 	return Option$1.match(Option$1.fromUndefinedOr(mutant.status), {
 		onSome: (status) => Result.succeed(toEarlyResultPlan(mutant, isStatic, status, mutant.statusReason, coveredByOfMutant(mutant))),
 		onNone: () => Boolean$1$1.match(isPerTestUncoveredNonStatic(command, mutant, isStatic), {
-			onTrue: () => Result.succeed(toEarlyResultPlan(mutant, isStatic, "NoCoverage", void 0, coveringTestIdsOf(command, mutant.id))),
+			onTrue: () => toNoCoverageRunPlan(mutant, command, isStatic, coveringTestIdsOf(command, mutant.id)),
 			onFalse: () => Boolean$1$1.match(hasCoverageForPlan(command.staticCoverage), {
 				onTrue: () => planForStaticallyCovered(mutant, command, isStatic),
-				onFalse: () => toRunPlan(mutant, command, command.timeSpentAllTests, command.globalTestFilter, void 0, void 0)
+				onFalse: () => toRunPlan(mutant, command, command.timeSpentAllTests, nonEmptyTestFilterOf(command.globalTestFilter), void 0, void 0)
 			})
 		})
 	});
@@ -18781,7 +19054,10 @@ const planMutationTest = Effect$1.fn(SpanTaxonomy_exports.Spans.mutationTestPlan
 		}))
 	})).pipe(Effect$1.ignoreCause);
 	const progressQueue = yield* RunEvents;
-	yield* Queue.offer(progressQueue, RunEvent_exports.PlanKnown.make({ total: plansForReporter.length + earlyResults.length }));
+	yield* Queue.offer(progressQueue, RunEvent_exports.PlanKnown.make({
+		total: plansForReporter.length + earlyResults.length,
+		shardPlan: null
+	}));
 	return {
 		runPlans: sortedPlans,
 		earlyResults,
@@ -18804,8 +19080,10 @@ const testRunnerWorkerSpawnOf = (loaded, configured) => Effect$1.mapError(Effect
 	cause: PluginNotFoundError.make({ descriptor: missing.descriptor })
 }));
 const acquire = Effect$1.fnUntraced(function* (spec) {
-	return yield* Pool.makeWithTTL({
-		acquire: buildTestRunner({
+	const reports = yield* WorkerReports;
+	const acquireOne = Effect$1.gen(function* () {
+		const startedAt = yield* Clock.currentTimeMillis;
+		const runner = yield* buildTestRunner({
 			options: spec.options,
 			fileDescriptions: spec.fileDescriptions,
 			sandboxWorkingDirectory: spec.sandboxWorkingDirectory,
@@ -18818,7 +19096,12 @@ const acquire = Effect$1.fnUntraced(function* (spec) {
 			sandboxWorkingDirectory: spec.sandboxWorkingDirectory,
 			workerEntrypoint: resolved.entrypoint,
 			idGenerator: spec.idGenerator
-		}))))),
+		})))));
+		yield* reports.report("testRunner", (yield* Clock.currentTimeMillis) - startedAt);
+		return runner;
+	});
+	return yield* Pool.makeWithTTL({
+		acquire: acquireOne,
 		min: spec.min,
 		max: spec.max,
 		timeToLive: IDLE_TIME_TO_LIVE
@@ -18831,6 +19114,9 @@ const TestRunnerPools = Blueprint.make()(TypeId).steps({
 const scoped = (spec) => TestRunnerPools.of(spec).scoped;
 //#endregion
 //#region src/run/mutation-test.cell.ts
+const TCE_EQUIVALENT_TO_ORIGINAL_REASON = "equivalent-to-original: tce";
+const TCE_DUPLICATE_AT_SITE_REASON = "duplicate-at-site: tce";
+const countIgnoredByReason = (results, reason) => results.filter((result) => result.status === "Ignored" && result.statusReason === reason).length;
 const writeMutationTestNoTests = Effect$1.fn(SpanTaxonomy_exports.Spans.mutationTestNoTests.name)(function* () {
 	const env = yield* RunEnvironment;
 	const now = yield* Clock.currentTimeMillis;
@@ -18934,22 +19220,26 @@ const proceedPipeline = Effect$1.fnUntraced(function* (raw) {
 	});
 	const runResults = yield* Effect$1.scoped(Effect$1.gen(function* () {
 		const checkpoint = yield* makeCheckpointWriter(context, settledResults);
+		const settleReported = (reported) => Effect$1.gen(function* () {
+			yield* announceSettledMutant(context, reported);
+			yield* checkpoint.record(reported);
+			return reported;
+		});
 		return yield* withPhaseSpan(SpanTaxonomy_exports.Spans.mutationTestBatch, {
 			total: plan.plannedTotal,
 			testRunners: prev.concurrency.testRunners
 		}, () => runCheckedPlans(checkedPlans, {
-			settleFailure: (mutantPlan, result) => Effect$1.gen(function* () {
-				const reported = yield* reporting.reportCheckFailure(toReportedMutant(mutantPlan.mutant), result);
-				yield* announceSettledMutant(context, reported);
-				yield* checkpoint.record(reported);
-				return reported;
+			settleFailure: (mutantPlan, result) => reporting.reportCheckFailure(toReportedMutant(mutantPlan.mutant), result).pipe(Effect$1.flatMap(settleReported)),
+			settleIgnored: (mutantPlan, result) => reporting.reportIgnored(toReportedMutant(mutantPlan.mutant), result).pipe(Effect$1.flatMap(settleReported)),
+			runPlan: (runPlan) => Option$1.match(Option$1.liftPredicate(runPlan, isNoCoveragePlan), {
+				onNone: () => Effect$1.scoped(mutantRunCell.run({
+					context,
+					testRunnerPool,
+					checkpoint,
+					plan: runPlan
+				})),
+				onSome: (noCoverageRunPlan) => reporting.reportNoCoverage(toReportedMutant(noCoverageRunPlan.mutant)).pipe(Effect$1.flatMap(settleReported))
 			}),
-			runPlan: (runPlan) => Effect$1.scoped(mutantRunCell.run({
-				context,
-				testRunnerPool,
-				checkpoint,
-				plan: runPlan
-			})),
 			concurrency: testRunnerCapacity
 		}).pipe(Stream.runFold(() => [], (acc, result) => {
 			acc.push(result);
@@ -18965,6 +19255,10 @@ const proceedPipeline = Effect$1.fnUntraced(function* (raw) {
 		requested: requestedIdsOf(prev.options),
 		results: allResults
 	}), (detail) => Queue.offer(progressQueue, detail), { discard: true });
+	yield* Queue.offer(progressQueue, RunEvent_exports.TceReported.make({
+		equivalentToOriginal: countIgnoredByReason(allResults, TCE_EQUIVALENT_TO_ORIGINAL_REASON),
+		duplicateAtSite: countIgnoredByReason(allResults, TCE_DUPLICATE_AT_SITE_REASON)
+	}));
 	const outcomeResult = yield* reporting.reportAll({
 		...reportingInputOf({
 			prev,
@@ -20056,11 +20350,11 @@ const prepareCell = Sandwich.named(SpanTaxonomy_exports.Spans.prepare.name)(read
 //#endregion
 //#region src/run/run-stages.cell.ts
 const configReadReasonOf = (cause) => Match$1.value(cause).pipe(Match$1.tag("ConfigError", (refused) => refused.message), Match$1.orElse(() => "Failed to read config"));
-const mutationTestCell = Cell.andThen(Cell.andThen(Cell.andThen(Cell.mapError(loadConfigCell, (cause) => StageError.make({
+const mutationTestCell = Cell.andThen(Cell.andThen(Cell.andThen(Cell.andThen(Cell.mapError(loadConfigCell, (cause) => StageError.make({
 	stage: "prepare",
 	reason: configReadReasonOf(cause),
 	cause
-})), Cell.mapError(readProjectCell, (cause) => StageError.make({
+})), (loaded) => refuseLocalMutationCell(loaded)), Cell.mapError(readProjectCell, (cause) => StageError.make({
 	stage: "prepare",
 	reason: "Failed to read project",
 	cause
@@ -20203,7 +20497,7 @@ S.Struct({
 	mode: OutputMode_exports.OutputMode,
 	signal: OutputMode_exports.ModeSignal
 });
-const nextFramingState = (state, event) => Match$1.value(event).pipe(Match$1.tag("verdict", "error", "help", () => FramingState.make({
+const nextFramingState = (state, event) => Match$1.value(event).pipe(Match$1.tag("verdict", "error", "help", "refused", () => FramingState.make({
 	mode: state.mode,
 	signal: state.signal,
 	headerWritten: state.headerWritten,
@@ -20224,7 +20518,7 @@ const nextFramingState = (state, event) => Match$1.value(event).pipe(Match$1.tag
 	terminalSeen: state.terminalSeen,
 	completed: e.completed,
 	total: e.total
-})), Match$1.tag("stream", () => state), Match$1.tag("phase", () => state), Match$1.tag("tick", () => state), Match$1.tag("plugins", () => state), Match$1.tag("formats", () => state), Match$1.tag("skipped", () => state), Match$1.tag("reuse", "mutant-detail", "feedback", () => state), Match$1.exhaustive);
+})), Match$1.tag("stream", () => state), Match$1.tag("phase", () => state), Match$1.tag("tick", () => state), Match$1.tag("worker", () => state), Match$1.tag("plugins", () => state), Match$1.tag("formats", () => state), Match$1.tag("skipped", () => state), Match$1.tag("reuse", "tce", "mutant-detail", "feedback", () => state), Match$1.exhaustive);
 const noteState = (state, event) => nextFramingState(state, event);
 const formatScore = (score) => Option$1.match(Option$1.fromNullishOr(score), {
 	onNone: () => "n/a",
@@ -20234,7 +20528,7 @@ const formatTotal = (total) => Option$1.match(Option$1.fromNullishOr(total), {
 	onNone: () => "?",
 	onSome: (val) => String(val)
 });
-const formatStderrEvent = (event) => Match$1.value(event).pipe(Match$1.tag("plan", (e) => `plan ${e.total} mutants`), Match$1.tag("phase", (e) => `phase ${e.phase}`), Match$1.tag("tick", (e) => `${e.completed}/${formatTotal(e.total)} elapsed ${e.elapsedMs}ms`), Match$1.tag("verdict", (e) => `score ${formatScore(e.score)} killed ${e.counts.killed} survived ${e.counts.survived}`), Match$1.tag("error", (e) => `error ${e.error}`), Match$1.tag("stream", () => null), Match$1.tag("mutantTested", () => null), Match$1.tag("help", () => null), Match$1.tag("plugins", () => null), Match$1.tag("formats", () => null), Match$1.tag("skipped", () => null), Match$1.tag("reuse", "mutant-detail", "feedback", () => null), Match$1.exhaustive);
+const formatStderrEvent = (event) => Match$1.value(event).pipe(Match$1.tag("plan", (e) => `plan ${e.total} mutants`), Match$1.tag("phase", (e) => `phase ${e.phase}`), Match$1.tag("tick", (e) => `${e.completed}/${formatTotal(e.total)} elapsed ${e.elapsedMs}ms`), Match$1.tag("verdict", (e) => `score ${formatScore(e.score)} killed ${e.counts.killed} survived ${e.counts.survived}`), Match$1.tag("error", (e) => `error ${e.error}`), Match$1.tag("refused", (e) => `refused ${e.rule}`), Match$1.tag("stream", () => null), Match$1.tag("mutantTested", () => null), Match$1.tag("worker", () => null), Match$1.tag("help", () => null), Match$1.tag("plugins", () => null), Match$1.tag("formats", () => null), Match$1.tag("skipped", () => null), Match$1.tag("reuse", "tce", "mutant-detail", "feedback", () => null), Match$1.exhaustive);
 const stderrLineFor = (state, event) => Boolean$1$1.match(Boolean$1$1.and(state.mode === "human", !state.terminalSeen), {
 	onTrue: () => formatStderrEvent(event),
 	onFalse: () => null
@@ -20398,16 +20692,17 @@ const CONFIG_CODE = 2;
 const UNKNOWN_FAILURE = "Unknown failure";
 const SIGNAL_REMEDIATION = "the run was interrupted by a signal; re-run it to continue";
 const PARSE_REMEDIATION = "re-run with --help to see the full usage";
+const REFUSAL_REMEDIATION = "run mutation testing on main CI (GitHub Actions)";
 const DEFAULT_REMEDIATION = "see --reportFile or the verdict envelope on stdout";
-const exitCodeOf = (outcome) => Match$1.value(outcome).pipe(Match$1.tag("RunOk", () => 0), Match$1.tag("RunInterrupted", (error) => error.code), Match$1.tag("RunParseFailed", () => CONFIG_CODE), Match$1.tag("RunSurvivorsRejected", () => CONFIG_CODE), Match$1.tag("RunConfigFailed", () => CONFIG_CODE), Match$1.tag("RunFailed", (failed) => failed.code), Match$1.exhaustive);
+const exitCodeOf = (outcome) => Match$1.value(outcome).pipe(Match$1.tag("RunOk", () => 0), Match$1.tag("RunInterrupted", (error) => error.code), Match$1.tag("RunParseFailed", () => CONFIG_CODE), Match$1.tag("RunSurvivorsRejected", () => CONFIG_CODE), Match$1.tag("RunConfigFailed", () => CONFIG_CODE), Match$1.tag("RunRefused", () => CONFIG_CODE), Match$1.tag("RunFailed", (failed) => failed.code), Match$1.exhaustive);
 const nonEmptyText = Option$1.liftPredicate(S.is(S.NonEmptyString));
 const capturedOrUnknown = (captured) => Option$1.getOrElse(nonEmptyText(captured), () => UNKNOWN_FAILURE);
 const capturedThenRecorded = (captured, recorded) => Option$1.getOrElse(nonEmptyText(captured), () => Option$1.getOrElse(Option$1.fromNullishOr(recorded), () => UNKNOWN_FAILURE));
-const failureTextOf = (error, captured) => Match$1.value(error).pipe(Match$1.tag("RunParseFailed", (failed) => Option$1.getOrElse(Option$1.map(Option$1.fromNullishOr(failed.unrecognized), (value) => `Received unknown argument: '${value}'`), () => capturedOrUnknown(captured))), Match$1.tag("RunSurvivorsRejected", (failed) => Option$1.getOrElse(Option$1.fromNullishOr(failed.diagnostic), () => UNKNOWN_FAILURE)), Match$1.tag("RunInterrupted", () => capturedOrUnknown(captured)), Match$1.tag("RunConfigFailed", (failed) => capturedThenRecorded(captured, failed.detail)), Match$1.tag("RunFailed", (failed) => capturedThenRecorded(captured, failed.diagnostic)), Match$1.exhaustive);
+const failureTextOf = (error, captured) => Match$1.value(error).pipe(Match$1.tag("RunParseFailed", (failed) => Option$1.getOrElse(Option$1.map(Option$1.fromNullishOr(failed.unrecognized), (value) => `Received unknown argument: '${value}'`), () => capturedOrUnknown(captured))), Match$1.tag("RunSurvivorsRejected", (failed) => Option$1.getOrElse(Option$1.fromNullishOr(failed.diagnostic), () => UNKNOWN_FAILURE)), Match$1.tag("RunInterrupted", () => capturedOrUnknown(captured)), Match$1.tag("RunConfigFailed", (failed) => capturedThenRecorded(captured, failed.detail)), Match$1.tag("RunRefused", (failed) => failed.message), Match$1.tag("RunFailed", (failed) => capturedThenRecorded(captured, failed.diagnostic)), Match$1.exhaustive);
 const remediationTextOf = (error) => Match$1.value(error).pipe(Match$1.tag("RunInterrupted", () => SIGNAL_REMEDIATION), Match$1.tag("RunParseFailed", () => PARSE_REMEDIATION), Match$1.tag("RunSurvivorsRejected", (failed) => Option$1.getOrElse(Option$1.fromNullishOr(failed.diagnostic), () => DEFAULT_REMEDIATION)), Match$1.tag("RunConfigFailed", (failed) => Option$1.match(Option$1.fromNullishOr(failed.detail), {
 	onSome: (detail) => `check the config file: ${detail}`,
 	onNone: () => "check the config file"
-})), Match$1.tag("RunFailed", () => DEFAULT_REMEDIATION), Match$1.exhaustive);
+})), Match$1.tag("RunRefused", () => REFUSAL_REMEDIATION), Match$1.tag("RunFailed", () => DEFAULT_REMEDIATION), Match$1.exhaustive);
 const errorEnvelopeFromOutcome = (input) => ErrorEnvelope.make({
 	schemaVersion: RunEvent_exports.StreamSchemaVersion.literal,
 	code: exitCodeOf(input.error),
@@ -20504,22 +20799,33 @@ const emitNullScoreVerdict = (params) => {
 			version: StrykerPackage.version
 		}
 	};
-	const envelope = buildVerdictEnvelope(report, mode.mode, mode.signal, stream.runId, basePath, pathService, Option$1.none(), null);
-	return Queue.offer(stream.queue, RunEvent_exports.VerdictReached.make({
-		schemaVersion: envelope.schemaVersion,
-		runId: envelope.runId,
-		mode: envelope.mode,
-		signal: envelope.signal,
-		score: envelope.score,
-		thresholds: envelope.thresholds,
-		reportFile: envelope.reportFile,
-		counts: envelope.counts,
-		mutants: envelope.mutants,
-		scope: envelope.scope,
-		mutantSetPolicy: envelope.mutantSetPolicy,
-		phaseDurations: envelope.phaseDurations,
-		static: envelope.static
-	}));
+	return Effect$1.gen(function* () {
+		const now = yield* Clock.currentTimeMillis;
+		const envelope = buildVerdictEnvelope({
+			...report,
+			budget: {
+				predictedSeconds: 0,
+				actualSeconds: (now - stream.startedAt) / 1e3
+			}
+		}, mode.mode, mode.signal, stream.runId, basePath, pathService, Option$1.none(), null);
+		yield* Queue.offer(stream.queue, RunEvent_exports.VerdictReached.make({
+			schemaVersion: envelope.schemaVersion,
+			runId: envelope.runId,
+			mode: envelope.mode,
+			signal: envelope.signal,
+			score: envelope.score,
+			thresholds: envelope.thresholds,
+			reportFile: envelope.reportFile,
+			counts: envelope.counts,
+			mutants: envelope.mutants,
+			scope: envelope.scope,
+			mutantSetPolicy: envelope.mutantSetPolicy,
+			incrementalMode: envelope.incrementalMode,
+			phaseDurations: envelope.phaseDurations,
+			static: envelope.static,
+			budget: envelope.budget
+		}));
+	});
 };
 const offerFailureEnvelope = (stream, failed, captured) => {
 	const envelope = errorEnvelopeFromOutcome({
@@ -20534,6 +20840,11 @@ const offerFailureEnvelope = (stream, failed, captured) => {
 		reason: null
 	}));
 };
+const offerRefusedEnvelope = (stream, refused) => Queue.offer(stream.queue, RunEvent_exports.Refused.make({
+	schemaVersion: RunEvent_exports.StreamSchemaVersion.literal,
+	rule: refused.rule,
+	message: refused.message
+}));
 const emitHelpEnvelope = (stream, help) => Queue.offer(stream.queue, RunEvent_exports.HelpRendered.make({
 	schemaVersion: RunEvent_exports.StreamSchemaVersion.literal,
 	code: 0,
@@ -20565,7 +20876,7 @@ const emitMachineModeOutput = Effect$1.fn(SpanTaxonomy_exports.Spans.runEventStr
 		onSuccess: (decision) => Match$1.value(decision).pipe(Match$1.tag("RunOk", (ok) => Option$1.match(helpPayload(ok, captured), {
 			onSome: (help) => emitHelpEnvelope(stream, help),
 			onNone: () => emitNullScoreVerdictWhenOpen(stream, mode, basePath, pathService)
-		})), Match$1.tag("RunParseFailed", (failed) => offerFailureEnvelope(stream, failed, captured)), Match$1.tag("RunSurvivorsRejected", (failed) => offerFailureEnvelope(stream, failed, captured)), Match$1.tag("RunConfigFailed", (failed) => offerFailureEnvelope(stream, failed, captured)), Match$1.tag("RunFailed", (failed) => offerFailureEnvelope(stream, failed, captured)), Match$1.exhaustive),
+		})), Match$1.tag("RunParseFailed", (failed) => offerFailureEnvelope(stream, failed, captured)), Match$1.tag("RunSurvivorsRejected", (failed) => offerFailureEnvelope(stream, failed, captured)), Match$1.tag("RunConfigFailed", (failed) => offerFailureEnvelope(stream, failed, captured)), Match$1.tag("RunRefused", (refused) => offerRefusedEnvelope(stream, refused)), Match$1.tag("RunFailed", (failed) => offerFailureEnvelope(stream, failed, captured)), Match$1.exhaustive),
 		onFailure: (failure) => offerFailureEnvelope(stream, failure, captured)
 	});
 });