@systemfsoftware/stryker-js-plugin-interface 5.0.0 → 6.0.1

package/dist/index.mjs

@@ -1,10 +1,297 @@
-import { CheckResultSchema, CheckResultSchema as CheckResultSchema$1, CheckerFailed, CheckerFailed as CheckerFailed$1, DryRunOptionsSchema, DryRunResultSchema, DryRunResultSchema as DryRunResultSchema$1, Mutant, MutantRunOptionsSchema, MutantRunResultSchema, MutantRunResultSchema as MutantRunResultSchema$1, ReporterEventUnion, ReporterEventUnion as ReporterEventUnion$1, ReporterFailed, ReporterFailed as ReporterFailed$1, TestRunnerCapabilitiesSchema, TestRunnerCapabilitiesSchema as TestRunnerCapabilitiesSchema$1, TestRunnerFailed, TestRunnerFailed as TestRunnerFailed$1 } from "@systemfsoftware/stryker-js-language";
+import { LocationSchema, LocationSchema as LocationSchema$1, Mutant, MutantActivationSchema, MutantRunOptionsSchema, MutantRunOptionsSchema as MutantRunOptionsSchema$1, MutantStatusSchema, MutantStatusSchema as MutantStatusSchema$1, OpenEndLocationSchema, OpenEndLocationSchema as OpenEndLocationSchema$1, PositionSchema, PositionSchema as PositionSchema$1, RunOptionsFields } from "@systemfsoftware/stryker-js-instrumenter";
+import * as Context from "effect/Context";
+import * as S from "effect/Schema";
 import * as Rpc from "effect/unstable/rpc/Rpc";
 import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
-import * as S from "effect/Schema";
-import * as Context from "effect/Context";
 import * as RpcMiddleware from "effect/unstable/rpc/RpcMiddleware";
+import { Effect } from "effect";
+import * as Match from "effect/Match";
 import * as Option from "effect/Option";
