@systemfsoftware/stryker-js-mutation-run 1.2.5

package/dist/plugins-Nx86IJQW.mjs

@@ -0,0 +1,1618 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { ConfigError } from "./errors.mjs";
+import { Timer } from "./timer.mjs";
+import { n as REMOVED_OPTIONS } from "./fork-schema-BHuTbRBR.mjs";
+import { INSTRUMENTER_CONSTANTS, StrykerOptionsSchema } from "@systemfsoftware/stryker-js-plugin-api/core";
+import { commonTokens, tokens } from "@systemfsoftware/stryker-js-plugin-api/plugin";
+import "typed-inject";
+import { ERROR_CODES, StrykerError, deepFreeze, deepMerge, errorToString, findUnserializables, isErrnoException, normalizeFileName, normalizeWhitespaces, notEmpty, propertyPath, testFilesProvided } from "@stryker-mutator/util";
+import fs from "fs";
+import { isDeepStrictEqual } from "util";
+import path from "path";
+import { URL, fileURLToPath, pathToFileURL } from "url";
+import { Match, Schema } from "effect";
+import "@systemfsoftware/stryker-js-plugin-api/logging";
+import { createRequire } from "module";
+import os from "os";
+import { Minimatch, minimatch } from "minimatch";
+import * as Result$1 from "effect/Result";
+import * as S from "effect/Schema";
+import { Subject, mergeMap } from "rxjs";
+import "@stryker-mutator/instrumenter";
+import "mutation-testing-report-schema";
+import * as Match$1 from "effect/Match";
+import { exec } from "child_process";
+import { DryRunStatus, TestStatus, toMutantRunResult } from "@systemfsoftware/stryker-js-plugin-api/test-runner";
+import treeKill from "tree-kill";
+//#region src/plugins/injection-tokens.ts
+var injection_tokens_exports = /* @__PURE__ */ __exportAll({
+	checkerConcurrencyTokens: () => checkerConcurrencyTokens,
+	checkerFactory: () => checkerFactory,
+	checkerPool: () => checkerPool,
+	clearTextEnabled: () => clearTextEnabled,
+	concurrencyTokenProvider: () => concurrencyTokenProvider,
+	disableTypeChecksHelper: () => disableTypeChecksHelper,
+	dryRunResult: () => dryRunResult,
+	execa: () => execa,
+	execaSync: () => execaSync,
+	fs: () => "fs",
+	incrementalDiffer: () => incrementalDiffer,
+	loggerActiveLevel: () => loggerActiveLevel,
+	loggerConsoleOut: () => loggerConsoleOut,
+	loggerShowColors: () => loggerShowColors,
+	loggingServer: () => loggingServer,
+	loggingServerAddress: () => loggingServerAddress,
+	loggingSink: () => loggingSink,
+	mutantTestPlanner: () => mutantTestPlanner,
+	mutants: () => mutants,
+	mutationTestReportHelper: () => mutationTestReportHelper,
+	optionsValidator: () => optionsValidator,
+	pluginCreator: () => pluginCreator,
+	pluginModulePaths: () => pluginModulePaths,
+	pluginsByKind: () => pluginsByKind,
+	process: () => process$1,
+	progressEnabled: () => progressEnabled,
+	project: () => project,
+	reporter: () => reporter,
+	reporterOverride: () => reporterOverride,
+	reporterPluginModules: () => reporterPluginModules,
+	requireFromCwd: () => requireFromCwd,
+	resolveFromCwd: () => resolveFromCwd,
+	resolvedMode: () => resolvedMode,
+	runEventSink: () => runEventSink,
+	runId: () => runId,
+	runStartedAt: () => runStartedAt,
+	sandbox: () => sandbox,
+	temporaryDirectory: () => temporaryDirectory,
+	testCoverage: () => testCoverage,
+	testRunnerConcurrencyTokens: () => testRunnerConcurrencyTokens,
+	testRunnerFactory: () => testRunnerFactory,
+	testRunnerPool: () => testRunnerPool,
+	timeOverheadMS: () => timeOverheadMS,
+	timer: () => timer,
+	unexpectedExitRegistry: () => unexpectedExitRegistry,
+	validationSchema: () => validationSchema,
+	workerIdGenerator: () => workerIdGenerator
+});
+const checkerPool = "checkerPool";
+const checkerFactory = "checkerFactory";
+const checkerConcurrencyTokens = "checkerConcurrencyTokens";
+const disableTypeChecksHelper = "disableTypeChecksHelper";
+const execa = "execa";
+const execaSync = "execaSync";
+const dryRunResult = "dryRunResult";
+const mutants = "mutants";
+const mutantTestPlanner = "mutantTestPlanner";
+const process$1 = "process";
+const pluginModulePaths = "pluginModulePaths";
+const temporaryDirectory = "temporaryDirectory";
+const unexpectedExitRegistry = "unexpectedExitRegistry";
+const timer = "timer";
+const timeOverheadMS = "timeOverheadMS";
+const loggingServerAddress = "loggingServerAddress";
+const loggerActiveLevel = "loggerActiveLevel";
+const loggerConsoleOut = "loggerConsoleOut";
+const loggerShowColors = "loggerShowColors";
+const loggingSink = "loggingSink";
+const runEventSink = "runEventSink";
+const runId = "runId";
+const resolvedMode = "resolvedMode";
+const progressEnabled = "progressEnabled";
+const clearTextEnabled = "clearTextEnabled";
+const runStartedAt = "runStartedAt";
+const reporterPluginModules = "reporterPluginModules";
+const loggingServer = "loggingServer";
+const mutationTestReportHelper = "mutationTestReportHelper";
+const sandbox = "sandbox";
+const concurrencyTokenProvider = "concurrencyTokenProvider";
+const testRunnerFactory = "testRunnerFactory";
+const testRunnerPool = "testRunnerPool";
+const testRunnerConcurrencyTokens = "testRunnerConcurrencyTokens";
+const reporter = "reporter";
+const reporterOverride = "reporterOverride";
+const pluginCreator = "pluginCreator";
+const pluginsByKind = "pluginsByKind";
+const validationSchema = "validationSchema";
+const optionsValidator = "optionsValidator";
+const requireFromCwd = "requireFromCwd";
+const resolveFromCwd = "resolveFromCwd";
+const testCoverage = "testCoverage";
+const incrementalDiffer = "incrementalDiffer";
+const project = "project";
+const workerIdGenerator = "worker-id-generator";
+//#endregion
+//#region src/plugins/plugin-creator.ts
+var PluginCreator = class {
+	pluginsByKind;
+	injector;
+	static inject = tokens(pluginsByKind, commonTokens.injector);
+	constructor(pluginsByKind, injector) {
+		this.pluginsByKind = pluginsByKind;
+		this.injector = injector;
+	}
+	create(kind, name) {
+		const plugin = this.findPlugin(kind, name);
+		if (isFactoryPlugin(plugin)) return this.injector.injectFunction(plugin.factory);
+		else if (isClassPlugin(plugin)) return this.injector.injectClass(plugin.injectableClass);
+		else if (isValuePlugin(plugin)) return plugin.value;
+		throw new Error(`Plugin "${kind}:${name}" could not be created, missing "factory", "injectableClass" or "value" property.`);
+	}
+	findPlugin(kind, name) {
+		const plugins = this.pluginsByKind.get(kind);
+		if (plugins) {
+			const pluginFound = plugins.find((plugin) => plugin.name.toLowerCase() === name.toLowerCase());
+			if (pluginFound && isPluginOfKind(pluginFound, kind)) return pluginFound;
+			else throw new ConfigError(`Cannot find ${kind} plugin "${name}". Did you forget to install it? Loaded ${kind} plugins were: ${new Intl.ListFormat("en").format(plugins.map((p) => `"${p.name}"`))}`);
+		} else throw new ConfigError(`Cannot find ${kind} plugin "${name}". In fact, no ${kind} plugins were loaded. Did you forget to install it?`);
+	}
+};
+function isPluginOfKind(plugin, kind) {
+	return plugin.kind === kind;
+}
+function isFactoryPlugin(plugin) {
+	return "factory" in plugin;
+}
+function isClassPlugin(plugin) {
+	return "injectableClass" in plugin;
+}
+function isValuePlugin(plugin) {
+	return "value" in plugin;
+}
+//#endregion
+//#region src/config/module-loader.ts
+/**
+* Wrapper around the 'import' expression (for testability)
+* Resolves bare specifiers relative to cwd so plugins in the
+* consumer's node_modules can be found even when the importing
+* module lives at a different path in the monorepo.
+*/
+function importModule(moduleName) {
+	if (moduleName.startsWith(".") || moduleName.startsWith("/") || moduleName.startsWith("file://")) return import(moduleName);
+	return import(createRequire(process.cwd() + "/noop.js").resolve(moduleName));
+}
+//#endregion
+//#region src/project/file-system.ts
+const MAX_CONCURRENT_FILE_IO = 256;
+/**
+* A wrapper around nodejs's 'fs' core module, for dependency injection purposes.
+*
+* Also has build-in buffering support with a concurrency limit (like "graceful-fs").
+*/
+var FileSystem = class {
+	/**
+	* The buffered work queue: each pending call is a zero-argument thunk that
+	* performs the real `fs.promises` call. `mergeMap` with the concurrency
+	* limit is the "graceful-fs" hat.
+	*/
+	todoSubject = new Subject();
+	subscription = this.todoSubject.pipe(mergeMap(async (work) => {
+		await work();
+	}, MAX_CONCURRENT_FILE_IO)).subscribe();
+	dispose() {
+		this.subscription.unsubscribe();
+	}
+	readFile(path, options) {
+		return this.queue(() => fs.promises.readFile(path, options));
+	}
+	copyFile(src, dest, mode) {
+		return this.queue(() => fs.promises.copyFile(src, dest, mode));
+	}
+	writeFile(path, data, options) {
+		return this.queue(() => fs.promises.writeFile(path, data, options));
+	}
+	mkdir(path, options) {
+		return this.queue(() => fs.promises.mkdir(path, options));
+	}
+	readdir(path, options) {
+		return this.queue(() => fs.promises.readdir(path, options));
+	}
+	/** Buffer one fs call behind the concurrency limit and await its outcome. */
+	queue(work) {
+		return new Promise((resolve, reject) => {
+			this.todoSubject.next(async () => {
+				try {
+					resolve(await work());
+				} catch (err) {
+					reject(err);
+				}
+			});
+		});
+	}
+};
+//#endregion
+//#region src/project/project-file.ts
+/**
+* Represents a file inside the project under test.
+* Has utility methods to help with copying it to the sandbox, or backing it up (when `--inPlace` is active)
+*
+* Assumes utf-8 as encoding when reading/writing content.
+*/
+var ProjectFile = class {
+	fs;
+	name;
+	mutate;
+	#currentContent;
+	#originalContent;
+	#relativePath;
+	constructor(fs, name, mutate) {
+		this.fs = fs;
+		this.name = name;
+		this.mutate = mutate;
+		this.#relativePath = path.relative(process.cwd(), this.name);
+	}
+	async #writeTo(to) {
+		if (this.#currentContent === void 0) await this.fs.copyFile(this.name, to);
+		else await this.fs.writeFile(to, this.#currentContent, "utf-8");
+	}
+	setContent(content) {
+		this.#currentContent = content;
+	}
+	async toInstrumenterFile() {
+		return {
+			content: await this.readContent(),
+			mutate: this.mutate,
+			name: this.name
+		};
+	}
+	async readContent() {
+		if (this.#currentContent === void 0) this.#currentContent = await this.readOriginal();
+		return this.#currentContent;
+	}
+	async readOriginal() {
+		if (this.#originalContent === void 0) {
+			try {
+				this.#originalContent = await this.fs.readFile(this.name, "utf-8");
+			} catch (e) {
+				throw new StrykerError(`Could not read file "${this.name}"`, e);
+			}
+			if (this.#currentContent === void 0) this.#currentContent = this.#originalContent;
+		}
+		return this.#originalContent;
+	}
+	async writeInPlace() {
+		if (this.#currentContent !== void 0 && this.hasChanges) await this.fs.writeFile(this.name, this.#currentContent, "utf-8");
+	}
+	async writeToSandbox(sandboxDir) {
+		const folderName = path.join(sandboxDir, path.dirname(this.#relativePath));
+		const targetFileName = path.join(folderName, path.basename(this.#relativePath));
+		await this.fs.mkdir(path.dirname(targetFileName), { recursive: true });
+		await this.#writeTo(targetFileName);
+		return targetFileName;
+	}
+	async backupTo(backupDir) {
+		const backupFileName = path.join(backupDir, this.#relativePath);
+		await this.fs.mkdir(path.dirname(backupFileName), { recursive: true });
+		if (this.#originalContent === void 0) await this.fs.copyFile(this.name, backupFileName);
+		else await this.fs.writeFile(backupFileName, this.#originalContent);
+		return backupFileName;
+	}
+	get hasChanges() {
+		return this.#currentContent !== this.#originalContent;
+	}
+};
+//#endregion
+//#region src/config/config-file-formats.ts
+const combine = (prefixes, suffixes, extensions) => {
+	const fileNames = [];
+	for (const prefix of prefixes) for (const suffix of suffixes) for (const extension of extensions) fileNames.push(`${prefix}stryker${suffix}.${extension}`);
+	return fileNames;
+};
+const SUPPORTED_CONFIG_FILE_NAMES = Object.freeze(combine(["", "."], [".conf", ".config"], [
+	"json",
+	"js",
+	"mjs",
+	"cjs"
+]));
+Object.freeze({
+	JSON: "stryker.config.json",
+	JAVASCRIPT: "stryker.config.mjs"
+});
+//#endregion
+//#region src/config/config-document.schema.ts
+/**
+* A Stryker config document read from disk or imported from a JS module: any
+* object record. Individual option keys and value shapes are enforced later
+* by the options validator against the derived JSON schema, so this boundary
+* decode only establishes that the document is an object — never a
+* hand-written `isRecord` narrowing.
+*/
+const ConfigDocumentSchema = S.Record(S.String, S.Unknown);
+/**
+* The shape of an imported JS config module as seen through the dynamic
+* `import()` boundary: a module namespace whose `default` export is the
+* config document. Only the default export is read here.
+*/
+const ImportedModuleSchema = S.Struct({ default: S.optional(S.Unknown) });
+//#endregion
+//#region src/config/extends-step.ts
+const initialExtendsStepState = {
+	visited: [],
+	documents: []
+};
+/**
+* Merge a child config over a parent's resolved options.
+* R2: scalars replace wholesale; objects merge one level deep.
+* R3: a child key set to `null` deletes the inherited key.
+* R4: the `plugins` array is the one exception to wholesale array replacement —
+* the parent's plugin loaders stay inherited and the child's descriptors are
+* appended, with the first occurrence of a descriptor winning.
+*
+* A copy of the precedence logic in `resolve-extends.ts`, moved here with the
+* original staying put. Where the original re-decoded each object through
+* `ConfigDocumentSchema`, this copy spreads the validated objects directly:
+* they already passed that schema at the read boundary, so the re-decode was
+* dead weight and its throw site does not move into this module.
+*/
+function mergeConfigs(parent, child) {
+	const out = { ...parent };
+	for (const [key, value] of Object.entries(child)) {
+		if (value === null) {
+			delete out[key];
+			continue;
+		}
+		const parentValue = parent[key];
+		if (key === "plugins") {
+			const parentPlugins = Array.isArray(parentValue) ? parentValue : [];
+			const childPlugins = Array.isArray(value) ? value : [];
+			const merged = [...parentPlugins, ...childPlugins];
+			out[key] = merged.filter((descriptor, index) => typeof descriptor !== "string" || !merged.slice(0, index).includes(descriptor));
+			continue;
+		}
+		out[key] = parentValue !== null && parentValue !== void 0 && typeof parentValue === "object" && !Array.isArray(parentValue) && typeof value === "object" && !Array.isArray(value) ? {
+			...parentValue,
+			...value
+		} : value;
+	}
+	return out;
+}
+/**
+* A bare package specifier (`pkg`, `@scope/pkg`, `@scope/pkg/sub`) versus a
+* filesystem path. Everything not starting with `./`, `../`, `/` or `\` is
+* treated as a specifier and routed through the Node resolver, so it honours
+* `package.json#exports` the way `@systemfsoftware/tsconfig` does for
+* `tsconfig.json`.
+*/
+function isModuleSpecifier(value) {
+	return !(value.startsWith("./") || value.startsWith("../") || value.startsWith("/") || value.startsWith("\\"));
+}
+const stripExtends = (document) => {
+	const { extends: _ignored, ...rest } = document;
+	return rest;
+};
+/**
+* Fold the accumulated chain bottom-up, exactly the order `resolveExtendsChain`
+* merged in: the root document first, its child over it, and so on up to the
+* document this step was asked to decide.
+*/
+const mergeChainDocuments = (documents) => documents.reduceRight((merged, entry) => mergeConfigs(merged, stripExtends(entry.options)), {});
+/**
+* Decide the next act in an `extends` chain. Receives the accumulated state
+* plus the last document read and the absolute path it was read from, and
+* returns exactly one of:
+*
+* - `done` — no further parent: the whole chain is merged and carried.
+* - `resolve` — a bare specifier the shell must resolve from `directory`.
+* - `read` — a relative path, already resolved against the declaring
+*   document's directory (never the process working directory).
+* - `refused` — a cycle (the path is already visited) or an `extends` that is
+*   not a string, naming the offending file.
+*
+* The request performs no read and no resolution; it is data the shell
+* performs and feeds back.
+*/
+const decideExtendsStep = (state, document, file) => {
+	if (state.visited.includes(file)) return {
+		_tag: "refused",
+		reason: "cycle",
+		file
+	};
+	const nextState = {
+		visited: [...state.visited, file],
+		documents: [...state.documents, {
+			path: file,
+			options: document
+		}]
+	};
+	return Match$1.value(document["extends"]).pipe(Match$1.when(void 0, () => ({
+		_tag: "done",
+		options: mergeChainDocuments(nextState.documents)
+	})), Match$1.when(null, () => ({
+		_tag: "done",
+		options: mergeChainDocuments(nextState.documents)
+	})), Match$1.when(Match$1.string, (extendValue) => Match$1.value(isModuleSpecifier(extendValue)).pipe(Match$1.when(true, () => ({
+		_tag: "resolve",
+		specifier: extendValue,
+		directory: path.dirname(file),
+		state: nextState
+	})), Match$1.when(false, () => ({
+		_tag: "read",
+		path: path.resolve(path.dirname(file), extendValue),
+		state: nextState
+	})), Match$1.exhaustive)), Match$1.orElse(() => ({
+		_tag: "refused",
+		reason: "non-string-extends",
+		file
+	})));
+};
+//#endregion
+//#region src/config/resolve-extends.ts
+async function readConfigFile(configFile) {
+	if (path.extname(configFile).toLowerCase() === ".json") {
+		let fileContent;
+		try {
+			fileContent = await fs.promises.readFile(configFile, "utf-8");
+		} catch (err) {
+			throw new ConfigError(`Cannot read config file "${configFile}"`, err);
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(fileContent);
+		} catch (err) {
+			throw new ConfigError(`Invalid config file "${configFile}". File contains invalid JSON`, err);
+		}
+		if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) throw new ConfigError(`Invalid config file "${configFile}". Config must be a JSON object`);
+		return S.decodeUnknownSync(ConfigDocumentSchema)(parsed);
+	}
+	let importedModule;
+	try {
+		importedModule = await import(pathToFileURL(path.resolve(configFile)).toString());
+	} catch (err) {
+		throw new ConfigError(`Invalid config file "${configFile}". Error during import`, err);
+	}
+	const exported = S.decodeUnknownSync(ImportedModuleSchema)(importedModule).default;
+	if (exported === void 0 || exported === null || typeof exported !== "object") throw new ConfigError(`Invalid config file "${configFile}". Default export of config file must be an object!`);
+	return S.decodeUnknownSync(ConfigDocumentSchema)(exported);
+}
+/**
+* The resolve act, split out of the deleted `resolveExtendsTarget`. Its
+* relative-path branch became the decision's `read` request; only this branch
+* survives, converting a bare specifier to an absolute path through node's
+* require resolver from the declaring config's directory — never the process
+* working directory (R10). The error message is the pre-split one, verbatim.
+*/
+function resolveExtendsSpecifier(specifier, configDir) {
+	const requireFrom = createRequire(path.join(configDir, "noop.js"));
+	try {
+		return requireFrom.resolve(specifier);
+	} catch (err) {
+		throw new ConfigError(`Cannot resolve extends target "${specifier}" from "${configDir}"`, err);
+	}
+}
+/**
+* Interpret the `extends` decision at the shell boundary (R9, KTD2).
+*
+* Drives `decideExtendsStep` in a plain async loop. The entry document is
+* already read by the caller; each returned request names the act the shell
+* performs — read this absolute path, or resolve this specifier from the
+* declaring directory — and the document the act yields is fed back together
+* with the state the request carried. The shell holds no decision of its own:
+* it only dispatches on the request it received and maps a refusal to the
+* `ConfigError` the pre-split chain surfaced, byte for byte.
+*/
+async function resolveExtends(configFile, document) {
+	const absolute = path.resolve(configFile);
+	let state = initialExtendsStepState;
+	let file = absolute;
+	let currentDocument = document;
+	for (;;) {
+		const outcome = await Match.value(decideExtendsStep(state, currentDocument, file)).pipe(Match.tag("done", (value) => ({
+			kind: "done",
+			options: value.options
+		})), Match.tag("read", (value) => readConfigFile(value.path).then((nextDocument) => ({
+			kind: "next",
+			state: value.state,
+			file: value.path,
+			document: nextDocument
+		}))), Match.tag("resolve", (value) => {
+			let resolvedPath;
+			try {
+				resolvedPath = resolveExtendsSpecifier(value.specifier, value.directory);
+			} catch (err) {
+				if (err instanceof ConfigError) throw err;
+				const reason = err instanceof Error ? `. ${err.message}` : "";
+				throw new ConfigError(`Cannot resolve extends target "${value.specifier}" from "${file}"${reason}`, err);
+			}
+			return readConfigFile(resolvedPath).then((nextDocument) => ({
+				kind: "next",
+				state: value.state,
+				file: resolvedPath,
+				document: nextDocument
+			}));
+		}), Match.tag("refused", (value) => {
+			const message = value.reason === "cycle" ? `Config inheritance cycle detected at "${value.file}"` : `Invalid config file "${value.file}". "extends" must be a string`;
+			throw new ConfigError(message);
+		}), Match.exhaustive);
+		if (outcome.kind === "done") return outcome.options;
+		state = outcome.state;
+		file = outcome.file;
+		currentDocument = outcome.document;
+	}
+}
+//#endregion
+//#region src/config/config-reader.ts
+const CONFIG_SYNTAX_HELP = `
+Example of how a config file should look:
+/**
+  * @type {import('@systemfsoftware/stryker-js-plugin-api/core').StrykerOptions}
+  */
+export default {
+  // You're options here!
+}
+
+Or using commonjs:
+/**
+  * @type {import('@systemfsoftware/stryker-js-plugin-api/core').StrykerOptions}
+  */
+module.exports = {
+  // You're options here!
+}
+
+See https://stryker-mutator.io/docs/stryker-js/config-file for more information.`.trim();
+async function exists(fileName) {
+	try {
+		await fs.promises.access(fileName);
+		return true;
+	} catch (err) {
+		if (isErrnoException(err) && err.code === "ENOENT") return false;
+		else throw err;
+	}
+}
+var ConfigReader = class {
+	log;
+	validator;
+	static inject = tokens(commonTokens.logger, optionsValidator);
+	constructor(log, validator) {
+		this.log = log;
+		this.validator = validator;
+	}
+	async readConfig(cliOptions) {
+		const options = await this.loadOptionsFromConfigFile(cliOptions);
+		deepMerge(options, cliOptions);
+		this.validator.validate(options);
+		if (this.log.isDebugEnabled()) this.log.debug(`Loaded config: ${JSON.stringify(options, null, 2)}`);
+		return options;
+	}
+	async loadOptionsFromConfigFile(cliOptions) {
+		const configFile = await this.findConfigFile(cliOptions["configFile"]);
+		if (!configFile) {
+			this.log.info("No config file specified. Running with command line arguments.");
+			this.log.info("Use `stryker init` command to generate your config file.");
+			return {};
+		}
+		this.log.debug(`Loading config from ${configFile}`);
+		const child = path.extname(configFile).toLocaleLowerCase() === ".json" ? await this.readJsonConfig(configFile) : await this.importJSConfig(configFile);
+		if (!("extends" in child)) return child;
+		return resolveExtends(configFile, child);
+	}
+	async findConfigFile(configFileName) {
+		if (typeof configFileName === "string") {
+			if (await exists(configFileName)) return configFileName;
+			else throw new ConfigReaderError("File does not exist!", configFileName);
+		}
+		for (const fileName of SUPPORTED_CONFIG_FILE_NAMES) if (await exists(fileName)) return fileName;
+	}
+	async readJsonConfig(configFile) {
+		const fileContent = await fs.promises.readFile(configFile, "utf-8");
+		try {
+			const parsed = JSON.parse(fileContent);
+			return S.decodeUnknownSync(S.Record(S.String, S.Unknown))(parsed);
+		} catch (err) {
+			throw new ConfigReaderError("File contains invalid JSON", configFile, err);
+		}
+	}
+	async importJSConfig(configFile) {
+		const importedModule = await this.importJSConfigModule(configFile);
+		if (this.hasDefaultExport(importedModule)) {
+			const maybeOptions = importedModule.default;
+			if (typeof maybeOptions !== "object") {
+				if (typeof maybeOptions === "function") this.log.fatal(`Invalid config file. Exporting a function is no longer supported. Please export an object with your configuration instead, or use a "stryker.conf.json" file.\n${CONFIG_SYNTAX_HELP}`);
+				else this.log.fatal(`Invalid config file. It must export an object, found a "${typeof maybeOptions}"!\n${CONFIG_SYNTAX_HELP}`);
+				throw new ConfigReaderError("Default export of config file must be an object!", configFile);
+			}
+			if (!maybeOptions || !Object.keys(maybeOptions).length) this.log.warn(`Stryker options were empty. Did you forget to export options from ${configFile}?`);
+			return { ...maybeOptions };
+		} else {
+			this.log.fatal(`Invalid config file. It is missing a default export. ${describeNamedExports()}\n${CONFIG_SYNTAX_HELP}`);
+			throw new ConfigReaderError("Config file must have a default export!", configFile);
+			function describeNamedExports() {
+				const namedExports = typeof importedModule === "object" && Object.keys(importedModule ?? {}) || [];
+				if (namedExports.length === 0) return "In fact, it didn't export anything.";
+				else return `Found named export(s): ${new Intl.ListFormat("en").format(namedExports.map((name) => `"${name}"`))}.`;
+			}
+		}
+	}
+	async importJSConfigModule(configFile) {
+		try {
+			return await importModule(pathToFileURL(path.resolve(configFile)).toString());
+		} catch (err) {
+			throw new ConfigReaderError("Error during import", configFile, err);
+		}
+	}
+	hasDefaultExport(importedModule) {
+		return importedModule && typeof importedModule === "object" && "default" in importedModule ? true : false;
+	}
+};
+var ConfigReaderError = class extends ConfigError {
+	constructor(message, configFileName, cause) {
+		super(`Invalid config file "${configFileName}". ${message}`, cause);
+	}
+};
+//#endregion
+//#region src/config/file-matcher.ts
+/**
+* A helper class for matching files using the `disableTypeChecks` setting.
+*/
+var FileMatcher = class {
+	allowHiddenFiles;
+	pattern;
+	constructor(pattern, allowHiddenFiles = true) {
+		this.allowHiddenFiles = allowHiddenFiles;
+		if (typeof pattern === "string") this.pattern = normalizeFileName(path.resolve(pattern));
+		else if (pattern) this.pattern = "**/*.{js,ts,jsx,tsx,html,vue,mjs,mts,cts,cjs}";
+		else this.pattern = pattern;
+	}
+	matches(fileName) {
+		if (typeof this.pattern === "string") return minimatch(normalizeFileName(path.resolve(fileName)), this.pattern, { dot: this.allowHiddenFiles });
+		else return this.pattern;
+	}
+};
+//#endregion
+//#region src/config/meta-schema-builder.ts
+var MetaSchemaBuilder = class {
+	schema;
+	log;
+	static inject = tokens(validationSchema, commonTokens.logger);
+	constructor(schema, log) {
+		this.schema = schema;
+		this.log = log;
+	}
+	buildMetaSchema(pluginSchemaContributions) {
+		this.log.debug("Contributing %s schemas from plugins to options validation.", pluginSchemaContributions.length);
+		return mergedSchema(this.schema, pluginSchemaContributions);
+	}
+};
+function mergedSchema(mainSchema, additionalSchemas) {
+	const schema = {
+		...mainSchema,
+		properties: { ...mainSchema.properties },
+		definitions: { ...mainSchema.definitions }
+	};
+	Object.assign(schema.properties, ...additionalSchemas.map((s) => s.properties));
+	Object.assign(schema.definitions, ...additionalSchemas.map((s) => s.definitions));
+	return schema;
+}
+//#endregion
+//#region src/project/incremental-report.schema.ts
+const PositionSchema = S.Struct({
+	line: S.Finite,
+	column: S.Finite
+});
+const LocationSchema = S.Struct({
+	start: PositionSchema,
+	end: PositionSchema
+});
+const OpenEndLocationSchema = S.Struct({
+	start: PositionSchema,
+	end: S.optionalKey(PositionSchema)
+});
+/** A report mutant: the full named surface of `MutantResult`. */
+const MutantResultLikeSchema = S.Struct({
+	id: S.String,
+	mutatorName: S.String,
+	replacement: S.String,
+	location: LocationSchema,
+	status: S.Literals([
+		"Killed",
+		"Survived",
+		"NoCoverage",
+		"Timeout",
+		"CompileError",
+		"RuntimeError",
+		"Ignored",
+		"Pending"
+	]),
+	killedBy: S.optionalKey(S.mutable(S.Array(S.String))),
+	coveredBy: S.optionalKey(S.mutable(S.Array(S.String))),
+	static: S.optionalKey(S.Boolean),
+	statusReason: S.optionalKey(S.String),
+	testsCompleted: S.optionalKey(S.Finite),
+	description: S.optionalKey(S.String),
+	duration: S.optionalKey(S.Finite)
+});
+/** A report file entry. */
+const FileResultLikeSchema = S.Struct({
+	language: S.String,
+	source: S.String,
+	mutants: S.mutable(S.Array(MutantResultLikeSchema))
+});
+/** A report test entry. */
+const TestDefinitionLikeSchema = S.Struct({
+	id: S.String,
+	name: S.String,
+	location: S.optionalKey(OpenEndLocationSchema)
+});
+/** A report test file. */
+const TestFileLikeSchema = S.Struct({
+	source: S.optionalKey(S.String),
+	tests: S.mutable(S.Array(TestDefinitionLikeSchema))
+});
+const ThresholdsLikeSchema = S.Struct({
+	high: S.Finite,
+	low: S.Finite
+});
+/**
+* The prior-report document the incremental differ reuses. An open struct:
+* every key the reader does not reshape is preserved verbatim. The report is
+* data from disk, so it is decoded through this schema rather than trusted.
+* `schemaVersion` and `thresholds` are declared — not just passed through the
+* open rest — because the reshaped document is returned as a
+* `MutationTestResult`, whose type names them.
+*/
+const IncrementalReportSchema = S.StructWithRest(S.Struct({
+	schemaVersion: S.String,
+	thresholds: ThresholdsLikeSchema,
+	files: S.Record(S.String, FileResultLikeSchema),
+	testFiles: S.optionalKey(S.Record(S.String, TestFileLikeSchema))
+}), [S.Record(S.String, S.Unknown)]);
+//#endregion
+//#region src/project/project.ts
+/**
+* Represents the project that is under test by Stryker users.
+* This represents the files in the current working directory.
+* Each file can be read into memory when needed (via `readContent`)
+*/
+var Project = class {
+	fileDescriptions;
+	incrementalReport;
+	files = /* @__PURE__ */ new Map();
+	filesToMutate = /* @__PURE__ */ new Map();
+	testFiles;
+	constructor(fs, fileDescriptions, incrementalReport, testFiles = []) {
+		this.fileDescriptions = fileDescriptions;
+		this.incrementalReport = incrementalReport;
+		this.testFiles = testFiles;
+		Object.entries(fileDescriptions).forEach(([name, desc]) => {
+			const file = new ProjectFile(fs, name, desc.mutate);
+			this.files.set(name, file);
+			if (desc.mutate) this.filesToMutate.set(name, file);
+		});
+	}
+	get isEmpty() {
+		return this.files.size === 0;
+	}
+	logFiles(log, ignoreRules, force, mutatePatterns, testFilePatterns = []) {
+		if (this.isEmpty) log.warn(normalizeWhitespaces(`No files found in directory ${process.cwd()} using ignore rules: ${JSON.stringify(ignoreRules)}. 
+      Make sure you run Stryker from the root directory of your project with the correct "${propertyPath()("ignorePatterns")}".`));
+		else {
+			if (this.filesToMutate.size) {
+				const incrementalInfo = this.incrementalReport ? ` using incremental report with ${Object.values(this.incrementalReport.files).reduce((total, { mutants }) => total + mutants.length, 0)} mutant(s), and ${Object.values(this.incrementalReport.testFiles ?? {}).reduce((total, { tests }) => total + tests.length, 0)} test(s)${force ? ". Force mode is activated, all mutants will be retested" : ""}` : "";
+				log.info(`Found ${this.filesToMutate.size} of ${this.files.size} file(s) to be mutated${incrementalInfo}.`);
+			} else {
+				const msg = normalizeWhitespaces(`Warning: No files found for mutation with the given glob expressions. As a result, a dry-run will be performed without actually modifying anything. 
+          If you intended to mutate files, please check and adjust the configuration.
+          Current glob pattern(s) used:
+          ${new Intl.ListFormat("en").format(mutatePatterns.map((pattern) => `"${pattern}"`))}.
+
+          To enable file mutation, consider configuring the \`${propertyPath()("mutate")}\` property in your configuration file or using the --mutate option via the command line.`);
+				log.warn(msg);
+			}
+			if (this.testFiles.length > 0) log.info(`Found ${this.testFiles.length} test file(s) matching --testFiles patterns.`);
+			if (log.isDebugEnabled()) {
+				log.debug(`All input files: ${JSON.stringify([...this.files.keys()], null, 2)}`);
+				log.debug(`Files to mutate: ${JSON.stringify([...this.filesToMutate.keys()], null, 2)}`);
+				if (this.testFiles.length > 0) log.debug(`Test files: ${JSON.stringify(this.testFiles, null, 2)}`);
+			}
+		}
+	}
+};
+//#endregion
+//#region src/project/project-reader.ts
+const ALWAYS_IGNORE = Object.freeze([
+	"node_modules",
+	".git",
+	"*.tsbuildinfo",
+	"/stryker.log",
+	".next",
+	".nuxt",
+	".svelte-kit"
+]);
+/**
+* @see https://stryker-mutator.io/docs/stryker-js/configuration/#mutate-string
+* @example
+* * "src/app.js:1-11" will mutate lines 1 through 11 inside app.js.
+* * "src/app.js:5:4-6:4" will mutate from line 5, column 4 through line 6 column 4 inside app.js (columns 4 are included).
+* * "src/app.js:5-6:4" will mutate from line 5, column 0 through line 6 column 4 inside app.js (column 4 is included).
+*/
+const MUTATION_RANGE_REGEX = /(.*?):((\d+)(?::(\d+))?-(\d+)(?::(\d+))?)$/;
+var ProjectReader = class {
+	fs;
+	log;
+	mutatePatterns;
+	testFilePatterns;
+	ignoreRules;
+	incremental;
+	force;
+	incrementalFile;
+	static inject = tokens("fs", commonTokens.logger, commonTokens.options);
+	constructor(fs, log, { mutate, tempDirName, ignorePatterns, incremental, incrementalFile, force, htmlReporter, jsonReporter, testFiles }) {
+		this.fs = fs;
+		this.log = log;
+		this.mutatePatterns = mutate;
+		this.testFilePatterns = testFiles ?? [];
+		this.ignoreRules = [
+			...ALWAYS_IGNORE,
+			tempDirName,
+			incrementalFile,
+			htmlReporter.fileName,
+			jsonReporter.fileName,
+			...ignorePatterns
+		];
+		this.incremental = incremental;
+		this.incrementalFile = incrementalFile;
+		this.force = force;
+	}
+	async read(targetMutatePatterns) {
+		const inputFileNames = await this.resolveInputFileNames();
+		const fileDescriptions = this.resolveFileDescriptions(inputFileNames, targetMutatePatterns);
+		const testFiles = this.resolveTestFiles(inputFileNames);
+		const project = new Project(this.fs, fileDescriptions, await this.readIncrementalReport(), testFiles);
+		project.logFiles(this.log, this.ignoreRules, this.force, this.mutatePatterns, this.testFilePatterns);
+		return project;
+	}
+	/**
+	* Resolves test file patterns to actual file paths.
+	* @param inputFileNames The list of all input file names to filter
+	* @returns Array of resolved test file paths
+	*/
+	resolveTestFiles(inputFileNames) {
+		if (this.testFilePatterns.length === 0) return [];
+		const resolvedTestFiles = [];
+		for (const pattern of this.testFilePatterns) {
+			const matcher = new FileMatcher(pattern, false);
+			const matchedFiles = inputFileNames.filter((fileName) => matcher.matches(fileName));
+			if (matchedFiles.length === 0) this.log.warn(`Glob pattern "${pattern}" did not match any test files.`);
+			resolvedTestFiles.push(...matchedFiles);
+		}
+		return [...new Set(resolvedTestFiles)];
+	}
+	/**
+	* Takes the list of file names and creates file description object from it, containing logic about wether or not it needs to be mutated.
+	* If a mutate pattern starts with a `!`, it negates the pattern.
+	* @param inputFileNames the file names to filter
+	* @param targetMutatePatterns optional mutate patterns to limit the initial scope of files to mutate (with ranges)
+	*/
+	resolveFileDescriptions(inputFileNames, targetMutatePatterns) {
+		const logAboutUselessPatterns = !isDeepStrictEqual(this.mutatePatterns, defaultOptions.mutate);
+		const mutateInputFileMap = /* @__PURE__ */ new Map();
+		inputFileNames.forEach((fileName) => mutateInputFileMap.set(fileName, { mutate: false }));
+		for (const pattern of this.mutatePatterns) if (pattern.startsWith("!")) {
+			const files = this.filterMutatePattern(mutateInputFileMap.keys(), pattern.substring(1));
+			if (logAboutUselessPatterns && files.size === 0) this.log.warn(`Glob pattern "${pattern}" did not exclude any files.`);
+			for (const fileName of files.keys()) mutateInputFileMap.set(fileName, { mutate: false });
+		} else {
+			const files = this.filterMutatePattern(inputFileNames, pattern);
+			if (logAboutUselessPatterns && files.size === 0) this.log.warn(`Glob pattern "${pattern}" did not result in any files.`);
+			for (const [fileName, file] of files) mutateInputFileMap.set(fileName, this.unionFileDescriptions(file, mutateInputFileMap.get(fileName)));
+		}
+		if (targetMutatePatterns) {
+			const seen = /* @__PURE__ */ new Map();
+			for (const pattern of targetMutatePatterns) {
+				const files = this.filterMutatePattern(mutateInputFileMap.keys(), pattern);
+				for (const [fileName, description] of files) {
+					const current = mutateInputFileMap.get(fileName);
+					if (current === void 0) continue;
+					const intersected = this.intersectFileDescriptions(current, description);
+					seen.set(fileName, this.unionFileDescriptions(intersected, seen.get(fileName)));
+				}
+			}
+			for (const fileName of mutateInputFileMap.keys()) {
+				const descriptionInSeen = seen.get(fileName);
+				if (descriptionInSeen) mutateInputFileMap.set(fileName, descriptionInSeen);
+				else mutateInputFileMap.set(fileName, { mutate: false });
+			}
+		}
+		return Object.fromEntries(mutateInputFileMap);
+	}
+	unionFileDescriptions(first, second) {
+		if (second) {
+			if (Array.isArray(first.mutate) && Array.isArray(second.mutate)) return { mutate: [...second.mutate, ...first.mutate] };
+			else if (second.mutate === true) return { mutate: true };
+			return { mutate: first.mutate || second.mutate };
+		}
+		return first;
+	}
+	intersectFileDescriptions(first, second) {
+		if (Array.isArray(first.mutate) && Array.isArray(second.mutate)) {
+			const secondMutate = second.mutate;
+			return { mutate: first.mutate.flatMap((firstRange) => secondMutate.map((secondRange) => {
+				const startLine = Math.max(firstRange.start.line, secondRange.start.line);
+				const endLine = Math.min(firstRange.end.line, secondRange.end.line);
+				if (startLine > endLine) return;
+				const startColumn = firstRange.start.line === startLine ? firstRange.start.column : secondRange.start.column;
+				const endColumn = firstRange.end.line === endLine ? firstRange.end.column : secondRange.end.column;
+				return {
+					start: {
+						line: startLine,
+						column: startColumn
+					},
+					end: {
+						line: endLine,
+						column: endColumn
+					}
+				};
+			})).filter(notEmpty) };
+		} else if (first.mutate === true) return second;
+		else if (second.mutate === true) return first;
+		return { mutate: false };
+	}
+	/**
+	* Filters a given list of file names given a mutate pattern.
+	* @param fileNames the file names to match to the pattern
+	* @param mutatePattern the pattern to match with
+	*/
+	filterMutatePattern(fileNames, mutatePattern) {
+		const mutationRangeMatch = MUTATION_RANGE_REGEX.exec(mutatePattern);
+		let mutate = true;
+		if (mutationRangeMatch) {
+			const [_, newPattern, _mutationRange, startLine, startColumn = "0", endLine, endColumn = Number.MAX_SAFE_INTEGER.toString()] = mutationRangeMatch;
+			mutatePattern = newPattern ?? mutatePattern;
+			mutate = [{
+				start: {
+					line: parseInt(startLine ?? "1") - 1,
+					column: parseInt(startColumn)
+				},
+				end: {
+					line: parseInt(endLine ?? "1") - 1,
+					column: parseInt(endColumn)
+				}
+			}];
+		}
+		const matcher = new FileMatcher(mutatePattern, false);
+		const inputFiles = /* @__PURE__ */ new Map();
+		for (const fileName of fileNames) if (matcher.matches(fileName)) inputFiles.set(fileName, { mutate });
+		return inputFiles;
+	}
+	async resolveInputFileNames() {
+		const ignoreRules = this.ignoreRules.map((pattern) => new Minimatch(pattern, {
+			dot: true,
+			flipNegate: true,
+			nocase: true
+		}));
+		/**
+		* Rewrite of: https://github.com/npm/ignore-walk/blob/0e4f87adccb3e16f526d2e960ed04bdc77fd6cca/index.js#L213-L215
+		*/
+		const matchesDirectoryPartially = (entryPath, rule) => {
+			return rule.match(`/${entryPath}`, true) || rule.match(entryPath, true);
+		};
+		const matchesDirectory = (entryName, entryPath, rule) => {
+			return matchesFile(entryName, entryPath, rule) || rule.match(`/${entryPath}/`) || rule.match(`${entryPath}/`) || rule.negate && matchesDirectoryPartially(entryPath, rule);
+		};
+		const matchesFile = (entryName, entryPath, rule) => {
+			return rule.match(entryName) || rule.match(entryPath) || rule.match(`/${entryPath}`);
+		};
+		const crawlDir = async (dir, rootDir = dir) => {
+			const dirEntries = await this.fs.readdir(dir, { withFileTypes: true });
+			const relativeName = path.relative(rootDir, dir);
+			return (await Promise.all(dirEntries.filter((dirEntry) => {
+				let included = true;
+				const entryPath = `${relativeName.length ? `${relativeName}/` : ""}${dirEntry.name}`;
+				ignoreRules.forEach((rule) => {
+					if (rule.negate !== included) {
+						if (dirEntry.isDirectory() ? matchesDirectory(dirEntry.name, entryPath, rule) : matchesFile(dirEntry.name, entryPath, rule)) included = rule.negate;
+					}
+				});
+				return included;
+			}).map(async (dirent) => {
+				if (dirent.isDirectory()) return crawlDir(path.resolve(rootDir, relativeName, dirent.name), rootDir);
+				else return path.resolve(rootDir, relativeName, dirent.name);
+			}))).flat();
+		};
+		return await crawlDir(process.cwd());
+	}
+	async readIncrementalReport() {
+		if (!this.incremental) return;
+		try {
+			const contents = await this.fs.readFile(this.incrementalFile, "utf-8");
+			const result = JSON.parse(contents);
+			const decoded = S.decodeUnknownSync(IncrementalReportSchema)(result);
+			return {
+				...decoded,
+				files: Object.fromEntries(Object.entries(decoded.files).map(([fileName, file]) => [fileName, {
+					...file,
+					mutants: file.mutants.map((mutant) => ({
+						...mutant,
+						location: reportLocationToStrykerLocation(mutant.location)
+					}))
+				}])),
+				...decoded.testFiles ? { testFiles: Object.fromEntries(Object.entries(decoded.testFiles).map(([fileName, file]) => [fileName, {
+					...file,
+					tests: file.tests.map((test) => ({
+						...test,
+						...test.location ? { location: reportOpenEndLocationToStrykerLocation(test.location) } : {}
+					}))
+				}])) } : {}
+			};
+		} catch (err) {
+			if (isErrnoException(err) && err.code === ERROR_CODES.NoSuchFileOrDirectory) {
+				this.log.info("No incremental result file found at %s, a full mutation testing run will be performed.", this.incrementalFile);
+				return;
+			}
+			throw err;
+		}
+	}
+};
+function reportOpenEndLocationToStrykerLocation({ start, end }) {
+	return {
+		start: reportPositionToStrykerPosition(start),
+		...end ? { end: reportPositionToStrykerPosition(end) } : {}
+	};
+}
+function reportLocationToStrykerLocation({ start, end }) {
+	return {
+		start: reportPositionToStrykerPosition(start),
+		end: reportPositionToStrykerPosition(end)
+	};
+}
+function reportPositionToStrykerPosition({ line, column }) {
+	return {
+		line: line - 1,
+		column: column - 1
+	};
+}
+//#endregion
+//#region src/worker-pool/kill.ts
+function kill(pid) {
+	const { promise, resolve, reject } = Promise.withResolvers();
+	if (pid === void 0) {
+		resolve();
+		return promise;
+	}
+	treeKill(pid, "SIGKILL", (err) => {
+		if (err && !canIgnore(err.code)) reject(err);
+		else resolve();
+	});
+	function canIgnore(code) {
+		return code === 255 || code === 128;
+	}
+	return promise;
+}
+//#endregion
+//#region src/test-runner/command-test-runner.ts
+/**
+* A test runner that uses a (bash or cmd) command to execute the tests.
+* Does not know hom many tests are executed or any code coverage results,
+* instead, it mimics a simple test result based on the exit code.
+* The command can be configured, but defaults to `npm test`.
+*/
+var CommandTestRunner = class CommandTestRunner {
+	workingDir;
+	/**
+	* "command"
+	*/
+	static runnerName = CommandTestRunner.name.replace("TestRunner", "").toLowerCase();
+	/**
+	* Determines whether a given name is "command" (ignore case)
+	* @param name Maybe "command", maybe not
+	*/
+	static is(name) {
+		return this.runnerName === name.toLowerCase();
+	}
+	settings;
+	testFilesProvided;
+	timeoutHandler;
+	constructor(workingDir, options) {
+		this.workingDir = workingDir;
+		this.settings = options.commandRunner;
+		this.testFilesProvided = testFilesProvided(options);
+	}
+	capabilities() {
+		return { reloadEnvironment: true };
+	}
+	async init() {
+		if (this.testFilesProvided) throw new Error(`The ${CommandTestRunner.runnerName} test runner does not support the --testFiles option.`);
+		return Promise.resolve();
+	}
+	async dryRun(_options) {
+		return this.run({});
+	}
+	async mutantRun({ activeMutant }) {
+		const result = await this.run({ activeMutantId: activeMutant.id });
+		return toMutantRunResult(result);
+	}
+	run({ activeMutantId }) {
+		const timerInstance = new Timer();
+		return new Promise((res, rej) => {
+			const output = [];
+			const env = activeMutantId === void 0 ? process.env : {
+				...process.env,
+				[INSTRUMENTER_CONSTANTS.ACTIVE_MUTANT_ENV_VARIABLE]: activeMutantId
+			};
+			const childProcess = exec(this.settings.command, {
+				cwd: this.workingDir,
+				env
+			});
+			if (childProcess.stdout === null || childProcess.stderr === null) throw new Error(`Expected stdout and stderr streams for "${this.settings.command}", but one of them is null.`);
+			const stdout = childProcess.stdout;
+			const stderr = childProcess.stderr;
+			childProcess.on("error", (error) => {
+				kill(childProcess.pid).then(() => handleResolve(errorResult(error))).catch(rej);
+			});
+			childProcess.on("exit", (code) => {
+				const result = completeResult(code, timerInstance);
+				handleResolve(result);
+			});
+			stdout.on("data", (chunk) => {
+				output.push(chunk);
+			});
+			stderr.on("data", (chunk) => {
+				output.push(chunk);
+			});
+			this.timeoutHandler = async () => {
+				handleResolve({ status: DryRunStatus.Timeout });
+				await kill(childProcess.pid);
+			};
+			const handleResolve = (runResult) => {
+				removeAllListeners();
+				this.timeoutHandler = void 0;
+				res(runResult);
+			};
+			function removeAllListeners() {
+				stderr.removeAllListeners();
+				stdout.removeAllListeners();
+				childProcess.removeAllListeners();
+			}
+			function errorResult(error) {
+				return {
+					errorMessage: errorToString(error),
+					status: DryRunStatus.Error
+				};
+			}
+			function completeResult(exitCode, timer) {
+				const duration = timer.elapsedMs();
+				if (exitCode === 0) return {
+					status: DryRunStatus.Complete,
+					tests: [{
+						id: "all",
+						name: "All tests",
+						status: TestStatus.Success,
+						timeSpentMs: duration
+					}]
+				};
+				else return {
+					status: DryRunStatus.Complete,
+					tests: [{
+						id: "all",
+						failureMessage: output.map((buf) => buf.toString()).join(os.EOL),
+						name: "All tests",
+						status: TestStatus.Failed,
+						timeSpentMs: duration
+					}]
+				};
+			}
+		});
+	}
+	async dispose() {
+		if (this.timeoutHandler) await this.timeoutHandler();
+	}
+};
+//#endregion
+//#region src/config/is-warning-enabled.ts
+function isWarningEnabled(warningType, warningOptions) {
+	if (typeof warningOptions === "boolean") return warningOptions;
+	else return !!warningOptions[warningType];
+}
+//#endregion
+//#region src/config/options-path.ts
+/**
+* Print the name of (or path to) a stryker option
+*/
+const optionsPath = propertyPath();
+//#endregion
+//#region src/config/validation-errors.ts
+/** `["mutator"]["name"]` — the path shape a rendered schema issue carries. */
+const PATH_LINE = /^at\s+(\[.*\])$/;
+const PATH_SEGMENT = /\["([^"]*)"\]|\[(\d+)\]/g;
+const EXPECTED_PATTERN = /^Expected a string matching the RegExp (.+)$/;
+const EXPECTED_TYPE = /^Expected (.+)$/;
+/** `["mutator"]["name"]` -> `mutator.name`; an index stays bracketed. */
+const dottedPath = (raw) => {
+	let path = "";
+	for (const [, key, index] of raw.matchAll(PATH_SEGMENT)) if (index !== void 0) path += `[${index}]`;
+	else path += path.length > 0 ? `.${key ?? ""}` : key ?? "";
+	return path;
+};
+/** The expectation, in the phrasing an operator reading the terminal already knows. */
+const phrase = (expectation) => {
+	const pattern = EXPECTED_PATTERN.exec(expectation);
+	if (pattern !== null) return `must match pattern "${pattern[1] ?? ""}"`;
+	const type = EXPECTED_TYPE.exec(expectation);
+	if (type !== null) return `should be ${type[1] ?? ""}`;
+	return expectation;
+};
+/**
+* Renders a decode failure as one message per offending option.
+*
+* This replaced roughly two hundred lines that existed to make a JSON Schema
+* engine's error objects readable: they deduplicated errors shadowing each other
+* on one path, merged the several type errors a union produced for one option,
+* and rebuilt the option's path by hand. The schema issue already carries the
+* expectation and the path, so what remains is naming the option and keeping the
+* phrasing the CLI contract pins — an operator is told which option is wrong and
+* what it must be, not how the value was decoded.
+*
+* An issue is an expectation line followed by its indented `at [...]` path. If
+* that shape ever changes, each line arrives as its own message: the phrasing
+* degrades and no information is lost.
+*/
+function describeErrors(error) {
+	const messages = [];
+	let expectation;
+	for (const raw of error.message.split("\n")) {
+		const line = raw.trim();
+		if (line.length === 0) continue;
+		const path = PATH_LINE.exec(line);
+		if (path !== null && expectation !== void 0) {
+			messages.push(`Config option "${dottedPath(path[1] ?? "")}" ${phrase(expectation)}.`);
+			expectation = void 0;
+			continue;
+		}
+		if (expectation !== void 0) messages.push(expectation);
+		expectation = line;
+	}
+	if (expectation !== void 0) messages.push(expectation);
+	return messages.length > 0 ? messages : [error.message];
+}
+//#endregion
+//#region src/config/options-validator.ts
+/**
+* Options are decoded by the schema that declares them. This replaced an ajv
+* instance run with `useDefaults`, which filled defaults from the *derived* JSON
+* Schema document and silently injected nothing wherever a `default` annotation
+* did not survive that derivation: `timeoutFactor`, `timeoutMS` and
+* `dryRunTimeoutMinutes` all arrived `undefined`, so
+* `dryRunTimeoutMinutes * 1000 * 60` was `NaN`, every dry run was given a 1 ms
+* budget, and each one reported "Initial test run timed out". Decoding through
+* the declaration cannot drift from it, and the open struct keeps the
+* plugin-contributed options a document-driven validator would have rejected.
+*
+* `errors: 'all'` keeps the previous behaviour of reporting every offending
+* option in one pass rather than stopping at the first.
+*/
+const decodeOptions = S.decodeUnknownResult(StrykerOptionsSchema, { errors: "all" });
+var OptionsValidator = class OptionsValidator {
+	schema;
+	log;
+	static inject = tokens(validationSchema, commonTokens.logger);
+	constructor(schema, log) {
+		this.schema = schema;
+		this.log = log;
+	}
+	/**
+	* Validates the provided options, throwing an error if something is wrong.
+	* Optionally also warns about excess or unserializable options.
+	* @param options The stryker options to validate
+	* @param mark Wether or not to log warnings on unknown properties or unserializable properties
+	*/
+	validate(options, mark = false) {
+		this.removeDeprecatedOptions(options);
+		this.validateRemovedSurface(options);
+		this.schemaValidate(options);
+		this.customValidation(options);
+		if (mark) this.markOptions(options);
+	}
+	/**
+	* Hard-fails on config names the rebuild removed (U2-U9): a removed
+	* top-level key (`dashboard`, `eventReporter`) or a removed reporter name
+	* inside `reporters` (`dots`, `event-recorder`, `progress-append-only`,
+	* `dashboard`). Runs ahead of `schemaValidate` because a removed key is
+	* absent from the AJV schema, so schema validation can never see it, and
+	* the warning path (`markExcessOptions`) only fires when `mark` is set and
+	* the `unknownOptions` warning is enabled — a removed key could otherwise
+	* be silently accepted. Only the known-removed names are checked; an
+	* unknown-but-not-removed key keeps its warning-only behaviour.
+	*/
+	validateRemovedSurface(rawOptions) {
+		const errors = [];
+		for (const key of Object.keys(rawOptions)) if (Object.hasOwn(REMOVED_OPTIONS, key)) errors.push(`Config option "${key}" is no longer supported. ${REMOVED_OPTIONS[key]}`);
+		const reporters = rawOptions["reporters"];
+		if (Array.isArray(reporters)) {
+			for (const name of reporters) if (typeof name === "string" && Object.hasOwn(REMOVED_OPTIONS, name)) errors.push(`Config option "reporters" contains removed reporter name "${name}". ${REMOVED_OPTIONS[name]}`);
+		}
+		errors.forEach((error) => this.log.error(error));
+		this.throwErrorIfNeeded(errors);
+	}
+	removeDeprecatedOptions(rawOptions) {
+		this.removeStringMutator(rawOptions);
+		this.removeMutatorName(rawOptions);
+		this.removeTestFramework(rawOptions);
+		this.removeTranspilers(rawOptions);
+		this.rewriteFiles(rawOptions);
+		this.removeJestEnableBail(rawOptions);
+		this.removeHtmlReporterBaseDir(rawOptions);
+		this.migrateMaxConcurrentTestRunners(rawOptions);
+	}
+	static recordOf(value) {
+		return S.decodeUnknownSync(S.Record(S.String, S.Unknown))(value);
+	}
+	removeStringMutator(rawOptions) {
+		if (typeof rawOptions["mutator"] !== "string") return;
+		this.log.warn("DEPRECATED. Use of \"mutator\" as string is no longer needed. You can remove it from your configuration. Stryker now supports mutating of JavaScript and friend files out of the box.");
+		delete rawOptions["mutator"];
+	}
+	removeMutatorName(rawOptions) {
+		const mutator = rawOptions["mutator"];
+		if (typeof mutator !== "object" || mutator === null) return;
+		const mutatorRecord = OptionsValidator.recordOf(mutator);
+		if (!mutatorRecord["name"]) return;
+		this.log.warn("DEPRECATED. Use of \"mutator.name\" is no longer needed. You can remove \"mutator.name\" from your configuration. Stryker now supports mutating of JavaScript and friend files out of the box.");
+		delete mutatorRecord["name"];
+		rawOptions["mutator"] = mutatorRecord;
+	}
+	removeTestFramework(rawOptions) {
+		if (!Object.keys(rawOptions).includes("testFramework")) return;
+		this.log.warn("DEPRECATED. Use of \"testFramework\" is no longer needed. You can remove it from your configuration. Your test runner plugin now handles its own test framework integration.");
+		delete rawOptions["testFramework"];
+	}
+	removeTranspilers(rawOptions) {
+		const transpilers = rawOptions["transpilers"];
+		if (!Array.isArray(transpilers)) return;
+		const example = transpilers.includes("babel") ? "babel src --out-dir lib" : transpilers.includes("typescript") ? "tsc -b" : transpilers.includes("webpack") ? "webpack --config webpack.config.js" : "npm run build";
+		this.log.warn(`DEPRECATED. Support for "transpilers" is removed. You can now configure your own "${optionsPath("buildCommand")}". For example, ${example}.`);
+		delete rawOptions["transpilers"];
+	}
+	rewriteFiles(rawOptions) {
+		const files = rawOptions["files"];
+		if (!Array.isArray(files)) return;
+		const ignorePatternsName = optionsPath("ignorePatterns");
+		const isString = (uncertain) => typeof uncertain === "string";
+		const newIgnorePatterns = ["**", ...files.filter(isString).map((filePattern) => filePattern.startsWith("!") ? filePattern.substr(1) : `!${filePattern}`)];
+		delete rawOptions["files"];
+		this.log.warn(`DEPRECATED. Use of "files" is deprecated, please use "${ignorePatternsName}" instead (or remove "files" altogether will probably work as well). For now, rewriting them as ${JSON.stringify(newIgnorePatterns)}. See https://stryker-mutator.io/docs/stryker-js/configuration/#ignorepatterns-string`);
+		const existingIgnorePatterns = Array.isArray(rawOptions[ignorePatternsName]) ? rawOptions[ignorePatternsName] : [];
+		rawOptions[ignorePatternsName] = [...newIgnorePatterns, ...existingIgnorePatterns];
+	}
+	removeJestEnableBail(rawOptions) {
+		const jestOptions = rawOptions["jest"];
+		if (typeof jestOptions !== "object" || jestOptions === null) return;
+		const jestRecord = OptionsValidator.recordOf(jestOptions);
+		const enableBail = jestRecord["enableBail"];
+		if (enableBail === void 0) return;
+		this.log.warn("DEPRECATED. Use of \"jest.enableBail\" is deprecated, please use \"disableBail\" instead. See https://stryker-mutator.io/docs/stryker-js/configuration#disablebail-boolean");
+		rawOptions["disableBail"] = !enableBail;
+		delete jestRecord["enableBail"];
+		rawOptions["jest"] = jestRecord;
+	}
+	removeHtmlReporterBaseDir(rawOptions) {
+		const htmlReporter = rawOptions["htmlReporter"];
+		if (typeof htmlReporter !== "object" || htmlReporter === null) return;
+		const reporter = OptionsValidator.recordOf(htmlReporter);
+		const baseDir = reporter["baseDir"];
+		if (!baseDir) return;
+		this.log.warn(`DEPRECATED. Use of "htmlReporter.baseDir" is deprecated, please use "${optionsPath("htmlReporter", "fileName")}" instead. See https://stryker-mutator.io/docs/stryker-js/configuration/#reporters-string`);
+		const baseDirText = typeof baseDir === "string" ? baseDir : JSON.stringify(baseDir) ?? "";
+		if (!reporter["fileName"]) reporter["fileName"] = path.join(baseDirText, "index.html");
+		delete reporter["baseDir"];
+		rawOptions["htmlReporter"] = reporter;
+	}
+	migrateMaxConcurrentTestRunners(rawOptions) {
+		const maxConcurrent = rawOptions["maxConcurrentTestRunners"];
+		if (typeof maxConcurrent !== "number" || maxConcurrent === Number.MAX_SAFE_INTEGER) return;
+		this.log.warn("DEPRECATED. Use of \"maxConcurrentTestRunners\" is deprecated. Please use \"concurrency\" instead.");
+		if (!rawOptions["concurrency"] && maxConcurrent < os.availableParallelism() - 1) rawOptions["concurrency"] = maxConcurrent;
+	}
+	customValidation(options) {
+		const additionalErrors = [];
+		if (options.thresholds.high < options.thresholds.low) additionalErrors.push("Config option \"thresholds.high\" should be higher than \"thresholds.low\".");
+		if (CommandTestRunner.is(options.testRunner)) {
+			if (options.testRunnerNodeArgs.length) this.log.warn("Using \"testRunnerNodeArgs\" together with the \"command\" test runner is not supported, these arguments will be ignored. You can add your custom arguments by setting the \"commandRunner.command\" option.");
+		}
+		if (options.ignoreStatic && options.coverageAnalysis !== "perTest") additionalErrors.push(`Config option "${optionsPath("ignoreStatic")}" is not supported with coverage analysis "${options.coverageAnalysis}". Either turn off "${optionsPath("ignoreStatic")}", or configure "${optionsPath("coverageAnalysis")}" to be "perTest".`);
+		options.mutate.forEach((mutateString, index) => {
+			const match = MUTATION_RANGE_REGEX.exec(mutateString);
+			if (match) {
+				if (new Minimatch(mutateString).hasMagic()) additionalErrors.push(`Config option "mutate[${index}]" is invalid. Cannot combine a glob expression with a mutation range in "${mutateString}".`);
+				else {
+					const [_, _fileName, mutationRange, startLine, _startColumn, endLine, _endColumn] = match;
+					const start = parseInt(startLine ?? "", 10);
+					const end = parseInt(endLine ?? "", 10);
+					if (start < 1) additionalErrors.push(`Config option "mutate[${index}]" is invalid. Mutation range "${mutationRange}" is invalid, line ${start} does not exist (lines start at 1).`);
+					if (start > end) additionalErrors.push(`Config option "mutate[${index}]" is invalid. Mutation range "${mutationRange}" is invalid. The "from" line number (${start}) should be less then the "to" line number (${end}).`);
+				}
+			}
+		});
+		additionalErrors.forEach((error) => this.log.error(error));
+		this.throwErrorIfNeeded(additionalErrors);
+	}
+	/**
+	* Decodes the options against their declaration, then writes the result back
+	* onto the caller's object: the previous engine filled defaults in place and
+	* every caller reads them off the object it passed, so the fill has to land
+	* there rather than in a copy.
+	*/
+	schemaValidate(options) {
+		const decoded = decodeOptions(options);
+		if (Result$1.isFailure(decoded)) {
+			const describedErrors = describeErrors(decoded.failure);
+			describedErrors.forEach((error) => this.log.error(error));
+			this.throwErrorIfNeeded(describedErrors);
+			return;
+		}
+		Object.assign(options, decoded.success);
+	}
+	throwErrorIfNeeded(errors) {
+		if (errors.length > 0) {
+			const headline = errors.length === 1 ? "Please correct this configuration error and try again." : "Please correct these configuration errors and try again.";
+			throw new ConfigError(`${headline} ${errors.join(" ")}`);
+		}
+	}
+	markOptions(options) {
+		this.markExcessOptions(options);
+		this.markUnserializableOptions(options);
+	}
+	markExcessOptions(options) {
+		const OPTIONS_ADDED_BY_STRYKER = [
+			"set",
+			"configFile",
+			"$schema"
+		];
+		if (isWarningEnabled("unknownOptions", options.warnings)) {
+			const schemaProperties = OptionsValidator.recordOf(this.schema["properties"] ?? {});
+			const schemaKeys = Object.keys(schemaProperties);
+			const excessPropertyNames = Object.keys(options).filter((key) => !key.endsWith("_comment")).filter((key) => !OPTIONS_ADDED_BY_STRYKER.includes(key)).filter((key) => !schemaKeys.includes(key));
+			if (excessPropertyNames.length) {
+				excessPropertyNames.forEach((excessPropertyName) => {
+					this.log.warn(`Unknown stryker config option "${excessPropertyName}".`);
+				});
+				this.log.warn(`Possible causes:
+     * Is it a typo on your end?
+     * Did you only write this property as a comment? If so, please postfix it with "_comment".
+     * You might be missing a plugin that is supposed to use it. Stryker loaded plugins from: ${JSON.stringify(options.plugins)}
+     * The plugin that is using it did not contribute explicit validation. 
+     (disable "${optionsPath("warnings", "unknownOptions")}" to ignore this warning)`);
+			}
+		}
+	}
+	markUnserializableOptions(options) {
+		if (isWarningEnabled("unserializableOptions", options.warnings)) {
+			const unserializables = findUnserializables(options);
+			if (unserializables) {
+				unserializables.forEach((unserializable) => this.log.warn(`Config option "${unserializable.path.join(".")}" is not (fully) serializable. ${unserializable.reason}. Any test runner or checker worker processes might not receive this value as intended.`));
+				this.log.warn(`(disable ${optionsPath("warnings", "unserializableOptions")} to ignore this warning)`);
+			}
+		}
+	}
+};
+/**
+* The defaults are the declaration decoded against an empty object: every field
+* that declares a default supplies it, and the result is the complete option
+* set. It no longer routes through the validator, which used to be the only way
+* to obtain them and produced an object missing three numeric defaults.
+*/
+function createDefaultOptions() {
+	return Result$1.getOrThrow(decodeOptions({}));
+}
+const defaultOptions = deepFreeze(createDefaultOptions());
+//#endregion
+//#region src/plugins/plugin-loader.schema.ts
+/**
+* The shape of a module namespace that contributes Stryker plugins:
+* an exported `strykerPlugins` array. Elements are runtime plugin objects,
+* so only array-ness is checked here.
+*/
+const PluginModuleSchema = Schema.Struct({ strykerPlugins: Schema.Array(Schema.Unknown) });
+/**
+* The shape of a module namespace that contributes a JSON schema
+* extension: an exported `strykerValidationSchema` record.
+*/
+const SchemaValidationContributionSchema = Schema.Struct({ strykerValidationSchema: Schema.Record(Schema.String, Schema.Unknown) });
+//#endregion
+//#region src/plugins/plugin-loader.ts
+const IGNORED_PACKAGES = [
+	"core",
+	"api",
+	"util",
+	"instrumenter"
+];
+/**
+* Can resolve modules and pull them into memory
+*/
+var PluginLoader = class {
+	log;
+	static inject = tokens(commonTokens.logger);
+	constructor(log) {
+		this.log = log;
+	}
+	/**
+	* 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/*"
+	*/
+	async load(pluginDescriptors) {
+		const pluginModules = await this.resolvePluginModules(pluginDescriptors);
+		const loadedPluginModules = (await Promise.all(pluginModules.map(async (moduleName) => {
+			return {
+				...await this.loadPlugin(moduleName),
+				moduleName
+			};
+		}))).filter(notEmpty);
+		const result = {
+			schemaContributions: [],
+			pluginsByKind: /* @__PURE__ */ new Map(),
+			pluginModulePaths: []
+		};
+		loadedPluginModules.forEach(({ plugins, schemaContribution, moduleName }) => {
+			if (plugins) {
+				result.pluginModulePaths.push(moduleName);
+				plugins.forEach((plugin) => {
+					const pluginsForKind = result.pluginsByKind.get(plugin.kind);
+					if (pluginsForKind) pluginsForKind.push(plugin);
+					else result.pluginsByKind.set(plugin.kind, [plugin]);
+				});
+			}
+			if (schemaContribution) result.schemaContributions.push(schemaContribution);
+		});
+		return result;
+	}
+	async resolvePluginModules(pluginDescriptors) {
+		return (await Promise.all(pluginDescriptors.map(async (pluginExpression) => {
+			if (pluginExpression.includes("*")) return await this.globPluginModules(pluginExpression);
+			else if (path.isAbsolute(pluginExpression) || pluginExpression.startsWith(".")) return pathToFileURL(path.resolve(pluginExpression)).toString();
+			else return pluginExpression;
+		}))).filter(notEmpty).flat();
+	}
+	async globPluginModules(pluginExpression) {
+		const { org, pkg } = parsePluginExpression(pluginExpression);
+		const pluginDirectory = path.resolve(fileURLToPath(new URL("../../../../../", import.meta.url)), org);
+		const regexp = new RegExp("^" + pkg.replace("*", ".*"));
+		this.log.debug("Loading %s from %s", pluginExpression, pluginDirectory);
+		const plugins = (await fs.promises.readdir(pluginDirectory)).filter((pluginName) => !IGNORED_PACKAGES.includes(pluginName) && regexp.test(pluginName)).map((pluginName) => `${org.length ? `${org}/` : ""}${pluginName}`);
+		if (plugins.length === 0 && !defaultOptions.plugins.includes(pluginExpression)) this.log.warn("Expression \"%s\" not resulted in plugins to load.", pluginExpression);
+		plugins.forEach((plugin) => this.log.debug("Loading plugin \"%s\" (matched with expression %s)", plugin, pluginExpression));
+		return plugins;
+	}
+	async loadPlugin(descriptor) {
+		this.log.debug("Loading plugin %s", descriptor);
+		try {
+			const module = await importModule(descriptor);
+			const plugins = isPluginModule(module) ? module.strykerPlugins : void 0;
+			const schemaContribution = hasValidationSchemaContribution(module) ? module.strykerValidationSchema : void 0;
+			if (plugins ?? schemaContribution) return {
+				plugins,
+				schemaContribution
+			};
+			else this.log.warn("Module \"%s\" did not contribute a StrykerJS plugin. It didn't export a \"%s\" or \"%s\".", descriptor, propertyPath()("strykerPlugins"), propertyPath()("strykerValidationSchema"));
+		} catch (e) {
+			if (isErrnoException(e) && e.code === "ERR_MODULE_NOT_FOUND" && e.message.indexOf(descriptor) !== -1) this.log.warn("Cannot find plugin \"%s\".\n  Did you forget to install it ?", descriptor);
+			else this.log.warn("Error during loading \"%s\" plugin:\n  %s", descriptor, errorToString(e));
+		}
+	}
+};
+/**
+* Distills organization name from a package expression.
+* @example
+*  '@stryker-mutator/core' => { org: '@stryker-mutator', 'core' }
+*  'glob' => { org: '', 'glob' }
+*/
+function parsePluginExpression(pluginExpression) {
+	const parts = pluginExpression.split("/");
+	if (parts.length > 1) return {
+		org: parts.slice(0, parts.length - 1).join("/"),
+		pkg: parts[parts.length - 1] ?? ""
+	};
+	else return {
+		org: "",
+		pkg: parts[0] ?? ""
+	};
+}
+function isPluginModule(module) {
+	return Schema.is(PluginModuleSchema)(module);
+}
+function hasValidationSchemaContribution(module) {
+	return Schema.is(SchemaValidationContributionSchema)(module);
+}
+//#endregion
+export { testRunnerPool as $, mutantTestPlanner as A, reporter as B, injection_tokens_exports as C, loggingServer as D, loggerShowColors as E, pluginModulePaths as F, runEventSink as G, reporterPluginModules as H, pluginsByKind as I, sandbox as J, runId as K, process$1 as L, mutationTestReportHelper as M, optionsValidator as N, loggingServerAddress as O, pluginCreator as P, testRunnerFactory as Q, progressEnabled as R, incrementalDiffer as S, loggerConsoleOut as T, requireFromCwd as U, reporterOverride as V, resolvedMode as W, testCoverage as X, temporaryDirectory as Y, testRunnerConcurrencyTokens as Z, clearTextEnabled as _, isWarningEnabled as a, dryRunResult as b, ProjectReader as c, ConfigReader as d, timeOverheadMS as et, FileSystem as f, checkerPool as g, checkerFactory as h, optionsPath as i, workerIdGenerator as it, mutants as j, loggingSink as k, MetaSchemaBuilder as l, checkerConcurrencyTokens as m, OptionsValidator as n, unexpectedExitRegistry as nt, CommandTestRunner as o, PluginCreator as p, runStartedAt as q, defaultOptions as r, validationSchema as rt, kill as s, PluginLoader as t, timer as tt, FileMatcher as u, concurrencyTokenProvider as v, loggerActiveLevel as w, execa as x, disableTypeChecksHelper as y, project as z };