@systemfsoftware/stryker-js-instrumenter 8.0.2 → 8.1.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @systemfsoftware/stryker-js-instrumenter
 
+## 8.1.0
+
+### Minor Changes
+
+- Three opt-in mutators plant Effect concurrency faults on top of the default set, so a mutation run can check that your concurrency tests catch races. `AtomicUpdateSplit` splits read-modify-write calls on `Ref` and `SynchronizedRef` into a separate read, a yield, and a separate write. `SynchronizationRemoval` removes semaphore permits, `Effect.uninterruptible`, and `Effect.uninterruptibleMask`. `FinalizerEscape` stops `ensuring`, `onExit`, `onError`, `onInterrupt`, `acquireRelease`, and `acquireUseRelease` cleanup from running on interruption. All three are off by default. Enable any subset by listing them under `mutator: { optInMutations: [...] }` in your configuration. A name that is not an opt-in mutator fails the run, and the error lists the known names. The replacements use Effect 4 APIs, so a repository on Effect 3.x must not opt in.
+
+### Patch Changes
+
+- Disable comments with the `next-line` scope now ignore the mutants on the line directly below the comment and record the given reason. Before this fix they ignored nothing.
+
 ## 8.0.2
 
 ### Patch Changes

package/README.md

@@ -16,6 +16,24 @@ pnpm add @systemfsoftware/stryker-js-instrumenter
 
 The instrumenter is used internally by the Stryker mutation testing framework to instrument source files with mutant coverage and switching logic.
 
