@systemfsoftware/stryker-js 13.0.0 → 14.0.0

package/dist/index.mjs

@@ -1,7 +1,35 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
-import { $ as ConfigDocumentSchema, A as metricsResultFromFiles, B as initialExtendsStepState, C as readConfig, D as RunEvents, E as IdGenerator, F as WorkerLauncher, G as ExtendsStepResolve, H as ExtendsStepDone, I as make, J as ConfigFileNotFoundError, K as ConfigError, L as FileMatcher, M as reporterWorkerFactory, N as spawnReporterWorker, O as RunIdentity, P as makeWorkerClient, Q as defaultOptions, R as decideExtendsStep, S as loadConfigCell, T as RunEnvironment, U as ExtendsStepRead, V as StrykerError, W as ExtendsStepRefused, X as ConfigFileUnsupportedError, Y as ConfigFileUnreadableError, Z as createDefaultOptions, _ as ClassifyWorkerExitCommand, a as isVmRunner, at as ReadConfigCommand, b as describeErrors, c as vmTestRunnerConfig, ct as survivorsPriorReport, d as RunEventDrainLive, dt as OutOfMemoryError, et as ExtendsStepDocumentSchema, f as makeRunEventStream, ft as WorkerBootTimeoutError, g as layerWorkerProtocol, h as nodePlatformLayer, i as makeChildProcessTestRunner, it as MergeResult, j as MetricsResultFromReport, k as VerdictEnvelope, l as isCommandRunner, lt as checkGroupedPlans, m as IncrementalReportSchema, mt as CheckerSkippedRequested, n as strykerCell, nt as ImportedModuleSchema, o as testRunnerConfigOf, ot as extendsPropertySchema, p as RunEventWireLine, pt as CheckerAnsweredUnrequested, q as ConfigFileInvalidError, r as buildTestRunner, rt as MergeCommand, s as vmRunnerPluginUrl, st as forkOptionsSchema, t as mutationTestCell, tt as ExtendsStepStateSchema, u as RunEventDrain, ut as ChildProcessCrashedError, v as ClassifyWorkerExitDecision, w as validateOptions, x as forkCoreSchema, y as classifyWorkerExit, z as importModule } from "./run-stages.cell-BN__EOCk.mjs";
-import { n as mergeConfigs } from "./merge-config-DA_v1hGx.mjs";
-import { C as SkippedFileRow, E as VerdictReached, S as RunStarted, T as VerdictMutant, _ as RunFailed, a as FormatRegistryRow, b as RunPhase, c as Heartbeat, d as PhaseEntered, f as PlanKnown, g as RunEvent, i as FormatRegistryResolved, k as PluginLoadFailureReason, l as HelpRendered, m as PluginsReported, n as StageError, o as FrameworkContributionRow, r as FormatClaimShadowingRow, s as FrameworkModuleRow, w as SkippedReported, y as RunMutantTested } from "./Run.schema-Bj7b_FMA.mjs";
+import { i as Mutant_exports, l as Report_exports, n as mergeConfigs } from "./merge-config-DCQE_2cC.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-CGUzIzPZ.mjs";
+import { n as StageError } from "./Run.schema-DuaneDGd.mjs";
+import { Cell, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
+import * as S from "effect/Schema";
+import * as Option from "effect/Option";
+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 FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Stream from "effect/Stream";
+import * as Clock from "effect/Clock";
+import * as Layer from "effect/Layer";
+import * as Queue from "effect/Queue";
+import "effect/Scope";
+import * as SocketServer from "effect/unstable/socket/SocketServer";
+import * as Fiber from "effect/Fiber";
+import * as DateTime from "effect/DateTime";
+import * as Ref from "effect/Ref";
+import * as Stdio from "effect/Stdio";
+import { NodeSocketServer } from "@effect/platform-node";
+import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
+import * as FiberSet from "effect/FiberSet";
+import * as Socket from "effect/unstable/socket/Socket";
+import { McpProtocol, McpServer, Tool, Toolkit } from "effect/unstable/ai";
 //#region src/Checker/mod.ts
 var Checker_exports = /* @__PURE__ */ __exportAll({
 	CheckerAnsweredUnrequested: () => CheckerAnsweredUnrequested,
@@ -56,6 +84,423 @@ var Engine_exports = /* @__PURE__ */ __exportAll({
 	strykerCell: () => strykerCell
 });
 //#endregion
+//#region src/Feedback/Feedback.schema.ts
+var FeedbackUnusable = class extends S.TaggedError()("FeedbackUnusable", { reason: S.String }) {
+	get message() {
+		return `Cannot record feedback: ${this.reason}`;
+	}
+};
+//#endregion
+//#region src/Feedback/read-report.ts
+const MUTATION_REPORT_FILE = "reports/mutation/mutation.json";
+const FEEDBACK_FILE = "reports/mutation/feedback.jsonl";
+const SURFACING_DEFAULTS = {
+	perLine: 1,
+	perFile: 7
+};
+const capsOf = (fields) => ({
+	perLine: Option.getOrElse(Option.fromNullishOr(fields.perLine), () => SURFACING_DEFAULTS.perLine),
+	perFile: Option.getOrElse(Option.fromNullishOr(fields.perFile), () => SURFACING_DEFAULTS.perFile)
+});
+const surfacingCapsOf = (report) => Option.getOrElse(Option.map(S.decodeUnknownOption(SurfacingFields)(report.config?.["surfacing"]), capsOf), () => SURFACING_DEFAULTS);
+const readMutationReport = (basePath) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const file = (yield* Path.Path).resolve(basePath, MUTATION_REPORT_FILE);
+	const text = yield* fs.readFileString(file).pipe(Effect.mapError(() => FeedbackUnusable.make({ reason: `cannot read the finished mutation report at ${file}; run \`stryker run\` first` })));
+	return yield* Effect.fromResult(Result.mapError(S.decodeResult(S.fromJsonString(Report_exports.MutationTestResult))(text), (error) => FeedbackUnusable.make({ reason: `cannot decode the finished mutation report at ${file}: ${error.message}` })));
+});
+const readSurfacedSurvivors = (basePath) => Effect.map(readMutationReport(basePath), (report) => surfacedSurvivorsOf(report, surfacingCapsOf(report)));
+//#endregion
+//#region src/Feedback/record-feedback.workflow.ts
+const RecordFeedbackTypeId = Symbol.for("@systemfsoftware/stryker-js/RecordFeedbackDecision");
+var FeedbackRecorded = class extends S.TaggedClass()("FeedbackRecorded", {
+	id: Mutant_exports.MutantId,
+	judgment: RunEvent_exports$1.FeedbackJudgment,
+	reason: S.NullOr(S.String)
+}) {
+	[RecordFeedbackTypeId] = RecordFeedbackTypeId;
+};
+var FeedbackRefused = class extends S.TaggedClass()("FeedbackRefused", { id: Mutant_exports.MutantId }) {
+	[RecordFeedbackTypeId] = RecordFeedbackTypeId;
+};
+const RecordFeedbackDecision = S.Union([FeedbackRecorded, FeedbackRefused]);
+var RecordFeedbackCommand = class extends S.Class("RecordFeedbackCommand")({
+	id: Mutant_exports.MutantId,
+	judgment: RunEvent_exports$1.FeedbackJudgment,
+	reason: S.NullOr(S.String),
+	knownIds: S.Array(Mutant_exports.MutantId)
+}) {
+	static [Workflow.InstrumentationBrand] = {};
+};
+const recordedOf = (command) => FeedbackRecorded.make({
+	id: command.id,
+	judgment: command.judgment,
+	reason: command.reason
+});
+const refusedOf = (command) => FeedbackRefused.make({ id: command.id });
+const decidedOf$1 = (command) => Match.value(Arr.contains(command.knownIds, command.id)).pipe(Match.when(true, () => recordedOf(command)), Match.when(false, () => refusedOf(command)), Match.exhaustive);
+const recordFeedback = Workflow.make({
+	command: RecordFeedbackCommand,
+	decision: RecordFeedbackDecision,
+	error: S.Never,
+	decide: (command) => Result.succeed(decidedOf$1(command))
+});
+//#endregion
+//#region src/Feedback/Feedback.cell.ts
+const appendLine = (basePath, line) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const file = path.resolve(basePath, FEEDBACK_FILE);
+	yield* fs.makeDirectory(path.dirname(file), { recursive: true }).pipe(Effect.orDie);
+	yield* fs.writeFileString(file, `${line}\n`, { flag: "a" }).pipe(Effect.orDie);
+});
+const encodeLine = (line) => Effect.orDie(S.encodeEffect(S.fromJsonString(RunEvent_exports$1.FeedbackReported))(line));
+const mutantIdOf = (id) => Effect.fromResult(Result.mapError(S.decodeResult(Mutant_exports.MutantId)(id), () => FeedbackUnusable.make({ reason: `${id} is not a 16-character lowercase hexadecimal mutant id` })));
+const recordFeedbackCell = (request) => Effect.gen(function* () {
+	const id = yield* mutantIdOf(request.id);
+	const survivors = yield* readSurfacedSurvivors(request.basePath);
+	const decision = Result.getOrThrow(recordFeedback(RecordFeedbackCommand.make({
+		id,
+		judgment: request.judgment,
+		reason: request.reason,
+		knownIds: survivors.map((survivor) => survivor.id)
+	})));
+	return yield* Match.value(decision).pipe(Match.tag("FeedbackRecorded", (recorded) => encodeLine(RunEvent_exports$1.FeedbackReported.make({
+		id: recorded.id,
+		judgment: recorded.judgment,
+		reason: recorded.reason
+	})).pipe(Effect.flatMap((line) => appendLine(request.basePath, line)), Effect.as(RunEvent_exports$1.FeedbackReported.make({
+		id: recorded.id,
+		judgment: recorded.judgment,
+		reason: recorded.reason
+	})))), Match.tag("FeedbackRefused", () => Effect.fail(FeedbackUnusable.make({ reason: `no surfaced survivor ${request.id} in the mutation report; run \`stryker run\` first, or read the ids from list_survivors` }))), Match.exhaustive);
+});
+//#endregion
+//#region src/output-mode.schema.ts
+const ResolvedMode = S.Struct({
+	mode: OutputMode_exports.OutputMode,
+	signal: OutputMode_exports.ModeSignal,
+	stdoutIsTTY: S.Boolean
+});
+//#endregion
+//#region src/Rerun/admit-mutant-rerun.workflow.ts
+const MutantRerunTypeId = Symbol.for("@systemfsoftware/stryker-js/MutantRerunAdmission");
+const PriorMutantShape = S.Struct({
+	...Mutant_exports.Mutant.fields,
+	relativeFileName: S.String
+});
+var AdmitMutantRerunCommand = class extends S.Class("AdmitMutantRerunCommand")({
+	ids: S.Array(Mutant_exports.MutantId),
+	priorMutants: S.Array(PriorMutantShape),
+	priorReportPath: S.String
+}) {
+	static [Workflow.InstrumentationBrand] = {};
+};
+var RerunAdmitted = class extends S.TaggedClass()("RerunAdmitted", {
+	ids: S.Array(Mutant_exports.MutantId),
+	mutateSpans: S.Array(S.String)
+}) {
+	[MutantRerunTypeId] = MutantRerunTypeId;
+};
+var RerunRefused = class extends S.TaggedClass()("RerunRefused", {
+	exitClass: S.Literal("ConfigError"),
+	unknownIds: S.Array(Mutant_exports.MutantId),
+	reason: S.String
+}) {
+	[MutantRerunTypeId] = MutantRerunTypeId;
+};
+const MutantRerunAdmission = S.Union([RerunAdmitted, RerunRefused]);
+const spanOf = (mutant) => `${mutant.relativeFileName}:${mutant.location.start.line}:${mutant.location.start.column}-${mutant.location.end.line}:${mutant.location.end.column}`;
+const requestedIdsOf = (command) => Arr.dedupe(command.ids);
+const priorMutantOf = (command, id) => Arr.findFirst(command.priorMutants, (mutant) => mutant.id === id);
+const unknownIdsOf = (command) => Arr.filter(requestedIdsOf(command), (id) => Option.isNone(priorMutantOf(command, id)));
+const mutateSpansOf = (command) => Arr.dedupe(Arr.getSomes(Arr.map(requestedIdsOf(command), (id) => Option.map(priorMutantOf(command, id), spanOf))));
+const refusalOf = (command, unknownIds) => RerunRefused.make({
+	exitClass: "ConfigError",
+	unknownIds,
+	reason: `Unknown mutant id(s): ${Arr.join(unknownIds, ", ")}. None of them appears in the prior mutation report at ${command.priorReportPath}; run \`stryker run\` to write a report that lists the ids you can re-run.`
+});
+const admittedOf = (command) => RerunAdmitted.make({
+	ids: requestedIdsOf(command),
+	mutateSpans: mutateSpansOf(command)
+});
+const decidedOf = (command) => {
+	const unknownIds = unknownIdsOf(command);
+	return Option.match(Arr.head(unknownIds), {
+		onNone: () => admittedOf(command),
+		onSome: () => refusalOf(command, unknownIds)
+	});
+};
+const admitMutantRerun = Workflow.make({
+	command: AdmitMutantRerunCommand,
+	decision: MutantRerunAdmission,
+	error: S.Never,
+	decide: (command) => Result.succeed(decidedOf(command))
+});
+//#endregion
+//#region src/Survivors/Survivors.schema.ts
+const PriorReportDocument = S.Struct({
+	config: S.optional(S.Record(S.String, S.Unknown)),
+	framework: S.optional(S.Struct({ version: S.optional(S.String) })),
+	files: S.Record(S.String, S.Struct({
+		source: S.String,
+		mutants: S.Array(S.Struct({
+			id: Mutant_exports.MutantId,
+			mutatorName: S.String,
+			replacement: S.optional(S.String),
+			status: Mutant_exports.MutantStatusSchema,
+			location: Mutant_exports.Location
+		}))
+	}))
+});
+//#endregion
+//#region src/Rerun/Rerun.cell.ts
+const DEFAULT_PRIOR_REPORT = "reports/mutation/mutation.json";
+const resolveRerunOptions = Effect.fnUntraced(function* (input) {
+	return yield* readConfig(input.cliOptions, {
+		command: "run",
+		mode: input.mode
+	});
+});
+const priorReportText = Effect.fnUntraced(function* (priorReportPath) {
+	return yield* (yield* FileSystem.FileSystem).readFileString(priorReportPath).pipe(Effect.option, Effect.map(Option.getOrElse(() => "")));
+});
+const priorMutantsOf = (text, basePath) => Option.match(S.decodeOption(S.fromJsonString(PriorReportDocument))(text), {
+	onNone: () => [],
+	onSome: (document) => Object.entries(document.files).flatMap(([file, fileResult]) => {
+		const fileName = `${basePath}/${file}`;
+		const relativeFileName = relativeNormalizedFileName(fileName, basePath);
+		return fileResult.mutants.map((mutant) => ({
+			_tag: "Mutant",
+			id: mutant.id,
+			fileName: Mutant_exports.CanonicalFileName.make(fileName),
+			mutatorName: Mutant_exports.MutatorName.make(mutant.mutatorName),
+			replacement: mutant.replacement ?? mutant.mutatorName,
+			location: mutant.location,
+			relativeFileName
+		}));
+	})
+});
+const readMutantRerun = Effect.fnUntraced(function* (input) {
+	const resolvedOptions = yield* resolveRerunOptions({
+		cliOptions: input.cliOptions,
+		mode: input.mode
+	});
+	const priorReportPath = DEFAULT_PRIOR_REPORT;
+	const text = yield* priorReportText(priorReportPath);
+	return {
+		ids: [...input.ids],
+		priorMutants: priorMutantsOf(text, input.basePath),
+		priorReportPath,
+		resolvedOptions,
+		settle: input.settle
+	};
+});
+const mutantRerunAdmissionCell = Sandwich.named(SpanTaxonomy_exports.Spans.rerun.name)(readMutantRerun).decide(admitMutantRerun).write({
+	RerunAdmitted: (admitted, raw) => raw.settle.runAdmitted({
+		ids: admitted.ids,
+		mutateSpans: admitted.mutateSpans,
+		resolvedOptions: raw.resolvedOptions
+	}),
+	RerunRefused: (refused) => Effect.flatMap(S.decodeEffect(RerunRefused)(refused), (decoded) => Effect.fail(decoded)),
+	CommandRejected: ({ issue }) => Effect.fail(RerunRefused.make({
+		exitClass: "ConfigError",
+		unknownIds: [],
+		reason: issue
+	}))
+});
+//#endregion
+//#region src/Mcp/mcp-tools.schema.ts
+const MutantDetail = S.Struct({
+	id: Mutant_exports.MutantId,
+	status: Mutant_exports.MutantStatusSchema,
+	coveringTests: S.Array(S.String),
+	killedBy: S.NullOr(S.String),
+	reproducer: S.String,
+	diff: S.NullOr(S.String)
+});
+var MutantUnusable = class extends S.TaggedError()("MutantUnusable", { id: Mutant_exports.MutantId }) {
+	get message() {
+		return `No mutant ${this.id} in the finished mutation report; run \`stryker run\` first, or read a known id from list_survivors.`;
+	}
+};
+var RerunUnusable = class extends S.TaggedError()("RerunUnusable", {
+	id: Mutant_exports.MutantId,
+	reason: S.String
+}) {
+	get message() {
+		return this.reason;
+	}
+};
+const ShowMutantFailure = S.Union([MutantUnusable, FeedbackUnusable]);
+const RerunMutantFailure = S.Union([MutantUnusable, RerunUnusable]);
+//#endregion
+//#region src/Mcp/mcp-tools.ts
+const reportDependencies = [FileSystem.FileSystem, Path.Path];
+const engineDependencies = [
+	FileSystem.FileSystem,
+	Path.Path,
+	Stdio.Stdio,
+	ChildProcessSpawner.ChildProcessSpawner,
+	GitDiff,
+	WorkerLauncher
+];
+const ListSurvivors = Tool.make("list_survivors", {
+	description: "List the surfaced survivors of the finished mutation report, capped exactly as the CLI caps them: at most one per line and seven per file.",
+	success: S.Array(SurvivorRef),
+	failure: FeedbackUnusable,
+	dependencies: reportDependencies
+});
+const ShowMutant = Tool.make("show_mutant", {
+	description: "Show one mutant's status, covering tests, killing test, reproducer command, and diff against the finished mutation report.",
+	parameters: S.Struct({ id: Mutant_exports.MutantId }),
+	success: MutantDetail,
+	failure: ShowMutantFailure,
+	dependencies: reportDependencies
+});
+const RerunMutant = Tool.make("rerun_mutant", {
+	description: "Re-run one mutant by id through the run pipeline, restricted to that mutant, and report its fresh status, covering tests, killing test, and reproducer.",
+	parameters: S.Struct({ id: Mutant_exports.MutantId }),
+	success: MutantDetail,
+	failure: RerunMutantFailure,
+	dependencies: engineDependencies
+});
+const ReportUsefulness = Tool.make("report_usefulness", {
+	description: "Record a useful or not-useful judgment for one surfaced survivor. The judgment is appended to reports/mutation/feedback.jsonl as a `feedback` stream line.",
+	parameters: S.Struct({
+		id: Mutant_exports.MutantId,
+		judgment: RunEvent_exports$1.FeedbackJudgment,
+		reason: S.String.pipe(S.NullOr, S.optional)
+	}),
+	success: RunEvent_exports$1.FeedbackReported,
+	failure: FeedbackUnusable,
+	dependencies: reportDependencies
+});
+const mcpToolkit = Toolkit.make(ListSurvivors, ShowMutant, RerunMutant, ReportUsefulness);
+//#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";
+const MCP_SERVER_INSTRUCTIONS = "Stryker mutation testing. Use list_survivors to read the surfaced survivors of the finished report, show_mutant to inspect one, rerun_mutant to re-run one through the run pipeline, and report_usefulness to record whether a survivor was worth acting on.";
+const MCP_MODE = ResolvedMode.make({
+	mode: "machine",
+	signal: "tool",
+	stdoutIsTTY: false
+});
+const readReproducers = (basePath) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const reproducerList = S.Array(ReproducerSchema).pipe(S.fromJsonString);
+	const text = yield* fs.readFileString(path.resolve(basePath, REPRODUCERS_FILE)).pipe(Effect.orElseSucceed(() => ""));
+	return Option.getOrElse(S.decodeOption(reproducerList)(text), () => []);
+});
+const diffOf = (reproducers, id) => Option.getOrElse(Option.map(Arr.findFirst(reproducers, (reproducer) => reproducer.id === id), (reproducer) => reproducer.diff), () => null);
+const readDiff = (basePath, id) => Effect.map(readReproducers(basePath), (reproducers) => diffOf(reproducers, id));
+const mutantsOf = (report) => Arr.flatMap(Object.values(report.files), (file) => file.mutants);
+const mutantAt = (report, id) => Arr.findFirst(mutantsOf(report), (mutant) => mutant.id === id);
+const coveringTestsOf = (mutant) => [...mutant.coveredBy ?? []];
+const killedByOf = (mutant) => Option.getOrNull(Arr.head([...mutant.killedBy ?? []]));
+const detailOf = (id, mutant, diff) => ({
+	id,
+	status: mutant.status,
+	coveringTests: coveringTestsOf(mutant),
+	killedBy: killedByOf(mutant),
+	reproducer: `stryker run --mutant ${id}`,
+	diff
+});
+const showMutant = (basePath, id) => Effect.gen(function* () {
+	const report = yield* readMutationReport(basePath);
+	const found = yield* Effect.fromOption(mutantAt(report, id)).pipe(Effect.mapError(() => MutantUnusable.make({ id })));
+	const diff = yield* readDiff(basePath, id);
+	return detailOf(id, found, diff);
+});
+const restrictedOptionsOf = ({ ids, mutateSpans, resolvedOptions }) => ({
+	...resolvedOptions,
+	mutate: [...mutateSpans],
+	mutantIds: [...ids],
+	incremental: true
+});
+const runRestricted = (basePath, options) => Effect.gen(function* () {
+	const queue = yield* Queue.bounded(RunEvent_exports$1.RunEvent.QUEUE_BOUND);
+	const environment = {
+		runId: MCP_RUN_ID,
+		resolvedMode: MCP_MODE,
+		runStartedAt: 0,
+		basePath,
+		builtinReporters: {},
+		allowConsoleColors: false
+	};
+	const runLayer = Layer.merge(RunEnvironment.stage(environment, queue), MachineConsole.captureLayer.pipe(Layer.provide(MachineConsole.layer)));
+	return yield* mutationTestCell.run({
+		cliOptions: options,
+		targetMutatePatterns: void 0
+	}).pipe(Effect.provide(runLayer), Effect.scoped, Effect.orDie);
+});
+const NO_RESULTS = {
+	results: [],
+	verdict: null
+};
+const resultsOf = (settled) => (settled ?? NO_RESULTS).results;
+const reportedOf = (results, id) => Effect.fromOption(Arr.head(mutantDetailEventsOf({
+	requested: Option.some([id]),
+	results
+}))).pipe(Effect.mapError(() => MutantUnusable.make({ id })));
+const reasonOfRerun = (error) => S.is(RerunRefused)(error) ? error.reason : error.message;
+const rerunFailureOf = (id) => (error) => S.is(MutantUnusable)(error) ? error : RerunUnusable.make({
+	id,
+	reason: reasonOfRerun(error)
+});
+const rerunMutant = (basePath, id) => Effect.gen(function* () {
+	const settled = yield* mutantRerunAdmissionCell.run({
+		ids: [id],
+		cliOptions: {},
+		mode: MCP_MODE.mode,
+		basePath,
+		settle: { runAdmitted: ({ ids, mutateSpans, resolvedOptions }) => runRestricted(basePath, restrictedOptionsOf({
+			ids,
+			mutateSpans,
+			resolvedOptions
+		})) }
+	}).pipe(Effect.catchTag("SchemaError", Effect.die), Effect.mapError(rerunFailureOf(id)));
+	const reported = yield* reportedOf(resultsOf(settled), id);
+	const diff = yield* readDiff(basePath, id);
+	return {
+		id: reported.id,
+		status: reported.status,
+		coveringTests: [...reported.coveringTests],
+		killedBy: reported.killedBy,
+		reproducer: reported.reproducer ?? `stryker run --mutant ${id}`,
+		diff
+	};
+});
+const handlers = (basePath) => mcpToolkit.toLayer({
+	list_survivors: () => readSurfacedSurvivors(basePath),
+	show_mutant: ({ id }) => showMutant(basePath, id),
+	rerun_mutant: ({ id }) => rerunMutant(basePath, id),
+	report_usefulness: ({ id, judgment, reason }) => recordFeedbackCell({
+		basePath,
+		id,
+		judgment,
+		reason: reason ?? null
+	})
+});
+const mcpServerLayer = ({ basePath }) => Layer.merge(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));
+//#endregion
+//#region src/Mcp/mod.ts
+var Mcp_exports = /* @__PURE__ */ __exportAll({
+	MutantDetail: () => MutantDetail,
+	MutantUnusable: () => MutantUnusable,
+	RerunMutantFailure: () => RerunMutantFailure,
+	ShowMutantFailure: () => ShowMutantFailure,
+	mcpServerLayer: () => mcpServerLayer,
+	mcpToolkit: () => mcpToolkit
+});
+//#endregion
 //#region src/Plugin/mod.ts
 var Plugin_exports = /* @__PURE__ */ __exportAll({
 	REPORTER_EVENT_BATCH_BOUND: () => 128,
@@ -72,35 +517,668 @@ var Plugin_exports = /* @__PURE__ */ __exportAll({
 //#endregion
 //#region src/RunEvent/mod.ts
 var RunEvent_exports = /* @__PURE__ */ __exportAll({
-	FormatClaimShadowingRow: () => FormatClaimShadowingRow,
-	FormatRegistryResolved: () => FormatRegistryResolved,
-	FormatRegistryRow: () => FormatRegistryRow,
-	FrameworkContributionRow: () => FrameworkContributionRow,
-	FrameworkModuleRow: () => FrameworkModuleRow,
-	Heartbeat: () => Heartbeat,
-	HelpRendered: () => HelpRendered,
 	MetricsResultFromReport: () => MetricsResultFromReport,
-	PhaseEntered: () => PhaseEntered,
-	PlanKnown: () => PlanKnown,
-	PluginLoadFailureReason: () => PluginLoadFailureReason,
-	PluginsReported: () => PluginsReported,
-	RunEvent: () => RunEvent,
 	RunEventDrain: () => RunEventDrain,
 	RunEventDrainLive: () => RunEventDrainLive,
-	RunEventWireLine: () => RunEventWireLine,
 	RunEvents: () => RunEvents,
-	RunFailed: () => RunFailed,
 	RunIdentity: () => RunIdentity,
-	RunMutantTested: () => RunMutantTested,
-	RunPhase: () => RunPhase,
-	RunStarted: () => RunStarted,
-	SkippedFileRow: () => SkippedFileRow,
-	SkippedReported: () => SkippedReported,
 	VerdictEnvelope: () => VerdictEnvelope,
-	VerdictMutant: () => VerdictMutant,
-	VerdictReached: () => VerdictReached,
+	buildVerdictEnvelope: () => buildVerdictEnvelope,
 	makeRunEventStream: () => makeRunEventStream,
-	metricsResultFromFiles: () => metricsResultFromFiles
+	metricsResultFromFiles: () => metricsResultFromFiles,
+	staticVerdictOf: () => staticVerdictOf
+});
+//#endregion
+//#region src/Serve/msp-framing.schema.ts
+var msp_framing_schema_exports = /* @__PURE__ */ __exportAll({
+	CONTENT_LENGTH_HEADER: () => CONTENT_LENGTH_HEADER,
+	FrameAction: () => FrameAction,
+	FramingBuffer: () => FramingBuffer,
+	FramingStep: () => FramingStep,
+	HeaderlessAction: () => HeaderlessAction,
+	IncompleteAction: () => IncompleteAction,
+	decodeUtf8: () => decodeUtf8,
+	emptyFraming: () => emptyFraming,
+	encodeUtf8: () => encodeUtf8,
+	frameOf: () => frameOf,
+	readFrames: () => readFrames
+});
+const CONTENT_LENGTH_HEADER = /content-length:\s*(\d+)/iu;
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+const encodeUtf8 = (text) => textEncoder.encode(text);
+const decodeUtf8 = (bytes) => textDecoder.decode(bytes);
+const FramingBuffer = S.Struct({ bytes: S.Uint8Array });
+const emptyFraming = { bytes: /* @__PURE__ */ new Uint8Array(0) };
+const FramingStep = S.Struct({
+	buffer: FramingBuffer,
+	frames: S.Array(S.String),
+	errors: S.Array(S.String)
+});
+const HEADER_END_BYTES = new Uint8Array([
+	13,
+	10,
+	13,
+	10
+]);
+const HEADERLESS = "a Content-Length header was expected before the message body";
+const concat = (left, right) => {
+	if (left.length === 0) return right;
+	const joined = new Uint8Array(left.length + right.length);
+	joined.set(left, 0);
+	joined.set(right, left.length);
+	return joined;
+};
+const isHeaderEndAt = (bytes, index) => HEADER_END_BYTES.every((byte, offset) => bytes[index + offset] === byte);
+const headerEndOf = (bytes) => Option.map(Option.filter(Option.fromUndefinedOr(bytes.findIndex((_byte, index) => isHeaderEndAt(bytes, index))), (found) => found >= 0), (found) => found + HEADER_END_BYTES.length);
+const declaredLengthOf = (header) => Option.filter(Option.map(Option.fromNullishOr(CONTENT_LENGTH_HEADER.exec(header)), (match) => Number(match[1])), (size) => Number.isSafeInteger(size) && size >= 0);
+const IncompleteAction = S.TaggedStruct("Incomplete", { rest: S.Uint8Array });
+const FrameAction = S.TaggedStruct("Frame", {
+	rest: S.Uint8Array,
+	frame: S.String
+});
+const HeaderlessAction = S.TaggedStruct("Headerless", { rest: S.Uint8Array });
+const bodyActionOf = (bytes, headerEnd, size) => Match.value(bytes.length - headerEnd < size).pipe(Match.when(true, () => IncompleteAction.make({ rest: bytes })), Match.when(false, () => FrameAction.make({
+	rest: bytes.subarray(headerEnd + size),
+	frame: decodeUtf8(bytes.subarray(headerEnd, headerEnd + size))
+})), Match.exhaustive);
+const withinHeader = (bytes, headerEnd) => Option.match(declaredLengthOf(decodeUtf8(bytes.subarray(0, headerEnd))), {
+	onNone: () => HeaderlessAction.make({ rest: bytes.subarray(headerEnd) }),
+	onSome: (size) => bodyActionOf(bytes, headerEnd, size)
+});
+const actionOf = (bytes) => Option.match(headerEndOf(bytes), {
+	onNone: () => IncompleteAction.make({ rest: bytes }),
+	onSome: (headerEnd) => withinHeader(bytes, headerEnd)
+});
+const readStep = (state) => Match.value(actionOf(state.rest)).pipe(Match.tag("Incomplete", () => ({
+	buffer: { bytes: state.rest },
+	frames: state.frames,
+	errors: state.errors
+})), Match.tag("Frame", (frame) => {
+	state.frames.push(frame.frame);
+	return readStep({
+		...state,
+		rest: frame.rest
+	});
+}), Match.tag("Headerless", (headerless) => {
+	state.errors.push(HEADERLESS);
+	return readStep({
+		...state,
+		rest: headerless.rest
+	});
+}), Match.exhaustive);
+const readFrames = dual(2, (buffer, chunk) => readStep({
+	rest: concat(buffer.bytes, chunk),
+	frames: [],
+	errors: []
+}));
+const frameOf = (payload) => {
+	const body = encodeUtf8(payload);
+	return concat(encodeUtf8(`Content-Length: ${body.length}\r\n\r\n`), body);
+};
+//#endregion
+//#region src/Serve/msp.schema.ts
+/**
+* The Mutation Server Protocol payloads this server speaks, as Effect schemas.
+*
+* The shapes are the published ones from `mutation-server-protocol`
+* (stryker-mutator/editor-plugins, `packages/mutation-server-protocol`,
+* published 0.4.1 at commit 47c1ee72b6238620474ec23082369491473d03dd —
+* https://cdn.jsdelivr.net/npm/mutation-server-protocol@0.4.1/README.md):
+* `ConfigureParams`/`ConfigureResult`, `DiscoverParams`/`DiscoverResult`,
+* `MutationTestParams`/`MutationTestResult`, and the
+* `reportMutationTestProgress` notification. Locations reuse the
+* mutation-testing-report schema's 1-based, end-exclusive `Position`/`Location`
+* through `Report`, which is the same base this engine already emits.
+*
+* `MSP_PROTOCOL_VERSION` is the version StrykerJS v10 answers `configure` with
+* (its `StrykerServer.configure` returns `{ version: '0.4.0' }`); the protocol
+* asks the server to name the version it supports, so the answer follows the
+* implementation clients were written against rather than the npm release.
+*
+* The base protocol is JSON-RPC 2.0: a request with an `id` is answered with a
+* matching result or error, a request without one is a notification, and the
+* server may push the progress notification at any time.
+*/
+var msp_schema_exports = /* @__PURE__ */ __exportAll({
+	ConfigureParams: () => ConfigureParams,
+	ConfigureResult: () => ConfigureResult,
+	DiscoverParams: () => DiscoverParams,
+	DiscoverResult: () => DiscoverResult,
+	DiscoveredFile: () => DiscoveredFile,
+	DiscoveredFiles: () => DiscoveredFiles,
+	DiscoveredMutant: () => DiscoveredMutant,
+	FileRange: () => FileRange,
+	JsonRpcErrorObject: () => JsonRpcErrorObject,
+	JsonRpcErrorResponse: () => JsonRpcErrorResponse,
+	JsonRpcId: () => JsonRpcId,
+	JsonRpcRequest: () => JsonRpcRequest,
+	JsonRpcResponse: () => JsonRpcResponse,
+	JsonRpcResultResponse: () => JsonRpcResultResponse,
+	JsonRpcVersion: () => JsonRpcVersion,
+	MSP_INTERNAL_ERROR: () => MSP_INTERNAL_ERROR,
+	MSP_INVALID_PARAMS: () => MSP_INVALID_PARAMS,
+	MSP_INVALID_REQUEST: () => MSP_INVALID_REQUEST,
+	MSP_METHODS: () => MSP_METHODS,
+	MSP_METHOD_NOT_FOUND: () => MSP_METHOD_NOT_FOUND,
+	MSP_PARSE_ERROR: () => MSP_PARSE_ERROR,
+	MSP_PROTOCOL_VERSION: () => MSP_PROTOCOL_VERSION,
+	MSP_SERVER_BUSY: () => MSP_SERVER_BUSY,
+	MspMethod: () => MspMethod,
+	MutationTestParams: () => MutationTestParams,
+	MutationTestResult: () => MutationTestResult,
+	ReportMutationTestProgress: () => ReportMutationTestProgress,
+	ServeError: () => ServeError,
+	decodeConfigureParams: () => decodeConfigureParams,
+	decodeDiscoverParams: () => decodeDiscoverParams,
+	decodeJsonRpcRequest: () => decodeJsonRpcRequest,
+	decodeMutationTestParams: () => decodeMutationTestParams,
+	encodeJsonRpcResponse: () => encodeJsonRpcResponse,
+	encodeProgressNotification: () => encodeProgressNotification,
+	restrictPatternsOf: () => restrictPatternsOf
+});
+var ServeError = class extends S.TaggedError()("ServeError", {
+	reason: S.String,
+	cause: S.optionalKey(S.Unknown)
+}) {
+	get message() {
+		return this.reason;
+	}
+};
+const MSP_PROTOCOL_VERSION = "0.4.0";
+const MSP_METHODS = {
+	configure: "configure",
+	discover: "discover",
+	mutationTest: "mutationTest",
+	reportMutationTestProgress: "reportMutationTestProgress"
+};
+const MspMethod = S.Literals([
+	MSP_METHODS.configure,
+	MSP_METHODS.discover,
+	MSP_METHODS.mutationTest,
+	MSP_METHODS.reportMutationTestProgress
+]);
+const JsonRpcVersion = S.Literal("2.0");
+const JsonRpcId = S.Union([
+	S.String,
+	S.Finite,
+	S.Null
+]);
+const JsonRpcRequest = S.Struct({
+	jsonrpc: JsonRpcVersion,
+	id: S.optionalKey(JsonRpcId),
+	method: S.String,
+	params: S.optionalKey(S.Json)
+});
+const JsonRpcErrorObject = S.Struct({
+	code: S.Int,
+	message: S.String,
+	data: S.optionalKey(S.Json)
+});
+const MSP_PARSE_ERROR = -32700;
+const MSP_INVALID_REQUEST = -32600;
+const MSP_METHOD_NOT_FOUND = -32601;
+const MSP_INVALID_PARAMS = -32602;
+const MSP_INTERNAL_ERROR = -32603;
+const MSP_SERVER_BUSY = -32e3;
+const JsonRpcErrorResponse = S.Struct({
+	jsonrpc: JsonRpcVersion,
+	id: S.NullOr(JsonRpcId),
+	error: JsonRpcErrorObject
+});
+const JsonRpcResultResponse = S.Struct({
+	jsonrpc: JsonRpcVersion,
+	id: JsonRpcId,
+	result: S.Unknown
+});
+const JsonRpcResponse = S.Union([JsonRpcResultResponse, JsonRpcErrorResponse]);
+const FileRange = S.Struct({
+	path: S.String,
+	range: S.optionalKey(Report_exports.Location)
+});
+const ConfigureParams = S.Struct({ configFilePath: S.optionalKey(S.String) });
+const ConfigureResult = S.Struct({ version: S.String });
+const DiscoveredMutant = S.Struct({
+	id: S.String,
+	location: Report_exports.Location,
+	description: S.optionalKey(S.String),
+	mutatorName: S.String,
+	replacement: S.optionalKey(S.String)
+});
+const DiscoveredFile = S.Struct({ mutants: S.Array(DiscoveredMutant) });
+const DiscoveredFiles = S.Record(S.String, DiscoveredFile);
+const FileRanges = S.Array(FileRange);
+const DiscoverParams = S.Struct({ files: FileRanges.pipe(S.optionalKey) });
+const DiscoverResult = S.Struct({ files: DiscoveredFiles });
+const MutationTestParams = S.Struct({
+	files: FileRanges.pipe(S.optionalKey),
+	mutants: S.optionalKey(DiscoveredFiles)
+});
+const MutationTestResult = S.Struct({ files: S.Record(S.String, S.Struct({ mutants: S.Array(Report_exports.MutantResult) })) });
+const ReportMutationTestProgress = S.Struct({
+	jsonrpc: JsonRpcVersion,
+	method: S.Literal(MSP_METHODS.reportMutationTestProgress),
+	params: MutationTestResult
+});
+const encodeJsonRpcResponse = S.encodeResult(S.fromJsonString(JsonRpcResponse));
+const encodeProgressNotification = S.encodeResult(S.fromJsonString(ReportMutationTestProgress));
+const decodeJsonRpcRequest = S.decodeUnknownResult(S.fromJsonString(JsonRpcRequest));
+const decodeConfigureParams = S.decodeUnknownResult(ConfigureParams);
+const decodeDiscoverParams = S.decodeUnknownResult(DiscoverParams);
+const decodeMutationTestParams = S.decodeUnknownResult(MutationTestParams);
+/**
+* The `targetMutatePatterns` this engine takes for a `FileRange` list, or
+* `undefined` when no restriction was asked for. A trailing slash means a
+* directory, matching the protocol.
+*
+* The positions pass through verbatim. This engine compares a range's `end`
+* against a mutant location's `end`, and both of those ends are the report
+* schema's 1-based, exclusive end — the same coordinate space MSP defines for
+* `Location` — so MSP's start-inclusive, end-exclusive range needs no
+* arithmetic here. (StrykerJS v10 subtracts one from both columns instead,
+* because its own mutate ranges are exclusive at the start; copying that would
+* shift this engine's start by a character.)
+*/
+const restrictPatternsOf = (files) => Option.getOrUndefined(Option.map(Option.filter(Option.fromUndefinedOr(files), (scopes) => scopes.length > 0), (scopes) => scopes.map(patternOf)));
+const patternOf = (file) => Option.match(Option.fromUndefinedOr(file.range), {
+	onNone: () => basePatternOf(file.path),
+	onSome: (range) => `${basePatternOf(file.path)}:${rangeTextOf(range)}`
+});
+const basePatternOf = (path) => Match.value(path.endsWith("/")).pipe(Match.when(true, () => `${path}**/*`), Match.when(false, () => path), Match.exhaustive);
+const rangeTextOf = (range) => `${range.start.line}:${range.start.column}-${range.end.line}:${range.end.column}`;
+//#endregion
+//#region src/Serve/msp-protocol.workflow.ts
+const MspDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js/MspDecision");
+var MspConfigureRequested = class extends S.TaggedClass()("MspConfigureRequested", {
+	id: JsonRpcId,
+	configFilePath: S.optionalKey(S.String)
+}) {
+	[MspDecisionTypeId] = MspDecisionTypeId;
+};
+var MspDiscoverRequested = class extends S.TaggedClass()("MspDiscoverRequested", {
+	id: JsonRpcId,
+	params: DiscoverParams
+}) {
+	[MspDecisionTypeId] = MspDecisionTypeId;
+};
+var MspMutationTestRequested = class extends S.TaggedClass()("MspMutationTestRequested", {
+	id: JsonRpcId,
+	params: MutationTestParams
+}) {
+	[MspDecisionTypeId] = MspDecisionTypeId;
+};
+var MspMethodNotFound = class extends S.TaggedClass()("MspMethodNotFound", {
+	id: JsonRpcId,
+	method: S.String
+}) {
+	[MspDecisionTypeId] = MspDecisionTypeId;
+};
+var MspInvalidParams = class extends S.TaggedClass()("MspInvalidParams", {
+	id: JsonRpcId,
+	method: S.String,
+	issue: S.String
+}) {
+	[MspDecisionTypeId] = MspDecisionTypeId;
+};
+var MspRequestBusy = class extends S.TaggedClass()("MspRequestBusy", {
+	id: JsonRpcId,
+	method: S.String
+}) {
+	[MspDecisionTypeId] = MspDecisionTypeId;
+};
+var MspNotificationIgnored = class extends S.TaggedClass()("MspNotificationIgnored", { method: S.String }) {
+	[MspDecisionTypeId] = MspDecisionTypeId;
+};
+var MspRequestCommand = class extends S.TaggedClass()("MspRequestCommand", {
+	id: S.optionalKey(JsonRpcId),
+	method: S.String,
+	params: S.optionalKey(S.Json),
+	busy: S.Boolean
+}) {
+	static [Workflow.InstrumentationBrand] = {};
+};
+const refusedParams = (id, method, issue) => MspInvalidParams.make({
+	id,
+	method,
+	issue: issue.message
+});
+const configured = (id, params) => Result.match(decodeConfigureParams(params), {
+	onFailure: (issue) => Result.succeed(refusedParams(id, MSP_METHODS.configure, issue)),
+	onSuccess: (decoded) => Result.succeed(MspConfigureRequested.make({
+		id,
+		...configFieldsOf(decoded.configFilePath)
+	}))
+});
+const configFieldsOf = (configFilePath) => Option.match(Option.fromUndefinedOr(configFilePath), {
+	onNone: () => ({}),
+	onSome: (path) => ({ configFilePath: path })
+});
+const discovered = (id, params) => Result.match(decodeDiscoverParams(params), {
+	onFailure: (issue) => Result.succeed(refusedParams(id, MSP_METHODS.discover, issue)),
+	onSuccess: (decoded) => Result.succeed(MspDiscoverRequested.make({
+		id,
+		params: decoded
+	}))
+});
+const mutationTest = (id, params) => Result.match(decodeMutationTestParams(params), {
+	onFailure: (issue) => Result.succeed(refusedParams(id, MSP_METHODS.mutationTest, issue)),
+	onSuccess: (decoded) => Result.succeed(MspMutationTestRequested.make({
+		id,
+		params: decoded
+	}))
+});
+const methodOf = (name) => S.decodeUnknownOption(MspMethod)(name);
+const dispatchMethod = (method, command, id) => Match.value(method).pipe(Match.when(MSP_METHODS.configure, () => configured(id, command.params)), Match.when(MSP_METHODS.discover, () => discovered(id, command.params)), Match.when(MSP_METHODS.mutationTest, () => mutationTest(id, command.params)), Match.when(MSP_METHODS.reportMutationTestProgress, () => Result.succeed(MspMethodNotFound.make({
+	id,
+	method: command.method
+}))), Match.exhaustive);
+const decidedForMethod = (command, id) => Option.match(methodOf(command.method), {
+	onNone: () => Result.succeed(MspMethodNotFound.make({
+		id,
+		method: command.method
+	})),
+	onSome: (method) => dispatchMethod(method, command, id)
+});
+const whileRunning = (command, id) => Boolean.match(command.busy, {
+	onTrue: () => Result.succeed(MspRequestBusy.make({
+		id,
+		method: command.method
+	})),
+	onFalse: () => decidedForMethod(command, id)
+});
+const decideMspRequest = (command) => Option.match(Option.fromUndefinedOr(command.id), {
+	onNone: () => Result.succeed(MspNotificationIgnored.make({ method: command.method })),
+	onSome: (id) => whileRunning(command, id)
+});
+const mspProtocol = Workflow.make({
+	command: MspRequestCommand,
+	decision: S.Union([
+		MspConfigureRequested,
+		MspDiscoverRequested,
+		MspMutationTestRequested,
+		MspMethodNotFound,
+		MspInvalidParams,
+		MspRequestBusy,
+		MspNotificationIgnored
+	]),
+	error: S.Never,
+	decide: decideMspRequest
+});
+//#endregion
+//#region src/Serve/Serve.cell.ts
+/**
+* The Mutation Server Protocol server: stdio and socket transports, one run at
+* a time.
+*
+* Each decoded request runs the same engine the CLI runs, restricted by the
+* `mutate` ranges or mutant ids the request named. The socket transport binds
+* loopback unless an explicit `--address` names another interface: the protocol
+* has no authentication and `mutationTest` executes the project's own test
+* code.
+*
+* Only framed JSON-RPC reaches stdout. Engine logging goes to stderr and the
+* protocol run disables reporters, because a reporter would otherwise write
+* human text onto the stream the client is parsing.
+*/
+const HEADLESS_MODE = {
+	mode: "human",
+	signal: "flag",
+	stdoutIsTTY: false
+};
+const PROTOCOL_CLI_OPTIONS = {
+	logLevel: "warn",
+	reporters: []
+};
+const LOOPBACK = "localhost";
+const LOOPBACK_NAMES = [
+	LOOPBACK,
+	"127.0.0.1",
+	"::1",
+	"[::1]"
+];
+const serveEnvironment = (basePath, startedAt) => ({
+	runId: generateRunId(DateTime.makeUnsafe(startedAt)),
+	resolvedMode: HEADLESS_MODE,
+	runStartedAt: startedAt,
+	basePath,
+	builtinReporters: { html: HtmlReporter_exports.makeHtmlReporter },
+	allowConsoleColors: false
+});
+const describe = (failure, fallback) => Option.getOrElse(Option.filter(Option.fromUndefinedOr(failure.message), S.is(S.NonEmptyString)), () => fallback);
+const optionalFieldsOf = (entries) => entries.reduce((fields, [key, value]) => {
+	if (value !== void 0) fields[key] = value;
+	return fields;
+}, {});
+const copiedOrUndefined = (tests) => Option.getOrUndefined(Option.map(Option.fromUndefinedOr(tests), (present) => [...present]));
+const withoutUndefined = (value) => value;
+const bucketOf = (grouped, key) => Option.getOrElse(Option.fromUndefinedOr(grouped.get(key)), () => {
+	const fresh = [];
+	grouped.set(key, fresh);
+	return fresh;
+});
+const withEngine = (consume, use) => Effect.gen(function* () {
+	const basePath = yield* (yield* FileSystem.FileSystem).realPath(".").pipe(Effect.mapError(() => ServeError.make({ reason: "cannot resolve the working directory" })));
+	const startedAt = yield* Clock.currentTimeMillis;
+	const env = serveEnvironment(basePath, startedAt);
+	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));
+		return yield* use({
+			env,
+			context
+		});
+	})).pipe(Effect.ensuring(Queue.end(events).pipe(Effect.andThen(Fiber.join(consumer)), Effect.ignore)));
+});
+const discoverStageCell = Cell.andThen(Cell.andThen(Cell.andThen(loadConfigCell, readProjectCell), prepareCell), Cell.andThen(concurrencyCell, instrumentCell));
+const discoveredFilesOf = (mutants, relativeFileName) => {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const mutant of mutants) bucketOf(grouped, relativeFileName(mutant.fileName)).push({
+		id: mutant.id,
+		location: mutant.location,
+		mutatorName: mutant.mutatorName,
+		...optionalFieldsOf([["replacement", mutant.replacement], ["description", withoutUndefined(mutant.description)]])
+	});
+	return Object.fromEntries([...grouped].map(([fileName, groupedMutants]) => [fileName, { mutants: groupedMutants }]));
+};
+const reportedMutantOf = (result) => Object.assign({
+	id: result.id,
+	location: result.location,
+	mutatorName: result.mutatorName,
+	replacement: result.replacement,
+	status: result.status
+}, optionalFieldsOf([
+	["static", withoutUndefined(result.static)],
+	["coveredBy", copiedOrUndefined(result.coveredBy)],
+	["killedBy", copiedOrUndefined(result.killedBy)],
+	["statusReason", withoutUndefined(result.statusReason)],
+	["testsCompleted", withoutUndefined(result.testsCompleted)],
+	["duration", Option.getOrUndefined(Option.map(Option.fromNullishOr(result.cost), (cost) => cost.testBodyMs))]
+]));
+const mutationTestFilesOf = (results, relativeFileName) => {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const result of results) bucketOf(grouped, relativeFileName(result.fileName)).push(reportedMutantOf(result));
+	return Object.fromEntries([...grouped].map(([fileName, groupedMutants]) => [fileName, { mutants: groupedMutants }]));
+};
+const progressOf = (tested) => ({
+	jsonrpc: "2.0",
+	method: MSP_METHODS.reportMutationTestProgress,
+	params: { files: { [tested.fileName]: { mutants: [Object.assign({
+		id: tested.id,
+		location: tested.location,
+		mutatorName: tested.mutatorName,
+		status: tested.status,
+		static: tested.static
+	}, optionalFieldsOf([
+		["replacement", withoutUndefined(tested.replacement)],
+		["duration", Option.getOrUndefined(Option.map(Option.fromNullishOr(tested.cost), (cost) => cost.testBodyMs))],
+		["testsCompleted", Option.getOrUndefined(Option.map(Option.fromNullishOr(tested.cost), (cost) => cost.testsExecuted))]
+	]))] } } }
+});
+const encodedOr = (encoded, what) => Result.match(encoded, {
+	onFailure: (issue) => ServeError.make({
+		reason: `cannot encode ${what}`,
+		cause: issue
+	}),
+	onSuccess: Effect.succeed
+});
+const optionsOf = (invocation, configFilePath) => Object.assign({
+	...invocation.cliOptions,
+	...PROTOCOL_CLI_OPTIONS
+}, optionalFieldsOf([["configFile", withoutUndefined(configFilePath)]]));
+const mutantIdsOf = (mutants) => Object.values(mutants).flatMap((file) => file.mutants.map((mutant) => mutant.id));
+const withPatterns = (options, patterns) => Option.getOrElse(Option.map(Option.fromUndefinedOr(patterns), (present) => ({
+	...options,
+	mutate: [...present]
+})), () => options);
+const mutationTestOptionsOf = (invocation, configFilePath, params) => Option.match(Option.fromUndefinedOr(params.mutants), {
+	onNone: () => withPatterns(optionsOf(invocation, configFilePath), restrictPatternsOf(params.files)),
+	onSome: (mutants) => ({
+		...optionsOf(invocation, configFilePath),
+		mutate: Object.keys(mutants),
+		mutantIds: mutantIdsOf(mutants)
+	})
+});
+const runDiscover = (options, targetMutatePatterns) => withEngine(() => Effect.void, ({ env, context }) => Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const done = yield* Cell.provideContext(discoverStageCell, context).run({
+		cliOptions: options,
+		targetMutatePatterns: targetMutatePatterns === void 0 ? void 0 : [...targetMutatePatterns]
+	});
+	return { files: discoveredFilesOf(done.mutants, (fileName) => path.relative(env.basePath, fileName)) };
+}).pipe(Effect.mapError((failure) => ServeError.make({
+	reason: describe(failure, "discovery failed"),
+	cause: failure
+}))));
+const runMutationTest = (options, targetMutatePatterns, notify) => withEngine((event) => Match.value(event).pipe(Match.tag("mutantTested", (tested) => notify(tested)), Match.orElse(() => Effect.void)), ({ env, context }) => Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const done = yield* Cell.provideContext(mutationTestCell, context).run({
+		cliOptions: options,
+		targetMutatePatterns: targetMutatePatterns === void 0 ? void 0 : [...targetMutatePatterns]
+	});
+	return { files: mutationTestFilesOf(done.results, (fileName) => path.relative(env.basePath, fileName)) };
+}).pipe(Effect.mapError((failure) => ServeError.make({
+	reason: describe(failure, "the mutation test failed"),
+	cause: failure
+}))));
+const respond = (connection, id, result) => Effect.flatMap(encodedOr(encodeJsonRpcResponse({
+	jsonrpc: "2.0",
+	id,
+	result
+}), "a response"), (payload) => connection.write(payload));
+const respondError = (connection, id, code, message) => Effect.flatMap(encodedOr(encodeJsonRpcResponse({
+	jsonrpc: "2.0",
+	id,
+	error: {
+		code,
+		message
+	}
+}), "an error response"), (payload) => connection.write(payload));
+const notifyProgress = (connection, notification) => Effect.flatMap(encodedOr(encodeProgressNotification(notification), "a progress notification"), (payload) => connection.write(payload));
+const runRequested = (decision, connection, stateRef, invocation) => {
+	const state = Effect.map(Ref.get(stateRef), (current) => current.configFilePath);
+	return Match.value(decision).pipe(Match.tag("MspConfigureRequested", ({ id, configFilePath }) => Effect.andThen(Ref.set(stateRef, { configFilePath }), respond(connection, id, { version: MSP_PROTOCOL_VERSION }))), Match.tag("MspDiscoverRequested", ({ id, params }) => Effect.gen(function* () {
+		const result = yield* Effect.result(runDiscover(optionsOf(invocation, yield* state), restrictPatternsOf(params.files)));
+		yield* Result.match(result, {
+			onFailure: (failure) => respondError(connection, id, MSP_INTERNAL_ERROR, failure.reason),
+			onSuccess: (files) => respond(connection, id, files)
+		});
+	})), Match.tag("MspMutationTestRequested", ({ id, params }) => Effect.gen(function* () {
+		const result = yield* Effect.result(runMutationTest(mutationTestOptionsOf(invocation, yield* state, params), void 0, (tested) => notifyProgress(connection, progressOf(tested))));
+		yield* Result.match(result, {
+			onFailure: (failure) => respondError(connection, id, MSP_INTERNAL_ERROR, failure.reason),
+			onSuccess: (files) => respond(connection, id, files)
+		});
+	})), Match.tag("MspMethodNotFound", ({ id, method }) => respondError(connection, id, MSP_METHOD_NOT_FOUND, `unknown method "${method}"`)), Match.tag("MspInvalidParams", ({ id, method, issue }) => respondError(connection, id, MSP_INVALID_PARAMS, `invalid params for "${method}": ${issue}`)), Match.tag("MspRequestBusy", ({ id }) => respondError(connection, id, MSP_SERVER_BUSY, "a mutation test is already running")), Match.tag("MspNotificationIgnored", () => Effect.void), Match.exhaustive);
+};
+const startsRunOf = (decision) => Match.value(decision).pipe(Match.tag("MspMutationTestRequested", () => true), Match.tag("MspConfigureRequested", () => false), Match.tag("MspDiscoverRequested", () => false), Match.tag("MspMethodNotFound", () => false), Match.tag("MspInvalidParams", () => false), Match.tag("MspRequestBusy", () => false), Match.tag("MspNotificationIgnored", () => false), Match.exhaustive);
+const releaseRun = (busy, startsRun) => Match.value(startsRun).pipe(Match.when(true, () => Ref.set(busy, false)), Match.when(false, () => Effect.void), Match.exhaustive);
+const dispatchRequest = (request, id, connection, stateRef, busy, invocation) => Effect.gen(function* () {
+	const running = yield* Ref.get(busy);
+	const decision = Result.getOrThrow(mspProtocol(MspRequestCommand.make({
+		id,
+		method: request.method,
+		params: request.params,
+		busy: running
+	})));
+	const startsRun = startsRunOf(decision);
+	const wasRunning = yield* Ref.modify(busy, (current) => [current, current || startsRun]);
+	yield* Match.value(wasRunning && startsRun).pipe(Match.when(true, () => respondError(connection, id, MSP_SERVER_BUSY, "a mutation test is already running")), Match.when(false, () => runRequested(decision, connection, stateRef, invocation).pipe(Effect.ensuring(releaseRun(busy, startsRun)))), Match.exhaustive);
+});
+const handleFrame = (raw, connection, stateRef, busy, invocation) => Result.match(decodeJsonRpcRequest(raw), {
+	onFailure: () => respondError(connection, null, MSP_PARSE_ERROR, "the message is not a JSON-RPC 2.0 request"),
+	onSuccess: (request) => Option.match(Option.fromUndefinedOr(request.id), {
+		onNone: () => Effect.void,
+		onSome: (id) => dispatchRequest({
+			method: request.method,
+			params: request.params
+		}, id, connection, stateRef, busy, invocation)
+	})
+});
+const serveConnection = (connection, invocation) => Effect.gen(function* () {
+	const stateRef = yield* Ref.make({ configFilePath: void 0 });
+	const busy = yield* Ref.make(false);
+	const decoder = yield* Ref.make(emptyFraming);
+	const handlers = yield* FiberSet.make();
+	yield* connection.chunks.pipe(Stream.runForEach((chunk) => Effect.gen(function* () {
+		const step = yield* Ref.modify(decoder, (buffer) => {
+			const read = readFrames(buffer, chunk);
+			return [read, read.buffer];
+		});
+		yield* Effect.forEach(step.errors, (error) => respondError(connection, null, MSP_PARSE_ERROR, error), { discard: true });
+		yield* Effect.forEach(step.frames, (frame) => FiberSet.run(handlers, handleFrame(frame, connection, stateRef, busy, invocation)), { discard: true });
+	})));
+	yield* FiberSet.join(handlers);
+});
+const stdioConnection = (stdio) => ({
+	chunks: stdio.stdin.pipe(Stream.catch(() => Stream.empty)),
+	write: (payload) => Stream.run(Stream.succeed(frameOf(payload)), stdio.stdout({ endOnDone: false })).pipe(Effect.mapError(() => ServeError.make({ reason: "cannot write to standard output" })))
+});
+const socketConnection = (socket) => Effect.gen(function* () {
+	const writer = yield* socket.writer;
+	const pull = yield* Socket.readerBytes(socket);
+	return {
+		chunks: Stream.fromEffectRepeat(pull).pipe(Stream.flatMap((batch) => Stream.fromIterable(batch)), Stream.catch(() => Stream.empty)),
+		write: (payload) => writer.writeAll([frameOf(payload)]).pipe(Effect.mapError(() => ServeError.make({ reason: "cannot write to the socket" })))
+	};
+}).pipe(Effect.orDie);
+const writeStderr = (stdio, line) => Stream.run(Stream.succeed(`${line}\n`), stdio.stderr({ endOnDone: false })).pipe(Effect.mapError(() => ServeError.make({ reason: "cannot write to standard error" })));
+const exposureWarning = (address) => `MSP socket mode is listening on ${address}, which is not loopback: the mutation server has no authentication and runs this project's test code, so anyone who can reach that interface can drive it.`;
+const portOf = (invocation) => Option.match(Option.fromUndefinedOr(invocation.port), {
+	onNone: () => ServeError.make({ reason: "the socket channel needs --port" }),
+	onSome: Effect.succeed
+});
+const exposureIfNeeded = (stdio, address) => Match.value(LOOPBACK_NAMES.includes(address)).pipe(Match.when(true, () => Effect.void), Match.when(false, () => writeStderr(stdio, exposureWarning(address))), Match.exhaustive);
+const bindListener = (address, port) => Layer.build(NodeSocketServer.layer({
+	port,
+	host: address
+})).pipe(Effect.mapError((failure) => ServeError.make({
+	reason: `cannot bind ${address}:${port}: ${describe(failure, "the listener failed")}`,
+	cause: failure
+})));
+const serveStdio = (invocation) => Effect.flatMap(Stdio.Stdio, (stdio) => serveConnection(stdioConnection(stdio), invocation));
+const serveSocket = (invocation) => Effect.gen(function* () {
+	const stdio = yield* Stdio.Stdio;
+	const address = Option.getOrElse(Option.fromUndefinedOr(invocation.address), () => LOOPBACK);
+	const port = yield* portOf(invocation);
+	yield* exposureIfNeeded(stdio, address);
+	const serverContext = yield* bindListener(address, port);
+	const server = Context.get(serverContext, SocketServer.SocketServer);
+	yield* writeStderr(stdio, `msp:listening ${String(server.address)}`);
+	const connections = yield* FiberSet.make();
+	return yield* server.run((socket) => FiberSet.run(connections, Effect.scoped(Effect.flatMap(socketConnection(socket), (connection) => serveConnection(connection, invocation))))).pipe(Effect.onInterrupt(() => FiberSet.clear(connections)), Effect.ensuring(FiberSet.clear(connections)), Effect.mapError((failure) => ServeError.make({
+		reason: `the listener failed: ${describe(failure, "unknown cause")}`,
+		cause: failure
+	})));
+});
+const serveMutationServer = (invocation) => Match.value(invocation.channel).pipe(Match.when("stdio", () => serveStdio(invocation)), Match.orElse(() => serveSocket(invocation)));
+//#endregion
+//#region src/Serve/mod.ts
+var Serve_exports = /* @__PURE__ */ __exportAll({
+	Framing: () => msp_framing_schema_exports,
+	Protocol: () => msp_schema_exports,
+	ServeError: () => ServeError,
+	serveMutationServer: () => serveMutationServer
 });
 //#endregion
 //#region src/Worker/mod.ts
@@ -117,4 +1195,4 @@ var Worker_exports = /* @__PURE__ */ __exportAll({
 	makeWorkerClient: () => makeWorkerClient
 });
 //#endregion
-export { Checker_exports as Checker, Configuration_exports as Configuration, Engine_exports as Engine, Plugin_exports as Plugin, RunEvent_exports as RunEvent, 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, Worker_exports as Worker };