@systemfsoftware/stryker-js-typescript-checker 0.1.0 → 1.2.2

package/.turbo/turbo-build.log

@@ -1,15 +1,21 @@
 $ tsdown
-ℹ tsdown v0.22.7 powered by rolldown v1.1.5
-ℹ config file: /mnt/projects/God/systemfsoftware/packages/stryker-js/typescript-checker/package.json 
-ℹ entry: src/index.ts
-ℹ tsconfig: tsconfig.json
-ℹ Build start
-ℹ Cleaning 2 files
-
- WARN  TypeScript 7.0 does not yet have a stable API and is experimental. Some options will be unavailable.
-
-ℹ Emit types with typescript@7.0.2
-ℹ dist/index.mjs    23.95 kB │ gzip: 6.75 kB
-ℹ dist/index.d.mts   4.66 kB │ gzip: 1.52 kB
-ℹ 2 files, total: 28.61 kB
-✔ Build complete in 1441ms
+ℹ tsdown v0.22.9 powered by rolldown v1.2.0
+ℹ config file: /home/runner/work/systemfsoftware/systemfsoftware/packages/stryker-js/typescript-checker/tsdown.config.ts 
+ℹ entry: ./src/index.ts
+
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+ WARN  `noExternal` is deprecated. Use `deps.alwaysBundle` instead.
+
+
+ WARN  TypeScript 7.0 does not yet have a stable API and is experimental. Some options will be unavailable.
+
+ℹ Emit types with typescript@7.0.2
+ℹ Hint: consider adding deps.onlyBundle option to avoid unintended bundling of dependencies, or set deps.onlyBundle: false to disable this hint.
+See more at https://tsdown.dev/options/dependencies#deps-onlybundle
+Detected dependencies in bundle:
+- @jsr/std__jsonc
+ℹ dist/index.mjs    31.56 kB │ gzip: 8.67 kB
+ℹ dist/index.d.mts   4.66 kB │ gzip: 1.52 kB
+ℹ 2 files, total: 36.22 kB
+✔ Build complete in 561ms

package/AGENTS.md

@@ -0,0 +1,7 @@
+# AGENTS.md — `@systemfsoftware/stryker-js-typescript-checker`
+
+> **Location:** `packages/stryker-js/typescript-checker/` — TypeScript checker plugin for Stryker, TS7-native. Universal agent rules live in the root `AGENTS.md`; this file carries only `typescript-checker/`-specific deltas.
+
+Extends `@stryker-mutator/api` checker protocol, compiling projects directly with `typescript` against their own tsconfig (parsed via `@std/jsonc`). Built via tsdown, single entrypoint.
+
+🛑 Don't depend on `typescript` from the host project — peer dep resolved at runtime.

package/dist/index.mjs

@@ -6,8 +6,231 @@ import { split, strykerReportBugUrl } from "@stryker-mutator/util";
 import { API, DiagnosticCategory } from "typescript/unstable/sync";
 import { createRequire } from "module";
 import path from "path";
+import { Data, Either, Schema } from "effect";
 import semver from "semver";
 import { SyntaxKind } from "typescript/unstable/ast";
