alink-cli 0.7.2 → 0.7.4

package/dist/NodeHttpServer-BGJlR_Kf.mjs

@@ -0,0 +1,826 @@
+#!/usr/bin/env node
+
+import { $t as parseHeader, Ct as setHeader, E as toHandled, H as toPersisted, J as fromWebSocket, Mt as TypeId, N as TypeId$2, Nt as inspect, Qt as isEmpty, R as MultipartError, St as setBody, U as decodeField, V as makeConfig, W as make$5, _n as fromInput$1, a as layer$3, at as ResponseError, bt as removeHeader, c as make$6, cn as fromRecordUnsafe, ct as causeResponse, dt as HttpPlatform, fn as raw, ft as make$4, hn as uint8Array, i as RequestInit, in as layerWeak, it as RequestParseError, j as HttpServerRequest, jt as MaxBodySize, ln as merge, n as import_websocket_server, nt as ClientAbort, o as HttpServer, pn as stream$1, r as Mime_default, rn as layer$2, rt as HttpServerError, s as layerTestClient, sn as fromInput, st as ServeError, tn as toSetCookieHeaders, vt as raw$1, z as TypeId$1 } from "./NodeSocket-08w4osAf.mjs";
+import { $c as combine, $i as makeUnsafe, Aa as cached, Cs as void_, Do as matchCauseEffect, Dr as map$1, Es as withFiber, Fr as orDie, Ga as die, Kr as runForEachArray, Qa as flatMap, Qu as add, Sa as andThen, Sc as forkUnsafe, So as map, Tc as provide$1, Xa as failCause, Xo as scope, Ya as fail, Yo as runSync, _f as pipe, aa as runIn, as as suspend, cs as tapCause, dc as provideMerge, el as die$1, fc as succeed$1, gs as try_, hd as fromNullishOr, hf as flow, hs as tryPromise, ja as callback, lc as mergeAll, lu as seconds, ms as timeoutOrElse, ni as unwrap, no as fnUntraced, ns as succeed, os as sync, po as interruptible, qo as runForkWith, rc as effect, sc as fresh, uc as provide, va as acquireRelease, vc as addFinalizer, yc as addFinalizerExit, zd as Class } from "./Schema-B3i-HrZQ.mjs";
+import { c as layer$4, d as pipeThroughDuplex, f as toArrayBuffer, m as toUint8Array, n as layer$5, p as toString, u as fromReadable } from "./NodeServices-DDZTiw5K.mjs";
+import { h as unwrap$1 } from "./Config-Bj2ZPCsP.mjs";
+import { Duplex, Readable } from "node:stream";
+import * as Fs from "node:fs";
+import * as Http from "node:http";
+import * as NodeStreamP from "node:stream/promises";
+import { pipeline } from "node:stream/promises";
+import * as Zlib from "node:zlib";
+//#region ../../node_modules/.pnpm/@effect+platform-node@4.0.0-beta.103_bufferutil@4.1.0_effect@4.0.0-beta.103_patch_hash=_7eec308fcf6351488fccaf9a0edac255/node_modules/@effect/platform-node/dist/NodeHttpIncomingMessage.js
+/**
+* Adapter base for exposing Node `http.IncomingMessage` values as Effect HTTP
+* incoming messages.
+*
+* Server requests and Node client responses both arrive as Node readable
+* streams with raw header objects, socket metadata, and one-shot body
+* consumption. This module's `NodeHttpIncomingMessage` class keeps the original
+* Node message available while presenting Effect's `HttpIncomingMessage` shape:
+* typed headers, remote address lookup, stream access, and text, JSON,
+* URL-encoded, and array-buffer body readers.
+*
+* @since 4.0.0
+*/
+/**
+* Adapts a Node `IncomingMessage` to Effect HTTP incoming messages.
+*
+* **When to use**
+*
+* Use to implement Node HTTP request or response adapters that expose the
+* Effect HTTP incoming-message interface.
+*
+* **Details**
+*
+* The adapter exposes headers, remote address, stream access, and cached body
+* decoders. Subclasses provide the error mapping for unknown Node errors.
+*
+* @category constructors
+* @since 4.0.0
+*/
+var NodeHttpIncomingMessage = class extends Class {
+	/**
+	* Marks this value as an HTTP incoming message for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[TypeId];
+	source;
+	onError;
+	remoteAddressOverride;
+	constructor(source, onError, remoteAddressOverride) {
+		super();
+		this[TypeId] = TypeId;
+		this.source = source;
+		this.onError = onError;
+		this.remoteAddressOverride = remoteAddressOverride;
+	}
+	get headers() {
+		return fromInput(this.source.headers);
+	}
+	get remoteAddress() {
+		return this.remoteAddressOverride ?? fromNullishOr(this.source.socket.remoteAddress);
+	}
+	textEffect;
+	get text() {
+		if (this.textEffect) return this.textEffect;
+		this.textEffect = runSync(cached(flatMap(MaxBodySize, (maxBodySize) => toString(() => this.source, {
+			onError: this.onError,
+			maxBytes: maxBodySize
+		}))));
+		this.arrayBufferEffect = map(this.textEffect, (_) => new TextEncoder().encode(_).buffer);
+		return this.textEffect;
+	}
+	get textUnsafe() {
+		return runSync(this.text);
+	}
+	get json() {
+		return flatMap(this.text, (text) => try_({
+			try: () => text === "" ? null : JSON.parse(text),
+			catch: this.onError
+		}));
+	}
+	get jsonUnsafe() {
+		return runSync(this.json);
+	}
+	get urlParamsBody() {
+		return flatMap(this.text, (_) => try_({
+			try: () => fromInput$1(new URLSearchParams(_)),
+			catch: this.onError
+		}));
+	}
+	get stream() {
+		return fromReadable({
+			evaluate: () => this.source,
+			onError: this.onError
+		});
+	}
+	arrayBufferEffect;
+	get arrayBuffer() {
+		if (this.arrayBufferEffect) return this.arrayBufferEffect;
+		this.arrayBufferEffect = withFiber((fiber) => toArrayBuffer(() => this.source, {
+			onError: this.onError,
+			maxBytes: fiber.getRef(MaxBodySize)
+		})).pipe(cached, runSync);
+		this.textEffect = map(this.arrayBufferEffect, (_) => new TextDecoder().decode(_));
+		return this.arrayBufferEffect;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-beta.103_bufferutil@4.1.0_effect@4.0.0-beta.103_patc_c414c3b6e1e822e230993f828f7aeb31/node_modules/@effect/platform-node-shared/dist/NodeHttpCompression.js
+/**
+* HTTP response compression backed by `node:zlib`, shared by the Node.js, Bun,
+* and Deno platforms.
+*
+* Byte-array bodies are compressed in one shot with the asynchronous
+* `node:zlib` APIs, preserving an exact `Content-Length`. Streaming bodies go
+* through `node:zlib` transform streams that flush each input chunk.
+*
+* @since 4.0.0
+*/
+/**
+* The compression algorithms supported by the runtime's `node:zlib`. `zstd`
+* requires Node.js 22.15 or newer.
+*
+* @category constants
+* @since 4.0.0
+*/
+const algorithms = /*#__PURE__*/ new Set(typeof Zlib.zstdCompress === "function" ? [
+	"gzip",
+	"deflate",
+	"br",
+	"zstd"
+] : [
+	"gzip",
+	"deflate",
+	"br"
+]);
+const brotliParams = (level, sizeHint) => {
+	const params = {};
+	if (level !== void 0) params[Zlib.constants.BROTLI_PARAM_QUALITY] = level;
+	if (sizeHint !== void 0) params[Zlib.constants.BROTLI_PARAM_SIZE_HINT] = sizeHint;
+	return { params };
+};
+const zstdParams = (level) => level === void 0 || level === 3 ? void 0 : { params: { [Zlib.constants.ZSTD_c_compressionLevel]: level } };
+const compress = (data, algorithm, options) => callback((resume) => {
+	const complete = (error, result) => resume(error === null ? succeed(result) : die(error));
+	switch (algorithm) {
+		case "gzip":
+			Zlib.gzip(data, { level: options?.level }, complete);
+			break;
+		case "deflate":
+			Zlib.deflate(data, { level: options?.level }, complete);
+			break;
+		case "br":
+			Zlib.brotliCompress(data, brotliParams(options?.level, data.byteLength), complete);
+			break;
+		case "zstd": {
+			const params = zstdParams(options?.level);
+			if (params === void 0) Zlib.zstdCompress(data, complete);
+			else Zlib.zstdCompress(data, params, complete);
+			break;
+		}
+	}
+});
+/**
+* Creates a `Compression` that compresses byte-array bodies in one shot with
+* the asynchronous `node:zlib` APIs, setting the exact `Content-Length` of the
+* compressed body. All other bodies are delegated to `fallback`.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make$3 = (fallback) => ({
+	algorithms: fallback.algorithms,
+	compressResponse(response, algorithm, options) {
+		const body = response.body;
+		if (body._tag !== "Uint8Array") return fallback.compressResponse(response, algorithm, options);
+		return map(compress(body.body, algorithm, options), (result) => setHeader(setBody(response, uint8Array(result, body.contentType)), "content-length", result.byteLength.toString()));
+	}
+});
+/**
+* Creates a `node:zlib` compression transform stream that flushes each input
+* chunk, for streaming response bodies.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const compressTransform = (algorithm, options) => {
+	switch (algorithm) {
+		case "gzip": return Zlib.createGzip({
+			level: options?.level,
+			flush: Zlib.constants.Z_SYNC_FLUSH
+		});
+		case "deflate": return Zlib.createDeflate({
+			level: options?.level,
+			flush: Zlib.constants.Z_SYNC_FLUSH
+		});
+		case "br": return Zlib.createBrotliCompress({
+			...brotliParams(options?.level),
+			flush: Zlib.constants.BROTLI_OPERATION_FLUSH
+		});
+		case "zstd": return Zlib.createZstdCompress({
+			...zstdParams(options?.level),
+			flush: Zlib.constants.ZSTD_e_flush
+		});
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-node@4.0.0-beta.103_bufferutil@4.1.0_effect@4.0.0-beta.103_patch_hash=_7eec308fcf6351488fccaf9a0edac255/node_modules/@effect/platform-node/dist/NodeHttpPlatform.js
+/**
+* Node.js implementation of the Effect HTTP platform service.
+*
+* This module connects the portable `HttpPlatform` file response helpers to
+* Node runtime primitives. It serves local files through Node readable streams,
+* supports byte ranges, converts Web `File` values to readable streams, and
+* fills in content type and content length headers when needed.
+*
+* @since 4.0.0
+*/
+const compressedBody = (response, body) => removeHeader(setBody(response, body), "content-length");
+/**
+* Creates the Node `HttpPlatform`, serving file responses from Node readable
+* streams and adding MIME type and content-length headers when needed.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make$2 = /*#__PURE__*/ make$4({
+	platform: "node",
+	compression: /* @__PURE__ */ make$3({
+		algorithms,
+		compressResponse(response, algorithm, options) {
+			const body = response.body;
+			switch (body._tag) {
+				case "Stream": return succeed(compressedBody(response, stream$1(pipeThroughDuplex(body.stream, { evaluate: () => compressTransform(algorithm, options) }), body.contentType)));
+				case "Raw": {
+					const readable = body.body instanceof Readable ? body.body : Readable.fromWeb(new Response(body.body).body);
+					const transform = compressTransform(algorithm, options);
+					readable.on("error", (cause) => transform.destroy(cause));
+					transform.on("error", (cause) => readable.destroy(cause));
+					transform.on("close", () => readable.destroy());
+					return succeed(compressedBody(response, raw(readable.pipe(transform), { contentType: body.contentType })));
+				}
+				default: return succeed(response);
+			}
+		}
+	}),
+	fileResponse(path, status, statusText, headers, start, end, contentLength) {
+		return raw$1(contentLength === 0 ? Readable.from([]) : Fs.createReadStream(path, {
+			start,
+			end: end === void 0 ? void 0 : end - 1
+		}), {
+			headers: {
+				...headers,
+				"content-type": headers["content-type"] ?? Mime_default.getType(path) ?? "application/octet-stream",
+				"content-length": contentLength.toString()
+			},
+			status,
+			statusText
+		});
+	},
+	fileWebResponse(file, status, statusText, headers, _options) {
+		return raw$1(Readable.fromWeb(file.stream()), {
+			headers: merge(headers, fromRecordUnsafe({
+				"content-type": headers["content-type"] ?? Mime_default.getType(file.name) ?? "application/octet-stream",
+				"content-length": file.size.toString()
+			})),
+			status,
+			statusText
+		});
+	}
+});
+/**
+* Provides the Node `HttpPlatform` together with the filesystem and ETag
+* services it needs for file responses.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer$1 = /*#__PURE__*/ pipe(/*#__PURE__*/ effect(HttpPlatform)(make$2), /*#__PURE__*/ provide(layer$4), /*#__PURE__*/ provide(layer$2));
+//#endregion
+//#region ../../node_modules/.pnpm/multipasta@0.2.8/node_modules/multipasta/dist/esm/node.js
+var MultipastaStream = class extends Duplex {
+	_parser;
+	_canWrite = true;
+	_writeCallback;
+	constructor(config) {
+		super({ readableObjectMode: true });
+		let currentError;
+		let currentFile;
+		this._parser = make$5({
+			...config,
+			onField: (info, value) => {
+				if (currentError !== void 0) return;
+				const field = {
+					_tag: "Field",
+					info,
+					value
+				};
+				this.push(field);
+				this.emit("field", field);
+			},
+			onFile: (info) => {
+				if (currentError !== void 0) return (_) => {};
+				const file = new FileStream(info, this);
+				currentFile = file;
+				this.push(file);
+				this.emit("file", file);
+				return (chunk) => {
+					this._canWrite = file.push(chunk);
+					if (chunk === null && !this._canWrite) {
+						currentFile = void 0;
+						this._resume();
+					}
+				};
+			},
+			onError: (error) => {
+				this.emit("error", error);
+				currentFile?.emit("error", error);
+				currentError = error;
+			},
+			onDone: () => {
+				this.push(null);
+			}
+		});
+	}
+	_resume() {
+		this._canWrite = true;
+		if (this._writeCallback !== void 0) {
+			const callback = this._writeCallback;
+			this._writeCallback = void 0;
+			callback();
+		}
+	}
+	_read(_size) {}
+	_write(chunk, encoding, callback) {
+		this._parser.write(chunk instanceof Uint8Array ? chunk : Buffer.from(chunk, encoding));
+		if (this._canWrite) callback();
+		else this._writeCallback = callback;
+	}
+	_final(callback) {
+		this._parser.end();
+		callback();
+	}
+};
+const make$1 = (config) => new MultipastaStream(config);
+var FileStream = class extends Readable {
+	info;
+	_parent;
+	_tag = "File";
+	filename;
+	constructor(info, _parent) {
+		super();
+		this.info = info;
+		this._parent = _parent;
+		this.filename = info.filename;
+	}
+	_read(_size) {
+		if (this._parent._canWrite === false) this._parent._resume();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-node@4.0.0-beta.103_bufferutil@4.1.0_effect@4.0.0-beta.103_patch_hash=_7eec308fcf6351488fccaf9a0edac255/node_modules/@effect/platform-node/dist/NodeMultipart.js
+/**
+* Node.js multipart parsing for HTTP `multipart/form-data` request bodies.
+*
+* `NodeMultipart` adapts a Node `Readable` plus incoming HTTP headers into
+* Effect's shared multipart model. It can expose form parts as a stream or
+* collect a complete persisted form by writing file uploads to scoped temporary
+* files through the current `FileSystem` and `Path` services. `fileToReadable`
+* returns the underlying Node readable stream for file parts produced by this
+* parser.
+*
+* @since 4.0.0
+*/
+/**
+* Parses multipart data from a Node readable request body and headers into a
+* stream of `Multipart.Part` values, converting parser failures to
+* `MultipartError`.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const stream = (source, headers) => makeConfig(headers).pipe(map((config) => fromReadable({
+	evaluate() {
+		const parser = make$1(config);
+		source.pipe(parser);
+		return parser;
+	},
+	onError: (error) => convertError(error)
+})), unwrap, map$1(convertPart));
+/**
+* Parses multipart data from a Node readable request body and persists file
+* parts using the current `FileSystem`, `Path`, and `Scope` services.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const persisted = (source, headers) => toPersisted(stream(source, headers), (path, file) => tryPromise({
+	try: (signal) => NodeStreamP.pipeline(file.file, Fs.createWriteStream(path), { signal }),
+	catch: (cause) => MultipartError.fromReason("InternalError", cause)
+}));
+const convertPart = (part) => part._tag === "Field" ? new FieldImpl(part.info, part.value) : new FileImpl(part);
+var PartBase = class extends Class {
+	[TypeId$1];
+	constructor() {
+		super();
+		this[TypeId$1] = TypeId$1;
+	}
+};
+var FieldImpl = class extends PartBase {
+	_tag = "Field";
+	key;
+	contentType;
+	value;
+	constructor(info, value) {
+		super();
+		this.key = info.name;
+		this.contentType = info.contentType;
+		this.value = decodeField(info, value);
+	}
+	toJSON() {
+		return {
+			_id: "@effect/platform/Multipart/Part",
+			_tag: "Field",
+			key: this.key,
+			value: this.value,
+			contentType: this.contentType
+		};
+	}
+};
+var FileImpl = class extends PartBase {
+	_tag = "File";
+	key;
+	name;
+	contentType;
+	content;
+	contentEffect;
+	file;
+	constructor(file) {
+		super();
+		this.file = file;
+		this.key = file.info.name;
+		this.name = file.filename ?? file.info.name;
+		this.contentType = file.info.contentType;
+		this.content = fromReadable({
+			evaluate: () => file,
+			onError: (cause) => MultipartError.fromReason("InternalError", cause)
+		});
+		this.contentEffect = toUint8Array(() => file, { onError: (cause) => MultipartError.fromReason("InternalError", cause) });
+	}
+	toJSON() {
+		return {
+			_id: "@effect/platform/Multipart/Part",
+			_tag: "File",
+			key: this.key,
+			name: this.name,
+			contentType: this.contentType
+		};
+	}
+};
+function convertError(cause) {
+	switch (cause._tag) {
+		case "ReachedLimit": switch (cause.limit) {
+			case "MaxParts": return MultipartError.fromReason("TooManyParts", cause);
+			case "MaxFieldSize": return MultipartError.fromReason("FieldTooLarge", cause);
+			case "MaxPartSize": return MultipartError.fromReason("FileTooLarge", cause);
+			case "MaxTotalSize": return MultipartError.fromReason("BodyTooLarge", cause);
+		}
+		default: return MultipartError.fromReason("Parse", cause);
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-node@4.0.0-beta.103_bufferutil@4.1.0_effect@4.0.0-beta.103_patch_hash=_7eec308fcf6351488fccaf9a0edac255/node_modules/@effect/platform-node/dist/NodeHttpServer.js
+/**
+* Node.js implementation of the Effect `HttpServer`.
+*
+* This module adapts a supplied Node `http.Server` into Effect's
+* platform-independent HTTP server service. It starts the server with Node
+* `listen` options, converts `request` events into `HttpServerRequest` values,
+* writes `HttpServerResponse` bodies through Node's `ServerResponse`, and
+* handles `upgrade` events by exposing the upgraded socket through
+* `HttpServerRequest.upgrade`. It also exports request and upgrade handler
+* constructors plus layers for the server alone, HTTP support services, the
+* combined server, configurable options, and tests.
+*
+* @since 4.0.0
+*/
+/**
+* Creates a scoped `HttpServer` from a Node `http.Server`, starts listening
+* with the supplied options, registers request and upgrade handling, and closes
+* the server during scope finalization with optional graceful-shutdown control.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make = /*#__PURE__*/ fnUntraced(function* (evaluate, options) {
+	const scope$2 = yield* scope;
+	const server = evaluate();
+	const shutdown = yield* callback((resume) => {
+		if (!server.listening) return resume(void_);
+		server.close((error) => {
+			if (error) resume(die(error));
+			else resume(void_);
+		});
+	}).pipe(cached);
+	const preemptiveShutdown = options.disablePreemptiveShutdown ? void_ : timeoutOrElse(shutdown, {
+		duration: options.gracefulShutdownTimeout ?? seconds(20),
+		orElse: () => void_
+	});
+	yield* addFinalizer(scope$2, shutdown);
+	yield* callback((resume) => {
+		function onError(cause) {
+			resume(fail(new ServeError({ cause })));
+		}
+		server.on("error", onError);
+		server.listen(options, () => {
+			server.off("error", onError);
+			resume(void_);
+		});
+	});
+	const address = server.address();
+	const wss = yield* acquireRelease(sync(() => new import_websocket_server.default({
+		...options.websocket,
+		noServer: true
+	})), (wss) => callback((resume) => {
+		wss.close(() => resume(void_));
+	})).pipe(provide$1(scope$2), cached);
+	return make$6({
+		address: typeof address === "string" ? {
+			_tag: "UnixAddress",
+			path: address
+		} : {
+			_tag: "TcpAddress",
+			hostname: address.address === "::" ? "0.0.0.0" : address.address,
+			port: address.port
+		},
+		serve: fnUntraced(function* (httpApp, middleware) {
+			const serveScope = yield* scope;
+			const scope$1 = forkUnsafe(serveScope, "parallel");
+			const handler = yield* makeHandler(httpApp, {
+				middleware,
+				scope: scope$1
+			});
+			const upgradeHandler = yield* makeUpgradeHandler(wss, httpApp, {
+				middleware,
+				scope: scope$1
+			});
+			yield* addFinalizerExit(serveScope, () => {
+				server.off("request", handler);
+				server.off("upgrade", upgradeHandler);
+				return preemptiveShutdown;
+			});
+			server.on("request", handler);
+			server.on("upgrade", upgradeHandler);
+		})
+	});
+});
+/**
+* Creates a Node `request` event handler for an Effect HTTP application,
+* injecting a `HttpServerRequest` and interrupting the request fiber if the
+* client closes the response before it finishes.
+*
+* @category handlers
+* @since 4.0.0
+*/
+const makeHandler = (httpEffect, options) => {
+	const handled = toHandled(httpEffect, handleResponse, options.middleware);
+	return withFiber((parent) => {
+		const services = parent.context;
+		return succeed(function handler(nodeRequest, nodeResponse) {
+			const fiber = runIn(runForkWith(add(services, HttpServerRequest, new ServerRequestImpl(nodeRequest, nodeResponse)))(handled), options.scope);
+			nodeResponse.on("close", () => {
+				if (!nodeResponse.writableEnded) fiber.interruptUnsafe(parent.id, ClientAbort.annotation);
+			});
+		});
+	});
+};
+/**
+* Creates a Node `upgrade` event handler for an Effect HTTP application,
+* exposing the upgraded WebSocket as the request's `upgrade` effect and
+* interrupting the request fiber when the socket closes early.
+*
+* @category handlers
+* @since 4.0.0
+*/
+const makeUpgradeHandler = (lazyWss, httpEffect, options) => {
+	const handledApp = toHandled(httpEffect, handleResponse, options.middleware);
+	return withFiber((parent) => {
+		const services = parent.context;
+		return succeed(function handler(nodeRequest, socket, head) {
+			let nodeResponse_ = void 0;
+			const nodeResponse = () => {
+				if (nodeResponse_ === void 0) {
+					nodeResponse_ = new Http.ServerResponse(nodeRequest);
+					nodeResponse_.assignSocket(socket);
+					nodeResponse_.on("finish", () => {
+						socket.end();
+					});
+				}
+				return nodeResponse_;
+			};
+			const upgradeEffect = fromWebSocket(flatMap(lazyWss, (wss) => acquireRelease(callback((resume) => wss.handleUpgrade(nodeRequest, socket, head, (ws) => {
+				resume(succeed(ws));
+			})), (ws) => sync(() => ws.close()))));
+			const fiber = runIn(runForkWith(add(services, HttpServerRequest, new ServerRequestImpl(nodeRequest, nodeResponse, upgradeEffect)))(handledApp), options.scope);
+			socket.on("close", () => {
+				if (!socket.writableEnded) fiber.interruptUnsafe(parent.id, ClientAbort.annotation);
+			});
+		});
+	});
+};
+var ServerRequestImpl = class ServerRequestImpl extends NodeHttpIncomingMessage {
+	[TypeId$2];
+	response;
+	upgradeEffect;
+	url;
+	headersOverride;
+	constructor(source, response, upgradeEffect, url = source.url, headersOverride, remoteAddressOverride) {
+		super(source, (cause) => new HttpServerError({ reason: new RequestParseError({
+			request: this,
+			cause
+		}) }), remoteAddressOverride);
+		this[TypeId$2] = TypeId$2;
+		this.response = response;
+		this.upgradeEffect = upgradeEffect;
+		this.url = url;
+		this.headersOverride = headersOverride;
+	}
+	cachedCookies;
+	get cookies() {
+		if (this.cachedCookies) return this.cachedCookies;
+		return this.cachedCookies = parseHeader(this.headers.cookie ?? "");
+	}
+	get resolvedResponse() {
+		return typeof this.response === "function" ? this.response() : this.response;
+	}
+	modify(options) {
+		return new ServerRequestImpl(this.source, this.response, this.upgradeEffect, options.url ?? this.url, options.headers ?? this.headersOverride, "remoteAddress" in options ? options.remoteAddress : this.remoteAddressOverride);
+	}
+	get originalUrl() {
+		return this.source.url;
+	}
+	cachedMethod;
+	get method() {
+		return this.cachedMethod ??= this.source.method.toUpperCase();
+	}
+	get headers() {
+		this.headersOverride ??= this.source.headers;
+		return this.headersOverride;
+	}
+	multipartEffect;
+	get multipart() {
+		if (this.multipartEffect) return this.multipartEffect;
+		this.multipartEffect = runSync(cached(persisted(this.source, this.source.headers)));
+		return this.multipartEffect;
+	}
+	get multipartStream() {
+		return stream(this.source, this.source.headers);
+	}
+	get upgrade() {
+		return this.upgradeEffect ?? fail(new HttpServerError({ reason: new RequestParseError({
+			request: this,
+			description: "not an upgradeable ServerRequest"
+		}) }));
+	}
+	toString() {
+		return `ServerRequest(${this.method} ${this.url})`;
+	}
+	toJSON() {
+		return inspect(this, {
+			_id: "HttpServerRequest",
+			method: this.method,
+			url: this.originalUrl
+		});
+	}
+};
+/**
+* Provides an `HttpServer` by creating and managing a scoped Node
+* `http.Server` with the supplied listen and shutdown options.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layerServer = /*#__PURE__*/ flow(make, /*#__PURE__*/ effect(HttpServer));
+/**
+* Provides the Node HTTP support services used by `NodeHttpServer`, including
+* the HTTP platform, ETag generator, and core Node platform services.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layerHttpServices = /*#__PURE__*/ mergeAll(layer$1, layerWeak, layer$5);
+/**
+* Provides a Node `HttpServer` together with the Node HTTP platform, ETag, and
+* core platform services required to serve requests.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer = (evaluate, options) => mergeAll(layerServer(evaluate, options), layerHttpServices);
+/**
+* Provides a Node `HttpServer` together with the Node HTTP platform, ETag,
+* and core Node platform services, reading the listen and shutdown options from
+* a `Config` value.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layerConfig = (evaluate, options) => mergeAll(effect(HttpServer)(flatMap(unwrap$1(options), (options) => make(evaluate, options))), layerHttpServices);
+/**
+* Provides a test HTTP server listening on an ephemeral port together with a
+* Fetch-backed `HttpClient` configured for server integration tests.
+*
+* @category testing
+* @since 4.0.0
+*/
+const layerTest = /*#__PURE__*/ layerTestClient.pipe(/*#__PURE__*/ provide(/*#__PURE__*/ fresh(layer$3).pipe(/*#__PURE__*/ provide(/*#__PURE__*/ succeed$1(RequestInit)({ keepalive: false })))), /*#__PURE__*/ provideMerge(/*#__PURE__*/ layer(Http.createServer, { port: 0 })));
+const handleResponse = (request, response) => {
+	const nodeResponse = request.resolvedResponse;
+	if (nodeResponse.writableEnded) return void_;
+	let headers = response.headers;
+	if (!isEmpty(response.cookies)) {
+		headers = { ...headers };
+		const toSet = toSetCookieHeaders(response.cookies);
+		if (headers["set-cookie"] !== void 0) toSet.push(headers["set-cookie"]);
+		headers["set-cookie"] = toSet;
+	}
+	if (request.method === "HEAD") {
+		nodeResponse.writeHead(response.status, headers);
+		return andThen(cancelResponseBody(response.body), callback((resume) => {
+			let completed = false;
+			const done = () => {
+				if (completed) return;
+				completed = true;
+				nodeResponse.off("close", done);
+				resume(void_);
+			};
+			nodeResponse.once("close", done);
+			nodeResponse.end(done);
+		}));
+	}
+	const body = response.body;
+	switch (body._tag) {
+		case "Empty":
+			nodeResponse.writeHead(response.status, headers);
+			nodeResponse.end();
+			return void_;
+		case "Raw":
+			nodeResponse.writeHead(response.status, headers);
+			if (typeof body.body === "object" && body.body !== null && "pipe" in body.body && typeof body.body.pipe === "function") return tryPromise({
+				try: (signal) => pipeline(body.body, nodeResponse, {
+					signal,
+					end: true
+				}),
+				catch: (cause) => new HttpServerError({ reason: new ResponseError({
+					request,
+					response,
+					description: "Error writing raw response",
+					cause
+				}) })
+			}).pipe(interruptible, tapCause(handleCause(nodeResponse, response)));
+			return callback((resume) => {
+				nodeResponse.end(body.body, () => resume(void_));
+			});
+		case "Uint8Array":
+			nodeResponse.writeHead(response.status, headers);
+			if (body.body.length < 1024 * 1024) {
+				nodeResponse.end(body.body);
+				return void_;
+			}
+			return callback((resume) => {
+				nodeResponse.end(body.body, () => resume(void_));
+			});
+		case "FormData": return suspend(() => {
+			const r = new globalThis.Response(body.formData);
+			nodeResponse.writeHead(response.status, {
+				...headers,
+				...Object.fromEntries(r.headers)
+			});
+			return callback((resume, signal) => {
+				Readable.fromWeb(r.body, { signal }).pipe(nodeResponse).on("error", (cause) => {
+					resume(fail(new HttpServerError({ reason: new ResponseError({
+						request,
+						response,
+						description: "Error writing FormData response",
+						cause
+					}) })));
+				}).once("finish", () => {
+					resume(void_);
+				});
+			}).pipe(interruptible, tapCause(handleCause(nodeResponse, response)));
+		});
+		case "Stream": {
+			nodeResponse.writeHead(response.status, headers);
+			const drainLatch = makeUnsafe();
+			nodeResponse.on("drain", () => drainLatch.openUnsafe());
+			return body.stream.pipe(orDie, runForEachArray((array) => {
+				const chunk = array.length > 1 ? Buffer.concat(array) : array[0];
+				if (nodeResponse.write(chunk)) return void_;
+				drainLatch.closeUnsafe();
+				return drainLatch.await;
+			}), interruptible, matchCauseEffect({
+				onSuccess: () => sync(() => nodeResponse.end()),
+				onFailure: handleCause(nodeResponse, response)
+			}));
+		}
+	}
+};
+const cancelResponseBody = (body) => {
+	const stream = body._tag === "Raw" ? body.body : void 0;
+	if (stream instanceof Readable) return sync(() => stream.destroy());
+	return void_;
+};
+const handleCause = (nodeResponse, originalResponse) => (originalCause) => flatMap(causeResponse(originalCause), ([response, cause]) => {
+	const headersSent = nodeResponse.headersSent;
+	if (!headersSent) nodeResponse.writeHead(response.status);
+	if (!nodeResponse.writableEnded) nodeResponse.end();
+	return failCause(headersSent ? combine(originalCause, die$1(originalResponse)) : cause);
+});
+//#endregion
+export { layer, layerConfig, layerHttpServices, layerServer, layerTest, make, makeHandler, makeUpgradeHandler };
+
+//# sourceMappingURL=NodeHttpServer-BGJlR_Kf.mjs.map