@systemfsoftware/stryker-js-typescript-checker 5.0.0 → 5.0.2

package/dist/index.mjs

@@ -5,17 +5,18 @@ import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";
 import * as S from "effect/Schema";
-import { Cell, Wire, Workflow } from "@systemfsoftware/effect-cell-types";
-import { Mutant, errorToString } from "@systemfsoftware/stryker-js/Mutant";
+import { Cell, Workflow } from "@systemfsoftware/effect-cell-types";
+import { Mutant, errorToString, normalizeFileName } from "@systemfsoftware/stryker-js/Mutant";
 import { Predicate, Result, Schema } from "effect";
 import * as HashMap from "effect/HashMap";
 import * as Match from "effect/Match";
-import * as MutableHashMap from "effect/MutableHashMap";
 import * as Option from "effect/Option";
 import { API, DiagnosticCategory } from "typescript/unstable/sync";
+import * as Arr from "effect/Array";
 import * as Result$1 from "effect/Result";
 import { StrykerOptionsSchema } from "@systemfsoftware/stryker-js/Schema";
 import * as Context from "effect/Context";
+import * as MutableHashMap from "effect/MutableHashMap";
 import * as MutableHashSet from "effect/MutableHashSet";
 import * as Ref from "effect/Ref";
 import { SyntaxKind } from "typescript/unstable/ast";
@@ -39,25 +40,29 @@ var typescript_checker_options_default = {
 	} }
 };
 //#endregion
