@systemfsoftware/stryker-js-typescript-checker 5.0.4 → 6.0.0

package/dist/index.mjs

@@ -1,22 +1,4 @@
-import { Checker, CheckerFailed, Mutant, RunConfiguration, StrykerOptionsSchema, declarePlugin, errorToString, normalizeFileName } from "@systemfsoftware/stryker-js";
-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 { Cell, Workflow } from "@systemfsoftware/effect-cell-types";
-import { Predicate, Result, Schema } from "effect";
-import * as HashMap from "effect/HashMap";
-import * as Match from "effect/Match";
-import * as Option from "effect/Option";
-import { API, DiagnosticCategory } from "typescript/unstable/sync";
-import * as Arr from "effect/Array";
-import * as Result$1 from "effect/Result";
-import * as Context from "effect/Context";
-import * as MutableHashMap from "effect/MutableHashMap";
-import * as MutableHashSet from "effect/MutableHashSet";
-import * as Ref from "effect/Ref";
-import { SyntaxKind } from "typescript/unstable/ast";
 //#region schema/typescript-checker-options.json
 var typescript_checker_options_default = {
 	$schema: "http://json-schema.org/draft-07/schema",
@@ -37,1245 +19,12 @@ var typescript_checker_options_default = {
 	} }
 };
 //#endregion
