@systemfsoftware/stryker-js-instrumenter 12.1.0 → 15.0.0

package/dist/index.mjs

@@ -36,8 +36,8 @@ function readFieldOf(record, key) {
 	return record[key];
 }
 const fieldOf = (value, key) => Option.getOrUndefined(Option.filter(Option.some(value), (candidate) => Predicate.hasProperty(key)(candidate)).pipe(Option.map((record) => readFieldOf(record, key))));
-const hasStringCode = (error) => Match.value(fieldOf(error, "code")).pipe(Match.when(Match.string, () => true), Match.orElse(() => false));
-const isErrnoException = (error) => Match.value(error).pipe(Match.when(Match.instanceOf(Error), hasStringCode), Match.orElse(() => false));
+const isStringField = (error, key) => Match.value(fieldOf(error, key)).pipe(Match.when(Match.string, () => true), Match.orElse(() => false));
+const isErrnoException = (error) => Match.value(error).pipe(Match.when(Match.instanceOf(Error), (candidate) => isStringField(candidate, "code") && isStringField(candidate, "syscall")), Match.orElse(() => false));
 const isEmptyNumber = (value) => Match.value(value).pipe(Match.when(0, () => true), Match.orElse(Number.isNaN));
 const isEmptyError = (error) => Match.value(error).pipe(Match.when(Match.undefined, () => true), Match.when(Match.null, () => true), Match.when(Match.string, (text) => text.length === 0), Match.when(Match.number, isEmptyNumber), Match.when(Match.boolean, (value) => !value), Match.orElse(() => false));
 const formatErrnoException = (error) => Match.value(error.stack).pipe(Match.when(hasText, (stack) => `${error.name}: ${error.code} (${error.syscall}) ${stack}`), Match.orElse(() => `${error.name}: ${error.code} (${error.syscall})`));
