@systemfsoftware/stryker-js 13.1.0 → 14.0.0

package/dist/merge-config-DCQE_2cC.mjs

@@ -0,0 +1,1473 @@
+import * as S from "effect/Schema";
+import * as Option$1 from "effect/Option";
+import * as Order from "effect/Order";
+import * as SchemaGetter$1 from "effect/SchemaGetter";
+import * as SchemaTransformation$1 from "effect/SchemaTransformation";
+import * as Context from "effect/Context";
+import { Effect, Schema, SchemaGetter, SchemaIssue, SchemaTransformation } from "effect";
+import * as Effect$1 from "effect/Effect";
+import * as Boolean$1 from "effect/Boolean";
+import * as Rpc from "effect/unstable/rpc/Rpc";
+import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
+import * as RpcMiddleware from "effect/unstable/rpc/RpcMiddleware";
+import * as Match$1 from "effect/Match";
+import { dual } from "effect/Function";
+import * as Record$1 from "effect/Record";
+import * as Predicate$1 from "effect/Predicate";
+//#region ../stryker-js-plugin-interface/dist/rolldown-runtime-D7D4PA-g.mjs
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region ../stryker-js-plugin-interface/dist/index.mjs
+/** A 1-based line: the first line of a file is line 1. */
+const Line = S.Int.check(S.isGreaterThanOrEqualTo(1));
+/** A 1-based column: the first character of a line is column 1. */
+const Column = S.Int.check(S.isGreaterThanOrEqualTo(1));
+const Position$1 = S.Struct({
+	line: Line,
+	column: Column
+});
+const positionOrder = Order.combine(Order.mapInput(Order.Number, (position) => position.line), Order.mapInput(Order.Number, (position) => position.column));
+const inOrder = (order) => (ends) => ({
+	start: Order.min(order)(ends.start, ends.end),
+	end: Order.max(order)(ends.start, ends.end)
+});
+const notReversed = (order) => (ends) => Order.isLessThanOrEqualTo(order)(ends.start, ends.end);
+const PositionEndsSchema = S.Struct({
+	start: Position$1,
+	end: Position$1
+});
+const OrderedEnds = S.declare((value) => S.is(PositionEndsSchema)(value) && notReversed(positionOrder)(value), {
+	expected: "a location whose end is not before its start",
+	toCodecArbitrary: () => S.link()(PositionEndsSchema, {
+		decode: SchemaGetter$1.transform(inOrder(positionOrder)),
+		encode: SchemaGetter$1.transform((ends) => ends)
+	})
+});
+const Location$1 = PositionEndsSchema.pipe(S.decodeTo(OrderedEnds, SchemaTransformation$1.passthrough()));
+const OpenEndsSchema = S.Struct({
+	start: Position$1,
+	end: S.optional(Position$1)
+});
+const closedEnds = (ends) => Option$1.map(Option$1.fromUndefinedOr(ends.end), (end) => ({
+	start: ends.start,
+	end
+}));
+const OrderedOpenEnds = S.declare((value) => S.is(OpenEndsSchema)(value) && Option$1.match(closedEnds(value), {
+	onNone: () => true,
+	onSome: notReversed(positionOrder)
+}), {
+	expected: "a location whose end, when present, is not before its start",
+	toCodecArbitrary: () => S.link()(OpenEndsSchema, {
+		decode: SchemaGetter$1.transform((ends) => Option$1.getOrElse(Option$1.map(closedEnds(ends), inOrder(positionOrder)), () => ends)),
+		encode: SchemaGetter$1.transform((ends) => ends)
+	})
+});
+const OpenEndLocation$1 = OpenEndsSchema.pipe(S.decodeTo(OrderedOpenEnds, SchemaTransformation$1.passthrough()));
+S.is(Line), S.is(Column), S.is(Location$1);
+const MutantStatusSchema = S.Literals([
+	"Killed",
+	"Survived",
+	"NoCoverage",
+	"CompileError",
+	"RuntimeError",
+	"Timeout",
+	"Ignored",
+	"Pending"
+]);
+const SurvivorStatusSchema = S.Literals(["Survived", "NoCoverage"]);
+const RememberedStatusSchema = S.Literals([
+	"Survived",
+	"Killed",
+	"Timeout",
+	"NoCoverage",
+	"Ignored"
+]);
+const EphemeralStatusSchema = S.Literals([
+	"CompileError",
+	"RuntimeError",
+	"Pending"
+]);
+const ActionableStatusSchema = S.Literals([
+	"Survived",
+	"NoCoverage",
+	"Timeout",
+	"RuntimeError"
+]);
+const MutantId = S.String.check(S.isPattern(/^[0-9a-f]{16}$/, { expected: "a 16-character lowercase hexadecimal mutant id" })).pipe(S.brand("MutantId"));
+const MutatorNameGrammar = S.String.check(S.isPattern(/^(?:[a-z][a-z0-9]*(?:-[a-z0-9]+)*\/)?[A-Z][A-Za-z0-9]*$/, { expected: "a PascalCase mutator name, optionally prefixed by a lowercase kebab-case namespace and a slash" }));
+const MutatorName = MutatorNameGrammar.pipe(S.brand("MutatorName"));
+const CanonicalFileName = S.String.pipe(S.decodeTo(S.String.pipe(S.check(S.isPattern(/^[^\\]+$/)), S.brand("CanonicalFileName")), {
+	decode: SchemaGetter$1.transform((fileName) => fileName.replace(/\\/g, "/")),
+	encode: SchemaGetter$1.transform((canonical) => canonical)
+}));
+/**
+* A mutant's file location in the mutation-testing-report-schema contract:
+* 1-based line and 1-based column, the same base the JSON report and the
+* machine stream emit. Every producer on the instrument path (node spans,
+* embedded-region shifts) targets this base; no downstream layer converts.
+*/
+const Mutant = S.TaggedStruct("Mutant", {
+	id: MutantId,
+	fileName: CanonicalFileName,
+	mutatorName: MutatorName,
+	replacement: S.String,
+	location: Location$1,
+	status: S.optional(MutantStatusSchema),
+	statusReason: S.optional(S.String),
+	coveredBy: S.String.pipe(S.Array, S.optional),
+	static: S.optional(S.Boolean),
+	testsCompleted: S.optional(S.Finite),
+	description: S.optional(S.String)
+}).check(S.makeFilter((mutant) => mutant.statusReason === void 0 || mutant.status !== void 0, { message: "a mutant carries a status reason only together with a status" }));
+const MutantFromUnknown = S.Unknown.pipe(S.decodeTo(Mutant));
+const RunOptionsFields = {
+	timeout: S.Finite.pipe(S.check(S.isGreaterThanOrEqualTo(0))),
+	disableBail: S.Boolean
+};
+const MutantActivationSchema = S.Literals(["runtime", "static"]);
+const HitCount = S.Int.pipe(S.check(S.isGreaterThanOrEqualTo(0)));
+const MutantRunOptionsSchema = S.Struct({
+	...RunOptionsFields,
+	activeMutant: Mutant,
+	sandboxFileName: S.String,
+	mutantActivation: MutantActivationSchema,
+	reloadEnvironment: S.Boolean,
+	testFilter: S.String.pipe(S.Array, S.optionalKey),
+	priorKillerTestIds: S.String.pipe(S.Array, S.optionalKey),
+	hitLimit: S.optionalKey(HitCount)
+});
+const asMutantIdKeyed = (counts) => Object.fromEntries(Object.entries(counts).filter(([key]) => S.is(MutantId)(key)));
+const asStringKeyed = (counts) => Object.fromEntries(Object.entries(counts));
+const MutantIdKeyedHitCounts = S.Record(S.String, HitCount).pipe(S.check(S.makeFilter((counts) => {
+	const unknownKey = Object.keys(counts).find((key) => !S.is(MutantId)(key));
+	return unknownKey === void 0 ? void 0 : {
+		path: [unknownKey],
+		issue: `hit counts must be keyed by mutant ids, got '${unknownKey}'`
+	};
+}, { arbitraryConstraint: { patterns: [{
+	source: "^[0-9a-f]{16}$",
+	flags: ""
+}] } })), S.decodeTo(S.Record(MutantId, HitCount), {
+	decode: SchemaGetter$1.transform(asMutantIdKeyed),
+	encode: SchemaGetter$1.transform(asStringKeyed)
+}));
+const MutantCoverageSchema = S.Struct({
+	perTest: S.Record(S.String, MutantIdKeyedHitCounts),
+	static: MutantIdKeyedHitCounts
+});
+SurvivorStatusSchema.literals, RememberedStatusSchema.literals, EphemeralStatusSchema.literals, ActionableStatusSchema.literals;
+const CheckerMutantWire = S.Struct({
+	id: MutantId,
+	fileName: CanonicalFileName,
+	mutatorName: MutatorName,
+	replacement: S.String,
+	location: Location$1
+});
+const CheckResultSchema = S.Union([S.Struct({ status: S.Literal("passed") }), S.Struct({
+	status: S.Literal("compileError"),
+	reason: S.String
+})]).pipe(S.toTaggedUnion("status"));
+const CheckStatus = S.Literals(CheckResultSchema.discriminants);
+var CheckerFailed = class extends S.TaggedError()("CheckerFailed", {
+	cause: S.String,
+	checkerName: S.String,
+	mutantIds: S.Array(MutantId)
+}) {
+	get message() {
+		const mutants = this.mutantIds.length === 0 ? "" : ` for mutants ${this.mutantIds.join(", ")}`;
+		return `Checker "${this.checkerName}" failed${mutants}: ${this.cause}`;
+	}
+};
+var Checker = class extends Context.Service()("@systemfsoftware/stryker-js-plugin-interface/Checker.service/Checker") {};
+var Checker_exports = /* @__PURE__ */ __exportAll({
+	CheckResultSchema: () => CheckResultSchema,
+	CheckStatus: () => CheckStatus,
+	Checker: () => Checker,
+	CheckerFailed: () => CheckerFailed,
+	CheckerMutantWire: () => CheckerMutantWire
+});
+S.TaggedError()("EvaluatorFailed", { cause: S.Unknown });
+Context.Service()("@systemfsoftware/stryker-js-plugin-interface/Evaluator.service/Evaluator");
+const RULE_IDS = [
+	"arid-logging",
+	"arid-telemetry",
+	"arid-time",
+	"arid-config-default",
+	"arid-memoization",
+	"redundant-relational",
+	"equivalent-to-original",
+	"duplicate-at-site",
+	"ignore-static",
+	"directive",
+	"excluded-mutator",
+	"ignorer"
+];
+const IgnoreRuleId = S.Literals(RULE_IDS);
+const SEPARATOR = ": ";
+const asLiteralPattern = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const REASON_SOURCE = `^(?:${RULE_IDS.map(asLiteralPattern).join("|")})${SEPARATOR}[\\s\\S]*$`;
+const IgnoreStatusReasonText = S.String.check(S.isPattern(new RegExp(REASON_SOURCE), { arbitraryConstraint: { patterns: [{
+	source: REASON_SOURCE,
+	flags: ""
+}] } }));
+const ReasonPartsSchema = S.Struct({
+	ruleId: IgnoreRuleId,
+	detail: S.String
+});
+const reasonPartsOf = (text) => Option$1.map(Option$1.fromNullishOr(RULE_IDS.find((ruleId) => text.startsWith(`${ruleId}${SEPARATOR}`))), (ruleId) => ({
+	ruleId,
+	detail: text.slice(ruleId.length + 2)
+}));
+const malformedReason = (text) => new SchemaIssue.InvalidValue({ message: `expected "<rule-id>${SEPARATOR}<detail>"` }, text);
+const partsOf$1 = SchemaGetter.transformEffect((text) => Effect$1.fromOption(reasonPartsOf(text), () => malformedReason(text)));
+const textOf$1 = SchemaGetter.transform((parts) => `${parts.ruleId}${SEPARATOR}${parts.detail}`);
+const IgnoreStatusReason = IgnoreStatusReasonText.pipe(S.decodeTo(ReasonPartsSchema, SchemaTransformation.makeTransformation({
+	decode: partsOf$1,
+	encode: textOf$1
+})));
+const Id = S.String.check(S.isPattern(/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/, { expected: "a lowercase kebab-case catalog entry id" })).pipe(S.brand("MutatorCatalogId"));
+const Tier = S.Literals(["default", "optIn"]);
+const Definition = S.NonEmptyString;
+/**
+* `after` lists the replacement texts in the order the mutator emits them, and
+* is empty when the entry must not fire on `before`.
+*/
+const Example = S.Struct({
+	before: S.String,
+	after: S.Array(S.String)
+});
+const EntryShape = S.Struct({
+	id: Id,
+	name: MutatorName,
+	tier: Tier,
+	definition: Definition,
+	examples: S.Array(Example)
+});
+const carriesExamples = S.makeFilter((entry) => entry.examples.length === 0 ? `mutator catalog entry "${entry.id}" carries no examples` : void 0);
+const carriesASnippet = S.makeFilter((entry) => {
+	return entry.examples.find((example) => example.before.length === 0) === void 0 ? void 0 : `mutator catalog entry "${entry.id}" carries an example with an empty before`;
+});
+const Entry = EntryShape.check(carriesExamples, carriesASnippet);
+const Provider = S.String.check(S.isPattern(/^(?:stryker|[a-z][a-z0-9]*(?:-[a-z0-9]+)*)$/, { expected: "the stock provider \"stryker\" or a lowercase kebab-case plugin namespace" })).pipe(S.brand("MutatorProvider"));
+const CatalogShape = S.Struct({
+	provider: Provider,
+	entries: S.NonEmptyArray(Entry)
+});
+const duplicatedValue = (values) => values.find((value, index) => values.indexOf(value) !== index);
+const namespaceOf = (name) => {
+	const slash = name.indexOf("/");
+	return slash === -1 ? void 0 : name.slice(0, slash);
+};
+const entryIdsAreUnique = S.makeFilter((catalog) => {
+	const duplicated = duplicatedValue(catalog.entries.map((entry) => entry.id));
+	return duplicated === void 0 ? void 0 : `mutator catalog entries share the id "${duplicated}"`;
+});
+const entryNamesAreUnique = S.makeFilter((catalog) => {
+	const duplicated = duplicatedValue(catalog.entries.map((entry) => entry.name));
+	return duplicated === void 0 ? void 0 : `mutator catalog entries share the mutator name "${duplicated}"`;
+});
+const ownedByProvider = (provider, name) => {
+	const namespace = namespaceOf(name);
+	return provider === "stryker" ? namespace === void 0 : namespace === provider;
+};
+const providerOwnsEveryName = S.makeFilter((catalog) => {
+	const unowned = catalog.entries.find((entry) => !ownedByProvider(catalog.provider, entry.name));
+	return unowned === void 0 ? void 0 : `provider "${catalog.provider}" does not own the mutator name "${unowned.name}"`;
+});
+const Catalog = CatalogShape.check(entryIdsAreUnique, entryNamesAreUnique, providerOwnsEveryName);
+var Mutant_exports = /* @__PURE__ */ __exportAll({
+	ActionableStatusSchema: () => ActionableStatusSchema,
+	CanonicalFileName: () => CanonicalFileName,
+	Column: () => Column,
+	EphemeralStatusSchema: () => EphemeralStatusSchema,
+	HitCount: () => HitCount,
+	IgnoreRuleId: () => IgnoreRuleId,
+	IgnoreStatusReason: () => IgnoreStatusReason,
+	IgnoreStatusReasonText: () => IgnoreStatusReasonText,
+	Line: () => Line,
+	Location: () => Location$1,
+	Mutant: () => Mutant,
+	MutantActivationSchema: () => MutantActivationSchema,
+	MutantCoverageSchema: () => MutantCoverageSchema,
+	MutantFromUnknown: () => MutantFromUnknown,
+	MutantId: () => MutantId,
+	MutantRunOptionsSchema: () => MutantRunOptionsSchema,
+	MutantStatusSchema: () => MutantStatusSchema,
+	MutatorName: () => MutatorName,
+	OpenEndLocation: () => OpenEndLocation$1,
+	Position: () => Position$1,
+	RememberedStatusSchema: () => RememberedStatusSchema,
+	RunOptionsFields: () => RunOptionsFields,
+	SurvivorStatusSchema: () => SurvivorStatusSchema,
+	duplicatedValue: () => duplicatedValue,
+	inOrder: () => inOrder,
+	notReversed: () => notReversed
+});
+var MutatorCatalog_exports = /* @__PURE__ */ __exportAll({
+	Catalog: () => Catalog,
+	Definition: () => Definition,
+	Entry: () => Entry,
+	Example: () => Example,
+	Id: () => Id,
+	Name: () => MutatorName,
+	Provider: () => Provider,
+	Tier: () => Tier
+});
+const isMutator = (value) => typeof value === "function";
+const implementsNothing = () => [];
+const mutatorArbitrary = Schema.link()(Schema.Null, {
+	decode: SchemaGetter.transform(() => implementsNothing),
+	encode: SchemaGetter.transform(() => null)
+});
+const Implementation = Schema.declare(isMutator, { toCodecArbitrary: () => mutatorArbitrary });
+const ProviderEntry = Schema.Struct({
+	id: Id,
+	name: MutatorName,
+	tier: Tier,
+	definition: Definition,
+	examples: Schema.NonEmptyArray(Example),
+	implementation: Implementation
+});
+const Contribution = Schema.Struct({
+	namespace: Provider,
+	entries: Schema.NonEmptyArray(ProviderEntry)
+});
+var MutatorProvider_exports = /* @__PURE__ */ __exportAll({
+	Contribution: () => Contribution,
+	Implementation: () => Implementation,
+	ProviderEntry: () => ProviderEntry
+});
+const statusBuckets = {
+	Detected: ["Killed", "Timeout"],
+	Undetected: ["Survived", "NoCoverage"],
+	Invalid: ["CompileError", "RuntimeError"],
+	Untested: ["Ignored", "Pending"]
+};
+const DetectedStatus = S.Literals(statusBuckets.Detected);
+const UndetectedStatus = S.Literals(statusBuckets.Undetected);
+const InvalidStatus = S.Literals(statusBuckets.Invalid);
+const UntestedStatus = S.Literals(statusBuckets.Untested);
+const NonNegativeInt = S.Int.pipe(S.check(S.isGreaterThanOrEqualTo(0)));
+const NonNegativeFinite = S.Finite.pipe(S.check(S.isGreaterThanOrEqualTo(0)));
+const Percentage = S.Finite.pipe(S.check(S.isBetween({
+	minimum: 0,
+	maximum: 100
+})));
+const MutationScore = S.TaggedUnion({
+	Scored: { percentage: Percentage },
+	Unscored: {}
+});
+const StaticClassSummarySchema = S.Struct({
+	count: NonNegativeInt,
+	costMs: NonNegativeFinite
+});
+const scorePercentageOf = (counts) => counts.counted > 0 ? Option$1.some(counts.detected / counts.counted * 100) : Option$1.none();
+var Metrics = class extends S.Class("Metrics")({
+	pending: NonNegativeInt,
+	killed: NonNegativeInt,
+	timeout: NonNegativeInt,
+	survived: NonNegativeInt,
+	noCoverage: NonNegativeInt,
+	runtimeErrors: NonNegativeInt,
+	compileErrors: NonNegativeInt,
+	ignored: NonNegativeInt
+}) {
+	get totalDetected() {
+		return this.timeout + this.killed;
+	}
+	get totalUndetected() {
+		return this.survived + this.noCoverage;
+	}
+	get totalCovered() {
+		return this.totalDetected + this.survived;
+	}
+	get totalValid() {
+		return this.totalUndetected + this.totalDetected;
+	}
+	get totalInvalid() {
+		return this.runtimeErrors + this.compileErrors;
+	}
+	get totalMutants() {
+		return this.totalValid + this.totalInvalid + this.ignored + this.pending;
+	}
+	get mutationScore() {
+		return Option$1.match(scorePercentageOf({
+			detected: this.totalDetected,
+			counted: this.totalValid
+		}), {
+			onNone: () => MutationScore.cases.Unscored.make({}),
+			onSome: (percentage) => MutationScore.cases.Scored.make({ percentage })
+		});
+	}
+	get mutationScoreBasedOnCoveredCode() {
+		return Option$1.match(scorePercentageOf({
+			detected: this.totalDetected,
+			counted: this.totalCovered
+		}), {
+			onNone: () => MutationScore.cases.Unscored.make({}),
+			onSome: (percentage) => MutationScore.cases.Scored.make({ percentage })
+		});
+	}
+};
+const MetricsSchema = Metrics;
+const MetricsResultSchema = S.Struct({
+	name: S.String,
+	metrics: Metrics,
+	childResults: S.Array(S.suspend(() => MetricsResultSchema))
+}).annotate({ identifier: "MetricsResult" });
+const StrykerCoverageAnalysis = S.Literal("perTest");
+const StrykerFileLogLevel = S.Literal("off");
+const StrykerLogLevel = S.Literal("info");
+const StrykerTempDirName = S.Literal(".stryker-tmp");
+/**
+* The Stryker option set, declared as ONE Effect Schema.
+*
+* Replaces the vendored `schema/stryker-core.json` codegen chain
+* (`tasks/generate-stryker-core.mjs` → `src-generated/stryker-core.ts`): every
+* option name, type, optionality and default is preserved, and
+* the JSON Schema document is **derived** from
+* `StrykerOptionsSchema` (no file read).
+*
+* Layering mirrors the original document:
+* - objects without `additionalProperties: false` there (the option set
+*   itself, `commandRunner`, `clearTextReporter`, `warnings`) are open here —
+*   `S.StructWithRest` with a `Record<string, unknown>` index keeps arbitrary
+*   plugin-proposed keys and makes the decoded type carry
+*   `[k: string]: unknown`;
+* - objects with `additionalProperties: false` (`htmlReporter`, `jsonReporter`,
+*   `thresholds`, `mutator`) are closed here.
+*
+* `dashboard` and `eventReporter` are absent: the reporters they configured were
+* removed, and the removed-option check rejects both names. Declaring them here
+* with defaults meant the default option set carried two options the very next
+* validation step refused - invisible only while the defaults were filled by a
+* separate engine that happened not to inject them.
+*/
+/** Open object: fixed fields plus an index signature accepting arbitrary plugin keys. */
+const openStruct = (fields) => S.StructWithRest(S.Struct(fields), [S.Record(S.String, S.Unknown)]);
+/**
+* Field that decodes to a value but defaults when the key is absent.
+*
+* The default is typed by the schema's ENCODED side, which is what
+* `withDecodingDefaultKey` consumes: a whole-object option can therefore default
+* to `{}` exactly when every field inside it carries its own default, and
+* the compiler decides that rather than the author asserting it.
+*
+* The annotation is applied to the schema BEFORE the default transform wraps it.
+* Annotating the wrapper instead leaves `default` off the derived JSON Schema
+* document, so a consumer filling defaults from that document (ajv
+* `useDefaults`) silently injects nothing.
+*/
+const defaulted = (schema, defaultValue) => {
+	const annotated = schema.annotate({ default: defaultValue });
+	return S.withDecodingDefaultKey(Effect.succeed(defaultValue))(annotated);
+};
+const LogLevel = S.Literals([
+	"off",
+	"fatal",
+	"error",
+	"warn",
+	"info",
+	"debug",
+	"trace"
+]);
+const CoverageAnalysisMode = S.Literals([
+	"off",
+	"all",
+	"perTest"
+]);
+const ReportType = S.Literals(["full", "mutationScore"]);
+const PackageManager = S.Literals([
+	"npm",
+	"yarn",
+	"pnpm"
+]);
+const MutantSetPolicy = S.Literals(["default", "full"]);
+const CommandRunnerOptionsSchema = openStruct({ command: defaulted(S.String, "npm test") });
+const ClearTextReporterOptions = openStruct({
+	allowColor: defaulted(S.Boolean, true),
+	allowEmojis: defaulted(S.Boolean, false),
+	logTests: defaulted(S.Boolean, true),
+	maxTestsToLog: defaulted(NonNegativeInt, 3),
+	reportTests: defaulted(S.Boolean, true),
+	reportMutants: defaulted(S.Boolean, true),
+	reportScoreTable: defaulted(S.Boolean, true),
+	skipFull: defaulted(S.Boolean, false)
+});
+const HtmlReporterOptions = S.Struct({ fileName: defaulted(S.String, "reports/mutation/mutation.html") });
+const JsonReporterOptions = S.Struct({ fileName: defaulted(S.String, "reports/mutation/mutation.json") });
+const MutationScoreThresholdsValuesSchema = S.Struct({
+	high: defaulted(Percentage, 80),
+	low: defaulted(Percentage, 60),
+	break: defaulted(S.NullOr(Percentage), null)
+});
+const OrderedThresholdsValuesSchema = S.Struct({
+	high: Percentage,
+	low: Percentage,
+	break: S.NullOr(Percentage)
+});
+const isOrderedThresholds = (value) => S.is(OrderedThresholdsValuesSchema)(value) && value.low <= value.high;
+const OrderedThresholds = S.declare(isOrderedThresholds, {
+	message: "a mutation score threshold pair has low at or below high",
+	toCodecArbitrary: () => S.link()(OrderedThresholdsValuesSchema, {
+		decode: SchemaGetter.transform(({ break: breaking, high, low }) => ({
+			break: breaking,
+			high: Math.max(high, low),
+			low: Math.min(high, low)
+		})),
+		encode: SchemaGetter.transform((thresholds) => thresholds)
+	})
+});
+const MutationScoreThresholdsSchema = MutationScoreThresholdsValuesSchema.pipe(S.decodeTo(OrderedThresholds, SchemaTransformation.passthrough()));
+const MutatorDescriptor = S.Struct({
+	excludedMutations: defaulted(S.Array(MutatorNameGrammar), []),
+	optInMutations: defaulted(S.Array(MutatorNameGrammar), []),
+	mutantSetPolicy: defaulted(MutantSetPolicy, "default")
+});
+const SurfacingOptions = S.Struct({
+	perLine: defaulted(NonNegativeInt, 1),
+	perFile: defaulted(NonNegativeInt, 7)
+});
+const WarningOptions = openStruct({
+	unknownOptions: defaulted(S.Boolean, true),
+	preprocessorErrors: defaulted(S.Boolean, true),
+	unserializableOptions: defaulted(S.Boolean, true),
+	slow: defaulted(S.Boolean, true)
+});
+const ConcurrencyCount = S.Int.pipe(S.check(S.isGreaterThanOrEqualTo(1)));
+const ConcurrencyPercent = S.String.pipe(S.check(S.isPattern(/^(100|[1-9]?[0-9])%$/)));
+const pluginSpecifierArbitrary = S.link()(S.Literals([
+	"file:///project/node_modules/@systemfsoftware/stryker-js-angular/index.mjs",
+	"file:///home/user/project/plugins/custom-plugin.mjs",
+	"effect",
+	"@systemfsoftware/stryker-js-angular",
+	"@systemfsoftware/stryker-js-svelte",
+	"my-plugin",
+	"@scope/my-plugin/sub/entry",
+	"my-plugin/sub"
+]), {
+	decode: SchemaGetter.transform((sample) => sample),
+	encode: SchemaGetter.transform((sample) => sample)
+});
+const PluginFileUrl = S.declare((value) => typeof value === "string" && /^(?:file:\/\/\/\S+|(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*(?:\/(?!\.\.?\/)[^/\s]+)*)$/.test(value), { toCodecArbitrary: () => pluginSpecifierArbitrary });
+const TestRunnerCustomConfigSchema = S.Struct({
+	plugin: PluginFileUrl,
+	nodeArgs: S.String.pipe(S.Array, S.optionalKey),
+	options: S.optionalKey(S.Record(S.String, S.Unknown))
+});
+const TestRunnerConfigSchema = S.Union([S.String, TestRunnerCustomConfigSchema]);
+const AnyNonStringTestRunner = S.declare((value) => typeof value !== "string", { message: "expected a custom test runner config" });
+const isCustomTestRunner = S.is(AnyNonStringTestRunner);
+const CheckerCustomConfigSchema = S.Struct({
+	plugin: PluginFileUrl,
+	nodeArgs: S.String.pipe(S.Array, S.optionalKey),
+	options: S.optionalKey(S.Record(S.String, S.Unknown))
+});
+const CheckerEntryConfigSchema = CheckerCustomConfigSchema;
+const StrykerOptionsSchema = S.StructWithRest(S.Struct({
+	allowConsoleColors: defaulted(S.Boolean, true),
+	buildCommand: S.optionalKey(S.String),
+	checkers: defaulted(S.Array(CheckerEntryConfigSchema), []),
+	checkerNodeArgs: defaulted(S.Array(S.String), []),
+	concurrency: S.optionalKey(S.Union([ConcurrencyCount, ConcurrencyPercent])),
+	commandRunner: defaulted(CommandRunnerOptionsSchema, { command: "npm test" }),
+	coverageAnalysis: defaulted(CoverageAnalysisMode, StrykerCoverageAnalysis.literal),
+	clearTextReporter: defaulted(ClearTextReporterOptions, {
+		allowColor: true,
+		allowEmojis: false,
+		logTests: true,
+		maxTestsToLog: 3,
+		reportTests: true,
+		reportMutants: true,
+		reportScoreTable: true,
+		skipFull: false
+	}),
+	dryRunOnly: defaulted(S.Boolean, false),
+	ignorePatterns: defaulted(S.Array(S.String), []),
+	ignoreStatic: defaulted(S.Boolean, false),
+	incremental: defaulted(S.Boolean, false),
+	incrementalFile: defaulted(S.String, "reports/stryker-incremental.json"),
+	incrementalSources: defaulted(S.Array(S.String), []),
+	progressStreamFile: defaulted(S.String, "reports/mutation-stream.jsonl"),
+	since: S.optionalKey(S.String),
+	force: defaulted(S.Boolean, false),
+	fileLogLevel: defaulted(LogLevel, StrykerFileLogLevel.literal),
+	inPlace: defaulted(S.Boolean, false),
+	logLevel: defaulted(LogLevel, StrykerLogLevel.literal),
+	maxConcurrentTestRunners: defaulted(S.Int.pipe(S.check(S.isGreaterThanOrEqualTo(1))), Number.MAX_SAFE_INTEGER),
+	maxTestRunnerReuse: defaulted(NonNegativeInt, 0),
+	mutate: defaulted(S.Array(S.String), ["{src,lib}/**/!(*.+(s|S)pec|*.+(t|T)est).+(cjs|mjs|js|ts|mts|cts|jsx|tsx|html|vue|svelte)", "!{src,lib}/**/__tests__/**/*.+(cjs|mjs|js|ts|mts|cts|jsx|tsx|html|vue|svelte)"]),
+	mutator: defaulted(MutatorDescriptor, {
+		excludedMutations: [],
+		optInMutations: [],
+		mutantSetPolicy: "default"
+	}),
+	surfacing: defaulted(SurfacingOptions, {
+		perLine: 1,
+		perFile: 7
+	}),
+	packageManager: S.optionalKey(PackageManager),
+	plugins: defaulted(S.Array(PluginFileUrl), []),
+	appendPlugins: defaulted(S.Array(PluginFileUrl), []),
+	reporters: defaulted(S.Array(S.String), [
+		"clear-text",
+		"progress",
+		"html"
+	]),
+	htmlReporter: defaulted(HtmlReporterOptions, { fileName: "reports/mutation/mutation.html" }),
+	jsonReporter: defaulted(JsonReporterOptions, { fileName: "reports/mutation/mutation.json" }),
+	disableTypeChecks: defaulted(S.Union([S.Boolean, S.String]), true),
+	symlinkNodeModules: defaulted(S.Boolean, true),
+	tempDirName: defaulted(S.String, StrykerTempDirName.literal),
+	cleanTempDir: defaulted(S.Literals([
+		"always",
+		false,
+		true
+	]), true),
+	testRunner: defaulted(TestRunnerConfigSchema, "vm"),
+	testRunnerNodeArgs: defaulted(S.Array(S.String), []),
+	thresholds: defaulted(MutationScoreThresholdsSchema, {
+		high: 80,
+		low: 60,
+		break: null
+	}),
+	timeoutFactor: defaulted(NonNegativeFinite, 1.5),
+	timeoutMS: defaulted(NonNegativeInt, 5e3),
+	dryRunTimeoutMinutes: defaulted(NonNegativeFinite, 5),
+	tsconfigFile: defaulted(S.String, "tsconfig.json"),
+	warnings: defaulted(S.Union([S.Boolean, WarningOptions]), true),
+	disableBail: defaulted(S.Boolean, false),
+	allowEmpty: defaulted(S.Boolean, false),
+	ignorers: defaulted(S.Array(PluginFileUrl), []),
+	testFiles: defaulted(S.Array(S.String), [])
+}), [S.Record(S.String, S.Unknown)]);
+var Options_exports = /* @__PURE__ */ __exportAll({
+	CheckerCustomConfigSchema: () => CheckerCustomConfigSchema,
+	CheckerEntryConfigSchema: () => CheckerEntryConfigSchema,
+	CommandRunnerOptionsSchema: () => CommandRunnerOptionsSchema,
+	CoverageAnalysisMode: () => CoverageAnalysisMode,
+	LogLevel: () => LogLevel,
+	MutantSetPolicy: () => MutantSetPolicy,
+	MutationScoreThresholdsSchema: () => MutationScoreThresholdsSchema,
+	PackageManager: () => PackageManager,
+	PluginFileUrl: () => PluginFileUrl,
+	ReportType: () => ReportType,
+	StrykerCoverageAnalysis: () => StrykerCoverageAnalysis,
+	StrykerFileLogLevel: () => StrykerFileLogLevel,
+	StrykerLogLevel: () => StrykerLogLevel,
+	StrykerOptionsSchema: () => StrykerOptionsSchema,
+	StrykerTempDirName: () => StrykerTempDirName,
+	TestRunnerConfigSchema: () => TestRunnerConfigSchema,
+	TestRunnerCustomConfigSchema: () => TestRunnerCustomConfigSchema,
+	isCustomTestRunner: () => isCustomTestRunner
+});
+const ExitCode = S.Int.pipe(S.check(S.isBetween({
+	minimum: 0,
+	maximum: 255
+})));
+const ExitClass = S.Literals([
+	"VerdictFail",
+	"ConfigError",
+	"RuntimeError",
+	"InternalError"
+]);
+const BASELINE_EXIT_CODES = {
+	VerdictFail: 1,
+	ConfigError: 2,
+	RuntimeError: 3,
+	InternalError: 4
+};
+const CLASS_BY_BASELINE_CODE = {
+	1: "VerdictFail",
+	2: "ConfigError",
+	3: "RuntimeError",
+	4: "InternalError"
+};
+const codeOfClass = (exitClass) => BASELINE_EXIT_CODES[exitClass];
+const classOfCode = (code) => CLASS_BY_BASELINE_CODE[code];
+const BaselineExitCode = S.Literals([
+	1,
+	2,
+	3,
+	4
+]);
+const ExitCodeFromClass = S.decodeTo(BaselineExitCode, SchemaTransformation.transform({
+	decode: codeOfClass,
+	encode: classOfCode
+}))(ExitClass);
+const Position = S.StructWithRest(S.Struct({
+	"line": S.Finite.annotate({ "examples": [4] }).check(S.isInt().annotate({ "expected": "an integer" })).check(S.isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })),
+	"column": S.Finite.annotate({ "examples": [3] }).check(S.isInt().annotate({ "expected": "an integer" })).check(S.isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" }))
+}), [S.Record(S.String, S.Json.annotate({ "expected": "JSON value" }))]).annotate({
+	"title": "Position",
+	"description": "Position of a mutation. Both line and column start at one.",
+	"identifier": "position"
+});
+const Thresholds = S.StructWithRest(S.Struct({
+	"high": S.Finite.annotate({
+		"description": "Higher bound threshold.",
+		"examples": [80]
+	}).check(S.isInt().annotate({ "expected": "an integer" })).check(S.isGreaterThanOrEqualTo(0).annotate({ "expected": "a value greater than or equal to 0" })).check(S.isLessThanOrEqualTo(100).annotate({ "expected": "a value less than or equal to 100" })),
+	"low": S.Finite.annotate({
+		"description": "Lower bound threshold.",
+		"examples": [60]
+	}).check(S.isInt().annotate({ "expected": "an integer" })).check(S.isGreaterThanOrEqualTo(0).annotate({ "expected": "a value greater than or equal to 0" })).check(S.isLessThanOrEqualTo(100).annotate({ "expected": "a value less than or equal to 100" })),
+	"break": S.optionalKey(S.Union([S.Finite.check(S.isFinite().annotate({ "expected": "a finite number" })).check(S.isGreaterThanOrEqualTo(0).annotate({ "expected": "a value greater than or equal to 0" })).check(S.isLessThanOrEqualTo(100).annotate({ "expected": "a value less than or equal to 100" })), S.Null]).annotate({ "description": "The mutation score below which the run breaks. Null disables the break." }))
+}), [S.Record(S.String, S.Json.annotate({ "expected": "JSON value" }))]).annotate({
+	"title": "Thresholds",
+	"description": "Thresholds for the status of the reported application.",
+	"identifier": "thresholds"
+});
+const PerformanceStatistics = S.StructWithRest(S.Struct({
+	"setup": S.Finite.annotate({ "description": "Time it took to run the setup phase in milliseconds." }).check(S.isFinite().annotate({ "expected": "a finite number" })),
+	"initialRun": S.Finite.annotate({ "description": "Time it took to run the initial test phase (dry-run) in milliseconds." }).check(S.isFinite().annotate({ "expected": "a finite number" })),
+	"mutation": S.Finite.annotate({ "description": "Time it took to run the mutation test phase in milliseconds." }).check(S.isFinite().annotate({ "expected": "a finite number" }))
+}), [S.Record(S.String, S.Json.annotate({ "expected": "JSON value" }))]).annotate({
+	"title": "PerformanceStatistics",
+	"description": "The performance statistics per phase. Total time should be roughly equal to the sum of all these.",
+	"identifier": "performanceStatistics"
+});
+const BrandingInformation = S.StructWithRest(S.Struct({
+	"homepageUrl": S.String.annotate({
+		"description": "URL to the homepage of the framework.",
+		"format": "uri"
+	}),
+	"imageUrl": S.optionalKey(S.String.annotate({ "description": "URL to an image for the framework, can be a data URL." }))
+}), [S.Record(S.String, S.Json.annotate({ "expected": "JSON value" }))]).annotate({
+	"title": "BrandingInformation",
+	"description": "Extra branding information about the framework used.",
+	"identifier": "brandingInformation"
+});
+const Dependencies = S.Record(S.String, S.String).annotate({
+	"title": "Dependencies",
+	"description": "Dependencies used by the framework. Key-value pair of dependencies and their versions.",
+	"identifier": "dependencies"
+});
+const OSInformation = S.StructWithRest(S.Struct({
+	"description": S.optionalKey(S.String.annotate({
+		"description": "Human-readable description of the OS",
+		"examples": [
+			"Windows 10 Pro",
+			"Debian Buster",
+			"Ubuntu 20.04.1 LTS"
+		]
+	})),
+	"platform": S.String.annotate({
+		"description": "Platform identifier",
+		"examples": ["linux", "win32"]
+	}),
+	"version": S.optionalKey(S.String.annotate({
+		"description": "Version of the OS or distribution",
+		"examples": ["10.0.19041"]
+	}))
+}), [S.Record(S.String, S.Json.annotate({ "expected": "JSON value" }))]).annotate({
+	"title": "OSInformation",
+	"identifier": "oSInformation"
+});
+const CpuInformation = S.StructWithRest(S.Struct({
+	"baseClock": S.optionalKey(S.Finite.annotate({ "description": "Clock speed in MHz" }).check(S.isFinite().annotate({ "expected": "a finite number" }))),
+	"logicalCores": S.Finite.check(S.isFinite().annotate({ "expected": "a finite number" })),
+	"model": S.optionalKey(S.String.annotate({ "examples": ["Intel(R) Core(TM) i9-9880H CPU @ 2.30GHz"] }))
+}), [S.Record(S.String, S.Json.annotate({ "expected": "JSON value" }))]).annotate({
+	"title": "CpuInformation",
+	"identifier": "cpuInformation"
+});
+const RamInformation = S.StructWithRest(S.Struct({ "total": S.Finite.annotate({ "description": "The total RAM of the system that performed mutation testing in MB." }).check(S.isFinite().annotate({ "expected": "a finite number" })) }), [S.Record(S.String, S.Json.annotate({ "expected": "JSON value" }))]).annotate({
+	"title": "RamInformation",
+	"identifier": "ramInformation"
+});
+const Location = S.StructWithRest(S.Struct({
+	"start": Position,
+	"end": Position
+}), [S.Record(S.String, S.Json.annotate({ "expected": "JSON value" }))]).annotate({
+	"title": "Location",
+	"description": "A location with start and end. Start is inclusive, end is exclusive.",
+	"identifier": "location"
+});
+const OpenEndLocation = S.StructWithRest(S.Struct({
+	"start": Position,
+	"end": S.optionalKey(Position)
+}), [S.Record(S.String, S.Json.annotate({ "expected": "JSON value" }))]).annotate({
+	"title": "OpenEndLocation",
+	"description": "A location where \"end\" is not required. Start is inclusive, end is exclusive.",
+	"identifier": "openEndLocation"
+});
+const FrameworkInformation = S.StructWithRest(S.Struct({
+	"name": S.String.annotate({
+		"description": "Name of the framework used.",
+		"examples": [
+			"Stryker",
+			"Stryker4s",
+			"Stryker.NET",
+			"Infection PHP",
+			"Pitest"
+		]
+	}),
+	"version": S.optionalKey(S.String.annotate({ "description": "Version of the framework." })),
+	"branding": S.optionalKey(BrandingInformation),
+	"dependencies": S.optionalKey(Dependencies)
+}), [S.Record(S.String, S.Json.annotate({ "expected": "JSON value" }))]).annotate({
+	"title": "FrameworkInformation",
+	"description": "Extra information about the framework used",
+	"identifier": "frameworkInformation"
+});
+const SystemInformation = S.StructWithRest(S.Struct({
+	"ci": S.Boolean.annotate({ "description": "Did mutation testing run in a Continuous Integration environment (pipeline)? Note that there is no way of knowing this for sure. It's done on a best-effort basis." }),
+	"os": S.optionalKey(OSInformation),
+	"cpu": S.optionalKey(CpuInformation),
+	"ram": S.optionalKey(RamInformation)
+}), [S.Record(S.String, S.Json.annotate({ "expected": "JSON value" }))]).annotate({
+	"title": "SystemInformation",
+	"description": "Information about the system that performed mutation testing.",
+	"identifier": "systemInformation"
+});
+const MutantResult = S.StructWithRest(S.Struct({
+	"coveredBy": S.optionalKey(S.Array(S.String).annotate({ "description": "The test ids that covered this mutant. If a mutation testing framework doesn't measure this information, it can simply be left out." })),
+	"description": S.optionalKey(S.String.annotate({
+		"description": "Description of the applied mutation.",
+		"examples": ["removed call to java/io/Writer::write"]
+	})),
+	"duration": S.optionalKey(S.Finite.annotate({ "description": "The net time it took to test this mutant in milliseconds. This is the time measurement without overhead from the mutation testing framework." }).check(S.isFinite().annotate({ "expected": "a finite number" }))),
+	"id": S.String.annotate({
+		"description": "Unique id, can be used to correlate this mutant across reports.",
+		"examples": ["321321"]
+	}),
+	"killedBy": S.optionalKey(S.Array(S.String).annotate({ "description": "The test ids that killed this mutant. It is a best practice to \"bail\" on first failing test, in which case you can fill this array with that one test." })),
+	"location": Location,
+	"mutatorName": S.String.annotate({
+		"description": "Category of the mutation.",
+		"examples": [
+			"ConditionalExpression",
+			"EqualityOperator",
+			"LogicalOperator"
+		]
+	}),
+	"replacement": S.optionalKey(S.String.annotate({
+		"description": "Actual mutation that has been applied.",
+		"examples": [
+			"-",
+			"+",
+			"&&",
+			"||"
+		]
+	})),
+	"static": S.optionalKey(S.Boolean.annotate({ "description": "A static mutant means that it was loaded once at during initialization, this makes it slow or even impossible to test, depending on the mutation testing framework." })),
+	"status": MutantStatusSchema.annotate({
+		"title": "MutantStatus",
+		"description": "Result of the mutation."
+	}),
+	"statusReason": S.optionalKey(S.String.annotate({ "description": "The reason that this mutant has this status. In the case of a killed mutant, this should be filled with the failure message(s) of the failing tests. In case of an error mutant, this should be filled with the error message." })),
+	"testsCompleted": S.optionalKey(S.Finite.annotate({ "description": "The number of tests actually completed in order to test this mutant. Can differ from \"coveredBy\" because of bailing a mutant test run after first failing test." }).check(S.isFinite().annotate({ "expected": "a finite number" })))
+}), [S.Record(S.String, S.Json.annotate({ "expected": "JSON value" }))]).annotate({
+	"title": "MutantResult",
+	"description": "Single mutation.",
+	"identifier": "mutantResult"
+});
+const TestDefinition = S.StructWithRest(S.Struct({
+	"id": S.String.annotate({ "description": "Unique id of the test, used to correlate what test killed a mutant." }),
+	"name": S.String.annotate({ "description": "Name of the test, used to display the test." }),
+	"location": S.optionalKey(OpenEndLocation)
+}), [S.Record(S.String, S.Json.annotate({ "expected": "JSON value" }))]).annotate({
+	"title": "TestDefinition",
+	"description": "A test in your test file.",
+	"identifier": "testDefinition"
+});
+const FileResult = S.StructWithRest(S.Struct({
+	"language": S.String.annotate({
+		"description": "Programming language that is used. Used for code highlighting, see https://prismjs.com/#examples.",
+		"examples": [
+			"javascript",
+			"typescript",
+			"cs",
+			"scala",
+			"java"
+		]
+	}),
+	"mutants": S.Array(MutantResult).check(S.isUnique().annotate({ "expected": "an array with unique items" })),
+	"source": S.String.annotate({
+		"description": "Full source code of the original file (without mutants), this is used to display exactly what was changed for each mutant.",
+		"examples": ["using System; using....."]
+	})
+}), [S.Record(S.String, S.Json.annotate({ "expected": "JSON value" }))]).annotate({
+	"title": "FileResult",
+	"description": "Mutated file, with the relative path of the file as the key.",
+	"identifier": "fileResult"
+});
+const TestFile = S.StructWithRest(S.Struct({
+	"source": S.optionalKey(S.String.annotate({ "description": "Full source code of the test file, this can be used to display in the report." })),
+	"tests": S.Array(TestDefinition)
+}), [S.Record(S.String, S.Json.annotate({ "expected": "JSON value" }))]).annotate({
+	"title": "TestFile",
+	"description": "A file containing one or more tests",
+	"identifier": "testFile"
+});
+const FileResultDictionary = S.Record(S.String, FileResult).annotate({
+	"title": "FileResultDictionary",
+	"description": "All mutated files.",
+	"identifier": "fileResultDictionary"
+});
+const TestFileDefinitionDictionary = S.Record(S.String, TestFile).annotate({
+	"title": "TestFileDefinitionDictionary",
+	"description": "Test file definitions by file path OR class name.",
+	"identifier": "testFileDefinitionDictionary"
+});
+const MutationTestResult = S.StructWithRest(S.Struct({
+	"config": S.optionalKey(S.Record(S.String, S.Json.annotate({ "expected": "JSON value" })).annotate({ "description": "Free-format object that represents the configuration used to run mutation testing." })),
+	"schemaVersion": S.String.annotate({
+		"description": "Major version of this report. Used for compatibility.",
+		"examples": [
+			"1",
+			"2.0",
+			"2.0.0"
+		]
+	}).check(S.isPattern(/* @__PURE__ */ new RegExp("^([1-2])(\\.(([1-9]\\d*)|0)){0,2}$")).annotate({ "expected": "a string matching the RegExp ^([1-2])(\\.(([1-9]\\d*)|0)){0,2}$" })),
+	"files": FileResultDictionary,
+	"testFiles": S.optionalKey(TestFileDefinitionDictionary),
+	"thresholds": Thresholds,
+	"projectRoot": S.optionalKey(S.String.annotate({
+		"description": "The optional location of the project root.",
+		"examples": ["C:\\Projects\\project-under-test", "/home/user/projects/project-under-test"]
+	})),
+	"performance": S.optionalKey(PerformanceStatistics),
+	"framework": S.optionalKey(FrameworkInformation),
+	"system": S.optionalKey(SystemInformation)
+}), [S.Record(S.String, S.Json.annotate({ "expected": "JSON value" }))]).annotate({
+	"title": "MutationTestResult",
+	"description": "Schema for a mutation testing report."
+});
+const TestId = S.NonEmptyString.pipe(S.brand("TestId"));
+const DryRunStatus = S.Literals([
+	"complete",
+	"error",
+	"timeout"
+]);
+const TestStatus = S.Literals([
+	"success",
+	"failed",
+	"skipped"
+]);
+const MutantRunStatus = S.Literals([
+	"killed",
+	"survived",
+	"timeout",
+	"error"
+]);
+const TestResultBase = {
+	id: TestId,
+	name: S.String,
+	timeSpentMs: NonNegativeFinite,
+	fileName: S.optionalKey(S.String),
+	startPosition: S.optionalKey(Position$1)
+};
+const TestResultSchema = S.Union([
+	S.Struct({
+		...TestResultBase,
+		status: S.Literal("failed"),
+		failureMessage: S.String
+	}),
+	S.Struct({
+		...TestResultBase,
+		status: S.Literal("skipped")
+	}),
+	S.Struct({
+		...TestResultBase,
+		status: S.Literal("success")
+	})
+]);
+const DryRunResultSchema = S.Union([
+	S.Struct({
+		status: S.Literal("complete"),
+		tests: S.Array(TestResultSchema),
+		mutantCoverage: S.optionalKey(MutantCoverageSchema),
+		globalTestInputs: S.String.pipe(S.Array, S.optionalKey)
+	}),
+	S.Struct({
+		status: S.Literal("timeout"),
+		reason: S.optionalKey(S.String)
+	}),
+	S.Struct({
+		status: S.Literal("error"),
+		errorMessage: S.String
+	})
+]);
+const ExecutedTestSchema = S.Struct({
+	id: TestId,
+	timeSpentMs: NonNegativeFinite
+});
+const MutantRunResultSchema = S.Union([
+	S.Struct({
+		status: S.Literal("killed"),
+		killedBy: S.Array(TestId),
+		failureMessage: S.String,
+		nrOfTests: NonNegativeInt,
+		executedTests: S.Array(ExecutedTestSchema)
+	}),
+	S.Struct({
+		status: S.Literal("survived"),
+		nrOfTests: NonNegativeInt,
+		executedTests: S.Array(ExecutedTestSchema)
+	}),
+	S.Struct({
+		status: S.Literal("timeout"),
+		reason: S.optionalKey(S.String)
+	}),
+	S.Struct({
+		status: S.Literal("error"),
+		errorMessage: S.String
+	})
+]);
+const CoverageAnalysisSchema = S.Literals([
+	"off",
+	"all",
+	"perTest"
+]);
+const DryRunOptionsSchema = S.Struct({
+	...RunOptionsFields,
+	coverageAnalysis: CoverageAnalysisSchema,
+	files: S.String.pipe(S.Array, S.optionalKey),
+	testFiles: S.String.pipe(S.Array, S.optionalKey)
+});
+const TestRunnerCapabilitiesSchema = S.Struct({ reloadEnvironment: S.Boolean });
+var TestRunnerFailed = class extends S.TaggedError()("TestRunnerFailed", {
+	cause: S.String,
+	phase: S.Literals([
+		"capabilities",
+		"dispose",
+		"dryRun",
+		"init",
+		"mutantRun"
+	]),
+	runnerName: S.String
+}) {
+	get message() {
+		return `Test runner "${this.runnerName}" failed during ${this.phase}: ${this.cause}`;
+	}
+};
+const RunTimingSchema = S.Struct({
+	net: NonNegativeFinite,
+	overhead: NonNegativeFinite
+});
+const ReporterPlanKind = S.Literals(["EarlyResult", "Run"]);
+const ReporterPlanDescriptorSchema = S.Struct({
+	mutantId: MutantId,
+	plan: ReporterPlanKind,
+	netTime: NonNegativeFinite,
+	reloadEnvironment: S.Boolean
+});
+var DryRunCompleted = class extends S.TaggedClass()("dryRunCompleted", {
+	timing: RunTimingSchema,
+	capabilities: TestRunnerCapabilitiesSchema,
+	testCount: NonNegativeInt,
+	tests: S.Array(TestResultSchema)
+}) {};
+var MutationTestingPlanReady = class extends S.TaggedClass()("mutationTestingPlanReady", {
+	total: NonNegativeInt,
+	plans: S.Array(ReporterPlanDescriptorSchema)
+}) {};
+var MutantTested = class extends S.TaggedClass()("mutantTested", {
+	id: MutantId,
+	status: MutantStatusSchema,
+	fileName: CanonicalFileName,
+	location: Location$1,
+	mutatorName: MutatorName,
+	replacement: S.NullOr(S.String),
+	completed: NonNegativeInt,
+	total: NonNegativeInt
+}) {};
+var MutationTestReportReady = class extends S.TaggedClass()("mutationTestReportReady", {
+	report: MutationTestResult,
+	metrics: MetricsResultSchema,
+	static: S.optional(StaticClassSummarySchema)
+}) {};
+const ReporterEventUnion = S.Union([
+	DryRunCompleted,
+	MutationTestingPlanReady,
+	MutantTested,
+	MutationTestReportReady
+]).pipe(S.toTaggedUnion("_tag"));
+const ReporterEventKind = S.Literals(ReporterEventUnion.discriminants);
+const ReporterEventSchema = S.toStandardSchemaV1(ReporterEventUnion);
+var ReporterFailed = class extends S.TaggedError()("ReporterFailed", {
+	cause: S.String,
+	event: ReporterEventKind,
+	reporterName: S.String
+}) {
+	get message() {
+		return `Reporter "${this.reporterName}" failed while handling ${this.event}: ${this.cause}`;
+	}
+};
+const TraceparentHeader = S.Literal("traceparent");
+const TracestateHeader = S.Literal("tracestate");
+const VERSION = S.String.pipe(S.check(S.isPattern(/^([0-9a-e][0-9a-f]|[0-9a-f][0-9a-e])$/)));
+const TRACE_ID = S.String.pipe(S.check(S.isPattern(/^[0-9a-f]*[1-9a-f][0-9a-f]*$/)), S.check(S.isLengthBetween(32, 32)));
+const SPAN_ID = S.String.pipe(S.check(S.isPattern(/^[0-9a-f]*[1-9a-f][0-9a-f]*$/)), S.check(S.isLengthBetween(16, 16)));
+const TraceContextPartsSchema = S.Struct({
+	version: VERSION,
+	traceId: TRACE_ID,
+	spanId: SPAN_ID,
+	traceFlags: S.Int.pipe(S.check(S.isBetween({
+		minimum: 0,
+		maximum: 255
+	}))),
+	traceState: S.optional(S.String)
+});
+const TraceparentPartsSchema = S.Struct({
+	version: VERSION,
+	traceId: TRACE_ID,
+	spanId: SPAN_ID,
+	traceFlags: S.Int.pipe(S.check(S.isBetween({
+		minimum: 0,
+		maximum: 255
+	})))
+});
+const HEX_VERSION = /^[0-9a-f]{2}$/;
+const HEX_TRACE_ID = /^[0-9a-f]{32}$/;
+const HEX_SPAN_ID = /^[0-9a-f]{16}$/;
+const HEX_FLAGS = /^[0-9a-f]{2}$/;
+const ALL_ZERO = /^0+$/;
+const FORBIDDEN_VERSION = "ff";
+const CURRENT_VERSION = "00";
+const TRACEPARENT_FIELD_COUNT = 4;
+const fieldAt = (fields, index) => fields[index] ?? "";
+const isNonZeroHex = (pattern, value) => pattern.test(value) && !ALL_ZERO.test(value);
+const acceptsFieldCount = (version, count) => version !== CURRENT_VERSION || count === TRACEPARENT_FIELD_COUNT;
+const isKnownVersion = (version) => HEX_VERSION.test(version) && version !== FORBIDDEN_VERSION;
+const isWellFormedTraceparent = (value) => {
+	const fields = value.split("-");
+	return [
+		acceptsFieldCount(fieldAt(fields, 0), fields.length),
+		isKnownVersion(fieldAt(fields, 0)),
+		isNonZeroHex(HEX_TRACE_ID, fieldAt(fields, 1)),
+		isNonZeroHex(HEX_SPAN_ID, fieldAt(fields, 2)),
+		HEX_FLAGS.test(fieldAt(fields, 3))
+	].every((check) => check);
+};
+const partsOf = (value) => {
+	const fields = value.split("-");
+	return {
+		version: fieldAt(fields, 0),
+		traceId: fieldAt(fields, 1),
+		spanId: fieldAt(fields, 2),
+		traceFlags: Number.parseInt(fieldAt(fields, 3), 16)
+	};
+};
+const formatOf = (parts) => `${parts.version}-${parts.traceId}-${parts.spanId}-${(parts.traceFlags & 255).toString(16).padStart(2, "0")}`;
+const malformedTraceparent = (value) => new SchemaIssue.InvalidValue({ message: "expected a W3C traceparent: version-traceId-spanId-flags" }, value);
+const decodeParts = SchemaGetter.transformEffect((value) => Boolean$1.match(isWellFormedTraceparent(value), {
+	onTrue: () => Effect$1.succeed(partsOf(value)),
+	onFalse: () => Effect$1.fail(malformedTraceparent(value))
+}));
+const encodeText = SchemaGetter.transform(formatOf);
+const Traceparent = S.String.pipe(S.decodeTo(TraceparentPartsSchema, SchemaTransformation.makeTransformation({
+	decode: decodeParts,
+	encode: encodeText
+})));
+const TRACESTATE_MEMBER = "[a-z][_0-9a-z\\-*/]{0,255}=[\\x20-\\x2b\\x2d-\\x3c\\x3e-\\x7e]{0,255}";
+const TRACESTATE_OWS = "[ \\t]*";
+const TRACESTATE = new RegExp(`^${TRACESTATE_MEMBER}(${TRACESTATE_OWS},${TRACESTATE_OWS}${TRACESTATE_MEMBER}){0,31}$`);
+const Tracestate = S.String.pipe(S.check(S.isPattern(TRACESTATE, { expected: "a W3C tracestate: comma-separated key=value members" })));
+const WorkerPluginKind = S.Literals([
+	"TestRunner",
+	"Checker",
+	"Reporter"
+]);
+const EvaluatorPluginKind = S.Literal("Evaluator");
+const PluginKindSchema = S.Union([WorkerPluginKind, EvaluatorPluginKind]);
+const TestRunnerDryRunRequest = S.Struct({ options: DryRunOptionsSchema });
+const TestRunnerMutantRunRequest = S.Struct({ options: MutantRunOptionsSchema });
+const CheckerRequest = S.Struct({
+	checkerName: S.String,
+	mutants: S.Array(CheckerMutantWire)
+});
+const CheckerCheckResult = S.Record(S.String, CheckResultSchema);
+const CheckerGroupResult = S.String.pipe(S.Array, S.Array);
+const ReporterInitOptions = S.Struct({
+	traceparent: S.optionalKey(Traceparent),
+	tracestate: S.optionalKey(Tracestate)
+});
+const ReporterEventBatch = S.Array(ReporterEventUnion);
+const ReporterAck = S.Void;
+const ReporterDrained = S.Void;
+var BoundaryPayloadRejected = class extends S.TaggedError()("BoundaryPayloadRejected", {
+	pluginName: S.String,
+	method: S.String,
+	cause: S.String
+}) {
+	get message() {
+		return `Plugin "${this.pluginName}" rejected the payload for ${this.method}: ${this.cause}`;
+	}
+};
+var BoundaryUnrecognizedSignal = class extends S.TaggedError()("BoundaryUnrecognizedSignal", {
+	pluginName: S.String,
+	method: S.String,
+	signal: S.String
+}) {
+	get message() {
+		return `Plugin "${this.pluginName}" sent an unrecognized signal "${this.signal}" for ${this.method}`;
+	}
+};
+const BoundaryErrorSchema = S.Union([
+	BoundaryPayloadRejected,
+	BoundaryUnrecognizedSignal,
+	TestRunnerFailed,
+	CheckerFailed,
+	ReporterFailed
+]);
+const WorkerEntryUrl = S.String.check(S.isPattern(/^file:\/\//, { expected: "a file: URL of the worker program" }));
+const WorkerPluginSpawnSchema = S.Struct({
+	kind: WorkerPluginKind,
+	entrypoint: WorkerEntryUrl
+});
+var PropagatedTrace = class extends Context.Service()("@systemfsoftware/stryker-js-plugin-interface/TraceContextRpc.service/PropagatedTrace") {};
+var TraceContextMiddleware = class extends RpcMiddleware.Service()("@systemfsoftware/stryker-js-plugin-interface/TraceContextMiddleware", { requiredForClient: true }) {};
+const capabilities = Rpc.make("capabilities", {
+	success: TestRunnerCapabilitiesSchema,
+	error: TestRunnerFailed
+}).middleware(TraceContextMiddleware);
+const dryRun = Rpc.make("dryRun", {
+	payload: TestRunnerDryRunRequest,
+	success: DryRunResultSchema,
+	error: TestRunnerFailed
+}).middleware(TraceContextMiddleware);
+const mutantRun = Rpc.make("mutantRun", {
+	payload: TestRunnerMutantRunRequest,
+	success: MutantRunResultSchema,
+	error: TestRunnerFailed
+}).middleware(TraceContextMiddleware);
+const check = Rpc.make("check", {
+	payload: CheckerRequest,
+	success: CheckerCheckResult,
+	error: CheckerFailed
+}).middleware(TraceContextMiddleware);
+const group = Rpc.make("group", {
+	payload: CheckerRequest,
+	success: CheckerGroupResult,
+	error: CheckerFailed
+}).middleware(TraceContextMiddleware);
+const init = Rpc.make("init", {
+	payload: ReporterInitOptions,
+	success: ReporterAck,
+	error: ReporterFailed
+}).middleware(TraceContextMiddleware);
+const onEventBatch = Rpc.make("onEventBatch", {
+	payload: ReporterEventBatch,
+	success: ReporterAck,
+	error: ReporterFailed
+}).middleware(TraceContextMiddleware);
+const flush = Rpc.make("flush", {
+	success: ReporterDrained,
+	error: ReporterFailed
+}).middleware(TraceContextMiddleware);
+const TestRunnerRpcs = RpcGroup.make(capabilities, dryRun, mutantRun);
+const CheckerRpcs = RpcGroup.make(check, group);
+const ReporterRpcs = RpcGroup.make(init, onEventBatch, flush);
+var Plugin_exports = /* @__PURE__ */ __exportAll({
+	BoundaryErrorSchema: () => BoundaryErrorSchema,
+	BoundaryPayloadRejected: () => BoundaryPayloadRejected,
+	BoundaryUnrecognizedSignal: () => BoundaryUnrecognizedSignal,
+	CheckerCheckResult: () => CheckerCheckResult,
+	CheckerGroupResult: () => CheckerGroupResult,
+	CheckerRequest: () => CheckerRequest,
+	CheckerRpcs: () => CheckerRpcs,
+	EvaluatorPluginKind: () => EvaluatorPluginKind,
+	ExitClass: () => ExitClass,
+	ExitCode: () => ExitCode,
+	ExitCodeFromClass: () => ExitCodeFromClass,
+	PluginKindSchema: () => PluginKindSchema,
+	ReporterAck: () => ReporterAck,
+	ReporterDrained: () => ReporterDrained,
+	ReporterEventBatch: () => ReporterEventBatch,
+	ReporterInitOptions: () => ReporterInitOptions,
+	ReporterRpcs: () => ReporterRpcs,
+	TestRunnerDryRunRequest: () => TestRunnerDryRunRequest,
+	TestRunnerMutantRunRequest: () => TestRunnerMutantRunRequest,
+	TestRunnerRpcs: () => TestRunnerRpcs,
+	WorkerEntryUrl: () => WorkerEntryUrl,
+	WorkerPluginKind: () => WorkerPluginKind,
+	WorkerPluginSpawnSchema: () => WorkerPluginSpawnSchema
+});
+const countOf = (mutants, status) => mutants.filter((mutant) => mutant.status === status).length;
+const metricsFromMutants = (mutants) => Metrics.make({
+	pending: countOf(mutants, "Pending"),
+	killed: countOf(mutants, "Killed"),
+	timeout: countOf(mutants, "Timeout"),
+	survived: countOf(mutants, "Survived"),
+	noCoverage: countOf(mutants, "NoCoverage"),
+	runtimeErrors: countOf(mutants, "RuntimeError"),
+	compileErrors: countOf(mutants, "CompileError"),
+	ignored: countOf(mutants, "Ignored")
+});
+const WrittenSchemaVersion = S.Literal("1.0");
+var Report_exports = /* @__PURE__ */ __exportAll({
+	BrandingInformation: () => BrandingInformation,
+	CpuInformation: () => CpuInformation,
+	Dependencies: () => Dependencies,
+	DetectedStatus: () => DetectedStatus,
+	FileResult: () => FileResult,
+	FileResultDictionary: () => FileResultDictionary,
+	FrameworkInformation: () => FrameworkInformation,
+	InvalidStatus: () => InvalidStatus,
+	Location: () => Location,
+	Metrics: () => Metrics,
+	MetricsResultSchema: () => MetricsResultSchema,
+	MetricsSchema: () => MetricsSchema,
+	MutantResult: () => MutantResult,
+	MutationScore: () => MutationScore,
+	MutationTestResult: () => MutationTestResult,
+	NonNegativeFinite: () => NonNegativeFinite,
+	NonNegativeInt: () => NonNegativeInt,
+	OSInformation: () => OSInformation,
+	OpenEndLocation: () => OpenEndLocation,
+	Percentage: () => Percentage,
+	PerformanceStatistics: () => PerformanceStatistics,
+	Position: () => Position,
+	RamInformation: () => RamInformation,
+	StaticClassSummarySchema: () => StaticClassSummarySchema,
+	SystemInformation: () => SystemInformation,
+	TestDefinition: () => TestDefinition,
+	TestFile: () => TestFile,
+	TestFileDefinitionDictionary: () => TestFileDefinitionDictionary,
+	Thresholds: () => Thresholds,
+	UndetectedStatus: () => UndetectedStatus,
+	UntestedStatus: () => UntestedStatus,
+	WrittenSchemaVersion: () => WrittenSchemaVersion,
+	metricsFromMutants: () => metricsFromMutants
+});
+var Reporter_exports = /* @__PURE__ */ __exportAll({
+	DryRunCompleted: () => DryRunCompleted,
+	MutantTested: () => MutantTested,
+	MutationTestReportReady: () => MutationTestReportReady,
+	MutationTestingPlanReady: () => MutationTestingPlanReady,
+	ReporterEventKind: () => ReporterEventKind,
+	ReporterEventSchema: () => ReporterEventSchema,
+	ReporterEventUnion: () => ReporterEventUnion,
+	ReporterFailed: () => ReporterFailed,
+	ReporterPlanDescriptorSchema: () => ReporterPlanDescriptorSchema,
+	ReporterPlanKind: () => ReporterPlanKind,
+	RunTimingSchema: () => RunTimingSchema
+});
+const HitLimitReasonPrefix = S.Literal("Hit limit reached");
+const WallClockTimeoutReason = S.Literal("wall-clock-timeout");
+const HIT_LIMIT_REASON_PREFIX = HitLimitReasonPrefix.literal;
+const HitLimitReasonText = S.String.check(S.isStartsWith(HIT_LIMIT_REASON_PREFIX, { arbitraryConstraint: {
+	patterns: [{
+		source: `^${HIT_LIMIT_REASON_PREFIX}[\\s\\S]*$`,
+		flags: ""
+	}],
+	minLength: HIT_LIMIT_REASON_PREFIX.length + 2
+} }));
+const HIT_LIMIT_REASON_SHAPE = /^Hit limit reached \((\d+)\/(\d+)\)$/;
+const limitsOf = SchemaGetter.transformEffect((text) => Option$1.match(Option$1.fromNullishOr(HIT_LIMIT_REASON_SHAPE.exec(text)), {
+	onNone: () => Effect$1.fail(malformedHitLimit(text)),
+	onSome: (matched) => Effect$1.succeed({
+		count: Number.parseInt(String(matched[1]), 10),
+		limit: Number.parseInt(String(matched[2]), 10)
+	})
+}));
+const textOf = SchemaGetter.transform((limits) => `${HitLimitReasonPrefix.literal} (${limits.count}/${limits.limit})`);
+const malformedHitLimit = (text) => new SchemaIssue.InvalidValue({ message: "expected \"Hit limit reached (count/limit)\"" }, text);
+const HitLimitReason = HitLimitReasonText.pipe(S.decodeTo(S.Struct({
+	count: S.Natural,
+	limit: S.Natural
+}), SchemaTransformation.makeTransformation({
+	decode: limitsOf,
+	encode: textOf
+})));
+var TestRunner = class extends Context.Service()("@systemfsoftware/stryker-js-plugin-interface/TestRunner.service/TestRunner") {};
+var TestRunner_exports = /* @__PURE__ */ __exportAll({
+	CoverageAnalysisSchema: () => CoverageAnalysisSchema,
+	DryRunOptionsSchema: () => DryRunOptionsSchema,
+	DryRunResultSchema: () => DryRunResultSchema,
+	DryRunStatus: () => DryRunStatus,
+	ExecutedTestSchema: () => ExecutedTestSchema,
+	HitLimitReason: () => HitLimitReason,
+	HitLimitReasonPrefix: () => HitLimitReasonPrefix,
+	HitLimitReasonText: () => HitLimitReasonText,
+	MutantRunResultSchema: () => MutantRunResultSchema,
+	MutantRunStatus: () => MutantRunStatus,
+	TestId: () => TestId,
+	TestResultSchema: () => TestResultSchema,
+	TestRunner: () => TestRunner,
+	TestRunnerCapabilitiesSchema: () => TestRunnerCapabilitiesSchema,
+	TestRunnerFailed: () => TestRunnerFailed,
+	TestStatus: () => TestStatus,
+	WallClockTimeoutReason: () => WallClockTimeoutReason
+});
+const TraceContextReference = Context.Reference("@systemfsoftware/stryker-js-plugin-interface/TraceContextReference", { defaultValue: () => Option$1.none() });
+var Trace_exports = /* @__PURE__ */ __exportAll({
+	PropagatedTrace: () => PropagatedTrace,
+	TraceContextMiddleware: () => TraceContextMiddleware,
+	TraceContextPartsSchema: () => TraceContextPartsSchema,
+	TraceContextReference: () => TraceContextReference,
+	Traceparent: () => Traceparent,
+	TraceparentHeader: () => TraceparentHeader,
+	Tracestate: () => Tracestate,
+	TracestateHeader: () => TracestateHeader
+});
+//#endregion
+//#region src/config/merge-config.ts
+/**
+* Whether an entry takes part in a merge: a key literally named `__proto__` never does — the
+* merged record must not gain a document-decided prototype — and an explicitly `undefined`
+* value states that the author left the key unset, not that they want it set to nothing.
+*/
+const usable = (value, key) => key !== "__proto__" && value !== void 0;
+const usableEntries = (source) => Record$1.filter(source, usable);
+const isConfigRecord = (value) => Predicate$1.isObject(value);
+const asConfigRecord = (value) => Option$1.filter(Option$1.fromUndefinedOr(value), isConfigRecord);
+const mergeNested = (base, override) => Option$1.match(asConfigRecord(override), {
+	onNone: () => override,
+	onSome: (overrideRecord) => mergeRecords(base, overrideRecord)
+});
+const hasUsableMember = (key) => (merged) => merged.hasOwnProperty(key) && merged[key] !== void 0;
+const ownValueOf = (merged, key) => Option$1.map(Option$1.liftPredicate(merged, hasUsableMember(key)), (present) => present[key]);
+const baseRecordOf = (ownValue) => Option$1.filter(Option$1.flatMap(ownValue, Option$1.fromUndefinedOr), isConfigRecord);
+const mergeKeyInto = (merged, override, key) => ({
+	...merged,
+	[key]: Option$1.match(baseRecordOf(ownValueOf(merged, key)), {
+		onNone: () => override,
+		onSome: (baseRecord) => mergeNested(baseRecord, override)
+	})
+});
+const mergeRecords = (base, overrides) => Record$1.reduce(usableEntries(overrides), usableEntries(base), mergeKeyInto);
+const mergeConfig = dual(2, (defaults, overrides) => mergeRecords(defaults, overrides));
+const isNonNullObject = (value) => typeof value === "object" && value !== null;
+const asUnknownArray = (value) => Array.isArray(value) ? value : [];
+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 isConfigOptionsRecord = (value) => isNonNullObject(value) && Array.isArray(value) === false;
+const mergeConfigRecords = (parentNested, childNested) => ({
+	...parentNested,
+	...childNested
+});
+const toConfigRecordOption = (value) => isConfigOptionsRecord(value) ? Option$1.some(value) : Option$1.none();
+const inheritNested = (parentValue, childValue) => Option$1.match(Option$1.all([toConfigRecordOption(parentValue), toConfigRecordOption(childValue)]), {
+	onSome: ([parentNested, childNested]) => mergeConfigRecords(parentNested, childNested),
+	onNone: () => childValue
+});
+const inheritEntry = (out, key, parentValue, childValue) => Match$1.value(childValue).pipe(Match$1.when(null, () => {
+	const next = { ...out };
+	delete next[key];
+	return next;
+}), Match$1.orElse(() => Match$1.value(key).pipe(Match$1.when("plugins", () => ({
+	...out,
+	[key]: mergePluginDescriptors(asUnknownArray(parentValue), asUnknownArray(childValue))
+})), Match$1.orElse(() => ({
+	...out,
+	[key]: inheritNested(parentValue, childValue)
+})))));
+const mergeConfigs = dual(2, (parent, child) => Object.entries(child).reduce((out, entry) => inheritEntry(out, entry[0], parent[entry[0]], entry[1]), { ...parent }));
+//#endregion
+export { MutatorCatalog_exports as a, Plugin_exports as c, TestRunner_exports as d, Trace_exports as f, Mutant_exports as i, Report_exports as l, mergeConfigs as n, MutatorProvider_exports as o, Checker_exports as r, Options_exports as s, mergeConfig as t, Reporter_exports as u };