@systemfsoftware/stryker-js-instrumenter 10.0.0 → 11.0.0

package/dist/index.mjs

@@ -8,10 +8,14 @@ import * as S from "effect/Schema";
 import * as Effect from "effect/Effect";
 import { dual } from "effect/Function";
 import { Handle, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
-import * as Order from "effect/Order";
-import * as SchemaGetter from "effect/SchemaGetter";
+import { Mutant, Options } from "@systemfsoftware/stryker-js-plugin-interface";
 import { RegExpParser, visitRegExpAST } from "@eslint-community/regexpp";
 import * as Arr from "effect/Array";
+import * as Order from "effect/Order";
+import * as SchemaGetter from "effect/SchemaGetter";
+import { SpanTaxonomy } from "@systemfsoftware/stryker-js-cli-contract";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils.js";
 //#region src/ErrorText.schema.ts
 var ErrorText = class extends S.Class("ErrorText")({ text: S.NonEmptyString }) {};
 var CauseText = class extends S.Class("CauseText")({ text: S.NonEmptyString }) {};
@@ -106,70 +110,8 @@ var ErrorText_exports = /* @__PURE__ */ __exportAll({
 	errorTextOf: () => errorTextOf$2
 });
 //#endregion
-//#region src/Location.schema.ts
-const Offset = S.Int.check(S.isGreaterThanOrEqualTo(0));
-/** A 1-based line: the first line of a file is line 1. */
-const Line = S.Int.check(S.isGreaterThanOrEqualTo(1));
-/** A 1-based column: the first character of a line is column 1. */
-const Column = S.Int.check(S.isGreaterThanOrEqualTo(1));
-const Position = S.Struct({
-	line: Line,
-	column: Column
-});
-const positionOrder = Order.combine(Order.mapInput(Order.Number, (position) => position.line), Order.mapInput(Order.Number, (position) => position.column));
-const inOrder = (order) => (ends) => ({
-	start: Order.min(order)(ends.start, ends.end),
-	end: Order.max(order)(ends.start, ends.end)
-});
-const notReversed = (order) => (ends) => Order.isLessThanOrEqualTo(order)(ends.start, ends.end);
-const PositionEnds = S.Struct({
-	start: Position,
-	end: Position
-});
-const Location = S.declare((value) => S.is(PositionEnds)(value) && notReversed(positionOrder)(value), {
-	expected: "a location whose end is not before its start",
-	toCodecArbitrary: () => S.link()(PositionEnds, {
-		decode: SchemaGetter.transform(inOrder(positionOrder)),
-		encode: SchemaGetter.transform((ends) => ends)
-	})
-});
-const OpenEnds = S.Struct({
-	start: Position,
-	end: S.optional(Position)
-});
-const closedEnds = (ends) => Option.map(Option.fromUndefinedOr(ends.end), (end) => ({
-	start: ends.start,
-	end
-}));
-const OpenEndLocation = S.declare((value) => S.is(OpenEnds)(value) && Option.match(closedEnds(value), {
-	onNone: () => true,
-	onSome: notReversed(positionOrder)
-}), {
-	expected: "a location whose end, when present, is not before its start",
-	toCodecArbitrary: () => S.link()(OpenEnds, {
-		decode: SchemaGetter.transform((ends) => Option.getOrElse(Option.map(closedEnds(ends), inOrder(positionOrder)), () => ends)),
-		encode: SchemaGetter.transform((ends) => ends)
-	})
-});
-const OffsetEnds = S.Struct({
-	start: Offset,
-	end: Offset
-});
-const Span = S.declare((value) => S.is(OffsetEnds)(value) && notReversed(Order.Number)(value), {
-	expected: "a span whose end is not before its start",
-	toCodecArbitrary: () => S.link()(OffsetEnds, {
-		decode: SchemaGetter.transform(inOrder(Order.Number)),
-		encode: SchemaGetter.transform((ends) => ends)
-	})
-});
-const ScriptOrigin = S.Struct({
-	line: Line,
-	columnShift: Offset
-});
-S.is(Offset), S.is(Line), S.is(Column), S.is(Location), S.is(Span);
-//#endregion
 //#region src/directives/directive.schema.ts
-const MutatorNameSchema = S.String.pipe(S.check(S.isPattern(/^[a-zA-Z]+(?: [a-zA-Z]+)*$/)));
+const MutatorNameSchema = S.String.pipe(S.check(S.isPattern(/^(?:[a-z][a-z0-9]*(?:-[a-z0-9]+)*\/)?[a-zA-Z][a-zA-Z0-9]*(?: [a-zA-Z][a-zA-Z0-9]*)*$/)));
 const DirectiveReasonSchema = S.String.pipe(S.check(S.isPattern(/^\S(?:[^\r\n\u2028\u2029]*\S)?$/)));
 const DirectiveSchema = S.Struct({
 	action: S.Literals(["disable", "restore"]),
@@ -179,106 +121,15 @@ const DirectiveSchema = S.Struct({
 });
 const LocatedDirectiveSchema = S.Struct({
 	directive: DirectiveSchema,
-	at: Position,
-	governedLine: Line
+	at: Mutant.Position,
+	governedLine: Mutant.Line
 });
 S.Struct({
 	directive: DirectiveSchema,
-	at: Position,
+	at: Mutant.Position,
 	mutatorName: MutatorNameSchema
 });
 //#endregion
-//#region src/Mutant.schema.ts
-const MutantStatusSchema = S.Literals([
-	"Killed",
-	"Survived",
-	"NoCoverage",
-	"CompileError",
-	"RuntimeError",
-	"Timeout",
-	"Ignored",
-	"Pending"
-]);
-const SurvivorStatusSchema = S.Literals(["Survived", "NoCoverage"]);
-const RememberedStatusSchema = S.Literals([
-	"Survived",
-	"Killed",
-	"Timeout",
-	"NoCoverage",
-	"Ignored"
-]);
-const EphemeralStatusSchema = S.Literals([
-	"CompileError",
-	"RuntimeError",
-	"Pending"
-]);
-const ActionableStatusSchema = S.Literals([
-	"Survived",
-	"NoCoverage",
-	"Timeout",
-	"RuntimeError"
-]);
-const MutantId = S.String.check(S.isPattern(/^(0|[1-9][0-9]*)$/)).pipe(S.brand("MutantId"));
-const MutatorName = S.NonEmptyString.pipe(S.brand("MutatorName"));
-const CanonicalFileName = S.String.pipe(S.decodeTo(S.String.pipe(S.check(S.isPattern(/^[^\\]+$/)), S.brand("CanonicalFileName")), {
-	decode: SchemaGetter.transform((fileName) => fileName.replace(/\\/g, "/")),
-	encode: SchemaGetter.transform((canonical) => canonical)
-}));
-/**
-* A mutant's file location in the mutation-testing-report-schema contract:
-* 1-based line and 1-based column, the same base the JSON report and the
-* machine stream emit. Every producer on the instrument path (node spans,
-* embedded-region shifts) targets this base; no downstream layer converts.
-*/
-const Mutant = S.TaggedStruct("Mutant", {
-	id: MutantId,
-	fileName: CanonicalFileName,
-	mutatorName: MutatorName,
-	replacement: S.String,
-	location: Location,
-	status: S.optional(MutantStatusSchema),
-	statusReason: S.optional(S.String),
-	coveredBy: S.String.pipe(S.Array, S.optional),
-	static: S.optional(S.Boolean),
-	testsCompleted: S.optional(S.Finite),
-	description: S.optional(S.String)
-}).check(S.makeFilter((mutant) => mutant.statusReason === void 0 || mutant.status !== void 0, { message: "a mutant carries a status reason only together with a status" }));
-const MutantFromUnknown = S.Unknown.pipe(S.decodeTo(Mutant));
-const RunOptionsFields = {
-	timeout: S.Finite.pipe(S.check(S.isGreaterThanOrEqualTo(0))),
-	disableBail: S.Boolean
-};
-const MutantActivationSchema = S.Literals(["runtime", "static"]);
-const HitCount = S.Int.pipe(S.check(S.isGreaterThanOrEqualTo(0)));
-const MutantRunOptionsSchema = S.Struct({
-	...RunOptionsFields,
-	activeMutant: Mutant,
-	sandboxFileName: S.String,
-	mutantActivation: MutantActivationSchema,
-	reloadEnvironment: S.Boolean,
-	testFilter: S.String.pipe(S.Array, S.optionalKey),
-	hitLimit: S.optionalKey(HitCount)
-});
-const MutantCoverageSchema = S.Struct({
-	perTest: S.Record(S.String, S.Record(MutantId, HitCount)),
-	static: S.Record(MutantId, HitCount)
-});
-var InstrumenterContext = class extends S.Class("InstrumenterContext")({
-	activeMutant: S.optional(S.String),
-	currentTestId: S.optional(S.String),
-	mutantCoverage: S.optional(MutantCoverageSchema),
-	hitCount: S.optional(HitCount),
-	hitLimit: S.optional(HitCount)
-}) {
-	static NAMESPACE = "__stryker__";
-	static MUTATION_COVERAGE_OBJECT = "mutantCoverage";
-	static ACTIVE_MUTANT = "activeMutant";
-	static CURRENT_TEST_ID = "currentTestId";
-	static HIT_COUNT = "hitCount";
-	static HIT_LIMIT = "hitLimit";
-	static ACTIVE_MUTANT_ENV_VARIABLE = "__STRYKER_ACTIVE_MUTANT__";
-};
-//#endregion
 //#region src/Instrument.schema.ts
 var InstrumentError = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/Instrument.schema/InstrumentError")("InstrumentError", {
 	message: S.String,
@@ -291,9 +142,9 @@ var InstrumentError = class extends S.TaggedError("@systemfsoftware/stryker-js-i
 		});
 	}
 };