@@ -211,6 +211,180 @@ var MutantsUnplaced = class extends S.TaggedError()("MutantsUnplaced", {
 };
 var PlacementRefused = class extends S.TaggedError()("PlacementRefused", { message: S.String }) {};
 //#endregion
+//#region src/assess-probe-eligibility.workflow.ts
+const OperandKind = S.Literals(["literal", "other"]);
+const BinaryOperator = S.Literals([
+	"==",
+	"!=",
+	"===",
+	"!==",
+	"<",
+	"<=",
+	">",
+	">=",
+	"<<",
+	">>",
+	">>>",
+	"+",
+	"-",
+	"*",
+	"/",
+	"%",
+	"**",
+	"|",
+	"^",
+	"&",
+	"in",
+	"instanceof"
+]);
+const UnaryOperator$1 = S.Literals([
+	"-",
+	"+",
+	"!",
+	"~",
+	"typeof",
+	"void",
+	"delete"
+]);
+const BinarySwap = S.TaggedStruct("BinarySwap", {
+	originalOperator: BinaryOperator,
+	replacementOperator: BinaryOperator
+});
+const UnarySwap = S.TaggedStruct("UnarySwap", {
+	originalOperator: UnaryOperator$1,
+	replacementOperator: S.NullOr(UnaryOperator$1)
+});
+const ConstantReplacement = S.TaggedStruct("ConstantReplacement", {
+	comparedOperator: S.NullOr(BinaryOperator),
+	left: OperandKind,
+	right: OperandKind
+});
+const UnrecognizedShape = S.TaggedStruct("UnrecognizedShape", {});
+const ProbeSite = S.Union([
+	BinarySwap,
+	UnarySwap,
+	ConstantReplacement,
+	UnrecognizedShape
+]);
+const ProbedMutatorName = S.Literals([
+	"ArithmeticOperator",
+	"EqualityOperator",
+	"UnaryOperator",
+	"ConditionalExpression"
+]);
+var AssessProbeEligibilityCommand = class extends S.TaggedClass()("AssessProbeEligibilityCommand", {
+	mutatorName: S.Union([ProbedMutatorName, S.String]),
+	site: ProbeSite
+}) {
+	static [Workflow.InstrumentationBrand] = {};
+};
+const ProbeDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js-instrumenter/ProbeDecision");
+var MutantProbed = class extends S.TaggedClass()("MutantProbed", { kind: Mutant.ProbeKind }) {
+	[ProbeDecisionTypeId] = ProbeDecisionTypeId;
+};
+var MutantUnprobed = class extends S.TaggedClass()("MutantUnprobed", { reason: Mutant.UnprobedReason }) {
+	[ProbeDecisionTypeId] = ProbeDecisionTypeId;
+};
+const PROBED_ARITHMETIC_ORIGINALS = {
+	"-": true,
+	"*": true,
+	"/": true,
+	"%": true
+};
+const ARITHMETIC_OPERATORS = {
+	"+": true,
+	...PROBED_ARITHMETIC_ORIGINALS
+};
+const RELATIONAL_OPERATORS$1 = {
+	"<": true,
+	"<=": true,
+	">": true,
+	">=": true
+};
+const EQUALITY_OPERATORS = {
+	"==": true,
+	"!=": true,
+	"===": true,
+	"!==": true
+};
+const COMPARISON_OPERATORS = {
+	...RELATIONAL_OPERATORS$1,
+	...EQUALITY_OPERATORS
+};
+const SIGN_OPERATORS = {
+	"+": true,
+	"-": true
+};
+const isIn = (table, operator) => table[operator] === true;
+const probed = (kind) => MutantProbed.make({ kind });
+const unprobed = (reason) => MutantUnprobed.make({ reason });
+const SHAPE_NOT_RECOGNIZED = () => unprobed("shape-not-recognized");
+const arithmeticSwap = (swap) => Boolean$1.match(isIn(PROBED_ARITHMETIC_ORIGINALS, swap.originalOperator), {
+	onFalse: () => unprobed("operator-not-probed"),
+	onTrue: () => Boolean$1.match(isIn(ARITHMETIC_OPERATORS, swap.replacementOperator), {
+		onFalse: SHAPE_NOT_RECOGNIZED,
+		onTrue: () => probed("arithmetic")
+	})
+});
+const nonRelationalEqualitySwap = (swap) => Boolean$1.match(isIn(EQUALITY_OPERATORS, swap.originalOperator), {
+	onFalse: () => unprobed("operator-not-probed"),
+	onTrue: () => unprobed("every-reach-infects")
+});
+const equalitySwap = (swap) => Boolean$1.match(isIn(RELATIONAL_OPERATORS$1, swap.originalOperator), {
+	onFalse: () => nonRelationalEqualitySwap(swap),
+	onTrue: () => Boolean$1.match(isIn(COMPARISON_OPERATORS, swap.replacementOperator), {
+		onFalse: SHAPE_NOT_RECOGNIZED,
+		onTrue: () => probed("relational")
+	})
+});
+const binarySwap = (mutator, swap) => Match.value(mutator).pipe(Match.when("ArithmeticOperator", () => arithmeticSwap(swap)), Match.when("EqualityOperator", () => equalitySwap(swap)), Match.when("UnaryOperator", SHAPE_NOT_RECOGNIZED), Match.when("ConditionalExpression", SHAPE_NOT_RECOGNIZED), Match.exhaustive);
+const FLIPPED_SIGN = {
+	"+": "-",
+	"-": "+"
+};
+const flipsSign = (swap) => Option.exists(Option.fromNullOr(swap.replacementOperator), (replacement) => replacement === FLIPPED_SIGN[swap.originalOperator]);
+const signSwap = (swap) => Boolean$1.match(isIn(SIGN_OPERATORS, swap.originalOperator), {
+	onFalse: () => unprobed("operator-not-probed"),
+	onTrue: () => Boolean$1.match(flipsSign(swap), {
+		onFalse: SHAPE_NOT_RECOGNIZED,
+		onTrue: () => probed("unary")
+	})
+});
+const unarySwap = (mutator, swap) => Match.value(mutator).pipe(Match.when("UnaryOperator", () => signSwap(swap)), Match.when("ArithmeticOperator", SHAPE_NOT_RECOGNIZED), Match.when("EqualityOperator", SHAPE_NOT_RECOGNIZED), Match.when("ConditionalExpression", SHAPE_NOT_RECOGNIZED), Match.exhaustive);
+const isComparison = (replacement) => Option.exists(Option.fromNullOr(replacement.comparedOperator), (operator) => isIn(COMPARISON_OPERATORS, operator));
+const isLiteral$1 = (operand) => operand === "literal";
+const comparisonConstant = (replacement) => Boolean$1.match(isComparison(replacement), {
+	onFalse: () => unprobed("not-a-comparison"),
+	onTrue: () => Boolean$1.match([replacement.left, replacement.right].every(isLiteral$1), {
+		onFalse: () => unprobed("operand-not-proven-local"),
+		onTrue: () => probed("constant")
+	})
+});
+const constantReplacement = (mutator, replacement) => Match.value(mutator).pipe(Match.when("ConditionalExpression", () => comparisonConstant(replacement)), Match.when("EqualityOperator", () => comparisonConstant(replacement)), Match.when("ArithmeticOperator", SHAPE_NOT_RECOGNIZED), Match.when("UnaryOperator", SHAPE_NOT_RECOGNIZED), Match.exhaustive);
+const siteDecision = (mutator, site) => Match.value(site).pipe(Match.tagsExhaustive({
+	BinarySwap: (swap) => binarySwap(mutator, swap),
+	UnarySwap: (swap) => unarySwap(mutator, swap),
+	ConstantReplacement: (replacement) => constantReplacement(mutator, replacement),
+	UnrecognizedShape: SHAPE_NOT_RECOGNIZED
+}));
+const assessProbeEligibility = Workflow.make({
+	command: AssessProbeEligibilityCommand,
+	decision: S.Union([MutantProbed, MutantUnprobed]),
+	error: S.Never,
+	decide: (command) => Result.succeed(Option.match(Option.liftPredicate(command.mutatorName, S.is(ProbedMutatorName)), {
+		onNone: () => unprobed("mutator-not-probed"),
+		onSome: (mutator) => siteDecision(mutator, command.site)
+	}))
+});
+//#endregion
+//#region src/relational-operator.schema.ts
+const RelationalOperator = S.Literals([
+	"<",
+	"<=",
+	">",
+	">="
+]);
+//#endregion
 //#region src/relational-sufficient-sets.ts
 /**
 * The sufficient sets of non-redundant relational-operator mutations.
@@ -228,12 +402,7 @@ var PlacementRefused = class extends S.TaggedError()("PlacementRefused", { messa
 * sets assume numeric operands without `NaN`; `mutantSetPolicy: 'full'`
 * restores every variant.
 */
-const RELATIONAL_OPERATORS = [
-	"<",
-	"<=",
-	">",
-	">="
-];
+const RELATIONAL_OPERATORS = RelationalOperator.literals;
 const isRelationalOperator = (operator) => RELATIONAL_OPERATORS.some((relational) => relational === operator);
 const SUFFICIENT_RELATIONAL_SETS = {
 	"<": {
@@ -751,106 +920,25 @@ const writeElement = (container, index, replacement) => Option.match(Option.filt
 	}
 });
 //#endregion
-//#region src/EffectCall.ts
-const MODULE_NAMES = [
-	"Effect",
-	"Ref",
-	"Semaphore",
-	"SynchronizedRef"
-];
+//#region src/effect-imports.ts
 const EFFECT_SOURCE = "effect";
 const FUNCTION_SOURCE = "effect/Function";
-const DATA_FIRST = "data-first";
-const DATA_LAST_PIPE_ARG = "data-last-pipe-arg";
-const DATA_LAST_PIPE_METHOD = "data-last-pipe-method";
-const DATA_LAST_IMMEDIATE = "data-last-immediate";
-const PIPED_REFERENCE = "piped-reference";
-const NO_ARGUMENTS = Object.freeze([]);
-const ARITIES = Object.freeze({
-	"Ref.modify": {
-		dataFirst: [2],
-		dataLast: 1
-	},
-	"Ref.modifySome": {
-		dataFirst: [2],
-		dataLast: 1
-	},
-	"Ref.update": {
-		dataFirst: [2],
-		dataLast: 1
-	},
-	"Ref.updateSome": {
-		dataFirst: [2],
-		dataLast: 1
-	},
-	"Ref.updateAndGet": {
-		dataFirst: [2],
-		dataLast: 1
-	},
-	"Ref.getAndUpdate": {
-		dataFirst: [2],
-		dataLast: 1
-	},
-	"SynchronizedRef.modify": {
-		dataFirst: [2],
-		dataLast: 1
-	},
-	"SynchronizedRef.modifySome": {
-		dataFirst: [2],
-		dataLast: 1
-	},
-	"SynchronizedRef.update": {
-		dataFirst: [2],
-		dataLast: 1
-	},
-	"SynchronizedRef.updateSome": {
-		dataFirst: [2],
-		dataLast: 1
-	},
-	"SynchronizedRef.updateAndGet": {
-		dataFirst: [2],
-		dataLast: 1
-	},
-	"SynchronizedRef.getAndUpdate": {
-		dataFirst: [2],
-		dataLast: 1
-	},
-	"Semaphore.withPermits": {
-		dataFirst: [3],
-		dataLast: 2
-	},
-	"Semaphore.withPermit": {
-		dataFirst: [2],
-		dataLast: 1
-	},
-	"Effect.ensuring": {
-		dataFirst: [2],
-		dataLast: 1
-	},
-	"Effect.onExit": {
-		dataFirst: [2],
-		dataLast: 1
-	},
-	"Effect.onError": {
-		dataFirst: [2],
-		dataLast: 1
-	},
-	"Effect.onInterrupt": {
-		dataFirst: [2],
-		dataLast: 1
-	},
-	"Effect.uninterruptible": { dataFirst: [1] },
-	"Effect.uninterruptibleMask": { dataFirst: [1] },
-	"Effect.acquireRelease": { dataFirst: [2, 3] },
-	"Effect.acquireUseRelease": { dataFirst: [3] }
-});
-const EMPTY_IMPORT_TABLE = Object.freeze({
+const emptyImportTable = (modules) => ({
+	modules,
 	moduleBindings: /* @__PURE__ */ new Map(),
 	namespaces: /* @__PURE__ */ new Map(),
 	bareFunctions: /* @__PURE__ */ new Map(),
-	pipeBindings: /* @__PURE__ */ new Set()
-});
-const buildImportTable = (program) => Arr.reduce(Arr.flatMap(Arr.filter(program.body, isImportDeclaration$1), importContributions), EMPTY_IMPORT_TABLE, applyContribution);
+	pipeBindings: /* @__PURE__ */ new Set(),
+	valueLocals: /* @__PURE__ */ new Set()
+});
+const buildImportTableDataFirst = (program, modules) => Arr.reduce(Arr.flatMap(Arr.filter(program.body, isImportDeclaration$1), (declaration) => importContributions(declaration, modules)), {
+	...emptyImportTable(modules),
+	valueLocals: valueImportLocals(program)
+}, applyContribution);
+const buildImportTable = dual((args) => args.length >= 2, buildImportTableDataFirst);
+const valueImportLocals = (program) => new Set(Arr.flatMap(Arr.filter(program.body, isImportDeclaration$1), valueSpecifierLocals));
+const valueSpecifierLocals = (declaration) => Option.toArray(onlyWhen(declaration.importKind !== "type", declaration)).flatMap((imported) => imported.specifiers.flatMap(valueSpecifierLocal));
+const valueSpecifierLocal = (specifier) => Match.value(specifier).pipe(Match.when(isNamedImportSpecifier, (named) => Option.toArray(onlyWhen(named.importKind !== "type", named.local.name))), Match.orElse((other) => [other.local.name]));
 const withEntry = (entries, key, value) => new Map([...entries, [key, value]]);
 const withMember = (members, value) => /* @__PURE__ */ new Set([...members, value]);
 const applyContribution = (table, contribution) => Match.value(contribution).pipe(Match.when((candidate) => candidate.kind === "module", (moduleBinding) => ({
@@ -869,13 +957,13 @@ const applyContribution = (table, contribution) => Match.value(contribution).pip
 	...table,
 	pipeBindings: withMember(table.pipeBindings, pipeBinding.local)
 })));
-const importContributions = (declaration) => Option.toArray(onlyWhen(declaration.importKind !== "type", declaration)).flatMap((imported) => Arr.flatMap(imported.specifiers, (specifier) => Option.toArray(specifierContribution(imported.source.value, specifier))));
-const specifierContribution = (source, specifier) => Match.value(specifier).pipe(Match.when(isNamedImportSpecifier, (named) => namedSpecifierContribution(source, named)), Match.when(isNamespaceImportSpecifier, (namespace) => namespaceSpecifierContribution(source, namespace)), Match.orElse(() => Option.none()));
-const namedSpecifierContribution = (source, specifier) => onlyWhen(specifier.importKind !== "type", specifier).pipe(Option.flatMap((imported) => namedContribution(source, moduleExportName(imported.imported), imported.local.name)));
-const namedContribution = (source, importedName, localName) => Match.value(source).pipe(Match.when((candidate) => candidate === EFFECT_SOURCE, () => effectRootContribution(importedName, localName)), Match.when((candidate) => candidate === FUNCTION_SOURCE, () => pipeContribution(importedName, localName)), Match.orElse(() => Option.map(moduleNameFromSource(source), (module) => bareFunctionContribution(localName, module, importedName))));
-const effectRootContribution = (importedName, localName) => Option.orElse(Option.map(moduleNameFromName(importedName), (module) => moduleContribution(localName, module)), () => pipeContribution(importedName, localName));
+const importContributions = (declaration, modules) => Option.toArray(onlyWhen(declaration.importKind !== "type", declaration)).flatMap((imported) => Arr.flatMap(imported.specifiers, (specifier) => Option.toArray(specifierContribution(imported.source.value, specifier, modules))));
+const specifierContribution = (source, specifier, modules) => Match.value(specifier).pipe(Match.when(isNamedImportSpecifier, (named) => namedSpecifierContribution(source, named, modules)), Match.when(isNamespaceImportSpecifier, (namespace) => namespaceSpecifierContribution(source, namespace, modules)), Match.orElse(() => Option.none()));
+const namedSpecifierContribution = (source, specifier, modules) => onlyWhen(specifier.importKind !== "type", specifier).pipe(Option.flatMap((imported) => namedContribution(source, moduleExportName(imported.imported), imported.local.name, modules)));
+const namedContribution = (source, importedName, localName, modules) => Match.value(source).pipe(Match.when((candidate) => candidate === EFFECT_SOURCE, () => effectRootContribution(importedName, localName, modules)), Match.when((candidate) => candidate === FUNCTION_SOURCE, () => pipeContribution(importedName, localName)), Match.orElse(() => Option.map(moduleNameFromSource(source, modules), (module) => bareFunctionContribution(localName, module, importedName))));
+const effectRootContribution = (importedName, localName, modules) => Option.orElse(Option.map(moduleNameFromName(importedName, modules), (module) => moduleContribution(localName, module)), () => pipeContribution(importedName, localName));
 const pipeContribution = (importedName, localName) => onlyWhen(importedName === "pipe", pipeContributionOf(localName));
-const namespaceSpecifierContribution = (source, specifier) => Option.map(namespaceBindingFor(source), (binding) => ({
+const namespaceSpecifierContribution = (source, specifier, modules) => Option.map(namespaceBindingFor(source, modules), (binding) => ({
 	kind: "namespace",
 	local: specifier.local.name,
 	binding
@@ -895,33 +983,14 @@ const pipeContributionOf = (local) => ({
 	kind: "pipe",
 	local
 });
-const namespaceBindingFor = (source) => Match.value(source).pipe(Match.when((candidate) => candidate === EFFECT_SOURCE, () => Option.some({ kind: "root" })), Match.when((candidate) => candidate === FUNCTION_SOURCE, () => Option.some({ kind: "functionModule" })), Match.orElse(() => Option.map(moduleNameFromSource(source), (module) => ({
+const namespaceBindingFor = (source, modules) => Match.value(source).pipe(Match.when((candidate) => candidate === EFFECT_SOURCE, () => Option.some({ kind: "root" })), Match.when((candidate) => candidate === FUNCTION_SOURCE, () => Option.some({ kind: "functionModule" })), Match.orElse(() => Option.map(moduleNameFromSource(source, modules), (module) => ({
 	kind: "module",
 	module
 }))));
-const moduleNameFromName = (name) => Arr.findFirst(MODULE_NAMES, (module) => module === name);
-const moduleNameFromSource = (source) => Arr.findFirst(MODULE_NAMES, (module) => source === `${EFFECT_SOURCE}/${module}`);
-const resolveEffectCallDataFirst = (node, context) => Option.flatMap(programOf(context), (program) => resolveIn(node, context, buildImportTable(program)));
-const resolveEffectCall = dual((args) => args.length >= 2, resolveEffectCallDataFirst);
-const programOf = (context) => Arr.findLast(context.ancestors, isProgram);
-const resolveIn = (node, context, table) => Match.value(node).pipe(Match.when(isCallExpression$1, (call) => resolveCall(call, context, table)), Match.when(isMemberExpression, (member) => resolveReference(member, context, table)), Match.when(isIdentifier$1, (reference) => resolveReference(reference, context, table)), Match.orElse(() => Option.none()));
-const resolveCall = (call, context, table) => Option.flatMap(resolveCallee(call.callee, context, table), (callee) => Option.flatMap(spreadFreeArguments$1(call.arguments), (args) => Option.flatMap(callForm(callee, args, call, context, table), (form) => Option.some({
-	module: callee.module,
-	exportName: callee.exportName,
-	form,
-	args,
-	moduleAccess: moduleAccessFunction(callee, context, table)
-}))));
-const resolveReference = (reference, context, table) => Option.flatMap(resolveCallee(reference, context, table), (callee) => Option.flatMap(referenceForm(reference, context, table), (form) => Option.some({
-	module: callee.module,
-	exportName: callee.exportName,
-	form,
-	args: NO_ARGUMENTS,
-	moduleAccess: moduleAccessFunction(callee, context, table)
-})));
-const referenceForm = (reference, context, table) => Option.flatMap(parentCall(context), (parent) => Option.map(pipePosition(parent, reference, context, table), () => PIPED_REFERENCE));
-const spreadFreeArguments$1 = (args) => Match.value(args.some(isSpreadElement)).pipe(Match.when(true, () => Option.none()), Match.orElse(() => Option.some(args.filter(isSpreadFree))));
-const resolveCallee = (callee, context, table) => Match.value(callee).pipe(Match.when(isIdentifier$1, (reference) => resolveBareCallee(reference, context, table)), Match.when(isMemberExpression, (member) => resolveMemberCallee(member, context, table)), Match.orElse(() => Option.none()));
+const moduleNameFromName = (name, modules) => Arr.findFirst(modules, (module) => module === name);
+const moduleNameFromSource = (source, modules) => Arr.findFirst(modules, (module) => source === `${EFFECT_SOURCE}/${module}`);
+const resolveCalleeDataFirst = (callee, context, table) => Match.value(callee).pipe(Match.when(isIdentifier$1, (reference) => resolveBareCallee(reference, context, table)), Match.when(isMemberExpression, (member) => resolveMemberCallee(member, context, table)), Match.orElse(() => Option.none()));
+const resolveCallee = dual((args) => args.length >= 3, resolveCalleeDataFirst);
 const resolveBareCallee = (reference, context, table) => Option.flatMap(Option.fromNullishOr(table.bareFunctions.get(reference.name)), (binding) => Option.map(unshadowedName(reference.name, context), () => ({
 	module: binding.module,
 	exportName: binding.exportName,
@@ -940,61 +1009,41 @@ const identifierModuleObject = (reference, context, table) => Option.orElse(Opti
 	module,
 	access: reference
 }))));
-const namespacedModuleObject = (member, context, table) => Option.flatMap(staticMemberName(member), (moduleName) => Option.flatMap(namespaceOf(member.object, context, table), (binding) => Match.value(binding).pipe(Match.when(isRootNamespace, () => Option.map(moduleNameFromName(moduleName), (module) => ({
+const namespacedModuleObject = (member, context, table) => Option.flatMap(staticMemberName(member), (moduleName) => Option.flatMap(namespaceOf(member.object, context, table), (binding) => moduleObjectOfNamespace(binding, moduleName, member, table)));
+const moduleObjectOfNamespace = (binding, moduleName, member, table) => binding.kind === "root" ? rootModuleObject(moduleName, member, table) : namedModuleObject(binding, moduleName, member);
+const rootModuleObject = (moduleName, member, table) => Option.map(moduleNameFromName(moduleName, table.modules), (module) => ({
 	module,
 	access: member
-}))), Match.when(isModuleNamespace, (moduleNamespace) => Option.map(onlyWhen(moduleNamespace.module === moduleName, member), (access) => ({
-	module: moduleNamespace.module,
+}));
+const namedModuleObject = (binding, moduleName, member) => binding.kind === "module" ? Option.map(onlyWhen(binding.module === moduleName, member), (access) => ({
+	module: binding.module,
 	access
-}))), Match.orElse(() => Option.none()))));
-const isRootNamespace = (binding) => binding.kind === "root";
-const moduleOf = (binding) => Match.value(binding).pipe(Match.when(isModuleNamespace, (moduleNamespace) => Option.some(moduleNamespace.module)), Match.orElse(() => Option.none()));
-const isModuleNamespace = (binding) => binding.kind === "module";
+})) : Option.none();
+const moduleOf = (binding) => binding.kind === "module" ? Option.some(binding.module) : Option.none();
 const namespaceOf = (expression, context, table) => Match.value(expression).pipe(Match.when(isIdentifier$1, (reference) => Option.flatMap(Option.fromNullishOr(table.namespaces.get(reference.name)), (binding) => Option.map(unshadowedName(reference.name, context), () => binding))), Match.orElse(() => Option.none()));
-const callForm = (callee, args, call, context, table) => Option.flatMap(arityOf(callee), (arity) => Match.value(args.length).pipe(Match.when((count) => arity.dataFirst.includes(count), () => Option.some(DATA_FIRST)), Match.when((count) => arity.dataLast === count, () => dataLastForm(call, context, table)), Match.orElse(() => Option.none())));
-const arityOf = (callee) => Option.fromNullishOr(ARITIES[`${callee.module}.${callee.exportName}`]);
-const dataLastForm = (call, context, table) => Option.flatMap(parentCall(context), (parent) => Match.value(parent.callee === call).pipe(Match.when(true, () => Option.some(DATA_LAST_IMMEDIATE)), Match.orElse(() => Option.flatMap(pipePosition(parent, call, context, table), formForPosition))));
-const pipePosition = (parent, argument, context, table) => Option.flatMap(argumentIndex(parent.arguments, argument), (index) => Option.orElse(onlyWhen(isPipeMethodCall(parent), {
-	index,
-	callee: "method"
-}), () => onlyWhen(isEffectPipeCall(parent, context, table), {
-	index,
-	callee: "effect"
-})));
-const formForPosition = (position) => Match.value(position.callee).pipe(Match.when((callee) => callee === "method", () => Option.some(DATA_LAST_PIPE_METHOD)), Match.orElse(() => onlyWhen(position.index >= 1, DATA_LAST_PIPE_ARG)));
-const argumentIndex = (args, node) => Option.flatMap(Option.fromNullishOr(args.findIndex((argument) => sameNode(argument, node))), (index) => onlyWhen(index >= 0, index));
-const parentCall = (context) => Option.flatMap(Option.fromNullishOr(context.parent), (parent) => Match.value(parent).pipe(Match.when(isCallExpression$1, (call) => Option.some(call)), Match.orElse(() => Option.none())));
-const isPipeMethodCall = (parent) => Match.value(parent.callee).pipe(Match.when(isMemberExpression, (member) => Option.exists(staticMemberName(member), (name) => name === "pipe")), Match.orElse(() => false));
-const isEffectPipeCall = (parent, context, table) => Match.value(parent.callee).pipe(Match.when(isIdentifier$1, (reference) => Boolean$1.and(isVisible(reference.name, context), table.pipeBindings.has(reference.name))), Match.when(isMemberExpression, (member) => Option.exists(staticMemberName(member), (name) => Boolean$1.and(name === "pipe", isPipeNamespace(member.object, context, table)))), Match.orElse(() => false));
-const isPipeNamespace = (expression, context, table) => Match.value(expression).pipe(Match.when(isIdentifier$1, (reference) => Option.match(namespaceOf(expression, context, table), {
-	onNone: () => false,
-	onSome: (binding) => Boolean$1.and(isPipeNamespaceBinding(binding), isVisible(reference.name, context))
-})), Match.orElse(() => false));
-const isPipeNamespaceBinding = (binding) => Match.value(binding.kind).pipe(Match.when((kind) => kind === "root", () => true), Match.when((kind) => kind === "functionModule", () => true), Match.orElse(() => false));
-const moduleAccessFunction = (callee, context, table) => (module) => Arr.findFirst([
+const moduleAccessFunctionDataFirst = (callee, context, table) => (module) => Arr.findFirst([
 	ownerAccessFor(callee, module),
 	namedModuleAccess(module, context, table),
 	rootNamespaceAccess(module, context, table),
 	moduleNamespaceAccess(module, context, table)
 ], Option.isSome).pipe(Option.flatten);
+const moduleAccessFunction = dual((args) => args.length >= 3, moduleAccessFunctionDataFirst);
 const ownerAccessFor = (callee, module) => Option.flatMap(callee.owner, (owner) => onlyWhen(owner.module === module, owner.access));
 const namedModuleAccess = (module, context, table) => Option.map(Option.fromNullishOr(table.moduleBindings.entries().find(([local, bound]) => Boolean$1.and(bound === module, isVisible(local, context)))), ([local]) => identifier(local));
 const rootNamespaceAccess = (module, context, table) => Option.map(Option.fromNullishOr(table.namespaces.entries().find(([local, binding]) => Boolean$1.and(binding.kind === "root", isVisible(local, context)))), ([local]) => memberExpression(identifier(local), identifier(module), false));
 const moduleNamespaceAccess = (module, context, table) => Option.map(Option.fromNullishOr(table.namespaces.entries().find(([local, binding]) => Option.exists(moduleOf(binding), (bound) => bound === module) && isVisible(local, context))), ([local]) => identifier(local));
-const isMovableArgument = (node) => nodesOutsideFunctions(node).every((candidate) => YIELD_OR_AWAIT_KINDS[nodeType(candidate) ?? ""] !== true);
-const YIELD_OR_AWAIT_KINDS = {
-	AwaitExpression: true,
-	YieldExpression: true
-};
-const isDroppableArgument = (node) => Match.value(node).pipe(Match.when(isIdentifier$1, () => true), Match.when(isLiteral, () => true), Match.when(isThisExpression, () => true), Match.when(isFunctionLike, () => true), Match.when(isMemberExpression, (member) => isCallFreeMemberChain(member)), Match.orElse(() => false));
-const isCallFreeMemberChain = (member) => Match.value(member.computed).pipe(Match.when(true, () => false), Match.orElse(() => Match.value(member.object).pipe(Match.when(isIdentifier$1, () => true), Match.when(isThisExpression, () => true), Match.when(isMemberExpression, (inner) => isCallFreeMemberChain(inner)), Match.orElse(() => false))));
-const identifiersIn = (node) => allNodesUnder(node).flatMap((candidate) => Option.toArray(identifierText(candidate)));
-const freshIdentifierDataFirst = (base, taken) => freeIdentifier(base, taken, 0);
-const freshIdentifier = dual((args) => args.length >= 2, freshIdentifierDataFirst);
-const freeIdentifier = (base, taken, suffix) => Match.value(taken.has(suffixedName(base, suffix))).pipe(Match.when(false, () => suffixedName(base, suffix)), Match.orElse(() => freeIdentifier(base, taken, suffix + 1)));
-const suffixedName = (base, suffix) => Match.value(suffix).pipe(Match.when(0, () => base), Match.orElse((count) => `${base}${count}`));
-const isShadowed = (name, context) => context.ancestors.some((ancestor) => scopeDeclares(ancestor, name));
-const isVisible = (name, context) => isShadowed(name, context) === false;
+const isEffectPipeCallDataFirst = (parent, context, table) => Match.value(parent.callee).pipe(Match.when(isIdentifier$1, (reference) => Boolean$1.and(isVisible(reference.name, context), table.pipeBindings.has(reference.name))), Match.when(isMemberExpression, (member) => Option.exists(staticMemberName(member), (name) => Boolean$1.and(name === "pipe", isPipeNamespace(member.object, context, table)))), Match.orElse(() => false));
+const isEffectPipeCall = dual((args) => args.length >= 3, isEffectPipeCallDataFirst);
+const isPipeNamespace = (expression, context, table) => Match.value(expression).pipe(Match.when(isIdentifier$1, (reference) => Option.match(namespaceOf(expression, context, table), {
+	onNone: () => false,
+	onSome: (binding) => Boolean$1.and(isPipeNamespaceBinding(binding), isVisible(reference.name, context))
+})), Match.orElse(() => false));
+const isPipeNamespaceBinding = (binding) => Match.value(binding.kind).pipe(Match.when((kind) => kind === "root", () => true), Match.when((kind) => kind === "functionModule", () => true), Match.orElse(() => false));
+const isImportedLocalDataFirst = (name, table) => table.valueLocals.has(name);
+const isImportedLocal = dual((args) => args.length >= 2, isImportedLocalDataFirst);
+const isShadowedDataFirst = (name, context) => context.ancestors.some((ancestor) => scopeDeclares(ancestor, name));
+const isShadowed = dual((args) => args.length >= 2, isShadowedDataFirst);
+const isVisible = (name, context) => isShadowedDataFirst(name, context) === false;
 const unshadowedName = (name, context) => onlyWhen(isVisible(name, context), name);
 const scopeDeclares = (ancestor, name) => Match.value(ancestor).pipe(Match.when(isProgram, (program) => statementsDeclare(program.body, name)), Match.when(isBlockStatement, (block) => statementsDeclare(block.body, name)), Match.when(isStaticBlock, (block) => statementsDeclare(block.body, name)), Match.when(isTSModuleBlock, (block) => statementsDeclare(block.body, name)), Match.when(isSwitchStatement, (statement) => statement.cases.some((caseClause) => statementsDeclare(caseClause.consequent, name))), Match.when(isFunctionLike, (fn) => functionDeclares(fn, name)), Match.when(isCatchClause, (clause) => patternDeclaresOr(clause.param, name)), Match.when(isForStatement, (statement) => variableDeclarationDeclaresOr(statement.init, name)), Match.when(isForInStatement, (statement) => variableDeclarationDeclaresOr(statement.left, name)), Match.when(isForOfStatement, (statement) => variableDeclarationDeclaresOr(statement.left, name)), Match.when(isClassLike, (cls) => declaresIdentifier(cls.id, name)), Match.orElse(() => false));
 const functionDeclares = (fn, name) => holdsAny([
@@ -1044,23 +1093,13 @@ const nodesOutsideFunctions = (root) => {
 	} });
 	return collected;
 };
-const allNodesUnder = (root) => {
-	const collected = [];
-	traverse(make(root), { enter(path) {
-		collected.push(path.node);
-	} });
-	return collected;
-};
 const pruneAtFunction = (path) => Option.match(onlyWhen(isFunctionLike(path.node), path), {
 	onNone: () => void 0,
 	onSome: (atFunction) => atFunction.skip()
 });
-const moduleCallDataFirst = (module, property, args) => callExpression(memberExpression(module, identifier(property), false), args);
-const moduleCall = dual((args) => args.length >= 3, moduleCallDataFirst);
 const onlyWhenDataFirst = (holds, value) => Match.value(holds).pipe(Match.when(true, () => Option.some(value)), Match.orElse(() => Option.none()));
 const onlyWhen = dual((args) => args.length >= 2, onlyWhenDataFirst);
 const holdsAny = (conditions) => conditions.some((condition) => condition);
-const sameNode = (first, second) => first === second;
 const FUNCTION_KINDS$1 = {
 	ArrowFunctionExpression: true,
 	FunctionDeclaration: true,
@@ -1097,6 +1136,154 @@ const isNamedIdentifier = (candidate) => nodeType(candidate) === "Identifier";
 const isThisExpression = (candidate) => nodeType(candidate) === "ThisExpression";
 const isLiteral = (candidate) => nodeType(candidate) === "Literal";
 const isStringLiteral$1 = (candidate) => nodeType(candidate) === "Literal";
+//#endregion
+//#region src/EffectCall.ts
+const MODULE_NAMES = [
+	"Effect",
+	"Ref",
+	"Semaphore",
+	"SynchronizedRef"
+];
+const DATA_FIRST = "data-first";
+const DATA_LAST_PIPE_ARG = "data-last-pipe-arg";
+const DATA_LAST_PIPE_METHOD = "data-last-pipe-method";
+const DATA_LAST_IMMEDIATE = "data-last-immediate";
+const PIPED_REFERENCE = "piped-reference";
+const NO_ARGUMENTS = Object.freeze([]);
+const ARITIES = Object.freeze({
+	"Ref.modify": {
+		dataFirst: [2],
+		dataLast: 1
+	},
+	"Ref.modifySome": {
+		dataFirst: [2],
+		dataLast: 1
+	},
+	"Ref.update": {
+		dataFirst: [2],
+		dataLast: 1
+	},
+	"Ref.updateSome": {
+		dataFirst: [2],
+		dataLast: 1
+	},
+	"Ref.updateAndGet": {
+		dataFirst: [2],
+		dataLast: 1
+	},
+	"Ref.getAndUpdate": {
+		dataFirst: [2],
+		dataLast: 1
+	},
+	"SynchronizedRef.modify": {
+		dataFirst: [2],
+		dataLast: 1
+	},
+	"SynchronizedRef.modifySome": {
+		dataFirst: [2],
+		dataLast: 1
+	},
+	"SynchronizedRef.update": {
+		dataFirst: [2],
+		dataLast: 1
+	},
+	"SynchronizedRef.updateSome": {
+		dataFirst: [2],
+		dataLast: 1
+	},
+	"SynchronizedRef.updateAndGet": {
+		dataFirst: [2],
+		dataLast: 1
+	},
+	"SynchronizedRef.getAndUpdate": {
+		dataFirst: [2],
+		dataLast: 1
+	},
+	"Semaphore.withPermits": {
+		dataFirst: [3],
+		dataLast: 2
+	},
+	"Semaphore.withPermit": {
+		dataFirst: [2],
+		dataLast: 1
+	},
+	"Effect.ensuring": {
+		dataFirst: [2],
+		dataLast: 1
+	},
+	"Effect.onExit": {
+		dataFirst: [2],
+		dataLast: 1
+	},
+	"Effect.onError": {
+		dataFirst: [2],
+		dataLast: 1
+	},
+	"Effect.onInterrupt": {
+		dataFirst: [2],
+		dataLast: 1
+	},
+	"Effect.uninterruptible": { dataFirst: [1] },
+	"Effect.uninterruptibleMask": { dataFirst: [1] },
+	"Effect.acquireRelease": { dataFirst: [2, 3] },
+	"Effect.acquireUseRelease": { dataFirst: [3] }
+});
+const resolveEffectCallDataFirst = (node, context) => Option.flatMap(programOf(context), (program) => resolveIn(node, context, buildImportTable(program, MODULE_NAMES)));
+const resolveEffectCall = dual((args) => args.length >= 2, resolveEffectCallDataFirst);
+const programOf = (context) => Arr.findLast(context.ancestors, isProgram);
+const resolveIn = (node, context, table) => Match.value(node).pipe(Match.when(isCallExpression$1, (call) => resolveCall(call, context, table)), Match.when(isMemberExpression, (member) => resolveReference(member, context, table)), Match.when(isIdentifier$1, (reference) => resolveReference(reference, context, table)), Match.orElse(() => Option.none()));
+const resolveCall = (call, context, table) => Option.flatMap(resolveCallee(call.callee, context, table), (callee) => Option.flatMap(spreadFreeArguments$1(call.arguments), (args) => Option.flatMap(callForm(callee, args, call, context, table), (form) => Option.some({
+	module: callee.module,
+	exportName: callee.exportName,
+	form,
+	args,
+	moduleAccess: moduleAccessFunction(callee, context, table)
+}))));
+const resolveReference = (reference, context, table) => Option.flatMap(resolveCallee(reference, context, table), (callee) => Option.flatMap(referenceForm(reference, context, table), (form) => Option.some({
+	module: callee.module,
+	exportName: callee.exportName,
+	form,
+	args: NO_ARGUMENTS,
+	moduleAccess: moduleAccessFunction(callee, context, table)
+})));
+const referenceForm = (reference, context, table) => Option.flatMap(parentCall(context), (parent) => Option.map(pipePosition(parent, reference, context, table), () => PIPED_REFERENCE));
+const spreadFreeArguments$1 = (args) => Match.value(args.some(isSpreadElement)).pipe(Match.when(true, () => Option.none()), Match.orElse(() => Option.some(args.filter(isSpreadFree))));
+const callForm = (callee, args, call, context, table) => Option.flatMap(arityOf(callee), (arity) => Match.value(args.length).pipe(Match.when((count) => arity.dataFirst.includes(count), () => Option.some(DATA_FIRST)), Match.when((count) => arity.dataLast === count, () => dataLastForm(call, context, table)), Match.orElse(() => Option.none())));
+const arityOf = (callee) => Option.fromNullishOr(ARITIES[`${callee.module}.${callee.exportName}`]);
+const dataLastForm = (call, context, table) => Option.flatMap(parentCall(context), (parent) => Match.value(parent.callee === call).pipe(Match.when(true, () => Option.some(DATA_LAST_IMMEDIATE)), Match.orElse(() => Option.flatMap(pipePosition(parent, call, context, table), formForPosition))));
+const pipePosition = (parent, argument, context, table) => Option.flatMap(argumentIndex(parent.arguments, argument), (index) => Option.orElse(onlyWhen(isPipeMethodCall(parent), {
+	index,
+	callee: "method"
+}), () => onlyWhen(isEffectPipeCall(parent, context, table), {
+	index,
+	callee: "effect"
+})));
+const formForPosition = (position) => Match.value(position.callee).pipe(Match.when((callee) => callee === "method", () => Option.some(DATA_LAST_PIPE_METHOD)), Match.orElse(() => onlyWhen(position.index >= 1, DATA_LAST_PIPE_ARG)));
+const argumentIndex = (args, node) => Option.flatMap(Option.fromNullishOr(args.findIndex((argument) => sameNode(argument, node))), (index) => onlyWhen(index >= 0, index));
+const parentCall = (context) => Option.flatMap(Option.fromNullishOr(context.parent), (parent) => Match.value(parent).pipe(Match.when(isCallExpression$1, (call) => Option.some(call)), Match.orElse(() => Option.none())));
+const isPipeMethodCall = (parent) => Match.value(parent.callee).pipe(Match.when(isMemberExpression, (member) => Option.exists(staticMemberName(member), (name) => name === "pipe")), Match.orElse(() => false));
+const isMovableArgument = (node) => nodesOutsideFunctions(node).every((candidate) => YIELD_OR_AWAIT_KINDS[nodeType(candidate) ?? ""] !== true);
+const YIELD_OR_AWAIT_KINDS = {
+	AwaitExpression: true,
+	YieldExpression: true
+};
+const isDroppableArgument = (node) => Match.value(node).pipe(Match.when(isIdentifier$1, () => true), Match.when(isLiteral, () => true), Match.when(isThisExpression, () => true), Match.when(isFunctionLike, () => true), Match.when(isMemberExpression, (member) => isCallFreeMemberChain(member)), Match.orElse(() => false));
+const isCallFreeMemberChain = (member) => Match.value(member.computed).pipe(Match.when(true, () => false), Match.orElse(() => Match.value(member.object).pipe(Match.when(isIdentifier$1, () => true), Match.when(isThisExpression, () => true), Match.when(isMemberExpression, (inner) => isCallFreeMemberChain(inner)), Match.orElse(() => false))));
+const identifiersIn = (node) => allNodesUnder(node).flatMap((candidate) => Option.toArray(identifierText(candidate)));
+const freshIdentifierDataFirst = (base, taken) => freeIdentifier(base, taken, 0);
+const freshIdentifier = dual((args) => args.length >= 2, freshIdentifierDataFirst);
+const freeIdentifier = (base, taken, suffix) => Match.value(taken.has(suffixedName(base, suffix))).pipe(Match.when(false, () => suffixedName(base, suffix)), Match.orElse(() => freeIdentifier(base, taken, suffix + 1)));
+const suffixedName = (base, suffix) => Match.value(suffix).pipe(Match.when(0, () => base), Match.orElse((count) => `${base}${count}`));
+const allNodesUnder = (root) => {
+	const collected = [];
+	traverse(make(root), { enter(path) {
+		collected.push(path.node);
+	} });
+	return collected;
+};
+const moduleCallDataFirst = (module, property, args) => callExpression(memberExpression(module, identifier(property), false), args);
+const moduleCall = dual((args) => args.length >= 3, moduleCallDataFirst);
+const sameNode = (first, second) => first === second;
 const isSpreadElement = (argument) => nodeType(argument) === "SpreadElement";
 const isSpreadFree = (argument) => nodeType(argument) !== "SpreadElement";
 //#endregion
@@ -1324,10 +1511,55 @@ function createMutantDataFirst(planned, fileName, original, replacement) {
 		replacement,
 		mutatorName: planned.mutatorName,
 		ignoreReason: planned.ignoreReason,
-		replacementCode: planned.replacementCode
+		replacementCode: planned.replacementCode,
+		...planned.subsumption === void 0 ? {} : { subsumption: planned.subsumption }
 	};
 }
 const createMutant = dual((args) => args.length >= 4, createMutantDataFirst);
+const subsumptionFieldOf = (mutant) => Option.match(Option.fromUndefinedOr(mutant.subsumption), {
+	onNone: () => ({}),
+	onSome: (subsumption) => ({ subsumption })
+});
+const statusReasonOf = (mutant) => Option.orElse(Option.fromUndefinedOr(mutant.ignoreReason), () => Option.map(Option.fromUndefinedOr(mutant.subsumption), Mutant.subsumedStatusReason));
+const isPrimitiveLiteral = (node) => node.type === "Literal" && !Predicate.hasProperty(node, "regex");
+const operandKindOf = (node) => isPrimitiveLiteral(node) ? "literal" : "other";
+const constantReplacementOf = (original) => isBinaryExpression(original) ? {
+	_tag: "ConstantReplacement",
+	comparedOperator: original.operator,
+	left: operandKindOf(original.left),
+	right: operandKindOf(original.right)
+} : {
+	_tag: "ConstantReplacement",
+	comparedOperator: null,
+	left: "other",
+	right: "other"
+};
+const unarySwapOf = (original, replacement) => ({
+	_tag: "UnarySwap",
+	originalOperator: original.operator,
+	replacementOperator: isPrefixUnaryExpression(replacement) ? replacement.operator : null
+});
+const probeSiteOf = (original, replacement) => Match.value({
+	original,
+	replacement
+}).pipe(Match.when({ replacement: isBooleanLiteral }, () => constantReplacementOf(original)), Match.when({
+	original: isBinaryExpression,
+	replacement: isBinaryExpression
+}, (pair) => ({
+	_tag: "BinarySwap",
+	originalOperator: pair.original.operator,
+	replacementOperator: pair.replacement.operator
+})), Match.when({ original: isPrefixUnaryExpression }, (pair) => unarySwapOf(pair.original, pair.replacement)), Match.orElse(() => ({ _tag: "UnrecognizedShape" })));
+const probeEligibilityOf = (mutant) => Result.match(assessProbeEligibility(AssessProbeEligibilityCommand.make({
+	mutatorName: mutant.mutatorName,
+	site: probeSiteOf(mutant.original, mutant.replacement)
+})), {
+	onFailure: (never) => never,
+	onSuccess: (decision) => Match.value(decision).pipe(Match.tagsExhaustive({
+		MutantProbed: (decided) => Mutant.Probed.make({ kind: decided.kind }),
+		MutantUnprobed: (decided) => Mutant.Unprobed.make({ reason: decided.reason })
+	}))
+});
 function toApiMutant(mutant) {
 	const baseFields = {
 		_tag: "Mutant",
@@ -1335,13 +1567,18 @@ function toApiMutant(mutant) {
 		id: mutant.id,
 		location: mutant.location,
 		mutatorName: mutant.mutatorName,
-		replacement: mutant.replacementCode
+		replacement: mutant.replacementCode,
+		probeEligibility: probeEligibilityOf(mutant)
 	};
-	return S.decodeResult(Mutant.Mutant)(mutant.ignoreReason === void 0 ? baseFields : {
-		...baseFields,
-		statusReason: mutant.ignoreReason,
-		status: "Ignored"
-	});
+	return S.decodeResult(Mutant.Mutant)(Option.match(statusReasonOf(mutant), {
+		onNone: () => baseFields,
+		onSome: (statusReason) => ({
+			...baseFields,
+			statusReason,
+			status: "Ignored",
+			...subsumptionFieldOf(mutant)
+		})
+	}));
 }
 function applyMutantDataFirst(mutant, originalTree) {
 	return Match.value(originalTree === mutant.original).pipe(Match.when(true, () => Result.succeed(mutant.replacement)), Match.when(false, () => cloneWithReplacement(mutant, originalTree)), Match.exhaustive);
@@ -1847,26 +2084,12 @@ function isConditionPosition(node, context) {
 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) => ({
+const relationalOperatorOf = (node) => Option.filter(Option.fromNullishOr(binaryOperatorOf(node)), isRelationalOperator);
+const isRelationalComparison = (node) => Option.isSome(relationalOperatorOf(node));
+const relationalSiteFacts = (node, context) => Option.getOrUndefined(Option.map(relationalOperatorOf(node), (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);
 }
@@ -2157,8 +2380,12 @@ function isUpdateExpression(node) {
 * Naming each mutator here costs one line when a mutator is added and makes
 * that line a compile-checked import instead of a runtime effect.
 *
-* `optInMutators` below follows the same hand-written rule, for the same
-* reason: a mutator exists for a run only when a human named it here.
+* Every stock mutator is default-tier: the stock registry declares no opt-in
+* entries, so `stockRegistry.optIn` is empty. Opt-in is a tier only a plugin
+* catalog declares for its own entries; a stock name placed in a run's
+* `mutator.optInMutations` is refused before instrumentation as a config
+* failure (`NotOptInTier`), because naming a default-tier entry as opt-in
+* would silently select nothing.
 */
 const defaultMutators = Object.freeze({
 	ArithmeticOperator: arithmeticOperatorMutator,
@@ -2176,23 +2403,17 @@ const defaultMutators = Object.freeze({
 	Regex: regexMutator,
 	StringLiteral: stringLiteralMutator,
 	UnaryOperator: unaryOperatorMutator,
-	UpdateOperator: updateOperatorMutator
-});
-const optInMutators = Object.freeze({
+	UpdateOperator: updateOperatorMutator,
 	AtomicUpdateSplit: atomicUpdateSplitMutator,
 	SynchronizationRemoval: synchronizationRemovalMutator,
 	FinalizerEscape: finalizerEscapeMutator
 });
 const stockRegistry = {
 	defaults: defaultMutators,
-	optIn: optInMutators
+	optIn: {}
 };
 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 implementations = new Map([...Object.entries(defaultMutators), ...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: () => [],
@@ -2211,9 +2432,12 @@ const registryOf = dual((args) => args.length >= 2, registryOfDataFirst);
 * of the defaults and removes none. Selection walks the registry's declared
 * order, not the order the run listed its names in, so a mutant's identity
 * never depends on how a config happened to spell the list; a name listed
-* twice selects its entry once. An unknown name selects nothing here —
-* `instrument` refuses it before any file is parsed, because a typo that
-* silently enables nothing removes mutants and raises the score.
+* twice selects its entry once. A name the loaded catalogs do not declare
+* opt-in selects nothing here; the refusal lives in `decodeMutatorSelection`
+* (packages/stryker-js/src/decode-mutator-selection.workflow.ts), which runs
+* before instrumentation and fails the run for an unknown or default-tier
+* name, because a typo that silently enables nothing removes mutants and
+* raises the score.
 *
 * Pure: a registry and a run's names in, entries and names out.
 */
@@ -2235,9 +2459,9 @@ var ParseFailed = class extends S.TaggedError("@systemfsoftware/stryker-js-instr
 	}
 };
 //#endregion
-//#region src/Parser.service.ts
+//#region src/Parser.ts
 const oxcModule = Effect.cached(Effect.promise(() => import("oxc-parser")));
-const loadOxc = Effect.flatMap(oxcModule, (load) => load);
+const loadOxc = Effect.flatten(oxcModule);
 const parseWithOxcDataFirst = Effect.fn(SpanTaxonomy.Spans.instrumentParserParseWithOxc.name)(function* (text, fileName, lang) {
 	const result = (yield* loadOxc).parseSync(fileName, text, {
 		lang,
@@ -3398,75 +3622,120 @@ const AridRuleId = S.Literals([
 	"arid-config-default",
 	"arid-memoization"
 ]);
-const AridCalleeSchema = S.Struct({
-	object: S.String,
+const AridEffectModule = S.Literals([
+	"Effect",
+	"Logger",
+	"Metric",
+	"Schedule",
+	"Duration",
+	"Config"
+]);
+const AridGlobalObject = S.Literals(["console"]);
+const AridEffectExportCallee = S.TaggedStruct("EffectExport", {
+	module: AridEffectModule,
+	exportName: S.String
+});
+const AridGlobalCallee = S.TaggedStruct("Global", {
+	name: AridGlobalObject,
 	member: S.String
 });
-const AridFrameSchema = S.Struct({
-	callee: S.Option(AridCalleeSchema),
-	childIsArgument: S.Boolean
+const AridCalleeSchema = S.Union([AridEffectExportCallee, AridGlobalCallee]);
+const AridArgumentFrame = S.TaggedStruct("ArgumentFrame", { callee: S.Option(AridCalleeSchema) });
+const AridThroughFrame = S.TaggedStruct("ThroughFrame", {});
+const AridFunctionBoundary = S.TaggedStruct("FunctionBoundary", {});
+const AridFrameSchema = S.Union([
+	AridArgumentFrame,
+	AridThroughFrame,
+	AridFunctionBoundary
+]);
+const isCallFrame = (frame) => Match.value(frame).pipe(Match.tagsExhaustive({
+	ArgumentFrame: () => true,
+	ThroughFrame: () => true,
+	FunctionBoundary: () => false
+}));
+const matchCallee = (callee, arms) => Match.value(callee).pipe(Match.tagsExhaustive({
+	EffectExport: arms.effectExport,
+	Global: arms.global
+}));
+const readsModule = (callee, module) => matchCallee(callee, {
+	effectExport: (effectExport) => effectExport.module === module,
+	global: () => false
+});
+const readsExport = (callee, module, exportName) => matchCallee(callee, {
+	effectExport: (effectExport) => [effectExport.module === module, effectExport.exportName === exportName].every(Boolean),
+	global: () => false
+});
+const readsExportPrefixed = (callee, module, prefix) => matchCallee(callee, {
+	effectExport: (effectExport) => [effectExport.module === module, effectExport.exportName.startsWith(prefix)].every(Boolean),
+	global: () => false
+});
+const readsGlobal = (callee) => matchCallee(callee, {
+	effectExport: () => false,
+	global: () => true
 });
-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")
+		matches: (callee) => readsExportPrefixed(callee, "Effect", "log")
 	},
 	{
 		ruleId: "arid-logging",
-		matches: (callee) => NAMED_LOGGERS.includes(callee.object)
+		matches: (callee) => readsModule(callee, "Logger")
+	},
+	{
+		ruleId: "arid-logging",
+		matches: readsGlobal
 	},
 	{
 		ruleId: "arid-telemetry",
-		matches: (callee) => readsMember(callee, "Effect", "withSpan")
+		matches: (callee) => readsExport(callee, "Effect", "withSpan")
 	},
 	{
 		ruleId: "arid-telemetry",
-		matches: (callee) => readsMemberPrefixed(callee, "Effect", "annotate")
+		matches: (callee) => readsExportPrefixed(callee, "Effect", "annotate")
 	},
 	{
 		ruleId: "arid-telemetry",
-		matches: (callee) => readsMember(callee, "Effect", "withLogSpan")
+		matches: (callee) => readsExport(callee, "Effect", "withLogSpan")
 	},
 	{
 		ruleId: "arid-telemetry",
-		matches: (callee) => readsNamespace(callee, "Metric")
+		matches: (callee) => readsModule(callee, "Metric")
 	},
 	{
-		ruleId: "arid-time",
-		matches: (callee) => readsMember(callee, "Effect", "sleep")
+		ruleId: "arid-telemetry",
+		matches: (callee) => readsExport(callee, "Effect", "fn")
 	},
 	{
 		ruleId: "arid-time",
-		matches: (callee) => readsNamespace(callee, "Schedule")
+		matches: (callee) => readsExport(callee, "Effect", "sleep")
 	},
 	{
 		ruleId: "arid-time",
-		matches: (callee) => readsNamespace(callee, "Duration")
+		matches: (callee) => readsModule(callee, "Schedule")
 	},
 	{
 		ruleId: "arid-time",
-		matches: (callee) => readsMember(callee, "Date", "now")
+		matches: (callee) => readsModule(callee, "Duration")
 	},
 	{
 		ruleId: "arid-config-default",
-		matches: (callee) => readsMember(callee, "Config", "withDefault")
+		matches: (callee) => readsExport(callee, "Config", "withDefault")
 	},
 	{
 		ruleId: "arid-memoization",
-		matches: (callee) => readsMember(callee, "Effect", "cached")
+		matches: (callee) => readsExport(callee, "Effect", "cached")
 	},
 	{
 		ruleId: "arid-memoization",
-		matches: (callee) => readsMember(callee, "Effect", "cachedWithTTL")
+		matches: (callee) => readsExport(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}`;
+const calleeDetail = (callee) => Match.value(callee).pipe(Match.tagsExhaustive({
+	EffectExport: (effectExport) => `${effectExport.module}.${effectExport.exportName}`,
+	Global: (global) => `${global.name}.${global.member}`
+}));
 var AridCodeCommand = class extends S.TaggedClass()("AridCodeCommand", {
 	policy: Options.MutantSetPolicy,
 	frames: S.Array(AridFrameSchema)
@@ -3483,11 +3752,15 @@ var AridSuppressed = class extends S.TaggedClass()("AridSuppressed", {
 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 matchOfFrame = (frame) => Match.value(frame).pipe(Match.tagsExhaustive({
+	ArgumentFrame: (argument) => Option.flatMap(argument.callee, (callee) => Option.map(ruleFor(callee), (ruleId) => ({
+		ruleId,
+		callee
+	}))),
+	ThroughFrame: () => Option.none(),
+	FunctionBoundary: () => Option.none()
+}));
+const firstMatch = (frames) => Option.firstSomeOf(Arr.takeWhile(frames, isCallFrame).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)
@@ -3785,14 +4058,9 @@ const placeMutants = Workflow.make({
 //#region src/mutant-set-policy.workflow.ts
 const MutantSetFactsSchema = S.Struct({
 	originalCode: S.String,
-	replacementCode: S.String,
-	relationalSufficient: S.Boolean
+	replacementCode: S.String
 });
-const MutantSetRuleId = S.Literals([
-	"redundant-relational",
-	"equivalent-to-original",
-	"duplicate-at-site"
-]);
+const MutantSetRuleId = S.Literals(["equivalent-to-original", "duplicate-at-site"]);
 var MutantSetPolicyCommand = class extends S.TaggedClass()("MutantSetPolicyCommand", {
 	policy: Options.MutantSetPolicy,
 	candidates: S.Array(MutantSetFactsSchema)
@@ -3830,10 +4098,6 @@ 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`
@@ -3842,7 +4106,7 @@ const duplicateSuppression = (facts, earlier, policy) => defaultOnly(policy, ()
 	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 outcomeOf = (facts, earlier, policy) => Option.getOrElse(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)]
@@ -3858,6 +4122,75 @@ const mutantSetPolicy = Workflow.make({
 	decide: (command) => Result.succeed([...outcomesFor(command)])
 });
 //#endregion
+//#region src/subsume-mutants.workflow.ts
+const COMPLEMENT_ROWS = {
+	"<": {
+		complement: ">=",
+		dominator: "<="
+	},
+	"<=": {
+		complement: ">",
+		dominator: "<"
+	},
+	">": {
+		complement: "<=",
+		dominator: ">="
+	},
+	">=": {
+		complement: "<",
+		dominator: ">"
+	}
+};
+var RelationalSite = class extends S.TaggedClass()("RelationalSite", { operator: RelationalOperator }) {};
+var OtherSite = class extends S.TaggedClass()("OtherSite", {}) {};
+const SubsumptionSite = S.Union([RelationalSite, OtherSite]);
+var OrderingOperator = class extends S.TaggedClass()("OrderingOperator", { operator: RelationalOperator }) {};
+var OtherReplacement = class extends S.TaggedClass()("OtherReplacement", {}) {};
+const SubsumptionReplacement = S.Union([OrderingOperator, OtherReplacement]);
+const StaticStatus = S.Literals(["StaticallyKept", "StaticallyIgnored"]);
+const SubsumptionCandidateSchema = S.Struct({
+	id: Mutant.MutantId,
+	replacement: SubsumptionReplacement,
+	status: StaticStatus
+});
+var SubsumeMutantsCommand = class extends S.TaggedClass()("SubsumeMutantsCommand", {
+	policy: Options.MutantSetPolicy,
+	site: SubsumptionSite,
+	candidates: S.Array(SubsumptionCandidateSchema)
+}) {
+	static [Workflow.InstrumentationBrand] = {};
+};
+const SubsumptionDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js-instrumenter/SubsumptionDecision");
+var Unaffected = class extends S.TaggedClass()("Unaffected", {}) {
+	[SubsumptionDecisionTypeId] = SubsumptionDecisionTypeId;
+};
+var Subsumed = class extends S.TaggedClass()("Subsumed", {
+	rule: S.Literal("complement"),
+	dominators: S.NonEmptyArray(Mutant.MutantId)
+}) {
+	[SubsumptionDecisionTypeId] = SubsumptionDecisionTypeId;
+};
+const SubsumptionDecision = S.Union([Unaffected, Subsumed]);
+const SubsumptionDecisions = S.Array(SubsumptionDecision);
+const replacesWith = (candidate, operator) => Match.value(candidate.replacement).pipe(Match.tag("OrderingOperator", (replacement) => replacement.operator === operator), Match.tag("OtherReplacement", () => false), Match.exhaustive);
+const isKeptAs = (candidate, operator) => [candidate.status === "StaticallyKept", replacesWith(candidate, operator)].every(Boolean);
+const dominatorsOf = (candidates, operator) => Option.liftPredicate(candidates.filter((candidate) => isKeptAs(candidate, COMPLEMENT_ROWS[operator].dominator)).map((candidate) => candidate.id), Arr.isArrayNonEmpty);
+const decideAt = (candidates, operator) => (candidate) => Option.match(Option.flatMap(Option.liftPredicate(candidate, (kept) => isKeptAs(kept, COMPLEMENT_ROWS[operator].complement)), () => dominatorsOf(candidates, operator)), {
+	onNone: () => Unaffected.make({}),
+	onSome: (dominators) => Subsumed.make({
+		rule: "complement",
+		dominators
+	})
+});
+const allUnaffected = (command) => command.candidates.map(() => Unaffected.make({}));
+const decisionsAtSite = (command) => Match.value(command.site).pipe(Match.tag("RelationalSite", (site) => command.candidates.map(decideAt(command.candidates, site.operator))), Match.tag("OtherSite", () => allUnaffected(command)), Match.exhaustive);
+const subsumeMutants = Workflow.make({
+	command: SubsumeMutantsCommand,
+	decision: SubsumptionDecisions,
+	error: S.Never,
+	decide: (command) => Result.succeed(Match.value(command.policy).pipe(Match.when("full", () => allUnaffected(command)), Match.when("default", () => decisionsAtSite(command)), Match.exhaustive))
+});
+//#endregion
 //#region src/plan-mutants.workflow.ts
 const WILDCARD = "all";
 const NEXT_LINE = "next-line";
@@ -3865,21 +4198,31 @@ const RULE_SEPARATOR = ": ";
 const policyWorkflow = mutantSetPolicy;
 const policyCommand = MutantSetPolicyCommand;
 const keptOutcome = MutantKept;
+const subsumptionWorkflow = subsumeMutants;
+const subsumptionCommand = SubsumeMutantsCommand;
+const unaffectedOutcome = Unaffected;
 const ignoreReasonFor = (ruleId, detail) => `${ruleId}${RULE_SEPARATOR}${detail}`;
+const IgnorerAnswerSchema = S.Struct({
+	ignorerName: S.String,
+	answer: S.Unknown
+});
 const MutantCandidateSchema = S.Struct({
 	id: Mutant.MutantId,
 	mutatorName: MutatorNameSchema,
 	replacementCode: S.String,
 	location: S.optional(Mutant.Location),
-	ignorerReason: S.optional(S.String),
-	mutantSet: MutantSetFactsSchema
+	ignorerAnswer: S.optional(IgnorerAnswerSchema),
+	aridReason: S.optional(Mutant.IgnoreStatusReasonText),
+	mutantSet: MutantSetFactsSchema,
+	subsumption: SubsumptionReplacement
 });
 const PlannedMutantSchema = S.Struct({
 	id: Mutant.MutantId,
 	mutatorName: MutatorNameSchema,
 	replacementCode: S.String,
 	location: Mutant.Location,
-	ignoreReason: S.optional(S.String)
+	ignoreReason: S.optional(S.String),
+	subsumption: S.optional(Mutant.Subsumed)
 });
 var PlanMutantsCommand = class extends S.TaggedClass()("PlanMutantsCommand", {
 	fileName: S.String,
@@ -3890,6 +4233,7 @@ var PlanMutantsCommand = class extends S.TaggedClass()("PlanMutantsCommand", {
 	rule: S.Array(LocatedDirectiveSchema),
 	directives: S.Array(LocatedDirectiveSchema),
 	candidates: S.Array(MutantCandidateSchema),
+	site: SubsumptionSite,
 	mutantSetPolicy: Options.MutantSetPolicy
 }) {
 	static [Workflow.InstrumentationBrand] = {};
@@ -3916,13 +4260,31 @@ var MutantWithoutLocation = class extends S.TaggedError()("MutantWithoutLocation
 		return `Mutant without a source location: ${this.mutatorName} in ${this.fileName}`;
 	}
 };
+var IgnorerAnsweredWithoutReason = class extends S.TaggedError()("IgnorerAnsweredWithoutReason", {
+	fileName: S.String,
+	mutantId: Mutant.MutantId,
+	ignorerName: S.String
+}) {
+	get message() {
+		return `Ignorer "${this.ignorerName}" ignored mutant ${this.mutantId} in ${this.fileName} without a reason. Make its \`shouldIgnore\` return a non-empty reason string, or \`undefined\` to keep the mutant.`;
+	}
+};
 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(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 ignorerReasonText = (answered) => Option.filter(S.decodeUnknownOption(S.String)(answered.answer), (reason) => reason.trim().length > 0);
+const ignorerRefusalOf = (command, candidate) => Option.flatMap(Option.fromNullishOr(candidate.ignorerAnswer), (answered) => Option.match(ignorerReasonText(answered), {
+	onNone: () => Option.some(IgnorerAnsweredWithoutReason.make({
+		fileName: command.fileName,
+		mutantId: candidate.id,
+		ignorerName: answered.ignorerName
+	})),
+	onSome: () => Option.none()
+}));
+const ignorerReason = (candidate) => Option.map(Option.flatMap(Option.fromNullishOr(candidate.ignorerAnswer), ignorerReasonText), (reason) => ignoreReasonFor("ignorer", reason));
+const ignoreReasonOf = (command, candidate, policyReason) => Option.getOrUndefined(Option.orElse(Option.orElse(Option.orElse(Option.orElse(directiveReason(command.rule, candidate.mutatorName, command.line), () => exclusionReason(command.excludedMutations, candidate.mutatorName)), () => ignorerReason(candidate)), () => Option.fromNullishOr(policyReason)), () => Option.fromNullishOr(candidate.aridReason)));
 const policyOutcomes = (command) => Result.match(policyWorkflow(policyCommand.make({
 	policy: command.mutantSetPolicy,
 	candidates: command.candidates.map((candidate) => candidate.mutantSet)
@@ -3932,6 +4294,38 @@ const policyOutcomes = (command) => Result.match(policyWorkflow(policyCommand.ma
 });
 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 staticReasonsAt = (command) => {
+	const policyReasons = policyReasonsAt(command);
+	return command.candidates.map((candidate, index) => ignoreReasonOf(command, candidate, policyReasons[index]));
+};
+const staticStatusOf = (reason) => Option.match(Option.fromNullishOr(reason), {
+	onNone: () => "StaticallyKept",
+	onSome: () => "StaticallyIgnored"
+});
+const subsumptionsAt = (command, staticReasons) => Result.match(subsumptionWorkflow(subsumptionCommand.make({
+	policy: command.mutantSetPolicy,
+	site: command.site,
+	candidates: command.candidates.map((candidate, index) => ({
+		id: candidate.id,
+		replacement: candidate.subsumption,
+		status: staticStatusOf(staticReasons[index])
+	}))
+})), {
+	onFailure: () => command.candidates.map(() => unaffectedOutcome.make({})),
+	onSuccess: (decisions) => decisions
+});
+const subsumedOf = (decision) => Match.value(decision).pipe(Match.tag("Subsumed", (subsumed) => Option.some({
+	_tag: "Subsumed",
+	rule: subsumed.rule,
+	dominators: subsumed.dominators
+})), Match.tag("Unaffected", () => Option.none()), Match.exhaustive);
+const candidateReasonsAt = (command) => {
+	const staticReasons = staticReasonsAt(command);
+	return Arr.zip(staticReasons, subsumptionsAt(command, staticReasons)).map(([ignoreReason, decision]) => ({
+		ignoreReason,
+		subsumption: subsumedOf(decision)
+	}));
+};
 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,
@@ -3957,23 +4351,27 @@ const shiftedLocation = (location, offset) => ({
 	start: shiftedPosition(location.start, offset),
 	end: shiftedPosition(location.end, offset)
 });
-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: candidate.id,
-		mutatorName: candidate.mutatorName,
-		replacementCode: candidate.replacementCode,
-		location: shiftedLocation(location, command.offset),
-		ignoreReason: ignoreReasonOf(command, candidate, policyReason)
+const plannedMutant = (command, candidate, reasons) => Option.match(ignorerRefusalOf(command, candidate), {
+	onSome: (refusal) => Result.fail(refusal),
+	onNone: () => Option.match(Option.fromNullishOr(candidate.location), {
+		onNone: () => Result.fail(MutantWithoutLocation.make({
+			fileName: command.fileName,
+			mutatorName: candidate.mutatorName
+		})),
+		onSome: (location) => Result.succeed({
+			id: candidate.id,
+			mutatorName: candidate.mutatorName,
+			replacementCode: candidate.replacementCode,
+			location: shiftedLocation(location, command.offset),
+			ignoreReason: reasons.ignoreReason,
+			...Option.match(reasons.subsumption, {
+				onNone: () => ({}),
+				onSome: (subsumption) => ({ subsumption })
+			})
+		})
 	})
 });
-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 plannedMutants = (command, reasons) => Arr.zip(command.candidates, reasons).reduce((accumulated, [candidate, reason]) => Result.flatMap(accumulated, (mutants) => Result.map(plannedMutant(command, candidate, reason), (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],
@@ -3986,9 +4384,10 @@ const planOf = (command, mutants) => Match.value(mutants.some(withoutReason)).pi
 const planMutants = Workflow.make({
 	command: PlanMutantsCommand,
 	decision: S.Union([MutantsPlanned, MutantsFullyIgnored]),
-	error: MutantWithoutLocation,
+	error: S.Union([MutantWithoutLocation, IgnorerAnsweredWithoutReason]),
 	decide: (command) => Result.gen(function* () {
-		const mutants = yield* plannedMutants(command);
+		const reasons = candidateReasonsAt(command);
+		const mutants = yield* plannedMutants(command, reasons);
 		return planOf(command, mutants);
 	})
 });
@@ -4357,7 +4756,10 @@ const plannedWithNodes = (candidates, planned, fileName, includes) => planned.fl
 	onNone: () => [],
 	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 ignorerAnswerFor = (node, ancestors, ignorers) => ignorers.reduce((answered, ignorer) => Option.orElse(answered, () => Option.map(Option.fromNullishOr(ignorer.shouldIgnore(node, ancestors)), (answer) => ({
+	ignorerName: ignorer.name,
+	answer
+}))), 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";
@@ -4367,23 +4769,47 @@ const isMemberOfIdentifierParts = (node) => isMemberExpressionValue(node) && has
 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,
+const unshadowedGlobalOf = (name, context, table) => Option.filter(Option.filter(Option.some(name), S.is(AridGlobalObject)), (global) => isShadowed(global, context) === false && isImportedLocal(global, table) === false);
+const aridGlobalCalleeOf = (callee, context, table) => Match.value(callee).pipe(Match.when(isNamedCallee, (named) => Option.map(unshadowedGlobalOf(named.object.name, context, table), (name) => ({
+	_tag: "Global",
+	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), {
+}))), Match.orElse(() => Option.none()));
+const aridCalleeOf = (call, callFrame, policy, table) => {
+	const context = toMutatorContext([call, ...ancestorsOfFrame(callFrame)], policy);
+	return Option.orElse(Option.map(resolveCallee(call.callee, context, table), (callee) => ({
+		_tag: "EffectExport",
+		module: callee.module,
+		exportName: callee.exportName
+	})), () => aridGlobalCalleeOf(call.callee, context, table));
+};
+const aridCallFrame = (current, ancestor, ancestorFrame, policy, table) => ancestor.arguments.some((argument) => argument === current.node) ? {
+	_tag: "ArgumentFrame",
+	callee: aridCalleeOf(ancestor, ancestorFrame, policy, table)
+} : { _tag: "ThroughFrame" };
+const aridCallFrameFor = (current, ancestorFrame, policy, table) => {
+	const ancestor = ancestorFrame.node;
+	if (ancestor.type !== "CallExpression") return [];
+	return [aridCallFrame(current, ancestor, ancestorFrame, policy, table)];
+};
+const functionBoundaryOf = (current) => isFunctionLike(current.node) ? [{ _tag: "FunctionBoundary" }] : [];
+const aridFramesOf = (frame, policy, table) => framesUpward(frame).flatMap((current) => [...functionBoundaryOf(current), ...Option.match(Option.fromNullishOr(current.parent), {
 	onNone: () => [],
-	onSome: (parent) => Option.toArray(aridFrameFor(current.node, parent.node))
-}));
+	onSome: (parent) => aridCallFrameFor(current, parent, policy, table)
+})]);
 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({
+const aridReasonOf = (frame, policy, table) => Match.value(aridCode(AridCodeCommand.make({
 	policy,
-	frames: [...aridFramesOf(frame)]
+	frames: [...aridFramesOf(frame, policy, table)]
 }))).pipe(Match.when(Result.isSuccess, (decided) => aridStatusReason(decided.success)), Match.orElse(() => Option.none()));
+const subsumptionSiteOf = (node) => Option.match(relationalOperatorOf(node), {
+	onNone: () => OtherSite.make({}),
+	onSome: (operator) => RelationalSite.make({ operator })
+});
+const subsumptionReplacementOf = (mutatorName, replacement) => Option.match(Option.filter(relationalOperatorOf(replacement), () => mutatorName === "EqualityOperator"), {
+	onNone: () => OtherReplacement.make({}),
+	onSome: (operator) => OrderingOperator.make({ operator })
+});
 const mutablesFor = (frame, location, context) => {
 	const ancestors = ancestorsOfFrame(frame);
 	const mutatorContext = toMutatorContext(ancestors, context.mutantSetPolicy);
@@ -4391,10 +4817,10 @@ const mutablesFor = (frame, location, context) => {
 		mutatorName,
 		replacement
 	})));
-	const ignorerReason = replacements.length === 0 ? void 0 : Option.getOrUndefined(ignorersReasonFor(frame.node, ancestors, context.ignorers));
-	const aridReason = aridReasonOf(frame, context.mutantSetPolicy);
+	if (replacements.length === 0) return [];
+	const ignorerAnswer = Option.getOrUndefined(ignorerAnswerFor(frame.node, ancestors, context.ignorers));
+	const aridReason = Option.getOrUndefined(aridReasonOf(frame, context.mutantSetPolicy, context.aridImportTable));
 	const originalCode = printNode(frame.node);
-	const relationalSite = relationalSiteFacts(frame.node, mutatorContext);
 	return replacements.map(({ mutatorName, replacement }) => {
 		const replacementCode = printNode(replacement);
 		const tuple = {
@@ -4406,7 +4832,6 @@ const mutablesFor = (frame, location, context) => {
 		return {
 			node: frame.node,
 			replacement,
-			aridReason,
 			data: {
 				id: mutantIdOf({
 					...tuple,
@@ -4415,12 +4840,13 @@ const mutablesFor = (frame, location, context) => {
 				mutatorName,
 				replacementCode,
 				location,
-				ignorerReason,
+				ignorerAnswer,
+				...aridReason === void 0 ? {} : { aridReason },
 				mutantSet: {
 					originalCode,
-					replacementCode,
-					relationalSufficient: relationalSufficientReplacement(relationalSite, replacement)
-				}
+					replacementCode
+				},
+				subsumption: subsumptionReplacementOf(mutatorName, replacement)
 			}
 		};
 	});
@@ -4461,18 +4887,8 @@ 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 planned = withAridReasons(candidates, plan.mutants);
-	const collected = plannedWithNodes(candidates, planned, context.fileName, () => true);
+	const collected = plannedWithNodes(candidates, plan.mutants, context.fileName, () => true);
 	const nextState = {
 		...state,
 		mutants: [...state.mutants, ...collected],
@@ -4480,7 +4896,7 @@ const collectPlan = (frame, candidates, plan, state, context) => {
 	};
 	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);
+		const live = plannedWithNodes(candidates, plan.mutants, context.fileName, (mutant) => placeable.has(mutant.id));
 		return attachPlaceable(live, frame, {
 			...nextState,
 			hasLiveMutants: nextState.hasLiveMutants || live.length > 0
@@ -4497,6 +4913,7 @@ const planMutantsAt = (frame, candidates, directives, location, state, context)
 		rule: [...state.directiveRule],
 		directives: [...directives],
 		candidates: candidates.map((candidate) => candidate.data),
+		site: subsumptionSiteOf(frame.node),
 		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)));
@@ -4615,6 +5032,9 @@ const refusalError = (refusal) => Match.value(refusal).pipe(Match.tag("NodeWitho
 })), Match.tag("MutantWithoutLocation", (failed) => InstrumentError.make({
 	message: `Mutant without a source location: ${failed.mutatorName} in ${failed.fileName}`,
 	cause: void 0
+})), Match.tag("IgnorerAnsweredWithoutReason", (failed) => InstrumentError.make({
+	message: failed.message,
+	cause: failed
 })), Match.exhaustive);
 const transformScriptDataFirst = Effect.fn(SpanTaxonomy.Spans.instrumentTransformScript.name)(function* ({ root, originFileName, rawContent, offset, comments }, mutantCollector, { options, mutateDescription, basePath }) {
 	const lineStarts = lineStartsOf(rawContent);
@@ -4629,6 +5049,7 @@ const transformScriptDataFirst = Effect.fn(SpanTaxonomy.Spans.instrumentTransfor
 		allMutatorNames: options.mutators.known.map((name) => name.toLowerCase()),
 		excludedMutations: options.excludedMutations,
 		mutantSetPolicy: options.mutantSetPolicy,
+		aridImportTable: buildImportTable(root, AridEffectModule.literals),
 		ignorers: options.ignorers,
 		ordinalOf: mutantCollector.ordinalOf
 	};
@@ -4875,7 +5296,7 @@ const spliceForAssigned = (request) => Option.match(request.registry.entryForFor
 	onSome: (entry) => spliceFileFor(request.file, entry)
 });
 //#endregion
-//#region src/drivers/oxc-program.ts
+//#region src/oxc-program.ts
 const EMBEDDED_SCRIPT_FILE = "embedded-script.js";
 const makeScriptParser = (oxc) => (source, scriptFormat) => {
 	const result = oxc.parseSync(EMBEDDED_SCRIPT_FILE, source, {
@@ -5044,6 +5465,11 @@ const admitInstrumentFiles = Workflow.make({
 });
 //#endregion
 //#region src/instrument-files.cell.ts
+const skippedOf = (raw) => raw.skipped.map(({ extension, file, reason }) => InstrumentFileSkip.make({
+	extension,
+	file,
+	reason
+}));
 const printedFile = (raw, { file, ast }) => Result.map(print(ast, raw.registry.entryForFormat), (content) => ({
 	name: file.name,
 	mutate: file.mutate,
@@ -5056,12 +5482,12 @@ const printedFiles = (raw) => Effect.forEach(raw.parsed, (parsed) => Effect.from
 const instrumentedResult = (raw) => Effect.map(printedFiles(raw), (files) => InstrumentResult.make({
 	files: [...files],
 	mutants: [...raw.mutants],
-	skipped: [...raw.skipped]
+	skipped: skippedOf(raw)
 }));
 const skippedOnlyResult = (raw) => InstrumentResult.make({
 	files: [],
 	mutants: [],
-	skipped: [...raw.skipped]
+	skipped: skippedOf(raw)
 });
 const readInstrumentFiles = Effect.fn(SpanTaxonomy.Spans.instrumentReadFiles.name)(function* (input) {
 	const outcomes = yield* Effect.forEach(input.files, (file) => fileOutcome({
@@ -5128,6 +5554,7 @@ const disableTypeChecks = dual((args) => Predicate.hasProperty(args[0], "content
 var Instrument_exports = /* @__PURE__ */ __exportAll({
 	InstrumentFileSkip: () => InstrumentFileSkip,
 	InstrumenterContext: () => InstrumenterContext,
+	MutateDescriptionSchema: () => MutateDescriptionSchema,
 	disableTypeChecks: () => disableTypeChecks,
 	instrument: () => instrument
 });
@@ -5135,7 +5562,6 @@ var Instrument_exports = /* @__PURE__ */ __exportAll({
 //#region src/Mutator/mod.ts
 var Mutator_exports = /* @__PURE__ */ __exportAll({
 	defaultMutators: () => defaultMutators,
-	optInMutators: () => optInMutators,
 	registryOf: () => registryOf,
 	selectMutators: () => selectMutators,
 	stockRegistry: () => stockRegistry