@hono/node-server 2.0.0-rc.1 → 2.0.0-rc.2

package/dist/{listener-Brd4yZ5d.js → index.cjs}

@@ -1,6 +1,9 @@
-const require_constants = require('./constants-B7DBcQew.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants = require('./constants-BXAKTxRC.cjs');
+let node_http = require("node:http");
 let node_http2 = require("node:http2");
 let node_stream = require("node:stream");
+let hono_ws = require("hono/ws");
 
 //#region src/error.ts
 var RequestError = class extends Error {
@@ -12,69 +15,19 @@ var RequestError = class extends Error {
 
 //#endregion
 //#region src/url.ts
-const isPathDelimiter = (charCode) => charCode === 47 || charCode === 63 || charCode === 35;
-const hasDotSegment = (url, dotIndex) => {
-	if ((dotIndex === 0 ? 47 : url.charCodeAt(dotIndex - 1)) !== 47) return false;
-	const nextIndex = dotIndex + 1;
-	if (nextIndex === url.length) return true;
-	const next = url.charCodeAt(nextIndex);
-	if (isPathDelimiter(next)) return true;
-	if (next !== 46) return false;
-	const nextNextIndex = dotIndex + 2;
-	if (nextNextIndex === url.length) return true;
-	return isPathDelimiter(url.charCodeAt(nextNextIndex));
-};
-const allowedRequestUrlChar = new Uint8Array(128);
-for (let c = 48; c <= 57; c++) allowedRequestUrlChar[c] = 1;
-for (let c = 65; c <= 90; c++) allowedRequestUrlChar[c] = 1;
-for (let c = 97; c <= 122; c++) allowedRequestUrlChar[c] = 1;
-(() => {
-	const chars = "-./:?#[]@!$&'()*+,;=~_";
-	for (let i = 0; i < 22; i++) allowedRequestUrlChar[chars.charCodeAt(i)] = 1;
-})();
-const safeHostChar = new Uint8Array(128);
-for (let c = 48; c <= 57; c++) safeHostChar[c] = 1;
-for (let c = 97; c <= 122; c++) safeHostChar[c] = 1;
-(() => {
-	const chars = ".-_:";
-	for (let i = 0; i < 4; i++) safeHostChar[chars.charCodeAt(i)] = 1;
-})();
+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}`;
-	let needsHostValidationByURL = false;
-	for (let i = 0, len = host.length; i < len; i++) {
-		const c = host.charCodeAt(i);
-		if (c > 127 || safeHostChar[c] === 0) {
-			needsHostValidationByURL = true;
-			break;
-		}
-		if (c === 58) {
-			i++;
-			const firstDigit = host.charCodeAt(i);
-			if (firstDigit < 49 || firstDigit > 57 || i + 4 > len || i + (firstDigit < 54 ? 5 : 4) < len) {
-				needsHostValidationByURL = true;
-				break;
-			}
-			for (; i < len; i++) {
-				const c = host.charCodeAt(i);
-				if (c < 48 || c > 57) {
-					needsHostValidationByURL = true;
-					break;
-				}
-			}
-		}
-	}
-	if (needsHostValidationByURL) {
+	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");
-		for (let i = 1, len = incomingUrl.length; i < len; i++) {
-			const c = incomingUrl.charCodeAt(i);
-			if (c > 127 || allowedRequestUrlChar[c] === 0 || c === 46 && hasDotSegment(incomingUrl, i)) return new URL(url).href;
-		}
+		if (!reValidRequestUrl.test(incomingUrl) || reDotSegment.test(incomingUrl)) return new URL(url).href;
 		return url;
 	}
 };
@@ -86,7 +39,7 @@ const toRequestError = (e) => {
 	return new RequestError(e.message, { cause: e });
 };
 const GlobalRequest = global.Request;
-var Request = class extends GlobalRequest {
+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;
@@ -100,9 +53,9 @@ var Request = class extends GlobalRequest {
 const newHeadersFromIncoming = (incoming) => {
 	const headerRecord = [];
 	const rawHeaders = incoming.rawHeaders;
-	for (let i = 0; i < rawHeaders.length; i += 2) {
-		const { [i]: key, [i + 1]: value } = rawHeaders;
-		if (key.charCodeAt(0) !== 58) headerRecord.push([key, value]);
+	for (let i = 0, len = rawHeaders.length; i < len; i += 2) {
+		const key = rawHeaders[i];
+		if (key.charCodeAt(0) !== 58) headerRecord.push([key, rawHeaders[i + 1]]);
 	}
 	return new Headers(headerRecord);
 };
@@ -115,7 +68,7 @@ const newRequestFromIncoming = (method, url, headers, incoming, abortController)
 	};
 	if (method === "TRACE") {
 		init.method = "GET";
-		const req = new Request(url, init);
+		const req = new Request$1(url, init);
 		Object.defineProperty(req, "method", { get() {
 			return "TRACE";
 		} });
@@ -138,7 +91,7 @@ const newRequestFromIncoming = (method, url, headers, incoming, abortController)
 			}
 		} });
 	} else init.body = node_stream.Readable.toWeb(incoming);
-	return new Request(url, init);
+	return new Request$1(url, init);
 };
 const getRequestCache = Symbol("getRequestCache");
 const requestCache = Symbol("requestCache");
@@ -330,7 +283,7 @@ const requestPrototype = {
 				} });
 				init.duplex = "half";
 			}
-			const req = new Request(this[urlKey], init);
+			const req = new Request$1(this[urlKey], init);
 			if (method === "TRACE") Object.defineProperty(req, "method", { get() {
 				return "TRACE";
 			} });
@@ -350,6 +303,9 @@ const requestPrototype = {
 		return false;
 	}
 };
+Object.defineProperty(requestPrototype, "signal", { get() {
+	return this[getAbortController]().signal;
+} });
 [
 	"cache",
 	"credentials",
@@ -359,7 +315,6 @@ const requestPrototype = {
 	"redirect",
 	"referrer",
 	"referrerPolicy",
-	"signal",
 	"keepalive"
 ].forEach((k) => {
 	Object.defineProperty(requestPrototype, k, { get() {
@@ -392,7 +347,18 @@ Object.defineProperty(requestPrototype, "json", { value: function() {
 	if (this[bodyConsumedDirectlyKey]) return rejectBodyUnusable();
 	return this.text().then(JSON.parse);
 } });
-Object.setPrototypeOf(requestPrototype, Request.prototype);
+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;
@@ -425,6 +391,7 @@ const newRequest = (incoming, defaultHostname) => {
 
 //#endregion
 //#region src/response.ts
+const defaultContentType = "text/plain; charset=UTF-8";
 const responseCache = Symbol("responseCache");
 const getResponseCache = Symbol("getResponseCache");
 const cacheKey = Symbol("cache");
@@ -450,16 +417,16 @@ var Response$1 = class Response$1 {
 				headers = new Headers(init.#init.headers);
 			}
 		} else this.#init = init;
-		if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) this[cacheKey] = [
+		if (body == null || typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) this[cacheKey] = [
 			init?.status || 200,
-			body,
+			body ?? null,
 			headers || init?.headers
 		];
 	}
 	get headers() {
 		const cache = this[cacheKey];
 		if (cache) {
-			if (!(cache[2] instanceof Headers)) cache[2] = new Headers(cache[2] || { "content-type": "text/plain; charset=UTF-8" });
+			if (!(cache[2] instanceof Headers)) cache[2] = new Headers(cache[2] || (cache[1] === null ? void 0 : { "content-type": defaultContentType }));
 			return cache[2];
 		}
 		return this[getResponseCache]().headers;
@@ -497,8 +464,62 @@ var Response$1 = class Response$1 {
 		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 = 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 src/utils.ts
@@ -537,7 +558,7 @@ function writeFromReadableStream(stream, writable) {
 	else if (writable.destroyed) return;
 	return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
 }
-const buildOutgoingHttpHeaders = (headers) => {
+const buildOutgoingHttpHeaders = (headers, defaultContentType) => {
 	const res = {};
 	if (!(headers instanceof Headers)) headers = new Headers(headers ?? void 0);
 	if (headers.has("set-cookie")) {
@@ -546,13 +567,63 @@ const buildOutgoingHttpHeaders = (headers) => {
 		else res[k] = v;
 		if (cookies.length > 0) res["set-cookie"] = cookies;
 	} else for (const [k, v] of headers) res[k] = v;
-	res["content-type"] ??= "text/plain; charset=UTF-8";
+	if (defaultContentType) res["content-type"] ??= defaultContentType;
 	return res;
 };
 
 //#endregion
 //#region src/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 node_http2.Http2ServerRequest) {
+		try {
+			incoming.stream?.close?.(node_http2.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) socket.destroySoon();
+	};
+	const timer = setTimeout(forceClose, DRAIN_TIMEOUT_MS);
+	timer.unref?.();
+	const onData = (chunk) => {
+		bytesRead += chunk.length;
+		if (bytesRead > MAX_DRAIN_BYTES) forceClose();
+	};
+	incoming.on("data", onData);
+	incoming.on("end", cleanup);
+	incoming.on("error", cleanup);
+	incoming.resume();
+};
+const makeCloseHandler = (req, incoming, outgoing, needsBodyCleanup) => () => {
+	if (incoming.errored) req[abortRequest](incoming.errored.toString());
+	else if (!outgoing.writableFinished) 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) => {
@@ -570,15 +641,44 @@ const flushHeaders = (outgoing) => {
 };
 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") {
+			outgoing.writeHead(status, {
+				"Content-Type": defaultContentType,
+				"Content-Length": Buffer.byteLength(body)
+			});
+			outgoing.end(body);
+		} else if (body instanceof Uint8Array) {
+			outgoing.writeHead(status, {
+				"Content-Type": defaultContentType,
+				"Content-Length": body.byteLength
+			});
+			outgoing.end(body);
+		} else if (body instanceof Blob) {
+			outgoing.writeHead(status, {
+				"Content-Type": defaultContentType,
+				"Content-Length": 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;
-	if (!header) header = { "content-type": "text/plain; charset=UTF-8" };
-	else if (header instanceof Headers) {
+	if (header instanceof Headers) {
 		hasContentLength = header.has("content-length");
-		header = buildOutgoingHttpHeaders(header);
+		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);
+		header = buildOutgoingHttpHeaders(headerObj, body === null ? void 0 : defaultContentType);
 	} else for (const key in header) if (key.length === 14 && key.toLowerCase() === "content-length") {
 		hasContentLength = true;
 		break;
@@ -589,7 +689,8 @@ const responseViaCache = async (res, outgoing) => {
 		else if (body instanceof Blob) header["Content-Length"] = body.size;
 	}
 	outgoing.writeHead(status, header);
-	if (typeof body === "string" || body instanceof Uint8Array) outgoing.end(body);
+	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);
@@ -608,7 +709,7 @@ const responseViaResponseObject = async (res, outgoing, options = {}) => {
 	}
 	else res = await res.catch(handleFetchError);
 	if (cacheKey in res) return responseViaCache(res, outgoing);
-	const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
+	const resHeaderRecord = buildOutgoingHttpHeaders(res.headers, res.body === null ? void 0 : defaultContentType);
 	if (res.body) {
 		const reader = res.body.getReader();
 		const values = [];
@@ -656,47 +757,47 @@ const responseViaResponseObject = async (res, outgoing, options = {}) => {
 };
 const getRequestListener = (fetchCallback, options = {}) => {
 	const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
-	if (options.overrideGlobalObjects !== false && global.Request !== Request) {
-		Object.defineProperty(global, "Request", { value: Request });
+	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);
-			let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
-			if (!incomingEnded) {
+			needsBodyCleanup = autoCleanupIncoming && !(incoming.method === "GET" || incoming.method === "HEAD");
+			if (needsBodyCleanup) {
 				incoming[wrapBodyStream] = true;
-				incoming.on("end", () => {
-					incomingEnded = true;
-				});
 				if (incoming instanceof node_http2.Http2ServerRequest) outgoing[outgoingEnded] = () => {
-					if (!incomingEnded) setTimeout(() => {
-						if (!incomingEnded) setTimeout(() => {
+					if (!incoming.readableEnded) setTimeout(() => {
+						if (!incoming.readableEnded) setTimeout(() => {
 							incoming.destroy();
 							outgoing.destroy();
 						});
 					});
 				};
 			}
-			outgoing.on("close", () => {
-				let abortReason;
-				if (incoming.errored) abortReason = incoming.errored.toString();
-				else if (!outgoing.writableFinished) abortReason = "Client connection prematurely closed.";
-				if (abortReason !== void 0) req[abortRequest](abortReason);
-				if (!incomingEnded) setTimeout(() => {
-					if (!incomingEnded) setTimeout(() => {
-						incoming.destroy();
-					});
-				});
-			});
 			res = fetchCallback(req, {
 				incoming,
 				outgoing
 			});
-			if (cacheKey in res) return responseViaCache(res, 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();
@@ -712,15 +813,194 @@ const getRequestListener = (fetchCallback, options = {}) => {
 };
 
 //#endregion
-Object.defineProperty(exports, 'RequestError', {
-  enumerable: true,
-  get: function () {
-    return RequestError;
-  }
+//#region src/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 ?? "";
+	}
+};
+const generateConnectionSymbol = () => Symbol("connection");
+const CONNECTION_SYMBOL_KEY = Symbol("CONNECTION_SYMBOL_KEY");
+const WAIT_FOR_WEBSOCKET_SYMBOL = Symbol("WAIT_FOR_WEBSOCKET_SYMBOL");
+const rejectUpgradeRequest = (socket, status) => {
+	socket.end(`HTTP/1.1 ${status.toString()} ${node_http.STATUS_CODES[status] ?? ""}\r\nConnection: close\r
+Content-Length: 0\r
+\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 waitForWebSocket = (request, connectionSymbol) => {
+		return new Promise((resolve) => {
+			waiterMap.set(request, {
+				resolve,
+				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;
+		try {
+			const response = await fetchCallback(createUpgradeRequest(request), env);
+			if (response instanceof Response) status = response.status;
+		} catch {
+			if (server.listenerCount("upgrade") === 1) rejectUpgradeRequest(socket, 500);
+			return;
+		}
+		const waiter = waiterMap.get(request);
+		if (!waiter || waiter.connectionSymbol !== env[CONNECTION_SYMBOL_KEY]) {
+			waiterMap.delete(request);
+			if (server.listenerCount("upgrade") === 1) rejectUpgradeRequest(socket, status);
+			return;
+		}
+		wss.handleUpgrade(request, socket, head, (ws) => {
+			wss.emit("connection", ws, request);
+		});
+	});
+	server.on("close", () => {
+		wss.close();
+	});
+};
+const upgradeWebSocket = (0, hono_ws.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 () => {
+		const ws = await waitForWebSocket(env.incoming, connectionSymbol);
+		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) : 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();
 });
-Object.defineProperty(exports, 'getRequestListener', {
-  enumerable: true,
-  get: function () {
-    return getRequestListener;
-  }
-});
+
+//#endregion
+//#region src/server.ts
+const createAdaptorServer = (options) => {
+	const fetchCallback = options.fetch;
+	const requestListener = getRequestListener(fetchCallback, {
+		hostname: options.hostname,
+		overrideGlobalObjects: options.overrideGlobalObjects,
+		autoCleanupIncoming: options.autoCleanupIncoming
+	});
+	const server = (options.createServer || node_http.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;
+};
+const serve = (options, listeningListener) => {
+	const server = createAdaptorServer(options);
+	server.listen(options?.port ?? 3e3, options.hostname, () => {
+		const serverInfo = server.address();
+		listeningListener && listeningListener(serverInfo);
+	});
+	return server;
+};
+
+//#endregion
+exports.RequestError = RequestError;
+exports.createAdaptorServer = createAdaptorServer;
+exports.getRequestListener = getRequestListener;
+exports.serve = serve;
+exports.upgradeWebSocket = upgradeWebSocket;