+//#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;
+			break;
+	}
+	return `Cannot parse JSONC: unexpected token "${token}" in JSONC at position ${position}`;
+}
+//#endregion
 //#region src/tsconfig-helpers.ts
 const COMPILER_OPTIONS_OVERRIDES = Object.freeze({
 	allowUnreachableCode: true,
@@ -37,29 +260,54 @@ function getTSVersion() {
 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}`);
 }
-function stripJsonComments(json) {
-	return json.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
-}
-function parseConfigFileTextToJson(fileName, jsonText) {
+/**
+* Error returned when a tsconfig file fails to parse or does not match the shape this package consumes.
+*/
+var TsConfigParseError = class extends Data.TaggedError("TsConfigParseError") {};
+const JsonRecord = Schema.Record({
+	key: Schema.String,
+	value: Schema.Unknown
+});
+const TsConfigSchema = Schema.Struct({
+	references: Schema.optional(Schema.Array(Schema.Struct({ path: Schema.String }, JsonRecord))),
+	compilerOptions: Schema.optional(JsonRecord)
+}, JsonRecord);
+/**
+* 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 stripped = stripJsonComments(jsonText);
-		return { config: JSON.parse(stripped) };
+		const value = parse(jsonText.replace(/^\uFEFF/, ""));
+		return Either.mapLeft(Schema.decodeUnknownEither(TsConfigSchema)(value), (issue) => new TsConfigParseError({
+			file: fileName,
+			reason: issue.message
+		}));
 	} catch (error) {
-		return { error };
+		return Either.left(new TsConfigParseError({
+			file: fileName,
+			reason: error instanceof Error ? error.message : String(error)
+		}));
 	}
 }
+/**
+* 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 = parseConfigFileTextToJson(tsconfigFileName, readFileSync(tsconfigFileName, "utf-8"));
-	if (parsed.error) return false;
-	return "references" in parsed.config;
+	const parsed = parseTsConfig(tsconfigFileName, readFileSync(tsconfigFileName, "utf-8"));
+	return Either.match(parsed, {
+		onLeft: () => false,
+		onRight: (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 parsedConfig The parsed config file
+* @param config The parsed config file
 * @param useBuildMode whether or not `--build` mode is used
 */
-function overrideOptions(parsedConfig, useBuildMode) {
-	const config = parsedConfig.config ?? {};
+function overrideOptions(config, useBuildMode) {
 	const compilerOptions = {
 		...config.compilerOptions,
 		...COMPILER_OPTIONS_OVERRIDES,
@@ -82,17 +330,15 @@ function overrideOptions(parsedConfig, useBuildMode) {
 }
 /**
 * Retrieves the referenced config files based on parsed configuration
-* @param parsedConfig The parsed config file
+* @param config The parsed config file
 * @param fromDirName The directory where to resolve from
 */
-function retrieveReferencedProjects(parsedConfig, fromDirName) {
-	const config = parsedConfig.config;
-	if (Array.isArray(config?.references)) return config.references.map((reference) => {
+function retrieveReferencedProjects(config, fromDirName) {
+	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);
 	});
-	return [];
 }
 /**
 * Replaces backslashes with forward slashes (used by typescript)
@@ -393,13 +639,14 @@ var TypescriptCompiler = class {
 			if (!current || processed.has(current)) continue;
 			processed.add(current);
 			const content = readFileSync(current, "utf-8");
-			const parsed = parseConfigFileTextToJson(current, content);
-			if (parsed.error) {
+			const parsed = parseTsConfig(current, content);
+			if (Either.isLeft(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.left.reason);
 				tsConfigOverrides.set(current, content);
 				continue;
 			}
-			tsConfigOverrides.set(current, overrideOptions(parsed, buildModeEnabled));
-			for (const referenced of retrieveReferencedProjects(parsed, path.dirname(current))) {
+			tsConfigOverrides.set(current, overrideOptions(parsed.right, buildModeEnabled));
+			for (const referenced of retrieveReferencedProjects(parsed.right, path.dirname(current))) {
 				this.allTSConfigFiles.add(referenced);
 				toProcess.push(referenced);
 			}

package/package.json

@@ -1,32 +1,41 @@
 {
   "name": "@systemfsoftware/stryker-js-typescript-checker",
-  "version": "0.1.0",
+  "version": "1.2.2",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
+    "directory": "packages/stryker-js/typescript-checker"
+  },
+  "homepage": "https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/stryker-js/typescript-checker#readme",
+  "bugs": "https://github.com/systemfsoftware/systemfsoftware/issues",
   "description": "TypeScript checker plugin for Stryker — TS7 native",
   "type": "module",
   "exports": {
-    ".": {
-      "@systemfsoftware/source": "./src/index.ts",
-      "default": "./dist/index.mjs"
-    },
+    ".": "./dist/index.mjs",
     "./package.json": "./package.json"
   },
   "license": "Apache-2.0",
   "dependencies": {
     "@stryker-mutator/api": "^9.6.1",
     "@stryker-mutator/util": "^9.6.1",
+    "effect": "^3.22.0",
     "semver": "^7.7.0",
     "tslib": "~2.8.0",
     "typescript": "^7"
   },
   "devDependencies": {
+    "@std/jsonc": "npm:@jsr/std__jsonc@^1.0.2",
     "@types/node": "^24",
     "@types/semver": "^7.5.8",
     "rimraf": "^6.1.3",
-    "tsdown": "^0.22.7",
+    "tsdown": "^0.22.9",
     "vitest": "^4",
-    "@systemfsoftware/tsconfig": "^1.0.0",
+    "@systemfsoftware/tsconfig": "^1.3.0",
     "@systemfsoftware/vitest-config": "^0.1.0"
   },
+  "inlinedDependencies": {
+    "@jsr/std__jsonc": "1.0.2"
+  },
   "scripts": {
     "clean": "rimraf dist",
     "build": "tsdown",

package/src/tsconfig-helpers.ts

@@ -2,6 +2,8 @@ import { readFileSync } from 'fs'
 import { createRequire } from 'module'
 import path from 'path'
 
+import { parse } from '@std/jsonc'
+import { Data, Either, Schema as S } from 'effect'
 import semver from 'semver'
 
 // Override some compiler options that have to do with code quality. When mutating, we're not interested in the resulting code quality
@@ -50,46 +52,71 @@ export function guardTSVersion(version = getTSVersion()): void {
 }
 
 /**
- * Determines whether or not to use `--build` mode based on "references" being there in the config file
- * @param tsconfigFileName The tsconfig file to parse
+ * Error returned when a tsconfig file fails to parse or does not match the shape this package consumes.
  */
-export interface ParsedConfig {
-  config?: unknown
-  error?: Error
-}
-
-function stripJsonComments(json: string): string {
-  return json
-    .replace(/\/\*[\s\S]*?\*\//g, '')
-    .replace(/\/\/.*$/gm, '')
-}
+export class TsConfigParseError extends Data.TaggedError('TsConfigParseError')<{
+  readonly file: string
+  readonly reason: string
+}> {}
+
+const JsonRecord = S.Record({ key: S.String, value: S.Unknown })
+const TsConfigSchema = S.Struct(
+  {
+    references: S.optional(S.Array(S.Struct({ path: S.String }, JsonRecord))),
+    compilerOptions: S.optional(JsonRecord),
+  },
+  JsonRecord,
+)
+type TsConfig = S.Schema.Type<typeof TsConfigSchema>
 
-export function parseConfigFileTextToJson(fileName: string, jsonText: string): ParsedConfig {
+/**
+ * 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
+ */
+export function parseTsConfig(fileName: string, jsonText: string): Either.Either<TsConfig, TsConfigParseError> {
+  // `@std/jsonc`'s whitespace set excludes U+FEFF, so it rejects a leading BOM, while `tsc` tolerates one.
   try {
-    const stripped = stripJsonComments(jsonText)
-    return { config: JSON.parse(stripped) }
+    const value = parse(jsonText.replace(/^\uFEFF/, ''))
+    // Rebuilds the object, reordering keys (declared fields hoist). Safe here: this
+    // package only reads the config, and `overrideOptions` builds a fresh object anyway.
+    // The core sibling (`packages/stryker-js/core/src/sandbox/parse-config-helper.ts`)
+    // deliberately uses an `S.is` guard instead — it mutates the parsed config and writes
+    // it back with `JSON.stringify`, so a rebuild there would reorder the user's tsconfig
+    // on disk. Independent boundaries by KTD-2; this note keeps the divergence deliberate.
+    return Either.mapLeft(
+      S.decodeUnknownEither(TsConfigSchema)(value),
+      (issue) => new TsConfigParseError({ file: fileName, reason: issue.message }),
+    )
   } catch (error) {
-    return { error: error as Error }
+    return Either.left(
+      new TsConfigParseError({
+        file: fileName,
+        reason: error instanceof Error ? error.message : String(error),
+      }),
+    )
   }
 }
 
+/**
+ * Determines whether or not to use `--build` mode based on "references" being there in the config file
+ * @param tsconfigFileName The tsconfig file to parse
+ */
 export function determineBuildModeEnabled(tsconfigFileName: string): boolean {
   const tsconfigFile = readFileSync(tsconfigFileName, 'utf-8')
-  const parsed = parseConfigFileTextToJson(tsconfigFileName, tsconfigFile)
-  if (parsed.error) {
-    return false
-  }
-  const useProjectReferences = 'references' in (parsed.config as { references?: unknown[] })
-  return useProjectReferences
+  const parsed = parseTsConfig(tsconfigFileName, tsconfigFile)
+  return Either.match(parsed, {
+    onLeft: () => false,
+    onRight: (config) => config.references !== undefined,
+  })
 }
 
 /**
  * Overrides some options to speed up compilation and disable some code quality checks we don't want during mutation testing
- * @param parsedConfig The parsed config file
+ * @param config The parsed config file
  * @param useBuildMode whether or not `--build` mode is used
  */
-export function overrideOptions(parsedConfig: ParsedConfig, useBuildMode: boolean): string {
-  const config = (parsedConfig.config ?? {}) as { compilerOptions?: Record<string, unknown> }
+export function overrideOptions(config: TsConfig, useBuildMode: boolean): string {
   const compilerOptions: Record<string, unknown> = {
     ...config.compilerOptions,
     ...COMPILER_OPTIONS_OVERRIDES,
@@ -124,27 +151,19 @@ export function overrideOptions(parsedConfig: ParsedConfig, useBuildMode: boolea
   })
 }
 
-interface ProjectReference {
-  path: string
-}
-
 /**
  * Retrieves the referenced config files based on parsed configuration
- * @param parsedConfig The parsed config file
+ * @param config The parsed config file
  * @param fromDirName The directory where to resolve from
  */
-export function retrieveReferencedProjects(parsedConfig: ParsedConfig, fromDirName: string): string[] {
-  const config = parsedConfig.config as { references?: ProjectReference[] } | undefined
-  if (Array.isArray(config?.references)) {
-    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)
-    })
-  }
-  return []
+export function retrieveReferencedProjects(config: TsConfig, fromDirName: string): string[] {
+  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)
+  })
 }
 
 /**

package/src/typescript-compiler.ts

@@ -4,6 +4,7 @@ import path from 'path'
 import type { Mutant, StrykerOptions } from '@stryker-mutator/api/core'
 import type { Logger } from '@stryker-mutator/api/logging'
 import { commonTokens, tokens } from '@stryker-mutator/api/plugin'
+import { Either } from 'effect'
 import { type SourceFile, SyntaxKind } from 'typescript/unstable/ast'
 import type { FileSystem } from 'typescript/unstable/fs'
 import { API, type Diagnostic, type DocumentIdentifier, type Program, type Snapshot } from 'typescript/unstable/sync'
@@ -16,7 +17,7 @@ import {
   getSourceMappingURL,
   guardTSVersion,
   overrideOptions,
-  parseConfigFileTextToJson,
+  parseTsConfig,
   retrieveReferencedProjects,
   toPosixFileName,
 } from './tsconfig-helpers.js'
@@ -205,16 +206,21 @@ export class TypescriptCompiler implements ITypescriptCompiler, IFileRelationCre
       processed.add(current)
 
       const content = readFileSync(current, 'utf-8')
-      const parsed = parseConfigFileTextToJson(current, content)
-      if (parsed.error) {
+      const parsed = parseTsConfig(current, content)
+      if (Either.isLeft(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.left.reason,
+        )
         tsConfigOverrides.set(current, content)
         continue
       }
-      tsConfigOverrides.set(current, overrideOptions(parsed, buildModeEnabled))
+      tsConfigOverrides.set(current, overrideOptions(parsed.right, buildModeEnabled))
 
       for (
         const referenced of retrieveReferencedProjects(
-          parsed,
+          parsed.right,
           path.dirname(current),
         )
       ) {

package/test/integration/single-project.it.spec.ts

@@ -6,9 +6,11 @@ import { CheckStatus } from '@stryker-mutator/api/check'
 import type { FailedCheckResult } from '@stryker-mutator/api/check'
 import type { Location, Mutant, StrykerOptions } from '@stryker-mutator/api/core'
 import type { Logger } from '@stryker-mutator/api/logging'
+import { Either } from 'effect'
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 
 import { HybridFileSystem } from '../../src/fs/hybrid-file-system.js'
+import { overrideOptions, parseTsConfig } from '../../src/tsconfig-helpers.js'
 import { TypescriptChecker } from '../../src/typescript-checker.js'
 import { TypescriptCompiler } from '../../src/typescript-compiler.js'
 
@@ -204,6 +206,39 @@ describe('Typescript checker on a single project', () => {
       'errorInFileAbove2Mutants/todo-counter.ts(7,7): error TS2322',
     )
   })
+
+  it('should compile the fixture source files discovered via the ** include glob', async () => {
+    // The fixture tsconfig selects its inputs via `include: ["src/**/*.ts"]`. If a comment
+    // stripper corrupted the glob (the `/**/` inside it looks like an empty block comment),
+    // TypeScript would find no input files and abort init with TS18003, so this assertion
+    // pins the end-to-end regression against the real checker path.
+    const mutant = createMutant(
+      'errorInFileAbove2Mutants/todo.ts',
+      'TodoList.allTodos.push(newItem)',
+      '"This should not be a string 🙄"',
+      'glob-pin',
+    )
+    const actual = await sut.check([mutant])
+    expect(actual['glob-pin']?.status).toBe(CheckStatus.CompileError)
+    expect((actual['glob-pin'] as FailedCheckResult).reason).toContain(
+      'todo.ts(15,9): error TS2322',
+    )
+  })
+
+  it('should preserve the fixture $schema URL and ** glob in the config produced by overrideOptions', () => {
+    // `$schema` holds a `//`-bearing string and `include` holds a `**` glob: the two shapes a
+    // naive comment stripper mangles. The compiler feeds the output of `overrideOptions` to
+    // TypeScript, so this asserts both survive byte-for-byte into that config.
+    const tsconfigFile = resolveTestResource('tsconfig.json')
+    const content = fs.readFileSync(tsconfigFile, 'utf8')
+    const parsed = parseTsConfig(tsconfigFile, content)
+    if (Either.isLeft(parsed)) {
+      throw new Error(`Expected fixture tsconfig to parse, got: ${parsed.left.reason}`)
+    }
+    const config = overrideOptions(parsed.right, false)
+    expect(config).toContain('"$schema":"https://json.schemastore.org/tsconfig"')
+    expect(config).toContain('"include":["src/**/*.ts"]')
+  })
 })
 
 const fileContents: Record<string, string> = Object.freeze({

package/test/integration/tsconfig-helpers.it.spec.ts

@@ -0,0 +1,199 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'fs'
+import { tmpdir } from 'os'
+import path from 'path'
+
+import { Either } from 'effect'
+import { afterEach, describe, expect, it } from 'vitest'
+
+import {
+  determineBuildModeEnabled,
+  overrideOptions,
+  parseTsConfig,
+  TsConfigParseError,
+} from '../../src/tsconfig-helpers.js'
+
+function expectRight<A, E>(either: Either.Either<A, E>): A {
+  if (Either.isLeft(either)) {
+    throw new Error(`Expected a Right result, got a Left: ${String(either.left)}`)
+  }
+  return either.right
+}
+
+describe('parseTsConfig', () => {
+  it('should preserve a glob pattern in include exactly', () => {
+    const config = expectRight(
+      parseTsConfig('tsconfig.json', '{"include":["src/**/*.workflow.ts"]}'),
+    )
+    expect(config).toEqual({ include: ['src/**/*.workflow.ts'] })
+  })
+
+  it('should round-trip a $schema URL unchanged', () => {
+    const config = expectRight(
+      parseTsConfig('tsconfig.json', '{"$schema":"https://json.schemastore.org/tsconfig"}'),
+    )
+    expect(config).toEqual({
+      $schema: 'https://json.schemastore.org/tsconfig',
+    })
+  })
+
+  it('should round-trip a Windows path and an escaped quote unchanged', () => {
+    const config = expectRight(
+      parseTsConfig(
+        'tsconfig.json',
+        '{"paths":{"a":["C:\\\\x//y"]},"description":"he said \\"hi\\""}',
+      ),
+    )
+    expect(config).toEqual({
+      paths: { a: ['C:\\x//y'] },
+      description: 'he said "hi"',
+    })
+  })
+
+  it('should accept trailing commas in nested objects and arrays', () => {
+    const config = expectRight(
+      parseTsConfig(
+        'tsconfig.json',
+        '{"compilerOptions":{"strict":true,},"include":["a.ts","b.ts",]}',
+      ),
+    )
+    expect(config).toEqual({
+      compilerOptions: { strict: true },
+      include: ['a.ts', 'b.ts'],
+    })
+  })
+
+  it('should accept content prefixed with a BOM', () => {
+    const withoutBom = expectRight(
+      parseTsConfig('tsconfig.json', '{"compilerOptions":{"strict":true}}'),
+    )
+    const withBom = expectRight(
+      parseTsConfig('tsconfig.json', '\uFEFF{"compilerOptions":{"strict":true}}'),
+    )
+    expect(withBom).toEqual(withoutBom)
+  })
+
+  it('should strip line and block comments', () => {
+    const config = expectRight(
+      parseTsConfig(
+        'tsconfig.json',
+        '{\n// a line comment\n"a": 1,\n/* a block comment */\n"b": 2\n}',
+      ),
+    )
+    expect(config).toEqual({ a: 1, b: 2 })
+  })
+
+  it('should preserve unknown nested keys inside compilerOptions', () => {
+    const config = expectRight(
+      parseTsConfig(
+        'tsconfig.json',
+        '{"compilerOptions":{"strict":true,"experimentalDecorators":true}}',
+      ),
+    )
+    expect(config.compilerOptions).toEqual({
+      strict: true,
+      experimentalDecorators: true,
+    })
+  })
+
+  it('should return a Left for a malformed document', () => {
+    const result = parseTsConfig('tsconfig.json', '{ "a": }')
+    expect(Either.isLeft(result)).toBe(true)
+    if (Either.isLeft(result)) {
+      expect(result.left).toBeInstanceOf(TsConfigParseError)
+      expect(result.left.file).toBe('tsconfig.json')
+      expect(result.left.reason.length).toBeGreaterThan(0)
+    }
+  })
+
+  it('should return a Left for truncated input', () => {
+    for (const truncated of ['{', '{"a":']) {
+      expect(Either.isLeft(parseTsConfig('tsconfig.json', truncated))).toBe(true)
+    }
+  })
+
+  it('should return a Left for an unterminated block comment', () => {
+    const result = parseTsConfig('tsconfig.json', '{"a":1,/* never closed')
+    expect(Either.isLeft(result)).toBe(true)
+  })
+
+  it('should return a Left for a bare string root (not a config object)', () => {
+    const result = parseTsConfig('tsconfig.json', '"just a string"')
+    expect(Either.isLeft(result)).toBe(true)
+    if (Either.isLeft(result)) {
+      expect(result.left).toBeInstanceOf(TsConfigParseError)
+      expect(result.left.file).toBe('tsconfig.json')
+      expect(result.left.reason.length).toBeGreaterThan(0)
+    }
+  })
+
+  it('should return a Left when references is not an array', () => {
+    const result = parseTsConfig('tsconfig.json', '{"references":"nope"}')
+    expect(Either.isLeft(result)).toBe(true)
+    if (Either.isLeft(result)) {
+      expect(result.left).toBeInstanceOf(TsConfigParseError)
+      expect(result.left.reason.length).toBeGreaterThan(0)
+    }
+  })
+})
+
+describe('overrideOptions', () => {
+  it('should apply the compiler-option overrides to an empty config', () => {
+    const parsed = JSON.parse(overrideOptions({}, false))
+    expect(parsed.compilerOptions).toMatchObject({
+      allowUnreachableCode: true,
+      noEmit: true,
+      target: 'es2022',
+      moduleResolution: 'bundler',
+    })
+  })
+
+  it('should preserve unknown top-level keys and unknown compilerOptions through to the output', () => {
+    const config = expectRight(
+      parseTsConfig(
+        'tsconfig.json',
+        '{"include":["src/**/*.ts"],"compilerOptions":{"strict":true,"experimentalDecorators":true}}',
+      ),
+    )
+    const output = JSON.parse(overrideOptions(config, false))
+    expect(output.include).toEqual(['src/**/*.ts'])
+    expect(output.compilerOptions.strict).toBe(true)
+    expect(output.compilerOptions.experimentalDecorators).toBe(true)
+  })
+})
+
+describe('determineBuildModeEnabled', () => {
+  let tempDir: string | undefined
+
+  afterEach(() => {
+    if (tempDir !== undefined) {
+      rmSync(tempDir, { recursive: true, force: true })
+    }
+  })
+
+  function createTsconfig(content: string): string {
+    tempDir = mkdtempSync(path.join(tmpdir(), 'tsconfig-helpers-'))
+    const tsconfigPath = path.join(tempDir, 'tsconfig.json')
+    writeFileSync(tsconfigPath, content)
+    return tsconfigPath
+  }
+
+  it('should return true when the config has references', () => {
+    const tsconfigPath = createTsconfig('{"references":[{"path":"./a"}]}')
+    expect(determineBuildModeEnabled(tsconfigPath)).toBe(true)
+  })
+
+  it('should return false when the config has no references', () => {
+    const tsconfigPath = createTsconfig('{"compilerOptions":{"strict":true}}')
+    expect(determineBuildModeEnabled(tsconfigPath)).toBe(false)
+  })
+
+  it('should return false when the config is a bare string instead of throwing a TypeError', () => {
+    const tsconfigPath = createTsconfig('"just a string"')
+    expect(determineBuildModeEnabled(tsconfigPath)).toBe(false)
+  })
+
+  it('should return false when references is not an array', () => {
+    const tsconfigPath = createTsconfig('{"references":"nope"}')
+    expect(determineBuildModeEnabled(tsconfigPath)).toBe(false)
+  })
+})

package/test/integration/typescript-checkers-errors.it.spec.ts

@@ -3,7 +3,7 @@ import { fileURLToPath } from 'url'
 
 import type { StrykerOptions } from '@stryker-mutator/api/core'
 import type { Logger } from '@stryker-mutator/api/logging'
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 
 import { HybridFileSystem } from '../../src/fs/hybrid-file-system.js'
 import { TypescriptChecker } from '../../src/typescript-checker.js'
@@ -18,7 +18,7 @@ const resolveTestResource = path.resolve.bind(
   'errors',
 ) as unknown as typeof path.resolve
 
-function createLogger(): Logger {
+function createLogger(warn: Logger['warn'] = () => {}): Logger {
   return {
     isTraceEnabled: () => false,
     isDebugEnabled: () => false,
@@ -29,18 +29,20 @@ function createLogger(): Logger {
     trace: () => {},
     debug: () => {},
     info: () => {},
-    warn: () => {},
+    warn,
     error: () => {},
     fatal: () => {},
   }
 }
 
-function createChecker(tsconfigFile: string): TypescriptChecker {
+function createChecker(
+  tsconfigFile: string,
+  logger: Logger = createLogger(),
+): TypescriptChecker {
   const options = {
     tsconfigFile,
     typescriptChecker: { prioritizePerformanceOverAccuracy: true },
   } as unknown as StrykerOptions
-  const logger = createLogger()
   const fileSystem = new HybridFileSystem()
   const compiler = new TypescriptCompiler(logger, options, fileSystem)
   return new TypescriptChecker(logger, options, compiler)
@@ -57,7 +59,7 @@ describe('Typescript checker errors', () => {
     await expect(sut.init()).rejects.toThrow(
       'testResources/errors/compile-error/add.ts(2,3): error TS2322:',
     )
-  })
+  }, 30_000)
 
   it('should reject initialization if tsconfig was invalid', async () => {
     const sut = createChecker(
@@ -71,6 +73,29 @@ describe('Typescript checker errors', () => {
     )
   })
 
+  it('should log a warning naming the tsconfig path and the skipped-overrides consequence when parsing falls back', async () => {
+    const warn = vi.fn()
+    const sut = createChecker(
+      resolveTestResource('invalid-tsconfig', 'tsconfig.json'),
+      createLogger(warn),
+    )
+
+    await expect(sut.init()).rejects.toThrow(
+      'testResources/errors/invalid-tsconfig/tsconfig.json(1,1): error TS1005:',
+    )
+
+    expect(warn).toHaveBeenCalled()
+    const warnings = warn.mock.calls
+      .map((call) => call.join(' '))
+      .join('\n')
+    expect(warnings).toContain(
+      'testResources/errors/invalid-tsconfig/tsconfig.json',
+    )
+    expect(warnings.toLowerCase()).toContain(
+      'compiler-option overrides and project-reference walking were skipped',
+    )
+  })
+
   it("should reject when tsconfig file doesn't exist", async () => {
     const sut = createChecker(
       resolveTestResource('empty-dir', 'tsconfig.json'),

package/testResources/single-project/tsconfig.json

@@ -1,4 +1,5 @@
 {
+  "$schema": "https://json.schemastore.org/tsconfig",
   "compilerOptions": {
     "strict": true,
     "target": "es5",
@@ -11,5 +12,6 @@
     "noUnusedParameters": true,
 
     "types": []
-  }
+  },
+  "include": ["src/**/*.ts"]
 }

package/tsconfig.json

@@ -3,8 +3,24 @@
   "compilerOptions": {
     "outDir": "dist",
     "rootDir": ".",
-    "types": ["node"]
+    "types": [
+      "node"
+    ],
+    // Fork of @stryker-mutator/typescript-checker: the leaf AGENTS.md mandates a minimal upstream
+    // diff, so the constitution policy in @systemfsoftware/tsconfig/effect is deliberately NOT
+    // extended here. The Effect Language Service runs at its own defaults — correctness tier only.
+    "plugins": [
+      {
+        "name": "@effect/language-service"
+      }
+    ]
   },
-  "include": ["src", "test"],
-  "exclude": ["node_modules", "dist"]
+  "include": [
+    "src",
+    "test"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
 }

package/tsdown.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from 'tsdown'
+
+export default defineConfig({
+  entry: {
+    index: './src/index.ts',
+  },
+  format: 'esm',
+  dts: true,
+  exports: { devExports: '@systemfsoftware/source' },
+  // `jsr:` specs publish as `npm:@jsr/std__jsonc@…`, which exists only on npm.jsr.io, so a
+  // default-registry consumer cannot install it. Inlining the parser (a leaf, no runtime
+  // imports) keeps the published artifact free of any `@jsr` dep. Dropping this line
+  // reintroduces an uninstallable release — verified by packing and installing the tarball.
+  noExternal: ['@std/jsonc'],
+  clean: false,
+})

package/vitest.config.ts

@@ -7,5 +7,7 @@ export default defineConfig({
       '**/.stryker-tmp/**',
       '**/testResources/**',
     ],
+    testTimeout: 30000,
+    hookTimeout: 30000,
   },
 })

package/.turbo/turbo-lint.log

@@ -1,3 +0,0 @@
-$ oxlint . --format=github
-Found 0 warnings and 0 errors.
-Finished in 103ms on 21 files with 94 rules using 12 threads.

package/testResources/project-references/src/src.tsbuildinfo

@@ -1 +0,0 @@
-{"program":{"fileNames":["../../../../../node_modules/typescript/lib/lib.d.ts","../../../../../node_modules/typescript/lib/lib.es5.d.ts","../../../../../node_modules/typescript/lib/lib.dom.d.ts","../../../../../node_modules/typescript/lib/lib.webworker.importscripts.d.ts","../../../../../node_modules/typescript/lib/lib.scripthost.d.ts","../dist/utils/math.d.ts","./index.ts","../dist/utils/text.d.ts","./job.ts"],"fileInfos":["2dc8c927c9c162a773c6bb3cdc4f3286c23f10eedc67414028f9cb5951610f60",{"version":"f20c05dbfe50a208301d2a1da37b9931bce0466eb5a1f4fe240971b4ecc82b67","affectsGlobalScope":true},{"version":"9b087de7268e4efc5f215347a62656663933d63c0b1d7b624913240367b999ea","affectsGlobalScope":true},{"version":"7fac8cb5fc820bc2a59ae11ef1c5b38d3832c6d0dfaec5acdb5569137d09a481","affectsGlobalScope":true},{"version":"097a57355ded99c68e6df1b738990448e0bf170e606707df5a7c0481ff2427cd","affectsGlobalScope":true},"80dbf481ae698a44d6d4b60f3c36d84a94b2a5eb14927eae5347b82f33ec0277",{"version":"c9b6bdd48b8bdb8d8e7690c7cc18897a494b6ab17dc58083dacfaf14b846ab4f","signature":"40b6409b8d0dced1f6c3964012b7a7c1cd50e24c3242095d1c8cfc6cabe8bd31"},"cdf6a65d46d64de68df5d8a322621f74327b1ee02c3fde41f736e11d307fcfb1",{"version":"e4c28c497fe6cc6364b113c181c32ba58e70f02d824295e72b15d9570b403104","signature":"9be66c79f48b4876970daed5167e069d7f12f1a1ca616ecaa0ca8280946344ca"}],"options":{"composite":true,"declaration":true,"declarationMap":true,"module":1,"noUnusedLocals":true,"noUnusedParameters":true,"outDir":"../dist/src","strict":true,"target":1,"tsBuildInfoFile":"./src.tsbuildinfo"},"fileIdsList":[[6],[8]],"referencedMap":[[7,1],[9,2]],"exportedModulesMap":[],"semanticDiagnosticsPerFile":[1,3,2,5,4,6,8,7,9],"latestChangedDtsFile":"../dist/src/job.d.ts"},"version":"4.8.4"}

package/testResources/project-references/utils/utils.tsbuildinfo

@@ -1 +0,0 @@
-{"program":{"fileNames":["../../../../../node_modules/typescript/lib/lib.d.ts","../../../../../node_modules/typescript/lib/lib.es5.d.ts","../../../../../node_modules/typescript/lib/lib.dom.d.ts","../../../../../node_modules/typescript/lib/lib.webworker.importscripts.d.ts","../../../../../node_modules/typescript/lib/lib.scripthost.d.ts","./math.ts","./text.ts"],"fileInfos":["2dc8c927c9c162a773c6bb3cdc4f3286c23f10eedc67414028f9cb5951610f60",{"version":"f20c05dbfe50a208301d2a1da37b9931bce0466eb5a1f4fe240971b4ecc82b67","affectsGlobalScope":true},{"version":"9b087de7268e4efc5f215347a62656663933d63c0b1d7b624913240367b999ea","affectsGlobalScope":true},{"version":"7fac8cb5fc820bc2a59ae11ef1c5b38d3832c6d0dfaec5acdb5569137d09a481","affectsGlobalScope":true},{"version":"097a57355ded99c68e6df1b738990448e0bf170e606707df5a7c0481ff2427cd","affectsGlobalScope":true},{"version":"6198e7d4a43aabb174a72ec9f0e8d2962912ad59ad90010aac3930868a8f62a4","signature":"0400cb85cef49e897c47df13e38b5cd199e0c900253f2d2ddf2e3491c27bc0a8"},{"version":"becd081df112726ab94c1ca1c05d6a59268fe0dabf7ad076d16ea851bf99e8fb","signature":"6039d94241358544e8d62a3a0ba90752a9973b3b2b422c187e2bcf7256fcda2e"}],"options":{"composite":true,"declaration":true,"declarationMap":true,"module":1,"noUnusedLocals":true,"noUnusedParameters":true,"outDir":"../dist/utils","strict":true,"target":1,"tsBuildInfoFile":"./utils.tsbuildinfo"},"referencedMap":[],"exportedModulesMap":[],"semanticDiagnosticsPerFile":[1,3,2,5,4,6,7],"latestChangedDtsFile":"../dist/utils/text.d.ts"},"version":"4.8.4"}

package/testResources/project-with-ts-buildinfo/do-not-delete.tsbuildinfo

@@ -1 +0,0 @@
-{"program":{"fileNames":["../../../../node_modules/typescript/lib/lib.d.ts","../../../../node_modules/typescript/lib/lib.es5.d.ts","../../../../node_modules/typescript/lib/lib.dom.d.ts","../../../../node_modules/typescript/lib/lib.webworker.importscripts.d.ts","../../../../node_modules/typescript/lib/lib.scripthost.d.ts","./src/index.ts"],"fileInfos":["2dc8c927c9c162a773c6bb3cdc4f3286c23f10eedc67414028f9cb5951610f60",{"version":"f20c05dbfe50a208301d2a1da37b9931bce0466eb5a1f4fe240971b4ecc82b67","affectsGlobalScope":true},{"version":"9b087de7268e4efc5f215347a62656663933d63c0b1d7b624913240367b999ea","affectsGlobalScope":true},{"version":"7fac8cb5fc820bc2a59ae11ef1c5b38d3832c6d0dfaec5acdb5569137d09a481","affectsGlobalScope":true},{"version":"097a57355ded99c68e6df1b738990448e0bf170e606707df5a7c0481ff2427cd","affectsGlobalScope":true},"39441a0f0f37ba8f1a5ef3bf717953d53469cfd7a8450a8a2221959a67905497"],"options":{"module":1,"noUnusedLocals":true,"noUnusedParameters":true,"outDir":"./dist","strict":true,"target":1,"tsBuildInfoFile":"./do-not-delete.tsbuildinfo"},"referencedMap":[],"exportedModulesMap":[],"semanticDiagnosticsPerFile":[1,3,2,5,4,6]},"version":"4.8.4"}