@systemfsoftware/stryker-js 17.0.2 → 22.0.0

package/dist/index.mjs

@@ -1,18 +1,19 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
-import { i as Mutant_exports, l as Report_exports, n as mergeConfigs } from "./merge-config-ruui2TPS.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-DnDU_wrY.mjs";
+import { i as Mutant_exports, l as Report_exports, n as mergeConfigs } from "./merge-config-BWQeU3-p.mjs";
+import { $ as IncrementalReportSchema, $t as checkCell, A as optionalField, At as ExtendsStepDone, B as nodePlatformLayer, Bt as createDefaultOptions, C as offerSkipsIfAny, Ct as WorkerLauncher, D as dryRunChoiceOf, Dt as importModule, E as reusedTestCoverage, Et as decideExtendsStep, F as diffScopeDecisionOf, Ft as ConfigError, G as git_diff_service_exports, Gt as ImportedModuleSchema, H as SourceParser, Ht as ConfigDocumentSchema, I as DryRunCoverageReused, It as ConfigFileInvalidError, J as git_diff_schema_exports, Jt as ReadConfigCommand, K as ChangedSince, Kt as MergeCommand, L as scoped$1, Lt as ConfigFileNotFoundError, M as relativeNormalizedFileName, Mt as ExtendsStepRefused, N as requireDryRun, Nt as ExtendsStepResolve, O as requireDryRunCommandOf, Ot as initialExtendsStepState, P as readProjectCell, Pt as FileMatcher, Q as classifyWorkerExit, Qt as groupCell, R as makeCheckerPoolHandle, Rt as ConfigFileUnreadableError, S as instrumentFiles, St as makeWorkerClient, T as readIncrementalReuse, Tt as ReproducerSchema, U as source_parser_service_exports, Ut as ExtendsStepDocumentSchema, V as layerWorkerProtocol, Vt as defaultOptions, W as GitDiff, Wt as ExtendsStepStateSchema, X as ClassifyWorkerExitCommand, Xt as forkOptionsSchema, Y as EmptyDirectory, Yt as extendsPropertySchema, Z as ClassifyWorkerExitDecision, Zt as survivorsPriorReport, _ as testRunnerConfigOf, _t as metricsResultFromFiles, a as HtmlReporter_exports, an as ShardPlan, at as RunEnvironment, b as planPrepare, bt as spawnReporterWorker, c as instrumentCell, cn as SpanTaxonomy_exports, ct as SurfacingFields, d as isCommandRunner, dn as CheckerSkippedRequested, dt as RunEvents, en as ChildProcessCrashedError, et as validateOptions, f as mutantDetailEventsOf, ft as RunIdentity, g as isVmRunner, gt as staticVerdictOf, h as readPrepare, ht as VerdictEnvelope, i as MachineConsole, in as RunEvent_exports$1, it as readConfig, j as import_closure_cell_exports, jt as ExtendsStepRead, k as incrementalReportTextsOf, kt as StrykerError, l as buildTestRunner, ln as CheckerAnsweredUnrequested, lt as SurvivorRef, m as admitPreparedProject, mt as generateRunId, n as RunEventDrain, nn as WorkerBootTimeoutError, nt as describeErrors, o as mutationTestCell, on as ShardPlanVersion, ot as IdGenerator, p as concurrencyCell, pt as buildVerdictEnvelope, q as WholeProject, qt as MergeResult, r as makeRunEventStream, rn as OutputMode_exports, rt as forkCoreSchema, s as prepareCell, sn as ShardProject, st as surfacedSurvivorsOf, t as strykerCell, tn as OutOfMemoryError, tt as loadConfigCell, u as makeChildProcessTestRunner, un as CheckerIgnoredWithoutRule, ut as StrykerPackage, v as vmRunnerPluginUrl, vt as MetricsResultFromReport, w as planInstrumentation, wt as make, x as enteringInstrumentPhase, xt as withPhaseSpan, y as vmTestRunnerConfig, yt as reporterWorkerFactory, z as programDigestOf, zt as ConfigFileUnsupportedError } from "./run-stages-BnFibYAg.mjs";
 import { n as StageError } from "./Run.schema-DuaneDGd.mjs";
