@systemfsoftware/stryker-js 3.0.2 → 5.0.0

package/dist/merge-config-BrrNQWje.mjs

@@ -0,0 +1,16 @@
+import * as Predicate from "effect/Predicate";
+import * as Record from "effect/Record";
+//#region src/config/merge-config.ts
+const usable = (value, key) => key !== "__proto__" && value !== void 0;
+const combineNested = (left, right) => {
+	if (Predicate.isObject(right)) return mergeRecords(left, right);
+	return right;
+};
+const combine = (left, right) => {
+	if (Predicate.isObject(left)) return combineNested(left, right);
+	return right;
+};
+const mergeRecords = (base, overrides) => Record.union(base, Record.filter(overrides, usable), combine);
+const mergeConfig = (defaults, overrides) => mergeRecords(defaults, overrides);
+//#endregion
+export { mergeConfig as t };

package/dist/mutation-test.cell-RmF-sBUm.d.mts

@@ -0,0 +1,509 @@
+import { r as ResolvedMode } from "./output-mode-CfGHDpi5.mjs";
+import { t as LoadedPlugins } from "./Plugins-sA_9VKus.mjs";
+import * as Effect 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 { CompleteDryRunResult, DryRunResult, ExitClass, MetricsResult, MutationTestResult, PartialStrykerOptions, ReporterFactory, ReporterRpcs, StrykerOptions, TestResult, TestRunnerCapabilities } from "@systemfsoftware/stryker-js-plugin-interface";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Queue from "effect/Queue";
+import "effect/Result";
+import * as S from "effect/Schema";
+import { CoverageData, FileDescription, FileDescriptions, Mutant, MutantStatus, MutateDescription, RunMutantResult } from "@systemfsoftware/stryker-js-instrumenter/mutants";
+import * as Cause from "effect/Cause";
+import * as Scope from "effect/Scope";
+import * as Duration from "effect/Duration";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as MutableHashSet from "effect/MutableHashSet";
+import { Schema } from "effect";
+import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
+import * as RpcClient from "effect/unstable/rpc/RpcClient";
+import * as Schedule from "effect/Schedule";
+import "@systemfsoftware/stryker-js-instrumenter";
+import { PlatformError } from "effect/PlatformError";
+import * as Rpc from "effect/unstable/rpc/Rpc";
+import { RpcClientError } from "effect/unstable/rpc/RpcClientError";
+import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
+import * as Socket from "effect/unstable/socket/Socket";
+import { Ignorer } from "@systemfsoftware/stryker-ignorer-interface";
+//#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.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.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.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.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 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 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.String>, 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.String, 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.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: Duration.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 { WorkerLauncherShape as $, forkOptionsSchema as A, PlanKnown as B, ConfigFileUnreadableError as C, MergeResult as D, MergeCommand as E, RunIdentity as F, RunStarted as G, RunFailed as H, RunIdentityShape as I, SpawnedSocketWorker as J, RunTerminalEvent as K, Heartbeat as L, IdGeneratorShape as M, classifyWorkerExit as N, ReadConfigCommand as O, RunEvents as P, WorkerLauncher as Q, HelpRendered as R, ConfigFileNotFoundError as S, ImportedModuleSchema as T, RunMutantTested as U, RunEvent as V, RunPhase as W, WorkerClientParams as X, WorkerBootError as Y, WorkerExit as Z, reporterWorkerFactory as _, WiredRunLayer as a, WorkerBootTimeoutError as at, ConfigError as b, PrepareDone as c, RunEnvironmentShape as d, WorkerSpawnParams as et, StrykerError as f, SpawnReporterWorkerParams as g, ReporterWorkerClient as h, StageServices as i, OutOfMemoryError as it, survivorsPriorReport as j, extendsPropertySchema as k, PrepareExecutorArgs as l, REPORTER_EVENT_BATCH_BOUND as m, EnginePorts as n, makeWorkerClient as nt, DryRunDone as o, IncrementalReportSchema as p, VerdictReached as q, RunStageServices as r, ChildProcessCrashedError as rt, InstrumentDone as s, MutationTestDone as t, connectRetry as tt, RunEnvironment as u, spawnReporterWorker as v, ConfigFileUnsupportedError as w, ConfigFileInvalidError as x, ConfigDocumentSchema as y, PhaseEntered as z };

package/dist/output-mode-CfGHDpi5.d.mts

@@ -0,0 +1,17 @@
+//#region src/output-mode.d.ts
+/**
+ * Mode type vocabulary shared with the CLI package. Runtime resolution
+ * (`resolveMode`) and gate functions (`isProgressEnabled`, `isColorEnabled`)
+ * live in the CLI; the `ResolvedMode` fields (`mode`, `signal`,
+ * `stdoutIsTTY`) ride along in `VerdictEnvelope` (`verdict-envelope.ts`),
+ * so the types stay where the data does.
+ */
+type OutputMode = 'human' | 'machine';
+type ModeSignal = 'flag' | 'env' | 'tty' | 'agent' | 'tool';
+interface ResolvedMode {
+  readonly mode: OutputMode;
+  readonly signal: ModeSignal;
+  readonly stdoutIsTTY: boolean;
+}
+//#endregion
+export { OutputMode as n, ResolvedMode as r, ModeSignal as t };