+//#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-plugin-interface/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-plugin-interface/Evaluator") {};
+//#endregion
+//#region src/ExitClass.schema.ts
+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)
+});
+//#endregion
+//#region src/ExitClass.ts
+const EXIT_CODE = {
+	VerdictFail: 1,
+	ConfigError: 2,
+	RuntimeError: 3,
+	InternalError: 4
+};
+//#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/Report.schema.ts
+const MutantResultSchema = S.Struct({
+	id: S.String,
+	mutatorName: S.String,
+	status: MutantStatusSchema$1,
+	location: LocationSchema$1,
+	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$1)
+});
+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/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$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 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
+}) {};
+//#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$1,
+	file: S.String,
+	location: LocationSchema$1,
+	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/Plugin.schema.ts
 const WorkerPluginKind = S.Literals([
 	"TestRunner",
@@ -12,18 +299,18 @@ const WorkerPluginKind = S.Literals([
 	"Reporter"
 ]);
 const TestRunnerDryRunRequest = S.Struct({ options: DryRunOptionsSchema });
-const TestRunnerMutantRunRequest = S.Struct({ options: MutantRunOptionsSchema });
+const TestRunnerMutantRunRequest = S.Struct({ options: MutantRunOptionsSchema$1 });
 const CheckerRequest = S.Struct({
 	checkerName: S.String,
 	mutants: S.Array(Mutant)
 });
-const CheckerCheckResult = S.Record(S.String, CheckResultSchema$1);
+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$1);
+const ReporterEventBatch = S.Array(ReporterEventUnion);
 const ReporterAck = S.Void;
 const ReporterDrained = S.Void;
 var BoundaryPayloadRejected = class extends S.TaggedError()("BoundaryPayloadRejected", {
@@ -39,9 +326,9 @@ var BoundaryUnrecognizedSignal = class extends S.TaggedError()("BoundaryUnrecogn
 const BoundaryErrorSchema = S.Union([
 	BoundaryPayloadRejected,
 	BoundaryUnrecognizedSignal,
-	TestRunnerFailed$1,
-	CheckerFailed$1,
-	ReporterFailed$1
+	TestRunnerFailed,
+	CheckerFailed,
+	ReporterFailed
 ]);
 const WorkerEntryUrl = S.String.check(S.isPattern(/^file:\/\//, { expected: "a file: URL of the worker program" }));
 const WorkerPluginSpawnSchema = S.Struct({
@@ -55,39 +342,315 @@ var TraceContextMiddleware = class extends RpcMiddleware.Service()("@systemfsoft
 //#endregion
 //#region src/Plugin.ts
 const TestRunnerRpcs = RpcGroup.make(Rpc.make("capabilities", {
-	success: TestRunnerCapabilitiesSchema$1,
-	error: TestRunnerFailed$1
+	success: TestRunnerCapabilitiesSchema,
+	error: TestRunnerFailed
 }), Rpc.make("dryRun", {
 	payload: TestRunnerDryRunRequest,
-	success: DryRunResultSchema$1,
-	error: TestRunnerFailed$1
+	success: DryRunResultSchema,
+	error: TestRunnerFailed
 }), Rpc.make("mutantRun", {
 	payload: TestRunnerMutantRunRequest,
-	success: MutantRunResultSchema$1,
-	error: TestRunnerFailed$1
+	success: MutantRunResultSchema,
+	error: TestRunnerFailed
 })).middleware(TraceContextMiddleware);
 const CheckerRpcs = RpcGroup.make(Rpc.make("check", {
 	payload: CheckerRequest,
 	success: CheckerCheckResult,
-	error: CheckerFailed$1
+	error: CheckerFailed
 }), Rpc.make("group", {
 	payload: CheckerRequest,
 	success: CheckerGroupResult,
-	error: CheckerFailed$1
+	error: CheckerFailed
 })).middleware(TraceContextMiddleware);
 const ReporterRpcs = RpcGroup.make(Rpc.make("init", {
 	payload: ReporterInitOptions,
 	success: ReporterAck,
-	error: ReporterFailed$1
+	error: ReporterFailed
 }), Rpc.make("onEventBatch", {
 	payload: ReporterEventBatch,
 	success: ReporterAck,
-	error: ReporterFailed$1
+	error: ReporterFailed
 }), Rpc.make("flush", {
 	success: ReporterDrained,
-	error: ReporterFailed$1
+	error: ReporterFailed
 })).middleware(TraceContextMiddleware);
 //#endregion
+//#region src/stryker-options.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"
+]);
+const ReportType = 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 CheckerCustomConfigSchema = S.Struct({
+	plugin: PluginFileUrl,
+	nodeArgs: S.optional(S.Array(S.String)),
+	options: S.optional(S.Record(S.String, S.Unknown))
+});
+const CheckerEntryConfigSchema = CheckerCustomConfigSchema;
+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)]);
+//#endregion
+//#region src/stryker-options.ts
+const isCustomTestRunner = (value) => typeof value !== "string";
+/**
+* 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-plugin-interface/TestRunner") {};
+function testFilesProvided(options) {
+	return options.testFiles !== void 0 && options.testFiles.length > 0;
+}
+//#endregion
 //#region src/TraceContext.ts
 const TRACEPARENT_HEADER = "traceparent";
 const TRACESTATE_HEADER = "tracestate";
@@ -129,4 +692,4 @@ const parseTraceparent = (value) => {
 };
 const TraceContextReference = Context.Reference("@systemfsoftware/stryker-js-plugin-interface/TraceContextReference", { defaultValue: () => Option.none() });
 //#endregion
-export { BoundaryErrorSchema, BoundaryPayloadRejected, BoundaryUnrecognizedSignal, CheckResultSchema, CheckerCheckResult, CheckerFailed, CheckerGroupResult, CheckerRequest, CheckerRpcs, DryRunResultSchema, MutantRunResultSchema, PropagatedTrace, ReporterAck, ReporterDrained, ReporterEventBatch, ReporterEventUnion, ReporterFailed, ReporterInitOptions, ReporterRpcs, TRACEPARENT_HEADER, TRACESTATE_HEADER, TestRunnerCapabilitiesSchema, TestRunnerDryRunRequest, TestRunnerFailed, TestRunnerMutantRunRequest, TestRunnerRpcs, TraceContextMiddleware, TraceContextReference, WorkerEntryUrl, WorkerPluginKind, WorkerPluginSpawnSchema, formatTraceparent, parseTraceparent };
+export { BoundaryErrorSchema, BoundaryPayloadRejected, BoundaryUnrecognizedSignal, BrandingInformationSchema, CheckResultSchema, CheckStatus, Checker, CheckerCheckResult, CheckerCustomConfigSchema, CheckerEntryConfigSchema, CheckerFailed, CheckerGroupResult, CheckerRequest, CheckerRpcs, CommandRunnerOptionsSchema, CoverageAnalysisMode, CoverageAnalysisSchema, DependenciesSchema, DryRunCompleted, DryRunOptionsSchema, DryRunResultSchema, DryRunStatus, EXIT_CODE, Evaluator, EvaluatorFailed, ExitClass, FileResultDictionarySchema, FileResultSchema, FrameworkInformationSchema, LocationSchema, LogLevel, MetricsResultSchema, MetricsSchema, MutantActivationSchema, MutantCoverageSchema, MutantResultSchema, MutantRunOptionsSchema, MutantRunResultSchema, MutantRunStatus, MutantStatusSchema, MutantTested, MutationScoreThresholdsSchema, MutationTestReportReady, MutationTestResultSchema, MutationTestingPlanReady, OpenEndLocationSchema, PackageManager, PluginFileUrl, PositionSchema, PropagatedTrace, RENDERED_OPTION_DEFAULTS, ReportType, ReporterAck, ReporterDrained, ReporterEventBatch, ReporterEventKind, ReporterEventSchema, ReporterEventUnion, ReporterFailed, ReporterInitOptions, ReporterPlanDescriptorSchema, ReporterPlanKind, ReporterRpcs, RunTimingSchema, StrykerOptionsSchema, TRACEPARENT_HEADER, TRACESTATE_HEADER, TestDefinitionSchema, TestFileDefinitionDictionarySchema, TestFileSchema, TestResultSchema, TestRunner, TestRunnerCapabilitiesSchema, TestRunnerConfigSchema, TestRunnerCustomConfigSchema, TestRunnerDryRunRequest, TestRunnerFailed, TestRunnerMutantRunRequest, TestRunnerRpcs, TestStatus, ThresholdsSchema, TraceContextMiddleware, TraceContextReference, WorkerEntryUrl, WorkerPluginKind, WorkerPluginSpawnSchema, formatTraceparent, isCustomTestRunner, parseTraceparent, propertyPath, strykerCoreSchema, strykerReportBugUrl, testFilesProvided, toMutantRunResult };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@systemfsoftware/stryker-js-plugin-interface",
-  "version": "5.0.0",
+  "version": "6.0.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/stryker-js-effect.git",
@@ -19,7 +19,7 @@
   },
   "dependencies": {
     "effect": "4.0.0-rc.112",
-    "@systemfsoftware/stryker-js-language": "^5.0.0"
+    "@systemfsoftware/stryker-js-instrumenter": "^8.0.0"
   },
   "devDependencies": {
     "@effect/tsgo": "^0.45.0",
@@ -36,8 +36,8 @@
     "tsdown": "^0.23.0",
     "typescript": "^7",
     "vitest": "^4",
-    "@systemfsoftware/tsdown-config": "^0.1.0",
-    "@systemfsoftware/vitest-config": "^0.1.0"
+    "@systemfsoftware/vitest-config": "^0.1.0",
+    "@systemfsoftware/tsdown-config": "^0.1.0"
   },
   "publishConfig": {
     "access": "public",