@systemfsoftware/stryker-js-typescript-checker 1.4.1 → 3.0.0

package/dist/index.mjs

@@ -1,14 +1,168 @@
 import { readFileSync } from "fs";
-import { PluginKind, Scope, commonTokens, declareFactoryPlugin, tokens } from "@systemfsoftware/stryker-js-plugin-api/plugin";
-import { Result, Schema } from "effect";
+import { Checker, CheckerFailed } from "@systemfsoftware/stryker-js/Checker";
+import { RunConfiguration, declarePlugin } from "@systemfsoftware/stryker-js/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 { EOL } from "os";
-import { CheckStatus } from "@systemfsoftware/stryker-js-plugin-api/check";
-import { split, strykerReportBugUrl } from "@systemfsoftware/stryker-js-util";
+import { Cell, Wire, Workflow } from "@systemfsoftware/effect-cell-types";
+import { Mutant, errorToString } from "@systemfsoftware/stryker-js/Mutant";
+import { Predicate, Result, Schema } from "effect";
+import { pipe } from "effect/Function";
+import * as HashMap from "effect/HashMap";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as Option from "effect/Option";
 import { API, DiagnosticCategory } from "typescript/unstable/sync";
+import * as Result$1 from "effect/Result";
 import { createRequire } from "module";
-import path from "path";
-import semver from "semver";
+import { StrykerOptionsSchema } from "@systemfsoftware/stryker-js/Schema";
+import * as Context from "effect/Context";
+import * as MutableHashSet from "effect/MutableHashSet";
+import * as Ref from "effect/Ref";
 import { SyntaxKind } from "typescript/unstable/ast";
+//#region src/Checker.schema.ts
+/**
+* Checker — declarations for the TypeScript checker.
+*
+* Houses the wire types and error variants shared by the capability and its
+* workflow. Decoded at the checker boundary; no I/O.
+*/
+var CheckMutantsCommand = class extends S.TaggedClass()("CheckMutantsCommand", { mutants: S.Array(Mutant) }) {};
+/**
+* Every way the TypeScript compiler can fail while serving a check.
+* One tagged error — callers branch only on failure itself; `reason` keeps
+* cases distinguishable in reports.
+*/
+var CompilerFailed = class extends S.TaggedError()("CompilerFailed", {
+	reason: S.Literals([
+		"not-initialized",
+		"no-projects",
+		"unknown-file-node",
+		"file-not-in-project"
+	]),
+	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`;
+		}
+	}
+};
+//#endregion
+//#region src/Checker.workflow.ts
+/**
+* Checker — pure check decision.
+*
+* `Workflow.make` lives here and only here. The workflow receives a fully
+* decoded input (mutants + diagnostics + file graph) and produces the
+* pass/compileError map without touching I/O.
+*/
+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)
+});
+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))
+})));
+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))
+}) {};
+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({
+			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;
+	const result = {};
+	for (const m of mutants) result[m.id] = { status: "passed" };
+	if (mutants.length === 0) return Result$1.succeed(result);
+	const first = mutants[0];
+	if (first === void 0 || nodes[normalizeFileName$3(first.fileName)] === void 0) return Result$1.succeed(result);
+	const classified = classifyDiagnosticsPure(diagnostics, mutants, nodes);
+	if (Result$1.isFailure(classified)) return Result$1.fail(classified.failure);
+	const { definitive } = classified.success;
+	for (const id of Object.keys(definitive)) {
+		const diags = definitive[id];
+		if (diags !== void 0) result[id] = {
+			status: "compileError",
+			reason: diags.map((d) => d.text).join("\n")
+		};
+	}
+	return Result$1.succeed(result);
+};
+const checkMutants = Workflow.make(CheckMutantsInput, (input) => buildResult(input));
+//#endregion
+//#region src/Compiler.schema.ts
+/**
+* Compiler — declarations for the TypeScript compiler and version guard.
+*/
+/** The installed TypeScript version is below the supported floor. */
+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}`;
+	}
+};
+/** Requested file is not present in the hybrid in-memory file map. */
+var HybridFileNotFoundError = class extends Schema.TaggedError()("HybridFileNotFoundError", { fileName: Schema.String }) {};
+//#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,26 +383,43 @@ 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.
+* Tsconfig — declarations for the TypeScript configuration consumed by the checker.
+*
+* Typed by Effect Schema and decoded at the boundary; the compiler capability
+* consumes only validated shapes.
 */
+/** The configured tsconfig failed to parse or is not a shape this package can consume. */
 var TsConfigParseError = class extends Schema.TaggedError()("TsConfigParseError", {
 	file: Schema.String,
 	reason: Schema.String
 }) {};
