@systemfsoftware/stryker-js-typescript-checker 1.4.0 → 2.0.0

package/dist/index.mjs

@@ -1,14 +1,454 @@
 import { readFileSync } from "fs";
-import { PluginKind, Scope, commonTokens, declareFactoryPlugin, tokens } from "@systemfsoftware/stryker-js-plugin-api/plugin";
-import { Result, Schema } from "effect";
+import { CheckStatus, Checker, CheckerFailed } from "@systemfsoftware/stryker-js-plugin-api/check";
+import { PluginKind, RunConfiguration, declarePlugin } from "@systemfsoftware/stryker-js-plugin-api/plugin";
+import * as Effect from "effect/Effect";
+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 { StrykerOptionsSchema, normalizeFileName, strykerReportBugUrl } from "@systemfsoftware/stryker-js-plugin-api/core";
+import * as Ref from "effect/Ref";
 import { EOL } from "os";
-import { split, strykerReportBugUrl } from "@stryker-mutator/util";
-import { CheckStatus } from "@systemfsoftware/stryker-js-plugin-api/check";
+import { Predicate, Result, Schema } from "effect";
+import * as Match from "effect/Match";
 import { API, DiagnosticCategory } from "typescript/unstable/sync";
-import { createRequire } from "module";
-import path from "path";
-import semver from "semver";
+import * as Context from "effect/Context";
 import { SyntaxKind } from "typescript/unstable/ast";
