@systemfsoftware/stryker-js 6.1.0 → 8.0.0

package/dist/{Plugins-DF95m9KO.d.mts → mutation-test.cell-Ch-QUquW.d.mts}

@@ -1,10 +1,30 @@
-import { $ as WorkerPluginKind, d as ExitClass } from "./index-BInJWa0x.mjs";
+import { $ as TestResult, Et as RunMutantResult, L as PartialStrykerOptions, P as MutationTestResult, St as MutateDescription, U as ReporterFactory, Y as StrykerOptions, b as ExitClass, ct as WorkerPluginKind, dt as FileDescription, f as CompleteDryRunResult, ft as FileDescriptions, ht as Mutant, q as ReporterRpcs, r as ResolvedMode, ut as CoverageData } from "./output-mode-CE6VNHfH.mjs";
 import * as Effect$1 from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
+import * as Stdio from "effect/Stdio";
+import { Cell } from "@systemfsoftware/effect-cell-types";
 import * as S from "effect/Schema";
 import "effect/Option";
 import { Schema } from "effect";
+import * as Context from "effect/Context";
+import * as Rpc from "effect/unstable/rpc/Rpc";
+import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
+import * as Layer from "effect/Layer";
+import * as Queue from "effect/Queue";
+import "effect/Result";
+import * as Cause from "effect/Cause";
+import * as Scope from "effect/Scope";
+import * as EffectDuration from "effect/Duration";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as MutableHashSet from "effect/MutableHashSet";
 import * as HashMap from "effect/HashMap";
