@systemfsoftware/stryker-js-mutation-run 1.2.5

package/dist/checker-C4tGiXtZ.mjs

@@ -0,0 +1,588 @@
+import { F as pluginModulePaths, O as loggingServerAddress, P as pluginCreator, Q as testRunnerFactory, Z as testRunnerConcurrencyTokens, h as checkerFactory, it as workerIdGenerator, m as checkerConcurrencyTokens, s as kill } from "./plugins-Nx86IJQW.mjs";
+import { i as WorkerMessageSchema, n as ProtocolEncodeError, r as ParentMessageSchema } from "./child-process-proxy-worker-lx1M5Mz3.mjs";
+import "@systemfsoftware/stryker-js-plugin-api/core";
+import { PluginKind, commonTokens, tokens } from "@systemfsoftware/stryker-js-plugin-api/plugin";
+import { tokens as tokens$1 } from "typed-inject";
+import { ExpirableTask, StrykerError, Task, isErrnoException, notEmpty } from "@stryker-mutator/util";
+import { URL, fileURLToPath } from "url";
+import "@systemfsoftware/stryker-js-plugin-api/logging";
+import os, { EOL } from "os";
+import * as S from "effect/Schema";
+import { BehaviorSubject, ReplaySubject, Subject, filter, ignoreElements, lastValueFrom, mergeMap, range, takeUntil, tap, zip } from "rxjs";
+import childProcess from "child_process";
+import "@systemfsoftware/stryker-js-plugin-api/test-runner";
+import "@systemfsoftware/stryker-js-plugin-api/check";
+import * as Exit from "effect/Exit";
+//#region src/worker-pool/concurrency-token-provider.ts
+var ConcurrencyTokenProvider = class {
+	log;
+	concurrencyCheckers;
+	concurrencyTestRunners;
+	testRunnerTokenSubject = new ReplaySubject();
+	get testRunnerToken$() {
+		return this.testRunnerTokenSubject;
+	}
+	checkerToken$;
+	static inject = tokens$1(commonTokens.options, commonTokens.logger);
+	constructor(options, log) {
+		this.log = log;
+		const availableParallelism = os.availableParallelism();
+		const concurrency = this.computeConcurrency(options.concurrency, availableParallelism);
+		if (options.checkers.length > 0) {
+			this.concurrencyCheckers = Math.max(Math.ceil(concurrency / 2), 1);
+			this.checkerToken$ = range(this.concurrencyCheckers);
+			this.concurrencyTestRunners = Math.max(Math.floor(concurrency / 2), 1);
+			log.info("Creating %s checker process(es) and %s test runner process(es).", this.concurrencyCheckers, this.concurrencyTestRunners);
+		} else {
+			this.concurrencyCheckers = 0;
+			this.checkerToken$ = range(1);
+			this.concurrencyTestRunners = concurrency;
+			log.info("Creating %s test runner process(es).", this.concurrencyTestRunners);
+		}
+		Array.from({ length: this.concurrencyTestRunners }).forEach(() => this.testRunnerTokenSubject.next(this.tick()));
+	}
+	computeConcurrency(concurrencyOption, availableParallelism) {
+		if (typeof concurrencyOption === "string") {
+			const percentageMatch = concurrencyOption.match(/^(100|[1-9]?[0-9])%$/);
+			if (percentageMatch && percentageMatch[1] !== void 0) {
+				const percentage = parseInt(percentageMatch[1], 10);
+				const computed = Math.max(1, Math.round(availableParallelism * percentage / 100));
+				this.log.debug("Computed concurrency %s from \"%s\" based on %s available parallelism.", computed, concurrencyOption, availableParallelism);
+				return computed;
+			}
+		}
+		if (typeof concurrencyOption === "number") return concurrencyOption;
+		return availableParallelism > 4 ? availableParallelism - 1 : availableParallelism;
+	}
+	freeCheckers() {
+		if (this.concurrencyCheckers > 0) {
+			this.log.debug("Checking done, creating %s additional test runner process(es)", this.concurrencyCheckers);
+			for (let i = 0; i < this.concurrencyCheckers; i++) this.testRunnerTokenSubject.next(this.tick());
+			this.testRunnerTokenSubject.complete();
+		}
+	}
+	count = 0;
+	tick() {
+		return this.count++;
+	}
+	dispose() {
+		this.testRunnerTokenSubject.complete();
+	}
+};
+//#endregion
+//#region src/worker-pool/pool.ts
+const MAX_CONCURRENT_INIT = 2;
+createTestRunnerPool.inject = tokens$1(testRunnerFactory, testRunnerConcurrencyTokens);
+function createTestRunnerPool(factory, concurrencyToken$) {
+	return new Pool(factory, concurrencyToken$);
+}
+createCheckerPool.inject = tokens$1(checkerFactory, checkerConcurrencyTokens);
+function createCheckerPool(factory, concurrencyToken$) {
+	return new Pool(factory, concurrencyToken$);
+}
+/**
+* Represents a work item: an input with a task and with a `result$` observable where the result (exactly one) will be streamed to.
+*/
+var WorkItem = class {
+	input;
+	task;
+	resultSubject = new Subject();
+	result$ = this.resultSubject.asObservable();
+	/**
+	* @param input The input to the ask
+	* @param task The task, where a resource and input is presented
+	*/
+	constructor(input, task) {
+		this.input = input;
+		this.task = task;
+	}
+	async execute(resource) {
+		try {
+			const output = await this.task(resource, this.input);
+			this.resultSubject.next(output);
+			this.resultSubject.complete();
+		} catch (err) {
+			this.resultSubject.error(err);
+		}
+	}
+	reject(error) {
+		this.resultSubject.error(error);
+	}
+	complete() {
+		this.resultSubject.complete();
+	}
+};
+/**
+* Represents a pool of resources. Use `schedule` to schedule work to be executed on the resources.
+* The pool will automatically recycle the resources, but will make sure only one task is executed
+* on one resource at any one time. Creates as many resources as the concurrency tokens allow.
+* Also takes care of the initialing of the resources (with `init()`)
+*/
+var Pool = class {
+	initSubject = new ReplaySubject();
+	disposedSubject = new BehaviorSubject(false);
+	dispose$ = this.disposedSubject.pipe(filter((isDisposed) => isDisposed));
+	createdResources = [];
+	todoSubject = new ReplaySubject();
+	constructor(factory, concurrencyToken$) {
+		const resourcesSubject = new Subject();
+		zip(resourcesSubject, this.todoSubject).pipe(mergeMap(async ([resource, workItem]) => {
+			await workItem.execute(resource);
+			resourcesSubject.next(resource);
+		}), ignoreElements(), takeUntil(this.dispose$)).subscribe({ error: (error) => {
+			this.todoSubject.subscribe((workItem) => workItem.reject(error));
+		} });
+		concurrencyToken$.pipe(takeUntil(this.dispose$), mergeMap(async () => {
+			if (this.disposedSubject.value) return;
+			const resource = factory();
+			this.createdResources.push(resource);
+			await resource.init?.();
+			return resource;
+		}, MAX_CONCURRENT_INIT), filter(notEmpty), tap({
+			complete: () => {
+				this.initSubject.next();
+				this.initSubject.complete();
+			},
+			error: (err) => {
+				this.initSubject.error(err);
+			}
+		})).subscribe({
+			next: (resource) => resourcesSubject.next(resource),
+			error: (err) => resourcesSubject.error(err)
+		});
+	}
+	/**
+	* Returns a promise that resolves if all concurrency tokens have resulted in initialized resources.
+	* This is optional, resources will get initialized either way.
+	*/
+	async init() {
+		await lastValueFrom(this.initSubject);
+	}
+	/**
+	* Schedules a task to be executed on resources in the pool. Each input is paired with a resource, which allows async work to be done.
+	* @param input$ The inputs to pair up with a resource.
+	* @param task The task to execute on each resource
+	*/
+	schedule(input$, task) {
+		return input$.pipe(mergeMap((input) => {
+			const workItem = new WorkItem(input, task);
+			this.todoSubject.next(workItem);
+			return workItem.result$;
+		}));
+	}
+	/**
+	* Dispose the pool
+	*/
+	async dispose() {
+		if (!this.disposedSubject.value) {
+			this.disposedSubject.next(true);
+			this.todoSubject.subscribe((workItem) => workItem.complete());
+			this.todoSubject.complete();
+			await Promise.all(this.createdResources.map((resource) => resource.dispose?.()));
+		}
+	}
+};
+//#endregion
+//#region src/worker-pool/resource-decorator.ts
+var ResourceDecorator = class {
+	producer;
+	innerResource;
+	constructor(producer) {
+		this.producer = producer;
+		this.innerResource = producer();
+	}
+	async init() {
+		await this.innerResource.init?.();
+	}
+	async dispose() {
+		await this.innerResource.dispose?.();
+	}
+	/**
+	* Disposes the current test runner and creates a new one
+	* To be used in decorators that need recreation.
+	*/
+	async recover() {
+		await this.dispose();
+		this.innerResource = this.producer();
+		return this.init();
+	}
+};
+//#endregion
+//#region src/checker/checker-facade.ts
+function toMap(mutantRunPlans) {
+	return new Map(mutantRunPlans.map((mutant) => [mutant.mutant.id, mutant]));
+}
+var CheckerFacade = class extends ResourceDecorator {
+	async check(checkerName, mutantRunPlans) {
+		const innerCheckerResult = Object.entries(await this.innerResource.check(checkerName, mutantRunPlans.map((mr) => mr.mutant)));
+		const mutantRunPlanMap = toMap(mutantRunPlans);
+		const results = innerCheckerResult.map(([id, res]) => {
+			const mutantRunPlan = mutantRunPlanMap.get(id);
+			if (!mutantRunPlan) throw new Error(`Checker "${checkerName}" returned a check result for mutant id "${id}", but a check wasn't requested for it. Stryker asked to check mutant ids: ${mutantRunPlans.map(({ mutant }) => mutant.id).join(",")}`);
+			return [mutantRunPlan, res];
+		});
+		if (mutantRunPlans.length > results.length) {
+			const resultIds = new Set(results.map(([{ mutant }]) => mutant.id));
+			const missingIds = mutantRunPlans.map(({ mutant }) => mutant.id).filter((id) => !resultIds.has(id));
+			throw new Error(`Checker "${checkerName}" was missing check results for mutant ids "${missingIds.join(",")}", while Stryker asked to check them`);
+		}
+		return results;
+	}
+	async group(checkerName, mutantRunPlans) {
+		const mutantIdGroups = await this.innerResource.group(checkerName, mutantRunPlans.map((mr) => mr.mutant));
+		const mutantRunPlanMap = toMap(mutantRunPlans);
+		const groupedMutantIds = /* @__PURE__ */ new Set();
+		const groups = mutantIdGroups.map((group) => group.map((id) => {
+			const mutantRunPlan = mutantRunPlanMap.get(id);
+			groupedMutantIds.add(id);
+			if (!mutantRunPlan) throw new Error(`Checker "${checkerName}" returned a group result for mutant id "${id}", but a group wasn't requested for it. Stryker asked to group mutant ids: ${mutantRunPlans.map(({ mutant }) => mutant.id).join(",")}!`);
+			return mutantRunPlan;
+		}));
+		if (mutantRunPlans.length > groupedMutantIds.size) {
+			const missingIds = mutantRunPlans.map(({ mutant }) => mutant.id).filter((id) => !groupedMutantIds.has(id));
+			throw new Error(`Checker "${checkerName}" was missing group results for mutant ids "${missingIds.join(",")}", while Stryker asked to group them!`);
+		}
+		return groups;
+	}
+};
+//#endregion
+//#region src/worker-pool/child-process-crashed-error.ts
+var ChildProcessCrashedError = class ChildProcessCrashedError extends StrykerError {
+	pid;
+	exitCode;
+	signal;
+	constructor(pid, message, exitCode, signal, innerError) {
+		super(message, innerError);
+		this.pid = pid;
+		this.exitCode = exitCode;
+		this.signal = signal;
+		Error.captureStackTrace(this, ChildProcessCrashedError);
+		Object.setPrototypeOf(this, ChildProcessCrashedError.prototype);
+	}
+};
+//#endregion
+//#region src/worker-pool/out-of-memory-error.ts
+var OutOfMemoryError = class OutOfMemoryError extends ChildProcessCrashedError {
+	constructor(pid, exitCode) {
+		super(pid, `Process ${pid} ran out of memory`, exitCode);
+		this.message = "Process ";
+		Error.captureStackTrace(this, OutOfMemoryError);
+		Object.setPrototypeOf(this, OutOfMemoryError.prototype);
+	}
+};
+//#endregion
+//#region src/worker-pool/string-builder.ts
+const DEFAULT_MAX_SIZE = 8192;
+var StringBuilder = class {
+	currentLength = 0;
+	strings = [];
+	maxSize = DEFAULT_MAX_SIZE;
+	append(str) {
+		this.strings.push(str);
+		this.currentLength += str.length;
+		while (this.currentLength > this.maxSize && this.strings.length > 1) {
+			const shifted = this.strings.shift();
+			if (shifted !== void 0) this.currentLength -= shifted.length;
+		}
+	}
+	toString() {
+		return this.strings.join("");
+	}
+	static concat(...builders) {
+		return builders.map((b) => b.toString()).filter(Boolean).join(EOL);
+	}
+};
+//#endregion
+//#region src/worker-pool/string-utils.ts
+function padLeft(input) {
+	return input.split("\n").map((str) => "	" + str).join("\n");
+}
+//#endregion
+//#region src/worker-pool/child-process-proxy.ts
+/**
+* This half's two directions, built once from the declared schemas. They take
+* `unknown` and return an `Exit`, which is what makes them the *only* codec this
+* half needs: the envelope performs the narrowing, so a separate `S.Json` check
+* on `args` would guard the same bytes twice, and a decode failure on a process
+* boundary is an expected outcome this code answers for rather than an exception
+* that leaves the type unmarked.
+*/
+const encodeWorkerMessage = S.encodeUnknownExit(S.fromJsonString(WorkerMessageSchema));
+const decodeParentMessage = S.decodeUnknownExit(S.fromJsonString(ParentMessageSchema));
+const BROKEN_PIPE_ERROR_CODE = "EPIPE";
+const IPC_CHANNEL_CLOSED_ERROR_CODE = "ERR_IPC_CHANNEL_CLOSED";
+const TIMEOUT_FOR_DISPOSE = 2e3;
+var ChildProcessProxy = class ChildProcessProxy {
+	proxy;
+	worker;
+	initTask;
+	disposeTask;
+	fatalError;
+	workerTasks = /* @__PURE__ */ new Map();
+	workerTaskCounter = 0;
+	log;
+	stdoutBuilder = new StringBuilder();
+	stderrBuilder = new StringBuilder();
+	isDisposed = false;
+	initMessage;
+	constructor(modulePath, namedExport, loggingServerAddress, options, fileDescriptions, pluginModulePaths, workingDirectory, logger, execArgv, idGenerator) {
+		const workerId = idGenerator.next().toString();
+		this.worker = childProcess.fork(fileURLToPath(new URL("./child-process-proxy-worker-main.mjs", import.meta.url)), {
+			silent: true,
+			execArgv,
+			env: {
+				STRYKER_MUTATOR_WORKER: workerId,
+				...process.env
+			}
+		});
+		this.initTask = new Task();
+		this.log = logger;
+		this.log.debug("Started %s in worker process %s with pid %s %s", namedExport, workerId, this.worker.pid, execArgv.length ? ` (using args ${execArgv.join(" ")})` : "");
+		this.worker.on("close", this.handleUnexpectedExit);
+		this.worker.on("error", this.handleError);
+		this.initMessage = {
+			kind: 0,
+			loggingServerAddress,
+			options,
+			fileDescriptions,
+			pluginModulePaths,
+			namedExport,
+			modulePath,
+			workingDirectory
+		};
+		this.listenForMessages();
+		this.listenToStdoutAndStderr();
+		this.proxy = this.initProxy();
+	}
+	/**
+	* @description Creates a proxy where each function of the object created using the constructorFunction arg is ran inside of a child process
+	*/
+	static create(modulePath, loggingServerAddress, options, fileDescriptions, pluginModulePaths, workingDirectory, injectableClass, execArgv, getLogger, idGenerator) {
+		return new ChildProcessProxy(modulePath, injectableClass.name, loggingServerAddress, options, fileDescriptions, pluginModulePaths, workingDirectory, getLogger(ChildProcessProxy.name), [...execArgv], idGenerator);
+	}
+	send(message) {
+		const encoded = encodeWorkerMessage(message);
+		if (Exit.isFailure(encoded)) throw new ProtocolEncodeError({ reason: String(encoded.cause) });
+		this.worker.send(encoded.value);
+	}
+	initProxy() {
+		return S.decodeUnknownSync(S.declare((input) => input !== null && typeof input === "object" && !Array.isArray(input), { description: "The runtime promisified facade of a child-process worker" }))(new Proxy({}, { get: (_, propertyKey) => {
+			if (typeof propertyKey === "string") return this.forward(propertyKey);
+			else return;
+		} }));
+	}
+	forward(methodName) {
+		return async (...args) => {
+			if (this.fatalError) return Promise.reject(this.fatalError);
+			else {
+				const workerTask = new Task();
+				const correlationId = this.workerTaskCounter++;
+				this.workerTasks.set(correlationId, workerTask);
+				this.initTask.promise.then(() => {
+					this.send({
+						args,
+						correlationId,
+						kind: 1,
+						methodName
+					});
+				}).catch((error) => {
+					workerTask.reject(error);
+				});
+				return workerTask.promise;
+			}
+		};
+	}
+	listenForMessages() {
+		this.worker.on("message", (serializedMessage) => {
+			const decoded = decodeParentMessage(serializedMessage);
+			if (Exit.isFailure(decoded)) {
+				this.fatalError = new ChildProcessCrashedError(this.worker.pid, String(decoded.cause));
+				return;
+			}
+			const message = decoded.value;
+			switch (message.kind) {
+				case 0:
+					this.send(this.initMessage);
+					break;
+				case 1:
+					this.initTask.resolve(void 0);
+					break;
+				case 3: {
+					const task = this.workerTasks.get(message.correlationId);
+					if (task !== void 0) {
+						task.resolve(message.result);
+						this.workerTasks.delete(message.correlationId);
+					}
+					break;
+				}
+				case 4: {
+					const task = this.workerTasks.get(message.correlationId);
+					if (task !== void 0) {
+						task.reject(new StrykerError(message.error));
+						this.workerTasks.delete(message.correlationId);
+					}
+					break;
+				}
+				case 5:
+					if (this.disposeTask) this.disposeTask.resolve(void 0);
+					break;
+				case 2:
+					this.fatalError = new StrykerError(message.error);
+					this.reportError(this.fatalError);
+					this.dispose();
+					break;
+				default: this.logUnidentifiedMessage(message);
+			}
+		});
+	}
+	listenToStdoutAndStderr() {
+		const handleData = (builder) => (data) => {
+			const output = data.toString();
+			builder.append(output);
+			this.log.trace(output);
+		};
+		if (this.worker.stdout) this.worker.stdout.on("data", handleData(this.stdoutBuilder));
+		if (this.worker.stderr) this.worker.stderr.on("data", handleData(this.stderrBuilder));
+	}
+	get stdout() {
+		return this.stdoutBuilder.toString();
+	}
+	get stderr() {
+		return this.stderrBuilder.toString();
+	}
+	reportError(error) {
+		const onGoingWorkerTasks = [...this.workerTasks.values()].filter((task) => !task.isCompleted);
+		if (!this.initTask.isCompleted) onGoingWorkerTasks.push(this.initTask);
+		if (onGoingWorkerTasks.length) onGoingWorkerTasks.forEach((task) => task.reject(error));
+	}
+	handleUnexpectedExit = (code, signal) => {
+		this.isDisposed = true;
+		const output = StringBuilder.concat(this.stderrBuilder, this.stdoutBuilder);
+		if (processOutOfMemory()) {
+			const oom = new OutOfMemoryError(this.worker.pid, code);
+			this.fatalError = oom;
+			this.log.warn(`Child process [pid ${oom.pid}] ran out of memory. Stdout and stderr are logged on debug level.`);
+			this.log.debug(stdoutAndStderr());
+		} else {
+			this.fatalError = new ChildProcessCrashedError(this.worker.pid, `Child process [pid ${this.worker.pid}] exited unexpectedly with exit code ${code} (${signal || "without signal"}). ${stdoutAndStderr()}`, code, signal);
+			this.log.warn(this.fatalError.message, this.fatalError);
+		}
+		this.reportError(this.fatalError);
+		function processOutOfMemory() {
+			return output.includes("JavaScript heap out of memory") || output.includes("FatalProcessOutOfMemory");
+		}
+		function stdoutAndStderr() {
+			if (output.length) return `Last part of stdout and stderr was:${os.EOL}${padLeft(output)}`;
+			else return "Stdout and stderr were empty.";
+		}
+	};
+	handleError = (error) => {
+		if (this.innerProcessIsCrashed(error)) {
+			this.log.warn(`Child process [pid ${this.worker.pid}] has crashed. See other warning messages for more info.`, error);
+			this.reportError(new ChildProcessCrashedError(this.worker.pid, `Child process [pid ${this.worker.pid}] has crashed`, void 0, void 0, error));
+		} else this.reportError(error);
+	};
+	innerProcessIsCrashed(error) {
+		return isErrnoException(error) && (error.code === BROKEN_PIPE_ERROR_CODE || error.code === IPC_CHANNEL_CLOSED_ERROR_CODE);
+	}
+	async dispose() {
+		if (!this.isDisposed) {
+			this.worker.removeListener("close", this.handleUnexpectedExit);
+			this.isDisposed = true;
+			this.log.debug("Disposing of worker process %s", this.worker.pid);
+			this.disposeTask = new ExpirableTask(TIMEOUT_FOR_DISPOSE);
+			this.send({ kind: 2 });
+			try {
+				await this.disposeTask.promise;
+			} finally {
+				this.log.debug("Kill %s", this.worker.pid);
+				await kill(this.worker.pid);
+			}
+		}
+	}
+	logUnidentifiedMessage(message) {
+		this.log.error(`Received unidentified message ${message}`);
+	}
+};
+//#endregion
+//#region src/checker/checker-worker.ts
+var CheckerWorker = class {
+	innerCheckers;
+	static inject = tokens(commonTokens.options, pluginCreator);
+	constructor(options, pluginCreator) {
+		this.innerCheckers = new Map(options.checkers.map((name) => [name, pluginCreator.create(PluginKind.Checker, name)]));
+	}
+	async init() {
+		for (const [name, checker] of this.innerCheckers.entries()) try {
+			await checker.init();
+		} catch (error) {
+			throw new StrykerError(`An error occurred during initialization of the "${name}" checker`, error);
+		}
+	}
+	async check(checkerName, mutants) {
+		return this.perform(checkerName, (checker) => checker.check(mutants));
+	}
+	async group(checkerName, mutants) {
+		return this.perform(checkerName, (checker) => checker.group?.(mutants) ?? mutants.map(({ id }) => [id]));
+	}
+	perform(checkerName, act) {
+		const checker = this.innerCheckers.get(checkerName);
+		if (checker) return act(checker);
+		else throw new Error(`Checker ${checkerName} does not exist!`);
+	}
+};
+//#endregion
+//#region src/checker/checker-child-process-proxy.ts
+var CheckerChildProcessProxy = class {
+	childProcess;
+	constructor(options, fileDescriptions, pluginModulePaths, loggingServerAddress, getLogger, idGenerator) {
+		this.childProcess = ChildProcessProxy.create(new URL("./checker-worker.mjs", import.meta.url).toString(), loggingServerAddress, options, fileDescriptions, pluginModulePaths, process.cwd(), CheckerWorker, options.checkerNodeArgs, getLogger, idGenerator);
+	}
+	async dispose() {
+		await this.childProcess.dispose();
+	}
+	async init() {
+		await this.childProcess.proxy.init();
+	}
+	async check(checkerName, mutants) {
+		return this.childProcess.proxy.check(checkerName, mutants);
+	}
+	async group(checkerName, mutants) {
+		return this.childProcess.proxy.group(checkerName, mutants);
+	}
+};
+//#endregion
+//#region src/checker/checker-retry-decorator.ts
+var CheckerRetryDecorator = class extends ResourceDecorator {
+	log;
+	constructor(producer, log) {
+		super(producer);
+		this.log = log;
+	}
+	async check(checkerName, mutants) {
+		return this.tryAction(() => this.innerResource.check(checkerName, mutants));
+	}
+	async group(checkerName, mutants) {
+		return this.tryAction(() => this.innerResource.group(checkerName, mutants));
+	}
+	async tryAction(act) {
+		try {
+			return await act();
+		} catch (error) {
+			if (error instanceof ChildProcessCrashedError) {
+				if (error instanceof OutOfMemoryError) this.log.warn(`Checker process [${error.pid}] ran out of memory. Retrying in a new process.`);
+				else this.log.warn(`Checker process [${error.pid}] crashed with exit code ${error.exitCode}. Retrying in a new process.`, error);
+				await this.recover();
+				return act();
+			} else throw error;
+		}
+	}
+};
+//#endregion
+//#region src/checker/checker-factory.ts
+createCheckerFactory.inject = tokens(commonTokens.options, commonTokens.fileDescriptions, loggingServerAddress, pluginModulePaths, commonTokens.getLogger, workerIdGenerator);
+function createCheckerFactory(options, fileDescriptions, loggingServerAddress, pluginModulePaths, getLogger, idGenerator) {
+	return () => new CheckerFacade(() => new CheckerRetryDecorator(() => new CheckerChildProcessProxy(options, fileDescriptions, pluginModulePaths, loggingServerAddress, getLogger, idGenerator), getLogger(CheckerRetryDecorator.name)));
+}
+//#endregion
+export { ChildProcessCrashedError as a, createTestRunnerPool as c, OutOfMemoryError as i, ConcurrencyTokenProvider as l, CheckerWorker as n, ResourceDecorator as o, ChildProcessProxy as r, createCheckerPool as s, createCheckerFactory as t };