+import { createRequire } from "module";
+//#region src/project/hybrid-file-system.schema.ts
+var HybridFileNotFoundError = class extends S.TaggedError()("HybridFileNotFoundError", { fileName: S.String }) {};
+//#endregion
+//#region src/project/script-file.ts
+function makeScriptFile(content, fileName, modifiedTime = /* @__PURE__ */ new Date()) {
+	return {
+		content,
+		fileName,
+		originalContent: content,
+		modifiedTime
+	};
+}
+function withContent(file, content) {
+	return {
+		...file,
+		content,
+		modifiedTime: /* @__PURE__ */ new Date()
+	};
+}
+function mutateScriptFile(file, mutant) {
+	const start = getOffset(file, mutant.location.start);
+	const end = getOffset(file, mutant.location.end);
+	const content = `${file.originalContent.slice(0, start)}${mutant.replacement}${file.originalContent.slice(end)}`;
+	return {
+		...file,
+		content,
+		modifiedTime: /* @__PURE__ */ new Date()
+	};
+}
+function resetScriptFile(file) {
+	return {
+		...file,
+		content: file.originalContent,
+		modifiedTime: /* @__PURE__ */ new Date()
+	};
+}
+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;
+	return offset;
+}
+//#endregion
+//#region src/project/hybrid-file-system.ts
+const makeEmptyFilesMap = () => /* @__PURE__ */ new Map();
+const makeEmptyOverridesMap = () => /* @__PURE__ */ new Map();
+const copyAndSet = (map, key, value) => {
+	const next = new Map(map);
+	next.set(key, value);
+	return next;
+};
+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 fileSystem = {
+		readFile: (fileName) => {
+			const normalized = normalizeFileName(fileName);
+			if (fileNameIsBuildInfo(normalized)) return null;
+			const override = overridesRef.ref.current.get(normalized);
+			if (override !== void 0) return override;
+			const files = filesRef.ref.current;
+			const file = files.get(normalized);
+			if (file) return file.content;
+			if (file === void 0 && files.has(normalized)) return null;
+		},
+		fileExists: (fileName) => {
+			const normalized = normalizeFileName(fileName);
+			if (fileNameIsBuildInfo(normalized)) return false;
+			if (overridesRef.ref.current.has(normalized)) return true;
+			const files = filesRef.ref.current;
+			if (files.has(normalized)) return files.get(normalized) !== void 0;
+		},
+		directoryExists: () => void 0,
+		getAccessibleEntries: () => void 0,
+		realpath: () => void 0
+	};
+	const getFile = (fileName) => Effect.gen(function* () {
+		const normalized = normalizeFileName(fileName);
+		const files = yield* Ref.get(filesRef);
+		if (files.has(normalized)) return files.get(normalized);
+		const content = yield* fsService.readFileString(normalized).pipe(Effect.orElseSucceed(() => void 0));
+		if (content === void 0) {
+			yield* Ref.update(filesRef, (m) => copyAndSet(m, normalized, void 0));
+			return;
+		}
+		const file = makeScriptFile(content, normalized);
+		yield* Ref.update(filesRef, (m) => copyAndSet(m, normalized, file));
+		return file;
+	});
+	const writeFile = (fileName, data) => Effect.gen(function* () {
+		const normalized = normalizeFileName(fileName);
+		const existing = (yield* Ref.get(filesRef)).get(normalized);
+		if (existing) {
+			const next = withContent(existing, data);
+			yield* Ref.update(filesRef, (m) => copyAndSet(m, normalized, next));
+		} else {
+			const file = makeScriptFile(data, normalized);
+			yield* Ref.update(filesRef, (m) => copyAndSet(m, normalized, file));
+		}
+	});
+	const mutateFile = (fileName, mutant) => Effect.gen(function* () {
+		const file = yield* getFile(fileName);
+		if (!file) return yield* new HybridFileNotFoundError({ fileName });
+		const next = mutateScriptFile(file, mutant);
+		const normalized = normalizeFileName(fileName);
+		yield* Ref.update(filesRef, (m) => copyAndSet(m, normalized, next));
+	});
+	const resetFile = (fileName) => Effect.gen(function* () {
+		const normalized = normalizeFileName(fileName);
+		const file = (yield* Ref.get(filesRef)).get(normalized);
+		if (file) {
+			const next = resetScriptFile(file);
+			yield* Ref.update(filesRef, (m) => copyAndSet(m, normalized, next));
+		}
+	});
+	const existsInMemory = (fileName) => Effect.gen(function* () {
+		return (yield* Ref.get(filesRef)).get(normalizeFileName(fileName)) !== void 0;
+	});
+	const setTsConfigOverrides = (overrides) => Ref.set(overridesRef, overrides);
+	return {
+		fileSystem,
+		getFile,
+		writeFile,
+		mutateFile,
+		resetFile,
+		existsInMemory,
+		setTsConfigOverrides
+	};
+});
+//#endregion
+//#region src/grouping/ts-file-node.ts
+function makeTSFileNode(fileName) {
+	return {
+		fileName,
+		parents: [],
+		children: []
+	};
+}
+function getAllParentReferencesIncludingSelf(node, allParentReferences = /* @__PURE__ */ new Set()) {
+	allParentReferences.add(node);
+	for (const parent of node.parents) if (!allParentReferences.has(parent)) getAllParentReferencesIncludingSelf(parent, allParentReferences);
+	return allParentReferences;
+}
+function getMutantsWithReferenceToChildrenOrSelf(node, mutants, nodesChecked = []) {
+	if (nodesChecked.includes(node.fileName)) return [];
+	nodesChecked.push(node.fileName);
+	const relatedMutants = mutants.filter((m) => normalizeFileName(m.fileName) === node.fileName);
+	const childResult = node.children.flatMap((c) => getMutantsWithReferenceToChildrenOrSelf(c, mutants, nodesChecked));
+	return [...relatedMutants, ...childResult];
+}
+//#endregion
+//#region src/diagnostics.schema.ts
+/**
+* The compiler returned a diagnostic without a file name. The checker cannot
+* attribute it to a mutant and the run should be failed rather than silently
+* marking every mutant as a compile error.
+*/
+var DiagnosticWithoutFileError = class extends S.TaggedError()("DiagnosticWithoutFileError", { text: S.String }) {};
+/**
+* The compiler reported a diagnostic in a file that is not part of the
+* project graph built from the tsconfig. This indicates a graph or FS
+* mismatch and must be surfaced as a checker failure rather than ignored.
+*/
+var DiagnosticInUnrelatedFileError = class extends S.TaggedError()("DiagnosticInUnrelatedFileError", {
+	text: S.String,
+	fileName: S.String
+}) {};
+//#endregion
+//#region src/diagnostics.ts
+/**
+* Pure decision: given a batch of diagnostics and the file graph, decide
+* which mutants are definitely responsible and which need an individual
+* re-check.
+*
+* No I/O, no clock, no throwing — diagnostics in, verdict out. The caller
+* (executor) performs the compiler call and, if `needsRetest` is non-empty,
+* re-invokes the compiler for each of those mutants individually.
+*/
+function classifyDiagnostics(diagnostics, mutants, nodes) {
+	const definitive = /* @__PURE__ */ new Map();
+	const needsRetest = /* @__PURE__ */ new Map();
+	if (diagnostics.length > 0 && mutants.length === 1) {
+		const only = mutants[0];
+		if (only !== void 0) definitive.set(only.id, [...diagnostics]);
+		return Result.succeed({
+			definitive,
+			needsRetest: []
+		});
+	}
+	for (const diagnostic of diagnostics) {
+		if (!diagnostic.fileName) return Result.fail(new DiagnosticWithoutFileError({ text: diagnostic.text }));
+		const node = nodes.get(diagnostic.fileName);
+		if (!node) return Result.fail(new DiagnosticInUnrelatedFileError({
+			text: diagnostic.text,
+			fileName: diagnostic.fileName
+		}));
+		const related = getMutantsWithReferenceToChildrenOrSelf(node, [...mutants]);
+		if (related.length === 0) for (const m of mutants) needsRetest.set(m.id, m);
+		else if (related.length === 1) {
+			const only = related[0];
+			if (only !== void 0) {
+				const existing = definitive.get(only.id);
+				if (existing) existing.push(diagnostic);
+				else definitive.set(only.id, [diagnostic]);
+			}
+		} else for (const m of related) needsRetest.set(m.id, m);
+	}
+	const filteredRetest = [...needsRetest.values()].filter((m) => !definitive.has(m.id));
+	return Result.succeed({
+		definitive,
+		needsRetest: filteredRetest
+	});
+}
+/**
+* Pure grouping decision: delegates to the existing `createGroups` but
+* expressed as a kernel entry so the checker can state the boundary.
+* `nodes` is the file graph; mutants outside the project are separated
+* before grouping, matching the executor's `split` that was previously
+* inline in `TypescriptChecker.group`.
+*/
+function partitionMutantsForGrouping(mutants, nodes, prioritizePerformanceOverAccuracy) {
+	if (!prioritizePerformanceOverAccuracy) return {
+		inside: [],
+		outside: [...mutants]
+	};
+	const outside = [];
+	const inside = [];
+	for (const m of mutants) if (nodes.get(normalizeFileName(m.fileName)) == null) outside.push(m);
+	else inside.push(m);
+	return {
+		inside,
+		outside
+	};
+}
+//#endregion
+//#region src/grouping/create-groups.ts
+/**
+* To speed up the type-checking we want to check multiple mutants at once.
+* When multiple mutants in different files don't have overlap in affected files (or have small overlap), we can type-check them simultaneously.
+* These mutants who can be tested at the same time are called a group.
+* Therefore, the return type is an array of arrays, in other words: an array of groups.
+*
+* @param mutants All the mutants of the test project.
+* @param nodes A graph representation of the test project.
+*/
+function createGroups(mutants, nodes) {
+	const groups = [];
+	const mutantsToGroup = new Set(mutants);
+	while (mutantsToGroup.size) {
+		const group = [];
+		const groupNodes = /* @__PURE__ */ new Set();
+		const nodesToIgnore = /* @__PURE__ */ new Set();
+		for (const currentMutant of mutantsToGroup) {
+			const currentNode = findNode(currentMutant.fileName, nodes);
+			if (!nodesToIgnore.has(currentNode) && !parentsHaveOverlapWith(currentNode, groupNodes)) {
+				group.push(currentMutant.id);
+				groupNodes.add(currentNode);
+				mutantsToGroup.delete(currentMutant);
+				addRangeOfNodesToSet(nodesToIgnore, getAllParentReferencesIncludingSelf(currentNode));
+			}
+		}
+		groups.push(group);
+	}
+	return groups;
+}
+function addRangeOfNodesToSet(nodes, nodesToAdd) {
+	for (const parent of nodesToAdd) nodes.add(parent);
+}
+function findNode(fileName, nodes) {
+	const node = nodes.get(normalizeFileName(fileName));
+	if (node == null) throw new Error(`Node not in graph: ${fileName}`);
+	return node;
+}
+function parentsHaveOverlapWith(currentNode, groupNodes) {
+	for (const parentNode of getAllParentReferencesIncludingSelf(currentNode)) if (groupNodes.has(parentNode)) return true;
+	return false;
+}
+//#endregion
+//#region src/typescript-checker.ts
+const emptyCheckResultMap = () => /* @__PURE__ */ new Map();
+const emptyDiagnosticMap = () => /* @__PURE__ */ new Map();
+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"];
+	return typeof val === "boolean" ? val : false;
+}
+function makeCheckerService({ options, compiler }) {
+	const formatDiagnostic = (error) => Effect.gen(function* () {
+		const severity = error.category === DiagnosticCategory.Error ? "error" : error.category === DiagnosticCategory.Warning ? "warning" : error.category === DiagnosticCategory.Suggestion ? "suggestion" : "message";
+		let location = "";
+		if (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(EOL);
+	});
+	const checkErrors = (mutants, errorsMap, nodes) => Effect.gen(function* () {
+		const classified = classifyDiagnostics(yield* compiler.check([...mutants]).pipe(Effect.mapError((cause) => new CheckerFailed({
+			checkerName: "typescript",
+			mutantIds: mutants.map((m) => m.id),
+			cause
+		}))), mutants, nodes);
+		if (Result.isFailure(classified)) {
+			const failure = classified.failure;
+			const message = Match.value(failure).pipe(Match.tag("DiagnosticWithoutFileError", (f) => `Typescript error: '${f.text}' was reported without a corresponding file. This shouldn't happen. Please open an issue using this link: ${strykerReportBugUrl(`[BUG]: TypeScript checker reports compile error without a corresponding file: ${f.text}`)}`), Match.tag("DiagnosticInUnrelatedFileError", (f) => `Typescript error: '${f.text}' was reported in an unrelated file (${f.fileName}). This file is not part of your project, or referenced from your project. This shouldn't happen, please open an issue using this link: ${strykerReportBugUrl(`[BUG]: TypeScript checker reports compile error in an unrelated file: ${f.text}`)}`), Match.exhaustive);
+			return yield* new CheckerFailed({
+				checkerName: "typescript",
+				mutantIds: mutants.map((m) => m.id),
+				cause: new Error(message)
+			});
+		}
+		const { definitive, needsRetest } = classified.success;
+		for (const [id, errors] of definitive.entries()) {
+			const existing = errorsMap.get(id);
+			if (existing) existing.push(...errors);
+			else errorsMap.set(id, [...errors]);
+		}
+		if (needsRetest.length > 0) {
+			yield* compiler.check([]).pipe(Effect.mapError((cause) => new CheckerFailed({
+				checkerName: "typescript",
+				mutantIds: needsRetest.map((m) => m.id),
+				cause
+			})));
+			for (const mutant of needsRetest) {
+				if (errorsMap.has(mutant.id)) continue;
+				yield* checkErrors([mutant], errorsMap, nodes);
+			}
+		}
+	});
+	return {
+		init: Effect.gen(function* () {
+			const errors = yield* compiler.init.pipe(Effect.mapError((cause) => new CheckerFailed({
+				checkerName: "typescript",
+				mutantIds: [],
+				cause
+			})));
+			if (errors.length > 0) {
+				const text = yield* createErrorText(errors);
+				return yield* new CheckerFailed({
+					checkerName: "typescript",
+					mutantIds: [],
+					cause: /* @__PURE__ */ new Error(`Typescript error(s) found in dry run compilation: ${text}`)
+				});
+			}
+		}),
+		check: (mutants) => Effect.gen(function* () {
+			const nodes = yield* compiler.nodes.pipe(Effect.mapError((cause) => new CheckerFailed({
+				checkerName: "typescript",
+				mutantIds: mutants.map((m) => m.id),
+				cause
+			})));
+			const result = emptyCheckResultMap();
+			for (const mutant of mutants) result.set(mutant.id, { status: CheckStatus.Passed });
+			const firstMutant = mutants[0];
+			if (!firstMutant || !nodes.get(normalizeFileName(firstMutant.fileName))) return result;
+			const errorsMap = emptyDiagnosticMap();
+			yield* checkErrors(mutants, errorsMap, nodes);
+			for (const [id, errors] of errorsMap.entries()) {
+				const text = yield* createErrorText(errors);
+				result.set(id, {
+					status: CheckStatus.CompileError,
+					reason: text
+				});
+			}
+			return result;
+		}),
+		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
+			})));
+			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;
+		})
+	};
+}
+//#endregion
+//#region src/compiler-error.schema.ts
+const TypeId = "~stryker/typescript-checker/CompilerFailed";
+/**
+* Every way the TypeScript compiler can fail while serving a check.
+*
+* One tagged error rather than four, because nothing branches on which of these
+* happened — they all reach the caller as a failed check. The `reason` keeps the
+* cases distinguishable in a report without inventing four types no consumer
+* discriminates.
+*/
+var CompilerFailed = class extends S.TaggedError(TypeId)("CompilerFailed", {
+	reason: S.Literals([
+		"not-initialized",
+		"no-projects",
+		"unknown-file-node",
+		"file-not-in-project"
+	]),
+	/** The file or tsconfig the failure is about, when it is about one. */
+	subject: S.optional(S.String)
+}) {
+	[TypeId] = TypeId;
+	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`;
+		}
+	}
+};
+//#endregion
+//#region src/declaration-source-mapping.ts
+const findSourceMapRegex = /\/\/# sourceMappingURL=(.+)$/m;
+function getSourceMappingURL(content) {
+	findSourceMapRegex.lastIndex = 0;
+	return findSourceMapRegex.exec(content)?.[1];
+}
+//#endregion
 //#region ../../../../../node_modules/.pnpm/@jsr+std__jsonc@1.0.2/node_modules/@jsr/std__jsonc/parse.js
 /**
 * Converts a JSON with Comments (JSONC) string into an object.
@@ -229,7 +669,7 @@ function buildErrorMessage({ type, sourceText, position }) {
 	return `Cannot parse JSONC: unexpected token "${token}" in JSONC at position ${position}`;
 }
 //#endregion
-//#region src/tsconfig-helpers.schema.ts
+//#region src/tsconfig.schema.ts
 /**
 * Error returned when a tsconfig file fails to parse or does not match the
 * shape this package consumes.
@@ -238,13 +678,21 @@ var TsConfigParseError = class extends Schema.TaggedError()("TsConfigParseError"
 	file: Schema.String,
 	reason: Schema.String
 }) {};
+/**
+* The configured tsconfig file could not be read from disk.
+*/
+var TsConfigNotFoundError = class extends Schema.TaggedError()("TsConfigNotFoundError", { file: Schema.String }) {
+	get message() {
+		return `The tsconfig file does not exist at: "${this.file}". Please configure the tsconfig file in your stryker.conf file using "tsconfigFile"`;
+	}
+};
 const JsonRecord = Schema.Record(Schema.String, Schema.Unknown);
 const TsConfigSchema = Schema.StructWithRest(Schema.Struct({
 	references: Schema.optional(Schema.Array(Schema.StructWithRest(Schema.Struct({ path: Schema.String }), [JsonRecord]))),
 	compilerOptions: Schema.optional(JsonRecord)
 }), [JsonRecord]);
 //#endregion
-//#region src/tsconfig-helpers.ts
+//#region src/tsconfig.ts
 const COMPILER_OPTIONS_OVERRIDES = Object.freeze({
 	allowUnreachableCode: true,
 	noUnusedLocals: false,
@@ -262,17 +710,6 @@ const LOW_EMIT_OPTIONS_FOR_PROJECT_REFERENCES = Object.freeze({
 	declarationMap: true,
 	declaration: true
 });
-let cachedTSVersion;
-function getTSVersion() {
-	if (cachedTSVersion === void 0) {
-		const require = createRequire(import.meta.url);
-		cachedTSVersion = Schema.decodeUnknownSync(Schema.Struct({ version: Schema.String }))(JSON.parse(readFileSync(require.resolve("typescript/package.json"), "utf-8"))).version;
-	}
-	return cachedTSVersion;
-}
-function guardTSVersion(version = getTSVersion()) {
-	if (!semver.satisfies(version, ">=7.0.0", { includePrerelease: true })) throw new Error(`@systemfsoftware/stryker-js-typescript-checker only supports typescript@7.0.0 or higher. Found typescript@${version}`);
-}
 /**
 * 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
@@ -296,13 +733,13 @@ function parseTsConfig(fileName, jsonText) {
 * Determines whether or not to use `--build` mode based on "references" being there in the config file
 * @param tsconfigFileName The tsconfig file to parse
 */
-function determineBuildModeEnabled(tsconfigFileName) {
-	const parsed = parseTsConfig(tsconfigFileName, readFileSync(tsconfigFileName, "utf-8"));
+const determineBuildModeEnabled = (tsconfigFileName, fsService) => Effect.gen(function* () {
+	const parsed = parseTsConfig(tsconfigFileName, yield* fsService.readFileString(tsconfigFileName));
 	return Result.match(parsed, {
 		onFailure: () => false,
 		onSuccess: (config) => config.references !== void 0
 	});
-}
+});
 /**
 * Overrides some options to speed up compilation and disable some code quality checks we don't want during mutation testing
 * @param config The parsed config file
@@ -332,354 +769,161 @@ function overrideOptions(config, useBuildMode) {
 * @param config The parsed config file
 * @param fromDirName The directory where to resolve from
 */
-function retrieveReferencedProjects(config, fromDirName) {
+function retrieveReferencedProjects(config, fromDirName, pathService) {
 	return (config.references ?? []).map((reference) => {
-		let resolved = path.resolve(fromDirName, reference.path);
-		if (!path.basename(resolved).endsWith(".json")) resolved = path.join(resolved, "tsconfig.json");
-		return toPosixFileName(resolved);
+		let resolved = pathService.resolve(fromDirName, reference.path);
+		if (!pathService.basename(resolved).endsWith(".json")) resolved = pathService.join(resolved, "tsconfig.json");
+		return normalizeFileName(resolved);
 	});
 }
+//#endregion
+//#region src/typescript-version.schema.ts
 /**
-* Replaces backslashes with forward slashes (used by typescript)
-* @param fileName The file name that may contain backslashes `\`
-* @returns posix and ts complaint file name (with `/`)
-*/
-function toPosixFileName(fileName) {
-	return fileName.replace(/\\/g, "/");
-}
-/**
-* Find source file in declaration file
-* @param content The content of the declaration file
-* @returns URL of the source file or undefined if not found
+* The installed TypeScript version is below the supported floor.
 */
-const findSourceMapRegex = /\/\/# sourceMappingURL=(.+)$/m;
-function getSourceMappingURL(content) {
-	findSourceMapRegex.lastIndex = 0;
-	return findSourceMapRegex.exec(content)?.[1];
-}
-//#endregion
-//#region src/grouping/ts-file-node.ts
-var TSFileNode = class {
-	fileName;
-	parents;
-	children;
-	constructor(fileName, parents, children) {
-		this.fileName = fileName;
-		this.parents = parents;
-		this.children = children;
-	}
-	getAllParentReferencesIncludingSelf(allParentReferences = /* @__PURE__ */ new Set()) {
-		allParentReferences.add(this);
-		this.parents.forEach((parent) => {
-			if (!allParentReferences.has(parent)) parent.getAllParentReferencesIncludingSelf(allParentReferences);
-		});
-		return allParentReferences;
-	}
-	getAllChildReferencesIncludingSelf(allChildReferences = /* @__PURE__ */ new Set()) {
-		allChildReferences.add(this);
-		this.children.forEach((child) => {
-			if (!allChildReferences.has(child)) child.getAllChildReferencesIncludingSelf(allChildReferences);
-		});
-		return allChildReferences;
-	}
-	getMutantsWithReferenceToChildrenOrSelf(mutants, nodesChecked = []) {
-		if (nodesChecked.includes(this.fileName)) return [];
-		nodesChecked.push(this.fileName);
-		const relatedMutants = mutants.filter((m) => toPosixFileName(m.fileName) === this.fileName);
-		const childResult = this.children.flatMap((c) => c.getMutantsWithReferenceToChildrenOrSelf(mutants, nodesChecked));
-		return [...relatedMutants, ...childResult];
+var UnsupportedTypeScriptVersionError = class extends Schema.TaggedError()("UnsupportedTypeScriptVersionError", { version: Schema.String }) {
+	get message() {
+		return `@systemfsoftware/stryker-js-typescript-checker only supports typescript@7.0.0 or higher. Found typescript@${this.version}`;
 	}
 };
 //#endregion
-//#region src/grouping/create-groups.ts
+//#region src/typescript-version.ts
+let cachedTSVersion;
+const getTSVersion = (fsService) => Effect.gen(function* () {
+	if (cachedTSVersion !== void 0) return cachedTSVersion;
+	const pkgPath = createRequire(import.meta.url).resolve("typescript/package.json");
+	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;
+	cachedTSVersion = version;
+	return version;
+});
 /**
-* To speed up the type-checking we want to check multiple mutants at once.
-* When multiple mutants in different files don't have overlap in affected files (or have small overlap), we can type-check them simultaneously.
-* These mutants who can be tested at the same time are called a group.
-* Therefore, the return type is an array of arrays, in other words: an array of groups.
+* Whether a TypeScript version satisfies the supported floor `>=7.0.0`.
 *
-* @param mutants All the mutants of the test project.
-* @param nodes A graph representation of the test project.
+* Prerelease handling: the suffix after `-` (e.g. `7.0.0-beta`, `7.0.0-rc.1`) and any
+* `+` build metadata is stripped before numeric comparison, so a `7.0.0` prerelease
+* compares as `7.0.0` and satisfies the floor. This preserves the prior
+* `satisfies(version, '>=7.0.0', { includePrerelease: true })` behaviour
+* where a TypeScript 7 prerelease must still pass the guard.
 */
-function createGroups(mutants, nodes) {
-	const groups = [];
-	const mutantsToGroup = new Set(mutants);
-	while (mutantsToGroup.size) {
-		const group = [];
-		const groupNodes = /* @__PURE__ */ new Set();
-		const nodesToIgnore = /* @__PURE__ */ new Set();
-		for (const currentMutant of mutantsToGroup) {
-			const currentNode = findNode(currentMutant.fileName, nodes);
-			if (!nodesToIgnore.has(currentNode) && !parentsHaveOverlapWith(currentNode, groupNodes)) {
-				group.push(currentMutant.id);
-				groupNodes.add(currentNode);
-				mutantsToGroup.delete(currentMutant);
-				addRangeOfNodesToSet(nodesToIgnore, currentNode.getAllParentReferencesIncludingSelf());
-			}
-		}
-		groups.push(group);
-	}
-	return groups;
-}
-function addRangeOfNodesToSet(nodes, nodesToAdd) {
-	for (const parent of nodesToAdd) nodes.add(parent);
+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;
 }
-function findNode(fileName, nodes) {
-	const node = nodes.get(toPosixFileName(fileName));
-	if (node == null) throw new Error(`Node not in graph: ${fileName}`);
-	return node;
-}
-function parentsHaveOverlapWith(currentNode, groupNodes) {
-	for (const parentNode of currentNode.getAllParentReferencesIncludingSelf()) if (groupNodes.has(parentNode)) return true;
-	return false;
-}
-const tsCompiler = "tsCompiler";
-//#endregion
-//#region src/project/script-file.ts
-var ScriptFile = class {
-	content;
-	fileName;
-	modifiedTime;
-	originalContent;
-	constructor(content, fileName, modifiedTime = /* @__PURE__ */ new Date()) {
-		this.content = content;
-		this.fileName = fileName;
-		this.modifiedTime = modifiedTime;
-		this.originalContent = content;
-	}
-	write(content) {
-		this.content = content;
-		this.touch();
-	}
-	mutate(mutant) {
-		const start = this.getOffset(mutant.location.start);
-		const end = this.getOffset(mutant.location.end);
-		this.content = `${this.originalContent.slice(0, start)}${mutant.replacement}${this.originalContent.slice(end)}`;
-		this.touch();
-	}
-	getOffset(pos) {
-		const lines = this.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;
-		return offset;
-	}
-	resetMutant() {
-		this.content = this.originalContent;
-		this.touch();
-	}
-	touch() {
-		this.modifiedTime = /* @__PURE__ */ new Date();
-	}
-};
+const guardTSVersion = (fsService) => Effect.gen(function* () {
+	const version = yield* getTSVersion(fsService);
+	if (!isSupportedTypescriptVersion(version)) return yield* new UnsupportedTypeScriptVersionError({ version });
+});
 //#endregion
-//#region src/project/hybrid-file-system.ts
-/**
-* A very simple hybrid file system.
-* * Readonly from disk
-* * Writes in-memory
-* * Hard caching
-* * Ability to mutate one file
-*/
-var HybridFileSystem = class {
-	files = /* @__PURE__ */ new Map();
-	/**
-	* Map of absolute tsconfig file paths to their adjusted JSON content.
-	* This allows the TS7 API to read overridden compiler options.
-	*/
-	tsConfigOverrides = /* @__PURE__ */ new Map();
-	readFile = (fileName) => {
-		const normalized = toPosixFileName(fileName);
-		if (this.fileNameIsBuildInfo(normalized)) return null;
-		const override = this.tsConfigOverrides.get(normalized);
-		if (override !== void 0) return override;
-		const file = this.files.get(normalized);
-		if (file) return file.content;
-		if (file === void 0 && this.files.has(normalized)) return null;
+//#region src/typescript-compiler.ts
+var TypeScriptCompiler = class extends Context.Service()("@systemfsoftware/stryker-js-typescript-checker/TypeScriptCompiler") {};
+const emptySourceFiles = () => /* @__PURE__ */ new Map();
+const emptyNodes = () => /* @__PURE__ */ new Map();
+const emptyStringMap = () => /* @__PURE__ */ new Map();
+const emptyStringSet = () => /* @__PURE__ */ new Set();
+const setFromArray = (arr) => new Set(arr);
+const unique = (arr) => [...new Set(arr)];
+const cloneMap = (m) => new Map(m);
+const makeDummy = Effect.gen(function* () {
+	const stateRef = yield* Ref.make({
+		api: void 0,
+		snapshot: void 0,
+		sourceFiles: emptySourceFiles(),
+		nodes: emptyNodes(),
+		lastMutants: [],
+		lastMutatedFileNames: [],
+		allTSConfigFiles: setFromArray(["tsconfig.json"]),
+		tsconfigFile: "tsconfig.json"
+	});
+	yield* Effect.addFinalizer(() => Effect.gen(function* () {
+		const s = yield* Ref.get(stateRef);
+		yield* Effect.sync(() => s.snapshot?.dispose());
+		yield* Effect.sync(() => s.api?.close());
+	}));
+	return {
+		init: Effect.succeed([]),
+		check: () => Effect.succeed([]),
+		nodes: Ref.get(stateRef).pipe(Effect.map((s) => s.nodes)),
+		close: Effect.gen(function* () {
+			const s = yield* Ref.get(stateRef);
+			yield* Effect.sync(() => s.snapshot?.dispose());
+			yield* Effect.sync(() => s.api?.close());
+			yield* Ref.update(stateRef, (prev) => ({
+				...prev,
+				snapshot: void 0,
+				api: void 0
+			}));
+		}),
+		getLineAndCharacterOfPosition: () => Effect.succeed(void 0)
 	};
-	fileExists = (fileName) => {
-		const normalized = toPosixFileName(fileName);
-		if (this.fileNameIsBuildInfo(normalized)) return false;
-		if (this.tsConfigOverrides.has(normalized)) return true;
-		if (this.files.has(normalized)) return this.files.get(normalized) !== void 0;
+});
+Layer.effect(TypeScriptCompiler)(makeDummy);
+function makeTypescriptCompiler(options, fs, fsService, pathService) {
+	if (!S.is(StrykerOptionsSchema)(options)) throw new Error("Invalid StrykerOptions");
+	const rawTsconfigFile = normalizeFileName(options.tsconfigFile);
+	const initialState = {
+		api: void 0,
+		snapshot: void 0,
+		sourceFiles: emptySourceFiles(),
+		nodes: emptyNodes(),
+		lastMutants: [],
+		lastMutatedFileNames: [],
+		allTSConfigFiles: setFromArray([rawTsconfigFile]),
+		tsconfigFile: rawTsconfigFile
 	};
-	directoryExists = () => {};
-	getAccessibleEntries = () => {};
-	realpath = () => {};
-	writeFile(fileName, data) {
-		const normalized = toPosixFileName(fileName);
-		const existingFile = this.files.get(normalized);
-		if (existingFile) existingFile.write(data);
-		else this.files.set(normalized, new ScriptFile(data, normalized));
-	}
-	getFile(fileName) {
-		const normalized = toPosixFileName(fileName);
-		if (!this.files.has(normalized)) try {
-			const content = readFileSync(normalized, "utf-8");
-			this.files.set(normalized, new ScriptFile(content, normalized));
-		} catch {
-			this.files.set(normalized, void 0);
-		}
-		return this.files.get(normalized);
-	}
-	mutateFile(fileName, mutant) {
-		const file = this.getFile(fileName);
-		if (!file) throw new Error(`Tried to mutate file "${fileName}" but it could not be found.`);
-		file.mutate(mutant);
-	}
-	resetFile(fileName) {
-		this.getFile(fileName)?.resetMutant();
-	}
-	existsInMemory(fileName) {
-		return this.files.get(toPosixFileName(fileName)) !== void 0;
-	}
-	fileNameIsBuildInfo(fileName) {
-		return fileName.endsWith(".tsbuildinfo");
-	}
-};
-//#endregion
-//#region src/typescript-compiler.ts
-var TypescriptCompiler = class {
-	log;
-	options;
-	fs;
-	static inject = tokens(commonTokens.logger, commonTokens.options, "fs");
-	allTSConfigFiles;
-	tsconfigFile;
-	api;
-	snapshot;
-	sourceFiles = /* @__PURE__ */ new Map();
-	_nodes = /* @__PURE__ */ new Map();
-	lastMutants = [];
-	lastMutatedFileNames = [];
-	constructor(log, options, fs) {
-		this.log = log;
-		this.options = options;
-		this.fs = fs;
-		this.tsconfigFile = toPosixFileName(path.resolve(toPosixFileName(this.options.tsconfigFile)));
-		this.allTSConfigFiles = /* @__PURE__ */ new Set([this.tsconfigFile]);
-	}
-	async init() {
-		guardTSVersion();
-		this.guardTSConfigFileExists();
-		const buildModeEnabled = determineBuildModeEnabled(this.tsconfigFile);
-		this.collectAllTSConfigFiles(buildModeEnabled);
-		this.api = new API({ fs: this.fs });
-		this.snapshot = this.api.updateSnapshot({ openProjects: [...this.allTSConfigFiles] });
-		const programs = this.getPrograms();
-		this.buildDependencyGraph(programs);
-		return this.check([]);
-	}
-	async check(mutants) {
-		for (const mutant of this.lastMutants) this.fs.resetFile(mutant.fileName);
-		for (const mutant of mutants) {
-			const file = this.fs.getFile(mutant.fileName);
-			if (!file) throw new Error(`Tried to check file "${mutant.fileName}" (which is part of your typescript project), but it could not be found.`);
-			file.mutate(mutant);
-		}
-		const mutatedFileNames = [...new Set(mutants.map((m) => toPosixFileName(m.fileName)))];
-		const changedFiles = [.../* @__PURE__ */ new Set([...this.lastMutatedFileNames, ...mutatedFileNames])];
-		if (this.api && this.snapshot) {
-			const oldSnapshot = this.snapshot;
-			this.snapshot = this.api.updateSnapshot({
-				openProjects: [...this.allTSConfigFiles],
-				fileChanges: { changed: changedFiles }
-			});
-			oldSnapshot.dispose();
-		}
-		this.lastMutants = mutants;
-		this.lastMutatedFileNames = mutatedFileNames;
-		return this.getPrograms().flatMap((program) => [
-			...program.getConfigFileParsingDiagnostics(),
-			...program.getSemanticDiagnostics(),
-			...program.getProgramDiagnostics()
-		]).filter((diagnostic) => diagnostic.category === DiagnosticCategory.Error);
-	}
-	get nodes() {
-		if (!this._nodes.size) {
-			for (const [fileName] of this.sourceFiles) {
-				const node = new TSFileNode(fileName, [], []);
-				this._nodes.set(fileName, node);
-			}
-			for (const [fileName, file] of this.sourceFiles) {
-				const node = this._nodes.get(fileName);
-				if (node == null) throw new Error(`Node for file '${fileName}' could not be found. This should not happen.`);
-				node.children = [...file.imports].map((importName) => this._nodes.get(importName)).filter((n) => n != null);
-			}
-			for (const [, node] of this._nodes) {
-				node.parents = [];
-				for (const [, n] of this._nodes) if (n.children.includes(node)) node.parents.push(n);
-			}
-		}
-		return this._nodes;
-	}
-	close() {
-		this.snapshot?.dispose();
-		this.api?.close();
-	}
-	getLineAndCharacterOfPosition(fileName, position) {
-		for (const program of this.getPrograms()) {
-			const sourceFile = program.getSourceFile(fileName);
-			if (sourceFile) return sourceFile.getLineAndCharacterOfPosition(position);
-		}
-	}
-	getPrograms() {
-		if (!this.snapshot) throw new Error("TypescriptCompiler not initialized");
-		const projects = this.snapshot.getProjects();
-		if (projects.length === 0) throw new Error(`No projects found for ${this.tsconfigFile}`);
+	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({
+			reason: "no-projects",
+			subject: s.tsconfigFile
+		});
 		return projects.map((project) => project.program);
-	}
-	collectAllTSConfigFiles(buildModeEnabled) {
-		const tsConfigOverrides = /* @__PURE__ */ new Map();
-		const toProcess = [this.tsconfigFile];
-		const processed = /* @__PURE__ */ new Set();
+	});
+	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 = emptyStringMap();
+		const toProcess = [s.tsconfigFile];
+		const processed = emptyStringSet();
 		while (toProcess.length > 0) {
 			const current = toProcess.pop();
 			if (!current || processed.has(current)) continue;
 			processed.add(current);
-			const content = readFileSync(current, "utf-8");
+			const content = yield* fsService.readFileString(current);
 			const parsed = parseTsConfig(current, content);
 			if (Result.isFailure(parsed)) {
-				this.log.warn(`Could not parse tsconfig file "%s": %s. Compiler-option overrides and project-reference walking were skipped for this file, so mutants may be misreported as compile errors.`, current, parsed.failure.reason);
 				tsConfigOverrides.set(current, content);
 				continue;
 			}
 			tsConfigOverrides.set(current, overrideOptions(parsed.success, buildModeEnabled));
-			for (const referenced of retrieveReferencedProjects(parsed.success, path.dirname(current))) {
-				this.allTSConfigFiles.add(referenced);
+			for (const referenced of retrieveReferencedProjects(parsed.success, pathService.dirname(current), pathService)) {
+				const normalized = normalizeFileName(referenced);
+				s.allTSConfigFiles.add(normalized);
 				toProcess.push(referenced);
 			}
 		}
-		this.fs.tsConfigOverrides = tsConfigOverrides;
-	}
-	buildDependencyGraph(programs) {
-		for (const program of programs) for (const fileName of program.getSourceFileNames()) {
-			if (fileName.endsWith(".d.ts") || fileName.includes("node_modules")) continue;
-			const normalized = toPosixFileName(fileName);
-			this.sourceFiles.set(normalized, {
-				fileName: normalized,
-				imports: /* @__PURE__ */ new Set()
-			});
-		}
-		for (const [fileName] of this.sourceFiles) {
-			const sourceFile = programs.map((p) => p.getSourceFile(fileName)).find((sf) => sf != null);
-			if (!sourceFile) continue;
-			const imports = this.extractImports(sourceFile);
-			for (const specifier of imports) {
-				const resolved = this.resolveModuleSpecifier(fileName, specifier);
-				if (resolved) {
-					const sourceFileName = this.resolveTSInputFile(resolved);
-					if (this.sourceFiles.has(sourceFileName)) this.sourceFiles.get(fileName)?.imports.add(sourceFileName);
-				}
-			}
-		}
-	}
-	extractImports(sourceFile) {
+		yield* fs.setTsConfigOverrides(tsConfigOverrides);
+		yield* Ref.update(stateRef, (prev) => ({
+			...prev,
+			allTSConfigFiles: setFromArray([...s.allTSConfigFiles])
+		}));
+	});
+	const extractImports = (sourceFile) => {
 		const result = [];
 		for (const statement of sourceFile.statements) if (statement.kind === SyntaxKind.ImportDeclaration) {
 			let spec;
@@ -695,17 +939,9 @@ var TypescriptCompiler = class {
 		for (const ref of sourceFile.referencedFiles) result.push(ref.fileName);
 		for (const ref of sourceFile.typeReferenceDirectives) result.push(ref.fileName);
 		return result;
-	}
-	resolveModuleSpecifier(sourceFileName, specifier) {
-		const cleaned = specifier.replace(/^['"]|['"]$/g, "");
-		if (!cleaned.startsWith("./") && !cleaned.startsWith("../")) return;
-		const baseDir = path.dirname(sourceFileName);
-		const resolved = toPosixFileName(path.resolve(baseDir, cleaned));
-		const candidates = this.getResolutionCandidates(resolved);
-		for (const candidate of candidates) if (this.sourceFiles.has(candidate)) return candidate;
-	}
-	getResolutionCandidates(resolved) {
-		const extension = path.extname(resolved);
+	};
+	const getResolutionCandidates = (resolved, pathService) => {
+		const extension = pathService.extname(resolved);
 		if (extension) {
 			const withoutExt = resolved.slice(0, -extension.length);
 			return [
@@ -736,124 +972,198 @@ var TypescriptCompiler = class {
 			`${resolved}/index.mjs`,
 			`${resolved}/index.cjs`
 		];
-	}
-	resolveTSInputFile(dependencyFileName) {
+	};
+	const resolveModuleSpecifier = (sourceFileName, specifier, sourceFiles, pathService) => {
+		const cleaned = specifier.replace(/^['"]|['"]$/g, "");
+		if (!cleaned.startsWith("./") && !cleaned.startsWith("../")) return;
+		const baseDir = pathService.dirname(sourceFileName);
+		const resolved = normalizeFileName(pathService.resolve(baseDir, cleaned));
+		const candidates = getResolutionCandidates(resolved, pathService);
+		for (const candidate of candidates) if (sourceFiles.has(candidate)) return candidate;
+	};
+	const resolveTSInputFile = (dependencyFileName, pathService) => {
 		if (!dependencyFileName.endsWith(".d.ts")) return dependencyFileName;
-		const file = this.fs.getFile(dependencyFileName);
-		if (!file) return dependencyFileName;
-		const sourceMappingURL = getSourceMappingURL(file.content);
+		const content = fs.fileSystem.readFile?.(dependencyFileName);
+		if (typeof content !== "string") return dependencyFileName;
+		const sourceMappingURL = getSourceMappingURL(content);
 		if (!sourceMappingURL) return dependencyFileName;
-		const sourceMapFileName = toPosixFileName(path.resolve(path.dirname(dependencyFileName), sourceMappingURL));
-		const sourceMap = this.fs.getFile(sourceMapFileName);
-		if (!sourceMap) {
-			this.log.warn(`Could not find sourcemap ${sourceMapFileName}`);
-			return dependencyFileName;
-		}
-		const sources = Schema.decodeUnknownSync(Schema.Struct({ sources: Schema.optional(Schema.Array(Schema.String)) }))(JSON.parse(sourceMap.content)).sources;
+		const sourceMapFileName = normalizeFileName(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 toPosixFileName(path.resolve(path.dirname(sourceMapFileName), sourcePath));
+			return normalizeFileName(pathService.resolve(pathService.dirname(sourceMapFileName), sourcePath));
 		}
 		return dependencyFileName;
-	}
-	guardTSConfigFileExists() {
-		try {
-			readFileSync(this.tsconfigFile, "utf-8");
-		} catch {
-			throw new Error(`The tsconfig file does not exist at: "${this.tsconfigFile}". Please configure the tsconfig file in your stryker.conf file using "tsconfigFile"`);
-		}
-	}
-};
-//#endregion
-//#region src/typescript-checker.ts
-const typescriptCheckerLoggerFactory = Object.assign((loggerFactory, target) => {
-	const targetName = target?.name ?? TypescriptChecker.name;
-	return loggerFactory(targetName === TypescriptChecker.name ? TypescriptChecker.name : `${TypescriptChecker.name}.${targetName}`);
-}, { inject: tokens(commonTokens.getLogger, commonTokens.target) });
-const create = Object.assign((injector) => injector.provideFactory(commonTokens.logger, typescriptCheckerLoggerFactory, Scope.Transient).provideClass("fs", HybridFileSystem).provideClass(tsCompiler, TypescriptCompiler).injectClass(TypescriptChecker), { inject: tokens(commonTokens.injector) });
-var TypescriptChecker = class {
-	logger;
-	tsCompiler;
-	static inject = tokens(commonTokens.logger, commonTokens.options, tsCompiler);
-	options;
-	constructor(logger, options, tsCompiler) {
-		this.logger = logger;
-		this.tsCompiler = tsCompiler;
-		this.options = options;
-	}
-	async init() {
-		const errors = await this.tsCompiler.init();
-		if (errors.length) throw new Error(`Typescript error(s) found in dry run compilation: ${this.createErrorText(errors)}`);
-	}
-	async check(mutants) {
-		const result = Object.fromEntries(mutants.map((mutant) => [mutant.id, { status: CheckStatus.Passed }]));
-		const firstMutant = mutants[0];
-		if (!firstMutant || !this.tsCompiler.nodes.get(toPosixFileName(firstMutant.fileName))) return result;
-		const mutantErrorRelationMap = await this.checkErrors(mutants, {}, this.tsCompiler.nodes);
-		for (const [id, errors] of Object.entries(mutantErrorRelationMap)) result[id] = {
-			status: CheckStatus.CompileError,
-			reason: this.createErrorText(errors)
-		};
-		return result;
-	}
-	group(mutants) {
-		if (!this.options.typescriptChecker?.prioritizePerformanceOverAccuracy) return Promise.resolve(mutants.map((m) => [m.id]));
-		const { nodes } = this.tsCompiler;
-		const [mutantsOutsideProject, mutantsInProject] = split(mutants, (m) => nodes.get(toPosixFileName(m.fileName)) == null);
-		const groups = createGroups(mutantsInProject, nodes);
-		if (mutantsOutsideProject.length) return Promise.resolve([mutantsOutsideProject.map((m) => m.id), ...groups]);
-		else return Promise.resolve(groups);
-	}
-	async checkErrors(mutants, errorsMap, nodes) {
-		const errors = await this.tsCompiler.check(mutants);
-		const mutantsThatCouldNotBeTestedInGroups = /* @__PURE__ */ new Set();
-		if (errors.length && mutants.length === 1) {
-			const onlyMutant = mutants[0];
-			if (onlyMutant !== void 0) errorsMap[onlyMutant.id] = errors;
-			return errorsMap;
+	};
+	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(fileName);
+			s.sourceFiles.set(normalized, {
+				fileName: normalized,
+				imports: emptyStringSet()
+			});
 		}
-		for (const error of errors) {
-			if (!error.fileName) throw new Error(`Typescript error: '${error.text}' was reported without a corresponding file. This shouldn't happen. Please open an issue using this link: ${strykerReportBugUrl(`[BUG]: TypeScript checker reports compile error without a corresponding file: ${error.text}`)}`);
-			const nodeErrorWasThrownIn = nodes.get(error.fileName);
-			if (!nodeErrorWasThrownIn) throw new Error(`Typescript error: '${error.text}' was reported in an unrelated file (${error.fileName}). This file is not part of your project, or referenced from your project. This shouldn't happen, please open an issue using this link: ${strykerReportBugUrl(`[BUG]: TypeScript checker reports compile error in an unrelated file: ${error.text}`)}`);
-			const mutantsRelatedToError = nodeErrorWasThrownIn.getMutantsWithReferenceToChildrenOrSelf(mutants);
-			if (mutantsRelatedToError.length === 0) for (const mutant of mutants) mutantsThatCouldNotBeTestedInGroups.add(mutant);
-			else if (mutantsRelatedToError.length === 1) {
-				const onlyRelatedMutant = mutantsRelatedToError[0];
-				if (onlyRelatedMutant !== void 0) {
-					const mutantId = onlyRelatedMutant.id;
-					if (errorsMap[mutantId]) errorsMap[mutantId].push(error);
-					else errorsMap[mutantId] = [error];
+		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) {
+					const sourceFileName = resolveTSInputFile(resolved, pathService);
+					if (s.sourceFiles.has(sourceFileName)) s.sourceFiles.get(fileName)?.imports.add(sourceFileName);
 				}
-			} else for (const mutant of mutantsRelatedToError) mutantsThatCouldNotBeTestedInGroups.add(mutant);
+			}
 		}
