@systemfsoftware/stryker-js-mutation-run 1.2.5

package/dist/incremental-differ-DY8AA09Q.mjs

@@ -0,0 +1,579 @@
+import { b as dryRunResult } from "./plugins-Nx86IJQW.mjs";
+import "@systemfsoftware/stryker-js-plugin-api/core";
+import { commonTokens } from "@systemfsoftware/stryker-js-plugin-api/plugin";
+import { normalizeFileName, normalizeLineEndings, notEmpty } from "@stryker-mutator/util";
+import path from "path";
+import "@systemfsoftware/stryker-js-plugin-api/logging";
+import "mutation-testing-report-schema";
+import { TestStatus } from "@systemfsoftware/stryker-js-plugin-api/test-runner";
+import { diff_match_patch } from "diff-match-patch";
+//#region src/mutants/diff-statistics-collector.ts
+var DiffChanges = class {
+	added = 0;
+	removed = 0;
+	toString() {
+		return `+${this.added} -${this.removed}`;
+	}
+};
+var DiffStatisticsCollector = class {
+	changesByFile = /* @__PURE__ */ new Map();
+	total = new DiffChanges();
+	count(file, change, amount = 1) {
+		if (amount === 0) return;
+		let changes = this.changesByFile.get(file);
+		if (!changes) {
+			changes = new DiffChanges();
+			this.changesByFile.set(file, changes);
+		}
+		switch (change) {
+			case "added":
+				changes.added += amount;
+				this.total.added += amount;
+				break;
+			case "removed":
+				changes.removed += amount;
+				this.total.removed += amount;
+		}
+	}
+	createDetailedReport() {
+		return [...this.changesByFile.entries()].map(([fileName, changes]) => `${fileName} ${changes.toString()}`);
+	}
+	createTotalsReport() {
+		return `${this.changesByFile.size} files changed (${this.total.toString()})`;
+	}
+};
+//#endregion
+//#region src/mutants/test-coverage.ts
+var TestCoverage = class {
+	#testsByMutantId;
+	#testsById;
+	#staticCoverage;
+	#hitsByMutantId;
+	constructor(testsByMutantId, testsById, staticCoverage, hitsByMutantId) {
+		this.#testsByMutantId = testsByMutantId;
+		this.#testsById = testsById;
+		this.#staticCoverage = staticCoverage;
+		this.#hitsByMutantId = hitsByMutantId;
+	}
+	get testsByMutantId() {
+		return this.#testsByMutantId;
+	}
+	get testsById() {
+		return this.#testsById;
+	}
+	get hitsByMutantId() {
+		return this.#hitsByMutantId;
+	}
+	get hasCoverage() {
+		return !!this.#staticCoverage;
+	}
+	hasStaticCoverage(mutantId) {
+		const coverage = this.#staticCoverage?.[mutantId];
+		return coverage !== void 0 && coverage > 0;
+	}
+	addTest(testResult) {
+		this.#testsById.set(testResult.id, testResult);
+	}
+	addCoverage(mutantId, testIds) {
+		const tests = this.#testsByMutantId.get(mutantId) ?? /* @__PURE__ */ new Set();
+		this.#testsByMutantId.set(mutantId, tests);
+		testIds.map((testId) => this.#testsById.get(testId)).filter(notEmpty).forEach((test) => tests.add(test));
+	}
+	forMutant(mutantId) {
+		return this.#testsByMutantId.get(mutantId);
+	}
+	static from = testCoverageFrom;
+};
+function testCoverageFrom({ tests, mutantCoverage }, logger) {
+	const hitsByMutantId = /* @__PURE__ */ new Map();
+	const testsByMutantId = /* @__PURE__ */ new Map();
+	const testsById = tests.reduce((acc, test) => acc.set(test.id, test), /* @__PURE__ */ new Map());
+	if (mutantCoverage) {
+		Object.entries(mutantCoverage.perTest).forEach(([testId, coverage]) => {
+			const foundTest = testsById.get(testId);
+			if (!foundTest) {
+				logger.warn(`Found test with id "${testId}" in coverage data, but not in the test results of the dry run. Not taking coverage data for this test into account.`);
+				return;
+			}
+			Object.entries(coverage).forEach(([mutantId, count]) => {
+				if (count > 0) {
+					let cov = testsByMutantId.get(mutantId);
+					if (!cov) {
+						cov = /* @__PURE__ */ new Set();
+						testsByMutantId.set(mutantId, cov);
+					}
+					cov.add(foundTest);
+				}
+			});
+		});
+		[mutantCoverage.static, ...Object.values(mutantCoverage.perTest)].forEach((coverageByMutantId) => {
+			Object.entries(coverageByMutantId).forEach(([mutantId, count]) => {
+				hitsByMutantId.set(mutantId, (hitsByMutantId.get(mutantId) ?? 0) + count);
+			});
+		});
+	}
+	return new TestCoverage(testsByMutantId, testsById, mutantCoverage?.static, hitsByMutantId);
+}
+testCoverageFrom.inject = [dryRunResult, commonTokens.logger];
+//#endregion
+//#region src/mutants/incremental-differ.ts
+/**
+* The 'diff match patch' high-performant 'diffing' of files.
+* @see https://github.com/google/diff-match-patch
+*/
+const diffMatchPatch = new diff_match_patch();
+/**
+* This class is responsible for calculating the diff between a run and a previous run based on the incremental report.
+*
+* Since the ids of tests and mutants can differ across reports (they are only unique within 1 report), this class
+* identifies mutants and tests by attributes that make them unique:
+* - Mutant: file name, mutator name, location and replacement
+* - Test: test name, test file name (if present) and location (if present).
+*
+* We're storing these identifiers in local variables (maps and sets) as strings.
+* We should move to 'records' for these when they come available: https://github.com/tc39/proposal-record-tuple
+*
+* A mutant result from the previous run is reused if the following conditions were met:
+* - The location of the mutant refers to a piece of code that didn't change
+* - If mutant was killed:
+*   - The culprit test wasn't changed
+* - If the mutant survived:
+*   - No test was added, and the mutant is not static. Static mutants are
+*     attributed to no test, so no test change can ever invalidate one; reusing
+*     a non-killed verdict for one would freeze it permanently.
+*
+* It uses google's "diff-match-patch" project to calculate the new locations for tests and mutants, see https://github.com/google/diff-match-patch.
+*/
+var IncrementalDiffer = class {
+	logger;
+	options;
+	mutantStatisticsCollector;
+	testStatisticsCollector;
+	mutateDescriptionByRelativeFileName;
+	static inject = [
+		commonTokens.logger,
+		commonTokens.options,
+		commonTokens.fileDescriptions
+	];
+	constructor(logger, options, fileDescriptions) {
+		this.logger = logger;
+		this.options = options;
+		this.mutateDescriptionByRelativeFileName = new Map(Object.entries(fileDescriptions).map(([name, description]) => [toRelativeNormalizedFileName(name), description.mutate]));
+	}
+	isInMutatedScope(relativeFileName, mutant) {
+		const mutate = this.mutateDescriptionByRelativeFileName.get(relativeFileName);
+		return mutate === true || Array.isArray(mutate) && mutate.some((range) => locationIncluded(range, mutant.location));
+	}
+	diff(currentMutants, testCoverage, incrementalReport, currentRelativeFiles) {
+		const { files, testFiles } = incrementalReport;
+		const mutantStatisticsCollector = new DiffStatisticsCollector();
+		const testStatisticsCollector = new DiffStatisticsCollector();
+		this.mutantStatisticsCollector = mutantStatisticsCollector;
+		this.testStatisticsCollector = testStatisticsCollector;
+		const reusableMutantsByKey = collectReusableMutantsByKey(this.logger);
+		const { byId: oldTestsById, byKey: oldTestInfoByKey } = collectReusableTestInfo(this.logger);
+		const { oldCoverageByMutantKey: oldCoverageTestKeysByMutantKey, oldKilledByMutantKey: oldKilledTestKeysByMutantKey } = collectOldKilledAndCoverageMatrix();
+		const oldTestKeys = new Set([...oldTestsById.values()].map(({ key }) => key));
+		const newTestKeys = new Set([...testCoverage.testsById].map(([, test]) => testToIdentifyingKey(test, toRelativeNormalizedFileName(test.fileName))));
+		const testInfoByKey = collectCurrentTestInfo();
+		for (const [key, { relativeFileName }] of testInfoByKey) if (!oldTestKeys.has(key)) testStatisticsCollector.count(relativeFileName, "added");
+		for (const [testKey, { test: { name, location }, relativeFileName }] of oldTestInfoByKey) if (!testInfoByKey.has(testKey)) {
+			const test = {
+				status: TestStatus.Success,
+				id: testKey,
+				name,
+				...location?.start === void 0 ? {} : { startPosition: location.start },
+				timeSpentMs: 0,
+				fileName: path.resolve(relativeFileName)
+			};
+			testInfoByKey.set(testKey, {
+				test,
+				relativeFileName
+			});
+			testCoverage.addTest(test);
+		}
+		let reusedMutantCount = 0;
+		const currentMutantKeys = /* @__PURE__ */ new Set();
+		const mutants = currentMutants.map((mutant) => {
+			const relativeFileName = toRelativeNormalizedFileName(mutant.fileName);
+			const mutantKey = mutantToIdentifyingKey(mutant, relativeFileName);
+			currentMutantKeys.add(mutantKey);
+			if (!mutant.status && !this.options.force) {
+				const oldMutant = reusableMutantsByKey.get(mutantKey);
+				if (oldMutant) {
+					const coveringTests = testCoverage.forMutant(mutant.id);
+					const killedByTestKeys = oldKilledTestKeysByMutantKey.get(mutantKey);
+					if (mutantCanBeReused(mutant, oldMutant, mutantKey, coveringTests, killedByTestKeys)) {
+						reusedMutantCount++;
+						const { status, statusReason, testsCompleted } = oldMutant;
+						return {
+							...mutant,
+							...status === void 0 ? {} : { status },
+							...statusReason === void 0 ? {} : { statusReason },
+							...testsCompleted === void 0 ? {} : { testsCompleted },
+							coveredBy: [...coveringTests ?? []].map(({ id }) => id),
+							killedBy: testKeysToId(killedByTestKeys)
+						};
+					}
+				} else mutantStatisticsCollector.count(relativeFileName, "added");
+			}
+			return mutant;
+		});
+		for (const [mutantKey, oldResult] of reusableMutantsByKey) if (!currentMutantKeys.has(mutantKey) && !this.isInMutatedScope(oldResult.relativeFileName, oldResult)) {
+			const coverage = oldCoverageTestKeysByMutantKey.get(mutantKey) ?? [];
+			const killed = oldKilledTestKeysByMutantKey.get(mutantKey) ?? [];
+			const coveredBy = testKeysToId(coverage);
+			const killedBy = testKeysToId(killed);
+			const reusedMutant = {
+				...oldResult,
+				id: mutantKey,
+				fileName: path.resolve(oldResult.relativeFileName),
+				replacement: oldResult.replacement ?? oldResult.mutatorName,
+				coveredBy,
+				killedBy
+			};
+			mutants.push(reusedMutant);
+			testCoverage.addCoverage(reusedMutant.id, coveredBy);
+		}
+		if (this.logger.isInfoEnabled()) {
+			const testInfo = testCoverage.hasCoverage ? `\n\tTests:\t\t${testStatisticsCollector.createTotalsReport()}` : "";
+			this.logger.info(`Incremental report:\n\tMutants:\t${mutantStatisticsCollector.createTotalsReport()}` + testInfo + `\n\tResult:\t\t${reusedMutantCount} of ${currentMutants.length} mutant result(s) are reused.`);
+		}
+		if (this.logger.isDebugEnabled()) {
+			const lineSeparator = "\n		";
+			const noChanges = "No changes";
+			const detailedMutantSummary = `${lineSeparator}${mutantStatisticsCollector.createDetailedReport().join(lineSeparator) || noChanges}`;
+			const detailedTestsSummary = `${lineSeparator}${testStatisticsCollector.createDetailedReport().join(lineSeparator) || noChanges}`;
+			this.logger.debug(`Detailed incremental report:\n\tMutants: ${detailedMutantSummary}\n\tTests: ${detailedTestsSummary}`);
+		}
+		return mutants;
+		function testKeysToId(testKeys) {
+			return [...testKeys ?? []].map((id) => testInfoByKey.get(id)).filter(notEmpty).map(({ test: { id } }) => id);
+		}
+		function collectReusableMutantsByKey(log) {
+			return new Map(Object.entries(files).flatMap(([fileName, oldFile]) => {
+				const relativeFileName = toRelativeNormalizedFileName(fileName);
+				const currentFileSource = currentRelativeFiles.get(relativeFileName);
+				if (currentFileSource) {
+					log.trace("Diffing %s", relativeFileName);
+					const { results, removeCount } = performFileDiff(oldFile.source, currentFileSource, oldFile.mutants);
+					mutantStatisticsCollector.count(relativeFileName, "removed", removeCount);
+					return results.map((m) => [mutantToIdentifyingKey(m, relativeFileName), {
+						...m,
+						relativeFileName
+					}]);
+				}
+				mutantStatisticsCollector.count(relativeFileName, "removed", oldFile.mutants.length);
+				return [];
+			}));
+		}
+		function collectReusableTestInfo(log) {
+			const byId = /* @__PURE__ */ new Map();
+			const byKey = /* @__PURE__ */ new Map();
+			Object.entries(testFiles ?? {}).forEach(([fileName, oldTestFile]) => {
+				const relativeFileName = toRelativeNormalizedFileName(fileName);
+				const currentFileSource = currentRelativeFiles.get(relativeFileName);
+				if (currentFileSource === void 0 && fileName !== "") {
+					log.debug("Test file removed: %s", relativeFileName);
+					testStatisticsCollector.count(relativeFileName, "removed", oldTestFile.tests.length);
+				} else if (currentFileSource !== void 0 && oldTestFile.source !== void 0) {
+					log.trace("Diffing %s", relativeFileName);
+					const locatedTests = closeLocations(oldTestFile);
+					const { results, removeCount } = performFileDiff(oldTestFile.source, currentFileSource, locatedTests);
+					testStatisticsCollector.count(relativeFileName, "removed", removeCount);
+					results.forEach((test) => {
+						const key = testToIdentifyingKey(test, relativeFileName);
+						const testInfo = {
+							key,
+							test,
+							relativeFileName
+						};
+						byId.set(test.id, testInfo);
+						byKey.set(key, testInfo);
+					});
+				} else oldTestFile.tests.map((test) => {
+					const key = testToIdentifyingKey(test, relativeFileName);
+					const testInfo = {
+						key,
+						test,
+						relativeFileName
+					};
+					byId.set(test.id, testInfo);
+					byKey.set(key, testInfo);
+				});
+			});
+			return {
+				byId,
+				byKey
+			};
+		}
+		function collectOldKilledAndCoverageMatrix() {
+			const oldCoverageByMutantKey = /* @__PURE__ */ new Map();
+			const oldKilledByMutantKey = /* @__PURE__ */ new Map();
+			for (const [key, mutant] of reusableMutantsByKey) {
+				const killedRow = new Set(mutant.killedBy?.map((testId) => oldTestsById.get(testId)?.key).filter(notEmpty));
+				const coverageRow = new Set(mutant.coveredBy?.map((testId) => oldTestsById.get(testId)?.key).filter(notEmpty));
+				killedRow.forEach((killed) => coverageRow.add(killed));
+				oldCoverageByMutantKey.set(key, coverageRow);
+				oldKilledByMutantKey.set(key, killedRow);
+			}
+			return {
+				oldCoverageByMutantKey,
+				oldKilledByMutantKey
+			};
+		}
+		function collectCurrentTestInfo() {
+			const byTestKey = /* @__PURE__ */ new Map();
+			for (const testResult of testCoverage.testsById.values()) {
+				const relativeFileName = toRelativeNormalizedFileName(testResult.fileName);
+				const key = testToIdentifyingKey(testResult, relativeFileName);
+				const info = {
+					relativeFileName,
+					test: testResult,
+					key
+				};
+				byTestKey.set(key, info);
+			}
+			return byTestKey;
+		}
+		function mutantCanBeReused(mutant, oldMutant, mutantKey, coveringTests, oldKillingTests) {
+			if (!testCoverage.hasCoverage) return true;
+			if (oldMutant.status === "Ignored") return false;
+			if (coveringTests === void 0 && testCoverage.hasStaticCoverage(mutant.id) && (oldMutant.status === "Survived" || oldMutant.status === "NoCoverage")) return false;
+			const testsDiff = diffTestCoverage(mutant.id, oldCoverageTestKeysByMutantKey.get(mutantKey), coveringTests);
+			if (oldMutant.status === "Killed") {
+				if (oldKillingTests) {
+					for (const killingTest of oldKillingTests) if (testsDiff.get(killingTest) === "same") return true;
+				}
+				return false;
+			}
+			for (const action of testsDiff.values()) if (action === "added") return false;
+			return true;
+		}
+		/**
+		* Determines if there is a diff between old test coverage and new test coverage.
+		*/
+		function diffTestCoverage(mutantId, oldCoveringTestKeys, newCoveringTests) {
+			const result = /* @__PURE__ */ new Map();
+			if (newCoveringTests) for (const newTest of newCoveringTests) {
+				const key = testToIdentifyingKey(newTest, toRelativeNormalizedFileName(newTest.fileName));
+				result.set(key, oldCoveringTestKeys?.has(key) ? "same" : "added");
+			}
+			if (oldCoveringTestKeys) {
+				const isStatic = testCoverage.hasStaticCoverage(mutantId);
+				for (const oldTestKey of oldCoveringTestKeys) if (!result.has(oldTestKey)) {
+					if (isStatic && newTestKeys.has(oldTestKey)) result.set(oldTestKey, "same");
+					else result.set(oldTestKey, "removed");
+				}
+			}
+			return result;
+		}
+	}
+};
+/**
+* Finds the diff of mutants and tests. Removes mutants / tests that no longer exist (changed or removed). Updates locations of mutants or tests that do still exist.
+* @param oldCode The old code to use for the diff
+* @param newCode The new (current) code to use for the diff
+* @param items The mutants or tests to be looked . These will be treated as immutable.
+* @returns A list of items with updated locations, without items that are changed.
+*/
+function performFileDiff(oldCode, newCode, items) {
+	const oldSourceNormalized = normalizeLineEndings(oldCode);
+	const currentSrcNormalized = normalizeLineEndings(newCode);
+	const diffChanges = diffMatchPatch.diff_main(oldSourceNormalized, currentSrcNormalized);
+	const toDo = new Set(items.map((m) => ({
+		...m,
+		location: deepClone(m.location)
+	})));
+	const [added, removed] = [1, -1];
+	const done = [];
+	const currentPosition = {
+		column: 0,
+		line: 0
+	};
+	let removeCount = 0;
+	for (const [change, text] of diffChanges) {
+		if (toDo.size === 0) break;
+		const offset = calculateOffset(text);
+		if (change === added) {
+			for (const test of toDo) {
+				const { location } = test;
+				if (gte(currentPosition, location.start) && gte(location.end, currentPosition)) {
+					removeCount++;
+					toDo.delete(test);
+				} else locationAdd(location, offset, currentPosition.line === location.start.line);
+			}
+			positionMove(currentPosition, offset);
+		} else if (change === removed) for (const item of toDo) {
+			const { location: { start } } = item;
+			if (gte(positionMove({ ...currentPosition }, offset), start)) {
+				removeCount++;
+				toDo.delete(item);
+			} else locationAdd(item.location, negate(offset), currentPosition.line === start.line);
+		}
+		else {
+			positionMove(currentPosition, offset);
+			toDo.forEach((item) => {
+				const { end } = item.location;
+				if (gte(currentPosition, end)) {
+					toDo.delete(item);
+					done.push(item);
+				}
+			});
+		}
+	}
+	done.push(...toDo);
+	return {
+		results: done,
+		removeCount
+	};
+}
+/**
+* A greater-than-equals implementation for positions
+*/
+function gte(a, b) {
+	return a.line > b.line || a.line === b.line && a.column >= b.column;
+}
+function locationIncluded(haystack, needle) {
+	const startIncluded = gte(needle.start, haystack.start);
+	const endIncluded = gte(haystack.end, needle.end);
+	return startIncluded && endIncluded;
+}
+function deepClone(loc) {
+	return {
+		start: { ...loc.start },
+		end: { ...loc.end }
+	};
+}
+/**
+* Reduces a mutant to a string that identifies the mutant across reports.
+* Consists of the relative file name, mutator name, replacement, and location
+*/
+function mutantToIdentifyingKey({ mutatorName, replacement, location: { start, end } }, relativeFileName) {
+	return `${relativeFileName}@${start.line}:${start.column}-${end.line}:${end.column}\n${mutatorName}: ${replacement}`;
+}
+function testToIdentifyingKey({ name, location, startPosition }, relativeFileName) {
+	startPosition = startPosition ?? location?.start ?? {
+		line: 0,
+		column: 0
+	};
+	return `${relativeFileName}@${startPosition.line}:${startPosition.column}\n${name}`;
+}
+function toRelativeNormalizedFileName(fileName) {
+	return normalizeFileName(path.relative(process.cwd(), fileName ?? ""));
+}
+function calculateOffset(text) {
+	const pos = {
+		line: 0,
+		column: 0
+	};
+	for (const char of text) if (char === "\n") {
+		pos.line++;
+		pos.column = 0;
+	} else pos.column++;
+	return pos;
+}
+function positionMove(pos, diff) {
+	pos.line += diff.line;
+	if (diff.line === 0) pos.column += diff.column;
+	else pos.column = diff.column;
+	return pos;
+}
+function locationAdd({ start, end }, { line, column }, currentLine) {
+	start.line += line;
+	if (currentLine) start.column += column;
+	end.line += line;
+	if (line === 0 && currentLine) end.column += column;
+}
+function negate({ line, column }) {
+	return {
+		line: -1 * line,
+		column: -1 * column
+	};
+}
+/**
+* Sets the end position of each test to the start position of the next test.
+* This is an educated guess and necessary.
+* If a test has no location, it is assumed it spans the entire file (line 0 to Infinity)
+*
+* Knowing the end location of tests is necessary in order to know if the test was changed.
+*/
+function closeLocations(testFile) {
+	const locatedTests = [];
+	const openEndedTests = [];
+	testFile.tests.forEach((test) => {
+		if (testHasLocation(test)) {
+			if (isClosed(test)) locatedTests.push(test);
+			else openEndedTests.push(test);
+		} else locatedTests.push({
+			...test,
+			location: {
+				start: {
+					line: 0,
+					column: 0
+				},
+				end: {
+					line: Number.POSITIVE_INFINITY,
+					column: 0
+				}
+			}
+		});
+	});
+	if (openEndedTests.length) {
+		openEndedTests.sort((a, b) => a.location.start.line - b.location.start.line);
+		const openEndedTestSet = new Set(openEndedTests);
+		const startPositions = uniqueStartPositions(openEndedTests);
+		let currentPositionIndex = 0;
+		openEndedTestSet.forEach((test) => {
+			if (eqPosition(test.location.start, startPositions[currentPositionIndex])) currentPositionIndex++;
+			const nextPosition = startPositions[currentPositionIndex];
+			if (nextPosition) {
+				locatedTests.push({
+					...test,
+					location: {
+						start: test.location.start,
+						end: nextPosition
+					}
+				});
+				openEndedTestSet.delete(test);
+			}
+		});
+		openEndedTestSet.forEach((lastTest) => {
+			locatedTests.push({
+				...lastTest,
+				location: {
+					start: lastTest.location.start,
+					end: {
+						line: Number.POSITIVE_INFINITY,
+						column: 0
+					}
+				}
+			});
+		});
+	}
+	return locatedTests;
+}
+/**
+* Determines the unique start positions of a sorted list of tests in order
+*/
+function uniqueStartPositions(sortedTests) {
+	let current;
+	return sortedTests.reduce((collector, { location: { start } }) => {
+		if (!current || current.line !== start.line || current.column !== start.column) {
+			current = start;
+			collector.push(current);
+		}
+		return collector;
+	}, []);
+}
+function testHasLocation(test) {
+	return !!test.location?.start;
+}
+function isClosed(test) {
+	return !!test.location.end;
+}
+function eqPosition(start, end) {
+	return start.column === end?.column && start.line === end.line;
+}
+//#endregion
+export { toRelativeNormalizedFileName as n, TestCoverage as r, IncrementalDiffer as t };

package/dist/index-CyOSz6LC.d.mts

@@ -0,0 +1,104 @@
+import { Injector, Plugin, PluginContext, PluginInterfaces, PluginKind, Plugins } from "@systemfsoftware/stryker-js-plugin-api/plugin";
+import { Logger } from "@systemfsoftware/stryker-js-plugin-api/logging";
+declare namespace injection_tokens_d_exports {
+  export { checkerConcurrencyTokens, checkerFactory, checkerPool, clearTextEnabled, concurrencyTokenProvider, disableTypeChecksHelper, dryRunResult, execa, execaSync, fs, incrementalDiffer, loggerActiveLevel, loggerConsoleOut, loggerShowColors, loggingServer, loggingServerAddress, loggingSink, mutantTestPlanner, mutants, mutationTestReportHelper, optionsValidator, pluginCreator, pluginModulePaths, pluginsByKind, process, progressEnabled, project, reporter, reporterOverride, reporterPluginModules, requireFromCwd, resolveFromCwd, resolvedMode, runEventSink, runId, runStartedAt, sandbox, temporaryDirectory, testCoverage, testRunnerConcurrencyTokens, testRunnerFactory, testRunnerPool, timeOverheadMS, timer, unexpectedExitRegistry, validationSchema, workerIdGenerator };
+}
+declare const checkerPool = "checkerPool";
+declare const checkerFactory = "checkerFactory";
+declare const checkerConcurrencyTokens = "checkerConcurrencyTokens";
+declare const disableTypeChecksHelper = "disableTypeChecksHelper";
+declare const execa = "execa";
+declare const execaSync = "execaSync";
+declare const dryRunResult = "dryRunResult";
+declare const mutants = "mutants";
+declare const mutantTestPlanner = "mutantTestPlanner";
+declare const process = "process";
+declare const pluginModulePaths = "pluginModulePaths";
+declare const temporaryDirectory = "temporaryDirectory";
+declare const unexpectedExitRegistry = "unexpectedExitRegistry";
+declare const timer = "timer";
+declare const timeOverheadMS = "timeOverheadMS";
+declare const loggingServerAddress = "loggingServerAddress";
+declare const loggerActiveLevel = "loggerActiveLevel";
+declare const loggerConsoleOut = "loggerConsoleOut";
+declare const loggerShowColors = "loggerShowColors";
+declare const loggingSink = "loggingSink";
+declare const runEventSink = "runEventSink";
+declare const runId = "runId";
+declare const resolvedMode = "resolvedMode";
+declare const progressEnabled = "progressEnabled";
+declare const clearTextEnabled = "clearTextEnabled";
+declare const runStartedAt = "runStartedAt";
+declare const reporterPluginModules = "reporterPluginModules";
+declare const loggingServer = "loggingServer";
+declare const mutationTestReportHelper = "mutationTestReportHelper";
+declare const sandbox = "sandbox";
+declare const concurrencyTokenProvider = "concurrencyTokenProvider";
+declare const testRunnerFactory = "testRunnerFactory";
+declare const testRunnerPool = "testRunnerPool";
+declare const testRunnerConcurrencyTokens = "testRunnerConcurrencyTokens";
+declare const reporter = "reporter";
+declare const reporterOverride = "reporterOverride";
+declare const pluginCreator = "pluginCreator";
+declare const pluginsByKind = "pluginsByKind";
+declare const validationSchema = "validationSchema";
+declare const optionsValidator = "optionsValidator";
+declare const requireFromCwd = "requireFromCwd";
+declare const resolveFromCwd = "resolveFromCwd";
+declare const fs = "fs";
+declare const testCoverage = "testCoverage";
+declare const incrementalDiffer = "incrementalDiffer";
+declare const project = "project";
+declare const workerIdGenerator = "worker-id-generator";
+//#endregion
+//#region src/plugins/plugin-creator.d.ts
+declare class PluginCreator {
+  private readonly pluginsByKind;
+  private readonly injector;
+  static readonly inject: ["pluginsByKind", "$injector"];
+  constructor(pluginsByKind: Map<PluginKind, Plugin<PluginKind>[]>, injector: Injector<PluginContext>);
+  create<TPlugin extends keyof Plugins>(kind: TPlugin, name: string): PluginInterfaces[TPlugin];
+  private findPlugin;
+}
+//#endregion
+//#region src/plugins/plugin-loader.d.ts
+/**
+ * Represents a collection of loaded plugins and metadata
+ */
+interface LoadedPlugins {
+  /**
+   * The JSON schema contributions loaded
+   */
+  schemaContributions: Record<string, unknown>[];
+  /**
+   * The actual Stryker plugins loaded, sorted by type
+   */
+  pluginsByKind: Map<PluginKind, Plugin<PluginKind>[]>;
+  /**
+   * The import specifiers or full URL paths to the actual plugins
+   */
+  pluginModulePaths: string[];
+}
+/**
+ * Can resolve modules and pull them into memory
+ */
+declare class PluginLoader {
+  private readonly log;
+  static inject: ["logger"];
+  constructor(log: Logger);
+  /**
+   * Loads plugins based on configured plugin descriptors.
+   * A plugin descriptor can be:
+   *  * A full url: "file:///home/nicojs/github/my-plugin.js"
+   *  * An absolute file path: "/home/nicojs/github/my-plugin.js"
+   *  * A relative path: "./my-plugin.js"
+   *  * A bare import expression: "@stryker-mutator/karma-runner"
+   *  * A simple glob expression (only wild cards are supported): "@stryker-mutator/*"
+   */
+  load(pluginDescriptors: readonly string[]): Promise<LoadedPlugins>;
+  private resolvePluginModules;
+  private globPluginModules;
+  private loadPlugin;
+}
+//#endregion
+export { injection_tokens_d_exports as a, progressEnabled as c, resolvedMode as d, runEventSink as f, clearTextEnabled as i, reporterOverride as l, runStartedAt as m, PluginLoader as n, loggingServerAddress as o, runId as p, PluginCreator as r, loggingSink as s, LoadedPlugins as t, reporterPluginModules as u };