@systemfsoftware/stryker-js 4.0.0 → 5.0.0

package/dist/index.mjs

@@ -1,1034 +1,3 @@
-import * as Context from "effect/Context";
-import * as S from "effect/Schema";
-import * as Match from "effect/Match";
-import * as Option from "effect/Option";
-import * as Arr from "effect/Array";
-import * as Predicate from "effect/Predicate";
-import * as Layer from "effect/Layer";
-import * as MutableHashMap from "effect/MutableHashMap";
-import * as Effect$1 from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as Result from "effect/Result";
-import { Effect } from "effect";
-//#region src/Checker.schema.ts
-const CheckStatus = S.Literals(["passed", "compileError"]);
-const CheckResultSchema = S.Union([S.Struct({ status: S.Literal("passed") }), S.Struct({
-	status: S.Literal("compileError"),
-	reason: S.String
-})]);
-var CheckerFailed = class extends S.TaggedError()("CheckerFailed", {
-	cause: S.String,
-	checkerName: S.String,
-	mutantIds: S.Array(S.String)
-}) {};
-//#endregion
-//#region src/Checker.ts
-var Checker = class extends Context.Service()("~@systemfsoftware/stryker-js/Checker") {};
-//#endregion
-//#region src/Evaluator.schema.ts
-var EvaluatorFailed = class extends S.TaggedError()("EvaluatorFailed", { cause: S.Unknown }) {};
-//#endregion
-//#region src/Evaluator.ts
-var Evaluator = class extends Context.Service()("~@systemfsoftware/stryker-js/Evaluator") {};
-//#endregion
-//#region src/ExitClass.schema.ts
-const ExitClass = S.Literals([
-	"VerdictFail",
-	"ConfigError",
-	"RuntimeError",
-	"InternalError"
-]);
-var ClassifyExitCommand = class extends S.TaggedClass()("ClassifyExitCommand", {
-	pending: S.Array(ExitClass),
-	signal: S.NullOr(S.Number),
-	score: S.NullOr(S.Number),
-	breakingThreshold: S.NullOr(S.Number)
-}) {};
-var ClassifyExitDecision = class extends S.TaggedClass()("ClassifyExitDecision", {
-	highestClass: S.NullOr(ExitClass),
-	verdictClass: S.NullOr(ExitClass)
-}) {};
-//#endregion
-//#region src/ExitClass.ts
-const EXIT_CODE = {
-	VerdictFail: 1,
-	ConfigError: 2,
-	RuntimeError: 3,
-	InternalError: 4
-};
-function highestExitClass(pending) {
-	return Array.from(pending).reduce((incumbent, challenger) => Option.match(Option.fromNullishOr(incumbent), {
-		onNone: () => challenger,
-		onSome: (value) => Match.value(EXIT_CODE[value] < EXIT_CODE[challenger]).pipe(Match.when(true, () => challenger), Match.when(false, () => value), Match.exhaustive)
-	}), null);
-}
-function resolveExitCode(pending, signal) {
-	return Option.match(Option.fromNullishOr(signal), {
-		onNone: () => Option.match(Option.fromNullishOr(highestExitClass(pending)), {
-			onNone: () => 0,
-			onSome: (exitClass) => EXIT_CODE[exitClass]
-		}),
-		onSome: (value) => 128 + value
-	});
-}
-function verdictExitClass(score, breakingThreshold) {
-	return Option.getOrNull(Option.zipWith(Option.fromNullishOr(score), Option.fromNullishOr(breakingThreshold), (value, threshold) => Match.value(value < threshold).pipe(Match.when(true, () => "VerdictFail"), Match.when(false, () => null), Match.exhaustive)));
-}
-const classifyExit = (command) => {
-	const verdictClass = verdictExitClass(command.score, command.breakingThreshold);
-	const highestClass = highestExitClass(Option.match(Option.fromNullishOr(verdictClass), {
-		onNone: () => command.pending,
-		onSome: (verdict) => Array.from(/* @__PURE__ */ new Set([...command.pending, verdict]))
-	}));
-	return ClassifyExitDecision.make({
-		highestClass,
-		verdictClass
-	});
-};
-//#endregion
-//#region src/Ignorer.ts
-var Ignorer = class extends Context.Service()("~@systemfsoftware/stryker-js/Ignorer") {};
-//#endregion
-//#region src/Metrics.schema.ts
-const MetricsSchema = S.Struct({
-	pending: S.Finite,
-	killed: S.Finite,
-	timeout: S.Finite,
-	survived: S.Finite,
-	noCoverage: S.Finite,
-	runtimeErrors: S.Finite,
-	compileErrors: S.Finite,
-	ignored: S.Finite,
-	totalDetected: S.Finite,
-	totalUndetected: S.Finite,
-	totalInvalid: S.Finite,
-	totalValid: S.Finite,
-	totalMutants: S.Finite,
-	totalCovered: S.Finite,
-	mutationScore: S.Finite,
-	mutationScoreBasedOnCoveredCode: S.Finite
-});
-const MetricsResultSchema = S.Struct({
-	name: S.String,
-	metrics: MetricsSchema,
-	childResults: S.Array(S.suspend(() => MetricsResultSchema))
-}).annotate({ identifier: "MetricsResult" });
-//#endregion
-//#region src/Metrics.ts
-const countStatus = (mutants, status) => mutants.filter((mutant) => mutant.status === status).length;
-const percentage = (numerator, denominator) => numerator / denominator * 100;
-/** A percentage whose denominator is zero is not 0%; `emptyDenominator` says what it is instead. */
-const percentOr = (emptyDenominator, numerator, denominator) => Match.value(denominator).pipe(Match.when(0, () => emptyDenominator), Match.orElse(() => percentage(numerator, denominator)));
-const coveredFraction = (totalDetected, totalCovered, totalValid) => Match.value(totalValid).pipe(Match.when(0, () => NaN), Match.orElse(() => percentOr(0, totalDetected, totalCovered)));
-const countMutants = (mutants) => {
-	const pending = countStatus(mutants, "Pending");
-	const killed = countStatus(mutants, "Killed");
-	const timeout = countStatus(mutants, "Timeout");
-	const survived = countStatus(mutants, "Survived");
-	const noCoverage = countStatus(mutants, "NoCoverage");
-	const runtimeErrors = countStatus(mutants, "RuntimeError");
-	const compileErrors = countStatus(mutants, "CompileError");
-	const ignored = countStatus(mutants, "Ignored");
-	const totalDetected = timeout + killed;
-	const totalUndetected = survived + noCoverage;
-	const totalCovered = totalDetected + survived;
-	const totalValid = totalUndetected + totalDetected;
-	const totalInvalid = runtimeErrors + compileErrors;
-	return {
-		pending,
-		killed,
-		timeout,
-		survived,
-		noCoverage,
-		runtimeErrors,
-		compileErrors,
-		ignored,
-		totalDetected,
-		totalUndetected,
-		totalCovered,
-		totalValid,
-		totalInvalid,
-		totalMutants: totalValid + totalInvalid + ignored + pending,
-		mutationScore: percentOr(NaN, totalDetected, totalValid),
-		mutationScoreBasedOnCoveredCode: coveredFraction(totalDetected, totalCovered, totalValid)
-	};
-};
-const segmentOf = (fileName) => {
-	const separator = fileName.indexOf("/");
-	if (separator === -1) return fileName;
-	return fileName.slice(0, separator);
-};
-const groupBySegment = (files) => Object.entries(files).reduce((groups, [fileName, file]) => {
-	const segment = segmentOf(fileName);
-	const group = groups[segment] ?? {};
-	group[fileName] = file;
-	groups[segment] = group;
-	return groups;
-}, {});
-const metricsOf = (files) => countMutants(Object.values(files).flatMap((file) => file.mutants));
-const fileResultOf = (fileName, file) => ({
-	name: fileName,
-	metrics: countMutants(file.mutants),
-	childResults: []
-});
-const nestedGroupResult = (segment, entries) => {
-	const nested = Object.fromEntries(entries.map(([fileName, file]) => [fileName.slice(segment.length + 1), file]));
-	return {
-		name: segment,
-		metrics: metricsOf(nested),
-		childResults: childResultsOf(nested)
-	};
-};
-const soleSegmentFileResult = (segment, entries) => Option.flatMap(Arr.head(entries), ([fileName, file]) => Match.value(fileName === segment && entries.length === 1).pipe(Match.when(true, () => Option.some(fileResultOf(fileName, file))), Match.orElse(() => Option.none())));
-const childResultOf = (segment, entries) => Option.getOrElse(soleSegmentFileResult(segment, entries), () => nestedGroupResult(segment, entries));
-const childResultsOf = (files) => Object.entries(groupBySegment(files)).map(([segment, grouped]) => childResultOf(segment, Object.entries(grouped))).sort((left, right) => left.name.localeCompare(right.name));
-const calculateMetrics = (files) => ({
-	name: "All files",
-	metrics: metricsOf(files),
-	childResults: childResultsOf(files)
-});
-//#endregion
-//#region src/Module.ts
-/**
-* Port over the host module loader, shaped as the subset of `node:module`
-* feature code may use: `createRequire` and `isBuiltin`. Resolving a
-* specifier against a project directory, importing a plugin, and asking
-* whether a name is a builtin all go through this one tag; no feature module
-* touches the host module API. The Node implementation ships in the
-* composition-root package (`@systemfsoftware/stryker-js-cli`); tests that do
-* not need real plugin resolution substitute a layer returning fixed paths.
-*
-* @since 2.0.0
-*/
-var Module = class extends Context.Service()("@systemfsoftware/stryker-js/Module") {};
-//#endregion
-//#region src/Report.schema.ts
-const PositionSchema = S.Struct({
-	line: S.Finite,
-	column: S.Finite
-});
-const LocationSchema = S.Struct({
-	start: PositionSchema,
-	end: PositionSchema
-});
-const OpenEndLocationSchema = S.Struct({
-	start: PositionSchema,
-	end: S.optional(PositionSchema)
-});
-const MutantStatusSchema = S.Literals([
-	"Killed",
-	"Survived",
-	"NoCoverage",
-	"CompileError",
-	"RuntimeError",
-	"Timeout",
-	"Ignored",
-	"Pending"
-]);
-const MutantResultSchema = S.Struct({
-	id: S.String,
-	mutatorName: S.String,
-	status: MutantStatusSchema,
-	location: LocationSchema,
-	replacement: S.optional(S.String),
-	description: S.optional(S.String),
-	statusReason: S.optional(S.String),
-	static: S.optional(S.Boolean),
-	coveredBy: S.optional(S.Array(S.String)),
-	killedBy: S.optional(S.Array(S.String)),
-	testsCompleted: S.optional(S.Finite),
-	duration: S.optional(S.Finite)
-});
-const FileResultSchema = S.Struct({
-	language: S.String,
-	source: S.String,
-	mutants: S.Array(MutantResultSchema)
-});
-const FileResultDictionarySchema = S.Record(S.String, FileResultSchema);
-const TestDefinitionSchema = S.Struct({
-	id: S.String,
-	name: S.String,
-	location: S.optional(OpenEndLocationSchema)
-});
-const TestFileSchema = S.Struct({
-	source: S.optional(S.String),
-	tests: S.Array(TestDefinitionSchema)
-});
-const TestFileDefinitionDictionarySchema = S.Record(S.String, TestFileSchema);
-const ThresholdsSchema = S.Struct({
-	high: S.Finite,
-	low: S.Finite
-});
-const BrandingInformationSchema = S.Struct({
-	homepageUrl: S.String,
-	imageUrl: S.optional(S.String)
-});
-const DependenciesSchema = S.Record(S.String, S.String);
-const FrameworkInformationSchema = S.Struct({
-	name: S.String,
-	version: S.optional(S.String),
-	branding: S.optional(BrandingInformationSchema),
-	dependencies: S.optional(DependenciesSchema)
-});
-const MutationTestResultSchema = S.Struct({
-	schemaVersion: S.String,
-	files: FileResultDictionarySchema,
-	thresholds: ThresholdsSchema,
-	config: S.optional(S.Record(S.String, S.Unknown)),
-	testFiles: S.optional(TestFileDefinitionDictionarySchema),
-	projectRoot: S.optional(S.String),
-	framework: S.optional(FrameworkInformationSchema)
-});
-//#endregion
-//#region src/Mutant.schema.ts
-var Mutant = class extends S.TaggedClass()("Mutant", {
-	id: S.NonEmptyString,
-	fileName: S.NonEmptyString,
-	mutatorName: S.NonEmptyString,
-	replacement: S.String,
-	location: LocationSchema,
-	status: S.optional(MutantStatusSchema),
-	statusReason: S.optional(S.String),
-	coveredBy: S.optional(S.Array(S.String)),
-	static: S.optional(S.Boolean),
-	testsCompleted: S.optional(S.Finite),
-	description: S.optional(S.String)
-}) {};
-//#endregion
-//#region src/Mutant.ts
-const isMutant = (value) => value instanceof Mutant;
-const INSTRUMENTER_CONSTANTS = Object.freeze({
-	NAMESPACE: "__stryker__",
-	MUTATION_COVERAGE_OBJECT: "mutantCoverage",
-	ACTIVE_MUTANT: "activeMutant",
-	CURRENT_TEST_ID: "currentTestId",
-	HIT_COUNT: "hitCount",
-	HIT_LIMIT: "hitLimit",
-	ACTIVE_MUTANT_ENV_VARIABLE: "__STRYKER_ACTIVE_MUTANT__"
-});
-function normalizeFileName(fileName) {
-	return fileName.replace(/\\/g, "/");
-}
-const hasText = (value) => Predicate.isString(value) && value.length > 0;
-const textIfNonEmpty = (value) => Option.getOrUndefined(Option.filter(Option.fromUndefinedOr(value), hasText));
-const fieldOf = (value, key) => Match.value(key in value).pipe(Match.when(true, () => {
-	return Reflect.get(value, key);
-}), Match.orElse(() => void 0));
-const hasStringCode = (error) => Match.value(fieldOf(error, "code")).pipe(Match.when(Match.string, () => true), Match.orElse(() => false));
-function isErrnoException(error) {
-	return Match.value(error).pipe(Match.when(Match.instanceOf(Error), hasStringCode), Match.orElse(() => false));
-}
-const isEmptyNumber = (value) => Match.value(value).pipe(Match.when(0, () => true), Match.orElse(Number.isNaN));
-const isEmptyError = (error) => Match.value(error).pipe(Match.when(Match.undefined, () => true), Match.when(Match.null, () => true), Match.when(Match.string, (text) => text.length === 0), Match.when(Match.number, isEmptyNumber), Match.when(Match.boolean, (value) => !value), Match.orElse(() => false));
-const formatErrnoException = (error) => Match.value(error.stack).pipe(Match.when(hasText, (stack) => `${error.name}: ${error.code} (${error.syscall}) ${stack}`), Match.orElse(() => `${error.name}: ${error.code} (${error.syscall})`));
-const formatError = (error) => Match.value(error.stack).pipe(Match.when(hasText, (stack) => `${error.name}: ${error.message}\n${stack}`), Match.orElse(() => `${error.name}: ${error.message}`));
-const isJsonPrimitive = (value) => Match.value(value).pipe(Match.when(Match.number, () => true), Match.when(Match.boolean, () => true), Match.when(Match.bigint, () => true), Match.orElse(() => false));
-const jsonText = (error) => {
-	try {
-		return textIfNonEmpty(JSON.stringify(error));
-	} catch {
-		return;
-	}
-};
-const isNonPlaceholderText = (text) => Match.value({
-	hasLength: text.length > 0,
-	isPlaceholder: text === "[object Object]"
-}).pipe(Match.when({
-	hasLength: true,
-	isPlaceholder: false
-}, () => true), Match.orElse(() => false));
-const isUsableText = (value) => Match.value(value).pipe(Match.when(Match.string, isNonPlaceholderText), Match.orElse(() => false));
-const usableText = (value) => Match.value(value).pipe(Match.when(isUsableText, (text) => text), Match.orElse(() => ""));
-const objectToStringText = (value) => Match.value(fieldOf(value, "toString")).pipe(Match.when(Match.instanceOf(Function), (callable) => {
-	try {
-		return usableText(Reflect.apply(callable, value, []));
-	} catch {
-		return "";
-	}
-}), Match.orElse(() => ""));
-const isObjectType = (cause) => typeof cause === "object";
-const toStringText = (error) => Match.value(error).pipe(Match.when(Match.null, () => ""), Match.when(isObjectType, (value) => objectToStringText(value)), Match.orElse(() => ""));
-const stringifyRest = (error) => Match.value(jsonText(error)).pipe(Match.when(hasText, (json) => json), Match.orElse(() => toStringText(error)));
-const stringifyNonError = (error) => Match.value(error).pipe(Match.when(Match.string, (text) => text), Match.when(isJsonPrimitive, (primitive) => JSON.stringify(primitive)), Match.orElse(() => stringifyRest(error)));
-const errorText = (error) => Match.value(error).pipe(Match.when(isErrnoException, formatErrnoException), Match.orElse(() => formatError(error)));
-function errorToString(error) {
-	return Match.value(error).pipe(Match.when(isEmptyError, () => ""), Match.when(Match.instanceOf(Error), errorText), Match.orElse(() => stringifyNonError(error)));
-}
-const ERROR_CODES = Object.freeze({ NoSuchFileOrDirectory: "ENOENT" });
-const errorNameOf = (value) => Match.value(value).pipe(Match.when(Match.instanceOf(Error), (error) => textIfNonEmpty(error.name)), Match.orElse(() => void 0));
-const tagOf = (value) => Match.value(textIfNonEmpty(fieldOf(value, "_tag"))).pipe(Match.when(hasText, (tag) => tag), Match.orElse(() => errorNameOf(value)));
-const textWithNested = (own, nested) => Match.value(own).pipe(Match.when(hasText, (text) => appendNested(text, nested)), Match.orElse(() => nested));
-const appendNested = (own, nested) => Match.value(nested).pipe(Match.when(hasText, (text) => `${own}: ${text}`), Match.orElse(() => own));
-const errorMessage = (error) => Match.value(error.message.length > 0).pipe(Match.when(true, () => error.message), Match.orElse(() => tagOf(error)));
-const errorMessageOrTag = (value) => Match.value(value).pipe(Match.when(Match.instanceOf(Error), errorMessage), Match.orElse(() => tagOf(value)));
-const messageText = (value) => Match.value(textIfNonEmpty(fieldOf(value, "message"))).pipe(Match.when(hasText, (message) => message), Match.orElse(() => errorMessageOrTag(value)));
-const ownCauseText = (value) => Match.value(textIfNonEmpty(fieldOf(value, "reason"))).pipe(Match.when(hasText, (reason) => reason), Match.orElse(() => messageText(value)));
-const causeText = (cause, depth) => Match.value(cause).pipe(Match.when(() => depth > 4, () => void 0), Match.when(Match.undefined, () => void 0), Match.when(Match.null, () => void 0), Match.when(Match.string, textIfNonEmpty), Match.when(isObjectType, (value) => textWithNested(ownCauseText(value), causeText(fieldOf(value, "cause"), depth + 1))), Match.orElse(() => void 0));
-//#endregion
-//#region src/Plugin.schema.ts
-const PluginKind = S.Literals([
-	"Checker",
-	"TestRunner",
-	"Reporter",
-	"Ignore",
-	"Evaluator"
-]);
-const PluginLayerKind = S.Literals([
-	"Checker",
-	"TestRunner",
-	"Ignore",
-	"Evaluator"
-]);
-var PluginLayerContribution = class extends S.TaggedClass()("PluginContribution", {
-	kind: PluginLayerKind,
-	name: S.String,
-	layer: S.Unknown
-}) {};
-var PluginReporterContribution = class extends S.TaggedClass()("PluginContribution", {
-	kind: PluginKind,
-	name: S.String,
-	make: S.Unknown
-}) {};
-var Shadowing = class extends S.TaggedClass()("Shadowing", {
-	kind: S.String,
-	name: S.String,
-	shadowedIndex: S.Finite,
-	winnerIndex: S.Finite
-}) {};
-//#endregion
-//#region src/Plugin.ts
-var RunConfiguration = class extends Context.Service()("~@systemfsoftware/stryker-js/RunConfiguration") {};
-var SandboxDirectory = class extends Context.Service()("~@systemfsoftware/stryker-js/SandboxDirectory") {};
-function declarePlugin(kind, name, payload) {
-	if (kind === "Reporter") return new PluginReporterContribution({
-		kind,
-		name,
-		make: payload
-	});
-	return new PluginLayerContribution({
-		kind,
-		name,
-		layer: payload
-	});
-}
-function foldContributions(contributions) {
-	const resolved = MutableHashMap.empty();
-	const shadowings = [];
-	const lastSeen = MutableHashMap.empty();
-	for (const [index, contribution] of contributions.entries()) {
-		const key = `${contribution.kind}:${contribution.name}`;
-		const previous = MutableHashMap.get(lastSeen, key);
-		shadowings.push(...Option.match(previous, {
-			onNone: () => [],
-			onSome: (shadowedIndex) => [new Shadowing({
-				kind: String(contribution.kind),
-				name: contribution.name,
-				shadowedIndex,
-				winnerIndex: index
-			})]
-		}));
-		MutableHashMap.set(resolved, key, contribution);
-		MutableHashMap.set(lastSeen, key, index);
-	}
-	return {
-		resolved,
-		shadowings
-	};
-}
-const reporterFactoryOf = (contribution) => Match.value(contribution).pipe(Match.discriminator("kind")("Reporter", (reporter) => [{
-	name: reporter.name,
-	make: reporter.make
-}]), Match.orElse(() => []));
-const layerOf = (contribution) => Match.value(contribution).pipe(Match.discriminator("kind")("Reporter", () => []), Match.orElse((nonReporter) => [nonReporter.layer]));
-const mergedLayer = (layers) => layers.reduce((accumulated, next) => Layer.merge(accumulated, next));
-function composePlugins(contributions) {
-	const { resolved, shadowings } = foldContributions(contributions);
-	const allResolved = Array.from(MutableHashMap.values(resolved));
-	const layers = allResolved.flatMap(layerOf);
-	return {
-		layer: Option.map(Option.fromUndefinedOr(layers.at(0)), () => mergedLayer(layers)),
-		reporterFactories: allResolved.flatMap(reporterFactoryOf),
-		shadowings
-	};
-}
-//#endregion
-//#region src/TestRunner.schema.ts
-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: S.String,
-	name: S.String,
-	timeSpentMs: S.Finite,
-	fileName: S.optionalKey(S.String),
-	startPosition: S.optionalKey(PositionSchema)
-};
-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 MutantCoverageSchema = S.Struct({
-	perTest: S.Record(S.String, S.Record(S.String, S.Finite)),
-	static: S.Record(S.String, S.Finite)
-});
-const DryRunResultSchema = S.Union([
-	S.Struct({
-		status: S.Literal("complete"),
-		tests: S.Array(TestResultSchema),
-		mutantCoverage: S.optionalKey(MutantCoverageSchema)
-	}),
-	S.Struct({
-		status: S.Literal("timeout"),
-		reason: S.optionalKey(S.String)
-	}),
-	S.Struct({
-		status: S.Literal("error"),
-		errorMessage: S.String
-	})
-]);
-const MutantRunResultSchema = S.Union([
-	S.Struct({
-		status: S.Literal("killed"),
-		killedBy: S.Array(S.String),
-		failureMessage: S.String,
-		nrOfTests: S.Finite
-	}),
-	S.Struct({
-		status: S.Literal("survived"),
-		nrOfTests: S.Finite
-	}),
-	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 RunOptionsFields = {
-	timeout: S.Finite,
-	disableBail: S.Boolean
-};
-const DryRunOptionsSchema = S.Struct({
-	...RunOptionsFields,
-	coverageAnalysis: CoverageAnalysisSchema,
-	files: S.optionalKey(S.Array(S.String)),
-	testFiles: S.optionalKey(S.Array(S.String))
-});
-const MutantActivationSchema = S.Literals(["runtime", "static"]);
-const MutantRunOptionsSchema = S.Struct({
-	...RunOptionsFields,
-	activeMutant: Mutant,
-	sandboxFileName: S.String,
-	mutantActivation: MutantActivationSchema,
-	reloadEnvironment: S.Boolean,
-	testFilter: S.optionalKey(S.Array(S.String)),
-	hitLimit: S.optionalKey(S.Finite)
-});
-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
-}) {};
-//#endregion
-//#region src/ReporterEvent.schema.ts
-const ReporterEventKind = S.Literals([
-	"dryRunCompleted",
-	"mutationTestingPlanReady",
-	"mutantTested",
-	"mutationTestReportReady"
-]);
-const RunTimingSchema = S.Struct({
-	net: S.Finite,
-	overhead: S.Finite
-});
-const ReporterPlanKind = S.Literals(["EarlyResult", "Run"]);
-const ReporterPlanDescriptorSchema = S.Struct({
-	mutantId: S.String,
-	plan: ReporterPlanKind,
-	netTime: S.Finite,
-	reloadEnvironment: S.Boolean
-});
-var DryRunCompleted = class extends S.TaggedClass()("dryRunCompleted", {
-	timing: RunTimingSchema,
-	capabilities: TestRunnerCapabilitiesSchema,
-	testCount: S.Finite,
-	tests: S.Array(TestResultSchema)
-}) {};
-var MutationTestingPlanReady = class extends S.TaggedClass()("mutationTestingPlanReady", {
-	total: S.Finite,
-	plans: S.Array(ReporterPlanDescriptorSchema)
-}) {};
-var MutantTested = class extends S.TaggedClass()("mutantTested", {
-	id: S.String,
-	status: MutantStatusSchema,
-	file: S.String,
-	location: LocationSchema,
-	mutator: S.String,
-	replacement: S.NullOr(S.String),
-	completed: S.Finite,
-	total: S.Finite
-}) {};
-var MutationTestReportReady = class extends S.TaggedClass()("mutationTestReportReady", {
-	report: MutationTestResultSchema,
-	metrics: MetricsResultSchema
-}) {};
-const ReporterEventUnion = S.Union([
-	DryRunCompleted,
-	MutationTestingPlanReady,
-	MutantTested,
-	MutationTestReportReady
-]);
-const ReporterEventSchema = S.toStandardSchemaV1(ReporterEventUnion);
-var ReporterFailed = class extends S.TaggedError()("ReporterFailed", {
-	cause: S.String,
-	event: ReporterEventKind,
-	reporterName: S.String
-}) {};
-//#endregion
-//#region src/Run.schema.ts
-const RunPhase = S.Literals([
-	"prepare",
-	"instrument",
-	"dry-run",
-	"mutation-test"
-]);
-const OutputMode = S.Literals(["human", "machine"]);
-const ModeSignal = S.Literals([
-	"flag",
-	"env",
-	"tty",
-	"agent",
-	"tool"
-]);
-var RunStarted = class extends S.TaggedClass()("stream", {
-	schemaVersion: S.String,
-	runId: S.String,
-	mode: OutputMode,
-	signal: ModeSignal
-}) {};
-var PhaseEntered = class extends S.TaggedClass()("phase", {
-	phase: RunPhase,
-	elapsedMs: S.Finite
-}) {};
-var PlanKnown = class extends S.TaggedClass()("plan", { total: S.Finite }) {};
-var RunMutantTested = class extends S.TaggedClass()("mutant", {
-	id: S.String,
-	status: MutantStatusSchema,
-	file: S.String,
-	location: LocationSchema,
-	mutator: S.String,
-	replacement: S.NullOr(S.String),
-	completed: S.Finite,
-	total: S.Finite
-}) {};
-var Heartbeat = class extends S.TaggedClass()("tick", {
-	elapsedMs: S.Finite,
-	completed: S.Finite,
-	total: S.NullOr(S.Finite)
-}) {};
-const VerdictThresholds = S.Struct({
-	high: S.Finite,
-	low: S.Finite,
-	break: S.NullOr(S.Finite)
-});
-const VerdictMutant = S.Struct({
-	id: S.String,
-	file: S.String,
-	location: LocationSchema,
-	mutator: S.String,
-	replacement: S.NullOr(S.String),
-	status: MutantStatusSchema
-});
-const VerdictCounts = S.Struct({
-	killed: S.Finite,
-	timeout: S.Finite,
-	survived: S.Finite,
-	noCoverage: S.Finite,
-	runtimeErrors: S.Finite,
-	compileErrors: S.Finite,
-	ignored: S.Finite,
-	pending: S.Finite
-});
-var VerdictReached = class extends S.TaggedClass()("verdict", {
-	schemaVersion: S.String,
-	runId: S.String,
-	mode: OutputMode,
-	signal: ModeSignal,
-	score: S.NullOr(S.Finite),
-	thresholds: VerdictThresholds,
-	reportFile: S.NullOr(S.String),
-	counts: VerdictCounts,
-	mutants: S.Array(VerdictMutant)
-}) {};
-var RunFailed = class extends S.TaggedClass()("error", {
-	schemaVersion: S.String,
-	code: S.Finite,
-	error: S.String,
-	remediation: S.String
-}) {};
-var HelpRendered = class extends S.TaggedClass()("help", {
-	schemaVersion: S.String,
-	code: S.Literals([0]),
-	help: S.String
-}) {};
-S.Union([
-	RunStarted,
-	PhaseEntered,
-	PlanKnown,
-	RunMutantTested,
-	Heartbeat,
-	VerdictReached,
-	RunFailed,
-	HelpRendered
-]);
-var RunCommand = class extends S.TaggedClass()("RunCommand", {
-	cliOptionsJson: S.String,
-	targetMutatePatterns: S.Array(S.String)
-}) {};
-var RunOutput = class extends S.TaggedClass()("RunOutput", {
-	verdictJson: S.String,
-	exitCode: S.Finite
-}) {};
-S.TaggedError()("RunDecodeError", { message: S.String });
-S.TaggedError()("RunReadError", { message: S.String });
-S.TaggedError()("RunWriteError", { message: S.String });
-var PlanMutationRunCommand = class extends S.TaggedClass()("PlanMutationRunCommand", {
-	configMutatePatterns: S.Array(S.String),
-	configMutatorNames: S.Array(S.String),
-	targetMutatePatterns: S.Array(S.String),
-	availableMutators: S.Array(S.String)
-}) {};
-var MutationRunPlan = class extends S.TaggedClass()("MutationRunPlan", {
-	mutatePatterns: S.Array(S.String),
-	mutatorNames: S.Array(S.String)
-}) {};
-//#endregion
-//#region src/Run.ts
-const firstNonEmpty = (preferred, fallback) => {
-	if (preferred.length > 0) return [...preferred];
-	return [...fallback];
-};
-const planMutationRun = (command) => MutationRunPlan.make({
-	mutatePatterns: firstNonEmpty(command.targetMutatePatterns, command.configMutatePatterns),
-	mutatorNames: firstNonEmpty(command.availableMutators, command.configMutatorNames)
-});
-var RunEvents = class extends Context.Service()("~@systemfsoftware/stryker-js/RunEvents") {};
-var RunIdentity = class extends Context.Service()("~@systemfsoftware/stryker-js/RunIdentity") {};
-const runMutationTest = (io, command) => Effect$1.gen(function* () {
-	const raw = yield* io.read(command);
-	const planCommand = yield* Result.match(S.decodeUnknownResult(PlanMutationRunCommand)(raw), {
-		onFailure: (error) => Effect$1.fail(error),
-		onSuccess: (decoded) => Effect$1.succeed(decoded)
-	});
-	const plan = planMutationRun(planCommand);
-	return yield* io.write(new RunOutput({
-		verdictJson: JSON.stringify({
-			mutate: plan.mutatePatterns,
-			mutatorNames: plan.mutatorNames
-		}),
-		exitCode: 0
-	}));
-});
-const shouldKeepTempDir = (exit, cleanTempDir) => Exit.isFailure(exit) && cleanTempDir !== "always";
-//#endregion
-//#region src/Schema.schema.ts
-const RENDERED_OPTION_DEFAULTS$1 = {
-	coverageAnalysis: "perTest",
-	fileLogLevel: "off",
-	logLevel: "info",
-	tempDirName: ".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
-* `strykerCoreSchema` is the JSON Schema document **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"
-]);
-S.Literals(["full", "mutationScore"]);
-const PackageManager = S.Literals([
-	"npm",
-	"yarn",
-	"pnpm"
-]);
-/** 0–100 percentage used by the mutation-score thresholds. */
-const Percentage = S.Finite.pipe(S.check(S.isBetween({
-	minimum: 0,
-	maximum: 100
-})));
-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(S.Finite.pipe(S.check(S.isGreaterThanOrEqualTo(0))), 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 MutationScoreThresholdsSchema = S.Struct({
-	high: defaulted(Percentage, 80),
-	low: defaulted(Percentage, 60),
-	break: defaulted(S.NullOr(Percentage), null)
-});
-const MutatorDescriptor = S.Struct({ excludedMutations: defaulted(S.Array(S.String), []) });
-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.Finite.pipe(S.check(S.isGreaterThanOrEqualTo(1)));
-const ConcurrencyPercent = S.String.pipe(S.check(S.isPattern(/^(100|[1-9]?[0-9])%$/)));
-const StrykerOptionsSchema = S.StructWithRest(S.Struct({
-	allowConsoleColors: defaulted(S.Boolean, true),
-	buildCommand: S.optional(S.String),
-	checkers: defaulted(S.Array(S.String), []),
-	checkerNodeArgs: defaulted(S.Array(S.String), []),
-	concurrency: S.optional(S.Union([ConcurrencyCount, ConcurrencyPercent])),
-	commandRunner: defaulted(CommandRunnerOptionsSchema, { command: "npm test" }),
-	coverageAnalysis: defaulted(CoverageAnalysisMode, RENDERED_OPTION_DEFAULTS$1.coverageAnalysis),
-	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"),
-	progressStreamFile: defaulted(S.String, "reports/mutation-stream.jsonl"),
-	force: defaulted(S.Boolean, false),
-	fileLogLevel: defaulted(LogLevel, RENDERED_OPTION_DEFAULTS$1.fileLogLevel),
-	inPlace: defaulted(S.Boolean, false),
-	logLevel: defaulted(LogLevel, RENDERED_OPTION_DEFAULTS$1.logLevel),
-	maxConcurrentTestRunners: defaulted(S.Finite, 9007199254740991),
-	maxTestRunnerReuse: defaulted(S.Finite, 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: [] }),
-	packageManager: S.optional(PackageManager),
-	plugins: defaulted(S.Array(S.String), ["@systemfsoftware/stryker-js-*"]),
-	appendPlugins: defaulted(S.Array(S.String), []),
-	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, RENDERED_OPTION_DEFAULTS$1.tempDirName),
-	cleanTempDir: defaulted(S.Literals([
-		"always",
-		false,
-		true
-	]), true),
-	testRunner: defaulted(S.String, "command"),
-	testRunnerNodeArgs: defaulted(S.Array(S.String), []),
-	thresholds: defaulted(MutationScoreThresholdsSchema, {
-		high: 80,
-		low: 60,
-		break: null
-	}),
-	timeoutFactor: defaulted(S.Finite, 1.5),
-	timeoutMS: defaulted(S.Finite, 5e3),
-	dryRunTimeoutMinutes: defaulted(S.Finite.pipe(S.check(S.isGreaterThanOrEqualTo(0))), 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(S.String), []),
-	testFiles: defaulted(S.Array(S.String), [])
-}), [S.Record(S.String, S.Unknown)]);
-//#endregion
-//#region src/Schema.ts
-/**
-* The four option defaults a human reads about in help text.
-*
-* `Schema.schema.ts` declares every default, and a CLI that wants to
-* name one in a `--help` description must read it from here rather than type
-* the literal a second time: a restated default drifts the moment the schema
-* moves, and no gate compares a help string against a schema annotation.
-*
-* Only these four are here because only these four are rendered. A default
-* nobody prints has one declaration site already, which is the schema.
-*/
-const RENDERED_OPTION_DEFAULTS = {
-	coverageAnalysis: "perTest",
-	fileLogLevel: "off",
-	logLevel: "info",
-	tempDirName: ".stryker-tmp"
-};
-/**
-* Given a base type, allows type safe access to the name of a property.
-* @param prop - The property name
-*/
-function propertyPath() {
-	const fn = (...args) => args.join(".");
-	return fn;
-}
-/**
-* Creates a URL to the page where a consumer can report a bug against this
-* project.
-*
-* The tracker is ours. The ported original addressed the upstream StrykerJS
-* repository, along with its label and issue-template parameters, so every bug
-* a consumer filed from a Stryker run arrived at a project that does not own
-* this code (`REPO-O1`) and prefilled a template that does not exist here.
-*
-* @param titleSuggestion - The title to be prefilled in.
-*/
-function strykerReportBugUrl(titleSuggestion) {
-	return `https://github.com/systemfsoftware/systemfsoftware/issues/new?title=${encodeURIComponent(titleSuggestion)}`;
-}
-/**
-* The JSON Schema document derived from `StrykerOptionsSchema`, self-contained.
-*
-* It lives beside the schema module rather than inside it because it is a *use*
-* of that schema, not a declaration of one: `S.toJsonSchemaDocument` consumes a
-* schema and returns a plain document. Keeping uses out of a `*.schema.ts` is
-* what lets a tool read every exported schema in a package and trust that each
-* one is a schema - the generated law suite does exactly that, and a document
-* handed to `toEncoded` takes the whole suite down with it.
-*/
-const strykerCoreSchema = (() => {
-	const { schema, definitions } = S.toJsonSchemaDocument(StrykerOptionsSchema);
-	if (Object.keys(definitions).length === 0) return schema;
-	return {
-		...schema,
-		definitions
-	};
-})();
-//#endregion
-//#region src/TestRunner.ts
-function toMutantRunResult(dryRunResult, reportAllKillers) {
-	return Match.value(dryRunResult).pipe(Match.discriminator("status")("complete", (complete) => {
-		const failed = complete.tests.filter((t) => t.status === "failed");
-		const nrOfTests = complete.tests.filter((t) => t.status !== "skipped").length;
-		return Option.match(Option.fromUndefinedOr(failed.at(0)), {
-			onNone: () => ({
-				nrOfTests,
-				status: "survived"
-			}),
-			onSome: (firstFailed) => ({
-				failureMessage: firstFailed.failureMessage,
-				killedBy: Match.value(reportAllKillers).pipe(Match.when(true, () => failed.map((t) => t.id)), Match.when(false, () => [firstFailed.id]), Match.exhaustive),
-				nrOfTests,
-				status: "killed"
-			})
-		});
-	}), Match.discriminator("status")("error", (errored) => ({
-		errorMessage: errored.errorMessage,
-		status: "error"
-	})), Match.discriminator("status")("timeout", (timedOut) => Option.match(Option.fromUndefinedOr(timedOut.reason), {
-		onNone: () => ({ status: "timeout" }),
-		onSome: (reason) => ({
-			reason,
-			status: "timeout"
-		})
-	})), Match.exhaustive);
-}
-var TestRunner = class extends Context.Service()("~@systemfsoftware/stryker-js/TestRunner") {};
-function testFilesProvided(options) {
-	return options.testFiles !== void 0 && options.testFiles.length > 0;
-}
-//#endregion
-export { BrandingInformationSchema, CheckResultSchema, CheckStatus, Checker, CheckerFailed, ClassifyExitCommand, ClassifyExitDecision, CommandRunnerOptionsSchema, CoverageAnalysisMode, CoverageAnalysisSchema, DependenciesSchema, DryRunCompleted, DryRunOptionsSchema, DryRunResultSchema, DryRunStatus, ERROR_CODES, EXIT_CODE, Evaluator, EvaluatorFailed, ExitClass, FileResultDictionarySchema, FileResultSchema, FrameworkInformationSchema, Heartbeat, HelpRendered, INSTRUMENTER_CONSTANTS, Ignorer, LocationSchema, LogLevel, MetricsResultSchema, MetricsSchema, ModeSignal, Module, Mutant, MutantActivationSchema, MutantCoverageSchema, MutantResultSchema, MutantRunOptionsSchema, MutantRunResultSchema, MutantRunStatus, MutantStatusSchema, MutantTested, MutationRunPlan, MutationScoreThresholdsSchema, MutationTestReportReady, MutationTestResultSchema, MutationTestingPlanReady, OpenEndLocationSchema, OutputMode, PackageManager, PhaseEntered, PlanKnown, PlanMutationRunCommand, PluginKind, PluginLayerContribution, PluginReporterContribution, PositionSchema, RENDERED_OPTION_DEFAULTS, ReporterEventKind, ReporterEventSchema, ReporterEventUnion, ReporterFailed, ReporterPlanDescriptorSchema, ReporterPlanKind, RunCommand, RunConfiguration, RunEvents, RunFailed, RunIdentity, RunMutantTested, RunOutput, RunPhase, RunStarted, RunTimingSchema, SandboxDirectory, Shadowing, StrykerOptionsSchema, TestDefinitionSchema, TestFileDefinitionDictionarySchema, TestFileSchema, TestResultSchema, TestRunner, TestRunnerCapabilitiesSchema, TestRunnerFailed, TestStatus, ThresholdsSchema, VerdictReached, calculateMetrics, causeText, classifyExit, composePlugins, countMutants, declarePlugin, errorToString, highestExitClass, isErrnoException, isMutant, normalizeFileName, planMutationRun, propertyPath, resolveExitCode, runMutationTest, shouldKeepTempDir, strykerCoreSchema, strykerReportBugUrl, testFilesProvided, toMutantRunResult, verdictExitClass };
+import { A as RunMutantTested, B as SUPPORTED_CONFIG_FILE_NAMES, C as RunEvents, D as PhaseEntered, E as HelpRendered, F as ExitClass, G as isModuleSpecifier, H as deepFreeze, I as highestExitClass, K as isWarningEnabled, L as resolveExitCode, M as RunStarted, N as VerdictReached, O as PlanKnown, P as EXIT_CODE, R as verdictExitClass, S as toRelativeNormalizedFileName, T as Heartbeat, U as defaultOptions, V as createDefaultOptions, W as findUnserializables, _ as IncrementalReportSchema, a as shouldKeepTempDir, b as reporterWorkerFactory, c as buildVerdictEnvelope, d as strykerVersion, f as calculateMetrics, g as matchesFile, h as createFileMatcher, i as mutationTestCell, j as RunPhase, k as RunFailed, l as generateRunId, m as checkGroupedPlans, n as RUN_EVENTS_QUEUE_BOUND, o as ACTIONABLE_STATUSES, p as countMutants, q as optionsPath, r as makeRunLayer, s as VERDICT_ENVELOPE_SCHEMA_VERSION, t as strykerCell, u as isActionableStatus, v as RunEnvironment, w as RunIdentity, x as spawnReporterWorker, y as REPORTER_EVENT_BATCH_BOUND, z as CONFIG_SYNTAX_HELP } from "./src-Bzh7ykDp.mjs";
+import { A as OutOfMemoryError, B as ConfigDocumentSchema, C as connectRetry, E as classifyWorkerExit, F as vmRunnerName, G as ConfigFileUnsupportedError, H as ConfigFileInvalidError, I as vmTestRunner, J as MergeResult, K as ImportedModuleSchema, L as StrykerError, M as VmRunner, N as isVmRunner, P as vmRunnerCapabilities, Q as survivorsPriorReport, S as WorkerLauncher, U as ConfigFileNotFoundError, V as ConfigError, W as ConfigFileUnreadableError, X as extendsPropertySchema, Y as ReadConfigCommand, Z as forkOptionsSchema, _ as validateOptions, c as decideExtendsStep, d as importModule, et as StageError, f as initialExtendsStepState, g as resolveExtends, h as readConfig, j as WorkerBootTimeoutError, k as ChildProcessCrashedError, l as describeErrors, m as mergeConfigs, p as loadConfigCell, q as MergeCommand, u as forkCoreSchema, v as buildTestRunner, w as makeWorkerClient, y as isCommandRunner } from "./plugin-worker-entry-DNu0SHO8.mjs";
+export { ACTIONABLE_STATUSES, CONFIG_SYNTAX_HELP, ChildProcessCrashedError, ConfigDocumentSchema, ConfigError, ConfigFileInvalidError, ConfigFileNotFoundError, ConfigFileUnreadableError, ConfigFileUnsupportedError, EXIT_CODE, ExitClass, Heartbeat, HelpRendered, ImportedModuleSchema, IncrementalReportSchema, MergeCommand, MergeResult, OutOfMemoryError, PhaseEntered, PlanKnown, REPORTER_EVENT_BATCH_BOUND, RUN_EVENTS_QUEUE_BOUND, ReadConfigCommand, RunEnvironment, RunEvents, RunFailed, RunIdentity, RunMutantTested, RunPhase, RunStarted, SUPPORTED_CONFIG_FILE_NAMES, StageError, StrykerError, VERDICT_ENVELOPE_SCHEMA_VERSION, VerdictReached, VmRunner, WorkerBootTimeoutError, WorkerLauncher, buildTestRunner, buildVerdictEnvelope, calculateMetrics, checkGroupedPlans, classifyWorkerExit, connectRetry, countMutants, createDefaultOptions, createFileMatcher, decideExtendsStep, deepFreeze, defaultOptions, describeErrors, extendsPropertySchema, findUnserializables, forkCoreSchema, forkOptionsSchema, generateRunId, highestExitClass, importModule, initialExtendsStepState, isActionableStatus, isCommandRunner, isModuleSpecifier, isVmRunner, isWarningEnabled, loadConfigCell, makeRunLayer, makeWorkerClient, matchesFile, mergeConfigs, mutationTestCell, optionsPath, readConfig, reporterWorkerFactory, resolveExitCode, resolveExtends, shouldKeepTempDir, spawnReporterWorker, strykerCell, strykerVersion, survivorsPriorReport, toRelativeNormalizedFileName, validateOptions, verdictExitClass, vmRunnerCapabilities, vmRunnerName, vmTestRunner };