-const MutateDescriptionSchema = S.Union([S.Boolean, S.Array(Location)]);
+const MutateDescriptionSchema = S.Union([S.Boolean, S.Array(Mutant.Location)]);
 const FileSchema = S.Struct({
-	name: CanonicalFileName,
+	name: Mutant.CanonicalFileName,
 	content: S.String,
 	mutate: MutateDescriptionSchema
 });
@@ -301,8 +152,9 @@ const IgnorerSchema = S.Unknown;
 S.Struct({
 	excludedMutations: S.Array(MutatorNameSchema),
 	ignorers: S.Array(IgnorerSchema),
-	noHeader: S.optional(S.Boolean),
-	optInMutations: S.String.pipe(S.Array, S.optional)
+	mutators: S.Unknown,
+	mutantSetPolicy: Options.MutantSetPolicy,
+	noHeader: S.optional(S.Boolean)
 });
 var InstrumentFileSkip = class extends S.TaggedClass()("InstrumentFileSkip", {
 	file: S.String,
@@ -318,7 +170,7 @@ var InstrumentFilesCommand = class extends S.TaggedClass()("InstrumentFilesComma
 };
 var InstrumentResult = class extends S.TaggedClass()("InstrumentResult", {
 	files: S.Array(FileSchema),
-	mutants: S.Array(Mutant),
+	mutants: S.Array(Mutant.Mutant),
 	skipped: S.Array(InstrumentFileSkip)
 }) {};
 const PlacerNameSchema = S.Literals([
@@ -331,18 +183,96 @@ var MutantsUnapplied = class extends S.TaggedError()("MutantsUnapplied", {
 	placer: PlacerNameSchema,
 	mutatorNames: S.Array(MutatorNameSchema),
 	cause: S.Defect()
-}) {};
+}) {
+	get message() {
+		return `Failed to apply ${this.mutatorNames.join(", ")} in ${this.fileName}`;
+	}
+};
 var MutantNotApplied = class extends S.TaggedError()("MutantNotApplied", {
 	fileName: S.String,
 	mutatorName: MutatorNameSchema
-}) {};
-var NodeWithoutSpan = class extends S.TaggedError()("NodeWithoutSpan", { fileName: S.String }) {};
+}) {
+	get message() {
+		return `Could not apply the ${this.mutatorName} mutant in ${this.fileName}`;
+	}
+};
+var NodeWithoutSpan = class extends S.TaggedError()("NodeWithoutSpan", { fileName: S.String }) {
+	get message() {
+		return `Node without a span in ${this.fileName}`;
+	}
+};
 var MutantsUnplaced = class extends S.TaggedError()("MutantsUnplaced", {
 	fileName: S.String,
 	detail: S.String
-}) {};
+}) {
+	get message() {
+		return `Mutants cannot be placed. This shouldn't happen! Unplaced mutants: ${this.detail}`;
+	}
+};
 var PlacementRefused = class extends S.TaggedError()("PlacementRefused", { message: S.String }) {};
 //#endregion
+//#region src/relational-sufficient-sets.ts
+/**
+* The sufficient sets of non-redundant relational-operator mutations.
+*
+* Source: René Just and Franz Schweiggert, "Higher Accuracy and Lower Run Time:
+* Efficient Mutation Analysis Using Non-Redundant Mutation Operators", Journal
+* of Software Testing, Verification and Reliability 24(5), 2014, Table III
+* (https://homes.cs.washington.edu/~rjust/publ/non_redundant_mutants_jstvr_2014.pdf).
+*
+* The paper groups every input tuple into the three intervals `a < b`,
+* `a == b`, and `a > b`. For each relational operator exactly one
+* minimal-distance mutation covers each interval, and those three mutations
+* subsume every other relational replacement. Each row below lists the two
+* replacement operators and the boolean the whole comparison collapses to. The
+* sets assume numeric operands without `NaN`; `mutantSetPolicy: 'full'`
+* restores every variant.
+*/
+const RELATIONAL_OPERATORS = [
+	"<",
+	"<=",
+	">",
+	">="
+];
+const isRelationalOperator = (operator) => RELATIONAL_OPERATORS.some((relational) => relational === operator);
+const SUFFICIENT_RELATIONAL_SETS = {
+	"<": {
+		replacements: ["<=", "!="],
+		literal: false
+	},
+	"<=": {
+		replacements: ["<", "=="],
+		literal: true
+	},
+	">": {
+		replacements: [">=", "!="],
+		literal: false
+	},
+	">=": {
+		replacements: [">", "=="],
+		literal: true
+	}
+};
+//#endregion
+//#region src/Location.schema.ts
+const Offset = S.Int.check(S.isGreaterThanOrEqualTo(0));
+const OffsetEnds = S.Struct({
+	start: Offset,
+	end: Offset
+});
+const Span = S.declare((value) => S.is(OffsetEnds)(value) && Mutant.notReversed(Order.Number)(value), {
+	expected: "a span whose end is not before its start",
+	toCodecArbitrary: () => S.link()(OffsetEnds, {
+		decode: SchemaGetter.transform(Mutant.inOrder(Order.Number)),
+		encode: SchemaGetter.transform((ends) => ends)
+	})
+});
+const ScriptOrigin = S.Struct({
+	line: Mutant.Line,
+	columnShift: Offset
+});
+S.is(Offset), S.is(Span);
+//#endregion
 //#region src/Location.ts
 const LINE_TERMINATOR = /\r\n|[\n\r\u2028\u2029]/g;
 const lineStartsOf = (text) => [0, ...[...text.matchAll(LINE_TERMINATOR)].map((match) => match.index + match[0].length)];
@@ -370,7 +300,7 @@ const positionAtOffset = (lineStarts, offset, low, high, start) => Boolean$1.mat
 	})
 });
 const positionAt = dual(2, (lineStarts, offset) => positionAtOffset(lineStarts, offset, 0, lineStarts.length - 1, 0));