+## Opt-in mutators
+
+Three mutators that plant Effect concurrency faults are available on request and stay out of the default set. Enable any subset in your Stryker config:
+
+```json
+{
+  "mutator": {
+    "optInMutations": ["AtomicUpdateSplit", "SynchronizationRemoval", "FinalizerEscape"]
+  }
+}
+```
+
+- **AtomicUpdateSplit** turns read-modify-write calls such as `Ref.update` or `SynchronizedRef.modify` into a separate read, a yield, and a separate write, so an interleaved mutation can lose an update.
+- **SynchronizationRemoval** drops the guarding effect of `Semaphore.withPermits`/`withPermit` and `Effect.uninterruptible`, letting code that assumed exclusivity or uninterruptibility run without it.
+- **FinalizerEscape** weakens `Effect.ensuring`, `Effect.onExit`, `Effect.onError`, and `Effect.onInterrupt` so their cleanup no longer runs on interruption.
+
+Naming a mutator that does not exist fails the run and lists the names that do. The replacements these mutators plant use Effect 4 APIs, so a repository on Effect 3.x must not opt in.
+
 ## License
 
 Apache-2.0. Part of [systemfsoftware](https://github.com/systemfsoftware/stryker-js-effect/tree/main/packages/stryker-js-instrumenter#readme).

package/dist/index.d.mts

@@ -71,6 +71,7 @@ export declare const InstrumenterOptionsSchema: S.Struct<{
     readonly excludedMutations: S.$Array<S.String>;
     readonly ignorers: S.$Array<S.Unknown>;
     readonly noHeader: S.optional<S.Boolean>;
+    readonly optInMutations: S.optional<S.$Array<S.String>>;
 }>;
 
 export declare class InstrumentError extends InstrumentError_base {

package/dist/index.mjs

@@ -1,12 +1,13 @@
 import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
 import * as S from "effect/Schema";
 import * as Arr from "effect/Array";
 import * as Match from "effect/Match";
-import * as Option from "effect/Option";
 import { walk } from "oxc-walker";
 import { Schema } from "effect";
 import { RegExpParser, visitRegExpAST } from "@eslint-community/regexpp";
+import * as Bool from "effect/Boolean";
 //#region src/Location.schema.ts
 const PositionSchema = S.Struct({
 	line: S.Finite,
@@ -88,7 +89,8 @@ const IgnorerSchema = S.Unknown;
 const InstrumenterOptionsSchema = S.Struct({
 	excludedMutations: S.Array(S.String),
 	ignorers: S.Array(IgnorerSchema),
-	noHeader: S.optional(S.Boolean)
+	noHeader: S.optional(S.Boolean),
+	optInMutations: S.optional(S.Array(S.String))
 });
 var InstrumentResult = class extends S.TaggedClass()("InstrumentResult", {
 	files: S.Array(FileSchema),
@@ -403,6 +405,22 @@ function unaryExpression(operator, argument, loc) {
 		prefix: true
 	}, loc);
 }
+function binaryExpression(operator, left, right, loc) {
+	return mark({
+		type: "BinaryExpression",
+		operator,
+		left,
+		right
+	}, loc);
+}
+function logicalExpression(operator, left, right, loc) {
+	return mark({
+		type: "LogicalExpression",
+		operator,
+		left,
+		right
+	}, loc);
+}
 function updateExpression(operator, argument, prefix, loc) {
 	return mark({
 		type: "UpdateExpression",
@@ -3028,14 +3046,14 @@ function isTSType(node) {
 function isNodeOfKind(node, kind) {
 	return node.type === kind;
 }
-const FUNCTION_KINDS = {
+const FUNCTION_KINDS$1 = {
 	FunctionDeclaration: true,
 	FunctionExpression: true,
 	TSDeclareFunction: true,
 	TSEmptyBodyFunctionExpression: true
 };
 function isFunctionNode(node) {
-	return FUNCTION_KINDS[node.type] === true;
+	return FUNCTION_KINDS$1[node.type] === true;
 }
 function isAssignmentPattern(node) {
 	return node.type === "AssignmentPattern";
@@ -3556,6 +3574,591 @@ function objectCauseTextOf(cause, depth) {
 	return isObjectType(cause) ? textWithNested(ownCauseText(cause), causeText(fieldOf(cause, "cause"), depth + 1)) : void 0;
 }
 //#endregion
+//#region src/EffectCall.ts
+/**
+* EffectCall — the resolution front half the opt-in concurrency mutators share.
+*
+* Given a visited node it answers: is this a covered Effect call (R1); through
+* which module and export did its callee resolve; which call form does its
+* argument count select (KTD10); does a data-last form sit where the replacement
+* function is contextually typed (R4); and how can each `effect` module the
+* replacement needs be reached from the file's own imports (KTD3). It decides
+* nothing about a replacement: a mutator asks for module access through the
+* description's `moduleAccess`, and gets none when the file has no unshadowed
+* binding for that module (R2).
+*
+* Pure. One expression per decision, no I/O, no throwing. The import table is
+* built once per Program and memoised in a WeakMap, because every visited node
+* asks for it and a file's imports never change mid-parse (KTD4).
+*/
+const MODULE_NAMES = [
+	"Effect",
+	"Ref",
+	"Semaphore",
+	"SynchronizedRef"
+];
+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({
+	moduleBindings: /* @__PURE__ */ new Map(),
+	namespaces: /* @__PURE__ */ new Map(),
+	bareFunctions: /* @__PURE__ */ new Map(),
+	pipeBindings: /* @__PURE__ */ new Set()
+});
+const importTables = /* @__PURE__ */ new WeakMap();
+const importTableFor = (program) => Option.getOrElse(Option.fromNullishOr(importTables.get(program)), () => rememberImportTable(program));
+function rememberImportTable(program) {
+	const table = buildImportTable(program);
+	importTables.set(program, table);
+	return table;
+}
+const buildImportTable = (program) => Arr.reduce(Arr.flatMap(Arr.filter(program.body, isImportDeclaration$1), importContributions), EMPTY_IMPORT_TABLE, applyContribution);
+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) => ({
+	...table,
+	moduleBindings: withEntry(table.moduleBindings, moduleBinding.local, moduleBinding.module)
+})), Match.when((candidate) => candidate.kind === "namespace", (namespaceBinding) => ({
+	...table,
+	namespaces: withEntry(table.namespaces, namespaceBinding.local, namespaceBinding.binding)
+})), Match.when((candidate) => candidate.kind === "bareFunction", (bareFunction) => ({
+	...table,
+	bareFunctions: withEntry(table.bareFunctions, bareFunction.local, {
+		module: bareFunction.module,
+		exportName: bareFunction.exportName
+	})
+})), Match.orElse((pipeBinding) => ({
+	...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 pipeContribution = (importedName, localName) => onlyWhen(importedName === "pipe", pipeContributionOf(localName));
+const namespaceSpecifierContribution = (source, specifier) => Option.map(namespaceBindingFor(source), (binding) => ({
+	kind: "namespace",
+	local: specifier.local.name,
+	binding
+}));
+const moduleContribution = (local, module) => ({
+	kind: "module",
+	local,
+	module
+});
+const bareFunctionContribution = (local, module, exportName) => ({
+	kind: "bareFunction",
+	local,
+	module,
+	exportName
+});
+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) => ({
+	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 resolveEffectCall = (node, context) => Option.flatMap(programOf(context), (program) => resolveIn(node, context, importTableFor(program)));
+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 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,
+	owner: Option.none()
+})));
+const resolveMemberCallee = (member, context, table) => Option.flatMap(staticMemberName(member), (exportName) => Option.map(resolveModuleObject(member.object, context, table), (owner) => ({
+	module: owner.module,
+	exportName,
+	owner: Option.some(owner)
+})));
+const resolveModuleObject = (expression, context, table) => Match.value(expression).pipe(Match.when(isIdentifier$1, (reference) => identifierModuleObject(reference, context, table)), Match.when(isMemberExpression, (member) => namespacedModuleObject(member, context, table)), Match.orElse(() => Option.none()));
+const identifierModuleObject = (reference, context, table) => Option.orElse(Option.flatMap(Option.fromNullishOr(table.moduleBindings.get(reference.name)), (module) => Option.map(unshadowedName(reference.name, context), () => ({
+	module,
+	access: reference
+}))), () => Option.flatMap(namespaceOf(reference, context, table), (binding) => Option.map(moduleOf(binding), (module) => ({
+	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) => ({
+	module,
+	access: member
+}))), Match.when(isModuleNamespace, (moduleNamespace) => Option.map(onlyWhen(moduleNamespace.module === moduleName, member), (access) => ({
+	module: moduleNamespace.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";
+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) => Bool.and(isVisible(reference.name, context), table.pipeBindings.has(reference.name))), Match.when(isMemberExpression, (member) => Option.exists(staticMemberName(member), (name) => Bool.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) => Bool.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([
+	ownerAccessFor(callee, module),
+	namedModuleAccess(module, context, table),
+	rootNamespaceAccess(module, context, table),
+	moduleNamespaceAccess(module, context, table)
+], Option.isSome).pipe(Option.flatten);
+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].find(([local, bound]) => Bool.and(bound === module, isVisible(local, context)))), ([local]) => identifier(local));
+const rootNamespaceAccess = (module, context, table) => Option.map(Option.fromNullishOr([...table.namespaces].find(([local, binding]) => Bool.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].find(([local, binding]) => Bool.and(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 freshIdentifier = (base, taken) => freeIdentifier(base, taken, 0);
+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 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([
+	fn.params.some((param) => patternDeclaresOr(param, name)),
+	declaresIdentifier(fn.id, name),
+	blockBodyDeclaresHoistedVar(fn.body, name)
+]);
+const blockBodyDeclaresHoistedVar = (body, name) => Option.match(Option.fromNullishOr(body), {
+	onNone: () => false,
+	onSome: (present) => Match.value(present).pipe(Match.when(isBlockStatement, (block) => hoistedVarsDeclare(block, name)), Match.orElse(() => false))
+});
+const hoistedVarsDeclare = (block, name) => nodesOutsideFunctions(block).some((candidate) => hoistedCandidateDeclares(candidate, name));
+const hoistedCandidateDeclares = (candidate, name) => Match.value(candidate).pipe(Match.when(isVariableDeclaration, (declaration) => Bool.and(declaration.kind === "var", statementBindingsDeclare(declaration, name))), Match.orElse(() => false));
+const statementsDeclare = (statements, name) => statements.some((statement) => statementDeclares(statement, name));
+const statementDeclares = (statement, name) => Match.value(statement).pipe(Match.when(isVariableDeclaration, (declaration) => statementBindingsDeclare(declaration, name)), Match.when(isFunctionDeclaration, (declaration) => declaresIdentifier(declaration.id, name)), Match.when(isClassLike, (declaration) => declaresIdentifier(declaration.id, name)), Match.when(isTSEnumDeclaration, (declaration) => declaration.id.name === name), Match.when(isTSModuleDeclaration, (declaration) => moduleDeclarationDeclares(declaration, name)), Match.when(isTSImportEqualsDeclaration, (declaration) => importEqualsDeclares(declaration, name)), Match.when(isExportNamedDeclaration, (declaration) => Option.exists(Option.fromNullishOr(declaration.declaration), (inner) => statementDeclares(inner, name))), Match.orElse(() => false));
+const statementBindingsDeclare = (declaration, name) => declaration.declarations.some((declarator) => patternDeclaresOr(declarator.id, name));
+const variableDeclarationDeclaresOr = (node, name) => Option.match(Option.fromNullishOr(node), {
+	onNone: () => false,
+	onSome: (present) => Match.value(present).pipe(Match.when(isVariableDeclaration, (declaration) => statementBindingsDeclare(declaration, name)), Match.orElse(() => false))
+});
+const moduleDeclarationDeclares = (declaration, name) => Bool.and(declaration.body !== null, Option.exists(identifierText(declaration.id), (text) => text === name));
+const importEqualsDeclares = (declaration, name) => Bool.and(declaration.importKind !== "type", declaration.id.name === name);
+const declaresIdentifier = (id, name) => Option.exists(identifierText(id), (text) => text === name);
+const patternDeclaresOr = (pattern, name) => Option.match(Option.fromNullishOr(pattern), {
+	onNone: () => false,
+	onSome: (present) => Match.value(present).pipe(Match.when(isBindingIdentifierPattern, (binding) => binding.name === name), Match.when(isObjectBindingPattern, (object) => object.properties.some((property) => propertyDeclares(property, name))), Match.when(isArrayBindingPattern, (array) => array.elements.some((element) => patternDeclaresOr(element, name))), Match.when(isAssignmentBindingPattern, (assignment) => patternDeclaresOr(assignment.left, name)), Match.when(isBindingRestElement, (rest) => patternDeclaresOr(rest.argument, name)), Match.orElse(() => false))
+});
+const propertyDeclares = (property, name) => Match.value(property).pipe(Match.when(isBindingProperty, (binding) => patternDeclaresOr(binding.value, name)), Match.when(isBindingRestElement, (rest) => patternDeclaresOr(rest.argument, name)), Match.orElse(() => false));
+const isBindingIdentifierPattern = (candidate) => nodeType(candidate) === "Identifier";
+const isObjectBindingPattern = (candidate) => nodeType(candidate) === "ObjectPattern";
+const isArrayBindingPattern = (candidate) => nodeType(candidate) === "ArrayPattern";
+const isAssignmentBindingPattern = (candidate) => nodeType(candidate) === "AssignmentPattern";
+const isBindingRestElement = (candidate) => nodeType(candidate) === "RestElement";
+const isBindingProperty = (candidate) => nodeType(candidate) === "Property";
+const identifierText = (node) => Option.match(Option.fromNullishOr(node), {
+	onNone: () => Option.none(),
+	onSome: (present) => Match.value(present).pipe(Match.when(isNamedIdentifier, (name) => Option.some(name.name)), Match.when(isStringLiteral$1, (literal) => literalValueText(literal.value)), Match.orElse(() => Option.none()))
+});
+const literalValueText = (value) => Match.value(value).pipe(Match.when(Predicate.isString, (text) => Option.some(text)), Match.orElse(() => Option.none()));
+const moduleExportName = (name) => Option.getOrElse(identifierText(name), () => "");
+const staticMemberName = (member) => Match.value(member.computed).pipe(Match.when(false, () => identifierText(member.property)), Match.orElse(() => Option.none()));
+const nodesOutsideFunctions = (root) => {
+	const collected = [];
+	traverse(root, { enter(path) {
+		collected.push(path.node);
+		pruneAtFunction(path);
+	} });
+	return collected;
+};
+const allNodesUnder = (root) => {
+	const collected = [];
+	traverse(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 moduleCall = (module, property, args) => callExpression(memberExpression(module, identifier(property), false), args);
+const onlyWhen = (holds, value) => Match.value(holds).pipe(Match.when(true, () => Option.some(value)), Match.orElse(() => Option.none()));
+const holdsAny = (conditions) => conditions.some((condition) => condition);
+const sameNode = (first, second) => first === second;
+const FUNCTION_KINDS = {
+	ArrowFunctionExpression: true,
+	FunctionDeclaration: true,
+	FunctionExpression: true
+};
+const CLASS_KINDS = {
+	ClassDeclaration: true,
+	ClassExpression: true
+};
+const isFunctionLike = (candidate) => FUNCTION_KINDS[nodeType(candidate) ?? ""] === true;
+const isClassLike = (candidate) => CLASS_KINDS[nodeType(candidate) ?? ""] === true;
+const isProgram = (candidate) => nodeType(candidate) === "Program";
+const isBlockStatement = (candidate) => nodeType(candidate) === "BlockStatement";
+const isStaticBlock = (candidate) => nodeType(candidate) === "StaticBlock";
+const isTSModuleBlock = (candidate) => nodeType(candidate) === "TSModuleBlock";
+const isSwitchStatement = (candidate) => nodeType(candidate) === "SwitchStatement";
+const isCatchClause = (candidate) => nodeType(candidate) === "CatchClause";
+const isForStatement = (candidate) => nodeType(candidate) === "ForStatement";
+const isForInStatement = (candidate) => nodeType(candidate) === "ForInStatement";
+const isForOfStatement = (candidate) => nodeType(candidate) === "ForOfStatement";
+const isVariableDeclaration = (candidate) => nodeType(candidate) === "VariableDeclaration";
+const isFunctionDeclaration = (candidate) => nodeType(candidate) === "FunctionDeclaration";
+const isTSEnumDeclaration = (candidate) => nodeType(candidate) === "TSEnumDeclaration";
+const isTSModuleDeclaration = (candidate) => nodeType(candidate) === "TSModuleDeclaration";
+const isTSImportEqualsDeclaration = (candidate) => nodeType(candidate) === "TSImportEqualsDeclaration";
+const isExportNamedDeclaration = (candidate) => nodeType(candidate) === "ExportNamedDeclaration";
+const isImportDeclaration$1 = (candidate) => nodeType(candidate) === "ImportDeclaration";
+const isNamedImportSpecifier = (candidate) => nodeType(candidate) === "ImportSpecifier";
+const isNamespaceImportSpecifier = (candidate) => nodeType(candidate) === "ImportNamespaceSpecifier";
+const isCallExpression$1 = (candidate) => nodeType(candidate) === "CallExpression";
+const isMemberExpression = (candidate) => nodeType(candidate) === "MemberExpression";
+const isIdentifier$1 = (candidate) => nodeType(candidate) === "Identifier";
+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";
+const isSpreadElement = (argument) => nodeType(argument) === "SpreadElement";
+const isSpreadFree = (argument) => nodeType(argument) !== "SpreadElement";
+//#endregion
+//#region src/AtomicUpdateSplit.ts
+const NO_MUTANTS$3 = [];
+const ATOMIC_UPDATE_SPLIT_MODULES = ["Ref", "SynchronizedRef"];
+const ATOMIC_UPDATE_SPLIT_OPERATIONS = [
+	"modify",
+	"modifySome",
+	"update",
+	"updateSome",
+	"updateAndGet",
+	"getAndUpdate"
+];
+const atomicUpdateSplitMutator = (node, context) => Option.match(resolveEffectCall(node, context), {
+	onNone: () => NO_MUTANTS$3,
+	onSome: (call) => Option.toArray(atomicUpdateSplitReplacement(call))
+});
+const atomicUpdateSplitReplacement = (call) => Option.flatMap(splitOperation(call), (operation) => Option.some(replacementExpression$1(operation)));
+const splitOperation = (call) => Match.value(call).pipe(Match.when(isAtomicUpdateSplitOperation, (covered) => splitOperationOf(covered)), Match.orElse(() => Option.none()));
+const isAtomicUpdateSplitOperation = (call) => Bool.and(included(ATOMIC_UPDATE_SPLIT_MODULES, call.module), included(ATOMIC_UPDATE_SPLIT_OPERATIONS, call.exportName));
+const splitOperationOf = (call) => Option.flatMap(moduleBindings(call), (bindings) => Option.flatMap(splitArguments$1(call), (args) => Option.some({
+	effectModule: bindings.effectModule,
+	operationModule: bindings.operationModule,
+	exportName: call.exportName,
+	ref: args.ref,
+	f: args.f,
+	binders: freshBinders$1(takenNames$2(call, bindings, args.f))
+})));
+const splitArguments$1 = (call) => Match.value(call.form).pipe(Match.when((form) => form === "data-first", () => dataFirstArguments$1(call)), Match.when((form) => form === "piped-reference", () => Option.none()), Match.orElse(() => dataLastArguments(call)));
+const dataFirstArguments$1 = (call) => Option.flatMap(Arr.get(call.args, 0), (ref) => Option.flatMap(Arr.get(call.args, 1), (f) => onlyWhen(Bool.and(isMovableArgument(ref), isMovableArgument(f)), {
+	ref: Option.some(cloneNode(ref)),
+	f: cloneNode(f)
+})));
+const dataLastArguments = (call) => Option.flatMap(Arr.get(call.args, 0), (f) => onlyWhen(isMovableArgument(f), {
+	ref: Option.none(),
+	f: cloneNode(f)
+}));
+const moduleBindings = (call) => Option.flatMap(call.moduleAccess("Effect"), (effectModule) => Option.map(call.moduleAccess(call.module), (operationModule) => ({
+	effectModule,
+	operationModule
+})));
+const takenNames$2 = (call, bindings, f) => /* @__PURE__ */ new Set([
+	...call.args.flatMap((argument) => identifiersIn(argument)),
+	...identifiersIn(f),
+	...identifiersIn(bindings.effectModule),
+	...identifiersIn(bindings.operationModule)
+]);
+const freshBinders$1 = (taken) => ({
+	self: freshIdentifier("self", taken),
+	s: freshIdentifier("s", taken),
+	snap: freshIdentifier("snap", taken),
+	b: freshIdentifier("b", taken),
+	a: freshIdentifier("a", taken)
+});
+const replacementExpression$1 = (operation) => Option.match(operation.ref, {
+	onNone: () => arrowFunctionExpression([identifier(operation.binders.self)], splitBody(operation)),
+	onSome: (ref) => moduleCall(operation.effectModule, "flatMap", [moduleCall(operation.effectModule, "succeed", [ref]), arrowFunctionExpression([identifier(operation.binders.self)], splitBody(operation))])
+});
+const splitBody = (operation) => moduleCall(operation.effectModule, "flatMap", [moduleCall(operation.operationModule, "get", [identifier(operation.binders.self)]), arrowFunctionExpression([identifier(operation.binders.s)], moduleCall(operation.effectModule, "flatMap", [moduleCall(operation.operationModule, "make", [identifier(operation.binders.s)]), arrowFunctionExpression([identifier(operation.binders.snap)], moduleCall(operation.effectModule, "flatMap", [moduleCall(operation.operationModule, operation.exportName, [identifier(operation.binders.snap), operation.f]), arrowFunctionExpression([identifier(operation.binders.b)], moduleCall(operation.effectModule, "flatMap", [memberExpression(operation.effectModule, identifier("yieldNow"), false), arrowFunctionExpression([], moduleCall(operation.effectModule, "flatMap", [moduleCall(operation.operationModule, "get", [identifier(operation.binders.snap)]), arrowFunctionExpression([identifier(operation.binders.a)], moduleCall(operation.effectModule, "as", [moduleCall(operation.operationModule, "set", [identifier(operation.binders.self), identifier(operation.binders.a)]), identifier(operation.binders.b)]))]))]))]))]))]);
+const included = (values, value) => values.includes(value);
+//#endregion
+//#region src/FinalizerEscape.ts
+const NO_MUTANTS$2 = [];
+const COVERED_MODULE = "Effect";
+const TAG = "_tag";
+const SUCCESS_TAG = "Success";
+const INTERRUPT_TAG = "Interrupt";
+const finalizerEscapeMutator = (node, context) => Option.match(resolveEffectCall(node, context), {
+	onNone: () => NO_MUTANTS$2,
+	onSome: (call) => Option.toArray(replacementOf(call))
+});
+const replacementOf = (call) => Option.flatMap(onlyWhen(call.module === COVERED_MODULE, call), (covered) => Option.flatMap(covered.moduleAccess(COVERED_MODULE), (effect) => Option.flatMap(coveredForm(covered), (form) => Option.flatMap(splitArguments(covered, form), (split) => Option.flatMap(shapeOf(covered.exportName, split.rest), (shape) => Option.some(replacementExpression(call, effect, form, split, shape)))))));
+const replacementExpression = (call, effect, form, split, shape) => {
+	const binders = freshBinders(takenNames$1(call, effect));
+	const plan = {
+		effect,
+		self: selfExpression(split, binders),
+		shape,
+		binders
+	};
+	return placedBody(form, bodyExpression(plan), binders);
+};
+const coveredForm = (call) => Match.value(call.form).pipe(Match.when("data-first", () => Option.some("data-first")), Match.when("data-last-pipe-arg", () => Option.some("data-last")), Match.when("data-last-pipe-method", () => Option.some("data-last")), Match.when("data-last-immediate", () => Option.some("data-last")), Match.orElse(() => Option.none()));
+const splitArguments = (call, form) => Match.value(form).pipe(Match.when("data-first", () => dataFirstArguments(call)), Match.orElse(() => Option.some({
+	self: Option.none(),
+	rest: [...call.args]
+})));
+const dataFirstArguments = (call) => Option.map(Arr.get(call.args, 0), (self) => ({
+	self: Option.some(cloneNode(self)),
+	rest: call.args.slice(1)
+}));
+const selfExpression = (split, binders) => Option.getOrElse(split.self, () => identifier(binders.self));
+const shapeOf = (exportName, rest) => Match.value(exportName).pipe(Match.when("ensuring", () => finalizerShape(rest)), Match.when("onExit", () => exitShape(rest)), Match.when("onError", () => handlerShape(rest)), Match.when("onInterrupt", () => droppedHandlerShape(rest)), Match.when("acquireRelease", () => releaseShape(rest)), Match.when("acquireUseRelease", () => useReleaseShape(rest)), Match.orElse(() => Option.none()));
+const finalizerShape = (rest) => Option.flatMap(Arr.get(rest, 0), (fin) => onlyWhen(isMovableArgument(fin), {
+	kind: "ensuring",
+	fin
+}));
+const exitShape = (rest) => Option.map(Arr.get(rest, 0), (f) => ({
+	kind: "onExit",
+	f
+}));
+const handlerShape = (rest) => Option.map(Arr.get(rest, 0), (h) => ({
+	kind: "onError",
+	h
+}));
+const droppedHandlerShape = (rest) => Option.flatMap(Arr.get(rest, 0), (h) => onlyWhen(isDroppableArgument(h), {
+	kind: "onInterrupt",
+	h
+}));
+const releaseShape = (rest) => Option.flatMap(Arr.get(rest, 0), (rel) => Option.flatMap(droppableOptionAt(rest, 1), (optionsDroppable) => onlyWhen(Bool.and(isMovableArgument(rel), optionsDroppable), {
+	kind: "acquireRelease",
+	rel
+})));
+const useReleaseShape = (rest) => Option.flatMap(Arr.get(rest, 1), (rel) => Option.flatMap(Arr.get(rest, 0), (use) => Option.flatMap(releaseArityOf(rel), (releaseArity) => onlyWhen(isMovableArgument(rel), {
+	kind: "acquireUseRelease",
+	use,
+	rel,
+	releaseArity
+}))));
+const droppableOptionAt = (rest, index) => Option.match(Arr.get(rest, index), {
+	onNone: () => Option.some(true),
+	onSome: (argument) => onlyWhen(isDroppableArgument(argument), true)
+});
+const bodyExpression = (plan) => Match.value(plan.shape).pipe(Match.when({ kind: "ensuring" }, (shape) => moduleCall(plan.effect, "onExitIf", [
+	plan.self,
+	notInterruptedPredicate(plan.binders),
+	arrowFunctionExpression([], shape.fin)
+])), Match.when({ kind: "onExit" }, (shape) => moduleCall(plan.effect, "onExitIf", [
+	plan.self,
+	notInterruptedPredicate(plan.binders),
+	shape.f
+])), Match.when({ kind: "onError" }, (shape) => moduleCall(plan.effect, "onErrorIf", [
+	plan.self,
+	noInterruptPredicate(plan.binders),
+	shape.h
+])), Match.when({ kind: "onInterrupt" }, () => plan.self), Match.when({ kind: "acquireRelease" }, (shape) => releaseBody(plan, shape)), Match.when({ kind: "acquireUseRelease" }, (shape) => useReleaseBody(plan, shape)), Match.exhaustive);
+const releaseBody = (plan, shape) => moduleCall(plan.effect, "flatMap", [moduleCall(plan.effect, "interruptible", [plan.self]), arrowFunctionExpression([identifier(plan.binders.a)], moduleCall(plan.effect, "acquireRelease", [moduleCall(plan.effect, "succeed", [identifier(plan.binders.a)]), shape.rel]))]);
+const useReleaseBody = (plan, shape) => moduleCall(plan.effect, "acquireUseRelease", [
+	plan.self,
+	shape.use,
+	arrowFunctionExpression([identifier(plan.binders.a), identifier(plan.binders.exit)], conditionalExpression(notInterruptedTest(plan.binders), appliedRelease(shape.rel, plan.binders, shape.releaseArity), memberExpression(plan.effect, identifier("void"), false)))
+]);
+const appliedRelease = (rel, binders, releaseArity) => callExpression(rel, Arr.take([identifier(binders.a), identifier(binders.exit)], releaseArity));
+const releaseArityOf = (rel) => Match.value(rel).pipe(Match.when(isInlineFunction, plainParameterArity), Match.orElse(() => Option.none()));
+const isInlineFunction = (candidate) => nodeType(candidate) === "ArrowFunctionExpression" || nodeType(candidate) === "FunctionExpression";
+const plainParameterArity = (fn) => onlyWhen(Bool.and(fn.params.every(isPlainParameter), fn.params.length <= 2), fn.params.length);
+const isPlainParameter = (param) => nodeType(param) === "Identifier";
+const placedBody = (form, body, binders) => Match.value(form).pipe(Match.when("data-first", () => body), Match.orElse(() => arrowFunctionExpression([identifier(binders.self)], body)));
+const notInterruptedPredicate = (binders) => arrowFunctionExpression([identifier(binders.exit)], notInterruptedTest(binders));
+const notInterruptedTest = (binders) => logicalExpression("||", tagCheck(binders.exit, SUCCESS_TAG), unaryExpression("!", interruptionSome(failureReasons(binders.exit), binders.reason)));
+const noInterruptPredicate = (binders) => arrowFunctionExpression([identifier(binders.cause)], unaryExpression("!", interruptionSome(causeReasons(binders.cause), binders.reason)));
+const tagCheck = (name, tag) => binaryExpression("===", memberExpression(identifier(name), identifier(TAG), false), stringLiteral(tag));
+const failureReasons = (exitName) => memberExpression(memberExpression(identifier(exitName), identifier("cause"), false), identifier("reasons"), false);
+const causeReasons = (causeName) => memberExpression(identifier(causeName), identifier("reasons"), false);
+const interruptionSome = (reasons, reasonName) => callExpression(memberExpression(reasons, identifier("some"), false), [arrowFunctionExpression([identifier(reasonName)], tagCheck(reasonName, INTERRUPT_TAG))]);
+const takenNames$1 = (call, effect) => /* @__PURE__ */ new Set([...call.args.flatMap((argument) => identifiersIn(argument)), ...identifiersIn(effect)]);
+const freshBinders = (taken) => ({
+	self: freshIdentifier("self", taken),
+	exit: freshIdentifier("exit", taken),
+	cause: freshIdentifier("cause", taken),
+	reason: freshIdentifier("reason", taken),
+	a: freshIdentifier("a", taken)
+});
+//#endregion
+//#region src/SynchronizationRemoval.ts
+/**
+* SynchronizationRemoval — the R7 mutants: a removed lock and a removed mask.
+*
+* Four call shapes, each producing the wrapped effect alone:
+*
+* - `Semaphore.withPermits(sem, n, e)` and `Semaphore.withPermit(sem, e)` become
+*   the guarded effect. The guard arguments are dropped, so they must be
+*   droppable (KTD5); the effect itself is cloned so the mutant's tree shares
+*   nothing with the original's.
+* - Their data-last forms become `(self) => self`, which the resolver only
+*   reports where that function is contextually typed (R4, KTD9) — a piped
+*   argument, a piped method argument, or the callee of an immediate call.
+* - `Effect.uninterruptible(e)` becomes `e`, and a bare `Effect.uninterruptible`
+*   used as a pipe argument becomes `(self) => self` (KTD9).
+* - `Effect.uninterruptibleMask(f)` becomes `E.suspend(() => f(E.interruptible))`
+*   (KTD7): `f` is called at run time, as the original calls it, and the restore
+*   it receives is the identity wherever the surrounding region is interruptible.
+*   This needs the Effect module object in scope (R2, KTD3).
+*
+* Resolution lives in `EffectCall.ts`; this module never inspects imports. It is
+* a pure function from a resolved call to the one mutant it implies, and yields
+* no mutant whenever the replacement would evaluate an argument twice or lean on
+* a moved argument that can yield.
+*/
+const NO_MUTANTS$1 = [];
+const synchronizationRemovalMutator = (node, context) => Option.match(resolveEffectCall(node, context), {
+	onNone: () => NO_MUTANTS$1,
+	onSome: (call) => Option.toArray(synchronizationRemovalReplacement(call))
+});
+const synchronizationRemovalReplacement = (call) => Match.value(call).pipe(Match.when(isWithPermits, withPermitsReplacement), Match.when(isWithPermit, withPermitReplacement), Match.when(isUninterruptible, uninterruptibleReplacement), Match.when(isUninterruptibleMask, uninterruptibleMaskReplacement), Match.orElse(() => Option.none()));
+const isWithPermits = (call) => Bool.and(call.module === "Semaphore", call.exportName === "withPermits");
+const isWithPermit = (call) => Bool.and(call.module === "Semaphore", call.exportName === "withPermit");
+const isUninterruptible = (call) => Bool.and(call.module === "Effect", call.exportName === "uninterruptible");
+const isUninterruptibleMask = (call) => Bool.and(call.module === "Effect", call.exportName === "uninterruptibleMask");
+const isDataFirst = (form) => form === "data-first";
+const isPipedReference = (form) => form === "piped-reference";
+const withPermitsReplacement = (call) => Match.value(call.form).pipe(Match.when(isDataFirst, () => whenDroppable(call, [0, 1], (guarded) => argumentReplacement(guarded, 2))), Match.orElse(() => whenDroppable(call, [0, 1], identityFunctionOf)));
+const withPermitReplacement = (call) => Match.value(call.form).pipe(Match.when(isDataFirst, () => whenDroppable(call, [0], (guarded) => argumentReplacement(guarded, 1))), Match.orElse(() => whenDroppable(call, [0], identityFunctionOf)));
+const uninterruptibleReplacement = (call) => Match.value(call.form).pipe(Match.when(isPipedReference, () => Option.some(identityFunction(call))), Match.orElse(() => argumentReplacement(call, 0)));
+const uninterruptibleMaskReplacement = (call) => whenMovable(call, [0], (masked) => Option.flatMap(masked.moduleAccess("Effect"), (effectModule) => Option.map(Arr.get(masked.args, 0), (f) => maskedReplacement(effectModule, f))));
+const maskedReplacement = (effectModule, f) => moduleCall(effectModule, "suspend", [arrowFunctionExpression([], callExpression(cloneNode(f), [memberExpression(effectModule, identifier("interruptible"), false)]))]);
+const argumentReplacement = (call, index) => Option.map(Arr.get(call.args, index), (argument) => cloneNode(argument));
+const identityFunctionOf = (call) => Option.some(identityFunction(call));
+const identityFunction = (call) => {
+	const name = freshIdentifier("self", takenNames(call));
+	return arrowFunctionExpression([identifier(name)], identifier(name));
+};
+const takenNames = (call) => new Set(call.args.flatMap((argument) => identifiersIn(argument)));
+const whenDroppable = (call, indices, build) => Option.flatMap(onlyWhen(argumentsDroppable(call, indices), call), build);
+const whenMovable = (call, indices, build) => Option.flatMap(onlyWhen(argumentsMovable(call, indices), call), build);
+const argumentsDroppable = (call, indices) => indices.every((index) => argumentSatisfies(call, index, isDroppableArgument));
+const argumentsMovable = (call, indices) => indices.every((index) => argumentSatisfies(call, index, isMovableArgument));
+const argumentSatisfies = (call, index, predicate) => Option.exists(Arr.get(call.args, index), predicate);
+//#endregion
 //#region src/Mutator.ts
 /**
 * Mutator — every mutation operator and its registry.
@@ -4391,8 +4994,11 @@ 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.
 */
-const allMutators = Object.freeze({
+const defaultMutators = Object.freeze({
 	ArithmeticOperator: arithmeticOperatorMutator,
 	ArrayDeclaration: arrayDeclarationMutator,
 	ArrowFunction: arrowFunctionMutator,
@@ -4410,6 +5016,28 @@ const allMutators = Object.freeze({
 	UnaryOperator: unaryOperatorMutator,
 	UpdateOperator: updateOperatorMutator
 });
+const optInMutators = Object.freeze({
+	AtomicUpdateSplit: atomicUpdateSplitMutator,
+	SynchronizationRemoval: synchronizationRemovalMutator,
+	FinalizerEscape: finalizerEscapeMutator
+});
+/**
+* The entries a run applies, and the names its directives may reference.
+*
+* Naming is additive, never a whitelist: `optInMutations` adds entries on top
+* 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.
+*
+* Pure: a registry and a run's names in, entries and names out.
+*/
+const selectMutators = (registry, optInMutations) => ({
+	active: [...Object.entries(registry.defaults), ...Object.entries(registry.optIn).filter(([name]) => optInMutations.includes(name))],
+	known: [...Object.keys(registry.defaults), ...Object.keys(registry.optIn)]
+});
 S.TaggedError("@systemfsoftware/stryker-js-instrumenter/Transformer.schema/PlacementFailed")("PlacementFailed", {
 	fileName: S.String,
 	placerName: S.String,
@@ -4425,6 +5053,10 @@ S.TaggedError("@systemfsoftware/stryker-js-instrumenter/Transformer.schema/Trans
 const STRYKER_NAMESPACE_HELPER = "stryNS_9fa48";
 const COVER_MUTANT_HELPER = "stryCov_9fa48";
 const IS_MUTANT_ACTIVE_HELPER = "stryMutAct_9fa48";
+const DEFAULT_MUTATOR_REGISTRY = {
+	defaults: defaultMutators,
+	optIn: optInMutators
+};
 function createMutantCollector() {
 	return [];
 }
@@ -4460,11 +5092,11 @@ function directiveApplies(directive, lowerMutatorName, line) {
 const NO_COMMENTS = [];
 const PARSE_FAILURE = "Stryker directive without directive type or mutators";
 const MISSING_LOCATION = "Comment without location";
-function processStrykerDirectives(rule, node, allMutatorNames, originFileName) {
+function processStrykerDirectives(rule, node, knownMutatorNames, originFileName, nodeLine) {
 	const directives = attachedComments(node).map(parseStrykerDirective).flatMap(Option.toArray);
-	const warnings = directives.flatMap((directive) => mutatorWarnings(directive, allMutatorNames, originFileName));
+	const warnings = directives.flatMap((directive) => mutatorWarnings(directive, knownMutatorNames, originFileName));
 	return {
-		rule: directives.reduce(applyStrykerDirective, rule),
+		rule: directives.map((directive) => nextLineOn(directive, nodeLine)).reduce(applyStrykerDirective, rule),
 		warnings
 	};
 }
@@ -4493,36 +5125,39 @@ function strykerDirective(match, loc) {
 function matchGroup(match, group) {
 	return Option.getOrThrowWith(Option.fromNullishOr(match[group]), () => /* @__PURE__ */ new Error(PARSE_FAILURE));
 }
-function applyStrykerDirective(rule, directive) {
-	return Match.value(directive.type).pipe(Match.when("disable", () => ignoreRuleFor(rule, directive)), Match.when("restore", () => restoreRuleFor(rule, directive)), Match.orElse(() => rule));
+const nextLineOn = (directive, nodeLine) => ({
+	directive,
+	nodeLine
+});
+function applyStrykerDirective(rule, directed) {
+	return Match.value(directed.directive.type).pipe(Match.when("disable", () => ignoreRuleFor(rule, directed)), Match.when("restore", () => restoreRuleFor(rule, directed)), Match.orElse(() => rule));
 }
-function ignoreRuleFor(rule, directive) {
+function ignoreRuleFor(rule, directed) {
 	return {
 		kind: "Ignore",
-		mutatorNames: directive.mutatorNames.map((mutatorName) => mutatorName.toLowerCase()),
-		line: directiveLine(directive),
-		ignoreReason: directive.reason,
+		mutatorNames: directed.directive.mutatorNames.map((mutatorName) => mutatorName.toLowerCase()),
+		line: directiveLine(directed),
+		ignoreReason: directed.directive.reason,
 		previous: rule
 	};
 }
-function restoreRuleFor(rule, directive) {
+function restoreRuleFor(rule, directed) {
 	return {
 		kind: "Restore",
-		mutatorNames: directive.mutatorNames.map((mutatorName) => mutatorName.toLowerCase()),
-		line: directiveLine(directive),
+		mutatorNames: directed.directive.mutatorNames.map((mutatorName) => mutatorName.toLowerCase()),
+		line: directiveLine(directed),
 		previous: rule
 	};
 }
-/** `next-line` directives carry the line they were written on; a block directive carries none. */
-function directiveLine(directive) {
-	return Match.value(directive.scope).pipe(Match.when("next-line", () => commentLocation(directive.loc).start.line), Match.orElse(() => void 0));
+function directiveLine(directed) {
+	return Match.value(directed.directive.scope).pipe(Match.when("next-line", () => directed.nodeLine), Match.orElse(() => void 0));
 }
 function commentLocation(loc) {
 	return Option.getOrThrowWith(Option.fromNullishOr(loc), () => /* @__PURE__ */ new Error(MISSING_LOCATION));
 }
-/** Warnings for the directive's mutator names that the configured mutators do not know. */
-function mutatorWarnings(directive, allMutatorNames, originFileName) {
-	return directive.mutatorNames.filter((mutatorName) => mutatorName !== WILDCARD).filter((mutatorName) => !allMutatorNames.includes(mutatorName.toLowerCase())).map((mutatorName) => mutatorWarning(directive, mutatorName, originFileName));
+/** Warnings for the directive's mutator names that no registered mutator answers to, selected or not. */
+function mutatorWarnings(directive, knownMutatorNames, originFileName) {
+	return directive.mutatorNames.filter((mutatorName) => mutatorName !== WILDCARD).filter((mutatorName) => !knownMutatorNames.includes(mutatorName.toLowerCase())).map((mutatorName) => mutatorWarning(directive, mutatorName, originFileName));
 }
 function mutatorWarning(directive, mutatorName, originFileName) {
 	const loc = commentLocation(directive.loc);
@@ -5008,19 +5643,21 @@ const emptyAppliedMutants = () => /* @__PURE__ */ new Map();
 function isMutateRangeList(value) {
 	return Array.isArray(value);
 }
-const transformScript = ({ root, originFileName, rawContent, offset, comments }, mutantCollector, { options, mutateDescription, basePath }, mutators, mutantPlacers) => {
+const transformScript = ({ root, originFileName, rawContent, offset, comments }, mutantCollector, { options, mutateDescription, basePath }, registry, mutantPlacers) => {
 	const placementMap = /* @__PURE__ */ new Map();
 	return Effect.gen(function* () {
 		const lineTable = buildLineTable(rawContent);
 		attachComments(root, comments, lineTable);
 		let directiveRule = rootRule;
-		const mutatorEntries = Object.entries(Option.getOrElse(Option.fromNullishOr(mutators), () => allMutators));
+		const mutatorRegistry = Option.getOrElse(Option.fromNullishOr(registry), () => DEFAULT_MUTATOR_REGISTRY);
+		const selection = selectMutators(mutatorRegistry, options.optInMutations);
+		const mutatorEntries = selection.active;
 		const placers = Option.getOrElse(Option.fromNullishOr(mutantPlacers), () => allMutantPlacers);
-		const allMutatorNames = mutatorEntries.map(([name]) => name.toLowerCase());
+		const knownMutatorNames = selection.known.map((name) => name.toLowerCase());
 		const warnings = [];
 		traverse(root, {
 			enter(path) {
-				const result = processStrykerDirectives(directiveRule, path.node, allMutatorNames, originFileName);
+				const result = processStrykerDirectives(directiveRule, path.node, knownMutatorNames, originFileName, nodeStartLine(path.node));
 				directiveRule = result.rule;
 				warnings.push(...result.warnings);
 				visitNode(path);
@@ -5030,6 +5667,12 @@ const transformScript = ({ root, originFileName, rawContent, offset, comments },
 				if (hasAppliedMutants(placement)) applyPlacement(path, placement);
 			}
 		});
+		function nodeStartLine(node) {
+			return Option.match(Option.fromNullishOr(spanOf(node)), {
+				onNone: () => 0,
+				onSome: (span) => positionFromLineTable(span.start, lineTable).line
+			});
+		}
 		yield* placeHeaderIfNeeded(mutantCollector, originFileName, options, root);
 		return warnings;
 		function visitNode(path) {
@@ -5303,9 +5946,26 @@ function toOneBasedLineNumber(range) {
 function isIgnorer(value) {
 	return Predicate.isObject(value) && typeof value["shouldIgnore"] === "function";
 }
+const EMPTY_MUTATION_NAMES = [];
+const KNOWN_OPT_IN_MUTATIONS = Object.keys(optInMutators);
+const requestedOptInMutations = (options) => Option.getOrElse(Option.fromNullishOr(options.optInMutations), () => EMPTY_MUTATION_NAMES);
+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 = (requested) => Option.match(unknownOptInMutationsError(requested), {
+	onNone: () => Effect.void,
+	onSome: (error) => Effect.fail(error)
+});
 function toTransformerOptions(options) {
 	const base = {
 		excludedMutations: [...options.excludedMutations],
+		optInMutations: [...requestedOptInMutations(options)],
 		ignorers: options.ignorers.filter(isIgnorer)
 	};
 	if (options.noHeader !== void 0) return {
@@ -5327,6 +5987,7 @@ function printedFile(file, ast) {
 	}];
 }
 const instrument = (files, options, basePath) => Effect.gen(function* () {
+	yield* refuseUnknownOptInMutations(requestedOptInMutations(options));
 	const schemaFiles = files.map((file) => ({
 		name: file.name,
 		content: file.content,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@systemfsoftware/stryker-js-instrumenter",
-  "version": "8.0.2",
+  "version": "8.1.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/stryker-js-effect.git",
@@ -31,6 +31,7 @@
     "oxc-walker": "^1"
   },
   "devDependencies": {
+    "@effect/platform-node": "4.0.0-rc.116",
     "@effect/tsgo": "^0.45.0",
     "@microsoft/api-extractor": "^7",
     "@systemfsoftware/arethetypeswrong-cli": "^4.2.0",
@@ -44,8 +45,8 @@
     "tsdown": "^0.23.0",
     "typescript": "^7",
     "vitest": "^5",
-    "@systemfsoftware/stryker-ignorer-interface": "^0.1.1",
     "@systemfsoftware/tsdown-config": "^0.1.0",
+    "@systemfsoftware/stryker-ignorer-interface": "^0.1.1",
     "@systemfsoftware/vitest-config": "^0.1.0"
   },
   "engines": {