package/dist/checker-resource-DTYEKXdg.d.mts

@@ -0,0 +1,108 @@
+import "./index-CyOSz6LC.mjs";
+import { FileDescriptions, Mutant, PartialStrykerOptions, StrykerOptions } from "@systemfsoftware/stryker-js-plugin-api/core";
+import "@systemfsoftware/stryker-js-plugin-api/plugin";
+import { Disposable, Injector as Injector$1 } from "typed-inject";
+import { Schema } from "effect";
+import { Logger } from "@systemfsoftware/stryker-js-plugin-api/logging";
+import "rxjs";
+import { TestRunner } from "@systemfsoftware/stryker-js-plugin-api/test-runner";
+import { CheckResult } from "@systemfsoftware/stryker-js-plugin-api/check";
+//#region src/logging/log-level.d.ts
+/**
+ * Re-export of @systemfsoftware/stryker-js-plugin-api/core's LogLevel const enum as a local runtime object.
+ * The upstream uses `const enum` which rolldown/oxc doesn't inline at bundle time,
+ * and which has no runtime emit.
+ *
+ * Using a const object + type pattern instead of an enum keeps the type structurally
+ * compatible with the upstream's LogLevel (both are the same string literal union),
+ * so values from @systemfsoftware/stryker-js-plugin-api/core types are assignable without casting.
+ */
+declare const LogLevel: {
+  readonly Trace: 'trace';
+  readonly Debug: 'debug';
+  readonly Information: 'info';
+  readonly Warning: 'warn';
+  readonly Error: 'error';
+  readonly Fatal: 'fatal';
+  readonly Off: 'off';
+};
+type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+//#endregion
+//#region src/logging/logging-event.schema.d.ts
+/**
+ * The wire format of a {@link LoggingEvent}; worker processes serialize
+ * events over the logging socket, the server deserializes them.
+ */
+declare const SerializedLoggingEventSchema: Schema.Struct<{
+  readonly startTime: Schema.String;
+  readonly categoryName: Schema.String;
+  readonly message: Schema.String;
+  readonly level: Schema.Literals<readonly ["trace", "debug", "info", "warn", "error", "fatal", "off"]>;
+  readonly pid: Schema.Finite;
+}>;
+type SerializedLoggingEvent = Schema.Schema.Type<typeof SerializedLoggingEventSchema>;
+//#endregion
+//#region src/logging/logging-event.d.ts
+declare class LoggingEvent {
+  #private;
+  readonly startTime: Date;
+  readonly categoryName: string;
+  readonly data: unknown[];
+  readonly level: LogLevel;
+  readonly pid: number;
+  private constructor();
+  static create(categoryName: string, level: LogLevel, data: unknown[]): LoggingEvent;
+  format(): string;
+  formatColorized(): string;
+  static deserialize(ser: SerializedLoggingEvent): LoggingEvent;
+  serialize(): SerializedLoggingEvent;
+}
+//#endregion
+//#region src/logging/logging-sink.d.ts
+interface LoggingSink {
+  log(event: LoggingEvent): void;
+  isEnabled(level: LogLevel): boolean;
+}
+//#endregion
+//#region src/logging/logging-backend.d.ts
+/**
+ * The logging backend that handles the actual logging. So to both a file and the stdout, stderr.
+ */
+declare class LoggingBackend implements LoggingSink, Disposable {
+  #private;
+  activeStdoutLevel: LogLevel;
+  activeFileLevel: LogLevel;
+  showColors: boolean;
+  static readonly inject: readonly ["loggerConsoleOut", "loggerShowColors"];
+  constructor(consoleOut: NodeJS.WritableStream, showColors: boolean);
+  log(event: LoggingEvent): void;
+  isEnabled(level: LogLevel): boolean;
+  get activeLogLevel(): LogLevel;
+  get priority(): 0 | 1 | 2 | 3 | 4 | 5 | 6;
+  /**
+   * `allowConsoleColors` is deliberately not read here (R8). It defaults to
+   * `true` in the schema, so honouring it would re-enable colour on every run
+   * and defeat the machine-mode contract; colour is decided once, from the
+   * resolved mode and `NO_COLOR`, and injected at construction.
+   */
+  configure({ logLevel, fileLogLevel }: PartialStrykerOptions): void;
+  dispose(): Promise<void>;
+}
+//#endregion
+//#region src/logging/logging-server.d.ts
+interface LoggingServerAddress {
+  port: number;
+}
+//#endregion
+//#region src/worker-pool/pool.d.ts
+interface Resource extends Partial<Disposable> {
+  init?(): Promise<void>;
+}
+//#endregion
+//#region src/checker/checker-resource.d.ts
+interface CheckerResource extends Resource {
+  check(checkerName: string, mutant: Mutant[]): Promise<Record<string, CheckResult>>;
+  group(checkerName: string, mutants: Mutant[]): Promise<string[][]>;
+}
+//#endregion
+export { LoggingServerAddress as n, LoggingBackend as r, CheckerResource as t };