-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]);
+/** The configured tsconfig file could not be read. */
+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 TsConfigSchema = Schema.Struct({
+	references: Schema.optional(Schema.Array(Schema.Struct({ path: Schema.String }))),
+	compilerOptions: Schema.optional(Schema.Record(Schema.String, Schema.Unknown))
+});
 //#endregion
-//#region src/tsconfig-helpers.ts
+//#region src/Tsconfig.ts
+/**
+* Tsconfig — capability for reading and normalizing TypeScript project configs.
+*
+* Normalizes via Effect Schema and tightens compilation options for mutation
+* checking (disabling quality checks, toggling emit for build-mode vs
+* single-project).
+*/
+const normalizeFileName$2 = (fileName) => fileName.replace(/\\/g, "/");
 const COMPILER_OPTIONS_OVERRIDES = Object.freeze({
 	allowUnreachableCode: true,
 	noUnusedLocals: false,
-	noUnusedParameters: false
+	noUnusedParameters: false,
+	skipLibCheck: true
 });
 const NO_EMIT_OPTIONS_FOR_SINGLE_PROJECT = Object.freeze({
 	noEmit: true,
@@ -260,19 +431,9 @@ const LOW_EMIT_OPTIONS_FOR_PROJECT_REFERENCES = Object.freeze({
 	emitDeclarationOnly: true,
 	noEmit: false,
 	declarationMap: true,
-	declaration: true
+	declaration: true,
+	composite: 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
@@ -286,33 +447,40 @@ 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: error instanceof Error ? error.message : typeof error === "string" ? error : JSON.stringify(error) ?? "a non-Error value was thrown"
+			reason
 		}));
 	}
 }
-/**
-* 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"));
+/** Whether `--build` mode should be enabled based on `references` in the tsconfig. */
+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
-* @param useBuildMode whether or not `--build` mode is used
+* 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,
-		...useBuildMode ? LOW_EMIT_OPTIONS_FOR_PROJECT_REFERENCES : NO_EMIT_OPTIONS_FOR_SINGLE_PROJECT
+		...extraOptions
 	};
 	if (!useBuildMode && compilerOptions["declarationDir"] !== void 0 && compilerOptions["declarationDir"] !== null) delete compilerOptions["declarationDir"];
 	if (useBuildMode) {
@@ -322,99 +490,247 @@ function overrideOptions(config, useBuildMode) {
 		delete compilerOptions["sourceRoot"];
 		delete compilerOptions["outFile"];
 	}
-	return JSON.stringify({
+	if (useBuildMode) return JSON.stringify({
 		...config,
 		compilerOptions
 	});
+	const { references: _references, ...withoutReferences } = config;
+	return JSON.stringify({
+		...withoutReferences,
+		compilerOptions
+	});
 }
 /**
-* Retrieves the referenced config files based on parsed configuration
-* @param config The parsed config file
-* @param fromDirName The directory where to resolve from
+* Retrieves the referenced config files based on parsed configuration.
 */
-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$2(resolved);
 	});
 }
+//#endregion
+//#region src/Compiler.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
+* Compiler — capability that hosts the TypeScript language service, the
+* in-memory file system, and the file-graph used for grouping.
+*
+* All `typescript/unstable/*` interaction is confined here; callers consume
+* only the Effect-typed service surface.
 */
+const normalizeFileName$1 = (fileName) => fileName.replace(/\\/g, "/");
 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];
