@systemfsoftware/stryker-js 12.1.1 → 13.0.0

package/dist/{Run.schema-BaK_pxuK.mjs → dist-BscHZmXN.mjs}

@@ -7,15 +7,15 @@ import * as Result from "effect/Result";
 import * as S from "effect/Schema";
 import * as Effect$1 from "effect/Effect";
 import { dual } from "effect/Function";
+import * as Order from "effect/Order";
+import * as SchemaGetter$1 from "effect/SchemaGetter";
 import * as Arr from "effect/Array";
-import * as SGetter from "effect/SchemaGetter";
 import * as Context from "effect/Context";
 import { Effect, SchemaGetter, SchemaIssue, SchemaTransformation } from "effect";
-import "effect/Exit";
 import * as Rpc from "effect/unstable/rpc/Rpc";
 import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
 import * as RpcMiddleware from "effect/unstable/rpc/RpcMiddleware";
-//#region ../stryker-js-plugin-interface/dist/rolldown-runtime-D7D4PA-g.mjs
+//#region ../stryker-js-instrumenter/dist/rolldown-runtime-D7D4PA-g.mjs
 var __defProp$1 = Object.defineProperty;
 var __exportAll$1 = (all, no_symbols) => {
 	let target = {};
@@ -27,18 +27,6 @@ var __exportAll$1 = (all, no_symbols) => {
 	return target;
 };
 //#endregion
-//#region ../stryker-js-instrumenter/dist/rolldown-runtime-D7D4PA-g.mjs
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-//#endregion
 //#region ../../node_modules/.pnpm/@eslint-community+regexpp@4.12.2/node_modules/@eslint-community/regexpp/index.mjs
 const latestEcmaVersion = 2025;
 let largeIdStartRanges = void 0;
@@ -2445,14 +2433,12 @@ function visitRegExpAST(node, handlers) {
 }
 //#endregion
 //#region ../stryker-js-instrumenter/dist/index.mjs
-var ErrorText = class ErrorText extends S.Class("ErrorText")({ text: S.NonEmptyString }) {
-	static fromCause = (cause) => Option$1.flatMap(nonEmptyText(errorTextOf$2(cause)), (text) => ErrorText.makeOption({ text }));
-};
-var CauseText = class CauseText extends S.Class("CauseText")({ text: S.NonEmptyString }) {
-	static fromCause = (cause) => Option$1.flatMap(nonEmptyText(causeChainTextOf(cause)), (text) => CauseText.makeOption({ text }));
-};
+var ErrorText = class extends S.Class("ErrorText")({ text: S.NonEmptyString }) {};
+var CauseText = class extends S.Class("CauseText")({ text: S.NonEmptyString }) {};
 const nonEmptyText = Option$1.liftPredicate(S.is(S.NonEmptyString));
-function errorTextOf$2(error) {
+const errorTextOf$2 = (cause) => Option$1.flatMap(nonEmptyText(errorTextValueOf(cause)), (text) => ErrorText.makeOption({ text }));
+const causeTextOf = (cause) => Option$1.flatMap(nonEmptyText(causeChainTextOf(cause)), (text) => CauseText.makeOption({ text }));
+function errorTextValueOf(error) {
 	return Match.value(error).pipe(Match.when(isEmptyError, () => ""), Match.when(Match.instanceOf(Error), errorText), Match.orElse(() => stringifyNonError(error)));
 }
 function causeChainTextOf(cause) {
@@ -2520,102 +2506,99 @@ function causeText(cause, depth) {
 function missingCauseTextOf(cause, depth) {
 	return Boolean$1$1.match(isMissingCause(cause), {
 		onTrue: () => void 0,
-		onFalse: () => causeTextOfValue(cause, depth)
+		onFalse: () => causeNodeTextOf(cause, depth)
 	});
 }
-function causeTextOfValue(cause, depth) {
+function causeNodeTextOf(cause, depth) {
 	return Match.value(cause).pipe(Match.when(Match.string, (text) => textIfNonEmpty(text)), Match.orElse((value) => objectCauseTextOf(value, depth)));
 }
 function objectCauseTextOf(cause, depth) {
 	return Option$1.getOrUndefined(Option$1.map(Option$1.filter(Option$1.some(cause), Predicate$1.isObjectOrArray), (object) => textWithNested(ownCauseText(object), causeText(fieldOf(object, "cause"), depth + 1))));
 }
-var ErrorText_exports = /* @__PURE__ */ __exportAll({
+var ErrorText_exports = /* @__PURE__ */ __exportAll$1({
 	CauseText: () => CauseText,
-	ErrorText: () => ErrorText
+	ErrorText: () => ErrorText,
+	causeTextOf: () => causeTextOf,
+	errorTextOf: () => errorTextOf$2
+});
+const Offset = S.Int.check(S.isGreaterThanOrEqualTo(0));
+/** A 1-based line: the first line of a file is line 1. */
+const Line = S.Int.check(S.isGreaterThanOrEqualTo(1));
+/** A 1-based column: the first character of a line is column 1. */
+const Column = S.Int.check(S.isGreaterThanOrEqualTo(1));
+const Position = S.Struct({
+	line: Line,
+	column: Column
+});
+const positionOrder = Order.combine(Order.mapInput(Order.Number, (position) => position.line), Order.mapInput(Order.Number, (position) => position.column));
+const inOrder = (order) => (ends) => ({
+	start: Order.min(order)(ends.start, ends.end),
+	end: Order.max(order)(ends.start, ends.end)
+});
+const notReversed = (order) => (ends) => Order.isLessThanOrEqualTo(order)(ends.start, ends.end);
+const PositionEnds = S.Struct({
+	start: Position,
+	end: Position
+});
+const Location = S.declare((value) => S.is(PositionEnds)(value) && notReversed(positionOrder)(value), {
+	expected: "a location whose end is not before its start",
+	toCodecArbitrary: () => S.link()(PositionEnds, {
+		decode: SchemaGetter$1.transform(inOrder(positionOrder)),
+		encode: SchemaGetter$1.transform((ends) => ends)
+	})
 });
-/**
-* File coordinates in the mutation-testing-report-schema contract: both line
-* and column are 1-based. The first line of a file is line 1, and the first
-* character of a line is column 1. Slicing a source line by one of these
-* positions uses `line - 1` for the line index and `column - 1` for the
-* character offset.
-*/
-const PositionSchema = S.Struct({
-	line: S.Int.pipe(S.check(S.isGreaterThanOrEqualTo(0))),
-	column: S.Int.pipe(S.check(S.isGreaterThanOrEqualTo(0)))
+const OpenEnds = S.Struct({
+	start: Position,
+	end: S.optional(Position)
 });
-const LocationSchema$1 = S.Struct({
-	start: PositionSchema,
-	end: PositionSchema
+const closedEnds = (ends) => Option$1.map(Option$1.fromUndefinedOr(ends.end), (end) => ({
+	start: ends.start,
+	end
+}));
+const OpenEndLocation = S.declare((value) => S.is(OpenEnds)(value) && Option$1.match(closedEnds(value), {
+	onNone: () => true,
+	onSome: notReversed(positionOrder)
+}), {
+	expected: "a location whose end, when present, is not before its start",
+	toCodecArbitrary: () => S.link()(OpenEnds, {
+		decode: SchemaGetter$1.transform((ends) => Option$1.getOrElse(Option$1.map(closedEnds(ends), inOrder(positionOrder)), () => ends)),
+		encode: SchemaGetter$1.transform((ends) => ends)
+	})
 });
-const OpenEndLocationSchema = S.Struct({
-	start: PositionSchema,
-	end: S.optional(PositionSchema)
+const OffsetEnds = S.Struct({
+	start: Offset,
+	end: Offset
+});
+const Span = S.declare((value) => S.is(OffsetEnds)(value) && notReversed(Order.Number)(value), {
+	expected: "a span whose end is not before its start",
+	toCodecArbitrary: () => S.link()(OffsetEnds, {
+		decode: SchemaGetter$1.transform(inOrder(Order.Number)),
+		encode: SchemaGetter$1.transform((ends) => ends)
+	})
+});
+const ScriptOrigin = S.Struct({
+	line: Line,
+	columnShift: Offset
+});
+S.is(Offset), S.is(Line), S.is(Column), S.is(Location), S.is(Span);
+const MutatorNameSchema = S.String.pipe(S.check(S.isPattern(/^[a-zA-Z]+(?: [a-zA-Z]+)*$/)));
+const DirectiveReasonSchema = S.String.pipe(S.check(S.isPattern(/^\S(?:[^\r\n\u2028\u2029]*\S)?$/)));
+const DirectiveSchema = S.Struct({
+	action: S.Literals(["disable", "restore"]),
+	scope: S.Literals(["next-line", "block"]),
+	mutatorNames: S.Array(MutatorNameSchema).check(S.isMinLength(1)),
+	reason: DirectiveReasonSchema
+});
+const LocatedDirectiveSchema = S.Struct({
+	directive: DirectiveSchema,
+	at: Position,
+	governedLine: Line
+});
+S.Struct({
+	directive: DirectiveSchema,
+	at: Position,
+	mutatorName: MutatorNameSchema
 });
-/**
-* A mutant's `location` already speaks the report contract (1-based line and
-* column), so the report's location is that location unchanged.
-*/
-const ReportLocationFromMutant = LocationSchema$1;
-const NonNegativeInt$1 = S.Int.pipe(S.check(S.isGreaterThanOrEqualTo(0)));
-var LineTable = class extends S.Class("LineTable")({ lineStarts: S.NonEmptyArray(NonNegativeInt$1) }) {
-	positionAt(offset) {
-		return positionOf(this.lineStarts, offset);
-	}
-	locationAt(span) {
-		return {
-			start: this.positionAt(span.start),
-			end: this.positionAt(span.end)
-		};
-	}
-	zeroBasedPositionAt(offset) {
-		return zeroBasedPositionOf(this.lineStarts, offset);
-	}
-};
-const LINE_TERMINATOR = /\r\n|[\n\r\u2028\u2029]/g;
-const lineStartsOf = (text) => ({ lineStarts: [0, ...[...text.matchAll(LINE_TERMINATOR)].map((match) => endOfMatch(match))] });
-const endOfMatch = (match) => (match.index ?? 0) + match[0].length;
-const canonicalTextOf = (table) => Boolean$1$1.match(table.lineStarts.length === 1, {
-	onTrue: () => "",
-	onFalse: () => `${Arr.zip(table.lineStarts.slice(0, -1), table.lineStarts.slice(1)).map(([start, next]) => " ".repeat(next - start - 1)).join("\n")}\n`
-});
-const LineTableFromText = S.String.pipe(S.decodeTo(LineTable, {
-	decode: SGetter.transform(lineStartsOf),
-	encode: SGetter.transform(canonicalTextOf)
-}));
-const middleIndex = (low, high) => low + (high - low >> 1);
-const zeroBasedPositionOf = (lineStarts, offset) => {
-	const search = (low, high, start) => Boolean$1$1.match(low > high, {
-		onTrue: () => ({
-			line: low - 1,
-			column: offset - start
-		}),
-		onFalse: () => Option$1.match(Arr.get(lineStarts, middleIndex(low, high)), {
-			onNone: () => ({
-				line: low - 1,
-				column: offset - start
-			}),
-			onSome: (found) => Boolean$1$1.match(found === offset, {
-				onTrue: () => ({
-					line: middleIndex(low, high),
-					column: offset - found
-				}),
-				onFalse: () => Boolean$1$1.match(found < offset, {
-					onTrue: () => search(middleIndex(low, high) + 1, high, found),
-					onFalse: () => search(low, middleIndex(low, high) - 1, start)
-				})
-			})
-		})
-	});
-	return search(0, lineStarts.length - 1, 0);
-};
-const positionOf = (lineStarts, offset) => {
-	const zeroBased = zeroBasedPositionOf(lineStarts, offset);
-	return {
-		line: zeroBased.line + 1,
-		column: zeroBased.column + 1
-	};
-};
 const MutantStatusSchema = S.Literals([
 	"Killed",
 	"Survived",
@@ -2626,11 +2609,30 @@ const MutantStatusSchema = S.Literals([
 	"Ignored",
 	"Pending"
 ]);
-const MutantId = S.NonEmptyString.pipe(S.brand("MutantId"));
+const SurvivorStatusSchema = S.Literals(["Survived", "NoCoverage"]);
+const RememberedStatusSchema = S.Literals([
+	"Survived",
+	"Killed",
+	"Timeout",
+	"NoCoverage",
+	"Ignored"
+]);
+const EphemeralStatusSchema = S.Literals([
+	"CompileError",
+	"RuntimeError",
+	"Pending"
+]);
+const ActionableStatusSchema = S.Literals([
+	"Survived",
+	"NoCoverage",
+	"Timeout",
+	"RuntimeError"
+]);
+const MutantId = S.String.check(S.isPattern(/^(0|[1-9][0-9]*)$/)).pipe(S.brand("MutantId"));
 const MutatorName = S.NonEmptyString.pipe(S.brand("MutatorName"));
 const CanonicalFileName = S.String.pipe(S.decodeTo(S.String.pipe(S.check(S.isPattern(/^[^\\]+$/)), S.brand("CanonicalFileName")), {
-	decode: SGetter.transform((fileName) => fileName.replace(/\\/g, "/")),
-	encode: SGetter.transform((canonical) => canonical)
+	decode: SchemaGetter$1.transform((fileName) => fileName.replace(/\\/g, "/")),
+	encode: SchemaGetter$1.transform((canonical) => canonical)
 }));
 /**
 * A mutant's file location in the mutation-testing-report-schema contract:
@@ -2638,19 +2640,19 @@ const CanonicalFileName = S.String.pipe(S.decodeTo(S.String.pipe(S.check(S.isPat
 * machine stream emit. Every producer on the instrument path (node spans,
 * embedded-region shifts) targets this base; no downstream layer converts.
 */
-var Mutant = class extends S.TaggedClass()("Mutant", {
+const Mutant = S.TaggedStruct("Mutant", {
 	id: MutantId,
 	fileName: CanonicalFileName,
 	mutatorName: MutatorName,
 	replacement: S.String,
-	location: LocationSchema$1,
+	location: Location,
 	status: S.optional(MutantStatusSchema),
 	statusReason: S.optional(S.String),
 	coveredBy: S.String.pipe(S.Array, S.optional),
 	static: S.optional(S.Boolean),
 	testsCompleted: S.optional(S.Finite),
 	description: S.optional(S.String)
-}) {};
+}).check(S.makeFilter((mutant) => mutant.statusReason === void 0 || mutant.status !== void 0, { message: "a mutant carries a status reason only together with a status" }));
 const MutantFromUnknown = S.Unknown.pipe(S.decodeTo(Mutant));
 const RunOptionsFields = {
 	timeout: S.Finite.pipe(S.check(S.isGreaterThanOrEqualTo(0))),
@@ -2668,15 +2670,15 @@ const MutantRunOptionsSchema = S.Struct({
 	hitLimit: S.optionalKey(HitCount)
 });
 const MutantCoverageSchema$1 = S.Struct({
-	perTest: S.Record(S.String, S.Record(S.String, HitCount)),
-	static: S.Record(S.String, HitCount)
+	perTest: S.Record(S.String, S.Record(MutantId, HitCount)),
+	static: S.Record(MutantId, HitCount)
 });
 var InstrumenterContext = class extends S.Class("InstrumenterContext")({
 	activeMutant: S.optional(S.String),
 	currentTestId: S.optional(S.String),
 	mutantCoverage: S.optional(MutantCoverageSchema$1),
-	hitCount: S.optional(S.Finite),
-	hitLimit: S.optional(S.Finite)
+	hitCount: S.optional(HitCount),
+	hitLimit: S.optional(HitCount)
 }) {
 	static NAMESPACE = "__stryker__";
 	static MUTATION_COVERAGE_OBJECT = "mutantCoverage";
@@ -2697,21 +2699,15 @@ var InstrumentError = class extends S.TaggedError("@systemfsoftware/stryker-js-i
 		});
 	}
 };
-const MutateDescriptionSchema = S.Union([S.Boolean, S.Array(LocationSchema$1)]);
-const SourceLineSchema = S.Int.pipe(S.check(S.isGreaterThanOrEqualTo(1)));
-const SourceColumnSchema = S.Int.pipe(S.check(S.isGreaterThanOrEqualTo(0)));
-const NodePositionSchema = S.Struct({
-	line: S.Int,
-	column: S.Int
-});
+const MutateDescriptionSchema = S.Union([S.Boolean, S.Array(Location)]);
 const FileSchema = S.Struct({
-	name: S.String,
+	name: CanonicalFileName,
 	content: S.String,
 	mutate: MutateDescriptionSchema
 });
 const IgnorerSchema = S.Unknown;
 S.Struct({
-	excludedMutations: S.Array(S.String),
+	excludedMutations: S.Array(MutatorNameSchema),
 	ignorers: S.Array(IgnorerSchema),
 	noHeader: S.optional(S.Boolean),
 	optInMutations: S.String.pipe(S.Array, S.optional)
@@ -2741,16 +2737,66 @@ const PlacerNameSchema = S.Literals([
 var MutantsUnapplied = class extends S.TaggedError()("MutantsUnapplied", {
 	fileName: S.String,
 	placer: PlacerNameSchema,
-	mutatorNames: S.Array(S.String),
+	mutatorNames: S.Array(MutatorNameSchema),
 	cause: S.Defect()
 }) {};
 var MutantNotApplied = class extends S.TaggedError()("MutantNotApplied", {
 	fileName: S.String,
-	mutatorName: S.String
+	mutatorName: MutatorNameSchema
+}) {};
+var NodeWithoutSpan = class extends S.TaggedError()("NodeWithoutSpan", { fileName: S.String }) {};
+var MutantsUnplaced = class extends S.TaggedError()("MutantsUnplaced", {
+	fileName: S.String,
+	detail: S.String
 }) {};
+var PlacementRefused = class extends S.TaggedError()("PlacementRefused", { message: S.String }) {};
+const LINE_TERMINATOR = /\r\n|[\n\r\u2028\u2029]/g;
+const lineStartsOf = (text) => [0, ...[...text.matchAll(LINE_TERMINATOR)].map((match) => match.index + match[0].length)];
+const middleIndex = (low, high) => low + (high - low >> 1);
+const positionAtOffset = (lineStarts, offset, low, high, start) => Boolean$1$1.match(low > high, {
+	onTrue: () => ({
+		line: low,
+		column: offset - start + 1
+	}),
+	onFalse: () => Option$1.match(Arr.get(lineStarts, middleIndex(low, high)), {
+		onNone: () => ({
+			line: low,
+			column: offset - start + 1
+		}),
+		onSome: (found) => Boolean$1$1.match(found === offset, {
+			onTrue: () => ({
+				line: middleIndex(low, high) + 1,
+				column: 1
+			}),
+			onFalse: () => Boolean$1$1.match(found < offset, {
+				onTrue: () => positionAtOffset(lineStarts, offset, middleIndex(low, high) + 1, high, found),
+				onFalse: () => positionAtOffset(lineStarts, offset, low, middleIndex(low, high) - 1, start)
+			})
+		})
+	})
+});
+const positionAt = dual(2, (lineStarts, offset) => positionAtOffset(lineStarts, offset, 0, lineStarts.length - 1, 0));
+const locationOf = dual(2, (lineStarts, span) => Location.make({
+	start: positionAt(lineStarts, span.start),
+	end: positionAt(lineStarts, span.end)
+}));
+const originAt = dual(2, (lineStarts, offset) => {
+	const position = positionAt(lineStarts, offset);
+	return ScriptOrigin.make({
+		line: position.line,
+		columnShift: position.column - 1
+	});
+});
+dual(2, (lineStarts, position) => Option$1.flatMap(Arr.get(lineStarts, position.line - 1), (start) => {
+	const offset = start + position.column - 1;
+	return Option$1.match(Arr.get(lineStarts, position.line), {
+		onNone: () => Option$1.some(offset),
+		onSome: (next) => Option$1.liftPredicate(offset, (candidate) => candidate < next)
+	});
+}));
 const formatKeyOf = (ast) => ast.format === "embedded" ? ast.formatId : ast.format;
-const TypeId$1 = Symbol.for("~systemfsoftware/stryker-js-instrumenter/Ast");
-const AstHandleDef = Handle.make()(TypeId$1);
+const TypeId = Symbol.for("~systemfsoftware/stryker-js-instrumenter/Ast");
+const AstHandleDef = Handle.make()(TypeId);
 AstHandleDef.is;
 const make = (root) => AstHandleDef.make({ root });
 const EXPRESSION_KINDS = {
@@ -2983,14 +3029,14 @@ const switchCase = dual((args) => isDataFirstArity(args, 2), (test, consequent,
 	consequent: [...consequent]
 }, loc));
 const cloneNode = (node) => structuredClone(node);
-const attachComments = dual((args) => args.length >= 3, (self, comments, lineTable) => Boolean$1$1.match(comments.length === 0, {
+const attachComments = dual((args) => args.length >= 3, (self, comments, lineStarts) => Boolean$1$1.match(comments.length === 0, {
 	onTrue: () => void 0,
 	onFalse: () => {
 		const nodes = collectNodes(self.root).filter((entry) => entry.node !== self.root);
 		nodes.sort((a, b) => a.start - b.start);
 		const groups = groupComments(nodes, comments);
-		assignComments(groups.leading, lineTable, "leadingComments");
-		assignComments(groups.trailing, lineTable, "trailingComments");
+		assignComments(groups.leading, lineStarts, "leadingComments");
+		assignComments(groups.trailing, lineStarts, "trailingComments");
 	}
 }));
 const groupComments = (nodes, comments) => {
@@ -3016,12 +3062,12 @@ const commentHost = (nodes, comment) => {
 };
 const followingNode = (nodes, comment) => Option$1.getOrUndefined(Option$1.map(Option$1.fromNullishOr(nodes.find((candidate) => candidate.start >= comment.end)), (entry) => entry.node));
 const precedingStatement = (nodes, comment) => Option$1.getOrUndefined(Option$1.map(Option$1.fromNullishOr(nodes.findLast((candidate) => candidate.end <= comment.start && isStatementKind(candidate.node))), (entry) => entry.node));
-const assignComments = (map, lineTable, field) => map.forEach((list, node) => Object.assign(node, { [field]: list.map((comment) => ({
+const assignComments = (map, lineStarts, field) => map.forEach((list, node) => Object.assign(node, { [field]: list.map((comment) => ({
 	...comment,
-	loc: {
-		start: lineTable.positionAt(comment.start),
-		end: lineTable.positionAt(comment.end)
-	}
+	loc: locationOf(lineStarts, {
+		start: comment.start,
+		end: comment.end
+	})
 })) }));
 const pushComment = (map, node, comment) => {
 	Option$1.match(Option$1.fromNullishOr(map.get(node)), {
@@ -3038,72 +3084,41 @@ const WALK_SKIPPED_KEYS = {
 	start: true,
 	end: true
 };
-const walkNodes = (root, visitors) => visitIfNode(root, {
-	key: null,
-	index: null
-}, visitors);
-const visitNode = (node, context, visitors) => {
-	const state = { skipped: false };
-	visitors.enter(node, context, { skip: () => {
-		state.skipped = true;
-	} });
-	Boolean$1$1.match(state.skipped, {
-		onTrue: () => void 0,
-		onFalse: () => visitChildren(node, visitors)
-	});
-	visitors.leave(node, context);
-};
-const visitChildren = (node, visitors) => Object.keys(node).forEach((key) => Boolean$1$1.match(WALK_SKIPPED_KEYS[key] === true, {
-	onTrue: () => void 0,
-	onFalse: () => visitSlot(node[key], key, visitors)
-}));
 const isChildList = (value) => Array.isArray(value);
-const visitSlot = (value, key, visitors) => Option$1.match(Option$1.filter(Option$1.some(value), isChildList), {
-	onSome: (items) => items.forEach((item, index) => visitIfNode(item, {
-		key,
-		index
-	}, visitors)),
-	onNone: () => visitIfNode(value, {
+const childSlotsOf = (node) => Object.keys(node).flatMap((key) => WALK_SKIPPED_KEYS[key] === true ? [] : childSlotsAt(key, node[key]));
+const childSlotsAt = (key, value) => isChildList(value) ? listSlotsAt(key, value) : singleSlotAt(key, value);
+const listSlotsAt = (key, value) => value.flatMap((item, index) => isAstNode(item) ? [{
+	key,
+	index,
+	node: item
+}] : []);
+const singleSlotAt = (key, value) => Option$1.match(Option$1.filter(Option$1.some(value), isAstNode), {
+	onNone: () => [],
+	onSome: (node) => [{
 		key,
-		index: null
-	}, visitors)
+		index: null,
+		node
+	}]
+});
+const asWalkedNode = (value) => Option$1.filter(Option$1.some(value), isAstNode);
+const childNodes = (node) => Option$1.match(asWalkedNode(node), {
+	onNone: () => [],
+	onSome: (walked) => childSlotsOf(walked).filter((slot) => !isCommentKey(slot.key)).map((slot) => ({
+		key: slot.key,
+		index: slot.index,
+		node: slot.node
+	}))
 });
-const visitIfNode = (value, context, visitors) => Option$1.match(Option$1.filter(Option$1.some(value), isAstNode), {
-	onNone: () => void 0,
-	onSome: (child) => visitNode(child, context, visitors)
-});
-const walker = (root, visitors) => {
-	const ancestors = [];
-	walkNodes(root, {
-		enter(node) {
-			visitors.enter?.(node, [...ancestors]);
-			ancestors.push(node);
-		},
-		leave(node) {
-			ancestors.pop();
-			visitors.leave?.(node, [...ancestors]);
-		}
-	});
-};
-const collectNodes = (root) => {
-	const out = [];
-	walker(root, { enter(node) {
-		appendEntry(node, out);
-	} });
-	return out;
-};
-const appendEntry = (node, out) => {
-	Option$1.match(Option$1.fromNullishOr(spanOf(node)), {
-		onNone: () => void 0,
-		onSome: (span) => {
-			out.push({
-				node,
-				start: span.start,
-				end: span.end
-			});
-		}
-	});
-};
+const collectNodes = (root) => Option$1.toArray(nodeEntryOf(root)).concat(childEntriesOf(root));
+const childEntriesOf = (root) => Option$1.match(asWalkedNode(root), {
+	onNone: () => [],
+	onSome: (node) => childSlotsOf(node).flatMap((slot) => collectNodes(slot.node))
+});
+const nodeEntryOf = (node) => Option$1.map(Option$1.fromNullishOr(spanOf(node)), (span) => ({
+	node,
+	start: span.start,
+	end: span.end
+}));
 function isAstNode(value) {
 	return Predicate$1.isObject(value) && typeof value["type"] === "string";
 }
@@ -3112,32 +3127,41 @@ const COMMENT_KEYS = {
 	trailingComments: true
 };
 const isCommentKey = (key) => typeof key === "string" && COMMENT_KEYS[key] === true;
-const walkTraverse = (root, stack, visitors) => {
-	walkNodes(root, {
-		enter(node, context, controls) {
-			readPath(stack, node, controls, context, visitors);
-		},
-		leave(_node, context) {
-			closePath(stack, context, visitors);
+const walkTraverse = (root, visitors) => Option$1.match(asWalkedNode(root), {
+	onNone: () => void 0,
+	onSome: (node) => traverseNode(node, null, {
+		key: null,
+		index: null
+	}, visitors)
+});
+const skipControls = () => {
+	let skipped = false;
+	return {
+		skipped: () => skipped,
+		skip: () => {
+			skipped = true;
 		}
-	});
+	};
 };
-const traverse = dual(2, (self, visitors) => walkTraverse(self.root, [], visitors));
-const readPath = (stack, node, controls, context, visitors) => {
+const traverseNode = (node, parentPath, context, visitors) => {
 	Boolean$1$1.match(isCommentKey(context.key), {
 		onTrue: () => void 0,
 		onFalse: () => {
-			const current = createPath(node, parentOf(stack), controls, context);
-			stack.push(current);
-			notify(visitors.enter, current);
+			const controls = skipControls();
+			const path = createPath(node, parentPath, controls, context);
+			notify(visitors.enter, path);
+			Boolean$1$1.match(controls.skipped(), {
+				onTrue: () => void 0,
+				onFalse: () => childSlotsOf(node).forEach((slot) => traverseNode(slot.node, path, {
+					key: slot.key,
+					index: slot.index
+				}, visitors))
+			});
+			notify(visitors.exit, path);
 		}
 	});
 };
-const closePath = (stack, context, visitors) => Boolean$1$1.match(isCommentKey(context.key), {
-	onTrue: () => void 0,
-	onFalse: () => notify(visitors.exit, stack.pop())
-});
-const parentOf = (stack) => Option$1.getOrNull(Arr.last(stack));
+const traverse = dual(2, (self, visitors) => walkTraverse(self.root, visitors));
 const notify = (visitor, path) => Option$1.match(Option$1.all({
 	visitor: Option$1.fromNullishOr(visitor),
 	path: Option$1.fromNullishOr(path)
@@ -3298,13 +3322,6 @@ const EMPTY_IMPORT_TABLE = Object.freeze({
 	bareFunctions: /* @__PURE__ */ new Map(),
 	pipeBindings: /* @__PURE__ */ new Set()
 });
-const importTables = /* @__PURE__ */ new WeakMap();
-const importTableFor = (program) => Option$1.getOrElse(Option$1.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]);
@@ -3356,7 +3373,7 @@ const namespaceBindingFor = (source) => Match.value(source).pipe(Match.when((can
 }))));
 const moduleNameFromName = (name) => Arr.findFirst(MODULE_NAMES, (module) => module === name);
 const moduleNameFromSource = (source) => Arr.findFirst(MODULE_NAMES, (module) => source === `${EFFECT_SOURCE}/${module}`);
-const resolveEffectCallDataFirst = (node, context) => Option$1.flatMap(programOf(context), (program) => resolveIn(node, context, importTableFor(program)));
+const resolveEffectCallDataFirst = (node, context) => Option$1.flatMap(programOf(context), (program) => resolveIn(node, context, buildImportTable(program)));
 const resolveEffectCall = dual((args) => args.length >= 2, resolveEffectCallDataFirst);
 const programOf = (context) => Arr.findLast(context.ancestors, isProgram);
 const resolveIn = (node, context, table) => Match.value(node).pipe(Match.when(isCallExpression$1, (call) => resolveCall(call, context, table)), Match.when(isMemberExpression, (member) => resolveReference(member, context, table)), Match.when(isIdentifier$1, (reference) => resolveReference(reference, context, table)), Match.orElse(() => Option$1.none()));
@@ -3754,9 +3771,10 @@ function eqNode(a, b) {
 	return identity !== void 0 && identity === nodeIdentity(b);
 }
 function nodeIdentity(node) {
-	const span = spanOf(node);
-	if (span === void 0) return;
-	return `${node.type}:${span.start}:${span.end}`;
+	return Option$1.match(Option$1.fromNullishOr(spanOf(node)), {
+		onNone: () => void 0,
+		onSome: (span) => `${node.type}:${span.start}:${span.end}`
+	});
 }
 function orDefault(value, fallback) {
 	return value ?? fallback;
@@ -3804,14 +3822,15 @@ function cloneWithReplacement(mutant, originalTree) {
 function hasReplaced(root, original, replacement) {
 	let applied = false;
 	traverse(make(root), { enter(path) {
-		if (!applied) applied = replaceFirstMatch(path, original, replacement);
+		applied = applied || replaceFirstMatch(path, original, replacement);
 	} });
 	return applied;
 }
 function replaceFirstMatch(path, original, replacement) {
-	if (eqNode(path.node, original) === false) return false;
-	path.replaceWith(replacement);
-	return true;
+	return Match.value(eqNode(path.node, original)).pipe(Match.when(false, () => false), Match.orElse(() => {
+		path.replaceWith(replacement);
+		return true;
+	}));
 }
 /**
 * The mutations of a regular expression pattern.
@@ -3840,17 +3859,16 @@ function replaceFirstMatch(path, original, replacement) {
 * quantifier removal ahead of class negation.
 */
 function mutateRegexPattern(pattern, flags) {
-	if (pattern.length === 0) return [];
-	return parseRegexMutants(pattern, orDefault(flags, ""));
+	return pattern.length === 0 ? [] : parseRegexMutants(pattern, orDefault(flags, ""));
 }
 function parseRegexMutants(pattern, flags) {
 	try {
 		const groups = collectSplices(pattern, flags);
-		groups.rest.sort((a, b) => a.start - b.start || a.priority - b.priority);
+		const rest = groups.rest.toSorted((a, b) => a.start - b.start || a.priority - b.priority);
 		return [
 			...groups.bol,
 			...groups.eol,
-			...groups.rest
+			...rest
 		].map((splice) => spliceText(pattern, splice));
 	} catch {
 		return [];
@@ -3912,18 +3930,17 @@ function negationMarker(negate) {
 }
 function collectCharacterClass(characterClass, groups) {
 	const pos = characterClass.start + 1;
-	if (characterClass.negate) groups.rest.push({
+	groups.rest.push(Match.value(characterClass.negate).pipe(Match.when(true, () => ({
 		start: pos,
 		end: pos + 1,
 		text: "",
 		priority: 1
-	});
-	else groups.rest.push({
+	})), Match.orElse(() => ({
 		start: pos,
 		end: pos,
 		text: "^",
 		priority: 1
-	});
+	}))));
 }
 function collectCharacterSet(characterSet, groups) {
 	pushWhen(groups.rest, characterSetSplice(characterSet));
@@ -3953,12 +3970,10 @@ function classSplice(characterSet) {
 /** `\d`-style sets invert by letter case, `\p{}` by `p`/`P`. */
 function invertedMarker(marker) {
 	const propertyMarker = PROPERTY_MARKERS[marker];
-	if (propertyMarker !== void 0) return propertyMarker;
-	return invertLetterCase(marker);
+	return propertyMarker === void 0 ? invertLetterCase(marker) : propertyMarker;
 }
 function invertLetterCase(letter) {
-	if (letter === letter.toUpperCase()) return letter.toLowerCase();
-	return letter.toUpperCase();
+	return letter === letter.toUpperCase() ? letter.toLowerCase() : letter.toUpperCase();
 }
 function collectQuantifier(quantifier, groups) {
 	groups.rest.push({
@@ -3974,11 +3989,15 @@ function anchorRemoval(assertion, pattern) {
 		end: assertion.end,
 		text: ""
 	};
-	if (spliceText(pattern, splice).length === 0) return;
-	return splice;
+	return spliceText(pattern, splice).length === 0 ? void 0 : splice;
 }
 function pushWhen(list, splice) {
-	if (splice !== void 0) list.push(splice);
+	Option$1.match(Option$1.fromNullishOr(splice), {
+		onNone: () => void 0,
+		onSome: (present) => {
+			list.push(present);
+		}
+	});
 }
 function spliceText(pattern, splice) {
 	return pattern.slice(0, splice.start) + splice.text + pattern.slice(splice.end);
@@ -4032,16 +4051,14 @@ function isStringConcatenation(node) {
 }
 /** A chained `a + b + c` carries its value on the innermost left operand's right side. */
 function outerLeftOperand(node) {
-	if (node.left.type === "BinaryExpression") return node.left.right;
-	return node.left;
+	return node.left.type === "BinaryExpression" ? node.left.right : node.left;
 }
 const arrayDeclarationMutator = (node) => Match.value(node).pipe(Match.when(isArrayExpression, (array) => [arrayDeclarationReplacement(array)]), Match.when(isArrayConstructorCall, (construct) => [arrayConstructorReplacement(construct)]), Match.orElse(() => NO_MUTANTS));
 function isArrayExpression(node) {
 	return node.type === "ArrayExpression";
 }
 function arrayDeclarationReplacement(array) {
-	if (array.elements.length > 0) return arrayExpression([]);
-	return arrayExpression([stringLiteral("Stryker was here")]);
+	return array.elements.length > 0 ? arrayExpression([]) : arrayExpression([stringLiteral("Stryker was here")]);
 }
 function isArrayConstructorCall(node) {
 	return isCallOrNewExpression(node) && isArrayIdentifier(node.callee);
@@ -4054,12 +4071,11 @@ function isArrayIdentifier(node) {
 }
 function arrayConstructorReplacement(construct) {
 	const mutatedCallArgs = constructorArguments(construct.arguments);
-	if (construct.type === "NewExpression") return newExpression(cloneNode(construct.callee), mutatedCallArgs);
-	return callExpression(cloneNode(construct.callee), mutatedCallArgs);
+	const callee = cloneNode(construct.callee);
+	return construct.type === "NewExpression" ? newExpression(callee, mutatedCallArgs) : callExpression(callee, mutatedCallArgs);
 }
 function constructorArguments(args) {
-	if (args.length > 0) return [];
-	return [arrayExpression([])];
+	return args.length > 0 ? [] : [arrayExpression([])];
 }
 const arrowFunctionMutator = (node) => Match.value(node).pipe(Match.when(isExpressionBodiedArrow, () => [arrowFunctionExpression([], identifier("undefined"))]), Match.orElse(() => NO_MUTANTS));
 function isExpressionBodiedArrow(node) {
@@ -4095,8 +4111,7 @@ function isStringLiteral(value) {
 	return nodeType(value) === "Literal" && hasStringValue(value);
 }
 function hasStringValue(value) {
-	if (!Predicate$1.hasProperty(value, "value")) return false;
-	return typeof value["value"] === "string";
+	return Predicate$1.hasProperty(value, "value") && typeof value["value"] === "string";
 }
 const stringAssignmentTypes = Object.freeze([
 	"&&=",
@@ -4179,8 +4194,7 @@ function hasSuperInChildren(node) {
 	return Object.keys(node).some((key) => containsSuperInValue(propertyOf(node, key)));
 }
 function containsSuperInValue(value) {
-	if (Array.isArray(value)) return value.some(containsSuperCall);
-	return containsSuperCall(value);
+	return Array.isArray(value) ? value.some(containsSuperCall) : containsSuperCall(value);
 }
 const booleanLiteralMutator = (node) => Match.value(node).pipe(Match.when(isBooleanLiteral, (literal) => [booleanLiteral(!literal.value)]), Match.when(isNegatedPrefix, (unary) => [cloneNode(unary.argument)]), Match.orElse(() => NO_MUTANTS));
 function isBooleanLiteral(node) {
@@ -4331,8 +4345,12 @@ const baseReplacements = {
 	setUTCSeconds: "setUTCMilliseconds"
 };
 const noReverseReplacements = ["getUTCDate", "setUTCDate"];
-const replacements = new Map(Object.entries(baseReplacements));
-for (const [key, value] of Object.entries(baseReplacements)) if (value !== null && !noReverseReplacements.includes(key)) replacements.set(value, key);
+const isReversible = (key, value) => value !== null && !noReverseReplacements.includes(key);
+const reverseReplacements = Object.fromEntries(Object.entries(baseReplacements).flatMap(([key, value]) => isReversible(key, value) ? [[value, key]] : []));
+const replacements = {
+	...baseReplacements,
+	...reverseReplacements
+};
 const methodExpressionMutator = (node) => Match.value(node).pipe(Match.when(isCallExpression, (call) => methodCallMutants(call)), Match.orElse(() => NO_MUTANTS));
 function methodCallMutants(call) {
 	return Match.value(methodMutation(call)).pipe(Match.when(isMethodMutation, (mutation) => [methodExpressionReplacement(mutation)]), Match.orElse(() => NO_MUTANTS));
@@ -4346,7 +4364,9 @@ function methodMutation(call) {
 	return Match.value(callee).pipe(Match.when(void 0, () => void 0), Match.orElse((member) => mutationFor(call, member)));
 }
 function mutationFor(call, callee) {
-	return Match.value(replacements.get(callee.property.name)).pipe(Match.when(void 0, () => void 0), Match.orElse((newName) => ({
+	const methodName = callee.property.name;
+	const replacement = Object.hasOwn(replacements, methodName) ? replacements[methodName] : void 0;
+	return Match.value(replacement).pipe(Match.when(void 0, () => void 0), Match.orElse((newName) => ({
 		call,
 		callee,
 		newName
@@ -4429,16 +4449,17 @@ const PLACEHOLDER = "Stryker was here!";
 const stringLiteralMutator = (node, context) => Match.value(node).pipe(Match.when(isTemplateLiteral, (template) => templateMutants(template)), Match.when(isStringLiteral, (literal) => mutantsWhen(isValidParent(literal, context), () => [stringLiteral(replacementText(literal.value.length === 0))])), Match.orElse(() => NO_MUTANTS));
 function templateMutants(template) {
 	const first = template.quasis[0];
-	if (first === void 0) return NO_MUTANTS;
-	return [emptyOrPlaceholderTemplate(template, first)];
+	return Option$1.match(Option$1.fromNullishOr(first), {
+		onNone: () => NO_MUTANTS,
+		onSome: (present) => [emptyOrPlaceholderTemplate(template, present)]
+	});
 }
 function emptyOrPlaceholderTemplate(template, first) {
 	const isEmptyTemplate = [template.quasis.length === 1, first.value.raw.length === 0].every(Boolean);
 	return templateLiteral([templateElement(replacementText(isEmptyTemplate))], []);
 }
 function replacementText(isEmpty) {
-	if (isEmpty) return PLACEHOLDER;
-	return "";
+	return isEmpty ? PLACEHOLDER : "";
 }
 function isValidParent(child, context) {
 	const parent = context.parent;
@@ -4591,10 +4612,7 @@ const selectMutators = dual((args) => args.length >= 2, selectMutatorsDataFirst)
 var ParseFailed = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/Parser.schema/ParseFailed")("ParseFailed", {
 	fileName: S.String,
 	message: S.String,
-	location: S.Struct({
-		line: S.Finite,
-		column: S.Finite
-	}),
+	location: Position,
 	cause: S.Defect()
 }) {
 	get message() {
@@ -4603,60 +4621,67 @@ var ParseFailed = class extends S.TaggedError("@systemfsoftware/stryker-js-instr
 };
 const oxcModule = Effect$1.cached(Effect$1.promise(() => import("./src-js-CvBdbRpe.mjs")));
 const loadOxc = Effect$1.flatMap(oxcModule, (load) => load);
-const parseWithOxcDataFirst = (text, fileName, lang) => Effect$1.gen(function* () {
+const parseWithOxcDataFirst = Effect$1.fn("stryker.instrument.parser.parseWithOxc")(function* (text, fileName, lang) {
 	const result = (yield* loadOxc).parseSync(fileName, text, {
 		lang,
 		range: true
 	});
-	const lineTable = yield* Effect$1.orDie(S.decodeEffect(LineTableFromText)(text));
-	const failure = oxcParseFailure(result.errors, fileName, lineTable);
-	if (failure !== void 0) return yield* failure;
-	return {
-		root: result.program,
-		comments: result.comments
-	};
+	const lineStarts = lineStartsOf(text);
+	const failure = oxcParseFailure(result.errors, fileName, lineStarts);
+	return yield* Option$1.match(Option$1.fromNullishOr(failure), {
+		onNone: () => Effect$1.succeed({
+			root: result.program,
+			comments: result.comments
+		}),
+		onSome: (failed) => Effect$1.fail(failed)
+	});
 });
 const parseWithOxc = dual((args) => args.length >= 3, parseWithOxcDataFirst);
-const oxcParseFailure = (errors, fileName, lineTable) => {
-	const first = errors.at(0);
-	if (first === void 0) return;
-	return ParseFailed.make({
+const oxcParseFailure = (errors, fileName, lineStarts) => Option$1.match(Option$1.fromNullishOr(errors.at(0)), {
+	onNone: () => void 0,
+	onSome: (first) => ParseFailed.make({
 		fileName,
 		message: first.message,
-		location: lineTable.positionAt(oxcErrorLabelStart(first)),
+		location: positionAt(lineStarts, oxcErrorLabelStart(first)),
 		cause: errors.map((reported) => reported.message)
-	});
-};
-const oxcErrorLabelStart = (error) => {
-	const label = error.labels.at(0);
-	if (label === void 0) return 0;
-	return label.start;
-};
+	})
+});
+const oxcErrorLabelStart = (error) => Option$1.getOrElse(Option$1.map(Option$1.fromNullishOr(error.labels.at(0)), (label) => label.start), () => 0);
 const createParser = () => ({ parse: (code, fileName, scriptFormat) => Match.value(scriptFormat).pipe(Match.when("js", () => parseJS(code, fileName)), Match.when("ts", () => parseTS(code, fileName)), Match.when("tsx", () => parseTsx(code, fileName)), Match.exhaustive) });
-const parseJSDataFirst = (text, fileName) => Effect$1.map(parseWithOxc(text, fileName, "js"), ({ root, comments }) => ({
-	originFileName: fileName,
-	rawContent: text,
-	format: "js",
-	root,
-	comments
-}));
+const parseJSDataFirst = Effect$1.fn("stryker.instrument.parser.parseJS")(function* (text, fileName) {
+	const parsed = yield* parseWithOxc(text, fileName, "js");
+	return {
+		originFileName: fileName,
+		rawContent: text,
+		format: "js",
+		root: parsed.root,
+		comments: parsed.comments
+	};
+});
 const parseJS = dual((args) => args.length >= 2, parseJSDataFirst);
-const parseTSDataFirst = (text, fileName) => Effect$1.map(parseWithOxc(text, fileName, "ts"), ({ root, comments }) => ({
-	originFileName: fileName,
-	rawContent: text,
-	format: "ts",
-	root,
-	comments
-}));
+const parseTSDataFirst = Effect$1.fn("stryker.instrument.parser.parseTS")(function* (text, fileName) {
+	const parsed = yield* parseWithOxc(text, fileName, "ts");
+	return {
+		originFileName: fileName,
+		rawContent: text,
+		format: "ts",
+		root: parsed.root,
+		comments: parsed.comments
+	};
+});
 const parseTS = dual((args) => args.length >= 2, parseTSDataFirst);
-const parseTsxDataFirst = (text, fileName) => Effect$1.map(parseWithOxc(text, fileName, "tsx"), ({ root, comments }) => ({
-	root,
-	comments,
-	format: "tsx",
-	originFileName: fileName,
-	rawContent: text
-}));
+const parseTsxDataFirst = Effect$1.fn("stryker.instrument.parser.parseTsx")(function* (text, fileName) {
+	const parsed = yield* parseWithOxc(text, fileName, "tsx");
+	return {
+		root: parsed.root,
+		comments: parsed.comments,
+		format: "tsx",
+		originFileName: fileName,
+		rawContent: text
+	};
+});
 const parseTsx = dual((args) => args.length >= 2, parseTsxDataFirst);
+var PrintFailed = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/print/PrintFailed.schema/PrintFailed")("PrintFailed", { message: S.String }) {};
 const printProgramDataFirst = (program, opts = {}) => programText(opts, program);
 const printProgram = dual((args) => Predicate$1.hasProperty(args[0], "type"), printProgramDataFirst);
 const printNode = (node) => dispatchNode({ indentLevel: 0 }, node, PREC.Sequence);
@@ -5643,28 +5668,19 @@ const externalModuleArgumentText = (value) => Boolean$1$1.match(Predicate$1.isTr
 function printDataFirst(file, entryForFormat) {
 	const context = { print: (inner) => print(inner, entryForFormat) };
 	return Option$1.match(entryForFormat(formatKeyOf(file)), {
-		onNone: () => missingFormatPrint(file),
-		onSome: (entry) => entry.print(file, context)
+		onNone: () => Result.fail(PrintFailed.make({ message: `No registered format renders the "${formatKeyOf(file)}" AST` })),
+		onSome: (entry) => Result.succeed(entry.print(file, context))
 	});
 }
 const print = dual((args) => args.length >= 2, printDataFirst);
-function missingFormatPrint(file) {
-	throw new Error(`No registered format renders the "${formatKeyOf(file)}" AST`);
-}
-function hashbangOf(root) {
-	if (!hasHashbang(root)) return null;
-	return printHashbang(root.hashbang);
-}
+const hashbangOf = (root) => hasHashbang(root) ? printHashbang(root.hashbang) : null;
 const hasHashbang = (root) => Predicate$1.hasProperty(root, "hashbang") && Predicate$1.isObject(root.hashbang);
 const printHashbang = (field) => ({
 	type: "Hashbang",
 	value: hashbangValue(field),
 	start: field.start
 });
-function hashbangValue(field) {
-	if (typeof field.value !== "string") return "";
-	return field.value;
-}
+const hashbangValue = (field) => typeof field.value === "string" ? field.value : "";
 const printScriptAst$1 = (root) => printProgram(root, { hashbang: hashbangOf(root) });
 const jsPrintDataFirst = (file) => printScriptAst$1(file.root);
 const jsPrint = dual((args) => args.length >= 2, jsPrintDataFirst);
@@ -5745,48 +5761,9 @@ const resolveFormat = Workflow.make({
 	error: FormatOverrideUnclaimed,
 	decide: (command) => Match.value(selectionFor(command)).pipe(Match.tag("ClaimSelected", ({ claim }) => Result.succeed(assignedFrom(claim, command))), Match.tag("PinUnclaimed", ({ formatId }) => Result.fail(overrideUnclaimedFrom(command, formatId))), Match.tag("ExtensionUnclaimed", () => Result.succeed(skippedFrom(command))), Match.exhaustive)
 });
-const MutatorNameSchema = S.String.pipe(S.check(S.isPattern(/^[a-zA-Z]+(?: [a-zA-Z]+)*$/)));
-const DirectiveReasonSchema = S.String.pipe(S.check(S.isPattern(/^\S(?:[\s\S]*\S)?$/)));
-const DirectiveSchema = S.Struct({
-	action: S.Literals(["disable", "restore"]),
-	scope: S.Literals(["next-line", "block"]),
-	mutatorNames: S.Array(MutatorNameSchema).check(S.isMinLength(1)),
-	reason: DirectiveReasonSchema
-});
-const LocatedPositionSchema = S.Struct({
-	line: SourceLineSchema,
-	column: SourceColumnSchema
-});
-const LocatedDirectiveSchema = S.Struct({
-	directive: DirectiveSchema,
-	at: LocatedPositionSchema,
-	governedLine: SourceLineSchema
-});
-S.Struct({
-	directive: DirectiveSchema,
-	at: LocatedPositionSchema,
-	mutatorName: S.String
-});
 const DIRECTIVE_PATTERN = /^\s?Stryker (disable|restore)(?: (next-line))? ([a-zA-Z, ]+)(?::(.+)?)?/;
 const DEFAULT_REASON = "Ignored using a comment";
 const NEXT_LINE$1 = "next-line";
-S.Struct({
-	clause: S.Literals([
-		" Stryker disable",
-		" Stryker restore",
-		" Stryker disable next-line",
-		" Stryker restore next-line",
-		" Stryker enable",
-		" nothing"
-	]),
-	nameLetters: S.Array(S.Literals([
-		"a",
-		"b",
-		"Z",
-		",",
-		" "
-	])).check(S.isMinLength(1))
-});
 var DecodeDirectiveCommand = class extends S.TaggedClass()("DecodeDirectiveCommand", { commentText: S.String }) {
 	static [Workflow.InstrumentationBrand] = {};
 };
@@ -5890,27 +5867,34 @@ const loadHeader = Effect$1.map(parseWithOxc(INSTRUMENTATION_HEADER_SOURCE, "ins
 	instrumentationHeaderValue = parsed.root.body;
 	return parsed.root.body;
 });
-const instrumentationHeader = instrumentationHeaderValue !== void 0 ? Effect$1.succeed(instrumentationHeaderValue) : loadHeader;
+const instrumentationHeader = Option$1.match(Option$1.fromNullishOr(instrumentationHeaderValue), {
+	onNone: () => loadHeader,
+	onSome: (header) => Effect$1.succeed(header)
+});
 const placeHeader = (root) => Effect$1.map(headerFor(root), (header) => {
 	root.body.unshift(...header);
 });
-const headerFor = (root) => Effect$1.map(instrumentationHeader, (header) => Option$1.match(leadingCommentsOf(root), {
+const headerFor = (root) => Effect$1.map(instrumentationHeader, (header) => Option$1.match(Option$1.all([Option$1.fromNullishOr(header[0]), leadingCommentsOf(root)]), {
 	onNone: () => header,
-	onSome: (leadingComments) => [commentedHeader(leadingComments, header), ...header.slice(1)]
+	onSome: ([firstHeader, leadingComments]) => commentedHeader(firstHeader, leadingComments, header.slice(1))
 }));
-const placeHeaderIfNeededDataFirst = (placed, options, root) => placed ? placeHeaderWhenWanted(options, root) : Effect$1.void;
+const placeHeaderIfNeededDataFirst = (placed, options, root) => Boolean$1$1.match(placed, {
+	onTrue: () => placeHeaderWhenWanted(options, root),
+	onFalse: () => Effect$1.void
+});
 const placeHeaderIfNeeded = dual((args) => args.length >= 3, placeHeaderIfNeededDataFirst);
-const placeHeaderWhenWanted = (options, root) => options.noHeader === true ? Effect$1.void : placeHeader(root);
+const placeHeaderWhenWanted = (options, root) => Boolean$1$1.match(options.noHeader === true, {
+	onTrue: () => Effect$1.void,
+	onFalse: () => placeHeader(root)
+});
 function leadingCommentsOf(root) {
 	const first = root.body[0];
-	if (!hasLeadingComments$1(first)) return Option$1.none();
-	return Option$1.some(first.leadingComments);
+	return Option$1.map(Option$1.liftPredicate(first, hasLeadingComments$1), (value) => value.leadingComments);
 }
-function commentedHeader(leadingComments, header) {
-	const firstHeader = Option$1.getOrThrowWith(Option$1.fromNullishOr(header[0]), () => /* @__PURE__ */ new Error("Instrumentation header is empty"));
+function commentedHeader(firstHeader, leadingComments, rest) {
 	const cloned = cloneNode(firstHeader);
 	Object.assign(cloned, { leadingComments });
-	return cloned;
+	return [cloned, ...rest];
 }
 const PlacementFactsSchema = S.Struct({
 	isExpression: S.Boolean,
@@ -5924,8 +5908,8 @@ const ReplacementFactsSchema = S.Struct({
 	isSwitchCase: S.Boolean
 });
 const PlacedMutantSchema = S.Struct({
-	id: S.String,
-	mutatorName: S.String,
+	id: MutantId,
+	mutatorName: MutatorNameSchema,
 	replacement: ReplacementFactsSchema
 });
 var PlaceMutantsCommand = class extends S.TaggedClass()("PlaceMutantsCommand", {
@@ -5938,19 +5922,19 @@ var PlaceMutantsCommand = class extends S.TaggedClass()("PlaceMutantsCommand", {
 const PlacementDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js-instrumenter/PlacementDecision");
 var ExpressionSite = class extends S.TaggedClass()("ExpressionSite", {
 	fileName: S.String,
-	mutantIds: S.Array(S.String)
+	mutantIds: S.Array(MutantId)
 }) {
 	[PlacementDecisionTypeId] = PlacementDecisionTypeId;
 };
 var StatementSite = class extends S.TaggedClass()("StatementSite", {
 	fileName: S.String,
-	mutantIds: S.Array(S.String)
+	mutantIds: S.Array(MutantId)
 }) {
 	[PlacementDecisionTypeId] = PlacementDecisionTypeId;
 };
 var SwitchCaseSite = class extends S.TaggedClass()("SwitchCaseSite", {
 	fileName: S.String,
-	mutantIds: S.Array(S.String)
+	mutantIds: S.Array(MutantId)
 }) {
 	[PlacementDecisionTypeId] = PlacementDecisionTypeId;
 };
@@ -5962,8 +5946,8 @@ const ExpectedKindSchema = S.Literals([
 var MutantKindMismatch = class extends S.TaggedError()("MutantKindMismatch", {
 	fileName: S.String,
 	placer: PlacerNameSchema,
-	mutantId: S.String,
-	mutatorName: S.String,
+	mutantId: MutantId,
+	mutatorName: MutatorNameSchema,
 	expected: ExpectedKindSchema
 }) {};
 var NoPlacerClaimsNode = class extends S.TaggedError()("NoPlacerClaimsNode", { fileName: S.String }) {};
@@ -6014,23 +5998,19 @@ const placeMutants = Workflow.make({
 		return siteOf(command, placer);
 	})
 });
-const LocationSchema = S.Struct({
-	start: NodePositionSchema,
-	end: NodePositionSchema
-});
 const WILDCARD = "all";
 const NEXT_LINE = "next-line";
 const MutantCandidateSchema = S.Struct({
-	mutatorName: S.String,
+	mutatorName: MutatorNameSchema,
 	replacementCode: S.String,
-	location: S.optional(LocationSchema),
+	location: S.optional(Location),
 	ignorerReason: S.optional(S.String)
 });
 const PlannedMutantSchema = S.Struct({
-	id: S.String,
-	mutatorName: S.String,
+	id: MutantId,
+	mutatorName: MutatorNameSchema,
 	replacementCode: S.String,
-	location: LocationSchema,
+	location: Location,
 	ignoreReason: S.optional(S.String)
 });
 const MutantCounterSchema = S.Int.pipe(S.check(S.isBetween({
@@ -6041,10 +6021,10 @@ const MutantCountSchema = S.Int.pipe(S.check(S.isGreaterThanOrEqualTo(0)));
 var PlanMutantsCommand = class extends S.TaggedClass()("PlanMutantsCommand", {
 	fileName: S.String,
 	firstIndex: MutantCounterSchema,
-	offset: NodePositionSchema,
-	line: SourceLineSchema,
-	mutatorNames: S.Array(S.String),
-	excludedMutations: S.Array(S.String),
+	offset: ScriptOrigin,
+	line: Line,
+	mutatorNames: S.Array(MutatorNameSchema),
+	excludedMutations: S.Array(MutatorNameSchema),
 	rule: S.Array(LocatedDirectiveSchema),
 	directives: S.Array(LocatedDirectiveSchema),
 	candidates: S.Array(MutantCandidateSchema)
@@ -6069,7 +6049,7 @@ var MutantsFullyIgnored = class extends S.TaggedClass()("MutantsFullyIgnored", {
 };
 var MutantWithoutLocation = class extends S.TaggedError()("MutantWithoutLocation", {
 	fileName: S.String,
-	mutatorName: S.String
+	mutatorName: MutatorNameSchema
 }) {};
 const reachedLine = (located, line) => Match.value(located.directive.scope).pipe(Match.when(NEXT_LINE, () => located.governedLine === line), Match.when("block", () => true), Match.exhaustive);
 const namesMutator = (located, lowerMutatorName) => located.directive.mutatorNames.some((name) => [name === WILDCARD, name.toLowerCase() === lowerMutatorName].some(Boolean));
@@ -6087,12 +6067,13 @@ const unusedDirectiveWarning = (unused, fileName) => {
 };
 const warningsOf = (command) => unusedDirectives(command.directives, command.mutatorNames).map((unused) => unusedDirectiveWarning(unused, command.fileName));
 /**
-* Both the node span (`source`) and the region origin (`offset`) are 1-based
-* file coordinates: the region's first line carries its column origin, later
-* lines start at column 1, so the shift adds `offset.line - 1` lines and —
-* only when the node sits on the region's first line — `offset.column`.
+* The node span (`source`) is a 1-based position inside the embedded script;
+* the region origin (`offset`) is where that script begins in its host file.
+* The region's first line carries its column shift, later lines start at
+* column 1, so the shift adds `offset.line - 1` lines and — only when the node
+* sits on the region's first line — `offset.columnShift`.
 */
-const columnOffsetOf = (source, offset) => Match.value(source.line === 1).pipe(Match.when(true, () => offset.column), Match.when(false, () => 0), Match.exhaustive);
+const columnOffsetOf = (source, offset) => Match.value(source.line === 1).pipe(Match.when(true, () => offset.columnShift), Match.when(false, () => 0), Match.exhaustive);
 const shiftedPosition = (source, offset) => ({
 	column: source.column + columnOffsetOf(source, offset),
 	line: source.line + offset.line - 1
@@ -6107,7 +6088,7 @@ const plannedMutant = (command, candidate, index) => Option$1.match(Option$1.fro
 		mutatorName: candidate.mutatorName
 	})),
 	onSome: (location) => Result.succeed({
-		id: `${command.firstIndex + index}`,
+		id: PlannedMutantSchema.fields.id.make(`${command.firstIndex + index}`),
 		mutatorName: candidate.mutatorName,
 		replacementCode: candidate.replacementCode,
 		location: shiftedLocation(location, command.offset),
@@ -6141,7 +6122,11 @@ const comparePositions = (a, b) => {
 };
 const locationIncluded = (haystack, needle) => comparePositions(haystack.start, needle.start) <= 0 && comparePositions(haystack.end, needle.end) >= 0;
 const locationOverlaps = (a, b) => comparePositions(a.start, b.end) <= 0 && comparePositions(a.end, b.start) >= 0;
-const errorTextOf$1 = (cause) => Option$1.getOrElse(Option$1.map(ErrorText.fromCause(cause), (rendered) => rendered.text), () => "");
+const errorTextOf$1 = (cause) => Option$1.getOrElse(Option$1.map(errorTextOf$2(cause), (rendered) => rendered.text), () => "");
+const traversalFailure = (cause) => InstrumentError.make({
+	message: cause instanceof Error ? cause.message : errorTextOf$1(cause),
+	cause
+});
 const DEFAULT_MUTATOR_REGISTRY = {
 	defaults: defaultMutators,
 	optIn: optInMutators
@@ -6164,28 +6149,20 @@ const locatedDirective = (comment, governedLine) => Option$1.flatMap(Option$1.fr
 	at: loc.start,
 	governedLine
 })));
-const directivesOf = (node, governedLineOf) => attachedComments(node).flatMap((comment) => Option$1.toArray(locatedDirective(comment, governedLineOf(node))));
+const directivesOf = (node, governedLine) => attachedComments(node).flatMap((comment) => Option$1.toArray(locatedDirective(comment, governedLine)));
 const foldInto = (rule, directive) => Match.value(foldRule(FoldRuleCommand.make({
 	rule,
 	directive
 }))).pipe(Match.when(Result.isSuccess, (folded) => folded.success.rule), Match.orElse(() => rule));
 const NO_COMMENTS = [];
-function attachedComments(node) {
-	if (!hasLeadingComments(node)) return NO_COMMENTS;
-	return node.leadingComments;
-}
+const attachedComments = (node) => hasLeadingComments(node) ? node.leadingComments : NO_COMMENTS;
 const hasLeadingComments = (value) => Predicate$1.hasProperty(value, "leadingComments") && Array.isArray(value.leadingComments);
-function ancestorsOf(path) {
-	const ancestors = [];
-	for (let current = path.parentPath; current !== null; current = current.parentPath) ancestors.push(current.node);
-	return ancestors;
-}
-function isTypeNode(path) {
+function isTypeNode(node) {
 	return [
-		tsTypeAnnotationNodeTypes.includes(path.node.type),
-		flowTypeAnnotationNodeTypes.includes(path.node.type),
-		isDeclareVariableStatement(path.node),
-		isDeclareModule(path.node)
+		tsTypeAnnotationNodeTypes.includes(node.type),
+		flowTypeAnnotationNodeTypes.includes(node.type),
+		isDeclareVariableStatement(node),
+		isDeclareModule(node)
 	].some((isType) => isType);
 }
 function isDeclareVariableStatement(node) {
@@ -6221,8 +6198,8 @@ const flowTypeAnnotationNodeTypes = Object.freeze([
 	"OpaqueType",
 	"TypeAlias"
 ]);
-function isImportDeclaration(path) {
-	return nodeType(path.node) === "TSImportEqualsDeclaration" || path.node.type === "ImportDeclaration";
+function isImportDeclaration(node) {
+	return nodeType(node) === "TSImportEqualsDeclaration" || node.type === "ImportDeclaration";
 }
 function mutantTestExpression(mutantId) {
 	return callExpression(identifier(IS_MUTANT_ACTIVE_HELPER), [stringLiteral(mutantId)]);
@@ -6230,41 +6207,33 @@ function mutantTestExpression(mutantId) {
 function mutationCoverageSequenceExpression(mutants, targetExpression) {
 	const mutantIds = [...mutants].map((mutant) => stringLiteral(mutant.id));
 	const sequence = [callExpression(identifier(COVER_MUTANT_HELPER), mutantIds)];
-	if (targetExpression !== void 0) sequence.push(targetExpression);
-	return sequenceExpression(sequence);
+	return sequenceExpression(targetExpression === void 0 ? sequence : [...sequence, targetExpression]);
 }
 const refusalPlacer = (refusal) => Match.value(refusal).pipe(Match.tag("MutantKindMismatch", (mismatch) => mismatch.placer), Match.tag("MutantsUnapplied", (unapplied) => unapplied.placer), Match.tag("NoPlacerClaimsNode", () => "no placer"), Match.tag("MutantNotApplied", () => "no placer"), Match.exhaustive);
 const refusalDetail = (refusal) => Match.value(refusal).pipe(Match.tag("MutantKindMismatch", (mismatch) => `Expected ${mismatch.expected} for mutant ${mismatch.mutantId}`), Match.tag("MutantsUnapplied", (unapplied) => `Failed to apply ${unapplied.mutatorNames.join(", ")}`), Match.tag("NoPlacerClaimsNode", () => "No placer claims the node"), Match.tag("MutantNotApplied", (unapplied) => `Could not apply the ${unapplied.mutatorName} mutant`), Match.exhaustive);
-const placementFailure = (refusal, nodePath, mutants, fileName, lineTable, basePath) => {
+const placementFailureMessage = (refusal, node, mutants, fileName, lineStarts, basePath) => {
 	const message = `${refusalPlacer(refusal)} could not place mutants with type(s): "${placementListFormat.format(mutants.map((mutant) => mutant.mutatorName))}"`;
-	return /* @__PURE__ */ new Error(`${placementLocation(nodePath.node, fileName, lineTable, basePath)} ${message}. Either remove this file from the list of files to be mutated, or exclude the mutator (using \`mutator.excludedMutations\`). Original error: ${refusalDetail(refusal)}`);
+	return `${placementLocation(node, fileName, lineStarts, basePath)} ${message}. Either remove this file from the list of files to be mutated, or exclude the mutator (using \`mutator.excludedMutations\`). Original error: ${refusalDetail(refusal)}`;
 };
 function nodeOfKind(mutant, node, isKind, kind) {
-	return narrowNode(node, isKind, `Cannot place mutant ${mutant.id}: expected ${kind}, got ${node.type}`);
-}
-function narrowNode(node, isKind, message) {
-	if (isKind(node)) return node;
-	throw new Error(message);
+	return isKind(node) ? Result.succeed(node) : Result.fail(/* @__PURE__ */ new Error(`Cannot place mutant ${mutant.id}: expected ${kind}, got ${node.type}`));
 }
 function expressionOf(node) {
-	return narrowNode(node, isExpressionKind, `Expected an expression, got ${node.type}`);
+	return isExpressionKind(node) ? Result.succeed(node) : Result.fail(/* @__PURE__ */ new Error(`Expected an expression, got ${node.type}`));
 }
 function statementOf(node) {
-	return narrowNode(node, isStatementKind, `Expected a statement, got ${node.type}`);
+	return isStatementKind(node) ? Result.succeed(node) : Result.fail(/* @__PURE__ */ new Error(`Expected a statement, got ${node.type}`));
 }
 function isSwitchCase(node) {
 	return nodeType(node) === "SwitchCase";
 }
 function switchCaseOf(node) {
-	return narrowNode(node, isSwitchCase, `Expected a switch case, got ${node.type}`);
+	return isSwitchCase(node) ? Result.succeed(node) : Result.fail(/* @__PURE__ */ new Error(`Expected a switch case, got ${node.type}`));
 }
-const fileNameWithin = (basePath, fileName) => {
-	if (basePath === void 0) return fileName;
-	return relativeTo(basePath, fileName);
-};
-function placementLocation(node, fileName, lineTable, basePath) {
+const fileNameWithin = (basePath, fileName) => basePath === void 0 ? fileName : relativeTo(basePath, fileName);
+function placementLocation(node, fileName, lineStarts, basePath) {
 	const relativeFile = fileNameWithin(basePath, fileName);
-	const position = Option$1.map(Option$1.fromNullishOr(spanOf(node)), (span) => lineTable.positionAt(span.start));
+	const position = Option$1.map(Option$1.fromNullishOr(spanOf(node)), (span) => positionAt(lineStarts, span.start));
 	return Option$1.match(position, {
 		onNone: () => `${relativeFile}:undefined:undefined`,
 		onSome: (at) => `${relativeFile}:${at.line}:${at.column}`
@@ -6274,27 +6243,25 @@ const placementListFormat = new Intl.ListFormat("en");
 const normalizeSeparators = (value) => value.replace(/\\/g, "/");
 const withTrailingSlash = (basePath) => {
 	const normalized = normalizeSeparators(basePath);
-	if (normalized.endsWith("/")) return normalized;
-	return `${normalized}/`;
+	return normalized.endsWith("/") ? normalized : `${normalized}/`;
 };
 const relativeTo = (basePath, fileName) => {
 	const prefix = withTrailingSlash(basePath);
 	const normalizedFile = normalizeSeparators(fileName);
-	if (!normalizedFile.startsWith(prefix)) return fileName;
-	return normalizedFile.slice(prefix.length);
+	return normalizedFile.startsWith(prefix) ? normalizedFile.slice(prefix.length) : fileName;
 };
 function classOrFunctionExpressionNamedIfNeeded(path) {
-	return Match.value(path.node).pipe(Match.when(isAnonymousFunctionOrClass, (node) => nameFromParent(path, node)), Match.orElse(() => void 0));
+	return Option$1.flatMap(Option$1.filter(Option$1.some(path.node), isAnonymousFunctionOrClass), (node) => nameFromParent(path, node));
 }
 function nameFromParent(path, node) {
 	return Match.value(path.parentPath?.node).pipe(Match.when(isVariableDeclarator, (declarator) => adoptDeclaredName(node, declarator)), Match.when({
 		type: "Property",
 		key: { type: "Identifier" }
-	}, () => namedPropertyValue(path, node)), Match.orElse(() => void 0));
+	}, () => namedPropertyValue(path, node)), Match.orElse(() => Option$1.none()));
 }
 /** A property value only survives by name when the declaration above it carries one. */
 function namedPropertyValue(path, node) {
-	return Match.value(path.getStatementParent()?.node.type).pipe(Match.when("VariableDeclaration", () => node), Match.orElse(() => void 0));
+	return Match.value(path.getStatementParent()?.node.type).pipe(Match.when("VariableDeclaration", () => Option$1.some(node)), Match.orElse(() => Option$1.none()));
 }
 function adoptIdentifier(node, identifier) {
 	node.id = identifier;
@@ -6307,14 +6274,11 @@ function isFunctionOrClassExpression(node) {
 	return node.type === "FunctionExpression" || node.type === "ClassExpression";
 }
 function arrowFunctionExpressionNamedIfNeeded(path) {
-	return Match.value(path.node).pipe(Match.when({ type: "ArrowFunctionExpression" }, (node) => arrowNamedByDeclarator(node, path.parentPath)), Match.orElse(() => void 0));
+	return Match.value(path.node).pipe(Match.when({ type: "ArrowFunctionExpression" }, (node) => arrowNamedByDeclarator(node, path.parentPath)), Match.orElse(() => Option$1.none()));
 }
 /** An arrow bound to a named declaration is re-emitted as a named function. */
 function arrowNamedByDeclarator(node, parentPath) {
-	return Option$1.match(declaratorIdentifier(parentPath), {
-		onNone: () => void 0,
-		onSome: (identifier) => namedArrowExpression(node, identifier)
-	});
+	return Option$1.map(declaratorIdentifier(parentPath), (identifier) => namedArrowExpression(node, identifier));
 }
 function namedArrowExpression(node, identifier) {
 	const declaration = variableDeclaration("const", [variableDeclarator(identifier, node)]);
@@ -6327,10 +6291,7 @@ function isVariableDeclarator(node) {
 	return nodeType(node) === "VariableDeclarator";
 }
 function adoptDeclaredName(node, declarator) {
-	return Option$1.match(declaredName(declarator), {
-		onNone: () => void 0,
-		onSome: (identifier) => adoptIdentifier(node, identifier)
-	});
+	return Option$1.map(declaredName(declarator), (identifier) => adoptIdentifier(node, identifier));
 }
 function declaredName(declarator) {
 	return Match.value(declarator.id).pipe(Match.when(isIdentifierReference, (identifier) => Option$1.some(identifier)), Match.orElse(() => Option$1.none()));
@@ -6339,10 +6300,10 @@ function isIdentifierReference(node) {
 	return nodeType(node) === "Identifier";
 }
 function nameIfAnonymous(path) {
-	return classOrFunctionExpressionNamedIfNeeded(path) ?? arrowNameOrNode(path);
-}
-function arrowNameOrNode(path) {
-	return arrowFunctionExpressionNamedIfNeeded(path) ?? expressionOf(path.node);
+	return Option$1.match(Option$1.orElse(classOrFunctionExpressionNamedIfNeeded(path), () => arrowFunctionExpressionNamedIfNeeded(path)), {
+		onNone: () => expressionOf(path.node),
+		onSome: (named) => Result.succeed(named)
+	});
 }
 function isChainLink(node) {
 	return [
@@ -6360,51 +6321,45 @@ function isCallExpressionNode(node) {
 function isNonNullExpression(node) {
 	return nodeType(node) === "TSNonNullExpression";
 }
-function isValidExpression(path) {
-	const parent = path.parentPath;
-	return parent === null || !isUnmutatableContext(path, parent);
+function isValidExpression(node, parent) {
+	return parent === null || !isUnmutatableContext(node, parent);
 }
-function isUnmutatableContext(path, parent) {
+function isUnmutatableContext(node, parent) {
 	return [
-		isObjectPropertyKey(path, parent),
-		isPartOfChain(path, parent),
+		isObjectPropertyKey(node, parent),
+		isPartOfChain(node, parent),
 		isTaggedTemplateTag(parent),
-		isDeletedOperand(path, parent),
-		isAssignedTarget(path, parent)
+		isDeletedOperand(node, parent),
+		isAssignedTarget(node, parent)
 	].some((invalid) => invalid);
 }
-function isObjectPropertyKey(path, parent) {
-	const parentNode = parent.node;
-	return parentNode.type === "Property" && parentNode.key === path.node;
+function isObjectPropertyKey(node, parent) {
+	return parent.type === "Property" && parent.key === node;
 }
 function isTaggedTemplateTag(parent) {
-	return parent.node.type === "TaggedTemplateExpression";
+	return parent.type === "TaggedTemplateExpression";
 }
-function isDeletedOperand(path, parent) {
-	const parentNode = parent.node;
-	return parentNode.type === "UnaryExpression" && parentNode.operator === "delete";
+function isDeletedOperand(node, parent) {
+	return parent.type === "UnaryExpression" && parent.operator === "delete";
 }
-function isAssignedTarget(path, parent) {
-	const parentNode = parent.node;
-	return parentNode.type === "AssignmentExpression" && parentNode.left === path.node;
+function isAssignedTarget(node, parent) {
+	return parent.type === "AssignmentExpression" && parent.left === node;
 }
-function isPartOfChain(path, parent) {
-	return isChainLink(path.node) && chainContinuesIn(path, parent);
+function isPartOfChain(node, parent) {
+	return isChainLink(node) && chainContinuesIn(node, parent);
 }
-function chainContinuesIn(path, parent) {
+function chainContinuesIn(node, parent) {
 	return [
-		isMemberAccessParent(path, parent),
-		isNonNullExpression(parent.node),
-		isCalleeParent(path, parent)
+		isMemberAccessParent(node, parent),
+		isNonNullExpression(parent),
+		isCalleeParent(node, parent)
 	].some((continues) => continues);
 }
-function isMemberAccessParent(path, parent) {
-	const parentNode = parent.node;
-	return parentNode.type === "MemberExpression" && isNotACallOnTheNode(parentNode, path.node);
+function isMemberAccessParent(node, parent) {
+	return parent.type === "MemberExpression" && isNotACallOnTheNode(parent, node);
 }
-function isCalleeParent(path, parent) {
-	const parentNode = parent.node;
-	return parentNode.type === "CallExpression" && parentNode.callee === path.node;
+function isCalleeParent(node, parent) {
+	return parent.type === "CallExpression" && parent.callee === node;
 }
 function isNotACallOnTheNode(member, node) {
 	return !(member.computed && member.property === node);
@@ -6421,27 +6376,31 @@ function isParenthesizedWrapper(value) {
 const expressionMutantPlacer = {
 	name: "expression",
 	place(path, appliedMutants) {
-		let expression = nameIfAnonymous(path);
-		expression = mutationCoverageSequenceExpression(appliedMutants.keys(), expression);
-		for (const [mutant, appliedMutant] of appliedMutants) expression = conditionalExpression(mutantTestExpression(mutant.id), nodeOfKind(mutant, unwrapParenthesizedExpression(appliedMutant), isExpressionKind, "an expression"), expression);
-		path.replaceWith(expression);
+		return Result.gen(function* () {
+			const base = yield* nameIfAnonymous(path);
+			const sequenced = mutationCoverageSequenceExpression(appliedMutants.keys(), base);
+			const expression = yield* [...appliedMutants].reduce((accumulated, [mutant, appliedMutant]) => Result.flatMap(accumulated, (current) => Result.map(nodeOfKind(mutant, unwrapParenthesizedExpression(appliedMutant), isExpressionKind, "an expression"), (replacement) => conditionalExpression(mutantTestExpression(mutant.id), replacement, current))), Result.succeed(sequenced));
+			path.replaceWith(expression);
+		});
 	}
 };
 const statementMutantPlacer = {
 	name: "statement",
 	place(path, appliedMutants) {
-		const body = [expressionStatement(mutationCoverageSequenceExpression(appliedMutants.keys())), ...statementsOf(path)];
-		const statement = [...appliedMutants].reduce(guardedStatement, blockStatement(body));
-		path.replaceWith(wrappedStatement(path, statement));
+		return Result.gen(function* () {
+			const statements = yield* statementsOf(path);
+			const body = [expressionStatement(mutationCoverageSequenceExpression(appliedMutants.keys())), ...statements];
+			const statement = yield* [...appliedMutants].reduce((accumulated, entry) => Result.flatMap(accumulated, (current) => guardedStatement(current, entry)), Result.succeed(blockStatement(body)));
+			path.replaceWith(wrappedStatement(path, statement));
+		});
 	}
 };
-function statementsOf(path) {
+const statementsOf = (path) => {
 	const node = path.node;
-	if (node.type === "BlockStatement") return node.body;
-	return [statementOf(node)];
-}
+	return node.type === "BlockStatement" ? Result.succeed(node.body) : Result.map(statementOf(node), (statement) => [statement]);
+};
 function guardedStatement(statement, entry) {
-	return ifStatement(mutantTestExpression(entry[0].id), blockStatement([nodeOfKind(entry[0], entry[1], isStatementKind, "a statement")]), statement);
+	return Result.map(nodeOfKind(entry[0], entry[1], isStatementKind, "a statement"), (narrowed) => ifStatement(mutantTestExpression(entry[0].id), blockStatement([narrowed]), statement));
 }
 function wrappedStatement(path, statement) {
 	return Match.value(nodeType(path.node)).pipe(Match.when("BlockStatement", () => blockStatement([statement])), Match.orElse(() => statement));
@@ -6452,13 +6411,11 @@ const placerBuilders = Object.freeze({
 	"switch-case": {
 		name: "switch-case",
 		place(path, appliedMutants) {
-			const currentCase = switchCaseOf(path.node);
-			let consequence = blockStatement([expressionStatement(mutationCoverageSequenceExpression(appliedMutants.keys())), ...currentCase.consequent]);
-			for (const [mutant, appliedMutant] of appliedMutants) {
-				const appliedCase = nodeOfKind(mutant, appliedMutant, isSwitchCase, "a switch case");
-				consequence = ifStatement(mutantTestExpression(mutant.id), blockStatement(appliedCase.consequent), consequence);
-			}
-			path.replaceWith(switchCase(currentCase.test, [consequence]));
+			return Result.gen(function* () {
+				const currentCase = yield* switchCaseOf(path.node);
+				const consequence = yield* [...appliedMutants].reduce((accumulated, [mutant, appliedMutant]) => Result.flatMap(accumulated, (current) => Result.map(nodeOfKind(mutant, appliedMutant, isSwitchCase, "a switch case"), (appliedCase) => ifStatement(mutantTestExpression(mutant.id), blockStatement(appliedCase.consequent), current))), Result.succeed(blockStatement([expressionStatement(mutationCoverageSequenceExpression(appliedMutants.keys())), ...currentCase.consequent])));
+				path.replaceWith(switchCase(currentCase.test, [consequence]));
+			});
 		}
 	}
 });
@@ -6474,231 +6431,281 @@ const transformDataFirst = (ast, mutantCollector, transformerContext) => {
 	}))));
 };
 const transform = dual((args) => args.length >= 3, transformDataFirst);
-const emptyAppliedMutants = () => /* @__PURE__ */ new Map();
-const traversalFailure = (cause) => InstrumentError.make({
-	message: cause instanceof Error ? cause.message : errorTextOf$1(cause),
-	cause
-});
 function isMutateRangeList(value) {
 	return Array.isArray(value);
 }
-const transformScriptDataFirst = ({ root, originFileName, rawContent, offset, comments }, mutantCollector, { options, mutateDescription, basePath }) => {
-	const placementMap = /* @__PURE__ */ new Map();
-	return Effect$1.gen(function* () {
-		const lineTable = yield* Effect$1.orDie(S.decodeEffect(LineTableFromText)(rawContent));
-		attachComments(make(root), comments, lineTable);
-		let directiveRule = [];
-		let hasLiveMutants = false;
-		const selection = selectMutators(DEFAULT_MUTATOR_REGISTRY, options.optInMutations);
-		const mutatorEntries = selection.active;
-		const allMutatorNames = selection.known.map((name) => name.toLowerCase());
-		const warnings = [];
-		yield* Effect$1.try({
-			try: () => traverse(make(root), {
-				enter(path) {
-					const directives = directivesOf(path.node, (node) => getNodeLocation(node).start.line);
-					directiveRule = directives.reduce(foldInto, directiveRule);
-					visitNode(path, directives);
-				},
-				exit(path) {
-					const placement = placementMap.get(path.node);
-					if (hasAppliedMutants(placement)) applyPlacement(path, placement);
-				}
-			}),
-			catch: traversalFailure
-		});
-		yield* placeHeaderIfNeeded(hasLiveMutants, options, root);
-		return warnings;
-		function visitNode(path, directives) {
-			if (shouldSkip(path)) {
-				path.skip();
-				return;
-			}
-			addToPlacementMapIfPossible(path);
-			placeCollectedMutants(path, directives);
-		}
-		function placementFacts(path) {
-			return {
-				isExpression: path.isExpression(),
-				isStatement: path.isStatement(),
-				isSwitchCase: nodeType(path.node) === "SwitchCase",
-				expressionIsValid: isValidExpression(path)
-			};
-		}
-		function placerNameOf(site) {
-			return Match.value(site).pipe(Match.tag("ExpressionSite", () => "expression"), Match.tag("StatementSite", () => "statement"), Match.tag("SwitchCaseSite", () => "switch-case"), Match.exhaustive);
-		}
-		function addToPlacementMapIfPossible(path) {
-			const facts = placementFacts(path);
-			const claimed = placeMutants(PlaceMutantsCommand.make({
-				fileName: originFileName,
-				facts,
-				mutants: []
-			}));
-			Match.value(claimed).pipe(Match.when(Result.isSuccess, () => placementMap.set(path.node, {
-				appliedMutants: emptyAppliedMutants(),
-				facts
-			})), Match.orElse(() => void 0));
-		}
-		function hasAppliedMutants(placement) {
-			return placement !== void 0 && placement.appliedMutants.size > 0;
-		}
-		function replacementRecord(mutant, applied) {
-			const replacement = unwrapParenthesizedExpression(applied);
-			return {
-				id: mutant.id,
-				mutatorName: mutant.mutatorName,
-				replacement: {
-					isExpression: isExpressionKind(replacement),
-					isStatement: isStatementKind(replacement),
-					isSwitchCase: nodeType(replacement) === "SwitchCase"
-				}
-			};
+const MUTATION_OFFSET = {
+	line: 1,
+	columnShift: 0
+};
+const initialFoldState = (firstIndex) => ({
+	directiveRule: [],
+	nextIndex: firstIndex,
+	mutants: [],
+	warnings: [],
+	claims: [],
+	placements: [],
+	hasLiveMutants: false
+});
+const framesUpward = (frame) => [frame, ...framesAbove(frame)];
+const framesAbove = (frame) => Option$1.match(Option$1.fromNullishOr(frame.parent), {
+	onNone: () => [],
+	onSome: (parent) => framesUpward(parent)
+});
+const parentNodeOf = (frame) => Option$1.getOrNull(Option$1.map(Option$1.fromNullishOr(frame.parent), (parent) => parent.node));
+const ancestorsOfFrame = (frame) => Option$1.match(Option$1.fromNullishOr(frame.parent), {
+	onNone: () => [],
+	onSome: (parent) => [parent.node, ...ancestorsOfFrame(parent)]
+});
+const placementFactsOf = (frame) => ({
+	isExpression: isExpressionKind(frame.node),
+	isStatement: isStatementKind(frame.node),
+	isSwitchCase: nodeType(frame.node) === "SwitchCase",
+	expressionIsValid: isValidExpression(frame.node, parentNodeOf(frame))
+});
+const placerNameOf = (site) => Match.value(site).pipe(Match.tag("ExpressionSite", () => "expression"), Match.tag("StatementSite", () => "statement"), Match.tag("SwitchCaseSite", () => "switch-case"), Match.exhaustive);
+const replacementRecord = (mutant, applied) => {
+	const replacement = unwrapParenthesizedExpression(applied);
+	return {
+		id: mutant.id,
+		mutatorName: mutant.mutatorName,
+		replacement: {
+			isExpression: isExpressionKind(replacement),
+			isStatement: isStatementKind(replacement),
+			isSwitchCase: nodeType(replacement) === "SwitchCase"
 		}
-		function raisePlacementRefusal(refusal, placement, path) {
-			throw placementFailure(refusal, path, [...placement.appliedMutants.keys()], originFileName, lineTable, basePath);
+	};
+};
+const plannedWithNodes = (candidates, planned, fileName) => candidates.flatMap((candidate, index) => Option$1.match(Option$1.fromNullishOr(planned[index]), {
+	onNone: () => [],
+	onSome: (mutant) => [createMutant(mutant, fileName, candidate.node, candidate.replacement)]
+}));
+const ignorersReasonFor = (node, ancestors, ignorers) => ignorers.reduce((reason, ignorer) => Option$1.orElse(reason, () => Option$1.fromNullishOr(ignorer.shouldIgnore(node, ancestors))), Option$1.none());
+const mutablesFor = (frame, location, context) => {
+	const ancestors = ancestorsOfFrame(frame);
+	const mutatorContext = toMutatorContext(ancestors);
+	const replacements = context.mutatorEntries.flatMap(([mutatorName, mutate]) => [...mutate(frame.node, mutatorContext)].map((replacement) => ({
+		mutatorName,
+		replacement
+	})));
+	const ignorerReason = replacements.length === 0 ? void 0 : Option$1.getOrUndefined(ignorersReasonFor(frame.node, ancestors, context.ignorers));
+	return replacements.map(({ mutatorName, replacement }) => ({
+		node: frame.node,
+		replacement,
+		data: {
+			mutatorName,
+			replacementCode: printNode(replacement),
+			location,
+			ignorerReason
 		}
-		function placeSite(site, placement, path) {
-			try {
-				placerBuilders[placerNameOf(site)].place(path, placement.appliedMutants);
-				path.skip();
-			} catch (error) {
-				raisePlacementRefusal(MutantsUnapplied.make({
-					fileName: originFileName,
-					placer: placerNameOf(site),
-					mutatorNames: [...placement.appliedMutants.keys()].map((mutant) => mutant.mutatorName),
-					cause: toError(error)
-				}), placement, path);
+	}));
+};
+const mutateRangesOf = (mutateDescription) => Option$1.filter(Option$1.some(mutateDescription), isMutateRangeList);
+const isOutsideMutateRanges = (location, mutateDescription) => Option$1.exists(mutateRangesOf(mutateDescription), (ranges) => ranges.every((range) => !locationOverlaps(range, location)));
+const isInsideMutateRanges = (location, mutateDescription) => Option$1.exists(mutateRangesOf(mutateDescription), (ranges) => ranges.some((range) => locationIncluded(range, location)));
+const shouldMutateAt = (location, mutateDescription) => mutateDescription === true || isInsideMutateRanges(location, mutateDescription);
+const shouldSkipNode = (frame, location, mutateDescription) => [
+	isTypeNode(frame.node),
+	isImportDeclaration(frame.node),
+	nodeType(frame.node) === "Decorator",
+	mutateDescription === false,
+	isOutsideMutateRanges(location, mutateDescription)
+].some((skip) => skip);
+const locationOfNode = (frame, context) => Option$1.match(Option$1.map(Option$1.fromNullishOr(spanOf(frame.node)), (span) => locationOf(context.lineStarts, span)), {
+	onNone: () => Result.fail(NodeWithoutSpan.make({ fileName: context.fileName })),
+	onSome: Result.succeed
+});
+const refusedPlacement = (refusal, node, mutants, context) => PlacementRefused.make({ message: placementFailureMessage(refusal, node, mutants, context.fileName, context.lineStarts, context.basePath) });
+const applyMutantToClaim = (mutant, target, appliedSoFar, context) => Result.mapError(applyMutant(mutant, target), (failure) => refusedPlacement(failure, target, appliedSoFar, context));
+const applyToClaim = (mutants, target, state, context) => {
+	const existing = state.claims.find((claim) => claim.node === target.node);
+	const priorMutants = existing === void 0 ? [] : existing.applied.map(([mutant]) => mutant);
+	const applied = mutants.reduce((accumulated, mutant) => Result.flatMap(accumulated, (entries) => Result.map(applyMutantToClaim(mutant, target.node, [...priorMutants, ...entries.map(([entry]) => entry)], context), (tree) => [...entries, [mutant, tree]])), Result.succeed([]));
+	return Result.map(applied, (entries) => ({
+		...state,
+		claims: state.claims.map((claim) => claim.node === target.node ? {
+			...claim,
+			applied: [...claim.applied, ...entries]
+		} : claim)
+	}));
+};
+const attachPlaceable = (mutants, frame, state, context) => Match.value(mutants.length > 0).pipe(Match.when(false, () => Result.succeed(state)), Match.when(true, () => Option$1.match(Option$1.fromNullishOr(framesUpward(frame).find((candidate) => state.claims.some((claim) => claim.node === candidate.node))), {
+	onNone: () => Result.fail(MutantsUnplaced.make({
+		fileName: context.fileName,
+		detail: JSON.stringify(mutants, null, 2)
+	})),
+	onSome: (target) => applyToClaim(mutants, target, state, context)
+})), Match.exhaustive);
+const collectPlan = (frame, candidates, plan, state, context) => {
+	const collected = plannedWithNodes(candidates, plan.mutants, context.fileName);
+	const nextState = {
+		...state,
+		mutants: [...state.mutants, ...collected],
+		warnings: [...state.warnings, ...plan.warnings],
+		nextIndex: plan.nextIndex
+	};
+	return Match.value(plan).pipe(Match.tag("MutantsPlanned", (planned) => attachPlaceable(plannedWithNodes(candidates, planned.placeable, context.fileName), frame, {
+		...nextState,
+		hasLiveMutants: true
+	}, context)), Match.orElse(() => Result.succeed(nextState)));
+};
+const planMutantsAt = (frame, candidates, directives, location, state, context) => {
+	const plan = planMutants(PlanMutantsCommand.make({
+		fileName: context.fileName,
+		firstIndex: state.nextIndex,
+		offset: context.offset,
+		line: location.start.line,
+		mutatorNames: [...context.allMutatorNames],
+		excludedMutations: [...context.excludedMutations],
+		rule: [...state.directiveRule],
+		directives: [...directives],
+		candidates: candidates.map((candidate) => candidate.data)
+	}));
+	return Match.value(plan).pipe(Match.when(Result.isFailure, (failed) => Result.fail(failed.failure)), Match.orElse((succeeded) => collectPlan(frame, candidates, succeeded.success, state, context)));
+};
+const candidatesFor = (frame, location, context) => Match.value(shouldMutateAt(location, context.mutateDescription)).pipe(Match.when(true, () => mutablesFor(frame, location, context)), Match.orElse(() => []));
+const needsPlan = (candidates, directives) => [candidates.length > 0, directives.length > 0].some(Boolean);
+const planAtNode = (frame, directives, location, state, context) => {
+	const candidates = candidatesFor(frame, location, context);
+	return Match.value(needsPlan(candidates, directives)).pipe(Match.when(false, () => Result.succeed(state)), Match.when(true, () => planMutantsAt(frame, candidates, directives, location, state, context)), Match.exhaustive);
+};
+const claimSelf = (frame, facts, claims, context) => {
+	const claimed = placeMutants(PlaceMutantsCommand.make({
+		fileName: context.fileName,
+		facts,
+		mutants: []
+	}));
+	return Match.value(claimed.pipe(Result.isSuccess)).pipe(Match.when(true, () => [...claims, {
+		node: frame.node,
+		facts,
+		applied: []
+	}]), Match.orElse(() => claims));
+};
+const siteOfClaim = (claim, context) => {
+	const mutants = claim.applied.map(([mutant]) => mutant);
+	const decision = placeMutants(PlaceMutantsCommand.make({
+		fileName: context.fileName,
+		facts: claim.facts,
+		mutants: claim.applied.map(([mutant, applied]) => replacementRecord(mutant, applied))
+	}));
+	return Match.value(decision).pipe(Match.when(Result.isFailure, (refused) => Result.fail(refusedPlacement(refused.failure, claim.node, mutants, context))), Match.orElse((decided) => Result.succeed(decided.success)));
+};
+const emitClaim = (claim, state, context) => Match.value(claim.applied.length > 0).pipe(Match.when(false, () => Result.succeed(state)), Match.when(true, () => Result.map(siteOfClaim(claim, context), (site) => ({
+	...state,
+	placements: [...state.placements, {
+		node: claim.node,
+		placer: placerNameOf(site),
+		applied: claim.applied
+	}]
+}))), Match.exhaustive);
+const emitPlacement = (frame, state, context) => Option$1.match(Option$1.fromNullishOr(state.claims.find((claim) => claim.node === frame.node)), {
+	onNone: () => Result.succeed(state),
+	onSome: (claim) => emitClaim(claim, state, context)
+});
+const foldChildren = (frame, state, context) => childNodes(frame.node).reduce((accumulated, child) => Result.flatMap(accumulated, (current) => foldPlacements({
+	node: child.node,
+	parent: frame
+}, current, context)), Result.succeed(state));
+const visitFrame = (frame, directives, location, state, context) => {
+	const facts = placementFactsOf(frame);
+	const claimed = claimSelf(frame, facts, state.claims, context);
+	return Result.flatMap(planAtNode(frame, directives, location, {
+		...state,
+		claims: claimed
+	}, context), (afterPlan) => Result.flatMap(foldChildren(frame, afterPlan, context), (afterChildren) => emitPlacement(frame, afterChildren, context)));
+};
+const foldPlacements = (frame, state, context) => Result.flatMap(locationOfNode(frame, context), (location) => {
+	const directives = directivesOf(frame.node, location.start.line);
+	const ruled = {
+		...state,
+		directiveRule: directives.reduce(foldInto, state.directiveRule)
+	};
+	return Match.value(shouldSkipNode(frame, location, context.mutateDescription)).pipe(Match.when(true, () => Result.succeed(ruled)), Match.when(false, () => visitFrame(frame, directives, location, ruled, context)), Match.exhaustive);
+});
+const planInstrumentation = (root, firstIndex, context) => Result.map(foldPlacements({
+	node: root,
+	parent: null
+}, initialFoldState(firstIndex), context), (state) => ({
+	mutants: state.mutants,
+	placements: state.placements,
+	warnings: state.warnings,
+	hasLiveMutants: state.hasLiveMutants
+}));
+const applyOnePlacement = (placement, path, previous, context) => {
+	const result = placerBuilders[placement.placer].place(path, new Map(placement.applied));
+	return Result.match(result, {
+		onFailure: (cause) => new Error(placementFailureMessage(MutantsUnapplied.make({
+			fileName: context.fileName,
+			placer: placement.placer,
+			mutatorNames: placement.applied.map(([mutant]) => mutant.mutatorName),
+			cause: toError(cause)
+		}), placement.node, placement.applied.map(([mutant]) => mutant), context.fileName, context.lineStarts, context.basePath)),
+		onSuccess: () => previous
+	});
+};
+const applyPlacementsToAst = (root, places, context) => {
+	let failure;
+	traverse(make(root), { exit(path) {
+		Option$1.match(Option$1.fromNullishOr(places.get(path.node)), {
+			onNone: () => void 0,
+			onSome: (placement) => {
+				failure = applyOnePlacement(placement, path, failure, context);
 			}
-		}
-		function applyPlacement(path, placement) {
-			const decision = placeMutants(PlaceMutantsCommand.make({
-				fileName: originFileName,
-				facts: placement.facts,
-				mutants: [...placement.appliedMutants].map(([mutant, applied]) => replacementRecord(mutant, applied))
-			}));
-			Match.value(decision).pipe(Match.when(Result.isFailure, (refused) => raisePlacementRefusal(refused.failure, placement, path)), Match.orElse((decided) => placeSite(decided.success, placement, path)));
-		}
-		function placeCollectedMutants(path, directives) {
-			const candidates = candidateSteps(path);
-			Match.value(needsPlan(candidates, directives)).pipe(Match.when(true, () => planAndPlace(path, candidates, directives)), Match.when(false, () => void 0), Match.exhaustive);
-		}
-		function candidateSteps(path) {
-			return Match.value(shouldMutate(path)).pipe(Match.when(true, () => mutablesFor(path)), Match.when(false, () => []), Match.exhaustive);
-		}
-		function needsPlan(candidates, directives) {
-			return [candidates.length > 0, directives.length > 0].some(Boolean);
-		}
-		function planAndPlace(path, candidates, directives) {
-			Match.value(planFor(path, candidates, directives)).pipe(Match.when(Option$1.isSome, (toPlace) => placeOnPath(path, toPlace.value)), Match.orElse(() => void 0));
-		}
-		function planFor(path, candidates, directives) {
-			const plan = planMutants(PlanMutantsCommand.make({
-				fileName: originFileName,
-				firstIndex: mutantCollector.nextIndex,
-				offset: offset ?? {
-					line: 1,
-					column: 0
-				},
-				line: getNodeLocation(path.node).start.line,
-				mutatorNames: allMutatorNames,
-				excludedMutations: options.excludedMutations,
-				rule: directiveRule,
-				directives: [...directives],
-				candidates: candidates.map((candidate) => candidate.data)
-			}));
-			return Match.value(plan).pipe(Match.when(Result.isFailure, (failed) => raisePlanFailure(failed.failure)), Match.orElse((succeeded) => collectPlanned(candidates, succeeded.success)));
-		}
-		function raisePlanFailure(failure) {
-			throw new Error(`Mutant without a source location: ${failure.mutatorName} in ${failure.fileName}`);
-		}
-		function collectPlanned(candidates, plan) {
-			mutantCollector.append(plannedWithNodes(candidates, plan.mutants));
-			warnings.push(...plan.warnings);
-			return Match.value(plan).pipe(Match.tag("MutantsPlanned", (planned) => {
-				hasLiveMutants = true;
-				return Option$1.some(plannedWithNodes(candidates, planned.placeable));
-			}), Match.orElse(() => Option$1.none()));
-		}
-		function plannedWithNodes(candidates, planned) {
-			return candidates.flatMap((candidate, index) => Option$1.match(Option$1.fromNullishOr(planned[index]), {
-				onNone: () => [],
-				onSome: (mutant) => [createMutant(mutant, originFileName, candidate.node, candidate.replacement)]
-			}));
-		}
-		function placeOnPath(path, mutantsToPlace) {
-			const placementPath = requiredPlacementPath(path, mutantsToPlace);
-			const placement = requiredPlacement(placementPath.node);
-			mutantsToPlace.forEach((mutant) => {
-				Match.value(applyMutant(mutant, placementPath.node)).pipe(Match.when(Result.isFailure, (failed) => raisePlacementRefusal(failed.failure, placement, path)), Match.orElse((applied) => placement.appliedMutants.set(mutant, applied.success)));
-			});
-		}
-		function requiredPlacementPath(path, mutantsToPlace) {
-			return Option$1.getOrThrowWith(Option$1.fromNullishOr(path.find((ancestor) => placementMap.has(ancestor.node))), () => unplacedMutantsError(mutantsToPlace));
-		}
-		function unplacedMutantsError(mutantsToPlace) {
-			return /* @__PURE__ */ new Error(`Mutants cannot be placed. This shouldn't happen! Unplaced mutants: ${JSON.stringify(mutantsToPlace, null, 2)}`);
-		}
-		function requiredPlacement(node) {
-			return Option$1.getOrThrowWith(Option$1.fromNullishOr(placementMap.get(node)), () => /* @__PURE__ */ new Error("Placement not found for node"));
-		}
-		function shouldSkip(path) {
-			return [
-				isTypeNode(path),
-				isImportDeclaration(path),
-				nodeType(path.node) === "Decorator",
-				mutateDescription === false,
-				isOutsideMutateRanges(path)
-			].some((skip) => skip);
-		}
-		function mutateRanges() {
-			return Option$1.filter(Option$1.some(mutateDescription), isMutateRangeList);
-		}
-		function isOutsideMutateRanges(path) {
-			return Option$1.exists(mutateRanges(), (ranges) => ranges.every((range) => !locationOverlaps(range, getNodeLocation(path.node))));
-		}
-		function shouldMutate(path) {
-			return mutateDescription === true || isInsideMutateRanges(path);
-		}
-		function isInsideMutateRanges(path) {
-			return Option$1.exists(mutateRanges(), (ranges) => ranges.some((range) => locationIncluded(range, getNodeLocation(path.node))));
-		}
-		function getNodeLocation(node) {
-			const span = spanOf(node);
-			if (span === void 0) throw new Error("Node without a span");
-			return {
-				start: lineTable.positionAt(span.start),
-				end: lineTable.positionAt(span.end)
-			};
-		}
-		function mutablesFor(path) {
-			const ancestors = ancestorsOf(path);
-			const context = toMutatorContext(ancestors);
-			const location = Option$1.map(Option$1.fromNullishOr(spanOf(path.node)), (span) => ({
-				start: lineTable.positionAt(span.start),
-				end: lineTable.positionAt(span.end)
-			}));
-			const replacements = mutatorEntries.flatMap(([mutatorName, mutate]) => [...mutate(path.node, context)].map((replacement) => ({
-				mutatorName,
-				replacement
-			})));
-			const ignorerReason = replacements.length === 0 ? void 0 : Option$1.getOrUndefined(ignorersReason(path.node, ancestors));
-			return replacements.map(({ mutatorName, replacement }) => ({
-				node: path.node,
-				replacement,
-				data: {
-					mutatorName,
-					replacementCode: printNode(replacement),
-					location: Option$1.getOrUndefined(location),
-					ignorerReason
-				}
-			}));
-		}
-		function ignorersReason(node, ancestors) {
-			return options.ignorers.reduce((reason, ignorer) => Option$1.orElse(reason, () => Option$1.fromNullishOr(ignorer.shouldIgnore(node, ancestors))), Option$1.none());
-		}
+		});
+	} });
+	return failure;
+};
+const applyPlan = (root, plan, context) => {
+	const places = new Map(plan.placements.map((placement) => [placement.node, placement]));
+	return Option$1.match(Option$1.fromNullishOr(applyPlacementsToAst(root, places, context)), {
+		onNone: () => Effect$1.void,
+		onSome: (error) => Effect$1.fail(InstrumentError.make({
+			message: error.message,
+			cause: error
+		}))
 	});
 };
+const refusalError = (refusal) => Match.value(refusal).pipe(Match.tag("NodeWithoutSpan", () => InstrumentError.make({
+	message: "Node without a span",
+	cause: void 0
+})), Match.tag("MutantsUnplaced", (unplaced) => InstrumentError.make({
+	message: `Mutants cannot be placed. This shouldn't happen! Unplaced mutants: ${unplaced.detail}`,
+	cause: void 0
+})), Match.tag("PlacementRefused", (refused) => InstrumentError.make({
+	message: refused.message,
+	cause: new Error(refused.message)
+})), Match.tag("MutantWithoutLocation", (failed) => InstrumentError.make({
+	message: `Mutant without a source location: ${failed.mutatorName} in ${failed.fileName}`,
+	cause: void 0
+})), Match.exhaustive);
+const transformScriptDataFirst = Effect$1.fn("stryker.instrument.transform.script")(function* ({ root, originFileName, rawContent, offset, comments }, mutantCollector, { options, mutateDescription, basePath }) {
+	const lineStarts = lineStartsOf(rawContent);
+	attachComments(make(root), comments, lineStarts);
+	const selection = selectMutators(DEFAULT_MUTATOR_REGISTRY, options.optInMutations);
+	const context = {
+		fileName: originFileName,
+		lineStarts,
+		mutateDescription,
+		offset: offset ?? MUTATION_OFFSET,
+		basePath,
+		mutatorEntries: selection.active,
+		allMutatorNames: selection.known.map((name) => name.toLowerCase()),
+		excludedMutations: options.excludedMutations,
+		ignorers: options.ignorers
+	};
+	const planned = yield* Effect$1.try({
+		try: () => planInstrumentation(root, mutantCollector.nextIndex, context),
+		catch: traversalFailure
+	});
+	const plan = yield* Match.value(planned).pipe(Match.when(Result.isFailure, (refused) => {
+		const error = refusalError(refused.failure);
+		return Effect$1.fail(error);
+	}), Match.orElse((succeeded) => Effect$1.succeed(succeeded.success)));
+	mutantCollector.append(plan.mutants);
+	yield* applyPlan(root, plan, context);
+	yield* placeHeaderIfNeeded(plan.hasLiveMutants, options, root);
+	return plan.warnings;
+});
 const transformScript = dual((args) => args.length >= 3, transformScriptDataFirst);
 function toMutatorContext(ancestors) {
 	return {
@@ -6707,10 +6714,7 @@ function toMutatorContext(ancestors) {
 		ancestors: [...ancestors]
 	};
 }
-function toError(value) {
-	if (value instanceof Error) return value;
-	return new Error("Unexpected error", { cause: value });
-}
+const toError = (value) => value instanceof Error ? value : new Error("Unexpected error", { cause: value });
 const tsDirectiveLikeRegEx = /@(ts-[a-z-]+)/;
 const commentDirectiveRegEx = /^(\s*)@(ts-[a-z-]+).*$/;
 const STARTING_COMMENT = /^\s*\/\*[\s\S]*?\*\//;
@@ -6718,18 +6722,15 @@ function disableTypeCheckingInScript(ast) {
 	return prefixWithNoCheck(removeTSDirectives(ast.rawContent, ast.comments));
 }
 function prefixWithNoCheck(code) {
-	if (code.startsWith("#")) return afterHashbang(code);
-	return afterLeadingComment(code);
+	return code.startsWith("#") ? afterHashbang(code) : afterLeadingComment(code);
 }
 function afterHashbang(code) {
 	const newLineIndex = code.indexOf("\n");
-	if (newLineIndex <= 0) return code;
-	return `${code.substring(0, newLineIndex)}\n// @ts-nocheck\n${code.substring(newLineIndex + 1)}`;
+	return newLineIndex <= 0 ? code : `${code.substring(0, newLineIndex)}\n// @ts-nocheck\n${code.substring(newLineIndex + 1)}`;
 }
 function afterLeadingComment(code) {
 	const leadingComment = leadingCommentOf(code);
-	if (leadingComment === void 0) return `// @ts-nocheck\n${code}`;
-	return `${leadingComment.concat("\n")}// @ts-nocheck\n${code.substring(leadingComment.length)}`;
+	return leadingComment === void 0 ? `// @ts-nocheck\n${code}` : `${leadingComment.concat("\n")}// @ts-nocheck\n${code.substring(leadingComment.length)}`;
 }
 function leadingCommentOf(code) {
 	return STARTING_COMMENT.exec(code)?.[0];
@@ -6751,29 +6752,24 @@ function removeRanges(text, ranges) {
 	return remaining.pruned + text.substring(remaining.cursor);
 }
 function tryParseTSDirective(comment) {
-	const match = commentDirectiveRegEx.exec(comment.value);
-	if (match === null) return void 0;
-	const directivePrefix = requirePart(match[1], "TS directive match without prefix");
-	const directiveName = requirePart(match[2], "TS directive match without directive name");
-	const startPos = comment.start + directivePrefix.length + 2;
+	return Option$1.match(Option$1.fromNullishOr(commentDirectiveRegEx.exec(comment.value)), {
+		onNone: () => void 0,
+		onSome: (match) => directiveRangeAt(comment.start, lengthOf(match[1]), lengthOf(match[2]))
+	});
+}
+const lengthOf = (text) => Option$1.getOrElse(Option$1.map(Option$1.fromNullishOr(text), (value) => value.length), () => 0);
+const directiveRangeAt = (commentStart, prefixLength, nameLength) => {
+	const startPos = commentStart + prefixLength + 2;
 	return {
 		startPos,
-		endPos: startPos + directiveName.length + 1
+		endPos: startPos + nameLength + 1
 	};
-}
-function requirePart(part, message) {
-	if (part === void 0) throw new Error(message);
-	return part;
-}
-const requireScriptAst = (ast) => {
-	if (ast.format === "embedded") return rejectAst(ast, "a script");
-	return ast;
 };
-const requireJsAst = (ast) => ast.format === "js" ? ast : rejectAst(ast, "a js script");
-const requireTsFamilyAst = (ast) => Match.value(ast).pipe(Match.when({ format: "ts" }, (ts) => ts), Match.when({ format: "tsx" }, (tsx) => tsx), Match.orElse((other) => rejectAst(other, "a ts script")));
-function rejectAst(ast, expected) {
-	throw new Error(`Expected ${expected} AST, received the "${ast.format}" format`);
-}
+const scriptAstError = (ast) => InstrumentError.make({
+	message: `Expected a script AST, received the "${ast.format}" format`,
+	cause: void 0
+});
+const scriptAstOf = (ast) => Match.value(ast).pipe(Match.when({ format: "embedded" }, () => Option$1.none()), Match.orElse((script) => Option$1.some(script)));
 const extensionOf = (fileName) => {
 	const dot = fileName.lastIndexOf(".");
 	return dot > Math.max(fileName.lastIndexOf("/"), fileName.lastIndexOf("\\")) ? fileName.slice(dot).toLowerCase() : "";
@@ -6805,12 +6801,19 @@ const resolutionCommandOfDataFirst = (registry, fileName, formatIdOverride) => F
 const resolutionCommandOf = dual((args) => typeof args[0] !== "string", resolutionCommandOfDataFirst);
 const scriptHooks = (scriptFormat) => ({
 	parse: (text, fileName, _context) => parseScriptFormat(scriptFormat, text, fileName),
-	transform: (ast, mutantCollector, context) => transformScript(requireScriptAst(ast), mutantCollector, context),
+	transform: (ast, mutantCollector, context) => Option$1.match(scriptAstOf(ast), {
+		onNone: () => Effect$1.fail(scriptAstError(ast)),
+		onSome: (script) => transformScript(script, mutantCollector, context)
+	}),
 	print: (ast, context) => printScriptAst(ast, context),
-	disableTypeChecks: (ast) => Effect$1.succeed(disableTypeCheckingInScript(requireScriptAst(ast)))
+	disableTypeChecks: (ast) => Option$1.match(scriptAstOf(ast), {
+		onNone: () => Effect$1.fail(scriptAstError(ast)),
+		onSome: (script) => Effect$1.succeed(disableTypeCheckingInScript(script))
+	})
 });
 const parseScriptFormat = (scriptFormat, text, fileName) => Match.value(scriptFormat).pipe(Match.when("js", () => parseJS(text, fileName)), Match.when("ts", () => parseTS(text, fileName)), Match.when("tsx", () => parseTsx(text, fileName)), Match.exhaustive);
-const printScriptAst = (ast, context) => ast.format === "js" ? jsPrint(requireJsAst(ast), context) : tsPrint(requireTsFamilyAst(ast), context);
+const printScriptAst = (ast, context) => Match.value(ast).pipe(Match.when({ format: "js" }, (js) => jsPrint(js, context)), Match.when({ format: "ts" }, (ts) => tsPrint(ts, context)), Match.when({ format: "tsx" }, (tsx) => tsPrint(tsx, context)), Match.orElse(printNothingForEmbeddedAst));
+const printNothingForEmbeddedAst = () => "";
 const coreFormatRegistry = formatRegistry([
 	{
 		claim: {
@@ -6928,19 +6931,8 @@ const spliceForAssigned = (request) => Option$1.match(request.registry.entryForF
 	onNone: () => Effect$1.succeed(request.file),
 	onSome: (entry) => spliceFileFor(request.file, entry)
 });
-const toOneBasedOrigin = (origin) => ({
-	line: origin.line + 1,
-	column: origin.column
-});
 const EMBEDDED_SCRIPT_FILE = "embedded-script.js";
-const loadFrameworkToolkit = Effect$1.gen(function* () {
-	const oxc = yield* loadOxc;
-	return {
-		parseScript: (source, scriptFormat) => parseScriptProgram(oxc, source, scriptFormat),
-		header: yield* instrumentationHeader
-	};
-});
-const parseScriptProgram = (oxc, source, scriptFormat) => {
+const makeScriptParser = (oxc) => (source, scriptFormat) => {
 	const result = oxc.parseSync(EMBEDDED_SCRIPT_FILE, source, {
 		lang: scriptFormat,
 		range: true
@@ -6950,19 +6942,27 @@ const parseScriptProgram = (oxc, source, scriptFormat) => {
 		fileName: EMBEDDED_SCRIPT_FILE,
 		message: first.message,
 		location: {
-			line: 0,
-			column: 0
+			line: 1,
+			column: 1
 		},
 		cause: first
 	});
 	return result.program;
 };
+const loadFrameworkToolkit = Effect$1.gen(function* () {
+	const oxc = yield* loadOxc;
+	const header = yield* instrumentationHeader;
+	return {
+		parseScript: makeScriptParser(oxc),
+		header
+	};
+});
 const frameworkContextOf = (toolkit) => ({
 	parseScript: toolkit.parseScript,
 	printScript: (script) => printProgram(script, { hashbang: null }),
 	instrumentationHeader: () => toolkit.header
 });
-const embeddedScriptsOf = (document, rawContent, originFileName, lineTable) => document.regions.flatMap((region, index) => {
+const embeddedScriptsOf = (document, rawContent, originFileName, lineStarts) => document.regions.flatMap((region, index) => {
 	return [{
 		region: index,
 		ast: {
@@ -6971,14 +6971,16 @@ const embeddedScriptsOf = (document, rawContent, originFileName, lineTable) => d
 			comments: [],
 			rawContent: rawContent.slice(region.start, region.end),
 			originFileName,
-			offset: toOneBasedOrigin(lineTable.zeroBasedPositionAt(region.start))
+			offset: originAt(lineStarts, region.start)
 		}
 	}];
 });
-const embeddedOf = (ast) => {
-	if (ast.format !== "embedded") throw new Error(`Expected an embedded document AST, received the "${ast.format}" format`);
-	return ast;
-};
+const embeddedAstError = (ast) => InstrumentError.make({
+	message: `Expected an embedded document AST, received the "${ast.format}" format`,
+	cause: void 0
+});
+const embeddedOf = (ast) => Match.value(ast).pipe(Match.when({ format: "embedded" }, (embedded) => Option$1.some(embedded)), Match.orElse(() => Option$1.none()));
+const printNothingForNonEmbeddedAst = () => "";
 const frameworkFailure = (moduleName, fileName, detail) => InstrumentError.make({
 	message: `The framework "${moduleName}" could not parse ${fileName}: ${detail}`,
 	cause: new Error(detail)
@@ -6987,7 +6989,7 @@ const hookFailure = (moduleName, hook, fileName, cause) => InstrumentError.make(
 	message: `The framework "${moduleName}" threw while running ${hook} for ${fileName}: ${errorTextOf(cause)}`,
 	cause
 });
-const errorTextOf = (cause) => Option$1.getOrElse(Option$1.map(ErrorText.fromCause(cause), (text) => text.text), () => "");
+const errorTextOf = (cause) => Option$1.getOrElse(Option$1.map(errorTextOf$2(cause), (rendered) => rendered.text), () => "");
 const runHook = (moduleName, hook, fileName, run) => Effect$1.try({
 	try: run,
 	catch: (cause) => hookFailure(moduleName, hook, fileName, cause)
@@ -7002,9 +7004,9 @@ const frameworkEntryOfDataFirst = (moduleName, framework) => ({
 	},
 	owner: moduleName,
 	ownerVersion: framework.claim.ownerVersion,
-	parse: (text, fileName) => Effect$1.gen(function* () {
+	parse: Effect$1.fn("stryker.instrument.framework_entry.parse")(function* (text, fileName) {
 		const context = frameworkContextOf(yield* loadFrameworkToolkit);
-		const lineTable = yield* Effect$1.orDie(S.decodeEffect(LineTableFromText)(text));
+		const lineStarts = lineStartsOf(text);
 		const result = yield* runHook(moduleName, "parse", fileName, () => framework.parse(text, context));
 		const document = yield* settled(moduleName, fileName, result);
 		return {
@@ -7014,26 +7016,28 @@ const frameworkEntryOfDataFirst = (moduleName, framework) => ({
 			rawContent: text,
 			document,
 			context,
-			scripts: embeddedScriptsOf(document, text, fileName, lineTable)
+			scripts: embeddedScriptsOf(document, text, fileName, lineStarts)
 		};
 	}),
-	transform: (ast, mutantCollector, context) => Effect$1.gen(function* () {
-		const embedded = embeddedOf(ast);
-		const warnings = yield* Effect$1.forEach(embedded.scripts, (script) => context.transform(script.ast, mutantCollector, context));
-		embedded.document = yield* runHook(moduleName, "transform", embedded.originFileName, () => framework.transform(embedded.document, embedded.context));
-		return warnings.flat();
+	transform: (ast, mutantCollector, context) => Option$1.match(embeddedOf(ast), {
+		onNone: () => Effect$1.fail(embeddedAstError(ast)),
+		onSome: Effect$1.fn("stryker.instrument.framework_entry.transform")(function* (embedded) {
+			const warnings = yield* Effect$1.forEach(embedded.scripts, (script) => context.transform(script.ast, mutantCollector, context));
+			embedded.document = yield* runHook(moduleName, "transform", embedded.originFileName, () => framework.transform(embedded.document, embedded.context));
+			return warnings.flat();
+		})
 	}),
-	print: (ast) => {
-		const embedded = embeddedOf(ast);
-		return framework.print(embedded.document, embedded.context);
-	},
-	disableTypeChecks: (ast) => {
-		const embedded = embeddedOf(ast);
-		return runHook(moduleName, "disableTypeChecks", embedded.originFileName, () => framework.disableTypeChecks(embedded.rawContent)).pipe(Effect$1.flatMap((result) => settled(moduleName, embedded.originFileName, result)));
-	}
+	print: (ast) => Option$1.match(embeddedOf(ast), {
+		onNone: printNothingForNonEmbeddedAst,
+		onSome: (embedded) => framework.print(embedded.document, embedded.context)
+	}),
+	disableTypeChecks: (ast) => Option$1.match(embeddedOf(ast), {
+		onNone: () => Effect$1.fail(embeddedAstError(ast)),
+		onSome: (embedded) => runHook(moduleName, "disableTypeChecks", embedded.originFileName, () => framework.disableTypeChecks(embedded.rawContent)).pipe(Effect$1.flatMap((result) => settled(moduleName, embedded.originFileName, result)))
+	})
 });
 const frameworkEntryOf = dual((args) => args.length >= 2, frameworkEntryOfDataFirst);
-var Format_exports = /* @__PURE__ */ __exportAll({
+var Format_exports = /* @__PURE__ */ __exportAll$1({
 	coreFormatRegistry: () => coreFormatRegistry,
 	extensionOf: () => extensionOf,
 	frameworkEntryOf: () => frameworkEntryOf,
@@ -7085,22 +7089,26 @@ const admitInstrumentFiles = Workflow.make({
 		skipped: command.skipped
 	}))), Match.exhaustive)
 });
-const printedFile = (raw, { file, ast }) => ({
+const printedFile = (raw, { file, ast }) => Result.map(print(ast, raw.registry.entryForFormat), (content) => ({
 	name: file.name,
 	mutate: file.mutate,
-	content: print(ast, raw.registry.entryForFormat)
-});
-const instrumentedResult = (raw) => InstrumentResult.make({
-	files: raw.parsed.map((parsed) => printedFile(raw, parsed)),
+	content
+}));
+const printedFiles = (raw) => Effect$1.forEach(raw.parsed, (parsed) => Effect$1.fromResult(printedFile(raw, parsed)), { concurrency: 1 }).pipe(Effect$1.mapError((failure) => InstrumentError.make({
+	message: failure.message,
+	cause: failure
+})));
+const instrumentedResult = (raw) => Effect$1.map(printedFiles(raw), (files) => InstrumentResult.make({
+	files: [...files],
 	mutants: [...raw.mutants],
 	skipped: [...raw.skipped]
-});
+}));
 const skippedOnlyResult = (raw) => InstrumentResult.make({
 	files: [],
 	mutants: [],
 	skipped: [...raw.skipped]
 });
-const readInstrumentFiles = (input) => Effect$1.gen(function* () {
+const readInstrumentFiles = Effect$1.fn("stryker.instrument.read_files")(function* (input) {
 	const outcomes = yield* Effect$1.forEach(input.files, (file) => fileOutcome({
 		registry: input.registry,
 		file
@@ -7129,7 +7137,7 @@ const readInstrumentFiles = (input) => Effect$1.gen(function* () {
 	};
 });
 const instrumentFilesCell = Sandwich.named("stryker.instrument.files")((input) => readInstrumentFiles(input)).decide(admitInstrumentFiles).write({
-	InstrumentFilesAdmitted: (_admitted, raw) => Effect$1.succeed(instrumentedResult(raw)),
+	InstrumentFilesAdmitted: (_admitted, raw) => instrumentedResult(raw),
 	InstrumentFilesSkippedOnly: (_skipped, raw) => Effect$1.succeed(skippedOnlyResult(raw)),
 	CommandRejected: ({ issue }) => Effect$1.fail(InstrumentError.make({
 		message: issue,
@@ -7137,7 +7145,7 @@ const instrumentFilesCell = Sandwich.named("stryker.instrument.files")((input) =
 	}))
 });
 const toSchemaFile = (file) => ({
-	name: file.name,
+	name: CanonicalFileName.make(file.name),
 	content: file.content,
 	mutate: file.mutate
 });
@@ -7172,15 +7180,20 @@ const disableTypeChecksDataFirst = (file, registry = coreFormatRegistry) => disa
 	cause
 })));
 const disableTypeChecks = dual((args) => Predicate$1.hasProperty(args[0], "content"), disableTypeChecksDataFirst);
-var Instrument_exports = /* @__PURE__ */ __exportAll({
+var Instrument_exports = /* @__PURE__ */ __exportAll$1({
 	InstrumentFileSkip: () => InstrumentFileSkip,
 	disableTypeChecks: () => disableTypeChecks,
 	instrument: () => instrument
 });
-var Mutant_exports = /* @__PURE__ */ __exportAll({
+var Mutant_exports = /* @__PURE__ */ __exportAll$1({
+	ActionableStatusSchema: () => ActionableStatusSchema,
 	CanonicalFileName: () => CanonicalFileName,
+	Column: () => Column,
+	EphemeralStatusSchema: () => EphemeralStatusSchema,
+	HitCount: () => HitCount,
 	InstrumenterContext: () => InstrumenterContext,
-	LocationSchema: () => LocationSchema$1,
+	Line: () => Line,
+	Location: () => Location,
 	Mutant: () => Mutant,
 	MutantActivationSchema: () => MutantActivationSchema,
 	MutantCoverageSchema: () => MutantCoverageSchema$1,
@@ -7189,32 +7202,48 @@ var Mutant_exports = /* @__PURE__ */ __exportAll({
 	MutantRunOptionsSchema: () => MutantRunOptionsSchema,
 	MutantStatusSchema: () => MutantStatusSchema,
 	MutatorName: () => MutatorName,
-	OpenEndLocationSchema: () => OpenEndLocationSchema,
-	PositionSchema: () => PositionSchema,
-	ReportLocationFromMutant: () => ReportLocationFromMutant,
-	RunOptionsFields: () => RunOptionsFields
+	Offset: () => Offset,
+	OpenEndLocation: () => OpenEndLocation,
+	Position: () => Position,
+	RememberedStatusSchema: () => RememberedStatusSchema,
+	RunOptionsFields: () => RunOptionsFields,
+	ScriptOrigin: () => ScriptOrigin,
+	Span: () => Span,
+	SurvivorStatusSchema: () => SurvivorStatusSchema
 });
 //#endregion
+//#region ../stryker-js-plugin-interface/dist/rolldown-runtime-D7D4PA-g.mjs
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
 //#region ../stryker-js-plugin-interface/dist/index.mjs
 const CheckerMutantWire = S.Struct({
 	id: Mutant_exports.MutantId,
 	fileName: Mutant_exports.CanonicalFileName,
 	mutatorName: Mutant_exports.MutatorName,
 	replacement: S.String,
-	location: Mutant_exports.LocationSchema
+	location: Mutant_exports.Location
 });
-const CheckStatus = S.Literals(["passed", "compileError"]);
 const CheckResultSchema = S.Union([S.Struct({ status: S.Literal("passed") }), S.Struct({
 	status: S.Literal("compileError"),
 	reason: S.String
-})]);
+})]).pipe(S.toTaggedUnion("status"));
+const CheckStatus = S.Literals(CheckResultSchema.discriminants);
 var CheckerFailed = class extends S.TaggedError()("CheckerFailed", {
 	cause: S.String,
 	checkerName: S.String,
-	mutantIds: S.Array(S.String)
+	mutantIds: S.Array(Mutant_exports.MutantId)
 }) {};
 var Checker = class extends Context.Service()("@systemfsoftware/stryker-js-plugin-interface/Checker.service/Checker") {};
-var Checker_exports = /* @__PURE__ */ __exportAll$1({
+var Checker_exports = /* @__PURE__ */ __exportAll({
 	CheckResultSchema: () => CheckResultSchema,
 	CheckStatus: () => CheckStatus,
 	Checker: () => Checker,
@@ -7237,7 +7266,8 @@ const MutationScore = S.TaggedUnion({
 	Scored: { percentage: Percentage },
 	Unscored: {}
 });
-var Metrics = class Metrics extends S.Class("Metrics")({
+const scorePercentageOf = (counts) => counts.counted > 0 ? Option$1.some(counts.detected / counts.counted * 100) : Option$1.none();
+var Metrics = class extends S.Class("Metrics")({
 	pending: NonNegativeInt,
 	killed: NonNegativeInt,
 	timeout: NonNegativeInt,
@@ -7266,35 +7296,209 @@ var Metrics = class Metrics extends S.Class("Metrics")({
 		return this.totalValid + this.totalInvalid + this.ignored + this.pending;
 	}
 	get mutationScore() {
-		return scoreOf(this.totalDetected, this.totalValid);
+		return Option$1.match(scorePercentageOf({
+			detected: this.totalDetected,
+			counted: this.totalValid
+		}), {
+			onNone: () => MutationScore.cases.Unscored.make({}),
+			onSome: (percentage) => MutationScore.cases.Scored.make({ percentage })
+		});
 	}
 	get mutationScoreBasedOnCoveredCode() {
-		return scoreOf(this.totalDetected, this.totalCovered);
-	}
-	static fromMutants(mutants) {
-		return Metrics.make({
-			pending: metricCountOf(mutants, "Pending"),
-			killed: metricCountOf(mutants, "Killed"),
-			timeout: metricCountOf(mutants, "Timeout"),
-			survived: metricCountOf(mutants, "Survived"),
-			noCoverage: metricCountOf(mutants, "NoCoverage"),
-			runtimeErrors: metricCountOf(mutants, "RuntimeError"),
-			compileErrors: metricCountOf(mutants, "CompileError"),
-			ignored: metricCountOf(mutants, "Ignored")
+		return Option$1.match(scorePercentageOf({
+			detected: this.totalDetected,
+			counted: this.totalCovered
+		}), {
+			onNone: () => MutationScore.cases.Unscored.make({}),
+			onSome: (percentage) => MutationScore.cases.Scored.make({ percentage })
 		});
 	}
 };
-const metricCountOf = (mutants, status) => mutants.filter((mutant) => mutant.status === status).length;
-const scoreOf = (detected, counted) => Boolean$1$1.match(counted > 0, {
-	onTrue: () => MutationScore.cases.Scored.make({ percentage: detected / counted * 100 }),
-	onFalse: () => MutationScore.cases.Unscored.make({})
-});
 const MetricsSchema = Metrics;
 const MetricsResultSchema = S.Struct({
 	name: S.String,
 	metrics: Metrics,
 	childResults: S.Array(S.suspend(() => MetricsResultSchema))
 }).annotate({ identifier: "MetricsResult" });
+const TestId = S.NonEmptyString.pipe(S.brand("TestId"));
+const DryRunStatus = S.Literals([
+	"complete",
+	"error",
+	"timeout"
+]);
+const TestStatus = S.Literals([
+	"success",
+	"failed",
+	"skipped"
+]);
+const MutantRunStatus = S.Literals([
+	"killed",
+	"survived",
+	"timeout",
+	"error"
+]);
+const TestResultBase = {
+	id: TestId,
+	name: S.String,
+	timeSpentMs: NonNegativeFinite,
+	fileName: S.optionalKey(S.String),
+	startPosition: S.optionalKey(Mutant_exports.Position)
+};
+const TestResultSchema = S.Union([
+	S.Struct({
+		...TestResultBase,
+		status: S.Literal("failed"),
+		failureMessage: S.String
+	}),
+	S.Struct({
+		...TestResultBase,
+		status: S.Literal("skipped")
+	}),
+	S.Struct({
+		...TestResultBase,
+		status: S.Literal("success")
+	})
+]);
+const MutantCoverageSchema = S.Struct({
+	perTest: S.Record(S.String, S.Record(Mutant_exports.MutantId, S.Finite)),
+	static: S.Record(Mutant_exports.MutantId, S.Finite)
+});
+const DryRunResultSchema = S.Union([
+	S.Struct({
+		status: S.Literal("complete"),
+		tests: S.Array(TestResultSchema),
+		mutantCoverage: S.optionalKey(MutantCoverageSchema)
+	}),
+	S.Struct({
+		status: S.Literal("timeout"),
+		reason: S.optionalKey(S.String)
+	}),
+	S.Struct({
+		status: S.Literal("error"),
+		errorMessage: S.String
+	})
+]);
+const MutantRunResultSchema = S.Union([
+	S.Struct({
+		status: S.Literal("killed"),
+		killedBy: S.Array(TestId),
+		failureMessage: S.String,
+		nrOfTests: NonNegativeInt
+	}),
+	S.Struct({
+		status: S.Literal("survived"),
+		nrOfTests: NonNegativeInt
+	}),
+	S.Struct({
+		status: S.Literal("timeout"),
+		reason: S.optionalKey(S.String)
+	}),
+	S.Struct({
+		status: S.Literal("error"),
+		errorMessage: S.String
+	})
+]);
+const CoverageAnalysisSchema = S.Literals([
+	"off",
+	"all",
+	"perTest"
+]);
+const DryRunOptionsSchema = S.Struct({
+	...Mutant_exports.RunOptionsFields,
+	coverageAnalysis: CoverageAnalysisSchema,
+	files: S.String.pipe(S.Array, S.optionalKey),
+	testFiles: S.String.pipe(S.Array, S.optionalKey)
+});
+const TestRunnerCapabilitiesSchema = S.Struct({ reloadEnvironment: S.Boolean });
+var TestRunnerFailed = class extends S.TaggedError()("TestRunnerFailed", {
+	cause: S.String,
+	phase: S.Literals([
+		"capabilities",
+		"dispose",
+		"dryRun",
+		"init",
+		"mutantRun"
+	]),
+	runnerName: S.String
+}) {};
+const MutantResultSchema = S.Struct({
+	id: Mutant_exports.MutantId,
+	mutatorName: S.String,
+	status: Mutant_exports.MutantStatusSchema,
+	location: Mutant_exports.Location,
+	replacement: S.optional(S.String),
+	description: S.optional(S.String),
+	statusReason: S.optional(S.String),
+	static: S.optional(S.Boolean),
+	coveredBy: S.Array(TestId).pipe(S.optional),
+	killedBy: S.Array(TestId).pipe(S.optional),
+	testsCompleted: S.optional(NonNegativeInt),
+	duration: S.optional(NonNegativeFinite)
+});
+const FileResultSchema = S.Struct({
+	language: S.String,
+	source: S.String,
+	mutants: S.Array(MutantResultSchema)
+});
+const FileResultDictionarySchema = S.Record(S.String, FileResultSchema);
+const TestDefinitionSchema = S.Struct({
+	id: TestId,
+	name: S.String,
+	location: S.optional(Mutant_exports.OpenEndLocation)
+});
+const TestFileSchema = S.Struct({
+	source: S.optional(S.String),
+	tests: S.Array(TestDefinitionSchema)
+});
+const TestFileDefinitionDictionarySchema = S.Record(S.String, TestFileSchema);
+const ThresholdsValuesSchema = S.Struct({
+	high: Percentage,
+	low: Percentage,
+	break: S.NullOr(Percentage)
+});
+const isOrderedThresholds = (value) => S.is(ThresholdsValuesSchema)(value) && value.low <= value.high;
+const OrderedThresholds = S.declare(isOrderedThresholds, {
+	message: "a mutation score threshold pair has low at or below high",
+	toCodecArbitrary: () => S.link()(ThresholdsValuesSchema, {
+		decode: SchemaGetter.transform(({ break: breaking, high, low }) => ({
+			break: breaking,
+			high: Math.max(high, low),
+			low: Math.min(high, low)
+		})),
+		encode: SchemaGetter.transform((thresholds) => thresholds)
+	})
+});
+const ThresholdsSchema = S.declare(isOrderedThresholds, {
+	message: "a mutation score threshold pair has low at or below high",
+	toCodecArbitrary: () => S.link()(ThresholdsValuesSchema, {
+		decode: SchemaGetter.transform(({ break: breaking, high, low }) => ({
+			break: breaking,
+			high: Math.max(high, low),
+			low: Math.min(low, high)
+		})),
+		encode: SchemaGetter.transform((thresholds) => thresholds)
+	})
+});
+const BrandingInformationSchema = S.Struct({
+	homepageUrl: S.String,
+	imageUrl: S.optional(S.String)
+});
+const DependenciesSchema = S.Record(S.String, S.String);
+const FrameworkInformationSchema = S.Struct({
+	name: S.String,
+	version: S.optional(S.String),
+	branding: S.optional(BrandingInformationSchema),
+	dependencies: S.optional(DependenciesSchema)
+});
+const MutationTestResultSchema = S.Struct({
+	schemaVersion: S.String,
+	files: FileResultDictionarySchema,
+	thresholds: ThresholdsSchema,
+	config: S.optional(S.Record(S.String, S.Unknown)),
+	testFiles: S.optional(TestFileDefinitionDictionarySchema),
+	projectRoot: S.optional(S.String),
+	framework: S.optional(FrameworkInformationSchema)
+});
 const StrykerCoverageAnalysis = S.Literal("perTest");
 const StrykerFileLogLevel = S.Literal("off");
 const StrykerLogLevel = S.Literal("info");
@@ -7367,7 +7571,7 @@ const ClearTextReporterOptions = openStruct({
 	allowColor: defaulted(S.Boolean, true),
 	allowEmojis: defaulted(S.Boolean, false),
 	logTests: defaulted(S.Boolean, true),
-	maxTestsToLog: defaulted(S.Finite.pipe(S.check(S.isGreaterThanOrEqualTo(0))), 3),
+	maxTestsToLog: defaulted(NonNegativeInt, 3),
 	reportTests: defaulted(S.Boolean, true),
 	reportMutants: defaulted(S.Boolean, true),
 	reportScoreTable: defaulted(S.Boolean, true),
@@ -7375,32 +7579,11 @@ const ClearTextReporterOptions = openStruct({
 });
 const HtmlReporterOptions = S.Struct({ fileName: defaulted(S.String, "reports/mutation/mutation.html") });
 const JsonReporterOptions = S.Struct({ fileName: defaulted(S.String, "reports/mutation/mutation.json") });
-const MutationScoreThresholdsValuesSchema = S.Struct({
+const MutationScoreThresholdsSchema = S.Struct({
 	high: defaulted(Percentage, 80),
 	low: defaulted(Percentage, 60),
 	break: defaulted(S.NullOr(Percentage), null)
-});
-const isMutationScoreThresholds = (value) => S.is(MutationScoreThresholdsValuesSchema)(value) && value.low <= value.high;
-/**
-* The pair is *built* ordered — a drawn pair is sorted — rather than drawn at
-* random and discarded until it happens to be ordered. The invariant lives on
-* the declaration because a filter over the pair cannot express `low <= high`
-* in the generation-constraint vocabulary, and only a declaration carries a
-* `toCodecArbitrary` derivation. The struct stays the wire side, so decoding
-* keeps member defaults and field paths.
-*/
-const OrderedMutationScoreThresholds = S.declare(isMutationScoreThresholds, {
-	message: "expected thresholds where low <= high",
-	toCodecArbitrary: () => S.link()(MutationScoreThresholdsValuesSchema, {
-		decode: SchemaGetter.transform(({ break: breaking, high, low }) => ({
-			high: Math.max(high, low),
-			low: Math.min(high, low),
-			break: breaking
-		})),
-		encode: SchemaGetter.transform((thresholds) => thresholds)
-	})
-});
-const MutationScoreThresholdsSchema = MutationScoreThresholdsValuesSchema.pipe(S.decodeTo(OrderedMutationScoreThresholds, SchemaTransformation.passthrough()));
+}).pipe(S.decodeTo(OrderedThresholds, SchemaTransformation.passthrough()));
 const MutatorDescriptor = S.Struct({
 	excludedMutations: defaulted(S.Array(S.String), []),
 	optInMutations: defaulted(S.Array(S.String), [])
@@ -7411,7 +7594,7 @@ const WarningOptions = openStruct({
 	unserializableOptions: defaulted(S.Boolean, true),
 	slow: defaulted(S.Boolean, true)
 });
-const ConcurrencyCount = S.Finite.pipe(S.check(S.isGreaterThanOrEqualTo(1)));
+const ConcurrencyCount = S.Int.pipe(S.check(S.isGreaterThanOrEqualTo(1)));
 const ConcurrencyPercent = S.String.pipe(S.check(S.isPattern(/^(100|[1-9]?[0-9])%$/)));
 const pluginSpecifierArbitrary = S.link()(S.Literals([
 	"file:///project/node_modules/@systemfsoftware/stryker-js-angular/index.mjs",
@@ -7469,8 +7652,8 @@ const StrykerOptionsSchema = S.StructWithRest(S.Struct({
 	fileLogLevel: defaulted(LogLevel, StrykerFileLogLevel.literal),
 	inPlace: defaulted(S.Boolean, false),
 	logLevel: defaulted(LogLevel, StrykerLogLevel.literal),
-	maxConcurrentTestRunners: defaulted(S.Finite, 9007199254740991),
-	maxTestRunnerReuse: defaulted(S.Finite, 0),
+	maxConcurrentTestRunners: defaulted(S.Int.pipe(S.check(S.isGreaterThanOrEqualTo(1))), Number.MAX_SAFE_INTEGER),
+	maxTestRunnerReuse: defaulted(NonNegativeInt, 0),
 	mutate: defaulted(S.Array(S.String), ["{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: [],
@@ -7501,9 +7684,9 @@ const StrykerOptionsSchema = S.StructWithRest(S.Struct({
 		low: 60,
 		break: null
 	}),
-	timeoutFactor: defaulted(S.Finite, 1.5),
-	timeoutMS: defaulted(S.Finite, 5e3),
-	dryRunTimeoutMinutes: defaulted(S.Finite.pipe(S.check(S.isGreaterThanOrEqualTo(0))), 5),
+	timeoutFactor: defaulted(NonNegativeFinite, 1.5),
+	timeoutMS: defaulted(NonNegativeInt, 5e3),
+	dryRunTimeoutMinutes: defaulted(NonNegativeFinite, 5),
 	tsconfigFile: defaulted(S.String, "tsconfig.json"),
 	warnings: defaulted(S.Union([S.Boolean, WarningOptions]), true),
 	disableBail: defaulted(S.Boolean, false),
@@ -7511,7 +7694,7 @@ const StrykerOptionsSchema = S.StructWithRest(S.Struct({
 	ignorers: defaulted(S.Array(PluginFileUrl), []),
 	testFiles: defaulted(S.Array(S.String), [])
 }), [S.Record(S.String, S.Unknown)]);
-var Options_exports = /* @__PURE__ */ __exportAll$1({
+var Options_exports = /* @__PURE__ */ __exportAll({
 	CheckerCustomConfigSchema: () => CheckerCustomConfigSchema,
 	CheckerEntryConfigSchema: () => CheckerEntryConfigSchema,
 	CommandRunnerOptionsSchema: () => CommandRunnerOptionsSchema,
@@ -7530,6 +7713,10 @@ var Options_exports = /* @__PURE__ */ __exportAll$1({
 	TestRunnerCustomConfigSchema: () => TestRunnerCustomConfigSchema,
 	isCustomTestRunner: () => isCustomTestRunner
 });
+const ExitCode = S.Int.pipe(S.check(S.isBetween({
+	minimum: 0,
+	maximum: 255
+})));
 const ExitClass = S.Literals([
 	"VerdictFail",
 	"ConfigError",
@@ -7560,193 +7747,13 @@ const ExitCodeFromClass = S.decodeTo(BaselineExitCode, SchemaTransformation.tran
 	decode: codeOfClass,
 	encode: classOfCode
 }))(ExitClass);
-const MutantResultSchema = S.Struct({
-	id: S.String,
-	mutatorName: S.String,
-	status: Mutant_exports.MutantStatusSchema,
-	location: Mutant_exports.LocationSchema,
-	replacement: S.optional(S.String),
-	description: S.optional(S.String),
-	statusReason: S.optional(S.String),
-	static: S.optional(S.Boolean),
-	coveredBy: S.String.pipe(S.Array, S.optional),
-	killedBy: S.String.pipe(S.Array, S.optional),
-	testsCompleted: S.optional(NonNegativeInt),
-	duration: S.optional(NonNegativeFinite)
-});
-const FileResultSchema = S.Struct({
-	language: S.String,
-	source: S.String,
-	mutants: S.Array(MutantResultSchema)
-});
-const FileResultDictionarySchema = S.Record(S.String, FileResultSchema);
-const TestDefinitionSchema = S.Struct({
-	id: S.String,
-	name: S.String,
-	location: S.optional(Mutant_exports.OpenEndLocationSchema)
-});
-const TestFileSchema = S.Struct({
-	source: S.optional(S.String),
-	tests: S.Array(TestDefinitionSchema)
-});
-const TestFileDefinitionDictionarySchema = S.Record(S.String, TestFileSchema);
-const ThresholdsValuesSchema = S.Struct({
-	high: Percentage,
-	low: Percentage
-});
-const isThresholds = (value) => S.is(ThresholdsValuesSchema)(value) && value.low <= value.high;
-/**
-* The pair is *built* ordered — a drawn pair is sorted — rather than drawn at
-* random and discarded until it happens to be ordered. The invariant lives on
-* the declaration because a filter over the pair cannot express `low <= high`
-* in the generation-constraint vocabulary, and only a declaration carries a
-* `toCodecArbitrary` derivation. `ThresholdsValuesSchema` stays the wire side, so
-* decoding keeps its field paths.
-*/
-const OrderedThresholds = S.declare(isThresholds, {
-	message: "expected thresholds where low <= high",
-	toCodecArbitrary: () => S.link()(ThresholdsValuesSchema, {
-		decode: SchemaGetter.transform(({ high, low }) => ({
-			high: Math.max(high, low),
-			low: Math.min(high, low)
-		})),
-		encode: SchemaGetter.transform((thresholds) => thresholds)
-	})
-});
-const ThresholdsSchema = ThresholdsValuesSchema.pipe(S.decodeTo(OrderedThresholds, SchemaTransformation.passthrough()));
-const BrandingInformationSchema = S.Struct({
-	homepageUrl: S.String,
-	imageUrl: S.optional(S.String)
-});
-const DependenciesSchema = S.Record(S.String, S.String);
-const FrameworkInformationSchema = S.Struct({
-	name: S.String,
-	version: S.optional(S.String),
-	branding: S.optional(BrandingInformationSchema),
-	dependencies: S.optional(DependenciesSchema)
-});
-const MutationTestResultSchema = S.Struct({
-	schemaVersion: S.String,
-	files: FileResultDictionarySchema,
-	thresholds: ThresholdsSchema,
-	config: S.optional(S.Record(S.String, S.Unknown)),
-	testFiles: S.optional(TestFileDefinitionDictionarySchema),
-	projectRoot: S.optional(S.String),
-	framework: S.optional(FrameworkInformationSchema)
-});
-const DryRunStatus = S.Literals([
-	"complete",
-	"error",
-	"timeout"
-]);
-const TestStatus = S.Literals([
-	"success",
-	"failed",
-	"skipped"
-]);
-const MutantRunStatus = S.Literals([
-	"killed",
-	"survived",
-	"timeout",
-	"error"
-]);
-const TestResultBase = {
-	id: S.String,
-	name: S.String,
-	timeSpentMs: S.Finite,
-	fileName: S.optionalKey(S.String),
-	startPosition: S.optionalKey(Mutant_exports.PositionSchema)
-};
-const TestResultSchema = S.Union([
-	S.Struct({
-		...TestResultBase,
-		status: S.Literal("failed"),
-		failureMessage: S.String
-	}),
-	S.Struct({
-		...TestResultBase,
-		status: S.Literal("skipped")
-	}),
-	S.Struct({
-		...TestResultBase,
-		status: S.Literal("success")
-	})
-]);
-const MutantCoverageSchema = S.Struct({
-	perTest: S.Record(S.String, S.Record(S.String, S.Finite)),
-	static: S.Record(S.String, S.Finite)
-});
-const DryRunResultSchema = S.Union([
-	S.Struct({
-		status: S.Literal("complete"),
-		tests: S.Array(TestResultSchema),
-		mutantCoverage: S.optionalKey(MutantCoverageSchema)
-	}),
-	S.Struct({
-		status: S.Literal("timeout"),
-		reason: S.optionalKey(S.String)
-	}),
-	S.Struct({
-		status: S.Literal("error"),
-		errorMessage: S.String
-	})
-]);
-const MutantRunResultSchema = S.Union([
-	S.Struct({
-		status: S.Literal("killed"),
-		killedBy: S.Array(S.String),
-		failureMessage: S.String,
-		nrOfTests: S.Finite
-	}),
-	S.Struct({
-		status: S.Literal("survived"),
-		nrOfTests: S.Finite
-	}),
-	S.Struct({
-		status: S.Literal("timeout"),
-		reason: S.optionalKey(S.String)
-	}),
-	S.Struct({
-		status: S.Literal("error"),
-		errorMessage: S.String
-	})
-]);
-const CoverageAnalysisSchema = S.Literals([
-	"off",
-	"all",
-	"perTest"
-]);
-const DryRunOptionsSchema = S.Struct({
-	...Mutant_exports.RunOptionsFields,
-	coverageAnalysis: CoverageAnalysisSchema,
-	files: S.String.pipe(S.Array, S.optionalKey),
-	testFiles: S.String.pipe(S.Array, S.optionalKey)
-});
-const TestRunnerCapabilitiesSchema = S.Struct({ reloadEnvironment: S.Boolean });
-var TestRunnerFailed = class extends S.TaggedError()("TestRunnerFailed", {
-	cause: S.String,
-	phase: S.Literals([
-		"capabilities",
-		"dispose",
-		"dryRun",
-		"init",
-		"mutantRun"
-	]),
-	runnerName: S.String
-}) {};
-const ReporterEventKind = S.Literals([
-	"dryRunCompleted",
-	"mutationTestingPlanReady",
-	"mutantTested",
-	"mutationTestReportReady"
-]);
 const RunTimingSchema = S.Struct({
 	net: NonNegativeFinite,
 	overhead: NonNegativeFinite
 });
 const ReporterPlanKind = S.Literals(["EarlyResult", "Run"]);
 const ReporterPlanDescriptorSchema = S.Struct({
-	mutantId: S.String,
+	mutantId: Mutant_exports.MutantId,
 	plan: ReporterPlanKind,
 	netTime: NonNegativeFinite,
 	reloadEnvironment: S.Boolean
@@ -7762,11 +7769,11 @@ var MutationTestingPlanReady = class extends S.TaggedClass()("mutationTestingPla
 	plans: S.Array(ReporterPlanDescriptorSchema)
 }) {};
 var MutantTested = class extends S.TaggedClass()("mutantTested", {
-	id: S.String,
+	id: Mutant_exports.MutantId,
 	status: Mutant_exports.MutantStatusSchema,
-	file: S.String,
-	location: Mutant_exports.LocationSchema,
-	mutator: S.String,
+	fileName: Mutant_exports.CanonicalFileName,
+	location: Mutant_exports.Location,
+	mutatorName: Mutant_exports.MutatorName,
 	replacement: S.NullOr(S.String),
 	completed: NonNegativeInt,
 	total: NonNegativeInt
@@ -7780,18 +7787,91 @@ const ReporterEventUnion = S.Union([
 	MutationTestingPlanReady,
 	MutantTested,
 	MutationTestReportReady
-]);
+]).pipe(S.toTaggedUnion("_tag"));
+const ReporterEventKind = S.Literals(ReporterEventUnion.discriminants);
 const ReporterEventSchema = S.toStandardSchemaV1(ReporterEventUnion);
 var ReporterFailed = class extends S.TaggedError()("ReporterFailed", {
 	cause: S.String,
 	event: ReporterEventKind,
 	reporterName: S.String
 }) {};
+const TraceparentHeader = S.Literal("traceparent");
+const TracestateHeader = S.Literal("tracestate");
+const VERSION = S.String.pipe(S.check(S.isPattern(/^([0-9a-e][0-9a-f]|[0-9a-f][0-9a-e])$/)));
+const TRACE_ID = S.String.pipe(S.check(S.isPattern(/^[0-9a-f]*[1-9a-f][0-9a-f]*$/)), S.check(S.isLengthBetween(32, 32)));
+const SPAN_ID = S.String.pipe(S.check(S.isPattern(/^[0-9a-f]*[1-9a-f][0-9a-f]*$/)), S.check(S.isLengthBetween(16, 16)));
+const TraceContextPartsSchema = S.Struct({
+	version: VERSION,
+	traceId: TRACE_ID,
+	spanId: SPAN_ID,
+	traceFlags: S.Int.pipe(S.check(S.isBetween({
+		minimum: 0,
+		maximum: 255
+	}))),
+	traceState: S.optional(S.String)
+});
+const TraceparentPartsSchema = S.Struct({
+	version: VERSION,
+	traceId: TRACE_ID,
+	spanId: SPAN_ID,
+	traceFlags: S.Int.pipe(S.check(S.isBetween({
+		minimum: 0,
+		maximum: 255
+	})))
+});
+const HEX_VERSION = /^[0-9a-f]{2}$/;
+const HEX_TRACE_ID = /^[0-9a-f]{32}$/;
+const HEX_SPAN_ID = /^[0-9a-f]{16}$/;
+const HEX_FLAGS = /^[0-9a-f]{2}$/;
+const ALL_ZERO = /^0+$/;
+const FORBIDDEN_VERSION = "ff";
+const CURRENT_VERSION = "00";
+const TRACEPARENT_FIELD_COUNT = 4;
+const fieldAt = (fields, index) => fields[index] ?? "";
+const isNonZeroHex = (pattern, value) => pattern.test(value) && !ALL_ZERO.test(value);
+const acceptsFieldCount = (version, count) => version !== CURRENT_VERSION || count === TRACEPARENT_FIELD_COUNT;
+const isKnownVersion = (version) => HEX_VERSION.test(version) && version !== FORBIDDEN_VERSION;
+const isWellFormedTraceparent = (value) => {
+	const fields = value.split("-");
+	return [
+		acceptsFieldCount(fieldAt(fields, 0), fields.length),
+		isKnownVersion(fieldAt(fields, 0)),
+		isNonZeroHex(HEX_TRACE_ID, fieldAt(fields, 1)),
+		isNonZeroHex(HEX_SPAN_ID, fieldAt(fields, 2)),
+		HEX_FLAGS.test(fieldAt(fields, 3))
+	].every((check) => check);
+};
+const partsOf = (value) => {
+	const fields = value.split("-");
+	return {
+		version: fieldAt(fields, 0),
+		traceId: fieldAt(fields, 1),
+		spanId: fieldAt(fields, 2),
+		traceFlags: Number.parseInt(fieldAt(fields, 3), 16)
+	};
+};
+const formatOf = (parts) => `${parts.version}-${parts.traceId}-${parts.spanId}-${(parts.traceFlags & 255).toString(16).padStart(2, "0")}`;
+const malformedTraceparent = (value) => new SchemaIssue.InvalidValue({ message: "expected a W3C traceparent: version-traceId-spanId-flags" }, value);
+const decodeParts = SchemaGetter.transformEffect((value) => Boolean$1$1.match(isWellFormedTraceparent(value), {
+	onTrue: () => Effect$1.succeed(partsOf(value)),
+	onFalse: () => Effect$1.fail(malformedTraceparent(value))
+}));
+const encodeText = SchemaGetter.transform(formatOf);
+const Traceparent = S.String.pipe(S.decodeTo(TraceparentPartsSchema, SchemaTransformation.makeTransformation({
+	decode: decodeParts,
+	encode: encodeText
+})));
+const TRACESTATE_MEMBER = "[a-z][_0-9a-z\\-*/]{0,255}=[\\x20-\\x2b\\x2d-\\x3c\\x3e-\\x7e]{0,255}";
+const TRACESTATE_OWS = "[ \\t]*";
+const TRACESTATE = new RegExp(`^${TRACESTATE_MEMBER}(${TRACESTATE_OWS},${TRACESTATE_OWS}${TRACESTATE_MEMBER}){0,31}$`);
+const Tracestate = S.String.pipe(S.check(S.isPattern(TRACESTATE, { expected: "a W3C tracestate: comma-separated key=value members" })));
 const WorkerPluginKind = S.Literals([
 	"TestRunner",
 	"Checker",
 	"Reporter"
 ]);
+const EvaluatorPluginKind = S.Literal("Evaluator");
+const PluginKindSchema = S.Union([WorkerPluginKind, EvaluatorPluginKind]);
 const TestRunnerDryRunRequest = S.Struct({ options: DryRunOptionsSchema });
 const TestRunnerMutantRunRequest = S.Struct({ options: Mutant_exports.MutantRunOptionsSchema });
 const CheckerRequest = S.Struct({
@@ -7801,8 +7881,8 @@ const CheckerRequest = S.Struct({
 const CheckerCheckResult = S.Record(S.String, CheckResultSchema);
 const CheckerGroupResult = S.String.pipe(S.Array, S.Array);
 const ReporterInitOptions = S.Struct({
-	traceparent: S.optionalKey(S.String),
-	tracestate: S.optionalKey(S.String)
+	traceparent: S.optionalKey(Traceparent),
+	tracestate: S.optionalKey(Tracestate)
 });
 const ReporterEventBatch = S.Array(ReporterEventUnion);
 const ReporterAck = S.Void;
@@ -7831,40 +7911,48 @@ const WorkerPluginSpawnSchema = S.Struct({
 });
 var PropagatedTrace = class extends Context.Service()("@systemfsoftware/stryker-js-plugin-interface/TraceContextRpc.service/PropagatedTrace") {};
 var TraceContextMiddleware = class extends RpcMiddleware.Service()("@systemfsoftware/stryker-js-plugin-interface/TraceContextMiddleware", { requiredForClient: true }) {};
-const TestRunnerRpcs = RpcGroup.make(Rpc.make("capabilities", {
+const capabilities = Rpc.make("capabilities", {
 	success: TestRunnerCapabilitiesSchema,
 	error: TestRunnerFailed
-}), Rpc.make("dryRun", {
+}).middleware(TraceContextMiddleware);
+const dryRun = Rpc.make("dryRun", {
 	payload: TestRunnerDryRunRequest,
 	success: DryRunResultSchema,
 	error: TestRunnerFailed
-}), Rpc.make("mutantRun", {
+}).middleware(TraceContextMiddleware);
+const mutantRun = Rpc.make("mutantRun", {
 	payload: TestRunnerMutantRunRequest,
 	success: MutantRunResultSchema,
 	error: TestRunnerFailed
-})).middleware(TraceContextMiddleware);
-const CheckerRpcs = RpcGroup.make(Rpc.make("check", {
+}).middleware(TraceContextMiddleware);
+const check = Rpc.make("check", {
 	payload: CheckerRequest,
 	success: CheckerCheckResult,
 	error: CheckerFailed
-}), Rpc.make("group", {
+}).middleware(TraceContextMiddleware);
+const group = Rpc.make("group", {
 	payload: CheckerRequest,
 	success: CheckerGroupResult,
 	error: CheckerFailed
-})).middleware(TraceContextMiddleware);
-const ReporterRpcs = RpcGroup.make(Rpc.make("init", {
+}).middleware(TraceContextMiddleware);
+const init = Rpc.make("init", {
 	payload: ReporterInitOptions,
 	success: ReporterAck,
 	error: ReporterFailed
-}), Rpc.make("onEventBatch", {
+}).middleware(TraceContextMiddleware);
+const onEventBatch = Rpc.make("onEventBatch", {
 	payload: ReporterEventBatch,
 	success: ReporterAck,
 	error: ReporterFailed
-}), Rpc.make("flush", {
+}).middleware(TraceContextMiddleware);
+const flush = Rpc.make("flush", {
 	success: ReporterDrained,
 	error: ReporterFailed
-})).middleware(TraceContextMiddleware);
-var Plugin_exports = /* @__PURE__ */ __exportAll$1({
+}).middleware(TraceContextMiddleware);
+const TestRunnerRpcs = RpcGroup.make(capabilities, dryRun, mutantRun);
+const CheckerRpcs = RpcGroup.make(check, group);
+const ReporterRpcs = RpcGroup.make(init, onEventBatch, flush);
+var Plugin_exports = /* @__PURE__ */ __exportAll({
 	BoundaryErrorSchema: () => BoundaryErrorSchema,
 	BoundaryPayloadRejected: () => BoundaryPayloadRejected,
 	BoundaryUnrecognizedSignal: () => BoundaryUnrecognizedSignal,
@@ -7872,8 +7960,11 @@ var Plugin_exports = /* @__PURE__ */ __exportAll$1({
 	CheckerGroupResult: () => CheckerGroupResult,
 	CheckerRequest: () => CheckerRequest,
 	CheckerRpcs: () => CheckerRpcs,
+	EvaluatorPluginKind: () => EvaluatorPluginKind,
 	ExitClass: () => ExitClass,
+	ExitCode: () => ExitCode,
 	ExitCodeFromClass: () => ExitCodeFromClass,
+	PluginKindSchema: () => PluginKindSchema,
 	ReporterAck: () => ReporterAck,
 	ReporterDrained: () => ReporterDrained,
 	ReporterEventBatch: () => ReporterEventBatch,
@@ -7886,7 +7977,18 @@ var Plugin_exports = /* @__PURE__ */ __exportAll$1({
 	WorkerPluginKind: () => WorkerPluginKind,
 	WorkerPluginSpawnSchema: () => WorkerPluginSpawnSchema
 });
-var Report_exports = /* @__PURE__ */ __exportAll$1({
+const countOf = (mutants, status) => mutants.filter((mutant) => mutant.status === status).length;
+const metricsFromMutants = (mutants) => Metrics.make({
+	pending: countOf(mutants, "Pending"),
+	killed: countOf(mutants, "Killed"),
+	timeout: countOf(mutants, "Timeout"),
+	survived: countOf(mutants, "Survived"),
+	noCoverage: countOf(mutants, "NoCoverage"),
+	runtimeErrors: countOf(mutants, "RuntimeError"),
+	compileErrors: countOf(mutants, "CompileError"),
+	ignored: countOf(mutants, "Ignored")
+});
+var Report_exports = /* @__PURE__ */ __exportAll({
 	BrandingInformationSchema: () => BrandingInformationSchema,
 	DependenciesSchema: () => DependenciesSchema,
 	DetectedStatus: () => DetectedStatus,
@@ -7902,15 +8004,17 @@ var Report_exports = /* @__PURE__ */ __exportAll$1({
 	MutationTestResultSchema: () => MutationTestResultSchema,
 	NonNegativeFinite: () => NonNegativeFinite,
 	NonNegativeInt: () => NonNegativeInt,
+	OrderedThresholds: () => OrderedThresholds,
 	Percentage: () => Percentage,
 	TestDefinitionSchema: () => TestDefinitionSchema,
 	TestFileDefinitionDictionarySchema: () => TestFileDefinitionDictionarySchema,
 	TestFileSchema: () => TestFileSchema,
 	ThresholdsSchema: () => ThresholdsSchema,
 	UndetectedStatus: () => UndetectedStatus,
-	UntestedStatus: () => UntestedStatus
+	UntestedStatus: () => UntestedStatus,
+	metricsFromMutants: () => metricsFromMutants
 });
-var Reporter_exports = /* @__PURE__ */ __exportAll$1({
+var Reporter_exports = /* @__PURE__ */ __exportAll({
 	DryRunCompleted: () => DryRunCompleted,
 	MutantTested: () => MutantTested,
 	MutationTestReportReady: () => MutationTestReportReady,
@@ -7951,7 +8055,7 @@ const HitLimitReason = HitLimitReasonText.pipe(S.decodeTo(S.Struct({
 	encode: textOf
 })));
 var TestRunner = class extends Context.Service()("@systemfsoftware/stryker-js-plugin-interface/TestRunner.service/TestRunner") {};
-var TestRunner_exports = /* @__PURE__ */ __exportAll$1({
+var TestRunner_exports = /* @__PURE__ */ __exportAll({
 	CoverageAnalysisSchema: () => CoverageAnalysisSchema,
 	DryRunOptionsSchema: () => DryRunOptionsSchema,
 	DryRunResultSchema: () => DryRunResultSchema,
@@ -7962,6 +8066,7 @@ var TestRunner_exports = /* @__PURE__ */ __exportAll$1({
 	MutantCoverageSchema: () => MutantCoverageSchema,
 	MutantRunResultSchema: () => MutantRunResultSchema,
 	MutantRunStatus: () => MutantRunStatus,
+	TestId: () => TestId,
 	TestResultSchema: () => TestResultSchema,
 	TestRunner: () => TestRunner,
 	TestRunnerCapabilitiesSchema: () => TestRunnerCapabilitiesSchema,
@@ -7969,306 +8074,16 @@ var TestRunner_exports = /* @__PURE__ */ __exportAll$1({
 	TestStatus: () => TestStatus,
 	WallClockTimeoutReason: () => WallClockTimeoutReason
 });
-const TraceparentHeader = S.Literal("traceparent");
-const TracestateHeader = S.Literal("tracestate");
-const VERSION = S.String.pipe(S.check(S.isPattern(/^([0-9a-e][0-9a-f]|[0-9a-f][0-9a-e])$/)));
-const TRACE_ID = S.String.pipe(S.check(S.isPattern(/^[0-9a-f]*[1-9a-f][0-9a-f]*$/)), S.check(S.isLengthBetween(32, 32)));
-const SPAN_ID = S.String.pipe(S.check(S.isPattern(/^[0-9a-f]*[1-9a-f][0-9a-f]*$/)), S.check(S.isLengthBetween(16, 16)));
-const TraceContextPartsSchema = S.Struct({
-	version: VERSION,
-	traceId: TRACE_ID,
-	spanId: SPAN_ID,
-	traceFlags: S.Int.pipe(S.check(S.isBetween({
-		minimum: 0,
-		maximum: 255
-	}))),
-	traceState: S.optional(S.String)
-});
-const TraceparentPartsSchema = S.Struct({
-	version: VERSION,
-	traceId: TRACE_ID,
-	spanId: SPAN_ID,
-	traceFlags: S.Int.pipe(S.check(S.isBetween({
-		minimum: 0,
-		maximum: 255
-	})))
-});
-const HEX_VERSION = /^[0-9a-f]{2}$/;
-const HEX_TRACE_ID = /^[0-9a-f]{32}$/;
-const HEX_SPAN_ID = /^[0-9a-f]{16}$/;
-const HEX_FLAGS = /^[0-9a-f]{2}$/;
-const ALL_ZERO = /^0+$/;
-const FORBIDDEN_VERSION = "ff";
-const CURRENT_VERSION = "00";
-const TRACEPARENT_FIELD_COUNT = 4;
-const fieldAt = (fields, index) => fields[index] ?? "";
-const isNonZeroHex = (pattern, value) => pattern.test(value) && !ALL_ZERO.test(value);
-const acceptsFieldCount = (version, count) => version !== CURRENT_VERSION || count === TRACEPARENT_FIELD_COUNT;
-const isKnownVersion = (version) => HEX_VERSION.test(version) && version !== FORBIDDEN_VERSION;
-const isWellFormedTraceparent = (value) => {
-	const fields = value.split("-");
-	return [
-		acceptsFieldCount(fieldAt(fields, 0), fields.length),
-		isKnownVersion(fieldAt(fields, 0)),
-		isNonZeroHex(HEX_TRACE_ID, fieldAt(fields, 1)),
-		isNonZeroHex(HEX_SPAN_ID, fieldAt(fields, 2)),
-		HEX_FLAGS.test(fieldAt(fields, 3))
-	].every((check) => check);
-};
-const partsOf = (value) => {
-	const fields = value.split("-");
-	return {
-		version: fieldAt(fields, 0),
-		traceId: fieldAt(fields, 1),
-		spanId: fieldAt(fields, 2),
-		traceFlags: Number.parseInt(fieldAt(fields, 3), 16)
-	};
-};
-const formatOf = (parts) => `${parts.version}-${parts.traceId}-${parts.spanId}-${(parts.traceFlags & 255).toString(16).padStart(2, "0")}`;
-const malformedTraceparent = (value) => new SchemaIssue.InvalidValue({ message: "expected a W3C traceparent: version-traceId-spanId-flags" }, value);
-const decodeParts = SchemaGetter.transformEffect((value) => Boolean$1$1.match(isWellFormedTraceparent(value), {
-	onTrue: () => Effect$1.succeed(partsOf(value)),
-	onFalse: () => Effect$1.fail(malformedTraceparent(value))
-}));
-const encodeText = SchemaGetter.transform(formatOf);
-const Traceparent = S.String.pipe(S.decodeTo(TraceparentPartsSchema, SchemaTransformation.makeTransformation({
-	decode: decodeParts,
-	encode: encodeText
-})));
 const TraceContextReference = Context.Reference("@systemfsoftware/stryker-js-plugin-interface/TraceContextReference", { defaultValue: () => Option$1.none() });
-var Trace_exports = /* @__PURE__ */ __exportAll$1({
+var Trace_exports = /* @__PURE__ */ __exportAll({
 	PropagatedTrace: () => PropagatedTrace,
 	TraceContextMiddleware: () => TraceContextMiddleware,
 	TraceContextPartsSchema: () => TraceContextPartsSchema,
 	TraceContextReference: () => TraceContextReference,
 	Traceparent: () => Traceparent,
 	TraceparentHeader: () => TraceparentHeader,
+	Tracestate: () => Tracestate,
 	TracestateHeader: () => TracestateHeader
 });
 //#endregion
-//#region src/run-event.schema.ts
-const RunPhase = S.Literals([
-	"prepare",
-	"instrument",
-	"dry-run",
-	"mutation-test"
-]);
-const OutputMode = S.Literals(["human", "machine"]);
-const ModeSignal = S.Literals([
-	"flag",
-	"env",
-	"tty",
-	"agent",
-	"tool"
-]);
-var RunStarted = class extends S.TaggedClass()("stream", {
-	schemaVersion: S.String,
-	runId: S.String,
-	mode: OutputMode,
-	signal: ModeSignal
-}) {};
-var PhaseEntered = class extends S.TaggedClass()("phase", {
-	phase: RunPhase,
-	elapsedMs: Report_exports.NonNegativeFinite
-}) {};
-var PlanKnown = class extends S.TaggedClass()("plan", { total: Report_exports.NonNegativeInt }) {};
-var RunMutantTested = class extends S.TaggedClass()("mutant", {
-	id: S.String,
-	status: Mutant_exports.MutantStatusSchema,
-	file: S.String,
-	location: Mutant_exports.LocationSchema,
-	mutator: S.String,
-	replacement: S.NullOr(S.String),
-	completed: Report_exports.NonNegativeInt,
-	total: Report_exports.NonNegativeInt
-}) {};
-var Heartbeat = class extends S.TaggedClass()("tick", {
-	elapsedMs: Report_exports.NonNegativeFinite,
-	completed: Report_exports.NonNegativeInt,
-	total: S.NullOr(Report_exports.NonNegativeInt)
-}) {};
-const VerdictThresholdsValuesSchema = S.Struct({
-	high: Report_exports.Percentage,
-	low: Report_exports.Percentage,
-	break: S.NullOr(Report_exports.Percentage)
-});
-const isVerdictThresholds = (value) => S.is(VerdictThresholdsValuesSchema)(value) && value.low <= value.high;
-/**
-* The pair is *built* ordered — a drawn pair is sorted — rather than drawn at
-* random and discarded until it happens to be ordered. The invariant lives on
-* the declaration because a filter over the pair cannot express `low <= high`
-* in the generation-constraint vocabulary, and only a declaration carries a
-* `toCodecArbitrary` derivation. The struct stays the wire side, so decoding
-* keeps its field paths.
-*/
-const OrderedVerdictThresholds = S.declare(isVerdictThresholds, {
-	message: "expected thresholds where low <= high",
-	toCodecArbitrary: () => S.link()(VerdictThresholdsValuesSchema, {
-		decode: SchemaGetter.transform(({ break: breaking, high, low }) => ({
-			break: breaking,
-			high: Math.max(high, low),
-			low: Math.min(high, low)
-		})),
-		encode: SchemaGetter.transform((thresholds) => thresholds)
-	})
-});
-const VerdictThresholds = VerdictThresholdsValuesSchema.pipe(S.decodeTo(OrderedVerdictThresholds, SchemaTransformation.passthrough()));
-const VerdictMutant = S.Struct({
-	id: S.String,
-	file: S.String,
-	location: Mutant_exports.LocationSchema,
-	mutator: S.String,
-	replacement: S.NullOr(S.String),
-	status: Mutant_exports.MutantStatusSchema
-});
-var VerdictReached = class extends S.TaggedClass()("verdict", {
-	schemaVersion: S.String,
-	runId: S.String,
-	mode: OutputMode,
-	signal: ModeSignal,
-	score: S.NullOr(Report_exports.Percentage),
-	thresholds: VerdictThresholds,
-	reportFile: S.NullOr(S.String),
-	counts: Report_exports.Metrics,
-	mutants: S.Array(VerdictMutant)
-}) {};
-const FrameworkContributionRow = S.Struct({
-	name: S.String,
-	formatId: S.String,
-	extensions: S.Array(S.String)
-});
-const FrameworkModuleRow = S.Struct({
-	moduleName: S.String,
-	contributions: S.Array(FrameworkContributionRow)
-});
-const FormatClaimShadowingRow = S.Struct({
-	extension: S.String,
-	winner: S.String,
-	loser: S.String
-});
-var PluginsReported = class extends S.TaggedClass()("plugins", {
-	modules: S.Array(FrameworkModuleRow),
-	shadowings: S.Array(FormatClaimShadowingRow)
-}) {};
-const FormatRegistryRow = S.Struct({
-	extension: S.String,
-	formatId: S.String,
-	ownerModule: S.String,
-	language: S.String
-});
-var FormatRegistryResolved = class extends S.TaggedClass()("formats", { rows: S.Array(FormatRegistryRow) }) {};
-const SkippedFileRow = S.Struct({
-	file: S.String,
-	extension: S.String,
-	reason: S.String
-});
-var SkippedReported = class extends S.TaggedClass()("skipped", { files: S.Array(SkippedFileRow) }) {};
-const PluginFailureReason = S.Literals([
-	"PeerMissing",
-	"PeerVersionUnsupported",
-	"PeerUnrecognized",
-	"InvalidContribution",
-	"ImportFailed"
-]);
-var RunFailed = class extends S.TaggedClass()("error", {
-	schemaVersion: S.String,
-	code: S.Finite,
-	error: S.String,
-	remediation: S.String,
-	reason: S.NullOr(PluginFailureReason)
-}) {};
-var HelpRendered = class extends S.TaggedClass()("help", {
-	schemaVersion: S.String,
-	code: S.Literals([0]),
-	help: S.String
-}) {};
-const RunEvent = Object.assign(S.Union([
-	RunStarted,
-	PhaseEntered,
-	PlanKnown,
-	RunMutantTested,
-	Heartbeat,
-	PluginsReported,
-	FormatRegistryResolved,
-	SkippedReported,
-	VerdictReached,
-	RunFailed,
-	HelpRendered
-]), { QUEUE_BOUND: 256 });
-S.TaggedClass()("RunCommand", {
-	cliOptionsJson: S.String,
-	targetMutatePatterns: S.Array(S.String)
-});
-S.TaggedClass()("RunOutput", {
-	verdictJson: S.String,
-	exitCode: S.Finite
-});
-var RunDecodeError = class extends S.TaggedError()("RunDecodeError", { message: S.String }) {};
-var RunReadError = class extends S.TaggedError()("RunReadError", { message: S.String }) {};
-S.TaggedError()("RunWriteError", { message: S.String });
-var PlanMutationRunCommand = class extends S.TaggedClass()("PlanMutationRunCommand", {
-	configMutatePatterns: S.Array(S.String),
-	configMutatorNames: S.Array(S.String),
-	targetMutatePatterns: S.Array(S.String),
-	availableMutators: S.Array(S.String)
-}) {};
-var MutationRunPlan = class extends S.TaggedClass()("MutationRunPlan", {
-	mutatePatterns: S.Array(S.String),
-	mutatorNames: S.Array(S.String)
-}) {};
-//#endregion
-//#region src/Run.schema.ts
-const TypeId = "~stryker/mutation-run/StageError";
-var StageError = class extends S.TaggedError(TypeId)("StageError", {
-	stage: S.Literals([
-		"prepare",
-		"instrument",
-		"dryRun",
-		"dryRunNoTests",
-		"mutationTest"
-	]),
-	reason: S.String,
-	cause: S.optional(S.Defect()),
-	command: S.optional(S.String)
-}) {
-	[TypeId] = TypeId;
-	get exitClass() {
-		return STAGE_PRESENTATION[this.stage].exitClass;
-	}
-	get message() {
-		const failure = `${STAGE_PRESENTATION[this.stage].label} failed: ${this.reason}`;
-		return Match.value(this.command).pipe(Match.when(Match.nonEmptyString, (present) => `${failure} (command: ${present})`), Match.orElse(() => failure));
-	}
-};
-const STAGE_PRESENTATION = {
-	prepare: {
-		label: "Prepare",
-		exitClass: "ConfigError"
-	},
-	instrument: {
-		label: "Instrument",
-		exitClass: "RuntimeError"
-	},
-	dryRun: {
-		label: "Dry run",
-		exitClass: "RuntimeError"
-	},
-	dryRunNoTests: {
-		label: "Dry run",
-		exitClass: "ConfigError"
-	},
-	mutationTest: {
-		label: "Mutation testing",
-		exitClass: "RuntimeError"
-	}
-};
-var PrepareError = class extends S.TaggedError()("PrepareError", {
-	stage: S.Literal("prepare"),
-	reason: S.String
-}) {
-	get message() {
-		return this.reason;
-	}
-};
-//#endregion
-export { Plugin_exports as A, RunReadError as C, VerdictReached as D, SkippedReported as E, ErrorText_exports as F, Format_exports as I, Instrument_exports as L, Reporter_exports as M, TestRunner_exports as N, Checker_exports as O, Trace_exports as P, Mutant_exports as R, RunPhase as S, SkippedFileRow as T, PluginsReported as _, FormatRegistryRow as a, RunFailed as b, Heartbeat as c, MutationRunPlan as d, OutputMode as f, PluginFailureReason as g, PlanMutationRunCommand as h, FormatRegistryResolved as i, Report_exports as j, Options_exports as k, HelpRendered as l, PlanKnown as m, StageError as n, FrameworkContributionRow as o, PhaseEntered as p, FormatClaimShadowingRow as r, FrameworkModuleRow as s, PrepareError as t, ModeSignal as u, RunDecodeError as v, RunStarted as w, RunMutantTested as x, RunEvent as y };
+export { Reporter_exports as a, ErrorText_exports as c, Mutant_exports as d, Report_exports as i, Format_exports as l, Options_exports as n, TestRunner_exports as o, Plugin_exports as r, Trace_exports as s, Checker_exports as t, Instrument_exports as u };