-const locationOf = dual(2, (lineStarts, span) => Location.make({
+const locationOf = dual(2, (lineStarts, span) => Mutant.Location.make({
 	start: positionAt(lineStarts, span.start),
 	end: positionAt(lineStarts, span.end)
 }));
@@ -1407,7 +1337,7 @@ function toApiMutant(mutant) {
 		mutatorName: mutant.mutatorName,
 		replacement: mutant.replacementCode
 	};
-	return S.decodeResult(Mutant)(mutant.ignoreReason === void 0 ? baseFields : {
+	return S.decodeResult(Mutant.Mutant)(mutant.ignoreReason === void 0 ? baseFields : {
 		...baseFields,
 		statusReason: mutant.ignoreReason,
 		status: "Ignored"
@@ -1828,9 +1758,19 @@ const booleanOperators = Object.freeze([
 	">=",
 	"||"
 ]);
-const conditionalExpressionMutator = (node, context) => Match.value(isTestOfLoop(node, context)).pipe(Match.when(true, () => [booleanLiteral(false)]), Match.orElse(() => conditionTestMutants(node, context)));
+const conditionalExpressionMutator = (node, context) => Match.value(isTestOfLoop(node, context)).pipe(Match.when(true, () => withSufficientConditional(node, context, [booleanLiteral(false)])), Match.orElse(() => conditionTestMutants(node, context)));
 function conditionTestMutants(node, context) {
-	return Match.value(isTestOfCondition(node, context)).pipe(Match.when(true, () => [booleanLiteral(true), booleanLiteral(false)]), Match.orElse(() => booleanExpressionMutants(node, context)));
+	return Match.value(isTestOfCondition(node, context)).pipe(Match.when(true, () => withSufficientConditional(node, context, [booleanLiteral(true), booleanLiteral(false)])), Match.orElse(() => booleanExpressionMutants(node, context)));
+}
+function withSufficientConditional(node, context, replacements) {
+	const literal = sufficientRelationalLiteral(node, context);
+	return literal === void 0 ? replacements : appendBooleanLiteral(replacements, literal);
+}
+function sufficientRelationalLiteral(node, context) {
+	return Option.getOrUndefined(Option.map(Option.filter(Option.fromNullishOr(relationalSiteFacts(node, context)), (facts) => [facts.inConditionPosition, context.mutantSetPolicy === "default"].every(Boolean)), (facts) => SUFFICIENT_RELATIONAL_SETS[facts.operator].literal));
+}
+function appendBooleanLiteral(replacements, literal) {
+	return replacements.some((replacement) => isBooleanLiteral(replacement) && replacement.value === literal) ? replacements : [...replacements, booleanLiteral(literal)];
 }
 function booleanExpressionMutants(node, context) {
 	return Match.value(isBooleanExpression(node)).pipe(Match.when(true, () => booleanExpressionReplacements(context)), Match.orElse(() => statementMutants(node)));
@@ -1893,6 +1833,40 @@ function isTestBearingStatement(node) {
 function testOfStatement(node) {
 	return Match.value(node).pipe(Match.when(isTestBearingStatement, (statement) => statement.test ?? void 0), Match.orElse(() => void 0));
 }
+const isConditionalExpression = (node) => node.type === "ConditionalExpression";
+function isTestOfConditionalExpression(node, context) {
+	return Option.exists(Option.filter(Option.fromNullishOr(context.parent), isConditionalExpression), (parent) => parent.test === node);
+}
+function isConditionPosition(node, context) {
+	return [
+		isTestOfLoop(node, context),
+		isTestOfCondition(node, context),
+		isTestOfConditionalExpression(node, context)
+	].some(Boolean);
+}
+function binaryOperatorOf(node) {
+	return node.type === "BinaryExpression" ? node.operator : void 0;
+}
+const isRelationalComparison = (node) => Option.exists(Option.fromNullishOr(binaryOperatorOf(node)), isRelationalOperator);
+const relationalSiteFactsDataFirst = (node, context) => Option.getOrUndefined(Option.map(Option.filter(Option.fromNullishOr(binaryOperatorOf(node)), isRelationalOperator), (operator) => ({
+	operator,
+	inConditionPosition: isConditionPosition(node, context)
+})));
+const relationalSiteFacts = dual((args) => args.length >= 2, relationalSiteFactsDataFirst);
+const relationalSufficientDataFirst = (facts, replacement) => facts === void 0 ? true : sufficientInCondition(facts, replacement);
+function sufficientInCondition(facts, replacement) {
+	return facts.inConditionPosition ? sufficientReplacementOf(facts, replacement) : true;
+}
+function sufficientReplacementOf(facts, replacement) {
+	return Match.value(replacement).pipe(Match.when(isBooleanLiteral, (literal) => literal.value === SUFFICIENT_RELATIONAL_SETS[facts.operator].literal), Match.when(isBinaryExpressionNode, (binary) => isSufficientOperator(facts, binary.operator)), Match.orElse(() => true));
+}
+const relationalSufficientReplacement = dual((args) => args.length >= 2, relationalSufficientDataFirst);
+function isSufficientOperator(facts, operator) {
+	return SUFFICIENT_RELATIONAL_SETS[facts.operator].replacements.some((sufficient) => sufficient === operator);
+}
+function isBinaryExpressionNode(node) {
+	return node.type === "BinaryExpression";
+}
 function isBooleanExpression(node) {
 	return isOperatorExpression(node) && booleanOperators.includes(node.operator);
 }
@@ -1910,12 +1884,23 @@ const operators = {
 	"!==": ["==="]
 };
 const EQUALITY_OPERATOR_KEYS = Object.keys(operators);
-const equalityOperatorMutator = (node) => Match.value(node).pipe(Match.when(isEqualityBinary, (binary) => mutatedEqualityOperators(binary)), Match.orElse(() => NO_MUTANTS));
+const equalityOperatorMutator = (node, context) => Match.value(node).pipe(Match.when(isEqualityBinary, (binary) => mutatedEqualityOperators(binary, context)), Match.orElse(() => NO_MUTANTS));
 function isEqualityBinary(node) {
 	return node.type === "BinaryExpression" && EQUALITY_OPERATOR_KEYS.includes(node.operator);
 }
-function mutatedEqualityOperators(binary) {
-	return operators[binary.operator].map((operator) => withOperator(binary, operator));
+function mutatedEqualityOperators(binary, context) {
+	const base = operators[binary.operator].map((operator) => withOperator(binary, operator));
+	return isRelationalConditionSite(binary, context) ? [...base, ...sufficientAdditions(binary)] : base;
+}
+function isRelationalConditionSite(node, context) {
+	return [
+		context.mutantSetPolicy === "default",
+		isRelationalComparison(node),
+		isConditionPosition(node, context)
+	].every(Boolean);
+}
+function sufficientAdditions(binary) {
+	return isRelationalOperator(binary.operator) ? SUFFICIENT_RELATIONAL_SETS[binary.operator].replacements.filter((operator) => !operators[binary.operator].some((replacement) => replacement === operator)).map((operator) => withOperator(binary, operator)) : NO_MUTANTS;
 }
 const logicalOperatorReplacements = Object.freeze({
 	"&&": "||",
@@ -2198,6 +2183,27 @@ const optInMutators = Object.freeze({
 	SynchronizationRemoval: synchronizationRemovalMutator,
 	FinalizerEscape: finalizerEscapeMutator
 });
+const stockRegistry = {
+	defaults: defaultMutators,
+	optIn: optInMutators
+};
+const registryOfDataFirst = (catalogs, contributions) => {
+	const implementations = new Map([
+		...Object.entries(defaultMutators),
+		...Object.entries(optInMutators),
+		...contributions.flatMap(({ entries }) => entries.map((entry) => [entry.name, entry.implementation]))
+	]);
+	const entries = catalogs.flatMap((catalog) => catalog.entries);
+	const entriesOfTier = (tier) => entries.filter((entry) => entry.tier === tier).flatMap((entry) => Option.match(Option.fromNullishOr(implementations.get(entry.name)), {
+		onNone: () => [],
+		onSome: (implementation) => [[entry.name, implementation]]
+	}));
+	return {
+		defaults: Object.fromEntries(entriesOfTier("default")),
+		optIn: Object.fromEntries(entriesOfTier("optIn"))
+	};
+};
+const registryOf = dual((args) => args.length >= 2, registryOfDataFirst);
 /**
 * The entries a run applies, and the names its directives may reference.
 *
@@ -2221,7 +2227,7 @@ const selectMutators = dual((args) => args.length >= 2, selectMutatorsDataFirst)
 var ParseFailed = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/Parser.schema/ParseFailed")("ParseFailed", {
 	fileName: S.String,
 	message: S.String,
-	location: Position,
+	location: Mutant.Position,
 	cause: S.Defect()
 }) {
 	get message() {
@@ -2232,7 +2238,7 @@ var ParseFailed = class extends S.TaggedError("@systemfsoftware/stryker-js-instr
 //#region src/Parser.service.ts
 const oxcModule = Effect.cached(Effect.promise(() => import("oxc-parser")));
 const loadOxc = Effect.flatMap(oxcModule, (load) => load);
-const parseWithOxcDataFirst = Effect.fn("stryker.instrument.parser.parseWithOxc")(function* (text, fileName, lang) {
+const parseWithOxcDataFirst = Effect.fn(SpanTaxonomy.Spans.instrumentParserParseWithOxc.name)(function* (text, fileName, lang) {
 	const result = (yield* loadOxc).parseSync(fileName, text, {
 		lang,
 		range: true
@@ -2259,7 +2265,7 @@ const oxcParseFailure = (errors, fileName, lineStarts) => Option.match(Option.fr
 });
 const oxcErrorLabelStart = (error) => Option.getOrElse(Option.map(Option.fromNullishOr(error.labels.at(0)), (label) => label.start), () => 0);
 const createParser = () => ({ parse: (code, fileName, scriptFormat) => Match.value(scriptFormat).pipe(Match.when("js", () => parseJS(code, fileName)), Match.when("ts", () => parseTS(code, fileName)), Match.when("tsx", () => parseTsx(code, fileName)), Match.exhaustive) });
-const parseJSDataFirst = Effect.fn("stryker.instrument.parser.parseJS")(function* (text, fileName) {
+const parseJSDataFirst = Effect.fn(SpanTaxonomy.Spans.instrumentParserParseJS.name)(function* (text, fileName) {
 	const parsed = yield* parseWithOxc(text, fileName, "js");
 	return {
 		originFileName: fileName,
@@ -2270,7 +2276,7 @@ const parseJSDataFirst = Effect.fn("stryker.instrument.parser.parseJS")(function
 	};
 });
 const parseJS = dual((args) => args.length >= 2, parseJSDataFirst);
-const parseTSDataFirst = Effect.fn("stryker.instrument.parser.parseTS")(function* (text, fileName) {
+const parseTSDataFirst = Effect.fn(SpanTaxonomy.Spans.instrumentParserParseTS.name)(function* (text, fileName) {
 	const parsed = yield* parseWithOxc(text, fileName, "ts");
 	return {
 		originFileName: fileName,
@@ -2281,7 +2287,7 @@ const parseTSDataFirst = Effect.fn("stryker.instrument.parser.parseTS")(function
 	};
 });
 const parseTS = dual((args) => args.length >= 2, parseTSDataFirst);
-const parseTsxDataFirst = Effect.fn("stryker.instrument.parser.parseTsx")(function* (text, fileName) {
+const parseTsxDataFirst = Effect.fn(SpanTaxonomy.Spans.instrumentParserParseTsx.name)(function* (text, fileName) {
 	const parsed = yield* parseWithOxc(text, fileName, "tsx");
 	return {
 		root: parsed.root,
@@ -2766,7 +2772,7 @@ const logicalExpressionText = (ctx, node, prec) => {
 };
 const conditionalExpressionText = (ctx, node, prec) => {
 	const myPrec = PREC.Conditional;
-	const testStr = wrapIfNeeded(ctx, node.test, precOf(node.test), myPrec, false);
+	const testStr = wrapIfNeeded(ctx, node.test, precOf(node.test), myPrec, CONDITIONAL_TEST_WRAPPED_KINDS[node.test.type] === true);
 	const consStr = dispatchNode(ctx, node.consequent, PREC.Assignment);
 	const altStr = dispatchNode(ctx, node.alternate, PREC.Assignment);
 	return parenthesizedIf(myPrec < prec, `${testStr} ? ${consStr} : ${altStr}`);
@@ -3164,6 +3170,7 @@ const MEMBER_OBJECT_WRAPPED_KINDS = {
 	AwaitExpression: true,
 	YieldExpression: true
 };
+const CONDITIONAL_TEST_WRAPPED_KINDS = { ConditionalExpression: true };
 const CALLEE_WRAPPED_KINDS = {
 	SequenceExpression: true,
 	ConditionalExpression: true
@@ -3339,7 +3346,11 @@ var FormatOverrideUnclaimed = class extends S.TaggedError()("FormatOverrideUncla
 	fileName: S.String,
 	formatId: S.String,
 	reason: S.String
-}) {};
+}) {
+	get message() {
+		return `Cannot instrument ${this.fileName}: ${this.reason}`;
+	}
+};
 const pinOf = (command) => Option.fromUndefinedOr(command.formatId);
 const matchesCommand = (claim, command) => Match.value(pinOf(command)).pipe(Match.when(Option.isSome, (pin) => claim.formatId === pin.value), Match.orElse(() => claim.extensions.includes(command.extension)));
 const claimFor = (command) => command.claims.find((claim) => matchesCommand(claim, command));
@@ -3380,9 +3391,117 @@ const resolveFormat = Workflow.make({
 	error: FormatOverrideUnclaimed,
 	decide: (command) => Match.value(selectionFor(command)).pipe(Match.tag("ClaimSelected", ({ claim }) => Result.succeed(assignedFrom(claim, command))), Match.tag("PinUnclaimed", ({ formatId }) => Result.fail(overrideUnclaimedFrom(command, formatId))), Match.tag("ExtensionUnclaimed", () => Result.succeed(skippedFrom(command))), Match.exhaustive)
 });
+const AridRuleId = S.Literals([
+	"arid-logging",
+	"arid-telemetry",
+	"arid-time",
+	"arid-config-default",
+	"arid-memoization"
+]);
+const AridCalleeSchema = S.Struct({
+	object: S.String,
+	member: S.String
+});
+const AridFrameSchema = S.Struct({
+	callee: S.Option(AridCalleeSchema),
+	childIsArgument: S.Boolean
+});
+const NAMED_LOGGERS = ["Logger", "console"];
+const readsNamespace = (callee, object) => callee.object === object;
+const readsName = (callee, name) => callee.member === name;
+const readsMember = (callee, object, member) => [readsNamespace(callee, object), readsName(callee, member)].every(Boolean);
+const readsMemberPrefixed = (callee, object, prefix) => [readsNamespace(callee, object), callee.member.startsWith(prefix)].every(Boolean);
+const ARID_RULES_IN_PRECEDENCE_ORDER = [
+	{
+		ruleId: "arid-logging",
+		matches: (callee) => readsMemberPrefixed(callee, "Effect", "log")
+	},
+	{
+		ruleId: "arid-logging",
+		matches: (callee) => NAMED_LOGGERS.includes(callee.object)
+	},
+	{
+		ruleId: "arid-telemetry",
+		matches: (callee) => readsMember(callee, "Effect", "withSpan")
+	},
+	{
+		ruleId: "arid-telemetry",
+		matches: (callee) => readsMemberPrefixed(callee, "Effect", "annotate")
+	},
+	{
+		ruleId: "arid-telemetry",
+		matches: (callee) => readsMember(callee, "Effect", "withLogSpan")
+	},
+	{
+		ruleId: "arid-telemetry",
+		matches: (callee) => readsNamespace(callee, "Metric")
+	},
+	{
+		ruleId: "arid-time",
+		matches: (callee) => readsMember(callee, "Effect", "sleep")
+	},
+	{
+		ruleId: "arid-time",
+		matches: (callee) => readsNamespace(callee, "Schedule")
+	},
+	{
+		ruleId: "arid-time",
+		matches: (callee) => readsNamespace(callee, "Duration")
+	},
+	{
+		ruleId: "arid-time",
+		matches: (callee) => readsMember(callee, "Date", "now")
+	},
+	{
+		ruleId: "arid-config-default",
+		matches: (callee) => readsMember(callee, "Config", "withDefault")
+	},
+	{
+		ruleId: "arid-memoization",
+		matches: (callee) => readsMember(callee, "Effect", "cached")
+	},
+	{
+		ruleId: "arid-memoization",
+		matches: (callee) => readsMember(callee, "Effect", "cachedWithTTL")
+	}
+];
+const ruleFor = (callee) => Option.map(Option.fromNullishOr(ARID_RULES_IN_PRECEDENCE_ORDER.find((rule) => rule.matches(callee))), (rule) => rule.ruleId);
+const calleeDetail = (callee) => `${callee.object}.${callee.member}`;
+var AridCodeCommand = class extends S.TaggedClass()("AridCodeCommand", {
+	policy: Options.MutantSetPolicy,
+	frames: S.Array(AridFrameSchema)
+}) {
+	static [Workflow.InstrumentationBrand] = {};
+};
+const AridCodeDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js-instrumenter/AridCodeDecision");
+var AridSuppressed = class extends S.TaggedClass()("AridSuppressed", {
+	ruleId: AridRuleId,
+	detail: S.String
+}) {
+	[AridCodeDecisionTypeId] = AridCodeDecisionTypeId;
+};
+var AridKept = class extends S.TaggedClass()("AridKept", {}) {
+	[AridCodeDecisionTypeId] = AridCodeDecisionTypeId;
+};
+const matchOfFrame = (frame) => Option.flatMap(Option.filter(frame.callee, () => frame.childIsArgument), (callee) => Option.map(ruleFor(callee), (ruleId) => ({
+	ruleId,
+	callee
+})));
+const firstMatch = (frames) => Option.firstSomeOf(frames.map(matchOfFrame));
+const defaultPolicyDecision = (frames) => Match.value(firstMatch(frames)).pipe(Match.when(Option.isSome, (found) => AridSuppressed.make({
+	ruleId: found.value.ruleId,
+	detail: calleeDetail(found.value.callee)
+})), Match.when(Option.isNone, () => AridKept.make({})), Match.exhaustive);
+const decisionFor = (command) => Match.value(command.policy).pipe(Match.when("default", () => defaultPolicyDecision(command.frames)), Match.when("full", () => AridKept.make({})), Match.exhaustive);
+const aridCode = Workflow.make({
+	command: AridCodeCommand,
+	decision: S.Union([AridSuppressed, AridKept]),
+	error: S.Never,
+	decide: (command) => Result.succeed(decisionFor(command))
+});
 //#endregion
 //#region src/directives/decode-directive.workflow.ts
-const DIRECTIVE_PATTERN = /^\s?Stryker (disable|restore)(?: (next-line))? ([a-zA-Z, ]+)(?::(.+)?)?/;
+const DIRECTIVE_PATTERN = /^\s?Stryker (disable|restore)(?: (next-line))? ([a-zA-Z0-9,/ -]+)(?::(.+)?)?/;
 const DEFAULT_REASON = "Ignored using a comment";
 const NEXT_LINE$1 = "next-line";
 var DecodeDirectiveCommand = class extends S.TaggedClass()("DecodeDirectiveCommand", { commentText: S.String }) {
@@ -3436,6 +3555,23 @@ const foldRule = Workflow.make({
 	decide: (command) => Match.value(command.directive.directive.action).pipe(Match.when("restore", () => Result.succeed(RestoreFolded.make({ rule: [...command.rule, command.directive] }))), Match.when("disable", () => Result.succeed(DisableFolded.make({ rule: [...command.rule, command.directive] }))), Match.exhaustive)
 });
 //#endregion
+//#region src/InstrumentContext.schema.ts
+var InstrumenterContext = class extends S.Class("InstrumenterContext")({
+	activeMutant: S.optional(S.String),
+	currentTestId: S.optional(S.String),
+	mutantCoverage: S.optional(Mutant.MutantCoverageSchema),
+	hitCount: S.optional(Mutant.HitCount),
+	hitLimit: S.optional(Mutant.HitCount)
+}) {
+	static NAMESPACE = "__stryker__";
+	static MUTATION_COVERAGE_OBJECT = "mutantCoverage";
+	static ACTIVE_MUTANT = "activeMutant";
+	static CURRENT_TEST_ID = "currentTestId";
+	static HIT_COUNT = "hitCount";
+	static HIT_LIMIT = "hitLimit";
+	static ACTIVE_MUTANT_ENV_VARIABLE = "__STRYKER_ACTIVE_MUTANT__";
+};
+//#endregion
 //#region src/InstrumentHeader.ts
 const hasLeadingComments$1 = (value) => Predicate.hasProperty(value, "leadingComments") && Array.isArray(value.leadingComments);
 const STRYKER_NAMESPACE_HELPER = "stryNS_9fa48";
@@ -3522,6 +3658,18 @@ function commentedHeader(firstHeader, leadingComments, rest) {
 	return [cloned, ...rest];
 }
 //#endregion
+//#region src/MutantIdentity.ts
+const MUTANT_ID_HEX_LENGTH = 16;
+const lengthPrefixed = (value) => `${value.length}:${value}`;
+const tupleFields = (tuple) => [
+	tuple.fileName,
+	tuple.mutatorName,
+	tuple.originalCode,
+	tuple.replacementCode
+];
+const mutantTupleKey = (tuple) => tupleFields(tuple).map(lengthPrefixed).join("");
+const mutantIdOf = (identity) => Mutant.MutantId.make(bytesToHex(sha256(utf8ToBytes([...tupleFields(identity), `${identity.ordinal}`].map(lengthPrefixed).join("")))).slice(0, MUTANT_ID_HEX_LENGTH));
+//#endregion
 //#region src/place-mutants.workflow.ts
 const PlacementFactsSchema = S.Struct({
 	isExpression: S.Boolean,
@@ -3535,7 +3683,7 @@ const ReplacementFactsSchema = S.Struct({
 	isSwitchCase: S.Boolean
 });
 const PlacedMutantSchema = S.Struct({
-	id: MutantId,
+	id: Mutant.MutantId,
 	mutatorName: MutatorNameSchema,
 	replacement: ReplacementFactsSchema
 });
@@ -3549,19 +3697,19 @@ var PlaceMutantsCommand = class extends S.TaggedClass()("PlaceMutantsCommand", {
 const PlacementDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js-instrumenter/PlacementDecision");
 var ExpressionSite = class extends S.TaggedClass()("ExpressionSite", {
 	fileName: S.String,
-	mutantIds: S.Array(MutantId)
+	mutantIds: S.Array(Mutant.MutantId)
 }) {
 	[PlacementDecisionTypeId] = PlacementDecisionTypeId;
 };
 var StatementSite = class extends S.TaggedClass()("StatementSite", {
 	fileName: S.String,
-	mutantIds: S.Array(MutantId)
+	mutantIds: S.Array(Mutant.MutantId)
 }) {
 	[PlacementDecisionTypeId] = PlacementDecisionTypeId;
 };
 var SwitchCaseSite = class extends S.TaggedClass()("SwitchCaseSite", {
 	fileName: S.String,
-	mutantIds: S.Array(MutantId)
+	mutantIds: S.Array(Mutant.MutantId)
 }) {
 	[PlacementDecisionTypeId] = PlacementDecisionTypeId;
 };
@@ -3573,11 +3721,19 @@ const ExpectedKindSchema = S.Literals([
 var MutantKindMismatch = class extends S.TaggedError()("MutantKindMismatch", {
 	fileName: S.String,
 	placer: PlacerNameSchema,
-	mutantId: MutantId,
+	mutantId: Mutant.MutantId,
 	mutatorName: MutatorNameSchema,
 	expected: ExpectedKindSchema
-}) {};
-var NoPlacerClaimsNode = class extends S.TaggedError()("NoPlacerClaimsNode", { fileName: S.String }) {};
+}) {
+	get message() {
+		return `Expected ${this.expected} for mutant ${this.mutantId} (${this.mutatorName}) in ${this.fileName}`;
+	}
+};
+var NoPlacerClaimsNode = class extends S.TaggedError()("NoPlacerClaimsNode", { fileName: S.String }) {
+	get message() {
+		return `No placer claims the node in ${this.fileName}`;
+	}
+};
 const claimingPlacer = (facts) => Match.value(facts).pipe(Match.when({
 	isExpression: true,
 	expressionIsValid: true
@@ -3626,66 +3782,156 @@ const placeMutants = Workflow.make({
 	})
 });
 //#endregion
+//#region src/mutant-set-policy.workflow.ts
+const MutantSetFactsSchema = S.Struct({
+	originalCode: S.String,
+	replacementCode: S.String,
+	relationalSufficient: S.Boolean
+});
+const MutantSetRuleId = S.Literals([
+	"redundant-relational",
+	"equivalent-to-original",
+	"duplicate-at-site"
+]);
+var MutantSetPolicyCommand = class extends S.TaggedClass()("MutantSetPolicyCommand", {
+	policy: Options.MutantSetPolicy,
+	candidates: S.Array(MutantSetFactsSchema)
+}) {
+	static [Workflow.InstrumentationBrand] = {};
+};
+const MutantSetOutcomeTypeId = Symbol.for("@systemfsoftware/stryker-js-instrumenter/MutantSetOutcome");
+var MutantSuppressed = class extends S.TaggedClass()("MutantSuppressed", {
+	ruleId: MutantSetRuleId,
+	detail: S.String
+}) {
+	[MutantSetOutcomeTypeId] = MutantSetOutcomeTypeId;
+};
+var MutantKept = class extends S.TaggedClass()("MutantKept", {}) {
+	[MutantSetOutcomeTypeId] = MutantSetOutcomeTypeId;
+};
+const MutantSetOutcome = S.Union([MutantSuppressed, MutantKept]);
+const MutantSetDecision = S.Array(MutantSetOutcome);
+const canonicalForm = (text) => stripOuterParentheses(text.trim());
+const stripOuterParentheses = (text) => Match.value(wrapsWhole(text)).pipe(Match.when(true, () => stripOuterParentheses(text.slice(1, -1).trim())), Match.orElse(() => text));
+const parenDepthDelta = (character) => Match.value(character).pipe(Match.when("(", () => 1), Match.when(")", () => -1), Match.orElse(() => 0));
+const depthsAfter = (text) => text.split("").reduce((depths, character) => [...depths, Option.getOrElse(Arr.last(depths), () => 0) + parenDepthDelta(character)], []);
+const wrapsWhole = (text) => {
+	const depths = depthsAfter(text);
+	return [
+		text.startsWith("("),
+		text.endsWith(")"),
+		depths.length > 0,
+		depths.slice(0, -1).every((depth) => depth >= 1),
+		Option.getOrElse(Arr.last(depths), () => 0) === 0
+	].every(Boolean);
+};
+const defaultOnly = (policy, value) => Match.value(policy).pipe(Match.when("full", () => Option.none()), Match.when("default", value), Match.exhaustive);
+const printedAs = (code) => canonicalForm(code);
+const printsSomething = (code) => printedAs(code).length > 0;
+const samePrintedCode = (left, right) => [printsSomething(left), printedAs(left) === printedAs(right)].every(Boolean);
+const alreadyPrinted = (code, earlier) => [printsSomething(code), earlier.includes(printedAs(code))].every(Boolean);
+const relationalSuppression = (facts, policy) => defaultOnly(policy, () => Option.map(Option.filter(Option.some(facts), (candidate) => candidate.relationalSufficient === false), () => MutantSuppressed.make({
+	ruleId: "redundant-relational",
+	detail: `${printedAs(facts.replacementCode)} is not in the sufficient set for ${printedAs(facts.originalCode)}`
+})));
+const equivalentSuppression = (facts, policy) => defaultOnly(policy, () => Option.map(Option.filter(Option.some(facts), (candidate) => samePrintedCode(candidate.replacementCode, candidate.originalCode)), () => MutantSuppressed.make({
+	ruleId: "equivalent-to-original",
+	detail: `${printedAs(facts.replacementCode)} is the original code`
+})));
+const duplicateSuppression = (facts, earlier, policy) => defaultOnly(policy, () => Option.map(Option.filter(Option.some(facts), (candidate) => alreadyPrinted(candidate.replacementCode, earlier)), () => MutantSuppressed.make({
+	ruleId: "duplicate-at-site",
+	detail: `${printedAs(facts.replacementCode)} is already planted at this site`
+})));
+const outcomeOf = (facts, earlier, policy) => Option.getOrElse(Option.orElse(relationalSuppression(facts, policy), () => Option.orElse(equivalentSuppression(facts, policy), () => duplicateSuppression(facts, earlier, policy))), () => MutantKept.make({}));
+const foldCandidate = (state, facts, policy) => ({
+	outcomes: [...state.outcomes, outcomeOf(facts, state.earlier, policy)],
+	earlier: [...state.earlier, canonicalForm(facts.replacementCode)]
+});
+const outcomesFor = (command) => command.candidates.reduce((state, facts) => foldCandidate(state, facts, command.policy), {
+	outcomes: [],
+	earlier: []
+}).outcomes;
+const mutantSetPolicy = Workflow.make({
+	command: MutantSetPolicyCommand,
+	decision: MutantSetDecision,
+	error: S.Never,
+	decide: (command) => Result.succeed([...outcomesFor(command)])
+});
+//#endregion
 //#region src/plan-mutants.workflow.ts
 const WILDCARD = "all";
 const NEXT_LINE = "next-line";
+const RULE_SEPARATOR = ": ";
+const policyWorkflow = mutantSetPolicy;
+const policyCommand = MutantSetPolicyCommand;
+const keptOutcome = MutantKept;
+const ignoreReasonFor = (ruleId, detail) => `${ruleId}${RULE_SEPARATOR}${detail}`;
 const MutantCandidateSchema = S.Struct({
+	id: Mutant.MutantId,
 	mutatorName: MutatorNameSchema,
 	replacementCode: S.String,
-	location: S.optional(Location),
-	ignorerReason: S.optional(S.String)
+	location: S.optional(Mutant.Location),
+	ignorerReason: S.optional(S.String),
+	mutantSet: MutantSetFactsSchema
 });
 const PlannedMutantSchema = S.Struct({
-	id: MutantId,
+	id: Mutant.MutantId,
 	mutatorName: MutatorNameSchema,
 	replacementCode: S.String,
-	location: Location,
+	location: Mutant.Location,
 	ignoreReason: S.optional(S.String)
 });
-const MutantCounterSchema = S.Int.pipe(S.check(S.isBetween({
-	minimum: 0,
-	maximum: 1e6
-})));
-const MutantCountSchema = S.Int.pipe(S.check(S.isGreaterThanOrEqualTo(0)));
 var PlanMutantsCommand = class extends S.TaggedClass()("PlanMutantsCommand", {
 	fileName: S.String,
-	firstIndex: MutantCounterSchema,
 	offset: ScriptOrigin,
-	line: Line,
+	line: Mutant.Line,
 	mutatorNames: S.Array(MutatorNameSchema),
 	excludedMutations: S.Array(MutatorNameSchema),
 	rule: S.Array(LocatedDirectiveSchema),
 	directives: S.Array(LocatedDirectiveSchema),
-	candidates: S.Array(MutantCandidateSchema)
+	candidates: S.Array(MutantCandidateSchema),
+	mutantSetPolicy: Options.MutantSetPolicy
 }) {
 	static [Workflow.InstrumentationBrand] = {};
 };
 const MutantPlanTypeId = Symbol.for("@systemfsoftware/stryker-js-instrumenter/MutantPlan");
 var MutantsPlanned = class extends S.TaggedClass()("MutantsPlanned", {
 	mutants: S.Array(PlannedMutantSchema),
-	placeable: S.Array(PlannedMutantSchema),
-	warnings: S.Array(S.String),
-	nextIndex: MutantCountSchema
+	placeableIds: S.Array(Mutant.MutantId),
+	warnings: S.Array(S.String)
 }) {
 	[MutantPlanTypeId] = MutantPlanTypeId;
 };
 var MutantsFullyIgnored = class extends S.TaggedClass()("MutantsFullyIgnored", {
 	mutants: S.Array(PlannedMutantSchema),
-	warnings: S.Array(S.String),
-	nextIndex: MutantCountSchema
+	warnings: S.Array(S.String)
 }) {
 	[MutantPlanTypeId] = MutantPlanTypeId;
 };
 var MutantWithoutLocation = class extends S.TaggedError()("MutantWithoutLocation", {
 	fileName: S.String,
 	mutatorName: MutatorNameSchema
-}) {};
+}) {
+	get message() {
+		return `Mutant without a source location: ${this.mutatorName} in ${this.fileName}`;
+	}
+};
 const reachedLine = (located, line) => Match.value(located.directive.scope).pipe(Match.when(NEXT_LINE, () => located.governedLine === line), Match.when("block", () => true), Match.exhaustive);
 const namesMutator = (located, lowerMutatorName) => located.directive.mutatorNames.some((name) => [name === WILDCARD, name.toLowerCase() === lowerMutatorName].some(Boolean));
 const lastReachingDirective = (rule, lowerMutatorName, line) => Option.fromNullishOr(rule.findLast((located) => [reachedLine(located, line), namesMutator(located, lowerMutatorName)].every(Boolean)));
-const directiveReason = (rule, mutatorName, line) => Option.flatMap(lastReachingDirective(rule, mutatorName.toLowerCase(), line), (located) => Match.value(located.directive.action).pipe(Match.when("disable", () => Option.some(located.directive.reason)), Match.when("restore", () => Option.none()), Match.exhaustive));
-const exclusionReason = (excludedMutations, mutatorName) => Match.value(excludedMutations.includes(mutatorName)).pipe(Match.when(true, () => Option.some(`Ignored because of excluded mutation "${mutatorName}"`)), Match.when(false, () => Option.none()), Match.exhaustive);
-const ignoreReasonOf = (command, candidate) => Option.getOrUndefined(Option.orElse(Option.orElse(directiveReason(command.rule, candidate.mutatorName, command.line), () => exclusionReason(command.excludedMutations, candidate.mutatorName)), () => Option.fromNullishOr(candidate.ignorerReason)));
+const directiveReason = (rule, mutatorName, line) => Option.flatMap(lastReachingDirective(rule, mutatorName.toLowerCase(), line), (located) => Match.value(located.directive.action).pipe(Match.when("disable", () => Option.some(ignoreReasonFor("directive", located.directive.reason))), Match.when("restore", () => Option.none()), Match.exhaustive));
+const exclusionReason = (excludedMutations, mutatorName) => Match.value(excludedMutations.includes(mutatorName)).pipe(Match.when(true, () => Option.some(ignoreReasonFor("excluded-mutator", `Ignored because of excluded mutation "${mutatorName}"`))), Match.when(false, () => Option.none()), Match.exhaustive);
+const ignorerReason = (candidate) => Option.map(Option.fromNullishOr(candidate.ignorerReason), (reason) => ignoreReasonFor("ignorer", reason));
+const ignoreReasonOf = (command, candidate, policyReason) => Option.getOrUndefined(Option.orElse(Option.orElse(Option.orElse(directiveReason(command.rule, candidate.mutatorName, command.line), () => exclusionReason(command.excludedMutations, candidate.mutatorName)), () => ignorerReason(candidate)), () => Option.fromNullishOr(policyReason)));
+const policyOutcomes = (command) => Result.match(policyWorkflow(policyCommand.make({
+	policy: command.mutantSetPolicy,
+	candidates: command.candidates.map((candidate) => candidate.mutantSet)
+})), {
+	onFailure: () => command.candidates.map(() => keptOutcome.make({})),
+	onSuccess: (outcomes) => outcomes
+});
+const policyReasonOf = (outcome) => Match.value(outcome).pipe(Match.withReturnType(), Match.tag("MutantSuppressed", (suppressed) => ignoreReasonFor(suppressed.ruleId, suppressed.detail)), Match.tag("MutantKept", () => void 0), Match.exhaustive);
+const policyReasonsAt = (command) => policyOutcomes(command).map(policyReasonOf);
 const unusedDirectives = (directives, mutatorNames) => directives.flatMap((located) => located.directive.mutatorNames.filter((mutatorName) => mutatorName !== WILDCARD).filter((mutatorName) => !mutatorNames.includes(mutatorName.toLowerCase())).map((mutatorName) => ({
 	directive: located.directive,
 	at: located.at,
@@ -3711,30 +3957,31 @@ const shiftedLocation = (location, offset) => ({
 	start: shiftedPosition(location.start, offset),
 	end: shiftedPosition(location.end, offset)
 });
-const plannedMutant = (command, candidate, index) => Option.match(Option.fromNullishOr(candidate.location), {
+const plannedMutant = (command, candidate, policyReason) => Option.match(Option.fromNullishOr(candidate.location), {
 	onNone: () => Result.fail(MutantWithoutLocation.make({
 		fileName: command.fileName,
 		mutatorName: candidate.mutatorName
 	})),
 	onSome: (location) => Result.succeed({
-		id: PlannedMutantSchema.fields.id.make(`${command.firstIndex + index}`),
+		id: candidate.id,
 		mutatorName: candidate.mutatorName,
 		replacementCode: candidate.replacementCode,
 		location: shiftedLocation(location, command.offset),
-		ignoreReason: ignoreReasonOf(command, candidate)
+		ignoreReason: ignoreReasonOf(command, candidate, policyReason)
 	})
 });
-const plannedMutants = (command) => command.candidates.reduce((accumulated, candidate, index) => Result.flatMap(accumulated, (mutants) => Result.map(plannedMutant(command, candidate, index), (mutant) => [...mutants, mutant])), Result.succeed([]));
+const plannedMutants = (command) => {
+	const policyReasons = policyReasonsAt(command);
+	return command.candidates.reduce((accumulated, candidate, index) => Result.flatMap(accumulated, (mutants) => Result.map(plannedMutant(command, candidate, policyReasons[index]), (mutant) => [...mutants, mutant])), Result.succeed([]));
+};
 const withoutReason = (mutant) => mutant.ignoreReason === void 0;
 const planOf = (command, mutants) => Match.value(mutants.some(withoutReason)).pipe(Match.when(true, () => MutantsPlanned.make({
 	mutants: [...mutants],
-	placeable: mutants.filter(withoutReason),
-	warnings: warningsOf(command),
-	nextIndex: command.firstIndex + mutants.length
+	placeableIds: mutants.filter(withoutReason).map((mutant) => mutant.id),
+	warnings: warningsOf(command)
 })), Match.when(false, () => MutantsFullyIgnored.make({
 	mutants: [...mutants],
-	warnings: warningsOf(command),
-	nextIndex: command.firstIndex + mutants.length
+	warnings: warningsOf(command)
 })), Match.exhaustive);
 const planMutants = Workflow.make({
 	command: PlanMutantsCommand,
@@ -3758,15 +4005,15 @@ const traversalFailure = (cause) => InstrumentError.make({
 	message: cause instanceof Error ? cause.message : errorTextOf$1(cause),
 	cause
 });
-const DEFAULT_MUTATOR_REGISTRY = {
-	defaults: defaultMutators,
-	optIn: optInMutators
-};
 const createMutantCollector = () => {
 	const mutants = [];
+	const occurrences = /* @__PURE__ */ new Map();
 	return {
-		get nextIndex() {
-			return mutants.length;
+		ordinalOf: (tuple) => {
+			const key = mutantTupleKey(tuple);
+			const ordinal = occurrences.get(key) ?? 0;
+			occurrences.set(key, ordinal + 1);
+			return ordinal;
 		},
 		append: (added) => {
 			mutants.push(...added);
@@ -4069,9 +4316,8 @@ const MUTATION_OFFSET = {
 	line: 1,
 	columnShift: 0
 };
-const initialFoldState = (firstIndex) => ({
+const initialFoldState = () => ({
 	directiveRule: [],
-	nextIndex: firstIndex,
 	mutants: [],
 	warnings: [],
 	claims: [],
@@ -4107,29 +4353,77 @@ const replacementRecord = (mutant, applied) => {
 		}
 	};
 };
-const plannedWithNodes = (candidates, planned, fileName) => candidates.flatMap((candidate, index) => Option.match(Option.fromNullishOr(planned[index]), {
+const plannedWithNodes = (candidates, planned, fileName, includes) => planned.flatMap((mutant, index) => Option.match(Option.fromNullishOr(candidates[index]), {
 	onNone: () => [],
-	onSome: (mutant) => [createMutant(mutant, fileName, candidate.node, candidate.replacement)]
+	onSome: (candidate) => includes(mutant) ? [createMutant(mutant, fileName, candidate.node, candidate.replacement)] : []
 }));
 const ignorersReasonFor = (node, ancestors, ignorers) => ignorers.reduce((reason, ignorer) => Option.orElse(reason, () => Option.fromNullishOr(ignorer.shouldIgnore(node, ancestors))), Option.none());
+const hasKey = (node, key) => key in node;
+const readKey = (node, key) => hasKey(node, key) ? node[key] : void 0;
+const isMemberExpressionValue = (node) => nodeType(node) === "MemberExpression";
+const isIdentifierValue = (value) => value !== void 0 && readKey(value, "type") === "Identifier";
+const hasIdentifierParts = (member) => [isIdentifierValue(readKey(member, "property")), isIdentifierValue(readKey(member, "object"))].every(Boolean);
+const isMemberOfIdentifierParts = (node) => isMemberExpressionValue(node) && hasIdentifierParts(node);
+function isNamedCallee(node) {
+	return isMemberOfIdentifierParts(node) && readKey(node, "computed") === false;
+}
+const aridCalleeOf = (callee) => Match.value(callee).pipe(Match.when(isNamedCallee, (named) => Option.some({
+	object: named.object.name,
+	member: named.property.name
+})), Match.orElse(() => Option.none()));
+const aridFrameFor = (child, ancestor) => ancestor.type === "CallExpression" ? Option.some({
+	callee: aridCalleeOf(ancestor.callee),
+	childIsArgument: ancestor.arguments.some((argument) => argument === child)
+}) : Option.none();
+const aridFramesOf = (frame) => framesUpward(frame).flatMap((current) => Option.match(Option.fromNullishOr(current.parent), {
+	onNone: () => [],
+	onSome: (parent) => Option.toArray(aridFrameFor(current.node, parent.node))
+}));
+const aridStatusReason = (decision) => Match.value(decision).pipe(Match.tag("AridSuppressed", (suppressed) => Option.some(`${suppressed.ruleId}: ${suppressed.detail}`)), Match.tag("AridKept", () => Option.none()), Match.exhaustive);
+const aridReasonOf = (frame, policy) => Match.value(aridCode(AridCodeCommand.make({
+	policy,
+	frames: [...aridFramesOf(frame)]
+}))).pipe(Match.when(Result.isSuccess, (decided) => aridStatusReason(decided.success)), Match.orElse(() => Option.none()));
 const mutablesFor = (frame, location, context) => {
 	const ancestors = ancestorsOfFrame(frame);
-	const mutatorContext = toMutatorContext(ancestors);
+	const mutatorContext = toMutatorContext(ancestors, context.mutantSetPolicy);
 	const replacements = context.mutatorEntries.flatMap(([mutatorName, mutate]) => [...mutate(frame.node, mutatorContext)].map((replacement) => ({
 		mutatorName,
 		replacement
 	})));
 	const ignorerReason = replacements.length === 0 ? void 0 : Option.getOrUndefined(ignorersReasonFor(frame.node, ancestors, context.ignorers));
-	return replacements.map(({ mutatorName, replacement }) => ({
-		node: frame.node,
-		replacement,
-		data: {
+	const aridReason = aridReasonOf(frame, context.mutantSetPolicy);
+	const originalCode = printNode(frame.node);
+	const relationalSite = relationalSiteFacts(frame.node, mutatorContext);
+	return replacements.map(({ mutatorName, replacement }) => {
+		const replacementCode = printNode(replacement);
+		const tuple = {
+			fileName: context.fileName,
 			mutatorName,
-			replacementCode: printNode(replacement),
-			location,
-			ignorerReason
-		}
-	}));
+			originalCode,
+			replacementCode
+		};
+		return {
+			node: frame.node,
+			replacement,
+			aridReason,
+			data: {
+				id: mutantIdOf({
+					...tuple,
+					ordinal: context.ordinalOf(tuple)
+				}),
+				mutatorName,
+				replacementCode,
+				location,
+				ignorerReason,
+				mutantSet: {
+					originalCode,
+					replacementCode,
+					relationalSufficient: relationalSufficientReplacement(relationalSite, replacement)
+				}
+			}
+		};
+	});
 };
 const mutateRangesOf = (mutateDescription) => Option.filter(Option.some(mutateDescription), isMutateRangeList);
 const isOutsideMutateRanges = (location, mutateDescription) => Option.exists(mutateRangesOf(mutateDescription), (ranges) => ranges.every((range) => !locationOverlaps(range, location)));
@@ -4167,30 +4461,43 @@ const attachPlaceable = (mutants, frame, state, context) => Match.value(mutants.
 	})),
 	onSome: (target) => applyToClaim(mutants, target, state, context)
 })), Match.exhaustive);
+const aridReasonAt = (candidates, index) => Option.flatMap(Option.fromNullishOr(candidates[index]), (candidate) => candidate.aridReason);
+const withAridReason = (mutant, reason) => Option.match(reason, {
+	onNone: () => mutant,
+	onSome: (text) => mutant.ignoreReason === void 0 ? {
+		...mutant,
+		ignoreReason: text
+	} : mutant
+});
+const withAridReasons = (candidates, planned) => planned.map((mutant, index) => withAridReason(mutant, aridReasonAt(candidates, index)));
 const collectPlan = (frame, candidates, plan, state, context) => {
-	const collected = plannedWithNodes(candidates, plan.mutants, context.fileName);
+	const planned = withAridReasons(candidates, plan.mutants);
+	const collected = plannedWithNodes(candidates, planned, context.fileName, () => true);
 	const nextState = {
 		...state,
 		mutants: [...state.mutants, ...collected],
-		warnings: [...state.warnings, ...plan.warnings],
-		nextIndex: plan.nextIndex
+		warnings: [...state.warnings, ...plan.warnings]
 	};
-	return Match.value(plan).pipe(Match.tag("MutantsPlanned", (planned) => attachPlaceable(plannedWithNodes(candidates, planned.placeable, context.fileName), frame, {
-		...nextState,
-		hasLiveMutants: true
-	}, context)), Match.orElse(() => Result.succeed(nextState)));
+	return Match.value(plan).pipe(Match.tag("MutantsPlanned", (plannedPlan) => {
+		const placeable = new Set(plannedPlan.placeableIds);
+		const live = plannedWithNodes(candidates, planned, context.fileName, (mutant) => placeable.has(mutant.id) && mutant.ignoreReason === void 0);
+		return attachPlaceable(live, frame, {
+			...nextState,
+			hasLiveMutants: nextState.hasLiveMutants || live.length > 0
+		}, context);
+	}), Match.tag("MutantsFullyIgnored", () => Result.succeed(nextState)), Match.exhaustive);
 };
 const planMutantsAt = (frame, candidates, directives, location, state, context) => {
 	const plan = planMutants(PlanMutantsCommand.make({
 		fileName: context.fileName,
-		firstIndex: state.nextIndex,
 		offset: context.offset,
 		line: location.start.line,
 		mutatorNames: [...context.allMutatorNames],
 		excludedMutations: [...context.excludedMutations],
 		rule: [...state.directiveRule],
 		directives: [...directives],
-		candidates: candidates.map((candidate) => candidate.data)
+		candidates: candidates.map((candidate) => candidate.data),
+		mutantSetPolicy: context.mutantSetPolicy
 	}));
 	return Match.value(plan).pipe(Match.when(Result.isFailure, (failed) => Result.fail(failed.failure)), Match.orElse((succeeded) => collectPlan(frame, candidates, succeeded.success, state, context)));
 };
@@ -4253,10 +4560,10 @@ const foldPlacements = (frame, state, context) => Result.flatMap(locationOfNode(
 	};
 	return Match.value(shouldSkipNode(frame, location, context.mutateDescription)).pipe(Match.when(true, () => Result.succeed(ruled)), Match.when(false, () => visitFrame(frame, directives, location, ruled, context)), Match.exhaustive);
 });
-const planInstrumentation = (root, firstIndex, context) => Result.map(foldPlacements({
+const planInstrumentation = (root, context) => Result.map(foldPlacements({
 	node: root,
 	parent: null
-}, initialFoldState(firstIndex), context), (state) => ({
+}, initialFoldState(), context), (state) => ({
 	mutants: state.mutants,
 	placements: state.placements,
 	warnings: state.warnings,
@@ -4309,23 +4616,24 @@ const refusalError = (refusal) => Match.value(refusal).pipe(Match.tag("NodeWitho
 	message: `Mutant without a source location: ${failed.mutatorName} in ${failed.fileName}`,
 	cause: void 0
 })), Match.exhaustive);
-const transformScriptDataFirst = Effect.fn("stryker.instrument.transform.script")(function* ({ root, originFileName, rawContent, offset, comments }, mutantCollector, { options, mutateDescription, basePath }) {
+const transformScriptDataFirst = Effect.fn(SpanTaxonomy.Spans.instrumentTransformScript.name)(function* ({ root, originFileName, rawContent, offset, comments }, mutantCollector, { options, mutateDescription, basePath }) {
 	const lineStarts = lineStartsOf(rawContent);
 	attachComments(make(root), comments, lineStarts);
-	const selection = selectMutators(DEFAULT_MUTATOR_REGISTRY, options.optInMutations);
 	const context = {
 		fileName: originFileName,
 		lineStarts,
 		mutateDescription,
 		offset: offset ?? MUTATION_OFFSET,
 		basePath,
-		mutatorEntries: selection.active,
-		allMutatorNames: selection.known.map((name) => name.toLowerCase()),
+		mutatorEntries: options.mutators.active,
+		allMutatorNames: options.mutators.known.map((name) => name.toLowerCase()),
 		excludedMutations: options.excludedMutations,
-		ignorers: options.ignorers
+		mutantSetPolicy: options.mutantSetPolicy,
+		ignorers: options.ignorers,
+		ordinalOf: mutantCollector.ordinalOf
 	};
 	const planned = yield* Effect.try({
-		try: () => planInstrumentation(root, mutantCollector.nextIndex, context),
+		try: () => planInstrumentation(root, context),
 		catch: traversalFailure
 	});
 	const plan = yield* Match.value(planned).pipe(Match.when(Result.isFailure, (refused) => {
@@ -4338,11 +4646,12 @@ const transformScriptDataFirst = Effect.fn("stryker.instrument.transform.script"
 	return plan.warnings;
 });
 const transformScript = dual((args) => args.length >= 3, transformScriptDataFirst);
-function toMutatorContext(ancestors) {
+function toMutatorContext(ancestors, mutantSetPolicy) {
 	return {
 		parent: ancestors[0],
 		grandParent: ancestors[1],
-		ancestors: [...ancestors]
+		ancestors: [...ancestors],
+		mutantSetPolicy
 	};
 }
 const toError = (value) => value instanceof Error ? value : new Error("Unexpected error", { cause: value });
@@ -4498,12 +4807,11 @@ const coreFormatRegistry = formatRegistry([
 ]);
 const resolveFileDataFirst = (registry, fileName, formatIdOverride) => resolveFormat(resolutionCommandOf(registry, fileName, formatIdOverride));
 const resolveFile = dual((args) => typeof args[0] !== "string", resolveFileDataFirst);
-const NO_OPT_IN_MUTATIONS = [];
-const optInMutationsOf = (options) => options.optInMutations ?? NO_OPT_IN_MUTATIONS;
 const isIgnorer = (value) => Predicate.isObject(value) && typeof value["shouldIgnore"] === "function";
 const toTransformerOptions = (options) => ({
 	excludedMutations: [...options.excludedMutations],
-	optInMutations: [...optInMutationsOf(options)],
+	mutators: options.mutators,
+	mutantSetPolicy: options.mutantSetPolicy,
 	ignorers: options.ignorers.filter(isIgnorer),
 	...options.noHeader !== void 0 ? { noHeader: options.noHeader } : {}
 });
@@ -4643,7 +4951,7 @@ const frameworkEntryOfDataFirst = (moduleName, framework) => ({
 	},
 	owner: moduleName,
 	ownerVersion: framework.claim.ownerVersion,
-	parse: Effect.fn("stryker.instrument.framework_entry.parse")(function* (text, fileName) {
+	parse: Effect.fn(SpanTaxonomy.Spans.instrumentFrameworkEntryParse.name)(function* (text, fileName) {
 		const context = frameworkContextOf(yield* loadFrameworkToolkit);
 		const lineStarts = lineStartsOf(text);
 		const result = yield* runHook(moduleName, "parse", fileName, () => framework.parse(text, context));
@@ -4660,7 +4968,7 @@ const frameworkEntryOfDataFirst = (moduleName, framework) => ({
 	}),
 	transform: (ast, mutantCollector, context) => Option.match(embeddedOf(ast), {
 		onNone: () => Effect.fail(embeddedAstError(ast)),
-		onSome: Effect.fn("stryker.instrument.framework_entry.transform")(function* (embedded) {
+		onSome: Effect.fn(SpanTaxonomy.Spans.instrumentFrameworkEntryTransform.name)(function* (embedded) {
 			const warnings = yield* Effect.forEach(embedded.scripts, (script) => context.transform(script.ast, mutantCollector, context));
 			embedded.document = yield* runHook(moduleName, "transform", embedded.originFileName, () => framework.transform(embedded.document, embedded.context));
 			return warnings.flat();
@@ -4699,7 +5007,7 @@ const readDisable = (input) => Effect.sync(() => {
 		registry: input.registry
 	};
 });
-const disableTypeChecksCell = Sandwich.named("stryker.instrument.disableTypeChecks")((input) => readDisable(input)).decide(resolveFormat).write({
+const disableTypeChecksCell = Sandwich.named(SpanTaxonomy.Spans.instrumentDisableTypeChecks.name)((input) => readDisable(input)).decide(resolveFormat).write({
 	FormatAssigned: (assigned, raw) => spliceForAssigned({
 		file: raw.file,
 		registry: raw.registry,
@@ -4755,7 +5063,7 @@ const skippedOnlyResult = (raw) => InstrumentResult.make({
 	mutants: [],
 	skipped: [...raw.skipped]
 });
-const readInstrumentFiles = Effect.fn("stryker.instrument.read_files")(function* (input) {
+const readInstrumentFiles = Effect.fn(SpanTaxonomy.Spans.instrumentReadFiles.name)(function* (input) {
 	const outcomes = yield* Effect.forEach(input.files, (file) => fileOutcome({
 		registry: input.registry,
 		file
@@ -4794,29 +5102,15 @@ const instrumentFilesCell = Sandwich.named("stryker.instrument.files")((input) =
 //#endregion
 //#region src/Instrument.service.ts
 const toSchemaFile = (file) => ({
-	name: CanonicalFileName.make(file.name),
+	name: Mutant.CanonicalFileName.make(file.name),
 	content: file.content,
 	mutate: file.mutate
 });
-const KNOWN_OPT_IN_MUTATIONS = Object.keys(optInMutators);
-const unknownOptInMutations = (requested) => requested.filter((name) => !KNOWN_OPT_IN_MUTATIONS.includes(name));
-const listNames = (names) => Option.match(Option.fromNullishOr(names.at(0)), {
-	onNone: () => "none",
-	onSome: () => names.map((name) => `'${name}'`).join(", ")
-});
-const unknownOptInMutationsError = (requested) => Option.map(Option.fromNullishOr(unknownOptInMutations(requested).at(0)), () => InstrumentError.make({
-	message: `Unknown opt-in mutations: ${listNames(unknownOptInMutations(requested))}. Known opt-in mutations: ${listNames(KNOWN_OPT_IN_MUTATIONS)}.`,
-	cause: void 0
-}));
-const refuseUnknownOptInMutations = (options) => Option.match(unknownOptInMutationsError(optInMutationsOf(options)), {
-	onNone: () => Effect.void,
-	onSome: (error) => Effect.fail(error)
-});
-const instrumentDataFirst = (files, options, registry = coreFormatRegistry) => refuseUnknownOptInMutations(options).pipe(Effect.andThen(instrumentFilesCell.run({
+const instrumentDataFirst = (files, options, registry = coreFormatRegistry) => instrumentFilesCell.run({
 	files: files.map(toSchemaFile),
 	options,
 	registry
-})));
+});
 const instrument = dual((args) => Array.isArray(args[0]), instrumentDataFirst);
 const disableTypeChecksDataFirst = (file, registry = coreFormatRegistry) => disableTypeChecksCell.run({
 	file: toSchemaFile(file),
@@ -4833,36 +5127,25 @@ const disableTypeChecks = dual((args) => Predicate.hasProperty(args[0], "content
 //#region src/Instrument/mod.ts
 var Instrument_exports = /* @__PURE__ */ __exportAll({
 	InstrumentFileSkip: () => InstrumentFileSkip,
+	InstrumenterContext: () => InstrumenterContext,
 	disableTypeChecks: () => disableTypeChecks,
 	instrument: () => instrument
 });
 //#endregion
-//#region src/Mutant/mod.ts
-var Mutant_exports = /* @__PURE__ */ __exportAll({
-	ActionableStatusSchema: () => ActionableStatusSchema,
-	CanonicalFileName: () => CanonicalFileName,
-	Column: () => Column,
-	EphemeralStatusSchema: () => EphemeralStatusSchema,
-	HitCount: () => HitCount,
-	InstrumenterContext: () => InstrumenterContext,
-	Line: () => Line,
-	Location: () => Location,
-	Mutant: () => Mutant,
-	MutantActivationSchema: () => MutantActivationSchema,
-	MutantCoverageSchema: () => MutantCoverageSchema,
-	MutantFromUnknown: () => MutantFromUnknown,
-	MutantId: () => MutantId,
-	MutantRunOptionsSchema: () => MutantRunOptionsSchema,
-	MutantStatusSchema: () => MutantStatusSchema,
-	MutatorName: () => MutatorName,
+//#region src/Mutator/mod.ts
+var Mutator_exports = /* @__PURE__ */ __exportAll({
+	defaultMutators: () => defaultMutators,
+	optInMutators: () => optInMutators,
+	registryOf: () => registryOf,
+	selectMutators: () => selectMutators,
+	stockRegistry: () => stockRegistry
+});
+//#endregion
+//#region src/Source/mod.ts
+var Source_exports = /* @__PURE__ */ __exportAll({
 	Offset: () => Offset,
-	OpenEndLocation: () => OpenEndLocation,
-	Position: () => Position,
-	RememberedStatusSchema: () => RememberedStatusSchema,
-	RunOptionsFields: () => RunOptionsFields,
 	ScriptOrigin: () => ScriptOrigin,
-	Span: () => Span,
-	SurvivorStatusSchema: () => SurvivorStatusSchema
+	Span: () => Span
 });
 //#endregion
-export { ErrorText_exports as ErrorText, Format_exports as Format, Instrument_exports as Instrument, Mutant_exports as Mutant, lineStartsOf, locationOf, offsetAt, originAt, positionAt };
+export { ErrorText_exports as ErrorText, Format_exports as Format, Instrument_exports as Instrument, Mutator_exports as Mutator, Source_exports as Source, lineStartsOf, locationOf, offsetAt, originAt, positionAt };