@systemfsoftware/stryker-js 5.0.0 → 6.0.0

package/dist/dist-CWbipfGB.mjs

@@ -0,0 +1,711 @@
+import * as Predicate from "effect/Predicate";
+import * as S from "effect/Schema";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as Context from "effect/Context";
+import * as Rpc from "effect/unstable/rpc/Rpc";
+import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
+import * as RpcMiddleware from "effect/unstable/rpc/RpcMiddleware";
+import { Effect } from "effect";
+//#region ../stryker-js-instrumenter/dist/Mutant-DnhV_fpo.mjs
+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"
+]);
+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)
+}) {};
+const RunOptionsFields = {
+	timeout: S.Finite,
+	disableBail: S.Boolean
+};
+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 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)));
+}
+Object.freeze({ NoSuchFileOrDirectory: "ENOENT" });
+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)
+}) {};
+Context.Service()("@systemfsoftware/stryker-js-plugin-interface/Checker");
+S.TaggedError()("EvaluatorFailed", { cause: S.Unknown });
+Context.Service()("@systemfsoftware/stryker-js-plugin-interface/Evaluator");
+const ExitClass = S.Literals([
+	"VerdictFail",
+	"ConfigError",
+	"RuntimeError",
+	"InternalError"
+]);
+S.TaggedClass()("ClassifyExitCommand", {
+	pending: S.Array(ExitClass),
+	signal: S.NullOr(S.Finite),
+	score: S.NullOr(S.Finite),
+	breakingThreshold: S.NullOr(S.Finite)
+});
+S.TaggedClass()("ClassifyExitDecision", {
+	highestClass: S.NullOr(ExitClass),
+	verdictClass: S.NullOr(ExitClass)
+});
+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" });
+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)
+});
+S.Literals([
+	"complete",
+	"error",
+	"timeout"
+]);
+S.Literals([
+	"success",
+	"failed",
+	"skipped"
+]);
+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 DryRunOptionsSchema = S.Struct({
+	...RunOptionsFields,
+	coverageAnalysis: CoverageAnalysisSchema,
+	files: S.optionalKey(S.Array(S.String)),
+	testFiles: S.optionalKey(S.Array(S.String))
+});
+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
+}) {};
+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
+]);
+S.toStandardSchemaV1(ReporterEventUnion);
+var ReporterFailed = class extends S.TaggedError()("ReporterFailed", {
+	cause: S.String,
+	event: ReporterEventKind,
+	reporterName: S.String
+}) {};
+const WorkerPluginKind = S.Literals([
+	"TestRunner",
+	"Checker",
+	"Reporter"
+]);
+const TestRunnerDryRunRequest = S.Struct({ options: DryRunOptionsSchema });
+const TestRunnerMutantRunRequest = S.Struct({ options: MutantRunOptionsSchema });
+const CheckerRequest = S.Struct({
+	checkerName: S.String,
+	mutants: S.Array(Mutant)
+});
+const CheckerCheckResult = S.Record(S.String, CheckResultSchema);
+const CheckerGroupResult = S.Array(S.Array(S.String));
+const ReporterInitOptions = S.Struct({
+	traceparent: S.optionalKey(S.String),
+	tracestate: S.optionalKey(S.String)
+});
+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
+}) {};
+var BoundaryUnrecognizedSignal = class extends S.TaggedError()("BoundaryUnrecognizedSignal", {
+	pluginName: S.String,
+	method: S.String,
+	signal: S.String
+}) {};
+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/PropagatedTrace") {};
+var TraceContextMiddleware = class extends RpcMiddleware.Service()("@systemfsoftware/stryker-js-plugin-interface/TraceContextMiddleware", { requiredForClient: true }) {};
+const TestRunnerRpcs = RpcGroup.make(Rpc.make("capabilities", {
+	success: TestRunnerCapabilitiesSchema,
+	error: TestRunnerFailed
+}), Rpc.make("dryRun", {
+	payload: TestRunnerDryRunRequest,
+	success: DryRunResultSchema,
+	error: TestRunnerFailed
+}), Rpc.make("mutantRun", {
+	payload: TestRunnerMutantRunRequest,
+	success: MutantRunResultSchema,
+	error: TestRunnerFailed
+})).middleware(TraceContextMiddleware);
+const CheckerRpcs = RpcGroup.make(Rpc.make("check", {
+	payload: CheckerRequest,
+	success: CheckerCheckResult,
+	error: CheckerFailed
+}), Rpc.make("group", {
+	payload: CheckerRequest,
+	success: CheckerGroupResult,
+	error: CheckerFailed
+})).middleware(TraceContextMiddleware);
+const ReporterRpcs = RpcGroup.make(Rpc.make("init", {
+	payload: ReporterInitOptions,
+	success: ReporterAck,
+	error: ReporterFailed
+}), Rpc.make("onEventBatch", {
+	payload: ReporterEventBatch,
+	success: ReporterAck,
+	error: ReporterFailed
+}), Rpc.make("flush", {
+	success: ReporterDrained,
+	error: ReporterFailed
+})).middleware(TraceContextMiddleware);
+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 PluginFileUrl = S.String.pipe(S.check(S.isStartsWith("file://")));
+const TestRunnerCustomConfigSchema = S.Struct({
+	plugin: PluginFileUrl,
+	nodeArgs: S.optional(S.Array(S.String)),
+	options: S.optional(S.Record(S.String, S.Unknown))
+});
+const TestRunnerConfigSchema = S.Union([S.String, TestRunnerCustomConfigSchema]);
+const CheckerEntryConfigSchema = S.Struct({
+	plugin: PluginFileUrl,
+	nodeArgs: S.optional(S.Array(S.String)),
+	options: S.optional(S.Record(S.String, S.Unknown))
+});
+const StrykerOptionsSchema = S.StructWithRest(S.Struct({
+	allowConsoleColors: defaulted(S.Boolean, true),
+	buildCommand: S.optional(S.String),
+	checkers: defaulted(S.Array(CheckerEntryConfigSchema), []),
+	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(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, RENDERED_OPTION_DEFAULTS$1.tempDirName),
+	cleanTempDir: defaulted(S.Literals([
+		"always",
+		false,
+		true
+	]), true),
+	testRunner: defaulted(TestRunnerConfigSchema, "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(PluginFileUrl), []),
+	testFiles: defaulted(S.Array(S.String), [])
+}), [S.Record(S.String, S.Unknown)]);
+const isCustomTestRunner = (value) => typeof value !== "string";
+(() => {
+	const { schema, definitions } = S.toJsonSchemaDocument(StrykerOptionsSchema);
+	if (Object.keys(definitions).length === 0) return schema;
+	return {
+		...schema,
+		definitions
+	};
+})();
+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);
+}
+Context.Service()("@systemfsoftware/stryker-js-plugin-interface/TestRunner");
+const TRACEPARENT_HEADER = "traceparent";
+const TRACESTATE_HEADER = "tracestate";
+const formatTraceparent = (parts) => `${parts.version}-${parts.traceId}-${parts.spanId}-${(parts.traceFlags & 255).toString(16).padStart(2, "0")}`;
+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 traceparentFields = (parts) => ({
+	version: fieldAt(parts, 0),
+	traceId: fieldAt(parts, 1),
+	spanId: fieldAt(parts, 2),
+	flags: fieldAt(parts, 3)
+});
+const acceptsFieldCount = (version, count) => version !== CURRENT_VERSION || count === TRACEPARENT_FIELD_COUNT;
+const isKnownVersion = (version) => HEX_VERSION.test(version) && version !== FORBIDDEN_VERSION;
+const isNonZeroHex = (pattern, value) => pattern.test(value) && !ALL_ZERO.test(value);
+const isWellFormedTraceparent = (fields, fieldCount) => [
+	acceptsFieldCount(fields.version, fieldCount),
+	isKnownVersion(fields.version),
+	isNonZeroHex(HEX_TRACE_ID, fields.traceId),
+	isNonZeroHex(HEX_SPAN_ID, fields.spanId),
+	HEX_FLAGS.test(fields.flags)
+].every((check) => check);
+const parseTraceparent = (value) => {
+	const parts = value.split("-");
+	const fields = traceparentFields(parts);
+	return Option.map(Option.liftPredicate(fields, (candidate) => isWellFormedTraceparent(candidate, parts.length)), (wellFormed) => ({
+		version: wellFormed.version,
+		traceId: wellFormed.traceId,
+		spanId: wellFormed.spanId,
+		traceFlags: Number.parseInt(wellFormed.flags, 16)
+	}));
+};
+const TraceContextReference = Context.Reference("@systemfsoftware/stryker-js-plugin-interface/TraceContextReference", { defaultValue: () => Option.none() });
+//#endregion
+export { formatTraceparent as A, errorToString as B, TestRunnerFailed as C, WorkerEntryUrl as D, TraceContextReference as E, LocationSchema as F, Mutant as I, MutantActivationSchema as L, parseTraceparent as M, toMutantRunResult as N, WorkerPluginKind as O, INSTRUMENTER_CONSTANTS as P, MutantStatusSchema as R, TestRunnerConfigSchema as S, TraceContextMiddleware as T, normalizeFileName as V, ReporterInitOptions as _, MetricsResultSchema as a, TRACEPARENT_HEADER as b, MutantTested as c, MutationTestingPlanReady as d, PropagatedTrace as f, ReporterFailed as g, ReporterEventBatch as h, FileResultSchema as i, isCustomTestRunner as j, WorkerPluginSpawnSchema as k, MutationTestReportReady as l, ReporterDrained as m, DryRunCompleted as n, MetricsSchema as o, ReporterAck as p, ExitClass as r, MutantResultSchema as s, CheckerRpcs as t, MutationTestResultSchema as u, ReporterRpcs as v, TestRunnerRpcs as w, TRACESTATE_HEADER as x, StrykerOptionsSchema as y, PositionSchema as z };