-	}
-};
-//#endregion
-//#region src/grouping/create-groups.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.
-*
-* @param mutants All the mutants of the test project.
-* @param nodes A graph representation of the test project.
+* 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 guardTSVersion = (fsService) => Effect.gen(function* () {
+	const version = yield* getTSVersion(fsService);
+	if (!isSupportedTypescriptVersion(version)) return yield* new UnsupportedTypeScriptVersionError({ version });
+});
+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;
+}
+const makeEmptyFilesMap = () => MutableHashMap.empty();
+const makeEmptyOverridesMap = () => MutableHashMap.empty();
+const setInPlace = (map, key, value) => {
+	MutableHashMap.set(map, key, value);
+	return map;
+};
+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$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;
+				}
+			}
+		},
+		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;
+			}
+		},
+		directoryExists: () => void 0,
+		getAccessibleEntries: () => void 0,
+		realpath: () => void 0
+	};
+	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 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 mutateFile = (fileName, mutant) => Effect.gen(function* () {
+		const file = yield* getFile(fileName);
+		if (file === void 0) return yield* new HybridFileNotFoundError({ fileName });
+		const next = mutateScriptFile(file, mutant);
+		const normalized = normalizeFileName$1(fileName);
+		yield* Ref.update(filesRef, (m) => setInPlace(m, normalized, next));
+	});
+	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 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;
+	});
+	const setTsConfigOverrides = (overrides) => Ref.set(overridesRef, overrides);
+	return {
+		fileSystem,
+		getFile,
+		writeFile,
+		mutateFile,
+		resetFile,
+		existsInMemory,
+		setTsConfigOverrides
+	};
+});
+function makeTSFileNode(fileName) {
+	return {
+		fileName,
+		parents: [],
+		children: []
+	};
+}
+function getAllParentReferencesIncludingSelf(node, allParentReferences = MutableHashSet.empty()) {
+	MutableHashSet.add(allParentReferences, node);
+	for (const parent of node.parents) if (!MutableHashSet.has(allParentReferences, parent)) getAllParentReferencesIncludingSelf(parent, allParentReferences);
+	return allParentReferences;
+}
 function createGroups(mutants, nodes) {
 	const groups = [];
-	const mutantsToGroup = new Set(mutants);
-	while (mutantsToGroup.size) {
+	const mutantsToGroup = MutableHashSet.fromIterable(mutants);
+	while (MutableHashSet.size(mutantsToGroup) > 0) {
 		const group = [];
-		const groupNodes = /* @__PURE__ */ new Set();
-		const nodesToIgnore = /* @__PURE__ */ new Set();
+		const groupNodes = MutableHashSet.empty();
+		const nodesToIgnore = MutableHashSet.empty();
 		for (const currentMutant of mutantsToGroup) {
 			const currentNode = findNode(currentMutant.fileName, nodes);
-			if (!nodesToIgnore.has(currentNode) && !parentsHaveOverlapWith(currentNode, groupNodes)) {
+			if (!MutableHashSet.has(nodesToIgnore, currentNode) && !parentsHaveOverlapWith(currentNode, groupNodes)) {
 				group.push(currentMutant.id);
-				groupNodes.add(currentNode);
-				mutantsToGroup.delete(currentMutant);
-				addRangeOfNodesToSet(nodesToIgnore, currentNode.getAllParentReferencesIncludingSelf());
+				MutableHashSet.add(groupNodes, currentNode);
+				MutableHashSet.remove(mutantsToGroup, currentMutant);
+				addRangeOfNodesToSet(nodesToIgnore, getAllParentReferencesIncludingSelf(currentNode));
 			}
 		}
 		groups.push(group);
@@ -422,264 +738,111 @@ function createGroups(mutants, nodes) {
 	return groups;
 }
 function addRangeOfNodesToSet(nodes, nodesToAdd) {
-	for (const parent of nodesToAdd) nodes.add(parent);
+	for (const parent of nodesToAdd) MutableHashSet.add(nodes, parent);
 }
 function findNode(fileName, nodes) {
-	const node = nodes.get(toPosixFileName(fileName));
-	if (node == null) throw new Error(`Node not in graph: ${fileName}`);
-	return node;
+	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}`);
 }
 function parentsHaveOverlapWith(currentNode, groupNodes) {
-	for (const parentNode of currentNode.getAllParentReferencesIncludingSelf()) if (groupNodes.has(parentNode)) return true;
+	for (const parentNode of getAllParentReferencesIncludingSelf(currentNode)) if (MutableHashSet.has(groupNodes, 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();
-	}
-};
-//#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;
+var TypeScriptCompiler = class extends Context.Service()("@systemfsoftware/stryker-js-typescript-checker/TypeScriptCompiler") {};
+const makeDummy = Effect.gen(function* () {
+	const stateRef = yield* Ref.make({
+		api: void 0,
+		snapshot: void 0,
+		sourceFiles: MutableHashMap.empty(),
+		nodes: MutableHashMap.empty(),
+		lastMutants: [],
+		lastMutatedFileNames: [],
+		allTSConfigFiles: MutableHashSet.fromIterable(["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$1(options.tsconfigFile);
+	const initialState = {
+		api: void 0,
+		snapshot: void 0,
+		sourceFiles: MutableHashMap.empty(),
+		nodes: MutableHashMap.empty(),
+		lastMutants: [],
+		lastMutatedFileNames: [],
+		allTSConfigFiles: MutableHashSet.fromIterable([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 = MutableHashMap.empty();
+		const toProcess = [s.tsconfigFile];
+		const processed = MutableHashSet.empty();
 		while (toProcess.length > 0) {
 			const current = toProcess.pop();
-			if (!current || processed.has(current)) continue;
-			processed.add(current);
-			const content = readFileSync(current, "utf-8");
+			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)) {
-				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);
+				MutableHashMap.set(tsConfigOverrides, current, content);
 				continue;
 			}
-			tsConfigOverrides.set(current, overrideOptions(parsed.success, buildModeEnabled));
-			for (const referenced of retrieveReferencedProjects(parsed.success, path.dirname(current))) {
-				this.allTSConfigFiles.add(referenced);
+			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);
 			}
 		}
-		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: MutableHashSet.fromIterable(s.allTSConfigFiles)
+		}));
+	});
+	const extractImports = (sourceFile) => {
 		const result = [];
 		for (const statement of sourceFile.statements) if (statement.kind === SyntaxKind.ImportDeclaration) {
 			let spec;
@@ -695,17 +858,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 +891,332 @@ 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$1(pathService.resolve(baseDir, cleaned));
+		const candidates = getResolutionCandidates(resolved, pathService);
+		for (const candidate of candidates) if (MutableHashMap.has(sourceFiles, 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);
-		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 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 toPosixFileName(path.resolve(path.dirname(sourceMapFileName), sourcePath));
+			return normalizeFileName$1(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$1(fileName);
+			MutableHashMap.set(s.sourceFiles, normalized, {
+				fileName: normalized,
+				imports: MutableHashSet.empty()
+			});
 		}
-		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 !== 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);
+					}
 				}
-			} 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: MutableHashMap.fromIterable(s.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);
 		}
-		return errorsMap;
-	}
-	createErrorText(errors) {
-		return errors.map((error) => this.formatDiagnostic(error)).join(EOL);
+		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: []
+			});
+		}
+		MutableHashMap.clear(s.nodes);
+		for (const [k, v] of withChildren) MutableHashMap.set(s.nodes, k, v);
+		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);
+		yield* Ref.update(stateRef, (prev) => ({
+			...prev,
+			nodes: MutableHashMap.fromIterable(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 = Array.from(MutableHashSet.fromIterable(mutants.map((m) => normalizeFileName$1(m.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
+			}));
+		}
+		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$1(pathService.resolve(rawTsconfigFile));
+		yield* Ref.update(stateRef, (prev) => ({
+			...prev,
+			tsconfigFile: absoluteTsconfigFile,
+			allTSConfigFiles: MutableHashSet.fromIterable([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: Array.from(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/Checker.ts
+/**
+* Checker — capability that validates mutants against the TypeScript compiler.
+*
+* Bridges the checker plugin protocol (`@systemfsoftware/stryker-js/Checker`)
+* to the compiler service and the pure `checkMutants` workflow. Diagnostics
+* are classified without I/O; the file graph is sourced from the compiler.
+*/
+const normalizeFileName = (fileName) => fileName.replace(/\\/g, "/");
+/**
+* Pure grouping decision: separates mutants inside the project graph from
+* those outside it, honouring `prioritizePerformanceOverAccuracy`.
+*/
+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 makeCheckDescription = (compiler) => pipe(Cell.read((command) => Effect.gen(function* () {
+	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
+	});
+})), Cell.decode((raw) => Result.succeed(raw)), Cell.decide(checkMutants), Cell.encode((outcome) => outcome), Cell.write((outcome) => Result.match(outcome, {
+	onFailure: (failure) => Effect.fail(new CheckerFailed({
+		checkerName: "typescript",
+		mutantIds: [],
+		cause: errorToString(failure)
+	})),
+	onSuccess: (record) => {
+		let map = HashMap.empty();
+		for (const [id, value] of Object.entries(record)) if (value.status === "passed") map = HashMap.set(map, id, { status: "passed" });
+		else map = HashMap.set(map, id, {
+			status: "compileError",
+			reason: value.reason
+		});
+		return Effect.succeed(map);
 	}
-	formatDiagnostic(error) {
-		const severity = error.category === DiagnosticCategory.Error ? "error" : error.category === DiagnosticCategory.Warning ? "warning" : error.category === DiagnosticCategory.Suggestion ? "suggestion" : "message";
+})));
+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 = "";
-		if (error.fileName) {
-			const lineAndCharacter = this.tsCompiler.getLineAndCharacterOfPosition(error.fileName, error.pos);
+		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(EOL);
+	});
+	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 command = new CheckMutantsCommand({ mutants: [...mutants] });
+			const description = makeCheckDescription(compiler);
+			return yield* Cell.apply(description, command);
+		}),
+		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;
+		})
+	};
+}
 //#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("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 };