@systemfsoftware/stryker-js-mutation-run 1.2.5

package/dist/checker-worker.d.mts

@@ -0,0 +1,16 @@
+import { r as PluginCreator } from "./index-CyOSz6LC.mjs";
+import { t as CheckerResource } from "./checker-resource-DTYEKXdg.mjs";
+import { Mutant, StrykerOptions } from "@systemfsoftware/stryker-js-plugin-api/core";
+import { CheckResult } from "@systemfsoftware/stryker-js-plugin-api/check";
+//#region src/checker/checker-worker.d.ts
+declare class CheckerWorker implements CheckerResource {
+  private readonly innerCheckers;
+  static inject: ["options", "pluginCreator"];
+  constructor(options: StrykerOptions, pluginCreator: PluginCreator);
+  init(): Promise<void>;
+  check(checkerName: string, mutants: Mutant[]): Promise<Record<string, CheckResult>>;
+  group(checkerName: string, mutants: Mutant[]): Promise<string[][]>;
+  private perform;
+}
+//#endregion
+export { CheckerWorker };

package/dist/checker-worker.mjs

@@ -0,0 +1,2 @@
+import { n as CheckerWorker } from "./checker-C4tGiXtZ.mjs";
+export { CheckerWorker };

package/dist/child-process-proxy-worker-lx1M5Mz3.mjs

