crossws 0.4.4 → 0.4.6

package/dist/adapters/node.mjs

@@ -1,125 +1,2 @@
-import "../_chunks/rolldown-runtime.mjs";
-import { i as AdapterHookable, r as getPeers, t as adapterUtils } from "../_chunks/adapter.mjs";
-import { n as import_websocket_server } from "../_chunks/libs/ws.mjs";
-import { n as Message, r as toBufferLike, t as Peer } from "../_chunks/peer.mjs";
-import { t as StubRequest } from "../_chunks/_request.mjs";
-import { t as WSError } from "../_chunks/error.mjs";
-
-//#region src/adapters/node.ts
-const nodeAdapter = (options = {}) => {
-	if ("Deno" in globalThis || "Bun" in globalThis) throw new Error("[crossws] Using Node.js adapter in an incompatible environment.");
-	const hooks = new AdapterHookable(options);
-	const globalPeers = /* @__PURE__ */ new Map();
-	const wss = options.wss || new import_websocket_server.default({
-		noServer: true,
-		handleProtocols: () => false,
-		...options.serverOptions
-	});
-	wss.on("connection", (ws, nodeReq) => {
-		const request = new NodeReqProxy(nodeReq);
-		const peers = getPeers(globalPeers, nodeReq._namespace);
-		const peer = new NodePeer({
-			ws,
-			request,
-			peers,
-			nodeReq,
-			namespace: nodeReq._namespace
-		});
-		peers.add(peer);
-		hooks.callHook("open", peer);
-		ws.on("message", (data) => {
-			if (Array.isArray(data)) data = Buffer.concat(data);
-			hooks.callHook("message", peer, new Message(data, peer));
-		});
-		ws.on("error", (error) => {
-			peers.delete(peer);
-			hooks.callHook("error", peer, new WSError(error));
-		});
-		ws.on("close", (code, reason) => {
-			peers.delete(peer);
-			hooks.callHook("close", peer, {
-				code,
-				reason: reason?.toString()
-			});
-		});
-	});
-	wss.on("headers", (outgoingHeaders, req) => {
-		const upgradeHeaders = req._upgradeHeaders;
-		if (upgradeHeaders) for (const [key, value] of new Headers(upgradeHeaders)) outgoingHeaders.push(`${key}: ${value}`);
-	});
-	return {
-		...adapterUtils(globalPeers),
-		handleUpgrade: async (nodeReq, socket, head, webRequest) => {
-			const request = webRequest || new NodeReqProxy(nodeReq);
-			const { upgradeHeaders, endResponse, context, namespace } = await hooks.upgrade(request);
-			if (endResponse) return sendResponse(socket, endResponse);
-			nodeReq._request = request;
-			nodeReq._upgradeHeaders = upgradeHeaders;
-			nodeReq._context = context;
-			nodeReq._namespace = namespace;
-			wss.handleUpgrade(nodeReq, socket, head, (ws) => {
-				wss.emit("connection", ws, nodeReq);
-			});
-		},
-		closeAll: (code, data, force) => {
-			for (const client of wss.clients) if (force) client.terminate();
-			else client.close(code, data);
-		}
-	};
-};
-var node_default = nodeAdapter;
-var NodePeer = class extends Peer {
-	get remoteAddress() {
-		return this._internal.nodeReq.socket?.remoteAddress;
-	}
-	get context() {
-		return this._internal.nodeReq._context;
-	}
-	send(data, options) {
-		const dataBuff = toBufferLike(data);
-		const isBinary = typeof dataBuff !== "string";
-		this._internal.ws.send(dataBuff, {
-			compress: options?.compress,
-			binary: isBinary,
-			...options
-		});
-		return 0;
-	}
-	publish(topic, data, options) {
-		const dataBuff = toBufferLike(data);
-		const isBinary = typeof data !== "string";
-		const sendOptions = {
-			compress: options?.compress,
-			binary: isBinary,
-			...options
-		};
-		for (const peer of this._internal.peers) if (peer !== this && peer._topics.has(topic)) peer._internal.ws.send(dataBuff, sendOptions);
-	}
-	close(code, data) {
-		this._internal.ws.close(code, data);
-	}
-	terminate() {
-		this._internal.ws.terminate();
-	}
-};
-var NodeReqProxy = class extends StubRequest {
-	constructor(req) {
-		const host = req.headers["host"] || "localhost";
-		const url = `${req.socket?.encrypted ?? req.headers["x-forwarded-proto"] === "https" ? "https" : "http"}://${host}${req.url}`;
-		super(url, { headers: req.headers });
-	}
-};
-async function sendResponse(socket, res) {
-	const head = [`HTTP/1.1 ${res.status || 200} ${res.statusText || ""}`, ...[...res.headers.entries()].map(([key, value]) => `${encodeURIComponent(key)}: ${encodeURIComponent(value)}`)];
-	socket.write(head.join("\r\n") + "\r\n\r\n");
-	if (res.body) for await (const chunk of res.body) socket.write(chunk);
-	return new Promise((resolve) => {
-		socket.end(() => {
-			socket.destroy();
-			resolve();
-		});
-	});
-}
-
-//#endregion
-export { node_default as default };
+import { fromNodeUpgradeHandler, nodeAdapter } from "../_chunks/node.mjs";
+export { nodeAdapter as default, fromNodeUpgradeHandler };

