acrylblends 0.8.1 → 0.9.0

package/lib/node-server.js

@@ -1,1588 +1,5 @@
-import { t as Acryl } from "./app-BM0rTCp7.js";
-import { basePath } from "./route.js";
-import { defineWebSocketHelper } from "./ws.js";
-import { t as serveStatic } from "./serve-static-B849HlX2.js";
+import { i as getRequestListener, n as serve, o as RequestError, r as upgradeWebSocket, t as createAdaptorServer } from "./server-DvgMGtzo.js";
+import { t as serveStatic } from "./serve-static-3uo_9rjF.js";
 import { getConnInfo } from "./node-server/conninfo.js";
-import { n as compileModule, t as MissingTypeScriptError } from "./transpile-QUK9b3eG.js";
-import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { STATUS_CODES, ServerResponse, createServer } from "node:http";
-import { Http2ServerRequest, constants } from "node:http2";
-import { Readable } from "node:stream";
-import { copyFileSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-//#region ../../plugins/acryl-node-server/src/adapter/error.ts
-var RequestError = class extends Error {
-	constructor(message, options) {
-		super(message, options);
-		this.name = "RequestError";
-	}
-};
-//#endregion
-//#region ../../plugins/acryl-node-server/src/adapter/headers.ts
-const nonJoinedHeaders = /* @__PURE__ */ new Set([
-	"age",
-	"authorization",
-	"content-length",
-	"content-type",
-	"etag",
-	"expires",
-	"from",
-	"host",
-	"if-modified-since",
-	"if-unmodified-since",
-	"last-modified",
-	"location",
-	"max-forwards",
-	"proxy-authorization",
-	"referer",
-	"retry-after",
-	"server",
-	"user-agent"
-]);
-const validHeaderName = /^[!#$%&'*+\-.^_`|~\dA-Za-z]+$/;
-const isHttpWhitespace = (code) => code === 9 || code === 10 || code === 13 || code === 32;
-const normalizeHeaderValue = (value) => {
-	if (!isHttpWhitespace(value.charCodeAt(0)) && !isHttpWhitespace(value.charCodeAt(value.length - 1))) return value;
-	let start = 0;
-	let end = value.length;
-	while (start < end && isHttpWhitespace(value.charCodeAt(start))) start++;
-	while (end > start && isHttpWhitespace(value.charCodeAt(end - 1))) end--;
-	return value.slice(start, end);
-};
-const forbiddenHeaderValue = /[\0\r\n]/;
-const GlobalHeaders = globalThis.Headers;
-const materializeHeaders = (rawHeaders, HeadersCtor = GlobalHeaders) => {
-	const headers = new HeadersCtor();
-	for (let i = 0; i < rawHeaders.length; i += 2) {
-		const name = rawHeaders[i];
-		if (!name.startsWith(":")) headers.append(name, rawHeaders[i + 1]);
-	}
-	return headers;
-};
-var RequestHeaders = class {
-	#incoming;
-	#rawHeaders;
-	#headers;
-	#invalidValue;
-	constructor(incoming) {
-		this.#incoming = incoming;
-		if (incoming instanceof Http2ServerRequest) this.#rawHeaders = incoming.rawHeaders.slice();
-	}
-	get #lazyRawHeaders() {
-		return this.#rawHeaders ??= this.#incoming.rawHeaders.slice();
-	}
-	get #native() {
-		if (!this.#headers) {
-			this.#headers = materializeHeaders(this.#lazyRawHeaders);
-			this.#rawHeaders = void 0;
-		}
-		return this.#headers;
-	}
-	#normalizedName(name) {
-		if (typeof name !== "string") return;
-		if (!validHeaderName.test(name)) throw new TypeError(`Invalid header name: ${name}`);
-		return name.toLowerCase();
-	}
-	#lookupHttp1(lowerName) {
-		const headers = this.#incoming instanceof Http2ServerRequest ? void 0 : this.#incoming.headers;
-		if (!headers || nonJoinedHeaders.has(lowerName) || lowerName === "set-cookie" || lowerName === "__proto__") return;
-		if (!Object.hasOwn(headers, lowerName)) return null;
-		const rawValue = headers[lowerName];
-		if (typeof rawValue === "string") {
-			const value = normalizeHeaderValue(rawValue);
-			return forbiddenHeaderValue.test(value) ? void 0 : value;
-		}
-	}
-	#lookup(rawHeaders, lowerName) {
-		const separator = lowerName === "cookie" ? "; " : ", ";
-		let value = null;
-		for (let i = 0; i < rawHeaders.length; i += 2) {
-			const rawName = rawHeaders[i];
-			if (rawName.length === lowerName.length && rawName.toLowerCase() === lowerName) {
-				const rawValue = normalizeHeaderValue(rawHeaders[i + 1]);
-				if (forbiddenHeaderValue.test(rawValue)) {
-					this.#invalidValue = true;
-					return;
-				}
-				value = value === null ? rawValue : value + separator + rawValue;
-			}
-		}
-		return value;
-	}
-	append(name, value) {
-		this.#native.append(name, value);
-	}
-	delete(name) {
-		this.#native.delete(name);
-	}
-	get(name) {
-		const lowerName = this.#normalizedName(name);
-		if (lowerName && !this.#headers && !this.#invalidValue) {
-			const http1Value = this.#lookupHttp1(lowerName);
-			if (http1Value !== void 0) return http1Value;
-			const value = this.#lookup(this.#lazyRawHeaders, lowerName);
-			if (value !== void 0) return value;
-		}
-		return this.#native.get(name);
-	}
-	has(name) {
-		const lowerName = this.#normalizedName(name);
-		if (lowerName && !this.#headers && !this.#invalidValue) {
-			const http1Value = this.#lookupHttp1(lowerName);
-			if (http1Value !== void 0) return http1Value !== null;
-			const value = this.#lookup(this.#lazyRawHeaders, lowerName);
-			if (value !== void 0) return value !== null;
-		}
-		return this.#native.has(name);
-	}
-	set(name, value) {
-		this.#native.set(name, value);
-	}
-	getSetCookie() {
-		return this.#native.getSetCookie();
-	}
-	keys() {
-		return this.#native.keys();
-	}
-	values() {
-		return this.#native.values();
-	}
-	entries() {
-		return this.#native.entries();
-	}
-	forEach(callback, thisArg) {
-		this.#native.forEach((value, key) => {
-			callback.call(thisArg, value, key, this);
-		});
-	}
-	[Symbol.iterator]() {
-		return this.entries();
-	}
-};
-Object.defineProperty(RequestHeaders.prototype, Symbol.for("nodejs.util.inspect.custom"), { value: function(depth, options, inspectFn) {
-	return `Headers (lightweight) ${inspectFn(Object.fromEntries(this), {
-		...options,
-		depth: depth == null ? null : depth - 1
-	})}`;
-} });
-Object.setPrototypeOf(RequestHeaders.prototype, GlobalHeaders.prototype);
-const newHeadersFromIncoming = (incoming) => globalThis.Headers === GlobalHeaders ? new RequestHeaders(incoming) : materializeHeaders(incoming.rawHeaders, globalThis.Headers);
-//#endregion
-//#region ../../plugins/acryl-node-server/src/adapter/url.ts
-const reValidRequestUrl = /^\/[!#$&-;=?-\[\]_a-z~]*$/;
-const reDotSegment = /\/\.\.?(?:[/?#]|$)/;
-const reValidHost = /^[a-z0-9._-]+(?::(?:[1-5]\d{3,4}|[6-9]\d{3}))?$/;
-const buildUrl = (scheme, host, incomingUrl) => {
-	const url = `${scheme}://${host}${incomingUrl}`;
-	if (!reValidHost.test(host)) {
-		const urlObj = new URL(url);
-		if (urlObj.hostname.length !== host.length && urlObj.hostname !== (host.includes(":") ? host.replace(/:\d+$/, "") : host).toLowerCase()) throw new RequestError("Invalid host header");
-		return urlObj.href;
-	} else if (incomingUrl.length === 0) return url + "/";
-	else {
-		if (incomingUrl.charCodeAt(0) !== 47) throw new RequestError("Invalid URL");
-		if (!reValidRequestUrl.test(incomingUrl) || reDotSegment.test(incomingUrl)) return new URL(url).href;
-		return url;
-	}
-};
-//#endregion
-//#region ../../plugins/acryl-node-server/src/adapter/request.ts
-const toRequestError = (e) => {
-	if (e instanceof RequestError) return e;
-	return new RequestError(e.message, { cause: e });
-};
-const GlobalRequest = global.Request;
-var Request$1 = class extends GlobalRequest {
-	constructor(input, options) {
-		if (typeof input === "object" && getRequestCache in input) {
-			const hasReplacementBody = options !== void 0 && "body" in options && options.body != null;
-			if (input[bodyConsumedDirectlyKey] && !hasReplacementBody) throw new TypeError("Cannot construct a Request with a Request object that has already been used.");
-			input = input[getRequestCache]();
-		}
-		if (typeof (options?.body)?.getReader !== "undefined") options.duplex ??= "half";
-		super(input, options);
-	}
-};
-const wrapBodyStream = Symbol("wrapBodyStream");
-const byteExactEncodings = /* @__PURE__ */ new Set([
-	"latin1",
-	"binary",
-	"hex",
-	"base64",
-	"base64url"
-]);
-const isByteExactEncoding = (encoding) => encoding === null || byteExactEncodings.has(encoding);
-const bodyBufferedBeforeDisconnectKey = Symbol("bodyBufferedBeforeDisconnect");
-const bodyBufferedLengthBeforeDisconnectKey = Symbol("bodyBufferedLengthBeforeDisconnect");
-const toBufferChunk = (chunk, encoding) => Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding ?? "utf8");
-const isRecoverableDisconnectedIncoming = (incoming) => !(incoming instanceof Http2ServerRequest) && !!incoming.complete && !!incoming.readableAborted && typeof incoming.read === "function" && isByteExactEncoding(incoming.readableEncoding);
-const recordBodyBufferedBeforeDisconnect = (incoming) => {
-	if (incoming.readableDidRead || !isRecoverableDisconnectedIncoming(incoming)) return;
-	const incomingWithRecovery = incoming;
-	incomingWithRecovery[bodyBufferedLengthBeforeDisconnectKey] ??= incoming.readableLength;
-};
-const readBodyBufferedBeforeDisconnect = (incoming, chunks) => {
-	if (incoming.readableDidRead && !chunks || !isRecoverableDisconnectedIncoming(incoming)) return;
-	const incomingWithRecovery = incoming;
-	if (incomingWithRecovery[bodyBufferedBeforeDisconnectKey] !== void 0) return incomingWithRecovery[bodyBufferedBeforeDisconnectKey];
-	let result;
-	const errored = incoming.errored;
-	if (errored && errored.code !== "ECONNRESET") result = errored;
-	else if (incomingWithRecovery[bodyBufferedLengthBeforeDisconnectKey] !== void 0 && incoming.readableLength !== incomingWithRecovery[bodyBufferedLengthBeforeDisconnectKey]) result = newBodyUnusableError();
-	else {
-		const bodyChunks = chunks ?? [];
-		const chunk = incoming.read();
-		if (chunk !== null) bodyChunks.push(toBufferChunk(chunk, incoming.readableEncoding));
-		const buffer = bodyChunks.length === 1 ? bodyChunks[0] : Buffer.concat(bodyChunks);
-		result = buffer;
-		const contentLength = incoming.headers["content-length"];
-		if (typeof contentLength === "string" && /^\d+$/.test(contentLength)) {
-			const expectedLength = Number(contentLength);
-			if (Number.isSafeInteger(expectedLength) && buffer.length !== expectedLength) result = newBodyUnusableError();
-		}
-	}
-	incomingWithRecovery[bodyBufferedBeforeDisconnectKey] = result;
-	return result;
-};
-const enqueueBufferedBody = (controller, buffered) => {
-	if (buffered instanceof Error) {
-		controller.error(buffered);
-		return;
-	}
-	if (buffered.length > 0) controller.enqueue(buffered);
-	controller.close();
-};
-const newRequestFromIncoming = (method, url, headers, incoming, abortController) => {
-	const init = {
-		method,
-		headers,
-		signal: abortController.signal
-	};
-	if (method === "TRACE") {
-		init.method = "GET";
-		const req = new Request$1(url, init);
-		Object.defineProperty(req, "method", { get() {
-			return "TRACE";
-		} });
-		return req;
-	}
-	if (!(method === "GET" || method === "HEAD")) if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) init.body = new ReadableStream({ start(controller) {
-		controller.enqueue(incoming.rawBody);
-		controller.close();
-	} });
-	else if (incoming[wrapBodyStream]) {
-		let reader;
-		init.body = new ReadableStream({ async pull(controller) {
-			try {
-				if (!reader) {
-					const buffered = readBodyBufferedBeforeDisconnect(incoming);
-					if (buffered !== void 0) {
-						enqueueBufferedBody(controller, buffered);
-						return;
-					}
-				}
-				reader ||= Readable.toWeb(incoming).getReader();
-				const { done, value } = await reader.read();
-				if (done) controller.close();
-				else controller.enqueue(value);
-			} catch (error) {
-				controller.error(error);
-			}
-		} });
-	} else {
-		const buffered = readBodyBufferedBeforeDisconnect(incoming);
-		if (buffered !== void 0) init.body = new ReadableStream({ start(controller) {
-			enqueueBufferedBody(controller, buffered);
-		} });
-		else init.body = Readable.toWeb(incoming);
-	}
-	return new Request$1(url, init);
-};
-const getRequestCache = Symbol("getRequestCache");
-const requestCache = Symbol("requestCache");
-const incomingKey = Symbol("incomingKey");
-const urlKey = Symbol("urlKey");
-const methodKey = Symbol("methodKey");
-const headersKey = Symbol("headersKey");
-const abortControllerKey = Symbol("abortControllerKey");
-const getAbortController = Symbol("getAbortController");
-const abortRequest = Symbol("abortRequest");
-const bodyBufferKey = Symbol("bodyBuffer");
-const bodyReadPromiseKey = Symbol("bodyReadPromise");
-const bodyConsumedDirectlyKey = Symbol("bodyConsumedDirectly");
-const bodyLockReaderKey = Symbol("bodyLockReader");
-const abortReasonKey = Symbol("abortReason");
-const newBodyUnusableError = () => {
-	return /* @__PURE__ */ new TypeError("Body is unusable");
-};
-const rejectBodyUnusable = () => {
-	return Promise.reject(newBodyUnusableError());
-};
-const textDecoder = new TextDecoder();
-const consumeBodyDirectOnce = (request) => {
-	if (request[bodyConsumedDirectlyKey]) return rejectBodyUnusable();
-	request[bodyConsumedDirectlyKey] = true;
-};
-const toArrayBuffer = (buf) => {
-	return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
-};
-const contentType = (request) => {
-	return (request[headersKey] ||= newHeadersFromIncoming(request[incomingKey])).get("content-type") || "";
-};
-const methodTokenRegExp = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
-const normalizeIncomingMethod = (method) => {
-	if (typeof method !== "string" || method.length === 0) return "GET";
-	switch (method) {
-		case "DELETE":
-		case "GET":
-		case "HEAD":
-		case "OPTIONS":
-		case "PATCH":
-		case "POST":
-		case "PUT":
-		case "QUERY": return method;
-	}
-	const upper = method.toUpperCase();
-	switch (upper) {
-		case "DELETE":
-		case "GET":
-		case "HEAD":
-		case "OPTIONS":
-		case "POST":
-		case "PUT": return upper;
-		default: return method;
-	}
-};
-const validateDirectReadMethod = (method) => {
-	if (!methodTokenRegExp.test(method)) return /* @__PURE__ */ new TypeError(`'${method}' is not a valid HTTP method.`);
-	const normalized = method.toUpperCase();
-	if (normalized === "CONNECT" || normalized === "TRACK" || normalized === "TRACE" && method !== "TRACE") return /* @__PURE__ */ new TypeError(`'${method}' HTTP method is unsupported.`);
-};
-const readBodyWithFastPath = (request, method, fromBuffer) => {
-	if (request[bodyConsumedDirectlyKey]) return rejectBodyUnusable();
-	const methodName = request.method;
-	if (methodName === "GET" || methodName === "HEAD") return request[getRequestCache]()[method]();
-	const methodValidationError = validateDirectReadMethod(methodName);
-	if (methodValidationError) return Promise.reject(methodValidationError);
-	if (request[requestCache]) {
-		if (methodName !== "TRACE") return request[requestCache][method]();
-	}
-	const alreadyUsedError = consumeBodyDirectOnce(request);
-	if (alreadyUsedError) return alreadyUsedError;
-	const raw = readRawBodyIfAvailable(request);
-	if (raw) {
-		const result = Promise.resolve(fromBuffer(raw, request));
-		request[bodyBufferKey] = void 0;
-		return result;
-	}
-	return readBodyDirect(request).then((buf) => {
-		const result = fromBuffer(buf, request);
-		request[bodyBufferKey] = void 0;
-		return result;
-	});
-};
-const readRawBodyIfAvailable = (request) => {
-	const incoming = request[incomingKey];
-	if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) return incoming.rawBody;
-};
-const normalizeAbortError = (request, incoming) => {
-	if (incoming.errored) return incoming.errored;
-	const reason = request[abortReasonKey];
-	if (reason !== void 0) return reason instanceof Error ? reason : new Error(String(reason));
-	return /* @__PURE__ */ new Error("Client connection prematurely closed.");
-};
-const readBodyDirect = (request) => {
-	if (request[bodyBufferKey]) return Promise.resolve(request[bodyBufferKey]);
-	if (request[bodyReadPromiseKey]) return request[bodyReadPromiseKey];
-	const incoming = request[incomingKey];
-	if (incoming.readableDidRead) return rejectBodyUnusable();
-	const buffered = readBodyBufferedBeforeDisconnect(incoming);
-	if (buffered !== void 0) {
-		if (buffered instanceof Error) return Promise.reject(buffered);
-		request[bodyBufferKey] = buffered;
-		return Promise.resolve(buffered);
-	}
-	const promise = new Promise((resolve, reject) => {
-		const chunks = [];
-		let settled = false;
-		const finish = (callback) => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			callback();
-		};
-		const recoverCompleteBodyAfterDisconnect = (error) => {
-			const streamError = incoming.errored ?? error;
-			if (!isRecoverableDisconnectedIncoming(incoming) || streamError && streamError.code !== "ECONNRESET") return false;
-			finish(() => {
-				const recovered = readBodyBufferedBeforeDisconnect(incoming, chunks);
-				if (recovered instanceof Error) reject(recovered);
-				else if (recovered === void 0) reject(error ?? normalizeAbortError(request, incoming));
-				else {
-					request[bodyBufferKey] = recovered;
-					resolve(recovered);
-				}
-			});
-			return true;
-		};
-		const onData = (chunk) => {
-			chunks.push(toBufferChunk(chunk, incoming.readableEncoding));
-		};
-		const onEnd = () => {
-			finish(() => {
-				const buffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks);
-				request[bodyBufferKey] = buffer;
-				resolve(buffer);
-			});
-		};
-		const onError = (error) => {
-			if (recoverCompleteBodyAfterDisconnect(error)) return;
-			finish(() => {
-				reject(error);
-			});
-		};
-		const onClose = () => {
-			if (incoming.readableEnded) {
-				onEnd();
-				return;
-			}
-			if (recoverCompleteBodyAfterDisconnect()) return;
-			finish(() => {
-				reject(normalizeAbortError(request, incoming));
-			});
-		};
-		const cleanup = () => {
-			incoming.off("data", onData);
-			incoming.off("end", onEnd);
-			incoming.off("error", onError);
-			incoming.off("close", onClose);
-			request[bodyReadPromiseKey] = void 0;
-		};
-		incoming.on("data", onData);
-		incoming.on("end", onEnd);
-		incoming.on("error", onError);
-		incoming.on("close", onClose);
-		queueMicrotask(() => {
-			if (settled) return;
-			if (incoming.readableEnded) onEnd();
-			else if (incoming.errored) onError(incoming.errored);
-			else if (incoming.destroyed) onClose();
-		});
-	});
-	request[bodyReadPromiseKey] = promise;
-	return promise;
-};
-const requestPrototype = {
-	get method() {
-		return this[methodKey];
-	},
-	get url() {
-		return this[urlKey];
-	},
-	get headers() {
-		return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
-	},
-	[abortRequest](reason) {
-		if (this[abortReasonKey] === void 0) this[abortReasonKey] = reason;
-		const abortController = this[abortControllerKey];
-		if (abortController && !abortController.signal.aborted) abortController.abort(reason);
-	},
-	[getAbortController]() {
-		this[abortControllerKey] ||= new AbortController();
-		if (this[abortReasonKey] !== void 0 && !this[abortControllerKey].signal.aborted) this[abortControllerKey].abort(this[abortReasonKey]);
-		return this[abortControllerKey];
-	},
-	[getRequestCache]() {
-		const abortController = this[getAbortController]();
-		if (this[requestCache]) return this[requestCache];
-		const method = this.method;
-		if (this[bodyConsumedDirectlyKey] && !(method === "GET" || method === "HEAD")) {
-			this[bodyBufferKey] = void 0;
-			const init = {
-				method: method === "TRACE" ? "GET" : method,
-				headers: this.headers,
-				signal: abortController.signal
-			};
-			if (method !== "TRACE") {
-				init.body = new ReadableStream({ start(c) {
-					c.close();
-				} });
-				init.duplex = "half";
-			}
-			const req = new Request$1(this[urlKey], init);
-			if (method === "TRACE") Object.defineProperty(req, "method", { get() {
-				return "TRACE";
-			} });
-			return this[requestCache] = req;
-		}
-		return this[requestCache] = newRequestFromIncoming(this.method, this[urlKey], this.headers, this[incomingKey], abortController);
-	},
-	get body() {
-		if (!this[bodyConsumedDirectlyKey]) return this[getRequestCache]().body;
-		const request = this[getRequestCache]();
-		if (!this[bodyLockReaderKey] && request.body) this[bodyLockReaderKey] = request.body.getReader();
-		return request.body;
-	},
-	get bodyUsed() {
-		if (this[bodyConsumedDirectlyKey]) return true;
-		if (this[requestCache]) return this[requestCache].bodyUsed;
-		return false;
-	}
-};
-Object.defineProperty(requestPrototype, "signal", { get() {
-	return this[getAbortController]().signal;
-} });
-[
-	"cache",
-	"credentials",
-	"destination",
-	"integrity",
-	"mode",
-	"redirect",
-	"referrer",
-	"referrerPolicy",
-	"keepalive"
-].forEach((k) => {
-	Object.defineProperty(requestPrototype, k, { get() {
-		return this[getRequestCache]()[k];
-	} });
-});
-["clone", "formData"].forEach((k) => {
-	Object.defineProperty(requestPrototype, k, { value: function() {
-		if (this[bodyConsumedDirectlyKey]) {
-			if (k === "clone") throw newBodyUnusableError();
-			return rejectBodyUnusable();
-		}
-		return this[getRequestCache]()[k]();
-	} });
-});
-Object.defineProperty(requestPrototype, "text", { value: function() {
-	return readBodyWithFastPath(this, "text", (buf) => textDecoder.decode(buf));
-} });
-Object.defineProperty(requestPrototype, "arrayBuffer", { value: function() {
-	return readBodyWithFastPath(this, "arrayBuffer", (buf) => toArrayBuffer(buf));
-} });
-Object.defineProperty(requestPrototype, "blob", { value: function() {
-	return readBodyWithFastPath(this, "blob", (buf, request) => {
-		const type = contentType(request);
-		return new Response(buf, type ? { headers: { "content-type": type } } : void 0).blob();
-	});
-} });
-Object.defineProperty(requestPrototype, "json", { value: function() {
-	if (this[bodyConsumedDirectlyKey]) return rejectBodyUnusable();
-	return this.text().then(JSON.parse);
-} });
-Object.defineProperty(requestPrototype, Symbol.for("nodejs.util.inspect.custom"), { value: function(depth, options, inspectFn) {
-	return `Request (lightweight) ${inspectFn({
-		method: this.method,
-		url: this.url,
-		headers: this.headers,
-		nativeRequest: this[requestCache]
-	}, {
-		...options,
-		depth: depth == null ? null : depth - 1
-	})}`;
-} });
-Object.setPrototypeOf(requestPrototype, Request$1.prototype);
-const newRequest = (incoming, defaultHostname) => {
-	const req = Object.create(requestPrototype);
-	req[incomingKey] = incoming;
-	req[methodKey] = normalizeIncomingMethod(incoming.method);
-	const incomingUrl = incoming.url || "";
-	if (incomingUrl[0] !== "/" && (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
-		if (incoming instanceof Http2ServerRequest) throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
-		try {
-			req[urlKey] = new URL(incomingUrl).href;
-		} catch (e) {
-			throw new RequestError("Invalid absolute URL", { cause: e });
-		}
-		return req;
-	}
-	const host = (incoming instanceof Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
-	if (!host) throw new RequestError("Missing host header");
-	let scheme;
-	if (incoming instanceof Http2ServerRequest) {
-		scheme = incoming.scheme;
-		if (!(scheme === "http" || scheme === "https")) throw new RequestError("Unsupported scheme");
-	} else scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
-	try {
-		req[urlKey] = buildUrl(scheme, host, incomingUrl);
-	} catch (e) {
-		if (e instanceof RequestError) throw e;
-		else throw new RequestError("Invalid URL", { cause: e });
-	}
-	return req;
-};
-//#endregion
-//#region ../../plugins/acryl-node-server/src/adapter/response.ts
-const defaultContentType = "text/plain; charset=UTF-8";
-const responseCache = Symbol("responseCache");
-const getResponseCache = Symbol("getResponseCache");
-const cacheKey = Symbol("cache");
-const GlobalResponse = global.Response;
-var Response$1 = class Response$1 {
-	#body;
-	#init;
-	[getResponseCache]() {
-		const cache = this[cacheKey];
-		const liveHeaders = cache && cache[2] instanceof Headers ? cache[2] : void 0;
-		delete this[cacheKey];
-		return this[responseCache] ||= new GlobalResponse(this.#body, liveHeaders ? {
-			status: this.#init?.status,
-			statusText: this.#init?.statusText,
-			headers: liveHeaders
-		} : this.#init);
-	}
-	constructor(body, init) {
-		let headers;
-		this.#body = body;
-		if (init instanceof GlobalResponse) {
-			const cachedGlobalResponse = init[responseCache];
-			if (cachedGlobalResponse) {
-				this.#init = cachedGlobalResponse;
-				this[getResponseCache]();
-				return;
-			}
-			this.#init = init instanceof Response$1 ? init.#init : init;
-			headers = new Headers(init.headers);
-		} else this.#init = init;
-		if (body == null || typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) this[cacheKey] = [
-			init?.status || 200,
-			body ?? null,
-			headers || init?.headers
-		];
-	}
-	get headers() {
-		const cache = this[cacheKey];
-		if (cache) {
-			if (!(cache[2] instanceof Headers)) cache[2] = new Headers(cache[2] || (cache[1] === null ? void 0 : { "content-type": "text/plain; charset=UTF-8" }));
-			return cache[2];
-		}
-		return this[getResponseCache]().headers;
-	}
-	get status() {
-		return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
-	}
-	get ok() {
-		const status = this.status;
-		return status >= 200 && status < 300;
-	}
-};
-[
-	"body",
-	"bodyUsed",
-	"redirected",
-	"statusText",
-	"trailers",
-	"type",
-	"url"
-].forEach((k) => {
-	Object.defineProperty(Response$1.prototype, k, { get() {
-		return this[getResponseCache]()[k];
-	} });
-});
-[
-	"arrayBuffer",
-	"blob",
-	"clone",
-	"formData",
-	"json",
-	"text"
-].forEach((k) => {
-	Object.defineProperty(Response$1.prototype, k, { value: function() {
-		return this[getResponseCache]()[k]();
-	} });
-});
-Object.defineProperty(Response$1.prototype, Symbol.for("nodejs.util.inspect.custom"), { value: function(depth, options, inspectFn) {
-	return `Response (lightweight) ${inspectFn({
-		status: this.status,
-		headers: this.headers,
-		ok: this.ok,
-		nativeResponse: this[responseCache]
-	}, {
-		...options,
-		depth: depth == null ? null : depth - 1
-	})}`;
-} });
-Object.setPrototypeOf(Response$1, GlobalResponse);
-Object.setPrototypeOf(Response$1.prototype, GlobalResponse.prototype);
-const validRedirectUrl = /^https?:\/\/[!#-;=?-[\]_a-z~A-Z]+$/;
-const parseRedirectUrl = (url) => {
-	if (url instanceof URL) return url.href;
-	if (validRedirectUrl.test(url)) return url;
-	return new URL(url).href;
-};
-const validRedirectStatuses = /* @__PURE__ */ new Set([
-	301,
-	302,
-	303,
-	307,
-	308
-]);
-Object.defineProperty(Response$1, "redirect", {
-	value: function redirect(url, status = 302) {
-		if (!validRedirectStatuses.has(status)) throw new RangeError("Invalid status code");
-		return new Response$1(null, {
-			status,
-			headers: { location: parseRedirectUrl(url) }
-		});
-	},
-	writable: true,
-	configurable: true
-});
-Object.defineProperty(Response$1, "json", {
-	value: function json(data, init) {
-		const body = JSON.stringify(data);
-		if (body === void 0) throw new TypeError("The data is not JSON serializable");
-		const initHeaders = init?.headers;
-		let headers;
-		if (initHeaders) {
-			headers = new Headers(initHeaders);
-			if (!headers.has("content-type")) headers.set("content-type", "application/json");
-		} else headers = { "content-type": "application/json" };
-		return new Response$1(body, {
-			status: init?.status ?? 200,
-			statusText: init?.statusText,
-			headers
-		});
-	},
-	writable: true,
-	configurable: true
-});
-//#endregion
-//#region ../../plugins/acryl-node-server/src/adapter/utils.ts
-async function readWithoutBlocking(readPromise) {
-	return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
-}
-function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
-	const cancel = (error) => {
-		reader.cancel(error).catch(() => {});
-	};
-	writable.on("close", cancel);
-	writable.on("error", cancel);
-	(currentReadPromise ?? reader.read()).then(flow, handleStreamError);
-	return reader.closed.finally(() => {
-		writable.off("close", cancel);
-		writable.off("error", cancel);
-	});
-	function handleStreamError(error) {
-		if (error) writable.destroy(error);
-	}
-	function onDrain() {
-		reader.read().then(flow, handleStreamError);
-	}
-	function flow({ done, value }) {
-		try {
-			if (done) writable.end();
-			else if (!writable.write(value)) writable.once("drain", onDrain);
-			else return reader.read().then(flow, handleStreamError);
-		} catch (e) {
-			handleStreamError(e);
-		}
-	}
-}
-function writeFromReadableStream(stream, writable) {
-	if (stream.locked) throw new TypeError("ReadableStream is locked.");
-	else if (writable.destroyed) return;
-	return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
-}
-const buildOutgoingHttpHeaders = (headers, defaultContentType) => {
-	const res = {};
-	if (!(headers instanceof Headers)) headers = new Headers(headers ?? void 0);
-	if (headers.has("set-cookie")) {
-		const cookies = [];
-		for (const [k, v] of headers) if (k === "set-cookie") cookies.push(v);
-		else res[k] = v;
-		if (cookies.length > 0) res["set-cookie"] = cookies;
-	} else for (const [k, v] of headers) res[k] = v;
-	if (defaultContentType) res["content-type"] ??= defaultContentType;
-	return res;
-};
-//#endregion
-//#region ../../plugins/acryl-node-server/src/adapter/listener.ts
-const outgoingEnded = Symbol("outgoingEnded");
-const incomingDraining = Symbol("incomingDraining");
-const DRAIN_TIMEOUT_MS = 500;
-const MAX_DRAIN_BYTES = 64 * 1024 * 1024;
-const drainIncoming = (incoming) => {
-	const incomingWithDrainState = incoming;
-	if (incoming.destroyed || incomingWithDrainState[incomingDraining]) return;
-	incomingWithDrainState[incomingDraining] = true;
-	if (incoming instanceof Http2ServerRequest) {
-		try {
-			incoming.stream?.close?.(constants.NGHTTP2_NO_ERROR);
-		} catch {}
-		return;
-	}
-	let bytesRead = 0;
-	const cleanup = () => {
-		clearTimeout(timer);
-		incoming.off("data", onData);
-		incoming.off("end", cleanup);
-		incoming.off("error", cleanup);
-	};
-	const forceClose = () => {
-		cleanup();
-		const socket = incoming.socket;
-		if (socket && !socket.destroyed) {
-			if (typeof socket.destroySoon === "function") socket.destroySoon();
-			else if (typeof socket.destroy === "function") socket.destroy();
-		}
-	};
-	const timer = setTimeout(forceClose, DRAIN_TIMEOUT_MS);
-	timer.unref?.();
-	const onData = (chunk) => {
-		bytesRead += chunk.length;
-		if (bytesRead > MAX_DRAIN_BYTES) forceClose();
-	};
-	incoming.removeAllListeners("data");
-	incoming.on("data", onData);
-	incoming.on("end", cleanup);
-	incoming.on("error", cleanup);
-	incoming.resume();
-};
-const makeCloseHandler = (req, incoming, outgoing, needsBodyCleanup) => () => {
-	if (incoming.errored) {
-		recordBodyBufferedBeforeDisconnect(incoming);
-		req[abortRequest](incoming.errored.toString());
-	} else if (!outgoing.writableFinished || incoming instanceof Http2ServerRequest && incoming.aborted) {
-		recordBodyBufferedBeforeDisconnect(incoming);
-		req[abortRequest]("Client connection prematurely closed.");
-	}
-	if (needsBodyCleanup && !incoming.readableEnded) setTimeout(() => {
-		if (!incoming.readableEnded) setTimeout(() => {
-			drainIncoming(incoming);
-		});
-	});
-};
-const isImmediateCacheableResponse = (res) => {
-	if (!(cacheKey in res)) return false;
-	const body = res[cacheKey][1];
-	return body === null || typeof body === "string" || body instanceof Uint8Array;
-};
-const handleRequestError = () => new Response(null, { status: 400 });
-const handleFetchError = (e) => new Response(null, { status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500 });
-const handleResponseError = (e, outgoing) => {
-	const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
-	if (err.code === "ERR_STREAM_PREMATURE_CLOSE") console.info("The user aborted a request.");
-	else {
-		console.error(e);
-		if (!outgoing.headersSent) {
-			if (outgoing instanceof ServerResponse) outgoing._contentLength = null;
-			outgoing.writeHead(500, { "Content-Type": "text/plain" });
-		}
-		outgoing.end(`Error: ${err.message}`);
-		outgoing.destroy(err);
-	}
-};
-const flushHeaders = (outgoing) => {
-	if ("flushHeaders" in outgoing && outgoing.writable) outgoing.flushHeaders();
-};
-const trySetContentLength = (outgoing, status, length) => {
-	const http1 = outgoing;
-	if (http1._contentLength === null && http1._hasBody && http1.useChunkedEncodingByDefault && !http1._removedContLen && status >= 200 && status !== 204 && status !== 304 && !outgoing.hasHeader("content-length") && !outgoing.hasHeader("transfer-encoding") && !outgoing.hasHeader("trailer")) {
-		http1._contentLength = length;
-		return true;
-	}
-	return false;
-};
-const writeDefaultHeaders = (outgoing, status, length) => {
-	if (trySetContentLength(outgoing, status, length)) outgoing.writeHead(status, { "Content-Type": defaultContentType });
-	else outgoing.writeHead(status, {
-		"Content-Type": defaultContentType,
-		"Content-Length": length
-	});
-};
-const responseViaCache = async (res, outgoing) => {
-	let [status, body, header] = res[cacheKey];
-	if (!header) {
-		if (body === null) {
-			outgoing.writeHead(status);
-			outgoing.end();
-		} else if (typeof body === "string") {
-			writeDefaultHeaders(outgoing, status, Buffer.byteLength(body));
-			outgoing.end(body);
-		} else if (body instanceof Uint8Array) {
-			writeDefaultHeaders(outgoing, status, body.byteLength);
-			outgoing.end(body);
-		} else if (body instanceof Blob) {
-			writeDefaultHeaders(outgoing, status, body.size);
-			outgoing.end(new Uint8Array(await body.arrayBuffer()));
-		} else {
-			outgoing.writeHead(status, { "Content-Type": defaultContentType });
-			flushHeaders(outgoing);
-			await writeFromReadableStream(body, outgoing)?.catch((e) => handleResponseError(e, outgoing));
-		}
-		outgoing[outgoingEnded]?.();
-		return;
-	}
-	let hasContentLength = false;
-	let plainHeaders = false;
-	let canAutoLength = true;
-	if (header instanceof Headers) {
-		hasContentLength = header.has("content-length");
-		header = buildOutgoingHttpHeaders(header, body === null ? void 0 : defaultContentType);
-	} else if (Array.isArray(header)) {
-		const headerObj = new Headers(header);
-		hasContentLength = headerObj.has("content-length");
-		header = buildOutgoingHttpHeaders(headerObj, body === null ? void 0 : defaultContentType);
-	} else {
-		plainHeaders = true;
-		for (const key in header) {
-			if (key.length === 14 && key.toLowerCase() === "content-length") {
-				hasContentLength = true;
-				break;
-			}
-			if (key.length === 17 && key.toLowerCase() === "transfer-encoding" || key.length === 7 && key.toLowerCase() === "trailer") canAutoLength = false;
-		}
-	}
-	if (!hasContentLength) {
-		let length;
-		if (typeof body === "string") length = Buffer.byteLength(body);
-		else if (body instanceof Uint8Array) length = body.byteLength;
-		else if (body instanceof Blob) length = body.size;
-		if (length !== void 0 && (!plainHeaders || !canAutoLength || !trySetContentLength(outgoing, status, length))) {
-			if (plainHeaders) header = { ...header };
-			header["Content-Length"] = length;
-		}
-	}
-	outgoing.writeHead(status, header);
-	if (body == null) outgoing.end();
-	else if (typeof body === "string" || body instanceof Uint8Array) outgoing.end(body);
-	else if (body instanceof Blob) outgoing.end(new Uint8Array(await body.arrayBuffer()));
-	else {
-		flushHeaders(outgoing);
-		await writeFromReadableStream(body, outgoing)?.catch((e) => handleResponseError(e, outgoing));
-	}
-	outgoing[outgoingEnded]?.();
-};
-const isPromise = (res) => typeof res.then === "function";
-const responseViaResponseObject = async (res, outgoing, options = {}) => {
-	if (isPromise(res)) if (options.errorHandler) try {
-		res = await res;
-	} catch (err) {
-		const errRes = await options.errorHandler(err);
-		if (!errRes) return;
-		res = errRes;
-	}
-	else res = await res.catch(handleFetchError);
-	if (cacheKey in res) return responseViaCache(res, outgoing);
-	const resHeaderRecord = buildOutgoingHttpHeaders(res.headers, res.body === null ? void 0 : defaultContentType);
-	if (res.body) {
-		const reader = res.body.getReader();
-		const values = [];
-		let done = false;
-		let currentReadPromise = void 0;
-		if (resHeaderRecord["transfer-encoding"] !== "chunked") {
-			let maxReadCount = 2;
-			for (let i = 0; i < maxReadCount; i++) {
-				currentReadPromise ||= reader.read();
-				const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
-					console.error(e);
-					done = true;
-				});
-				if (!chunk) {
-					if (i === 1) {
-						await new Promise((resolve) => setTimeout(resolve));
-						maxReadCount = 3;
-						continue;
-					}
-					break;
-				}
-				currentReadPromise = void 0;
-				if (chunk.value) values.push(chunk.value);
-				if (chunk.done) {
-					done = true;
-					break;
-				}
-			}
-			if (done && !("content-length" in resHeaderRecord)) resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
-		}
-		outgoing.writeHead(res.status, resHeaderRecord);
-		values.forEach((value) => {
-			outgoing.write(value);
-		});
-		if (done) outgoing.end();
-		else {
-			if (values.length === 0) flushHeaders(outgoing);
-			await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
-		}
-	} else if (resHeaderRecord["x-acryl-already-sent"]) {} else {
-		outgoing.writeHead(res.status, resHeaderRecord);
-		outgoing.end();
-	}
-	outgoing[outgoingEnded]?.();
-};
-const getRequestListener = (fetchCallback, options = {}) => {
-	const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
-	if (options.overrideGlobalObjects !== false && global.Request !== Request$1) {
-		Object.defineProperty(global, "Request", { value: Request$1 });
-		Object.defineProperty(global, "Response", { value: Response$1 });
-	}
-	return async (incoming, outgoing) => {
-		let res, req;
-		let needsBodyCleanup = false;
-		let closeHandlerAttached = false;
-		const ensureCloseHandler = () => {
-			if (!req || closeHandlerAttached) return;
-			closeHandlerAttached = true;
-			outgoing.on("close", makeCloseHandler(req, incoming, outgoing, needsBodyCleanup));
-		};
-		try {
-			req = newRequest(incoming, options.hostname);
-			needsBodyCleanup = autoCleanupIncoming && !(incoming.method === "GET" || incoming.method === "HEAD");
-			if (needsBodyCleanup) {
-				incoming[wrapBodyStream] = true;
-				if (incoming instanceof Http2ServerRequest) outgoing[outgoingEnded] = () => {
-					if (!incoming.readableEnded) setTimeout(() => {
-						if (!incoming.readableEnded) setTimeout(() => {
-							incoming.destroy();
-							outgoing.destroy();
-						});
-					});
-				};
-			}
-			res = fetchCallback(req, {
-				incoming,
-				outgoing
-			});
-			if (!isPromise(res) && isImmediateCacheableResponse(res)) {
-				if (needsBodyCleanup && !incoming.readableEnded) outgoing.once("finish", () => {
-					if (!incoming.readableEnded) drainIncoming(incoming);
-				});
-				return responseViaCache(res, outgoing);
-			}
-			ensureCloseHandler();
-		} catch (e) {
-			if (!res) if (options.errorHandler) {
-				ensureCloseHandler();
-				res = await options.errorHandler(req ? e : toRequestError(e));
-				if (!res) return;
-			} else if (!req) res = handleRequestError();
-			else res = handleFetchError(e);
-			else return handleResponseError(e, outgoing);
-		}
-		try {
-			return await responseViaResponseObject(res, outgoing, options);
-		} catch (e) {
-			return handleResponseError(e, outgoing);
-		}
-	};
-};
-//#endregion
-//#region ../../plugins/acryl-node-server/src/adapter/websocket.ts
-/**
-* @link https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
-*/
-const CloseEvent = globalThis.CloseEvent ?? class extends Event {
-	#eventInitDict;
-	constructor(type, eventInitDict = {}) {
-		super(type, eventInitDict);
-		this.#eventInitDict = eventInitDict;
-	}
-	get wasClean() {
-		return this.#eventInitDict.wasClean ?? false;
-	}
-	get code() {
-		return this.#eventInitDict.code ?? 0;
-	}
-	get reason() {
-		return this.#eventInitDict.reason ?? "";
-	}
-};
-/**
-* Node.js has no global `ErrorEvent`, unlike `Event`/`MessageEvent`/`CloseEvent`.
-* @link https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent
-*/
-const ErrorEvent = globalThis.ErrorEvent ?? class extends Event {
-	#eventInitDict;
-	constructor(type, eventInitDict = {}) {
-		super(type, eventInitDict);
-		this.#eventInitDict = eventInitDict;
-	}
-	get message() {
-		return this.#eventInitDict.message ?? "";
-	}
-	get filename() {
-		return this.#eventInitDict.filename ?? "";
-	}
-	get lineno() {
-		return this.#eventInitDict.lineno ?? 0;
-	}
-	get colno() {
-		return this.#eventInitDict.colno ?? 0;
-	}
-	get error() {
-		return this.#eventInitDict.error ?? null;
-	}
-};
-const generateConnectionSymbol = () => Symbol("connection");
-const CONNECTION_SYMBOL_KEY = Symbol("CONNECTION_SYMBOL_KEY");
-const WAIT_FOR_WEBSOCKET_SYMBOL = Symbol("WAIT_FOR_WEBSOCKET_SYMBOL");
-const responseHeadersToSkip = /* @__PURE__ */ new Set([
-	"connection",
-	"content-length",
-	"keep-alive",
-	"proxy-authenticate",
-	"proxy-authorization",
-	"te",
-	"trailer",
-	"transfer-encoding",
-	"upgrade",
-	"sec-websocket-accept",
-	"sec-websocket-extensions",
-	"sec-websocket-protocol"
-]);
-const appendResponseHeaders = (headers, responseHeaders) => {
-	if (!responseHeaders) return;
-	responseHeaders.forEach((value, key) => {
-		if (responseHeadersToSkip.has(key.toLowerCase())) return;
-		headers.push(`${key}: ${value}`);
-	});
-};
-const rejectUpgradeRequest = (socket, status, responseHeaders) => {
-	const responseLines = ["Connection: close", "Content-Length: 0"];
-	appendResponseHeaders(responseLines, responseHeaders);
-	socket.end(`HTTP/1.1 ${status.toString()} ${STATUS_CODES[status] ?? ""}\r\n${responseLines.join("\r\n")}\r\n\r
-`);
-};
-const createUpgradeRequest = (request) => {
-	const protocol = request.socket.encrypted ? "https" : "http";
-	const url = new URL(request.url ?? "/", `${protocol}://${request.headers.host ?? "localhost"}`);
-	const headers = new Headers();
-	for (const key in request.headers) {
-		const value = request.headers[key];
-		if (!value) continue;
-		headers.append(key, Array.isArray(value) ? value[0] : value);
-	}
-	return new Request(url, { headers });
-};
-const setupWebSocket = (options) => {
-	const { server, fetchCallback, wss } = options;
-	const waiterMap = /* @__PURE__ */ new Map();
-	wss.on("connection", (ws, request) => {
-		const waiter = waiterMap.get(request);
-		if (waiter) {
-			waiter.resolve(ws);
-			waiterMap.delete(request);
-		}
-	});
-	const rejectWaiter = (request) => {
-		const waiter = waiterMap.get(request);
-		if (waiter) {
-			waiterMap.delete(request);
-			waiter.reject(/* @__PURE__ */ new Error("WebSocket handshake aborted"));
-		}
-	};
-	const waitForWebSocket = (request, connectionSymbol) => {
-		return new Promise((resolve, reject) => {
-			waiterMap.set(request, {
-				resolve,
-				reject,
-				connectionSymbol
-			});
-		});
-	};
-	server.on("upgrade", async (request, socket, head) => {
-		if (request.headers.upgrade?.toLowerCase() !== "websocket") return;
-		const env = {
-			incoming: request,
-			outgoing: void 0,
-			wss,
-			[WAIT_FOR_WEBSOCKET_SYMBOL]: waitForWebSocket
-		};
-		let status = 400;
-		let responseHeaders;
-		try {
-			const response = await fetchCallback(createUpgradeRequest(request), env);
-			if (response instanceof Response) {
-				status = response.status;
-				responseHeaders = response.headers;
-			}
-		} catch {
-			if (server.listenerCount("upgrade") === 1) rejectUpgradeRequest(socket, 500);
-			return;
-		}
-		const waiter = waiterMap.get(request);
-		if (!waiter || waiter.connectionSymbol !== env[CONNECTION_SYMBOL_KEY]) {
-			rejectWaiter(request);
-			if (server.listenerCount("upgrade") === 1) rejectUpgradeRequest(socket, status, responseHeaders);
-			return;
-		}
-		const addResponseHeaders = (headers) => {
-			appendResponseHeaders(headers, responseHeaders);
-		};
-		const reclaimWaiterOnClose = () => rejectWaiter(request);
-		socket.once("close", reclaimWaiterOnClose);
-		wss.on("headers", addResponseHeaders);
-		try {
-			wss.handleUpgrade(request, socket, head, (ws) => {
-				socket.off("close", reclaimWaiterOnClose);
-				wss.emit("connection", ws, request);
-			});
-		} finally {
-			wss.off("headers", addResponseHeaders);
-		}
-	});
-	server.on("close", () => {
-		wss.close();
-	});
-};
-const upgradeWebSocket = defineWebSocketHelper(async (c, events, options) => {
-	if (c.req.header("upgrade")?.toLowerCase() !== "websocket") return;
-	const env = c.env;
-	const waitForWebSocket = env[WAIT_FOR_WEBSOCKET_SYMBOL];
-	if (!waitForWebSocket || !env.incoming) return new Response(null, { status: 500 });
-	const connectionSymbol = generateConnectionSymbol();
-	env[CONNECTION_SYMBOL_KEY] = connectionSymbol;
-	(async () => {
-		let ws;
-		try {
-			ws = await waitForWebSocket(env.incoming, connectionSymbol);
-		} catch {
-			return;
-		}
-		const messagesReceivedInStarting = [];
-		const bufferMessage = (data, isBinary) => {
-			messagesReceivedInStarting.push([data, isBinary]);
-		};
-		ws.on("message", bufferMessage);
-		const ctx = {
-			binaryType: "arraybuffer",
-			close(code, reason) {
-				ws.close(code, reason);
-			},
-			protocol: ws.protocol,
-			raw: ws,
-			get readyState() {
-				return ws.readyState;
-			},
-			send(source, opts) {
-				ws.send(source, { compress: opts?.compress });
-			},
-			url: new URL(c.req.url)
-		};
-		try {
-			events?.onOpen?.(new Event("open"), ctx);
-		} catch (e) {
-			(options?.onError ?? console.error)(e);
-		}
-		const handleMessage = (data, isBinary) => {
-			const datas = Array.isArray(data) ? data : [data];
-			for (const data of datas) try {
-				events?.onMessage?.(new MessageEvent("message", { data: isBinary ? data instanceof ArrayBuffer ? data : data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength) : typeof data === "string" ? data : Buffer.from(data).toString("utf-8") }), ctx);
-			} catch (e) {
-				(options?.onError ?? console.error)(e);
-			}
-		};
-		ws.off("message", bufferMessage);
-		for (const message of messagesReceivedInStarting) handleMessage(...message);
-		ws.on("message", (data, isBinary) => {
-			handleMessage(data, isBinary);
-		});
-		ws.on("close", (code, reason) => {
-			try {
-				events?.onClose?.(new CloseEvent("close", {
-					code,
-					reason: reason.toString()
-				}), ctx);
-			} catch (e) {
-				(options?.onError ?? console.error)(e);
-			}
-		});
-		ws.on("error", (error) => {
-			try {
-				events?.onError?.(new ErrorEvent("error", { error }), ctx);
-			} catch (e) {
-				(options?.onError ?? console.error)(e);
-			}
-		});
-	})();
-	return new Response();
-});
-function createAdaptorServer(options) {
-	const fetchCallback = options.fetch;
-	const requestListener = getRequestListener(fetchCallback, {
-		hostname: options.hostname,
-		overrideGlobalObjects: options.overrideGlobalObjects,
-		autoCleanupIncoming: options.autoCleanupIncoming
-	});
-	const server = (options.createServer || createServer)(options.serverOptions || {}, requestListener);
-	if (options.websocket && options.websocket.server) {
-		if (options.websocket.server.options.noServer !== true) throw new Error("WebSocket server must be created with { noServer: true } option");
-		setupWebSocket({
-			server,
-			fetchCallback,
-			wss: options.websocket.server
-		});
-	}
-	return server;
-}
-function serve(options, listeningListener) {
-	const server = createAdaptorServer(options);
-	server.listen(options?.port ?? 3e3, options.hostname ?? "127.0.0.1", () => {
-		const serverInfo = server.address();
-		listeningListener && listeningListener(serverInfo);
-	});
-	return server;
-}
-//#endregion
-//#region ../../plugins/acryl-node-server/src/client-modules.ts
-/**
-* Client components without a bundler. `clientModules({ root: 'src/client' })` is an app that serves the TypeScript and JSX modules of a
-* folder to the browser as ES modules: a `.tsx`/`.ts`/`.jsx` file compiled with the app's own `typescript` (JSX for `acrylblends/jsx/dom`),
-* a `.js`/`.mjs` file as it is. The framework's own browser imports (`acrylblends/jsx/dom` with its runtimes and `client`,
-* `acrylblends/client` and `acrylblends/read-sse`) are rewritten to three self-contained files the same app serves, at a URL relative to each module, so a page needs
-* one `<script type="module" src="/client/counter.tsx">` and no import map, under whatever path the app is routed at.
-*
-* Production runs without `typescript` (a deploy that leaves out devDependencies): `buildClientModules` writes the same compiled modules
-* and the three browser files into a folder, and with `NODE_ENV=production` and `compiled` set, only that folder is served.
-*/
-/** The folder the three browser files are served from, below the app's mount. A source folder of this name is not served. */
-const RUNTIME_DIR = "@acrylblends";
-/** The framework's browser imports and the browser file that provides each. */
-const BROWSER_IMPORTS = {
-	"acrylblends/jsx/dom": "jsx-dom.js",
-	"acrylblends/jsx/dom/jsx-runtime": "jsx-dom.js",
-	"acrylblends/jsx/dom/jsx-dev-runtime": "jsx-dom.js",
-	"acrylblends/jsx/dom/client": "jsx-dom.js",
-	"acrylblends/client": "client.js",
-	"acrylblends/read-sse": "read-sse.js"
-};
-const RUNTIME_FILES = [
-	"jsx-dom.js",
-	"client.js",
-	"read-sse.js"
-];
-const COMPILED = /* @__PURE__ */ new Set([
-	".ts",
-	".tsx",
-	".jsx",
-	".mts"
-]);
-const SERVED = /* @__PURE__ */ new Set([
-	...COMPILED,
-	".js",
-	".mjs"
-]);
-const JS_TYPE = "text/javascript; charset=utf-8";
-/** The cache bound when `cacheBytes` is not given. */
-const DEFAULT_CACHE_BYTES = 16 * 1024 * 1024;
-/** The framework's three browser files, next to the built module that contains this code. */
-const defaultRuntimeDir = () => fileURLToPath(new URL("./browser/", import.meta.url));
-/** A module path below the root (`widgets/counter.tsx`) with the URL prefix that reaches the browser files from it. */
-const runtimePrefix = (relativePath) => {
-	const depth = relativePath.split("/").length - 1;
-	return depth === 0 ? "./" : "../".repeat(depth);
-};
-/** One client module compiled for the browser: TypeScript and JSX compiled, the framework's imports pointed at its browser files. */
-function compileForBrowser(file, relativePath) {
-	const prefix = runtimePrefix(relativePath);
-	return compileModule(file, readFileSync(file, "utf8"), {
-		importSource: "acrylblends/jsx/dom",
-		defaultImportSource: "acrylblends/jsx/dom",
-		what: "is a client module",
-		rewrite: (specifier) => {
-			const target = BROWSER_IMPORTS[specifier];
-			return target === void 0 ? void 0 : `${prefix}${RUNTIME_DIR}/${target}`;
-		}
-	});
-}
-/**
-* The path below the root a request names, or `undefined` when it must not be served: a `..` or dot segment, a backslash or NUL, an
-* extension outside the served set, or a `.d.ts` file.
-*/
-function servedPath(requestPath) {
-	let decoded;
-	try {
-		decoded = decodeURIComponent(requestPath);
-	} catch {
-		return;
-	}
-	const parts = decoded.split("/").filter((part) => part !== "");
-	if (parts.length === 0 || parts.some((part) => part.startsWith(".") || part.includes("\\") || part.includes("\0"))) return void 0;
-	const path = parts.join("/");
-	if (!SERVED.has(extname(path)) || path.endsWith(".d.ts")) return void 0;
-	return path;
-}
-/** A real file inside `root` (symbolic links followed), or `undefined`. */
-function fileInside(root, path) {
-	try {
-		const file = realpathSync(join(root, ...path.split("/")));
-		return file.startsWith(root + sep) && statSync(file).isFile() ? file : void 0;
-	} catch {
-		return;
-	}
-}
-/** A file's validator: its size and modification time. */
-const etagOf = (stat) => `"${stat.size.toString(36)}-${Math.trunc(stat.mtimeMs).toString(36)}"`;
-/** Compiled modules, least recently served first, bounded by the UTF-8 bytes of their code. Exported for its tests. */
-var CompileCache = class {
-	entries = /* @__PURE__ */ new Map();
-	bytes = 0;
-	limit;
-	constructor(limit) {
-		this.limit = limit;
-	}
-	get(file, mtimeMs, size) {
-		const entry = this.entries.get(file);
-		if (entry === void 0) return void 0;
-		this.entries.delete(file);
-		if (entry.mtimeMs !== mtimeMs || entry.size !== size) {
-			this.bytes -= entry.bytes;
-			return;
-		}
-		this.entries.set(file, entry);
-		return entry;
-	}
-	set(file, stat, code) {
-		const entry = {
-			mtimeMs: stat.mtimeMs,
-			size: stat.size,
-			etag: etagOf(stat),
-			code,
-			bytes: Buffer.byteLength(code)
-		};
-		const previous = this.entries.get(file);
-		if (previous !== void 0) {
-			this.entries.delete(file);
-			this.bytes -= previous.bytes;
-		}
-		if (entry.bytes > this.limit) return entry;
-		this.entries.set(file, entry);
-		this.bytes += entry.bytes;
-		for (const [key, old] of this.entries) {
-			if (this.bytes <= this.limit) break;
-			this.entries.delete(key);
-			this.bytes -= old.bytes;
-		}
-		return entry;
-	}
-	/** The UTF-8 bytes of code held now. */
-	get heldBytes() {
-		return this.bytes;
-	}
-	/** The files held now, least recently served first. */
-	get files() {
-		return [...this.entries.keys()];
-	}
-};
-const absolute = (path) => isAbsolute(path) ? path : resolve(path);
-/** A folder's real path; one that does not exist (a production image that ships only the compiled folder) keeps its absolute path. */
-const realFolder = (path) => {
-	try {
-		return realpathSync(absolute(path));
-	} catch {
-		return absolute(path);
-	}
-};
-/**
-* An app serving a folder of client modules to the browser. Route it where the page's script tags point: `app.route('/client',
-* clientModules({ root: 'src/client' }))` serves `src/client/counter.tsx` at `/client/counter.tsx`. Files are compiled on request and
-* cached until they change (bounded by `cacheBytes`); a response carries an ETag and `Cache-Control: no-cache`, so an edit shows on the
-* next reload. With `NODE_ENV=production` and `compiled` set, only the `compiled` folder is served and nothing is compiled.
-* @param options - the folder, the precompiled folder, and the cache bound.
-* @returns the app.
-*/
-function clientModules(options) {
-	const root = realFolder(options.root);
-	const runtimeDir = absolute(options.runtimeDir ?? defaultRuntimeDir());
-	let compiled;
-	if (process.env.NODE_ENV === "production" && options.compiled !== void 0) try {
-		compiled = realpathSync(absolute(options.compiled));
-	} catch {
-		throw new Error(`acrylblends: the compiled client folder ${absolute(options.compiled)} does not exist; build it with buildClientModules before starting in production`);
-	}
-	const cache = new CompileCache(options.cacheBytes ?? DEFAULT_CACHE_BYTES);
-	const app = new Acryl();
-	app.get("/*", (c) => {
-		const requestPath = c.req.path.slice(basePath(c).length);
-		const runtime = /^\/@acrylblends\/([a-z-]+\.js)$/u.exec(requestPath)?.[1];
-		const send = (code, etag) => {
-			if (c.req.header("if-none-match") === etag) return c.body(null, 304, {
-				etag,
-				"cache-control": "no-cache"
-			});
-			return c.body(code, 200, {
-				"content-type": JS_TYPE,
-				etag,
-				"cache-control": "no-cache"
-			});
-		};
-		const serveFile = (file) => {
-			const stat = statSync(file);
-			return send(readFileSync(file, "utf8"), etagOf(stat));
-		};
-		if (runtime !== void 0) {
-			if (!RUNTIME_FILES.includes(runtime)) return c.notFound();
-			return serveFile(compiled === void 0 ? join(runtimeDir, runtime) : join(compiled, RUNTIME_DIR, runtime));
-		}
-		const path = servedPath(requestPath);
-		if (path === void 0 || path.split("/")[0] === RUNTIME_DIR) return c.notFound();
-		if (compiled !== void 0) {
-			const file = fileInside(compiled, path);
-			if (file !== void 0) return serveFile(file);
-			if (fileInside(root, path) !== void 0) return c.text(`acrylblends: ${path} is not in ${relative(process.cwd(), compiled) || compiled}; build the client modules again (buildClientModules)`, 500);
-			return c.notFound();
-		}
-		const file = fileInside(root, path);
-		if (file === void 0) return c.notFound();
-		if (!COMPILED.has(extname(file))) return serveFile(file);
-		const stat = statSync(file);
-		let entry = cache.get(file, stat.mtimeMs, stat.size);
-		if (entry === void 0) {
-			let code;
-			try {
-				code = compileForBrowser(file, path);
-			} catch (error) {
-				if (error instanceof MissingTypeScriptError) return c.text(error.message, 500);
-				throw error;
-			}
-			entry = cache.set(file, stat, code);
-		}
-		return send(entry.code, entry.etag);
-	});
-	return app;
-}
-/** Every served file below `dir`, as paths below `root` with `/` separators; dot entries, `node_modules` and the runtime folder skipped. */
-function sourceFiles(root, dir = root) {
-	const files = [];
-	for (const entry of readdirSync(dir, { withFileTypes: true })) {
-		if (entry.name.startsWith(".") || entry.name === "node_modules" || dir === root && entry.name === RUNTIME_DIR) continue;
-		const full = join(dir, entry.name);
-		if (entry.isDirectory()) files.push(...sourceFiles(root, full));
-		else if (entry.isFile() && SERVED.has(extname(entry.name)) && !entry.name.endsWith(".d.ts")) files.push(relative(root, full).split(sep).join("/"));
-	}
-	return files.sort();
-}
-/**
-* Compile a folder of client modules once, for a production that has no `typescript`: each module is written to `outDir` at the same
-* relative path and file name (so the page's URLs stay the same), compiled exactly as {@link clientModules} compiles it, and the three
-* browser files are copied to `outDir/@acrylblends/`. Files already in `outDir` that no source produces are left there.
-* @param options - the source folder and the output folder.
-* @returns the paths written, relative to `outDir`.
-* @throws MissingTypeScriptError when the app has no `typescript`; an error when `outDir` lies inside `root`.
-*/
-function buildClientModules(options) {
-	const root = realpathSync(absolute(options.root));
-	const outDir = absolute(options.outDir);
-	const runtimeDir = absolute(options.runtimeDir ?? defaultRuntimeDir());
-	if (outDir === root || outDir.startsWith(root + sep)) throw new Error(`acrylblends: the output folder ${outDir} lies inside the client folder ${root}`);
-	const written = [];
-	for (const path of sourceFiles(root)) {
-		const source = join(root, ...path.split("/"));
-		const target = join(outDir, ...path.split("/"));
-		mkdirSync(dirname(target), { recursive: true });
-		if (COMPILED.has(extname(path))) writeFileSync(target, compileForBrowser(source, path));
-		else copyFileSync(source, target);
-		written.push(path);
-	}
-	mkdirSync(join(outDir, RUNTIME_DIR), { recursive: true });
-	for (const name of RUNTIME_FILES) {
-		copyFileSync(join(runtimeDir, name), join(outDir, RUNTIME_DIR, name));
-		written.push(`${RUNTIME_DIR}/${name}`);
-	}
-	return written;
-}
-//#endregion
+import { n as clientModules, t as buildClientModules } from "./client-modules-CLvWOjbd.js";
 export { RequestError, buildClientModules, clientModules, createAdaptorServer, getConnInfo, getRequestListener, serve, serveStatic, upgradeWebSocket };