@systemfsoftware/stryker-js-cli 8.0.1 → 9.0.0

package/dist/worker-runtime-DNtUUMeD.mjs

@@ -1,697 +0,0 @@
-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 };