@systemfsoftware/stryker-js 17.0.1 → 22.0.0

package/dist/{merge-config-ruui2TPS.mjs → merge-config-BWQeU3-p.mjs}

@@ -1,17 +1,18 @@
 import * as S from "effect/Schema";
+import { Effect, Schema, SchemaGetter, SchemaIssue, SchemaTransformation } from "effect";
+import * as Arr from "effect/Array";
+import * as Effect$1 from "effect/Effect";
 import * as Option$1 from "effect/Option";
-import * as Order from "effect/Order";
+import * as Order$1 from "effect/Order";
 import * as SchemaGetter$1 from "effect/SchemaGetter";
 import * as SchemaTransformation$1 from "effect/SchemaTransformation";
+import { dual } from "effect/Function";
 import * as Context from "effect/Context";
-import { Effect, Schema, SchemaGetter, SchemaIssue, SchemaTransformation } from "effect";
-import * as Effect$1 from "effect/Effect";
 import * as Boolean$1 from "effect/Boolean";
 import * as Rpc from "effect/rpc/Rpc";
 import * as RpcGroup from "effect/rpc/RpcGroup";
 import * as RpcMiddleware from "effect/rpc/RpcMiddleware";
 import * as Match$1 from "effect/Match";
-import { dual } from "effect/Function";
 import * as Record$1 from "effect/Record";
 import * as Predicate$1 from "effect/Predicate";
 //#region ../stryker-js-plugin-interface/dist/rolldown-runtime-D7D4PA-g.mjs
@@ -27,6 +28,155 @@ var __exportAll = (all, no_symbols) => {
 };
 //#endregion
 //#region ../stryker-js-plugin-interface/dist/index.mjs