-import { Cell, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
+import { Blueprint, Cell, Handle, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
 import * as S from "effect/Schema";
+import * as Arr from "effect/Array";
+import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
+import { dual } from "effect/Function";
 import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
 import * as Boolean from "effect/Boolean";
-import * as Arr from "effect/Array";
 import * as Match from "effect/Match";
 import * as Result from "effect/Result";
-import { dual } from "effect/Function";
 import "effect/Cause";
+import * as Record from "effect/Record";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
 import * as Stream from "effect/Stream";
@@ -20,8 +21,10 @@ import * as Clock from "effect/Clock";
 import * as Layer from "effect/Layer";
 import * as Queue from "effect/Queue";
 import "effect/Scope";
+import * as MutableHashMap from "effect/MutableHashMap";
 import * as SocketServer from "effect/socket/SocketServer";
 import * as Fiber from "effect/Fiber";
+import * as HashSet from "effect/HashSet";
 import * as DateTime from "effect/DateTime";
 import * as Ref from "effect/Ref";
 import * as Stdio from "effect/Stdio";
@@ -29,12 +32,20 @@ import { NodeSocketServer } from "@effect/platform-node";
 import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
 import * as FiberSet from "effect/FiberSet";
 import * as Socket from "effect/socket/Socket";
+import "effect/Console";
 import { McpProtocol, McpServer, Tool, Toolkit } from "effect/ai";
+//#region src/Checker/Checker.cell.ts
+const checkGroupedCell = groupCell.pipe(Cell.flatMap((groups) => Cell.mapInput(Cell.collect(checkCell, (perGroup) => perGroup.flat()), (input) => groups.map((group) => ({
+	...input,
+	plans: group
+})))));
+//#endregion
 //#region src/Checker/mod.ts
 var Checker_exports = /* @__PURE__ */ __exportAll({
 	CheckerAnsweredUnrequested: () => CheckerAnsweredUnrequested,
+	CheckerIgnoredWithoutRule: () => CheckerIgnoredWithoutRule,
 	CheckerSkippedRequested: () => CheckerSkippedRequested,
-	checkGroupedPlans: () => checkGroupedPlans
+	checkGroupedCell: () => checkGroupedCell
 });
 //#endregion
 //#region src/Configuration/mod.ts
@@ -72,15 +83,587 @@ var Configuration_exports = /* @__PURE__ */ __exportAll({
 	validateOptions: () => validateOptions
 });
 //#endregion
+//#region src/plan-request.schema.ts
+const CostsFieldSchema = S.StructWithRest(S.Struct({ costs: S.Record(S.String, S.Struct({
+	predictedMs: S.Finite,
+	actualMs: S.NullOr(S.Finite)
+})).pipe(S.optional) }), [S.Record(S.String, S.Json)]);
+const CompileErrorProbeSchema = S.Struct({ files: S.Record(S.String, S.Struct({ mutants: S.Array(S.Struct({ status: S.String })) })) });
+var PlanShardsRefused = class extends S.TaggedError()("PlanShardsRefused", { detail: S.String }) {
+	exitClass = "ConfigError";
+	next = "Pass --target-seconds above 0 and --max-shards of 1 or more, and name each project directory once in --projects.";
+	get reason() {
+		return `stryker plan: the planner refused its input: ${this.detail}. ${this.next}`;
+	}
+	get message() {
+		return this.reason;
+	}
+};
+//#endregion
+//#region src/plan-shards.workflow.ts
+const { ceil, max, min, sign } = Math;
+const MAX_COST_MS = Number.MAX_SAFE_INTEGER;
+const CostMs = S.Finite.pipe(S.check(S.isBetween({
+	minimum: 0,
+	maximum: MAX_COST_MS
+})));
+const PositiveSeconds = S.Finite.pipe(S.check(S.isGreaterThan(0)));
+const PositiveInt = S.Int.pipe(S.check(S.isGreaterThanOrEqualTo(1)));
+const PlannedMutant = S.Struct({
+	project: S.String,
+	id: Mutant_exports.MutantId,
+	costMs: CostMs,
+	dependsOnDryRun: S.Boolean,
+	placementKey: S.optional(Mutant_exports.MutantId)
+});
+const mutantKeyOf = (mutant) => `\u0000${mutant.project}\u0000${mutant.id}`;
+const plannedMutantsAreDistinct = S.makeFilter((mutants) => Boolean.match(new Set(mutants.map(mutantKeyOf)).size === mutants.length, {
+	onTrue: () => void 0,
+	onFalse: () => "two planned mutants share a project and a mutant id"
+}), { arbitraryConstraint: { uniqueBy: mutantKeyOf } });
+const PlannedMutants = S.Array(PlannedMutant).check(plannedMutantsAreDistinct);
+var PlanShardsCommand = class extends S.TaggedClass()("PlanShardsCommand", {
+	targetSeconds: PositiveSeconds,
+	maxShards: S.optional(PositiveInt),
+	mutants: PlannedMutants,
+	dryRunCosts: S.Record(S.String, CostMs)
+}) {
+	static [Workflow.InstrumentationBrand] = {};
+};
+const ShardPlanTypeId = Symbol.for("@systemfsoftware/stryker-js/PlannedShards");
+var PlannedShard = class extends S.TaggedClass()("PlannedShard", {
+	index: S.Int,
+	count: S.Int,
+	predictedSeconds: Report_exports.NonNegativeFinite,
+	projects: S.Array(ShardProject)
+}) {
+	[ShardPlanTypeId] = ShardPlanTypeId;
+};
+const compareText = (left, right) => sign(Number(left > right) - Number(left < right));
+const compareProjectThenId = (left, right) => Boolean.match(compareText(left.project, right.project) === 0, {
+	onTrue: () => compareText(left.id, right.id),
+	onFalse: () => compareText(left.project, right.project)
+});
+const totalCostMsOf = (mutants) => mutants.reduce((total, mutant) => total + mutant.costMs, 0);
+const dryRunCostOf = (command, project) => Option.getOrElse(Record.get(command.dryRunCosts, project), () => 0);
+const dependentProjectsOf = (command) => {
+	const byProject = command.mutants.reduce((accumulated, mutant) => Boolean.match(mutant.dependsOnDryRun, {
+		onTrue: () => Record.set(accumulated, mutant.project, [...Option.getOrElse(Record.get(accumulated, mutant.project), () => []), mutant]),
+		onFalse: () => accumulated
+	}), {});
+	return [...Record.toEntries(byProject)].sort(([left], [right]) => compareText(left, right)).map(([project, mutants]) => ({
+		project,
+		dependentCostMs: totalCostMsOf(mutants),
+		dryRunCostMs: dryRunCostOf(command, project),
+		mutants
+	}));
+};
+const dryRunBinsNeededOf = (project, targetMs) => {
+	const remainingMs = targetMs - project.dryRunCostMs;
+	return Boolean.match(remainingMs > 0, {
+		onTrue: () => max(1, ceil(project.dependentCostMs / remainingMs)),
+		onFalse: () => Number.POSITIVE_INFINITY
+	});
+};
+const plannedLoadMsOf = (command, projects, targetMs) => totalCostMsOf(command.mutants) + projects.reduce((total, project) => {
+	const bins = dryRunBinsNeededOf(project, targetMs);
+	return Boolean.match(Number.isFinite(bins), {
+		onTrue: () => total + bins * project.dryRunCostMs,
+		onFalse: () => total
+	});
+}, 0);
+const neededShardsOf = (command, loadMs) => max(1, ceil(loadMs / 1e3 / command.targetSeconds));
+const cappedShardsOf = (command, loadMs) => Option.match(Option.fromUndefinedOr(command.maxShards), {
+	onNone: () => neededShardsOf(command, loadMs),
+	onSome: (maxShards) => max(1, min(maxShards, neededShardsOf(command, loadMs)))
+});
+const shardCountOf = (command, loadMs) => min(cappedShardsOf(command, loadMs), max(command.mutants.length, 1));
+const EMPTY_BIN = {
+	mutants: [],
+	load: 0
+};
+const emptyBins = (count) => Array.from({ length: count }, () => ({
+	mutants: [],
+	load: 0
+}));
+const indicesOf = (count) => Array.from({ length: count }, (_unused, index) => index);
+const loadAt = (bins, index) => Option.getOrElse(Option.fromUndefinedOr(bins[index]), () => EMPTY_BIN).load;
+const leastLoadedOf = (bins, indices) => indices.reduce((best, index) => Boolean.match(loadAt(bins, index) < loadAt(bins, best), {
+	onTrue: () => index,
+	onFalse: () => best
+}), Option.getOrElse(Option.fromUndefinedOr(indices[0]), () => 0));
+const compareLoadedBins = (left, right) => sign(sign(left.load - right.load) * 2 + sign(left.index - right.index));
+const leastLoadedIndicesOf = (bins, count) => indicesOf(bins.length).map((index) => ({
+	index,
+	load: loadAt(bins, index)
+})).sort(compareLoadedBins).slice(0, count).map((entry) => entry.index);
+const placementKeyOf$1 = (mutant) => Option.getOrElse(Option.fromUndefinedOr(mutant.placementKey), () => mutantKeyOf(mutant));
+const projectOfGroup = (members) => Option.match(Arr.head(members), {
+	onNone: () => "",
+	onSome: (head) => head.project
+});
+const placementGroupsOf = (mutants) => Record.toEntries(Arr.groupBy(mutants, placementKeyOf$1)).map(([key, members]) => {
+	const sorted = [...members].sort(compareProjectThenId);
+	return {
+		key,
+		project: projectOfGroup(sorted),
+		mutants: sorted,
+		costMs: totalCostMsOf(sorted),
+		dependsOnDryRun: sorted.some((mutant) => mutant.dependsOnDryRun)
+	};
+});
+const compareGroupsCostliestFirst = (left, right) => Boolean.match(left.costMs === right.costMs, {
+	onTrue: () => Boolean.match(compareText(left.project, right.project) === 0, {
+		onTrue: () => compareText(left.key, right.key),
+		onFalse: () => compareText(left.project, right.project)
+	}),
+	onFalse: () => sign(right.costMs - left.costMs)
+});
+const withGroupIn = (bins, index, group) => bins.map((bin, at) => Boolean.match(at === index, {
+	onTrue: () => ({
+		mutants: [...bin.mutants, ...group.mutants],
+		load: bin.load + group.costMs
+	}),
+	onFalse: () => bin
+}));
+const reservedBin = (bins, index, costMs) => bins.map((bin, at) => Boolean.match(at === index, {
+	onTrue: () => ({
+		mutants: bin.mutants,
+		load: bin.load + costMs
+	}),
+	onFalse: () => bin
+}));
+const projectsOf$1 = (mutants) => {
+	const byProject = mutants.reduce((accumulated, mutant) => Record.set(accumulated, mutant.project, [...Option.getOrElse(Record.get(accumulated, mutant.project), () => []), mutant.id]), {});
+	return [...Record.toEntries(byProject)].sort(([left], [right]) => compareText(left, right)).map(([project, ids]) => ({
+		project,
+		mutants: [...ids].sort(compareText)
+	}));
+};
+const shardsOf = (command) => {
+	const targetMs = command.targetSeconds * 1e3;
+	const dependentProjects = dependentProjectsOf(command);
+	const count = shardCountOf(command, plannedLoadMsOf(command, dependentProjects, targetMs));
+	const reserved = dependentProjects.reduce((accumulated, project) => {
+		const indices = leastLoadedIndicesOf(accumulated.bins, min(dryRunBinsNeededOf(project, targetMs), count));
+		return {
+			bins: indices.reduce((bins, index) => reservedBin(bins, index, project.dryRunCostMs), accumulated.bins),
+			indicesByProject: {
+				...accumulated.indicesByProject,
+				[project.project]: indices
+			}
+		};
+	}, {
+		bins: emptyBins(count),
+		indicesByProject: {}
+	});
+	const groups = placementGroupsOf(command.mutants);
+	const withDependents = groups.filter((group) => group.dependsOnDryRun).sort(compareGroupsCostliestFirst).reduce((bins, group) => withGroupIn(bins, leastLoadedOf(bins, Option.getOrElse(Record.get(reserved.indicesByProject, group.project), () => indicesOf(count))), group), reserved.bins);
+	return groups.filter((group) => Boolean.not(group.dependsOnDryRun)).sort(compareGroupsCostliestFirst).reduce((bins, group) => withGroupIn(bins, leastLoadedOf(bins, indicesOf(bins.length)), group), withDependents).map((bin, index) => PlannedShard.make({
+		index: index + 1,
+		count,
+		predictedSeconds: bin.load / 1e3,
+		projects: projectsOf$1(bin.mutants)
+	}));
+};
+const planShards = Workflow.make({
+	command: PlanShardsCommand,
+	decision: S.Array(PlannedShard),
+	error: S.Never,
+	decide: (command) => Result.succeed(shardsOf(command))
+});
+//#endregion
+//#region src/project-directory.ts
+const projectsOf = (projects) => Option.getOrElse(Option.filter(Option.fromUndefinedOr(projects), Arr.isReadonlyArrayNonEmpty), () => ["."]);
+const inProjectDirectory = (directory, body) => Effect.suspend(() => {
+	const previous = globalThis.process.cwd();
+	return Effect.acquireUseRelease(Effect.sync(() => globalThis.process.chdir(directory)), () => body, () => Effect.sync(() => globalThis.process.chdir(previous)));
+});
+/**
+* Runs `body` once per `--projects` entry, one at a time, with the process
+* working directory switched to that entry, because config discovery reads
+* the working directory. No entries means the working directory alone.
+*/
+const forEachProjectDirectory = dual(2, (projects, body) => Effect.forEach(projectsOf(projects), (directory) => inProjectDirectory(directory, body(directory)), { concurrency: 1 }));
+//#endregion
+//#region src/run/plan-instrument.cell.ts
+const gatherPlanInstrument = Effect.fn(SpanTaxonomy_exports.Spans.instrumentGather.name)(function* (command) {
+	const { filesToMutate, instrumentResult, instrumentedProject } = yield* instrumentFiles(command);
+	return {
+		_tag: "InstrumentCommand",
+		fileCount: filesToMutate.length,
+		inPlace: command.options.inPlace,
+		pluginCount: command.loadedPlugins.pluginModulePaths.length,
+		prev: command,
+		instrumentedProject,
+		instrumentResult,
+		mutants: instrumentResult.mutants
+	};
+});
+const readPlanInstrument = (command) => enteringInstrumentPhase(command.project.filesToMutate.size, gatherPlanInstrument(command));
+const writePlanInstrument = (raw) => Effect.as(offerSkipsIfAny({
+	skipped: raw.instrumentResult.skipped,
+	claimants: raw.prev.frameworkClaimants
+}), {
+	project: raw.instrumentedProject,
+	mutants: raw.mutants,
+	options: raw.prev.options,
+	incrementalReportDiscard: raw.prev.incrementalReportDiscard
+});
+const planInstrumentCell = Sandwich.named(SpanTaxonomy_exports.Spans.instrument.name)(readPlanInstrument).decide(planInstrumentation).write({
+	InPlaceInstrument: (_decision, raw) => writePlanInstrument(raw),
+	EphemeralInstrument: (_decision, raw) => writePlanInstrument(raw),
+	CommandRejected: ({ issue }) => Effect.fail(StageError.make({
+		stage: "instrument",
+		reason: issue
+	}))
+});
+//#endregion
+//#region src/run/plan-prepare.cell.ts
+const writePrepareForInstrument = (raw) => withPhaseSpan(SpanTaxonomy_exports.Spans.preparePhase, {}, () => Effect.gen(function* () {
+	yield* admitPreparedProject(raw);
+	yield* Queue.offer(raw.queue, RunEvent_exports$1.PhaseEntered.make({
+		phase: "prepare",
+		elapsedMs: raw.now - raw.env.runStartedAt
+	}));
+	return {
+		project: raw.project,
+		loadedPlugins: raw.loaded,
+		ignorers: raw.ignorers,
+		mutatorCatalogs: raw.mutatorCatalogs,
+		mutatorSelection: raw.mutatorSelection,
+		formatRegistry: raw.formatRegistry,
+		options: raw.options,
+		frameworkClaimants: raw.frameworkClaimants,
+		incrementalReportDiscard: raw.incrementalReportDiscard
+	};
+}));
+const prepareForInstrumentCell = Sandwich.named(SpanTaxonomy_exports.Spans.prepare.name)(readPrepare).decide(planPrepare).write({
+	HumanReporters: (_decision, raw) => writePrepareForInstrument(raw),
+	MachineReporters: (_decision, raw) => writePrepareForInstrument(raw),
+	CommandRejected: ({ issue }) => Effect.fail(StageError.make({
+		stage: "prepare",
+		reason: issue
+	}))
+});
+//#endregion
+//#region src/plan-request.cell.ts
+const DEFAULT_MUTANT_COST_MS = 1e3;
+const prepareStageCell = Cell.andThen(Cell.andThen(loadConfigCell, readProjectCell), prepareForInstrumentCell);
+const planStageCell = Cell.andThen(prepareStageCell, (prepared) => Cell.map(planInstrumentCell, (done) => ({
+	prepared,
+	done
+})));
+const namedCostsOf = (costs) => Object.fromEntries(Object.entries(costs).flatMap(([mutantId, entry]) => Option.toArray(Option.map(Option.orElse(Option.fromNullishOr(entry.actualMs), () => Option.fromNullishOr(entry.predictedMs)), (costMs) => [mutantId, costMs]))));
+const reportCostsOf = (texts) => texts.reduce((accumulated, text) => Option.match(S.decodeOption(S.fromJsonString(CostsFieldSchema))(text), {
+	onNone: () => accumulated,
+	onSome: (decoded) => Option.match(Option.fromUndefinedOr(decoded.costs), {
+		onNone: () => accumulated,
+		onSome: (costs) => ({
+			...namedCostsOf(costs),
+			...accumulated
+		})
+	})
+}), {});
+const testsTimeOf = (tests) => tests.reduce((total, test) => total + test.timeSpentMs, 0);
+const runsWholeSuite = (testCoverage, mutantId) => Option.match(Option.fromNullishOr(testCoverage.staticCoverage), {
+	onNone: () => true,
+	onSome: (staticCoverage) => Option.getOrElse(Option.fromUndefinedOr(staticCoverage[mutantId]), () => 0) > 0
+});
+const coveringCostOf = (coverage, testCoverage, mutantId) => Option.orElse(Option.map(Option.filter(Option.map(MutableHashMap.get(testCoverage.testsByMutantId, mutantId), (tests) => testsTimeOf([...tests])), (millis) => millis > 0), (millis) => millis + coverage.timeOverheadMs), () => Option.filter(Option.some(testsTimeOf(coverage.tests) + coverage.timeOverheadMs), () => runsWholeSuite(testCoverage, mutantId)));
+const costOf = (mutantId, reportCosts, coverage, testCoverage) => Option.getOrElse(Option.orElse(Record.get(reportCosts, mutantId), () => Option.flatMap(coverage, (present) => coveringCostOf(present, testCoverage, mutantId))), () => DEFAULT_MUTANT_COST_MS);
+const emptyTestCoverage = () => ({
+	testsByMutantId: MutableHashMap.empty(),
+	testsById: MutableHashMap.empty(),
+	staticCoverage: void 0,
+	hitsByMutantId: MutableHashMap.empty(),
+	dryRunCoverage: void 0
+});
+const dependentMutantIdsOf = (decision) => Match.value(decision).pipe(Match.tag("DryRunNeeded", (needed) => needed.dependentMutantIds), Match.tag("DryRunSkippable", () => []), Match.exhaustive);
+const labelOf = (path, basePath, project) => {
+	const relative = path.relative(basePath, project).replace(/\\/g, "/");
+	return relative.length === 0 ? "." : relative;
+};
+const reportHoldsCompileErrorRecord = (text) => Option.exists(S.decodeOption(S.fromJsonString(CompileErrorProbeSchema))(text), (report) => Object.values(report.files).some((file) => file.mutants.some((mutant) => mutant.status === "CompileError")));
+const programDigestAtPlanTime = ({ texts, context, options, loadedPlugins, project }) => Boolean.match(Boolean.and(Boolean.not(options.inPlace), texts.some(reportHoldsCompileErrorRecord)), {
+	onTrue: () => Effect.gen(function* () {
+		const pool = yield* scoped$1({
+			options,
+			loadedPlugins,
+			size: 1,
+			workingDirectory: project
+		});
+		return yield* Option.match(Option.fromNullishOr(pool), {
+			onNone: () => Effect.as(Effect.void, void 0),
+			onSome: (present) => programDigestOf(makeCheckerPoolHandle(present), project)
+		});
+	}).pipe(Effect.provide(context), Effect.scoped),
+	onFalse: () => Effect.as(Effect.void, void 0)
+});
+const projectDiffOf = (path, planRoot, project, diff) => {
+	const fromProject = (file) => path.relative(project, path.resolve(planRoot, file)).replace(/\\/g, "/");
+	return {
+		...diff,
+		hunks: diff.hunks.map((hunk) => ({
+			...hunk,
+			file: fromProject(hunk.file)
+		})),
+		untrackedFiles: diff.untrackedFiles.map(fromProject)
+	};
+};
+const stageCliOptionsOf = (since, full) => Option.match(Option.fromUndefinedOr(since), {
+	onNone: () => ({ force: full }),
+	onSome: (present) => ({
+		force: full,
+		since: present
+	})
+});
+const plannedDiffOf = (path, planDiff, project) => Option.match(planDiff.diff, {
+	onNone: () => WholeProject.make({}),
+	onSome: (diff) => ChangedSince.make({ diff: projectDiffOf(path, planDiff.root, project, diff) })
+});
+const resolvedSinceOf = (planDiff) => Option.getOrUndefined(Option.map(planDiff.diff, (diff) => diff.ref));
+const subsumedOf = (mutant) => Option.filter(Option.fromUndefinedOr(mutant.subsumption), S.is(Mutant_exports.Subsumed));
+const dominatorIdsOf = (mutants) => new Set(mutants.flatMap((mutant) => Option.match(subsumedOf(mutant), {
+	onNone: () => [],
+	onSome: (subsumed) => subsumed.dominators
+})));
+const placementKeyOf = (dominatorIds, mutant) => Option.getOrUndefined(Option.orElse(Option.map(subsumedOf(mutant), (subsumed) => subsumed.dominators[0]), () => Option.liftPredicate(mutant.id, (id) => dominatorIds.has(id))));
+const planProject = (request, channel, labelBase, planDiff, directory) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const basePath = channel.environment.basePath;
+	const project = yield* fs.realPath(path.resolve(basePath, directory));
+	const env = {
+		...channel.environment.host.env,
+		basePath: project
+	};
+	const context = yield* Layer.build(RunEnvironment.layerStage(env, channel.environment.host.events));
+	const stageInput = {
+		cliOptions: stageCliOptionsOf(resolvedSinceOf(planDiff), request.full),
+		targetMutatePatterns: void 0,
+		plannedDiff: plannedDiffOf(path, planDiff, project)
+	};
+	const { prepared, done } = yield* Cell.provideContext(planStageCell, context).run(stageInput);
+	const texts = yield* incrementalReportTextsOf({
+		basePath: project,
+		options: done.options
+	});
+	const dryRunChoice = yield* dryRunChoiceOf(done, project, texts);
+	const coverage = dryRunChoice.prior;
+	const testCoverage = Option.match(coverage, {
+		onNone: emptyTestCoverage,
+		onSome: reusedTestCoverage
+	});
+	const reportCosts = reportCostsOf(texts);
+	const label = labelOf(path, labelBase, project);
+	const programDigest = yield* programDigestAtPlanTime({
+		texts,
+		context,
+		options: done.options,
+		loadedPlugins: prepared.loadedPlugins,
+		project
+	});
+	const reuse = yield* readIncrementalReuse({
+		project: done.project,
+		currentMutants: [...done.mutants],
+		testCoverage,
+		basePath: project,
+		force: request.full,
+		options: done.options,
+		globalTestInputs: Option.map(coverage, (present) => [...present.globalTestInputs]).pipe(Option.getOrElse(() => [])),
+		observedModules: Option.getOrUndefined(Option.map(coverage, (present) => present.testFileModules)),
+		originalFileOf: (file) => path.resolve(file),
+		programDigestOf: Effect.succeed(programDigest)
+	});
+	const dryRunDecision = Result.getOrElse(requireDryRun(requireDryRunCommandOf({
+		options: done.options,
+		mutants: [...reuse.mutants, ...reuse.rememberedResults],
+		texts,
+		kept: dryRunChoice.kept
+	})), (neverError) => neverError);
+	const dependentIds = HashSet.fromIterable(dependentMutantIdsOf(dryRunDecision));
+	const dryRunCostMs = Boolean.match(S.is(DryRunCoverageReused)(dryRunChoice.decision), {
+		onTrue: () => 0,
+		onFalse: () => Option.getOrElse(Option.map(coverage, (present) => testsTimeOf(present.tests) + present.timeOverheadMs), () => DEFAULT_MUTANT_COST_MS)
+	});
+	const dominatorIds = dominatorIdsOf(reuse.mutants);
+	return {
+		label,
+		mutants: [...reuse.mutants.map((mutant) => ({
+			id: mutant.id,
+			costMs: costOf(mutant.id, reportCosts, coverage, testCoverage),
+			dependsOnDryRun: HashSet.has(dependentIds, mutant.id),
+			...optionalField("placementKey", placementKeyOf(dominatorIds, mutant))
+		})), ...reuse.rememberedResults.map((mutant) => ({
+			id: mutant.id,
+			costMs: 0,
+			dependsOnDryRun: HashSet.has(dependentIds, mutant.id),
+			...optionalField("placementKey", placementKeyOf(dominatorIds, mutant))
+		}))],
+		files: [...HashSet.fromIterable([...reuse.mutants, ...reuse.rememberedResults].map((mutant) => path.resolve(project, mutant.fileName)))].sort(),
+		dryRunCostMs,
+		reuse: {
+			reused: reuse.rememberedResults.length,
+			ran: reuse.mutants.length,
+			refused: reuse.refusalCounts,
+			...done.incrementalReportDiscard === void 0 ? {} : { discard: done.incrementalReportDiscard }
+		}
+	};
+}).pipe(Effect.orDie);
+const planScopeOf = (diff, planned, basePath) => Option.match(diff, {
+	onNone: () => Effect.succeed({ _tag: "Unscoped" }),
+	onSome: (present) => Effect.gen(function* () {
+		const path = yield* Path.Path;
+		const git = yield* GitDiff;
+		const root = yield* git.toplevel(basePath);
+		const files = [...HashSet.fromIterable(planned.flatMap((entry) => entry.files.map((file) => path.relative(root, file).replace(/\\/g, "/"))))].sort();
+		const sources = yield* git.sourceDigest({
+			cwd: basePath,
+			paths: files
+		});
+		return Match.value(diffScopeDecisionOf(present)).pipe(Match.tag("DiffScoped", () => ({
+			_tag: "DiffScoped",
+			base: present.base,
+			head: present.head,
+			sources,
+			files
+		})), Match.tag("FullScope", (full) => ({
+			_tag: "FullScope",
+			base: present.base,
+			head: present.head,
+			sources,
+			files,
+			reason: full.reason
+		})), Match.exhaustive);
+	})
+});
+const assemblePlan = (request, scope, planned, dryRunCosts) => Effect.map(PlanShardsCommand.makeEffect({
+	targetSeconds: request.targetSeconds,
+	maxShards: request.maxShards,
+	mutants: planned.map((mutant) => ({ ...mutant })),
+	dryRunCosts
+}).pipe(Effect.mapError((issue) => PlanShardsRefused.make({ detail: new S.SchemaError(issue).message }))), (command) => shardPlanOf(request, scope, Result.getOrElse(planShards(command), (neverError) => neverError)));
+const shardPlanOf = (request, scope, shards) => ({
+	version: ShardPlanVersion.literal,
+	scope,
+	targetSeconds: request.targetSeconds,
+	shards: shards.map((shard) => ({
+		index: shard.index,
+		count: shard.count,
+		predictedSeconds: shard.predictedSeconds,
+		projects: shard.projects.map((entry) => ({
+			project: entry.project,
+			mutants: [...entry.mutants]
+		}))
+	})),
+	matrix: { include: shards.map((shard) => ({
+		shard: `${shard.index}/${shard.count}`,
+		predictedSeconds: shard.predictedSeconds
+	})) }
+});
+const writePlan = (request, channel, plan) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const text = yield* Effect.orDie(S.encodeEffect(S.fromJsonString(ShardPlan, { space: 2 }))(plan));
+	return yield* Option.match(Option.fromUndefinedOr(request.out), {
+		onNone: () => Effect.sync(() => channel.environment.console.log(text)),
+		onSome: (out) => Effect.gen(function* () {
+			const target = path.resolve(channel.environment.basePath, out);
+			yield* fs.makeDirectory(path.dirname(target), { recursive: true });
+			yield* fs.writeFileString(target, text);
+		})
+	});
+}).pipe(Effect.orDie);
+const labelBaseOf = (path, basePath, out) => Option.getOrElse(Option.map(Option.fromUndefinedOr(out), (present) => path.dirname(path.resolve(basePath, present))), () => basePath);
+const planReuseRowOf = (entry) => RunEvent_exports$1.PlanProjectReuse.make({
+	project: entry.label,
+	reused: entry.reuse.reused,
+	ran: entry.reuse.ran,
+	refused: entry.reuse.refused,
+	...Option.match(Option.fromUndefinedOr(entry.reuse.discard), {
+		onNone: () => ({}),
+		onSome: (discard) => ({ discard: RunEvent_exports$1.PlanReportDiscard.make({
+			reason: discard.reason,
+			expected: discard.expected,
+			...Option.match(Option.fromUndefinedOr(discard.actual), {
+				onNone: () => ({}),
+				onSome: (actual) => ({ actual })
+			})
+		}) })
+	})
+});
+const planDiffOf = (since, basePath) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const root = yield* Effect.orDie(fs.realPath(basePath));
+	return {
+		root,
+		diff: yield* Option.match(Option.fromUndefinedOr(since), {
+			onNone: () => Effect.succeedNone,
+			onSome: (ref) => Effect.asSome(Effect.flatMap(GitDiff, (git) => git.changedSince({
+				cwd: root,
+				ref
+			})))
+		})
+	};
+});
+const rootOptionsOf = (request, channel) => Effect.gen(function* () {
+	const env = {
+		...channel.environment.host.env,
+		basePath: channel.environment.basePath
+	};
+	const context = yield* Layer.build(RunEnvironment.layerStage(env, channel.environment.host.events));
+	return (yield* Cell.provideContext(loadConfigCell, context).run({
+		cliOptions: stageCliOptionsOf(request.since, request.full),
+		targetMutatePatterns: void 0
+	})).options;
+}).pipe(Effect.orDie);
+const realProjectOf = (fs, path, basePath, directory) => {
+	const resolved = path.resolve(basePath, directory);
+	return fs.realPath(resolved).pipe(Effect.orElseSucceed(() => resolved));
+};
+const distinctProjectsOf = (basePath, projects) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const keyed = yield* Effect.forEach(Option.getOrElse(Option.fromUndefinedOr(projects), () => []), (directory) => Effect.map(realProjectOf(fs, path, basePath, directory), (real) => ({
+		directory,
+		real
+	})));
+	return Arr.dedupeWith(keyed, (left, right) => left.real === right.real).map((entry) => entry.directory);
+});
+const planRequest = ({ request, channel }) => Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const labelBase = labelBaseOf(path, channel.environment.basePath, request.out);
+	const rootOptions = yield* rootOptionsOf(request, channel);
+	const resolvedSince = Option.getOrUndefined(Option.orElse(Option.fromUndefinedOr(request.since), () => Option.fromUndefinedOr(rootOptions.since)));
+	const planDiff = yield* planDiffOf(resolvedSince, channel.environment.basePath);
+	const planned = yield* forEachProjectDirectory(yield* distinctProjectsOf(channel.environment.basePath, request.projects), (directory) => planProject(request, channel, labelBase, planDiff, directory));
+	const scheduled = planned.flatMap((entry) => entry.mutants.map((mutant) => ({
+		project: entry.label,
+		...mutant
+	})));
+	const dryRunCosts = Object.fromEntries(planned.map((entry) => [entry.label, entry.dryRunCostMs]));
+	const scope = yield* planScopeOf(planDiff.diff, planned, channel.environment.basePath);
+	const plan = yield* assemblePlan(request, scope, scheduled, dryRunCosts);
+	yield* Queue.offer(channel.environment.host.events, RunEvent_exports$1.PlanKnown.make({
+		total: scheduled.length,
+		shardPlan: plan,
+		projects: planned.map(planReuseRowOf)
+	}));
+	yield* writePlan(request, channel, plan).pipe(Effect.orDie);
+}).pipe(Effect.scoped);
+//#endregion
 //#region src/Engine/mod.ts
 var Engine_exports = /* @__PURE__ */ __exportAll({
 	IdGenerator: () => IdGenerator,
 	IncrementalReportSchema: () => IncrementalReportSchema,
+	PlanShardsRefused: () => PlanShardsRefused,
 	RunEnvironment: () => RunEnvironment,
 	StageError: () => StageError,
 	StrykerError: () => StrykerError,
 	mutationTestCell: () => mutationTestCell,
 	nodePlatformLayer: () => nodePlatformLayer,
+	planRequest: () => planRequest,
 	strykerCell: () => strykerCell
 });
 //#endregion
