@systemfsoftware/stryker-js 13.0.0 → 14.0.0

package/dist/index.d.mts

@@ -1,23 +1,29 @@
-import { c as mod_d_exports$2$2, d as Ignorer, f as Node_2, i as mod_d_exports$4$1, l as mod_d_exports$3$1, n as mod_d_exports$2$1, o as mod_d_exports$6$1, t as mod_d_exports$6, u as Framework } from "./index-C09A80iv.mjs";
-import { a as ImmutablePrimitive, i as Immutable, n as mergeConfigs, o as Primitive } from "./merge-config-X_AxYxMY.mjs";
-import { A as VerdictCounts, C as RunMutantTested, D as RunTerminalEvent, E as RunStarted, M as VerdictReached, O as SkippedFileRow, a as OutputMode, b as RunEvent, c as FormatRegistryResolved, d as FrameworkModuleRow, f as Heartbeat, g as PlanKnown, h as PhaseEntered, i as ModeSignal, j as VerdictMutant, k as SkippedReported, l as FormatRegistryRow, n as StageError, o as ResolvedMode, p as HelpRendered, r as PluginLoadFailureReason, s as FormatClaimShadowingRow, u as FrameworkContributionRow, v as PluginsReported, w as RunPhase, x as RunFailed } from "./Run.schema-BlvpjFjJ.mjs";
-import { $ as ConfigFileNotFoundError, A as ReporterWorkerClient, B as ProjectFile, C as PluginSource, D as TestCoverage, E as SandboxHandle, F as WorkerLauncherShape, G as makeRunEventStream, H as RunEventDrain, I as WorkerSpawnParams, J as RunIdentity, K as ResolvedModeInput, L as SpawnedSocketWorker, M as reporterWorkerFactory, N as spawnReporterWorker, O as REPORTER_EVENT_BATCH_BOUND, P as WorkerLauncher, Q as ConfigFileInvalidError, R as make, S as PluginKind, T as WorkerPluginSource, U as RunEventDrainLive, V as IncrementalReportSchema, W as RunEventStream, X as StrykerError, Y as RunIdentityShape, Z as ConfigError, _ as EvaluatorPluginDescriptor, a as StageServices, at as WorkerBootTimeoutError, b as PluginDescriptor, c as IdGeneratorShape, d as InstrumentDone, et as ConfigFileUnreadableError, f as PrepareDone, g as AnyWorkerPluginSource, h as AnyWorkerPluginDescriptor, i as RunStageServices, it as WorkerBootError, j as SpawnReporterWorkerParams, k as ReporterStage, l as MutationTestDone, m as AnyPluginDescriptor, n as RunEnvironmentShape, nt as ChildProcessCrashedError, o as WiredRunLayer, ot as WorkerExit, p as PrepareExecutorArgs, q as RunEvents, r as EnginePorts, rt as OutOfMemoryError, s as IdGenerator, t as RunEnvironment, tt as ConfigFileUnsupportedError, u as DryRunDone, v as EvaluatorPluginSource, w as WorkerPluginDescriptor, x as PluginDescriptorOf, y as LoadedPlugins, z as Project } from "./RunEnvironment.service-BJAsZsdn.mjs";
+import { c as mod_d_exports$9, i as mod_d_exports$5$1, l as Ignorer, n as mod_d_exports$2$1, o as mod_d_exports$7$1, t as mod_d_exports$8, u as Node_2 } from "./index-C5FRZ4Ni.mjs";
+import { a as ImmutablePrimitive, i as Immutable, n as mergeConfigs, o as Primitive } from "./merge-config-IXgoKiix.mjs";
+import { n as StageError } from "./Run.schema-DErVOVSj.mjs";
+import { $ as makeRunEventStream, A as ReporterWorkerClient, B as ProjectFile, C as PluginSource, D as TestCoverage, E as SandboxHandle, F as WorkerLauncherShape, G as git_diff_service_d_exports, H as mod_d_exports$2$11, I as WorkerSpawnParams, J as RunIdentity, K as git_diff_schema_d_exports, L as SpawnedSocketWorker, M as reporterWorkerFactory, N as spawnReporterWorker, O as REPORTER_EVENT_BATCH_BOUND, P as WorkerLauncher, Q as RunEventStream, R as make, S as PluginKind, T as WorkerPluginSource, U as Framework, V as IncrementalReportSchema, W as GitDiff, X as RunEventDrain, Y as RunIdentityShape, Z as RunEventDrainLive, _ as EvaluatorPluginDescriptor, a as StageServices, at as StrykerError, b as PluginDescriptor, c as IdGeneratorShape, ct as ConfigFileNotFoundError, d as InstrumentDone, dt as ChildProcessCrashedError, et as ResolvedModeInput, f as PrepareDone, ft as OutOfMemoryError, g as AnyWorkerPluginSource, h as AnyWorkerPluginDescriptor, ht as WorkerExit, i as RunStageServices, it as mod_d_exports$1$7, j as SpawnReporterWorkerParams, k as ReporterStage, l as MutationTestDone, lt as ConfigFileUnreadableError, m as AnyPluginDescriptor, mt as WorkerBootTimeoutError, n as RunEnvironmentShape, nt as PhaseClock, o as WiredRunLayer, ot as ConfigError, p as PrepareExecutorArgs, pt as WorkerBootError, q as RunEvents, r as EnginePorts, rt as mod_d_exports$10, s as IdGenerator, st as ConfigFileInvalidError, t as RunEnvironment, tt as ResolvedMode, u as DryRunDone, ut as ConfigFileUnsupportedError, v as EvaluatorPluginSource, w as WorkerPluginDescriptor, x as PluginDescriptorOf, y as LoadedPlugins, z as Project } from "./RunEnvironment.service-C8nNTyKa.mjs";
 import { Blueprint, Cell, Handle, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
 import * as S from "effect/Schema";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 import * as Rpc from "effect/unstable/rpc/Rpc";
 import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
-import "effect/Cause";
+import * as Result from "effect/Result";
+import "effect/Metric";
+import * as Cause from "effect/Cause";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
 import * as Layer from "effect/Layer";
 import "effect/Queue";
 import * as Scope from "effect/Scope";
 import * as RpcClient from "effect/unstable/rpc/RpcClient";
+import "effect/DateTime";
+import * as Stdio from "effect/Stdio";
 import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
 import { RpcClientError } from "effect/unstable/rpc/RpcClientError";
 import * as Socket from "effect/unstable/socket/Socket";
 import { PlatformError } from "effect/PlatformError";
+import { McpServer, Tool, Toolkit } from "effect/unstable/ai";
 //#region src/admit-checker-answer.workflow.d.ts
 declare const CheckerAnsweredUnrequested_base: S.Class<CheckerAnsweredUnrequested, S.TaggedStruct<"CheckerAnsweredUnrequested", {
   readonly checkerName: S.String;
@@ -25,13 +31,17 @@ declare const CheckerAnsweredUnrequested_base: S.Class<CheckerAnsweredUnrequeste
   readonly unrequestedIds: S.$Array<S.String>;
   readonly requestedIds: S.$Array<S.String>;
 }>, import("effect/Cause").YieldableError>;
-declare class CheckerAnsweredUnrequested extends CheckerAnsweredUnrequested_base {}
+declare class CheckerAnsweredUnrequested extends CheckerAnsweredUnrequested_base {
+  get message(): string;
+}
 declare const CheckerSkippedRequested_base: S.Class<CheckerSkippedRequested, S.TaggedStruct<"CheckerSkippedRequested", {
   readonly checkerName: S.String;
   readonly phase: S.Literals<readonly ["check", "group"]>;
   readonly missingIds: S.$Array<S.String>;
 }>, import("effect/Cause").YieldableError>;
-declare class CheckerSkippedRequested extends CheckerSkippedRequested_base {}
+declare class CheckerSkippedRequested extends CheckerSkippedRequested_base {
+  get message(): string;
+}
 type CheckerContractBroken = CheckerAnsweredUnrequested | CheckerSkippedRequested;
 //#endregion
 //#region src/Checker/Checker.handle.d.ts
@@ -45,14 +55,14 @@ type CheckerCrash = ChildProcessCrashedError | OutOfMemoryError;
  * which lets the retry combinator prove it handles every one of them.
  */
 interface CheckerResourceService {
-  readonly check: (checkerName: string, mutants: readonly mod_d_exports$6.CheckerMutantWire[]) => Effect.Effect<Record<string, mod_d_exports$6.CheckResult>, CheckerCrash | mod_d_exports$6.CheckerFailed>;
-  readonly group: (checkerName: string, mutants: readonly mod_d_exports$6.CheckerMutantWire[]) => Effect.Effect<readonly (readonly string[])[], CheckerCrash | mod_d_exports$6.CheckerFailed>;
+  readonly check: (checkerName: string, mutants: readonly mod_d_exports$8.CheckerMutantWire[]) => Effect.Effect<Record<string, mod_d_exports$8.CheckResult>, CheckerCrash | mod_d_exports$8.CheckerFailed>;
+  readonly group: (checkerName: string, mutants: readonly mod_d_exports$8.CheckerMutantWire[]) => Effect.Effect<readonly (readonly string[])[], CheckerCrash | mod_d_exports$8.CheckerFailed>;
 }
 //#endregion
-//#region src/Checker/Checker.cell.d.ts
+//#region src/Checker/Checker.plans.d.ts
 declare const checkGroupedPlans: {
-  (checker: CheckerResourceService, checkerName: string, plans: readonly mod_d_exports$3$1.RunPlan[]): Effect.Effect<readonly (readonly [mod_d_exports$3$1.RunPlan, mod_d_exports$6.CheckResult])[], CheckerCrash | mod_d_exports$6.CheckerFailed | CheckerContractBroken>;
-  (checkerName: string, plans: readonly mod_d_exports$3$1.RunPlan[]): (checker: CheckerResourceService) => Effect.Effect<readonly (readonly [mod_d_exports$3$1.RunPlan, mod_d_exports$6.CheckResult])[], CheckerCrash | mod_d_exports$6.CheckerFailed | CheckerContractBroken>;
+  (checker: CheckerResourceService, checkerName: string, plans: readonly mod_d_exports$2$1.RunPlan[]): Effect.Effect<readonly (readonly [mod_d_exports$2$1.RunPlan, mod_d_exports$8.CheckResult])[], CheckerCrash | mod_d_exports$8.CheckerFailed | CheckerContractBroken>;
+  (checkerName: string, plans: readonly mod_d_exports$2$1.RunPlan[]): (checker: CheckerResourceService) => Effect.Effect<readonly (readonly [mod_d_exports$2$1.RunPlan, mod_d_exports$8.CheckResult])[], CheckerCrash | mod_d_exports$8.CheckerFailed | CheckerContractBroken>;
 };
 declare namespace mod_d_exports {
   export { CheckerAnsweredUnrequested, CheckerContractBroken, CheckerCrash, CheckerResourceService, CheckerSkippedRequested, checkGroupedPlans };
@@ -122,7 +132,9 @@ declare const forkOptionsSchema: S.StructWithRest<S.Struct<{
   readonly ignoreStatic: S.withDecodingDefaultKey<S.Boolean, never>;
   readonly incremental: S.withDecodingDefaultKey<S.Boolean, never>;
   readonly incrementalFile: S.withDecodingDefaultKey<S.String, never>;
+  readonly incrementalSources: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
   readonly progressStreamFile: S.withDecodingDefaultKey<S.String, never>;
+  readonly since: S.optionalKey<S.String>;
   readonly force: S.withDecodingDefaultKey<S.Boolean, never>;
   readonly fileLogLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never>;
   readonly inPlace: S.withDecodingDefaultKey<S.Boolean, never>;
@@ -133,6 +145,11 @@ declare const forkOptionsSchema: S.StructWithRest<S.Struct<{
   readonly mutator: S.withDecodingDefaultKey<S.Struct<{
     readonly excludedMutations: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
     readonly optInMutations: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly mutantSetPolicy: S.withDecodingDefaultKey<S.Literals<readonly ["default", "full"]>, never>;
+  }>, never>;
+  readonly surfacing: S.withDecodingDefaultKey<S.Struct<{
+    readonly perLine: S.withDecodingDefaultKey<S.Int, never>;
+    readonly perFile: S.withDecodingDefaultKey<S.Int, never>;
   }>, never>;
   readonly packageManager: S.optionalKey<S.Literals<readonly ["npm", "yarn", "pnpm"]>>;
   readonly plugins: S.withDecodingDefaultKey<S.$Array<S.declare<string, string>>, never>;
@@ -181,13 +198,14 @@ declare const forkOptionsSchema: S.StructWithRest<S.Struct<{
   readonly allowEmpty: S.withDecodingDefaultKey<S.Boolean, never>;
   readonly ignorers: S.withDecodingDefaultKey<S.$Array<S.declare<string, string>>, never>;
   readonly testFiles: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly mutantIds: S.optionalKey<S.$Array<S.String>>;
   readonly survivorsPriorReport: S.optionalKey<S.String>;
   readonly extends: S.optionalKey<S.String>;
 }>, readonly [S.$Record<S.String, S.Unknown>]>;
 //#endregion
 //#region src/config/default-options.d.ts
-declare const createDefaultOptions: Effect.Effect<mod_d_exports$2$1.StrykerOptions>;
-declare const defaultOptions: Effect.Effect<Immutable<mod_d_exports$2$1.StrykerOptions>, never, never>;
+declare const createDefaultOptions: Effect.Effect<mod_d_exports$5$1.StrykerOptions>;
+declare const defaultOptions: Effect.Effect<Immutable<mod_d_exports$5$1.StrykerOptions>, never, never>;
 //#endregion
 //#region src/run/extends-step.workflow.d.ts
 declare const ExtendsStepDecisionTypeId: unique symbol;
@@ -294,7 +312,9 @@ declare const ConfigFromFile_base: S.Class<ConfigFromFile, S.TaggedStruct<"Confi
     readonly ignoreStatic: S.withDecodingDefaultKey<S.Boolean, never>;
     readonly incremental: S.withDecodingDefaultKey<S.Boolean, never>;
     readonly incrementalFile: S.withDecodingDefaultKey<S.String, never>;
+    readonly incrementalSources: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
     readonly progressStreamFile: S.withDecodingDefaultKey<S.String, never>;
+    readonly since: S.optionalKey<S.String>;
     readonly force: S.withDecodingDefaultKey<S.Boolean, never>;
     readonly fileLogLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never>;
     readonly inPlace: S.withDecodingDefaultKey<S.Boolean, never>;
@@ -305,6 +325,11 @@ declare const ConfigFromFile_base: S.Class<ConfigFromFile, S.TaggedStruct<"Confi
     readonly mutator: S.withDecodingDefaultKey<S.Struct<{
       readonly excludedMutations: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
       readonly optInMutations: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+      readonly mutantSetPolicy: S.withDecodingDefaultKey<S.Literals<readonly ["default", "full"]>, never>;
+    }>, never>;
+    readonly surfacing: S.withDecodingDefaultKey<S.Struct<{
+      readonly perLine: S.withDecodingDefaultKey<S.Int, never>;
+      readonly perFile: S.withDecodingDefaultKey<S.Int, never>;
     }>, never>;
     readonly packageManager: S.optionalKey<S.Literals<readonly ["npm", "yarn", "pnpm"]>>;
     readonly plugins: S.withDecodingDefaultKey<S.$Array<S.declare<string, string>>, never>;
@@ -389,7 +414,9 @@ declare const ConfigFromDefaults_base: S.Class<ConfigFromDefaults, S.TaggedStruc
     readonly ignoreStatic: S.withDecodingDefaultKey<S.Boolean, never>;
     readonly incremental: S.withDecodingDefaultKey<S.Boolean, never>;
     readonly incrementalFile: S.withDecodingDefaultKey<S.String, never>;
+    readonly incrementalSources: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
     readonly progressStreamFile: S.withDecodingDefaultKey<S.String, never>;
+    readonly since: S.optionalKey<S.String>;
     readonly force: S.withDecodingDefaultKey<S.Boolean, never>;
     readonly fileLogLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never>;
     readonly inPlace: S.withDecodingDefaultKey<S.Boolean, never>;
@@ -400,6 +427,11 @@ declare const ConfigFromDefaults_base: S.Class<ConfigFromDefaults, S.TaggedStruc
     readonly mutator: S.withDecodingDefaultKey<S.Struct<{
       readonly excludedMutations: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
       readonly optInMutations: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+      readonly mutantSetPolicy: S.withDecodingDefaultKey<S.Literals<readonly ["default", "full"]>, never>;
+    }>, never>;
+    readonly surfacing: S.withDecodingDefaultKey<S.Struct<{
+      readonly perLine: S.withDecodingDefaultKey<S.Int, never>;
+      readonly perFile: S.withDecodingDefaultKey<S.Int, never>;
     }>, never>;
     readonly packageManager: S.optionalKey<S.Literals<readonly ["npm", "yarn", "pnpm"]>>;
     readonly plugins: S.withDecodingDefaultKey<S.$Array<S.declare<string, string>>, never>;
@@ -461,21 +493,23 @@ type ValidationSchemaDocument<A = unknown> = {
   readonly [key: string]: A;
 };
 //#endregion
-//#region src/run/load-config.cell.d.ts
+//#region src/run/load-config.d.ts
 interface ConfigInvocation {
   readonly command: 'run' | 'merge-reports';
-  readonly mode: OutputMode;
+  readonly mode: mod_d_exports$10.OutputMode;
 }
 declare const forkCoreSchema: import("effect/JsonSchema").JsonSchema;
 declare const describeErrors: (error: S.SchemaError) => readonly string[];
 declare const readConfig: {
-  (invocation: ConfigInvocation): (cliOptions: mod_d_exports$2$1.PartialStrykerOptions) => Effect.Effect<mod_d_exports$2$1.StrykerOptions, ConfigReadError, FileSystem.FileSystem | Path.Path>;
-  (cliOptions: mod_d_exports$2$1.PartialStrykerOptions, invocation: ConfigInvocation): Effect.Effect<mod_d_exports$2$1.StrykerOptions, ConfigReadError, FileSystem.FileSystem | Path.Path>;
+  (invocation: ConfigInvocation): (cliOptions: mod_d_exports$5$1.PartialStrykerOptions) => Effect.Effect<mod_d_exports$5$1.StrykerOptions, ConfigReadError, FileSystem.FileSystem | Path.Path>;
+  (cliOptions: mod_d_exports$5$1.PartialStrykerOptions, invocation: ConfigInvocation): Effect.Effect<mod_d_exports$5$1.StrykerOptions, ConfigReadError, FileSystem.FileSystem | Path.Path>;
 };
+//#endregion
+//#region src/run/load-config.cell.d.ts
 declare const loadConfigCell: Sandwich.WrittenFrom<{
-  readonly cliOptions: mod_d_exports$2$1.PartialStrykerOptions;
+  readonly cliOptions: mod_d_exports$5$1.PartialStrykerOptions;
   readonly targetMutatePatterns: readonly string[] | undefined;
-}, ConfigReadError, FileSystem.FileSystem | Path.Path | RunEnvironment | RunEvents, S.Union<readonly [typeof ConfigFromFile, typeof ConfigFromDefaults]>, {
+}, ConfigReadError, import("effect/FileSystem").FileSystem | import("effect/Path").Path | PhaseClock | RunEnvironment | RunEvents, import("effect/Schema").Union<readonly [typeof ConfigFromFile, typeof ConfigFromDefaults]>, {
   ConfigFromFile: ({ options }: {
     readonly _tag: "ConfigFromFile";
     readonly options: {
@@ -512,7 +546,9 @@ declare const loadConfigCell: Sandwich.WrittenFrom<{
       readonly ignoreStatic: boolean;
       readonly incremental: boolean;
       readonly incrementalFile: string;
+      readonly incrementalSources: readonly string[];
       readonly progressStreamFile: string;
+      readonly since?: string;
       readonly force: boolean;
       readonly fileLogLevel: "debug" | "error" | "fatal" | "info" | "off" | "trace" | "warn";
       readonly inPlace: boolean;
@@ -523,6 +559,11 @@ declare const loadConfigCell: Sandwich.WrittenFrom<{
       readonly mutator: {
         readonly excludedMutations: readonly string[];
         readonly optInMutations: readonly string[];
+        readonly mutantSetPolicy: "default" | "full";
+      };
+      readonly surfacing: {
+        readonly perLine: number;
+        readonly perFile: number;
       };
       readonly packageManager?: "npm" | "pnpm" | "yarn";
       readonly plugins: readonly string[];
@@ -610,7 +651,9 @@ declare const loadConfigCell: Sandwich.WrittenFrom<{
       readonly ignoreStatic: boolean;
       readonly incremental: boolean;
       readonly incrementalFile: string;
+      readonly incrementalSources: readonly string[];
       readonly progressStreamFile: string;
+      readonly since?: string;
       readonly force: boolean;
       readonly fileLogLevel: "debug" | "error" | "fatal" | "info" | "off" | "trace" | "warn";
       readonly inPlace: boolean;
@@ -621,6 +664,11 @@ declare const loadConfigCell: Sandwich.WrittenFrom<{
       readonly mutator: {
         readonly excludedMutations: readonly string[];
         readonly optInMutations: readonly string[];
+        readonly mutantSetPolicy: "default" | "full";
+      };
+      readonly surfacing: {
+        readonly perLine: number;
+        readonly perFile: number;
       };
       readonly packageManager?: "npm" | "pnpm" | "yarn";
       readonly plugins: readonly string[];
@@ -704,7 +752,9 @@ declare const loadConfigCell: Sandwich.WrittenFrom<{
       readonly ignoreStatic: boolean;
       readonly incremental: boolean;
       readonly incrementalFile: string;
+      readonly incrementalSources: readonly string[];
       readonly progressStreamFile: string;
+      readonly since?: string;
       readonly force: boolean;
       readonly fileLogLevel: "debug" | "error" | "fatal" | "info" | "off" | "trace" | "warn";
       readonly inPlace: boolean;
@@ -715,6 +765,11 @@ declare const loadConfigCell: Sandwich.WrittenFrom<{
       readonly mutator: {
         readonly excludedMutations: readonly string[];
         readonly optInMutations: readonly string[];
+        readonly mutantSetPolicy: "default" | "full";
+      };
+      readonly surfacing: {
+        readonly perLine: number;
+        readonly perFile: number;
       };
       readonly packageManager?: "npm" | "pnpm" | "yarn";
       readonly plugins: readonly string[];
@@ -802,7 +857,9 @@ declare const loadConfigCell: Sandwich.WrittenFrom<{
       readonly ignoreStatic: boolean;
       readonly incremental: boolean;
       readonly incrementalFile: string;
+      readonly incrementalSources: readonly string[];
       readonly progressStreamFile: string;
+      readonly since?: string;
       readonly force: boolean;
       readonly fileLogLevel: "debug" | "error" | "fatal" | "info" | "off" | "trace" | "warn";
       readonly inPlace: boolean;
@@ -813,6 +870,11 @@ declare const loadConfigCell: Sandwich.WrittenFrom<{
       readonly mutator: {
         readonly excludedMutations: readonly string[];
         readonly optInMutations: readonly string[];
+        readonly mutantSetPolicy: "default" | "full";
+      };
+      readonly surfacing: {
+        readonly perLine: number;
+        readonly perFile: number;
       };
       readonly packageManager?: "npm" | "pnpm" | "yarn";
       readonly plugins: readonly string[];
@@ -863,10 +925,12 @@ declare const loadConfigCell: Sandwich.WrittenFrom<{
   ConfigOptionsRefused: ({ message }: {
     readonly _tag: "ConfigOptionsRefused";
     readonly message: string;
-  }) => Effect.Effect<never, ConfigError, RunEnvironment | RunEvents>;
-  CommandRejected: ({ issue }: Sandwich.CommandRejected) => Effect.Effect<never, ConfigError, RunEnvironment | RunEvents>;
+  }) => Effect.Effect<never, ConfigError, PhaseClock | RunEnvironment | RunEvents>;
+  CommandRejected: ({ issue }: Sandwich.CommandRejected) => Effect.Effect<never, ConfigError, PhaseClock | RunEnvironment | RunEvents>;
 }>;
-declare const validateOptions: (<A = unknown>(schema: ValidationSchemaDocument) => (options: Record<string, A>) => Effect.Effect<mod_d_exports$2$1.StrykerOptions, ConfigError>) & (<A = unknown>(options: Record<string, A>, schema: ValidationSchemaDocument) => Effect.Effect<mod_d_exports$2$1.StrykerOptions, ConfigError>);
+//#endregion
+//#region src/run/validate-options.d.ts
+declare const validateOptions: (<A = unknown>(schema: ValidationSchemaDocument) => (options: Record<string, A>) => Effect.Effect<mod_d_exports$5$1.StrykerOptions, ConfigError>) & (<A = unknown>(options: Record<string, A>, schema: ValidationSchemaDocument) => Effect.Effect<mod_d_exports$5$1.StrykerOptions, ConfigError>);
 declare namespace mod_d_exports$1 {
   export { ConfigDocumentSchema, ConfigError, ConfigFileInvalidError, ConfigFileNotFoundError, ConfigFileUnreadableError, ConfigFileUnsupportedError, ConfigInvocation, ExtendsRefusalReason, ExtendsStepDecision, ExtendsStepDocument, ExtendsStepDocumentSchema, ExtendsStepDone, ExtendsStepRead, ExtendsStepRefused, ExtendsStepResolve, ExtendsStepState, ExtendsStepStateSchema, FileMatcher, Immutable, ImmutablePrimitive, ImportedModuleSchema, MergeCommand, MergeResult, Primitive, ReadConfigCommand, ValidationSchemaDocument, createDefaultOptions, decideExtendsStep, defaultOptions, describeErrors, extendsPropertySchema, forkCoreSchema, forkOptionsSchema, importModule, initialExtendsStepState, loadConfigCell, mergeConfigs, readConfig, survivorsPriorReport, validateOptions };
 }
@@ -875,46 +939,165 @@ declare namespace mod_d_exports$1 {
 declare const nodePlatformLayer: Layer.Layer<EnginePorts>;
 //#endregion
 //#region src/run/host.service.d.ts
-type StrykerRun = (options: mod_d_exports$2$1.PartialStrykerOptions, targetMutatePatterns?: string[]) => Effect.Effect<MutationTestDone, StageError, never>;
+type StrykerRun = (options: mod_d_exports$5$1.PartialStrykerOptions, targetMutatePatterns?: string[]) => Effect.Effect<MutationTestDone, StageError, never>;
 //#endregion
 //#region src/run/run-stages.cell.d.ts
 declare const mutationTestCell: Cell.Cell<PrepareExecutorArgs, MutationTestDone, StageError, StageServices>;
+//#endregion
+//#region src/run/run-stages.d.ts
 declare const strykerCell: {
-  (options: mod_d_exports$2$1.PartialStrykerOptions, targetMutatePatterns?: readonly string[]): Effect.Effect<MutationTestDone, StageError | PlatformError, EnginePorts>;
-  (targetMutatePatterns?: readonly string[]): (options: mod_d_exports$2$1.PartialStrykerOptions) => Effect.Effect<MutationTestDone, StageError | PlatformError, EnginePorts>;
+  (options: mod_d_exports$5$1.PartialStrykerOptions, targetMutatePatterns?: readonly string[]): Effect.Effect<MutationTestDone, StageError | PlatformError, EnginePorts>;
+  (targetMutatePatterns?: readonly string[]): (options: mod_d_exports$5$1.PartialStrykerOptions) => Effect.Effect<MutationTestDone, StageError | PlatformError, EnginePorts>;
 };
 declare namespace mod_d_exports$2 {
   export { DryRunDone, EnginePorts, IdGenerator, IdGeneratorShape, IncrementalReportSchema, InstrumentDone, MutationTestDone, PrepareDone, PrepareExecutorArgs, Project, ProjectFile, RunEnvironment, RunEnvironmentShape, RunStageServices, SandboxHandle, StageError, StageServices, StrykerError, StrykerRun, TestCoverage, WiredRunLayer, mutationTestCell, nodePlatformLayer, strykerCell };
 }
+declare namespace import_closure_cell_d_exports {
+  export { ImportClosureAnalysis, ImportClosureInput, TestFileClosureDigest, analyzeImportClosure };
+}
+interface ImportClosureInput {
+  readonly rootDir: string;
+  readonly projectFiles: readonly string[];
+  readonly testFiles: readonly string[];
+  readonly globalInputs?: readonly string[];
+}
+interface TestFileClosureDigest {
+  readonly testFile: string;
+  readonly files: readonly string[];
+  readonly open: boolean;
+  readonly digest: string;
+}
+interface ImportClosureAnalysis {
+  readonly closures: readonly TestFileClosureDigest[];
+  readonly projectDigest: string;
+}
+declare const analyzeImportClosure: (input: ImportClosureInput) => Effect.Effect<ImportClosureAnalysis, PlatformError, FileSystem.FileSystem | Path.Path>;
+//#endregion
+//#region src/Mcp/mcp-server.cell.d.ts
+interface McpServerOptions {
+  readonly basePath: string;
+}
+declare const mcpServerLayer: ({ basePath }: McpServerOptions) => Layer.Layer<McpServer.McpServer | import("effect/unstable/ai/McpSchema").McpServerClient, Cause.IllegalArgumentError, import("effect/Stdio").Stdio>;
+//#endregion
+//#region src/Feedback/Feedback.schema.d.ts
+declare const FeedbackUnusable_base: S.Class<FeedbackUnusable, S.TaggedStruct<"FeedbackUnusable", {
+  readonly reason: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class FeedbackUnusable extends FeedbackUnusable_base {
+  get message(): string;
+}
+//#endregion
+//#region src/Mcp/mcp-tools.schema.d.ts
+declare const MutantDetail: S.Struct<{
+  readonly id: S.brand<S.String, "MutantId">;
+  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+  readonly coveringTests: S.$Array<S.String>;
+  readonly killedBy: S.NullOr<S.String>;
+  readonly reproducer: S.String;
+  readonly diff: S.NullOr<S.String>;
+}>;
+type MutantDetail = typeof MutantDetail.Type;
+declare const MutantUnusable_base: S.Class<MutantUnusable, S.TaggedStruct<"MutantUnusable", {
+  readonly id: S.brand<S.String, "MutantId">;
+}>, import("effect/Cause").YieldableError>;
+declare class MutantUnusable extends MutantUnusable_base {
+  get message(): string;
+}
+declare const RerunUnusable_base: S.Class<RerunUnusable, S.TaggedStruct<"RerunUnusable", {
+  readonly id: S.brand<S.String, "MutantId">;
+  readonly reason: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class RerunUnusable extends RerunUnusable_base {
+  get message(): string;
+}
+declare const ShowMutantFailure: S.Union<readonly [typeof MutantUnusable, typeof FeedbackUnusable]>;
+declare const RerunMutantFailure: S.Union<readonly [typeof MutantUnusable, typeof RerunUnusable]>;
+//#endregion
+//#region src/Mcp/mcp-tools.d.ts
+declare const mcpToolkit: Toolkit.Toolkit<{
+  readonly list_survivors: Tool.Tool<"list_survivors", {
+    readonly parameters: Tool.EmptyParams;
+    readonly success: S.$Array<S.Struct<{
+      readonly id: S.brand<S.String, "MutantId">;
+      readonly fileName: S.String;
+      readonly line: S.Int;
+    }>>;
+    readonly failure: typeof FeedbackUnusable;
+    readonly failureMode: "error";
+  }, FileSystem.FileSystem | Path.Path>;
+  readonly report_usefulness: Tool.Tool<"report_usefulness", {
+    readonly parameters: S.Struct<{
+      readonly id: S.brand<S.String, "MutantId">;
+      readonly judgment: S.Literals<readonly ["useful", "not-useful"]>;
+      readonly reason: S.optional<S.NullOr<S.String>>;
+    }>;
+    readonly success: typeof mod_d_exports$1$7.FeedbackReported;
+    readonly failure: typeof FeedbackUnusable;
+    readonly failureMode: "error";
+  }, FileSystem.FileSystem | Path.Path>;
+  readonly rerun_mutant: Tool.Tool<"rerun_mutant", {
+    readonly parameters: S.Struct<{
+      readonly id: S.brand<S.String, "MutantId">;
+    }>;
+    readonly success: S.Struct<{
+      readonly id: S.brand<S.String, "MutantId">;
+      readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+      readonly coveringTests: S.$Array<S.String>;
+      readonly killedBy: S.NullOr<S.String>;
+      readonly reproducer: S.String;
+      readonly diff: S.NullOr<S.String>;
+    }>;
+    readonly failure: S.Union<readonly [typeof MutantUnusable, typeof RerunUnusable]>;
+    readonly failureMode: "error";
+  }, ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | GitDiff | Path.Path | Stdio.Stdio | WorkerLauncher>;
+  readonly show_mutant: Tool.Tool<"show_mutant", {
+    readonly parameters: S.Struct<{
+      readonly id: S.brand<S.String, "MutantId">;
+    }>;
+    readonly success: S.Struct<{
+      readonly id: S.brand<S.String, "MutantId">;
+      readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+      readonly coveringTests: S.$Array<S.String>;
+      readonly killedBy: S.NullOr<S.String>;
+      readonly reproducer: S.String;
+      readonly diff: S.NullOr<S.String>;
+    }>;
+    readonly failure: S.Union<readonly [typeof MutantUnusable, typeof FeedbackUnusable]>;
+    readonly failureMode: "error";
+  }, FileSystem.FileSystem | Path.Path>;
+}>;
+declare namespace mod_d_exports$3 {
+  export { McpServerOptions, MutantDetail, MutantUnusable, RerunMutantFailure, ShowMutantFailure, mcpServerLayer, mcpToolkit };
+}
 //#endregion
 //#region src/TestRunner.schema.d.ts
-type PooledTestRunnerError = mod_d_exports$6$1.TestRunnerFailed | ChildProcessCrashedError | OutOfMemoryError;
+type PooledTestRunnerError = mod_d_exports$9.TestRunnerFailed | ChildProcessCrashedError | OutOfMemoryError;
 //#endregion
 //#region src/pooled-test-runner.handle.d.ts
 declare const TypeId: unique symbol;
 type TypeId = typeof TypeId;
 declare const PooledTestRunner: Handle.Definition<typeof TypeId, {
-  readonly capabilities: Effect.Effect<mod_d_exports$6$1.TestRunnerCapabilities, PooledTestRunnerError>;
+  readonly capabilities: Effect.Effect<mod_d_exports$9.TestRunnerCapabilities, PooledTestRunnerError>;
   readonly init: Effect.Effect<void, PooledTestRunnerError>;
-  readonly dryRun: (options: mod_d_exports$6$1.DryRunOptions) => Effect.Effect<mod_d_exports$6$1.DryRunResult, PooledTestRunnerError>;
-  readonly mutantRun: (options: mod_d_exports$3$1.MutantRunOptions) => Effect.Effect<mod_d_exports$6$1.MutantRunResult, PooledTestRunnerError>;
+  readonly dryRun: (options: mod_d_exports$9.DryRunOptions) => Effect.Effect<mod_d_exports$9.DryRunResult, PooledTestRunnerError>;
+  readonly mutantRun: (options: mod_d_exports$2$1.MutantRunOptions) => Effect.Effect<mod_d_exports$9.MutantRunResult, PooledTestRunnerError>;
 }, never, never>;
 type PooledTestRunner = Handle.Of<typeof PooledTestRunner>;
 //#endregion
 //#region src/command-runner.blueprint.d.ts
-declare const isCommandRunner: (name: mod_d_exports$2$1.TestRunnerConfig) => name is 'command';
+declare const isCommandRunner: (name: mod_d_exports$5$1.TestRunnerConfig) => name is 'command';
 //#endregion
 //#region src/TestRunner.blueprint.d.ts
 interface ChildProcessTestRunnerParams {
-  readonly options: mod_d_exports$2$1.StrykerOptions;
-  readonly fileDescriptions: mod_d_exports$2$2.FileDescriptions;
+  readonly options: mod_d_exports$5$1.StrykerOptions;
+  readonly fileDescriptions: mod_d_exports$2$11.FileDescriptions;
   readonly sandboxWorkingDirectory: string;
   readonly workerEntrypoint: string;
   readonly idGenerator: IdGeneratorShape;
 }
 interface TestRunnerBuildContext {
-  readonly options: mod_d_exports$2$1.StrykerOptions;
-  readonly fileDescriptions: mod_d_exports$2$2.FileDescriptions;
+  readonly options: mod_d_exports$5$1.StrykerOptions;
+  readonly fileDescriptions: mod_d_exports$2$11.FileDescriptions;
   readonly sandboxWorkingDirectory: string;
   readonly idGenerator: IdGeneratorShape;
   readonly retire: Effect.Effect<void>;
@@ -929,98 +1112,436 @@ declare const buildTestRunner: {
 //#region src/vm-runner.d.ts
 declare const vmRunnerName = "vm";
 declare const vmRunnerPluginUrl: () => string;
-declare const isVmRunner: (name: mod_d_exports$2$1.TestRunnerConfig) => name is typeof vmRunnerName;
-declare const vmTestRunnerConfig: () => mod_d_exports$2$1.TestRunnerCustomConfig;
-declare const testRunnerConfigOf: (configured: mod_d_exports$2$1.TestRunnerConfig) => mod_d_exports$2$1.TestRunnerConfig;
-declare namespace mod_d_exports$3 {
+declare const isVmRunner: (name: mod_d_exports$5$1.TestRunnerConfig) => name is typeof vmRunnerName;
+declare const vmTestRunnerConfig: () => mod_d_exports$5$1.TestRunnerCustomConfig;
+declare const testRunnerConfigOf: (configured: mod_d_exports$5$1.TestRunnerConfig) => mod_d_exports$5$1.TestRunnerConfig;
+declare namespace mod_d_exports$4 {
   export { AnyPluginDescriptor, AnyWorkerPluginDescriptor, AnyWorkerPluginSource, EvaluatorPluginDescriptor, EvaluatorPluginSource, Framework, Ignorer, LoadedPlugins, Node_2 as Node, PluginDescriptor, PluginDescriptorOf, PluginKind, PluginSource, PooledTestRunner, PooledTestRunnerError, REPORTER_EVENT_BATCH_BOUND, ReporterStage, ReporterWorkerClient, SpawnReporterWorkerParams, TestRunnerBuildContext, WorkerPluginDescriptor, WorkerPluginSource, buildTestRunner, isCommandRunner, isVmRunner, makeChildProcessTestRunner, reporterWorkerFactory, spawnReporterWorker, testRunnerConfigOf, vmRunnerPluginUrl, vmTestRunnerConfig };
 }
 //#endregion
 //#region src/reporting/metrics-from-report.schema.d.ts
 declare const MetricsResultFromReport_base: S.Class<MetricsResultFromReport, S.Struct<{
   readonly name: S.String;
-  readonly metrics: typeof mod_d_exports$4$1.Metrics;
-  readonly childResults: S.$Array<S.suspend<S.Codec<mod_d_exports$4$1.MetricsResult, mod_d_exports$4$1.MetricsResultEncoded, never, never>>>;
-}>, mod_d_exports$4$1.MetricsResultEncoded>;
+  readonly metrics: typeof mod_d_exports$7$1.Metrics;
+  readonly childResults: S.$Array<S.suspend<S.Codec<mod_d_exports$7$1.MetricsResult, mod_d_exports$7$1.MetricsResultEncoded, never, never>>>;
+}>, mod_d_exports$7$1.MetricsResultEncoded>;
 declare class MetricsResultFromReport extends MetricsResultFromReport_base {}
 //#endregion
 //#region src/reporting/metrics-from-report.d.ts
-type Files = Readonly<Record<string, mod_d_exports$4$1.FileResult>>;
+type Files = Readonly<Record<string, mod_d_exports$7$1.FileResult>>;
 declare const metricsResultFromFiles: (files: Files) => MetricsResultFromReport;
 //#endregion
+//#region src/reporting/static-verdict.d.ts
+declare const staticVerdictOf: (results: readonly mod_d_exports$2$1.RunMutantResult[]) => mod_d_exports$1$7.StaticVerdict | null;
+//#endregion
 //#region src/reporting/verdict-envelope.schema.d.ts
 declare const VerdictEnvelope_base: S.Class<VerdictEnvelope, S.Struct<{
-  readonly schemaVersion: S.Literal<"1.1">;
+  readonly schemaVersion: S.Literal<"2.0">;
   readonly runId: S.brand<S.String, "RunId">;
   readonly mode: S.Literals<readonly ["human", "machine"]>;
   readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
   readonly score: S.NullOr<S.Finite>;
-  readonly thresholds: S.declare<{
-    readonly high: number;
-    readonly low: number;
-    readonly break: number | null;
-  }, {
-    readonly high: number;
-    readonly low: number;
-    readonly break: number | null;
+  readonly thresholds: S.Struct<{
+    readonly high: S.Finite;
+    readonly low: S.Finite;
+    readonly break: S.NullOr<S.Finite>;
   }>;
-  readonly counts: typeof mod_d_exports$4$1.Metrics;
+  readonly counts: typeof mod_d_exports$7$1.Metrics;
   readonly reportFile: S.NullOr<S.decodeTo<S.brand<S.String, "CanonicalFileName">, S.String, never, never>>;
   readonly mutants: S.$Array<S.Struct<{
-    readonly id: S.brand<S.String, "MutantId">;
+    readonly id: S.String;
     readonly file: S.String;
-    readonly location: S.declare<{
-      readonly start: {
-        readonly line: number;
-        readonly column: number;
-      };
-      readonly end: {
-        readonly line: number;
-        readonly column: number;
-      };
-    }, {
-      readonly start: {
-        readonly line: number;
-        readonly column: number;
-      };
-      readonly end: {
-        readonly line: number;
-        readonly column: number;
-      };
+    readonly location: S.Struct<{
+      readonly start: S.Struct<{
+        readonly line: S.Int;
+        readonly column: S.Int;
+      }>;
+      readonly end: S.Struct<{
+        readonly line: S.Int;
+        readonly column: S.Int;
+      }>;
     }>;
     readonly mutator: S.String;
     readonly replacement: S.NullOr<S.String>;
     readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
   }>>;
+  readonly scope: S.Literals<readonly ["full", "diff"]>;
+  readonly mutantSetPolicy: S.Literals<readonly ["default", "full"]>;
+  readonly phaseDurations: S.NullOr<S.Struct<{
+    readonly prepare: S.Finite;
+    readonly instrument: S.Finite;
+    readonly 'dry-run': S.Finite;
+    readonly 'mutation-test': S.Finite;
+  }>>;
+  readonly static: S.NullOr<S.Struct<{
+    readonly count: S.Int;
+    readonly costMs: S.Finite;
+  }>>;
 }>, {}>;
 declare class VerdictEnvelope extends VerdictEnvelope_base {}
 //#endregion
-//#region src/run-event-wire.schema.d.ts
-declare const RunEventWireLine: S.decodeTo<S.fromJsonString<S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, S.Codec<RunMutantTested, {
-  readonly _tag: "mutant";
-  readonly id: string;
-  readonly status: "CompileError" | "Ignored" | "Killed" | "NoCoverage" | "Pending" | "RuntimeError" | "Survived" | "Timeout";
-  readonly file: string;
-  readonly location: {
-    readonly start: {
-      readonly line: number;
-      readonly column: number;
-    };
-    readonly end: {
-      readonly line: number;
-      readonly column: number;
-    };
-  };
-  readonly mutator: string;
-  readonly replacement: string | null;
-  readonly completed: number;
-  readonly total: number;
-}, never, never>, typeof Heartbeat, typeof PluginsReported, typeof FormatRegistryResolved, typeof SkippedReported, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]> & {
-  QUEUE_BOUND: number;
-}>, S.String, never, never>;
-type RunEventWireLine = typeof RunEventWireLine.Type;
-declare namespace mod_d_exports$4 {
-  export { FormatClaimShadowingRow, FormatRegistryResolved, FormatRegistryRow, FrameworkContributionRow, FrameworkModuleRow, Heartbeat, HelpRendered, MetricsResultFromReport, ModeSignal, OutputMode, PhaseEntered, PlanKnown, PluginLoadFailureReason, PluginsReported, ResolvedMode, ResolvedModeInput, RunEvent, RunEventDrain, RunEventDrainLive, RunEventStream, RunEventWireLine, RunEvents, RunFailed, RunIdentity, RunIdentityShape, RunMutantTested, RunPhase, RunStarted, RunTerminalEvent, SkippedFileRow, SkippedReported, VerdictCounts, VerdictEnvelope, VerdictMutant, VerdictReached, makeRunEventStream, metricsResultFromFiles };
+//#region src/reporting/verdict-envelope.d.ts
+declare const buildVerdictEnvelope: {
+  (mode: mod_d_exports$10.OutputMode, signal: mod_d_exports$10.ModeSignal, runId: mod_d_exports$1$7.RunId, basePath: string, pathService: Path.Path, phaseDurations: Option.Option<mod_d_exports$1$7.PhaseDurations>, staticVerdict: mod_d_exports$1$7.StaticVerdict | null): (report: mod_d_exports$7$1.MutationTestResult) => VerdictEnvelope;
+  (report: mod_d_exports$7$1.MutationTestResult, mode: mod_d_exports$10.OutputMode, signal: mod_d_exports$10.ModeSignal, runId: mod_d_exports$1$7.RunId, basePath: string, pathService: Path.Path, phaseDurations: Option.Option<mod_d_exports$1$7.PhaseDurations>, staticVerdict: mod_d_exports$1$7.StaticVerdict | null): VerdictEnvelope;
+};
+declare namespace mod_d_exports$5 {
+  export { MetricsResultFromReport, ResolvedMode, ResolvedModeInput, RunEventDrain, RunEventDrainLive, RunEventStream, RunEvents, RunIdentity, RunIdentityShape, VerdictEnvelope, buildVerdictEnvelope, makeRunEventStream, metricsResultFromFiles, staticVerdictOf };
+}
+declare namespace msp_framing_schema_d_exports {
+  export { CONTENT_LENGTH_HEADER, FrameAction, FramingAction, FramingBuffer, FramingBytes, FramingReader, FramingStep, HeaderPattern, HeaderlessAction, IncompleteAction, decodeUtf8, emptyFraming, encodeUtf8, frameOf, readFrames };
+}
+type HeaderPattern = RegExp;
+type FramingBytes = Uint8Array;
+declare const CONTENT_LENGTH_HEADER: HeaderPattern;
+declare const encodeUtf8: (text: string) => FramingBytes;
+declare const decodeUtf8: (bytes: FramingBytes) => string;
+declare const FramingBuffer: S.Struct<{
+  readonly bytes: S.Uint8Array;
+}>;
+type FramingBuffer = typeof FramingBuffer.Type;
+declare const emptyFraming: FramingBuffer;
+declare const FramingStep: S.Struct<{
+  readonly buffer: S.Struct<{
+    readonly bytes: S.Uint8Array;
+  }>;
+  readonly frames: S.$Array<S.String>;
+  readonly errors: S.$Array<S.String>;
+}>;
+type FramingStep = typeof FramingStep.Type;
+declare const IncompleteAction: S.TaggedStruct<"Incomplete", {
+  readonly rest: S.Uint8Array;
+}>;
+declare const FrameAction: S.TaggedStruct<"Frame", {
+  readonly rest: S.Uint8Array;
+  readonly frame: S.String;
+}>;
+declare const HeaderlessAction: S.TaggedStruct<"Headerless", {
+  readonly rest: S.Uint8Array;
+}>;
+type FramingAction = typeof IncompleteAction.Type | typeof FrameAction.Type | typeof HeaderlessAction.Type;
+type FramingReader = {
+  (buffer: FramingBuffer, chunk: FramingBytes): FramingStep;
+  (chunk: FramingBytes): (buffer: FramingBuffer) => FramingStep;
+};
+declare const readFrames: FramingReader;
+declare const frameOf: (payload: string) => FramingBytes;
+declare namespace msp_schema_d_exports {
+  export { ConfigureParams, ConfigureResult, DiscoverParams, DiscoverResult, DiscoveredFile, DiscoveredFiles, DiscoveredMutant, FileRange, JsonRpcErrorObject, JsonRpcErrorResponse, JsonRpcId, JsonRpcRequest, JsonRpcResponse, JsonRpcResultResponse, JsonRpcVersion, MSP_INTERNAL_ERROR, MSP_INVALID_PARAMS, MSP_INVALID_REQUEST, MSP_METHODS, MSP_METHOD_NOT_FOUND, MSP_PARSE_ERROR, MSP_PROTOCOL_VERSION, MSP_SERVER_BUSY, MspEncoder, MspErrorCode, MspLocation, MspMethod, MspMethodTable, MspMutantResult, MspMutantStatus, MspParamDecoder, MspVersion, MutatePatterns, MutationTestParams, MutationTestResult, ReportMutationTestProgress, ServeError, decodeConfigureParams, decodeDiscoverParams, decodeJsonRpcRequest, decodeMutationTestParams, encodeJsonRpcResponse, encodeProgressNotification, restrictPatternsOf };
+}
+declare const ServeError_base: S.Class<ServeError, S.TaggedStruct<"ServeError", {
+  readonly reason: S.String;
+  readonly cause: S.optionalKey<S.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+declare class ServeError extends ServeError_base {
+  get message(): string;
+}
+type MspVersion = string;
+declare const MSP_PROTOCOL_VERSION: MspVersion;
+interface MspMethodTable {
+  readonly configure: 'configure';
+  readonly discover: 'discover';
+  readonly mutationTest: 'mutationTest';
+  readonly reportMutationTestProgress: 'reportMutationTestProgress';
+}
+declare const MSP_METHODS: MspMethodTable;
+declare const MspMethod: S.Literals<readonly ["configure", "discover", "mutationTest", "reportMutationTestProgress"]>;
+type MspMethod = typeof MspMethod.Type;
+declare const JsonRpcVersion: S.Literal<"2.0">;
+declare const JsonRpcId: S.Union<readonly [S.String, S.Finite, S.Null]>;
+type JsonRpcId = typeof JsonRpcId.Type;
+declare const JsonRpcRequest: S.Struct<{
+  readonly jsonrpc: S.Literal<"2.0">;
+  readonly id: S.optionalKey<S.Union<readonly [S.String, S.Finite, S.Null]>>;
+  readonly method: S.String;
+  readonly params: S.optionalKey<S.Codec<S.Json, S.Json, never, never>>;
+}>;
+type JsonRpcRequest = typeof JsonRpcRequest.Type;
+declare const JsonRpcErrorObject: S.Struct<{
+  readonly code: S.Int;
+  readonly message: S.String;
+  readonly data: S.optionalKey<S.Codec<S.Json, S.Json, never, never>>;
+}>;
+type MspErrorCode = number;
+declare const MSP_PARSE_ERROR: MspErrorCode;
+declare const MSP_INVALID_REQUEST: MspErrorCode;
+declare const MSP_METHOD_NOT_FOUND: MspErrorCode;
+declare const MSP_INVALID_PARAMS: MspErrorCode;
+declare const MSP_INTERNAL_ERROR: MspErrorCode;
+declare const MSP_SERVER_BUSY: MspErrorCode;
+declare const JsonRpcErrorResponse: S.Struct<{
+  readonly jsonrpc: S.Literal<"2.0">;
+  readonly id: S.NullOr<S.Union<readonly [S.String, S.Finite, S.Null]>>;
+  readonly error: S.Struct<{
+    readonly code: S.Int;
+    readonly message: S.String;
+    readonly data: S.optionalKey<S.Codec<S.Json, S.Json, never, never>>;
+  }>;
+}>;
+declare const JsonRpcResultResponse: S.Struct<{
+  readonly jsonrpc: S.Literal<"2.0">;
+  readonly id: S.Union<readonly [S.String, S.Finite, S.Null]>;
+  readonly result: S.Unknown;
+}>;
+declare const JsonRpcResponse: S.Union<readonly [S.Struct<{
+  readonly jsonrpc: S.Literal<"2.0">;
+  readonly id: S.Union<readonly [S.String, S.Finite, S.Null]>;
+  readonly result: S.Unknown;
+}>, S.Struct<{
+  readonly jsonrpc: S.Literal<"2.0">;
+  readonly id: S.NullOr<S.Union<readonly [S.String, S.Finite, S.Null]>>;
+  readonly error: S.Struct<{
+    readonly code: S.Int;
+    readonly message: S.String;
+    readonly data: S.optionalKey<S.Codec<S.Json, S.Json, never, never>>;
+  }>;
+}>]>;
+type JsonRpcResponse = typeof JsonRpcResponse.Type;
+type MspLocation = mod_d_exports$7$1.Location;
+type MspMutantStatus = mod_d_exports$2$1.MutantStatus;
+type MspMutantResult = mod_d_exports$7$1.MutantResult;
+declare const FileRange: S.Struct<{
+  readonly path: S.String;
+  readonly range: S.optionalKey<S.StructWithRest<S.Struct<{
+    readonly start: S.StructWithRest<S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+    readonly end: S.StructWithRest<S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+  }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>>;
+}>;
+type FileRange = typeof FileRange.Type;
+declare const ConfigureParams: S.Struct<{
+  readonly configFilePath: S.optionalKey<S.String>;
+}>;
+type ConfigureParams = typeof ConfigureParams.Type;
+declare const ConfigureResult: S.Struct<{
+  readonly version: S.String;
+}>;
+type ConfigureResult = typeof ConfigureResult.Type;
+declare const DiscoveredMutant: S.Struct<{
+  readonly id: S.String;
+  readonly location: S.StructWithRest<S.Struct<{
+    readonly start: S.StructWithRest<S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+    readonly end: S.StructWithRest<S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+  }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+  readonly description: S.optionalKey<S.String>;
+  readonly mutatorName: S.String;
+  readonly replacement: S.optionalKey<S.String>;
+}>;
+type DiscoveredMutant = typeof DiscoveredMutant.Type;
+declare const DiscoveredFile: S.Struct<{
+  readonly mutants: S.$Array<S.Struct<{
+    readonly id: S.String;
+    readonly location: S.StructWithRest<S.Struct<{
+      readonly start: S.StructWithRest<S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+      readonly end: S.StructWithRest<S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+    }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+    readonly description: S.optionalKey<S.String>;
+    readonly mutatorName: S.String;
+    readonly replacement: S.optionalKey<S.String>;
+  }>>;
+}>;
+type DiscoveredFile = typeof DiscoveredFile.Type;
+declare const DiscoveredFiles: S.$Record<S.String, S.Struct<{
+  readonly mutants: S.$Array<S.Struct<{
+    readonly id: S.String;
+    readonly location: S.StructWithRest<S.Struct<{
+      readonly start: S.StructWithRest<S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+      readonly end: S.StructWithRest<S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+    }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+    readonly description: S.optionalKey<S.String>;
+    readonly mutatorName: S.String;
+    readonly replacement: S.optionalKey<S.String>;
+  }>>;
+}>>;
+type DiscoveredFiles = typeof DiscoveredFiles.Type;
+declare const DiscoverParams: S.Struct<{
+  readonly files: S.optionalKey<S.$Array<S.Struct<{
+    readonly path: S.String;
+    readonly range: S.optionalKey<S.StructWithRest<S.Struct<{
+      readonly start: S.StructWithRest<S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+      readonly end: S.StructWithRest<S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+    }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>>;
+  }>>>;
+}>;
+type DiscoverParams = typeof DiscoverParams.Type;
+declare const DiscoverResult: S.Struct<{
+  readonly files: S.$Record<S.String, S.Struct<{
+    readonly mutants: S.$Array<S.Struct<{
+      readonly id: S.String;
+      readonly location: S.StructWithRest<S.Struct<{
+        readonly start: S.StructWithRest<S.Struct<{
+          readonly line: S.Finite;
+          readonly column: S.Finite;
+        }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+        readonly end: S.StructWithRest<S.Struct<{
+          readonly line: S.Finite;
+          readonly column: S.Finite;
+        }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+      }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+      readonly description: S.optionalKey<S.String>;
+      readonly mutatorName: S.String;
+      readonly replacement: S.optionalKey<S.String>;
+    }>>;
+  }>>;
+}>;
+type DiscoverResult = typeof DiscoverResult.Type;
+declare const MutationTestParams: S.Struct<{
+  readonly files: S.optionalKey<S.$Array<S.Struct<{
+    readonly path: S.String;
+    readonly range: S.optionalKey<S.StructWithRest<S.Struct<{
+      readonly start: S.StructWithRest<S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+      readonly end: S.StructWithRest<S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+    }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>>;
+  }>>>;
+  readonly mutants: S.optionalKey<S.$Record<S.String, S.Struct<{
+    readonly mutants: S.$Array<S.Struct<{
+      readonly id: S.String;
+      readonly location: S.StructWithRest<S.Struct<{
+        readonly start: S.StructWithRest<S.Struct<{
+          readonly line: S.Finite;
+          readonly column: S.Finite;
+        }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+        readonly end: S.StructWithRest<S.Struct<{
+          readonly line: S.Finite;
+          readonly column: S.Finite;
+        }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+      }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+      readonly description: S.optionalKey<S.String>;
+      readonly mutatorName: S.String;
+      readonly replacement: S.optionalKey<S.String>;
+    }>>;
+  }>>>;
+}>;
+type MutationTestParams = typeof MutationTestParams.Type;
+declare const MutationTestResult: S.Struct<{
+  readonly files: S.$Record<S.String, S.Struct<{
+    readonly mutants: S.$Array<S.StructWithRest<S.Struct<{
+      readonly coveredBy: S.optionalKey<S.$Array<S.String>>;
+      readonly description: S.optionalKey<S.String>;
+      readonly duration: S.optionalKey<S.Finite>;
+      readonly id: S.String;
+      readonly killedBy: S.optionalKey<S.$Array<S.String>>;
+      readonly location: S.StructWithRest<S.Struct<{
+        readonly start: S.StructWithRest<S.Struct<{
+          readonly line: S.Finite;
+          readonly column: S.Finite;
+        }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+        readonly end: S.StructWithRest<S.Struct<{
+          readonly line: S.Finite;
+          readonly column: S.Finite;
+        }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+      }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+      readonly mutatorName: S.String;
+      readonly replacement: S.optionalKey<S.String>;
+      readonly static: S.optionalKey<S.Boolean>;
+      readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+      readonly statusReason: S.optionalKey<S.String>;
+      readonly testsCompleted: S.optionalKey<S.Finite>;
+    }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>>;
+  }>>;
+}>;
+type MutationTestResult = typeof MutationTestResult.Type;
+declare const ReportMutationTestProgress: S.Struct<{
+  readonly jsonrpc: S.Literal<"2.0">;
+  readonly method: S.Literal<"reportMutationTestProgress">;
+  readonly params: S.Struct<{
+    readonly files: S.$Record<S.String, S.Struct<{
+      readonly mutants: S.$Array<S.StructWithRest<S.Struct<{
+        readonly coveredBy: S.optionalKey<S.$Array<S.String>>;
+        readonly description: S.optionalKey<S.String>;
+        readonly duration: S.optionalKey<S.Finite>;
+        readonly id: S.String;
+        readonly killedBy: S.optionalKey<S.$Array<S.String>>;
+        readonly location: S.StructWithRest<S.Struct<{
+          readonly start: S.StructWithRest<S.Struct<{
+            readonly line: S.Finite;
+            readonly column: S.Finite;
+          }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+          readonly end: S.StructWithRest<S.Struct<{
+            readonly line: S.Finite;
+            readonly column: S.Finite;
+          }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+        }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>;
+        readonly mutatorName: S.String;
+        readonly replacement: S.optionalKey<S.String>;
+        readonly static: S.optionalKey<S.Boolean>;
+        readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+        readonly statusReason: S.optionalKey<S.String>;
+        readonly testsCompleted: S.optionalKey<S.Finite>;
+      }>, readonly [S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>]>>;
+    }>>;
+  }>;
+}>;
+type ReportMutationTestProgress = typeof ReportMutationTestProgress.Type;
+type MspEncoder<A> = (value: A) => Result.Result<string, S.SchemaError>;
+type MspParamDecoder<A> = (params: S.Json | undefined) => Result.Result<A, S.SchemaError>;
+declare const encodeJsonRpcResponse: MspEncoder<JsonRpcResponse>;
+declare const encodeProgressNotification: MspEncoder<ReportMutationTestProgress>;
+declare const decodeJsonRpcRequest: MspParamDecoder<JsonRpcRequest>;
+declare const decodeConfigureParams: MspParamDecoder<ConfigureParams>;
+declare const decodeDiscoverParams: MspParamDecoder<DiscoverParams>;
+declare const decodeMutationTestParams: MspParamDecoder<MutationTestParams>;
+type MutatePatterns = ReadonlyArray<string>;
+/**
+ * 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.)
+ */
+declare const restrictPatternsOf: (files: ReadonlyArray<FileRange> | undefined) => MutatePatterns | undefined;
+//#endregion
+//#region src/Serve/Serve.cell.d.ts
+interface ServeRequest {
+  readonly channel: 'stdio' | 'socket';
+  readonly port?: number;
+  readonly address?: string;
+  readonly cliOptions?: mod_d_exports$5$1.PartialStrykerOptions;
+}
+declare const serveMutationServer: (invocation: ServeRequest) => Effect.Effect<void, ServeError, EnginePorts | Scope.Scope>;
+declare namespace mod_d_exports$6 {
+  export { msp_framing_schema_d_exports as Framing, msp_schema_d_exports as Protocol, ServeError, ServeRequest, serveMutationServer };
 }
 //#endregion
 //#region src/classify-worker-exit.workflow.d.ts
@@ -1054,7 +1575,7 @@ declare const classifyWorkerExit: Workflow.MadeWorkflow<typeof ClassifyWorkerExi
 //#region src/worker-client.blueprint.d.ts
 interface WorkerClientParams<Rpcs extends Rpc.Any> {
   readonly rpcs: RpcGroup.RpcGroup<Rpcs>;
-  readonly options: mod_d_exports$2$1.StrykerOptions;
+  readonly options: mod_d_exports$5$1.StrykerOptions;
   readonly entrypoint: string;
   readonly workingDirectory: string;
   readonly execArgv: readonly string[];
@@ -1065,8 +1586,8 @@ declare const makeWorkerClient: <Rpcs extends Rpc.Any>(params: WorkerClientParam
 //#endregion
 //#region src/worker-protocol.blueprint.d.ts
 declare const layerWorkerProtocol: (socket: Layer.Layer<Socket.Socket, Socket.SocketError>) => Layer.Layer<RpcClient.Protocol, Socket.SocketError>;
-declare namespace mod_d_exports$5 {
+declare namespace mod_d_exports$7 {
   export { ChildProcessCrashedError, ClassifyWorkerExitCommand, ClassifyWorkerExitDecision, OutOfMemoryError, SpawnedSocketWorker, WorkerBootError, WorkerBootTimeoutError, WorkerClientParams, WorkerExit, WorkerLauncher, WorkerLauncherShape, WorkerSpawnParams, classifyWorkerExit, layerWorkerProtocol, make as makeSpawnedSocketWorker, makeWorkerClient };
 }
 //#endregion
-export { mod_d_exports as Checker, mod_d_exports$1 as Configuration, mod_d_exports$2 as Engine, mod_d_exports$3 as Plugin, mod_d_exports$4 as RunEvent, mod_d_exports$5 as Worker };
+export { mod_d_exports as Checker, mod_d_exports$1 as Configuration, mod_d_exports$2 as Engine, git_diff_service_d_exports as GitDiff, git_diff_schema_d_exports as GitDiffSchema, import_closure_cell_d_exports as ImportClosure, mod_d_exports$3 as Mcp, mod_d_exports$4 as Plugin, mod_d_exports$5 as RunEvent, mod_d_exports$6 as Serve, mod_d_exports$7 as Worker };