crossws 0.4.5 → 0.4.7

package/dist/adapters/deno.mjs

@@ -1,13 +1,16 @@
-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 WSError } from "../_chunks/error.mjs";
+import { AdapterHookable, adapterUtils, getPeers, toBufferLike } from "../_chunks/adapter.mjs";
+import { Message, Peer } from "../_chunks/peer.mjs";
+import { WSError } from "../_chunks/error.mjs";
 const denoAdapter = (options = {}) => {
 	if (typeof Deno === "undefined") throw new Error("[crossws] Using Deno adapter in an incompatible environment.");
 	const hooks = new AdapterHookable(options);
 	const globalPeers = /* @__PURE__ */ new Map();
+	const baseUtils = adapterUtils(globalPeers, options);
 	return {
-		...adapterUtils(globalPeers),
+		...baseUtils,
 		handleUpgrade: async (request, info) => {
+			const remoteAddress = info.remoteAddr?.hostname;
+			const requestSnapshot = snapshotRequest(request);
 			const { upgradeHeaders, endResponse, context, namespace } = await hooks.upgrade(request);
 			if (endResponse) return endResponse;
 			const headers = upgradeHeaders instanceof Headers ? upgradeHeaders : new Headers(upgradeHeaders);
@@ -18,11 +21,12 @@ const denoAdapter = (options = {}) => {
 			const peers = getPeers(globalPeers, namespace);
 			const peer = new DenoPeer({
 				ws: upgrade.socket,
-				request,
+				request: requestSnapshot,
 				peers,
-				denoInfo: info,
+				remoteAddress,
 				context,
-				namespace
+				namespace,
+				sync: baseUtils.sync
 			});
 			peers.add(peer);
 			upgrade.socket.addEventListener("open", () => {
@@ -43,14 +47,23 @@ const denoAdapter = (options = {}) => {
 		}
 	};
 };
+function snapshotRequest(request) {
+	const url = request.url;
+	const headers = new Headers(request.headers);
+	return new Proxy(request, { get(target, prop, receiver) {
+		if (prop === "url") return url;
+		if (prop === "headers") return headers;
+		return Reflect.get(target, prop, receiver);
+	} });
+}
 var DenoPeer = class extends Peer {
 	get remoteAddress() {
-		return this._internal.denoInfo.remoteAddr?.hostname;
+		return this._internal.remoteAddress;
 	}
 	send(data) {
 		return this._internal.ws.send(toBufferLike(data));
 	}
-	publish(topic, data) {
+	_publish(topic, data) {
 		const dataBuff = toBufferLike(data);
 		for (const peer of this._internal.peers) if (peer !== this && peer._topics.has(topic)) peer._internal.ws.send(dataBuff);
 	}

package/dist/adapters/node.d.mts

@@ -1,2 +1,2 @@
-import { a as fromNodeUpgradeHandler, i as NodeUpgradeHandler, n as NodeOptions, r as nodeAdapter, t as NodeAdapter } from "../_chunks/node.mjs";
-export { NodeAdapter, NodeOptions, NodeUpgradeHandler, nodeAdapter as default, fromNodeUpgradeHandler };
+import { NodeAdapter, NodeOptions, NodeUpgradeHandler, fromNodeUpgradeHandler, nodeAdapter } from "../_chunks/node.mjs";
+export { NodeAdapter, NodeOptions, type NodeUpgradeHandler, nodeAdapter as default, fromNodeUpgradeHandler };

package/dist/adapters/node.mjs

@@ -1,2 +1,2 @@
-import { n as fromNodeUpgradeHandler, t as nodeAdapter } from "../_chunks/node.mjs";
+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,11 +1,12 @@
-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";
+import { AdapterHookable, adapterUtils, getPeers, toString } from "../_chunks/adapter.mjs";
+import { Message, Peer } from "../_chunks/peer.mjs";
 const sseAdapter = (opts = {}) => {
 	const hooks = new AdapterHookable(opts);
 	const globalPeers = /* @__PURE__ */ new Map();
 	const peersMap = opts.bidir ? /* @__PURE__ */ new Map() : void 0;
+	const baseUtils = adapterUtils(globalPeers, opts);
 	return {
-		...adapterUtils(globalPeers),
+		...baseUtils,
 		fetch: async (request) => {
 			const { upgradeHeaders, endResponse, context, namespace } = await hooks.upgrade(request);
 			if (endResponse) return endResponse;
@@ -31,7 +32,8 @@ const sseAdapter = (opts = {}) => {
 					hooks,
 					ws,
 					context,
-					namespace
+					namespace,
+					sync: baseUtils.sync
 				});
 				peers.add(peer);
 				if (opts.bidir) {
@@ -83,7 +85,7 @@ var SSEPeer = class extends Peer {
 		this._sendEvent("message", toString(data));
 		return 0;
 	}
-	publish(topic, data) {
+	_publish(topic, data) {
 		const dataBuff = toString(data);
 		for (const peer of this._internal.peers) if (peer !== this && peer._topics.has(topic)) peer._sendEvent("message", dataBuff);
 	}

package/dist/adapters/uws.d.mts

@@ -1,5 +1,5 @@
-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, SyncDriver } from "../_chunks/adapter.mjs";
+import { WebSocket } from "../_chunks/web.mjs";
 import uws from "uWebSockets.js";
 declare const StubRequest: {
   new (url: string, init?: RequestInit): Request;
@@ -29,6 +29,7 @@ declare class UWSPeer extends Peer<{
   uws: uws.WebSocket<UserData>;
   ws: UwsWebSocketProxy;
   uwsData: UserData;
+  sync?: SyncDriver;
 }> {
   get remoteAddress(): string | undefined;
   get context(): PeerContext;
@@ -37,7 +38,7 @@ declare class UWSPeer extends Peer<{
   }): number;
   subscribe(topic: string): void;
   unsubscribe(topic: string): void;
-  publish(topic: string, message: string, options?: {
+  _publish(topic: string, message: string, options?: {
     compress?: boolean;
   }): number;
   close(code?: number, reason?: uws.RecognizedString): void;
@@ -47,8 +48,8 @@ declare class UWSReqProxy extends StubRequest {
   constructor(req: uws.HttpRequest);
 }
 declare class UwsWebSocketProxy implements Partial<WebSocket> {
-  private _uws;
   readyState?: number;
+  private _uws;
   constructor(_uws: uws.WebSocket<UserData>);
   get bufferedAmount(): number;
   get protocol(): string;

package/dist/adapters/uws.mjs

@@ -1,16 +1,17 @@
-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";
+import { AdapterHookable, adapterUtils, getPeers, toBufferLike } from "../_chunks/adapter.mjs";
+import { Message, Peer } from "../_chunks/peer.mjs";
+import { StubRequest } from "../_chunks/_request.mjs";
 const uwsAdapter = (options = {}) => {
 	const hooks = new AdapterHookable(options);
 	const globalPeers = /* @__PURE__ */ new Map();
+	const baseUtils = adapterUtils(globalPeers, options, { nativePubSub: true });
 	return {
-		...adapterUtils(globalPeers),
+		...baseUtils,
 		websocket: {
 			...options.uws,
 			close(ws, code, message) {
 				const peers = getPeers(globalPeers, ws.getUserData().namespace);
-				const peer = getPeer(ws, peers);
+				const peer = getPeer(ws, peers, baseUtils.sync);
 				peer._internal.ws.readyState = 2;
 				peers.delete(peer);
 				hooks.callHook("close", peer, {
@@ -20,12 +21,16 @@ const uwsAdapter = (options = {}) => {
 				peer._internal.ws.readyState = 3;
 			},
 			message(ws, message, _isBinary) {
-				const peer = getPeer(ws, getPeers(globalPeers, ws.getUserData().namespace));
+				const peer = getPeer(ws, getPeers(globalPeers, ws.getUserData().namespace), baseUtils.sync);
 				hooks.callHook("message", peer, new Message(message, peer));
 			},
+			drain(ws) {
+				const peer = getPeer(ws, getPeers(globalPeers, ws.getUserData().namespace));
+				hooks.callHook("drain", peer);
+			},
 			open(ws) {
 				const peers = getPeers(globalPeers, ws.getUserData().namespace);
-				const peer = getPeer(ws, peers);
+				const peer = getPeer(ws, peers, baseUtils.sync);
 				peers.add(peer);
 				hooks.callHook("open", peer);
 			},
@@ -70,7 +75,7 @@ const uwsAdapter = (options = {}) => {
 		}
 	};
 };
-function getPeer(uws, peers) {
+function getPeer(uws, peers, sync) {
 	const uwsData = uws.getUserData();
 	if (uwsData.peer) return uwsData.peer;
 	const peer = new UWSPeer({
@@ -79,7 +84,8 @@ function getPeer(uws, peers) {
 		ws: new UwsWebSocketProxy(uws),
 		request: uwsData.webReq,
 		namespace: uwsData.namespace,
-		uwsData
+		uwsData,
+		sync
 	});
 	uwsData.peer = peer;
 	return peer;
@@ -106,7 +112,7 @@ var UWSPeer = class extends Peer {
 		this._topics.delete(topic);
 		this._internal.uws.unsubscribe(topic);
 	}
-	publish(topic, message, options) {
+	_publish(topic, message, options) {
 		const data = toBufferLike(message);
 		const isBinary = typeof data !== "string";
 		this._internal.uws.publish(topic, data, isBinary, options?.compress);
@@ -137,6 +143,7 @@ var UWSReqProxy = class extends StubRequest {
 };
 var UwsWebSocketProxy = class {
 	readyState = 1;
+	_uws;
 	constructor(_uws) {
 		this._uws = _uws;
 	}

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,19 +1,42 @@
-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";
-import { n as WSOptions, t as ServerWithWSOptions } from "./_chunks/_types.mjs";
+import { Adapter, AdapterInstance, AdapterInternal, AdapterOptions, Hooks, Message, Peer, PeerContext, ResolveHooks, SyncAdapter, SyncDriver, SyncErrorContext, SyncMessage, WSError, WaitForDrainOptions, 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}.
+   * based on the incoming {@link Peer}. The resolver may be **async** (return a
+   * promise) — useful when the upstream address isn't known yet at connect time
+   * (e.g. a worker that's still booting or being hot-reloaded). Client frames
+   * sent in the meantime are buffered (bounded by {@link maxBufferSize}) and a
+   * non-zero {@link connectTimeout} also covers the resolution, so a resolver
+   * that never settles closes the peer with `1011` rather than hanging. With
+   * `connectTimeout: 0` (timeout disabled) a never-settling resolver leaves the
+   * peer open until {@link maxBufferSize} is hit (`1009`), so pair an unbounded
+   * timeout with your own resolver deadline.
    */
-  target: string | URL | ((peer: Peer) => string | URL);
+  target: string | URL | ((peer: Peer) => string | URL | Promise<string | URL>);
   /**
-   * Forward the client's `sec-websocket-protocol` header to the upstream.
+   * 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;
+  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`
@@ -79,4 +102,4 @@ interface WebSocketProxyOptions {
  * ```
  */
 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 };
+export { type Adapter, type AdapterInstance, type AdapterInternal, type AdapterOptions, type Hooks, type Message, type Peer, type PeerContext, type ResolveHooks, type ServerWithWSOptions, type SyncAdapter, type SyncDriver, type SyncErrorContext, type SyncMessage, type WSError, type WSOptions, type WaitForDrainOptions, type WebSocketProxyOptions, createWebSocketProxy, defineHooks, defineWebSocketAdapter };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { a as defineHooks, n as defineWebSocketAdapter } from "./_chunks/adapter.mjs";
+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]+$/;
@@ -11,24 +11,13 @@ function createWebSocketProxy(target) {
 		upgrade(request) {
 			const reqProtocol = request.headers.get("sec-websocket-protocol");
 			if (options.forwardProtocol === false || !reqProtocol) return;
-			const accepted = reqProtocol.split(",")[0].trim();
-			if (!TOKEN_RE.test(accepted)) 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,
+				ws: void 0,
 				buffer: [],
 				bufferSize: 0,
 				open: false,
@@ -41,26 +30,20 @@ function createWebSocketProxy(target) {
 				_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;
+			let resolved;
+			try {
+				resolved = _resolveTarget(options.target, peer);
+			} catch {
 				_cleanupState(upstreams, peer.id, state);
-				_safeClose(peer, _remapIncomingCode(event.code), event.reason);
-			});
-			ws.addEventListener("error", () => {
+				_safeClose(peer, 1011, "Upstream setup failed");
+				return;
+			}
+			if (resolved instanceof Promise) resolved.then((url) => _dialUpstream(upstreams, peer, state, url, options, WebSocketCtor), () => {
 				if (upstreams.get(peer.id) !== state) return;
 				_cleanupState(upstreams, peer.id, state);
-				_safeClose(peer, 1011, "Upstream error");
+				_safeClose(peer, 1011, "Upstream setup failed");
 			});
+			else _dialUpstream(upstreams, peer, state, resolved, options, WebSocketCtor);
 		},
 		message(peer, message) {
 			const state = upstreams.get(peer.id);
@@ -68,7 +51,7 @@ function createWebSocketProxy(target) {
 			const raw = typeof message.rawData === "string" ? message.rawData : message.uint8Array();
 			if (state.open) {
 				try {
-					state.ws.send(raw);
+					state.ws?.send(raw);
 				} catch {}
 				return;
 			}
@@ -88,7 +71,7 @@ function createWebSocketProxy(target) {
 			_clearTimeout(state);
 			upstreams.delete(peer.id);
 			try {
-				state.ws.close(_normalizeOutgoingCode(details.code), _truncateReason(details.reason));
+				state.ws?.close(_normalizeOutgoingCode(details.code), _truncateReason(details.reason));
 			} catch {}
 		},
 		error(peer) {
@@ -97,16 +80,56 @@ function createWebSocketProxy(target) {
 			_clearTimeout(state);
 			upstreams.delete(peer.id);
 			try {
-				state.ws.close(1011, "Peer error");
+				state.ws?.close(1011, "Peer error");
 			} catch {}
 		}
 	};
 }
+function _dialUpstream(upstreams, peer, state, url, options, WebSocketCtor) {
+	if (upstreams.get(peer.id) !== state) return;
+	let ws;
+	try {
+		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 {
+		_cleanupState(upstreams, peer.id, state);
+		_safeClose(peer, 1011, "Upstream setup failed");
+		return;
+	}
+	state.ws = ws;
+	ws.addEventListener("open", () => {
+		if (upstreams.get(peer.id) !== state) return;
+		_clearTimeout(state);
+		state.open = true;
+		try {
+			for (const data of state.buffer) ws.send(data);
+		} catch {} finally {
+			state.buffer.length = 0;
+			state.bufferSize = 0;
+		}
+	});
+	ws.addEventListener("message", (event) => {
+		if (upstreams.get(peer.id) !== state) return;
+		_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");
+	});
+}
 function _cleanupState(upstreams, id, state) {
 	_clearTimeout(state);
 	upstreams.delete(id);
 	try {
-		state.ws.close();
+		state.ws?.close();
 	} catch {}
 }
 function _clearTimeout(state) {
@@ -117,8 +140,12 @@ function _clearTimeout(state) {
 }
 function _resolveTarget(target, peer) {
 	const raw = typeof target === "function" ? target(peer) : target;
+	if (_isThenable(raw)) return Promise.resolve(raw).then((value) => value instanceof URL ? value : new URL(value));
 	return raw instanceof URL ? raw : new URL(raw);
 }
+function _isThenable(value) {
+	return value != null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
 function _resolveWsOptions(headers, peer) {
 	if (!headers) return;
 	const resolved = typeof headers === "function" ? headers(peer) : headers;
@@ -127,10 +154,26 @@ function _resolveWsOptions(headers, peer) {
 }
 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));

package/dist/server/bun.d.mts

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

package/dist/server/bunny.d.mts

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

package/dist/server/cloudflare.d.mts

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

package/dist/server/default.d.mts

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

package/dist/server/deno.d.mts

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

package/dist/server/node.d.mts

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

package/dist/server/node.mjs

@@ -1,4 +1,4 @@
-import { t as nodeAdapter } from "../_chunks/node.mjs";
+import { nodeAdapter } from "../_chunks/node.mjs";
 import { NodeRequest, serve as serve$1 } from "srvx/node";
 function plugin(wsOpts) {
 	return (server) => {

package/dist/sync.d.mts

@@ -0,0 +1,2 @@
+import { PostgresClientLike, RedisClientLike, SyncAdapter, SyncDriver, SyncDriverName, SyncDriverOptions, SyncMessage, broadcastChannel, cluster, decodeEnvelope, encodeEnvelope, pgsql, redis, setupPrimaryCluster, syncDrivers } from "./_chunks/adapter.mjs";
+export { type PostgresClientLike, type RedisClientLike, type SyncAdapter, type SyncDriver, SyncDriverName, SyncDriverOptions, type SyncMessage, broadcastChannel, cluster, decodeEnvelope, encodeEnvelope, pgsql, redis, setupPrimaryCluster, syncDrivers };