@@ -278,7 +861,8 @@ const priorMutantsOf = (text, basePath) => Option.match(S.decodeOption(S.fromJso
 			mutatorName: Mutant_exports.MutatorName.make(mutant.mutatorName),
 			replacement: mutant.replacement ?? mutant.mutatorName,
 			location: mutant.location,
-			relativeFileName
+			relativeFileName,
+			probeEligibility: Mutant_exports.Unprobed.make({ reason: "not-decided" })
 		}));
 	})
 });
@@ -343,7 +927,9 @@ const engineDependencies = [
 	Path.Path,
 	Stdio.Stdio,
 	ChildProcessSpawner.ChildProcessSpawner,
+	EmptyDirectory,
 	GitDiff,
+	SourceParser,
 	WorkerLauncher
 ];
 const ListSurvivors = Tool.make("list_survivors", {
@@ -379,6 +965,25 @@ const ReportUsefulness = Tool.make("report_usefulness", {
 });
 const mcpToolkit = Toolkit.make(ListSurvivors, ShowMutant, RerunMutant, ReportUsefulness);
 //#endregion
+//#region src/Mcp/rerun-stage.handle.ts
+const TypeId$1 = Symbol.for("~systemfsoftware/stryker-js/Mcp/RerunStage");
+const RerunStageHandle = Handle.make()(TypeId$1);
+RerunStageHandle.is;
+const makeRerunStageHandle = (stage) => RerunStageHandle.make({}, stage);
+const run = dual(3, (handle, cell, input) => Cell.provideContext(cell, RerunStageHandle.slot(handle)).run(input));
+//#endregion
+//#region src/Mcp/rerun-stage.blueprint.ts
+const TypeId = Symbol.for("~systemfsoftware/stryker-js/Mcp/RerunStageBlueprint");
+const acquire = Effect.fnUntraced(function* (spec) {
+	const stage = yield* Layer.build(Layer.merge(RunEnvironment.layerStage(spec.environment, spec.events), MachineConsole.layerCapture.pipe(Layer.provide(MachineConsole.layer))));
+	return makeRerunStageHandle(stage);
+});
+const RerunStages = Blueprint.make()(TypeId).steps({
+	steps: {},
+	targets: { scoped: acquire }
+});
+const scoped = (spec) => RerunStages.of(spec).scoped;
+//#endregion
 //#region src/Mcp/mcp-server.cell.ts
 const MCP_RUN_ID = RunEvent_exports$1.RunId.make("01ARZ3NDEKTSV4RRFFQ69G5FAM");
 const REPRODUCERS_FILE = "reports/mutation/reproducers.json";
@@ -431,11 +1036,13 @@ const runRestricted = (basePath, options) => Effect.gen(function* () {
 		builtinReporters: {},
 		allowConsoleColors: false
 	};
-	const runLayer = Layer.merge(RunEnvironment.stage(environment, queue), MachineConsole.captureLayer.pipe(Layer.provide(MachineConsole.layer)));
-	return yield* mutationTestCell.run({
+	return yield* Effect.scoped(Effect.flatMap(scoped({
+		environment,
+		events: queue
+	}), run(mutationTestCell, {
 		cliOptions: options,
 		targetMutatePatterns: void 0
-	}).pipe(Effect.provide(runLayer), Effect.scoped, Effect.orDie);
+	}))).pipe(Effect.orDie);
 });
 const NO_RESULTS = {
 	results: [],
@@ -485,12 +1092,14 @@ const handlers = (basePath) => mcpToolkit.toLayer({
 		reason: reason ?? null
 	})
 });
