@systemfsoftware/stryker-js-instrumenter 9.0.1 → 10.0.1

package/dist/index.mjs

@@ -8,18 +8,19 @@ import * as S from "effect/Schema";
 import * as Effect from "effect/Effect";
 import { dual } from "effect/Function";
 import { Handle, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
-import * as Arr from "effect/Array";
-import * as SGetter from "effect/SchemaGetter";
+import * as Order from "effect/Order";
+import * as SchemaGetter from "effect/SchemaGetter";
 import { RegExpParser, visitRegExpAST } from "@eslint-community/regexpp";
+import * as Arr from "effect/Array";
 //#region src/ErrorText.schema.ts
-var ErrorText = class ErrorText extends S.Class("ErrorText")({ text: S.NonEmptyString }) {
-	static fromCause = (cause) => Option.flatMap(nonEmptyText(errorTextOf$2(cause)), (text) => ErrorText.makeOption({ text }));
-};
-var CauseText = class CauseText extends S.Class("CauseText")({ text: S.NonEmptyString }) {
-	static fromCause = (cause) => Option.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 }) {};
+//#endregion
+//#region src/error-text.ts
 const nonEmptyText = Option.liftPredicate(S.is(S.NonEmptyString));
-function errorTextOf$2(error) {
+const errorTextOf$2 = (cause) => Option.flatMap(nonEmptyText(errorTextValueOf(cause)), (text) => ErrorText.makeOption({ text }));
+const causeTextOf = (cause) => Option.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) {
@@ -87,10 +88,10 @@ function causeText(cause, depth) {
 function missingCauseTextOf(cause, depth) {
 	return Boolean$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) {
@@ -100,93 +101,92 @@ function objectCauseTextOf(cause, depth) {
 //#region src/ErrorText/mod.ts
 var ErrorText_exports = /* @__PURE__ */ __exportAll({
 	CauseText: () => CauseText,
-	ErrorText: () => ErrorText
+	ErrorText: () => ErrorText,
+	causeTextOf: () => causeTextOf,
+	errorTextOf: () => errorTextOf$2
 });
 //#endregion
 //#region src/Location.schema.ts
-/**
-* 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 LocationSchema$1 = S.Struct({
-	start: PositionSchema,
-	end: PositionSchema
+const Offset = S.Int.check(S.isGreaterThanOrEqualTo(0));
+/** A 1-based line: the first line of a file is line 1. */
+const Line = S.Int.check(S.isGreaterThanOrEqualTo(1));
+/** A 1-based column: the first character of a line is column 1. */
+const Column = S.Int.check(S.isGreaterThanOrEqualTo(1));
+const Position = S.Struct({
+	line: Line,
+	column: Column
+});
+const positionOrder = Order.combine(Order.mapInput(Order.Number, (position) => position.line), Order.mapInput(Order.Number, (position) => position.column));
+const inOrder = (order) => (ends) => ({
+	start: Order.min(order)(ends.start, ends.end),
+	end: Order.max(order)(ends.start, ends.end)
+});
+const notReversed = (order) => (ends) => Order.isLessThanOrEqualTo(order)(ends.start, ends.end);
+const PositionEnds = S.Struct({
+	start: Position,
+	end: Position
+});
+const Location = S.declare((value) => S.is(PositionEnds)(value) && notReversed(positionOrder)(value), {
+	expected: "a location whose end is not before its start",
+	toCodecArbitrary: () => S.link()(PositionEnds, {
+		decode: SchemaGetter.transform(inOrder(positionOrder)),
+		encode: SchemaGetter.transform((ends) => ends)
+	})
 });
-const OpenEndLocationSchema = S.Struct({
-	start: PositionSchema,
-	end: S.optional(PositionSchema)
+const OpenEnds = S.Struct({
+	start: Position,
+	end: S.optional(Position)
 });
-/**
-* 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 = S.Int.pipe(S.check(S.isGreaterThanOrEqualTo(0)));
-var LineTable = class extends S.Class("LineTable")({ lineStarts: S.NonEmptyArray(NonNegativeInt) }) {
-	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.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 closedEnds = (ends) => Option.map(Option.fromUndefinedOr(ends.end), (end) => ({
+	start: ends.start,
+	end
 }));
-const middleIndex = (low, high) => low + (high - low >> 1);
-const zeroBasedPositionOf = (lineStarts, offset) => {
-	const search = (low, high, start) => Boolean$1.match(low > high, {
-		onTrue: () => ({
-			line: low - 1,
-			column: offset - start
-		}),
-		onFalse: () => Option.match(Arr.get(lineStarts, middleIndex(low, high)), {
-			onNone: () => ({
-				line: low - 1,
-				column: offset - start
-			}),
-			onSome: (found) => Boolean$1.match(found === offset, {
-				onTrue: () => ({
-					line: middleIndex(low, high),
-					column: offset - found
-				}),
-				onFalse: () => Boolean$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 OpenEndLocation = S.declare((value) => S.is(OpenEnds)(value) && Option.match(closedEnds(value), {
+	onNone: () => true,
+	onSome: notReversed(positionOrder)
+}), {
+	expected: "a location whose end, when present, is not before its start",
+	toCodecArbitrary: () => S.link()(OpenEnds, {
+		decode: SchemaGetter.transform((ends) => Option.getOrElse(Option.map(closedEnds(ends), inOrder(positionOrder)), () => ends)),
+		encode: SchemaGetter.transform((ends) => ends)
+	})
+});
+const OffsetEnds = S.Struct({
+	start: Offset,
+	end: Offset
+});
+const Span = S.declare((value) => S.is(OffsetEnds)(value) && notReversed(Order.Number)(value), {
+	expected: "a span whose end is not before its start",
+	toCodecArbitrary: () => S.link()(OffsetEnds, {
+		decode: SchemaGetter.transform(inOrder(Order.Number)),
+		encode: SchemaGetter.transform((ends) => ends)
+	})
+});
+const ScriptOrigin = S.Struct({
+	line: Line,
+	columnShift: Offset
+});
+S.is(Offset), S.is(Line), S.is(Column), S.is(Location), S.is(Span);
+//#endregion
+//#region src/directives/directive.schema.ts
+const MutatorNameSchema = S.String.pipe(S.check(S.isPattern(/^[a-zA-Z]+(?: [a-zA-Z]+)*$/)));
+const 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
+});
 //#endregion
 //#region src/Mutant.schema.ts
 const MutantStatusSchema = S.Literals([
@@ -199,11 +199,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.transform((fileName) => fileName.replace(/\\/g, "/")),
+	encode: SchemaGetter.transform((canonical) => canonical)
 }));
 /**
 * A mutant's file location in the mutation-testing-report-schema contract:
@@ -211,19 +230,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))),
@@ -241,15 +260,15 @@ const MutantRunOptionsSchema = S.Struct({
 	hitLimit: S.optionalKey(HitCount)
 });
 const MutantCoverageSchema = 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),
-	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";
@@ -272,21 +291,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)
@@ -316,13 +329,81 @@ 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()
-}) {};
+}) {
+	get message() {
+		return `Failed to apply ${this.mutatorNames.join(", ")} in ${this.fileName}`;
+	}
+};
 var MutantNotApplied = class extends S.TaggedError()("MutantNotApplied", {
 	fileName: S.String,
-	mutatorName: S.String
-}) {};
+	mutatorName: MutatorNameSchema
+}) {
+	get message() {
+		return `Could not apply the ${this.mutatorName} mutant in ${this.fileName}`;
+	}
+};
+var NodeWithoutSpan = class extends S.TaggedError()("NodeWithoutSpan", { fileName: S.String }) {
+	get message() {
+		return `Node without a span in ${this.fileName}`;
+	}
+};
+var MutantsUnplaced = class extends S.TaggedError()("MutantsUnplaced", {
+	fileName: S.String,
+	detail: S.String
+}) {
+	get message() {
+		return `Mutants cannot be placed. This shouldn't happen! Unplaced mutants: ${this.detail}`;
+	}
+};
+var PlacementRefused = class extends S.TaggedError()("PlacementRefused", { message: S.String }) {};
+//#endregion
+//#region src/Location.ts
+const LINE_TERMINATOR = /\r\n|[\n\r\u2028\u2029]/g;
+const lineStartsOf = (text) => [0, ...[...text.matchAll(LINE_TERMINATOR)].map((match) => match.index + match[0].length)];
+const middleIndex = (low, high) => low + (high - low >> 1);
+const positionAtOffset = (lineStarts, offset, low, high, start) => Boolean$1.match(low > high, {
+	onTrue: () => ({
+		line: low,
+		column: offset - start + 1
+	}),
+	onFalse: () => Option.match(Arr.get(lineStarts, middleIndex(low, high)), {
+		onNone: () => ({
+			line: low,
+			column: offset - start + 1
+		}),
+		onSome: (found) => Boolean$1.match(found === offset, {
+			onTrue: () => ({
+				line: middleIndex(low, high) + 1,
+				column: 1
+			}),
+			onFalse: () => Boolean$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
+	});
+});
+const offsetAt = dual(2, (lineStarts, position) => Option.flatMap(Arr.get(lineStarts, position.line - 1), (start) => {
+	const offset = start + position.column - 1;
+	return Option.match(Arr.get(lineStarts, position.line), {
+		onNone: () => Option.some(offset),
+		onSome: (next) => Option.liftPredicate(offset, (candidate) => candidate < next)
+	});
+}));
 //#endregion
 //#region src/Ast.handle.ts
 const formatKeyOf = (ast) => ast.format === "embedded" ? ast.formatId : ast.format;
@@ -560,14 +641,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.match(comments.length === 0, {
+const attachComments = dual((args) => args.length >= 3, (self, comments, lineStarts) => Boolean$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) => {
@@ -593,12 +674,12 @@ const commentHost = (nodes, comment) => {
 };
 const followingNode = (nodes, comment) => Option.getOrUndefined(Option.map(Option.fromNullishOr(nodes.find((candidate) => candidate.start >= comment.end)), (entry) => entry.node));
 const precedingStatement = (nodes, comment) => Option.getOrUndefined(Option.map(Option.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.match(Option.fromNullishOr(map.get(node)), {
@@ -615,72 +696,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.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.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.match(Option.filter(Option.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.match(Option.filter(Option.some(value), isAstNode), {
+	onNone: () => [],
+	onSome: (node) => [{
 		key,
-		index: null
-	}, visitors)
+		index: null,
+		node
+	}]
+});
+const asWalkedNode = (value) => Option.filter(Option.some(value), isAstNode);
+const childNodes = (node) => Option.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.match(Option.filter(Option.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.match(Option.fromNullishOr(spanOf(node)), {
-		onNone: () => void 0,
-		onSome: (span) => {
-			out.push({
-				node,
-				start: span.start,
-				end: span.end
-			});
-		}
-	});
-};
+const collectNodes = (root) => Option.toArray(nodeEntryOf(root)).concat(childEntriesOf(root));
+const childEntriesOf = (root) => Option.match(asWalkedNode(root), {
+	onNone: () => [],
+	onSome: (node) => childSlotsOf(node).flatMap((slot) => collectNodes(slot.node))
+});
+const nodeEntryOf = (node) => Option.map(Option.fromNullishOr(spanOf(node)), (span) => ({
+	node,
+	start: span.start,
+	end: span.end
+}));
 function isAstNode(value) {
 	return Predicate.isObject(value) && typeof value["type"] === "string";
 }
@@ -689,32 +739,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.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.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.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.match(isCommentKey(context.key), {
-	onTrue: () => void 0,
-	onFalse: () => notify(visitors.exit, stack.pop())
-});
-const parentOf = (stack) => Option.getOrNull(Arr.last(stack));
+const traverse = dual(2, (self, visitors) => walkTraverse(self.root, visitors));
 const notify = (visitor, path) => Option.match(Option.all({
 	visitor: Option.fromNullishOr(visitor),
 	path: Option.fromNullishOr(path)
@@ -877,13 +936,6 @@ const EMPTY_IMPORT_TABLE = Object.freeze({
 	bareFunctions: /* @__PURE__ */ new Map(),
 	pipeBindings: /* @__PURE__ */ new Set()
 });
-const importTables = /* @__PURE__ */ new WeakMap();
-const importTableFor = (program) => Option.getOrElse(Option.fromNullishOr(importTables.get(program)), () => rememberImportTable(program));
-function rememberImportTable(program) {
-	const table = buildImportTable(program);
-	importTables.set(program, table);
-	return table;
-}
 const buildImportTable = (program) => Arr.reduce(Arr.flatMap(Arr.filter(program.body, isImportDeclaration$1), importContributions), EMPTY_IMPORT_TABLE, applyContribution);
 const withEntry = (entries, key, value) => new Map([...entries, [key, value]]);
 const withMember = (members, value) => /* @__PURE__ */ new Set([...members, value]);
@@ -935,7 +987,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.flatMap(programOf(context), (program) => resolveIn(node, context, importTableFor(program)));
+const resolveEffectCallDataFirst = (node, context) => Option.flatMap(programOf(context), (program) => resolveIn(node, context, buildImportTable(program)));
 const resolveEffectCall = dual((args) => args.length >= 2, resolveEffectCallDataFirst);
 const programOf = (context) => Arr.findLast(context.ancestors, isProgram);
 const resolveIn = (node, context, table) => Match.value(node).pipe(Match.when(isCallExpression$1, (call) => resolveCall(call, context, table)), Match.when(isMemberExpression, (member) => resolveReference(member, context, table)), Match.when(isIdentifier$1, (reference) => resolveReference(reference, context, table)), Match.orElse(() => Option.none()));
@@ -1341,9 +1393,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.match(Option.fromNullishOr(spanOf(node)), {
+		onNone: () => void 0,
+		onSome: (span) => `${node.type}:${span.start}:${span.end}`
+	});
 }
 function orDefault(value, fallback) {
 	return value ?? fallback;
@@ -1391,14 +1444,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.
@@ -1427,17 +1481,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 [];
@@ -1500,18 +1553,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));
@@ -1541,12 +1593,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({
@@ -1562,11 +1612,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.match(Option.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);
@@ -1620,16 +1674,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);
@@ -1642,12 +1694,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) {
@@ -1683,8 +1734,7 @@ function isStringLiteral(value) {
 	return nodeType(value) === "Literal" && hasStringValue(value);
 }
 function hasStringValue(value) {
-	if (!Predicate.hasProperty(value, "value")) return false;
-	return typeof value["value"] === "string";
+	return Predicate.hasProperty(value, "value") && typeof value["value"] === "string";
 }
 const stringAssignmentTypes = Object.freeze([
 	"&&=",
@@ -1767,8 +1817,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) {
@@ -1919,8 +1968,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));
@@ -1934,7 +1987,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
@@ -2017,16 +2072,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.match(Option.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;
@@ -2181,10 +2237,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() {
@@ -2195,61 +2248,70 @@ var ParseFailed = class extends S.TaggedError("@systemfsoftware/stryker-js-instr
 //#region src/Parser.service.ts
 const oxcModule = Effect.cached(Effect.promise(() => import("oxc-parser")));
 const loadOxc = Effect.flatMap(oxcModule, (load) => load);
-const parseWithOxcDataFirst = (text, fileName, lang) => Effect.gen(function* () {
+const parseWithOxcDataFirst = Effect.fn("stryker.instrument.parser.parseWithOxc")(function* (text, fileName, lang) {
 	const result = (yield* loadOxc).parseSync(fileName, text, {
 		lang,
 		range: true
 	});
-	const lineTable = yield* Effect.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.match(Option.fromNullishOr(failure), {
+		onNone: () => Effect.succeed({
+			root: result.program,
+			comments: result.comments
+		}),
+		onSome: (failed) => Effect.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.match(Option.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.getOrElse(Option.map(Option.fromNullishOr(error.labels.at(0)), (label) => label.start), () => 0);
 const createParser = () => ({ parse: (code, fileName, scriptFormat) => Match.value(scriptFormat).pipe(Match.when("js", () => parseJS(code, fileName)), Match.when("ts", () => parseTS(code, fileName)), Match.when("tsx", () => parseTsx(code, fileName)), Match.exhaustive) });
-const parseJSDataFirst = (text, fileName) => Effect.map(parseWithOxc(text, fileName, "js"), ({ root, comments }) => ({
-	originFileName: fileName,
-	rawContent: text,
-	format: "js",
-	root,
-	comments
-}));
+const parseJSDataFirst = Effect.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.map(parseWithOxc(text, fileName, "ts"), ({ root, comments }) => ({
-	originFileName: fileName,
-	rawContent: text,
-	format: "ts",
-	root,
-	comments
-}));
+const parseTSDataFirst = Effect.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.map(parseWithOxc(text, fileName, "tsx"), ({ root, comments }) => ({
-	root,
-	comments,
-	format: "tsx",
-	originFileName: fileName,
-	rawContent: text
-}));
+const parseTsxDataFirst = Effect.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);
 //#endregion
+//#region src/print/PrintFailed.schema.ts
+var PrintFailed = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/print/PrintFailed.schema/PrintFailed")("PrintFailed", { message: S.String }) {};
+//#endregion
 //#region src/print/SourceText.ts
 const printProgramDataFirst = (program, opts = {}) => programText(opts, program);
 const printProgram = dual((args) => Predicate.hasProperty(args[0], "type"), printProgramDataFirst);
@@ -3239,28 +3301,19 @@ const externalModuleArgumentText = (value) => Boolean$1.match(Predicate.isTruthy
 function printDataFirst(file, entryForFormat) {
 	const context = { print: (inner) => print(inner, entryForFormat) };
 	return Option.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.hasProperty(root, "hashbang") && Predicate.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);
@@ -3302,7 +3355,11 @@ var FormatOverrideUnclaimed = class extends S.TaggedError()("FormatOverrideUncla
 	fileName: S.String,
 	formatId: S.String,
 	reason: S.String
-}) {};
+}) {
+	get message() {
+		return `Cannot instrument ${this.fileName}: ${this.reason}`;
+	}
+};
 const pinOf = (command) => Option.fromUndefinedOr(command.formatId);
 const matchesCommand = (claim, command) => Match.value(pinOf(command)).pipe(Match.when(Option.isSome, (pin) => claim.formatId === pin.value), Match.orElse(() => claim.extensions.includes(command.extension)));
 const claimFor = (command) => command.claims.find((claim) => matchesCommand(claim, command));
@@ -3344,51 +3401,10 @@ const resolveFormat = Workflow.make({
 	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)
 });
 //#endregion
-//#region src/directives/directive.schema.ts
-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
-});
-//#endregion
 //#region src/directives/decode-directive.workflow.ts
 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] = {};
 };
@@ -3496,27 +3512,34 @@ const loadHeader = Effect.map(parseWithOxc(INSTRUMENTATION_HEADER_SOURCE, "instr
 	instrumentationHeaderValue = parsed.root.body;
 	return parsed.root.body;
 });
-const instrumentationHeader = instrumentationHeaderValue !== void 0 ? Effect.succeed(instrumentationHeaderValue) : loadHeader;
+const instrumentationHeader = Option.match(Option.fromNullishOr(instrumentationHeaderValue), {
+	onNone: () => loadHeader,
+	onSome: (header) => Effect.succeed(header)
+});
 const placeHeader = (root) => Effect.map(headerFor(root), (header) => {
 	root.body.unshift(...header);
 });
-const headerFor = (root) => Effect.map(instrumentationHeader, (header) => Option.match(leadingCommentsOf(root), {
+const headerFor = (root) => Effect.map(instrumentationHeader, (header) => Option.match(Option.all([Option.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.void;
+const placeHeaderIfNeededDataFirst = (placed, options, root) => Boolean$1.match(placed, {
+	onTrue: () => placeHeaderWhenWanted(options, root),
+	onFalse: () => Effect.void
+});
 const placeHeaderIfNeeded = dual((args) => args.length >= 3, placeHeaderIfNeededDataFirst);
-const placeHeaderWhenWanted = (options, root) => options.noHeader === true ? Effect.void : placeHeader(root);
+const placeHeaderWhenWanted = (options, root) => Boolean$1.match(options.noHeader === true, {
+	onTrue: () => Effect.void,
+	onFalse: () => placeHeader(root)
+});
 function leadingCommentsOf(root) {
 	const first = root.body[0];
-	if (!hasLeadingComments$1(first)) return Option.none();
-	return Option.some(first.leadingComments);
+	return Option.map(Option.liftPredicate(first, hasLeadingComments$1), (value) => value.leadingComments);
 }
-function commentedHeader(leadingComments, header) {
-	const firstHeader = Option.getOrThrowWith(Option.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];
 }
 //#endregion
 //#region src/place-mutants.workflow.ts
@@ -3532,8 +3555,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", {
@@ -3546,19 +3569,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;
 };
@@ -3570,11 +3593,19 @@ 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 }) {};
+}) {
+	get message() {
+		return `Expected ${this.expected} for mutant ${this.mutantId} (${this.mutatorName}) in ${this.fileName}`;
+	}
+};
+var NoPlacerClaimsNode = class extends S.TaggedError()("NoPlacerClaimsNode", { fileName: S.String }) {
+	get message() {
+		return `No placer claims the node in ${this.fileName}`;
+	}
+};
 const claimingPlacer = (facts) => Match.value(facts).pipe(Match.when({
 	isExpression: true,
 	expressionIsValid: true
@@ -3624,23 +3655,19 @@ const placeMutants = Workflow.make({
 });
 //#endregion
 //#region src/plan-mutants.workflow.ts
-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({
@@ -3651,10 +3678,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)
@@ -3679,8 +3706,12 @@ var MutantsFullyIgnored = class extends S.TaggedClass()("MutantsFullyIgnored", {
 };
 var MutantWithoutLocation = class extends S.TaggedError()("MutantWithoutLocation", {
 	fileName: S.String,
-	mutatorName: S.String
-}) {};
+	mutatorName: MutatorNameSchema
+}) {
+	get message() {
+		return `Mutant without a source location: ${this.mutatorName} in ${this.fileName}`;
+	}
+};
 const reachedLine = (located, line) => Match.value(located.directive.scope).pipe(Match.when(NEXT_LINE, () => located.governedLine === line), Match.when("block", () => true), Match.exhaustive);
 const namesMutator = (located, lowerMutatorName) => located.directive.mutatorNames.some((name) => [name === WILDCARD, name.toLowerCase() === lowerMutatorName].some(Boolean));
 const lastReachingDirective = (rule, lowerMutatorName, line) => Option.fromNullishOr(rule.findLast((located) => [reachedLine(located, line), namesMutator(located, lowerMutatorName)].every(Boolean)));
@@ -3697,12 +3728,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
@@ -3717,7 +3749,7 @@ const plannedMutant = (command, candidate, index) => Option.match(Option.fromNul
 		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),
@@ -3753,7 +3785,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.getOrElse(Option.map(ErrorText.fromCause(cause), (rendered) => rendered.text), () => "");
+const errorTextOf$1 = (cause) => Option.getOrElse(Option.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
@@ -3776,28 +3812,20 @@ const locatedDirective = (comment, governedLine) => Option.flatMap(Option.fromNu
 	at: loc.start,
 	governedLine
 })));
-const directivesOf = (node, governedLineOf) => attachedComments(node).flatMap((comment) => Option.toArray(locatedDirective(comment, governedLineOf(node))));
+const directivesOf = (node, governedLine) => attachedComments(node).flatMap((comment) => Option.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.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) {
@@ -3833,8 +3861,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)]);
@@ -3842,41 +3870,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.map(Option.fromNullishOr(spanOf(node)), (span) => lineTable.positionAt(span.start));
+	const position = Option.map(Option.fromNullishOr(spanOf(node)), (span) => positionAt(lineStarts, span.start));
 	return Option.match(position, {
 		onNone: () => `${relativeFile}:undefined:undefined`,
 		onSome: (at) => `${relativeFile}:${at.line}:${at.column}`
@@ -3886,27 +3906,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.flatMap(Option.filter(Option.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.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.some(node)), Match.orElse(() => Option.none()));
 }
 function adoptIdentifier(node, identifier) {
 	node.id = identifier;
@@ -3919,14 +3937,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.none()));
 }
 /** An arrow bound to a named declaration is re-emitted as a named function. */
 function arrowNamedByDeclarator(node, parentPath) {
-	return Option.match(declaratorIdentifier(parentPath), {
-		onNone: () => void 0,
-		onSome: (identifier) => namedArrowExpression(node, identifier)
-	});
+	return Option.map(declaratorIdentifier(parentPath), (identifier) => namedArrowExpression(node, identifier));
 }
 function namedArrowExpression(node, identifier) {
 	const declaration = variableDeclaration("const", [variableDeclarator(identifier, node)]);
@@ -3939,10 +3954,7 @@ function isVariableDeclarator(node) {
 	return nodeType(node) === "VariableDeclarator";
 }
 function adoptDeclaredName(node, declarator) {
-	return Option.match(declaredName(declarator), {
-		onNone: () => void 0,
-		onSome: (identifier) => adoptIdentifier(node, identifier)
-	});
+	return Option.map(declaredName(declarator), (identifier) => adoptIdentifier(node, identifier));
 }
 function declaredName(declarator) {
 	return Match.value(declarator.id).pipe(Match.when(isIdentifierReference, (identifier) => Option.some(identifier)), Match.orElse(() => Option.none()));
@@ -3951,10 +3963,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.match(Option.orElse(classOrFunctionExpressionNamedIfNeeded(path), () => arrowFunctionExpressionNamedIfNeeded(path)), {
+		onNone: () => expressionOf(path.node),
+		onSome: (named) => Result.succeed(named)
+	});
 }
 function isChainLink(node) {
 	return [
@@ -3972,51 +3984,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);
@@ -4033,27 +4039,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));
@@ -4064,13 +4074,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]));
+			});
 		}
 	}
 });