+const RULE_IDS = [
+	"arid-logging",
+	"arid-telemetry",
+	"arid-time",
+	"arid-config-default",
+	"arid-memoization",
+	"redundant-relational",
+	"equivalent-to-original",
+	"duplicate-at-site",
+	"ignore-static",
+	"directive",
+	"excluded-mutator",
+	"ignorer",
+	"checker"
+];
+const KEEP_ALL = "To keep these mutants, set `mutator.mutantSetPolicy: 'full'`.";
+const ARID_CALLEE = "The callee must come from an `effect` import under any local name, or be `console` when nothing in scope rebinds or imports it. A call around a function never covers a mutant inside it; a call inside that function still does. The detail names the canonical callee, such as `Effect.logInfo`.";
+const RULE_DOCUMENTATION = {
+	"arid-logging": `The mutant sits in a logging call (console.*, Logger, Effect.log*). ${ARID_CALLEE} ${KEEP_ALL}`,
+	"arid-telemetry": `The mutant sits in a telemetry span, annotation or metric (Effect.withSpan, annotate*, withLogSpan, Metric), or in a non-function argument of \`Effect.fn\` such as the span name and options. ${ARID_CALLEE} ${KEEP_ALL}`,
+	"arid-time": `The mutant sits in a time or schedule value (Duration, Schedule, Effect.sleep). ${ARID_CALLEE} ${KEEP_ALL}`,
+	"arid-config-default": `The mutant sits in a config default (Config.withDefault). ${ARID_CALLEE} ${KEEP_ALL}`,
+	"arid-memoization": `The mutant sits in a memoization wrapper (Effect.cached*). ${ARID_CALLEE} ${KEEP_ALL}`,
+	"redundant-relational": `Another mutant at the same relational operator already covers this one. ${KEEP_ALL}`,
+	"equivalent-to-original": `The mutant behaves exactly like the original code, so no test can kill it. ${KEEP_ALL} With detail \`tce\`, the TypeScript checker compiled it to the original's output; remove that checker from \`checkers\` to keep it.`,
+	"duplicate-at-site": `Another mutant at the same site produces the same code. ${KEEP_ALL} With detail \`tce\`, the TypeScript checker compiled both to the same output; remove that checker from \`checkers\` to keep it.`,
+	"ignore-static": "The mutant is static (it runs once at module load). To keep it, set `ignoreStatic: false`.",
+	directive: "A `// Stryker disable` comment covers the mutant. To keep it, remove or narrow the comment.",
+	"excluded-mutator": "Its mutator is listed in `mutator.excludedMutations`. To keep it, remove it from that list.",
+	ignorer: "An ignorer plugin from `ignorers` removed it; the detail is the plugin's reason, which a plugin with codes of its own starts with `<plugin>/<code>: `. To keep it, remove that plugin or change its rule.",
+	checker: "A checker plugin from `checkers` ignored it. To keep it, remove that plugin or change its rule."
+};
+const SETTLED_CODES_BY_STATUS = {
+	Killed: ["killed", "remembered"],
+	Survived: [
+		"covered-not-killed",
+		"coverage-not-measured",
+		"remembered"
+	],
+	NoCoverage: ["not-covered", "remembered"],
+	Timeout: ["timed-out", "remembered"],
+	RuntimeError: ["runtime-error"],
+	CompileError: ["compile-error", "remembered"]
+};
+const SETTLED_CODES = Arr.dedupe(Object.values(SETTLED_CODES_BY_STATUS).flat());
+const SETTLED_DOCUMENTATION = {
+	"covered-not-killed": "Survived: the tests that cover the mutant ran and none failed. Strengthen an assertion in one of its covering tests.",
+	"coverage-not-measured": "Survived: coverage analysis was off, so every test ran, none failed, and the run cannot name the covering tests. Set `coverageAnalysis: perTest` to learn them.",
+	"not-covered": "NoCoverage: no test executes the mutant's location. Add a test that reaches it.",
+	"timed-out": "Timeout: a test run with the mutant active exceeded its limit; the detail keeps the wall-clock or hit-limit text. A timeout counts as detected.",
+	"runtime-error": "RuntimeError: the test run crashed with the mutant active; the detail is the error message. It is left out of the score.",
+	"compile-error": "CompileError: the mutant does not compile; the detail is the checker's or runner's message. It is left out of the score.",
+	killed: "Killed: a test failed with the mutant active; the detail is the failure message.",
+	remembered: "The status comes from the previous run's report, and the mutant did not run again; the detail names that run's code when it had one. Run with `--full` to run it again. A reused Ignored mutant keeps its rule code instead."
+};
+const RUN_FAILURE_CODES = [
+	"initial-test-run-failed",
+	"config-invalid",
+	"plugin-load-failed",
+	"shard-reports-missing",
+	"shard-reports-overlap",
+	"score-below-break",
+	"new-survivors",
+	"budget-exceeded",
+	"mutation-runs-on-main-ci"
+];
+const RUN_FAILURE_DOCUMENTATION = {
+	"initial-test-run-failed": "The test suite failed before any mutant ran, so no mutant was judged. Fix the failing tests the detail names.",
+	"config-invalid": "The Stryker configuration does not decode; the detail names the option. Fix that option.",
+	"plugin-load-failed": "A plugin did not load; the detail begins with its plugin-load failure reason (a missing, unsupported or unrecognised peer). Install or fix what it names.",
+	"shard-reports-missing": "`stryker merge` lacks a report for a planned shard; the detail names the missing mutants. Re-run the shards that hold them.",
+	"shard-reports-overlap": "`stryker merge` found one mutant in two shard reports; the detail names it. Re-run the shards from one plan.",
+	"score-below-break": "The mutation score fell below `thresholds.break`; the detail gives the score and the threshold. Kill survivors or lower the threshold.",
+	"new-survivors": "`stryker gate` found survivors absent from the committed baseline; the detail lists them. Kill them, or update the baseline when they are accepted.",
+	"budget-exceeded": "The run took longer than the budget baseline allows; the detail gives the actual and allowed seconds. Speed the run up or update the baseline.",
+	"mutation-runs-on-main-ci": "A local mutation run was refused: mutation runs only on main CI. Read its CI report."
+};
+const TOOL_REFUSAL_CODES = [
+	"report-missing",
+	"report-unreadable",
+	"unknown-mutant-id",
+	"cursor-stale",
+	"rerun-refused"
+];
+const TOOL_REFUSAL_DOCUMENTATION = {
+	"report-missing": "The finished mutation report the tool reads does not exist. Run `stryker run` first.",
+	"report-unreadable": "The mutation report does not decode; the detail names the problem. Run `stryker run` to write it again.",
+	"unknown-mutant-id": "No mutant in the report has the id asked for; the detail names it. Ask for an id the report lists.",
+	"cursor-stale": "The page cursor belongs to a different report or filter. Restart paging without a cursor.",
+	"rerun-refused": "The rerun was refused; the detail says why. Fix what it names, then rerun."
+};
+const STABLE_CODE = "A stable code shared by every consumer: renaming or removing one is a breaking change.";
+const IgnoreRuleId = S.Literals(RULE_IDS).mapMembers((members) => members.map((member) => member.annotate({ description: RULE_DOCUMENTATION[member.literal] }))).annotate({ description: `Why an Ignored mutant was removed. ${STABLE_CODE}` });
+const SettledReasonCode = S.Literals(SETTLED_CODES).mapMembers((members) => members.map((member) => member.annotate({ description: SETTLED_DOCUMENTATION[member.literal] }))).annotate({ description: `Why a mutant that was judged has its status. ${STABLE_CODE}` });
+const RunFailureCode = S.Literals(RUN_FAILURE_CODES).mapMembers((members) => members.map((member) => member.annotate({ description: RUN_FAILURE_DOCUMENTATION[member.literal] }))).annotate({ description: `Why a run failed or was refused. ${STABLE_CODE}` });
+const ToolRefusalCode = S.Literals(TOOL_REFUSAL_CODES).mapMembers((members) => members.map((member) => member.annotate({ description: TOOL_REFUSAL_DOCUMENTATION[member.literal] }))).annotate({ description: `Why a CLI or MCP query was refused. ${STABLE_CODE}` });
+const SEPARATOR = ": ";
+const asLiteralPattern = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const reasonPatternOf = (codes) => {
+	const source = `^(?:${codes.map(asLiteralPattern).join("|")})${SEPARATOR}[\\s\\S]*$`;
+	return S.isPattern(new RegExp(source, "u"), { arbitraryConstraint: { patterns: [{
+		source,
+		flags: "u"
+	}] } });
+};
+const malformedReason = (text) => new SchemaIssue.InvalidValue({ message: `expected "<code>${SEPARATOR}<detail>"` }, text);
+const reasonPartsOf = (codes) => {
+	const Parts = S.Struct({
+		code: S.Literals(codes),
+		detail: S.String
+	});
+	const partsOf = (text) => Option$1.map(Option$1.fromNullishOr(codes.find((code) => text.startsWith(code) && text.startsWith(SEPARATOR, code.length))), (code) => ({
+		code,
+		detail: text.slice(code.length + 2)
+	}));
+	return {
+		Parts,
+		transformation: SchemaTransformation.makeTransformation({
+			decode: SchemaGetter.transformEffect((text) => Effect$1.fromOption(partsOf(text), () => malformedReason(text))),
+			encode: SchemaGetter.transform((parts) => `${parts.code}${SEPARATOR}${parts.detail}`)
+		})
+	};
+};
+const IgnoreStatusReasonText = S.String.check(reasonPatternOf(RULE_IDS));
+const IgnoreStatusReason = IgnoreStatusReasonText.pipe(S.decodeTo(S.Struct({
+	code: IgnoreRuleId,
+	detail: S.String
+}), reasonPartsOf(RULE_IDS).transformation));
+const ignoreStatusReasonText = (parts) => `${parts.code}${SEPARATOR}${parts.detail}`;
+const settledVariantOf = (status, codes) => {
+	const admitted = codes;
+	const { Parts, transformation } = reasonPartsOf(admitted);
+	return S.Struct({
+		status: S.Literal(status),
+		statusReason: S.String.check(reasonPatternOf(admitted)).pipe(S.decodeTo(Parts, transformation))
+	});
+};
+const StatusReason = S.Union([
+	S.Struct({
+		status: S.Literal("Ignored"),
+		statusReason: IgnoreStatusReason
+	}),
+	settledVariantOf("Killed", SETTLED_CODES_BY_STATUS.Killed),
+	settledVariantOf("Survived", SETTLED_CODES_BY_STATUS.Survived),
+	settledVariantOf("NoCoverage", SETTLED_CODES_BY_STATUS.NoCoverage),
+	settledVariantOf("Timeout", SETTLED_CODES_BY_STATUS.Timeout),
+	settledVariantOf("RuntimeError", SETTLED_CODES_BY_STATUS.RuntimeError),
+	settledVariantOf("CompileError", SETTLED_CODES_BY_STATUS.CompileError)
+]).pipe(S.toTaggedUnion("status")).annotate({ description: "A mutant status with its reason, `<code>: <detail>` decoded to `{ code, detail }`. Each status admits only its own codes; a Pending mutant has no reason." });
 /** A 1-based line: the first line of a file is line 1. */
 const Line = S.Int.check(S.isGreaterThanOrEqualTo(1));
 /** A 1-based column: the first character of a line is column 1. */
