@systemfsoftware/stryker-js 3.0.2 → 5.0.0

package/dist/plugin-worker-entry-DNu0SHO8.mjs

@@ -0,0 +1,1413 @@
+import { t as mergeConfig } from "./merge-config-BrrNQWje.mjs";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { StrykerOptionsSchema, TestRunnerFailed, TestRunnerRpcs, WorkerEntryUrl, WorkerPluginKind, toMutantRunResult } from "@systemfsoftware/stryker-js-plugin-interface";
+import * as Clock from "effect/Clock";
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import * as S from "effect/Schema";
+import * as Stream from "effect/Stream";
+import { INSTRUMENTER_CONSTANTS } from "@systemfsoftware/stryker-js-instrumenter/mutants";
+import * as Array$1 from "effect/Array";
+import * as Cause from "effect/Cause";
+import "effect/Exit";
+import * as Predicate from "effect/Predicate";
+import * as Duration from "effect/Duration";
+import { Schema } from "effect";
+import * as HashMap from "effect/HashMap";
+import * as HashSet from "effect/HashSet";
+import { Minimatch } from "minimatch";
+import { encodeWorkerOptions, layerTraceContextClient } from "@systemfsoftware/stryker-js-plugin-runtime";
+import * as Ref from "effect/Ref";
+import * as ChildProcess from "effect/unstable/process/ChildProcess";
+import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
+import { NodeFileSystem, NodePath, NodeSocket, NodeStdio } from "@effect/platform-node";
+import * as NodeChildProcessSpawner from "@effect/platform-node-shared/NodeChildProcessSpawner";
+import * as NodeCrypto from "@effect/platform-node-shared/NodeCrypto";
+import * as Crypto from "effect/Crypto";
+import * as RpcClient from "effect/unstable/rpc/RpcClient";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+import * as Schedule from "effect/Schedule";
+//#region src/Run.schema.ts
+const TypeId = "~stryker/mutation-run/StageError";
+var StageError = class extends S.TaggedError(TypeId)("StageError", {
+	stage: S.Literals([
+		"prepare",
+		"instrument",
+		"dryRun",
+		"dryRunNoTests",
+		"mutationTest"
+	]),
+	reason: S.String,
+	cause: S.optional(S.Defect()),
+	command: S.optional(S.String)
+}) {
+	[TypeId] = TypeId;
+	get exitClass() {
+		return STAGE_PRESENTATION[this.stage].exitClass;
+	}
+	get message() {
+		const failure = `${STAGE_PRESENTATION[this.stage].label} failed: ${this.reason}`;
+		return Match.value(this.command).pipe(Match.when(Match.nonEmptyString, (present) => `${failure} (command: ${present})`), Match.orElse(() => failure));
+	}
+};
+const STAGE_PRESENTATION = {
+	prepare: {
+		label: "Prepare",
+		exitClass: "ConfigError"
+	},
+	instrument: {
+		label: "Instrument",
+		exitClass: "RuntimeError"
+	},
+	dryRun: {
+		label: "Dry run",
+		exitClass: "RuntimeError"
+	},
+	dryRunNoTests: {
+		label: "Dry run",
+		exitClass: "ConfigError"
+	},
+	mutationTest: {
+		label: "Mutation testing",
+		exitClass: "RuntimeError"
+	}
+};
+var PrepareError = class extends S.TaggedError()("PrepareError", {
+	stage: S.Literal("prepare"),
+	reason: S.String
+}) {};
+//#endregion
+//#region src/Config.schema.ts
+const ConfigDocumentSchema = S.Record(S.String, S.Unknown);
+const ImportedModuleSchema = S.Struct({ default: S.optional(S.Unknown) });
+var ConfigFileNotFoundError = class extends S.TaggedError()("ConfigFileNotFoundError", { file: S.String }) {
+	exitClass = "ConfigError";
+};
+var ConfigFileUnsupportedError = class extends S.TaggedError()("ConfigFileUnsupportedError", {
+	file: S.String,
+	hint: S.String
+}) {
+	exitClass = "ConfigError";
+	get message() {
+		return this.hint;
+	}
+};
+var ConfigFileUnreadableError = class extends S.TaggedError()("ConfigFileUnreadableError", {
+	file: S.String,
+	cause: S.Unknown
+}) {
+	exitClass = "ConfigError";
+};
+var ConfigFileInvalidError = class extends S.TaggedError()("ConfigFileInvalidError", {
+	file: S.String,
+	cause: S.Unknown
+}) {
+	exitClass = "ConfigError";
+};
+var ConfigError = class extends S.TaggedError()("ConfigError", { message: S.String }) {
+	exitClass = "ConfigError";
+};
+var ReadConfigCommand = class extends S.TaggedClass()("ReadConfigCommand", {
+	cliOptions: S.Record(S.String, S.Unknown),
+	basePath: S.String
+}) {};
+var MergeCommand = class extends S.TaggedClass()("MergeCommand", {
+	base: S.Record(S.String, S.Unknown),
+	overrides: S.Record(S.String, S.Unknown)
+}) {};
+var MergeResult = class extends S.TaggedClass()("MergeResult", { merged: S.Record(S.String, S.Unknown) }) {};
+const survivorsPriorReport = S.optionalKey(S.String.pipe(S.annotate({ description: "The path of the prior mutation report a --survivors run admits against and re-tests the survivors of. Defaults to \"reports/mutation-report.json\" when unset. Deliberately has no default: a default would be injected into every resolved options object and written into every report, poisoning the KTD7 marker that identifies a report produced by a survivors run." })));
+const extendsPropertySchema = S.optionalKey(S.String.pipe(S.annotate({ description: "Path to another stryker config file whose options merge underneath this one. Resolved relative to this file. A child scalar or array replaces the inherited value; a child object merges one level deep; a child key set to null deletes the inherited key. Inheritance chains are not rewritten, so an inherited relative path value still resolves against the working directory of the run that reads it." })));
+const forkOptionsSchema = S.StructWithRest(S.Struct({
+	...StrykerOptionsSchema.schema.fields,
+	survivorsPriorReport,
+	extends: extendsPropertySchema
+}), [S.Record(S.String, S.Unknown)]);
+//#endregion
+//#region src/Project.ignore.ts
+const ALWAYS_IGNORE = Object.freeze([
+	"node_modules",
+	".git",
+	"*.tsbuildinfo",
+	"/stryker.log",
+	".next",
+	".nuxt",
+	".svelte-kit"
+]);
+const MUTATION_RANGE_REGEX = /(.*?):((\d+)(?::(\d+))?-(\d+)(?::(\d+))?)$/;
+//#endregion
+//#region src/stryker-error.schema.ts
+var StrykerError = class extends Schema.TaggedError()("StrykerError", {
+	message: Schema.String,
+	cause: Schema.optional(Schema.Unknown)
+}) {};
+//#endregion
+//#region src/VmRunner.ts
+var VmRunner = class extends Context.Service()("@systemfsoftware/stryker-js/VmRunner") {};
+const vmRunnerName = "vm";
+const ALL_TESTS_NAME = "All tests";
+const isVmRunner = (name) => name.toLowerCase() === "vm";
+const vmRunnerCapabilities = { reloadEnvironment: true };
+const FALLBACK_FILE_NAME = "stryker-vm-tests.js";
+const errorText = (error) => Match.value(error).pipe(Match.when(Match.instanceOf(Error), (failure) => failure.message), Match.orElse((value) => String(value)));
+const compileFailure = (file, cause) => TestRunnerFailed.make({
+	runnerName: "vm",
+	phase: "init",
+	cause: `Could not compile "${file}" for the in-memory runner: ${errorText(cause)}`
+});
+const compileTests = (platform, fs, testFiles) => Effect.gen(function* () {
+	const sources = yield* Effect.forEach(testFiles, (file) => fs.readFileString(file).pipe(Effect.mapError((cause) => compileFailure(file, cause)), Effect.flatMap((source) => Effect.try({
+		try: () => platform.module.stripTypeScriptTypes(source, { mode: "transform" }),
+		catch: (cause) => compileFailure(file, cause)
+	}))));
+	const fileName = Option.getOrElse(Option.fromUndefinedOr(testFiles.at(0)), () => FALLBACK_FILE_NAME);
+	return {
+		fileName,
+		script: yield* Effect.try({
+			try: () => new platform.vm.Script(sources.join("\n;\n"), { filename: fileName }),
+			catch: (cause) => compileFailure(fileName, cause)
+		})
+	};
+});
+const sandboxFor = (platform, fileName, activeMutantId) => {
+	const namespace = Match.value(activeMutantId).pipe(Match.when(Match.string, (active) => ({ [INSTRUMENTER_CONSTANTS.ACTIVE_MUTANT]: active })), Match.orElse(() => ({})));
+	const moduleExports = {};
+	const moduleObj = { exports: moduleExports };
+	const sandbox = {
+		...globalThis,
+		[INSTRUMENTER_CONSTANTS.NAMESPACE]: namespace,
+		require: platform.module.createRequire(fileName),
+		module: moduleObj,
+		exports: moduleExports,
+		__filename: fileName
+	};
+	sandbox["global"] = sandbox;
+	sandbox["globalThis"] = sandbox;
+	return sandbox;
+};
+const resultFromRun = (failureMessage, timeSpentMs) => Match.value(failureMessage).pipe(Match.when(Match.string, (failure) => ({
+	status: "complete",
+	tests: [{
+		id: "all",
+		name: ALL_TESTS_NAME,
+		status: "failed",
+		failureMessage: failure,
+		timeSpentMs
+	}]
+})), Match.orElse(() => ({
+	status: "complete",
+	tests: [{
+		id: "all",
+		name: ALL_TESTS_NAME,
+		status: "success",
+		timeSpentMs
+	}]
+})));
+const runInFreshContext = (platform, compiled, activeMutantId) => Effect.sync(() => {
+	const context = platform.vm.createContext(sandboxFor(platform, compiled.fileName, activeMutantId));
+	try {
+		compiled.script.runInContext(context);
+		return;
+	} catch (cause) {
+		return errorText(cause);
+	}
+});
+const runOnce = (platform, compiled, activeMutantId) => Effect.gen(function* () {
+	const startedAt = yield* Clock.currentTimeMillis;
+	const failure = yield* runInFreshContext(platform, compiled, activeMutantId);
+	const elapsedMs = (yield* Clock.currentTimeMillis) - startedAt;
+	return resultFromRun(failure, elapsedMs);
+});
+const vmTestRunner = (config) => Effect.gen(function* () {
+	const platform = yield* VmRunner;
+	const fs = yield* FileSystem.FileSystem;
+	const compiled = yield* Ref.make(Option.none());
+	const compiledTests = (testFiles) => Effect.gen(function* () {
+		const cached = yield* Ref.get(compiled);
+		if (Option.isSome(cached)) return cached.value;
+		const tests = yield* compileTests(platform, fs, testFiles);
+		yield* Ref.set(compiled, Option.some(tests));
+		return tests;
+	});
+	const run = (testFiles, activeMutantId) => compiledTests(testFiles).pipe(Effect.flatMap((tests) => runOnce(platform, tests, activeMutantId)));
+	const testFilesOf = (override) => Match.value(config.testFiles).pipe(Match.when((files) => files.length > 0, (files) => files), Match.orElse(() => override ?? []));
+	return {
+		capabilities: Effect.succeed(vmRunnerCapabilities),
+		init: Effect.void,
+		dryRun: (options) => run(testFilesOf(options.testFiles), void 0),
+		mutantRun: (options) => run(config.testFiles, options.activeMutant.id).pipe(Effect.map((result) => toMutantRunResult(result, true)), Effect.catchTag("TestRunnerFailed", (failure) => Effect.succeed(toMutantRunResult({
+			status: "error",
+			errorMessage: failure.cause
+		}, true))))
+	};
+});
+Schema.TaggedError()("WorkerMethodError", {
+	message: Schema.String,
+	name: Schema.optional(Schema.String),
+	stack: Schema.optional(Schema.String)
+});
+/**
+* A process identifier. `S.Int` rather than `S.Number` because the plain number
+* domain admits `NaN` and the infinities, and a pid is none of those.
+*/
+const ProcessId = Schema.Int;
+/**
+* How a child process ended.
+*/
+const ChildExit = Schema.Union([Schema.Struct({
+	_tag: Schema.Literals(["Code"]),
+	code: Schema.Int
+}), Schema.Struct({
+	_tag: Schema.Literals(["Signal"]),
+	signal: Schema.String
+})]);
+/**
+* The child process hosting a worker ended when it was not supposed to.
+*/
+var ChildProcessCrashedError = class extends Schema.TaggedError()("ChildProcessCrashedError", {
+	pid: ProcessId,
+	exit: ChildExit,
+	cause: Schema.optional(Schema.String)
+}) {
+	exitClass = "InternalError";
+};
+var OutOfMemoryError = class extends Schema.TaggedError()("OutOfMemoryError", {
+	pid: ProcessId,
+	exitCode: Schema.Int
+}) {
+	exitClass = "RuntimeError";
+};
+var WorkerBootTimeoutError = class extends Schema.TaggedError()("WorkerBootTimeoutError", { pid: ProcessId }) {
+	exitClass = "InternalError";
+};
+//#endregion
+//#region src/Worker.ts
+var IdGenerator = class extends Context.Service()("@systemfsoftware/stryker-js/Worker/IdGenerator") {};
+const makeIdGenerator = Effect.gen(function* () {
+	const ref = yield* Ref.make(0);
+	return { next: Ref.getAndUpdate(ref, (n) => n + 1) };
+});
+const layer = Layer.effect(IdGenerator)(makeIdGenerator);
+const ASSUMED_PARALLELISM = 4;
+const reportedParallelism = () => {
+	if (typeof globalThis.navigator === "undefined") return void 0;
+	return globalThis.navigator.hardwareConcurrency;
+};
+const getAvailableParallelism = () => {
+	const reported = reportedParallelism();
+	if (typeof reported !== "number") return ASSUMED_PARALLELISM;
+	return reported;
+};
+const PERCENTAGE_OPTION = /^(100|[1-9]?[0-9])%$/;
+const percentageOf = (text) => Option.fromNullishOr(PERCENTAGE_OPTION.exec(text)?.[1]).pipe(Option.map((digits) => Number.parseInt(digits, 10)), Option.getOrUndefined);
+const defaultedTotal = (availableParallelism) => Match.value(availableParallelism > 4).pipe(Match.when(true, () => availableParallelism - 1), Match.orElse(() => availableParallelism));
+const unsetDetails = (availableParallelism) => ({
+	total: defaultedTotal(availableParallelism),
+	isPercentage: false
+});
+const percentageDetails = (text, availableParallelism) => Match.value(percentageOf(text)).pipe(Match.when(Predicate.isNumber, (percentage) => ({
+	total: Math.max(1, Math.round(availableParallelism * percentage / 100)),
+	isPercentage: true
+})), Match.orElse(() => unsetDetails(availableParallelism)));
+const computeTotalConcurrencyDetails = (concurrencyOption, availableParallelism) => Match.value(concurrencyOption).pipe(Match.when(Predicate.isString, (text) => percentageDetails(text, availableParallelism)), Match.when(Predicate.isNumber, (total) => ({
+	total,
+	isPercentage: false
+})), Match.orElse(() => unsetDetails(availableParallelism)));
+const splitConcurrency = (total, checkerCount) => {
+	if (checkerCount > 0) return {
+		checkers: Math.max(Math.ceil(total / 2), 1),
+		testRunners: Math.max(Math.floor(total / 2), 1)
+	};
+	return {
+		testRunners: total,
+		checkers: 0
+	};
+};
+const announcePercentage = (resolved) => Match.value(resolved.isPercentage).pipe(Match.when(true, () => Effect.logDebug(`Computed concurrency ${resolved.total} from "${resolved.option}" based on ${resolved.availableParallelism} available parallelism.`)), Match.orElse(() => Effect.void));
+const announceProcesses = (split) => Match.value(split.checkers > 0).pipe(Match.when(true, () => Effect.logInfo(`Creating ${split.checkers} checker process(es) and ${split.testRunners} test runner process(es).`)), Match.orElse(() => Effect.logInfo(`Creating ${split.testRunners} test runner process(es).`)));
+const makeConcurrency = (options) => Effect.gen(function* () {
+	const availableParallelism = yield* Effect.sync(getAvailableParallelism);
+	const { total, isPercentage } = computeTotalConcurrencyDetails(options.concurrency, availableParallelism);
+	yield* announcePercentage({
+		option: options.concurrency,
+		total,
+		isPercentage,
+		availableParallelism
+	});
+	const result = splitConcurrency(total, options.checkers.length);
+	yield* announceProcesses(result);
+	return result;
+});
+const OUT_OF_MEMORY_EXIT_CODES = [134, 137];
+const isOutOfMemoryExit = (exitCode) => OUT_OF_MEMORY_EXIT_CODES.includes(exitCode);
+const classifyWorkerExit = (pid, exitCode) => Match.value(exitCode).pipe(Match.when(isOutOfMemoryExit, () => OutOfMemoryError.make({
+	pid,
+	exitCode
+})), Match.orElse(() => ChildProcessCrashedError.make({
+	pid,
+	exit: {
+		_tag: "Code",
+		code: exitCode
+	},
+	cause: "worker exited before it accepted the RPC connection"
+})));
+//#endregion
+//#region src/WorkerLauncher.ts
+const connectRetry = Schedule.max([Schedule.spaced(50), Schedule.recurs(100)]);
+var WorkerLauncher = class extends Context.Service()("@systemfsoftware/stryker-js/WorkerLauncher") {};
+const makeWorkerClient = (params) => Effect.gen(function* () {
+	const worker = yield* (yield* WorkerLauncher).spawn({
+		entrypoint: params.entrypoint,
+		workingDirectory: params.workingDirectory,
+		execArgv: params.execArgv,
+		optionsJson: params.optionsJson,
+		tempDirPrefix: params.tempDirPrefix,
+		env: params.env
+	});
+	const protocol = yield* Layer.build(worker.clientLayer).pipe(Effect.retry(connectRetry), Effect.raceFirst(worker.exited), Effect.catchTag("SocketError", () => Effect.fail(WorkerBootTimeoutError.make({ pid: worker.pid }))));
+	return yield* RpcClient.make(params.rpcs).pipe(Effect.provideContext(protocol), Effect.provide(layerTraceContextClient));
+});
+//#endregion
+//#region src/platform/node.ts
+const restrictToOwnerOrWarn = (fs, file) => fs.chmod(file, 384).pipe(Effect.catchTag("PlatformError", (cause) => Effect.logWarning(`Could not restrict "${file}" to its owner; the worker directory's own mode still protects it.`).pipe(Effect.annotateLogs("cause", cause))));
+const restrictSocketToOwnerOrWarn = (fs, socketPath) => Match.value(process.platform).pipe(Match.when("win32", () => Effect.void), Match.orElse(() => restrictToOwnerOrWarn(fs, socketPath)));
+/**
+* The Node worker launcher: spawn a worker child with this runtime's
+* executable, host the RPC server's address as a `net` `path` endpoint (a
+* socket file in the worker directory on POSIX, a same-user named pipe on
+* Windows), and connect the NDJSON protocol client over `NodeSocket`.
+*/
+const nodeWorkerLauncherLayer = Layer.effect(WorkerLauncher, Effect.gen(function* () {
+	const crypto = yield* Crypto.Crypto;
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	return { spawn: (params) => Effect.gen(function* () {
+		const workerDir = yield* fs.makeTempDirectoryScoped({ prefix: params.tempDirPrefix });
+		const workerId = yield* crypto.randomUUIDv4;
+		const socketPath = Match.value(process.platform).pipe(Match.when("win32", () => `\\\\.\\pipe\\stryker-worker-${workerId}`), Match.orElse(() => path.join(workerDir, "worker.sock")));
+		const optionsFile = path.join(workerDir, "options.json");
+		yield* fs.writeFileString(optionsFile, params.optionsJson);
+		yield* restrictToOwnerOrWarn(fs, optionsFile);
+		const entrypointPath = yield* path.fromFileUrl(new URL(params.entrypoint));
+		const handle = yield* ChildProcess.make(process.execPath, [...params.execArgv, entrypointPath], {
+			cwd: params.workingDirectory,
+			extendEnv: true,
+			env: {
+				STRYKER_WORKER_DIR: workerDir,
+				STRYKER_SOCKET: socketPath,
+				...params.env
+			},
+			stderr: "inherit"
+		}).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner));
+		const clientLayer = RpcClient.layerProtocolSocket({ retryTransientErrors: true }).pipe(Layer.provide(NodeSocket.layerNet({ path: socketPath })), Layer.provide(RpcSerialization.layerNdjson), Layer.tap(() => restrictSocketToOwnerOrWarn(fs, socketPath)));
+		const exited = handle.exitCode.pipe(Effect.orDie, Effect.flatMap((exitCode) => Effect.fail(classifyWorkerExit(Number(handle.pid), exitCode))));
+		return {
+			pid: Number(handle.pid),
+			clientLayer,
+			exited
+		};
+	}).pipe(Effect.catchIf(S.is(ChildProcessCrashedError), (error) => Effect.fail(error), () => Effect.fail(ChildProcessCrashedError.make({
+		pid: 0,
+		exit: {
+			_tag: "Code",
+			code: 1
+		},
+		cause: "worker spawn failed"
+	})))) };
+}));
+const nodeFsPathLayer = Layer.mergeAll(NodeFileSystem.layer, NodePath.layer);
+const nodeSpawnerLayer = NodeChildProcessSpawner.layer.pipe(Layer.provide(nodeFsPathLayer));
+const nodeBase = Layer.mergeAll(nodeFsPathLayer, nodeSpawnerLayer, NodeStdio.layer);
+const nodePlatformLayer = Layer.mergeAll(nodeWorkerLauncherLayer.pipe(Layer.provide(Layer.merge(nodeBase, NodeCrypto.layer))), nodeBase);
+/**
+* The in-memory runner's platform: the V8 sandbox module and the module
+* builtin that strips TypeScript and resolves a sandbox's `require`.
+*
+* Reached through `process.getBuiltinModule` rather than an `import` because a
+* Node builtin import is forbidden in product code; the call is wrapped in
+* `Effect.promise` so a platform without `node:vm` fails as a defect — the
+* runner has no fallback to fall back to.
+*/
+const nodeVmPlatformLayer = Layer.effect(VmRunner, Effect.sync(() => ({
+	module: process.getBuiltinModule("node:module"),
+	vm: process.getBuiltinModule("node:vm")
+})));
+S.TaggedError()("CommandRunnerUnsupportedOption", { option: S.String });
+S.Struct({
+	static: S.Record(S.String, S.Finite),
+	perTest: S.Record(S.String, S.Record(S.String, S.Finite))
+});
+//#endregion
+//#region src/TestRunner.ts
+/**
+* The test runner capability — spawning, timeout, retry, reuse and environment
+* decisions for the engine's test execution.
+*/
+const toRunnerBootFailure = (runnerName) => (error) => Match.value(error).pipe(Match.tag("WorkerBootTimeoutError", (timeout) => TestRunnerFailed.make({
+	runnerName,
+	phase: "init",
+	cause: `Worker ${timeout.pid} did not accept the RPC connection before its boot window closed; its stderr above carries the reason`
+})), Match.tag("ChildProcessCrashedError", (crashed) => crashed), Match.tag("OutOfMemoryError", (outOfMemory) => outOfMemory), Match.exhaustive);
+const toRunnerFailure = (runnerName, phase) => (error) => Match.value(error).pipe(Match.tag("TestRunnerFailed", (e) => e), Match.orElse((e) => TestRunnerFailed.make({
+	runnerName,
+	phase,
+	cause: e.message
+})));
+/**
+* A test runner that runs in a child process.
+*
+* Spawning happens **once**, here, and the child's teardown is a finalizer on the
+* scope this Effect is acquired in — which is the scope `Pool.make` opens for one
+* worker. So a worker lives as long as its pool slot, and each `dryRun` or
+* `mutantRun` only sends a message to a process that is already up.
+*
+* The scope boundary is the whole correctness question. Putting it inside each
+* method type-checks identically and spawns a Node process per mutant, which
+* makes the pool hold nothing and pays worker startup thousands of times.
+*
+* A failed spawn stays a typed failure rather than a defect, because
+* `Pool.invalidate` and the crash-retry combinator can only act on a failure they
+* can see.
+*/
+const makeChildProcessTestRunner = (params) => Effect.gen(function* () {
+	const runnerName = params.options.testRunner;
+	const optionsJson = yield* encodeWorkerOptions(params.options);
+	const client = yield* makeWorkerClient({
+		rpcs: TestRunnerRpcs,
+		entrypoint: params.workerEntrypoint,
+		workingDirectory: params.sandboxWorkingDirectory,
+		execArgv: [...params.options.testRunnerNodeArgs],
+		optionsJson,
+		tempDirPrefix: "stryker-test-runner-",
+		env: {
+			NODE_ENV: "test",
+			VITEST: "1",
+			STRYKER_SANDBOX_DIR: params.sandboxWorkingDirectory
+		}
+	}).pipe(Effect.mapError(toRunnerBootFailure(runnerName)));
+	return {
+		capabilities: client.capabilities().pipe(Effect.mapError(toRunnerFailure(runnerName, "capabilities"))),
+		init: Effect.void,
+		dryRun: (options) => client.dryRun({ options }).pipe(Effect.mapError(toRunnerFailure(runnerName, "dryRun"))),
+		mutantRun: (options) => client.mutantRun({ options }).pipe(Effect.mapError(toRunnerFailure(runnerName, "mutantRun")))
+	};
+});
+/**
+* Report a run that outlives its timeout as a timed-out result.
+*
+* `Effect.timeoutOrElse` is the race, and retiring the worker belongs to the
+* pool, which invalidates it. An interrupted `Effect` is cancelled, where a
+* losing `Promise` was not.
+*/
+const withTimeout = (inner) => ({
+	...inner,
+	dryRun: (options) => {
+		const policy = Effect.timeoutOrElse({
+			duration: Duration.millis(options.timeout),
+			orElse: () => Effect.succeed({ status: "timeout" })
+		});
+		return inner.dryRun(options).pipe(policy);
+	},
+	mutantRun: (options) => {
+		const policy = Effect.timeoutOrElse({
+			duration: Duration.millis(options.timeout),
+			orElse: () => Effect.succeed({ status: "timeout" })
+		});
+		return inner.mutantRun(options).pipe(policy);
+	}
+});
+/**
+* Retry a run whose runner crashed, and report the crash as a result once the
+* attempts are spent.
+*
+* Every failure is retried, not only out-of-memory; the out-of-memory check
+* only changes the log message. On exhaustion the combinator produces a
+* `status: Error` result rather than failing, because one broken runner must
+* not end the whole run. The exhausted message renders the `Cause`, which
+* keeps the chain that led there.
+*/
+const withRetry = (inner) => {
+	const attempt = (run, onExhausted) => run.pipe(Effect.tapError((error) => Match.value(error).pipe(Match.when(S.is(OutOfMemoryError), (outOfMemory) => Effect.logInfo(`Test runner process [${outOfMemory.pid}] ran out of memory. That usually means the tests leak memory. Stryker restarts the process and carries on, but the run is slower for it.`)), Match.orElse(() => Effect.void))), Effect.retry({ times: 2 }), Effect.catchCause((cause) => Effect.succeed(onExhausted(`Test runner crashed. Tried 2 times to restart it without any luck. ${Cause.pretty(cause)}`))));
+	return {
+		...inner,
+		dryRun: (options) => attempt(inner.dryRun(options), (errorMessage) => ({
+			status: "error",
+			errorMessage
+		})),
+		mutantRun: (options) => attempt(inner.mutantRun(options), (errorMessage) => ({
+			status: "error",
+			errorMessage
+		}))
+	};
+};
+/**
+* Retire a runner after a configured number of mutant runs.
+*
+* The count lives in a `Ref` the combinator closes over, so nothing outside can
+* read or reset it. `retire` is supplied rather than being a `recover()` the
+* runner performs on itself: the pool owns worker lifetime, so retiring one is
+* `Pool.invalidate`, and a runner that restarts itself behind the pool's back
+* would create two owners of one process.
+*/
+const withMaxReuse = (options, retire) => (inner) => Effect.gen(function* () {
+	const restartAfter = options.maxTestRunnerReuse;
+	if (restartAfter <= 0) return inner;
+	const runs = yield* Ref.make(0);
+	return {
+		...inner,
+		mutantRun: (runOptions) => {
+			const policy = (self) => Effect.gen(function* () {
+				if ((yield* Ref.updateAndGet(runs, (n) => n + 1)) > restartAfter) {
+					yield* retire;
+					yield* Ref.set(runs, 1);
+				}
+				return yield* self;
+			});
+			return policy(inner.mutantRun(runOptions));
+		}
+	};
+});
+const stateNeedsReload = (requested, current) => Match.value(requested).pipe(Match.when(true, () => current !== "pristine"), Match.orElse(() => current === "loaded-static-mutant"));
+const reloadsEnvironment = (request) => request.canReload && stateNeedsReload(request.requested, request.current);
+const retiresWorker = (request) => !request.canReload && request.current === "loaded-static-mutant";
+const stateAfterRun = (requested) => Match.value(requested).pipe(Match.when(true, () => "loaded-static-mutant"), Match.orElse(() => "loaded"));
+const environmentPlan = (request) => ({
+	reloadEnvironment: reloadsEnvironment(request),
+	retire: retiresWorker(request),
+	nextState: stateAfterRun(request.requested)
+});
+/**
+* Decide whether the test environment must be reloaded before a mutant runs.
+*
+* The decision produces a new options value; the caller's options are not
+* mutated, so a caller that reuses its own options does not read a value it
+* never wrote.
+*/
+const withEnvironmentReload = (retire) => (inner) => Effect.gen(function* () {
+	const state = yield* Ref.make("pristine");
+	return {
+		...inner,
+		dryRun: (options) => {
+			const policy = (self) => Ref.set(state, "loaded").pipe(Effect.andThen(self));
+			return policy(inner.dryRun(options));
+		},
+		mutantRun: (options) => Effect.gen(function* () {
+			const current = yield* Ref.get(state);
+			const canReload = (yield* inner.capabilities).reloadEnvironment;
+			const plan = environmentPlan({
+				requested: options.reloadEnvironment,
+				current,
+				canReload
+			});
+			if (plan.retire) yield* retire;
+			const policy = (self) => Effect.gen(function* () {
+				const result = yield* self;
+				yield* Ref.set(state, plan.nextState);
+				return result;
+			});
+			return yield* policy(inner.mutantRun({
+				...options,
+				reloadEnvironment: plan.reloadEnvironment
+			}));
+		})
+	};
+});
+/** "command" — the name this runner answers to in the options. */
+const commandRunnerName = "command";
+/** Whether a configured runner name selects this runner. */
+const isCommandRunner = (name) => name.toLowerCase() === commandRunnerName;
+/** Each call is a fresh process, so the environment is always reloadable. */
+const commandRunnerCapabilities = { reloadEnvironment: true };
+/** One test result standing for the whole command, decided by its exit code. */
+const resultFromExit = (exitCode, output, timeSpentMs) => {
+	if (exitCode === 0) return {
+		status: "complete",
+		tests: [{
+			id: "all",
+			name: ALL_TESTS_NAME,
+			status: "success",
+			timeSpentMs
+		}]
+	};
+	return {
+		status: "complete",
+		tests: [{
+			id: "all",
+			name: ALL_TESTS_NAME,
+			status: "failed",
+			failureMessage: output,
+			timeSpentMs
+		}]
+	};
+};
+const mutantActivation = (activeMutantId) => Match.value(activeMutantId).pipe(Match.when(Predicate.isString, (id) => ({
+	env: { [INSTRUMENTER_CONSTANTS.ACTIVE_MUTANT_ENV_VARIABLE]: id },
+	extendEnv: true
+})), Match.orElse(() => void 0));
+const spawnResult = (outcome, elapsed) => Match.value(outcome).pipe(Match.tag("Failure", (failed) => ({
+	status: "error",
+	errorMessage: String(failed.cause)
+})), Match.tag("Success", (exited) => resultFromExit(exited.value.exitCode, exited.value.output, elapsed)), Match.exhaustive);
+/**
+* Run the configured command once.
+*
+* `activeMutantId` is threaded through the environment rather than the command
+* line, which is how the instrumented code finds the mutant to activate.
+*/
+const runCommand = (config, activeMutantId) => Effect.gen(function* () {
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const startedAt = yield* Clock.currentTimeMillis;
+	const command = ChildProcess.make(config.options.commandRunner.command, {
+		shell: true,
+		cwd: config.workingDir,
+		...mutantActivation(activeMutantId)
+	});
+	const outcome = yield* Effect.scoped(Effect.gen(function* () {
+		const handle = yield* spawner.spawn(command);
+		return {
+			output: yield* Stream.mkString(Stream.decodeText(handle.all)),
+			exitCode: yield* handle.exitCode
+		};
+	})).pipe(Effect.exit);
+	const elapsed = (yield* Clock.currentTimeMillis) - startedAt;
+	return spawnResult(outcome, elapsed);
+});
+/** Run the tests with no mutant active, to establish the baseline. */
+const commandRunnerDryRun = (config) => runCommand(config, void 0);
+/** Run the tests with one mutant active. */
+const commandRunnerMutantRun = (config, { activeMutant }) => runCommand(config, activeMutant.id).pipe(Effect.map((result) => toMutantRunResult(result, true)));
+/**
+* The command runner, wrapped in the two adjustments that apply to it.
+*
+* No reuse limit and no environment reload, because every call is a new
+* process: there is nothing to reuse and nothing loaded to reload. The
+* combinators applied are the list that remains.
+*
+* The spawner is provided into each operation here rather than appearing in the
+* port's `R`. A port that named its own dependencies would make every consumer
+* discover and supply them (`REPO-A3`), and the service is built exactly where
+* the spawner is already in scope.
+*/
+const commandRunner = (context, spawner) => {
+	const config = {
+		workingDir: context.sandboxWorkingDirectory,
+		options: context.options
+	};
+	const provided = Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner);
+	const base = {
+		capabilities: Effect.succeed(commandRunnerCapabilities),
+		init: Effect.void,
+		dryRun: () => commandRunnerDryRun(config).pipe(provided),
+		mutantRun: (options) => commandRunnerMutantRun(config, options).pipe(provided)
+	};
+	return withRetry(withTimeout(base));
+};
+const inProcessRunner = (context) => Match.value(context.options.testRunner).pipe(Match.when(isCommandRunner, () => Option.some(ChildProcessSpawner.ChildProcessSpawner.pipe(Effect.map((spawner) => commandRunner(context, spawner))))), Match.when(isVmRunner, () => Option.some(vmTestRunner({ testFiles: context.testFiles }).pipe(Effect.provide(nodeVmPlatformLayer)))), Match.orElse(() => Option.none()));
+const buildTestRunner = (context, childProcessRunner) => Effect.gen(function* () {
+	const inProcess = inProcessRunner(context);
+	if (Option.isSome(inProcess)) return yield* inProcess.value;
+	const base = yield* childProcessRunner;
+	const timed = withTimeout(base);
+	const limited = yield* withMaxReuse(context.options, context.retire)(timed);
+	const reloading = yield* withEnvironmentReload(context.retire)(limited);
+	return withRetry(reloading);
+});
+//#endregion
+//#region src/run/load-config.cell.ts
+const isNonNullObject = (value) => typeof value === "object" && value !== null;
+const optionsPath = (...path) => path.join(".");
+const combine = (prefixes, suffixes, extensions) => prefixes.flatMap((prefix) => suffixes.flatMap((suffix) => extensions.map((extension) => `${prefix}stryker${suffix}.${extension}`)));
+const CONFIG_FILE_NAME_PREFIXES = ["", "."];
+const CONFIG_FILE_NAME_SUFFIXES = [".conf", ".config"];
+const SUPPORTED_CONFIG_FILE_EXTENSIONS = [
+	"ts",
+	"mts",
+	"js",
+	"mjs"
+];
+const LEGACY_CONFIG_FILE_EXTENSIONS = ["json", "cjs"];
+const configFileNames = (extensions) => combine([...CONFIG_FILE_NAME_PREFIXES], [...CONFIG_FILE_NAME_SUFFIXES], [...extensions]);
+const SUPPORTED_CONFIG_FILE_NAMES = Object.freeze(configFileNames(SUPPORTED_CONFIG_FILE_EXTENSIONS));
+const LEGACY_CONFIG_FILE_NAMES = Object.freeze(configFileNames(LEGACY_CONFIG_FILE_EXTENSIONS));
+const SUPPORTED_CONFIG_FILE_EXTENSION_GUIDE = `one of these extensions: ${SUPPORTED_CONFIG_FILE_EXTENSIONS.map((extension) => `.${extension}`).join(", ")}`;
+const legacyConfigHint = (file) => `Stryker no longer reads JSON or CommonJS config files. Convert "${file}" to a config module with an "export default { ... }" object — Stryker reads config modules with ${SUPPORTED_CONFIG_FILE_EXTENSION_GUIDE} — and delete the legacy file.`;
+const unsupportedConfigHint = (file) => `"${file}" is not a supported config file. Stryker reads config modules with ${SUPPORTED_CONFIG_FILE_EXTENSION_GUIDE}, for example "stryker.config.ts" with an "export default { ... }" object.`;
+const extendsChildHint = (file) => `The extended config "${file}" is a JSON or CommonJS config file, which Stryker no longer reads. Convert it to a config module — Stryker reads config modules with ${SUPPORTED_CONFIG_FILE_EXTENSION_GUIDE} — and point "extends" at the converted file.`;
+const shadowedLegacyWarning = (legacyFile, supportedFile) => `Ignoring the legacy config file "${legacyFile}": "${supportedFile}" is the config Stryker reads. Stryker no longer reads JSON or CommonJS config files; delete the legacy file.`;
+const isArrayValue = (value) => Array.isArray(value);
+const freezeArrayValue = (value) => Object.freeze(value.map(deepFreeze));
+const freezeMapEntry = ([entryKey, entryValue]) => [deepFreeze(entryKey), deepFreeze(entryValue)];
+const freezeMapValue = (value) => Object.freeze(new Map([...value.entries()].map(freezeMapEntry)));
+const freezeSetValue = (value) => Object.freeze(new Set([...value.values()].map(deepFreeze)));
+const freezeRegExpValue = (value) => Object.freeze(value);
+const freezeRecordValue = (value) => Object.freeze(Object.entries(value).reduce((frozen, [property, propertyValue]) => {
+	frozen[property] = deepFreeze(propertyValue);
+	return frozen;
+}, {}));
+function deepFreeze(target) {
+	return Match.value(target).pipe(Match.when(isArrayValue, freezeArrayValue), Match.when((value) => value instanceof Map, freezeMapValue), Match.when((value) => value instanceof RegExp, freezeRegExpValue), Match.when((value) => value instanceof Set, freezeSetValue), Match.when(isNonNullObject, freezeRecordValue), Match.orElse(() => target));
+}
+const scopedUnserializable = (scope) => (description) => ({
+	...description,
+	path: [scope, ...description.path]
+});
+const describeUnserializableChild = (child, scope) => Match.value(findUnserializables(child)).pipe(Match.when(void 0, () => []), Match.orElse((descriptions) => descriptions.map(scopedUnserializable(scope))));
+const collectUnserializables = (groups) => {
+	const found = groups.flat();
+	if (found.length > 0) return found;
+};
+const describeUnserializableArray = (value) => collectUnserializables(value.map((child, index) => describeUnserializableChild(child, index.toString())));
+const describeUnserializableRecord = (value) => collectUnserializables(Object.entries(value).map(([key, child]) => describeUnserializableChild(child, key)));
+const isPlainObjectValue = (value) => !Array.isArray(value) && value.constructor === Object;
+const classNameOf = (value) => Match.value(value.constructor).pipe(Match.when(Match.defined, (ctor) => ctor.name), Match.orElse(() => "Object"));
+const describeUnserializableInstance = (value) => [{
+	path: [],
+	reason: `Value is an instance of "${classNameOf(value)}", this detail will get lost in translation during serialization`
+}];
+const describeUnserializableObject = (value) => Match.value(value).pipe(Match.when(isArrayValue, describeUnserializableArray), Match.when(isPlainObjectValue, describeUnserializableRecord), Match.orElse(describeUnserializableInstance));
+const NON_JSON_PRIMITIVE_TYPES = [
+	"bigint",
+	"function",
+	"symbol"
+];
+const isNonJsonPrimitive = (value) => NON_JSON_PRIMITIVE_TYPES.includes(typeof value);
+const describeNonJsonPrimitive = (value) => [{
+	path: [],
+	reason: `Primitive type "${typeof value}" has no JSON representation`
+}];
+const describeNumber = (value) => {
+	if (isFinite(value)) return void 0;
+	return [{
+		reason: `Number value \`${value}\` has no JSON representation`,
+		path: []
+	}];
+};
+function findUnserializables(thing) {
+	return Match.value(thing).pipe(Match.when((value) => typeof value === "number", describeNumber), Match.when(isNonJsonPrimitive, describeNonJsonPrimitive), Match.when(isNonNullObject, describeUnserializableObject), Match.orElse(() => void 0));
+}
+function isWarningEnabled(warningType, warningOptions) {
+	if (typeof warningOptions === "boolean") return warningOptions;
+	else return warningOptions[warningType] === true;
+}
+const PATH_LINE = /^at\s+(\[.*\])$/;
+const PATH_SEGMENT = /\["([^"]*)"\]|\[(\d+)\]/g;
+const EXPECTED_PATTERN = /^Expected a string matching the RegExp (.+)$/;
+const EXPECTED_TYPE = /^Expected (.+)$/;
+const appendPathSegment = (path, segment) => Match.value(segment[2]).pipe(Match.when(void 0, () => appendKeySegment(path, segment[1] ?? "")), Match.orElse((index) => `${path}[${index}]`));
+const appendKeySegment = (path, key) => Match.value(path.length > 0).pipe(Match.when(true, () => `${path}.${key}`), Match.orElse(() => `${path}${key}`));
+const dottedPath = (raw) => Array.from(raw.matchAll(PATH_SEGMENT)).reduce(appendPathSegment, "");
+const phraseExpectedType = (expectation) => Match.value(EXPECTED_TYPE.exec(expectation)).pipe(Match.when((match) => match !== null, (match) => `should be ${match[1] ?? ""}`), Match.orElse(() => expectation));
+const phrase = (expectation) => Match.value(EXPECTED_PATTERN.exec(expectation)).pipe(Match.when((match) => match !== null, (match) => `must match pattern "${match[1] ?? ""}"`), Match.orElse(() => phraseExpectedType(expectation)));
+const EMPTY_ERROR_DESCRIPTION_STATE = {
+	messages: [],
+	expectation: void 0
+};
+const isBlankLine = (line) => line.length === 0;
+const startExpectation = (state, line) => Match.value(state.expectation).pipe(Match.when(void 0, () => ({
+	messages: state.messages,
+	expectation: line
+})), Match.orElse((pending) => ({
+	messages: [...state.messages, pending],
+	expectation: line
+})));
+const completeExpectation = (state, pathText, line) => Match.value(state.expectation).pipe(Match.when(void 0, () => startExpectation(state, line)), Match.orElse((pending) => ({
+	messages: [...state.messages, `Config option "${dottedPath(pathText)}" ${phrase(pending)}.`],
+	expectation: void 0
+})));
+const applyErrorLine = (state, line) => Match.value(PATH_LINE.exec(line)).pipe(Match.when((match) => match !== null, (match) => completeExpectation(state, match[1] ?? "", line)), Match.orElse(() => startExpectation(state, line)));
+const advanceErrorDescription = (state, rawLine) => Match.value(rawLine.trim()).pipe(Match.when(isBlankLine, () => state), Match.orElse((line) => applyErrorLine(state, line)));
+const completedErrorMessages = (state) => Match.value(state.expectation).pipe(Match.when(void 0, () => state.messages), Match.orElse((pending) => [...state.messages, pending]));
+const errorMessageOrFallback = (messages, fallback) => Match.value(messages.length > 0).pipe(Match.when(true, () => [...messages]), Match.orElse(() => [fallback]));
+function describeErrors(error) {
+	const state = error.message.split("\n").reduce(advanceErrorDescription, EMPTY_ERROR_DESCRIPTION_STATE);
+	return errorMessageOrFallback(completedErrorMessages(state), error.message);
+}
+function importModule(moduleName) {
+	return Effect.tryPromise({
+		try: () => import(moduleName),
+		catch: (cause) => StrykerError.make({
+			message: `Failed to import module "${moduleName}"`,
+			cause
+		})
+	});
+}
+const initialExtendsStepState = {
+	visited: [],
+	documents: []
+};
+const DoneTag = { _tag: "done" };
+const ReadTag = { _tag: "read" };
+const ResolveTag = { _tag: "resolve" };
+const RefusedTag = { _tag: "refused" };
+const asUnknownArray = (value) => {
+	if (Array.isArray(value)) return value;
+	return [];
+};
+const isFirstDescriptorOccurrence = (descriptors) => (descriptor, index) => typeof descriptor !== "string" || descriptors.slice(0, index).includes(descriptor) === false;
+const mergePluginDescriptors = (parentPlugins, childPlugins) => {
+	const merged = [...parentPlugins, ...childPlugins];
+	return merged.filter(isFirstDescriptorOccurrence(merged));
+};
+const inheritNested = (parentValue, childValue) => Match.value(parentValue).pipe(Match.when((value) => isNonNullObject(value) && Array.isArray(value) === false, (parentNested) => Match.value(childValue).pipe(Match.when((value) => isNonNullObject(value) && Array.isArray(value) === false, (childNested) => ({
+	...parentNested,
+	...childNested
+})), Match.orElse(() => childValue))), Match.orElse(() => childValue));
+const inheritEntry = (out, key, parentValue, childValue) => Match.value(childValue).pipe(Match.when(null, () => {
+	const next = { ...out };
+	delete next[key];
+	return next;
+}), Match.orElse(() => Match.value(key).pipe(Match.when("plugins", () => ({
+	...out,
+	[key]: mergePluginDescriptors(asUnknownArray(parentValue), asUnknownArray(childValue))
+})), Match.orElse(() => ({
+	...out,
+	[key]: inheritNested(parentValue, childValue)
+})))));
+function mergeConfigs(parent, child) {
+	return Object.entries(child).reduce((out, entry) => inheritEntry(out, entry[0], parent[entry[0]], entry[1]), { ...parent });
+}
+const RELATIVE_SPECIFIER_PREFIXES = [
+	"./",
+	"../",
+	"/",
+	"\\"
+];
+function isModuleSpecifier(value) {
+	return RELATIVE_SPECIFIER_PREFIXES.every((prefix) => value.startsWith(prefix) === false);
+}
+const stripExtends = (document) => {
+	const { extends: _ignored, ...rest } = document;
+	return rest;
+};
+const mergeChainDocuments = (documents) => documents.reduceRight((merged, entry) => mergeConfigs(merged, stripExtends(entry.options)), {});
+const decideExtendsStep = (state, document, file, pathService) => {
+	if (state.visited.includes(file)) return {
+		...RefusedTag,
+		reason: "cycle",
+		file
+	};
+	const nextState = {
+		visited: [...state.visited, file],
+		documents: [...state.documents, {
+			path: file,
+			options: document
+		}]
+	};
+	return Match.value(document["extends"]).pipe(Match.when(void 0, () => ({
+		...DoneTag,
+		options: mergeChainDocuments(nextState.documents)
+	})), Match.when(null, () => ({
+		...DoneTag,
+		options: mergeChainDocuments(nextState.documents)
+	})), Match.when(Match.string, (extendValue) => Match.value(isModuleSpecifier(extendValue)).pipe(Match.when(true, () => ({
+		...ResolveTag,
+		specifier: extendValue,
+		state: nextState
+	})), Match.when(false, () => ({
+		...ReadTag,
+		path: pathService.resolve(pathService.dirname(file), extendValue),
+		state: nextState
+	})), Match.exhaustive)), Match.orElse(() => ({
+		...RefusedTag,
+		reason: "non-string-extends",
+		file
+	})));
+};
+const decodeConfigDocument = (configFile, document) => S.decodeUnknownEffect(ConfigDocumentSchema)(document).pipe(Effect.mapError((cause) => ConfigFileInvalidError.make({
+	file: configFile,
+	cause
+})));
+const requireDefaultExport = (configFile, defaultExport) => Match.value(defaultExport).pipe(Match.when(void 0, () => Effect.fail(ConfigFileInvalidError.make({
+	file: configFile,
+	cause: "Config file must have a default export!"
+}))), Match.when(isNonNullObject, (value) => Effect.succeed(value)), Match.orElse(() => Effect.fail(ConfigFileInvalidError.make({
+	file: configFile,
+	cause: "Default export of config file must be an object!"
+}))));
+const isConfigFactory = (value) => typeof value === "function";
+const factoryFailureCause = (cause) => Match.value(cause).pipe(Match.when(Match.instanceOf(Error), (error) => new Error(`Evaluating the config module's exported factory failed: ${error.message}`, { cause: error })), Match.orElse(() => cause));
+/**
+* Settle a config module's default export into the object the document schema decodes.
+*
+* `./config` types `defineConfig` as accepting the config object, a promise of it,
+* or a factory receiving `ConfigEnv`, so the loader accepts all three. The factory
+* is invoked here because this is the only place that knows the invocation the
+* config is being read for; the promise is awaited here because a promise is a
+* non-null object and would otherwise reach the document decoder as one.
+*/
+const settleConfigDefault = (configFile, defaultExport, configEnv) => Effect.tryPromise({
+	try: () => Promise.resolve(defaultExport).then((exported) => Match.value(exported).pipe(Match.when(isConfigFactory, (factory) => factory(configEnv)), Match.orElse((value) => value))),
+	catch: (cause) => ConfigFileInvalidError.make({
+		file: configFile,
+		cause: factoryFailureCause(cause)
+	})
+}).pipe(Effect.flatMap((settled) => requireDefaultExport(configFile, settled)));
+const ERASABLE_SYNTAX_HELP = "Config modules may use only erasable TypeScript syntax: no enums, no namespaces with runtime code, no parameter properties, and no decorators.";
+const carriesCode = (cause) => cause instanceof Error && "code" in cause;
+const errorCodeOf = (cause) => {
+	const code = Match.value(cause).pipe(Match.when(carriesCode, (error) => error.code), Match.orElse(() => void 0));
+	if (typeof code === "string") return code;
+};
+const errorMessageOf = (cause) => {
+	const message = Match.value(cause).pipe(Match.when(Match.instanceOf(Error), (error) => error.message), Match.orElse(() => void 0));
+	if (typeof message === "string") return message;
+};
+const importFailureDetail = (failure) => errorMessageOf(failure.cause) ?? failure.message;
+const configImportCause = (configFile, failure) => Match.value(errorCodeOf(failure.cause)).pipe(Match.when("ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX", () => new Error(`The config file "${configFile}" uses TypeScript syntax Node cannot execute. ${ERASABLE_SYNTAX_HELP}`, { cause: failure.cause })), Match.when("ERR_UNKNOWN_FILE_EXTENSION", () => new Error(`The config file "${configFile}" has an extension Node cannot load. Stryker reads config modules with ${SUPPORTED_CONFIG_FILE_EXTENSION_GUIDE}.`, { cause: failure.cause })), Match.when("ERR_MODULE_NOT_FOUND", () => new Error(`The config file "${configFile}" imports a module Node cannot find. The specifier is most likely not installed — install it as a dependency of the project, or remove the import. Node reported: ${importFailureDetail(failure)}`, { cause: failure.cause })), Match.when("ERR_PACKAGE_PATH_NOT_EXPORTED", () => new Error(`The config file "${configFile}" imports a path a package does not export. The package is installed but its "exports" map leaves this specifier out — import a path the package publishes. Node reported: ${importFailureDetail(failure)}`, { cause: failure.cause })), Match.orElse(() => failure));
+const configModuleUrl = (configFile, pathService) => Match.value(configFile.startsWith("file:")).pipe(Match.when(true, () => Effect.try({
+	try: () => new URL(configFile),
+	catch: (cause) => ConfigFileUnreadableError.make({
+		file: configFile,
+		cause
+	})
+})), Match.orElse(() => pathService.toFileUrl(pathService.resolve(configFile)).pipe(Effect.mapError((cause) => ConfigFileUnreadableError.make({
+	file: configFile,
+	cause
+})))));
+const readConfigModule = (configFile, configEnv) => Effect.gen(function* () {
+	const pathService = yield* Path.Path;
+	const importedModule = yield* importModule((yield* configModuleUrl(configFile, pathService)).href).pipe(Effect.mapError((failure) => ConfigFileUnreadableError.make({
+		file: configFile,
+		cause: configImportCause(configFile, failure)
+	})));
+	const exported = yield* S.decodeUnknownEffect(ImportedModuleSchema)(importedModule).pipe(Effect.mapError((cause) => ConfigFileInvalidError.make({
+		file: configFile,
+		cause
+	})), Effect.map((decoded) => decoded.default));
+	const document = yield* settleConfigDefault(configFile, exported, configEnv);
+	return yield* decodeConfigDocument(configFile, document);
+});
+const configFileExtension = (configFile, pathService) => pathService.extname(configFile).toLowerCase().slice(1);
+const isLegacyConfigFile = (configFile, pathService) => LEGACY_CONFIG_FILE_EXTENSIONS.includes(configFileExtension(configFile, pathService));
+const readExtendsChild = (configFile, configEnv) => Effect.gen(function* () {
+	const pathService = yield* Path.Path;
+	return yield* Match.value(isLegacyConfigFile(configFile, pathService)).pipe(Match.when(true, () => Effect.fail(ConfigFileUnsupportedError.make({
+		file: configFile,
+		hint: extendsChildHint(configFile)
+	}))), Match.orElse(() => readConfigModule(configFile, configEnv)));
+});
+const canonicalConfigFile = (file, pathService) => Match.value(file.startsWith("file:")).pipe(Match.when(true, () => Effect.try({
+	try: () => new URL(file),
+	catch: (cause) => ConfigFileUnreadableError.make({
+		file,
+		cause
+	})
+}).pipe(Effect.flatMap((url) => pathService.fromFileUrl(url).pipe(Effect.mapError((cause) => ConfigFileUnreadableError.make({
+	file,
+	cause
+})))))), Match.orElse(() => Effect.succeed(pathService.resolve(file))));
+function resolveExtendsSpecifier(specifier) {
+	return Effect.try({
+		try: () => import.meta.resolve(specifier),
+		catch: (cause) => ConfigFileUnreadableError.make({
+			file: specifier,
+			cause
+		})
+	});
+}
+function resolveExtends(configFile, document, configEnv) {
+	return Effect.gen(function* () {
+		const pathService = yield* Path.Path;
+		const loop = (state, file, currentDocument) => Effect.gen(function* () {
+			const canonicalFile = yield* canonicalConfigFile(file, pathService);
+			return yield* Match.value(decideExtendsStep(state, currentDocument, canonicalFile, pathService)).pipe(Match.tag("done", (d) => Effect.succeed(d.options)), Match.tag("read", (d) => readExtendsChild(d.path, configEnv).pipe(Effect.flatMap((nextDocument) => loop(d.state, d.path, nextDocument)))), Match.tag("resolve", (d) => resolveExtendsSpecifier(d.specifier).pipe(Effect.flatMap((resolvedUrl) => readExtendsChild(resolvedUrl, configEnv).pipe(Effect.flatMap((nextDocument) => loop(d.state, resolvedUrl, nextDocument)))))), Match.tag("refused", (d) => {
+				let message = `Invalid config file "${d.file}". "extends" must be a string`;
+				if (d.reason === "cycle") message = `Config inheritance cycle detected at "${d.file}"`;
+				return Effect.fail(ConfigFileInvalidError.make({
+					file: d.file,
+					cause: message
+				}));
+			}), Match.exhaustive);
+		});
+		return yield* loop(initialExtendsStepState, configFile, document);
+	});
+}
+const forkCoreSchema = S.toJsonSchemaDocument(forkOptionsSchema).schema;
+const decodeOptions = S.decodeUnknownResult(StrykerOptionsSchema, { errors: "all" });
+function recordOf(value) {
+	return { ...value };
+}
+const thresholdErrors = (options) => Match.value(options.thresholds.high < options.thresholds.low).pipe(Match.when(true, () => ["Config option \"thresholds.high\" should be higher than \"thresholds.low\"."]), Match.orElse(() => []));
+const ignoreStaticErrors = (options) => Match.value(options.ignoreStatic && options.coverageAnalysis !== "perTest").pipe(Match.when(true, () => [`Config option "${optionsPath("ignoreStatic")}" is not supported with coverage analysis "${options.coverageAnalysis}". Either turn off "${optionsPath("ignoreStatic")}", or configure "${optionsPath("coverageAnalysis")}" to be "perTest".`]), Match.orElse(() => []));
+const matchLineNumber = (match, group) => Number.parseInt(match[group] ?? "", 10);
+const startLineErrors = (index, mutationRange, start) => Match.value(start < 1).pipe(Match.when(true, () => [`Config option "mutate[${index}]" is invalid. Mutation range "${mutationRange}" is invalid, line ${start} does not exist (lines start at 1).`]), Match.orElse(() => []));
+const lineOrderErrors = (index, mutationRange, start, end) => Match.value(start > end).pipe(Match.when(true, () => [`Config option "mutate[${index}]" is invalid. Mutation range "${mutationRange}" is invalid. The "from" line number (${start}) should be less then the "to" line number (${end}).`]), Match.orElse(() => []));
+const mutationRangeBoundErrors = (index, match) => {
+	const mutationRange = match[2];
+	const start = matchLineNumber(match, 3);
+	const end = matchLineNumber(match, 5);
+	return [...startLineErrors(index, mutationRange, start), ...lineOrderErrors(index, mutationRange, start, end)];
+};
+const requireUnmagicalMutationRange = (mutateString, index, match) => Match.value(new Minimatch(mutateString).hasMagic()).pipe(Match.when(true, () => [`Config option "mutate[${index}]" is invalid. Cannot combine a glob expression with a mutation range in "${mutateString}".`]), Match.orElse(() => mutationRangeBoundErrors(index, match)));
+const mutationRangeErrors = (mutateString, index) => Match.value(MUTATION_RANGE_REGEX.exec(mutateString)).pipe(Match.when((match) => match !== null, (match) => requireUnmagicalMutationRange(mutateString, index, match)), Match.orElse(() => []));
+const warnOnIgnoredNodeArgs = (nodeArgs) => Match.value(nodeArgs.length > 0).pipe(Match.when(true, () => Effect.logWarning("Using \"testRunnerNodeArgs\" together with the \"command\" test runner is not supported, these arguments will be ignored. You can add your custom arguments by setting the \"commandRunner.command\" option.")), Match.orElse(() => Effect.void));
+const warnOnCommandRunnerNodeArgs = (options) => Match.value(isCommandRunner(options.testRunner)).pipe(Match.when(true, () => warnOnIgnoredNodeArgs(options.testRunnerNodeArgs)), Match.orElse(() => Effect.void));
+const customValidationErrors = (options) => [
+	...thresholdErrors(options),
+	...ignoreStaticErrors(options),
+	...options.mutate.flatMap(mutationRangeErrors)
+];
+function customValidation(options) {
+	const additionalErrors = customValidationErrors(options);
+	return warnOnCommandRunnerNodeArgs(options).pipe(Effect.flatMap(() => logConfigErrors(additionalErrors)), Effect.flatMap(() => throwErrorIfNeeded(additionalErrors)));
+}
+function schemaValidate(options) {
+	const decoded = decodeOptions(options);
+	if (Result.isFailure(decoded)) return failWithConfigErrors(describeErrors(decoded.failure));
+	Object.assign(options, decoded.success);
+	return Effect.succeed(decoded.success);
+}
+const configErrorHeadline = (errors) => Match.value(errors.length === 1).pipe(Match.when(true, () => "Please correct this configuration error and try again."), Match.orElse(() => "Please correct these configuration errors and try again."));
+const configErrorMessage = (errors) => `${configErrorHeadline(errors)} ${errors.join(" ")}`;
+const logConfigErrors = (errors) => Effect.gen(function* () {
+	for (const error of errors) yield* Effect.logError(error);
+});
+const failWithConfigErrors = (errors) => logConfigErrors(errors).pipe(Effect.flatMap(() => Effect.fail(ConfigError.make({ message: configErrorMessage(errors) }))));
+function throwErrorIfNeeded(errors) {
+	if (errors.length === 0) return Effect.void;
+	return Effect.fail(ConfigError.make({ message: configErrorMessage(errors) }));
+}
+const OPTIONS_ADDED_BY_STRYKER = [
+	"set",
+	"configFile",
+	"$schema"
+];
+const schemaPropertyNames = (schema) => Match.value(schema["properties"]).pipe(Match.when(isNonNullObject, (properties) => Object.keys(recordOf(properties))), Match.orElse(() => []));
+const excessOptionNames = (options, schema) => {
+	const schemaKeys = schemaPropertyNames(schema);
+	return Object.keys(options).filter((key) => key.endsWith("_comment") === false).filter((key) => OPTIONS_ADDED_BY_STRYKER.includes(key) === false).filter((key) => schemaKeys.includes(key) === false);
+};
+const warnAboutUnknownOptions = (options, excessNames) => Effect.gen(function* () {
+	for (const excessPropertyName of excessNames) yield* Effect.logWarning(`Unknown stryker config option "${excessPropertyName}".`);
+	const pluginsJson = yield* S.encodeEffect(S.fromJsonString(S.Array(S.String)))([...options.plugins]).pipe(Effect.orDie);
+	yield* Effect.logWarning(`Possible causes:
+     * Is it a typo on your end?
+     * Did you only write this property as a comment? If so, please postfix it with "_comment".
+     * You might be missing a plugin that is supposed to use it. Stryker loaded plugins from: ${pluginsJson}
+     * The plugin that is using it did not contribute explicit validation. 
+      (disable "${optionsPath("warnings", "unknownOptions")}" to ignore this warning)`);
+});
+const unknownOptionWarning = (options, schema) => {
+	const excessNames = excessOptionNames(options, schema);
+	return Match.value(excessNames.length > 0).pipe(Match.when(true, () => warnAboutUnknownOptions(options, excessNames)), Match.orElse(() => Effect.void));
+};
+function markExcessOptions(options, schema) {
+	return Effect.gen(function* () {
+		if (isWarningEnabled("unknownOptions", options.warnings)) yield* unknownOptionWarning(options, schema);
+	});
+}
+const logUnserializableWarnings = (unserializables) => Effect.gen(function* () {
+	for (const unserializable of unserializables) yield* Effect.logWarning(`Config option "${unserializable.path.join(".")}" is not (fully) serializable. ${unserializable.reason}. Any test runner or checker worker processes might not receive this value as intended.`);
+	yield* Effect.logWarning(`(disable ${optionsPath("warnings", "unserializableOptions")} to ignore this warning)`);
+});
+const warnAboutUnserializableOptions = (options) => Match.value(findUnserializables(options)).pipe(Match.when(void 0, () => Effect.void), Match.orElse((unserializables) => logUnserializableWarnings(unserializables)));
+function markUnserializableOptions(options) {
+	return Effect.gen(function* () {
+		if (isWarningEnabled("unserializableOptions", options.warnings)) yield* warnAboutUnserializableOptions(options);
+	});
+}
+function markOptions(options, schema) {
+	return Effect.gen(function* () {
+		yield* markExcessOptions(options, schema);
+		yield* markUnserializableOptions(options);
+	});
+}
+function validateOptions(options, schema) {
+	return Effect.gen(function* () {
+		const typed = yield* schemaValidate(options);
+		yield* customValidation(typed);
+		yield* markOptions(typed, schema);
+		return typed;
+	});
+}
+const createDefaultOptions = S.decodeEffect(StrykerOptionsSchema)({}).pipe(Effect.orDie);
+Effect.map(createDefaultOptions, (opts) => deepFreeze(opts));
+`
+Example of how a config file should look:
+/**
+  * @type {import('@systemfsoftware/stryker-js-plugin-interface').StrykerOptions}
+  */
+export default {
+  // Your options here!
+}
+
+A config file is a TypeScript or ESM JavaScript module: stryker.conf.ts, stryker.config.ts, or the same names with a .mts, .js, or .mjs extension.
+
+See https://stryker-mutator.io/docs/stryker-js/config-file for more information.`.trim();
+function exists(fileName) {
+	return Effect.gen(function* () {
+		return yield* (yield* FileSystem.FileSystem).access(fileName).pipe(Effect.as(true), Effect.catchTag("PlatformError", (error) => Match.value(error.reason).pipe(Match.tag("NotFound", () => Effect.succeed(false)), Match.orElse(() => Effect.fail(ConfigFileUnreadableError.make({
+			file: fileName,
+			cause: error
+		}))))), Effect.mapError((error) => ConfigFileUnreadableError.make({
+			file: fileName,
+			cause: error
+		})));
+	});
+}
+const requireExistingConfigFile = (configFileName) => exists(configFileName).pipe(Effect.flatMap((doesExist) => Match.value(doesExist).pipe(Match.when(true, () => Effect.succeed(configFileName)), Match.orElse(() => Effect.fail(ConfigFileNotFoundError.make({ file: configFileName }))))));
+const firstExistingConfigFile = (fileNames) => Option.match(Option.fromUndefinedOr(fileNames[0]), {
+	onNone: () => Effect.succeedNone,
+	onSome: (head) => exists(head).pipe(Effect.flatMap((doesExist) => {
+		if (doesExist) return Effect.succeedSome(head);
+		return firstExistingConfigFile(fileNames.slice(1));
+	}))
+});
+const configFileFor = (configFileName) => Effect.gen(function* () {
+	const pathService = yield* Path.Path;
+	const supported = SUPPORTED_CONFIG_FILE_EXTENSIONS.includes(configFileExtension(configFileName, pathService));
+	const legacy = isLegacyConfigFile(configFileName, pathService);
+	return yield* Match.value(supported).pipe(Match.when(true, () => requireExistingConfigFile(configFileName)), Match.orElse(() => Effect.fail(ConfigFileUnsupportedError.make({
+		file: configFileName,
+		hint: Match.value(legacy).pipe(Match.when(true, () => legacyConfigHint(configFileName)), Match.orElse(() => unsupportedConfigHint(configFileName)))
+	}))));
+});
+const firstLegacyConfigFile = () => firstExistingConfigFile([...LEGACY_CONFIG_FILE_NAMES]);
+const legacyConfigError = (file) => ConfigFileUnsupportedError.make({
+	file,
+	hint: legacyConfigHint(file)
+});
+const legacyConfigWarning = (file, supportedFile) => Effect.logWarning(shadowedLegacyWarning(file, supportedFile));
+const refuseLegacyOnlyProject = () => firstLegacyConfigFile().pipe(Effect.flatMap((legacyFile) => Option.match(legacyFile, {
+	onNone: () => Effect.succeedNone,
+	onSome: (file) => Effect.fail(legacyConfigError(file))
+})));
+const warnShadowedLegacyConfig = (supportedFile) => firstLegacyConfigFile().pipe(Effect.flatMap((legacyFile) => Option.match(legacyFile, {
+	onNone: () => Effect.succeed(supportedFile),
+	onSome: (file) => Effect.as(legacyConfigWarning(file, supportedFile), supportedFile)
+})));
+const discoverConfigFile = () => firstExistingConfigFile([...SUPPORTED_CONFIG_FILE_NAMES]).pipe(Effect.flatMap((found) => Option.match(found, {
+	onNone: () => refuseLegacyOnlyProject().pipe(Effect.map((legacy) => Option.getOrUndefined(legacy))),
+	onSome: (supportedFile) => warnShadowedLegacyConfig(supportedFile)
+})));
+function findConfigFile(configFileName) {
+	return Match.value(configFileName).pipe(Match.when(Match.string, (fileName) => configFileFor(fileName)), Match.orElse(() => discoverConfigFile()));
+}
+const resolveChildExtends = (configFile, child, configEnv) => Match.value("extends" in child).pipe(Match.when(true, () => resolveExtends(configFile, child, configEnv)), Match.orElse(() => Effect.succeed(child)));
+const isCiEnvironment = Config.string("CI").pipe(Effect.map((value) => Match.value(value.trim().toLowerCase()).pipe(Match.when("", () => false), Match.when("0", () => false), Match.when("false", () => false), Match.orElse(() => true))), Effect.orElseSucceed(() => false));
+function loadOptionsFromConfigFile(cliOptions, configEnv) {
+	return findConfigFile(cliOptions["configFile"]).pipe(Effect.flatMap((configFile) => Match.value(configFile).pipe(Match.when(void 0, () => Effect.succeed({})), Match.orElse((found) => readConfigModule(found, configEnv).pipe(Effect.flatMap((child) => resolveChildExtends(found, child, configEnv)))))));
+}
+function readConfig(cliOptions, invocation) {
+	return Effect.gen(function* () {
+		const configEnv = {
+			command: invocation.command,
+			mode: invocation.mode,
+			isDryRun: cliOptions["dryRunOnly"] === true,
+			isCi: yield* isCiEnvironment
+		};
+		const cliRecord = yield* S.decodeUnknownEffect(ConfigDocumentSchema)(cliOptions).pipe(Effect.orDie);
+		const fileRecord = yield* loadOptionsFromConfigFile(cliRecord, configEnv);
+		const fileOptions = yield* Result.match(S.decodeUnknownResult(ConfigDocumentSchema)(fileRecord), {
+			onFailure: (cause) => Effect.fail(ConfigFileInvalidError.make({
+				file: "config",
+				cause
+			})),
+			onSuccess: (options) => Effect.succeed(options)
+		});
+		const merged = mergeConfig(fileOptions, cliRecord);
+		const decoded = S.decodeUnknownResult(StrykerOptionsSchema)(merged);
+		if (Result.isFailure(decoded)) throw ConfigError.make({ message: configErrorMessage(describeErrors(decoded.failure)) });
+		return decoded.success;
+	});
+}
+const loadConfigCell = readConfig;
+//#endregion
+//#region src/Plugins.schema.ts
+/**
+* Plugins capability — declarations for plugin module shapes and load failures.
+*/
+const PluginDescriptorSchema = Schema.Union([Schema.Struct({
+	kind: WorkerPluginKind,
+	name: Schema.String,
+	workerEntry: WorkerEntryUrl
+}), Schema.Struct({
+	kind: Schema.Literals(["Evaluator"]),
+	name: Schema.String
+})]);
+const PluginModuleSchema = Schema.Struct({ strykerPlugins: Schema.Array(PluginDescriptorSchema) });
+const isShouldIgnore = (value) => typeof value === "function";
+const ignoreNothing = () => void 0;
+const IgnorerEntrySchema = Schema.Struct({
+	name: Schema.String,
+	shouldIgnore: Schema.declare(isShouldIgnore, { toArbitrary: () => (fc) => fc.constant(ignoreNothing) })
+});
+const IgnorerModuleSchema = Schema.Struct({ strykerIgnorers: Schema.Array(IgnorerEntrySchema) });
+const SchemaValidationContributionSchema = Schema.Struct({ strykerValidationSchema: Schema.Record(Schema.String, Schema.Unknown) });
+var PluginNotFoundError = class extends Schema.TaggedError()("PluginNotFoundError", { descriptor: Schema.String }) {
+	exitClass = "ConfigError";
+};
+var PluginLoadFailedError = class extends Schema.TaggedError()("PluginLoadFailedError", {
+	descriptor: Schema.String,
+	cause: Schema.Unknown
+}) {
+	exitClass = "InternalError";
+};
+//#endregion
+//#region src/Plugins.ts
+const NO_IGNORERS = [];
+const buildPluginLoadPlan = (entries) => {
+	const declarations = entries.flatMap((entry, index) => (entry.plugins ?? []).map((plugin) => ({
+		plugin,
+		moduleName: entry.moduleName,
+		entryIndex: index
+	})));
+	const shadowingState = declarations.reduce((acc, declaration, position) => {
+		const key = `${declaration.plugin.kind}:${declaration.plugin.name}`;
+		return {
+			seen: HashMap.set(acc.seen, key, {
+				position,
+				entryIndex: declaration.entryIndex
+			}),
+			shadowings: Option.match(HashMap.get(acc.seen, key), {
+				onNone: () => acc.shadowings,
+				onSome: (previous) => [...acc.shadowings, {
+					kind: declaration.plugin.kind,
+					name: declaration.plugin.name,
+					shadowedIndex: previous.entryIndex,
+					winnerIndex: declaration.entryIndex
+				}]
+			})
+		};
+	}, {
+		seen: HashMap.empty(),
+		shadowings: []
+	});
+	const winningDeclarations = declarations.filter((declaration, position) => Option.match(HashMap.get(shadowingState.seen, `${declaration.plugin.kind}:${declaration.plugin.name}`), {
+		onNone: () => false,
+		onSome: (winner) => winner.position === position
+	}));
+	const pluginsByKind = winningDeclarations.reduce((map, declaration) => Option.match(HashMap.get(map, declaration.plugin.kind), {
+		onNone: () => HashMap.set(map, declaration.plugin.kind, [declaration.plugin]),
+		onSome: (existing) => HashMap.set(map, declaration.plugin.kind, [...existing, declaration.plugin])
+	}), HashMap.empty());
+	const pluginSources = winningDeclarations.map((declaration) => Match.value(declaration.plugin).pipe(Match.when((plugin) => plugin.kind === "Evaluator", (evaluator) => ({
+		kind: "Evaluator",
+		name: evaluator.name,
+		modulePath: declaration.moduleName
+	})), Match.orElse((worker) => ({
+		kind: worker.kind,
+		name: worker.name,
+		modulePath: declaration.moduleName,
+		workerEntry: worker.workerEntry
+	}))));
+	const pluginModulePaths = entries.flatMap((entry) => Option.match(Option.fromUndefinedOr(entry.plugins), {
+		onNone: () => [],
+		onSome: () => [entry.moduleName]
+	}));
+	return {
+		schemaContributions: entries.flatMap((entry) => Option.match(Option.fromUndefinedOr(entry.schemaContribution), {
+			onNone: () => [],
+			onSome: (value) => [value]
+		})),
+		pluginsByKind,
+		pluginModulePaths,
+		pluginSources,
+		shadowings: shadowingState.shadowings
+	};
+};
+const failPluginLoad = (descriptor, error) => Effect.logWarning(`Error during loading "${descriptor}" plugin`).pipe(Effect.andThen(() => Effect.fail(PluginLoadFailedError.make({
+	descriptor,
+	cause: error
+}))));
+const modulePluginContributions = (module) => Match.value(Predicate.hasProperty(module, "strykerPlugins")).pipe(Match.when(true, () => Schema.decodeUnknownResult(PluginModuleSchema)(module).pipe(Result.map((pluginModule) => pluginModule.strykerPlugins))), Match.orElse(() => Result.succeed(void 0)));
+const moduleIgnorers = (module) => Match.value(Predicate.hasProperty(module, "strykerIgnorers")).pipe(Match.when(true, () => Schema.decodeUnknownResult(IgnorerModuleSchema)(module).pipe(Result.map((ignorerModule) => ignorerModule.strykerIgnorers))), Match.orElse(() => Result.succeed(void 0)));
+const moduleSchemaContribution = (module) => Match.value(module).pipe(Match.when(hasValidationSchemaContribution, (contribution) => contribution.strykerValidationSchema), Match.orElse(() => void 0));
+const pluginContributionsOf = (module) => Result.flatMap(moduleIgnorers(module), (ignorers) => Result.map(modulePluginContributions(module), (plugins) => ({
+	plugins,
+	ignorers,
+	schemaContribution: moduleSchemaContribution(module)
+})));
+const hasContribution = (contributions) => [
+	contributions.plugins,
+	contributions.ignorers,
+	contributions.schemaContribution
+].some((contribution) => contribution !== void 0);
+const warnUndescribedPluginModule = (descriptor) => Effect.logWarning(`Module "${descriptor}" did not contribute a StrykerJS plugin. It didn't export a "strykerPlugins", "strykerIgnorers", or "strykerValidationSchema".`).pipe(Effect.as(void 0));
+const describeLoadedPlugin = (descriptor, module) => Result.match(pluginContributionsOf(module), {
+	onFailure: (cause) => failPluginLoad(descriptor, cause),
+	onSuccess: (contributions) => Match.value(hasContribution(contributions)).pipe(Match.when(true, () => Effect.succeed(contributions)), Match.orElse(() => warnUndescribedPluginModule(descriptor)))
+});
+function loadPlugin(descriptor, entrypoint) {
+	return Effect.gen(function* () {
+		yield* Effect.logDebug(`Loading plugin ${descriptor}`);
+		const maybeModule = yield* importModule(entrypoint).pipe(Effect.catch((error) => failPluginLoad(descriptor, error)));
+		const module = Option.getOrUndefined(Option.fromUndefinedOr(maybeModule));
+		if (module === void 0) return;
+		return yield* describeLoadedPlugin(descriptor, module);
+	});
+}
+function loadPlugins(pluginDescriptors) {
+	return Effect.gen(function* () {
+		const path = yield* Path.Path;
+		const entrypoints = yield* Effect.forEach(Array$1.fromIterable(HashSet.fromIterable(pluginDescriptors)), (specifier) => path.fromFileUrl(new URL(specifier)).pipe(Effect.map((entrypoint) => ({
+			specifier,
+			entrypoint
+		})), Effect.mapError((cause) => PluginLoadFailedError.make({
+			descriptor: specifier,
+			cause
+		}))), { concurrency: "unbounded" });
+		const loaded = yield* Effect.forEach(entrypoints, (resolved) => loadPlugin(resolved.specifier, resolved.entrypoint).pipe(Effect.map((plugin) => {
+			if (plugin === void 0) return;
+			return {
+				...plugin,
+				moduleName: resolved.entrypoint
+			};
+		})), { concurrency: "unbounded" }).pipe(Effect.map((arr) => arr.filter(Predicate.isNotNullish)));
+		const ignorers = loaded.flatMap((entry) => entry.ignorers ?? NO_IGNORERS);
+		const entries = loaded.map((entry) => ({
+			moduleName: entry.moduleName,
+			plugins: entry.plugins,
+			schemaContribution: entry.schemaContribution
+		}));
+		const plan_ = buildPluginLoadPlan(entries);
+		for (const shadowing of plan_.shadowings) yield* Effect.logWarning(`Plugin "${shadowing.name}" of kind "${shadowing.kind}" at index ${shadowing.winnerIndex} shadows plugin at index ${shadowing.shadowedIndex}.`);
+		return {
+			schemaContributions: plan_.schemaContributions,
+			pluginsByKind: plan_.pluginsByKind,
+			pluginModulePaths: plan_.pluginModulePaths,
+			pluginSources: plan_.pluginSources,
+			ignorers
+		};
+	});
+}
+function hasValidationSchemaContribution(module) {
+	return Schema.is(SchemaValidationContributionSchema)(module);
+}
+const findByKindAndName = (items, kind, name) => Option.fromUndefinedOr(items.find((item) => item.kind === kind && item.name.toLowerCase() === name.toLowerCase()));
+const findContribution = (descriptors, kind, name) => Effect.fromOption(Option.filter(findByKindAndName(descriptors, kind, name), (descriptor) => descriptor.kind === kind), () => PluginNotFoundError.make({ descriptor: `${kind}:${name} (available: ${descriptors.map((d) => d.name).join(", ")})` }));
+function findPlugin(pluginsByKind, kind, name) {
+	return Option.match(HashMap.get(pluginsByKind, kind), {
+		onNone: () => Effect.fail(PluginNotFoundError.make({ descriptor: `${kind}:${name} (no ${kind} plugins were loaded)` })),
+		onSome: (descriptors) => findContribution(descriptors, kind, name)
+	});
+}
+function create(pluginsByKind, kind, name) {
+	return findPlugin(pluginsByKind, kind, name);
+}
+function createAll(pluginsByKind, kind) {
+	const descriptors = HashMap.get(pluginsByKind, kind);
+	if (Option.isNone(descriptors)) return Effect.succeed([]);
+	return Effect.succeed(descriptors.value.filter((d) => d.kind === kind));
+}
+//#endregion
+//#region src/plugin-worker-entry.ts
+const missingWorkerEntry = (stage, kind, name) => (failure) => StageError.make({
+	stage,
+	reason: `the ${kind} plugin "${name}" is not among the loaded plugins`,
+	cause: failure
+});
+const requiredSource = (params) => Effect.fromOption(findByKindAndName(params.loaded.pluginSources, params.kind, params.name), () => PluginNotFoundError.make({ descriptor: `${params.kind}:${params.name}` }));
+const resolvePluginWorkerEntry = (params) => requiredSource(params).pipe(Effect.map((source) => ({
+	kind: params.kind,
+	entrypoint: source.workerEntry
+})));
+//#endregion
+export { PrepareError as $, OutOfMemoryError as A, ConfigDocumentSchema as B, connectRetry as C, layer as D, classifyWorkerExit as E, vmRunnerName as F, ConfigFileUnsupportedError as G, ConfigFileInvalidError as H, vmTestRunner as I, MergeResult as J, ImportedModuleSchema as K, StrykerError as L, VmRunner as M, isVmRunner as N, makeConcurrency as O, vmRunnerCapabilities as P, survivorsPriorReport as Q, ALWAYS_IGNORE as R, WorkerLauncher as S, IdGenerator as T, ConfigFileNotFoundError as U, ConfigError as V, ConfigFileUnreadableError as W, extendsPropertySchema as X, ReadConfigCommand as Y, forkOptionsSchema as Z, validateOptions as _, loadPlugins as a, makeChildProcessTestRunner as b, decideExtendsStep as c, importModule as d, StageError as et, initialExtendsStepState as f, resolveExtends as g, readConfig as h, createAll as i, WorkerBootTimeoutError as j, ChildProcessCrashedError as k, describeErrors as l, mergeConfigs as m, resolvePluginWorkerEntry as n, PluginLoadFailedError as o, loadConfigCell as p, MergeCommand as q, create as r, PluginNotFoundError as s, missingWorkerEntry as t, forkCoreSchema as u, buildTestRunner as v, makeWorkerClient as w, nodePlatformLayer as x, isCommandRunner as y, MUTATION_RANGE_REGEX as z };