+import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
+import * as RpcClient from "effect/unstable/rpc/RpcClient";
+import * as Schedule from "effect/Schedule";
+import { PlatformError } from "effect/PlatformError";
+import { RpcClientError } from "effect/unstable/rpc/RpcClientError";
+import * as Socket from "effect/unstable/socket/Socket";
 //#region src/Run.schema.d.ts
 declare const TypeId: '~stryker/mutation-run/StageError';
 declare const StageError_base: S.Class<StageError, S.TaggedStruct<"StageError", {
@@ -19,6 +39,194 @@ declare class StageError extends StageError_base {
   get message(): string;
 }
 //#endregion
+//#region src/Worker.schema.d.ts
+declare const ChildProcessCrashedError_base: Schema.Class<ChildProcessCrashedError, Schema.TaggedStruct<"ChildProcessCrashedError", {
+  readonly pid: Schema.Int;
+  readonly exit: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literals<readonly ["Code"]>;
+    readonly code: Schema.Int;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literals<readonly ["Signal"]>;
+    readonly signal: Schema.String;
+  }>]>;
+  readonly cause: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The child process hosting a worker ended when it was not supposed to.
+ */
+declare class ChildProcessCrashedError extends ChildProcessCrashedError_base {
+  readonly exitClass: 'InternalError';
+}
+declare const OutOfMemoryError_base: Schema.Class<OutOfMemoryError, Schema.TaggedStruct<"OutOfMemoryError", {
+  readonly pid: Schema.Int;
+  readonly exitCode: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+declare class OutOfMemoryError extends OutOfMemoryError_base {
+  readonly exitClass: 'RuntimeError';
+}
+declare const WorkerBootTimeoutError_base: Schema.Class<WorkerBootTimeoutError, Schema.TaggedStruct<"WorkerBootTimeoutError", {
+  readonly pid: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+declare class WorkerBootTimeoutError extends WorkerBootTimeoutError_base {
+  readonly exitClass: 'InternalError';
+}
+//#endregion
+//#region src/WorkerLauncher.d.ts
+declare const connectRetry: Schedule.Schedule<import("effect/Duration").Duration, unknown, never, never>;
+type WorkerExit = ChildProcessCrashedError | OutOfMemoryError;
+interface SpawnedSocketWorker {
+  readonly pid: number;
+  readonly clientLayer: Layer.Layer<RpcClient.Protocol, Socket.SocketError>;
+  readonly exited: Effect$1.Effect<never, WorkerExit>;
+}
+interface WorkerSpawnParams {
+  readonly entrypoint: string;
+  readonly workingDirectory: string;
+  readonly execArgv: readonly string[];
+  readonly optionsJson: string;
+  readonly tempDirPrefix: string;
+  readonly env?: Readonly<Record<string, string>> | undefined;
+}
+interface WorkerLauncherShape {
+  readonly spawn: (params: WorkerSpawnParams) => Effect$1.Effect<SpawnedSocketWorker, ChildProcessCrashedError, Scope.Scope>;
+}
+declare const WorkerLauncher_base: Context.ServiceClass<WorkerLauncher, "@systemfsoftware/stryker-js/WorkerLauncher", WorkerLauncherShape>;
+declare class WorkerLauncher extends WorkerLauncher_base {}
+type WorkerBootError = WorkerExit | WorkerBootTimeoutError;
+interface WorkerClientParams<Rpcs extends Rpc.Any> extends WorkerSpawnParams {
+  readonly rpcs: RpcGroup.RpcGroup<Rpcs>;
+}
+declare const makeWorkerClient: <Rpcs extends Rpc.Any>(params: WorkerClientParams<Rpcs>) => Effect$1.Effect<RpcClient.RpcClient<Rpcs, RpcClientError>, WorkerBootError, Scope.Scope | WorkerLauncher>;
+//#endregion
+//#region src/RunEvent.schema.d.ts
+declare const RunPhase: S.Literals<readonly ["prepare", "instrument", "dry-run", "mutation-test"]>;
+type RunPhase = typeof RunPhase.Type;
+declare const RunStarted_base: S.Class<RunStarted, S.TaggedStruct<"stream", {
+  readonly schemaVersion: S.String;
+  readonly runId: S.String;
+  readonly mode: S.Literals<readonly ["human", "machine"]>;
+  readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+}>, {}>;
+declare class RunStarted extends RunStarted_base {}
+declare const PhaseEntered_base: S.Class<PhaseEntered, S.TaggedStruct<"phase", {
+  readonly phase: S.Literals<readonly ["prepare", "instrument", "dry-run", "mutation-test"]>;
+  readonly elapsedMs: S.Finite;
+}>, {}>;
+declare class PhaseEntered extends PhaseEntered_base {}
+declare const PlanKnown_base: S.Class<PlanKnown, S.TaggedStruct<"plan", {
+  readonly total: S.Finite;
+}>, {}>;
+declare class PlanKnown extends PlanKnown_base {}
+declare const RunMutantTested_base: S.Class<RunMutantTested, S.TaggedStruct<"mutant", {
+  readonly id: S.String;
+  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+  readonly file: S.String;
+  readonly location: S.Struct<{
+    readonly start: S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>;
+    readonly end: S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>;
+  }>;
+  readonly mutator: S.String;
+  readonly replacement: S.NullOr<S.String>;
+  readonly completed: S.Finite;
+  readonly total: S.Finite;
+}>, {}>;
+declare class RunMutantTested extends RunMutantTested_base {}
+declare const Heartbeat_base: S.Class<Heartbeat, S.TaggedStruct<"tick", {
+  readonly elapsedMs: S.Finite;
+  readonly completed: S.Finite;
+  readonly total: S.NullOr<S.Finite>;
+}>, {}>;
+declare class Heartbeat extends Heartbeat_base {}
+declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdict", {
+  readonly schemaVersion: S.String;
+  readonly runId: S.String;
+  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.Struct<{
+    readonly high: S.Finite;
+    readonly low: S.Finite;
+    readonly break: S.NullOr<S.Finite>;
+  }>;
+  readonly reportFile: S.NullOr<S.String>;
+  readonly counts: S.Struct<{
+    readonly killed: S.Finite;
+    readonly timeout: S.Finite;
+    readonly survived: S.Finite;
+    readonly noCoverage: S.Finite;
+    readonly runtimeErrors: S.Finite;
+    readonly compileErrors: S.Finite;
+    readonly ignored: S.Finite;
+    readonly pending: S.Finite;
+  }>;
+  readonly mutants: S.$Array<S.Struct<{
+    readonly id: S.String;
+    readonly file: S.String;
+    readonly location: S.Struct<{
+      readonly start: S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>;
+      readonly end: S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>;
+    }>;
+    readonly mutator: S.String;
+    readonly replacement: S.NullOr<S.String>;
+    readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+  }>>;
+}>, {}>;
+declare class VerdictReached extends VerdictReached_base {}
+declare const RunFailed_base: S.Class<RunFailed, S.TaggedStruct<"error", {
+  readonly schemaVersion: S.String;
+  readonly code: S.Finite;
+  readonly error: S.String;
+  readonly remediation: S.String;
+}>, {}>;
+declare class RunFailed extends RunFailed_base {}
+declare const HelpRendered_base: S.Class<HelpRendered, S.TaggedStruct<"help", {
+  readonly schemaVersion: S.String;
+  readonly code: S.Literals<readonly [0]>;
+  readonly help: S.String;
+}>, {}>;
+declare class HelpRendered extends HelpRendered_base {}
+declare const RunEvent: S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, typeof RunMutantTested, typeof Heartbeat, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]>;
+type RunEvent = typeof RunEvent.Type;
+type RunTerminalEvent = VerdictReached | RunFailed | HelpRendered;
+//#endregion
+//#region src/RunEvents.d.ts
+declare const RunEvents_base: Context.ServiceClass<RunEvents, "@systemfsoftware/stryker-js/RunEvents", Queue.Queue<Heartbeat | HelpRendered | PhaseEntered | PlanKnown | RunFailed | RunMutantTested | RunStarted | VerdictReached, Cause.Done<void>>>;
+declare class RunEvents extends RunEvents_base {}
+interface RunIdentityShape {
+  readonly runId: string;
+  readonly basePath: string;
+}
+declare const RunIdentity_base: Context.ServiceClass<RunIdentity, "@systemfsoftware/stryker-js/RunEvents/RunIdentity", RunIdentityShape>;
+declare class RunIdentity extends RunIdentity_base {}
+//#endregion
+//#region src/Mutants.d.ts
+interface TestCoverage {
+  readonly testsByMutantId: MutableHashMap.MutableHashMap<string, MutableHashSet.MutableHashSet<TestResult>>;
+  readonly testsById: MutableHashMap.MutableHashMap<string, TestResult>;
+  readonly staticCoverage: CoverageData | undefined;
+  readonly hitsByMutantId: MutableHashMap.MutableHashMap<string, number>;
+}
+//#endregion
+//#region src/Worker.d.ts
+interface IdGeneratorShape {
+  readonly next: Effect$1.Effect<number>;
+}
+declare const IdGenerator_base: Context.ServiceClass<IdGenerator, "@systemfsoftware/stryker-js/Worker/IdGenerator", IdGeneratorShape>;
+declare class IdGenerator extends IdGenerator_base {}
+declare const classifyWorkerExit: (pid: number, exitCode: number) => ChildProcessCrashedError | OutOfMemoryError;
+//#endregion
 //#region ../ignorers/interface/dist/index.d.ts
 declare interface AccessorProperty$1 extends Span$1 {
   type: AccessorPropertyType;
@@ -1324,21 +1532,6 @@ declare interface YieldExpression$1 extends Span$1 {
   parent?: Node$1;
 }
 //#endregion
-//#region src/Plugins.schema.d.ts
-declare const PluginNotFoundError_base: Schema.Class<PluginNotFoundError, Schema.TaggedStruct<"PluginNotFoundError", {
-  readonly descriptor: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-declare class PluginNotFoundError extends PluginNotFoundError_base {
-  readonly exitClass: 'ConfigError';
-}
-declare const PluginLoadFailedError_base: Schema.Class<PluginLoadFailedError, Schema.TaggedStruct<"PluginLoadFailedError", {
-  readonly descriptor: Schema.String;
-  readonly cause: Schema.Unknown;
-}>, import("effect/Cause").YieldableError>;
-declare class PluginLoadFailedError extends PluginLoadFailedError_base {
-  readonly exitClass: 'InternalError';
-}
-//#endregion
 //#region src/Plugins.d.ts
 type PluginKind = WorkerPluginKind | 'Evaluator';
 interface WorkerPluginDescriptor<K extends WorkerPluginKind = WorkerPluginKind> {
@@ -1369,23 +1562,6 @@ interface EvaluatorPluginSource {
 }
 type AnyWorkerPluginSource = { [K in WorkerPluginKind]: WorkerPluginSource<K>; }[WorkerPluginKind];
 type PluginSource = AnyWorkerPluginSource | EvaluatorPluginSource;
-interface PluginLoaderEntryLike {
-  readonly moduleName: string;
-  readonly plugins: readonly PluginDescriptor[] | undefined;
-  readonly schemaContribution: Record<string, unknown> | undefined;
-}
-interface PluginLoadPlan {
-  readonly schemaContributions: readonly Record<string, unknown>[];
-  readonly pluginsByKind: HashMap.HashMap<PluginKind, readonly PluginDescriptor[]>;
-  readonly pluginModulePaths: readonly string[];
-  readonly pluginSources: readonly PluginSource[];
-  readonly shadowings: readonly {
-    readonly kind: PluginKind;
-    readonly name: string;
-    readonly shadowedIndex: number;
-    readonly winnerIndex: number;
-  }[];
-}
 interface LoadedPlugins {
   readonly schemaContributions: readonly Record<string, unknown>[];
   readonly pluginsByKind: HashMap.HashMap<PluginKind, readonly PluginDescriptor[]>;
@@ -1393,8 +1569,349 @@ interface LoadedPlugins {
   readonly pluginSources: readonly PluginSource[];
   readonly ignorers: readonly Ignorer[];
 }
-declare function loadPlugins(pluginDescriptors: readonly string[]): Effect$1.Effect<LoadedPlugins, PluginLoadFailedError, Path.Path>;
-declare function create<K extends PluginKind>(pluginsByKind: HashMap.HashMap<PluginKind, readonly AnyPluginDescriptor[]>, kind: K, name: string): Effect$1.Effect<PluginDescriptorOf<K>, PluginNotFoundError>;
-declare function createAll<K extends PluginKind>(pluginsByKind: HashMap.HashMap<PluginKind, readonly AnyPluginDescriptor[]>, kind: K): Effect$1.Effect<readonly PluginDescriptorOf<K>[]>;
 //#endregion
-export { loadPlugins as _, EvaluatorPluginSource as a, Ignorer as b, PluginDescriptorOf as c, PluginLoaderEntryLike as d, PluginSource as f, createAll as g, create as h, EvaluatorPluginDescriptor as i, PluginKind as l, WorkerPluginSource as m, AnyWorkerPluginDescriptor as n, LoadedPlugins as o, WorkerPluginDescriptor as p, AnyWorkerPluginSource as r, PluginDescriptor as s, AnyPluginDescriptor as t, PluginLoadPlan as u, PluginLoadFailedError as v, StageError as x, PluginNotFoundError as y };
+//#region src/Config.schema.d.ts
+declare const ConfigDocumentSchema: S.$Record<S.String, S.Unknown>;
+declare const ImportedModuleSchema: S.Struct<{
+  readonly default: S.optional<S.Unknown>;
+}>;
+declare const ConfigFileNotFoundError_base: S.Class<ConfigFileNotFoundError, S.TaggedStruct<"ConfigFileNotFoundError", {
+  readonly file: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ConfigFileNotFoundError extends ConfigFileNotFoundError_base {
+  readonly exitClass: 'ConfigError';
+}
+declare const ConfigFileUnsupportedError_base: S.Class<ConfigFileUnsupportedError, S.TaggedStruct<"ConfigFileUnsupportedError", {
+  readonly file: S.String;
+  readonly hint: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ConfigFileUnsupportedError extends ConfigFileUnsupportedError_base {
+  readonly exitClass: 'ConfigError';
+  get message(): string;
+}
+declare const ConfigFileUnreadableError_base: S.Class<ConfigFileUnreadableError, S.TaggedStruct<"ConfigFileUnreadableError", {
+  readonly file: S.String;
+  readonly cause: S.Unknown;
+}>, import("effect/Cause").YieldableError>;
+declare class ConfigFileUnreadableError extends ConfigFileUnreadableError_base {
+  readonly exitClass: 'ConfigError';
+}
+declare const ConfigFileInvalidError_base: S.Class<ConfigFileInvalidError, S.TaggedStruct<"ConfigFileInvalidError", {
+  readonly file: S.String;
+  readonly cause: S.Unknown;
+}>, import("effect/Cause").YieldableError>;
+declare class ConfigFileInvalidError extends ConfigFileInvalidError_base {
+  readonly exitClass: 'ConfigError';
+}
+declare const ConfigError_base: S.Class<ConfigError, S.TaggedStruct<"ConfigError", {
+  readonly message: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ConfigError extends ConfigError_base {
+  readonly exitClass: 'ConfigError';
+}
+declare const ReadConfigCommand_base: S.Class<ReadConfigCommand, S.TaggedStruct<"ReadConfigCommand", {
+  readonly cliOptions: S.$Record<S.String, S.Unknown>;
+  readonly basePath: S.String;
+}>, {}>;
+declare class ReadConfigCommand extends ReadConfigCommand_base {}
+declare const MergeCommand_base: S.Class<MergeCommand, S.TaggedStruct<"MergeCommand", {
+  readonly base: S.$Record<S.String, S.Unknown>;
+  readonly overrides: S.$Record<S.String, S.Unknown>;
+}>, {}>;
+declare class MergeCommand extends MergeCommand_base {}
+declare const MergeResult_base: S.Class<MergeResult, S.TaggedStruct<"MergeResult", {
+  readonly merged: S.$Record<S.String, S.Unknown>;
+}>, {}>;
+declare class MergeResult extends MergeResult_base {}
+declare const ExtendsStepDocumentSchema: S.Struct<{
+  readonly path: S.String;
+  readonly options: S.$Record<S.String, S.Unknown>;
+}>;
+type ExtendsStepDocument = typeof ExtendsStepDocumentSchema.Type;
+declare const ExtendsStepStateSchema: S.Struct<{
+  readonly visited: S.$Array<S.String>;
+  readonly documents: S.$Array<S.Struct<{
+    readonly path: S.String;
+    readonly options: S.$Record<S.String, S.Unknown>;
+  }>>;
+}>;
+type ExtendsStepState = typeof ExtendsStepStateSchema.Type;
+type ExtendsRefusalReason = 'cycle' | 'non-string-extends';
+declare const ExtendsStepDone_base: S.Class<ExtendsStepDone, S.TaggedStruct<"done", {
+  readonly options: S.$Record<S.String, S.Unknown>;
+}>, {}>;
+declare class ExtendsStepDone extends ExtendsStepDone_base {}
+declare const ExtendsStepRead_base: S.Class<ExtendsStepRead, S.TaggedStruct<"read", {
+  readonly path: S.String;
+  readonly state: S.Struct<{
+    readonly visited: S.$Array<S.String>;
+    readonly documents: S.$Array<S.Struct<{
+      readonly path: S.String;
+      readonly options: S.$Record<S.String, S.Unknown>;
+    }>>;
+  }>;
+}>, {}>;
+declare class ExtendsStepRead extends ExtendsStepRead_base {}
+declare const ExtendsStepResolve_base: S.Class<ExtendsStepResolve, S.TaggedStruct<"resolve", {
+  readonly specifier: S.String;
+  readonly state: S.Struct<{
+    readonly visited: S.$Array<S.String>;
+    readonly documents: S.$Array<S.Struct<{
+      readonly path: S.String;
+      readonly options: S.$Record<S.String, S.Unknown>;
+    }>>;
+  }>;
+}>, {}>;
+declare class ExtendsStepResolve extends ExtendsStepResolve_base {}
+declare const ExtendsStepRefused_base: S.Class<ExtendsStepRefused, S.TaggedStruct<"refused", {
+  readonly reason: S.Literals<readonly ["cycle", "non-string-extends"]>;
+  readonly file: S.String;
+}>, {}>;
+declare class ExtendsStepRefused extends ExtendsStepRefused_base {}
+type ExtendsStepDecision = ExtendsStepDone | ExtendsStepRead | ExtendsStepResolve | ExtendsStepRefused;
+declare const survivorsPriorReport: S.optionalKey<S.String>;
+declare const extendsPropertySchema: S.optionalKey<S.String>;
+declare const forkOptionsSchema: S.StructWithRest<S.Struct<{
+  readonly allowConsoleColors: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly buildCommand: S.optional<S.String>;
+  readonly checkers: S.withDecodingDefaultKey<S.$Array<S.Struct<{
+    readonly plugin: S.String;
+    readonly nodeArgs: S.optional<S.$Array<S.String>>;
+    readonly options: S.optional<S.$Record<S.String, S.Unknown>>;
+  }>>, never>;
+  readonly checkerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly concurrency: S.optional<S.Union<readonly [S.Finite, S.String]>>;
+  readonly commandRunner: S.withDecodingDefaultKey<S.StructWithRest<S.Struct<{
+    readonly command: S.withDecodingDefaultKey<S.String, never>;
+  }>, readonly [S.$Record<S.String, S.Unknown>]>, never>;
+  readonly coverageAnalysis: S.withDecodingDefaultKey<S.Literals<readonly ["off", "all", "perTest"]>, never>;
+  readonly clearTextReporter: S.withDecodingDefaultKey<S.StructWithRest<S.Struct<{
+    readonly allowColor: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly allowEmojis: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly logTests: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly maxTestsToLog: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly reportTests: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly reportMutants: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly reportScoreTable: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly skipFull: S.withDecodingDefaultKey<S.Boolean, never>;
+  }>, readonly [S.$Record<S.String, S.Unknown>]>, never>;
+  readonly dryRunOnly: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly ignorePatterns: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly ignoreStatic: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly incremental: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly incrementalFile: S.withDecodingDefaultKey<S.String, never>;
+  readonly progressStreamFile: S.withDecodingDefaultKey<S.String, never>;
+  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>;
+  readonly logLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never>;
+  readonly maxConcurrentTestRunners: S.withDecodingDefaultKey<S.Finite, never>;
+  readonly maxTestRunnerReuse: S.withDecodingDefaultKey<S.Finite, never>;
+  readonly mutate: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly mutator: S.withDecodingDefaultKey<S.Struct<{
+    readonly excludedMutations: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  }>, never>;
+  readonly packageManager: S.optional<S.Literals<readonly ["npm", "yarn", "pnpm"]>>;
+  readonly plugins: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly appendPlugins: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly reporters: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly htmlReporter: S.withDecodingDefaultKey<S.Struct<{
+    readonly fileName: S.withDecodingDefaultKey<S.String, never>;
+  }>, never>;
+  readonly jsonReporter: S.withDecodingDefaultKey<S.Struct<{
+    readonly fileName: S.withDecodingDefaultKey<S.String, never>;
+  }>, never>;
+  readonly disableTypeChecks: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean, S.String]>, never>;
+  readonly symlinkNodeModules: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly tempDirName: S.withDecodingDefaultKey<S.String, never>;
+  readonly cleanTempDir: S.withDecodingDefaultKey<S.Literals<readonly ["always", false, true]>, never>;
+  readonly testRunner: S.withDecodingDefaultKey<S.Union<readonly [S.String, S.Struct<{
+    readonly plugin: S.String;
+    readonly nodeArgs: S.optional<S.$Array<S.String>>;
+    readonly options: S.optional<S.$Record<S.String, S.Unknown>>;
+  }>]>, never>;
+  readonly testRunnerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly thresholds: S.withDecodingDefaultKey<S.Struct<{
+    readonly high: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly low: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly break: S.withDecodingDefaultKey<S.NullOr<S.Finite>, never>;
+  }>, never>;
+  readonly timeoutFactor: S.withDecodingDefaultKey<S.Finite, never>;
+  readonly timeoutMS: S.withDecodingDefaultKey<S.Finite, never>;
+  readonly dryRunTimeoutMinutes: S.withDecodingDefaultKey<S.Finite, never>;
+  readonly tsconfigFile: S.withDecodingDefaultKey<S.String, never>;
+  readonly warnings: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean, S.StructWithRest<S.Struct<{
+    readonly unknownOptions: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly preprocessorErrors: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly unserializableOptions: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly slow: S.withDecodingDefaultKey<S.Boolean, never>;
+  }>, readonly [S.$Record<S.String, S.Unknown>]>]>, never>;
+  readonly disableBail: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly allowEmpty: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly ignorers: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly testFiles: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly survivorsPriorReport: S.optionalKey<S.String>;
+  readonly extends: S.optionalKey<S.String>;
+}>, readonly [S.$Record<S.String, S.Unknown>]>;
+//#endregion
+//#region src/ReporterStream.d.ts
+declare const ReporterStageTypeId: unique symbol;
+/**
+ * An attached reporter stage, opaque at the engine boundary: the published
+ * phase types carry this handle so the attachment machinery (queues, fibers,
+ * the state latch) never reaches an adopter's compiler. Constructed only by
+ * `attachReporterFactories`.
+ */
+interface ReporterStage {
+  readonly [ReporterStageTypeId]: typeof ReporterStageTypeId;
+}
+declare const REPORTER_EVENT_BATCH_BOUND = 128;
+type ReporterWorkerClient = RpcClient.RpcClient<RpcGroup.Rpcs<typeof ReporterRpcs>, RpcClientError>;
+declare const reporterWorkerFactory: (client: ReporterWorkerClient) => ReporterFactory;
+interface SpawnReporterWorkerParams {
+  readonly entrypoint: string;
+  readonly projectBasePath: string;
+  readonly execArgv: readonly string[];
+  readonly options: StrykerOptions;
+  readonly tempDirPrefix: string;
+}
+declare const spawnReporterWorker: (params: SpawnReporterWorkerParams) => Effect$1.Effect<ReporterWorkerClient, WorkerBootError, Scope.Scope | WorkerLauncher>;
+//#endregion
+//#region src/IncrementalReport.schema.d.ts
+declare const IncrementalReportSchema: S.StructWithRest<S.Struct<{
+  readonly schemaVersion: S.String;
+  readonly thresholds: S.Struct<{
+    readonly high: S.Finite;
+    readonly low: S.Finite;
+  }>;
+  readonly files: S.$Record<S.String, S.Struct<{
+    readonly language: S.String;
+    readonly source: S.String;
+    readonly mutants: S.$Array<S.Struct<{
+      readonly id: S.String;
+      readonly mutatorName: S.String;
+      readonly replacement: S.String;
+      readonly location: S.Struct<{
+        readonly start: S.Struct<{
+          readonly line: S.Finite;
+          readonly column: S.Finite;
+        }>;
+        readonly end: S.Struct<{
+          readonly line: S.Finite;
+          readonly column: S.Finite;
+        }>;
+      }>;
+      readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "Timeout", "CompileError", "RuntimeError", "Ignored", "Pending"]>;
+      readonly killedBy: S.optional<S.$Array<S.String>>;
+      readonly coveredBy: S.optional<S.$Array<S.String>>;
+      readonly static: S.optional<S.Boolean>;
+      readonly statusReason: S.optional<S.String>;
+      readonly testsCompleted: S.optional<S.Finite>;
+      readonly description: S.optional<S.String>;
+      readonly duration: S.optional<S.Finite>;
+    }>>;
+  }>>;
+  readonly testFiles: S.optional<S.$Record<S.String, S.Struct<{
+    readonly source: S.optional<S.String>;
+    readonly tests: S.$Array<S.Struct<{
+      readonly id: S.String;
+      readonly name: S.String;
+      readonly location: S.optional<S.Struct<{
+        readonly start: S.Struct<{
+          readonly line: S.Finite;
+          readonly column: S.Finite;
+        }>;
+        readonly end: S.optional<S.Struct<{
+          readonly line: S.Finite;
+          readonly column: S.Finite;
+        }>>;
+      }>>;
+    }>>;
+  }>>>;
+}>, readonly [S.$Record<S.String, S.Unknown>]>;
+//#endregion
+//#region src/Project.d.ts
+interface ProjectFile extends FileDescription {
+  readonly name: string;
+  readonly mutate: MutateDescription;
+  readonly content: string | undefined;
+  readonly originalContent: string | undefined;
+}
+interface Project {
+  readonly fileDescriptions: FileDescriptions;
+  readonly incrementalReport: MutationTestResult | undefined;
+  readonly testFiles: readonly string[];
+  readonly files: MutableHashMap.MutableHashMap<string, ProjectFile>;
+  readonly filesToMutate: MutableHashMap.MutableHashMap<string, ProjectFile>;
+}
+//#endregion
+//#region src/stryker-error.schema.d.ts
+declare const StrykerError_base: Schema.Class<StrykerError, Schema.TaggedStruct<"StrykerError", {
+  readonly message: Schema.String;
+  readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+declare class StrykerError extends StrykerError_base {}
+//#endregion
+//#region src/Sandbox.d.ts
+interface SandboxHandle {
+  readonly workingDirectory: string;
+  readonly sandboxFileFor: (fileName: string) => string;
+  readonly originalFileFor: (sandboxFileName: string) => string;
+}
+//#endregion
+//#region src/run/RunEnvironment.d.ts
+interface RunEnvironmentShape {
+  readonly runId: string;
+  readonly resolvedMode: ResolvedMode;
+  readonly runStartedAt: number;
+  readonly basePath: string;
+  readonly builtinReporters: Readonly<Record<string, ReporterFactory>>;
+  readonly allowConsoleColors: boolean;
+}
+declare const RunEnvironment_base: Context.ServiceClass<RunEnvironment, "@systemfsoftware/stryker-js/run/RunEnvironment", RunEnvironmentShape>;
+declare class RunEnvironment extends RunEnvironment_base {}
+//#endregion
+//#region src/run/prepare.cell.d.ts
+interface PrepareDone {
+  readonly project: Project;
+  readonly loadedPlugins: LoadedPlugins;
+  readonly ignorers: readonly Ignorer[];
+  readonly options: StrykerOptions;
+  readonly temporaryDirectoryPath: string;
+  readonly reporterStage: ReporterStage;
+}
+interface PrepareExecutorArgs {
+  cliOptions: PartialStrykerOptions;
+  targetMutatePatterns: string[] | undefined;
+}
+//#endregion
+//#region src/run/instrument.cell.d.ts
+interface InstrumentDone extends PrepareDone {
+  readonly mutants: readonly Mutant[];
+  readonly sandbox: SandboxHandle;
+  readonly concurrency: {
+    readonly testRunners: number;
+    readonly checkers: number;
+  };
+}
+//#endregion
+//#region src/run/dry-run.cell.d.ts
+interface DryRunDone extends InstrumentDone {
+  readonly dryRunResult: CompleteDryRunResult;
+  readonly testCoverage: TestCoverage;
+  readonly timeOverhead: EffectDuration.Duration;
+}
+//#endregion
+//#region src/run/StageServices.d.ts
+type StageServices = ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | IdGenerator | Path.Path | RunEnvironment | RunEvents | Scope.Scope | Stdio.Stdio | WorkerLauncher;
+type EnginePorts = ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Path.Path | Stdio.Stdio | WorkerLauncher;
+type RunStageServices = RunEnvironment | RunEvents | IdGenerator | Scope.Scope;
+type WiredRunLayer = Layer.Layer<RunStageServices | EnginePorts, never, never>;
+//#endregion
+//#region src/run/mutation-test.cell.d.ts
+interface MutationTestDone {
+  readonly results: readonly RunMutantResult[];
+  readonly verdict: ExitClass | null;
+}
+//#endregion
+export { PluginDescriptorOf as $, ExtendsStepDecision as A, connectRetry as At, MergeCommand as B, ConfigDocumentSchema as C, SpawnedSocketWorker as Ct, ConfigFileUnreadableError as D, WorkerLauncher as Dt, ConfigFileNotFoundError as E, WorkerExit as Et, ExtendsStepRefused as F, StageError as Ft, survivorsPriorReport as G, ReadConfigCommand as H, ExtendsStepResolve as I, AnyWorkerPluginSource as J, AnyPluginDescriptor as K, ExtendsStepState as L, ExtendsStepDocumentSchema as M, ChildProcessCrashedError as Mt, ExtendsStepDone as N, OutOfMemoryError as Nt, ConfigFileUnsupportedError as O, WorkerLauncherShape as Ot, ExtendsStepRead as P, WorkerBootTimeoutError as Pt, PluginDescriptor as Q, ExtendsStepStateSchema as R, spawnReporterWorker as S, VerdictReached as St, ConfigFileInvalidError as T, WorkerClientParams as Tt, extendsPropertySchema as U, MergeResult as V, forkOptionsSchema as W, EvaluatorPluginSource as X, EvaluatorPluginDescriptor as Y, LoadedPlugins as Z, REPORTER_EVENT_BATCH_BOUND as _, RunFailed as _t, WiredRunLayer as a, IdGenerator as at, SpawnReporterWorkerParams as b, RunStarted as bt, PrepareDone as c, TestCoverage as ct, RunEnvironmentShape as d, RunIdentityShape as dt, PluginKind as et, SandboxHandle as f, Heartbeat as ft, IncrementalReportSchema as g, RunEvent as gt, ProjectFile as h, PlanKnown as ht, StageServices as i, Ignorer as it, ExtendsStepDocument as j, makeWorkerClient as jt, ExtendsRefusalReason as k, WorkerSpawnParams as kt, PrepareExecutorArgs as l, RunEvents as lt, Project as m, PhaseEntered as mt, EnginePorts as n, WorkerPluginDescriptor as nt, DryRunDone as o, IdGeneratorShape as ot, StrykerError as p, HelpRendered as pt, AnyWorkerPluginDescriptor as q, RunStageServices as r, WorkerPluginSource as rt, InstrumentDone as s, classifyWorkerExit as st, MutationTestDone as t, PluginSource as tt, RunEnvironment as u, RunIdentity as ut, ReporterStage as v, RunMutantTested as vt, ConfigError as w, WorkerBootError as wt, reporterWorkerFactory as x, RunTerminalEvent as xt, ReporterWorkerClient as y, RunPhase as yt, ImportedModuleSchema as z };