-		if (mutantsThatCouldNotBeTestedInGroups.size) await this.tsCompiler.check([]);
-		for (const mutant of mutantsThatCouldNotBeTestedInGroups) {
-			if (errorsMap[mutant.id]) continue;
-			await this.checkErrors([mutant], errorsMap, nodes);
+		yield* Ref.update(stateRef, (prev) => ({
+			...prev,
+			sourceFiles: cloneMap(s.sourceFiles)
+		}));
+	});
+	const getNodesEffect = Effect.gen(function* () {
+		const s = yield* Ref.get(stateRef);
+		if (s.nodes.size > 0) return s.nodes;
+		for (const [fileName] of s.sourceFiles) {
+			const node = makeTSFileNode(fileName);
+			s.nodes.set(fileName, node);
 		}
-		return errorsMap;
-	}
-	createErrorText(errors) {
-		return errors.map((error) => this.formatDiagnostic(error)).join(EOL);
-	}
-	formatDiagnostic(error) {
-		const severity = error.category === DiagnosticCategory.Error ? "error" : error.category === DiagnosticCategory.Warning ? "warning" : error.category === DiagnosticCategory.Suggestion ? "suggestion" : "message";
-		let location = "";
-		if (error.fileName) {
-			const lineAndCharacter = this.tsCompiler.getLineAndCharacterOfPosition(error.fileName, error.pos);
-			const line = (lineAndCharacter?.line ?? 0) + 1;
-			const character = (lineAndCharacter?.character ?? 0) + 1;
-			location = `${error.fileName}(${line},${character}): `;
+		const withChildren = emptyNodes();
+		for (const [fileName, file] of s.sourceFiles) {
+			const node = s.nodes.get(fileName);
+			if (node == null) return yield* new CompilerFailed({
+				reason: "unknown-file-node",
+				subject: fileName
+			});
+			const children = [...file.imports].map((importName) => s.nodes.get(importName)).filter((n) => n !== void 0);
+			withChildren.set(fileName, {
+				...node,
+				children,
+				parents: []
+			});
 		}
-		return `${location}${severity} TS${error.code}: ${error.text}`;
-	}
-};
+		s.nodes.clear();
+		for (const [k, v] of withChildren) s.nodes.set(k, v);
+		const withParents = emptyNodes();
+		for (const [fileName, node] of s.nodes) {
+			const parents = [];
+			for (const [, n] of s.nodes) if (n.children.includes(node)) parents.push(n);
+			withParents.set(fileName, {
+				...node,
+				parents
+			});
+		}
+		s.nodes.clear();
+		for (const [k, v] of withParents) s.nodes.set(k, v);
+		yield* Ref.update(stateRef, (prev) => ({
+			...prev,
+			nodes: cloneMap(s.nodes)
+		}));
+		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 = unique(mutants.map((m) => normalizeFileName(m.fileName)));
+		const changedFiles = unique([...state.lastMutatedFileNames, ...mutatedFileNames]);
+		const current = yield* Ref.get(stateRef);
+		if (current.api && current.snapshot) {
+			const oldSnapshot = current.snapshot;
+			const nextSnapshot = current.api.updateSnapshot({
+				openProjects: [...current.allTSConfigFiles],
+				fileChanges: { changed: changedFiles }
+			});
+			yield* Effect.sync(() => oldSnapshot.dispose());
+			yield* Ref.update(stateRef, (prev) => ({
+				...prev,
+				snapshot: nextSnapshot
+			}));
+		}
+		yield* Ref.update(stateRef, (prev) => ({
+			...prev,
+			lastMutants: [...mutants],
+			lastMutatedFileNames: mutatedFileNames
+		}));
+		return (yield* getProgramsEffect()).flatMap((program) => [
+			...program.getConfigFileParsingDiagnostics(),
+			...program.getSemanticDiagnostics(),
+			...program.getProgramDiagnostics()
+		]).filter((diagnostic) => diagnostic.category === DiagnosticCategory.Error);
+	});
+	const init = Effect.gen(function* () {
+		yield* guardTSVersion(fsService);
+		const absoluteTsconfigFile = normalizeFileName(pathService.resolve(rawTsconfigFile));
+		yield* Ref.update(stateRef, (prev) => ({
+			...prev,
+			tsconfigFile: absoluteTsconfigFile,
+			allTSConfigFiles: setFromArray([absoluteTsconfigFile])
+		}));
+		yield* guardTSConfigFileExistsEffect;
+		const buildModeEnabled = yield* determineBuildModeEnabled(absoluteTsconfigFile, fsService);
+		yield* collectAllTSConfigFiles(buildModeEnabled);
+		const s = yield* Ref.get(stateRef);
+		const api = new API({ fs: fs.fileSystem });
+		const snapshot = api.updateSnapshot({ openProjects: [...s.allTSConfigFiles] });
+		yield* Ref.update(stateRef, (prev) => ({
+			...prev,
+			api,
+			snapshot
+		}));
+		const programs = yield* getProgramsEffect();
+		yield* buildDependencyGraph(programs);
+		return yield* check([]);
+	});
+	const close = Effect.gen(function* () {
+		const s = yield* Ref.get(stateRef);
+		yield* Effect.sync(() => s.snapshot?.dispose());
+		yield* Effect.sync(() => s.api?.close());
+		yield* Ref.update(stateRef, (prev) => ({
+			...prev,
+			snapshot: void 0,
+			api: void 0
+		}));
+	});
+	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 {
+		init,
+		check,
+		nodes: getNodesEffect,
+		close,
+		getLineAndCharacterOfPosition
+	};
+}
 //#endregion
 //#region src/index.ts
