@cmmd-center/forge 0.9.0 → 0.9.1

package/dist/NodeHttpServer-C7YMYP5R.cjs

@@ -0,0 +1,616 @@
+#!/usr/bin/env node
+
+const require_chunk = require("./chunk-BhaIgcZK.cjs");
+const require_Schema = require("./Schema-Bij_WAra.cjs");
+const require_Path = require("./Path-CsbBuCFB.cjs");
+const require_NodeTerminal = require("./NodeTerminal-B9u7fFYa.cjs");
+const require_NodeServices = require("./NodeServices-BISZRY3e.cjs");
+const require_HttpServer = require("./HttpServer-aJkhz6yu.cjs");
+const require_Config = require("./Config-DMA9WqtC.cjs");
+const require_Mime = require("./Mime-aSilaQX9.cjs");
+let node_stream = require("node:stream");
+let node_fs = require("node:fs");
+node_fs = require_chunk.__toESM(node_fs);
+let node_http = require("node:http");
+node_http = require_chunk.__toESM(node_http);
+let node_stream_promises = require("node:stream/promises");
+node_stream_promises = require_chunk.__toESM(node_stream_promises);
+//#region ../../node_modules/.bun/@effect+platform-node@4.0.0-beta.45+6a386fbfc71a3ef3/node_modules/@effect/platform-node/dist/NodeHttpIncomingMessage.js
+/**
+* @since 1.0.0
+*/
+/**
+* @since 1.0.0
+* @category Constructors
+*/
+var NodeHttpIncomingMessage = class extends require_Schema.Class$2 {
+	/**
+	* @since 1.0.0
+	*/
+	[require_HttpServer.TypeId$3];
+	source;
+	onError;
+	remoteAddressOverride;
+	constructor(source, onError, remoteAddressOverride) {
+		super();
+		this[require_HttpServer.TypeId$3] = require_HttpServer.TypeId$3;
+		this.source = source;
+		this.onError = onError;
+		this.remoteAddressOverride = remoteAddressOverride;
+	}
+	get headers() {
+		return require_HttpServer.fromInput$1(this.source.headers);
+	}
+	get remoteAddress() {
+		return this.remoteAddressOverride ?? require_Schema.fromNullishOr(this.source.socket.remoteAddress);
+	}
+	textEffect;
+	get text() {
+		if (this.textEffect) return this.textEffect;
+		this.textEffect = require_Schema.runSync(require_Schema.cached(require_Schema.flatMap(require_HttpServer.MaxBodySize.asEffect(), (maxBodySize) => require_NodeTerminal.toString(() => this.source, {
+			onError: this.onError,
+			maxBytes: maxBodySize
+		}))));
+		return this.textEffect;
+	}
+	get textUnsafe() {
+		return require_Schema.runSync(this.text);
+	}
+	get json() {
+		return require_Schema.flatMap(this.text, (text) => require_Schema.try_({
+			try: () => text === "" ? null : JSON.parse(text),
+			catch: this.onError
+		}));
+	}
+	get jsonUnsafe() {
+		return require_Schema.runSync(this.json);
+	}
+	get urlParamsBody() {
+		return require_Schema.flatMap(this.text, (_) => require_Schema.try_({
+			try: () => require_HttpServer.fromInput(new URLSearchParams(_)),
+			catch: this.onError
+		}));
+	}
+	get stream() {
+		return require_NodeTerminal.fromReadable({
+			evaluate: () => this.source,
+			onError: this.onError
+		});
+	}
+	get arrayBuffer() {
+		return require_Schema.withFiber((fiber) => require_NodeTerminal.toArrayBuffer(() => this.source, {
+			onError: this.onError,
+			maxBytes: fiber.getRef(require_HttpServer.MaxBodySize)
+		}));
+	}
+};
+//#endregion
+//#region ../../node_modules/.bun/@effect+platform-node@4.0.0-beta.45+6a386fbfc71a3ef3/node_modules/@effect/platform-node/dist/NodeHttpPlatform.js
+/**
+* @since 1.0.0
+*/
+/**
+* @since 1.0.0
+* @category Constructors
+*/
+const make$2 = /* @__PURE__ */ require_HttpServer.make$1({
+	fileResponse(path, status, statusText, headers, start, end, contentLength) {
+		const stream = contentLength === 0 ? node_stream.Readable.from([]) : node_fs.createReadStream(path, {
+			start,
+			end: end === void 0 ? void 0 : end - 1
+		});
+		return require_HttpServer.raw(stream, {
+			headers: {
+				...headers,
+				"content-type": headers["content-type"] ?? require_Mime.Mime_default.getType(path) ?? "application/octet-stream",
+				"content-length": contentLength.toString()
+			},
+			status,
+			statusText
+		});
+	},
+	fileWebResponse(file, status, statusText, headers, _options) {
+		return require_HttpServer.raw(node_stream.Readable.fromWeb(file.stream()), {
+			headers: require_HttpServer.merge(headers, require_HttpServer.fromRecordUnsafe({
+				"content-type": headers["content-type"] ?? require_Mime.Mime_default.getType(file.name) ?? "application/octet-stream",
+				"content-length": file.size.toString()
+			})),
+			status,
+			statusText
+		});
+	}
+});
+/**
+* @since 1.0.0
+* @category Layers
+*/
+const layer$1 = /* @__PURE__ */ require_Schema.pipe(/* @__PURE__ */ require_Schema.effect(require_HttpServer.HttpPlatform)(make$2), /* @__PURE__ */ require_Schema.provide$1(require_NodeServices.layer$1), /* @__PURE__ */ require_Schema.provide$1(require_HttpServer.layer$1));
+//#endregion
+//#region ../../node_modules/.bun/multipasta@0.2.7/node_modules/multipasta/dist/esm/node.js
+var MultipastaStream = class extends node_stream.Duplex {
+	_parser;
+	_canWrite = true;
+	_writeCallback;
+	constructor(config) {
+		super({ readableObjectMode: true });
+		let currentError;
+		let currentFile;
+		this._parser = require_HttpServer.make$2({
+			...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 node_stream.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/.bun/@effect+platform-node@4.0.0-beta.45+6a386fbfc71a3ef3/node_modules/@effect/platform-node/dist/NodeMultipart.js
+/**
+* @since 1.0.0
+*/
+/**
+* @since 1.0.0
+* @category constructors
+*/
+const stream = (source, headers) => require_HttpServer.makeConfig(headers).pipe(require_Schema.map((config) => require_NodeTerminal.fromReadable({
+	evaluate() {
+		const parser = make$1(config);
+		source.pipe(parser);
+		return parser;
+	},
+	onError: (error) => convertError(error)
+})), require_Path.unwrap, require_Path.map(convertPart));
+/**
+* @since 1.0.0
+* @category constructors
+*/
+const persisted = (source, headers) => require_HttpServer.toPersisted(stream(source, headers), (path, file) => require_Schema.tryPromise({
+	try: (signal) => node_stream_promises.pipeline(file.file, node_fs.createWriteStream(path), { signal }),
+	catch: (cause) => require_HttpServer.MultipartError.fromReason("InternalError", cause)
+}));
+const convertPart = (part) => part._tag === "Field" ? new FieldImpl(part.info, part.value) : new FileImpl(part);
+var PartBase = class extends require_Schema.Class$2 {
+	[require_HttpServer.TypeId$1];
+	constructor() {
+		super();
+		this[require_HttpServer.TypeId$1] = require_HttpServer.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 = require_HttpServer.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 = require_NodeTerminal.fromReadable({
+			evaluate: () => file,
+			onError: (cause) => require_HttpServer.MultipartError.fromReason("InternalError", cause)
+		});
+		this.contentEffect = require_NodeTerminal.toUint8Array(() => file, { onError: (cause) => require_HttpServer.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 require_HttpServer.MultipartError.fromReason("TooManyParts", cause);
+			case "MaxFieldSize": return require_HttpServer.MultipartError.fromReason("FieldTooLarge", cause);
+			case "MaxPartSize": return require_HttpServer.MultipartError.fromReason("FileTooLarge", cause);
+			case "MaxTotalSize": return require_HttpServer.MultipartError.fromReason("BodyTooLarge", cause);
+		}
+		default: return require_HttpServer.MultipartError.fromReason("Parse", cause);
+	}
+}
+//#endregion
+//#region ../../node_modules/.bun/@effect+platform-node@4.0.0-beta.45+6a386fbfc71a3ef3/node_modules/@effect/platform-node/dist/NodeHttpServer.js
+/**
+* @since 1.0.0
+*/
+/**
+* @since 1.0.0
+* @category constructors
+*/
+const make = /* @__PURE__ */ require_Schema.fnUntraced(function* (evaluate, options) {
+	const scope$1 = yield* require_Schema.scope;
+	const server = evaluate();
+	const shutdown = yield* require_Schema.callback((resume) => {
+		if (!server.listening) return resume(require_Schema.void_);
+		server.close((error) => {
+			if (error) resume(require_Schema.die(error));
+			else resume(require_Schema.void_);
+		});
+	}).pipe(require_Schema.cached);
+	const preemptiveShutdown = options.disablePreemptiveShutdown ? require_Schema.void_ : require_Schema.timeoutOrElse(shutdown, {
+		duration: options.gracefulShutdownTimeout ?? require_Schema.seconds(20),
+		orElse: () => require_Schema.void_
+	});
+	yield* require_Schema.addFinalizer$1(scope$1, shutdown);
+	yield* require_Schema.callback((resume) => {
+		function onError(cause) {
+			resume(require_Schema.fail(new require_HttpServer.ServeError({ cause })));
+		}
+		server.on("error", onError);
+		server.listen(options, () => {
+			server.off("error", onError);
+			resume(require_Schema.void_);
+		});
+	});
+	const address = server.address();
+	const wss = yield* require_Schema.acquireRelease(require_Schema.sync(() => new require_Mime.import_websocket_server.default({ noServer: true })), (wss) => require_Schema.callback((resume) => {
+		wss.close(() => resume(require_Schema.void_));
+	})).pipe(require_Schema.provide$2(scope$1), require_Schema.cached);
+	return require_HttpServer.make({
+		address: typeof address === "string" ? {
+			_tag: "UnixAddress",
+			path: address
+		} : {
+			_tag: "TcpAddress",
+			hostname: address.address === "::" ? "0.0.0.0" : address.address,
+			port: address.port
+		},
+		serve: require_Schema.fnUntraced(function* (httpApp, middleware) {
+			const serveScope = yield* require_Schema.scope;
+			const scope$2 = require_Schema.forkUnsafe(serveScope, "parallel");
+			const handler = yield* makeHandler(httpApp, {
+				middleware,
+				scope: scope$2
+			});
+			const upgradeHandler = yield* makeUpgradeHandler(wss, httpApp, {
+				middleware,
+				scope: scope$2
+			});
+			yield* require_Schema.addFinalizerExit(serveScope, () => {
+				server.off("request", handler);
+				server.off("upgrade", upgradeHandler);
+				return preemptiveShutdown;
+			});
+			server.on("request", handler);
+			server.on("upgrade", upgradeHandler);
+		})
+	});
+});
+/**
+* @since 1.0.0
+* @category Handlers
+*/
+const makeHandler = (httpEffect, options) => {
+	const handled = require_HttpServer.toHandled(httpEffect, handleResponse, options.middleware);
+	return require_Schema.withFiber((parent) => {
+		const services = parent.context;
+		return require_Schema.succeed(function handler(nodeRequest, nodeResponse) {
+			const map = new Map(services.mapUnsafe);
+			map.set(require_HttpServer.HttpServerRequest.key, new ServerRequestImpl(nodeRequest, nodeResponse));
+			const fiber = require_Path.runIn(require_Schema.runForkWith(require_Schema.makeUnsafe$3(map))(handled), options.scope);
+			nodeResponse.on("close", () => {
+				if (!nodeResponse.writableEnded) fiber.interruptUnsafe(parent.id, require_HttpServer.ClientAbort.annotation);
+			});
+		});
+	});
+};
+/**
+* @since 1.0.0
+* @category Handlers
+*/
+const makeUpgradeHandler = (lazyWss, httpEffect, options) => {
+	const handledApp = require_HttpServer.toHandled(httpEffect, handleResponse, options.middleware);
+	return require_Schema.withFiber((parent) => {
+		const services = parent.context;
+		return require_Schema.succeed(function handler(nodeRequest, socket, head) {
+			let nodeResponse_ = void 0;
+			const nodeResponse = () => {
+				if (nodeResponse_ === void 0) {
+					nodeResponse_ = new node_http.ServerResponse(nodeRequest);
+					nodeResponse_.assignSocket(socket);
+					nodeResponse_.on("finish", () => {
+						socket.end();
+					});
+				}
+				return nodeResponse_;
+			};
+			const upgradeEffect = require_HttpServer.fromWebSocket(require_Schema.flatMap(lazyWss, (wss) => require_Schema.acquireRelease(require_Schema.callback((resume) => wss.handleUpgrade(nodeRequest, socket, head, (ws) => {
+				resume(require_Schema.succeed(ws));
+			})), (ws) => require_Schema.sync(() => ws.close()))));
+			const map = new Map(services.mapUnsafe);
+			map.set(require_HttpServer.HttpServerRequest.key, new ServerRequestImpl(nodeRequest, nodeResponse, upgradeEffect));
+			const fiber = require_Path.runIn(require_Schema.runForkWith(require_Schema.makeUnsafe$3(map))(handledApp), options.scope);
+			socket.on("close", () => {
+				if (!socket.writableEnded) fiber.interruptUnsafe(parent.id, require_HttpServer.ClientAbort.annotation);
+			});
+		});
+	});
+};
+var ServerRequestImpl = class ServerRequestImpl extends NodeHttpIncomingMessage {
+	[require_HttpServer.TypeId];
+	response;
+	upgradeEffect;
+	url;
+	headersOverride;
+	constructor(source, response, upgradeEffect, url = source.url, headersOverride, remoteAddressOverride) {
+		super(source, (cause) => new require_HttpServer.HttpServerError({ reason: new require_HttpServer.RequestParseError({
+			request: this,
+			cause
+		}) }), remoteAddressOverride);
+		this[require_HttpServer.TypeId] = require_HttpServer.TypeId;
+		this.response = response;
+		this.upgradeEffect = upgradeEffect;
+		this.url = url;
+		this.headersOverride = headersOverride;
+	}
+	cachedCookies;
+	get cookies() {
+		if (this.cachedCookies) return this.cachedCookies;
+		return this.cachedCookies = require_HttpServer.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;
+	}
+	get method() {
+		return 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 = require_Schema.runSync(require_Schema.cached(persisted(this.source, this.source.headers)));
+		return this.multipartEffect;
+	}
+	get multipartStream() {
+		return stream(this.source, this.source.headers);
+	}
+	get upgrade() {
+		return this.upgradeEffect ?? require_Schema.fail(new require_HttpServer.HttpServerError({ reason: new require_HttpServer.RequestParseError({
+			request: this,
+			description: "not an upgradeable ServerRequest"
+		}) }));
+	}
+	toString() {
+		return `ServerRequest(${this.method} ${this.url})`;
+	}
+	toJSON() {
+		return require_HttpServer.inspect(this, {
+			_id: "HttpServerRequest",
+			method: this.method,
+			url: this.originalUrl
+		});
+	}
+};
+/**
+* @since 1.0.0
+* @category Layers
+*/
+const layerServer = /* @__PURE__ */ require_Schema.flow(make, /* @__PURE__ */ require_Schema.effect(require_HttpServer.HttpServer));
+/**
+* @since 1.0.0
+* @category Layers
+*/
+const layerHttpServices = /* @__PURE__ */ require_Schema.mergeAll(layer$1, require_HttpServer.layerWeak, require_NodeServices.layer);
+/**
+* @since 1.0.0
+* @category Layers
+*/
+const layer = (evaluate, options) => require_Schema.mergeAll(layerServer(evaluate, options), layerHttpServices);
+/**
+* @since 1.0.0
+* @category Layers
+*/
+const layerConfig = (evaluate, options) => require_Schema.mergeAll(require_Schema.effect(require_HttpServer.HttpServer)(require_Schema.flatMap(require_Config.unwrap(options).asEffect(), (options) => make(evaluate, options))), layerHttpServices);
+/**
+* @since 1.0.0
+* @category Testing
+*/
+const layerTest = /* @__PURE__ */ require_HttpServer.layerTestClient.pipe(/* @__PURE__ */ require_Schema.provide$1(/* @__PURE__ */ require_Schema.fresh(require_HttpServer.layer).pipe(/* @__PURE__ */ require_Schema.provide$1(/* @__PURE__ */ require_Schema.succeed$1(require_HttpServer.RequestInit)({ keepalive: false })))), /* @__PURE__ */ require_Schema.provideMerge(/* @__PURE__ */ layer(node_http.createServer, { port: 0 })));
+const handleResponse = (request, response) => {
+	const nodeResponse = request.resolvedResponse;
+	if (nodeResponse.writableEnded) return require_Schema.void_;
+	let headers = response.headers;
+	if (!require_HttpServer.isEmpty(response.cookies)) {
+		headers = { ...headers };
+		const toSet = require_HttpServer.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 require_Schema.callback((resume) => {
+			nodeResponse.end(() => resume(require_Schema.void_));
+		});
+	}
+	const body = response.body;
+	switch (body._tag) {
+		case "Empty":
+			nodeResponse.writeHead(response.status, headers);
+			nodeResponse.end();
+			return require_Schema.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 require_Schema.tryPromise({
+				try: (signal) => (0, node_stream_promises.pipeline)(body.body, nodeResponse, {
+					signal,
+					end: true
+				}),
+				catch: (cause) => new require_HttpServer.HttpServerError({ reason: new require_HttpServer.ResponseError({
+					request,
+					response,
+					description: "Error writing raw response",
+					cause
+				}) })
+			}).pipe(require_Schema.interruptible, require_Schema.tapCause(handleCause(nodeResponse, response)));
+			return require_Schema.callback((resume) => {
+				nodeResponse.end(body.body, () => resume(require_Schema.void_));
+			});
+		case "Uint8Array":
+			nodeResponse.writeHead(response.status, headers);
+			if (body.body.length < 1024 * 1024) {
+				nodeResponse.end(body.body);
+				return require_Schema.void_;
+			}
+			return require_Schema.callback((resume) => {
+				nodeResponse.end(body.body, () => resume(require_Schema.void_));
+			});
+		case "FormData": return require_Schema.suspend$1(() => {
+			const r = new globalThis.Response(body.formData);
+			nodeResponse.writeHead(response.status, {
+				...headers,
+				...Object.fromEntries(r.headers)
+			});
+			return require_Schema.callback((resume, signal) => {
+				node_stream.Readable.fromWeb(r.body, { signal }).pipe(nodeResponse).on("error", (cause) => {
+					resume(require_Schema.fail(new require_HttpServer.HttpServerError({ reason: new require_HttpServer.ResponseError({
+						request,
+						response,
+						description: "Error writing FormData response",
+						cause
+					}) })));
+				}).once("finish", () => {
+					resume(require_Schema.void_);
+				});
+			}).pipe(require_Schema.interruptible, require_Schema.tapCause(handleCause(nodeResponse, response)));
+		});
+		case "Stream": {
+			nodeResponse.writeHead(response.status, headers);
+			const drainLatch = require_Path.makeUnsafe$1();
+			nodeResponse.on("drain", () => drainLatch.openUnsafe());
+			return body.stream.pipe(require_Path.orDie, require_Path.runForEachArray((array) => {
+				let needDrain = false;
+				for (let i = 0; i < array.length; i++) {
+					const written = nodeResponse.write(array[i]);
+					if (!written && !needDrain) {
+						needDrain = true;
+						drainLatch.closeUnsafe();
+					} else if (written && needDrain) needDrain = false;
+				}
+				if (!needDrain) return require_Schema.void_;
+				return drainLatch.await;
+			}), require_Schema.interruptible, require_Schema.matchCauseEffect({
+				onSuccess: () => require_Schema.sync(() => nodeResponse.end()),
+				onFailure: handleCause(nodeResponse, response)
+			}));
+		}
+	}
+};
+const handleCause = (nodeResponse, originalResponse) => (originalCause) => require_Schema.flatMap(require_HttpServer.causeResponse(originalCause), ([response, cause]) => {
+	const headersSent = nodeResponse.headersSent;
+	if (!headersSent) nodeResponse.writeHead(response.status);
+	if (!nodeResponse.writableEnded) nodeResponse.end();
+	return require_Schema.failCause(headersSent ? require_Schema.combine(originalCause, require_Schema.die$2(originalResponse)) : cause);
+});
+//#endregion
+exports.layer = layer;
+exports.layerConfig = layerConfig;
+exports.layerHttpServices = layerHttpServices;
+exports.layerServer = layerServer;
+exports.layerTest = layerTest;
+exports.make = make;
+exports.makeHandler = makeHandler;
+exports.makeUpgradeHandler = makeUpgradeHandler;
+
+//# sourceMappingURL=NodeHttpServer-C7YMYP5R.cjs.map