@systemfsoftware/stryker-js-cli 7.0.1 → 8.0.1

package/dist/worker-runtime-DNtUUMeD.mjs

@@ -0,0 +1,697 @@
+import { $n as make$2, $r as interrupt, Aa as forkUnsafe, Ai as runForkWith, Ao as ParentSpan, As as isSome, Bi as suspend, Cc as identity, Ci as provideService, Da as addFinalizerExit, Dr as catchDefect, Ea as addFinalizer, Er as catchCause, Fa as UnhandledLogLevel, Ga as interrupt$1, Gr as forkChild, Ha as die, Hr as fnUntraced, Ia as _await, Jr as forkScoped, Kt as encodeSync, La as doneUnsafe, Lr as ensuring, Ma as makeUnsafe, Mn as runForEachArray, Mo as TaggedError, Na as provide, Ni as scope, Nr as context, Oa as close, Pi as scoped, Ri as succeed, Sc as flow, Si as provideContext, So as reportCauseUnsafe, Sr as annotateLogs, Ta as Scope, Tr as callback, Ua as fail, Ui as tapCause, Va as makeUnsafe$2, Vi as sync, Vr as flatMap, Vt as decodeUnknownEffect, Xr as gen, Ya as void_$1, _a as effectDiscard, _c as constTrue, _r as acquireRelease, ar as offer, bc as constant, cr as take, do as squash, dr as getCurrent, ds as getOrUndefinedUnsafe, fs as getUnsafe, gi as onExit, gs as omit, ha as effect, hr as runIn, ia as withFiber, ii as logFatal, io as hasInterrupts, ir as make$4, ja as make$3, jo as externalSpan, ka as closeUnsafe, ki as runFork, kr as catchReason, ln as defaultFormatter, lo as map, lr as takeAll, ls as get, mc as isTagged, ms as makeUnsafe$1, ni as logDebug, oa as withSpan, os as Service, ot as Any, pa as catchDone, pi as matchEffect, qt as encodeUnknownEffect, ra as whileLoop, ro as hasDies, si as logWithLevel, ss as add, ta as void_, ti as isEffect, ui as mapError, uo as pretty, us as getOrUndefined, ut as Defect, vi as orDie, vt as NonEmptyArray, wc as pipe, wi as raceFirst, xr as andThen, ya as launch, yc as constVoid, yr as addFinalizer$1, za as isDeferred, zi as succeedNone, zr as fail$1 } from "./dist-CgglvcIb.mjs";
+import { B as ServerClient, F as RpcSerialization, G as isStreamSchema, H as isWrapper, J as CloseEvent, K as Collector, L as RequestId, P as withRun, Q as fromInput, R as ResponseDefectEncoded, U as ClientAbort, V as exitSchema, W as getStreamSchemas, X as SocketError, Y as SocketCloseError, Z as SocketOpenError, a as NetSocket, ft as makeUnsafe$3, o as fromDuplex, q as makeCollectorUnsafe, z as constPong } from "./node-ZeTkblqG.mjs";
+import * as Net from "node:net";
+//#region ../../../node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/unstable/socket/SocketServer.js
+/**
+* Service contract for servers that accept socket connections.
+*
+* `SocketServer` exposes the bound server `address` and a long-running `run`
+* loop that hands each accepted connection to a handler as a `Socket.Socket`.
+* The module also defines TCP and Unix socket address models plus the
+* server-level errors reported while opening or running a server. Platform
+* layers provide concrete implementations of this service.
+*
+* @since 4.0.0
+*/
+/**
+* Context service for a socket server, exposing its bound address and a run
+* loop that handles each accepted `Socket`.
+*
+* @category services
+* @since 4.0.0
+*/
+var SocketServer = class extends Service()("@effect/platform/SocketServer") {};
+/**
+* Runtime type identifier attached to `SocketServerError` values.
+*
+* @category type IDs
+* @since 4.0.0
+*/
+const ErrorTypeId = "@effect/platform/SocketServer/SocketServerError";
+/**
+* Error reason for failures that occur while opening a socket server.
+*
+* @category errors
+* @since 4.0.0
+*/
+var SocketServerOpenError = class extends TaggedError("SocketServerOpenError") {
+	get message() {
+		return "Open";
+	}
+};
+TaggedError("SocketServerUnknownError");
+/**
+* Tagged socket server error that wraps a server error reason and exposes its
+* cause.
+*
+* @category errors
+* @since 4.0.0
+*/
+var SocketServerError = class extends TaggedError("SocketServerError") {
+	constructor(props) {
+		super({
+			...props,
+			cause: props.reason.cause
+		});
+	}
+	/**
+	* Marks this value as a socket server error for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ErrorTypeId] = ErrorTypeId;
+	/**
+	* Delegates the public message to the underlying socket server error reason.
+	*
+	* @since 4.0.0
+	*/
+	get message() {
+		return this.reason.message;
+	}
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/unstable/rpc/RpcServer.js
+/**
+* Creates an RPC server for an already-decoded message channel, running
+* handlers for a group and sending decoded server responses through
+* `onFromServer`.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const makeNoSerialization = /*#__PURE__*/ fnUntraced(function* (group, options) {
+	const enableTracing = options.disableTracing !== true;
+	const enableSpanPropagation = options.disableSpanPropagation !== true;
+	const supportsAck = options.disableClientAcks !== true;
+	const spanPrefix = options.spanPrefix ?? "RpcServer";
+	const concurrency = options.concurrency ?? "unbounded";
+	const disableFatalDefects = options.disableFatalDefects ?? false;
+	const services = yield* context();
+	const scope = get(services, Scope);
+	const trackFiber = runIn(forkUnsafe(scope, "parallel"));
+	const concurrencySemaphore = concurrency === "unbounded" ? void 0 : yield* make$2(concurrency);
+	const clients = /* @__PURE__ */ new Map();
+	let isShutdown = false;
+	const shutdownLatch = makeUnsafe$3(false);
+	yield* addFinalizer(scope, withFiber((parent) => {
+		isShutdown = true;
+		for (const client of clients.values()) {
+			client.ended = true;
+			if (client.fibers.size === 0) {
+				trackFiber(runForkWith(services)(endClient(client)));
+				continue;
+			}
+			for (const fiber of client.fibers.values()) fiber.interruptUnsafe(parent.id);
+		}
+		if (clients.size === 0) return void_;
+		return shutdownLatch.await;
+	}));
+	const disconnect = (clientId) => withFiber((parent) => {
+		const client = clients.get(clientId);
+		if (!client) return void_;
+		for (const fiber of client.fibers.values()) fiber.interruptUnsafe(parent.id);
+		clients.delete(clientId);
+		return void_;
+	});
+	const write = (clientId, message, opts) => catchDefect(withFiber((requestFiber) => {
+		if (isShutdown) return interrupt;
+		let client = clients.get(clientId);
+		if (!client) {
+			client = {
+				id: clientId,
+				latches: /* @__PURE__ */ new Map(),
+				fibers: /* @__PURE__ */ new Map(),
+				ended: false,
+				serverClient: new ServerClient(clientId)
+			};
+			clients.set(clientId, client);
+		} else if (client.ended) return interrupt;
+		switch (message._tag) {
+			case "Request": return handleRequest(requestFiber, client, message, opts);
+			case "Ack": {
+				const latch = client.latches.get(message.requestId);
+				return latch ? latch.open : void_;
+			}
+			case "Interrupt": {
+				const fiber = client.fibers.get(message.requestId);
+				if (fiber) {
+					fiber.interruptUnsafe(requestFiber.id, ClientAbort.annotation);
+					return void_;
+				}
+				return options.onFromServer({
+					_tag: "Exit",
+					clientId,
+					requestId: message.requestId,
+					exit: interrupt$1()
+				});
+			}
+			case "Eof":
+				client.ended = true;
+				if (client.fibers.size > 0) return void_;
+				return endClient(client);
+			default: return sendDefect(client, `Unknown request tag: ${message._tag}`);
+		}
+	}), (defect) => sendDefect(clients.get(clientId), defect));
+	const endClient = (client) => {
+		clients.delete(client.id);
+		const write = options.onFromServer({
+			_tag: "ClientEnd",
+			clientId: client.id
+		});
+		if (isShutdown && clients.size === 0) return andThen(write, shutdownLatch.open);
+		return write;
+	};
+	const handleRequest = (requestFiber, client, request, opts) => {
+		if (client.fibers.has(request.id)) return interrupt;
+		const rpc = group.requests.get(request.tag);
+		const entry = getOrUndefinedUnsafe(services, rpc?.key);
+		if (!rpc || !entry) {
+			const write = catchDefect(options.onFromServer({
+				_tag: "Exit",
+				clientId: client.id,
+				requestId: request.id,
+				exit: die(`Unknown request tag: ${request.tag}`)
+			}), (defect) => sendDefect(client, defect));
+			if (!client.ended || client.fibers.size > 0) return write;
+			return ensuring(write, endClient(client));
+		}
+		const isStream = isStreamSchema(rpc.successSchema);
+		const metadata = {
+			rpc,
+			client: client.serverClient,
+			requestId: request.id,
+			headers: request.headers,
+			payload: request.payload
+		};
+		const result = entry.handler(request.payload, metadata);
+		const isWrapper$1 = isWrapper(result);
+		const isFork = isWrapper$1 && result.fork;
+		const isUninterruptible = isWrapper$1 && result.uninterruptible;
+		const streamOrEffect = isWrapper$1 ? result.value : result;
+		const handler = isStream ? streamEffect(client, request, streamOrEffect) : streamOrEffect;
+		const withMiddleware = rpc.middlewares.size > 0 ? applyMiddleware(services, handler, metadata) : handler;
+		let responded = false;
+		const scope = makeUnsafe();
+		let deferred = void 0;
+		let effect = onExit(withMiddleware, (exit) => {
+			responded = true;
+			let write;
+			if (exit._tag === "Success") {
+				if (isDeferred(exit.value)) {
+					deferred = exit.value;
+					write = void_;
+				} else write = options.onFromServer({
+					_tag: "Exit",
+					clientId: client.id,
+					requestId: request.id,
+					exit
+				});
+			} else if (!disableFatalDefects && hasDies(exit.cause) && !hasInterrupts(exit.cause)) write = sendDefect(client, squash(exit.cause));
+			else write = options.onFromServer({
+				_tag: "Exit",
+				clientId: client.id,
+				requestId: request.id,
+				exit
+			});
+			const close = closeUnsafe(scope, exit);
+			if (exit._tag === "Failure") reportCauseUnsafe(getCurrent(), exit.cause);
+			return close ? ensuring(write, close) : write;
+		});
+		if (opts?.onRequest) effect = opts.onRequest(effect);
+		if (enableTracing) {
+			const parentSpan = getOrUndefined(requestFiber.context, ParentSpan);
+			effect = withSpan(effect, `${spanPrefix}.${request.tag}`, {
+				captureStackTrace: false,
+				attributes: options.spanAttributes,
+				parent: enableSpanPropagation && request.spanId ? externalSpan({
+					traceId: request.traceId,
+					spanId: request.spanId,
+					sampled: request.sampled
+				}) : void 0,
+				links: enableSpanPropagation && parentSpan ? [{
+					span: parentSpan,
+					attributes: {}
+				}] : void 0
+			});
+		}
+		if (!isFork && concurrencySemaphore) effect = concurrencySemaphore.withPermit(effect);
+		const context = new Map(entry.context.mapUnsafe);
+		requestFiber.context.mapUnsafe.forEach((value, key) => context.set(key, value));
+		context.set(Scope.key, scope);
+		const runFork = runForkWith(makeUnsafe$1(context));
+		const fiber = trackFiber(runFork(effect, isUninterruptible ? { uninterruptible: true } : void 0));
+		client.fibers.set(request.id, fiber);
+		fiber.addObserver(function onExit$1(exit) {
+			if (deferred) {
+				const fiber = trackFiber(runFork(onExit(_await(deferred), (exit) => options.onFromServer({
+					_tag: "Exit",
+					clientId: client.id,
+					requestId: request.id,
+					exit
+				}))));
+				client.fibers.set(request.id, fiber);
+				deferred = void 0;
+				fiber.addObserver(onExit$1);
+				return;
+			}
+			if (!responded && exit._tag === "Failure") trackFiber(runFork(options.onFromServer({
+				_tag: "Exit",
+				clientId: client.id,
+				requestId: request.id,
+				exit: interrupt$1()
+			})));
+			client.fibers.delete(request.id);
+			client.latches.delete(request.id);
+			if (client.ended && client.fibers.size === 0) trackFiber(runFork(endClient(client)));
+		});
+		return void_;
+	};
+	const streamEffect = (client, request, stream) => {
+		let latch = client.latches.get(request.id);
+		if (supportsAck && !latch) {
+			latch = makeUnsafe$3(false);
+			client.latches.set(request.id, latch);
+		}
+		if (isEffect(stream)) return stream.pipe(flatMap((queue) => whileLoop({
+			while: constTrue,
+			body: constant(flatMap(takeAll(queue), (values) => {
+				const write = options.onFromServer({
+					_tag: "Chunk",
+					clientId: client.id,
+					requestId: request.id,
+					values
+				});
+				if (!latch) return write;
+				latch.closeUnsafe();
+				return flatMap(write, () => latch.await);
+			})),
+			step: constVoid
+		})), catchDone(() => void_), scoped);
+		return runForEachArray(stream, (values) => {
+			const write = options.onFromServer({
+				_tag: "Chunk",
+				clientId: client.id,
+				requestId: request.id,
+				values
+			});
+			if (!latch) return write;
+			latch.closeUnsafe();
+			return andThen(write, latch.await);
+		});
+	};
+	const sendDefect = (client, defect) => suspend(() => {
+		const shouldEnd = client.ended && client.fibers.size === 0;
+		const write = options.onFromServer({
+			_tag: "Defect",
+			clientId: client.id,
+			defect
+		});
+		if (!shouldEnd) return write;
+		return andThen(write, endClient(client));
+	});
+	return identity({
+		write,
+		disconnect
+	});
+});
+const applyMiddleware = (context, handler, options) => {
+	for (const service of options.rpc.middlewares) handler = getUnsafe(context, service)(handler, options);
+	return handler;
+};
+/**
+* Runs an RPC server for a group using the current server `Protocol`, decoding
+* requests, invoking handlers, encoding responses, and managing in-flight
+* request lifetime.
+*
+* @category running
+* @since 4.0.0
+*/
+const make$1 = /*#__PURE__*/ fnUntraced(function* (group, options) {
+	const { codecFor, disconnects, end, run, send, supportsAck, supportsSpanPropagation, supportsTransferables } = yield* Protocol;
+	const encodeDefectUnsafe = encodeSync(codecFor(Defect()));
+	const services = yield* context();
+	const scope = yield* make$3();
+	const server = yield* makeNoSerialization(group, {
+		...options,
+		disableClientAcks: !supportsAck,
+		disableSpanPropagation: !supportsSpanPropagation,
+		onFromServer(response) {
+			const client = clients.get(response.clientId);
+			if (!client) return void_;
+			switch (response._tag) {
+				case "Chunk": {
+					const schemas = client.schemas.get(response.requestId);
+					if (!schemas) return void_;
+					return handleEncode(client, response.requestId, schemas.encodeDefect, schemas.collector, provideContext(schemas.encodeChunk(response.values), schemas.context), (values) => ({
+						_tag: "Chunk",
+						requestId: response.requestId,
+						values
+					}));
+				}
+				case "Exit": {
+					const schemas = client.schemas.get(response.requestId);
+					if (!schemas) return void_;
+					client.schemas.delete(response.requestId);
+					return handleEncode(client, response.requestId, schemas.encodeDefect, schemas.collector, provideContext(schemas.encodeExit(response.exit), schemas.context), (exit) => ({
+						_tag: "Exit",
+						requestId: response.requestId,
+						exit
+					}));
+				}
+				case "Defect": return sendDefect(client, response.defect);
+				case "ClientEnd":
+					clients.delete(response.clientId);
+					return end(response.clientId);
+			}
+		}
+	}).pipe(provide(scope));
+	yield* forkChild(whileLoop({
+		while: constTrue,
+		body: constant(flatMap(take(disconnects), (clientId) => {
+			clients.delete(clientId);
+			return server.disconnect(clientId);
+		})),
+		step: constVoid
+	}));
+	const schemasCache = /* @__PURE__ */ new WeakMap();
+	const getSchemas = (rpc) => {
+		let schemas = schemasCache.get(rpc);
+		if (!schemas) {
+			const entry = getOrUndefinedUnsafe(services, rpc.key);
+			const streamSchemas = getStreamSchemas(rpc.successSchema);
+			schemas = {
+				decode: decodeUnknownEffect(codecFor(rpc.payloadSchema)),
+				encodeChunk: encodeUnknownEffect(codecFor(NonEmptyArray(isSome(streamSchemas) ? streamSchemas.value.success : Any))),
+				encodeExit: encodeUnknownEffect(codecFor(exitSchema(rpc))),
+				encodeDefect: encodeUnknownEffect(codecFor(rpc.defectSchema)),
+				context: entry.context
+			};
+			schemasCache.set(rpc, schemas);
+		}
+		return schemas;
+	};
+	const clients = /* @__PURE__ */ new Map();
+	const handleEncode = (client, requestId, encodeDefect, collector, effect, onSuccess) => (collector ? provideService(effect, Collector, collector) : effect).pipe(flatMap((a) => send(client.id, onSuccess(a), collector && collector.clearUnsafe())), catchCause((cause) => {
+		client.schemas.delete(requestId);
+		const defect = squash(map(cause, (e) => defaultFormatter(e.issue)));
+		return andThen(sendRequestDefect(client, requestId, encodeDefect, defect), server.write(client.id, {
+			_tag: "Interrupt",
+			requestId,
+			interruptors: []
+		}));
+	}));
+	const sendRequestDefect = (client, requestId, encodeDefect, defect) => catchCause(flatMap(encodeDefect(defect), (encodedDefect) => send(client.id, {
+		_tag: "Exit",
+		requestId,
+		exit: {
+			_tag: "Failure",
+			cause: [{
+				_tag: "Die",
+				defect: encodedDefect
+			}]
+		}
+	})), (cause) => sendDefect(client, squash(cause)));
+	const sendDefect = (client, defect) => catchCause(send(client.id, ResponseDefectEncoded(encodeDefectUnsafe(defect))), (cause) => annotateLogs(logDebug(cause), {
+		module: "RpcServer",
+		method: "sendDefect"
+	}));
+	return yield* run((clientId, request) => {
+		let client = clients.get(clientId);
+		if (!client) {
+			client = {
+				id: clientId,
+				schemas: /* @__PURE__ */ new Map()
+			};
+			clients.set(clientId, client);
+		}
+		switch (request._tag) {
+			case "Request": {
+				const tag = Object.hasOwn(request, "tag") ? request.tag : "";
+				let requestId;
+				switch (typeof request.id) {
+					case "number":
+					case "string":
+						requestId = RequestId(request.id);
+						break;
+					default: return sendDefect(client, `Invalid request id: ${request.id}`);
+				}
+				const rpc = group.requests.get(tag);
+				if (!rpc) return sendRequestDefect(client, requestId, (defect) => succeed(defect), `Unknown request tag: ${tag}`);
+				const schemas = getSchemas(rpc);
+				return matchEffect(provideContext(schemas.decode(request.payload), schemas.context), {
+					onFailure: (error) => sendRequestDefect(client, requestId, schemas.encodeDefect, defaultFormatter(error.issue)),
+					onSuccess: (payload) => {
+						client.schemas.set(requestId, supportsTransferables ? {
+							...schemas,
+							collector: makeCollectorUnsafe()
+						} : schemas);
+						return server.write(clientId, {
+							...request,
+							id: requestId,
+							payload,
+							headers: fromInput(request.headers)
+						});
+					}
+				});
+			}
+			case "Ping": return catchCause(send(client.id, constPong), (cause) => sendDefect(client, squash(cause)));
+			case "Eof": return server.write(clientId, request);
+			case "Ack": return server.write(clientId, {
+				...request,
+				requestId: RequestId(request.requestId)
+			});
+			case "Interrupt": return server.write(clientId, {
+				...request,
+				requestId: RequestId(request.requestId),
+				interruptors: []
+			});
+			default: return sendDefect(client, `Unknown request tag: ${request._tag}`);
+		}
+	}).pipe(tapCause((cause) => logFatal("BUG: RpcServer protocol crashed", cause)), onExit((exit) => close(scope, exit)));
+});
+/**
+* Provides a scoped layer that starts an RPC server for a group using the
+* current server `Protocol`.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer$1 = (group, options) => effectDiscard(forkScoped(make$1(group, options)));
+/**
+* Defines the service interface for an RPC server transport, responsible for receiving
+* encoded client messages, sending encoded responses, tracking clients, and
+* declaring transport capabilities.
+*
+* **When to use**
+*
+* Use to provide the transport boundary for RPC servers over HTTP, WebSocket,
+* workers, sockets, or custom protocols.
+*
+* @category services
+* @since 4.0.0
+*/
+var Protocol = class extends Service()("effect/rpc/RpcServer/Protocol") {
+	/**
+	* Creates a server protocol service from the supplied RPC implementation.
+	*
+	* @since 4.0.0
+	*/
+	static make = /*#__PURE__*/ withRun();
+};
+/**
+* Creates a server `Protocol` backed by the current `SocketServer`, accepting
+* socket connections and routing decoded RPC messages.
+*
+* @category protocols
+* @since 4.0.0
+*/
+const makeProtocolSocketServer = /*#__PURE__*/ gen(function* () {
+	const server = yield* SocketServer;
+	const { onSocket, protocol } = yield* makeSocketProtocol;
+	yield* forkScoped(server.run(fnUntraced(onSocket, scoped)));
+	return protocol;
+});
+/**
+* RPC protocol that uses `SocketServer` for communication.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layerProtocolSocketServer = /*#__PURE__*/ effect(Protocol)(makeProtocolSocketServer);
+const makeSocketProtocol = /*#__PURE__*/ gen(function* () {
+	const serialization = yield* RpcSerialization;
+	const encodeDefectUnsafe = encodeSync(serialization.codecFor(Defect()));
+	const disconnects = yield* make$4();
+	let clientId = 0;
+	const clients = /* @__PURE__ */ new Map();
+	const clientIds = /* @__PURE__ */ new Set();
+	let writeRequest;
+	const onSocket = function* (socket, headers) {
+		const scope$1 = yield* scope;
+		const parser = serialization.makeUnsafe();
+		const id = clientId++;
+		yield* addFinalizerExit(scope$1, () => {
+			clients.delete(id);
+			clientIds.delete(id);
+			return offer(disconnects, id);
+		});
+		const writeRaw = yield* socket.writer;
+		const write = (response) => {
+			try {
+				const encoded = parser.encode(response);
+				if (encoded === void 0) return void_;
+				return orDie(writeRaw(encoded));
+			} catch (cause) {
+				return orDie(writeRaw(parser.encode(ResponseDefectEncoded(encodeDefectUnsafe(cause)))));
+			}
+		};
+		clients.set(id, { write });
+		clientIds.add(id);
+		yield* socket.runRaw((data) => {
+			try {
+				const decoded = parser.decode(data);
+				if (decoded.length === 0) return void_;
+				let i = 0;
+				return whileLoop({
+					while: () => i < decoded.length,
+					body() {
+						const message = decoded[i++];
+						if (message._tag === "Request" && headers) message.headers = headers.concat(message.headers);
+						return writeRequest(id, message);
+					},
+					step: constVoid
+				});
+			} catch (cause) {
+				if (isTagged(cause, "MaxBufferSizeExceeded")) return writeRaw(new CloseEvent(1009, String(cause)));
+				return writeRaw(parser.encode(ResponseDefectEncoded(encodeDefectUnsafe(cause))));
+			}
+		}).pipe(catchReason("SocketError", "SocketCloseError", (_) => void_), orDie);
+	};
+	return {
+		protocol: yield* Protocol.make((writeRequest_) => {
+			writeRequest = writeRequest_;
+			return succeed({
+				disconnects,
+				send: (clientId, response) => {
+					const client = clients.get(clientId);
+					if (!client) return void_;
+					return orDie(client.write(response));
+				},
+				end(_clientId) {
+					return void_;
+				},
+				clientIds: sync(() => clientIds),
+				initialMessage: succeedNone,
+				supportsAck: true,
+				supportsTransferables: false,
+				supportsSpanPropagation: true,
+				supportsNotifications: true,
+				codecFor: serialization.codecFor
+			});
+		}),
+		onSocket
+	};
+});
+Service()("@effect/platform-node-shared/NodeSocketServer/IncomingMessage");
+/**
+* Provides a TCP `SocketServer` by creating and managing a scoped Node
+* `net.Server` with the supplied server and listen options.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer = /*#__PURE__*/ flow(/* @__PURE__ */ fnUntraced(function* (options) {
+	const errorDeferred = makeUnsafe$2();
+	const pending = /* @__PURE__ */ new Map();
+	function defaultOnConnection(conn) {
+		const remove = () => {
+			pending.delete(conn);
+			conn.off("close", remove);
+			conn.off("error", remove);
+		};
+		pending.set(conn, remove);
+		conn.on("close", remove);
+		conn.on("error", remove);
+	}
+	let onConnection = defaultOnConnection;
+	let server;
+	yield* addFinalizer$1(() => callback((resume) => {
+		pending.forEach((remove, conn) => {
+			remove();
+			conn.destroy();
+		});
+		server?.close(() => resume(void_));
+	}));
+	server = Net.createServer(options, (conn) => onConnection(conn));
+	server.on("error", (err) => doneUnsafe(errorDeferred, fail(err)));
+	yield* callback((resume) => {
+		server.listen(options, () => resume(void_));
+	}).pipe(raceFirst(mapError(_await(errorDeferred), (err) => new SocketServerError({ reason: new SocketServerOpenError({ cause: err }) }))));
+	const run = fnUntraced(function* (handler) {
+		const scope = yield* make$3();
+		const services = omit(Scope)(yield* context());
+		const trackFiber = runIn(scope);
+		const prevOnConnection = onConnection;
+		onConnection = function(conn) {
+			let error;
+			conn.on("error", (err) => {
+				error = err;
+			});
+			pipe(fromDuplex(acquireRelease(suspend(() => {
+				if (error) return fail$1(new SocketError({ reason: new SocketOpenError({
+					kind: "Unknown",
+					cause: error
+				}) }));
+				else if (conn.closed) return fail$1(new SocketError({ reason: new SocketCloseError({ code: 1e3 }) }));
+				return succeed(conn);
+			}), (conn) => sync(() => {
+				if (conn.closed === false) conn.destroySoon();
+			}))), flatMap(handler), catchCause(reportUnhandledError), runForkWith(add(services, NetSocket, conn)), trackFiber);
+		};
+		pending.forEach((remove, conn) => {
+			remove();
+			onConnection(conn);
+		});
+		return yield* callback((_resume) => {
+			return suspend(() => {
+				onConnection = prevOnConnection;
+				return close(scope, void_$1);
+			});
+		});
+	});
+	const address = server.address();
+	return SocketServer.of({
+		address: typeof address === "string" ? {
+			_tag: "UnixAddress",
+			path: address
+		} : {
+			_tag: "TcpAddress",
+			hostname: address.address,
+			port: address.port
+		},
+		run
+	});
+}), /*#__PURE__*/ effect(SocketServer));
+const reportUnhandledError = (cause) => withFiber((fiber) => {
+	const unhandledLogLevel = fiber.getRef(UnhandledLogLevel);
+	if (unhandledLogLevel) return logWithLevel(unhandledLogLevel)(cause, "Unhandled error in SocketServer");
+	return void_;
+});
+//#endregion
+//#region src/workers/worker-runtime.ts
+const workerSocketPath = (label) => {
+	const socketPath = process.env["STRYKER_SOCKET"];
+	if (socketPath === void 0) {
+		process.stderr.write(`${label}: STRYKER_SOCKET is not set\n`);
+		process.exit(1);
+	}
+	return socketPath;
+};
+const launchWorker = (main, label) => {
+	runFork(launch(main).pipe(tapCause((cause) => sync(() => {
+		process.stderr.write(`${label}: ${pretty(cause)}\n`);
+		process.exitCode = 1;
+	}))));
+};
+//#endregion
+export { layerProtocolSocketServer as a, layer$1 as i, workerSocketPath as n, layer as r, launchWorker as t };