@@ -4086,231 +4094,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.gen(function* () {
-		const lineTable = yield* Effect.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.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.match(Option.fromNullishOr(frame.parent), {
+	onNone: () => [],
+	onSome: (parent) => framesUpward(parent)
+});
+const parentNodeOf = (frame) => Option.getOrNull(Option.map(Option.fromNullishOr(frame.parent), (parent) => parent.node));
+const ancestorsOfFrame = (frame) => Option.match(Option.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.match(Option.fromNullishOr(planned[index]), {
+	onNone: () => [],
+	onSome: (mutant) => [createMutant(mutant, fileName, candidate.node, candidate.replacement)]
+}));
+const ignorersReasonFor = (node, ancestors, ignorers) => ignorers.reduce((reason, ignorer) => Option.orElse(reason, () => Option.fromNullishOr(ignorer.shouldIgnore(node, ancestors))), Option.none());
+const 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.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.filter(Option.some(mutateDescription), isMutateRangeList);
+const isOutsideMutateRanges = (location, mutateDescription) => Option.exists(mutateRangesOf(mutateDescription), (ranges) => ranges.every((range) => !locationOverlaps(range, location)));
+const isInsideMutateRanges = (location, mutateDescription) => Option.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.match(Option.map(Option.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.match(Option.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.match(Option.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.match(Option.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.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.some(plannedWithNodes(candidates, planned.placeable));
-			}), Match.orElse(() => Option.none()));
-		}
-		function plannedWithNodes(candidates, planned) {
-			return candidates.flatMap((candidate, index) => Option.match(Option.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.getOrThrowWith(Option.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.getOrThrowWith(Option.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.filter(Option.some(mutateDescription), isMutateRangeList);
-		}
-		function isOutsideMutateRanges(path) {
-			return Option.exists(mutateRanges(), (ranges) => ranges.every((range) => !locationOverlaps(range, getNodeLocation(path.node))));
-		}
-		function shouldMutate(path) {
-			return mutateDescription === true || isInsideMutateRanges(path);
-		}
-		function isInsideMutateRanges(path) {
-			return Option.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.map(Option.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.getOrUndefined(ignorersReason(path.node, ancestors));
-			return replacements.map(({ mutatorName, replacement }) => ({
-				node: path.node,
-				replacement,
-				data: {
-					mutatorName,
-					replacementCode: printNode(replacement),
-					location: Option.getOrUndefined(location),
-					ignorerReason
-				}
-			}));
-		}
-		function ignorersReason(node, ancestors) {
-			return options.ignorers.reduce((reason, ignorer) => Option.orElse(reason, () => Option.fromNullishOr(ignorer.shouldIgnore(node, ancestors))), Option.none());
-		}
+		});
+	} });
+	return failure;
+};
+const applyPlan = (root, plan, context) => {
+	const places = new Map(plan.placements.map((placement) => [placement.node, placement]));
+	return Option.match(Option.fromNullishOr(applyPlacementsToAst(root, places, context)), {
+		onNone: () => Effect.void,
+		onSome: (error) => Effect.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.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.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.fail(error);
+	}), Match.orElse((succeeded) => Effect.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 {
@@ -4319,10 +4377,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 });
 //#endregion
 //#region src/TypeCheckDisablers.ts
 const tsDirectiveLikeRegEx = /@(ts-[a-z-]+)/;
@@ -4332,18 +4387,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];
@@ -4365,31 +4417,26 @@ 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.match(Option.fromNullishOr(commentDirectiveRegEx.exec(comment.value)), {
+		onNone: () => void 0,
+		onSome: (match) => directiveRangeAt(comment.start, lengthOf(match[1]), lengthOf(match[2]))
+	});
+}
+const lengthOf = (text) => Option.getOrElse(Option.map(Option.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;
-}
+};
 //#endregion
 //#region src/Format.ts
-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.none()), Match.orElse((script) => Option.some(script)));
 const extensionOf = (fileName) => {
 	const dot = fileName.lastIndexOf(".");
 	return dot > Math.max(fileName.lastIndexOf("/"), fileName.lastIndexOf("\\")) ? fileName.slice(dot).toLowerCase() : "";
@@ -4421,12 +4468,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.match(scriptAstOf(ast), {
+		onNone: () => Effect.fail(scriptAstError(ast)),
+		onSome: (script) => transformScript(script, mutantCollector, context)
+	}),
 	print: (ast, context) => printScriptAst(ast, context),
-	disableTypeChecks: (ast) => Effect.succeed(disableTypeCheckingInScript(requireScriptAst(ast)))
+	disableTypeChecks: (ast) => Option.match(scriptAstOf(ast), {
+		onNone: () => Effect.fail(scriptAstError(ast)),
+		onSome: (script) => Effect.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: {
@@ -4545,20 +4599,9 @@ const spliceForAssigned = (request) => Option.match(request.registry.entryForFor
 	onSome: (entry) => spliceFileFor(request.file, entry)
 });
 //#endregion
-//#region src/FrameworkEntry.ts
-const toOneBasedOrigin = (origin) => ({
-	line: origin.line + 1,
-	column: origin.column
-});
+//#region src/drivers/oxc-program.ts
 const EMBEDDED_SCRIPT_FILE = "embedded-script.js";
-const loadFrameworkToolkit = Effect.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
@@ -4568,19 +4611,29 @@ 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;
 };
+//#endregion
+//#region src/FrameworkEntry.ts
+const loadFrameworkToolkit = Effect.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: {
@@ -4589,14 +4642,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.some(embedded)), Match.orElse(() => Option.none()));
+const printNothingForNonEmbeddedAst = () => "";
 const frameworkFailure = (moduleName, fileName, detail) => InstrumentError.make({
 	message: `The framework "${moduleName}" could not parse ${fileName}: ${detail}`,
 	cause: new Error(detail)
@@ -4605,7 +4660,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.getOrElse(Option.map(ErrorText.fromCause(cause), (text) => text.text), () => "");
+const errorTextOf = (cause) => Option.getOrElse(Option.map(errorTextOf$2(cause), (rendered) => rendered.text), () => "");
 const runHook = (moduleName, hook, fileName, run) => Effect.try({
 	try: run,
 	catch: (cause) => hookFailure(moduleName, hook, fileName, cause)
@@ -4620,9 +4675,9 @@ const frameworkEntryOfDataFirst = (moduleName, framework) => ({
 	},
 	owner: moduleName,
 	ownerVersion: framework.claim.ownerVersion,
-	parse: (text, fileName) => Effect.gen(function* () {
+	parse: Effect.fn("stryker.instrument.framework_entry.parse")(function* (text, fileName) {
 		const context = frameworkContextOf(yield* loadFrameworkToolkit);
-		const lineTable = yield* Effect.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 {
@@ -4632,23 +4687,25 @@ 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.gen(function* () {
-		const embedded = embeddedOf(ast);
-		const warnings = yield* Effect.forEach(embedded.scripts, (script) => context.transform(script.ast, mutantCollector, context));
-		embedded.document = yield* runHook(moduleName, "transform", embedded.originFileName, () => framework.transform(embedded.document, embedded.context));
-		return warnings.flat();
+	transform: (ast, mutantCollector, context) => Option.match(embeddedOf(ast), {
+		onNone: () => Effect.fail(embeddedAstError(ast)),
+		onSome: Effect.fn("stryker.instrument.framework_entry.transform")(function* (embedded) {
+			const warnings = yield* Effect.forEach(embedded.scripts, (script) => context.transform(script.ast, mutantCollector, context));
+			embedded.document = yield* runHook(moduleName, "transform", embedded.originFileName, () => framework.transform(embedded.document, embedded.context));
+			return warnings.flat();
+		})
 	}),
-	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.flatMap((result) => settled(moduleName, embedded.originFileName, result)));
-	}
+	print: (ast) => Option.match(embeddedOf(ast), {
+		onNone: printNothingForNonEmbeddedAst,
+		onSome: (embedded) => framework.print(embedded.document, embedded.context)
+	}),
+	disableTypeChecks: (ast) => Option.match(embeddedOf(ast), {
+		onNone: () => Effect.fail(embeddedAstError(ast)),
+		onSome: (embedded) => runHook(moduleName, "disableTypeChecks", embedded.originFileName, () => framework.disableTypeChecks(embedded.rawContent)).pipe(Effect.flatMap((result) => settled(moduleName, embedded.originFileName, result)))
+	})
 });
 const frameworkEntryOf = dual((args) => args.length >= 2, frameworkEntryOfDataFirst);
 //#endregion
@@ -4711,22 +4768,26 @@ const admitInstrumentFiles = Workflow.make({
 });
 //#endregion
 //#region src/instrument-files.cell.ts
-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.forEach(raw.parsed, (parsed) => Effect.fromResult(printedFile(raw, parsed)), { concurrency: 1 }).pipe(Effect.mapError((failure) => InstrumentError.make({
+	message: failure.message,
+	cause: failure
+})));
+const instrumentedResult = (raw) => Effect.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.gen(function* () {
+const readInstrumentFiles = Effect.fn("stryker.instrument.read_files")(function* (input) {
 	const outcomes = yield* Effect.forEach(input.files, (file) => fileOutcome({
 		registry: input.registry,
 		file
@@ -4755,7 +4816,7 @@ const readInstrumentFiles = (input) => Effect.gen(function* () {
 	};
 });
 const instrumentFilesCell = Sandwich.named("stryker.instrument.files")((input) => readInstrumentFiles(input)).decide(admitInstrumentFiles).write({
-	InstrumentFilesAdmitted: (_admitted, raw) => Effect.succeed(instrumentedResult(raw)),
+	InstrumentFilesAdmitted: (_admitted, raw) => instrumentedResult(raw),
 	InstrumentFilesSkippedOnly: (_skipped, raw) => Effect.succeed(skippedOnlyResult(raw)),
 	CommandRejected: ({ issue }) => Effect.fail(InstrumentError.make({
 		message: issue,
@@ -4765,7 +4826,7 @@ const instrumentFilesCell = Sandwich.named("stryker.instrument.files")((input) =
 //#endregion
 //#region src/Instrument.service.ts
 const toSchemaFile = (file) => ({
-	name: file.name,
+	name: CanonicalFileName.make(file.name),
 	content: file.content,
 	mutate: file.mutate
 });
@@ -4810,9 +4871,14 @@ var Instrument_exports = /* @__PURE__ */ __exportAll({
 //#endregion
 //#region src/Mutant/mod.ts
 var Mutant_exports = /* @__PURE__ */ __exportAll({
+	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,
@@ -4821,10 +4887,14 @@ 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
-export { ErrorText_exports as ErrorText, Format_exports as Format, Instrument_exports as Instrument, Mutant_exports as Mutant };
+export { ErrorText_exports as ErrorText, Format_exports as Format, Instrument_exports as Instrument, Mutant_exports as Mutant, lineStartsOf, locationOf, offsetAt, originAt, positionAt };