@systemfsoftware/stryker-js-instrumenter 6.0.0 → 7.0.0

package/dist/index.mjs

@@ -1,17 +1,15 @@
-import { INSTRUMENTER_CONSTANTS, Mutant } from "@systemfsoftware/stryker-js/Mutant";
+import { INSTRUMENTER_CONSTANTS, Mutant } from "@systemfsoftware/stryker-js-language";
 import * as Effect from "effect/Effect";
 import * as Predicate from "effect/Predicate";
 import * as S from "effect/Schema";
 import * as Arr from "effect/Array";
 import * as Match from "effect/Match";
 import * as Option from "effect/Option";
-import path from "path";
-import "@systemfsoftware/stryker-js/Ignorer";
-import { propertyPath, strykerReportBugUrl } from "@systemfsoftware/stryker-js/Schema";
-import path$1 from "node:path";
+import { walk } from "oxc-walker";
+import { Schema } from "effect";
 import { RegExpParser, visitRegExpAST } from "@eslint-community/regexpp";
 //#region src/Instrument.schema.ts
-var InstrumentError = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/InstrumentError")("InstrumentError", {
+var InstrumentError = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/Instrument.schema/InstrumentError")("InstrumentError", {
 	message: S.String,
 	cause: S.Defect()
 }) {
@@ -35,27 +33,11 @@ const FileSchema = S.Struct({
 	mutate: MutateDescriptionSchema
 });
 const IgnorerSchema = S.Unknown;
-const AstSchema = S.Unknown;
-const InstrumenterOptionsSchema = S.Struct({
+S.Struct({
 	excludedMutations: S.Array(S.String),
 	ignorers: S.Array(IgnorerSchema),
 	noHeader: S.optional(S.Boolean)
 });
-var InstrumentCommand = class extends S.TaggedClass()("InstrumentCommand", {
-	files: S.Array(FileSchema),
-	options: InstrumenterOptionsSchema
-}) {};
-var InstrumentDecoded = class extends S.TaggedClass()("InstrumentDecoded", {
-	files: S.Array(FileSchema),
-	options: InstrumenterOptionsSchema,
-	asts: S.Array(AstSchema),
-	mutants: S.Array(Mutant)
-}) {};
-var InstrumentDecision = class extends S.TaggedClass()("InstrumentDecision", {
-	files: S.Array(FileSchema),
-	mutants: S.Array(Mutant),
-	asts: S.Array(AstSchema)
-}) {};
 var InstrumentResult = class extends S.TaggedClass()("InstrumentResult", {
 	files: S.Array(FileSchema),
 	mutants: S.Array(Mutant)
@@ -124,13 +106,10 @@ function requireMidpoint(midValue) {
 	return midValue;
 }
 //#endregion
-//#region src/estree.ts
-/**
-* ESTree toolkit — node builders, kind classification and a walker with
-* parent-chain paths. The walker replaces the previous traversal stack: oxc hands
-* back standard ESTree, so the instrumenter owns the traversal instead of
-* without pulling scope machinery along.
-*/
+//#region src/Traversal.schema.ts
+var TraversalStopped = class extends Schema.TaggedError()("TraversalStopped", {}) {};
+//#endregion
+//#region src/Ast.ts
 const EXPRESSION_KINDS = /* @__PURE__ */ new Set([
 	"ArrayExpression",
 	"ArrowFunctionExpression",
@@ -196,10 +175,6 @@ const STATEMENT_KINDS = /* @__PURE__ */ new Set([
 	"WhileStatement",
 	"WithStatement"
 ]);
-/**
-* The node's [start, end) offsets. oxc is invoked with `range: true`, so every
-* parsed node carries one; synthesized builders omit it.
-*/
 function spanOf(node) {
 	const range = node.range;
 	if (range === void 0) return void 0;
@@ -208,10 +183,6 @@ function spanOf(node) {
 		end: range[1]
 	};
 }
-/**
-* The node's `type` tag, for checks against kinds outside the @types/estree
-* union (TS and JSX extensions oxc emits).
-*/
 function nodeType(node) {
 	if (!isAstNode(node)) return void 0;
 	return node.type;
@@ -240,19 +211,22 @@ function identifier(name, loc) {
 function stringLiteral(value, loc) {
 	return mark({
 		type: "Literal",
-		value
+		value,
+		raw: null
 	}, loc);
 }
 function booleanLiteral(value, loc) {
 	return mark({
 		type: "Literal",
-		value
+		value,
+		raw: null
 	}, loc);
 }
 function regExpLiteral(pattern, flags, loc) {
 	return mark({
 		type: "Literal",
 		value: null,
+		raw: null,
 		regex: {
 			pattern,
 			flags
@@ -280,12 +254,12 @@ function newExpression(callee, args = [], loc) {
 		arguments: [...args]
 	}, loc);
 }
-function memberExpression(object, property, computed, optional, loc) {
+function memberExpression(object, property, optional, loc) {
 	return mark({
 		type: "MemberExpression",
 		object,
 		property,
-		computed,
+		computed: false,
 		optional
 	}, loc);
 }
@@ -293,6 +267,8 @@ function arrowFunctionExpression(params, body, loc) {
 	const fnBody = body;
 	return mark({
 		type: "ArrowFunctionExpression",
+		id: null,
+		generator: false,
 		params: [...params],
 		body: fnBody,
 		async: false,
@@ -393,20 +369,9 @@ function switchCase(test, consequent, loc) {
 		consequent: [...consequent]
 	}, loc);
 }
-/**
-* Deep clone of a plain ESTree node. oxc nodes are JSON-shaped, so
-* Deep clone over plain nodes: no prototypes to preserve.
-*/
 function cloneNode(node) {
 	return structuredClone(node);
 }
-/**
-* Attaches every comment to the node it precedes (`leadingComments`) or, when
-* no node follows it, to the node it trails (`trailingComments`). oxc ships
-* comments flat, and the Stryker directive pass reads `node.leadingComments`,
-* so the flat list is folded into the tree once per transform with the file's
-* line table in hand.
-*/
 function attachComments(root, comments, lineTable) {
 	if (comments.length === 0) return;
 	const nodes = collectNodes(root).filter((entry) => entry.node !== root);
@@ -423,13 +388,6 @@ function groupComments(nodes, comments) {
 	for (const comment of comments) hostComment(nodes, comment, groups);
 	return groups;
 }
-/**
-* The map a comment is hosted in. A comment attaches to the node it precedes;
-* one that precedes nothing — a same-line trailing comment — attaches to the
-* nearest statement before it, because the statement printer is the only
-* emitter of trailing comments and an expression host would never reach the
-* output.
-*/
 function hostComment(nodes, comment, groups) {
 	const host = [{
 		field: "leading",
@@ -467,32 +425,27 @@ function pushComment(map, node, comment) {
 	if (list === void 0) map.set(node, [comment]);
 	else list.push(comment);
 }
-/** oxc emits a node's children as a plain array the walker reads and replaces into. */
 const isNodeList = (value) => Array.isArray(value);
-function collectNodes(node) {
+const walker = (root, visitors) => {
+	const ancestors = [];
+	walk(root, {
+		enter(node) {
+			visitors.enter?.(node, [...ancestors]);
+			ancestors.push(node);
+		},
+		leave(node) {
+			ancestors.pop();
+			visitors.leave?.(node, [...ancestors]);
+		}
+	});
+};
+function collectNodes(root) {
 	const out = [];
-	collect$1(node, out);
+	walker(root, { enter(node) {
+		appendEntry(node, out);
+	} });
 	return out;
 }
-function collect$1(node, out) {
-	if (isNodeList(node)) return collectList(node, out);
-	collectAstNode(node, out);
-}
-function collectList(items, out) {
-	for (const item of items) collect$1(item, out);
-}
-function collectAstNode(value, out) {
-	if (!isAstNode(value)) return;
-	appendEntry(value, out);
-	collectChildren(value, out);
-}
-function collectChildren(node, out) {
-	for (const key of Object.keys(node)) collectChild(node, key, out);
-}
-function collectChild(node, key, out) {
-	if (SKIP_KEYS.has(key)) return;
-	collect$1(node[key], out);
-}
 function appendEntry(node, out) {
 	const span = spanOf(node);
 	if (span === void 0) return;
@@ -512,80 +465,59 @@ function positionFromLineTable(offset, lineTable) {
 	const zeroBased = positionFromOffset(lineTable, offset);
 	return {
 		line: zeroBased.line + 1,
-		column: zeroBased.column
+		column: zeroBased.column + 1
 	};
 }
-const SKIP_KEYS = /* @__PURE__ */ new Set([
-	"type",
-	"start",
-	"end",
-	"range",
-	"loc",
-	"leadingComments",
-	"trailingComments"
-]);
-function traverse(root, visitors) {
-	visit(root, null, "root", void 0, visitors, {
-		skipped: /* @__PURE__ */ new Set(),
-		stopped: false
-	});
+const COMMENT_KEYS = /* @__PURE__ */ new Set(["leadingComments", "trailingComments"]);
+function isCommentKey(key) {
+	return typeof key === "string" && COMMENT_KEYS.has(key);
 }
-function visit(node, parentPath, key, listKey, visitors, context) {
-	if (context.stopped) return;
-	visitAstNode(node, parentPath, key, listKey, visitors, context);
+function traverse(root, visitors) {
+	const stack = [];
+	try {
+		walk(root, {
+			enter(node, _parent, context) {
+				readPath(stack, node, this, context, visitors);
+			},
+			leave(_node, _parent, context) {
+				closePath(stack, context, visitors);
+			}
+		});
+	} catch (error) {
+		rethrowUnlessStopped(error);
+	}
 }
-function visitAstNode(node, parentPath, key, listKey, visitors, context) {
-	if (!isVisitable(node, context)) return;
-	const path = createPath(node, parentPath, key, listKey, context);
+const rethrowUnlessStopped = (error) => {
+	if (!S.is(TraversalStopped)(error)) throw error;
+};
+const readPath = (stack, node, controls, context, visitors) => {
+	if (isCommentKey(context.key)) return;
+	const path = createPath(node, parentOf(stack), controls, context);
+	stack.push(path);
 	notify(visitors.enter, path);
-	visitEnteredNode(node, path, visitors, context);
-}
-function isVisitable(node, context) {
-	return isAstNode(node) && !context.skipped.has(node);
-}
-function visitEnteredNode(node, path, visitors, context) {
-	if (context.skipped.has(node)) return;
-	visitChildren(node, path, visitors, context);
-	notifyExit(visitors.exit, path, context);
-}
-function notifyExit(visitor, path, context) {
-	if (context.stopped) return;
-	notify(visitor, path);
-}
+};
+const closePath = (stack, context, visitors) => {
+	if (isCommentKey(context.key)) return;
+	notify(visitors.exit, stack.pop());
+};
+const parentOf = (stack) => Option.getOrNull(Arr.last(stack));
 function notify(visitor, path) {
 	if (visitor === void 0) return;
-	visitor(path);
-}
-function visitChildren(node, path, visitors, context) {
-	Object.keys(node).every((key) => keepVisitingKey(node, path, key, visitors, context));
-}
-function keepVisitingKey(node, path, key, visitors, context) {
-	if (SKIP_KEYS.has(key)) return true;
-	return keepVisitingChild(node[key], path, key, visitors, context);
+	relay(visitor, path);
 }
-function keepVisitingChild(child, path, key, visitors, context) {
-	if (isNodeList(child)) return keepVisitingList(child, path, key, visitors, context);
-	return keepVisitingValue(child, path, key, void 0, visitors, context);
-}
-function keepVisitingList(items, path, key, visitors, context) {
-	return items.every((item, index) => keepVisitingValue(item, path, key, String(index), visitors, context));
-}
-function keepVisitingValue(value, path, key, listKey, visitors, context) {
-	visit(value, path, key, listKey, visitors, context);
-	return !context.stopped;
-}
-function createPath(node, parentPath, key, listKey, context) {
+const relay = (visitor, path) => {
+	if (path !== void 0) visitor(path);
+};
+function createPath(node, parentPath, controls, context) {
+	const key = typeof context.key === "string" ? context.key : void 0;
 	const path = {
 		node,
 		parentPath,
-		parent: parentPath?.node,
-		key,
-		listKey,
 		skip() {
-			context.skipped.add(node);
+			controls.skip();
 		},
 		stop() {
-			context.stopped = true;
+			throw TraversalStopped.make({});
 		},
 		find(predicate) {
 			return nearest(path, predicate);
@@ -594,10 +526,7 @@ function createPath(node, parentPath, key, listKey, context) {
 			return nearest(parentPath, (ancestor) => isStatementKind(ancestor.node));
 		},
 		replaceWith(replacement) {
-			replaceInParent(parentPath, key, listKey, replacement);
-		},
-		is(kind) {
-			return node.type === kind;
+			replaceInSlot(parentPath, key, context.index, replacement);
 		},
 		isExpression() {
 			return isExpressionKind(node);
@@ -616,39 +545,36 @@ function takeOrAscend(path, predicate) {
 	if (predicate(path)) return path;
 	return nearest(path.parentPath, predicate);
 }
-function replaceInParent(parentPath, key, listKey, replacement) {
+function replaceInSlot(parentPath, key, index, replacement) {
 	if (parentPath === null) return;
-	replaceChild(parentPath.node, key, listKey, replacement);
+	writeInto(parentPath.node, key, index, replacement);
 }
-function replaceChild(parent, key, listKey, replacement) {
+function writeInto(parent, key, index, replacement) {
 	if (!isAstNode(parent)) return;
-	assignChild(parent, key, listKey, replacement);
+	writeAtKey(parent, key, index, replacement);
 }
-function assignChild(parent, key, listKey, replacement) {
-	if (listKey === void 0) {
-		parent[key] = replacement;
-		return;
-	}
-	assignIndexed(parent, key, listKey, replacement);
-}
-function assignIndexed(parent, key, listKey, replacement) {
-	const index = Number(listKey);
-	const container = parent[key];
-	if (isIndexedList(container, index)) container[index] = replacement;
+function writeAtKey(parent, key, index, replacement) {
+	Match.value(key).pipe(Match.when(Predicate.isString, (slot) => writeAtSlot(parent, slot, index, replacement)), Match.orElse(() => void 0));
 }
-function isIndexedList(container, index) {
-	return isNodeList(container) && Number.isInteger(index);
+function writeAtSlot(parent, key, index, replacement) {
+	Match.value(index).pipe(Match.when(Match.null, () => overwrite(parent, key, replacement)), Match.orElse((position) => writeElement(parent[key], position, replacement)));
 }
+const overwrite = (parent, key, replacement) => {
+	parent[key] = replacement;
+};
+const writeElement = (container, index, replacement) => {
+	if (isNodeList(container)) container[index] = replacement;
+};
 //#endregion
 //#region src/Oxc.ts
 let oxc;
-const loadOxc = async () => {
-	if (oxc === void 0) oxc = await import("oxc-parser");
+const loadOxc = Effect.gen(function* () {
+	if (oxc === void 0) oxc = yield* Effect.promise(() => import("oxc-parser"));
 	return oxc;
-};
+});
 //#endregion
 //#region src/Parser.schema.ts
-var ParseFailed = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/ParseFailed")("ParseFailed", {
+var ParseFailed = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/Parser.schema/ParseFailed")("ParseFailed", {
 	fileName: S.String,
 	message: S.String,
 	location: S.Struct({
@@ -661,7 +587,7 @@ var ParseFailed = class extends S.TaggedError("@systemfsoftware/stryker-js-instr
 		return `Failed to parse ${this.fileName} at ${this.location.line}:${this.location.column}: ${this.message}`;
 	}
 };
-var ParserNotFound = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/ParserNotFound")("ParserNotFound", {
+var ParserNotFound = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/Parser.schema/ParserNotFound")("ParserNotFound", {
 	fileName: S.String,
 	extension: S.String,
 	cause: S.Defect()
@@ -670,7 +596,7 @@ var ParserNotFound = class extends S.TaggedError("@systemfsoftware/stryker-js-in
 		return `No parser registered for ${this.fileName} (extension "${this.extension}")`;
 	}
 };
-var SvelteVersionNotSupported = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/SvelteVersionNotSupported")("SvelteVersionNotSupported", {
+var SvelteVersionNotSupported = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/Parser.schema/SvelteVersionNotSupported")("SvelteVersionNotSupported", {
 	version: S.String,
 	fileName: S.String,
 	cause: S.Defect()
@@ -679,7 +605,7 @@ var SvelteVersionNotSupported = class extends S.TaggedError("@systemfsoftware/st
 		return `Svelte version ${this.version} is not supported for ${this.fileName} (expected >=3.30)`;
 	}
 };
-var SvelteWalkerNotFound = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/SvelteWalkerNotFound")("SvelteWalkerNotFound", {
+var SvelteWalkerNotFound = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/Parser.schema/SvelteWalkerNotFound")("SvelteWalkerNotFound", {
 	fileName: S.String,
 	cause: S.Defect()
 }) {
@@ -687,7 +613,7 @@ var SvelteWalkerNotFound = class extends S.TaggedError("@systemfsoftware/stryker
 		return `Svelte walker not found for ${this.fileName}`;
 	}
 };
-S.TaggedError("@systemfsoftware/stryker-js-instrumenter/SvelteParseFailed")("SvelteParseFailed", {
+S.TaggedError("@systemfsoftware/stryker-js-instrumenter/Parser.schema/SvelteParseFailed")("SvelteParseFailed", {
 	fileName: S.String,
 	cause: S.Defect()
 });
@@ -729,23 +655,23 @@ function fieldOf(value, key) {
 function appendIfDefined(values, value) {
 	if (value !== void 0) values.push(value);
 }
-async function parseWithOxc(text, fileName, lang) {
-	const { parseSync } = await loadOxc();
+const parseWithOxc = (text, fileName, lang) => Effect.gen(function* () {
+	const { parseSync } = yield* loadOxc;
 	const result = parseSync(fileName, text, {
 		lang,
 		range: true
 	});
 	const failure = oxcParseFailure(result.errors, text, fileName);
-	if (failure !== void 0) throw failure;
+	if (failure !== void 0) return yield* failure;
 	return {
 		root: result.program,
 		comments: result.comments
 	};
-}
+});
 function oxcParseFailure(errors, text, fileName) {
 	const first = errors.at(0);
 	if (first === void 0) return;
-	return new ParseFailed({
+	return ParseFailed.make({
 		fileName,
 		message: first.message,
 		location: positionFromLineTable(oxcErrorLabelStart(first), buildLineTable(text)),
@@ -772,13 +698,16 @@ function shiftScriptOffsets(ast, offset) {
 }
 function createParser() {
 	const jsParse = createJSParser();
-	async function parse(code, fileName, formatOverride) {
+	function parse(code, fileName, formatOverride) {
 		const format = getFormat(fileName, formatOverride);
-		if (!format) throw new ParserNotFound({
-			fileName,
-			extension: path.extname(fileName).toLowerCase(),
-			cause: void 0
-		});
+		if (!format) {
+			const ext = extensionOf(fileName);
+			return Effect.fail(ParserNotFound.make({
+				fileName,
+				extension: ext,
+				cause: void 0
+			}));
+		}
 		return Match.value(format).pipe(Match.when("js", () => jsParse(code, fileName)), Match.when("tsx", () => parseTsx(code, fileName)), Match.when("ts", () => parseTS(code, fileName)), Match.when("html", () => parseHtml(code, fileName, { parse })), Match.when("svelte", () => parseSvelte(code, fileName, { parse })), Match.exhaustive);
 	}
 	return parse;
@@ -798,40 +727,37 @@ const FORMAT_BY_EXTENSION = {
 	".svelte": "svelte"
 };
 function getFormat(fileName, override) {
-	return override ?? FORMAT_BY_EXTENSION[path.extname(fileName).toLowerCase()];
+	return override ?? FORMAT_BY_EXTENSION[extensionOf(fileName)];
 }
+const dotBeforeSlash = (dot, slash) => dot >= 0 && dot > slash;
+const extensionOf = (fileName) => {
+	const dot = fileName.lastIndexOf(".");
+	const slash = Math.max(fileName.lastIndexOf("/"), fileName.lastIndexOf("\\"));
+	return dotBeforeSlash(dot, slash) ? fileName.slice(dot).toLowerCase() : "";
+};
 function createJSParser() {
-	return async function parse(text, fileName) {
-		const { root, comments } = await parseWithOxc(text, fileName, "js");
-		return {
-			originFileName: fileName,
-			rawContent: text,
-			format: "js",
-			root,
-			comments
-		};
-	};
-}
-async function parseTS(text, fileName) {
-	const { root, comments } = await parseWithOxc(text, fileName, "ts");
-	return {
+	return (text, fileName) => Effect.map(parseWithOxc(text, fileName, "js"), ({ root, comments }) => ({
 		originFileName: fileName,
 		rawContent: text,
-		format: "ts",
+		format: "js",
 		root,
 		comments
-	};
-}
-async function parseTsx(text, fileName) {
-	const { root, comments } = await parseWithOxc(text, fileName, "tsx");
-	return {
-		root,
-		comments,
-		format: "tsx",
-		originFileName: fileName,
-		rawContent: text
-	};
+	}));
 }
+const parseTS = (text, fileName) => Effect.map(parseWithOxc(text, fileName, "ts"), ({ root, comments }) => ({
+	originFileName: fileName,
+	rawContent: text,
+	format: "ts",
+	root,
+	comments
+}));
+const parseTsx = (text, fileName) => Effect.map(parseWithOxc(text, fileName, "tsx"), ({ root, comments }) => ({
+	root,
+	comments,
+	format: "tsx",
+	originFileName: fileName,
+	rawContent: text
+}));
 const SCRIPT_TYPE_FORMATS = {
 	tsx: "tsx",
 	"text/tsx": "tsx",
@@ -843,27 +769,25 @@ const SCRIPT_TYPE_FORMATS = {
 	javascript: "js",
 	module: "js"
 };
-async function parseHtml(text, originFileName, context) {
-	return {
-		originFileName,
-		rawContent: text,
-		format: "html",
-		root: await ngHtmlParser(text, originFileName, context)
-	};
-}
-async function ngHtmlParser(text, fileName, parserContext) {
-	const ngParser = await import("angular-html-parser");
+const parseHtml = (text, originFileName, context) => Effect.map(ngHtmlParser(text, originFileName, context), (root) => ({
+	originFileName,
+	rawContent: text,
+	format: "html",
+	root
+}));
+const ngHtmlParser = (text, fileName, parserContext) => Effect.gen(function* () {
+	const ngParser = yield* Effect.promise(() => import("angular-html-parser"));
 	const { rootNodes, errors } = ngParser.parse(text, {
 		canSelfClose: true,
 		allowHtmComponentClosingTags: true,
 		isTagNameCaseSensitive: true
 	});
-	if (errors.length !== 0) throw htmlErrorFailure(errors, fileName);
-	const scriptsAsPromised = [];
+	if (errors.length !== 0) return yield* htmlErrorFailure(errors, fileName);
+	const scriptEffects = [];
 	const scriptCollector = {
 		visitElement: (el, context) => {
 			const scriptFormat = getScriptType(el);
-			if (scriptFormat) scriptsAsPromised.push(parseScript(el, scriptFormat));
+			if (scriptFormat) scriptEffects.push(parseScript(el, scriptFormat));
 			ngParser.visitAll(scriptCollector, el.children, context);
 		},
 		visitAttribute: () => void 0,
@@ -880,10 +804,9 @@ async function ngHtmlParser(text, fileName, parserContext) {
 		visitDirective: () => void 0
 	};
 	ngParser.visitAll(scriptCollector, rootNodes);
-	return { scripts: await Promise.all(scriptsAsPromised) };
-	async function parseScript(el, scriptFormat) {
-		const ast = await parserContext.parse(elementScriptText(el, text), fileName, scriptFormat);
-		if (ast != null) {
+	return { scripts: yield* Effect.all(scriptEffects) };
+	function parseScript(el, scriptFormat) {
+		return Effect.map(parserContext.parse(elementScriptText(el, text), fileName, scriptFormat), (ast) => {
 			const offset = el.startSourceSpan.end;
 			shiftScriptOffsets(ast, offset.offset);
 			return {
@@ -893,13 +816,12 @@ async function ngHtmlParser(text, fileName, parserContext) {
 					line: offset.line
 				}
 			};
-		}
-		return ast;
+		});
 	}
-}
+});
 function htmlErrorFailure(errors, fileName) {
 	const first = errors.at(0);
-	if (first === void 0) return new ParseFailed({
+	if (first === void 0) return ParseFailed.make({
 		fileName,
 		message: "HTML parser reported errors but first error is missing",
 		location: {
@@ -908,7 +830,7 @@ function htmlErrorFailure(errors, fileName) {
 		},
 		cause: errors
 	});
-	return new ParseFailed({
+	return ParseFailed.make({
 		fileName,
 		message: first.msg,
 		location: toSourceLocation(first.span.start),
@@ -950,7 +872,7 @@ const SVELTE_5 = {
 	major: 5,
 	minor: 0
 };
-const ESTREE_WALKER_MISSING = "estree-walker module without walk export";
+const WALKER_MODULE_MISSING = "walker module without walk export";
 const COMPILER_WALK_MISSING = "svelte/compiler module without walk export";
 const INSTANCE_RANGE_MISSING = "Svelte instance script without a source range";
 const MODULE_RANGE_MISSING = "Svelte module script without a source range";
@@ -1031,75 +953,68 @@ function rangedExpressionOf(payload) {
 * Due to the way Svelte 5 is structured, we can no longer use the typings from Svelte 4, even though
 * we use the legacy AST. The full Svelte 5 migration should update these typings to use the new AST.
 */
-function loadWalker(version, fileName) {
-	return Match.value(isAtLeast(version, SVELTE_5)).pipe(Match.when(true, () => loadWalkerModule(import.meta.resolve("estree-walker"), fileName, ESTREE_WALKER_MISSING)), Match.orElse(() => loadWalkerModule("svelte/compiler", fileName, COMPILER_WALK_MISSING)));
-}
+const loadWalker = (version, fileName) => Match.value(isAtLeast(version, SVELTE_5)).pipe(Match.when(true, () => loadWalkerModule(import.meta.resolve("oxc-walker"), fileName, WALKER_MODULE_MISSING)), Match.orElse(() => loadWalkerModule("svelte/compiler", fileName, COMPILER_WALK_MISSING)));
 /**
 * The specifier is chosen at run time and both modules are optional peers of
 * this package, so neither can be a static import.
 */
-async function loadWalkerModule(specifier, fileName, cause) {
-	const module = await import(specifier);
+const loadWalkerModule = (specifier, fileName, cause) => Effect.gen(function* () {
+	const module = yield* Effect.promise(() => import(specifier));
 	const walk = Match.value(module).pipe(Match.when(isRecordWithWalk, (record) => record.walk), Match.orElse(() => void 0));
-	if (walk === void 0) throw new SvelteWalkerNotFound({
+	if (walk === void 0) return yield* SvelteWalkerNotFound.make({
 		fileName,
 		cause
 	});
 	return walk;
-}
-async function parseSvelte(text, fileName, context) {
-	const { parse: svelteParse, preprocess, VERSION } = await import("svelte/compiler");
-	if (!isAtLeast(VERSION, MINIMUM_SVELTE_VERSION)) throw new SvelteVersionNotSupported({
+});
+const parseSvelte = (text, fileName, context) => Effect.gen(function* () {
+	const { parse: svelteParse, preprocess, VERSION } = yield* Effect.promise(() => import("svelte/compiler"));
+	if (!isAtLeast(VERSION, MINIMUM_SVELTE_VERSION)) return yield* SvelteVersionNotSupported.make({
 		version: VERSION,
 		fileName,
 		cause: `Expected >=3.30`
 	});
-	const walk = await loadWalker(VERSION, fileName);
+	const walk = yield* loadWalker(VERSION, fileName);
 	const lineStarts = computeLineStarts(text);
-	const { replacedCode, scriptMap } = await replaceScripts(text);
+	const { replacedCode, scriptMap } = yield* replaceScripts(text, preprocess);
 	const svelteAst = svelteParse(replacedCode, { filename: fileName });
 	const { remappedModuleScriptRange, remappedScriptRanges } = remapScriptLocations(replacedCode, scriptMap, getModuleScriptRange(svelteAst), getTemplateScriptRanges(svelteAst, walk));
-	const [moduleScript, ...additionalScripts] = await Promise.all([parseTemplateScriptIfDefined(remappedModuleScriptRange), ...remappedScriptRanges.map(parseTemplateScript)]);
 	return {
 		originFileName: fileName,
 		rawContent: text,
 		format: "svelte",
-		root: svelteRoot(moduleScript, additionalScripts)
+		root: svelteRoot(yield* parseTemplateScriptIfDefined(remappedModuleScriptRange, context, text, fileName, lineStarts), yield* Effect.forEach(remappedScriptRanges, (range) => parseTemplateScript(range, context, text, fileName, lineStarts)))
 	};
-	/**
-	* Replaces script tags with placeholders.
-	* This is needed, because svelte's `parse` doesn't support `lang="ts"`.
-	*/
-	async function replaceScripts(code) {
-		const map = /* @__PURE__ */ new Map();
-		let scriptIndex = 0;
+});
+const replaceScripts = (code, preprocess) => {
+	const map = /* @__PURE__ */ new Map();
+	let scriptIndex = 0;
+	return Effect.gen(function* () {
 		return {
-			replacedCode: (await preprocess(code, { script(script) {
+			replacedCode: (yield* Effect.promise(() => preprocess(code, { script(script) {
 				const scriptName = `script${scriptIndex++}`;
 				map.set(scriptName, script);
 				return { code: scriptName };
-			} })).code,
+			} }))).code,
 			scriptMap: map
 		};
-	}
-	async function parseTemplateScriptIfDefined(range) {
-		if (range) return parseTemplateScript(range);
-	}
-	async function parseTemplateScript({ start, end, isExpression, format }) {
-		const scriptText = text.slice(start, end);
-		return {
-			ast: {
-				...await context.parse(scriptText, fileName, format),
-				offset: positionFromOffset(lineStarts, start)
-			},
-			range: {
-				start,
-				end
-			},
-			isExpression
-		};
-	}
-}
+	});
+};
+const parseTemplateScriptIfDefined = (range, context, text, fileName, lineStarts) => Effect.gen(function* () {
+	if (range === void 0) return;
+	return yield* parseTemplateScript(range, context, text, fileName, lineStarts);
+});
+const parseTemplateScript = ({ start, end, isExpression, format }, context, text, fileName, lineStarts) => Effect.map(context.parse(text.slice(start, end), fileName, format), (parsed) => ({
+	ast: {
+		...parsed,
+		offset: positionFromOffset(lineStarts, start)
+	},
+	range: {
+		start,
+		end
+	},
+	isExpression
+}));
 function svelteRoot(moduleScript, additionalScripts) {
 	return Match.value(moduleScript).pipe(Match.when(void 0, () => ({ additionalScripts })), Match.orElse((script) => ({
 		moduleScript: script,
@@ -1725,15 +1640,15 @@ var PrintState = class {
 			case "accessor":
 				this.out += `${fields.kind} `;
 				this.out += this.propertyKeyText(fields.key, fields.computed === true, PREC.Assignment);
-				this.printFunctionValue(fields.value);
+				this.printFunctionTail(fields.value);
 				break;
 			case "method":
 				this.out += `${flagText(fields.async, "async ")}${flagText(fields.generator, "*")}`;
 				this.out += this.propertyKeyText(fields.key, fields.computed === true, PREC.Assignment);
-				this.printFunctionValue(fields.value);
+				this.printFunctionTail(fields.value);
 				break;
 			case "shorthand":
-				this.out += identifierName$1(fields.key);
+				this.out += identifierName(fields.key);
 				break;
 			case "shorthandDefault":
 				this.printShorthandDefaultProperty(fields);
@@ -1746,7 +1661,7 @@ var PrintState = class {
 	}
 	printShorthandDefaultProperty(fields) {
 		const right = this.assignmentNodeText(fields.value.right);
-		this.out += `${identifierName$1(fields.key)} = ${right}`;
+		this.out += `${identifierName(fields.key)} = ${right}`;
 	}
 	propertyKeyText(key, computed, computedPrec) {
 		switch (computed) {
@@ -1765,10 +1680,6 @@ var PrintState = class {
 	printPropertyKeyForClass(key, computed) {
 		this.out += this.propertyKeyText(key, computed, PREC.Sequence);
 	}
-	printFunctionValue(fn) {
-		if (!fn) return;
-		this.printFunctionTail(fn);
-	}
 	printFunctionTail(fn) {
 		this.out += this.typeParametersText(fn.typeParameters);
 		this.out += `(${this.paramsText(fn.params)})`;
@@ -2224,13 +2135,16 @@ var PrintState = class {
 		}
 	}
 	printExpressionStatement(node) {
-		if (node.directive) {
+		if (this.isDirective(node.directive)) {
 			this.out += JSON.stringify(node.directive) + ";";
 			return;
 		}
 		this.printNode(node.expression, PREC.Sequence);
 		this.out += ";";
 	}
+	isDirective(directive) {
+		return directive != null && directive !== "";
+	}
 	printIfStatement(node) {
 		this.out += "if (";
 		this.printNode(node.test, PREC.Sequence);
@@ -3094,12 +3008,12 @@ function propertyForm(fields) {
 	}
 }
 function isShorthandMatch(fields) {
-	return fields.shorthand === true && namesMatch(identifierName$1(fields.key), identifierName$1(fields.value));
+	return fields.shorthand === true && namesMatch(identifierName(fields.key), identifierName(fields.value));
 }
 function isShorthandDefaultMatch(fields) {
-	return fields.shorthand === true && namesMatch(identifierName$1(fields.key), defaultTargetName(fields.value));
+	return fields.shorthand === true && namesMatch(identifierName(fields.key), defaultTargetName(fields.value));
 }
-function identifierName$1(node) {
+function identifierName(node) {
 	switch (nodeKind(node)) {
 		case "Identifier": return node.name;
 		default: return;
@@ -3107,7 +3021,7 @@ function identifierName$1(node) {
 }
 function defaultTargetName(node) {
 	switch (nodeKind(node)) {
-		case "AssignmentPattern": return identifierName$1(node.left);
+		case "AssignmentPattern": return identifierName(node.left);
 		default: return;
 	}
 }
@@ -3376,12 +3290,8 @@ const hashbangOf = (root) => {
 	if (!isHashbang(hashbang)) return null;
 	return hashbang;
 };
-const jsPrint = (file) => {
-	return printProgram(file.root, { hashbang: hashbangOf(file.root) });
-};
-const tsPrint = (file) => {
-	return printProgram(file.root, { hashbang: hashbangOf(file.root) });
-};
+const jsPrint = (file) => printProgram(file.root, { hashbang: hashbangOf(file.root) });
+const tsPrint = (file) => printProgram(file.root, { hashbang: hashbangOf(file.root) });
 function getScriptStart$1(script) {
 	const span = spanOf(script.root);
 	if (span === void 0) throw new Error("Script AST root without start");
@@ -3439,7 +3349,7 @@ function appendStatement(state, script, rawContent, context) {
 /**
 * Node identity: same kind, same span. oxc nodes always carry a range
 * (parsed with `range: true`), which is a stronger identity than the old
-* estree line/column loc.
+* line/column loc.
 */
 function eqNode(a, b) {
 	const identity = nodeIdentity(a);
@@ -3740,7 +3650,13 @@ const arithmeticOperatorReplacements = Object.freeze({
 const ARITHMETIC_OPERATOR_KEYS = Object.keys(arithmeticOperatorReplacements);
 const arithmeticOperatorMutator = (node) => Match.value(node).pipe(Match.when(isArithmeticBinary, (binary) => [withOperator(binary, arithmeticOperatorReplacements[binary.operator])]), Match.orElse(() => NO_MUTANTS));
 function isArithmeticBinary(node) {
-	return node.type === "BinaryExpression" && isSupportedArithmeticOperator(node.operator, node);
+	return isBinaryExpression(node) && isSupportedArithmeticOperator(node.operator, node);
+}
+function isBinaryExpression(node) {
+	return node.type === "BinaryExpression" && !isPrivateInExpression(node);
+}
+function isPrivateInExpression(node) {
+	return node.left.type === "PrivateIdentifier";
 }
 function isSupportedArithmeticOperator(operator, node) {
 	return ARITHMETIC_OPERATOR_KEYS.includes(operator) && !isStringConcatenation(node);
@@ -4087,7 +4003,7 @@ function methodExpressionReplacement(mutation) {
 	return Match.value(mutation.newName).pipe(Match.when(null, () => callExpression(cloneNode(mutation.callee.object), [], mutation.callee.optional === true)), Match.orElse((newName) => renamedMethodCall(mutation, newName)));
 }
 function renamedMethodCall(mutation, newName) {
-	return callExpression(memberExpression(cloneNode(mutation.callee.object), identifier(newName), false, mutation.callee.optional === true), spreadFreeArguments(mutation.call.arguments), mutation.call.optional === true);
+	return callExpression(memberExpression(cloneNode(mutation.callee.object), identifier(newName), mutation.callee.optional === true), spreadFreeArguments(mutation.call.arguments), mutation.call.optional === true);
 }
 function spreadFreeArguments(args) {
 	return args.filter(isNotSpreadElement).map((argument) => cloneNode(argument));
@@ -4277,13 +4193,13 @@ const allMutators = Object.freeze({
 	UnaryOperator: unaryOperatorMutator,
 	UpdateOperator: updateOperatorMutator
 });
-S.TaggedError("@systemfsoftware/stryker-js-instrumenter/PlacementFailed")("PlacementFailed", {
+S.TaggedError("@systemfsoftware/stryker-js-instrumenter/Transformer.schema/PlacementFailed")("PlacementFailed", {
 	fileName: S.String,
 	placerName: S.String,
 	mutantIds: S.Array(S.String),
 	cause: S.Defect()
 });
-S.TaggedError("@systemfsoftware/stryker-js-instrumenter/TransformFailed")("TransformFailed", {
+S.TaggedError("@systemfsoftware/stryker-js-instrumenter/Transformer.schema/TransformFailed")("TransformFailed", {
 	fileName: S.String,
 	cause: S.Defect()
 });
@@ -4392,32 +4308,10 @@ function mutatorWarning(directive, mutatorName, originFileName) {
 		onSome: (scope) => `${directive.type} ${scope}`
 	})}' directive. Mutator with name '${mutatorName}' not found. Directive found at: ${originFileName}:${loc.start.line}:${loc.start.column}.`;
 }
-function toIgnorerPath(path) {
-	let parentResult = null;
-	if (path.parentPath !== null) parentResult = toIgnorerPath(path.parentPath);
-	const node = path.node;
-	return {
-		node: path.node,
-		parentPath: parentResult,
-		isObjectExpression() {
-			return nodeType(node) === "ObjectExpression";
-		},
-		isCallExpression() {
-			return nodeType(node) === "CallExpression";
-		},
-		isClassProperty() {
-			return nodeType(node) === "PropertyDefinition";
-		},
-		isClassPrivateProperty() {
-			return nodeType(node) === "PropertyDefinition" && nodeType(propertyKeyOf(node)) === "PrivateIdentifier";
-		},
-		isClassAccessorProperty() {
-			return nodeType(node) === "AccessorProperty";
-		}
-	};
-}
-function propertyKeyOf(node) {
-	return Option.getOrUndefined(Option.map(Option.filter(Option.some(node), Predicate.hasProperty("key")), (holder) => holder["key"]));
+function ancestorsOf(path) {
+	const ancestors = [];
+	for (let current = path.parentPath; current !== null; current = current.parentPath) ancestors.push(current.node);
+	return ancestors;
 }
 function isTypeNode(path) {
 	return [
@@ -4477,27 +4371,35 @@ function nodeOfKind(mutant, node, isKind, kind) {
 	if (!isKind(node)) throw new Error(`Cannot place mutant ${mutant.id}: expected ${kind}, got ${node.type}`);
 	return node;
 }
-function throwPlacementError(error, nodePath, placer, mutants, fileName, lineTable) {
-	const message = `${placer.name} could not place mutants with type(s): "${new Intl.ListFormat("en").format(mutants.map((mutant) => mutant.mutatorName))}"`;
-	const errorMessage = `${placementLocation(nodePath.node, fileName, lineTable)} ${message}. Either remove this file from the list of files to be mutated, or exclude the mutator (using ${propertyPath()("mutator", "excludedMutations")}). Please report this issue at ${strykerReportBugUrl(message)}. Original error: ${error.stack}`;
+function throwPlacementError(error, nodePath, placer, mutants, fileName, lineTable, basePath) {
+	const message = `${placer.name} could not place mutants with type(s): "${placementListFormat.format(mutants.map((mutant) => mutant.mutatorName))}"`;
+	const errorMessage = `${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: ${error.stack}`;
 	throw new Error(errorMessage);
 }
-function placementLocation(node, fileName, lineTable) {
-	const relativeFile = path$1.relative(process.cwd(), fileName);
+function placementLocation(node, fileName, lineTable, basePath) {
+	const relativeFile = basePath === void 0 ? fileName : relativeTo(basePath, fileName);
 	const position = Option.map(Option.fromNullishOr(spanOf(node)), (span) => positionFromLineTable(span.start, lineTable));
 	return Option.match(position, {
 		onNone: () => `${relativeFile}:undefined:undefined`,
 		onSome: (at) => `${relativeFile}:${at.line}:${at.column}`
 	});
 }
+const placementListFormat = new Intl.ListFormat("en");
+const normalizeSeparators = (value) => value.replace(/\\/g, "/");
+const withTrailingSlash = (basePath) => {
+	const normalized = normalizeSeparators(basePath);
+	return normalized.endsWith("/") ? normalized : `${normalized}/`;
+};
+const relativeTo = (basePath, fileName) => {
+	const prefix = withTrailingSlash(basePath);
+	const normalizedFile = normalizeSeparators(fileName);
+	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));
 }
 function nameFromParent(path, node) {
-	return Match.value(path.parentPath?.node).pipe(Match.when({
-		type: "VariableDeclarator",
-		id: { type: "Identifier" }
-	}, (declarator) => adoptIdentifier(node, declarator.id)), Match.when({
+	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));
@@ -4530,10 +4432,22 @@ function namedArrowExpression(node, identifier) {
 	return callExpression(arrowFunctionExpression([], blockStatement([variableDeclaration("const", [variableDeclarator(identifier, node)]), returnStatement(identifier)])), []);
 }
 function declaratorIdentifier(parentPath) {
-	return Option.flatMap(Option.fromNullishOr(parentPath), (parent) => Match.value(parent.node).pipe(Match.when({
-		type: "VariableDeclarator",
-		id: { type: "Identifier" }
-	}, (declarator) => Option.some(declarator.id)), Match.orElse(() => Option.none())));
+	return Option.flatMap(Option.fromNullishOr(parentPath), (parent) => Match.value(parent.node).pipe(Match.when(isVariableDeclarator, (declarator) => declaredName(declarator)), Match.orElse(() => Option.none())));
+}
+function isVariableDeclarator(node) {
+	return nodeType(node) === "VariableDeclarator";
+}
+function adoptDeclaredName(node, declarator) {
+	return Option.match(declaredName(declarator), {
+		onNone: () => void 0,
+		onSome: (identifier) => adoptIdentifier(node, identifier)
+	});
+}
+function declaredName(declarator) {
+	return Match.value(declarator.id).pipe(Match.when(isIdentifierReference, (identifier) => Option.some(identifier)), Match.orElse(() => Option.none()));
+}
+function isIdentifierReference(node) {
+	return nodeType(node) === "Identifier";
 }
 function nameIfAnonymous(path) {
 	return classOrFunctionExpressionNamedIfNeeded(path) ?? arrowNameOrNode(path);
@@ -4668,139 +4582,9 @@ const allMutantPlacers = Object.freeze([
 		}
 	}
 ]);
-const ANGULAR_SIGNAL_IO_FUNCTIONS = Object.freeze([
-	"input",
-	"model",
-	"output"
-]);
-const ANGULAR_SIGNAL_QUERY_FUNCTIONS = Object.freeze([
-	"contentChild",
-	"contentChildren",
-	"viewChild",
-	"viewChildren"
-]);
-const INPUT_MODEL_OUTPUT_CONFIG_MSG = "Angular signal based input, model and output functions configuration object cannot be mutated as that causes issues with the Angular compiler.";
-const SIGNAL_QUERY_OPTIONS_MSG = "Angular signal query options object cannot be mutated as that causes issues with the Angular compiler.";
-function shouldIgnore(path) {
-	return Option.orElse(reasonAt(path), () => ancestorReason(path));
-}
-function reasonAt(path) {
-	return Match.value(path).pipe(Match.when(isInputModelOrOutputConfigurationObject, () => Option.some(INPUT_MODEL_OUTPUT_CONFIG_MSG)), Match.when(isSignalQueryOptionsObject, () => Option.some(SIGNAL_QUERY_OPTIONS_MSG)), Match.orElse(() => Option.none()));
-}
-function ancestorReason(path) {
-	return Option.flatMap(Option.fromNullishOr(path.parentPath), shouldIgnore);
-}
-const angularIgnorer = { shouldIgnore };
-function isClassFieldLike(path) {
-	return CLASS_FIELD_KINDS.includes(nodeType(path.node) ?? "");
-}
-const CLASS_FIELD_KINDS = Object.freeze(["PropertyDefinition", "AccessorProperty"]);
-function isInputModelOrOutputConfigurationObject(path) {
-	return Option.match(signalCallSiteOf(path, isPropertyDefinitionField), {
-		onNone: () => false,
-		onSome: (site) => isArgumentAt(site, signalIoArgumentIndex(site.callee))
-	});
-}
-function isSignalQueryOptionsObject(path) {
-	return Option.match(signalCallSiteOf(path, isClassFieldLike), {
-		onNone: () => false,
-		onSome: (site) => isSignalQueryCall(site.callee) && isArgumentAt(site, Option.some(1))
-	});
-}
-function isPropertyDefinitionField(path) {
-	return nodeType(path.node) === "PropertyDefinition";
-}
-/** The call that takes the object expression as an argument, when a field-like member owns it. */
-function signalCallSiteOf(path, ownsCallSite) {
-	return Option.flatMap(ownedCallPath(path, ownsCallSite), (callPath) => Option.map(callArgumentsOf(callPath), (call) => ({
-		...call,
-		objectExpression: path
-	})));
-}
-function ownedCallPath(path, ownsCallSite) {
-	const argument = Option.filter(Option.some(path), (candidate) => isOwnedCallArgument(candidate, ownsCallSite));
-	return Option.flatMap(argument, (candidate) => Option.fromNullishOr(candidate.parentPath));
-}
-function isOwnedCallArgument(path, ownsCallSite) {
-	return isObjectArgumentOfCall(path) && ownsCallSiteOf(path, ownsCallSite);
-}
-function isObjectArgumentOfCall(path) {
-	return nodeType(path.node) === "ObjectExpression" && parentIsCallExpression(path);
-}
-function parentIsCallExpression(path) {
-	return nodeType(path.parentPath?.node) === "CallExpression";
-}
-function ownsCallSiteOf(path, ownsCallSite) {
-	return Option.exists(Option.fromNullishOr(path.parentPath?.parentPath), ownsCallSite);
-}
-function callArgumentsOf(callPath) {
-	return Option.flatMap(Option.filter(Option.some(callPath.node), hasCallShape), (call) => Option.map(argumentArrayOf(call["arguments"]), (args) => ({
-		callee: call["callee"],
-		args
-	})));
-}
-function hasCallShape(callNode) {
-	return Predicate.hasProperty(callNode, "callee") && Predicate.hasProperty(callNode, "arguments");
-}
-function argumentArrayOf(argument) {
-	return Option.filter(Option.some(argument), isUnknownArray);
-}
-function isUnknownArray(value) {
+function isCommentArray(value) {
 	return Array.isArray(value);
 }
-function signalIoArgumentIndex(callee) {
-	return Match.value(callee).pipe(Match.when(isRequiredSignalIoCall, () => Option.some(0)), Match.when(isOutputCall, () => Option.some(0)), Match.when(isSignalIoCall, () => Option.some(1)), Match.orElse(() => Option.none()));
-}
-function isRequiredSignalIoCall(callee) {
-	return isMemberExpressionWithIdentifier(callee, ANGULAR_SIGNAL_IO_FUNCTIONS, "required");
-}
-function isOutputCall(callee) {
-	return isIdentifierWithName(callee, "output");
-}
-function isSignalIoCall(callee) {
-	return isIdentifierIn(callee, ANGULAR_SIGNAL_IO_FUNCTIONS);
-}
-function isSignalQueryCall(callee) {
-	return isIdentifierIn(callee, ANGULAR_SIGNAL_QUERY_FUNCTIONS) || isMemberExpressionWithIdentifier(callee, ANGULAR_SIGNAL_QUERY_FUNCTIONS, "required");
-}
-function isArgumentAt(site, index) {
-	return Option.exists(index, (position) => site.args.length > position && site.args[position] === site.objectExpression.node);
-}
-function isIdentifierWithName(node, name) {
-	return Option.contains(identifierName(node), name);
-}
-function isIdentifierIn(node, names) {
-	return Option.exists(identifierName(node), (name) => names.includes(name));
-}
-function identifierName(node) {
-	return Option.map(identifierNode(node), (identifier) => identifier.name);
-}
-function identifierNode(node) {
-	return Option.filter(Option.some(node), isNamedIdentifier);
-}
-function isNamedIdentifier(node) {
-	return hasNodeType(node, "Identifier") && isStringProperty(node, "name");
-}
-function hasNodeType(node, type) {
-	return Predicate.hasProperty(node, "type") && node["type"] === type;
-}
-function isStringProperty(node, property) {
-	return Predicate.hasProperty(node, property) && typeof node[property] === "string";
-}
-function isMemberExpressionWithIdentifier(node, objectNames, propertyName) {
-	return Option.exists(memberPartsOf(node), (member) => isIdentifierIn(member.object, objectNames) && isIdentifierWithName(member.property, propertyName));
-}
-function memberPartsOf(node) {
-	return Option.filter(Option.some(node), isMemberExpressionRecord);
-}
-function isMemberExpressionRecord(node) {
-	return hasNodeType(node, "MemberExpression") && isPropertyBearing(node);
-}
-function isPropertyBearing(node) {
-	return Predicate.hasProperty(node, "object") && Predicate.hasProperty(node, "property");
-}
-const strykerPlugins = [];
-const frameworkPluginsFileUrl = import.meta.url;
 const INSTRUMENTATION_HEADER_SOURCE = `// @ts-nocheck
 var ${STRYKER_NAMESPACE_HELPER} = function(){
   var g = typeof globalThis === 'object' && globalThis && globalThis.Math === Math && globalThis || new Function("return this")();
@@ -4847,32 +4631,29 @@ var ${IS_MUTANT_ACTIVE_HELPER} = function(id) {
   return isActive(id);
 }`;
 let instrumentationHeaderValue;
-const instrumentationHeader = async () => {
+const instrumentationHeader = Effect.gen(function* () {
 	if (instrumentationHeaderValue === void 0) {
-		instrumentationHeaderValue = (await parseWithOxc(INSTRUMENTATION_HEADER_SOURCE, "instrumenter-header.js", "js")).root.body;
+		instrumentationHeaderValue = (yield* parseWithOxc(INSTRUMENTATION_HEADER_SOURCE, "instrumenter-header.js", "js")).root.body;
 		deepFreeze(instrumentationHeaderValue);
 	}
 	return instrumentationHeaderValue;
-};
-async function placeHeaderIfNeeded(mutantCollector, originFileName, options, root) {
-	if (shouldPlaceHeader(mutantCollector, originFileName, options)) await placeHeader(root);
-}
+});
+const placeHeaderIfNeeded = (mutantCollector, originFileName, options, root) => Effect.gen(function* () {
+	if (shouldPlaceHeader(mutantCollector, originFileName, options)) yield* placeHeader(root);
+});
+const placeHeader = (root) => Effect.map(headerFor(root), (header) => {
+	root.body.unshift(...header);
+});
 function shouldPlaceHeader(mutantCollector, originFileName, options) {
 	return hasPlacedMutants(mutantCollector, originFileName) && options.noHeader !== true;
 }
-async function placeHeader(root) {
-	root.body.unshift(...await headerFor(root));
-}
-async function headerFor(root) {
-	const header = await instrumentationHeader();
-	return Option.match(leadingCommentsOf(root), {
-		onNone: () => header,
-		onSome: (leadingComments) => [commentedHeader(leadingComments, header), ...header.slice(1)]
-	});
-}
+const headerFor = (root) => Effect.map(instrumentationHeader, (header) => Option.match(leadingCommentsOf(root), {
+	onNone: () => header,
+	onSome: (leadingComments) => [commentedHeader(leadingComments, header), ...header.slice(1)]
+}));
 function leadingCommentsOf(root) {
 	const firstStatement = root.body[0];
-	return Option.filter(Option.fromNullishOr(firstStatement?.leadingComments), isUnknownArray);
+	return Option.filter(Option.fromNullishOr(firstStatement?.leadingComments), isCommentArray);
 }
 function commentedHeader(leadingComments, header) {
 	const cloned = cloneNode(Option.getOrThrowWith(Option.fromNullishOr(header[0]), () => /* @__PURE__ */ new Error("Instrumentation header is empty")));
@@ -4915,7 +4696,7 @@ function isMap(value) {
 function isSet(value) {
 	return value instanceof Set;
 }
-async function transform(ast, mutantCollector, transformerContext) {
+const transform = (ast, mutantCollector, transformerContext) => {
 	const context = {
 		...transformerContext,
 		transform
@@ -4927,32 +4708,27 @@ async function transform(ast, mutantCollector, transformerContext) {
 		case "tsx": return transformScript(ast, mutantCollector, context);
 		case "svelte": return transformSvelte(ast, mutantCollector, context);
 	}
-}
-const transformHtml = async ({ root }, mutantCollector, context) => {
-	const warnings = [];
-	for (const script of root.scripts) warnings.push(...await context.transform(script, mutantCollector, context));
-	return warnings;
 };
+const transformHtml = ({ root }, mutantCollector, context) => Effect.map(Effect.forEach(root.scripts, (script) => context.transform(script, mutantCollector, context)), (perScript) => perScript.flat());
 const moduleScript = `<script context="module">
 \n<\/script>\n`;
-const transformSvelte = async (svelte, mutantCollector, context) => {
-	const warnings = [];
+const transformSvelte = (svelte, mutantCollector, context) => Effect.gen(function* () {
 	const { root } = svelte;
 	const scripts = [root.moduleScript, ...root.additionalScripts].filter(Predicate.isNotNullish);
-	for (const script of scripts) warnings.push(...await context.transform(script.ast, mutantCollector, {
+	const warnings = (yield* Effect.forEach(scripts, (script) => context.transform(script.ast, mutantCollector, {
 		...context,
 		options: {
 			...context.options,
 			noHeader: true
 		}
-	}));
-	await placeModuleHeaderIfNeeded(svelte, mutantCollector);
+	}))).flat();
+	yield* placeModuleHeaderIfNeeded(svelte, mutantCollector);
 	return warnings;
-};
-async function placeModuleHeaderIfNeeded(svelte, mutantCollector) {
-	if (hasPlacedMutants(mutantCollector, svelte.originFileName)) await placeModuleHeader(svelte);
-}
-async function placeModuleHeader(svelte) {
+});
+const placeModuleHeaderIfNeeded = (svelte, mutantCollector) => Effect.gen(function* () {
+	if (hasPlacedMutants(mutantCollector, svelte.originFileName)) yield* placeModuleHeader(svelte);
+});
+const placeModuleHeader = (svelte) => Effect.gen(function* () {
 	const { root, originFileName } = svelte;
 	if (!root.moduleScript) {
 		root.moduleScript = {
@@ -4975,162 +4751,161 @@ async function placeModuleHeader(svelte) {
 			script.range.end += moduleScript.length;
 		});
 	}
-	await placeHeader(root.moduleScript.ast.root);
-}
+	yield* placeHeader(root.moduleScript.ast.root);
+});
 function emptyProgram() {
 	return {
 		type: "Program",
 		sourceType: "module",
-		body: []
+		body: [],
+		hashbang: null
 	};
 }
+const emptyAppliedMutants = () => /* @__PURE__ */ new Map();
 function isMutateRangeList(value) {
 	return Array.isArray(value);
 }
-const transformScript = async ({ root, originFileName, rawContent, offset, comments }, mutantCollector, { options, mutateDescription }, mutators, mutantPlacers) => {
-	const lineTable = buildLineTable(rawContent);
-	attachComments(root, comments, lineTable);
+const transformScript = ({ root, originFileName, rawContent, offset, comments }, mutantCollector, { options, mutateDescription, basePath }, mutators, mutantPlacers) => {
 	const placementMap = /* @__PURE__ */ new Map();
-	let directiveRule = rootRule;
-	const mutatorEntries = Object.entries(Option.getOrElse(Option.fromNullishOr(mutators), () => allMutators));
-	const placers = Option.getOrElse(Option.fromNullishOr(mutantPlacers), () => allMutantPlacers);
-	const allMutatorNames = mutatorEntries.map(([name]) => name.toLowerCase());
-	const warnings = [];
-	traverse(root, {
-		enter(path) {
-			const result = processStrykerDirectives(directiveRule, path.node, allMutatorNames, originFileName);
-			directiveRule = result.rule;
-			warnings.push(...result.warnings);
-			visitNode(path);
-		},
-		exit(path) {
-			const placement = placementMap.get(path.node);
-			if (hasAppliedMutants(placement)) applyPlacement(path, placement);
+	return Effect.gen(function* () {
+		const lineTable = buildLineTable(rawContent);
+		attachComments(root, comments, lineTable);
+		let directiveRule = rootRule;
+		const mutatorEntries = Object.entries(Option.getOrElse(Option.fromNullishOr(mutators), () => allMutators));
+		const placers = Option.getOrElse(Option.fromNullishOr(mutantPlacers), () => allMutantPlacers);
+		const allMutatorNames = mutatorEntries.map(([name]) => name.toLowerCase());
+		const warnings = [];
+		traverse(root, {
+			enter(path) {
+				const result = processStrykerDirectives(directiveRule, path.node, allMutatorNames, originFileName);
+				directiveRule = result.rule;
+				warnings.push(...result.warnings);
+				visitNode(path);
+			},
+			exit(path) {
+				const placement = placementMap.get(path.node);
+				if (hasAppliedMutants(placement)) applyPlacement(path, placement);
+			}
+		});
+		yield* placeHeaderIfNeeded(mutantCollector, originFileName, options, root);
+		return warnings;
+		function visitNode(path) {
+			if (shouldSkip(path)) {
+				path.skip();
+				return;
+			}
+			addToPlacementMapIfPossible(path);
+			placeCollectedMutantsIfMutating(path);
 		}
-	});
-	await placeHeaderIfNeeded(mutantCollector, originFileName, options, root);
-	return warnings;
-	function visitNode(path) {
-		if (shouldSkip(path)) {
-			path.skip();
-			return;
+		function addToPlacementMapIfPossible(path) {
+			const placer = placers.find((candidate) => candidate.canPlace(path));
+			if (placer !== void 0) placementMap.set(path.node, {
+				appliedMutants: emptyAppliedMutants(),
+				placer
+			});
 		}
-		addToPlacementMapIfPossible(path);
-		placeCollectedMutantsIfMutating(path);
-	}
-	function addToPlacementMapIfPossible(path) {
-		const placer = placers.find((candidate) => candidate.canPlace(path));
-		if (placer !== void 0) placementMap.set(path.node, {
-			appliedMutants: /* @__PURE__ */ new Map(),
-			placer
-		});
-	}
-	function hasAppliedMutants(placement) {
-		return placement !== void 0 && placement.appliedMutants.size > 0;
-	}
-	function applyPlacement(path, placement) {
-		try {
-			placement.placer.place(path, placement.appliedMutants);
-			path.skip();
-		} catch (error) {
-			throwPlacementError(toError(error), path, placement.placer, [...placement.appliedMutants.keys()], originFileName, lineTable);
+		function hasAppliedMutants(placement) {
+			return placement !== void 0 && placement.appliedMutants.size > 0;
 		}
-	}
-	function placeCollectedMutantsIfMutating(path) {
-		if (shouldMutate(path)) placeCollectedMutants(path);
-	}
-	function placeCollectedMutants(path) {
-		const mutantsToPlace = collectMutants(path);
-		if (mutantsToPlace.length === 0) return;
-		const placementPath = requiredPlacementPath(path, mutantsToPlace);
-		const placement = requiredPlacement(placementPath.node);
-		mutantsToPlace.forEach((mutant) => {
-			placement.appliedMutants.set(mutant, applyMutant(mutant, placementPath.node));
-		});
-	}
-	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: positionFromLineTable(span.start, lineTable),
-			end: positionFromLineTable(span.end, lineTable)
-		};
-	}
-	function ignoreMessageFor(path) {
-		return Option.getOrUndefined(ignorerReason(toIgnorerPath(path)));
-	}
-	function ignorerReason(view) {
-		return options.ignorers.reduce((reason, ignorer) => Option.orElse(reason, () => ignorer.shouldIgnore(view)), Option.none());
-	}
-	function collectMutants(path) {
-		return mutablesFor(path).map((mutable) => collect(mutantCollector, originFileName, path.node, mutable, offset, lineTable)).filter((mutant) => mutant.ignoreReason === void 0);
-	}
-	function mutablesFor(path) {
-		const context = toMutatorContext(path);
-		const line = getNodeLocation(path.node).start.line;
-		return mutatorEntries.flatMap(([mutatorName, mutate]) => [...mutate(path.node, context)].map((replacement) => mutableFor(path, mutatorName, replacement, line)));
-	}
-	function mutableFor(path, mutatorName, replacement, line) {
-		const mutableEntry = {
-			replacement,
-			mutatorName
-		};
-		const ignoreReason = ignoreReasonFor(path, mutatorName, line);
-		if (ignoreReason !== void 0) mutableEntry.ignoreReason = ignoreReason;
-		return mutableEntry;
-	}
-	function ignoreReasonFor(path, mutatorName, line) {
-		return directiveOrExclusion(mutatorName, line) ?? ignoreMessageFor(path);
-	}
-	function directiveOrExclusion(mutatorName, line) {
-		return findIgnoreReason(directiveRule, mutatorName, line) ?? findExcludedMutatorIgnoreReason(mutatorName);
-	}
-	function findExcludedMutatorIgnoreReason(mutatorName) {
-		if (options.excludedMutations.includes(mutatorName)) return `Ignored because of excluded mutation "${mutatorName}"`;
-		else return;
-	}
+		function applyPlacement(path, placement) {
+			try {
+				placement.placer.place(path, placement.appliedMutants);
+				path.skip();
+			} catch (error) {
+				throwPlacementError(toError(error), path, placement.placer, [...placement.appliedMutants.keys()], originFileName, lineTable, basePath);
+			}
+		}
+		function placeCollectedMutantsIfMutating(path) {
+			if (shouldMutate(path)) placeCollectedMutants(path);
+		}
+		function placeCollectedMutants(path) {
+			const mutantsToPlace = collectMutants(path);
+			if (mutantsToPlace.length === 0) return;
+			const placementPath = requiredPlacementPath(path, mutantsToPlace);
+			const placement = requiredPlacement(placementPath.node);
+			mutantsToPlace.forEach((mutant) => {
+				placement.appliedMutants.set(mutant, applyMutant(mutant, placementPath.node));
+			});
+		}
+		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: positionFromLineTable(span.start, lineTable),
+				end: positionFromLineTable(span.end, lineTable)
+			};
+		}
+		function ignoreMessageFor(node, ancestors) {
+			return ignorerReason(node, ancestors);
+		}
+		function ignorerReason(node, ancestors) {
+			return options.ignorers.map((ignorer) => ignorer.shouldIgnore(node, ancestors)).find((reason) => reason !== void 0);
+		}
+		function collectMutants(path) {
+			return mutablesFor(path).map((mutable) => collect(mutantCollector, originFileName, path.node, mutable, offset, lineTable)).filter((mutant) => mutant.ignoreReason === void 0);
+		}
+		function mutablesFor(path) {
+			const ancestors = ancestorsOf(path);
+			const context = toMutatorContext(ancestors);
+			const line = getNodeLocation(path.node).start.line;
+			return mutatorEntries.flatMap(([mutatorName, mutate]) => [...mutate(path.node, context)].map((replacement) => mutableFor(path.node, ancestors, mutatorName, replacement, line)));
+		}
+		function mutableFor(node, ancestors, mutatorName, replacement, line) {
+			const mutableEntry = {
+				replacement,
+				mutatorName
+			};
+			const ignoreReason = ignoreReasonFor(node, ancestors, mutatorName, line);
+			if (ignoreReason !== void 0) mutableEntry.ignoreReason = ignoreReason;
+			return mutableEntry;
+		}
+		function ignoreReasonFor(node, ancestors, mutatorName, line) {
+			return directiveOrExclusion(mutatorName, line) ?? ignoreMessageFor(node, ancestors);
+		}
+		function directiveOrExclusion(mutatorName, line) {
+			return findIgnoreReason(directiveRule, mutatorName, line) ?? findExcludedMutatorIgnoreReason(mutatorName);
+		}
+		function findExcludedMutatorIgnoreReason(mutatorName) {
+			if (options.excludedMutations.includes(mutatorName)) return `Ignored because of excluded mutation "${mutatorName}"`;
+			else return;
+		}
+	});
 };
-function toMutatorContext(path) {
-	const ancestors = [];
-	let current = path.parentPath;
-	while (current !== null) {
-		ancestors.push(current.node);
-		current = current.parentPath;
-	}
+function toMutatorContext(ancestors) {
 	return {
 		parent: ancestors[0],
 		grandParent: ancestors[1],
-		ancestors
+		ancestors: [...ancestors]
 	};
 }
 function toError(value) {
@@ -5142,18 +4917,22 @@ function toError(value) {
 const commentDirectiveRegEx = /^(\s*)@(ts-[a-z-]+).*$/;
 const tsDirectiveLikeRegEx = /@(ts-[a-z-]+)/;
 const STARTING_COMMENT = /^\s*\/\*[\s\S]*?\*\//;
-async function disableTypeChecks(file) {
+const disableTypeChecks = (file) => {
 	const format = getFormat(file.name);
-	if (format === void 0) return file;
+	if (format === void 0) return Effect.succeed(file);
 	return disableTypeChecksFor(file, format);
-}
-async function disableTypeChecksFor(file, format) {
-	if (isJSFileWithoutTSDirectives(file, format)) return {
+};
+const disableTypeChecksFor = (file, format) => {
+	if (isJSFileWithoutTSDirectives(file, format)) return Effect.succeed({
 		...file,
 		content: prefixWithNoCheck(file.content)
-	};
-	return withDisabledTypeChecking(file, await createParser()(file.content, file.name));
-}
+	});
+	const parse = createParser();
+	return Effect.map(parse(file.content, file.name).pipe(Effect.mapError((cause) => InstrumentError.make({
+		message: `Failed to parse ${file.name}`,
+		cause
+	}))), (ast) => withDisabledTypeChecking(file, ast));
+};
 function withDisabledTypeChecking(file, ast) {
 	switch (ast.format) {
 		case "js":
@@ -5278,13 +5057,13 @@ function toOneBasedLineNumber(range) {
 		}
 	}));
 }
-function isIgnorerService(value) {
+function isIgnorer(value) {
 	return Predicate.isObject(value) && typeof value["shouldIgnore"] === "function";
 }
 function toTransformerOptions(options) {
 	const base = {
 		excludedMutations: [...options.excludedMutations],
-		ignorers: options.ignorers.filter(isIgnorerService)
+		ignorers: options.ignorers.filter(isIgnorer)
 	};
 	if (options.noHeader !== void 0) return {
 		...base,
@@ -5296,54 +5075,6 @@ const AST_SHAPE = ["format", "root"];
 function isAst(value) {
 	return Predicate.isObject(value) && AST_SHAPE.every((key) => key in value);
 }
-const readCollected = (command) => Effect.gen(function* () {
-	const { files, options } = command;
-	const parse = createParser();
-	const parsed = yield* Effect.forEach(files, (file) => Effect.map(Effect.tryPromise({
-		try: () => parse(file.content, file.name),
-		catch: (cause) => new InstrumentError({
-			message: `Failed to parse ${file.name}`,
-			cause
-		})
-	}), (ast) => ({
-		file,
-		ast
-	})));
-	const collector = createMutantCollector();
-	yield* Effect.forEach(parsed, ({ file, ast }) => Effect.tryPromise({
-		try: () => transform(ast, collector, {
-			options: toTransformerOptions(options),
-			mutateDescription: toOneBasedLineNumber(file.mutate)
-		}),
-		catch: (cause) => new InstrumentError({
-			message: `Failed to transform ${file.name}`,
-			cause
-		})
-	}));
-	const mutants = yield* Effect.try({
-		try: () => collector.map(toApiMutant),
-		catch: (cause) => new InstrumentError({
-			message: "Failed to instrument",
-			cause
-		})
-	});
-	return {
-		files,
-		options,
-		asts: parsed.map(({ ast }) => ast),
-		mutants
-	};
-});
-const printDecision = (decision) => Effect.try({
-	try: () => InstrumentResult.make({
-		files: decision.files.flatMap((file, index) => printedFile(file, decision.asts[index])),
-		mutants: decision.mutants
-	}),
-	catch: (cause) => new InstrumentError({
-		message: "Failed to print",
-		cause
-	})
-});
 function printedFile(file, ast) {
 	if (!isAst(ast)) return [];
 	return [{
@@ -5352,28 +5083,47 @@ function printedFile(file, ast) {
 		content: print(ast)
 	}];
 }
-const decideInstrument = (decoded) => InstrumentDecision.make({
-	files: decoded.files,
-	mutants: decoded.mutants,
-	asts: decoded.asts
-});
-const instrument = (files, options) => Effect.gen(function* () {
+const instrument = (files, options, basePath) => Effect.gen(function* () {
 	const schemaFiles = files.map((file) => ({
 		name: file.name,
 		content: file.content,
 		mutate: file.mutate
 	}));
-	const collected = yield* readCollected(InstrumentCommand.make({
-		files: schemaFiles,
-		options
-	}));
-	const decision = decideInstrument(InstrumentDecoded.make({
-		files: collected.files,
-		options: collected.options,
-		asts: collected.asts,
-		mutants: collected.mutants
-	}));
-	return yield* printDecision(decision);
+	const parse = createParser();
+	const parsed = yield* Effect.forEach(schemaFiles, (file) => Effect.map(parse(file.content, file.name).pipe(Effect.mapError((cause) => InstrumentError.make({
+		message: `Failed to parse ${file.name}`,
+		cause
+	}))), (ast) => ({
+		file,
+		ast
+	})));
+	const collector = createMutantCollector();
+	yield* Effect.forEach(parsed, ({ file, ast }) => transform(ast, collector, {
+		options: toTransformerOptions(options),
+		mutateDescription: toOneBasedLineNumber(file.mutate),
+		basePath
+	}).pipe(Effect.mapError((cause) => InstrumentError.make({
+		message: `Failed to transform ${file.name}`,
+		cause
+	}))));
+	const mutants = yield* Effect.try({
+		try: () => collector.map(toApiMutant),
+		catch: (cause) => InstrumentError.make({
+			message: "Failed to instrument",
+			cause
+		})
+	});
+	const printed = yield* Effect.try({
+		try: () => parsed.flatMap(({ file, ast }) => printedFile(file, ast)),
+		catch: (cause) => InstrumentError.make({
+			message: "Failed to print",
+			cause
+		})
+	});
+	return InstrumentResult.make({
+		files: printed,
+		mutants
+	});
 });
 //#endregion
-export { angularIgnorer, disableTypeChecks, frameworkPluginsFileUrl, instrument, strykerPlugins };
+export { disableTypeChecks, instrument };