-//#region src/check-mutants.workflow.ts
-var DiagnosticWithoutFileError = class extends S.TaggedError()("DiagnosticWithoutFileError", { text: Wire.mint(S.String) }) {};
-var DiagnosticInUnrelatedFileError = class extends S.TaggedError()("DiagnosticInUnrelatedFileError", {
-	text: Wire.mint(S.String),
-	fileName: Wire.mint(S.String)
-}) {};
-const DiagnosticSchema = Wire.wire({
-	fileName: Wire.mint(S.optional(Wire.mint(S.String))),
-	text: Wire.mint(S.String)
+//#region src/CheckMutants.schema.ts
+/** A file name the node map can be keyed by: non-empty, and naming an extension. */
+const SourceFileSchema = S.NonEmptyString.pipe(S.check(S.isPattern(/\.[^./\\]+$/)));
+const DiagnosticSchema = S.Struct({
+	fileName: S.optional(SourceFileSchema),
+	text: S.String
 });
-const TSFileNodeSchema = Wire.mint(S.suspend(() => Wire.wire({
-	fileName: Wire.mint(S.String),
-	parents: Wire.mint(S.Array(TSFileNodeSchema)),
-	children: Wire.mint(S.Array(TSFileNodeSchema))
-})));
+const TSFileNodeSchema = S.suspend(() => S.Struct({
+	fileName: SourceFileSchema,
+	parents: S.Array(TSFileNodeSchema),
+	children: S.Array(TSFileNodeSchema)
+}));
 var CheckMutantsInput = class extends S.TaggedClass()("CheckMutantsInput", {
 	mutants: S.Array(Mutant),
 	diagnostics: S.Array(DiagnosticSchema),
-	nodes: Wire.mint(S.Record(Wire.mint(S.String), TSFileNodeSchema))
+	nodes: S.Record(SourceFileSchema, TSFileNodeSchema)
+}) {};
+//#endregion
+//#region src/check-mutants.workflow.ts
+var DiagnosticWithoutFileError = class extends S.TaggedError()("DiagnosticWithoutFileError", { text: S.String }) {};
+var DiagnosticInUnrelatedFileError = class extends S.TaggedError()("DiagnosticInUnrelatedFileError", {
+	text: S.String,
+	fileName: S.String
 }) {};
 const CheckMutantsTypeId = Symbol.for("@systemfsoftware/stryker-js-typescript-checker/CheckMutants");
 const MutantCheckStatusSchema = S.Union([S.Struct({ status: S.Literal("passed") }), S.Struct({
@@ -74,83 +79,90 @@ var RetestRequired = class extends S.TaggedClass()("RetestRequired", {
 	[CheckMutantsTypeId] = CheckMutantsTypeId;
 };
 const normalizeFileName$3 = (fileName) => fileName.replace(/\\/g, "/");
-const getMutantsWithReferenceToChildrenOrSelf = (node, mutants, nodesChecked = []) => {
-	if (nodesChecked.includes(node.fileName)) return [];
-	nodesChecked.push(node.fileName);
-	const relatedMutants = mutants.filter((m) => normalizeFileName$3(m.fileName) === node.fileName);
-	const childResult = node.children.flatMap((c) => getMutantsWithReferenceToChildrenOrSelf(c, mutants, nodesChecked));
-	return [...relatedMutants, ...childResult];
-};
-const classifyDiagnosticsPure = (diagnostics, mutants, nodes) => {
-	const definitive = {};
-	const needsRetest = {};
-	if (diagnostics.length > 0 && mutants.length === 1) {
-		const only = mutants[0];
-		if (only !== void 0) {
-			definitive[only.id] = [...diagnostics];
-			return Result$1.succeed({
-				definitive,
-				needsRetest: []
-			});
-		}
-	}
-	for (const diagnostic of diagnostics) {
-		const fileName = diagnostic.fileName;
-		if (fileName === void 0 || fileName === "") return Result$1.fail(new DiagnosticWithoutFileError({ text: diagnostic.text }));
-		const node = nodes[fileName];
-		if (node === void 0) return Result$1.fail(new DiagnosticInUnrelatedFileError({
+const nodeAt = (fileName, nodes) => Option.filter(Option.fromUndefinedOr(nodes[fileName]), () => Object.hasOwn(nodes, fileName));
+const nodeOf = (diagnostic, nodes) => Option.match(Option.filter(Option.fromUndefinedOr(diagnostic.fileName), (fileName) => fileName !== ""), {
+	onNone: () => Result$1.fail(new DiagnosticWithoutFileError({ text: diagnostic.text })),
+	onSome: (fileName) => Option.match(nodeAt(fileName, nodes), {
+		onNone: () => Result$1.fail(new DiagnosticInUnrelatedFileError({
 			text: diagnostic.text,
 			fileName
-		}));
-		const related = getMutantsWithReferenceToChildrenOrSelf(node, [...mutants]);
-		if (related.length === 0) for (const m of mutants) needsRetest[m.id] = m;
-		else if (related.length === 1) {
-			const only = related[0];
-			if (only !== void 0) {
-				const existing = definitive[only.id];
-				if (existing !== void 0) existing.push(diagnostic);
-				else definitive[only.id] = [diagnostic];
-			}
-		} else for (const m of related) needsRetest[m.id] = m;
-	}
-	const filteredRetest = Object.values(needsRetest).filter((m) => definitive[m.id] === void 0);
-	return Result$1.succeed({
-		definitive,
-		needsRetest: filteredRetest
-	});
-};
-const buildResult = (input) => {
-	const mutants = input.mutants;
-	const diagnostics = input.diagnostics;
-	const nodes = input.nodes;
-	if (mutants.length === 0) return Result$1.succeed(CheckFinished.make({ results: {} }));
-	const first = mutants[0];
-	if (first === void 0 || nodes[normalizeFileName$3(first.fileName)] === void 0) {
-		const results = {};
-		for (const m of mutants) results[m.id] = { status: "passed" };
-		return Result$1.succeed(CheckFinished.make({ results }));
-	}
-	const classified = classifyDiagnosticsPure(diagnostics, mutants, nodes);
-	if (Result$1.isFailure(classified)) return Result$1.fail(classified.failure);
-	const { definitive, needsRetest } = classified.success;
-	const retestIds = {};
-	for (const m of needsRetest) retestIds[m.id] = true;
-	const results = {};
-	for (const m of mutants) {
-		const diags = definitive[m.id];
-		if (diags !== void 0) results[m.id] = {
+		})),
+		onSome: (node) => Result$1.succeed(node)
+	})
+});
+const walk = (node, mutants, visited) => Option.match(Option.filter(Option.some(node), (current) => !visited.includes(current.fileName)), {
+	onNone: () => [],
+	onSome: (current) => [...mutants.filter((mutant) => normalizeFileName$3(mutant.fileName) === current.fileName), ...current.children.flatMap((child) => walk(child, mutants, [...visited, current.fileName]))]
+});
+const emptyAccumulator = () => ({
+	definitive: HashMap.empty(),
+	needsRetest: HashMap.empty()
+});
+const addAll = (into, mutants) => mutants.reduce((accumulated, mutant) => HashMap.set(accumulated, mutant.id, mutant), into);
+const appendDiagnostic = (into, mutantId, diagnostic) => HashMap.set(into, mutantId, [...Option.getOrElse(HashMap.get(into, mutantId), () => []), diagnostic]);
+const classifyOne = (state, diagnostic, mutants, nodes) => Result$1.flatMap(nodeOf(diagnostic, nodes), (node) => {
+	const related = walk(node, mutants, []);
+	return Result$1.succeed(Option.match(Option.filter(Arr.head(related), () => related.length === 1), {
+		onSome: (only) => ({
+			definitive: appendDiagnostic(state.definitive, only.id, diagnostic),
+			needsRetest: state.needsRetest
+		}),
+		onNone: () => Option.match(Arr.head(related), {
+			onNone: () => ({
+				definitive: state.definitive,
+				needsRetest: addAll(state.needsRetest, mutants)
+			}),
+			onSome: () => ({
+				definitive: state.definitive,
+				needsRetest: addAll(state.needsRetest, related)
+			})
+		})
+	}));
+});
+const classifyDiagnostics = (diagnostics, mutants, nodes) => Option.match(Option.filter(Option.filter(Arr.head(mutants), () => mutants.length === 1), () => diagnostics.length > 0), {
+	onSome: (only) => Result$1.succeed({
+		definitive: HashMap.set(HashMap.empty(), only.id, [...diagnostics]),
+		needsRetest: []
+	}),
+	onNone: () => Result$1.map(diagnostics.reduce((accumulated, diagnostic) => Result$1.flatMap(accumulated, (state) => classifyOne(state, diagnostic, mutants, nodes)), Result$1.succeed(emptyAccumulator())), (state) => ({
+		definitive: state.definitive,
+		needsRetest: HashMap.toValues(state.needsRetest).filter((mutant) => !HashMap.has(state.definitive, mutant.id))
+	}))
+});
+const passedResults = (mutants) => mutants.map((mutant) => [mutant.id, { status: "passed" }]);
+const checkResults = (mutants, classification) => {
+	const retestIds = classification.needsRetest.reduce((accumulated, mutant) => HashMap.set(accumulated, mutant.id, true), HashMap.empty());
+	return mutants.flatMap((mutant) => Option.match(HashMap.get(classification.definitive, mutant.id), {
+		onSome: (diagnostics) => [[mutant.id, {
 			status: "compileError",
-			reason: diags.map((d) => d.text).join("\n")
-		};
-		else if (retestIds[m.id] !== true) results[m.id] = { status: "passed" };
-	}
-	if (needsRetest.length === 0) return Result$1.succeed(CheckFinished.make({ results }));
-	return Result$1.succeed(RetestRequired.make({
-		results,
-		needsRetest: [...needsRetest]
+			reason: diagnostics.map((entry) => entry.text).join("\n")
+		}]],
+		onNone: () => Option.match(Option.filter(Option.some({ status: "passed" }), () => !HashMap.has(retestIds, mutant.id)), {
+			onSome: (status) => [[mutant.id, status]],
+			onNone: () => []
+		})
 	}));
 };
-const checkMutants = Workflow.make(CheckMutantsInput, (input) => buildResult(input));
+const verdictOf = (mutants, classification) => {
+	const results = Object.fromEntries(checkResults(mutants, classification));
+	return Option.match(Arr.head(classification.needsRetest), {
+		onNone: () => CheckFinished.make({ results }),
+		onSome: () => RetestRequired.make({
+			results,
+			needsRetest: [...classification.needsRetest]
+		})
+	});
+};
+const classify = (input) => Result$1.map(classifyDiagnostics(input.diagnostics, input.mutants, input.nodes), (classification) => verdictOf(input.mutants, classification));
+const withoutDisambiguation = (input) => Option.match(Arr.head(input.mutants), {
+	onNone: () => Option.some(CheckFinished.make({ results: {} })),
+	onSome: (first) => Option.map(Option.filter(Option.some(first), () => !Object.hasOwn(input.nodes, normalizeFileName$3(first.fileName))), () => CheckFinished.make({ results: Object.fromEntries(passedResults(input.mutants)) }))
+});
+const verdict = (input) => Option.match(withoutDisambiguation(input), {
+	onNone: () => classify(input),
+	onSome: (decision) => Result$1.succeed(decision)
+});
+const checkMutants = Workflow.make(CheckMutantsInput, verdict);
 //#endregion
 //#region src/Checker.schema.ts
 /**
@@ -159,6 +171,7 @@ const checkMutants = Workflow.make(CheckMutantsInput, (input) => buildResult(inp
 * Houses the wire types and error variants shared by the capability and its
 * workflow. Decoded at the checker boundary; no I/O.
 */
+const TypescriptCheckerOptionsSchema = S.Struct({ typescriptChecker: S.optional(S.Struct({ prioritizePerformanceOverAccuracy: S.optional(S.Boolean) })) });
 var CheckMutantsCommand = class extends S.TaggedClass()("CheckMutantsCommand", { mutants: S.Array(Mutant) }) {};
 /**
 * Every way the TypeScript compiler can fail while serving a check.
@@ -175,12 +188,7 @@ var CompilerFailed = class extends S.TaggedError()("CompilerFailed", {
 	subject: S.optional(S.String)
 }) {
 	get message() {
-		switch (this.reason) {
-			case "not-initialized": return "The TypeScript compiler was used before it was initialized";
-			case "no-projects": return `No projects were found for ${this.subject ?? "the tsconfig"}`;
-			case "unknown-file-node": return `The file graph has no node for '${this.subject ?? "a file"}', which should not happen`;
-			case "file-not-in-project": return `'${this.subject ?? "a file"}' is part of your TypeScript project but could not be found on disk`;
-		}
+		return Match.value(this.reason).pipe(Match.when("not-initialized", () => "The TypeScript compiler was used before it was initialized"), Match.when("no-projects", () => `No projects were found for ${this.subject ?? "the tsconfig"}`), Match.when("unknown-file-node", () => `The file graph has no node for '${this.subject ?? "a file"}', which should not happen`), Match.when("file-not-in-project", () => `'${this.subject ?? "a file"}' is part of your TypeScript project but could not be found on disk`), Match.exhaustive);
 	}
 };
 //#endregion
@@ -468,6 +476,10 @@ const LOW_EMIT_OPTIONS_FOR_PROJECT_REFERENCES = Object.freeze({
 	declaration: true,
 	composite: true
 });
+const reasonOfThrown = (error) => Match.value(error).pipe(Match.when(Predicate.isError, (thrown) => thrown.message), Match.when(Predicate.isString, (thrown) => thrown), Match.orElse((thrown) => Option.match(Option.filter(Option.fromUndefinedOr(JSON.stringify(thrown)), (text) => text.length > 0), {
+	onNone: () => "a non-Error value was thrown",
+	onSome: (text) => text
+})));
 /**
 * Parses the raw text of a tsconfig file into a typed config, rejecting shapes this package cannot consume.
 * @param fileName The tsconfig file name, used for error reporting
@@ -481,17 +493,9 @@ function parseTsConfig(fileName, jsonText) {
 			reason: error.message
 		}));
 	} catch (error) {
-		let reason;
-		if (error instanceof Error) reason = error.message;
-		else if (typeof error === "string") reason = error;
-		else {
-			const stringified = JSON.stringify(error);
-			if (stringified.length === 0) reason = "a non-Error value was thrown";
-			else reason = stringified;
-		}
 		return Result.fail(new TsConfigParseError({
 			file: fileName,
-			reason
+			reason: reasonOfThrown(error)
 		}));
 	}
 }
@@ -503,36 +507,39 @@ const determineBuildModeEnabled = (tsconfigFileName, fsService) => Effect.gen(fu
 		onSuccess: (config) => config.references !== void 0
 	});
 });
-/**
-* Overrides compiler options to speed up compilation and disable code quality
-* checks irrelevant during mutation testing.
-*/
-function overrideOptions(config, useBuildMode) {
-	let extraOptions;
-	if (useBuildMode) extraOptions = LOW_EMIT_OPTIONS_FOR_PROJECT_REFERENCES;
-	else extraOptions = NO_EMIT_OPTIONS_FOR_SINGLE_PROJECT;
-	const compilerOptions = {
-		...config.compilerOptions,
-		...COMPILER_OPTIONS_OVERRIDES,
-		...extraOptions
-	};
-	if (!useBuildMode && compilerOptions["declarationDir"] !== void 0 && compilerOptions["declarationDir"] !== null) delete compilerOptions["declarationDir"];
-	if (useBuildMode) {
-		delete compilerOptions["inlineSourceMap"];
-		delete compilerOptions["inlineSources"];
-		delete compilerOptions["mapRoute"];
-		delete compilerOptions["sourceRoot"];
-		delete compilerOptions["outFile"];
-	}
-	if (useBuildMode) return JSON.stringify({
+const withCompilerOverrides = (config, extraOptions) => ({
+	...config.compilerOptions,
+	...COMPILER_OPTIONS_OVERRIDES,
+	...extraOptions
+});
+const projectReferencesJson = (config) => {
+	const compilerOptions = withCompilerOverrides(config, LOW_EMIT_OPTIONS_FOR_PROJECT_REFERENCES);
+	delete compilerOptions["inlineSourceMap"];
+	delete compilerOptions["inlineSources"];
+	delete compilerOptions["mapRoute"];
+	delete compilerOptions["sourceRoot"];
+	delete compilerOptions["outFile"];
+	return JSON.stringify({
 		...config,
 		compilerOptions
 	});
+};
+const singleProjectJson = (config) => {
+	const compilerOptions = withCompilerOverrides(config, NO_EMIT_OPTIONS_FOR_SINGLE_PROJECT);
+	if (compilerOptions["declarationDir"] !== null) delete compilerOptions["declarationDir"];
 	const { references: _references, ...withoutReferences } = config;
 	return JSON.stringify({
 		...withoutReferences,
 		compilerOptions
 	});
+};
+/**
+* Overrides compiler options to speed up compilation and disable code quality
+* checks irrelevant during mutation testing.
+*/
+function overrideOptions(config, useBuildMode) {
+	if (useBuildMode) return projectReferencesJson(config);
+	return singleProjectJson(config);
 }
 /**
 * Retrieves the referenced config files based on parsed configuration.
@@ -548,35 +555,71 @@ function retrieveReferencedProjects(config, fromDirName, pathService) {
 //#region src/Compiler.ts
 const normalizeFileName$1 = (fileName) => fileName.replace(/\\/g, "/");
 const findSourceMapRegex = /\/\/# sourceMappingURL=(.+)$/m;
+/** A specifier that resolves relative to the importing file. */
+const relativeSpecifierPattern = /^\.\.?\//;
+/** A file that never belongs to the dependency graph: declarations and dependencies. */
+const ignoredGraphFileNamePattern = /\.d\.ts$|node_modules/;
 function getSourceMappingURL(content) {
 	return findSourceMapRegex.exec(content)?.[1];
 }
 let cachedTSVersion;
-const getTSVersion = (fsService, pathService) => Effect.gen(function* () {
-	if (cachedTSVersion !== void 0) return cachedTSVersion;
+const isString = (value) => typeof value === "string";
+const isNonEmptyString = (value) => value !== void 0 && value !== "";
+const versionFieldOf = (raw) => {
+	if (Predicate.hasProperty(raw, "version")) return Option.some(raw.version);
+	return Option.none();
+};
+const readTypescriptPackageVersion = (fsService, pathService) => Effect.gen(function* () {
 	const urlString = import.meta.resolve("typescript/package.json");
 	const pkgPath = yield* pathService.fromFileUrl(new URL(urlString));
 	const text = yield* fsService.readFileString(pkgPath);
 	const raw = JSON.parse(text);
-	let version = "";
-	if (Predicate.hasProperty(raw, "version") && typeof raw.version === "string") version = raw.version;
+	return Option.getOrElse(Option.flatMap(versionFieldOf(raw), (version) => Option.liftPredicate(version, isString)), () => "");
+});
+const getTSVersion = (fsService, pathService) => Effect.gen(function* () {
+	if (cachedTSVersion !== void 0) return cachedTSVersion;
+	const version = yield* readTypescriptPackageVersion(fsService, pathService);
 	cachedTSVersion = version;
 	return version;
 });
+const minimumSupportedTypeScriptVersion = {
+	major: 7,
+	minor: 0,
+	patch: 0
+};
+const versionComponent = (parts, index) => {
+	const part = parts[index];
+	if (part === void 0) return 0;
+	return Number.parseInt(part, 10);
+};
+/** Drops any pre-release (`-`) or build (`+`) suffix, keeping the numeric base. */
+const parseTypeScriptVersion = (version) => {
+	const parts = version.replace(/[-+][\s\S]*$/, "").split(".");
+	return {
+		major: versionComponent(parts, 0),
+		minor: versionComponent(parts, 1),
+		patch: versionComponent(parts, 2)
+	};
+};
+const compareVersionNumbers = (left, right) => {
+	return [
+		left.major - right.major,
+		left.minor - right.minor,
+		left.patch - right.patch
+	].find((difference) => difference !== 0) ?? 0;
+};
 /**
 * Whether a TypeScript version satisfies `>=7.0.0`. Pre-release suffixes are
 * stripped so `7.0.0-beta` compares as `7.0.0`.
 */
 function isSupportedTypescriptVersion(version) {
-	const dashBase = version.split("-")[0] ?? version;
-	const parts = (dashBase.split("+")[0] ?? dashBase).split(".").map((p) => Number.parseInt(p, 10));
-	const major = parts[0] ?? 0;
-	const minor = parts[1] ?? 0;
-	const patch = parts[2] ?? 0;
-	if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch)) return false;
-	if (major !== 7) return major > 7;
-	if (minor !== 0) return minor > 0;
-	return patch >= 0;
+	const parsed = parseTypeScriptVersion(version);
+	if (![
+		parsed.major,
+		parsed.minor,
+		parsed.patch
+	].every((part) => !Number.isNaN(part))) return false;
+	return compareVersionNumbers(parsed, minimumSupportedTypeScriptVersion) >= 0;
 }
 const guardTSVersion = (fsService, pathService) => Effect.gen(function* () {
 	const version = yield* getTSVersion(fsService, pathService);
@@ -617,13 +660,10 @@ function resetScriptFile(file) {
 function getOffset(file, pos) {
 	const lines = file.originalContent.split("\n");
 	const lineCount = Math.min(pos.line, lines.length);
-	let offset = 0;
-	for (let i = 0; i < lineCount; i++) {
-		const line = lines[i];
-		if (line === void 0) break;
-		offset += line.length + 1;
-	}
-	offset += pos.column;
+	let offset = pos.column;
+	lines.forEach((line, index) => {
+		if (index < lineCount) offset += line.length + 1;
+	});
 	return offset;
 }
 const makeEmptyFilesMap = () => MutableHashMap.empty();
@@ -635,67 +675,63 @@ const setInPlace = (map, key, value) => {
 const makeHybridFileSystem = (fsService) => Effect.gen(function* () {
 	const filesRef = yield* Ref.make(makeEmptyFilesMap());
 	const overridesRef = yield* Ref.make(makeEmptyOverridesMap());
-	const fileNameIsBuildInfo = (fileName) => fileName.endsWith(".tsbuildinfo");
+	const memoryContent = (file) => {
+		if (file === void 0) return null;
+		return file.content;
+	};
+	const readFromSources = (files, overrides, fileName) => {
+		const override = MutableHashMap.get(overrides, fileName);
+		if (Option.isSome(override)) return override.value;
+		return Option.match(MutableHashMap.get(files, fileName), {
+			onNone: () => void 0,
+			onSome: memoryContent
+		});
+	};
+	const existsInSources = (files, overrides, fileName) => {
+		const override = MutableHashMap.get(overrides, fileName);
+		if (Option.isSome(override)) return true;
+		return Option.match(MutableHashMap.get(files, fileName), {
+			onNone: () => void 0,
+			onSome: (file) => file !== void 0
+		});
+	};
 	const fileSystem = {
 		readFile: (fileName) => {
 			const normalized = normalizeFileName$1(fileName);
-			if (fileNameIsBuildInfo(normalized)) return null;
-			const overrideOpt = MutableHashMap.get(overridesRef.ref.current, normalized);
-			if (Option.isSome(overrideOpt)) return overrideOpt.value;
-			const files = filesRef.ref.current;
-			if (MutableHashMap.has(files, normalized)) {
-				const fileOpt = MutableHashMap.get(files, normalized);
-				if (Option.isSome(fileOpt)) {
-					const file = fileOpt.value;
-					if (file !== void 0) return file.content;
-					return null;
-				}
-			}
+			if (normalized.endsWith(".tsbuildinfo")) return null;
+			return readFromSources(filesRef.ref.current, overridesRef.ref.current, normalized);
 		},
 		fileExists: (fileName) => {
 			const normalized = normalizeFileName$1(fileName);
-			if (fileNameIsBuildInfo(normalized)) return false;
-			if (MutableHashMap.has(overridesRef.ref.current, normalized)) return true;
-			const files = filesRef.ref.current;
-			if (MutableHashMap.has(files, normalized)) {
-				const opt = MutableHashMap.get(files, normalized);
-				if (Option.isSome(opt)) return opt.value !== void 0;
-				return false;
-			}
+			if (normalized.endsWith(".tsbuildinfo")) return false;
+			return existsInSources(filesRef.ref.current, overridesRef.ref.current, normalized);
 		},
 		directoryExists: () => void 0,
 		getAccessibleEntries: () => void 0,
 		realpath: () => void 0
 	};
+	const readFileFromDisk = (fileName) => Effect.gen(function* () {
+		const content = yield* fsService.readFileString(fileName).pipe(Effect.orElseSucceed(() => void 0));
+		const file = Option.getOrUndefined(Option.map(Option.fromUndefinedOr(content), (text) => makeScriptFile(text, fileName)));
+		yield* Ref.update(filesRef, (m) => setInPlace(m, fileName, file));
+		return file;
+	});
 	const getFile = (fileName) => Effect.gen(function* () {
 		const normalized = normalizeFileName$1(fileName);
 		const files = yield* Ref.get(filesRef);
-		if (MutableHashMap.has(files, normalized)) {
-			const opt = MutableHashMap.get(files, normalized);
-			if (Option.isSome(opt)) return opt.value;
-		}
-		const content = yield* fsService.readFileString(normalized).pipe(Effect.orElseSucceed(() => void 0));
-		if (content === void 0) {
-			yield* Ref.update(filesRef, (m) => setInPlace(m, normalized, void 0));
-			return;
-		}
-		const file = makeScriptFile(content, normalized);
-		yield* Ref.update(filesRef, (m) => setInPlace(m, normalized, file));
-		return file;
+		const cached = MutableHashMap.get(files, normalized);
+		if (Option.isSome(cached)) return cached.value;
+		return yield* readFileFromDisk(normalized);
 	});
+	const fileForWrite = (existing, data, fileName) => {
+		if (existing === void 0) return makeScriptFile(data, fileName);
+		return withContent(existing, data);
+	};
 	const writeFile = (fileName, data) => Effect.gen(function* () {
 		const normalized = normalizeFileName$1(fileName);
 		const files = yield* Ref.get(filesRef);
-		const existingOpt = MutableHashMap.get(files, normalized);
-		let existing = void 0;
-		if (Option.isSome(existingOpt)) existing = existingOpt.value;
-		if (existing !== void 0) {
-			const next = withContent(existing, data);
-			yield* Ref.update(filesRef, (m) => setInPlace(m, normalized, next));
-		} else {
-			const file = makeScriptFile(data, normalized);
-			yield* Ref.update(filesRef, (m) => setInPlace(m, normalized, file));
-		}
+		const existing = Option.getOrUndefined(MutableHashMap.get(files, normalized));
+		yield* Ref.update(filesRef, (m) => setInPlace(m, normalized, fileForWrite(existing, data, normalized)));
 	});
 	const mutateFile = (fileName, mutant) => Effect.gen(function* () {
 		const file = yield* getFile(fileName);
@@ -707,20 +743,13 @@ const makeHybridFileSystem = (fsService) => Effect.gen(function* () {
 	const resetFile = (fileName) => Effect.gen(function* () {
 		const normalized = normalizeFileName$1(fileName);
 		const files = yield* Ref.get(filesRef);
-		const opt = MutableHashMap.get(files, normalized);
-		let file = void 0;
-		if (Option.isSome(opt)) file = opt.value;
-		if (file !== void 0) {
-			const next = resetScriptFile(file);
-			yield* Ref.update(filesRef, (m) => setInPlace(m, normalized, next));
-		}
+		const file = Option.getOrUndefined(MutableHashMap.get(files, normalized));
+		if (file === void 0) return;
+		yield* Ref.update(filesRef, (m) => setInPlace(m, normalized, resetScriptFile(file)));
 	});
 	const existsInMemory = (fileName) => Effect.gen(function* () {
 		const files = yield* Ref.get(filesRef);
-		const opt = MutableHashMap.get(files, normalizeFileName$1(fileName));
-		let file = void 0;
-		if (Option.isSome(opt)) file = opt.value;
-		return file !== void 0;
+		return Option.getOrUndefined(MutableHashMap.get(files, normalizeFileName$1(fileName))) !== void 0;
 	});
 	const setTsConfigOverrides = (overrides) => Ref.set(overridesRef, overrides);
 	return {
@@ -742,42 +771,50 @@ function makeTSFileNode(fileName) {
 }
 function getAllParentReferencesIncludingSelf(node, allParentReferences = MutableHashSet.empty()) {
 	MutableHashSet.add(allParentReferences, node);
-	for (const parent of node.parents) if (!MutableHashSet.has(allParentReferences, parent)) getAllParentReferencesIncludingSelf(parent, allParentReferences);
+	node.parents.forEach((parent) => collectParentReference(parent, allParentReferences));
 	return allParentReferences;
 }
-function createGroups(mutants, nodes) {
-	const groups = [];
-	const mutantsToGroup = MutableHashSet.fromIterable(mutants);
-	while (MutableHashSet.size(mutantsToGroup) > 0) {
-		const group = [];
-		const groupNodes = MutableHashSet.empty();
-		const nodesToIgnore = MutableHashSet.empty();
-		for (const currentMutant of mutantsToGroup) {
-			const currentNode = findNode(currentMutant.fileName, nodes);
-			if (!MutableHashSet.has(nodesToIgnore, currentNode) && !parentsHaveOverlapWith(currentNode, groupNodes)) {
-				group.push(currentMutant.id);
-				MutableHashSet.add(groupNodes, currentNode);
-				MutableHashSet.remove(mutantsToGroup, currentMutant);
-				addRangeOfNodesToSet(nodesToIgnore, getAllParentReferencesIncludingSelf(currentNode));
-			}
-		}
-		groups.push(group);
-	}
-	return groups;
+function collectParentReference(parent, allParentReferences) {
+	if (MutableHashSet.has(allParentReferences, parent)) return;
+	getAllParentReferencesIncludingSelf(parent, allParentReferences);
 }
 function addRangeOfNodesToSet(nodes, nodesToAdd) {
-	for (const parent of nodesToAdd) MutableHashSet.add(nodes, parent);
+	for (const node of nodesToAdd) MutableHashSet.add(nodes, node);
 }
 function findNode(fileName, nodes) {
-	const nodeOption = MutableHashMap.get(nodes, normalizeFileName$1(fileName));
-	if (Option.isSome(nodeOption)) return nodeOption.value;
-	const fallbackOption = MutableHashMap.get(nodes, fileName);
-	if (Option.isSome(fallbackOption)) return fallbackOption.value;
-	throw new Error(`Node not in graph: ${fileName}`);
+	const node = Option.firstSomeOf([MutableHashMap.get(nodes, normalizeFileName$1(fileName)), MutableHashMap.get(nodes, fileName)]);
+	if (Option.isNone(node)) throw new Error(`Node not in graph: ${fileName}`);
+	return node.value;
 }
 function parentsHaveOverlapWith(currentNode, groupNodes) {
-	for (const parentNode of getAllParentReferencesIncludingSelf(currentNode)) if (MutableHashSet.has(groupNodes, parentNode)) return true;
-	return false;
+	return Array.from(getAllParentReferencesIncludingSelf(currentNode)).some((parentNode) => MutableHashSet.has(groupNodes, parentNode));
+}
+function mutantCanJoinGroup(currentNode, group) {
+	if (MutableHashSet.has(group.ignoredNodes, currentNode)) return false;
+	return !parentsHaveOverlapWith(currentNode, group.nodes);
+}
+function addMutantToGroup(currentMutant, mutantsToGroup, group, nodes) {
+	const currentNode = findNode(currentMutant.fileName, nodes);
+	if (!mutantCanJoinGroup(currentNode, group)) return;
+	group.mutantIds.push(currentMutant.id);
+	MutableHashSet.add(group.nodes, currentNode);
+	MutableHashSet.remove(mutantsToGroup, currentMutant);
+	addRangeOfNodesToSet(group.ignoredNodes, getAllParentReferencesIncludingSelf(currentNode));
+}
+function takeGroup(mutantsToGroup, nodes) {
+	const group = {
+		mutantIds: [],
+		nodes: MutableHashSet.empty(),
+		ignoredNodes: MutableHashSet.empty()
+	};
+	for (const currentMutant of mutantsToGroup) addMutantToGroup(currentMutant, mutantsToGroup, group, nodes);
+	return group.mutantIds;
+}
+function createGroups(mutants, nodes) {
+	const groups = [];
+	const mutantsToGroup = MutableHashSet.fromIterable(mutants);
+	while (MutableHashSet.size(mutantsToGroup) > 0) groups.push(takeGroup(mutantsToGroup, nodes));
+	return groups;
 }
 var TypeScriptCompiler = class extends Context.Service()("@systemfsoftware/stryker-js-typescript-checker/TypeScriptCompiler") {};
 const makeDummy = Effect.gen(function* () {
@@ -828,63 +865,91 @@ function makeTypescriptCompiler(options, fs, fsService, pathService) {
 		tsconfigFile: rawTsconfigFile
 	};
 	const stateRef = Ref.makeUnsafe(initialState);
-	const getProgramsEffect = () => Effect.gen(function* () {
-		const s = yield* Ref.get(stateRef);
-		if (!s.snapshot) return yield* new CompilerFailed({ reason: "not-initialized" });
-		const projects = s.snapshot.getProjects();
-		if (projects.length === 0) return yield* new CompilerFailed({
+	const snapshotOf = (state) => {
+		if (state.snapshot === void 0) return Effect.fail(new CompilerFailed({ reason: "not-initialized" }));
+		return Effect.succeed(state.snapshot);
+	};
+	const programsOf = (snapshot, tsconfigFile) => {
+		const projects = snapshot.getProjects();
+		if (projects.length === 0) return Effect.fail(new CompilerFailed({
 			reason: "no-projects",
-			subject: s.tsconfigFile
-		});
-		return projects.map((project) => project.program);
+			subject: tsconfigFile
+		}));
+		return Effect.succeed(projects.map((project) => project.program));
+	};
+	const getProgramsEffect = () => Effect.gen(function* () {
+		const state = yield* Ref.get(stateRef);
+		const snapshot = yield* snapshotOf(state);
+		return yield* programsOf(snapshot, state.tsconfigFile);
 	});
 	const guardTSConfigFileExistsEffect = Effect.gen(function* () {
 		const s = yield* Ref.get(stateRef);
 		yield* fsService.readFileString(s.tsconfigFile).pipe(Effect.mapError(() => new TsConfigNotFoundError({ file: s.tsconfigFile })));
 	});
-	const collectAllTSConfigFiles = (buildModeEnabled) => Effect.gen(function* () {
-		const s = yield* Ref.get(stateRef);
-		const tsConfigOverrides = MutableHashMap.empty();
-		const toProcess = [s.tsconfigFile];
-		const processed = MutableHashSet.empty();
-		while (toProcess.length > 0) {
-			const current = toProcess.pop();
-			if (current === void 0 || current === "" || MutableHashSet.has(processed, current)) continue;
-			MutableHashSet.add(processed, current);
-			const content = yield* fsService.readFileString(current);
-			const parsed = parseTsConfig(current, content);
-			if (Result.isFailure(parsed)) {
-				MutableHashMap.set(tsConfigOverrides, current, content);
-				continue;
-			}
-			MutableHashMap.set(tsConfigOverrides, current, overrideOptions(parsed.success, buildModeEnabled));
-			for (const referenced of retrieveReferencedProjects(parsed.success, pathService.dirname(current), pathService)) {
-				const normalized = normalizeFileName$1(referenced);
-				MutableHashSet.add(s.allTSConfigFiles, normalized);
-				toProcess.push(referenced);
-			}
+	const isBlankTsConfigPath = (current) => current === void 0 || current === "";
+	const isUnprocessedTsConfigPath = (current, processed) => !isBlankTsConfigPath(current) && !MutableHashSet.has(processed, current);
+	const recordParsedTsConfig = (current, config, traversal) => {
+		MutableHashMap.set(traversal.overrides, current, overrideOptions(config, traversal.buildModeEnabled));
+		for (const referenced of retrieveReferencedProjects(config, pathService.dirname(current), pathService)) {
+			MutableHashSet.add(traversal.allTsConfigFiles, normalizeFileName$1(referenced));
+			traversal.pending.push(referenced);
+		}
+	};
+	const recordTsConfig = (current, content, parsed, traversal) => {
+		if (Result.isFailure(parsed)) {
+			MutableHashMap.set(traversal.overrides, current, content);
+			return;
 		}
-		yield* fs.setTsConfigOverrides(tsConfigOverrides);
+		recordParsedTsConfig(current, parsed.success, traversal);
+	};
+	const processNextTsConfig = (traversal) => Effect.gen(function* () {
+		const current = traversal.pending.pop();
+		if (!isUnprocessedTsConfigPath(current, traversal.processed)) return;
+		MutableHashSet.add(traversal.processed, current);
+		const content = yield* fsService.readFileString(current);
+		recordTsConfig(current, content, parseTsConfig(current, content), traversal);
+	});
+	const collectAllTSConfigFiles = (buildModeEnabled) => Effect.gen(function* () {
+		const state = yield* Ref.get(stateRef);
+		const traversal = {
+			overrides: MutableHashMap.empty(),
+			pending: [state.tsconfigFile],
+			processed: MutableHashSet.empty(),
+			allTsConfigFiles: state.allTSConfigFiles,
+			buildModeEnabled
+		};
+		while (traversal.pending.length > 0) yield* processNextTsConfig(traversal);
+		yield* fs.setTsConfigOverrides(traversal.overrides);
 		yield* Ref.update(stateRef, (prev) => ({
 			...prev,
-			allTSConfigFiles: MutableHashSet.fromIterable(s.allTSConfigFiles)
+			allTSConfigFiles: MutableHashSet.fromIterable(traversal.allTsConfigFiles)
 		}));
 	});
-	const extractImports = (sourceFile) => {
-		const result = [];
-		for (const statement of sourceFile.statements) if (statement.kind === SyntaxKind.ImportDeclaration) {
-			let spec;
-			statement.forEachChild((child) => {
-				if (child.kind === SyntaxKind.StringLiteral) spec = child;
-			});
-			if (spec) result.push(spec.getText(sourceFile));
-		} else if (statement.kind === SyntaxKind.ImportEqualsDeclaration) statement.forEachChild((child) => {
+	const importDeclarationSpecifierOf = (statement, sourceFile) => {
+		if (statement.kind !== SyntaxKind.ImportDeclaration) return Option.none();
+		let specifier;
+		statement.forEachChild((child) => {
+			if (child.kind === SyntaxKind.StringLiteral) specifier = child;
+		});
+		return Option.map(Option.fromUndefinedOr(specifier), (found) => found.getText(sourceFile));
+	};
+	const collectImportEqualsSpecifiers = (statement, sourceFile, into) => {
+		if (statement.kind !== SyntaxKind.ImportEqualsDeclaration) return;
+		statement.forEachChild((child) => {
 			if (child.kind === SyntaxKind.ExternalModuleReference) child.forEachChild((refChild) => {
-				if (refChild.kind === SyntaxKind.StringLiteral) result.push(refChild.getText(sourceFile));
+				if (refChild.kind === SyntaxKind.StringLiteral) into.push(refChild.getText(sourceFile));
 			});
 		});
-		for (const ref of sourceFile.referencedFiles) result.push(ref.fileName);
-		for (const ref of sourceFile.typeReferenceDirectives) result.push(ref.fileName);
+	};
+	const extractImports = (sourceFile) => {
+		const result = [];
+		sourceFile.statements.forEach((statement) => {
+			const specifier = importDeclarationSpecifierOf(statement, sourceFile);
+			if (Option.isSome(specifier)) result.push(specifier.value);
+			collectImportEqualsSpecifiers(statement, sourceFile, result);
+		});
+		sourceFile.referencedFiles.forEach((ref) => result.push(ref.fileName));
+		sourceFile.typeReferenceDirectives.forEach((ref) => result.push(ref.fileName));
 		return result;
 	};
 	const getResolutionCandidates = (resolved, pathService) => {
@@ -922,127 +987,160 @@ function makeTypescriptCompiler(options, fs, fsService, pathService) {
 	};
 	const resolveModuleSpecifier = (sourceFileName, specifier, sourceFiles, pathService) => {
 		const cleaned = specifier.replace(/^['"]|['"]$/g, "");
-		if (!cleaned.startsWith("./") && !cleaned.startsWith("../")) return;
+		if (!relativeSpecifierPattern.test(cleaned)) return;
 		const baseDir = pathService.dirname(sourceFileName);
 		const resolved = normalizeFileName$1(pathService.resolve(baseDir, cleaned));
-		const candidates = getResolutionCandidates(resolved, pathService);
-		for (const candidate of candidates) if (MutableHashMap.has(sourceFiles, candidate)) return candidate;
+		return getResolutionCandidates(resolved, pathService).find((candidate) => MutableHashMap.has(sourceFiles, candidate));
+	};
+	const readFileText = (fileName) => Option.liftPredicate(fs.fileSystem.readFile?.(fileName), isString);
+	const sourcesFieldOf = (rawMap) => {
+		if (!Predicate.hasProperty(rawMap, "sources")) return Option.none();
+		return Option.liftPredicate(rawMap.sources, Array.isArray);
+	};
+	const onlySourceOf = (sources) => {
+		const names = sources.filter(isString);
+		if (names.length !== 1) return Option.none();
+		return Option.fromUndefinedOr(names[0]);
+	};
+	const sourcePathFromMap = (declarationFileName, reference, pathService) => {
+		const sourceMapFileName = normalizeFileName$1(pathService.resolve(pathService.dirname(declarationFileName), reference));
+		return Option.flatMap(Option.flatMap(readFileText(sourceMapFileName), (content) => Option.flatMap(sourcesFieldOf(JSON.parse(content)), onlySourceOf)), (source) => Option.some(normalizeFileName$1(pathService.resolve(pathService.dirname(sourceMapFileName), source))));
 	};
+	const sourceMappedFileName = (declarationFileName, pathService) => Option.flatMap(Option.flatMap(readFileText(declarationFileName), (content) => Option.liftPredicate(getSourceMappingURL(content), isNonEmptyString)), (reference) => sourcePathFromMap(declarationFileName, reference, pathService));
 	const resolveTSInputFile = (dependencyFileName, pathService) => {
 		if (!dependencyFileName.endsWith(".d.ts")) return dependencyFileName;
-		const content = fs.fileSystem.readFile?.(dependencyFileName);
-		if (typeof content !== "string") return dependencyFileName;
-		const sourceMappingURL = getSourceMappingURL(content);
-		if (sourceMappingURL === void 0 || sourceMappingURL === "") return dependencyFileName;
-		const sourceMapFileName = normalizeFileName$1(pathService.resolve(pathService.dirname(dependencyFileName), sourceMappingURL));
-		const sourceMapContent = fs.fileSystem.readFile?.(sourceMapFileName);
-		if (typeof sourceMapContent !== "string") return dependencyFileName;
-		const rawMap = JSON.parse(sourceMapContent);
-		let sources;
-		if (Predicate.hasProperty(rawMap, "sources") && Array.isArray(rawMap.sources)) sources = rawMap.sources.filter((s) => typeof s === "string");
-		if (sources?.length === 1) {
-			const sourcePath = sources[0];
-			if (sourcePath === void 0) return dependencyFileName;
-			return normalizeFileName$1(pathService.resolve(pathService.dirname(sourceMapFileName), sourcePath));
-		}
-		return dependencyFileName;
+		return Option.getOrElse(sourceMappedFileName(dependencyFileName, pathService), () => dependencyFileName);
+	};
+	const registerGraphFile = (fileName, sourceFiles) => {
+		if (ignoredGraphFileNamePattern.test(fileName)) return;
+		const normalized = normalizeFileName$1(fileName);
+		MutableHashMap.set(sourceFiles, normalized, {
+			fileName: normalized,
+			imports: MutableHashSet.empty()
+		});
+	};
+	const registerSourceFiles = (programs, sourceFiles) => {
+		for (const program of programs) program.getSourceFileNames().forEach((fileName) => registerGraphFile(fileName, sourceFiles));
+	};
+	const isUsableResolution = (resolved) => resolved !== void 0 && resolved !== "";
+	const addImportEdge = (fileName, importedFileName, sourceFiles) => {
+		if (!MutableHashMap.has(sourceFiles, importedFileName)) return;
+		Option.match(MutableHashMap.get(sourceFiles, fileName), {
+			onNone: () => void 0,
+			onSome: (entry) => MutableHashSet.add(entry.imports, importedFileName)
+		});
+	};
+	const linkImport = (fileName, specifier, sourceFiles) => {
+		const resolved = resolveModuleSpecifier(fileName, specifier, sourceFiles, pathService);
+		if (!isUsableResolution(resolved)) return;
+		addImportEdge(fileName, resolveTSInputFile(resolved, pathService), sourceFiles);
+	};
+	const linkFileImports = (fileName, programs, sourceFiles) => {
+		const sourceFile = programs.map((program) => program.getSourceFile(fileName)).find((candidate) => candidate != null);
+		if (sourceFile === void 0) return;
+		extractImports(sourceFile).forEach((specifier) => linkImport(fileName, specifier, sourceFiles));
 	};
 	const buildDependencyGraph = (programs) => Effect.gen(function* () {
-		const s = yield* Ref.get(stateRef);
-		for (const program of programs) for (const fileName of program.getSourceFileNames()) {
-			if (fileName.endsWith(".d.ts") || fileName.includes("node_modules")) continue;
-			const normalized = normalizeFileName$1(fileName);
-			MutableHashMap.set(s.sourceFiles, normalized, {
-				fileName: normalized,
-				imports: MutableHashSet.empty()
-			});
-		}
-		for (const [fileName] of s.sourceFiles) {
-			const sourceFile = programs.map((p) => p.getSourceFile(fileName)).find((sf) => sf != null);
-			if (!sourceFile) continue;
-			const imports = extractImports(sourceFile);
-			for (const specifier of imports) {
-				const resolved = resolveModuleSpecifier(fileName, specifier, s.sourceFiles, pathService);
-				if (resolved !== void 0 && resolved !== "") {
-					const sourceFileName = resolveTSInputFile(resolved, pathService);
-					if (MutableHashMap.has(s.sourceFiles, sourceFileName)) {
-						const entryOpt = MutableHashMap.get(s.sourceFiles, fileName);
-						if (Option.isSome(entryOpt)) MutableHashSet.add(entryOpt.value.imports, sourceFileName);
-					}
-				}
-			}
-		}
+		const state = yield* Ref.get(stateRef);
+		registerSourceFiles(programs, state.sourceFiles);
+		for (const [fileName] of state.sourceFiles) linkFileImports(fileName, programs, state.sourceFiles);
 		yield* Ref.update(stateRef, (prev) => ({
 			...prev,
-			sourceFiles: MutableHashMap.fromIterable(s.sourceFiles)
+			sourceFiles: MutableHashMap.fromIterable(state.sourceFiles)
 		}));
 	});
-	const getNodesEffect = Effect.gen(function* () {
-		const s = yield* Ref.get(stateRef);
-		if (MutableHashMap.size(s.nodes) > 0) return s.nodes;
-		for (const [fileName] of s.sourceFiles) {
-			const node = makeTSFileNode(fileName);
-			MutableHashMap.set(s.nodes, fileName, node);
-		}
-		const withChildren = MutableHashMap.empty();
-		for (const [fileName, file] of s.sourceFiles) {
-			const nodeOpt = MutableHashMap.get(s.nodes, fileName);
-			if (Option.isNone(nodeOpt)) return yield* new CompilerFailed({
-				reason: "unknown-file-node",
-				subject: fileName
-			});
-			const node = nodeOpt.value;
-			const children = Array.from(file.imports).map((importName) => Option.getOrUndefined(MutableHashMap.get(s.nodes, importName))).filter((n) => n !== void 0);
-			MutableHashMap.set(withChildren, fileName, {
-				...node,
-				children,
-				parents: []
-			});
+	const createEmptyNodes = (state) => {
+		for (const [fileName] of state.sourceFiles) MutableHashMap.set(state.nodes, fileName, makeTSFileNode(fileName));
+	};
+	const childNodeOf = (state, fileName, imports) => Effect.gen(function* () {
+		const node = MutableHashMap.get(state.nodes, fileName);
+		if (Option.isNone(node)) return yield* new CompilerFailed({
+			reason: "unknown-file-node",
+			subject: fileName
+		});
+		const children = Array.from(imports).map((importName) => Option.getOrUndefined(MutableHashMap.get(state.nodes, importName))).filter((child) => child !== void 0);
+		return {
+			...node.value,
+			children,
+			parents: []
+		};
+	});
+	const collectChildNodes = (state, withChildren) => Effect.gen(function* () {
+		for (const [fileName, file] of state.sourceFiles) {
+			const node = yield* childNodeOf(state, fileName, file.imports);
+			MutableHashMap.set(withChildren, fileName, node);
 		}
-		MutableHashMap.clear(s.nodes);
-		for (const [k, v] of withChildren) MutableHashMap.set(s.nodes, k, v);
+	});
+	const replaceMapContents = (target, source) => {
+		MutableHashMap.clear(target);
+		for (const [key, value] of source) MutableHashMap.set(target, key, value);
+	};
+	const parentNodesOf = (node, nodes) => {
+		const parents = [];
+		MutableHashMap.forEach(nodes, (candidate) => {
+			if (candidate.children.includes(node)) parents.push(candidate);
+		});
+		return parents;
+	};
+	const linkParentReferences = (state) => {
 		const withParents = MutableHashMap.empty();
-		for (const [fileName, node] of s.nodes) {
-			const parents = [];
-			for (const [, n] of s.nodes) if (n.children.includes(node)) parents.push(n);
-			MutableHashMap.set(withParents, fileName, {
-				...node,
-				parents
-			});
-		}
-		MutableHashMap.clear(s.nodes);
-		for (const [k, v] of withParents) MutableHashMap.set(s.nodes, k, v);
+		for (const [fileName, node] of state.nodes) MutableHashMap.set(withParents, fileName, {
+			...node,
+			parents: parentNodesOf(node, state.nodes)
+		});
+		replaceMapContents(state.nodes, withParents);
+	};
+	const buildFileNodes = (state) => Effect.gen(function* () {
+		createEmptyNodes(state);
+		const withChildren = MutableHashMap.empty();
+		yield* collectChildNodes(state, withChildren);
+		replaceMapContents(state.nodes, withChildren);
+		linkParentReferences(state);
+		yield* Ref.update(stateRef, (prev) => ({
+			...prev,
+			nodes: MutableHashMap.fromIterable(state.nodes)
+		}));
+	});
+	const getNodesEffect = Effect.gen(function* () {
+		const state = yield* Ref.get(stateRef);
+		if (MutableHashMap.size(state.nodes) > 0) return state.nodes;
+		yield* buildFileNodes(state);
+		return state.nodes;
+	});
+	const resetMutatedFiles = (mutants) => Effect.gen(function* () {
+		for (const mutant of mutants) yield* fs.resetFile(mutant.fileName);
+	});
+	const applyMutant = (mutant) => Effect.gen(function* () {
+		if ((yield* fs.getFile(mutant.fileName)) === void 0) return yield* new CompilerFailed({
+			reason: "file-not-in-project",
+			subject: mutant.fileName
+		});
+		yield* fs.mutateFile(mutant.fileName, mutant);
+	});
+	const applyMutants = (mutants) => Effect.gen(function* () {
+		for (const mutant of mutants) yield* applyMutant(mutant);
+	});
+	const hasOpenSnapshot = (state) => state.api !== void 0 && state.snapshot !== void 0;
+	const updateSnapshot = (state, changedFiles) => Effect.gen(function* () {
+		const previous = state.snapshot;
+		const next = state.api.updateSnapshot({
+			openProjects: Array.from(state.allTSConfigFiles),
+			fileChanges: { changed: changedFiles }
+		});
+		yield* Effect.sync(() => previous.dispose());
 		yield* Ref.update(stateRef, (prev) => ({
 			...prev,
-			nodes: MutableHashMap.fromIterable(s.nodes)
+			snapshot: next
 		}));
-		return s.nodes;
 	});
 	const check = (mutants) => Effect.gen(function* () {
 		const state = yield* Ref.get(stateRef);
-		for (const mutant of state.lastMutants) yield* fs.resetFile(mutant.fileName);
-		for (const mutant of mutants) {
-			if (!(yield* fs.getFile(mutant.fileName))) return yield* new CompilerFailed({
-				reason: "file-not-in-project",
-				subject: mutant.fileName
-			});
-			yield* fs.mutateFile(mutant.fileName, mutant);
-		}
-		const mutatedFileNames = Array.from(MutableHashSet.fromIterable(mutants.map((m) => normalizeFileName$1(m.fileName))));
+		yield* resetMutatedFiles(state.lastMutants);
+		yield* applyMutants(mutants);
+		const mutatedFileNames = Array.from(MutableHashSet.fromIterable(mutants.map((mutant) => normalizeFileName$1(mutant.fileName))));
 		const changedFiles = Array.from(MutableHashSet.fromIterable([...state.lastMutatedFileNames, ...mutatedFileNames]));
 		const current = yield* Ref.get(stateRef);
-		if (current.api && current.snapshot) {
-			const oldSnapshot = current.snapshot;
-			const nextSnapshot = current.api.updateSnapshot({
-				openProjects: Array.from(current.allTSConfigFiles),
-				fileChanges: { changed: changedFiles }
-			});
-			yield* Effect.sync(() => oldSnapshot.dispose());
-			yield* Ref.update(stateRef, (prev) => ({
-				...prev,
-				snapshot: nextSnapshot
-			}));
-		}
+		if (hasOpenSnapshot(current)) yield* updateSnapshot(current, changedFiles);
 		yield* Ref.update(stateRef, (prev) => ({
 			...prev,
 			lastMutants: [...mutants],
@@ -1088,11 +1186,7 @@ function makeTypescriptCompiler(options, fs, fsService, pathService) {
 		}));
 	});
 	const getLineAndCharacterOfPosition = (fileName, position) => Effect.gen(function* () {
-		const programs = yield* getProgramsEffect();
-		for (const program of programs) {
-			const sourceFile = program.getSourceFile(fileName);
-			if (sourceFile) return sourceFile.getLineAndCharacterOfPosition(position);
-		}
+		return (yield* getProgramsEffect()).map((program) => program.getSourceFile(fileName)).find((sourceFile) => sourceFile !== void 0)?.getLineAndCharacterOfPosition(position);
 	});
 	return {
 		init,
@@ -1103,141 +1197,74 @@ function makeTypescriptCompiler(options, fs, fsService, pathService) {
 	};
 }
 //#endregion
+//#region src/mutant-groups.ts
+const groupsWithStrangers = (inside, outside, nodes) => {
+	const groups = createGroups([...inside], nodes);
+	if (outside.length > 0) return [outside.map((mutant) => mutant.id), ...groups];
+	return groups;
+};
+const knownFileGroups = (mutants, nodes) => {
+	const inside = mutants.filter((mutant) => Option.isSome(MutableHashMap.get(nodes, normalizeFileName(mutant.fileName))));
+	const outside = mutants.filter((mutant) => Option.isNone(MutableHashMap.get(nodes, normalizeFileName(mutant.fileName))));
+	if (inside.length === 0) return mutants.map((mutant) => [mutant.id]);
+	return groupsWithStrangers(inside, outside, nodes);
+};
+const groupMutants = (mutants, nodes, prioritizePerformanceOverAccuracy) => {
+	if (prioritizePerformanceOverAccuracy) return knownFileGroups(mutants, nodes);
+	return [mutants.map((mutant) => mutant.id)];
+};
+//#endregion
 //#region src/Checker.ts
-const normalizeFileName = (fileName) => fileName.replace(/\\/g, "/");
-function partitionMutantsForGrouping(mutants, nodes, prioritizePerformanceOverAccuracy) {
-	if (!prioritizePerformanceOverAccuracy) return {
-		inside: [],
-		outside: [...mutants]
-	};
-	const outside = [];
-	const inside = [];
-	for (const m of mutants) if (Option.isNone(MutableHashMap.get(nodes, normalizeFileName(m.fileName)))) outside.push(m);
-	else inside.push(m);
-	return {
-		inside,
-		outside
-	};
-}
 function getPrioritize(options) {
-	if (!Predicate.hasProperty(options, "typescriptChecker")) return false;
-	const tc = options["typescriptChecker"];
-	if (typeof tc !== "object" || tc === null) return false;
-	if (!Predicate.hasProperty(tc, "prioritizePerformanceOverAccuracy")) return false;
-	const val = tc["prioritizePerformanceOverAccuracy"];
-	if (typeof val === "boolean") return val;
-	return false;
+	const decoded = Schema.decodeUnknownOption(TypescriptCheckerOptionsSchema)(options);
+	return Option.getOrElse(Option.flatMap(decoded, (value) => Option.fromUndefinedOr(value.typescriptChecker?.prioritizePerformanceOverAccuracy)), () => false);
 }
+const refuse = (mutantIds, cause) => new CheckerFailed({
+	checkerName: "typescript",
+	mutantIds: [...mutantIds],
+	cause: errorToString(cause)
+});
+const severityOf = (category) => Match.value(category).pipe(Match.when(DiagnosticCategory.Error, () => "error"), Match.when(DiagnosticCategory.Warning, () => "warning"), Match.when(DiagnosticCategory.Suggestion, () => "suggestion"), Match.orElse(() => "message"));
+const toCheckResult = (answer) => {
+	if (answer.status === "passed") return { status: "passed" };
+	return {
+		status: "compileError",
+		reason: answer.reason
+	};
+};
+const mergeAnswers = (runs) => runs.reduce((merged, answers) => Object.entries(answers).reduce((into, [id, answer]) => HashMap.set(into, id, toCheckResult(answer)), merged), HashMap.empty());
 const checkCell = Cell.layer({
-	read: (command) => Effect.gen(function* () {
-		const compiler = yield* TypeScriptCompiler;
-		const nodesHm = yield* compiler.nodes.pipe(Effect.mapError((cause) => new CheckerFailed({
-			checkerName: "typescript",
-			mutantIds: command.mutants.map((m) => m.id),
-			cause: errorToString(cause)
-		})));
-		const nodes = {};
-		for (const [k, v] of nodesHm) nodes[k] = v;
-		const diagnostics = yield* compiler.check([...command.mutants]).pipe(Effect.mapError((cause) => new CheckerFailed({
-			checkerName: "typescript",
-			mutantIds: command.mutants.map((m) => m.id),
-			cause: errorToString(cause)
-		})));
-		return new CheckMutantsInput({
-			mutants: [...command.mutants],
-			diagnostics: [...diagnostics],
-			nodes
-		});
-	}),
-	decode: (raw) => Result.succeed(raw),
+	read: (command) => Effect.flatMap(TypeScriptCompiler, (compiler) => Effect.zipWith(compiler.nodes, compiler.check([...command.mutants]), (nodes, diagnostics) => new CheckMutantsInput({
+		mutants: [...command.mutants],
+		diagnostics: [...diagnostics],
+		nodes: Object.fromEntries(nodes)
+	}))).pipe(Effect.mapError((cause) => refuse(command.mutants.map((mutant) => mutant.id), cause))),
 	decide: checkMutants,
-	encode: (outcome) => outcome,
 	write: (outcome) => Result.match(outcome, {
-		onFailure: (failure) => Effect.fail(new CheckerFailed({
-			checkerName: "typescript",
-			mutantIds: [],
-			cause: errorToString(failure)
-		})),
-		onSuccess: (decision) => Effect.succeed(decision)
+		onFailure: (failure) => Effect.fail(refuse([], failure)),
+		onSuccess: Effect.succeed
 	})
 });
 function makeCheckerService({ options, compiler }) {
-	const formatDiagnostic = (error) => Effect.gen(function* () {
-		let severity;
-		if (error.category === DiagnosticCategory.Error) severity = "error";
-		else if (error.category === DiagnosticCategory.Warning) severity = "warning";
-		else if (error.category === DiagnosticCategory.Suggestion) severity = "suggestion";
-		else severity = "message";
-		let location = "";
-		const unknownError = error;
-		if (typeof unknownError === "object" && unknownError !== null && "fileName" in unknownError && typeof unknownError.fileName === "string") {
-			const fileName = unknownError.fileName;
-			const lineAndCharacter = yield* compiler.getLineAndCharacterOfPosition(fileName, error.pos).pipe(Effect.orElseSucceed(() => void 0));
-			location = `${fileName}(${(lineAndCharacter?.line ?? 0) + 1},${(lineAndCharacter?.character ?? 0) + 1}): `;
-		} else if (error.fileName !== void 0 && error.fileName !== "") {
-			const lineAndCharacter = yield* compiler.getLineAndCharacterOfPosition(error.fileName, error.pos).pipe(Effect.orElseSucceed(() => void 0));
-			const line = (lineAndCharacter?.line ?? 0) + 1;
-			const character = (lineAndCharacter?.character ?? 0) + 1;
-			location = `${error.fileName}(${line},${character}): `;
-		}
-		return `${location}${severity} TS${error.code}: ${error.text}`;
-	});
-	const createErrorText = (errors) => Effect.gen(function* () {
-		return (yield* Effect.forEach(errors, formatDiagnostic)).join("\n");
+	const verify = Cell.provide(checkCell, Layer.succeed(TypeScriptCompiler, compiler));
+	const positionOf = (error) => Option.match(Option.filter(Option.fromUndefinedOr(error.fileName), (fileName) => fileName !== ""), {
+		onNone: () => Effect.succeed(""),
+		onSome: (fileName) => compiler.getLineAndCharacterOfPosition(fileName, error.pos).pipe(Effect.orElseSucceed(() => void 0), Effect.map((at) => Option.match(Option.fromUndefinedOr(at), {
+			onNone: () => `${fileName}(1,1): `,
+			onSome: (position) => `${fileName}(${position.line + 1},${position.character + 1}): `
+		})))
 	});
+	const formatDiagnostic = (error) => positionOf(error).pipe(Effect.map((position) => `${position}${severityOf(error.category)} TS${error.code}: ${error.text}`));
+	const createErrorText = (errors) => Effect.map(Effect.forEach(errors, formatDiagnostic), (parts) => parts.join("\n"));
+	const soloRound = (mutant) => Cell.run(verify, new CheckMutantsCommand({ mutants: [mutant] })).pipe(Effect.map((decision) => decision.results));
+	const soloRounds = (decision) => Match.value(decision).pipe(Match.tag("CheckFinished", () => Effect.succeed([])), Match.tag("RetestRequired", (retest) => Cell.run(verify, new CheckMutantsCommand({ mutants: [] })).pipe(Effect.flatMap(() => Effect.forEach(retest.needsRetest, soloRound)))), Match.exhaustive);
 	return {
-		init: Effect.gen(function* () {
-			const errors = yield* compiler.init.pipe(Effect.mapError((cause) => new CheckerFailed({
-				checkerName: "typescript",
-				mutantIds: [],
-				cause: errorToString(cause)
-			})));
-			if (errors.length > 0) {
-				const text = yield* createErrorText(errors);
-				return yield* new CheckerFailed({
-					checkerName: "typescript",
-					mutantIds: [],
-					cause: errorToString(/* @__PURE__ */ new Error(`Typescript error(s) found in dry run compilation: ${text}`))
-				});
-			}
-		}),
-		check: (mutants) => Effect.gen(function* () {
-			const applyOnce = (group) => Cell.run(checkCell, new CheckMutantsCommand({ mutants: [...group] })).pipe(Effect.provideService(TypeScriptCompiler, compiler));
-			const first = yield* applyOnce(mutants);
-			let map = HashMap.empty();
-			const mergeResults = (results) => {
-				for (const [id, value] of Object.entries(results)) if (value.status === "passed") map = HashMap.set(map, id, { status: "passed" });
-				else map = HashMap.set(map, id, {
-					status: "compileError",
-					reason: value.reason
-				});
-			};
-			mergeResults(first.results);
-			yield* Match.value(first).pipe(Match.tag("CheckFinished", () => Effect.void), Match.tag("RetestRequired", (retest) => Effect.gen(function* () {
-				yield* applyOnce([]);
-				const originals = {};
-				for (const m of mutants) originals[m.id] = m;
-				for (const pending of retest.needsRetest) {
-					const original = originals[pending.id];
-					if (original === void 0) continue;
-					const one = yield* applyOnce([original]);
-					mergeResults(one.results);
-				}
-			})), Match.exhaustive);
-			return map;
-		}),
-		group: (mutants) => Effect.gen(function* () {
-			const nodes = yield* compiler.nodes.pipe(Effect.mapError((cause) => new CheckerFailed({
-				checkerName: "typescript",
-				mutantIds: mutants.map((m) => m.id),
-				cause: errorToString(cause)
-			})));
-			const { inside, outside } = partitionMutantsForGrouping(mutants, nodes, getPrioritize(options));
-			if (inside.length === 0) return mutants.map((m) => [m.id]);
-			const groups = createGroups([...inside], nodes);
-			if (outside.length > 0) return [outside.map((m) => m.id), ...groups];
-			return groups;
-		})
+		init: compiler.init.pipe(Effect.mapError((cause) => refuse([], cause)), Effect.flatMap((errors) => {
+			if (errors.length === 0) return Effect.void;
+			return createErrorText(errors).pipe(Effect.map((text) => refuse([], /* @__PURE__ */ new Error(`Typescript error(s) found in dry run compilation: ${text}`))), Effect.flatMap(Effect.fail));
+		})),
+		check: (mutants) => Cell.run(verify, new CheckMutantsCommand({ mutants: [...mutants] })).pipe(Effect.flatMap((first) => Effect.map(soloRounds(first), (rounds) => mergeAnswers([first.results, ...rounds])))),
+		group: (mutants) => compiler.nodes.pipe(Effect.map((nodes) => groupMutants(mutants, nodes, getPrioritize(options))), Effect.mapError((cause) => refuse(mutants.map((mutant) => mutant.id), cause)))
 	};
 }
 //#endregion