@systemfsoftware/stryker-js-typescript-checker 7.0.1 → 7.0.3

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @systemfsoftware/stryker-js-typescript-checker
 
+## 7.0.3
+
+### Patch Changes
+
+- A checker that fails now fails mutation testing with that checker's cause, instead of crashing with an empty error. The TypeScript checker type-checks each mutant, so compile errors appear in the report. Verdict counts are non-negative integers; `Metrics` is a class you can build from mutant statuses; a threshold `low` may not exceed `high`.
+
+## 7.0.2
+
+### Patch Changes
+
+- The checker request carries a plain data record, not the instrumenter's `Mutant` class. `CheckerRequest.mutants` and `CheckerService.check`/`group` now speak `CheckerMutantWire` - `id`, `fileName`, `mutatorName`, `replacement`, and `location`. A mutant that cannot be described to a checker is skipped instead of reaching it.
+
+  With `OTEL_ENABLED=true` the CLI now exports its OpenTelemetry metrics to `OTEL_EXPORTER_OTLP_ENDPOINT`, and `OTEL_METRIC_EXPORT_INTERVAL` sets the export interval in milliseconds. Checker timings, mutant counts, and worker crashes now reach a metrics backend.
+
+  `ConfigEnv` and `resolveExtends` are no longer exported. Import `ConfigEnv` from the config entry point of the package, and read merged options with `loadConfigCell` or `readConfig` from the package root - either performs the `extends` walk, validation and merge in order.
+
+- Updated dependencies:
+  - @systemfsoftware/stryker-js-plugin-interface@7.0.0
+
 ## 7.0.1
 
 ### Patch Changes

package/dist/main.mjs

@@ -1,5 +1,5 @@
 import { createRequire } from "node:module";
-import { LocationSchema, Mutant, MutantRunOptionsSchema, MutantStatusSchema, OpenEndLocationSchema, PositionSchema, RunOptionsFields, errorToString, normalizeFileName } from "@systemfsoftware/stryker-js-instrumenter";
+import { LocationSchema, MutantRunOptionsSchema, MutantStatusSchema, OpenEndLocationSchema, PositionSchema, RunOptionsFields, errorToString, normalizeFileName } from "@systemfsoftware/stryker-js-instrumenter";
 import { createRequire as createRequire$1 } from "module";
 import * as Net from "node:net";
 import * as Crypto from "node:crypto";
@@ -8064,6 +8064,15 @@ const withSpan$1 = function() {
 	return (self, ...args) => useSpan$1(name, fnArg ? fnArg(...args) : options, (span) => withParentSpan(self, span, traceOptions));
 };
 /** @internal */
