@systemfsoftware/stryker-js 5.0.0 → 6.1.0

package/dist/{plugin-worker-entry-DNu0SHO8.mjs → plugin-worker-entry-D00fedxV.mjs}

@@ -1,37 +1,42 @@
+import { A as formatTraceparent, C as TestRunnerFailed, D as WorkerEntryUrl, E as TraceContextReference, M as parseTraceparent, N as toMutantRunResult, O as WorkerPluginKind, P as INSTRUMENTER_CONSTANTS, T as TraceContextMiddleware, b as TRACEPARENT_HEADER, f as PropagatedTrace, j as isCustomTestRunner, w as TestRunnerRpcs, x as TRACESTATE_HEADER, y as StrykerOptionsSchema } from "./dist-CWbipfGB.mjs";
 import { t as mergeConfig } from "./merge-config-BrrNQWje.mjs";
-import * as Effect from "effect/Effect";
+import * as Effect$1 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 Predicate from "effect/Predicate";
+import * as S from "effect/Schema";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as Context from "effect/Context";
+import * as RpcMiddleware from "effect/unstable/rpc/RpcMiddleware";
+import { Schema } from "effect";
 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 api from "@opentelemetry/api";
+import * as Tracer from "effect/Tracer";
+import * as Headers from "effect/unstable/http/Headers";
+import { NodeFileSystem, NodePath, NodeSocket, NodeStdio } from "@effect/platform-node";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+import "effect/unstable/rpc/RpcServer";
+import * as NodeSdk from "@effect/opentelemetry/NodeSdk";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
 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";
@@ -83,6 +88,42 @@ var PrepareError = class extends S.TaggedError()("PrepareError", {
 	reason: S.String
 }) {};
 //#endregion