package/dist/adapters/sse.d.mts

@@ -1,2 +1,2 @@
-import { n as SSEOptions, r as sseAdapter, t as SSEAdapter } from "../_chunks/sse.mjs";
+import { SSEAdapter, SSEOptions, sseAdapter } from "../_chunks/sse.mjs";
 export { SSEAdapter, SSEOptions, sseAdapter as default };

package/dist/adapters/sse.mjs

@@ -1,7 +1,5 @@
-import { i as AdapterHookable, r as getPeers, t as adapterUtils } from "../_chunks/adapter.mjs";
-import { i as toString, n as Message, t as Peer } from "../_chunks/peer.mjs";
-
-//#region src/adapters/sse.ts
+import { AdapterHookable, adapterUtils, getPeers } from "../_chunks/adapter.mjs";
+import { Message, Peer, toString } from "../_chunks/peer.mjs";
 const sseAdapter = (opts = {}) => {
 	const hooks = new AdapterHookable(opts);
 	const globalPeers = /* @__PURE__ */ new Map();
@@ -55,7 +53,6 @@ const sseAdapter = (opts = {}) => {
 		}
 	};
 };
-var sse_default = sseAdapter;
 var SSEPeer = class extends Peer {
 	_sseStream;
 	_sseStreamController;
@@ -97,6 +94,4 @@ var SSEPeer = class extends Peer {
 var SSEWebSocketStub = class {
 	readyState;
 };
-
-//#endregion
-export { sse_default as default };
+export { sseAdapter as default };

package/dist/adapters/uws.d.mts

@@ -1,13 +1,9 @@
-import { d as PeerContext, n as AdapterInstance, r as AdapterOptions, t as Adapter, u as Peer } from "../_chunks/adapter.mjs";
-import { a as WebSocket } from "../_chunks/web.mjs";
+import { Adapter, AdapterInstance, AdapterOptions, Peer, PeerContext } from "../_chunks/adapter.mjs";
+import { WebSocket } from "../_chunks/web.mjs";
 import uws from "uWebSockets.js";
-
-//#region src/_request.d.ts
 declare const StubRequest: {
   new (url: string, init?: RequestInit): Request;
 };
-//#endregion
-//#region src/adapters/uws.d.ts
 type UserData = {
   peer?: UWSPeer;
   req: uws.HttpRequest;
@@ -58,5 +54,4 @@ declare class UwsWebSocketProxy implements Partial<WebSocket> {
   get protocol(): string;
   get extensions(): string;
 }
-//#endregion
 export { UWSAdapter, UWSOptions, uwsAdapter as default };

package/dist/adapters/uws.mjs

@@ -1,8 +1,6 @@
-import { i as AdapterHookable, r as getPeers, t as adapterUtils } from "../_chunks/adapter.mjs";
-import { n as Message, r as toBufferLike, t as Peer } from "../_chunks/peer.mjs";
-import { t as StubRequest } from "../_chunks/_request.mjs";
-
-//#region src/adapters/uws.ts
+import { AdapterHookable, adapterUtils, getPeers } from "../_chunks/adapter.mjs";
+import { Message, Peer, toBufferLike } from "../_chunks/peer.mjs";
+import { StubRequest } from "../_chunks/_request.mjs";
 const uwsAdapter = (options = {}) => {
 	const hooks = new AdapterHookable(options);
 	const globalPeers = /* @__PURE__ */ new Map();
@@ -21,7 +19,7 @@ const uwsAdapter = (options = {}) => {
 				});
 				peer._internal.ws.readyState = 3;
 			},
-			message(ws, message, isBinary) {
+			message(ws, message, _isBinary) {
 				const peer = getPeer(ws, getPeers(globalPeers, ws.getUserData().namespace));
 				hooks.callHook("message", peer, new Message(message, peer));
 			},
@@ -72,7 +70,6 @@ const uwsAdapter = (options = {}) => {
 		}
 	};
 };
-var uws_default = uwsAdapter;
 function getPeer(uws, peers) {
 	const uwsData = uws.getUserData();
 	if (uwsData.peer) return uwsData.peer;
@@ -139,6 +136,7 @@ var UWSReqProxy = class extends StubRequest {
 	}
 };
 var UwsWebSocketProxy = class {
+	_uws;
 	readyState = 1;
 	constructor(_uws) {
 		this._uws = _uws;
@@ -153,6 +151,4 @@ var UwsWebSocketProxy = class {
 		return this._uws?.getUserData().extensions;
 	}
 };
-
-//#endregion
-export { uws_default as default };
+export { uwsAdapter as default };

package/dist/adapters/vercel.d.mts

@@ -0,0 +1,25 @@
+import { Adapter } from "../_chunks/adapter.mjs";
+import { NodeAdapter, NodeOptions } from "../_chunks/node.mjs";
+import { IncomingMessage, ServerResponse } from "node:http";
+interface VercelAdapter extends Omit<NodeAdapter, "handleUpgrade"> {
+  /**
+   * Handle a WebSocket upgrade from a Web `Request` (fetch-style handlers).
+   *
+   * Returns a `204` {@link Response} when the upgrade was handled, or
+   * `undefined` when the request is not a WebSocket upgrade or Vercel's upgrade
+   * context is unavailable.
+   */
+  handleWebUpgrade(request: Request): Promise<Response | undefined>;
+  /**
+   * Handle a WebSocket upgrade from a Node.js `IncomingMessage` (Node-style
+   * handlers).
+   *
+   * Returns `true` when the upgrade was handled (and ends `res` with `204`), or
+   * `false` when the request is not a WebSocket upgrade or Vercel's upgrade
+   * context is unavailable.
+   */
+  handleNodeUpgrade(req: IncomingMessage, res: ServerResponse): Promise<boolean>;
+}
+interface VercelOptions extends NodeOptions {}
+declare const vercelAdapter: Adapter<VercelAdapter, VercelOptions>;
+export { VercelAdapter, VercelOptions, vercelAdapter as default };

package/dist/adapters/vercel.mjs

@@ -0,0 +1,48 @@
+import { nodeAdapter } from "../_chunks/node.mjs";
+import { NodeRequest } from "srvx/node";
+const VERCEL_REQUEST_CONTEXT_SYMBOL = Symbol.for("@vercel/request-context");
+const vercelAdapter = (options = {}) => {
+	const wss = nodeAdapter(options);
+	async function handleWebUpgrade(request) {
+		if (!_isWsUpgrade(request.method, request.headers.get("upgrade") || void 0)) return;
+		const upgrade = _getVercelUpgrade();
+		if (!upgrade) return;
+		await wss.handleUpgrade(upgrade.req, upgrade.socket, upgrade.head, request);
+		return new Response(null, { status: 204 });
+	}
+	async function handleNodeUpgrade(req, res) {
+		if (!_isWsUpgrade(req.method, req.headers.upgrade)) return false;
+		const upgrade = _getVercelUpgrade();
+		if (!upgrade) return false;
+		await wss.handleUpgrade(upgrade.req, upgrade.socket, upgrade.head, new NodeRequest({
+			req,
+			res
+		}));
+		if (!res.headersSent && !res.writableEnded) {
+			res.statusCode = 204;
+			res.end();
+		}
+		return true;
+	}
+	const { handleUpgrade: _, ...rest } = wss;
+	return {
+		...rest,
+		handleWebUpgrade,
+		handleNodeUpgrade
+	};
+};
+function _isWsUpgrade(method, upgradeHeader) {
+	return method === "GET" && upgradeHeader?.toLowerCase?.() === "websocket";
+}
+function _getVercelUpgrade() {
+	const upgrade = _getVercelRequestContext()?.upgradeWebSocket?.();
+	return upgrade?.req && upgrade?.socket && upgrade?.head ? upgrade : void 0;
+}
+function _getVercelRequestContext() {
+	const store = globalThis[VERCEL_REQUEST_CONTEXT_SYMBOL];
+	if (typeof store?.get !== "function") return;
+	const context = store.get();
+	if (!context || typeof context !== "object") return;
+	return context;
+}
+export { vercelAdapter as default };

package/dist/index.d.mts

@@ -1,2 +1,97 @@
-import { a as Hooks, c as Message, d as PeerContext, f as WSError, i as defineWebSocketAdapter, l as AdapterInternal, n as AdapterInstance, o as ResolveHooks, r as AdapterOptions, s as defineHooks, t as Adapter, u as Peer } from "./_chunks/adapter.mjs";
-export { type Adapter, type AdapterInstance, type AdapterInternal, type AdapterOptions, type Hooks, type Message, type Peer, type PeerContext, type ResolveHooks, type WSError, defineHooks, defineWebSocketAdapter };
+import { Adapter, AdapterInstance, AdapterInternal, AdapterOptions, Hooks, Message, Peer, PeerContext, ResolveHooks, WSError, defineHooks, defineWebSocketAdapter } from "./_chunks/adapter.mjs";
+import { ServerWithWSOptions, WSOptions } from "./_chunks/_types.mjs";
+interface WebSocketProxyOptions {
+  /**
+   * Target WebSocket URL to proxy to (`ws://` or `wss://`).
+   *
+   * Can be a static string/URL or a function that resolves the target dynamically
+   * based on the incoming {@link Peer}.
+   */
+  target: string | URL | ((peer: Peer) => string | URL);
+  /**
+   * Subprotocol(s) to offer the upstream during the handshake.
+   *
+   * - `true` (default) — forward the client's `sec-websocket-protocol` verbatim.
+   * - `false` — offer no subprotocol upstream.
+   * - `string` / `string[]` — offer a fixed subprotocol (or list) upstream,
+   *   regardless of what the client requested.
+   * - `Record<string, string>` — rewrite map applied to the client's offered
+   *   tokens: a token that matches a key is swapped for its value; tokens not
+   *   in the map are forwarded verbatim.
+   * - function — resolve the upstream subprotocol(s) per {@link Peer}. Return a
+   *   string, an array of strings, or `undefined` to offer none. Useful when the
+   *   rewrite depends on more than the token value alone.
+   *
+   * Note: this controls only what is offered to the *upstream*. The subprotocol
+   * echoed back to the *client* remains the first token the client offered (per
+   * RFC 6455, the selected protocol must be one the client proposed).
+   *
+   * @default true
+   */
+  forwardProtocol?: boolean | string | string[] | Record<string, string> | ((peer: Peer) => string | string[] | undefined | void);
+  /**
+   * Maximum number of bytes buffered per peer while the upstream connection
+   * is still opening. If exceeded, the peer is closed with code `1009`
+   * (Message Too Big). Set to `0` to disable the limit.
+   *
+   * @default 1048576 (1 MiB)
+   */
+  maxBufferSize?: number;
+  /**
+   * Milliseconds to wait for the upstream WebSocket handshake to complete.
+   * If the upstream does not open within the timeout, the peer is closed
+   * with code `1011`. Set to `0` to disable the timeout.
+   *
+   * @default 10000
+   */
+  connectTimeout?: number;
+  /**
+   * Custom `WebSocket` constructor used to dial the upstream. Useful when
+   * the runtime does not expose a global `WebSocket` (Node.js < 22) or
+   * when you want to use a different client implementation (e.g. `ws`,
+   * `undici`, a mock for tests).
+   *
+   * @default globalThis.WebSocket
+   */
+  WebSocket?: typeof WebSocket;
+  /**
+   * Extra headers to send on the upstream handshake. Can be a static
+   * object or a resolver called per peer.
+   *
+   * Useful to forward identity from the incoming request (`cookie`,
+   * `authorization`, `origin`), or to inject a shared secret the
+   * upstream expects.
+   *
+   * > [!NOTE]
+   * > The WHATWG global `WebSocket` constructor does not accept custom
+   * > headers — this option is only honored by `WebSocket` constructors
+   * > that take a third options argument (e.g. `ws`, `undici`). Pass
+   * > one via the {@link WebSocket} option to use it.
+   *
+   * @example
+   * ```ts
+   * createWebSocketProxy({
+   *   target: "wss://backend.example.com",
+   *   WebSocket: WsFromNodeWs,
+   *   headers: (peer) => ({
+   *     cookie: peer.request.headers.get("cookie") ?? "",
+   *     "x-forwarded-for": peer.remoteAddress ?? "",
+   *   }),
+   * });
+   * ```
+   */
+  headers?: HeadersInit | ((peer: Peer) => HeadersInit | undefined | void);
+}
+/**
+ * Create a set of crossws hooks that proxy incoming WebSocket connections
+ * to an upstream `ws://` or `wss://` target.
+ *
+ * @example
+ * ```ts
+ * import { createWebSocketProxy } from "crossws";
+ *
+ * const hooks = createWebSocketProxy("wss://echo.websocket.org");
+ * ```
+ */
+declare function createWebSocketProxy(target: WebSocketProxyOptions["target"] | WebSocketProxyOptions): Partial<Hooks>;
+export { type Adapter, type AdapterInstance, type AdapterInternal, type AdapterOptions, type Hooks, type Message, type Peer, type PeerContext, type ResolveHooks, type ServerWithWSOptions, type WSError, type WSOptions, type WebSocketProxyOptions, createWebSocketProxy, defineHooks, defineWebSocketAdapter };

package/dist/index.mjs

@@ -1,3 +1,178 @@
-import { a as defineHooks, n as defineWebSocketAdapter } from "./_chunks/adapter.mjs";
-
-export { defineHooks, defineWebSocketAdapter };
+import { defineHooks, defineWebSocketAdapter } from "./_chunks/adapter.mjs";
+const DEFAULT_MAX_BUFFER_SIZE = 1024 * 1024;
+const DEFAULT_CONNECT_TIMEOUT = 1e4;
+const TOKEN_RE = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+function createWebSocketProxy(target) {
+	const options = typeof target === "string" || target instanceof URL || typeof target === "function" ? { target } : target;
+	const WebSocketCtor = options.WebSocket ?? globalThis.WebSocket;
+	if (typeof WebSocketCtor !== "function") throw new TypeError("createWebSocketProxy requires a `WebSocket` constructor. Pass one via the `WebSocket` option, or use a runtime that provides a global `WebSocket` (Node.js >= 22, Bun, Deno, Cloudflare Workers, browsers).");
+	const upstreams = /* @__PURE__ */ new Map();
+	return {
+		upgrade(request) {
+			const reqProtocol = request.headers.get("sec-websocket-protocol");
+			if (options.forwardProtocol === false || !reqProtocol) return;
+			const accepted = _splitProtocolHeader(reqProtocol)[0];
+			if (!accepted || !TOKEN_RE.test(accepted)) return;
+			return { headers: { "sec-websocket-protocol": accepted } };
+		},
+		open(peer) {
+			let ws;
+			try {
+				const url = _resolveTarget(options.target, peer);
+				const protocols = _resolveProtocols(peer, options.forwardProtocol);
+				const wsOptions = _resolveWsOptions(options.headers, peer);
+				ws = wsOptions ? new WebSocketCtor(url, protocols, wsOptions) : new WebSocketCtor(url, protocols);
+				ws.binaryType = "arraybuffer";
+			} catch {
+				_safeClose(peer, 1011, "Upstream setup failed");
+				return;
+			}
+			const state = {
+				ws,
+				buffer: [],
+				bufferSize: 0,
+				open: false,
+				timeout: void 0
+			};
+			upstreams.set(peer.id, state);
+			const timeoutMs = options.connectTimeout ?? DEFAULT_CONNECT_TIMEOUT;
+			if (timeoutMs > 0) state.timeout = setTimeout(() => {
+				if (upstreams.get(peer.id) !== state || state.open) return;
+				_cleanupState(upstreams, peer.id, state);
+				_safeClose(peer, 1011, "Upstream connect timeout");
+			}, timeoutMs);
+			ws.addEventListener("open", () => {
+				_clearTimeout(state);
+				state.open = true;
+				for (const data of state.buffer) ws.send(data);
+				state.buffer.length = 0;
+				state.bufferSize = 0;
+			});
+			ws.addEventListener("message", (event) => {
+				_safeSend(peer, event.data);
+			});
+			ws.addEventListener("close", (event) => {
+				if (upstreams.get(peer.id) !== state) return;
+				_cleanupState(upstreams, peer.id, state);
+				_safeClose(peer, _remapIncomingCode(event.code), event.reason);
+			});
+			ws.addEventListener("error", () => {
+				if (upstreams.get(peer.id) !== state) return;
+				_cleanupState(upstreams, peer.id, state);
+				_safeClose(peer, 1011, "Upstream error");
+			});
+		},
+		message(peer, message) {
+			const state = upstreams.get(peer.id);
+			if (!state) return;
+			const raw = typeof message.rawData === "string" ? message.rawData : message.uint8Array();
+			if (state.open) {
+				try {
+					state.ws.send(raw);
+				} catch {}
+				return;
+			}
+			const size = typeof raw === "string" ? raw.length * 3 : raw.byteLength;
+			const limit = options.maxBufferSize ?? DEFAULT_MAX_BUFFER_SIZE;
+			if (limit > 0 && state.bufferSize + size > limit) {
+				_cleanupState(upstreams, peer.id, state);
+				_safeClose(peer, 1009, "Proxy buffer limit exceeded");
+				return;
+			}
+			state.buffer.push(typeof raw === "string" ? raw : Uint8Array.from(raw));
+			state.bufferSize += size;
+		},
+		close(peer, details) {
+			const state = upstreams.get(peer.id);
+			if (!state) return;
+			_clearTimeout(state);
+			upstreams.delete(peer.id);
+			try {
+				state.ws.close(_normalizeOutgoingCode(details.code), _truncateReason(details.reason));
+			} catch {}
+		},
+		error(peer) {
+			const state = upstreams.get(peer.id);
+			if (!state) return;
+			_clearTimeout(state);
+			upstreams.delete(peer.id);
+			try {
+				state.ws.close(1011, "Peer error");
+			} catch {}
+		}
+	};
+}
+function _cleanupState(upstreams, id, state) {
+	_clearTimeout(state);
+	upstreams.delete(id);
+	try {
+		state.ws.close();
+	} catch {}
+}
+function _clearTimeout(state) {
+	if (state.timeout !== void 0) {
+		clearTimeout(state.timeout);
+		state.timeout = void 0;
+	}
+}
+function _resolveTarget(target, peer) {
+	const raw = typeof target === "function" ? target(peer) : target;
+	return raw instanceof URL ? raw : new URL(raw);
+}
+function _resolveWsOptions(headers, peer) {
+	if (!headers) return;
+	const resolved = typeof headers === "function" ? headers(peer) : headers;
+	if (!resolved) return;
+	return { headers: resolved };
+}
+function _resolveProtocols(peer, forwardProtocol) {
+	if (forwardProtocol === false) return;
+	if (typeof forwardProtocol === "function") return _normalizeProtocols(forwardProtocol(peer));
+	if (typeof forwardProtocol === "string" || Array.isArray(forwardProtocol)) return _normalizeProtocols(forwardProtocol);
+	const header = peer.request?.headers.get("sec-websocket-protocol");
+	if (!header) return;
+	const offered = _splitProtocolHeader(header);
+	if (forwardProtocol && typeof forwardProtocol === "object") {
+		const map = forwardProtocol;
+		return _normalizeProtocols(offered.map((p) => Object.prototype.hasOwnProperty.call(map, p) ? map[p] : p));
+	}
+	return _normalizeProtocols(offered);
+}
+function _splitProtocolHeader(header) {
+	return header.split(",").map((p) => p.trim()).filter(Boolean);
+}
+function _normalizeProtocols(value) {
+	if (value == null) return;
+	const list = (Array.isArray(value) ? value : [value]).filter((p) => p != null).map((p) => String(p).trim()).filter(Boolean);
+	const deduped = [...new Set(list)];
+	return deduped.length > 0 ? deduped : void 0;
+}
+function _safeClose(peer, code, reason) {
+	try {
+		peer.close(code, _truncateReason(reason));
+	} catch {}
+}
+function _safeSend(peer, data) {
+	try {
+		peer.send(data);
+	} catch {}
+}
+function _truncateReason(reason) {
+	if (!reason) return reason;
+	const bytes = new TextEncoder().encode(reason);
+	if (bytes.length <= 123) return reason;
+	return new TextDecoder("utf-8", { fatal: false }).decode(bytes.subarray(0, 123));
+}
+function _remapIncomingCode(code) {
+	if (code === void 0) return void 0;
+	if (code === 1005) return 1e3;
+	if (code === 1006 || code === 1015) return 1011;
+	return code;
+}
+function _normalizeOutgoingCode(code) {
+	if (code === void 0) return void 0;
+	if (code === 1e3) return 1e3;
+	if (code >= 3e3 && code <= 4999) return code;
+	return 1e3;
+}
+export { createWebSocketProxy, defineHooks, defineWebSocketAdapter };

package/dist/server/bun.d.mts

@@ -1,11 +1,5 @@
-import "../_chunks/bun.mjs";
-import "../_chunks/cloudflare.mjs";
-import "../_chunks/node.mjs";
-import { n as WSOptions, t as ServerWithWSOptions } from "../_chunks/_types.mjs";
+import { ServerWithWSOptions, WSOptions } from "../_chunks/_types.mjs";
 import { Server, ServerPlugin } from "srvx";
-
-//#region src/server/bun.d.ts
 declare function plugin(wsOpts: WSOptions): ServerPlugin;
 declare function serve(options: ServerWithWSOptions): Server;
-//#endregion
 export { plugin, serve };

package/dist/server/bun.mjs

@@ -1,10 +1,8 @@
-import bun_default from "../adapters/bun.mjs";
+import bunAdapter from "../adapters/bun.mjs";
 import { serve as serve$1 } from "srvx/bun";
-
-//#region src/server/bun.ts
 function plugin(wsOpts) {
 	return (server) => {
-		const ws = bun_default({
+		const ws = bunAdapter({
 			hooks: wsOpts,
 			resolve: wsOpts.resolve,
 			...wsOpts.options?.bun
@@ -25,6 +23,4 @@ function serve(options) {
 	}
 	return serve$1(options);
 }
-
-//#endregion
-export { plugin, serve };
+export { plugin, serve };

package/dist/server/bunny.d.mts

@@ -0,0 +1,5 @@
+import { ServerWithWSOptions, WSOptions } from "../_chunks/_types.mjs";
+import { Server, ServerPlugin } from "srvx";
+declare function plugin(wsOpts: WSOptions): ServerPlugin;
+declare function serve(options: ServerWithWSOptions): Server;
+export { plugin, serve };

package/dist/server/bunny.mjs

@@ -0,0 +1,23 @@
+import bunnyAdapter from "../adapters/bunny.mjs";
+import { serve as serve$1 } from "srvx/bunny";
+function plugin(wsOpts) {
+	return (server) => {
+		const ws = bunnyAdapter({
+			hooks: wsOpts,
+			resolve: wsOpts.resolve,
+			...wsOpts.options?.bunny
+		});
+		server.options.middleware.unshift((req, next) => {
+			if (req.headers.get("upgrade")?.toLowerCase() === "websocket") return ws.handleUpgrade(req);
+			return next();
+		});
+	};
+}
+function serve(options) {
+	if (options.websocket) {
+		options.plugins ||= [];
+		options.plugins.push(plugin(options.websocket));
+	}
+	return serve$1(options);
+}
+export { plugin, serve };

package/dist/server/cloudflare.d.mts

@@ -1,11 +1,5 @@
-import "../_chunks/bun.mjs";
-import "../_chunks/cloudflare.mjs";
-import "../_chunks/node.mjs";
-import { n as WSOptions, t as ServerWithWSOptions } from "../_chunks/_types.mjs";
+import { ServerWithWSOptions, WSOptions } from "../_chunks/_types.mjs";
 import { Server, ServerPlugin } from "srvx";
-
-//#region src/server/cloudflare.d.ts
 declare function plugin(wsOpts: WSOptions): ServerPlugin;
 declare function serve(options: ServerWithWSOptions): Server;
-//#endregion
 export { plugin, serve };