@@ -0,0 +1,567 @@
+import { D as loggingServer, E as loggerShowColors, I as pluginsByKind, O as loggingServerAddress, P as pluginCreator, T as loggerConsoleOut, k as loggingSink, p as PluginCreator, t as PluginLoader, w as loggerActiveLevel } from "./plugins-Nx86IJQW.mjs";
+import { StrykerOptionsSchema } from "@systemfsoftware/stryker-js-plugin-api/core";
+import { Scope, commonTokens } from "@systemfsoftware/stryker-js-plugin-api/plugin";
+import "typed-inject";
+import { errorToString } from "@stryker-mutator/util";
+import fs from "fs";
+import util, { promisify } from "util";
+import path from "path";
+import { Exit, Schema } from "effect";
+import "@systemfsoftware/stryker-js-plugin-api/logging";
+import net from "net";
+import net$1 from "node:net";
+import { promisify as promisify$1 } from "node:util";
+//#region src/logging/log-level.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.
+*/
+const LogLevel = {
+	Trace: "trace",
+	Debug: "debug",
+	Information: "info",
+	Warning: "warn",
+	Error: "error",
+	Fatal: "fatal",
+	Off: "off"
+};
+//#endregion
+//#region src/logging/logging-event.schema.ts
+/**
+* The wire format of a {@link LoggingEvent}; worker processes serialize
+* events over the logging socket, the server deserializes them.
+*/
+const SerializedLoggingEventSchema = Schema.Struct({
+	startTime: Schema.String,
+	categoryName: Schema.String,
+	message: Schema.String,
+	level: Schema.Literals([
+		LogLevel.Trace,
+		LogLevel.Debug,
+		LogLevel.Information,
+		LogLevel.Warning,
+		LogLevel.Error,
+		LogLevel.Fatal,
+		LogLevel.Off
+	]),
+	pid: Schema.Finite
+});
+//#endregion
+//#region src/logging/logging-event.ts
+const pattern = ["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)", "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"].join("|");
+const ansiRegex = new RegExp(pattern, "g");
+var LoggingEvent = class LoggingEvent {
+	startTime;
+	categoryName;
+	data;
+	level;
+	pid;
+	constructor(categoryName, level, data, startTime, pid) {
+		this.startTime = startTime;
+		this.categoryName = categoryName;
+		this.data = data;
+		this.level = level;
+		this.pid = pid;
+	}
+	static create(categoryName, level, data) {
+		return new LoggingEvent(categoryName, level, data, /* @__PURE__ */ new Date(), process.pid);
+	}
+	format() {
+		return `${this.#formatPrefix()} ${this.#formatMessage().replace(ansiRegex, "")}`;
+	}
+	formatColorized() {
+		return `${this.#colorizedStart()}${this.#formatPrefix()}${this.#colorizedEnd()} ${this.#formatMessage()}`;
+	}
+	#formatPrefix() {
+		return `${this.startTime.toTimeString().slice(0, 8)} (${this.pid}) ${this.level.toUpperCase()} ${this.categoryName}`;
+	}
+	#formatMessage() {
+		return util.format(...this.data);
+	}
+	#colorizedStart() {
+		return `\x1B[${styles[this.level]}m`;
+	}
+	#colorizedEnd() {
+		return "\x1B[39m";
+	}
+	static deserialize(ser) {
+		return new LoggingEvent(ser.categoryName, ser.level, [ser.message], new Date(ser.startTime), ser.pid);
+	}
+	serialize() {
+		return {
+			startTime: this.startTime.toJSON(),
+			categoryName: this.categoryName,
+			message: this.#formatMessage(),
+			level: this.level,
+			pid: this.pid
+		};
+	}
+};
+const styles = Object.freeze({
+	trace: 34,
+	debug: 36,
+	info: 32,
+	warn: 33,
+	error: 91,
+	fatal: 35,
+	off: 90
+});
+//#endregion
+//#region src/logging/priority.ts
+const logLevelPriority = Object.freeze({
+	[LogLevel.Trace]: 0,
+	[LogLevel.Debug]: 1,
+	[LogLevel.Information]: 2,
+	[LogLevel.Warning]: 3,
+	[LogLevel.Error]: 4,
+	[LogLevel.Fatal]: 5,
+	[LogLevel.Off]: 6
+});
+function minPriority(a, b) {
+	return logLevelPriority[a] < logLevelPriority[b] ? a : b;
+}
+//#endregion
+//#region src/logging/logging-backend.ts
+const LOG_FILE_NAME = "stryker.log";
+/**
+* The logging backend that handles the actual logging. So to both a file and the stdout, stderr.
+*/
+var LoggingBackend = class {
+	activeStdoutLevel = LogLevel.Information;
+	activeFileLevel = LogLevel.Off;
+	showColors;
+	#consoleOut;
+	static inject = [loggerConsoleOut, loggerShowColors];
+	constructor(consoleOut, showColors) {
+		this.#consoleOut = consoleOut;
+		this.showColors = showColors;
+	}
+	log(event) {
+		const eventPriority = logLevelPriority[event.level];
+		if (eventPriority >= logLevelPriority[this.activeStdoutLevel]) this.#consoleOut.write(`${this.showColors ? event.formatColorized() : event.format()}\n`);
+		if (eventPriority >= logLevelPriority[this.activeFileLevel] && !this.#fileStream.errored) this.#fileStream.write(`${event.format()}\n`);
+	}
+	isEnabled(level) {
+		return logLevelPriority[level] >= this.priority;
+	}
+	get activeLogLevel() {
+		return minPriority(this.activeStdoutLevel, this.activeFileLevel);
+	}
+	get priority() {
+		return logLevelPriority[this.activeLogLevel];
+	}
+	/**
+	* `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 }) {
+		if (logLevel) this.activeStdoutLevel = logLevel;
+		if (fileLogLevel) this.activeFileLevel = fileLogLevel;
+	}
+	#_fileStream;
+	get #fileStream() {
+		if (!this.#_fileStream) {
+			this.#_fileStream = fs.createWriteStream(LOG_FILE_NAME, { flags: "a" });
+			this.#_fileStream.on("error", (error) => {
+				console.error(`An error occurred while writing to "${LOG_FILE_NAME}"`, error);
+			});
+		}
+		return this.#_fileStream;
+	}
+	async dispose() {
+		if (this.#_fileStream) await promisify(this.#_fileStream.end.bind(this.#_fileStream))();
+	}
+};
+//#endregion
+//#region src/logging/logger-impl.ts
+var LoggerImpl = class {
+	#categoryName;
+	#loggingBackend;
+	constructor(categoryName, loggingBackend) {
+		this.#categoryName = categoryName;
+		this.#loggingBackend = loggingBackend;
+	}
+	isTraceEnabled() {
+		return this.#loggingBackend.isEnabled(LogLevel.Trace);
+	}
+	isDebugEnabled() {
+		return this.#loggingBackend.isEnabled(LogLevel.Debug);
+	}
+	isInfoEnabled() {
+		return this.#loggingBackend.isEnabled(LogLevel.Information);
+	}
+	isWarnEnabled() {
+		return this.#loggingBackend.isEnabled(LogLevel.Warning);
+	}
+	isErrorEnabled() {
+		return this.#loggingBackend.isEnabled(LogLevel.Error);
+	}
+	isFatalEnabled() {
+		return this.#loggingBackend.isEnabled(LogLevel.Fatal);
+	}
+	trace(message, ...args) {
+		this.#loggingBackend.log(LoggingEvent.create(this.#categoryName, LogLevel.Trace, [message, ...args]));
+	}
+	debug(message, ...args) {
+		this.#loggingBackend.log(LoggingEvent.create(this.#categoryName, LogLevel.Debug, [message, ...args]));
+	}
+	info(message, ...args) {
+		this.#loggingBackend.log(LoggingEvent.create(this.#categoryName, LogLevel.Information, [message, ...args]));
+	}
+	warn(message, ...args) {
+		this.#loggingBackend.log(LoggingEvent.create(this.#categoryName, LogLevel.Warning, [message, ...args]));
+	}
+	error(message, ...args) {
+		this.#loggingBackend.log(LoggingEvent.create(this.#categoryName, LogLevel.Error, [message, ...args]));
+	}
+	fatal(message, ...args) {
+		this.#loggingBackend.log(LoggingEvent.create(this.#categoryName, LogLevel.Fatal, [message, ...args]));
+	}
+};
+//#endregion
+//#region src/logging/logging-server.ts
+const DELIMITER = "__STRYKER_CORE__";
+var LoggingServer = class LoggingServer {
+	loggingSink;
+	static inject = [loggingSink];
+	#server;
+	constructor(loggingSink) {
+		this.loggingSink = loggingSink;
+		this.#server = net$1.createServer((socket) => {
+			socket.setEncoding("utf-8");
+			let dataSoFar = "";
+			socket.on("data", (data) => {
+				dataSoFar += data;
+				let index;
+				while ((index = dataSoFar.indexOf(DELIMITER)) !== -1) {
+					const serialized = JSON.parse(dataSoFar.substring(0, index));
+					const logEvent = Schema.decodeUnknownSync(SerializedLoggingEventSchema)(serialized);
+					dataSoFar = dataSoFar.substring(index + 16);
+					this.loggingSink.log(LoggingEvent.deserialize(logEvent));
+				}
+			});
+			socket.on("error", (error) => {
+				this.loggingSink.log(LoggingEvent.create(LoggingServer.name, LogLevel.Debug, ["An worker log process hung up unexpectedly", error]));
+			});
+		});
+	}
+	listen() {
+		const { promise, resolve } = Promise.withResolvers();
+		this.#server.listen(() => {
+			const address = this.#server.address();
+			if (address === null || typeof address === "string") throw new Error(`Address of the logging server is not an AddressInfo: ${typeof address}`);
+			resolve({ port: address.port });
+		});
+		return promise;
+	}
+	async dispose() {
+		await promisify$1(this.#server.close.bind(this.#server))();
+	}
+};
+//#endregion
+//#region src/logging/logging-client.ts
+var LoggingClient = class LoggingClient {
+	logLevel;
+	loggingServerAddress;
+	#socket;
+	static inject = [loggerActiveLevel, loggingServerAddress];
+	constructor(logLevel, loggingServerAddress) {
+		this.logLevel = logLevel;
+		this.loggingServerAddress = loggingServerAddress;
+	}
+	openConnection() {
+		return new Promise((res, rej) => {
+			this.#socket = net.createConnection(this.loggingServerAddress.port, "localhost", res);
+			this.#socket.on("error", (error) => {
+				console.error("Error occurred in logging client", error);
+				rej(error);
+			});
+		});
+	}
+	log(event) {
+		if (!this.#socket) throw new Error(`Cannot use the logging client before it is connected, please call '${LoggingClient.name}.prototype.${LoggingClient.prototype.openConnection.name}' first`);
+		if (this.isEnabled(event.level) && this.#socket.writable) this.#socket.write(JSON.stringify(event.serialize()) + DELIMITER);
+	}
+	isEnabled(level) {
+		return logLevelPriority[level] >= logLevelPriority[this.logLevel];
+	}
+	async dispose() {
+		if (this.#socket) await promisify(this.#socket.end.bind(this.#socket))();
+	}
+};
+//#endregion
+//#region src/logging/provide-logging.ts
+function getLoggerFactory(loggingSink) {
+	return (categoryName) => new LoggerImpl(categoryName ?? "UNKNOWN", loggingSink);
+}
+getLoggerFactory.inject = [loggingSink];
+function loggerFactory(getLogger, target) {
+	return getLogger(target?.name);
+}
+loggerFactory.inject = [commonTokens.getLogger, commonTokens.target];
+function provideLogging(injector) {
+	return injector.provideFactory(commonTokens.getLogger, getLoggerFactory).provideFactory(commonTokens.logger, loggerFactory, Scope.Transient).provideClass("loggingServer", LoggingServer);
+}
+provideLogging.inject = [loggingSink, commonTokens.injector];
+async function provideLoggingBackend(injector, loggerConsoleOut$1, showColors) {
+	const out = injector.provideValue(loggerConsoleOut, loggerConsoleOut$1).provideValue(loggerShowColors, showColors).provideClass(loggingSink, LoggingBackend).provideClass(loggingServer, LoggingServer);
+	const loggingServerAddress$2 = await out.resolve(loggingServer).listen();
+	return out.provideValue(loggingServerAddress, loggingServerAddress$2);
+}
+provideLoggingBackend.inject = [commonTokens.injector];
+async function provideLoggingClient(injector, loggingServerAddress$1, activeLogLevel) {
+	const out = injector.provideValue(loggingServerAddress, loggingServerAddress$1).provideValue(loggerActiveLevel, activeLogLevel).provideClass(loggingSink, LoggingClient);
+	await out.resolve(loggingSink).openConnection();
+	return out;
+}
+//#endregion
+//#region src/worker-pool/message-protocol.schema.ts
+const LoggingServerAddressSchema = Schema.Struct({ port: Schema.Finite });
+const PositionSchema = Schema.Struct({
+	line: Schema.Finite,
+	column: Schema.Finite
+});
+const MutationRangeSchema = Schema.Struct({
+	start: PositionSchema,
+	end: PositionSchema
+});
+const FileDescriptionSchema = Schema.Struct({ mutate: Schema.Union([Schema.mutable(Schema.Array(MutationRangeSchema)), Schema.Boolean]) });
+const FileDescriptionsSchema = Schema.Record(Schema.String, FileDescriptionSchema);
+const InitMessageSchema = Schema.Struct({
+	kind: Schema.Literal(0),
+	loggingServerAddress: LoggingServerAddressSchema,
+	options: StrykerOptionsSchema,
+	fileDescriptions: FileDescriptionsSchema,
+	pluginModulePaths: Schema.Array(Schema.String),
+	workingDirectory: Schema.String,
+	namedExport: Schema.String,
+	modulePath: Schema.String
+});
+const CallMessageSchema = Schema.Struct({
+	correlationId: Schema.Finite,
+	kind: Schema.Literal(1),
+	args: Schema.mutable(Schema.Array(Schema.Any)),
+	methodName: Schema.String
+});
+const DisposeMessageSchema = Schema.Struct({ kind: Schema.Literal(2) });
+/** Messages sent from the parent process to the child process. */
+const WorkerMessageSchema = Schema.Union([
+	CallMessageSchema,
+	DisposeMessageSchema,
+	InitMessageSchema
+]);
+const ReadyMessageSchema = Schema.Struct({ kind: Schema.Literals([
+	5,
+	1,
+	0
+]) });
+const WorkResultSchema = Schema.Struct({
+	correlationId: Schema.Finite,
+	kind: Schema.Literal(3),
+	result: Schema.Any
+});
+const RejectionResultSchema = Schema.Struct({
+	correlationId: Schema.Finite,
+	kind: Schema.Literal(4),
+	error: Schema.String
+});
+const InitRejectionResultSchema = Schema.Struct({
+	kind: Schema.Literal(2),
+	error: Schema.String
+});
+/** Messages sent from the child process back to the parent process. */
+const ParentMessageSchema = Schema.Union([
+	ReadyMessageSchema,
+	WorkResultSchema,
+	RejectionResultSchema,
+	InitRejectionResultSchema
+]);
+/**
+* Both wire schemas are declared with `S.fromJsonString` applied at the point of
+* use, never here: a const initialized to `S.encodeSync(...)` is a *use* of a
+* schema, not a declaration of one, and this file declares. Keeping the uses out
+* also keeps them out of the generated law suite, which reads every exported
+* schema in the package and cannot build an arbitrary from a function.
+*/
+//#endregion
+//#region src/worker-pool/subject-module.schema.ts
+/**
+* The child worker was pointed at a module that carries no constructable value
+* under the requested export name. It is a tagged error rather than a bare
+* `throw` so the failure has a name in the type and survives the process
+* boundary as data: the parent reads it back off the `InitError` reply.
+*/
+var SubjectModuleError = class extends Schema.TaggedError()("SubjectModuleError", {
+	modulePath: Schema.String,
+	namedExport: Schema.String
+}) {};
+/**
+* This half produced a message its own schema refuses to encode. Unlike a decode
+* failure there is no honest way to answer it on the wire - the reply itself is
+* what is broken - so it stays a defect this process raises rather than a value
+* it sends.
+*/
+var ProtocolEncodeError = class extends Schema.TaggedError()("ProtocolEncodeError", { reason: Schema.String }) {};
+//#endregion
+//#region src/worker-pool/child-process-proxy-worker.ts
+/**
+* This half's two directions, built once from the declared schemas. Three
+* properties matter and each is load-bearing:
+*
+* - The JSON boundary belongs to the schema. A hand-written `JSON.stringify`
+*   step is not schema-aware, so it drops a member the decoder then demands and
+*   the two halves of one format disagree.
+* - They return an `Exit`, never throwing. A decode failure on a process
+*   boundary is an expected outcome, so it is a value this code must answer for
+*   rather than an exception that leaves the type unmarked.
+* - They take `unknown`, so the envelope codec performs the only narrowing this
+*   half needs. A separate `S.Json` check on the payload would guard the same
+*   bytes twice: `args` and `result` are declared `S.Json`, so these already
+*   reject anything the wire cannot carry.
+*/
+const decodeWorkerMessage = Schema.decodeUnknownExit(Schema.fromJsonString(WorkerMessageSchema));
+const encodeParentMessage = Schema.encodeUnknownExit(Schema.fromJsonString(ParentMessageSchema));
+/**
+* The two runtime narrowings this worker cannot derive statically, because both
+* subjects arrive from a path decided at runtime. They are type guards rather
+* than schemas on purpose: a `Schema.declare` whose predicate only asks
+* `typeof x === 'function'` states far more than it decides, and it cannot be
+* generated, round-tripped or held to any law - the schema law suite refuses it.
+*/
+const isCallableMember = (input) => typeof input === "function";
+const isSubjectClass = (input) => typeof input === "function";
+var ChildProcessProxyWorker = class ChildProcessProxyWorker {
+	injectorFactory;
+	log;
+	injector;
+	realSubject;
+	constructor(injectorFactory) {
+		this.injectorFactory = injectorFactory;
+		process.on("message", this.handleMessage);
+		this.send({ kind: 0 });
+		this.injector = this.injectorFactory();
+	}
+	send(value) {
+		const encoded = encodeParentMessage(value);
+		if (Exit.isFailure(encoded)) throw new ProtocolEncodeError({ reason: String(encoded.cause) });
+		if (process.send) process.send(encoded.value);
+	}
+	handleMessage = (serializedMessage) => {
+		const decoded = decodeWorkerMessage(serializedMessage);
+		if (Exit.isFailure(decoded)) {
+			this.send({
+				error: String(decoded.cause),
+				kind: 2
+			});
+			return;
+		}
+		const message = decoded.value;
+		switch (message.kind) {
+			case 0:
+				this.handleInit(message);
+				this.removeAnyAdditionalMessageListeners(this.handleMessage);
+				break;
+			case 1:
+				this.handleCall(message);
+				this.removeAnyAdditionalMessageListeners(this.handleMessage);
+				break;
+			case 2: {
+				const sendCompleted = () => {
+					this.send({ kind: 5 });
+				};
+				this.injector.dispose().then(sendCompleted).catch(sendCompleted);
+				break;
+			}
+		}
+	};
+	async handleInit(message) {
+		try {
+			this.handlePromiseRejections();
+			const pluginInjector = provideLogging(await provideLoggingClient(this.injector, message.loggingServerAddress, minPriority(message.options.logLevel, message.options.fileLogLevel))).provideValue(commonTokens.options, message.options).provideValue(commonTokens.fileDescriptions, message.fileDescriptions);
+			this.log = pluginInjector.resolve(commonTokens.getLogger)(ChildProcessProxyWorker.name);
+			const { pluginsByKind: pluginsByKind$1 } = await pluginInjector.injectClass(PluginLoader).load(message.pluginModulePaths);
+			const workingDir = path.resolve(message.workingDirectory);
+			const injector = pluginInjector.provideValue(pluginsByKind, pluginsByKind$1).provideValue(commonTokens.sandboxDirectory, workingDir).provideClass(pluginCreator, PluginCreator);
+			const childModule = await import(message.modulePath);
+			const namedExport = Schema.decodeUnknownSync(Schema.Record(Schema.String, Schema.Unknown))(childModule)[message.namedExport];
+			if (!isSubjectClass(namedExport)) throw new SubjectModuleError({
+				modulePath: message.modulePath,
+				namedExport: message.namedExport
+			});
+			const RealSubjectClass = namedExport;
+			if (process.cwd() !== workingDir) {
+				this.log.debug(`Changing current working directory for this process to ${workingDir}`);
+				process.chdir(workingDir);
+			}
+			this.realSubject = injector.injectClass(RealSubjectClass);
+			this.send({ kind: 1 });
+		} catch (err) {
+			this.send({
+				error: errorToString(err),
+				kind: 2
+			});
+		}
+	}
+	async handleCall(message) {
+		try {
+			const result = await this.doCall(message);
+			this.send({
+				correlationId: message.correlationId,
+				kind: 3,
+				result: result ?? null
+			});
+		} catch (err) {
+			this.send({
+				correlationId: message.correlationId,
+				error: errorToString(err),
+				kind: 4
+			});
+		}
+	}
+	doCall(message) {
+		const realSubject = this.realSubject;
+		if (realSubject === void 0) throw new Error("Cannot call methods on the real subject before the child process is initialized.");
+		const subjectMember = realSubject[message.methodName];
+		if (isCallableMember(subjectMember)) return Reflect.apply(subjectMember, realSubject, message.args);
+		else return subjectMember;
+	}
+	/**
+	* Remove any addition message listeners that might me eavesdropping.
+	* the @ngtools/webpack plugin listens to messages and throws an error whenever it could not handle a message
+	* @see https://github.com/angular/angular-cli/blob/f776d3cf7982b64734c57fe4407434e9f4ec09f7/packages/%40ngtools/webpack/src/type_checker.ts#L79
+	* @param exceptListener The listener that should remain
+	*/
+	removeAnyAdditionalMessageListeners(exceptListener) {
+		process.listeners("message").forEach((listener) => {
+			if (listener !== exceptListener) {
+				this.log?.debug("Removing an additional message listener, we don't want eavesdropping on our inter-process communication: %s", listener.toString());
+				process.removeListener("message", listener);
+			}
+		});
+	}
+	/**
+	* During mutation testing, it's to be expected that promise rejections are not handled synchronously anymore (or not at all)
+	* Let's handle those events so future versions of node don't crash
+	* See issue 350: https://github.com/stryker-mutator/stryker-js/issues/350
+	*/
+	handlePromiseRejections() {
+		const unhandledRejections = [];
+		process.on("unhandledRejection", (reason, promise) => {
+			const unhandledPromiseId = unhandledRejections.push(promise);
+			this.log?.debug(`UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: ${unhandledPromiseId}): ${errorToString(reason)}`);
+		});
+		process.on("rejectionHandled", (promise) => {
+			const unhandledPromiseId = unhandledRejections.indexOf(promise) + 1;
+			this.log?.debug(`PromiseRejectionHandledWarning: Promise rejection was handled asynchronously (rejection id: ${unhandledPromiseId})`);
+		});
+	}
+};
+//#endregion
+export { provideLogging as a, WorkerMessageSchema as i, ProtocolEncodeError as n, provideLoggingBackend as o, ParentMessageSchema as r, ChildProcessProxyWorker as t };

package/dist/child-process-proxy-worker-main.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/child-process-proxy-worker-main.mjs

@@ -0,0 +1,6 @@
+import { t as ChildProcessProxyWorker } from "./child-process-proxy-worker-lx1M5Mz3.mjs";
+import { createInjector } from "typed-inject";
+//#region src/worker-pool/child-process-proxy-worker-main.ts
+new ChildProcessProxyWorker(createInjector);
+//#endregion
+export {};

package/dist/child-process-test-runner-worker-BTWRYb8V.mjs

@@ -0,0 +1,50 @@
+import { P as pluginCreator } from "./plugins-Nx86IJQW.mjs";
+import "@systemfsoftware/stryker-js-plugin-api/core";
+import { PluginKind, commonTokens, tokens } from "@systemfsoftware/stryker-js-plugin-api/plugin";
+import { errorToString } from "@stryker-mutator/util";
+import * as S from "effect/Schema";
+import { DryRunStatus, MutantRunStatus } from "@systemfsoftware/stryker-js-plugin-api/test-runner";
+//#region src/test-runner/mutant-coverage.schema.ts
+/**
+* The coverage document the instrumented test bundle accumulates:
+* hit counts per mutant id, both statically (once per test file) and per
+* test id.
+*/
+const MutantCoverageSchema = S.Struct({
+	static: S.Record(S.String, S.Finite),
+	perTest: S.Record(S.String, S.Record(S.String, S.Finite))
+});
+//#endregion
+//#region src/test-runner/child-process-test-runner-worker.ts
+var ChildProcessTestRunnerWorker = class {
+	underlyingTestRunner;
+	static inject = tokens(commonTokens.options, pluginCreator);
+	constructor({ testRunner }, pluginCreator) {
+		this.underlyingTestRunner = pluginCreator.create(PluginKind.TestRunner, testRunner);
+	}
+	async capabilities() {
+		return this.underlyingTestRunner.capabilities();
+	}
+	async init() {
+		if (this.underlyingTestRunner.init) await this.underlyingTestRunner.init();
+	}
+	async dispose() {
+		if (this.underlyingTestRunner.dispose) await this.underlyingTestRunner.dispose();
+	}
+	async dryRun(options) {
+		const dryRunResult = await this.underlyingTestRunner.dryRun(options);
+		if (dryRunResult.status === DryRunStatus.Complete && !dryRunResult.mutantCoverage && options.coverageAnalysis !== "off") {
+			const mutantCoverage = S.decodeUnknownSync(S.optional(MutantCoverageSchema))(globalThis.__mutantCoverage__);
+			if (mutantCoverage !== void 0) dryRunResult.mutantCoverage = mutantCoverage;
+		}
+		if (dryRunResult.status === DryRunStatus.Error) dryRunResult.errorMessage = errorToString(dryRunResult.errorMessage);
+		return dryRunResult;
+	}
+	async mutantRun(options) {
+		const result = await this.underlyingTestRunner.mutantRun(options);
+		if (result.status === MutantRunStatus.Error) result.errorMessage = errorToString(result.errorMessage);
+		return result;
+	}
+};
+//#endregion
+export { ChildProcessTestRunnerWorker as t };

package/dist/child-process-test-runner-worker.d.mts

@@ -0,0 +1,16 @@
+import { r as PluginCreator } from "./index-CyOSz6LC.mjs";
+import { StrykerOptions } from "@systemfsoftware/stryker-js-plugin-api/core";
+import { DryRunOptions, DryRunResult, MutantRunOptions, MutantRunResult, TestRunner, TestRunnerCapabilities } from "@systemfsoftware/stryker-js-plugin-api/test-runner";
+//#region src/test-runner/child-process-test-runner-worker.d.ts
+declare class ChildProcessTestRunnerWorker implements TestRunner {
+  private readonly underlyingTestRunner;
+  static inject: ["options", "pluginCreator"];
+  constructor({ testRunner }: StrykerOptions, pluginCreator: PluginCreator);
+  capabilities(): Promise<TestRunnerCapabilities>;
+  init(): Promise<void>;
+  dispose(): Promise<void>;
+  dryRun(options: DryRunOptions): Promise<DryRunResult>;
+  mutantRun(options: MutantRunOptions): Promise<MutantRunResult>;
+}
+//#endregion
+export { ChildProcessTestRunnerWorker };

package/dist/child-process-test-runner-worker.mjs

@@ -0,0 +1,2 @@
+import { t as ChildProcessTestRunnerWorker } from "./child-process-test-runner-worker-BTWRYb8V.mjs";
+export { ChildProcessTestRunnerWorker };

package/dist/config/base.d.mts

@@ -0,0 +1,21 @@
+import { StrykerOptionsSchema } from "@systemfsoftware/stryker-js-plugin-api/core";
+import * as S from "effect/Schema";
+//#region src/config/base-preset.d.ts
+/**
+ * The document a config file holds: the schema's INPUT side, before
+ * defaults are applied. Typed against the schema instead of the decoded
+ * `StrykerOptions` because this file is a template for user config files,
+ * not a resolved option set — and the deep-partial of the decoded type
+ * collapses array fields (`never[]`) that this document legitimately sets.
+ */
+type BasePreset = S.Codec.Encoded<typeof StrykerOptionsSchema>;
+/**
+ * Modal Stryker options, inherited via
+ * `"extends": "@systemfsoftware/stryker-js-mutation-run/config/base"`.
+ *
+ * Relative paths below resolve against the working directory of the run that
+ * reads them — the consuming package — not against this file.
+ */
+declare const basePreset: BasePreset;
+//#endregion
+export { basePreset as default };