+//#region src/glob-match.ts
+const GLOB_META = /[*?[{]/;
+const isGlob = (value) => GLOB_META.test(value);
+const escapeRegex = (value) => value.replace(/[\\^$.|()+]/g, "\\$&");
+const globSegmentToRegex = (segment) => Match.value(segment.length === 0).pipe(Match.when(true, () => ""), Match.orElse(() => {
+	const char = segment[0] ?? "";
+	const rest = segment.slice(1);
+	return Match.value(char).pipe(Match.when("*", () => Match.value(rest.startsWith("*")).pipe(Match.when(true, () => {
+		const afterStars = rest.slice(1);
+		return Match.value(afterStars.startsWith("/")).pipe(Match.when(true, () => `(?:(?:[^/]+/)*)?${globSegmentToRegex(afterStars.slice(1))}`), Match.orElse(() => `.*${globSegmentToRegex(afterStars)}`));
+	}), Match.orElse(() => `[^/]*${globSegmentToRegex(rest)}`))), Match.when("?", () => `[^/]${globSegmentToRegex(rest)}`), Match.when("{", () => {
+		const close = segment.indexOf("}");
+		return Match.value(close < 0).pipe(Match.when(true, () => `${escapeRegex(char)}${globSegmentToRegex(rest)}`), Match.orElse(() => {
+			const inner = segment.slice(1, close);
+			const after = segment.slice(close + 1);
+			return `(?:${inner.split(",").map(globSegmentToRegex).join("|")})${globSegmentToRegex(after)}`;
+		}));
+	}), Match.when("[", () => {
+		const close = segment.indexOf("]", 1);
+		return Match.value(close < 0).pipe(Match.when(true, () => `${escapeRegex(char)}${globSegmentToRegex(rest)}`), Match.orElse(() => `${segment.slice(0, close + 1)}${globSegmentToRegex(segment.slice(close + 1))}`));
+	}), Match.orElse(() => `${escapeRegex(char)}${globSegmentToRegex(rest)}`));
+}));
+const globToRegExp = (pattern, caseInsensitive) => new RegExp(`^${globSegmentToRegex(pattern)}$`, Match.value(caseInsensitive).pipe(Match.when(true, () => "i"), Match.orElse(() => "")));
+const matchesGlob = (path, pattern, caseInsensitive = false) => globToRegExp(pattern, caseInsensitive).test(path);
+const compileIgnoreRule = (pattern) => {
+	const negate = pattern.startsWith("!");
+	const glob = Match.value(negate).pipe(Match.when(true, () => pattern.slice(1)), Match.orElse(() => pattern));
+	const re = globToRegExp(glob, true);
+	const prefix = new RegExp(re.source.replace(/\$$/, ""), re.flags);
+	return {
+		negate,
+		matches: (candidate) => re.test(candidate),
+		matchesPrefix: (candidate) => prefix.test(candidate)
+	};
+};
+//#endregion
 //#region src/Config.schema.ts
 const ConfigDocumentSchema = S.Record(S.String, S.Unknown);
 const ImportedModuleSchema = S.Struct({ default: S.optional(S.Unknown) });
@@ -122,6 +163,27 @@ var MergeCommand = class extends S.TaggedClass()("MergeCommand", {
 	overrides: S.Record(S.String, S.Unknown)
 }) {};
 var MergeResult = class extends S.TaggedClass()("MergeResult", { merged: S.Record(S.String, S.Unknown) }) {};
+const ExtendsStepDocumentSchema = S.Struct({
+	path: S.String,
+	options: ConfigDocumentSchema
+});
+const ExtendsStepStateSchema = S.Struct({
+	visited: S.Array(S.String),
+	documents: S.Array(ExtendsStepDocumentSchema)
+});
+var ExtendsStepDone = class extends S.TaggedClass()("done", { options: ConfigDocumentSchema }) {};
+var ExtendsStepRead = class extends S.TaggedClass()("read", {
+	path: S.String,
+	state: ExtendsStepStateSchema
+}) {};
+var ExtendsStepResolve = class extends S.TaggedClass()("resolve", {
+	specifier: S.String,
+	state: ExtendsStepStateSchema
+}) {};
+var ExtendsStepRefused = class extends S.TaggedClass()("refused", {
+	reason: S.Literals(["cycle", "non-string-extends"]),
+	file: S.String
+}) {};
 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({
@@ -148,11 +210,108 @@ var StrykerError = class extends Schema.TaggedError()("StrykerError", {
 	cause: Schema.optional(Schema.Unknown)
 }) {};
 //#endregion
+//#region ../stryker-js-plugin-runtime/dist/index.mjs
+const CURRENT_VERSION = "00";
+const serializedTraceState = (traceState) => Option.filter(Option.map(Option.fromUndefinedOr(traceState), (state) => state.serialize()), (serialized) => serialized.length > 0);
+const traceStateField = (traceState) => Option.match(serializedTraceState(traceState), {
+	onNone: () => ({}),
+	onSome: (serialized) => ({ traceState: serialized })
+});
+const tracePartsOf = (context) => Option.map(Option.liftPredicate(context, (candidate) => api.trace.isSpanContextValid(candidate)), (valid) => ({
+	version: CURRENT_VERSION,
+	traceId: valid.traceId,
+	spanId: valid.spanId,
+	traceFlags: valid.traceFlags,
+	...traceStateField(valid.traceState)
+}));
+const partsOfSpan = (span) => Option.flatMap(Option.map(Option.fromUndefinedOr(span), (present) => present.spanContext()), tracePartsOf);
+const remotePartsFromHeaders = (headers) => Option.map(Option.flatMap(Headers.get(headers, TRACEPARENT_HEADER), parseTraceparent), (parts) => ({
+	...parts,
+	traceState: Option.getOrUndefined(Headers.get(headers, TRACESTATE_HEADER))
+}));
+const traceHeaders = (parts) => {
+	const traceparent = Headers.set(Headers.empty, TRACEPARENT_HEADER, formatTraceparent(parts));
+	if (parts.traceState === void 0) return traceparent;
+	return Headers.set(traceparent, TRACESTATE_HEADER, parts.traceState);
+};
+const inject = (request, parts) => ({
+	...request,
+	headers: Headers.merge(request.headers, traceHeaders(parts))
+});
+const hostParts = Effect$1.map(Effect$1.context(), (context) => Option.orElse(Context.get(context, TraceContextReference), () => partsOfSpan(api.trace.getSpan(api.context.active()))));
+const clientMiddleware = (options) => hostParts.pipe(Effect$1.flatMap((parts) => Option.match(parts, {
+	onNone: () => options.next(options.request),
+	onSome: (present) => options.next(inject(options.request, present))
+})));
+const layerTraceContextClient = RpcMiddleware.layerClient(TraceContextMiddleware, clientMiddleware);
+const SAMPLED_FLAG = 1;
+const traceStateOption = (traceState) => Option.match(Option.fromUndefinedOr(traceState), {
+	onNone: () => ({}),
+	onSome: (state) => ({ traceState: state })
+});
+const sampledFlagOf = (sampled) => {
+	if (sampled) return SAMPLED_FLAG;
+	return 0;
+};
+const externalSpanOf = (parts) => Tracer.externalSpan({
+	traceId: parts.traceId,
+	spanId: parts.spanId,
+	sampled: (parts.traceFlags & SAMPLED_FLAG) === SAMPLED_FLAG,
+	...traceStateOption(parts.traceState)
+});
+const partsOfEffectSpan = (span) => ({
+	version: CURRENT_VERSION,
+	traceId: span.traceId,
+	spanId: span.spanId,
+	traceFlags: sampledFlagOf(span.sampled)
+});
+const serverMiddleware = (effect, options) => {
+	const remote = remotePartsFromHeaders(options.headers);
+	const attributes = { "rpc.method": options.rpc._tag };
+	return Option.match(Option.map(remote, externalSpanOf), {
+		onNone: () => Effect$1.useSpan(`rpc.${options.rpc._tag}`, { attributes }, () => effect),
+		onSome: (parent) => Effect$1.useSpan(`rpc.${options.rpc._tag}`, {
+			attributes,
+			parent
+		}, () => effect)
+	}).pipe(Effect$1.provideService(PropagatedTrace, remote));
+};
+Layer.succeed(TraceContextMiddleware, serverMiddleware);
+let wire;
+const workerOptionsWire = () => wire ??= S.fromJsonString(S.toCodecJson(StrykerOptionsSchema));
+const encodeWorkerOptions = (options) => S.encodeEffect(workerOptionsWire())(options).pipe(Effect$1.orDie);
+const decodeWorkerOptions = (raw) => S.decodeUnknownEffect(workerOptionsWire())(raw);
+Effect$1.gen(function* () {
+	const workerDir = yield* Config.string("STRYKER_WORKER_DIR");
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const raw = yield* fs.readFileString(path.join(workerDir, "options.json"));
+	return yield* decodeWorkerOptions(raw);
+});
+const WORKER_SERVICE_NAME = "stryker-js-plugin-worker";
+const DEFAULT_ENDPOINT = "http://127.0.0.1:4318";
+const TRACES_SUFFIX = "/v1/traces";
+const tracesUrl = (endpoint) => {
+	const trimmed = endpoint.replace(/\/+$/u, "");
+	if (trimmed.endsWith(TRACES_SUFFIX)) return trimmed;
+	return `${trimmed}${TRACES_SUFFIX}`;
+};
+const otlpLayer = (serviceName, endpoint) => NodeSdk.layer(() => ({
+	resource: { serviceName },
+	spanProcessor: new SimpleSpanProcessor(new OTLPTraceExporter({ url: tracesUrl(endpoint) }))
+}));
+Layer.unwrap(Effect$1.gen(function* () {
+	if (!(yield* Config.boolean("OTEL_ENABLED").pipe(Config.withDefault(false)))) return Layer.empty;
+	const serviceName = yield* Config.string("OTEL_SERVICE_NAME").pipe(Config.withDefault(WORKER_SERVICE_NAME));
+	const endpoint = yield* Config.string("OTEL_EXPORTER_OTLP_ENDPOINT").pipe(Config.withDefault(DEFAULT_ENDPOINT));
+	return otlpLayer(serviceName, endpoint);
+}));
+//#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 isVmRunner = (name) => typeof name === "string" && 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)));
@@ -161,15 +320,15 @@ const compileFailure = (file, cause) => TestRunnerFailed.make({
 	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({
+const compileTests = (platform, fs, testFiles) => Effect$1.gen(function* () {
+	const sources = yield* Effect$1.forEach(testFiles, (file) => fs.readFileString(file).pipe(Effect$1.mapError((cause) => compileFailure(file, cause)), Effect$1.flatMap((source) => Effect$1.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({
+		script: yield* Effect$1.try({
 			try: () => new platform.vm.Script(sources.join("\n;\n"), { filename: fileName }),
 			catch: (cause) => compileFailure(fileName, cause)
 		})
@@ -209,7 +368,7 @@ const resultFromRun = (failureMessage, timeSpentMs) => Match.value(failureMessag
 		timeSpentMs
 	}]
 })));
-const runInFreshContext = (platform, compiled, activeMutantId) => Effect.sync(() => {
+const runInFreshContext = (platform, compiled, activeMutantId) => Effect$1.sync(() => {
 	const context = platform.vm.createContext(sandboxFor(platform, compiled.fileName, activeMutantId));
 	try {
 		compiled.script.runInContext(context);
@@ -218,30 +377,30 @@ const runInFreshContext = (platform, compiled, activeMutantId) => Effect.sync(()
 		return errorText(cause);
 	}
 });
-const runOnce = (platform, compiled, activeMutantId) => Effect.gen(function* () {
+const runOnce = (platform, compiled, activeMutantId) => Effect$1.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 vmTestRunner = (config) => Effect$1.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 compiledTests = (testFiles) => Effect$1.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 run = (testFiles, activeMutantId) => compiledTests(testFiles).pipe(Effect$1.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,
+		capabilities: Effect$1.succeed(vmRunnerCapabilities),
+		init: Effect$1.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({
+		mutantRun: (options) => run(config.testFiles, options.activeMutant.id).pipe(Effect$1.map((result) => toMutantRunResult(result, true)), Effect$1.catchTag("TestRunnerFailed", (failure) => Effect$1.succeed(toMutantRunResult({
 			status: "error",
 			errorMessage: failure.cause
 		}, true))))
@@ -289,7 +448,7 @@ var WorkerBootTimeoutError = class extends Schema.TaggedError()("WorkerBootTimeo
 //#endregion
 //#region src/Worker.ts
 var IdGenerator = class extends Context.Service()("@systemfsoftware/stryker-js/Worker/IdGenerator") {};
-const makeIdGenerator = Effect.gen(function* () {
+const makeIdGenerator = Effect$1.gen(function* () {
 	const ref = yield* Ref.make(0);
 	return { next: Ref.getAndUpdate(ref, (n) => n + 1) };
 });
@@ -329,10 +488,10 @@ const splitConcurrency = (total, checkerCount) => {
 		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 announcePercentage = (resolved) => Match.value(resolved.isPercentage).pipe(Match.when(true, () => Effect$1.logDebug(`Computed concurrency ${resolved.total} from "${resolved.option}" based on ${resolved.availableParallelism} available parallelism.`)), Match.orElse(() => Effect$1.void));
+const announceProcesses = (split) => Match.value(split.checkers > 0).pipe(Match.when(true, () => Effect$1.logInfo(`Creating ${split.checkers} checker process(es) and ${split.testRunners} test runner process(es).`)), Match.orElse(() => Effect$1.logInfo(`Creating ${split.testRunners} test runner process(es).`)));
+const makeConcurrency = (options) => Effect$1.gen(function* () {
+	const availableParallelism = yield* Effect$1.sync(getAvailableParallelism);
 	const { total, isPercentage } = computeTotalConcurrencyDetails(options.concurrency, availableParallelism);
 	yield* announcePercentage({
 		option: options.concurrency,
@@ -361,7 +520,7 @@ const classifyWorkerExit = (pid, exitCode) => Match.value(exitCode).pipe(Match.w
 //#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 makeWorkerClient = (params) => Effect$1.gen(function* () {
 	const worker = yield* (yield* WorkerLauncher).spawn({
 		entrypoint: params.entrypoint,
 		workingDirectory: params.workingDirectory,
@@ -370,25 +529,24 @@ const makeWorkerClient = (params) => Effect.gen(function* () {
 		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));
+	const protocol = yield* Layer.build(worker.clientLayer).pipe(Effect$1.retry(connectRetry), Effect$1.raceFirst(worker.exited), Effect$1.catchTag("SocketError", () => Effect$1.fail(WorkerBootTimeoutError.make({ pid: worker.pid }))));
+	return yield* RpcClient.make(params.rpcs).pipe(Effect$1.provideContext(protocol), Effect$1.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)));
+const restrictToOwnerOrWarn = (fs, file) => fs.chmod(file, 384).pipe(Effect$1.catchTag("PlatformError", (cause) => Effect$1.logWarning(`Could not restrict "${file}" to its owner; the worker directory's own mode still protects it.`).pipe(Effect$1.annotateLogs("cause", cause))));
 /**
 * 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 nodeWorkerLauncherLayer = Layer.effect(WorkerLauncher, Effect$1.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* () {
+	return { spawn: (params) => Effect$1.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")));
@@ -405,15 +563,15 @@ const nodeWorkerLauncherLayer = Layer.effect(WorkerLauncher, Effect.gen(function
 				...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))));
+		}).pipe(Effect$1.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner));
+		const clientLayer = RpcClient.layerProtocolSocket({ retryTransientErrors: true }).pipe(Layer.provide(NodeSocket.layerNet({ path: socketPath })), Layer.provide(RpcSerialization.layerNdjson));
+		const exited = handle.exitCode.pipe(Effect$1.orDie, Effect$1.flatMap((exitCode) => Effect$1.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({
+	}).pipe(Effect$1.catchIf(S.is(ChildProcessCrashedError), (error) => Effect$1.fail(error), () => Effect$1.fail(ChildProcessCrashedError.make({
 		pid: 0,
 		exit: {
 			_tag: "Code",
@@ -435,7 +593,7 @@ const nodePlatformLayer = Layer.mergeAll(nodeWorkerLauncherLayer.pipe(Layer.prov
 * `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(() => ({
+const nodeVmPlatformLayer = Layer.effect(VmRunner, Effect$1.sync(() => ({
 	module: process.getBuiltinModule("node:module"),
 	vm: process.getBuiltinModule("node:vm")
 })));
@@ -476,14 +634,15 @@ const toRunnerFailure = (runnerName, phase) => (error) => Match.value(error).pip
 * `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 makeChildProcessTestRunner = (params) => Effect$1.gen(function* () {
+	const runnerName = Match.value(params.options.testRunner).pipe(Match.when(isCustomTestRunner, (runner) => runner.plugin), Match.orElse((name) => name));
+	const execArgv = Match.value(params.options.testRunner).pipe(Match.when(isCustomTestRunner, (runner) => Match.value(runner.nodeArgs).pipe(Match.when(Match.undefined, () => params.options.testRunnerNodeArgs), Match.orElse((args) => args))), Match.orElse(() => params.options.testRunnerNodeArgs));
 	const optionsJson = yield* encodeWorkerOptions(params.options);
 	const client = yield* makeWorkerClient({
 		rpcs: TestRunnerRpcs,
 		entrypoint: params.workerEntrypoint,
 		workingDirectory: params.sandboxWorkingDirectory,
-		execArgv: [...params.options.testRunnerNodeArgs],
+		execArgv: [...execArgv],
 		optionsJson,
 		tempDirPrefix: "stryker-test-runner-",
 		env: {
@@ -491,12 +650,12 @@ const makeChildProcessTestRunner = (params) => Effect.gen(function* () {
 			VITEST: "1",
 			STRYKER_SANDBOX_DIR: params.sandboxWorkingDirectory
 		}
-	}).pipe(Effect.mapError(toRunnerBootFailure(runnerName)));
+	}).pipe(Effect$1.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")))
+		capabilities: client.capabilities().pipe(Effect$1.mapError(toRunnerFailure(runnerName, "capabilities"))),
+		init: Effect$1.void,
+		dryRun: (options) => client.dryRun({ options }).pipe(Effect$1.mapError(toRunnerFailure(runnerName, "dryRun"))),
+		mutantRun: (options) => client.mutantRun({ options }).pipe(Effect$1.mapError(toRunnerFailure(runnerName, "mutantRun")))
 	};
 });
 /**
@@ -509,16 +668,16 @@ const makeChildProcessTestRunner = (params) => Effect.gen(function* () {
 const withTimeout = (inner) => ({
 	...inner,
 	dryRun: (options) => {
-		const policy = Effect.timeoutOrElse({
+		const policy = Effect$1.timeoutOrElse({
 			duration: Duration.millis(options.timeout),
-			orElse: () => Effect.succeed({ status: "timeout" })
+			orElse: () => Effect$1.succeed({ status: "timeout" })
 		});
 		return inner.dryRun(options).pipe(policy);
 	},
 	mutantRun: (options) => {
-		const policy = Effect.timeoutOrElse({
+		const policy = Effect$1.timeoutOrElse({
 			duration: Duration.millis(options.timeout),
-			orElse: () => Effect.succeed({ status: "timeout" })
+			orElse: () => Effect$1.succeed({ status: "timeout" })
 		});
 		return inner.mutantRun(options).pipe(policy);
 	}
@@ -534,7 +693,7 @@ const withTimeout = (inner) => ({
 * 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)}`))));
+	const attempt = (run, onExhausted) => run.pipe(Effect$1.tapError((error) => Match.value(error).pipe(Match.when(S.is(OutOfMemoryError), (outOfMemory) => Effect$1.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$1.void))), Effect$1.retry({ times: 2 }), Effect$1.catchCause((cause) => Effect$1.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) => ({
@@ -556,14 +715,14 @@ const withRetry = (inner) => {
 * `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 withMaxReuse = (options, retire) => (inner) => Effect$1.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* () {
+			const policy = (self) => Effect$1.gen(function* () {
 				if ((yield* Ref.updateAndGet(runs, (n) => n + 1)) > restartAfter) {
 					yield* retire;
 					yield* Ref.set(runs, 1);
@@ -590,15 +749,15 @@ const environmentPlan = (request) => ({
 * 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 withEnvironmentReload = (retire) => (inner) => Effect$1.gen(function* () {
 	const state = yield* Ref.make("pristine");
 	return {
 		...inner,
 		dryRun: (options) => {
-			const policy = (self) => Ref.set(state, "loaded").pipe(Effect.andThen(self));
+			const policy = (self) => Ref.set(state, "loaded").pipe(Effect$1.andThen(self));
 			return policy(inner.dryRun(options));
 		},
-		mutantRun: (options) => Effect.gen(function* () {
+		mutantRun: (options) => Effect$1.gen(function* () {
 			const current = yield* Ref.get(state);
 			const canReload = (yield* inner.capabilities).reloadEnvironment;
 			const plan = environmentPlan({
@@ -607,7 +766,7 @@ const withEnvironmentReload = (retire) => (inner) => Effect.gen(function* () {
 				canReload
 			});
 			if (plan.retire) yield* retire;
-			const policy = (self) => Effect.gen(function* () {
+			const policy = (self) => Effect$1.gen(function* () {
 				const result = yield* self;
 				yield* Ref.set(state, plan.nextState);
 				return result;
@@ -619,10 +778,8 @@ const withEnvironmentReload = (retire) => (inner) => Effect.gen(function* () {
 		})
 	};
 });
-/** "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;
+const isCommandRunner = (name) => typeof name === "string" && name.toLowerCase() === "command";
 /** 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. */
@@ -661,7 +818,7 @@ const spawnResult = (outcome, elapsed) => Match.value(outcome).pipe(Match.tag("F
 * `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 runCommand = (config, activeMutantId) => Effect$1.gen(function* () {
 	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
 	const startedAt = yield* Clock.currentTimeMillis;
 	const command = ChildProcess.make(config.options.commandRunner.command, {
@@ -669,20 +826,20 @@ const runCommand = (config, activeMutantId) => Effect.gen(function* () {
 		cwd: config.workingDir,
 		...mutantActivation(activeMutantId)
 	});
-	const outcome = yield* Effect.scoped(Effect.gen(function* () {
+	const outcome = yield* Effect$1.scoped(Effect$1.gen(function* () {
 		const handle = yield* spawner.spawn(command);
 		return {
 			output: yield* Stream.mkString(Stream.decodeText(handle.all)),
 			exitCode: yield* handle.exitCode
 		};
-	})).pipe(Effect.exit);
+	})).pipe(Effect$1.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)));
+const commandRunnerMutantRun = (config, { activeMutant }) => runCommand(config, activeMutant.id).pipe(Effect$1.map((result) => toMutantRunResult(result, true)));
 /**
 * The command runner, wrapped in the two adjustments that apply to it.
 *
@@ -700,17 +857,17 @@ const commandRunner = (context, spawner) => {
 		workingDir: context.sandboxWorkingDirectory,
 		options: context.options
 	};
-	const provided = Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner);
+	const provided = Effect$1.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner);
 	const base = {
-		capabilities: Effect.succeed(commandRunnerCapabilities),
-		init: Effect.void,
+		capabilities: Effect$1.succeed(commandRunnerCapabilities),
+		init: Effect$1.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 inProcessRunner = (context) => Match.value(context.options.testRunner).pipe(Match.when(isCommandRunner, () => Option.some(ChildProcessSpawner.ChildProcessSpawner.pipe(Effect$1.map((spawner) => commandRunner(context, spawner))))), Match.when(isVmRunner, () => Option.some(vmTestRunner({ testFiles: context.testFiles }).pipe(Effect$1.provide(nodeVmPlatformLayer)))), Match.orElse(() => Option.none()));
+const buildTestRunner = (context, childProcessRunner) => Effect$1.gen(function* () {
 	const inProcess = inProcessRunner(context);
 	if (Option.isSome(inProcess)) return yield* inProcess.value;
 	const base = yield* childProcessRunner;
@@ -830,7 +987,7 @@ function describeErrors(error) {
 	return errorMessageOrFallback(completedErrorMessages(state), error.message);
 }
 function importModule(moduleName) {
-	return Effect.tryPromise({
+	return Effect$1.tryPromise({
 		try: () => import(moduleName),
 		catch: (cause) => StrykerError.make({
 			message: `Failed to import module "${moduleName}"`,
@@ -842,10 +999,6 @@ 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 [];
@@ -888,11 +1041,10 @@ const stripExtends = (document) => {
 };
 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,
+	if (state.visited.includes(file)) return ExtendsStepRefused.make({
 		reason: "cycle",
 		file
-	};
+	});
 	const nextState = {
 		visited: [...state.visited, file],
 		documents: [...state.documents, {
@@ -900,34 +1052,25 @@ const decideExtendsStep = (state, document, file, pathService) => {
 			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,
+	return Match.value(document["extends"]).pipe(Match.when(void 0, () => ExtendsStepDone.make({ options: mergeChainDocuments(nextState.documents) })), Match.when(null, () => ExtendsStepDone.make({ options: mergeChainDocuments(nextState.documents) })), Match.when(Match.string, (extendValue) => Match.value(isModuleSpecifier(extendValue)).pipe(Match.when(true, () => ExtendsStepResolve.make({
 		specifier: extendValue,
 		state: nextState
-	})), Match.when(false, () => ({
-		...ReadTag,
+	})), Match.when(false, () => ExtendsStepRead.make({
 		path: pathService.resolve(pathService.dirname(file), extendValue),
 		state: nextState
-	})), Match.exhaustive)), Match.orElse(() => ({
-		...RefusedTag,
+	})), Match.exhaustive)), Match.orElse(() => ExtendsStepRefused.make({
 		reason: "non-string-extends",
 		file
 	})));
 };
-const decodeConfigDocument = (configFile, document) => S.decodeUnknownEffect(ConfigDocumentSchema)(document).pipe(Effect.mapError((cause) => ConfigFileInvalidError.make({
+const decodeConfigDocument = (configFile, document) => S.decodeUnknownEffect(ConfigDocumentSchema)(document).pipe(Effect$1.mapError((cause) => ConfigFileInvalidError.make({
 	file: configFile,
 	cause
 })));
-const requireDefaultExport = (configFile, defaultExport) => Match.value(defaultExport).pipe(Match.when(void 0, () => Effect.fail(ConfigFileInvalidError.make({
+const requireDefaultExport = (configFile, defaultExport) => Match.value(defaultExport).pipe(Match.when(void 0, () => Effect$1.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({
+}))), Match.when(isNonNullObject, (value) => Effect$1.succeed(value)), Match.orElse(() => Effect$1.fail(ConfigFileInvalidError.make({
 	file: configFile,
 	cause: "Default export of config file must be an object!"
 }))));
@@ -942,13 +1085,13 @@ const factoryFailureCause = (cause) => Match.value(cause).pipe(Match.when(Match.
 * 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({
+const settleConfigDefault = (configFile, defaultExport, configEnv) => Effect$1.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)));
+}).pipe(Effect$1.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) => {
@@ -961,50 +1104,50 @@ const errorMessageOf = (cause) => {
 };
 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({
+const configModuleUrl = (configFile, pathService) => Match.value(configFile.startsWith("file:")).pipe(Match.when(true, () => Effect$1.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({
+})), Match.orElse(() => pathService.toFileUrl(pathService.resolve(configFile)).pipe(Effect$1.mapError((cause) => ConfigFileUnreadableError.make({
 	file: configFile,
 	cause
 })))));
-const readConfigModule = (configFile, configEnv) => Effect.gen(function* () {
+const readConfigModule = (configFile, configEnv) => Effect$1.gen(function* () {
 	const pathService = yield* Path.Path;
-	const importedModule = yield* importModule((yield* configModuleUrl(configFile, pathService)).href).pipe(Effect.mapError((failure) => ConfigFileUnreadableError.make({
+	const importedModule = yield* importModule((yield* configModuleUrl(configFile, pathService)).href).pipe(Effect$1.mapError((failure) => ConfigFileUnreadableError.make({
 		file: configFile,
 		cause: configImportCause(configFile, failure)
 	})));
-	const exported = yield* S.decodeUnknownEffect(ImportedModuleSchema)(importedModule).pipe(Effect.mapError((cause) => ConfigFileInvalidError.make({
+	const exported = yield* S.decodeUnknownEffect(ImportedModuleSchema)(importedModule).pipe(Effect$1.mapError((cause) => ConfigFileInvalidError.make({
 		file: configFile,
 		cause
-	})), Effect.map((decoded) => decoded.default));
+	})), Effect$1.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 readExtendsChild = (configFile, configEnv) => Effect$1.gen(function* () {
 	const pathService = yield* Path.Path;
-	return yield* Match.value(isLegacyConfigFile(configFile, pathService)).pipe(Match.when(true, () => Effect.fail(ConfigFileUnsupportedError.make({
+	return yield* Match.value(isLegacyConfigFile(configFile, pathService)).pipe(Match.when(true, () => Effect$1.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({
+const canonicalConfigFile = (file, pathService) => Match.value(file.startsWith("file:")).pipe(Match.when(true, () => Effect$1.try({
 	try: () => new URL(file),
 	catch: (cause) => ConfigFileUnreadableError.make({
 		file,
 		cause
 	})
-}).pipe(Effect.flatMap((url) => pathService.fromFileUrl(url).pipe(Effect.mapError((cause) => ConfigFileUnreadableError.make({
+}).pipe(Effect$1.flatMap((url) => pathService.fromFileUrl(url).pipe(Effect$1.mapError((cause) => ConfigFileUnreadableError.make({
 	file,
 	cause
-})))))), Match.orElse(() => Effect.succeed(pathService.resolve(file))));
+})))))), Match.orElse(() => Effect$1.succeed(pathService.resolve(file))));
 function resolveExtendsSpecifier(specifier) {
-	return Effect.try({
+	return Effect$1.try({
 		try: () => import.meta.resolve(specifier),
 		catch: (cause) => ConfigFileUnreadableError.make({
 			file: specifier,
@@ -1013,14 +1156,14 @@ function resolveExtendsSpecifier(specifier) {
 	});
 }
 function resolveExtends(configFile, document, configEnv) {
-	return Effect.gen(function* () {
+	return Effect$1.gen(function* () {
 		const pathService = yield* Path.Path;
-		const loop = (state, file, currentDocument) => Effect.gen(function* () {
+		const loop = (state, file, currentDocument) => Effect$1.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) => {
+			return yield* Match.value(decideExtendsStep(state, currentDocument, canonicalFile, pathService)).pipe(Match.tag("done", (d) => Effect$1.succeed(d.options)), Match.tag("read", (d) => readExtendsChild(d.path, configEnv).pipe(Effect$1.flatMap((nextDocument) => loop(d.state, d.path, nextDocument)))), Match.tag("resolve", (d) => resolveExtendsSpecifier(d.specifier).pipe(Effect$1.flatMap((resolvedUrl) => readExtendsChild(resolvedUrl, configEnv).pipe(Effect$1.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({
+				return Effect$1.fail(ConfigFileInvalidError.make({
 					file: d.file,
 					cause: message
 				}));
@@ -1045,10 +1188,10 @@ const mutationRangeBoundErrors = (index, match) => {
 	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 requireUnmagicalMutationRange = (mutateString, index, match) => Match.value(isGlob(mutateString)).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 warnOnIgnoredNodeArgs = (nodeArgs) => Match.value(nodeArgs.length > 0).pipe(Match.when(true, () => Effect$1.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$1.void));
+const warnOnCommandRunnerNodeArgs = (options) => Match.value(isCommandRunner(options.testRunner)).pipe(Match.when(true, () => warnOnIgnoredNodeArgs(options.testRunnerNodeArgs)), Match.orElse(() => Effect$1.void));
 const customValidationErrors = (options) => [
 	...thresholdErrors(options),
 	...ignoreStaticErrors(options),
@@ -1056,23 +1199,23 @@ const customValidationErrors = (options) => [
 ];
 function customValidation(options) {
 	const additionalErrors = customValidationErrors(options);
-	return warnOnCommandRunnerNodeArgs(options).pipe(Effect.flatMap(() => logConfigErrors(additionalErrors)), Effect.flatMap(() => throwErrorIfNeeded(additionalErrors)));
+	return warnOnCommandRunnerNodeArgs(options).pipe(Effect$1.flatMap(() => logConfigErrors(additionalErrors)), Effect$1.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);
+	return Effect$1.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 logConfigErrors = (errors) => Effect$1.gen(function* () {
+	for (const error of errors) yield* Effect$1.logError(error);
 });
-const failWithConfigErrors = (errors) => logConfigErrors(errors).pipe(Effect.flatMap(() => Effect.fail(ConfigError.make({ message: configErrorMessage(errors) }))));
+const failWithConfigErrors = (errors) => logConfigErrors(errors).pipe(Effect$1.flatMap(() => Effect$1.fail(ConfigError.make({ message: configErrorMessage(errors) }))));
 function throwErrorIfNeeded(errors) {
-	if (errors.length === 0) return Effect.void;
-	return Effect.fail(ConfigError.make({ message: configErrorMessage(errors) }));
+	if (errors.length === 0) return Effect$1.void;
+	return Effect$1.fail(ConfigError.make({ message: configErrorMessage(errors) }));
 }
 const OPTIONS_ADDED_BY_STRYKER = [
 	"set",
@@ -1084,10 +1227,10 @@ 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:
+const warnAboutUnknownOptions = (options, excessNames) => Effect$1.gen(function* () {
+	for (const excessPropertyName of excessNames) yield* Effect$1.logWarning(`Unknown stryker config option "${excessPropertyName}".`);
+	const pluginsJson = yield* S.encodeEffect(S.fromJsonString(S.Array(S.String)))([...options.plugins]).pipe(Effect$1.orDie);
+	yield* Effect$1.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}
@@ -1096,39 +1239,39 @@ const warnAboutUnknownOptions = (options, excessNames) => Effect.gen(function* (
 });
 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));
+	return Match.value(excessNames.length > 0).pipe(Match.when(true, () => warnAboutUnknownOptions(options, excessNames)), Match.orElse(() => Effect$1.void));
 };
 function markExcessOptions(options, schema) {
-	return Effect.gen(function* () {
+	return Effect$1.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 logUnserializableWarnings = (unserializables) => Effect$1.gen(function* () {
+	for (const unserializable of unserializables) yield* Effect$1.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$1.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)));
+const warnAboutUnserializableOptions = (options) => Match.value(findUnserializables(options)).pipe(Match.when(void 0, () => Effect$1.void), Match.orElse((unserializables) => logUnserializableWarnings(unserializables)));
 function markUnserializableOptions(options) {
-	return Effect.gen(function* () {
+	return Effect$1.gen(function* () {
 		if (isWarningEnabled("unserializableOptions", options.warnings)) yield* warnAboutUnserializableOptions(options);
 	});
 }
 function markOptions(options, schema) {
-	return Effect.gen(function* () {
+	return Effect$1.gen(function* () {
 		yield* markExcessOptions(options, schema);
 		yield* markUnserializableOptions(options);
 	});
 }
 function validateOptions(options, schema) {
-	return Effect.gen(function* () {
+	return Effect$1.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));
+const createDefaultOptions = S.decodeEffect(StrykerOptionsSchema)({}).pipe(Effect$1.orDie);
+Effect$1.map(createDefaultOptions, (opts) => deepFreeze(opts));
 `
 Example of how a config file should look:
 /**
@@ -1142,29 +1285,29 @@ A config file is a TypeScript or ESM JavaScript module: stryker.conf.ts, stryker
 
 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({
+	return Effect$1.gen(function* () {
+		return yield* (yield* FileSystem.FileSystem).access(fileName).pipe(Effect$1.as(true), Effect$1.catchTag("PlatformError", (error) => Match.value(error.reason).pipe(Match.tag("NotFound", () => Effect$1.succeed(false)), Match.orElse(() => Effect$1.fail(ConfigFileUnreadableError.make({
 			file: fileName,
 			cause: error
-		}))))), Effect.mapError((error) => ConfigFileUnreadableError.make({
+		}))))), Effect$1.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 requireExistingConfigFile = (configFileName) => exists(configFileName).pipe(Effect$1.flatMap((doesExist) => Match.value(doesExist).pipe(Match.when(true, () => Effect$1.succeed(configFileName)), Match.orElse(() => Effect$1.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);
+	onNone: () => Effect$1.succeedNone,
+	onSome: (head) => exists(head).pipe(Effect$1.flatMap((doesExist) => {
+		if (doesExist) return Effect$1.succeedSome(head);
 		return firstExistingConfigFile(fileNames.slice(1));
 	}))
 });
-const configFileFor = (configFileName) => Effect.gen(function* () {
+const configFileFor = (configFileName) => Effect$1.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({
+	return yield* Match.value(supported).pipe(Match.when(true, () => requireExistingConfigFile(configFileName)), Match.orElse(() => Effect$1.fail(ConfigFileUnsupportedError.make({
 		file: configFileName,
 		hint: Match.value(legacy).pipe(Match.when(true, () => legacyConfigHint(configFileName)), Match.orElse(() => unsupportedConfigHint(configFileName)))
 	}))));
@@ -1174,43 +1317,43 @@ 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 legacyConfigWarning = (file, supportedFile) => Effect$1.logWarning(shadowedLegacyWarning(file, supportedFile));
+const refuseLegacyOnlyProject = () => firstLegacyConfigFile().pipe(Effect$1.flatMap((legacyFile) => Option.match(legacyFile, {
+	onNone: () => Effect$1.succeedNone,
+	onSome: (file) => Effect$1.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 warnShadowedLegacyConfig = (supportedFile) => firstLegacyConfigFile().pipe(Effect$1.flatMap((legacyFile) => Option.match(legacyFile, {
+	onNone: () => Effect$1.succeed(supportedFile),
+	onSome: (file) => Effect$1.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))),
+const discoverConfigFile = () => firstExistingConfigFile([...SUPPORTED_CONFIG_FILE_NAMES]).pipe(Effect$1.flatMap((found) => Option.match(found, {
+	onNone: () => refuseLegacyOnlyProject().pipe(Effect$1.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));
+const resolveChildExtends = (configFile, child, configEnv) => Match.value("extends" in child).pipe(Match.when(true, () => resolveExtends(configFile, child, configEnv)), Match.orElse(() => Effect$1.succeed(child)));
+const isCiEnvironment = Config.string("CI").pipe(Effect$1.map((value) => Match.value(value.trim().toLowerCase()).pipe(Match.when("", () => false), Match.when("0", () => false), Match.when("false", () => false), Match.orElse(() => true))), Effect$1.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)))))));
+	return findConfigFile(cliOptions["configFile"]).pipe(Effect$1.flatMap((configFile) => Match.value(configFile).pipe(Match.when(void 0, () => Effect$1.succeed({})), Match.orElse((found) => readConfigModule(found, configEnv).pipe(Effect$1.flatMap((child) => resolveChildExtends(found, child, configEnv)))))));
 }
 function readConfig(cliOptions, invocation) {
-	return Effect.gen(function* () {
+	return Effect$1.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 cliRecord = yield* S.decodeUnknownEffect(ConfigDocumentSchema)(cliOptions).pipe(Effect$1.orDie);
 		const fileRecord = yield* loadOptionsFromConfigFile(cliRecord, configEnv);
 		const fileOptions = yield* Result.match(S.decodeUnknownResult(ConfigDocumentSchema)(fileRecord), {
-			onFailure: (cause) => Effect.fail(ConfigFileInvalidError.make({
+			onFailure: (cause) => Effect$1.fail(ConfigFileInvalidError.make({
 				file: "config",
 				cause
 			})),
-			onSuccess: (options) => Effect.succeed(options)
+			onSuccess: (options) => Effect$1.succeed(options)
 		});
 		const merged = mergeConfig(fileOptions, cliRecord);
 		const decoded = S.decodeUnknownResult(StrykerOptionsSchema)(merged);
@@ -1313,7 +1456,7 @@ const buildPluginLoadPlan = (entries) => {
 		shadowings: shadowingState.shadowings
 	};
 };
-const failPluginLoad = (descriptor, error) => Effect.logWarning(`Error during loading "${descriptor}" plugin`).pipe(Effect.andThen(() => Effect.fail(PluginLoadFailedError.make({
+const failPluginLoad = (descriptor, error) => Effect$1.logWarning(`Error during loading "${descriptor}" plugin`).pipe(Effect$1.andThen(() => Effect$1.fail(PluginLoadFailedError.make({
 	descriptor,
 	cause: error
 }))));
@@ -1330,37 +1473,37 @@ const hasContribution = (contributions) => [
 	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 warnUndescribedPluginModule = (descriptor) => Effect$1.logWarning(`Module "${descriptor}" did not contribute a StrykerJS plugin. It didn't export a "strykerPlugins", "strykerIgnorers", or "strykerValidationSchema".`).pipe(Effect$1.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)))
+	onSuccess: (contributions) => Match.value(hasContribution(contributions)).pipe(Match.when(true, () => Effect$1.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)));
+	return Effect$1.gen(function* () {
+		yield* Effect$1.logDebug(`Loading plugin ${descriptor}`);
+		const maybeModule = yield* importModule(entrypoint).pipe(Effect$1.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* () {
+	return Effect$1.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) => ({
+		const entrypoints = yield* Effect$1.forEach(Array$1.fromIterable(HashSet.fromIterable(pluginDescriptors)), (specifier) => path.fromFileUrl(new URL(specifier)).pipe(Effect$1.map((entrypoint) => ({
 			specifier,
 			entrypoint
-		})), Effect.mapError((cause) => PluginLoadFailedError.make({
+		})), Effect$1.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) => {
+		const loaded = yield* Effect$1.forEach(entrypoints, (resolved) => loadPlugin(resolved.specifier, resolved.entrypoint).pipe(Effect$1.map((plugin) => {
 			if (plugin === void 0) return;
 			return {
 				...plugin,
-				moduleName: resolved.entrypoint
+				moduleName: resolved.specifier
 			};
-		})), { concurrency: "unbounded" }).pipe(Effect.map((arr) => arr.filter(Predicate.isNotNullish)));
+		})), { concurrency: "unbounded" }).pipe(Effect$1.map((arr) => arr.filter(Predicate.isNotNullish)));
 		const ignorers = loaded.flatMap((entry) => entry.ignorers ?? NO_IGNORERS);
 		const entries = loaded.map((entry) => ({
 			moduleName: entry.moduleName,
@@ -1368,7 +1511,7 @@ function loadPlugins(pluginDescriptors) {
 			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}.`);
+		for (const shadowing of plan_.shadowings) yield* Effect$1.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,
@@ -1378,14 +1521,21 @@ function loadPlugins(pluginDescriptors) {
 		};
 	});
 }
+const pluginUrlsFromOptions = (options) => [
+	...options.plugins,
+	...options.appendPlugins,
+	...options.ignorers,
+	...Match.value(options.testRunner).pipe(Match.when(isCustomTestRunner, (runner) => [runner.plugin]), Match.orElse(() => [])),
+	...options.checkers.map((checker) => checker.plugin)
+];
 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(", ")})` }));
+const findContribution = (descriptors, kind, name) => Effect$1.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)` })),
+		onNone: () => Effect$1.fail(PluginNotFoundError.make({ descriptor: `${kind}:${name} (no ${kind} plugins were loaded)` })),
 		onSome: (descriptors) => findContribution(descriptors, kind, name)
 	});
 }
@@ -1394,8 +1544,8 @@ function create(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));
+	if (Option.isNone(descriptors)) return Effect$1.succeed([]);
+	return Effect$1.succeed(descriptors.value.filter((d) => d.kind === kind));
 }
 //#endregion
 //#region src/plugin-worker-entry.ts
@@ -1404,10 +1554,32 @@ const missingWorkerEntry = (stage, kind, name) => (failure) => StageError.make({
 	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) => ({
+const requiredSource = (params) => Effect$1.fromOption(findByKindAndName(params.loaded.pluginSources, params.kind, params.name), () => PluginNotFoundError.make({ descriptor: `${params.kind}:${params.name}` }));
+const resolvePluginWorkerEntry = (params) => requiredSource(params).pipe(Effect$1.map((source) => ({
 	kind: params.kind,
 	entrypoint: source.workerEntry
 })));
+const resolveConfiguredWorkerSpawn = (params) => {
+	const byName = (name) => requiredSource({
+		loaded: params.loaded,
+		kind: params.kind,
+		name
+	}).pipe(Effect$1.map((source) => ({
+		name,
+		spawn: {
+			kind: params.kind,
+			entrypoint: source.workerEntry
+		}
+	})));
+	if (typeof params.configured === "string") return byName(params.configured);
+	const pluginUrl = params.configured.plugin;
+	return Effect$1.fromOption(Option.map(Option.fromUndefinedOr(params.loaded.pluginSources.find((source) => source.kind === params.kind && source.modulePath === pluginUrl)), (source) => ({
+		name: source.name,
+		spawn: {
+			kind: params.kind,
+			entrypoint: source.workerEntry
+		}
+	})), () => PluginNotFoundError.make({ descriptor: `${params.kind}:${pluginUrl}` }));
+};
 //#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 };
+export { ExtendsStepRefused as $, makeConcurrency as A, partsOfEffectSpan as B, nodePlatformLayer as C, IdGenerator as D, makeWorkerClient as E, isVmRunner as F, ConfigError as G, ALWAYS_IGNORE as H, vmRunnerCapabilities as I, ConfigFileUnreadableError as J, ConfigFileInvalidError as K, vmRunnerName as L, OutOfMemoryError as M, WorkerBootTimeoutError as N, classifyWorkerExit as O, VmRunner as P, ExtendsStepRead as Q, vmTestRunner as R, makeChildProcessTestRunner as S, connectRetry as T, MUTATION_RANGE_REGEX as U, StrykerError as V, ConfigDocumentSchema as W, ExtendsStepDocumentSchema as X, ConfigFileUnsupportedError as Y, ExtendsStepDone as Z, readConfig as _, createAll as a, ReadConfigCommand as at, buildTestRunner as b, PluginLoadFailedError as c, survivorsPriorReport as ct, describeErrors as d, PrepareError as dt, ExtendsStepResolve as et, forkCoreSchema as f, StageError as ft, mergeConfigs as g, loadConfigCell as h, create as i, MergeResult as it, ChildProcessCrashedError as j, layer as k, PluginNotFoundError as l, compileIgnoreRule as lt, initialExtendsStepState as m, resolveConfiguredWorkerSpawn as n, ImportedModuleSchema as nt, loadPlugins as o, extendsPropertySchema as ot, importModule as p, ConfigFileNotFoundError as q, resolvePluginWorkerEntry as r, MergeCommand as rt, pluginUrlsFromOptions as s, forkOptionsSchema as st, missingWorkerEntry as t, ExtendsStepStateSchema as tt, decideExtendsStep as u, matchesGlob as ut, resolveExtends as v, WorkerLauncher as w, isCommandRunner as x, validateOptions as y, encodeWorkerOptions as z };