-const mcpServerLayer = ({ basePath }) => Layer.merge(McpServer.layerStdio({
+const provideEngineToRequests = McpServer.middleware()(Effect.map(Effect.context(), (context) => (effect) => Effect.provideContext(effect, context)));
+const mcpServerLayer = ({ basePath }) => McpServer.layerStdio({
 	name: "stryker",
 	version: StrykerPackage.version,
 	instructions: MCP_SERVER_INSTRUCTIONS,
-	protocols: [McpProtocol.v2025_06_18]
-}), McpServer.toolkit(mcpToolkit)).pipe(Layer.provide(handlers(basePath)), Layer.provide(MachineConsole.layer));
+	protocols: [McpProtocol.v2025_06_18],
+	registrations: McpServer.toolkit(mcpToolkit).pipe(Layer.provide(provideEngineToRequests.layer), Layer.provide(handlers(basePath)))
+}).pipe(Layer.provide(MachineConsole.layer));
 //#endregion
 //#region src/Mcp/mod.ts
 var Mcp_exports = /* @__PURE__ */ __exportAll({
@@ -520,7 +1129,6 @@ var Plugin_exports = /* @__PURE__ */ __exportAll({
 var RunEvent_exports = /* @__PURE__ */ __exportAll({
 	MetricsResultFromReport: () => MetricsResultFromReport,
 	RunEventDrain: () => RunEventDrain,
-	RunEventDrainLive: () => RunEventDrainLive,
 	RunEvents: () => RunEvents,
 	RunIdentity: () => RunIdentity,
 	VerdictEnvelope: () => VerdictEnvelope,
@@ -964,7 +1572,7 @@ const withEngine = (consume, use) => Effect.gen(function* () {
 	const events = yield* Queue.bounded(RunEvent_exports$1.RunEvent.QUEUE_BOUND);
 	const consumer = yield* Stream.fromQueue(events).pipe(Stream.runForEach(consume), Effect.forkChild);
 	return yield* Effect.scoped(Effect.gen(function* () {
-		const context = yield* Layer.build(RunEnvironment.stage(env, events));
+		const context = yield* Layer.build(RunEnvironment.layerStage(env, events));
 		return yield* use({
 			env,
 			context
@@ -1196,4 +1804,4 @@ var Worker_exports = /* @__PURE__ */ __exportAll({
 	makeWorkerClient: () => makeWorkerClient
 });
 //#endregion
-export { Checker_exports as Checker, Configuration_exports as Configuration, Engine_exports as Engine, git_diff_service_exports as GitDiff, git_diff_schema_exports as GitDiffSchema, import_closure_cell_exports as ImportClosure, Mcp_exports as Mcp, Plugin_exports as Plugin, RunEvent_exports as RunEvent, Serve_exports as Serve, Worker_exports as Worker };
+export { Checker_exports as Checker, Configuration_exports as Configuration, Engine_exports as Engine, git_diff_service_exports as GitDiff, git_diff_schema_exports as GitDiffSchema, import_closure_cell_exports as ImportClosure, Mcp_exports as Mcp, Plugin_exports as Plugin, RunEvent_exports as RunEvent, Serve_exports as Serve, source_parser_service_exports as SourceParser, Worker_exports as Worker };