@systemfsoftware/stryker-js 10.1.2 → 10.2.0

package/dist/main.mjs

@@ -4007,6 +4007,34 @@ const map$13 = /*#__PURE__*/ dual(2, (self, f) => isNone(self) ? none() : some(f
 */
 const flatMap$7 = /*#__PURE__*/ dual(2, (self, f) => isNone(self) ? none() : f(self.value));
 /**
+* Flattens a nested `Option<Option<A>>` into `Option<A>`.
+*
+* **When to use**
+*
+* Use when you need to remove one layer of nested `Option`.
+*
+* **Details**
+*
+* - `Some(Some(value))` → `Some(value)`
+* - `Some(None)` → `None`
+* - `None` → `None`
+*
+* **Example** (Flattening nested Options)
+*
+* ```ts import.meta.vitest
+* import { Option } from "effect"
+*
+* Option.flatten(Option.some(Option.some("value"))) // => Option.some("value")
+* Option.flatten(Option.some(Option.none())) // => Option.none()
+* ```
+*
+* @see {@link flatMap} which is `map` + `flatten`
+*
+* @category sequencing
+* @since 2.0.0
+*/
+const flatten$3 = /*#__PURE__*/ flatMap$7(identity);
+/**
 * Combines a structure of `Option`s (tuple, struct, or iterable) into a single
 * `Option` containing the unwrapped structure.
 *
@@ -6082,6 +6110,39 @@ function isOutOfBounds(i, as) {
 	return !Number.isFinite(i) || i < 0 || i >= as.length;
 }
 /**
+* Reads an element at the given index safely, returning `Option.some` or
+* `Option.none` if the index is out of bounds.
+*
+* **When to use**
+*
+* Use when you need to read an array element by index and handle an
+* out-of-bounds index as `Option.none`.
+*
+* **Details**
+*
+* The index is floored to an integer. This never throws.
+*
+* **Example** (Accessing indexes safely)
+*
+* ```ts import.meta.vitest
+* import { Array, Option } from "effect"
+*
+* Array.get([1, 2, 3], 1) // => Option.some(2)
+* Array.get([1, 2, 3], 10) // => Option.none()
+* ```
+*
+* @see {@link getUnsafe} for indexed access that throws when the index is out of bounds
+* @see {@link head} for reading the first element as an `Option`
+* @see {@link last} for reading the last element as an `Option`
+*
+* @category getters
+* @since 2.0.0
+*/
+const get$8 = /*#__PURE__*/ dual(2, (self, index) => {
+	const i = Math.floor(index);
+	return isOutOfBounds(i, self) ? none() : some(self[i]);
+});
+/**
 * Returns the first element of an array safely wrapped in `Option.some`, or
 * `Option.none` if the array is empty.
 *
@@ -6104,10 +6165,7 @@ function isOutOfBounds(i, as) {
 * @category getters
 * @since 2.0.0
 */
-const head = /*#__PURE__*/ (/* @__PURE__ */ dual(2, (self, index) => {
-	const i = Math.floor(index);
-	return isOutOfBounds(i, self) ? none() : some(self[i]);
-}))(0);
+const head = /*#__PURE__*/ get$8(0);
 /**
 * Returns the last element of an array safely wrapped in `Option.some`, or
 * `Option.none` if the array is empty.
@@ -6155,6 +6213,38 @@ const last = (self) => isReadonlyArrayNonEmpty(self) ? some(lastNonEmpty(self))
 * @since 2.0.0
 */
 const lastNonEmpty = (self) => self[self.length - 1];
+const clampCount = (n, length) => Math.min(normalize$1(n), length);
+/**
+* Keeps the first `n` elements, creating a new array.
+*
+* **When to use**
+*
+* Use to keep up to the first `n` elements from an iterable as a new array.
+*
+* **Details**
+*
+* `n` is rounded down and clamped to `[0, length]`. `NaN` is treated as `0`.
+* Returns an empty array when `n <= 0`.
+*
+* **Example** (Taking from the start)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.take([1, 2, 3, 4, 5], 3) // => [1, 2, 3]
+* ```
+*
+* @see {@link takeRight} for keeping elements from the end
+* @see {@link takeWhile} for keeping an initial prefix while a predicate holds
+* @see {@link drop} for removing elements from the start
+*
+* @category getters
+* @since 2.0.0
+*/
+const take$2 = /*#__PURE__*/ dual(2, (self, n) => {
+	const input = fromIterable$7(self);
+	return input.slice(0, clampCount(n, input.length));
+});
 /**
 * Takes elements from the start while the predicate holds, stopping at the
 * first element that fails.
@@ -25075,7 +25165,7 @@ const layer$14 = /* @__PURE__ */ succeed$6(Stdio, /*#__PURE__*/ make$34({
 }));
 //#endregion
 //#region package.json
-var version = "10.1.2";
+var version = "10.2.0";
 var engines = { "node": ">=24.13.1" };
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-rc.116/node_modules/effect/dist/Logger.js
@@ -27160,7 +27250,7 @@ const isNever = /*#__PURE__*/ makeGuard("Never");
 * @category guards
 * @since 3.10.0
 */
-const isLiteral = /*#__PURE__*/ makeGuard("Literal");
+const isLiteral$1 = /*#__PURE__*/ makeGuard("Literal");
 /**
 * Narrows an {@link AST} to {@link UniqueSymbol}.
 *
@@ -27565,7 +27655,7 @@ const number$1 = /*#__PURE__*/ new Number$4();
 * @category constructors
 * @since 4.0.0
 */
-const Boolean$6 = class extends ASTNodeImpl {
+const Boolean$7 = class extends ASTNodeImpl {
 	_tag = "Boolean";
 	/** @internal */
 	getParser() {
@@ -27590,7 +27680,7 @@ const Boolean$6 = class extends ASTNodeImpl {
 * @category constructors
 * @since 4.0.0
 */
-const boolean$1 = /*#__PURE__*/ new Boolean$6();
+const boolean$1 = /*#__PURE__*/ new Boolean$7();
 /**
 * Constructs a {@link Arrays}.
 *
@@ -28152,7 +28242,7 @@ function collectSentinels(ast) {
 		case "Objects": return ast.propertySignatures.flatMap((ps) => {
 			const type = ps.type;
 			if (!isOptional(type)) {
-				if (isLiteral(type)) return [{
+				if (isLiteral$1(type)) return [{
 					key: ps.name,
 					literal: type.literal
 				}];
@@ -28165,7 +28255,7 @@ function collectSentinels(ast) {
 		});
 		case "Arrays": return ast.elements.flatMap((e, i) => {
 			if (!isOptional(e)) {
-				if (isLiteral(e)) return [{
+				if (isLiteral$1(e)) return [{
 					key: i,
 					literal: e.literal
 				}];
@@ -28200,9 +28290,9 @@ function getIndex(types) {
 		const encoded = toCandidate(a);
 		if (isNever(encoded)) continue;
 		if (onlyLiterals) {
-			if (isLiteral(encoded) || isUniqueSymbol(encoded)) {
+			if (isLiteral$1(encoded) || isUniqueSymbol(encoded)) {
 				literalCandidates ??= /* @__PURE__ */ new Map();
-				const literal = isLiteral(encoded) ? encoded.literal : encoded.symbol;
+				const literal = isLiteral$1(encoded) ? encoded.literal : encoded.symbol;
 				let arr = literalCandidates.get(literal);
 				if (!arr) literalCandidates.set(literal, arr = []);
 				arr.push(a);
@@ -28378,12 +28468,12 @@ const Union$1 = class extends ASTNodeImpl {
 			const encoded = toEncoded$1(type);
 			switch (encoded._tag) {
 				case "Arrays": {
-					const literals = encoded.elements.filter(isLiteral);
+					const literals = encoded.elements.filter(isLiteral$1);
 					if (literals.length > 0) return `${formatIsMutable(encoded.isMutable)}[ ${literals.map((e) => getExpected(e) + formatIsOptional(e.context?.isOptional)).join(", ")}, ... ]`;
 					break;
 				}
 				case "Objects": {
-					const literals = encoded.propertySignatures.filter((ps) => isLiteral(ps.type));
+					const literals = encoded.propertySignatures.filter((ps) => isLiteral$1(ps.type));
 					if (literals.length > 0) return `{ ${literals.map((ps) => `${formatIsMutable(ps.type.context?.isMutable)}${formatPropertyKey(ps.name)}${formatIsOptional(ps.type.context?.isOptional)}: ${getExpected(ps.type)}`).join(", ")}, ... }`;
 					break;
 				}
@@ -33667,7 +33757,7 @@ const Number$3 = /*#__PURE__*/ make$22(number$1);
 * @category schemas
 * @since 4.0.0
 */
-const Boolean$5 = /*#__PURE__*/ make$22(boolean$1);
+const Boolean$6 = /*#__PURE__*/ make$22(boolean$1);
 /**
 * Schema for a TypeScript `void` return value.
 *
@@ -34083,7 +34173,7 @@ const FalseLiterals = /*#__PURE__*/ Literals$2([
 	"n"
 ]);
 /** @internal */
-const BooleanLiterals = /*#__PURE__*/ Literals$2([...TrueLiterals.literals, ...FalseLiterals.literals]).pipe(/*#__PURE__*/ decodeTo(Boolean$5, /*#__PURE__*/ transform$2({
+const BooleanLiterals = /*#__PURE__*/ Literals$2([...TrueLiterals.literals, ...FalseLiterals.literals]).pipe(/*#__PURE__*/ decodeTo(Boolean$6, /*#__PURE__*/ transform$2({
 	decode: (value) => value === "true" || value === "yes" || value === "on" || value === "1" || value === "y",
 	encode: (value) => value ? "true" : "false"
 })));
@@ -36655,6 +36745,33 @@ function walk(input, options) {
 		leave: options.leave
 	}, { scopeTracker: options.scopeTracker }).traverse(input);
 }
+globalThis.Boolean;
+/**
+* Combines two booleans using logical AND: `self && that`.
+*
+* **When to use**
+*
+* Use to require both boolean operands to be `true`.
+*
+* **Details**
+*
+* Supports both data-first and data-last forms.
+*
+* **Example** (Combining booleans with AND)
+*
+* ```ts import.meta.vitest
+* import { Boolean } from "effect"
+*
+* Boolean.and(true, true) // => true
+* Boolean.and(true, false) // => false
+* Boolean.and(false, true) // => false
+* Boolean.and(false, false) // => false
+* ```
+*
+* @category combinators
+* @since 2.0.0
+*/
+const and = /*#__PURE__*/ dual(2, (self, that) => self && that);
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-rc.116/node_modules/effect/dist/ConfigProvider.js
 /**
@@ -41085,13 +41202,13 @@ var Mutant = class extends TaggedClass()("Mutant", {
 	status: optional$4(MutantStatusSchema),
 	statusReason: optional$4(String$7),
 	coveredBy: optional$4(ArraySchema(String$7)),
-	static: optional$4(Boolean$5),
+	static: optional$4(Boolean$6),
 	testsCompleted: optional$4(Finite$3),
 	description: optional$4(String$7)
 }) {};
 const RunOptionsFields = {
 	timeout: Finite$3,
-	disableBail: Boolean$5
+	disableBail: Boolean$6
 };
 const MutantActivationSchema = Literals$2(["runtime", "static"]);
 const MutantRunOptionsSchema = Struct({
@@ -41099,7 +41216,7 @@ const MutantRunOptionsSchema = Struct({
 	activeMutant: Mutant,
 	sandboxFileName: String$7,
 	mutantActivation: MutantActivationSchema,
-	reloadEnvironment: Boolean$5,
+	reloadEnvironment: Boolean$6,
 	testFilter: optionalKey(ArraySchema(String$7)),
 	hitLimit: optionalKey(Finite$3)
 });
@@ -41119,7 +41236,7 @@ const PositionSchema$1$1 = Struct({
 const FileSchema = Struct({
 	name: String$7,
 	content: String$7,
-	mutate: Union([Boolean$5, ArraySchema(Struct({
+	mutate: Union([Boolean$6, ArraySchema(Struct({
 		start: PositionSchema$1$1,
 		end: PositionSchema$1$1
 	}))])
@@ -41128,7 +41245,8 @@ const IgnorerSchema = Unknown;
 Struct({
 	excludedMutations: ArraySchema(String$7),
 	ignorers: ArraySchema(IgnorerSchema),
-	noHeader: optional$4(Boolean$5)
+	noHeader: optional$4(Boolean$6),
+	optInMutations: optional$4(ArraySchema(String$7))
 });
 var InstrumentResult = class extends TaggedClass()("InstrumentResult", {
 	files: ArraySchema(FileSchema),
@@ -41437,6 +41555,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",
@@ -44053,14 +44187,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";
@@ -44508,11 +44642,11 @@ const hasStringCode = (error) => value(fieldOf(error, "code")).pipe(when(string,
 function isErrnoException(error) {
 	return value(error).pipe(when(instanceOf(Error), hasStringCode), orElse$1(() => false));
 }
-const isEmptyNumber = (value$24) => value(value$24).pipe(when(0, () => true), orElse$1(Number.isNaN));
+const isEmptyNumber = (value$27) => value(value$27).pipe(when(0, () => true), orElse$1(Number.isNaN));
 const isEmptyError = (error) => value(error).pipe(when(_undefined, () => true), when(_null, () => true), when(string, (text) => text.length === 0), when(number, isEmptyNumber), when(boolean, (value) => !value), orElse$1(() => false));
 const formatErrnoException = (error) => value(error.stack).pipe(when(hasText, (stack) => `${error.name}: ${error.code} (${error.syscall}) ${stack}`), orElse$1(() => `${error.name}: ${error.code} (${error.syscall})`));
 const formatError = (error) => value(error.stack).pipe(when(hasText, (stack) => `${error.name}: ${error.message}\n${stack}`), orElse$1(() => `${error.name}: ${error.message}`));
-const isJsonPrimitive = (value$22) => value(value$22).pipe(when(number, () => true), when(boolean, () => true), when(bigint, () => true), orElse$1(() => false));
+const isJsonPrimitive = (value$18) => value(value$18).pipe(when(number, () => true), when(boolean, () => true), when(bigint, () => true), orElse$1(() => false));
 const jsonText = (error) => {
 	try {
 		return textIfNonEmpty(JSON.stringify(error));
@@ -44527,11 +44661,11 @@ const isNonPlaceholderText = (text) => value({
 	hasLength: true,
 	isPlaceholder: false
 }, () => true), orElse$1(() => false));
-const isUsableText = (value$21) => value(value$21).pipe(when(string, isNonPlaceholderText), orElse$1(() => false));
+const isUsableText = (value$26) => value(value$26).pipe(when(string, isNonPlaceholderText), orElse$1(() => false));
 const usableText = (value) => isUsableText(value) ? value : "";
-const objectToStringText = (value$25) => value(fieldOf(value$25, "toString")).pipe(when(instanceOf(Function), (callable) => {
+const objectToStringText = (value$28) => value(fieldOf(value$28, "toString")).pipe(when(instanceOf(Function), (callable) => {
 	try {
-		return usableText(Reflect.apply(callable, value$25, []));
+		return usableText(Reflect.apply(callable, value$28, []));
 	} catch {
 		return "";
 	}
@@ -44555,14 +44689,14 @@ function errorToString(error) {
 	return value(error).pipe(when(isEmptyError, () => ""), when(instanceOf(Error), errorText$2), orElse$1(() => stringifyNonError(error)));
 }
 Object.freeze({ NoSuchFileOrDirectory: "ENOENT" });
-const errorNameOf = (value$20) => value(value$20).pipe(when(instanceOf(Error), (error) => textIfNonEmpty(error.name)), orElse$1(() => void 0));
-const tagOf = (value$23) => value(textIfNonEmpty(fieldOf(value$23, "_tag"))).pipe(when(hasText, (tag) => tag), orElse$1(() => errorNameOf(value$23)));
+const errorNameOf = (value$25) => value(value$25).pipe(when(instanceOf(Error), (error) => textIfNonEmpty(error.name)), orElse$1(() => void 0));
+const tagOf = (value$19) => value(textIfNonEmpty(fieldOf(value$19, "_tag"))).pipe(when(hasText, (tag) => tag), orElse$1(() => errorNameOf(value$19)));
 const textWithNested = (own, nested) => value(own).pipe(when(hasText, (text) => appendNested(text, nested)), orElse$1(() => nested));
 const appendNested = (own, nested) => value(nested).pipe(when(hasText, (text) => `${own}: ${text}`), orElse$1(() => own));
 const errorMessage = (error) => value(error.message.length > 0).pipe(when(true, () => error.message), orElse$1(() => tagOf(error)));
-const errorMessageOrTag = (value$19) => value(value$19).pipe(when(instanceOf(Error), errorMessage), orElse$1(() => tagOf(value$19)));
-const messageText = (value$26) => value(textIfNonEmpty(fieldOf(value$26, "message"))).pipe(when(hasText, (message) => message), orElse$1(() => errorMessageOrTag(value$26)));
-const ownCauseText = (value$18) => value(textIfNonEmpty(fieldOf(value$18, "reason"))).pipe(when(hasText, (reason) => reason), orElse$1(() => messageText(value$18)));
+const errorMessageOrTag = (value$24) => value(value$24).pipe(when(instanceOf(Error), errorMessage), orElse$1(() => tagOf(value$24)));
+const messageText = (value$21) => value(textIfNonEmpty(fieldOf(value$21, "message"))).pipe(when(hasText, (message) => message), orElse$1(() => errorMessageOrTag(value$21)));
+const ownCauseText = (value$22) => value(textIfNonEmpty(fieldOf(value$22, "reason"))).pipe(when(hasText, (reason) => reason), orElse$1(() => messageText(value$22)));
 const isPastDepth = (depth) => depth > 4;
 const isMissingCause = (cause) => cause === void 0 || cause === null;
 const causeText = (cause, depth) => isPastDepth(depth) ? void 0 : missingCauseTextOf(cause, depth);
@@ -44576,6 +44710,583 @@ function objectCauseTextOf(cause, depth) {
 	return isObjectType(cause) ? textWithNested(ownCauseText(cause), causeText(fieldOf(cause, "cause"), depth + 1)) : void 0;
 }
 /**
+* 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) => getOrElse(fromNullishOr(importTables.get(program)), () => rememberImportTable(program));
+function rememberImportTable(program) {
+	const table = buildImportTable(program);
+	importTables.set(program, table);
+	return table;
+}
+const buildImportTable = (program) => reduce$2(flatMap$5(filter$2(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) => value(contribution).pipe(when((candidate) => candidate.kind === "module", (moduleBinding) => ({
+	...table,
+	moduleBindings: withEntry(table.moduleBindings, moduleBinding.local, moduleBinding.module)
+})), when((candidate) => candidate.kind === "namespace", (namespaceBinding) => ({
+	...table,
+	namespaces: withEntry(table.namespaces, namespaceBinding.local, namespaceBinding.binding)
+})), when((candidate) => candidate.kind === "bareFunction", (bareFunction) => ({
+	...table,
+	bareFunctions: withEntry(table.bareFunctions, bareFunction.local, {
+		module: bareFunction.module,
+		exportName: bareFunction.exportName
+	})
+})), orElse$1((pipeBinding) => ({
+	...table,
+	pipeBindings: withMember(table.pipeBindings, pipeBinding.local)
+})));
+const importContributions = (declaration) => toArray(onlyWhen(declaration.importKind !== "type", declaration)).flatMap((imported) => flatMap$5(imported.specifiers, (specifier) => toArray(specifierContribution(imported.source.value, specifier))));
+const specifierContribution = (source, specifier) => value(specifier).pipe(when(isNamedImportSpecifier, (named) => namedSpecifierContribution(source, named)), when(isNamespaceImportSpecifier, (namespace) => namespaceSpecifierContribution(source, namespace)), orElse$1(() => none()));
+const namedSpecifierContribution = (source, specifier) => onlyWhen(specifier.importKind !== "type", specifier).pipe(flatMap$7((imported) => namedContribution(source, moduleExportName(imported.imported), imported.local.name)));
+const namedContribution = (source, importedName, localName) => value(source).pipe(when((candidate) => candidate === EFFECT_SOURCE, () => effectRootContribution(importedName, localName)), when((candidate) => candidate === FUNCTION_SOURCE, () => pipeContribution(importedName, localName)), orElse$1(() => map$13(moduleNameFromSource(source), (module) => bareFunctionContribution(localName, module, importedName))));
+const effectRootContribution = (importedName, localName) => orElse$3(map$13(moduleNameFromName(importedName), (module) => moduleContribution(localName, module)), () => pipeContribution(importedName, localName));
+const pipeContribution = (importedName, localName) => onlyWhen(importedName === "pipe", pipeContributionOf(localName));
+const namespaceSpecifierContribution = (source, specifier) => map$13(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) => value(source).pipe(when((candidate) => candidate === EFFECT_SOURCE, () => some({ kind: "root" })), when((candidate) => candidate === FUNCTION_SOURCE, () => some({ kind: "functionModule" })), orElse$1(() => map$13(moduleNameFromSource(source), (module) => ({
+	kind: "module",
+	module
+}))));
+const moduleNameFromName = (name) => findFirst(MODULE_NAMES, (module) => module === name);
+const moduleNameFromSource = (source) => findFirst(MODULE_NAMES, (module) => source === `${EFFECT_SOURCE}/${module}`);
+const resolveEffectCall = (node, context) => flatMap$7(programOf(context), (program) => resolveIn(node, context, importTableFor(program)));
+const programOf = (context) => findLast(context.ancestors, isProgram);
+const resolveIn = (node, context, table) => value(node).pipe(when(isCallExpression$1, (call) => resolveCall(call, context, table)), when(isMemberExpression, (member) => resolveReference(member, context, table)), when(isIdentifier$1, (reference) => resolveReference(reference, context, table)), orElse$1(() => none()));
+const resolveCall = (call, context, table) => flatMap$7(resolveCallee(call.callee, context, table), (callee) => flatMap$7(spreadFreeArguments$1(call.arguments), (args) => flatMap$7(callForm(callee, args, call, context, table), (form) => some({
+	module: callee.module,
+	exportName: callee.exportName,
+	form,
+	args,
+	moduleAccess: moduleAccessFunction(callee, context, table)
+}))));
+const resolveReference = (reference, context, table) => flatMap$7(resolveCallee(reference, context, table), (callee) => flatMap$7(referenceForm(reference, context, table), (form) => some({
+	module: callee.module,
+	exportName: callee.exportName,
+	form,
+	args: NO_ARGUMENTS,
+	moduleAccess: moduleAccessFunction(callee, context, table)
+})));
+const referenceForm = (reference, context, table) => flatMap$7(parentCall(context), (parent) => map$13(pipePosition(parent, reference, context, table), () => PIPED_REFERENCE));
+const spreadFreeArguments$1 = (args) => value(args.some(isSpreadElement)).pipe(when(true, () => none()), orElse$1(() => some(args.filter(isSpreadFree))));
+const resolveCallee = (callee, context, table) => value(callee).pipe(when(isIdentifier$1, (reference) => resolveBareCallee(reference, context, table)), when(isMemberExpression, (member) => resolveMemberCallee(member, context, table)), orElse$1(() => none()));
+const resolveBareCallee = (reference, context, table) => flatMap$7(fromNullishOr(table.bareFunctions.get(reference.name)), (binding) => map$13(unshadowedName(reference.name, context), () => ({
+	module: binding.module,
+	exportName: binding.exportName,
+	owner: none()
+})));
+const resolveMemberCallee = (member, context, table) => flatMap$7(staticMemberName(member), (exportName) => map$13(resolveModuleObject(member.object, context, table), (owner) => ({
+	module: owner.module,
+	exportName,
+	owner: some(owner)
+})));
+const resolveModuleObject = (expression, context, table) => value(expression).pipe(when(isIdentifier$1, (reference) => identifierModuleObject(reference, context, table)), when(isMemberExpression, (member) => namespacedModuleObject(member, context, table)), orElse$1(() => none()));
+const identifierModuleObject = (reference, context, table) => orElse$3(flatMap$7(fromNullishOr(table.moduleBindings.get(reference.name)), (module) => map$13(unshadowedName(reference.name, context), () => ({
+	module,
+	access: reference
+}))), () => flatMap$7(namespaceOf(reference, context, table), (binding) => map$13(moduleOf(binding), (module) => ({
+	module,
+	access: reference
+}))));
+const namespacedModuleObject = (member, context, table) => flatMap$7(staticMemberName(member), (moduleName) => flatMap$7(namespaceOf(member.object, context, table), (binding) => value(binding).pipe(when(isRootNamespace, () => map$13(moduleNameFromName(moduleName), (module) => ({
+	module,
+	access: member
+}))), when(isModuleNamespace, (moduleNamespace) => map$13(onlyWhen(moduleNamespace.module === moduleName, member), (access) => ({
+	module: moduleNamespace.module,
+	access
+}))), orElse$1(() => none()))));
+const isRootNamespace = (binding) => binding.kind === "root";
+const moduleOf = (binding) => value(binding).pipe(when(isModuleNamespace, (moduleNamespace) => some(moduleNamespace.module)), orElse$1(() => none()));
+const isModuleNamespace = (binding) => binding.kind === "module";
+const namespaceOf = (expression, context, table) => value(expression).pipe(when(isIdentifier$1, (reference) => flatMap$7(fromNullishOr(table.namespaces.get(reference.name)), (binding) => map$13(unshadowedName(reference.name, context), () => binding))), orElse$1(() => none()));
+const callForm = (callee, args, call, context, table) => flatMap$7(arityOf(callee), (arity) => value(args.length).pipe(when((count) => arity.dataFirst.includes(count), () => some(DATA_FIRST)), when((count) => arity.dataLast === count, () => dataLastForm(call, context, table)), orElse$1(() => none())));
+const arityOf = (callee) => fromNullishOr(ARITIES[`${callee.module}.${callee.exportName}`]);
+const dataLastForm = (call, context, table) => flatMap$7(parentCall(context), (parent) => value(parent.callee === call).pipe(when(true, () => some(DATA_LAST_IMMEDIATE)), orElse$1(() => flatMap$7(pipePosition(parent, call, context, table), formForPosition))));
+const pipePosition = (parent, argument, context, table) => flatMap$7(argumentIndex(parent.arguments, argument), (index) => orElse$3(onlyWhen(isPipeMethodCall(parent), {
+	index,
+	callee: "method"
+}), () => onlyWhen(isEffectPipeCall(parent, context, table), {
+	index,
+	callee: "effect"
+})));
+const formForPosition = (position) => value(position.callee).pipe(when((callee) => callee === "method", () => some(DATA_LAST_PIPE_METHOD)), orElse$1(() => onlyWhen(position.index >= 1, DATA_LAST_PIPE_ARG)));
+const argumentIndex = (args, node) => flatMap$7(fromNullishOr(args.findIndex((argument) => sameNode(argument, node))), (index) => onlyWhen(index >= 0, index));
+const parentCall = (context) => flatMap$7(fromNullishOr(context.parent), (parent) => value(parent).pipe(when(isCallExpression$1, (call) => some(call)), orElse$1(() => none())));
+const isPipeMethodCall = (parent) => value(parent.callee).pipe(when(isMemberExpression, (member) => exists$1(staticMemberName(member), (name) => name === "pipe")), orElse$1(() => false));
+const isEffectPipeCall = (parent, context, table) => value(parent.callee).pipe(when(isIdentifier$1, (reference) => and(isVisible(reference.name, context), table.pipeBindings.has(reference.name))), when(isMemberExpression, (member) => exists$1(staticMemberName(member), (name) => and(name === "pipe", isPipeNamespace(member.object, context, table)))), orElse$1(() => false));
+const isPipeNamespace = (expression, context, table) => value(expression).pipe(when(isIdentifier$1, (reference) => match$7(namespaceOf(expression, context, table), {
+	onNone: () => false,
+	onSome: (binding) => and(isPipeNamespaceBinding(binding), isVisible(reference.name, context))
+})), orElse$1(() => false));
+const isPipeNamespaceBinding = (binding) => value(binding.kind).pipe(when((kind) => kind === "root", () => true), when((kind) => kind === "functionModule", () => true), orElse$1(() => false));
+const moduleAccessFunction = (callee, context, table) => (module) => findFirst([
+	ownerAccessFor(callee, module),
+	namedModuleAccess(module, context, table),
+	rootNamespaceAccess(module, context, table),
+	moduleNamespaceAccess(module, context, table)
+], isSome).pipe(flatten$3);
+const ownerAccessFor = (callee, module) => flatMap$7(callee.owner, (owner) => onlyWhen(owner.module === module, owner.access));
+const namedModuleAccess = (module, context, table) => map$13(fromNullishOr([...table.moduleBindings].find(([local, bound]) => and(bound === module, isVisible(local, context)))), ([local]) => identifier(local));
+const rootNamespaceAccess = (module, context, table) => map$13(fromNullishOr([...table.namespaces].find(([local, binding]) => and(binding.kind === "root", isVisible(local, context)))), ([local]) => memberExpression(identifier(local), identifier(module), false));
+const moduleNamespaceAccess = (module, context, table) => map$13(fromNullishOr([...table.namespaces].find(([local, binding]) => and(exists$1(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) => value(node).pipe(when(isIdentifier$1, () => true), when(isLiteral, () => true), when(isThisExpression, () => true), when(isFunctionLike, () => true), when(isMemberExpression, (member) => isCallFreeMemberChain(member)), orElse$1(() => false));
+const isCallFreeMemberChain = (member) => value(member.computed).pipe(when(true, () => false), orElse$1(() => value(member.object).pipe(when(isIdentifier$1, () => true), when(isThisExpression, () => true), when(isMemberExpression, (inner) => isCallFreeMemberChain(inner)), orElse$1(() => false))));
+const identifiersIn = (node) => allNodesUnder(node).flatMap((candidate) => toArray(identifierText(candidate)));
+const freshIdentifier = (base, taken) => freeIdentifier(base, taken, 0);
+const freeIdentifier = (base, taken, suffix) => value(taken.has(suffixedName(base, suffix))).pipe(when(false, () => suffixedName(base, suffix)), orElse$1(() => freeIdentifier(base, taken, suffix + 1)));
+const suffixedName = (base, suffix) => value(suffix).pipe(when(0, () => base), orElse$1((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) => value(ancestor).pipe(when(isProgram, (program) => statementsDeclare(program.body, name)), when(isBlockStatement, (block) => statementsDeclare(block.body, name)), when(isStaticBlock, (block) => statementsDeclare(block.body, name)), when(isTSModuleBlock, (block) => statementsDeclare(block.body, name)), when(isSwitchStatement, (statement) => statement.cases.some((caseClause) => statementsDeclare(caseClause.consequent, name))), when(isFunctionLike, (fn) => functionDeclares(fn, name)), when(isCatchClause, (clause) => patternDeclaresOr(clause.param, name)), when(isForStatement, (statement) => variableDeclarationDeclaresOr(statement.init, name)), when(isForInStatement, (statement) => variableDeclarationDeclaresOr(statement.left, name)), when(isForOfStatement, (statement) => variableDeclarationDeclaresOr(statement.left, name)), when(isClassLike, (cls) => declaresIdentifier(cls.id, name)), orElse$1(() => 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) => match$7(fromNullishOr(body), {
+	onNone: () => false,
+	onSome: (present) => value(present).pipe(when(isBlockStatement, (block) => hoistedVarsDeclare(block, name)), orElse$1(() => false))
+});
+const hoistedVarsDeclare = (block, name) => nodesOutsideFunctions(block).some((candidate) => hoistedCandidateDeclares(candidate, name));
+const hoistedCandidateDeclares = (candidate, name) => value(candidate).pipe(when(isVariableDeclaration, (declaration) => and(declaration.kind === "var", statementBindingsDeclare(declaration, name))), orElse$1(() => false));
+const statementsDeclare = (statements, name) => statements.some((statement) => statementDeclares(statement, name));
+const statementDeclares = (statement, name) => value(statement).pipe(when(isVariableDeclaration, (declaration) => statementBindingsDeclare(declaration, name)), when(isFunctionDeclaration, (declaration) => declaresIdentifier(declaration.id, name)), when(isClassLike, (declaration) => declaresIdentifier(declaration.id, name)), when(isTSEnumDeclaration, (declaration) => declaration.id.name === name), when(isTSModuleDeclaration, (declaration) => moduleDeclarationDeclares(declaration, name)), when(isTSImportEqualsDeclaration, (declaration) => importEqualsDeclares(declaration, name)), when(isExportNamedDeclaration, (declaration) => exists$1(fromNullishOr(declaration.declaration), (inner) => statementDeclares(inner, name))), orElse$1(() => false));
+const statementBindingsDeclare = (declaration, name) => declaration.declarations.some((declarator) => patternDeclaresOr(declarator.id, name));
+const variableDeclarationDeclaresOr = (node, name) => match$7(fromNullishOr(node), {
+	onNone: () => false,
+	onSome: (present) => value(present).pipe(when(isVariableDeclaration, (declaration) => statementBindingsDeclare(declaration, name)), orElse$1(() => false))
+});
+const moduleDeclarationDeclares = (declaration, name) => and(declaration.body !== null, exists$1(identifierText(declaration.id), (text) => text === name));
+const importEqualsDeclares = (declaration, name) => and(declaration.importKind !== "type", declaration.id.name === name);
+const declaresIdentifier = (id, name) => exists$1(identifierText(id), (text) => text === name);
+const patternDeclaresOr = (pattern, name) => match$7(fromNullishOr(pattern), {
+	onNone: () => false,
+	onSome: (present) => value(present).pipe(when(isBindingIdentifierPattern, (binding) => binding.name === name), when(isObjectBindingPattern, (object) => object.properties.some((property) => propertyDeclares(property, name))), when(isArrayBindingPattern, (array) => array.elements.some((element) => patternDeclaresOr(element, name))), when(isAssignmentBindingPattern, (assignment) => patternDeclaresOr(assignment.left, name)), when(isBindingRestElement, (rest) => patternDeclaresOr(rest.argument, name)), orElse$1(() => false))
+});
+const propertyDeclares = (property, name) => value(property).pipe(when(isBindingProperty, (binding) => patternDeclaresOr(binding.value, name)), when(isBindingRestElement, (rest) => patternDeclaresOr(rest.argument, name)), orElse$1(() => 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) => match$7(fromNullishOr(node), {
+	onNone: () => none(),
+	onSome: (present) => value(present).pipe(when(isNamedIdentifier, (name) => some(name.name)), when(isStringLiteral$1, (literal) => literalValueText(literal.value)), orElse$1(() => none()))
+});
+const literalValueText = (value$20) => value(value$20).pipe(when(isString, (text) => some(text)), orElse$1(() => none()));
+const moduleExportName = (name) => getOrElse(identifierText(name), () => "");
+const staticMemberName = (member) => value(member.computed).pipe(when(false, () => identifierText(member.property)), orElse$1(() => 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) => match$7(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$23) => value(holds).pipe(when(true, () => some(value$23)), orElse$1(() => 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";
+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) => match$7(resolveEffectCall(node, context), {
+	onNone: () => NO_MUTANTS$3,
+	onSome: (call) => toArray(atomicUpdateSplitReplacement(call))
+});
+const atomicUpdateSplitReplacement = (call) => flatMap$7(splitOperation(call), (operation) => some(replacementExpression$1(operation)));
+const splitOperation = (call) => value(call).pipe(when(isAtomicUpdateSplitOperation, (covered) => splitOperationOf(covered)), orElse$1(() => none()));
+const isAtomicUpdateSplitOperation = (call) => and(included(ATOMIC_UPDATE_SPLIT_MODULES, call.module), included(ATOMIC_UPDATE_SPLIT_OPERATIONS, call.exportName));
+const splitOperationOf = (call) => flatMap$7(moduleBindings(call), (bindings) => flatMap$7(splitArguments$1(call), (args) => 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) => value(call.form).pipe(when((form) => form === "data-first", () => dataFirstArguments$1(call)), when((form) => form === "piped-reference", () => none()), orElse$1(() => dataLastArguments(call)));
+const dataFirstArguments$1 = (call) => flatMap$7(get$8(call.args, 0), (ref) => flatMap$7(get$8(call.args, 1), (f) => onlyWhen(and(isMovableArgument(ref), isMovableArgument(f)), {
+	ref: some(cloneNode(ref)),
+	f: cloneNode(f)
+})));
+const dataLastArguments = (call) => flatMap$7(get$8(call.args, 0), (f) => onlyWhen(isMovableArgument(f), {
+	ref: none(),
+	f: cloneNode(f)
+}));
+const moduleBindings = (call) => flatMap$7(call.moduleAccess("Effect"), (effectModule) => map$13(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) => match$7(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);
+const NO_MUTANTS$2 = [];
+const COVERED_MODULE = "Effect";
+const TAG = "_tag";
+const SUCCESS_TAG = "Success";
+const INTERRUPT_TAG = "Interrupt";
+const finalizerEscapeMutator = (node, context) => match$7(resolveEffectCall(node, context), {
+	onNone: () => NO_MUTANTS$2,
+	onSome: (call) => toArray(replacementOf(call))
+});
+const replacementOf = (call) => flatMap$7(onlyWhen(call.module === COVERED_MODULE, call), (covered) => flatMap$7(covered.moduleAccess(COVERED_MODULE), (effect) => flatMap$7(coveredForm(covered), (form) => flatMap$7(splitArguments(covered, form), (split) => flatMap$7(shapeOf(covered.exportName, split.rest), (shape) => 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) => value(call.form).pipe(when("data-first", () => some("data-first")), when("data-last-pipe-arg", () => some("data-last")), when("data-last-pipe-method", () => some("data-last")), when("data-last-immediate", () => some("data-last")), orElse$1(() => none()));
+const splitArguments = (call, form) => value(form).pipe(when("data-first", () => dataFirstArguments(call)), orElse$1(() => some({
+	self: none(),
+	rest: [...call.args]
+})));
+const dataFirstArguments = (call) => map$13(get$8(call.args, 0), (self) => ({
+	self: some(cloneNode(self)),
+	rest: call.args.slice(1)
+}));
+const selfExpression = (split, binders) => getOrElse(split.self, () => identifier(binders.self));
+const shapeOf = (exportName, rest) => value(exportName).pipe(when("ensuring", () => finalizerShape(rest)), when("onExit", () => exitShape(rest)), when("onError", () => handlerShape(rest)), when("onInterrupt", () => droppedHandlerShape(rest)), when("acquireRelease", () => releaseShape(rest)), when("acquireUseRelease", () => useReleaseShape(rest)), orElse$1(() => none()));
+const finalizerShape = (rest) => flatMap$7(get$8(rest, 0), (fin) => onlyWhen(isMovableArgument(fin), {
+	kind: "ensuring",
+	fin
+}));
+const exitShape = (rest) => map$13(get$8(rest, 0), (f) => ({
+	kind: "onExit",
+	f
+}));
+const handlerShape = (rest) => map$13(get$8(rest, 0), (h) => ({
+	kind: "onError",
+	h
+}));
+const droppedHandlerShape = (rest) => flatMap$7(get$8(rest, 0), (h) => onlyWhen(isDroppableArgument(h), {
+	kind: "onInterrupt",
+	h
+}));
+const releaseShape = (rest) => flatMap$7(get$8(rest, 0), (rel) => flatMap$7(droppableOptionAt(rest, 1), (optionsDroppable) => onlyWhen(and(isMovableArgument(rel), optionsDroppable), {
+	kind: "acquireRelease",
+	rel
+})));
+const useReleaseShape = (rest) => flatMap$7(get$8(rest, 1), (rel) => flatMap$7(get$8(rest, 0), (use) => flatMap$7(releaseArityOf(rel), (releaseArity) => onlyWhen(isMovableArgument(rel), {
+	kind: "acquireUseRelease",
+	use,
+	rel,
+	releaseArity
+}))));
+const droppableOptionAt = (rest, index) => match$7(get$8(rest, index), {
+	onNone: () => some(true),
+	onSome: (argument) => onlyWhen(isDroppableArgument(argument), true)
+});
+const bodyExpression = (plan) => value(plan.shape).pipe(when({ kind: "ensuring" }, (shape) => moduleCall(plan.effect, "onExitIf", [
+	plan.self,
+	notInterruptedPredicate(plan.binders),
+	arrowFunctionExpression([], shape.fin)
+])), when({ kind: "onExit" }, (shape) => moduleCall(plan.effect, "onExitIf", [
+	plan.self,
+	notInterruptedPredicate(plan.binders),
+	shape.f
+])), when({ kind: "onError" }, (shape) => moduleCall(plan.effect, "onErrorIf", [
+	plan.self,
+	noInterruptPredicate(plan.binders),
+	shape.h
+])), when({ kind: "onInterrupt" }, () => plan.self), when({ kind: "acquireRelease" }, (shape) => releaseBody(plan, shape)), when({ kind: "acquireUseRelease" }, (shape) => useReleaseBody(plan, shape)), 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, take$2([identifier(binders.a), identifier(binders.exit)], releaseArity));
+const releaseArityOf = (rel) => value(rel).pipe(when(isInlineFunction, plainParameterArity), orElse$1(() => none()));
+const isInlineFunction = (candidate) => nodeType(candidate) === "ArrowFunctionExpression" || nodeType(candidate) === "FunctionExpression";
+const plainParameterArity = (fn) => onlyWhen(and(fn.params.every(isPlainParameter), fn.params.length <= 2), fn.params.length);
+const isPlainParameter = (param) => nodeType(param) === "Identifier";
+const placedBody = (form, body, binders) => value(form).pipe(when("data-first", () => body), orElse$1(() => 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)
+});
+/**
+* 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) => match$7(resolveEffectCall(node, context), {
+	onNone: () => NO_MUTANTS$1,
+	onSome: (call) => toArray(synchronizationRemovalReplacement(call))
+});
+const synchronizationRemovalReplacement = (call) => value(call).pipe(when(isWithPermits, withPermitsReplacement), when(isWithPermit, withPermitReplacement), when(isUninterruptible, uninterruptibleReplacement), when(isUninterruptibleMask, uninterruptibleMaskReplacement), orElse$1(() => none()));
+const isWithPermits = (call) => and(call.module === "Semaphore", call.exportName === "withPermits");
+const isWithPermit = (call) => and(call.module === "Semaphore", call.exportName === "withPermit");
+const isUninterruptible = (call) => and(call.module === "Effect", call.exportName === "uninterruptible");
+const isUninterruptibleMask = (call) => and(call.module === "Effect", call.exportName === "uninterruptibleMask");
+const isDataFirst = (form) => form === "data-first";
+const isPipedReference = (form) => form === "piped-reference";
+const withPermitsReplacement = (call) => value(call.form).pipe(when(isDataFirst, () => whenDroppable(call, [0, 1], (guarded) => argumentReplacement(guarded, 2))), orElse$1(() => whenDroppable(call, [0, 1], identityFunctionOf)));
+const withPermitReplacement = (call) => value(call.form).pipe(when(isDataFirst, () => whenDroppable(call, [0], (guarded) => argumentReplacement(guarded, 1))), orElse$1(() => whenDroppable(call, [0], identityFunctionOf)));
+const uninterruptibleReplacement = (call) => value(call.form).pipe(when(isPipedReference, () => some(identityFunction(call))), orElse$1(() => argumentReplacement(call, 0)));
+const uninterruptibleMaskReplacement = (call) => whenMovable(call, [0], (masked) => flatMap$7(masked.moduleAccess("Effect"), (effectModule) => map$13(get$8(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) => map$13(get$8(call.args, index), (argument) => cloneNode(argument));
+const identityFunctionOf = (call) => 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) => flatMap$7(onlyWhen(argumentsDroppable(call, indices), call), build);
+const whenMovable = (call, indices, build) => flatMap$7(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) => exists$1(get$8(call.args, index), predicate);
+/**
 * Mutator — every mutation operator and its registry.
 */
 /**
@@ -45408,8 +46119,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,
@@ -45427,6 +46141,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)]
+});
 TaggedError("@systemfsoftware/stryker-js-instrumenter/Transformer.schema/PlacementFailed")("PlacementFailed", {
 	fileName: String$7,
 	placerName: String$7,
@@ -45440,6 +46176,10 @@ TaggedError("@systemfsoftware/stryker-js-instrumenter/Transformer.schema/Transfo
 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 [];
 }
@@ -45475,11 +46215,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(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
 	};
 }
@@ -45508,36 +46248,39 @@ function strykerDirective(match, loc) {
 function matchGroup(match, group) {
 	return getOrThrowWith$1(fromNullishOr(match[group]), () => /* @__PURE__ */ new Error(PARSE_FAILURE));
 }
-function applyStrykerDirective(rule, directive) {
-	return value(directive.type).pipe(when("disable", () => ignoreRuleFor(rule, directive)), when("restore", () => restoreRuleFor(rule, directive)), orElse$1(() => rule));
+const nextLineOn = (directive, nodeLine) => ({
+	directive,
+	nodeLine
+});
+function applyStrykerDirective(rule, directed) {
+	return value(directed.directive.type).pipe(when("disable", () => ignoreRuleFor(rule, directed)), when("restore", () => restoreRuleFor(rule, directed)), orElse$1(() => 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 value(directive.scope).pipe(when("next-line", () => commentLocation(directive.loc).start.line), orElse$1(() => void 0));
+function directiveLine(directed) {
+	return value(directed.directive.scope).pipe(when("next-line", () => directed.nodeLine), orElse$1(() => void 0));
 }
 function commentLocation(loc) {
 	return getOrThrowWith$1(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);
@@ -46023,19 +46766,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 gen(function* () {
 		const lineTable = buildLineTable(rawContent);
 		attachComments(root, comments, lineTable);
 		let directiveRule = rootRule;
-		const mutatorEntries = Object.entries(getOrElse(fromNullishOr(mutators), () => allMutators));
+		const mutatorRegistry = getOrElse(fromNullishOr(registry), () => DEFAULT_MUTATOR_REGISTRY);
+		const selection = selectMutators(mutatorRegistry, options.optInMutations);
+		const mutatorEntries = selection.active;
 		const placers = getOrElse(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);
@@ -46045,6 +46790,12 @@ const transformScript = ({ root, originFileName, rawContent, offset, comments },
 				if (hasAppliedMutants(placement)) applyPlacement(path, placement);
 			}
 		});
+		function nodeStartLine(node) {
+			return match$7(fromNullishOr(spanOf(node)), {
+				onNone: () => 0,
+				onSome: (span) => positionFromLineTable(span.start, lineTable).line
+			});
+		}
 		yield* placeHeaderIfNeeded(mutantCollector, originFileName, options, root);
 		return warnings;
 		function visitNode(path) {
@@ -46316,9 +47067,26 @@ function toOneBasedLineNumber(range) {
 function isIgnorer(value) {
 	return isObject(value) && typeof value["shouldIgnore"] === "function";
 }
+const EMPTY_MUTATION_NAMES = [];
+const KNOWN_OPT_IN_MUTATIONS = Object.keys(optInMutators);
+const requestedOptInMutations = (options) => getOrElse(fromNullishOr(options.optInMutations), () => EMPTY_MUTATION_NAMES);
+const unknownOptInMutations = (requested) => requested.filter((name) => !KNOWN_OPT_IN_MUTATIONS.includes(name));
+const listNames$1 = (names) => match$7(fromNullishOr(names.at(0)), {
+	onNone: () => "none",
+	onSome: () => names.map((name) => `'${name}'`).join(", ")
+});
+const unknownOptInMutationsError = (requested) => map$13(fromNullishOr(unknownOptInMutations(requested).at(0)), () => InstrumentError$1.make({
+	message: `Unknown opt-in mutations: ${listNames$1(unknownOptInMutations(requested))}. Known opt-in mutations: ${listNames$1(KNOWN_OPT_IN_MUTATIONS)}.`,
+	cause: void 0
+}));
+const refuseUnknownOptInMutations = (requested) => match$7(unknownOptInMutationsError(requested), {
+	onNone: () => void_$1,
+	onSome: (error) => fail$2(error)
+});
 function toTransformerOptions(options) {
 	const base = {
 		excludedMutations: [...options.excludedMutations],
+		optInMutations: [...requestedOptInMutations(options)],
 		ignorers: options.ignorers.filter(isIgnorer)
 	};
 	if (options.noHeader !== void 0) return {
@@ -46340,6 +47108,7 @@ function printedFile(file, ast) {
 	}];
 }
 const instrument = (files, options, basePath) => gen(function* () {
+	yield* refuseUnknownOptInMutations(requestedOptInMutations(options));
 	const schemaFiles = files.map((file) => ({
 		name: file.name,
 		content: file.content,
@@ -46922,7 +47691,7 @@ const FileResultDictionarySchema = Record(String$7, Struct({
 		replacement: optional$4(String$7),
 		description: optional$4(String$7),
 		statusReason: optional$4(String$7),
-		static: optional$4(Boolean$5),
+		static: optional$4(Boolean$6),
 		coveredBy: optional$4(ArraySchema(String$7)),
 		killedBy: optional$4(ArraySchema(String$7)),
 		testsCompleted: optional$4(NonNegativeInt),
@@ -47070,7 +47839,7 @@ const DryRunOptionsSchema = Struct({
 	files: optionalKey(ArraySchema(String$7)),
 	testFiles: optionalKey(ArraySchema(String$7))
 });
-const TestRunnerCapabilitiesSchema = Struct({ reloadEnvironment: Boolean$5 });
+const TestRunnerCapabilitiesSchema = Struct({ reloadEnvironment: Boolean$6 });
 var TestRunnerFailed = class extends TaggedError()("TestRunnerFailed", {
 	cause: String$7,
 	phase: Literals$2([
@@ -47096,7 +47865,7 @@ const ReporterPlanDescriptorSchema = Struct({
 	mutantId: String$7,
 	plan: Literals$2(["EarlyResult", "Run"]),
 	netTime: NonNegativeFinite,
-	reloadEnvironment: Boolean$5
+	reloadEnvironment: Boolean$6
 });
 var DryRunCompleted = class extends TaggedClass()("dryRunCompleted", {
 	timing: RunTimingSchema,
@@ -47282,14 +48051,14 @@ const PackageManager = Literals$2([
 ]);
 const CommandRunnerOptionsSchema = openStruct({ command: defaulted(String$7, "npm test") });
 const ClearTextReporterOptions = openStruct({
-	allowColor: defaulted(Boolean$5, true),
-	allowEmojis: defaulted(Boolean$5, false),
-	logTests: defaulted(Boolean$5, true),
+	allowColor: defaulted(Boolean$6, true),
+	allowEmojis: defaulted(Boolean$6, false),
+	logTests: defaulted(Boolean$6, true),
 	maxTestsToLog: defaulted(Finite$3.pipe(check(isGreaterThanOrEqualTo(0))), 3),
-	reportTests: defaulted(Boolean$5, true),
-	reportMutants: defaulted(Boolean$5, true),
-	reportScoreTable: defaulted(Boolean$5, true),
-	skipFull: defaulted(Boolean$5, false)
+	reportTests: defaulted(Boolean$6, true),
+	reportMutants: defaulted(Boolean$6, true),
+	reportScoreTable: defaulted(Boolean$6, true),
+	skipFull: defaulted(Boolean$6, false)
 });
 const HtmlReporterOptions = Struct({ fileName: defaulted(String$7, "reports/mutation/mutation.html") });
 const JsonReporterOptions = Struct({ fileName: defaulted(String$7, "reports/mutation/mutation.json") });
@@ -47319,12 +48088,15 @@ const OrderedMutationScoreThresholds = declare(isMutationScoreThresholds, {
 	})
 });
 const MutationScoreThresholdsSchema = MutationScoreThresholdsValuesSchema.pipe(decodeTo(OrderedMutationScoreThresholds, passthrough()));
-const MutatorDescriptor = Struct({ excludedMutations: defaulted(ArraySchema(String$7), []) });
+const MutatorDescriptor = Struct({
+	excludedMutations: defaulted(ArraySchema(String$7), []),
+	optInMutations: defaulted(ArraySchema(String$7), [])
+});
 const WarningOptions = openStruct({
-	unknownOptions: defaulted(Boolean$5, true),
-	preprocessorErrors: defaulted(Boolean$5, true),
-	unserializableOptions: defaulted(Boolean$5, true),
-	slow: defaulted(Boolean$5, true)
+	unknownOptions: defaulted(Boolean$6, true),
+	preprocessorErrors: defaulted(Boolean$6, true),
+	unserializableOptions: defaulted(Boolean$6, true),
+	slow: defaulted(Boolean$6, true)
 });
 const ConcurrencyCount = Finite$3.pipe(check(isGreaterThanOrEqualTo(1)));
 const ConcurrencyPercent = String$7.pipe(check(isPattern(/^(100|[1-9]?[0-9])%$/)));
@@ -47340,7 +48112,7 @@ const CheckerEntryConfigSchema = Struct({
 	options: optional$4(Record(String$7, Unknown))
 });
 const StrykerOptionsSchema = StructWithRest(Struct({
-	allowConsoleColors: defaulted(Boolean$5, true),
+	allowConsoleColors: defaulted(Boolean$6, true),
 	buildCommand: optional$4(String$7),
 	checkers: defaulted(ArraySchema(CheckerEntryConfigSchema), []),
 	checkerNodeArgs: defaulted(ArraySchema(String$7), []),
@@ -47357,20 +48129,23 @@ const StrykerOptionsSchema = StructWithRest(Struct({
 		reportScoreTable: true,
 		skipFull: false
 	}),
-	dryRunOnly: defaulted(Boolean$5, false),
+	dryRunOnly: defaulted(Boolean$6, false),
 	ignorePatterns: defaulted(ArraySchema(String$7), []),
-	ignoreStatic: defaulted(Boolean$5, false),
-	incremental: defaulted(Boolean$5, false),
+	ignoreStatic: defaulted(Boolean$6, false),
+	incremental: defaulted(Boolean$6, false),
 	incrementalFile: defaulted(String$7, "reports/stryker-incremental.json"),
 	progressStreamFile: defaulted(String$7, "reports/mutation-stream.jsonl"),
-	force: defaulted(Boolean$5, false),
+	force: defaulted(Boolean$6, false),
 	fileLogLevel: defaulted(LogLevel$1, RENDERED_OPTION_DEFAULTS$1.fileLogLevel),
-	inPlace: defaulted(Boolean$5, false),
+	inPlace: defaulted(Boolean$6, false),
 	logLevel: defaulted(LogLevel$1, RENDERED_OPTION_DEFAULTS$1.logLevel),
 	maxConcurrentTestRunners: defaulted(Finite$3, 9007199254740991),
 	maxTestRunnerReuse: defaulted(Finite$3, 0),
 	mutate: defaulted(ArraySchema(String$7), ["{src,lib}/**/!(*.+(s|S)pec|*.+(t|T)est).+(cjs|mjs|js|ts|mts|cts|jsx|tsx|html|vue|svelte)", "!{src,lib}/**/__tests__/**/*.+(cjs|mjs|js|ts|mts|cts|jsx|tsx|html|vue|svelte)"]),
-	mutator: defaulted(MutatorDescriptor, { excludedMutations: [] }),
+	mutator: defaulted(MutatorDescriptor, {
+		excludedMutations: [],
+		optInMutations: []
+	}),
 	packageManager: optional$4(PackageManager),
 	plugins: defaulted(ArraySchema(PluginFileUrl), []),
 	appendPlugins: defaulted(ArraySchema(PluginFileUrl), []),
@@ -47381,8 +48156,8 @@ const StrykerOptionsSchema = StructWithRest(Struct({
 	]),
 	htmlReporter: defaulted(HtmlReporterOptions, { fileName: "reports/mutation/mutation.html" }),
 	jsonReporter: defaulted(JsonReporterOptions, { fileName: "reports/mutation/mutation.json" }),
-	disableTypeChecks: defaulted(Union([Boolean$5, String$7]), true),
-	symlinkNodeModules: defaulted(Boolean$5, true),
+	disableTypeChecks: defaulted(Union([Boolean$6, String$7]), true),
+	symlinkNodeModules: defaulted(Boolean$6, true),
 	tempDirName: defaulted(String$7, RENDERED_OPTION_DEFAULTS$1.tempDirName),
 	cleanTempDir: defaulted(Literals$2([
 		"always",
@@ -47400,9 +48175,9 @@ const StrykerOptionsSchema = StructWithRest(Struct({
 	timeoutMS: defaulted(Finite$3, 5e3),
 	dryRunTimeoutMinutes: defaulted(Finite$3.pipe(check(isGreaterThanOrEqualTo(0))), 5),
 	tsconfigFile: defaulted(String$7, "tsconfig.json"),
-	warnings: defaulted(Union([Boolean$5, WarningOptions]), true),
-	disableBail: defaulted(Boolean$5, false),
-	allowEmpty: defaulted(Boolean$5, false),
+	warnings: defaulted(Union([Boolean$6, WarningOptions]), true),
+	disableBail: defaulted(Boolean$6, false),
+	allowEmpty: defaulted(Boolean$6, false),
 	ignorers: defaulted(ArraySchema(PluginFileUrl), []),
 	testFiles: defaulted(ArraySchema(String$7), [])
 }), [Record(String$7, Unknown)]);
@@ -54215,7 +54990,7 @@ function wasProducedBySurvivorsRun(priorReport) {
 const hashValueSchema = () => Union([
 	Null,
 	Finite$3,
-	Boolean$5,
+	Boolean$6,
 	String$7,
 	ArraySchema(suspend$1(hashValueSchema)),
 	Record(String$7, suspend$1(hashValueSchema))
@@ -54324,14 +55099,14 @@ const admitSurvivorsRun = Workflow_exports.make(AdmitSurvivorsRunCommand, decide
 //#endregion
 //#region src/classify-run-outcome.workflow.ts
 var RunOutcomeCommand = class extends TaggedClass()("RunOutcomeCommand", {
-	succeeded: Boolean$5,
-	interrupted: Boolean$5,
+	succeeded: Boolean$6,
+	interrupted: Boolean$6,
 	helpErrorCount: optional$4(Finite$3),
-	cliError: Boolean$5,
+	cliError: Boolean$6,
 	unrecognized: optional$4(String$7),
 	survivorsReason: optional$4(Literals$2(["no-report", "mismatch"])),
 	survivorsDiagnostic: optional$4(String$7),
-	schemaError: Boolean$5,
+	schemaError: Boolean$6,
 	successExitClass: optional$4(ExitClass),
 	highestExitClass: optional$4(ExitClass),
 	configDetail: optional$4(String$7),
@@ -54345,7 +55120,7 @@ var RunExit = class extends TaggedError()("RunExit", { code: Finite$3 }) {
 const CONFIG_CODE$1 = 2;
 const classCode = (exitClass) => value(exitClass).pipe(when("VerdictFail", () => 1), when("ConfigError", () => CONFIG_CODE$1), when("RuntimeError", () => 3), when("InternalError", () => 4), exhaustive);
 const RunOutcomeTypeId = Symbol.for("@systemfsoftware/stryker-js/RunOutcome");
-var RunOk = class extends TaggedClass()("RunOk", { help: Boolean$5 }) {
+var RunOk = class extends TaggedClass()("RunOk", { help: Boolean$6 }) {
 	[RunOutcomeTypeId] = RunOutcomeTypeId;
 };
 var RunInterrupted = class extends TaggedError()("RunInterrupted", { code: Finite$3 }) {
@@ -55684,7 +56459,7 @@ const EMPTY_TEST_FILES = {};
 const ReportPart = Struct({
 	label: String$7,
 	outcome: String$7,
-	incomplete: Boolean$5,
+	incomplete: Boolean$6,
 	report: optional$4(MutationTestResultSchema)
 });
 const MergeVerdictRow = Struct({
@@ -64701,7 +65476,7 @@ function jsonSchema() {
 	schema = Union([
 		Null,
 		Finite$3,
-		Boolean$5,
+		Boolean$6,
 		String$7,
 		ArraySchema(suspend$1(() => schema)),
 		Record(String$7, suspend$1(() => schema))
@@ -64723,12 +65498,12 @@ function regexpSchema() {
 			"^\\d{4}-\\d{2}-\\d{2}$"
 		]),
 		flags: Struct({
-			g: Boolean$5,
-			i: Boolean$5,
-			m: Boolean$5,
-			s: Boolean$5,
-			u: Boolean$5,
-			y: Boolean$5
+			g: Boolean$6,
+			i: Boolean$6,
+			m: Boolean$6,
+			s: Boolean$6,
+			u: Boolean$6,
+			y: Boolean$6
 		})
 	});
 }
@@ -66174,12 +66949,12 @@ var PlannedTestView = class extends Class("PlannedTestView")({
 	fullName: String$7,
 	file: String$7,
 	seq: Finite$3,
-	inverted: Boolean$5,
-	skipped: Boolean$5
+	inverted: Boolean$6,
+	skipped: Boolean$6
 }) {};
 var DrainRegistryCommand = class extends TaggedClass()("DrainRegistryCommand", {
 	plan: ArraySchema(PlannedTestView),
-	timedOut: optional$4(Boolean$5),
+	timedOut: optional$4(Boolean$6),
 	outcomes: optional$4(Record(String$7, TestOutcomeSchema)),
 	lateRejections: optional$4(ArraySchema(String$7))
 }) {};
@@ -84036,8 +84811,8 @@ const FramingState = Struct({
 		"agent",
 		"tool"
 	]),
-	headerWritten: Boolean$5,
-	terminalSeen: Boolean$5,
+	headerWritten: Boolean$6,
+	terminalSeen: Boolean$6,
 	completed: NonNegativeInt,
 	total: NullOr(NonNegativeInt)
 });
@@ -84180,7 +84955,7 @@ var DryRunCommand = class extends TaggedClass()("DryRunCommand", {
 	]),
 	testCount: Finite$3,
 	failedTestCount: Finite$3,
-	allowEmpty: Boolean$5,
+	allowEmpty: Boolean$6,
 	errorMessage: optional$4(String$7),
 	reason: optional$4(String$7)
 }) {};
@@ -86204,7 +86979,7 @@ var InstrumentError = class extends TaggedError()("InstrumentError", {
 }) {};
 var InstrumentCommand = class extends TaggedClass()("InstrumentCommand", {
 	fileCount: Finite$3,
-	inPlace: Boolean$5,
+	inPlace: Boolean$6,
 	pluginCount: Finite$3
 }) {};
 const InstrumentDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js/InstrumentDecision");
@@ -86266,7 +87041,7 @@ const FileResultLikeSchema = Struct({
 		]),
 		killedBy: optional$4(ArraySchema(String$7)),
 		coveredBy: optional$4(ArraySchema(String$7)),
-		static: optional$4(Boolean$5),
+		static: optional$4(Boolean$6),
 		statusReason: optional$4(String$7),
 		testsCompleted: optional$4(Finite$3),
 		description: optional$4(String$7),
@@ -87065,17 +87840,17 @@ const ExtendsArraySchema = ArraySchema(String$7);
 TaggedClass()("SandboxCommand", {
 	fileEntries: ArraySchema(Struct({
 		name: String$7,
-		hasChanges: Boolean$5
+		hasChanges: Boolean$6
 	})),
 	basePath: String$7,
 	workingDirectory: String$7,
 	backupDirectory: String$7,
-	inPlace: Boolean$5
+	inPlace: Boolean$6
 });
 TaggedClass()("SandboxDecision", { entries: ArraySchema(Struct({
 	original: String$7,
 	target: String$7,
-	needsBackup: Boolean$5
+	needsBackup: Boolean$6
 })) });
 //#endregion
 //#region src/Sandbox.ts
@@ -87415,7 +88190,8 @@ const instrumentCell = Sandwich_exports.read((command) => gen(function* () {
 	})));
 	const instrumentResult = yield* instrument(filesToMutate, {
 		ignorers: [...command.ignorers],
-		excludedMutations: [...command.options.mutator.excludedMutations]
+		excludedMutations: [...command.options.mutator.excludedMutations],
+		optInMutations: [...command.options.mutator.optInMutations]
 	}, env.basePath).pipe(mapError$1((cause) => StageError.make({
 		stage: "instrument",
 		reason: "Instrumenter failed",
@@ -87486,10 +88262,10 @@ const instrumentCell = Sandwich_exports.read((command) => gen(function* () {
 //#endregion
 //#region src/MutationTest.schema.ts
 var MutationTestCommand = class extends TaggedClass()("MutationTestCommand", {
-	dryRunOnly: Boolean$5,
-	allowEmpty: Boolean$5,
+	dryRunOnly: Boolean$6,
+	allowEmpty: Boolean$6,
 	testCount: Finite$3,
-	isZero: Boolean$5
+	isZero: Boolean$6
 }) {};
 //#endregion
 //#region src/admit-mutation-test.workflow.ts
@@ -90430,9 +91206,9 @@ const runStrykerCli = (input, createRunEventStream) => gen(function* () {
 //#region src/resolve-output-mode.workflow.ts
 const TOOL_VARIABLES$1 = ["CLAUDECODE", "CODEX_SANDBOX"];
 var ResolveModeCommand = class extends TaggedClass()("ResolveModeCommand", {
-	stdoutIsTTY: Boolean$5,
-	text: optional$4(Boolean$5),
-	json: optional$4(Boolean$5),
+	stdoutIsTTY: Boolean$6,
+	text: optional$4(Boolean$6),
+	json: optional$4(Boolean$6),
 	envMode: optional$4(String$7),
 	agent: optional$4(String$7),
 	toolVars: optional$4(Record(String$7, String$7))
@@ -90454,13 +91230,13 @@ const ModeSignal = Literals$2([
 ]);
 var HumanOutput = class extends TaggedClass()("HumanOutput", {
 	signal: ModeSignal,
-	stdoutIsTTY: Boolean$5
+	stdoutIsTTY: Boolean$6
 }) {
 	[ResolveModeTypeId] = ResolveModeTypeId;
 };
 var MachineOutput = class extends TaggedClass()("MachineOutput", {
 	signal: ModeSignal,
-	stdoutIsTTY: Boolean$5
+	stdoutIsTTY: Boolean$6
 }) {
 	[ResolveModeTypeId] = ResolveModeTypeId;
 };