package/dist/plugin-loader.d.mts

@@ -0,0 +1,106 @@
+import * as Effect from 'effect/Effect';
+import * as HashMap from 'effect/HashMap';
+import { Ignorer } from '@systemfsoftware/stryker-ignorer-interface';
+import * as Path from 'effect/Path';
+import { Schema } from 'effect';
+import { WorkerPluginKind } from '@systemfsoftware/stryker-js-plugin-interface';
+import { WorkerPluginSpawn } from '@systemfsoftware/stryker-js-plugin-interface';
+import { YieldableError } from 'effect/Cause';
+
+declare type AnyPluginDescriptor = AnyWorkerPluginDescriptor | EvaluatorPluginDescriptor;
+
+declare type AnyWorkerPluginDescriptor = { [K in WorkerPluginKind]: WorkerPluginDescriptor<K>; }[WorkerPluginKind];
+
+declare type AnyWorkerPluginSource = { [K in WorkerPluginKind]: WorkerPluginSource<K>; }[WorkerPluginKind];
+
+export declare function create<K extends PluginKind>(pluginsByKind: HashMap.HashMap<PluginKind, readonly AnyPluginDescriptor[]>, kind: K, name: string): Effect.Effect<PluginDescriptorOf<K>, PluginNotFoundError>;
+
+export declare function createAll<K extends PluginKind>(pluginsByKind: HashMap.HashMap<PluginKind, readonly AnyPluginDescriptor[]>, kind: K): Effect.Effect<readonly PluginDescriptorOf<K>[]>;
+
+declare interface EvaluatorPluginDescriptor {
+    readonly kind: 'Evaluator';
+    readonly name: string;
+}
+
+declare interface EvaluatorPluginSource {
+    readonly kind: 'Evaluator';
+    readonly name: string;
+    readonly modulePath: string;
+}
+
+export declare interface LoadedPlugins {
+    readonly schemaContributions: readonly Record<string, unknown>[];
+    readonly pluginsByKind: HashMap.HashMap<PluginKind, readonly PluginDescriptor[]>;
+    readonly pluginModulePaths: readonly string[];
+    readonly pluginSources: readonly PluginSource[];
+    readonly ignorers: readonly Ignorer[];
+}
+
+export declare function loadPlugins(pluginDescriptors: readonly string[]): Effect.Effect<LoadedPlugins, PluginLoadFailedError, Path.Path>;
+
+export declare type PluginDescriptor<K extends PluginKind = PluginKind> = PluginDescriptorOf<K>;
+
+export declare type PluginDescriptorOf<K extends PluginKind> = Extract<AnyPluginDescriptor, {
+    readonly kind: K;
+}>;
+
+export declare type PluginKind = WorkerPluginKind | 'Evaluator';
+
+export declare interface PluginLoaderEntryLike {
+    readonly moduleName: string;
+    readonly plugins: readonly PluginDescriptor[] | undefined;
+    readonly schemaContribution: Record<string, unknown> | undefined;
+}
+
+export declare class PluginLoadFailedError extends PluginLoadFailedError_base {
+    readonly exitClass: 'InternalError';
+}
+
+declare const PluginLoadFailedError_base: Schema.Class<PluginLoadFailedError, Schema.TaggedStruct<"PluginLoadFailedError", {
+    readonly descriptor: Schema.String;
+    readonly cause: Schema.Unknown;
+}>, YieldableError>;
+
+export declare 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;
+    }[];
+}
+
+export declare class PluginNotFoundError extends PluginNotFoundError_base {
+    readonly exitClass: 'ConfigError';
+}
+
+declare const PluginNotFoundError_base: Schema.Class<PluginNotFoundError, Schema.TaggedStruct<"PluginNotFoundError", {
+    readonly descriptor: Schema.String;
+}>, YieldableError>;
+
+export declare type PluginSource = AnyWorkerPluginSource | EvaluatorPluginSource;
+
+export declare const resolvePluginWorkerEntry: (params: {
+    readonly loaded: Pick<LoadedPlugins, 'pluginSources'>;
+    readonly kind: WorkerPluginKind;
+    readonly name: string;
+}) => Effect.Effect<WorkerPluginSpawn, PluginNotFoundError>;
+
+declare interface WorkerPluginDescriptor<K extends WorkerPluginKind = WorkerPluginKind> {
+    readonly kind: K;
+    readonly name: string;
+    readonly workerEntry: string;
+}
+
+declare interface WorkerPluginSource<K extends WorkerPluginKind = WorkerPluginKind> {
+    readonly kind: K;
+    readonly name: string;
+    readonly modulePath: string;
+    readonly workerEntry: string;
+}
+
+export { }

package/dist/plugin-loader.mjs

@@ -0,0 +1,2 @@
+import { a as loadPlugins, i as createAll, n as resolvePluginWorkerEntry, o as PluginLoadFailedError, r as create, s as PluginNotFoundError } from "./plugin-worker-entry-DNu0SHO8.mjs";
+export { PluginLoadFailedError, PluginNotFoundError, create, createAll, loadPlugins, resolvePluginWorkerEntry };