-const strykerPlugins = [declareFactoryPlugin(PluginKind.Checker, "typescript", create)];
-const createTypescriptChecker = create;
-const strykerValidationSchema = Schema.decodeUnknownSync(Schema.Record(Schema.String, Schema.Unknown))(JSON.parse(readFileSync(new URL("../schema/typescript-checker-options.json", import.meta.url), "utf-8")));
+const strykerPlugins = [declarePlugin(PluginKind.Checker, "typescript", Layer.effect(Checker, Effect.gen(function* () {
+	const options = yield* RunConfiguration;
+	const fsService = yield* FileSystem.FileSystem;
+	const pathService = yield* Path.Path;
+	return makeCheckerService({
+		options,
+		compiler: makeTypescriptCompiler(options, yield* makeHybridFileSystem(fsService), fsService, pathService)
+	});
+})))];
+const rawSchema = JSON.parse(readFileSync(new URL("../schema/typescript-checker-options.json", import.meta.url), "utf-8"));
+if (!S.is(S.Record(S.String, S.Unknown))(rawSchema)) throw new Error("Invalid typescript-checker schema file");
+const strykerValidationSchema = rawSchema;
 //#endregion
-export { createTypescriptChecker, strykerPlugins, strykerValidationSchema };
+export { strykerPlugins, strykerValidationSchema };