@@ -35,12 +185,12 @@ const Position$1 = S.Struct({
 	line: Line,
 	column: Column
 });
-const positionOrder = Order.combine(Order.mapInput(Order.Number, (position) => position.line), Order.mapInput(Order.Number, (position) => position.column));
+const positionOrder = Order$1.combine(Order$1.mapInput(Order$1.Number, (position) => position.line), Order$1.mapInput(Order$1.Number, (position) => position.column));
 const inOrder = (order) => (ends) => ({
-	start: Order.min(order)(ends.start, ends.end),
-	end: Order.max(order)(ends.start, ends.end)
+	start: Order$1.min(order)(ends.start, ends.end),
+	end: Order$1.max(order)(ends.start, ends.end)
 });
-const notReversed = (order) => (ends) => Order.isLessThanOrEqualTo(order)(ends.start, ends.end);
+const notReversed = (order) => (ends) => Order$1.isLessThanOrEqualTo(order)(ends.start, ends.end);
 const PositionEndsSchema = S.Struct({
 	start: Position$1,
 	end: Position$1
@@ -89,7 +239,8 @@ const RememberedStatusSchema = S.Literals([
 	"Killed",
 	"Timeout",
 	"NoCoverage",
-	"Ignored"
+	"Ignored",
+	"CompileError"
 ]);
 const EphemeralStatusSchema = S.Literals([
 	"CompileError",
@@ -102,6 +253,15 @@ const ActionableStatusSchema = S.Literals([
 	"Timeout",
 	"RuntimeError"
 ]);
+const SettledStatusSchema = MutantStatusSchema.pick([
+	"Killed",
+	"Survived",
+	"NoCoverage",
+	"CompileError",
+	"RuntimeError",
+	"Timeout",
+	"Pending"
+]);
 const MutantId = S.String.check(S.isPattern(/^[0-9a-f]{16}$/u, { expected: "a 16-character lowercase hexadecimal mutant id" })).pipe(S.brand("MutantId"));
 const MutatorNameGrammar = S.String.check(S.isPattern(/^(?:[a-z][a-z0-9]*(?:-[a-z0-9]+)*\/)?[A-Z][A-Za-z0-9]*$/u, { expected: "a PascalCase mutator name, optionally prefixed by a lowercase kebab-case namespace and a slash" }));
 const MutatorName = MutatorNameGrammar.pipe(S.brand("MutatorName"));
@@ -109,6 +269,67 @@ const CanonicalFileName = S.String.pipe(S.decodeTo(S.String.pipe(S.check(S.isPat
 	decode: SchemaGetter$1.transform((fileName) => fileName.replace(/\\/g, "/")),
 	encode: SchemaGetter$1.transform((canonical) => canonical)
 }));
+const Subsumed = S.TaggedStruct("Subsumed", {
+	rule: S.Literals(["complement"]),
+	dominators: S.NonEmptyArray(MutantId)
+});
+const subsumedStatusReason = (subsumed) => ignoreStatusReasonText({
+	code: "redundant-relational",
+	detail: `subsumed by ${subsumed.dominators[0]} (${subsumed.rule}): every test that kills ${subsumed.dominators[0]} kills this mutant, so act on ${subsumed.dominators[0]}, or set mutator.mutantSetPolicy 'full' to run it`
+});
+/**
+* Why a subsumed mutant ran after all: none of its dominators ran, and each
+* cause names one dominator and why it did not run, in `dominators` order.
+*/
+const ReadmitCauseCode = S.Literals([
+	"dominator-ignored-at-check",
+	"dominator-compile-error",
+	"dominator-ignored-at-plan",
+	"dominator-remembered-without-running",
+	"dominator-unsettled"
+]);
+const Readmitted = S.TaggedStruct("Readmitted", {
+	rule: Subsumed.fields.rule,
+	causes: S.NonEmptyArray(S.Struct({
+		dominator: MutantId,
+		code: ReadmitCauseCode,
+		detail: S.String
+	}))
+});
+const Subsumption = S.Union([Subsumed, Readmitted]);
+const ProbeKind = S.Literals([
+	"arithmetic",
+	"relational",
+	"unary",
+	"constant"
+]);
+const Probed = S.TaggedStruct("Probed", { kind: ProbeKind });
+/**
+* Why a mutant carries no probe and runs exactly as it would without one:
+* - `mutator-not-probed`: its mutator is outside the probed set.
+* - `operator-not-probed`: its mutator is probed, but not for this original operator.
+* - `every-reach-infects`: an `==`/`!=`/`===`/`!==` swap changes the value on every evaluation.
+* - `not-a-comparison`: a constant replacement of an expression that is not a comparison.
+* - `operand-not-proven-local`: a constant replacement of a comparison whose operand may run user code.
+* - `shape-not-recognized`: the original and replacement nodes do not have the probed form.
+* - `not-decided`: the mutant was built or decoded without an eligibility decision.
+*/
+const UnprobedReason = S.Literals([
+	"mutator-not-probed",
+	"operator-not-probed",
+	"every-reach-infects",
+	"not-a-comparison",
+	"operand-not-proven-local",
+	"shape-not-recognized",
+	"not-decided"
+]);
+const Unprobed = S.TaggedStruct("Unprobed", { reason: UnprobedReason });
+const ProbeEligibility = S.Union([Probed, Unprobed]);
+const NOT_DECIDED = {
+	_tag: "Unprobed",
+	reason: "not-decided"
+};
+const subsumptionMatchesStatus = dual(2, (subsumption, status) => S.is(Subsumed)(subsumption) ? status === "Ignored" : status !== "Ignored");
 /**
 * A mutant's file location in the mutation-testing-report-schema contract:
 * 1-based line and 1-based column, the same base the JSON report and the
@@ -126,8 +347,10 @@ const Mutant = S.TaggedStruct("Mutant", {
 	coveredBy: S.String.pipe(S.Array, S.optional),
 	static: S.optional(S.Boolean),
 	testsCompleted: S.optional(S.Finite),
-	description: S.optional(S.String)
-}).check(S.makeFilter((mutant) => mutant.statusReason === void 0 || mutant.status !== void 0, { message: "a mutant carries a status reason only together with a status" }));
+	description: S.optional(S.String),
+	subsumption: S.optional(Subsumption),
+	probeEligibility: ProbeEligibility.pipe(S.withConstructorDefault(Effect$1.succeed(NOT_DECIDED)), S.withDecodingDefaultKey(Effect$1.succeed(NOT_DECIDED)))
+}).check(S.makeFilter((mutant) => mutant.statusReason === void 0 || mutant.status !== void 0, { message: "a mutant carries a status reason only together with a status" }), S.makeFilter((mutant) => mutant.subsumption === void 0 || subsumptionMatchesStatus(mutant.subsumption, mutant.status), { message: "a Subsumed mutant is Ignored, and a Readmitted mutant is not Ignored" }));
 const MutantFromUnknown = S.Unknown.pipe(S.decodeTo(Mutant));
 const RunOptionsFields = {
 	timeout: S.Finite.pipe(S.check(S.isGreaterThanOrEqualTo(0))),
@@ -172,6 +395,14 @@ const CheckerMutantWire = S.Struct({
 	replacement: S.String,
 	location: Location$1
 });
+/**
+* The digest of the TypeScript program a checker loaded: SHA-256 over the sorted
+* hashes of every source file in the program (lib and node_modules declarations
+* included), every tsconfig in its chain, the TypeScript version, the checker
+* plugin version, and the checker's options. A `CompileError` verdict is reusable
+* only when two runs' digests are byte-equal, so a missing digest is never a match.
+*/
+const ProgramDigest = S.String.check(S.isPattern(/^[0-9a-f]{64}$/u, { expected: "a 64-character lowercase hexadecimal program digest" })).pipe(S.brand("ProgramDigest"));
 const CheckResultSchema = S.Union([
 	S.Struct({ status: S.Literal("passed") }),
 	S.Struct({
@@ -180,7 +411,18 @@ const CheckResultSchema = S.Union([
 	}),
 	S.Struct({
 		status: S.Literal("ignored"),
+		reason: IgnoreStatusReasonText
+	})
+]).pipe(S.toTaggedUnion("status"));
+const CheckAnswerSchema = S.Union([
+	S.Struct({ status: S.Literal("passed") }),
+	S.Struct({
+		status: S.Literal("compileError"),
 		reason: S.String
+	}),
+	S.Struct({
+		status: S.Literal("ignored"),
+		reason: S.optional(S.Unknown)
 	})
 ]).pipe(S.toTaggedUnion("status"));
 const CheckStatus = S.Literals(CheckResultSchema.discriminants);
@@ -196,51 +438,16 @@ var CheckerFailed = class extends S.TaggedError()("CheckerFailed", {
 };
 var Checker = class extends Context.Service()("@systemfsoftware/stryker-js-plugin-interface/Checker.service/Checker") {};
 var Checker_exports = /* @__PURE__ */ __exportAll({
+	CheckAnswerSchema: () => CheckAnswerSchema,
 	CheckResultSchema: () => CheckResultSchema,
 	CheckStatus: () => CheckStatus,
 	Checker: () => Checker,
 	CheckerFailed: () => CheckerFailed,
-	CheckerMutantWire: () => CheckerMutantWire
+	CheckerMutantWire: () => CheckerMutantWire,
+	ProgramDigest: () => ProgramDigest
 });
 S.TaggedError()("EvaluatorFailed", { cause: S.Unknown });
 Context.Service()("@systemfsoftware/stryker-js-plugin-interface/Evaluator.service/Evaluator");
-const RULE_IDS = [
-	"arid-logging",
-	"arid-telemetry",
-	"arid-time",
-	"arid-config-default",
-	"arid-memoization",
-	"redundant-relational",
-	"equivalent-to-original",
-	"duplicate-at-site",
-	"ignore-static",
-	"directive",
-	"excluded-mutator",
-	"ignorer"
-];
-const IgnoreRuleId = S.Literals(RULE_IDS);
-const SEPARATOR = ": ";
-const asLiteralPattern = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-const REASON_SOURCE = `^(?:${RULE_IDS.map(asLiteralPattern).join("|")})${SEPARATOR}[\\s\\S]*$`;
-const IgnoreStatusReasonText = S.String.check(S.isPattern(new RegExp(REASON_SOURCE, "u"), { arbitraryConstraint: { patterns: [{
-	source: REASON_SOURCE,
-	flags: "u"
-}] } }));
-const ReasonPartsSchema = S.Struct({
-	ruleId: IgnoreRuleId,
-	detail: S.String
-});
-const reasonPartsOf = (text) => Option$1.map(Option$1.fromNullishOr(RULE_IDS.find((ruleId) => text.startsWith(`${ruleId}${SEPARATOR}`))), (ruleId) => ({
-	ruleId,
-	detail: text.slice(ruleId.length + 2)
-}));
-const malformedReason = (text) => new SchemaIssue.InvalidValue({ message: `expected "<rule-id>${SEPARATOR}<detail>"` }, text);
-const partsOf$1 = SchemaGetter.transformEffect((text) => Effect$1.fromOption(reasonPartsOf(text), () => malformedReason(text)));
-const textOf$1 = SchemaGetter.transform((parts) => `${parts.ruleId}${SEPARATOR}${parts.detail}`);
-const IgnoreStatusReason = IgnoreStatusReasonText.pipe(S.decodeTo(ReasonPartsSchema, SchemaTransformation.makeTransformation({
-	decode: partsOf$1,
-	encode: textOf$1
-})));
 const Id = S.String.check(S.isPattern(/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u, { expected: "a lowercase kebab-case catalog entry id" })).pipe(S.brand("MutatorCatalogId"));
 const Tier = S.Literals(["default", "optIn"]);
 const Definition = S.NonEmptyString;
@@ -312,12 +519,28 @@ var Mutant_exports = /* @__PURE__ */ __exportAll({
 	MutatorName: () => MutatorName,
 	OpenEndLocation: () => OpenEndLocation$1,
 	Position: () => Position$1,
+	ProbeEligibility: () => ProbeEligibility,
+	ProbeKind: () => ProbeKind,
+	Probed: () => Probed,
+	ReadmitCauseCode: () => ReadmitCauseCode,
+	Readmitted: () => Readmitted,
 	RememberedStatusSchema: () => RememberedStatusSchema,
+	RunFailureCode: () => RunFailureCode,
 	RunOptionsFields: () => RunOptionsFields,
+	SettledReasonCode: () => SettledReasonCode,
+	SettledStatusSchema: () => SettledStatusSchema,
+	StatusReason: () => StatusReason,
+	Subsumed: () => Subsumed,
+	Subsumption: () => Subsumption,
 	SurvivorStatusSchema: () => SurvivorStatusSchema,
+	ToolRefusalCode: () => ToolRefusalCode,
+	Unprobed: () => Unprobed,
+	UnprobedReason: () => UnprobedReason,
 	duplicatedValue: () => duplicatedValue,
 	inOrder: () => inOrder,
-	notReversed: () => notReversed
+	notReversed: () => notReversed,
+	subsumedStatusReason: () => subsumedStatusReason,
+	subsumptionMatchesStatus: () => subsumptionMatchesStatus
 });
 var MutatorCatalog_exports = /* @__PURE__ */ __exportAll({
 	Catalog: () => Catalog,
@@ -728,7 +951,7 @@ const Thresholds = S.StructWithRest(S.Struct({
 		"description": "Lower bound threshold.",
 		"examples": [60]
 	}).check(S.isInt().annotate({ "expected": "an integer" })).check(S.isGreaterThanOrEqualTo(0).annotate({ "expected": "a value greater than or equal to 0" })).check(S.isLessThanOrEqualTo(100).annotate({ "expected": "a value less than or equal to 100" })),
-	"break": S.optionalKey(S.Union([S.Finite.check(S.isFinite().annotate({ "expected": "a finite number" })).check(S.isGreaterThanOrEqualTo(0).annotate({ "expected": "a value greater than or equal to 0" })).check(S.isLessThanOrEqualTo(100).annotate({ "expected": "a value less than or equal to 100" })), S.Null]).annotate({ "description": "The mutation score below which the run breaks. Null disables the break." }))
+	"break": S.optionalKey(S.Union([S.Finite.check(S.isGreaterThanOrEqualTo(0).annotate({ "expected": "a value greater than or equal to 0" })).check(S.isLessThanOrEqualTo(100).annotate({ "expected": "a value less than or equal to 100" })), S.Null]).annotate({ "description": "The mutation score below which the run breaks. Null disables the break." }))
 }), [S.Record(S.String, S.Json.annotate({ "expected": "JSON value" }))]).annotate({
 	"title": "Thresholds",
 	"description": "Thresholds for the status of the reported application.",
@@ -782,7 +1005,7 @@ const OSInformation = S.StructWithRest(S.Struct({
 });
 const CpuInformation = S.StructWithRest(S.Struct({
 	"baseClock": S.optionalKey(S.Finite.annotate({ "description": "Clock speed in MHz" }).check(S.isFinite().annotate({ "expected": "a finite number" }))),
-	"logicalCores": S.Finite.check(S.isFinite().annotate({ "expected": "a finite number" })),
+	"logicalCores": S.Finite,
 	"model": S.optionalKey(S.String.annotate({ "examples": ["Intel(R) Core(TM) i9-9880H CPU @ 2.30GHz"] }))
 }), [S.Record(S.String, S.Json.annotate({ "expected": "JSON value" }))]).annotate({
 	"title": "CpuInformation",
@@ -936,7 +1159,7 @@ const MutationTestResult = S.StructWithRest(S.Struct({
 			"2.0",
 			"2.0.0"
 		]
-	}).check(S.isPattern(/* @__PURE__ */ new RegExp("^([1-2])(\\.(([1-9]\\d*)|0)){0,2}$", "u")).annotate({ "expected": "a string matching the RegExp ^([1-2])(\\.(([1-9]\\d*)|0)){0,2}$" })),
+	}).check(S.isPattern(new globalThis.RegExp("^([1-2])(\\.(([1-9]\\d*)|0)){0,2}$", "u")).annotate({ "expected": "a string matching the RegExp ^([1-2])(\\.(([1-9]\\d*)|0)){0,2}$" })),
 	"files": FileResultDictionary,
 	"testFiles": S.optionalKey(TestFileDefinitionDictionary),
 	"thresholds": Thresholds,
@@ -995,7 +1218,8 @@ const DryRunResultSchema = S.Union([
 		status: S.Literal("complete"),
 		tests: S.Array(TestResultSchema),
 		mutantCoverage: S.optionalKey(MutantCoverageSchema),
-		globalTestInputs: S.String.pipe(S.Array, S.optionalKey)
+		globalTestInputs: S.String.pipe(S.Array, S.optionalKey),
+		testFileModules: S.optionalKey(S.Record(S.String, S.String.pipe(S.Array)))
 	}),
 	S.Struct({
 		status: S.Literal("timeout"),
@@ -1198,8 +1422,9 @@ const CheckerRequest = S.Struct({
 	checkerName: S.String,
 	mutants: S.Array(CheckerMutantWire)
 });
-const CheckerCheckResult = S.Record(S.String, CheckResultSchema);
+const CheckerCheckResult = S.Record(S.String, CheckAnswerSchema);
 const CheckerGroupResult = S.String.pipe(S.Array, S.Array);
+const CheckerDigestRequest = S.Struct({ checkerName: S.String });
 const ReporterInitOptions = S.Struct({
 	traceparent: S.optionalKey(Traceparent),
 	tracestate: S.optionalKey(Tracestate)
@@ -1239,6 +1464,112 @@ const WorkerPluginSpawnSchema = S.Struct({
 });
 var PropagatedTrace = class extends Context.Service()("@systemfsoftware/stryker-js-plugin-interface/TraceContextRpc.service/PropagatedTrace") {};
 var TraceContextMiddleware = class extends RpcMiddleware.Service()("@systemfsoftware/stryker-js-plugin-interface/TraceContextMiddleware", { requiredForClient: true }) {};
+const TypeQueryVersion = S.Literals([1, 2]);
+const TypeQueryCandidate = S.Struct({
+	candidateId: S.String,
+	text: S.String
+});
+const TypeQuerySiteKind = S.Literals(["expression", "function-body"]);
+const TypeQuerySite = S.Struct({
+	siteId: S.String,
+	kind: TypeQuerySiteKind,
+	location: Location$1,
+	candidates: S.Array(TypeQueryCandidate)
+});
+const TypeQueryFile = S.Struct({
+	fileName: S.String,
+	content: S.String,
+	sites: S.Array(TypeQuerySite)
+});
+const TypeQueryRequest = S.Struct({
+	version: S.Int,
+	tsconfigFile: S.String,
+	files: S.NonEmptyArray(TypeQueryFile)
+});
+const UnknownReason = S.Literals([
+	"candidate-not-context-free",
+	"candidate-not-found",
+	"site-not-found",
+	"site-not-expression",
+	"no-contextual-type",
+	"error-type",
+	"instantiable-target",
+	"overloaded-or-generic-call",
+	"context-not-enforced",
+	"site-not-function-body",
+	"candidate-not-empty-body",
+	"return-type-not-declared",
+	"generator-body",
+	"constructor-body",
+	"getter-requires-return",
+	"implicit-return-rejected",
+	"async-return-not-promise"
+]);
+const TypeAnswerTypeId = Symbol.for("@systemfsoftware/stryker-js-plugin-interface/TypeAnswer");
+var Assignable = class extends S.TaggedClass()("Assignable", { candidateType: S.String }) {
+	[TypeAnswerTypeId] = TypeAnswerTypeId;
+};
+var NotAssignable = class extends S.TaggedClass()("NotAssignable", {
+	candidateType: S.String,
+	contextualType: S.String
+}) {
+	[TypeAnswerTypeId] = TypeAnswerTypeId;
+};
+var Unknown = class extends S.TaggedClass()("Unknown", { reason: UnknownReason }) {
+	[TypeAnswerTypeId] = TypeAnswerTypeId;
+};
+const TypeAnswer = S.Union([
+	Assignable,
+	NotAssignable,
+	Unknown
+]);
+const CandidateAnswer = S.Struct({
+	candidateId: S.String,
+	answer: TypeAnswer
+});
+const SiteAnswer = S.Struct({
+	siteId: S.String,
+	siteType: S.OptionFromNullOr(S.String),
+	contextualType: S.OptionFromNullOr(S.String),
+	candidates: S.Array(CandidateAnswer)
+});
+const FileAnswered = S.TaggedStruct("FileAnswered", {
+	fileName: S.String,
+	sites: S.Array(SiteAnswer)
+});
+const FileRefusedReason = S.Literals([
+	"not-in-project",
+	"server-crashed",
+	"query-timed-out"
+]);
+const FileRefused = S.TaggedStruct("FileRefused", {
+	fileName: S.String,
+	reason: FileRefusedReason,
+	nextAction: S.String
+});
+const FileOutcome = S.Union([FileAnswered, FileRefused]);
+const TypeQueryResponse = S.Struct({
+	version: TypeQueryVersion,
+	files: S.Array(FileOutcome)
+});
+const TypeQueryRefusedReason = S.Literals(["unsupported-version", "project-open-failed"]);
+var TypeQueryRefused = class extends S.TaggedError()("TypeQueryRefused", {
+	version: S.Int,
+	reason: TypeQueryRefusedReason,
+	nextAction: S.String
+}) {
+	get message() {
+		return `${this.reason}: ${this.nextAction}`;
+	}
+};
+const CheckerCapabilities = S.Struct({ typeQuery: S.Array(S.Int) });
+const TypeQueryServed = S.TaggedStruct("TypeQueryServed", { version: TypeQueryVersion });
+const TypeQueryNotServed = S.TaggedStruct("TypeQueryNotServed", {
+	version: TypeQueryVersion,
+	declared: S.Array(S.Int),
+	nextAction: S.String
+});
+S.Union([TypeQueryServed, TypeQueryNotServed]);
 const capabilities = Rpc.make("capabilities", {
 	success: TestRunnerCapabilitiesSchema,
 	error: TestRunnerFailed
@@ -1264,6 +1595,21 @@ const group = Rpc.make("group", {
 	success: CheckerGroupResult,
 	error: CheckerFailed
 }).middleware(TraceContextMiddleware);
+const digest = Rpc.make("digest", {
+	payload: CheckerDigestRequest,
+	success: ProgramDigest,
+	error: CheckerFailed
+}).middleware(TraceContextMiddleware);
+const checkerCapabilities = Rpc.make("capabilities", {
+	payload: CheckerDigestRequest,
+	success: CheckerCapabilities,
+	error: CheckerFailed
+}).middleware(TraceContextMiddleware);
+const typeQuery = Rpc.make("typeQuery", {
+	payload: TypeQueryRequest,
+	success: TypeQueryResponse,
+	error: TypeQueryRefused
+}).middleware(TraceContextMiddleware);
 const init = Rpc.make("init", {
 	payload: ReporterInitOptions,
 	success: ReporterAck,
@@ -1279,13 +1625,14 @@ const flush = Rpc.make("flush", {
 	error: ReporterFailed
 }).middleware(TraceContextMiddleware);
 const TestRunnerRpcs = RpcGroup.make(capabilities, dryRun, mutantRun);
-const CheckerRpcs = RpcGroup.make(check, group);
+const CheckerRpcs = RpcGroup.make(check, group, digest, checkerCapabilities, typeQuery);
 const ReporterRpcs = RpcGroup.make(init, onEventBatch, flush);
 var Plugin_exports = /* @__PURE__ */ __exportAll({
 	BoundaryErrorSchema: () => BoundaryErrorSchema,
 	BoundaryPayloadRejected: () => BoundaryPayloadRejected,
 	BoundaryUnrecognizedSignal: () => BoundaryUnrecognizedSignal,
 	CheckerCheckResult: () => CheckerCheckResult,
+	CheckerDigestRequest: () => CheckerDigestRequest,
 	CheckerGroupResult: () => CheckerGroupResult,
 	CheckerRequest: () => CheckerRequest,
 	CheckerRpcs: () => CheckerRpcs,
@@ -1427,6 +1774,16 @@ var Trace_exports = /* @__PURE__ */ __exportAll({
 	Tracestate: () => Tracestate,
 	TracestateHeader: () => TracestateHeader
 });
+const notServed = (capabilities, version) => TypeQueryNotServed.make({
+	version,
+	declared: capabilities.typeQuery,
+	nextAction: `Keep every mutant: this checker declares type-query versions [${capabilities.typeQuery.join(", ")}], not ${version}. Use a checker that declares version ${version}, or send a version it declares.`
+});
+dual(2, (capabilities, version) => Boolean$1.match(Arr.contains(capabilities.typeQuery, version), {
+	onTrue: () => TypeQueryServed.make({ version }),
+	onFalse: () => notServed(capabilities, version)
+}));
+Context.Service()("@systemfsoftware/stryker-js-plugin-interface/TypeQuery.service/TypeQuery");
 //#endregion
 //#region src/config/merge-config.ts
 /**

package/dist/{merge-config-52qu-jD7.d.mts → merge-config-D0F1cI43.d.mts}

@@ -1,4 +1,4 @@
-import { i as mod_d_exports$5 } from "./index-y-Pg3XgT.mjs";
+import { i as mod_d_exports$5 } from "./index-ClWSuUog.mjs";
 import * as S from "effect/Schema";
 //#region src/config/stryker-config.schema.d.ts
 type StrykerConfig = mod_d_exports$5.PartialStrykerOptions;

package/dist/promises.d.mts

@@ -1,5 +1,5 @@
-import { i as mod_d_exports$5 } from "./index-y-Pg3XgT.mjs";
-import { l as MutationTestDone } from "./RunEnvironment.service-Cluh-Bxt.mjs";
-//#region src/drivers/promise.d.ts
+import { i as mod_d_exports$5 } from "./index-ClWSuUog.mjs";
+import { d as MutationTestDone } from "./RunEnvironment.service-D4so1HnE.mjs";
+//#region src/promises/run.d.ts
 export declare const run: ((targetMutatePatterns?: readonly string[]) => (options: mod_d_exports$5.PartialStrykerOptions) => Promise<MutationTestDone>) & ((options: mod_d_exports$5.PartialStrykerOptions, targetMutatePatterns?: readonly string[]) => Promise<MutationTestDone>);
 //#endregion

package/dist/promises.mjs

@@ -1,7 +1,7 @@
-import { C as nodePlatformLayer, t as strykerCell } from "./run-stages-CpYiJ2Mz.mjs";
+import { B as nodePlatformLayer, t as strykerCell } from "./run-stages-BnFibYAg.mjs";
 import * as Effect from "effect/Effect";
 import { dual } from "effect/Function";
-//#region src/drivers/promise.ts
+//#region src/promises/run.ts
 const run = dual((args) => args.length === 2 || Array.isArray(args[0]) === false, (options, targetMutatePatterns) => Effect.runPromise(strykerCell(options, targetMutatePatterns).pipe(Effect.provide(nodePlatformLayer))));
 //#endregion
 export { run };