+const annotateCurrentSpan$1 = (...args) => withFiber$1((fiber) => {
+	const span = fiber.currentSpanLocal;
+	if (span) {
+		if (args.length === 1) for (const [key, value] of Object.entries(args[0])) span.attribute(key, value);
+		else span.attribute(args[0], args[1]);
+	}
+	return void_$3;
+});
+/** @internal */
 const ClockRef = /*#__PURE__*/ Reference("effect/Clock", { defaultValue: () => new ClockImpl() });
 const MAX_TIMER_MILLIS = 2 ** 31 - 1;
 var ClockImpl = class {
@@ -13448,6 +13457,30 @@ const interruptible = interruptible$1;
 */
 const forever = forever$1;
 /**
+* Adds an annotation to the current span if available.
+*
+* **Example** (Annotating the current span)
+*
+* ```ts import.meta.vitest
+* import { Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   yield* Effect.annotateCurrentSpan("userId", "123")
+*   yield* Effect.annotateCurrentSpan({
+*     operation: "user-lookup"
+*   })
+*   return "success"
+* })
+*
+* const traced = Effect.withSpan(program, "user-operation")
+* Effect.runSync(traced) // => "success"
+* ```
+*
+* @category tracing
+* @since 2.0.0
+*/
+const annotateCurrentSpan = annotateCurrentSpan$1;
+/**
 * Create a new span for tracing, and automatically close it when the effect
 * completes.
 *
@@ -28440,6 +28473,23 @@ const set$1 = /*#__PURE__*/ dual(2, (self, value) => sync(() => set$2(self.ref,
 const update = /*#__PURE__*/ dual(2, (self, f) => sync(() => {
 	self.ref.current = f(self.ref.current);
 }));
+//#endregion
+//#region ../stryker-js-plugin-interface/dist/index.mjs
+/** A position inside a file, in the coordinates the wire carries — 0-based line and column. */
+const CheckerPositionWire = Struct({
+	line: Finite,
+	column: Finite
+});
+const CheckerMutantWire = Struct({
+	id: NonEmptyString,
+	fileName: NonEmptyString,
+	mutatorName: NonEmptyString,
+	replacement: String$1,
+	location: Struct({
+		start: CheckerPositionWire,
+		end: CheckerPositionWire
+	})
+});
 Literals(["passed", "compileError"]);
 const CheckResultSchema = Union([Struct({ status: Literal("passed") }), Struct({
 	status: Literal("compileError"),
@@ -28469,26 +28519,86 @@ TaggedClass()("ClassifyExitDecision", {
 	highestClass: NullOr(ExitClass),
 	verdictClass: NullOr(ExitClass)
 });
+Union([Literal("Killed"), Literal("Timeout")]);
+Union([Literal("Survived"), Literal("NoCoverage")]);
+Union([Literal("CompileError"), Literal("RuntimeError")]);
+Union([Literal("Ignored"), Literal("Pending")]);
+const NonNegativeInt = Int.pipe(check(isGreaterThanOrEqualTo(0)));
+const NonNegativeFinite = Finite.pipe(check(isGreaterThanOrEqualTo(0)));
+const Percentage = Finite.pipe(check(isBetween({
+	minimum: 0,
+	maximum: 100
+})));
+var Metrics = class Metrics extends Class("Metrics")({
+	pending: NonNegativeInt,
+	killed: NonNegativeInt,
+	timeout: NonNegativeInt,
+	survived: NonNegativeInt,
+	noCoverage: NonNegativeInt,
+	runtimeErrors: NonNegativeInt,
+	compileErrors: NonNegativeInt,
+	ignored: NonNegativeInt
+}) {
+	get totalDetected() {
+		return this.timeout + this.killed;
+	}
+	get totalUndetected() {
+		return this.survived + this.noCoverage;
+	}
+	get totalCovered() {
+		return this.totalDetected + this.survived;
+	}
+	get totalValid() {
+		return this.totalUndetected + this.totalDetected;
+	}
+	get totalInvalid() {
+		return this.runtimeErrors + this.compileErrors;
+	}
+	get totalMutants() {
+		return this.totalValid + this.totalInvalid + this.ignored + this.pending;
+	}
+	get mutationScore() {
+		if (this.totalValid === 0) return NaN;
+		return Math.min(100, Math.max(0, this.totalDetected / this.totalValid * 100));
+	}
+	get mutationScoreBasedOnCoveredCode() {
+		if (this.totalCovered === 0) return NaN;
+		return Math.min(100, Math.max(0, this.totalDetected / this.totalCovered * 100));
+	}
+	static fromMutants(mutants) {
+		const counts = emptyMetricCounts();
+		for (const mutant of mutants) incrementMetricStatus(counts, mutant.status);
+		return Metrics.make(counts);
+	}
+};
+const emptyMetricCounts = () => ({
+	pending: 0,
+	killed: 0,
+	timeout: 0,
+	survived: 0,
+	noCoverage: 0,
+	runtimeErrors: 0,
+	compileErrors: 0,
+	ignored: 0
+});
+const METRIC_STATUS_KEYS = {
+	Pending: "pending",
+	Killed: "killed",
+	Timeout: "timeout",
+	Survived: "survived",
+	NoCoverage: "noCoverage",
+	RuntimeError: "runtimeErrors",
+	CompileError: "compileErrors",
+	Ignored: "ignored"
+};
+const incrementMetricStatus = (counts, status) => {
+	const key = METRIC_STATUS_KEYS[status];
+	if (key === void 0) return;
+	counts[key] += 1;
+};
 const MetricsResultSchema = Struct({
 	name: String$1,
-	metrics: Struct({
-		pending: Finite,
-		killed: Finite,
-		timeout: Finite,
-		survived: Finite,
-		noCoverage: Finite,
-		runtimeErrors: Finite,
-		compileErrors: Finite,
-		ignored: Finite,
-		totalDetected: Finite,
-		totalUndetected: Finite,
-		totalInvalid: Finite,
-		totalValid: Finite,
-		totalMutants: Finite,
-		totalCovered: Finite,
-		mutationScore: Finite,
-		mutationScoreBasedOnCoveredCode: Finite
-	}),
+	metrics: Metrics,
 	childResults: ArraySchema(suspend(() => MetricsResultSchema))
 }).annotate({ identifier: "MetricsResult" });
 const FileResultDictionarySchema = Record(String$1, Struct({
@@ -28505,8 +28615,8 @@ const FileResultDictionarySchema = Record(String$1, Struct({
 		static: optional(Boolean$2),
 		coveredBy: optional(ArraySchema(String$1)),
 		killedBy: optional(ArraySchema(String$1)),
-		testsCompleted: optional(Finite),
-		duration: optional(Finite)
+		testsCompleted: optional(NonNegativeInt),
+		duration: optional(NonNegativeFinite)
 	}))
 }));
 const TestDefinitionSchema = Struct({
@@ -28519,9 +28629,23 @@ const TestFileDefinitionDictionarySchema = Record(String$1, Struct({
 	tests: ArraySchema(TestDefinitionSchema)
 }));
 const ThresholdsSchema = Struct({
-	high: Finite,
-	low: Finite
-});
+	high: Percentage,
+	low: Percentage
+}).pipe(check(makeFilter((t) => t.low <= t.high, {
+	expected: "thresholds where low <= high",
+	arbitrary: { candidate: { make: (fc) => fc.tuple(fc.float({
+		min: 0,
+		max: 100,
+		noNaN: true
+	}), fc.float({
+		min: 0,
+		max: 100,
+		noNaN: true
+	})).map(([a, b]) => ({
+		high: Math.max(a, b),
+		low: Math.min(a, b)
+	})) } }
+})));
 const BrandingInformationSchema = Struct({
 	homepageUrl: String$1,
 	imageUrl: optional(String$1)
@@ -28649,23 +28773,23 @@ const ReporterEventKind = Literals([
 	"mutationTestReportReady"
 ]);
 const RunTimingSchema = Struct({
-	net: Finite,
-	overhead: Finite
+	net: NonNegativeFinite,
+	overhead: NonNegativeFinite
 });
 const ReporterPlanDescriptorSchema = Struct({
 	mutantId: String$1,
 	plan: Literals(["EarlyResult", "Run"]),
-	netTime: Finite,
+	netTime: NonNegativeFinite,
 	reloadEnvironment: Boolean$2
 });
 var DryRunCompleted = class extends TaggedClass()("dryRunCompleted", {
 	timing: RunTimingSchema,
 	capabilities: TestRunnerCapabilitiesSchema,
-	testCount: Finite,
+	testCount: NonNegativeInt,
 	tests: ArraySchema(TestResultSchema)
 }) {};
 var MutationTestingPlanReady = class extends TaggedClass()("mutationTestingPlanReady", {
-	total: Finite,
+	total: NonNegativeInt,
 	plans: ArraySchema(ReporterPlanDescriptorSchema)
 }) {};
 var MutantTested = class extends TaggedClass()("mutantTested", {
@@ -28675,8 +28799,8 @@ var MutantTested = class extends TaggedClass()("mutantTested", {
 	location: LocationSchema,
 	mutator: String$1,
 	replacement: NullOr(String$1),
-	completed: Finite,
-	total: Finite
+	completed: NonNegativeInt,
+	total: NonNegativeInt
 }) {};
 var MutationTestReportReady = class extends TaggedClass()("mutationTestReportReady", {
 	report: MutationTestResultSchema,
@@ -28703,7 +28827,7 @@ const TestRunnerDryRunRequest = Struct({ options: DryRunOptionsSchema });
 const TestRunnerMutantRunRequest = Struct({ options: MutantRunOptionsSchema });
 const CheckerRequest = Struct({
 	checkerName: String$1,
-	mutants: ArraySchema(Mutant)
+	mutants: ArraySchema(CheckerMutantWire)
 });
 const CheckerCheckResult = Record(String$1, CheckResultSchema);
 const CheckerGroupResult = ArraySchema(ArraySchema(String$1));
@@ -28839,11 +28963,6 @@ const PackageManager = Literals([
 	"yarn",
 	"pnpm"
 ]);
-/** 0–100 percentage used by the mutation-score thresholds. */
-const Percentage = Finite.pipe(check(isBetween({
-	minimum: 0,
-	maximum: 100
-})));
 const CommandRunnerOptionsSchema = openStruct({ command: defaulted(String$1, "npm test") });
 const ClearTextReporterOptions = openStruct({
 	allowColor: defaulted(Boolean$2, true),
@@ -28861,7 +28980,26 @@ const MutationScoreThresholdsSchema = Struct({
 	high: defaulted(Percentage, 80),
 	low: defaulted(Percentage, 60),
 	break: defaulted(NullOr(Percentage), null)
-});
+}).pipe(check(makeFilter((t) => t.low <= t.high, {
+	expected: "thresholds where low <= high",
+	arbitrary: { candidate: { make: (fc) => fc.tuple(fc.float({
+		min: 0,
+		max: 100,
+		noNaN: true
+	}), fc.float({
+		min: 0,
+		max: 100,
+		noNaN: true
+	}), fc.option(fc.float({
+		min: 0,
+		max: 100,
+		noNaN: true
+	}), { nil: null })).map(([a, b, brk]) => ({
+		high: Math.max(a, b),
+		low: Math.min(a, b),
+		break: brk
+	})) } }
+})));
 const MutatorDescriptor = Struct({ excludedMutations: defaulted(ArraySchema(String$1), []) });
 const WarningOptions = openStruct({
 	unknownOptions: defaulted(Boolean$2, true),
@@ -51816,7 +51954,7 @@ const TSFileNodeSchema = suspend(() => Struct({
 	children: ArraySchema(TSFileNodeSchema)
 }));
 var CheckMutantsInput = class extends TaggedClass()("CheckMutantsInput", {
-	mutants: ArraySchema(Mutant),
+	mutants: ArraySchema(CheckerMutantWire),
 	diagnostics: ArraySchema(DiagnosticSchema),
 	nodes: Record(SourceFileSchema, TSFileNodeSchema)
 }) {};
@@ -51837,7 +51975,7 @@ var CheckFinished = class extends TaggedClass()("CheckFinished", { results: Reco
 };
 var RetestRequired = class extends TaggedClass()("RetestRequired", {
 	results: Record(String$1, MutantCheckStatusSchema),
-	needsRetest: ArraySchema(Mutant)
+	needsRetest: ArraySchema(CheckerMutantWire)
 }) {
 	[CheckMutantsTypeId] = CheckMutantsTypeId;
 };
@@ -51927,7 +52065,7 @@ const verdict = (input) => match$4(withoutDisambiguation(input), {
 });
 const checkMutants = Workflow_exports.make(CheckMutantsInput, verdict);
 Struct({ typescriptChecker: optional(Struct({ prioritizePerformanceOverAccuracy: optional(Boolean$2) })) });
-var CheckMutantsCommand = class extends TaggedClass()("CheckMutantsCommand", { mutants: ArraySchema(Mutant) }) {};
+var CheckMutantsCommand = class extends TaggedClass()("CheckMutantsCommand", { mutants: ArraySchema(CheckerMutantWire) }) {};
 /**
 * Every way the TypeScript compiler can fail while serving a check.
 * One tagged error — callers branch only on failure itself; `reason` keeps
@@ -52256,7 +52394,7 @@ function parseTsConfig(fileName, jsonText) {
 }
 /** Whether `--build` mode should be enabled based on `references` in the tsconfig. */
 const determineBuildModeEnabled = (tsconfigFileName, fsService) => gen(function* () {
-	const parsed = parseTsConfig(tsconfigFileName, yield* fsService.readFileString(tsconfigFileName));
+	const parsed = parseTsConfig(tsconfigFileName, yield* fsService.readFileString(tsconfigFileName).pipe(orElseSucceed(() => "")));
 	return match$3(parsed, {
 		onFailure: () => false,
 		onSuccess: (config) => config.references !== void 0
@@ -52334,7 +52472,7 @@ const readTypescriptPackageVersion = (fsService, pathService) => gen(function* (
 		onSuccess: (value) => value
 	});
 	return getOrElse(flatMap$4(versionFieldOf(raw), (version) => liftPredicate(version, isString)), () => "");
-});
+}).pipe(orElseSucceed(() => ""));
 const getTSVersion = (fsService, pathService) => gen(function* () {
 	if (cachedTSVersion !== void 0) return cachedTSVersion;
 	const version = yield* readTypescriptPackageVersion(fsService, pathService);
@@ -52419,7 +52557,7 @@ function resetScriptFile(file, now) {
 function getOffset(file, pos) {
 	const lines = file.originalContent.split("\n");
 	const lineCount = Math.min(pos.line, lines.length);
-	let offset = pos.column;
+	let offset = Math.max(0, pos.column - 1);
 	lines.forEach((line, index) => {
 		if (index < lineCount) offset += line.length + 1;
 	});
@@ -52641,7 +52779,7 @@ function makeTypescriptCompiler(options, fs, fsService, pathService) {
 		}));
 		return succeed$1(projects.map((project) => project.program));
 	};
-	const getProgramsEffect = () => gen(function* () {
+	const getPrograms = () => gen(function* () {
 		const state = yield* get$1(stateRef);
 		const snapshot = yield* snapshotOf(state);
 		return yield* programsOf(snapshot, state.tsconfigFile);
@@ -52670,7 +52808,7 @@ function makeTypescriptCompiler(options, fs, fsService, pathService) {
 		const current = traversal.pending.pop();
 		if (!isUnprocessedTsConfigPath(current, traversal.processed)) return;
 		add(traversal.processed, current);
-		const content = yield* fsService.readFileString(current);
+		const content = yield* fsService.readFileString(current).pipe(mapError(() => TsConfigNotFoundError.make({ file: current })));
 		recordTsConfig(current, content, parseTsConfig(current, content), traversal);
 	});
 	const collectAllTSConfigFiles = (buildModeEnabled) => gen(function* () {
@@ -52875,15 +53013,20 @@ function makeTypescriptCompiler(options, fs, fsService, pathService) {
 		yield* buildFileNodes(state);
 		return state.nodes;
 	});
+	const resolveFileName = (fileName) => normalizeFileName$1(pathService.resolve(fileName));
 	const resetMutatedFiles = (mutants) => gen(function* () {
-		for (const mutant of mutants) yield* fs.resetFile(mutant.fileName);
+		for (const mutant of mutants) yield* fs.resetFile(resolveFileName(mutant.fileName));
 	});
 	const applyMutant = (mutant) => gen(function* () {
-		if ((yield* fs.getFile(mutant.fileName)) === void 0) return yield* CompilerFailed.make({
+		const resolved = resolveFileName(mutant.fileName);
+		if ((yield* fs.getFile(resolved)) === void 0) return yield* CompilerFailed.make({
 			reason: "file-not-in-project",
 			subject: mutant.fileName
 		});
-		yield* fs.mutateFile(mutant.fileName, mutant);
+		yield* fs.mutateFile(resolved, mutant).pipe(mapError(() => CompilerFailed.make({
+			reason: "file-not-in-project",
+			subject: mutant.fileName
+		})));
 	});
 	const applyMutants = (mutants) => gen(function* () {
 		for (const mutant of mutants) yield* applyMutant(mutant);
@@ -52901,25 +53044,40 @@ function makeTypescriptCompiler(options, fs, fsService, pathService) {
 			snapshot: next
 		}));
 	});
+	const refreshSnapshotIfOpen = (current, changedFiles) => {
+		if (!hasOpenSnapshot(current)) return void_$1;
+		return updateSnapshot(current, changedFiles);
+	};
+	const annotateDiagnosticSample = (diagnostics) => {
+		if (diagnostics.length === 0) return void_$1;
+		const summary = diagnostics.slice(0, 10).map((d) => `${d.fileName ?? "unknown"}:${d.code}: ${d.text}`).join("; ");
+		return annotateCurrentSpan({ "typescript.diagnostics.sample": summary });
+	};
 	const check = (mutants) => gen(function* () {
 		const state = yield* get$1(stateRef);
 		yield* resetMutatedFiles(state.lastMutants);
 		yield* applyMutants(mutants);
-		const mutatedFileNames = Array.from(fromIterable(mutants.map((mutant) => normalizeFileName$1(mutant.fileName))));
+		const mutatedFileNames = Array.from(fromIterable(mutants.map((mutant) => resolveFileName(mutant.fileName))));
 		const changedFiles = Array.from(fromIterable([...state.lastMutatedFileNames, ...mutatedFileNames]));
 		const current = yield* get$1(stateRef);
-		if (hasOpenSnapshot(current)) yield* updateSnapshot(current, changedFiles);
+		yield* refreshSnapshotIfOpen(current, changedFiles);
 		yield* update(stateRef, (prev) => ({
 			...prev,
 			lastMutants: [...mutants],
 			lastMutatedFileNames: mutatedFileNames
 		}));
-		return (yield* getProgramsEffect()).flatMap((program) => [
+		const diagnostics = (yield* getPrograms()).flatMap((program) => [
 			...program.getConfigFileParsingDiagnostics(),
 			...program.getSemanticDiagnostics(),
 			...program.getProgramDiagnostics()
 		]).filter((diagnostic) => diagnostic.category === DiagnosticCategory.Error);
-	});
+		yield* annotateCurrentSpan({ "typescript.diagnostics.count": diagnostics.length });
+		yield* annotateDiagnosticSample(diagnostics);
+		return diagnostics;
+	}).pipe(withSpan("typescript-checker.compiler.check", { attributes: {
+		"stryker.mutants.count": mutants.length,
+		"stryker.mutants.ids": mutants.map((m) => m.id).join(",")
+	} }));
 	const init = gen(function* () {
 		yield* guardTSVersion(fsService, pathService);
 		const absoluteTsconfigFile = normalizeFileName$1(pathService.resolve(rawTsconfigFile));
@@ -52939,7 +53097,7 @@ function makeTypescriptCompiler(options, fs, fsService, pathService) {
 			api,
 			snapshot
 		}));
-		const programs = yield* getProgramsEffect();
+		const programs = yield* getPrograms();
 		yield* buildDependencyGraph(programs);
 		return yield* check([]);
 	});
@@ -52954,12 +53112,12 @@ function makeTypescriptCompiler(options, fs, fsService, pathService) {
 		}));
 	});
 	const getLineAndCharacterOfPosition = (fileName, position) => gen(function* () {
-		return (yield* getProgramsEffect()).map((program) => program.getSourceFile(fileName)).find((sourceFile) => sourceFile !== void 0)?.getLineAndCharacterOfPosition(position);
+		return (yield* getPrograms().pipe(orElseSucceed(() => []))).map((program) => program.getSourceFile(fileName)).find((sourceFile) => sourceFile !== void 0)?.getLineAndCharacterOfPosition(position);
 	});
 	return {
 		init,
 		check,
-		nodes: getNodesEffect,
+		nodes: getNodesEffect.pipe(orDie),
 		close,
 		getLineAndCharacterOfPosition
 	};
@@ -52979,7 +53137,7 @@ const knownFileGroups = (mutants, nodes) => {
 };
 const groupMutants = (mutants, nodes, prioritizePerformanceOverAccuracy) => {
 	if (prioritizePerformanceOverAccuracy) return knownFileGroups(mutants, nodes);
-	return [mutants.map((mutant) => mutant.id)];
+	return mutants.map((mutant) => [mutant.id]);
 };
 //#endregion
 //#region src/Checker.ts
@@ -53023,14 +53181,14 @@ const makeCheckerService = ({ options, compiler }) => {
 	});
 	const formatDiagnostic = (error) => positionOf(error).pipe(map$2((position) => `${position}${severityOf(error.category)} TS${error.code}: ${error.text}`));
 	const createErrorText = (errors) => map$2(forEach$2(errors, formatDiagnostic), (parts) => parts.join("\n"));
-	const soloRound = (mutant) => verify.run(CheckMutantsCommand.make({ mutants: [mutant] })).pipe(map$2((decision) => decision.results));
+	const soloRound = (mutant) => verify.run(CheckMutantsCommand.make({ mutants: [mutant] })).pipe(withSpan("typescript-checker.soloRound", { attributes: { "stryker.mutant.id": mutant.id } }), map$2((decision) => decision.results));
 	const soloRounds = (decision) => value(decision).pipe(tag("CheckFinished", () => succeed$1([])), tag("RetestRequired", (retest) => verify.run(CheckMutantsCommand.make({ mutants: [] })).pipe(flatMap(() => forEach$2(retest.needsRetest, soloRound)))), exhaustive);
 	return {
 		init: compiler.init.pipe(mapError((cause) => refuse([], cause)), flatMap((errors) => {
 			if (errors.length === 0) return void_$1;
 			return createErrorText(errors).pipe(map$2((text) => refuse([], /* @__PURE__ */ new Error(`Typescript error(s) found in dry run compilation: ${text}`))), flatMap(fail));
 		})),
-		check: (mutants) => verify.run(CheckMutantsCommand.make({ mutants: [...mutants] })).pipe(flatMap((first) => map$2(soloRounds(first), (rounds) => mergeAnswers([first.results, ...rounds])))),
+		check: (mutants) => verify.run(CheckMutantsCommand.make({ mutants: [...mutants] })).pipe(flatMap((first) => map$2(soloRounds(first), (rounds) => mergeAnswers([first.results, ...rounds]))), withSpan("typescript-checker.check", { attributes: { "stryker.mutants.count": mutants.length } })),
 		group: (mutants) => compiler.nodes.pipe(map$2((nodes) => groupMutants(mutants, nodes, getPrioritize(options))), mapError((cause) => refuse(mutants.map((mutant) => mutant.id), cause)))
 	};
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@systemfsoftware/stryker-js-typescript-checker",
-  "version": "7.0.1",
+  "version": "7.0.3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/stryker-js-effect.git",
@@ -30,8 +30,8 @@
     "effect": "4.0.0-rc.112",
     "typescript": "^7",
     "@systemfsoftware/stryker-js-instrumenter": "^8.0.0",
-    "@systemfsoftware/stryker-js-plugin-interface": "^6.0.1",
-    "@systemfsoftware/stryker-js-plugin-runtime": "^5.0.1"
+    "@systemfsoftware/stryker-js-plugin-interface": "^7.1.0",
+    "@systemfsoftware/stryker-js-plugin-runtime": "^5.0.2"
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.0-rc.112",
@@ -56,8 +56,8 @@
     "rimraf": "^6.1.3",
     "tsdown": "^0.23.0",
     "vitest": "^4",
-    "@systemfsoftware/stryker-config": "^0.1.0",
     "@systemfsoftware/tsdown-config": "^0.1.0",
+    "@systemfsoftware/stryker-config": "^0.1.0",
     "@systemfsoftware/vitest-config": "^0.1.0"
   },
   "inlinedDependencies": {