-//#region src/CheckMutants.schema.ts
-/** A file name the node map can be keyed by: non-empty, and naming an extension. */
-const SourceFileSchema = S.NonEmptyString.pipe(S.check(S.isPattern(/\.[^./\\]+$/)));
-const DiagnosticSchema = S.Struct({
-	fileName: S.optional(SourceFileSchema),
-	text: S.String
-});
-const TSFileNodeSchema = S.suspend(() => S.Struct({
-	fileName: SourceFileSchema,
-	parents: S.Array(TSFileNodeSchema),
-	children: S.Array(TSFileNodeSchema)
-}));
-var CheckMutantsInput = class extends S.TaggedClass()("CheckMutantsInput", {
-	mutants: S.Array(Mutant),
-	diagnostics: S.Array(DiagnosticSchema),
-	nodes: S.Record(SourceFileSchema, TSFileNodeSchema)
-}) {};
-//#endregion
-//#region src/check-mutants.workflow.ts
-var DiagnosticWithoutFileError = class extends S.TaggedError()("DiagnosticWithoutFileError", { text: S.String }) {};
-var DiagnosticInUnrelatedFileError = class extends S.TaggedError()("DiagnosticInUnrelatedFileError", {
-	text: S.String,
-	fileName: S.String
-}) {};
-const CheckMutantsTypeId = Symbol.for("@systemfsoftware/stryker-js-typescript-checker/CheckMutants");
-const MutantCheckStatusSchema = S.Union([S.Struct({ status: S.Literal("passed") }), S.Struct({
-	status: S.Literal("compileError"),
-	reason: S.String
-})]);
-var CheckFinished = class extends S.TaggedClass()("CheckFinished", { results: S.Record(S.String, MutantCheckStatusSchema) }) {
-	[CheckMutantsTypeId] = CheckMutantsTypeId;
-};
-var RetestRequired = class extends S.TaggedClass()("RetestRequired", {
-	results: S.Record(S.String, MutantCheckStatusSchema),
-	needsRetest: S.Array(Mutant)
-}) {
-	[CheckMutantsTypeId] = CheckMutantsTypeId;
-};
-const normalizeFileName$3 = (fileName) => fileName.replace(/\\/g, "/");
-const nodeAt = (fileName, nodes) => Option.filter(Option.fromUndefinedOr(nodes[fileName]), () => Object.hasOwn(nodes, fileName));
-const nodeOf = (diagnostic, nodes) => Option.match(Option.filter(Option.fromUndefinedOr(diagnostic.fileName), (fileName) => fileName !== ""), {
-	onNone: () => Result$1.fail(new DiagnosticWithoutFileError({ text: diagnostic.text })),
-	onSome: (fileName) => Option.match(nodeAt(fileName, nodes), {
-		onNone: () => Result$1.fail(new DiagnosticInUnrelatedFileError({
-			text: diagnostic.text,
-			fileName
-		})),
-		onSome: (node) => Result$1.succeed(node)
-	})
-});
-const walk = (node, mutants, visited) => Option.match(Option.filter(Option.some(node), (current) => !visited.includes(current.fileName)), {
-	onNone: () => [],
-	onSome: (current) => [...mutants.filter((mutant) => normalizeFileName$3(mutant.fileName) === current.fileName), ...current.children.flatMap((child) => walk(child, mutants, [...visited, current.fileName]))]
-});
-const emptyAccumulator = () => ({
-	definitive: HashMap.empty(),
-	needsRetest: HashMap.empty()
-});
-const addAll = (into, mutants) => mutants.reduce((accumulated, mutant) => HashMap.set(accumulated, mutant.id, mutant), into);
-const appendDiagnostic = (into, mutantId, diagnostic) => HashMap.set(into, mutantId, [...Option.getOrElse(HashMap.get(into, mutantId), () => []), diagnostic]);
-const classifyOne = (state, diagnostic, mutants, nodes) => Result$1.flatMap(nodeOf(diagnostic, nodes), (node) => {
-	const related = walk(node, mutants, []);
-	return Result$1.succeed(Option.match(Option.filter(Arr.head(related), () => related.length === 1), {
-		onSome: (only) => ({
-			definitive: appendDiagnostic(state.definitive, only.id, diagnostic),
-			needsRetest: state.needsRetest
-		}),
-		onNone: () => Option.match(Arr.head(related), {
-			onNone: () => ({
-				definitive: state.definitive,
-				needsRetest: addAll(state.needsRetest, mutants)
-			}),
-			onSome: () => ({
-				definitive: state.definitive,
-				needsRetest: addAll(state.needsRetest, related)
-			})
-		})
-	}));
-});
-const classifyDiagnostics = (diagnostics, mutants, nodes) => Option.match(Option.filter(Option.filter(Arr.head(mutants), () => mutants.length === 1), () => diagnostics.length > 0), {
-	onSome: (only) => Result$1.succeed({
-		definitive: HashMap.set(HashMap.empty(), only.id, [...diagnostics]),
-		needsRetest: []
-	}),
-	onNone: () => Result$1.map(diagnostics.reduce((accumulated, diagnostic) => Result$1.flatMap(accumulated, (state) => classifyOne(state, diagnostic, mutants, nodes)), Result$1.succeed(emptyAccumulator())), (state) => ({
-		definitive: state.definitive,
-		needsRetest: HashMap.toValues(state.needsRetest).filter((mutant) => !HashMap.has(state.definitive, mutant.id))
-	}))
-});
-const passedResults = (mutants) => mutants.map((mutant) => [mutant.id, { status: "passed" }]);
-const checkResults = (mutants, classification) => {
-	const retestIds = classification.needsRetest.reduce((accumulated, mutant) => HashMap.set(accumulated, mutant.id, true), HashMap.empty());
-	return mutants.flatMap((mutant) => Option.match(HashMap.get(classification.definitive, mutant.id), {
-		onSome: (diagnostics) => [[mutant.id, {
-			status: "compileError",
-			reason: diagnostics.map((entry) => entry.text).join("\n")
-		}]],
-		onNone: () => Option.match(Option.filter(Option.some({ status: "passed" }), () => !HashMap.has(retestIds, mutant.id)), {
-			onSome: (status) => [[mutant.id, status]],
-			onNone: () => []
-		})
-	}));
-};
-const verdictOf = (mutants, classification) => {
-	const results = Object.fromEntries(checkResults(mutants, classification));
-	return Option.match(Arr.head(classification.needsRetest), {
-		onNone: () => CheckFinished.make({ results }),
-		onSome: () => RetestRequired.make({
-			results,
-			needsRetest: [...classification.needsRetest]
-		})
-	});
-};
-const classify = (input) => Result$1.map(classifyDiagnostics(input.diagnostics, input.mutants, input.nodes), (classification) => verdictOf(input.mutants, classification));
-const withoutDisambiguation = (input) => Option.match(Arr.head(input.mutants), {
-	onNone: () => Option.some(CheckFinished.make({ results: {} })),
-	onSome: (first) => Option.map(Option.filter(Option.some(first), () => !Object.hasOwn(input.nodes, normalizeFileName$3(first.fileName))), () => CheckFinished.make({ results: Object.fromEntries(passedResults(input.mutants)) }))
-});
-const verdict = (input) => Option.match(withoutDisambiguation(input), {
-	onNone: () => classify(input),
-	onSome: (decision) => Result$1.succeed(decision)
-});
-const checkMutants = Workflow.make(CheckMutantsInput, verdict);
-//#endregion
-//#region src/Checker.schema.ts
-/**
-* 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.
-*/
-const TypescriptCheckerOptionsSchema = S.Struct({ typescriptChecker: S.optional(S.Struct({ prioritizePerformanceOverAccuracy: S.optional(S.Boolean) })) });
-var CheckMutantsCommand = class extends S.TaggedClass()("CheckMutantsCommand", { mutants: S.Array(Mutant) }) {};
-/**
-* Every way the TypeScript compiler can fail while serving a check.
-* 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() {
-		return Match.value(this.reason).pipe(Match.when("not-initialized", () => "The TypeScript compiler was used before it was initialized"), Match.when("no-projects", () => `No projects were found for ${this.subject ?? "the tsconfig"}`), Match.when("unknown-file-node", () => `The file graph has no node for '${this.subject ?? "a file"}', which should not happen`), Match.when("file-not-in-project", () => `'${this.subject ?? "a file"}' is part of your TypeScript project but could not be found on disk`), Match.exhaustive);
-	}
-};
-//#endregion
-//#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.
-*
-* @example Usage
-* ```ts
-* import { parse } from "@std/jsonc";
-* import { assertEquals } from "@std/assert";
-*
-* assertEquals(parse('{"foo": "bar"}'), { foo: "bar" });
-* assertEquals(parse('{"foo": "bar", }'), { foo: "bar" });
-* assertEquals(parse('{"foo": "bar", } /* comment *\/'), { foo: "bar" });
-* ```
-*
-* @throws {SyntaxError} If the JSONC string is invalid.
-* @param text A valid JSONC string.
-* @returns The parsed JsonValue from the JSONC string.
-*/ function parse(text) {
-	if (new.target) throw new TypeError("Cannot create an instance: parse is not a constructor");
-	return new JsoncParser(text).parse();
-}
-var JsoncParser = class {
-	#whitespace = /* @__PURE__ */ new Set(" 	\r\n");
-	#numberEndToken = /* @__PURE__ */ new Set([..."[]{}:,/", ...this.#whitespace]);
-	#text;
-	#length;
-	#tokenized;
-	constructor(text) {
-		this.#text = `${text}`;
-		this.#length = this.#text.length;
-		this.#tokenized = this.#tokenize();
-	}
-	parse() {
-		const token = this.#getNext();
-		const res = this.#parseJsonValue(token);
-		const { done, value } = this.#tokenized.next();
-		if (!done) throw new SyntaxError(buildErrorMessage(value));
-		return res;
-	}
-	/** Read the next token. If the token is read to the end, it throws a SyntaxError. */ #getNext() {
-		const { done, value } = this.#tokenized.next();
-		if (done) throw new SyntaxError("Cannot parse JSONC: unexpected end of JSONC input");
-		return value;
-	}
-	/** Split the JSONC string into token units. Whitespace and comments are skipped. */ *#tokenize() {
-		for (let i = 0; i < this.#length; i++) {
-			if (this.#whitespace.has(this.#text[i])) continue;
-			if (this.#text[i] === "/" && this.#text[i + 1] === "*") {
-				i += 2;
-				let hasEndOfComment = false;
-				for (; i < this.#length; i++) if (this.#text[i] === "*" && this.#text[i + 1] === "/") {
-					hasEndOfComment = true;
-					break;
-				}
-				if (!hasEndOfComment) throw new SyntaxError("Cannot parse JSONC: unexpected end of JSONC input");
-				i++;
-				continue;
-			}
-			if (this.#text[i] === "/" && this.#text[i + 1] === "/") {
-				i += 2;
-				for (; i < this.#length; i++) if (this.#text[i] === "\n" || this.#text[i] === "\r") break;
-				continue;
-			}
-			switch (this.#text[i]) {
-				case "{":
-					yield {
-						type: "BeginObject",
-						position: i
-					};
-					break;
-				case "}":
-					yield {
-						type: "EndObject",
-						position: i
-					};
-					break;
-				case "[":
-					yield {
-						type: "BeginArray",
-						position: i
-					};
-					break;
-				case "]":
-					yield {
-						type: "EndArray",
-						position: i
-					};
-					break;
-				case ":":
-					yield {
-						type: "NameSeparator",
-						position: i
-					};
-					break;
-				case ",":
-					yield {
-						type: "ValueSeparator",
-						position: i
-					};
-					break;
-				case "\"": {
-					const startIndex = i;
-					let shouldEscapeNext = false;
-					i++;
-					for (; i < this.#length; i++) {
-						if (this.#text[i] === "\"" && !shouldEscapeNext) break;
-						shouldEscapeNext = this.#text[i] === "\\" && !shouldEscapeNext;
-					}
-					yield {
-						type: "String",
-						sourceText: this.#text.substring(startIndex, i + 1),
-						position: startIndex
-					};
-					break;
-				}
-				default: {
-					const startIndex = i;
-					for (; i < this.#length; i++) if (this.#numberEndToken.has(this.#text[i])) break;
-					i--;
-					yield {
-						type: "NullOrTrueOrFalseOrNumber",
-						sourceText: this.#text.substring(startIndex, i + 1),
-						position: startIndex
-					};
-				}
-			}
-		}
-	}
-	#parseJsonValue(value) {
-		switch (value.type) {
-			case "BeginObject": return this.#parseObject();
-			case "BeginArray": return this.#parseArray();
-			case "NullOrTrueOrFalseOrNumber": return this.#parseNullOrTrueOrFalseOrNumber(value);
-			case "String": return this.#parseString(value);
-			default: throw new SyntaxError(buildErrorMessage(value));
-		}
-	}
-	#parseObject() {
-		const target = {};
-		while (true) {
-			const token1 = this.#getNext();
-			if (token1.type === "EndObject") return target;
-			if (token1.type !== "String") throw new SyntaxError(buildErrorMessage(token1));
-			const key = this.#parseString(token1);
-			const token2 = this.#getNext();
-			if (token2.type !== "NameSeparator") throw new SyntaxError(buildErrorMessage(token2));
-			const token3 = this.#getNext();
-			Object.defineProperty(target, key, {
-				value: this.#parseJsonValue(token3),
-				writable: true,
-				enumerable: true,
-				configurable: true
-			});
-			const token4 = this.#getNext();
-			if (token4.type === "EndObject") return target;
-			if (token4.type !== "ValueSeparator") throw new SyntaxError(buildErrorMessage(token4));
-		}
-	}
-	#parseArray() {
-		const target = [];
-		while (true) {
-			const token1 = this.#getNext();
-			if (token1.type === "EndArray") return target;
-			target.push(this.#parseJsonValue(token1));
-			const token2 = this.#getNext();
-			if (token2.type === "EndArray") return target;
-			if (token2.type !== "ValueSeparator") throw new SyntaxError(buildErrorMessage(token2));
-		}
-	}
-	#parseString(value) {
-		let parsed;
-		try {
-			parsed = JSON.parse(value.sourceText);
-		} catch {
-			throw new SyntaxError(buildErrorMessage(value));
-		}
-		if (typeof parsed !== "string") throw new TypeError(`Parsed value is not a string: ${parsed}`);
-		return parsed;
-	}
-	#parseNullOrTrueOrFalseOrNumber(value) {
-		if (value.sourceText === "null") return null;
-		if (value.sourceText === "true") return true;
-		if (value.sourceText === "false") return false;
-		let parsed;
-		try {
-			parsed = JSON.parse(value.sourceText);
-		} catch {
-			throw new SyntaxError(buildErrorMessage(value));
-		}
-		if (typeof parsed !== "number") throw new TypeError(`Parsed value is not a number: ${parsed}`);
-		return parsed;
-	}
-};
-function buildErrorMessage({ type, sourceText, position }) {
-	let token = "";
-	switch (type) {
-		case "BeginObject":
-			token = "{";
-			break;
-		case "EndObject":
-			token = "}";
-			break;
-		case "BeginArray":
-			token = "[";
-			break;
-		case "EndArray":
-			token = "]";
-			break;
-		case "NameSeparator":
-			token = ":";
-			break;
-		case "ValueSeparator":
-			token = ",";
-			break;
-		case "NullOrTrueOrFalseOrNumber":
-		case "String": token = 30 < sourceText.length ? `${sourceText.slice(0, 30)}...` : sourceText;
-	}
-	return `Cannot parse JSONC: unexpected token "${token}" in JSONC at position ${position}`;
-}
-//#endregion
-//#region src/Tsconfig.schema.ts
-/**
-* 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
-}) {};
-/** 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.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,
-	skipLibCheck: true
-});
-const NO_EMIT_OPTIONS_FOR_SINGLE_PROJECT = Object.freeze({
-	noEmit: true,
-	incremental: false,
-	tsBuildInfoFile: void 0,
-	composite: false
-});
-const LOW_EMIT_OPTIONS_FOR_PROJECT_REFERENCES = Object.freeze({
-	emitDeclarationOnly: true,
-	noEmit: false,
-	declarationMap: true,
-	declaration: true,
-	composite: true
-});
-const reasonOfThrown = (error) => Match.value(error).pipe(Match.when(Predicate.isError, (thrown) => thrown.message), Match.when(Predicate.isString, (thrown) => thrown), Match.orElse((thrown) => Option.match(Option.filter(Option.fromUndefinedOr(JSON.stringify(thrown)), (text) => text.length > 0), {
-	onNone: () => "a non-Error value was thrown",
-	onSome: (text) => text
-})));
-/**
-* Parses the raw text of a tsconfig file into a typed config, rejecting shapes this package cannot consume.
-* @param fileName The tsconfig file name, used for error reporting
-* @param jsonText The raw tsconfig content
-*/
-function parseTsConfig(fileName, jsonText) {
-	try {
-		const value = parse(jsonText.replace(/^\uFEFF/, ""));
-		return Result.mapError(Schema.decodeUnknownResult(TsConfigSchema)(value), (error) => new TsConfigParseError({
-			file: fileName,
-			reason: error.message
-		}));
-	} catch (error) {
-		return Result.fail(new TsConfigParseError({
-			file: fileName,
-			reason: reasonOfThrown(error)
-		}));
-	}
-}
-/** 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
-	});
-});
-const withCompilerOverrides = (config, extraOptions) => ({
-	...config.compilerOptions,
-	...COMPILER_OPTIONS_OVERRIDES,
-	...extraOptions
-});
-const projectReferencesJson = (config) => {
-	const compilerOptions = withCompilerOverrides(config, LOW_EMIT_OPTIONS_FOR_PROJECT_REFERENCES);
-	delete compilerOptions["inlineSourceMap"];
-	delete compilerOptions["inlineSources"];
-	delete compilerOptions["mapRoute"];
-	delete compilerOptions["sourceRoot"];
-	delete compilerOptions["outFile"];
-	return JSON.stringify({
-		...config,
-		compilerOptions
-	});
-};
-const singleProjectJson = (config) => {
-	const compilerOptions = withCompilerOverrides(config, NO_EMIT_OPTIONS_FOR_SINGLE_PROJECT);
-	if (compilerOptions["declarationDir"] !== null) delete compilerOptions["declarationDir"];
-	const { references: _references, ...withoutReferences } = config;
-	return JSON.stringify({
-		...withoutReferences,
-		compilerOptions
-	});
-};
-/**
-* Overrides compiler options to speed up compilation and disable code quality
-* checks irrelevant during mutation testing.
-*/
-function overrideOptions(config, useBuildMode) {
-	if (useBuildMode) return projectReferencesJson(config);
-	return singleProjectJson(config);
-}
-/**
-* Retrieves the referenced config files based on parsed configuration.
-*/
-function retrieveReferencedProjects(config, fromDirName, pathService) {
-	return (config.references ?? []).map((reference) => {
-		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
-const normalizeFileName$1 = (fileName) => fileName.replace(/\\/g, "/");
-const findSourceMapRegex = /\/\/# sourceMappingURL=(.+)$/m;
-/** A specifier that resolves relative to the importing file. */
-const relativeSpecifierPattern = /^\.\.?\//;
-/** A file that never belongs to the dependency graph: declarations and dependencies. */
-const ignoredGraphFileNamePattern = /\.d\.ts$|node_modules/;
-function getSourceMappingURL(content) {
-	return findSourceMapRegex.exec(content)?.[1];
-}
-let cachedTSVersion;
-const isString = (value) => typeof value === "string";
-const isNonEmptyString = (value) => value !== void 0 && value !== "";
-const versionFieldOf = (raw) => {
-	if (Predicate.hasProperty(raw, "version")) return Option.some(raw.version);
-	return Option.none();
-};
-const readTypescriptPackageVersion = (fsService, pathService) => Effect.gen(function* () {
-	const urlString = import.meta.resolve("typescript/package.json");
-	const pkgPath = yield* pathService.fromFileUrl(new URL(urlString));
-	const text = yield* fsService.readFileString(pkgPath);
-	const raw = JSON.parse(text);
-	return Option.getOrElse(Option.flatMap(versionFieldOf(raw), (version) => Option.liftPredicate(version, isString)), () => "");
-});
-const getTSVersion = (fsService, pathService) => Effect.gen(function* () {
-	if (cachedTSVersion !== void 0) return cachedTSVersion;
-	const version = yield* readTypescriptPackageVersion(fsService, pathService);
-	cachedTSVersion = version;
-	return version;
-});
-const minimumSupportedTypeScriptVersion = {
-	major: 7,
-	minor: 0,
-	patch: 0
-};
-const versionComponent = (parts, index) => {
-	const part = parts[index];
-	if (part === void 0) return 0;
-	return Number.parseInt(part, 10);
-};
-/** Drops any pre-release (`-`) or build (`+`) suffix, keeping the numeric base. */
-const parseTypeScriptVersion = (version) => {
-	const parts = version.replace(/[-+][\s\S]*$/, "").split(".");
-	return {
-		major: versionComponent(parts, 0),
-		minor: versionComponent(parts, 1),
-		patch: versionComponent(parts, 2)
-	};
-};
-const compareVersionNumbers = (left, right) => {
-	return [
-		left.major - right.major,
-		left.minor - right.minor,
-		left.patch - right.patch
-	].find((difference) => difference !== 0) ?? 0;
-};
-/**
-* Whether a TypeScript version satisfies `>=7.0.0`. Pre-release suffixes are
-* stripped so `7.0.0-beta` compares as `7.0.0`.
-*/
-function isSupportedTypescriptVersion(version) {
-	const parsed = parseTypeScriptVersion(version);
-	if (![
-		parsed.major,
-		parsed.minor,
-		parsed.patch
-	].every((part) => !Number.isNaN(part))) return false;
-	return compareVersionNumbers(parsed, minimumSupportedTypeScriptVersion) >= 0;
-}
-const guardTSVersion = (fsService, pathService) => Effect.gen(function* () {
-	const version = yield* getTSVersion(fsService, pathService);
-	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 = pos.column;
-	lines.forEach((line, index) => {
-		if (index < lineCount) offset += line.length + 1;
-	});
-	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 memoryContent = (file) => {
-		if (file === void 0) return null;
-		return file.content;
-	};
-	const readFromSources = (files, overrides, fileName) => {
-		const override = MutableHashMap.get(overrides, fileName);
-		if (Option.isSome(override)) return override.value;
-		return Option.match(MutableHashMap.get(files, fileName), {
-			onNone: () => void 0,
-			onSome: memoryContent
-		});
-	};
-	const existsInSources = (files, overrides, fileName) => {
-		const override = MutableHashMap.get(overrides, fileName);
-		if (Option.isSome(override)) return true;
-		return Option.match(MutableHashMap.get(files, fileName), {
-			onNone: () => void 0,
-			onSome: (file) => file !== void 0
-		});
-	};
-	const fileSystem = {
-		readFile: (fileName) => {
-			const normalized = normalizeFileName$1(fileName);
-			if (normalized.endsWith(".tsbuildinfo")) return null;
-			return readFromSources(filesRef.ref.current, overridesRef.ref.current, normalized);
-		},
-		fileExists: (fileName) => {
-			const normalized = normalizeFileName$1(fileName);
-			if (normalized.endsWith(".tsbuildinfo")) return false;
-			return existsInSources(filesRef.ref.current, overridesRef.ref.current, normalized);
-		},
-		directoryExists: () => void 0,
-		getAccessibleEntries: () => void 0,
-		realpath: () => void 0
-	};
-	const readFileFromDisk = (fileName) => Effect.gen(function* () {
-		const content = yield* fsService.readFileString(fileName).pipe(Effect.orElseSucceed(() => void 0));
-		const file = Option.getOrUndefined(Option.map(Option.fromUndefinedOr(content), (text) => makeScriptFile(text, fileName)));
-		yield* Ref.update(filesRef, (m) => setInPlace(m, fileName, file));
-		return file;
-	});
-	const getFile = (fileName) => Effect.gen(function* () {
-		const normalized = normalizeFileName$1(fileName);
-		const files = yield* Ref.get(filesRef);
-		const cached = MutableHashMap.get(files, normalized);
-		if (Option.isSome(cached)) return cached.value;
-		return yield* readFileFromDisk(normalized);
-	});
-	const fileForWrite = (existing, data, fileName) => {
-		if (existing === void 0) return makeScriptFile(data, fileName);
-		return withContent(existing, data);
-	};
-	const writeFile = (fileName, data) => Effect.gen(function* () {
-		const normalized = normalizeFileName$1(fileName);
-		const files = yield* Ref.get(filesRef);
-		const existing = Option.getOrUndefined(MutableHashMap.get(files, normalized));
-		yield* Ref.update(filesRef, (m) => setInPlace(m, normalized, fileForWrite(existing, data, normalized)));
-	});
-	const mutateFile = (fileName, mutant) => Effect.gen(function* () {
-		const file = yield* getFile(fileName);
-		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 file = Option.getOrUndefined(MutableHashMap.get(files, normalized));
-		if (file === void 0) return;
-		yield* Ref.update(filesRef, (m) => setInPlace(m, normalized, resetScriptFile(file)));
-	});
-	const existsInMemory = (fileName) => Effect.gen(function* () {
-		const files = yield* Ref.get(filesRef);
-		return Option.getOrUndefined(MutableHashMap.get(files, normalizeFileName$1(fileName))) !== 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);
-	node.parents.forEach((parent) => collectParentReference(parent, allParentReferences));
-	return allParentReferences;
-}
-function collectParentReference(parent, allParentReferences) {
-	if (MutableHashSet.has(allParentReferences, parent)) return;
-	getAllParentReferencesIncludingSelf(parent, allParentReferences);
-}
-function addRangeOfNodesToSet(nodes, nodesToAdd) {
-	for (const node of nodesToAdd) MutableHashSet.add(nodes, node);
-}
-function findNode(fileName, nodes) {
-	const node = Option.firstSomeOf([MutableHashMap.get(nodes, normalizeFileName$1(fileName)), MutableHashMap.get(nodes, fileName)]);
-	if (Option.isNone(node)) throw new Error(`Node not in graph: ${fileName}`);
-	return node.value;
-}
-function parentsHaveOverlapWith(currentNode, groupNodes) {
-	return Array.from(getAllParentReferencesIncludingSelf(currentNode)).some((parentNode) => MutableHashSet.has(groupNodes, parentNode));
-}
-function mutantCanJoinGroup(currentNode, group) {
-	if (MutableHashSet.has(group.ignoredNodes, currentNode)) return false;
-	return !parentsHaveOverlapWith(currentNode, group.nodes);
-}
-function addMutantToGroup(currentMutant, mutantsToGroup, group, nodes) {
-	const currentNode = findNode(currentMutant.fileName, nodes);
-	if (!mutantCanJoinGroup(currentNode, group)) return;
-	group.mutantIds.push(currentMutant.id);
-	MutableHashSet.add(group.nodes, currentNode);
-	MutableHashSet.remove(mutantsToGroup, currentMutant);
-	addRangeOfNodesToSet(group.ignoredNodes, getAllParentReferencesIncludingSelf(currentNode));
-}
-function takeGroup(mutantsToGroup, nodes) {
-	const group = {
-		mutantIds: [],
-		nodes: MutableHashSet.empty(),
-		ignoredNodes: MutableHashSet.empty()
-	};
-	for (const currentMutant of mutantsToGroup) addMutantToGroup(currentMutant, mutantsToGroup, group, nodes);
-	return group.mutantIds;
-}
-function createGroups(mutants, nodes) {
-	const groups = [];
-	const mutantsToGroup = MutableHashSet.fromIterable(mutants);
-	while (MutableHashSet.size(mutantsToGroup) > 0) groups.push(takeGroup(mutantsToGroup, nodes));
-	return groups;
-}
-var TypeScriptCompiler = class extends Context.Service()("@systemfsoftware/stryker-js-typescript-checker/TypeScriptCompiler") {};
-const makeDummy = Effect.gen(function* () {
-	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)
-	};
-});
-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
-	};
-	const stateRef = Ref.makeUnsafe(initialState);
-	const snapshotOf = (state) => {
-		if (state.snapshot === void 0) return Effect.fail(new CompilerFailed({ reason: "not-initialized" }));
-		return Effect.succeed(state.snapshot);
-	};
-	const programsOf = (snapshot, tsconfigFile) => {
-		const projects = snapshot.getProjects();
-		if (projects.length === 0) return Effect.fail(new CompilerFailed({
-			reason: "no-projects",
-			subject: tsconfigFile
-		}));
-		return Effect.succeed(projects.map((project) => project.program));
-	};
-	const getProgramsEffect = () => Effect.gen(function* () {
-		const state = yield* Ref.get(stateRef);
-		const snapshot = yield* snapshotOf(state);
-		return yield* programsOf(snapshot, state.tsconfigFile);
-	});
-	const guardTSConfigFileExistsEffect = Effect.gen(function* () {
-		const s = yield* Ref.get(stateRef);
-		yield* fsService.readFileString(s.tsconfigFile).pipe(Effect.mapError(() => new TsConfigNotFoundError({ file: s.tsconfigFile })));
-	});
-	const isBlankTsConfigPath = (current) => current === void 0 || current === "";
-	const isUnprocessedTsConfigPath = (current, processed) => !isBlankTsConfigPath(current) && !MutableHashSet.has(processed, current);
-	const recordParsedTsConfig = (current, config, traversal) => {
-		MutableHashMap.set(traversal.overrides, current, overrideOptions(config, traversal.buildModeEnabled));
-		for (const referenced of retrieveReferencedProjects(config, pathService.dirname(current), pathService)) {
-			MutableHashSet.add(traversal.allTsConfigFiles, normalizeFileName$1(referenced));
-			traversal.pending.push(referenced);
-		}
-	};
-	const recordTsConfig = (current, content, parsed, traversal) => {
-		if (Result.isFailure(parsed)) {
-			MutableHashMap.set(traversal.overrides, current, content);
-			return;
-		}
-		recordParsedTsConfig(current, parsed.success, traversal);
-	};
-	const processNextTsConfig = (traversal) => Effect.gen(function* () {
-		const current = traversal.pending.pop();
-		if (!isUnprocessedTsConfigPath(current, traversal.processed)) return;
-		MutableHashSet.add(traversal.processed, current);
-		const content = yield* fsService.readFileString(current);
-		recordTsConfig(current, content, parseTsConfig(current, content), traversal);
-	});
-	const collectAllTSConfigFiles = (buildModeEnabled) => Effect.gen(function* () {
-		const state = yield* Ref.get(stateRef);
-		const traversal = {
-			overrides: MutableHashMap.empty(),
-			pending: [state.tsconfigFile],
-			processed: MutableHashSet.empty(),
-			allTsConfigFiles: state.allTSConfigFiles,
-			buildModeEnabled
-		};
-		while (traversal.pending.length > 0) yield* processNextTsConfig(traversal);
-		yield* fs.setTsConfigOverrides(traversal.overrides);
-		yield* Ref.update(stateRef, (prev) => ({
-			...prev,
-			allTSConfigFiles: MutableHashSet.fromIterable(traversal.allTsConfigFiles)
-		}));
-	});
-	const importDeclarationSpecifierOf = (statement, sourceFile) => {
-		if (statement.kind !== SyntaxKind.ImportDeclaration) return Option.none();
-		let specifier;
-		statement.forEachChild((child) => {
-			if (child.kind === SyntaxKind.StringLiteral) specifier = child;
-		});
-		return Option.map(Option.fromUndefinedOr(specifier), (found) => found.getText(sourceFile));
-	};
-	const collectImportEqualsSpecifiers = (statement, sourceFile, into) => {
-		if (statement.kind !== SyntaxKind.ImportEqualsDeclaration) return;
-		statement.forEachChild((child) => {
-			if (child.kind === SyntaxKind.ExternalModuleReference) child.forEachChild((refChild) => {
-				if (refChild.kind === SyntaxKind.StringLiteral) into.push(refChild.getText(sourceFile));
-			});
-		});
-	};
-	const extractImports = (sourceFile) => {
-		const result = [];
-		sourceFile.statements.forEach((statement) => {
-			const specifier = importDeclarationSpecifierOf(statement, sourceFile);
-			if (Option.isSome(specifier)) result.push(specifier.value);
-			collectImportEqualsSpecifiers(statement, sourceFile, result);
-		});
-		sourceFile.referencedFiles.forEach((ref) => result.push(ref.fileName));
-		sourceFile.typeReferenceDirectives.forEach((ref) => result.push(ref.fileName));
-		return result;
-	};
-	const getResolutionCandidates = (resolved, pathService) => {
-		const extension = pathService.extname(resolved);
-		if (extension) {
-			const withoutExt = resolved.slice(0, -extension.length);
-			return [
-				resolved,
-				`${withoutExt}.ts`,
-				`${withoutExt}.tsx`,
-				`${withoutExt}.d.ts`,
-				`${withoutExt}.js`,
-				`${withoutExt}.jsx`,
-				`${withoutExt}.mjs`,
-				`${withoutExt}.cjs`
-			];
-		}
-		return [
-			resolved,
-			`${resolved}.ts`,
-			`${resolved}.tsx`,
-			`${resolved}.d.ts`,
-			`${resolved}/index.ts`,
-			`${resolved}/index.tsx`,
-			`${resolved}/index.d.ts`,
-			`${resolved}.js`,
-			`${resolved}.jsx`,
-			`${resolved}.mjs`,
-			`${resolved}.cjs`,
-			`${resolved}/index.js`,
-			`${resolved}/index.jsx`,
-			`${resolved}/index.mjs`,
-			`${resolved}/index.cjs`
-		];
-	};
-	const resolveModuleSpecifier = (sourceFileName, specifier, sourceFiles, pathService) => {
-		const cleaned = specifier.replace(/^['"]|['"]$/g, "");
-		if (!relativeSpecifierPattern.test(cleaned)) return;
-		const baseDir = pathService.dirname(sourceFileName);
-		const resolved = normalizeFileName$1(pathService.resolve(baseDir, cleaned));
-		return getResolutionCandidates(resolved, pathService).find((candidate) => MutableHashMap.has(sourceFiles, candidate));
-	};
-	const readFileText = (fileName) => Option.liftPredicate(fs.fileSystem.readFile?.(fileName), isString);
-	const sourcesFieldOf = (rawMap) => {
-		if (!Predicate.hasProperty(rawMap, "sources")) return Option.none();
-		return Option.liftPredicate(rawMap.sources, Array.isArray);
-	};
-	const onlySourceOf = (sources) => {
-		const names = sources.filter(isString);
-		if (names.length !== 1) return Option.none();
-		return Option.fromUndefinedOr(names[0]);
-	};
-	const sourcePathFromMap = (declarationFileName, reference, pathService) => {
-		const sourceMapFileName = normalizeFileName$1(pathService.resolve(pathService.dirname(declarationFileName), reference));
-		return Option.flatMap(Option.flatMap(readFileText(sourceMapFileName), (content) => Option.flatMap(sourcesFieldOf(JSON.parse(content)), onlySourceOf)), (source) => Option.some(normalizeFileName$1(pathService.resolve(pathService.dirname(sourceMapFileName), source))));
-	};
-	const sourceMappedFileName = (declarationFileName, pathService) => Option.flatMap(Option.flatMap(readFileText(declarationFileName), (content) => Option.liftPredicate(getSourceMappingURL(content), isNonEmptyString)), (reference) => sourcePathFromMap(declarationFileName, reference, pathService));
-	const resolveTSInputFile = (dependencyFileName, pathService) => {
-		if (!dependencyFileName.endsWith(".d.ts")) return dependencyFileName;
-		return Option.getOrElse(sourceMappedFileName(dependencyFileName, pathService), () => dependencyFileName);
-	};
-	const registerGraphFile = (fileName, sourceFiles) => {
-		if (ignoredGraphFileNamePattern.test(fileName)) return;
-		const normalized = normalizeFileName$1(fileName);
-		MutableHashMap.set(sourceFiles, normalized, {
-			fileName: normalized,
-			imports: MutableHashSet.empty()
-		});
-	};
-	const registerSourceFiles = (programs, sourceFiles) => {
-		for (const program of programs) program.getSourceFileNames().forEach((fileName) => registerGraphFile(fileName, sourceFiles));
-	};
-	const isUsableResolution = (resolved) => resolved !== void 0 && resolved !== "";
-	const addImportEdge = (fileName, importedFileName, sourceFiles) => {
-		if (!MutableHashMap.has(sourceFiles, importedFileName)) return;
-		Option.match(MutableHashMap.get(sourceFiles, fileName), {
-			onNone: () => void 0,
-			onSome: (entry) => MutableHashSet.add(entry.imports, importedFileName)
-		});
-	};
-	const linkImport = (fileName, specifier, sourceFiles) => {
-		const resolved = resolveModuleSpecifier(fileName, specifier, sourceFiles, pathService);
-		if (!isUsableResolution(resolved)) return;
-		addImportEdge(fileName, resolveTSInputFile(resolved, pathService), sourceFiles);
-	};
-	const linkFileImports = (fileName, programs, sourceFiles) => {
-		const sourceFile = programs.map((program) => program.getSourceFile(fileName)).find((candidate) => candidate != null);
-		if (sourceFile === void 0) return;
-		extractImports(sourceFile).forEach((specifier) => linkImport(fileName, specifier, sourceFiles));
-	};
-	const buildDependencyGraph = (programs) => Effect.gen(function* () {
-		const state = yield* Ref.get(stateRef);
-		registerSourceFiles(programs, state.sourceFiles);
-		for (const [fileName] of state.sourceFiles) linkFileImports(fileName, programs, state.sourceFiles);
-		yield* Ref.update(stateRef, (prev) => ({
-			...prev,
-			sourceFiles: MutableHashMap.fromIterable(state.sourceFiles)
-		}));
-	});
-	const createEmptyNodes = (state) => {
-		for (const [fileName] of state.sourceFiles) MutableHashMap.set(state.nodes, fileName, makeTSFileNode(fileName));
-	};
-	const childNodeOf = (state, fileName, imports) => Effect.gen(function* () {
-		const node = MutableHashMap.get(state.nodes, fileName);
-		if (Option.isNone(node)) return yield* new CompilerFailed({
-			reason: "unknown-file-node",
-			subject: fileName
-		});
-		const children = Array.from(imports).map((importName) => Option.getOrUndefined(MutableHashMap.get(state.nodes, importName))).filter((child) => child !== void 0);
-		return {
-			...node.value,
-			children,
-			parents: []
-		};
-	});
-	const collectChildNodes = (state, withChildren) => Effect.gen(function* () {
-		for (const [fileName, file] of state.sourceFiles) {
-			const node = yield* childNodeOf(state, fileName, file.imports);
-			MutableHashMap.set(withChildren, fileName, node);
-		}
-	});
-	const replaceMapContents = (target, source) => {
-		MutableHashMap.clear(target);
-		for (const [key, value] of source) MutableHashMap.set(target, key, value);
-	};
-	const parentNodesOf = (node, nodes) => {
-		const parents = [];
-		MutableHashMap.forEach(nodes, (candidate) => {
-			if (candidate.children.includes(node)) parents.push(candidate);
-		});
-		return parents;
-	};
-	const linkParentReferences = (state) => {
-		const withParents = MutableHashMap.empty();
-		for (const [fileName, node] of state.nodes) MutableHashMap.set(withParents, fileName, {
-			...node,
-			parents: parentNodesOf(node, state.nodes)
-		});
-		replaceMapContents(state.nodes, withParents);
-	};
-	const buildFileNodes = (state) => Effect.gen(function* () {
-		createEmptyNodes(state);
-		const withChildren = MutableHashMap.empty();
-		yield* collectChildNodes(state, withChildren);
-		replaceMapContents(state.nodes, withChildren);
-		linkParentReferences(state);
-		yield* Ref.update(stateRef, (prev) => ({
-			...prev,
-			nodes: MutableHashMap.fromIterable(state.nodes)
-		}));
-	});
-	const getNodesEffect = Effect.gen(function* () {
-		const state = yield* Ref.get(stateRef);
-		if (MutableHashMap.size(state.nodes) > 0) return state.nodes;
-		yield* buildFileNodes(state);
-		return state.nodes;
-	});
-	const resetMutatedFiles = (mutants) => Effect.gen(function* () {
-		for (const mutant of mutants) yield* fs.resetFile(mutant.fileName);
-	});
-	const applyMutant = (mutant) => Effect.gen(function* () {
-		if ((yield* fs.getFile(mutant.fileName)) === void 0) return yield* new CompilerFailed({
-			reason: "file-not-in-project",
-			subject: mutant.fileName
-		});
-		yield* fs.mutateFile(mutant.fileName, mutant);
-	});
-	const applyMutants = (mutants) => Effect.gen(function* () {
-		for (const mutant of mutants) yield* applyMutant(mutant);
-	});
-	const hasOpenSnapshot = (state) => state.api !== void 0 && state.snapshot !== void 0;
-	const updateSnapshot = (state, changedFiles) => Effect.gen(function* () {
-		const previous = state.snapshot;
-		const next = state.api.updateSnapshot({
-			openProjects: Array.from(state.allTSConfigFiles),
-			fileChanges: { changed: changedFiles }
-		});
-		yield* Effect.sync(() => previous.dispose());
-		yield* Ref.update(stateRef, (prev) => ({
-			...prev,
-			snapshot: next
-		}));
-	});
-	const check = (mutants) => Effect.gen(function* () {
-		const state = yield* Ref.get(stateRef);
-		yield* resetMutatedFiles(state.lastMutants);
-		yield* applyMutants(mutants);
-		const mutatedFileNames = Array.from(MutableHashSet.fromIterable(mutants.map((mutant) => normalizeFileName$1(mutant.fileName))));
-		const changedFiles = Array.from(MutableHashSet.fromIterable([...state.lastMutatedFileNames, ...mutatedFileNames]));
-		const current = yield* Ref.get(stateRef);
-		if (hasOpenSnapshot(current)) yield* updateSnapshot(current, changedFiles);
-		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, pathService);
-		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* () {
-		return (yield* getProgramsEffect()).map((program) => program.getSourceFile(fileName)).find((sourceFile) => sourceFile !== void 0)?.getLineAndCharacterOfPosition(position);
-	});
-	return {
-		init,
-		check,
-		nodes: getNodesEffect,
-		close,
-		getLineAndCharacterOfPosition
-	};
-}
-//#endregion
-//#region src/mutant-groups.ts
-const groupsWithStrangers = (inside, outside, nodes) => {
-	const groups = createGroups([...inside], nodes);
-	if (outside.length > 0) return [outside.map((mutant) => mutant.id), ...groups];
-	return groups;
-};
-const knownFileGroups = (mutants, nodes) => {
-	const inside = mutants.filter((mutant) => Option.isSome(MutableHashMap.get(nodes, normalizeFileName(mutant.fileName))));
-	const outside = mutants.filter((mutant) => Option.isNone(MutableHashMap.get(nodes, normalizeFileName(mutant.fileName))));
-	if (inside.length === 0) return mutants.map((mutant) => [mutant.id]);
-	return groupsWithStrangers(inside, outside, nodes);
-};
-const groupMutants = (mutants, nodes, prioritizePerformanceOverAccuracy) => {
-	if (prioritizePerformanceOverAccuracy) return knownFileGroups(mutants, nodes);
-	return [mutants.map((mutant) => mutant.id)];
-};
-//#endregion
-//#region src/Checker.ts
-function getPrioritize(options) {
-	const decoded = Schema.decodeUnknownOption(TypescriptCheckerOptionsSchema)(options);
-	return Option.getOrElse(Option.flatMap(decoded, (value) => Option.fromUndefinedOr(value.typescriptChecker?.prioritizePerformanceOverAccuracy)), () => false);
-}
-const refuse = (mutantIds, cause) => new CheckerFailed({
-	checkerName: "typescript",
-	mutantIds: [...mutantIds],
-	cause: errorToString(cause)
-});
-const severityOf = (category) => Match.value(category).pipe(Match.when(DiagnosticCategory.Error, () => "error"), Match.when(DiagnosticCategory.Warning, () => "warning"), Match.when(DiagnosticCategory.Suggestion, () => "suggestion"), Match.orElse(() => "message"));
-const toCheckResult = (answer) => {
-	if (answer.status === "passed") return { status: "passed" };
-	return {
-		status: "compileError",
-		reason: answer.reason
-	};
-};
-const mergeAnswers = (runs) => runs.reduce((merged, answers) => Object.entries(answers).reduce((into, [id, answer]) => HashMap.set(into, id, toCheckResult(answer)), merged), HashMap.empty());
-const checkCell = Cell.layer({
-	read: (command) => Effect.flatMap(TypeScriptCompiler, (compiler) => Effect.zipWith(compiler.nodes, compiler.check([...command.mutants]), (nodes, diagnostics) => new CheckMutantsInput({
-		mutants: [...command.mutants],
-		diagnostics: [...diagnostics],
-		nodes: Object.fromEntries(nodes)
-	}))).pipe(Effect.mapError((cause) => refuse(command.mutants.map((mutant) => mutant.id), cause))),
-	decide: checkMutants,
-	write: (outcome) => Result.match(outcome, {
-		onFailure: (failure) => Effect.fail(refuse([], failure)),
-		onSuccess: Effect.succeed
-	})
-});
-const makeCheckerService = ({ options, compiler }) => {
-	const verify = Cell.provide(checkCell, Layer.succeed(TypeScriptCompiler, compiler));
-	const positionOf = (error) => Option.match(Option.filter(Option.fromUndefinedOr(error.fileName), (fileName) => fileName !== ""), {
-		onNone: () => Effect.succeed(""),
-		onSome: (fileName) => compiler.getLineAndCharacterOfPosition(fileName, error.pos).pipe(Effect.orElseSucceed(() => void 0), Effect.map((at) => Option.match(Option.fromUndefinedOr(at), {
-			onNone: () => `${fileName}(1,1): `,
-			onSome: (position) => `${fileName}(${position.line + 1},${position.character + 1}): `
-		})))
-	});
-	const formatDiagnostic = (error) => positionOf(error).pipe(Effect.map((position) => `${position}${severityOf(error.category)} TS${error.code}: ${error.text}`));
-	const createErrorText = (errors) => Effect.map(Effect.forEach(errors, formatDiagnostic), (parts) => parts.join("\n"));
-	const soloRound = (mutant) => verify.run(new CheckMutantsCommand({ mutants: [mutant] })).pipe(Effect.map((decision) => decision.results));
-	const soloRounds = (decision) => Match.value(decision).pipe(Match.tag("CheckFinished", () => Effect.succeed([])), Match.tag("RetestRequired", (retest) => verify.run(new CheckMutantsCommand({ mutants: [] })).pipe(Effect.flatMap(() => Effect.forEach(retest.needsRetest, soloRound)))), Match.exhaustive);
-	return {
-		init: compiler.init.pipe(Effect.mapError((cause) => refuse([], cause)), Effect.flatMap((errors) => {
-			if (errors.length === 0) return Effect.void;
-			return createErrorText(errors).pipe(Effect.map((text) => refuse([], /* @__PURE__ */ new Error(`Typescript error(s) found in dry run compilation: ${text}`))), Effect.flatMap(Effect.fail));
-		})),
-		check: (mutants) => verify.run(new CheckMutantsCommand({ mutants: [...mutants] })).pipe(Effect.flatMap((first) => Effect.map(soloRounds(first), (rounds) => mergeAnswers([first.results, ...rounds])))),
-		group: (mutants) => compiler.nodes.pipe(Effect.map((nodes) => groupMutants(mutants, nodes, getPrioritize(options))), Effect.mapError((cause) => refuse(mutants.map((mutant) => mutant.id), cause)))
-	};
-};
-//#endregion
 //#region src/index.ts
-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;
-	const compiler = makeTypescriptCompiler(options, yield* makeHybridFileSystem(fsService), fsService, pathService);
-	return makeCheckerService({
-		options,
-		compiler
-	});
-})))];
+const strykerPlugins = [{
+	kind: "Checker",
+	name: "typescript",
+	workerEntry: new URL("./main.mjs", import.meta.url).href
+}];
 const rawSchema = typescript_checker_options_default;
 if (!S.is(S.Record(S.String, S.Unknown))(rawSchema)) throw new Error("Invalid typescript-checker schema file");
 const strykerValidationSchema = rawSchema;