crossws 0.4.5 → 0.4.7

package/dist/_chunks/bun.d.mts

@@ -1,4 +1,4 @@
-import { d as PeerContext, n as AdapterInstance, r as AdapterOptions, t as Adapter, u as Peer } from "./adapter.mjs";
+import { Adapter, AdapterInstance, AdapterOptions, Peer, PeerContext, SyncDriver } from "./adapter.mjs";
 import { Server, ServerWebSocket, WebSocketHandler } from "bun";
 interface BunAdapter extends AdapterInstance {
   websocket: WebSocketHandler<ContextData>;
@@ -18,13 +18,15 @@ declare class BunPeer extends Peer<{
   namespace: string;
   request: Request;
   peers: Set<BunPeer>;
+  sync?: SyncDriver;
 }> {
   get remoteAddress(): string;
   get context(): PeerContext;
+  get bufferedAmount(): number;
   send(data: unknown, options?: {
     compress?: boolean;
   }): number;
-  publish(topic: string, data: unknown, options?: {
+  _publish(topic: string, data: unknown, options?: {
     compress?: boolean;
   }): number;
   subscribe(topic: string): void;
@@ -32,4 +34,4 @@ declare class BunPeer extends Peer<{
   close(code?: number, reason?: string): void;
   terminate(): void;
 }
-export { BunOptions as n, bunAdapter as r, BunAdapter as t };
+export { BunAdapter, BunOptions, bunAdapter };

package/dist/_chunks/bunny.d.mts

@@ -1,4 +1,4 @@
-import { n as AdapterInstance, r as AdapterOptions, t as Adapter } from "./adapter.mjs";
+import { Adapter, AdapterInstance, AdapterOptions } from "./adapter.mjs";
 interface BunnyAdapter extends AdapterInstance {
   handleUpgrade(req: Request): Promise<Response>;
 }
@@ -19,4 +19,4 @@ interface BunnyOptions extends AdapterOptions {
   idleTimeout?: number;
 }
 declare const bunnyAdapter: Adapter<BunnyAdapter, BunnyOptions>;
-export { BunnyOptions as n, bunnyAdapter as r, BunnyAdapter as t };
+export { BunnyAdapter, BunnyOptions, bunnyAdapter };

package/dist/_chunks/cloudflare.d.mts

@@ -1,5 +1,5 @@
-import { n as AdapterInstance, r as AdapterOptions, t as Adapter } from "./adapter.mjs";
-import { a as WebSocket$1 } from "./web.mjs";
+import { Adapter, AdapterInstance, AdapterOptions } from "./adapter.mjs";
+import { WebSocket as WebSocket$1 } from "./web.mjs";
 import { DurableObject } from "cloudflare:workers";
 import * as CF from "@cloudflare/workers-types";
 type WSDurableObjectStub = CF.DurableObjectStub & {
@@ -39,4 +39,4 @@ interface CloudflareDurableAdapter extends AdapterInstance {
   handleDurablePublish: (obj: DurableObject, topic: string, data: unknown, opts: any) => Promise<void>;
   handleDurableClose(obj: DurableObject, ws: WebSocket | CF.WebSocket | WebSocket$1, code: number, reason: string, wasClean: boolean): Promise<void>;
 }
-export { CloudflareOptions as n, cloudflareAdapter as r, CloudflareDurableAdapter as t };
+export { CloudflareDurableAdapter, CloudflareOptions, cloudflareAdapter };

package/dist/_chunks/deno.d.mts

@@ -1,4 +1,4 @@
-import { n as AdapterInstance, r as AdapterOptions, t as Adapter } from "./adapter.mjs";
+import { Adapter, AdapterInstance, AdapterOptions } from "./adapter.mjs";
 interface DenoAdapter extends AdapterInstance {
   handleUpgrade(req: Request, info: ServeHandlerInfo): Promise<Response>;
 }
@@ -11,4 +11,4 @@ type ServeHandlerInfo = {
   };
 };
 declare const denoAdapter: Adapter<DenoAdapter, DenoOptions>;
-export { DenoOptions as n, denoAdapter as r, DenoAdapter as t };
+export { DenoAdapter, DenoOptions, denoAdapter };

package/dist/_chunks/error.mjs

@@ -4,4 +4,4 @@ var WSError = class extends Error {
 		this.name = "WSError";
 	}
 };
-export { WSError as t };
+export { WSError };

package/dist/_chunks/libs/ws.mjs

@@ -1,4 +1,26 @@
-import { n as __require, r as __toESM, t as __commonJSMin } from "../rolldown-runtime.mjs";
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
 var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const BINARY_TYPES = [
 		"nodebuffer",
@@ -509,6 +531,8 @@ var require_receiver = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			this._binaryType = options.binaryType || BINARY_TYPES[0];
 			this._extensions = options.extensions || {};
 			this._isServer = !!options.isServer;
+			this._maxBufferedChunks = options.maxBufferedChunks | 0;
+			this._maxFragments = options.maxFragments | 0;
 			this._maxPayload = options.maxPayload | 0;
 			this._skipUTF8Validation = !!options.skipUTF8Validation;
 			this[kWebSocket] = void 0;
@@ -530,6 +554,10 @@ var require_receiver = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 		_write(chunk, encoding, cb) {
 			if (this._opcode === 8 && this._state == GET_INFO) return cb();
+			if (this._maxBufferedChunks > 0 && this._buffers.length >= this._maxBufferedChunks) {
+				cb(this.createError(RangeError, "Too many buffered chunks", false, 1008, "WS_ERR_TOO_MANY_BUFFERED_PARTS"));
+				return;
+			}
 			this._bufferedBytes += chunk.length;
 			this._buffers.push(chunk);
 			this.startLoop(cb);
@@ -709,6 +737,10 @@ var require_receiver = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				return;
 			}
 			if (data.length) {
+				if (this._maxFragments > 0 && this._fragments.length >= this._maxFragments) {
+					cb(this.createError(RangeError, "Too many message fragments", false, 1008, "WS_ERR_TOO_MANY_BUFFERED_PARTS"));
+					return;
+				}
 				this._messageLength = this._totalPayloadLength;
 				this._fragments.push(data);
 			}
@@ -723,6 +755,10 @@ var require_receiver = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 						cb(this.createError(RangeError, "Max payload size exceeded", false, 1009, "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"));
 						return;
 					}
+					if (this._maxFragments > 0 && this._fragments.length >= this._maxFragments) {
+						cb(this.createError(RangeError, "Too many message fragments", false, 1008, "WS_ERR_TOO_MANY_BUFFERED_PARTS"));
+						return;
+					}
 					this._fragments.push(buf);
 				}
 				this.dataMessage(cb);
@@ -827,6 +863,7 @@ var require_receiver = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 var require_sender = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { Duplex: Duplex$3 } = __require("stream");
 	const { randomFillSync } = __require("crypto");
+	const { types: { isUint8Array } } = __require("util");
 	const PerMessageDeflate = require_permessage_deflate();
 	const { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants();
 	const { isBlob, isValidStatusCode } = require_validation();
@@ -931,7 +968,8 @@ var require_sender = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				buf = Buffer.allocUnsafe(2 + length);
 				buf.writeUInt16BE(code, 0);
 				if (typeof data === "string") buf.write(data, 2);
-				else buf.set(data, 2);
+				else if (isUint8Array(data)) buf.set(data, 2);
+				else throw new TypeError("Second argument must be a string or a Uint8Array");
 			}
 			const options = {
 				[kByteLength]: buf.length,
@@ -1119,7 +1157,8 @@ var require_sender = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			this._state = DEFLATING;
 			perMessageDeflate.compress(data, options.fin, (_, buf) => {
 				if (this._socket.destroyed) {
-					callCallbacks(this, /* @__PURE__ */ new Error("The socket was closed while data was being compressed"), cb);
+					const err = /* @__PURE__ */ new Error("The socket was closed while data was being compressed");
+					callCallbacks(this, err, cb);
 					return;
 				}
 				this._bufferedBytes -= options[kByteLength];
@@ -1507,6 +1546,8 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				binaryType: this.binaryType,
 				extensions: this._extensions,
 				isServer: this._isServer,
+				maxBufferedChunks: options.maxBufferedChunks,
+				maxFragments: options.maxFragments,
 				maxPayload: options.maxPayload,
 				skipUTF8Validation: options.skipUTF8Validation
 			});
@@ -1714,6 +1755,8 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			autoPong: true,
 			closeTimeout: CLOSE_TIMEOUT,
 			protocolVersion: protocolVersions[1],
+			maxBufferedChunks: 1024 * 1024,
+			maxFragments: 128 * 1024,
 			maxPayload: 100 * 1024 * 1024,
 			skipUTF8Validation: false,
 			perMessageDeflate: true,
@@ -1903,6 +1946,8 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			websocket.setSocket(socket, head, {
 				allowSynchronousEvents: opts.allowSynchronousEvents,
 				generateMask: opts.generateMask,
+				maxBufferedChunks: opts.maxBufferedChunks,
+				maxFragments: opts.maxFragments,
 				maxPayload: opts.maxPayload,
 				skipUTF8Validation: opts.skipUTF8Validation
 			});
@@ -2188,6 +2233,8 @@ var require_websocket_server = /* @__PURE__ */ __commonJSMin(((exports, module)
 			options = {
 				allowSynchronousEvents: true,
 				autoPong: true,
+				maxBufferedChunks: 1024 * 1024,
+				maxFragments: 128 * 1024,
 				maxPayload: 100 * 1024 * 1024,
 				skipUTF8Validation: false,
 				perMessageDeflate: false,
@@ -2372,6 +2419,8 @@ var require_websocket_server = /* @__PURE__ */ __commonJSMin(((exports, module)
 			socket.removeListener("error", socketOnError);
 			ws.setSocket(socket, head, {
 				allowSynchronousEvents: this.options.allowSynchronousEvents,
+				maxBufferedChunks: this.options.maxBufferedChunks,
+				maxFragments: this.options.maxFragments,
 				maxPayload: this.options.maxPayload,
 				skipUTF8Validation: this.options.skipUTF8Validation
 			});
@@ -2426,4 +2475,4 @@ require_sender();
 require_subprotocol();
 var import_websocket = /* @__PURE__ */ __toESM(require_websocket(), 1);
 var import_websocket_server = /* @__PURE__ */ __toESM(require_websocket_server(), 1);
-export { import_websocket_server as n, import_websocket as t };
+export { import_websocket, import_websocket_server };

package/dist/_chunks/node.d.mts

@@ -1,4 +1,4 @@
-import { a as Hooks, n as AdapterInstance, r as AdapterOptions, t as Adapter } from "./adapter.mjs";
+import { Adapter, AdapterInstance, AdapterOptions, Hooks } from "./adapter.mjs";
 import { EventEmitter } from "events";
 import { Agent, ClientRequest, ClientRequestArgs, IncomingMessage, OutgoingHttpHeaders, Server } from "node:http";
 import { Duplex, DuplexOptions } from "node:stream";
@@ -325,4 +325,4 @@ interface NodeOptions extends AdapterOptions {
   serverOptions?: ServerOptions;
 }
 declare const nodeAdapter: Adapter<NodeAdapter, NodeOptions>;
-export { fromNodeUpgradeHandler as a, NodeUpgradeHandler as i, NodeOptions as n, nodeAdapter as r, NodeAdapter as t };
+export { NodeAdapter, NodeOptions, NodeUpgradeHandler, fromNodeUpgradeHandler, nodeAdapter };

package/dist/_chunks/node.mjs

@@ -1,8 +1,8 @@
-import { i as AdapterHookable, r as getPeers, t as adapterUtils } from "./adapter.mjs";
-import { n as import_websocket_server } from "./libs/ws.mjs";
-import { n as Message, r as toBufferLike, t as Peer } from "./peer.mjs";
-import { t as WSError } from "./error.mjs";
-import { t as StubRequest } from "./_request.mjs";
+import { import_websocket_server } from "./libs/ws.mjs";
+import { AdapterHookable, adapterUtils, getPeers, toBufferLike } from "./adapter.mjs";
+import { Message, Peer } from "./peer.mjs";
+import { WSError } from "./error.mjs";
+import { StubRequest } from "./_request.mjs";
 function fromNodeUpgradeHandler(handler) {
 	return { async upgrade(request) {
 		const node = request.runtime?.node;
@@ -15,6 +15,7 @@ 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 baseUtils = adapterUtils(globalPeers, options);
 	const wss = options.wss || new import_websocket_server.default({
 		noServer: true,
 		handleProtocols: () => false,
@@ -28,7 +29,8 @@ const nodeAdapter = (options = {}) => {
 			request,
 			peers,
 			nodeReq,
-			namespace: nodeReq._namespace
+			namespace: nodeReq._namespace,
+			sync: baseUtils.sync
 		});
 		peers.add(peer);
 		hooks.callHook("open", peer);
@@ -41,8 +43,12 @@ const nodeAdapter = (options = {}) => {
 			peers.delete(peer);
 			hooks.callHook("error", peer, new WSError(error));
 		});
+		const socket = ws._socket;
+		const onDrain = () => hooks.callHook("drain", peer);
+		socket?.on("drain", onDrain);
 		ws.on("close", (code, reason) => {
 			peers.delete(peer);
+			socket?.off("drain", onDrain);
 			hooks.callHook("close", peer, {
 				code,
 				reason: reason?.toString()
@@ -54,7 +60,7 @@ const nodeAdapter = (options = {}) => {
 		if (upgradeHeaders) for (const [key, value] of new Headers(upgradeHeaders)) outgoingHeaders.push(`${key}: ${value}`);
 	});
 	return {
-		...adapterUtils(globalPeers),
+		...baseUtils,
 		handleUpgrade: async (nodeReq, socket, head, webRequest) => {
 			const request = webRequest || new NodeReqProxy(nodeReq);
 			const { upgradeHeaders, endResponse, handled, context, namespace } = await hooks.upgrade(request);
@@ -89,11 +95,11 @@ var NodePeer = class extends Peer {
 			binary: isBinary,
 			...options
 		});
-		return 0;
+		return this._internal.ws.bufferedAmount;
 	}
-	publish(topic, data, options) {
+	_publish(topic, data, options) {
 		const dataBuff = toBufferLike(data);
-		const isBinary = typeof data !== "string";
+		const isBinary = typeof dataBuff !== "string";
 		const sendOptions = {
 			compress: options?.compress,
 			binary: isBinary,
@@ -126,4 +132,4 @@ async function sendResponse(socket, res) {
 		});
 	});
 }
-export { fromNodeUpgradeHandler as n, nodeAdapter as t };
+export { fromNodeUpgradeHandler, nodeAdapter };

package/dist/_chunks/peer.mjs

@@ -1,28 +1,4 @@
-const kNodeInspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
-function toBufferLike(val) {
-	if (val === void 0 || val === null) return "";
-	const type = typeof val;
-	if (type === "string") return val;
-	if (type === "number" || type === "boolean" || type === "bigint") return val.toString();
-	if (type === "function" || type === "symbol") return "{}";
-	if (val instanceof Uint8Array || val instanceof ArrayBuffer) return val;
-	if (isPlainObject(val)) return JSON.stringify(val);
-	return val;
-}
-function toString(val) {
-	if (typeof val === "string") return val;
-	const data = toBufferLike(val);
-	if (typeof data === "string") return data;
-	return `data:application/octet-stream;base64,${btoa(String.fromCharCode(...new Uint8Array(data)))}`;
-}
-function isPlainObject(value) {
-	if (value === null || typeof value !== "object") return false;
-	const prototype = Object.getPrototypeOf(value);
-	if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) return false;
-	if (Symbol.iterator in value) return false;
-	if (Symbol.toStringTag in value) return Object.prototype.toString.call(value) === "[object Module]";
-	return true;
-}
+import { kNodeInspect, serializeMessage } from "./adapter.mjs";
 var Message = class {
 	event;
 	peer;
@@ -147,6 +123,34 @@ var Peer = class {
 	get topics() {
 		return this._topics;
 	}
+	get bufferedAmount() {
+		return this._internal.ws?.bufferedAmount ?? 0;
+	}
+	waitForDrain(opts = {}) {
+		const threshold = opts.threshold ?? 0;
+		if (this.bufferedAmount <= threshold) return Promise.resolve();
+		const signal = opts.signal;
+		if (signal?.aborted) return Promise.reject(signal.reason);
+		return new Promise((resolve, reject) => {
+			const check = () => {
+				if (this.bufferedAmount <= threshold || (this.websocket.readyState ?? 1) > 1) {
+					cleanup();
+					resolve();
+				}
+			};
+			const onAbort = () => {
+				cleanup();
+				reject(signal.reason);
+			};
+			const timer = setInterval(check, opts.pollInterval ?? 100);
+			timer.unref?.();
+			const cleanup = () => {
+				clearInterval(timer);
+				signal?.removeEventListener("abort", onAbort);
+			};
+			signal?.addEventListener("abort", onAbort, { once: true });
+		});
+	}
 	terminate() {
 		this.close();
 	}
@@ -156,6 +160,14 @@ var Peer = class {
 	unsubscribe(topic) {
 		this._topics.delete(topic);
 	}
+	publish(topic, data, options) {
+		this._publish(topic, data, options);
+		this._internal.sync?.publish({
+			namespace: this.namespace,
+			topic,
+			data: serializeMessage(data)
+		});
+	}
 	toString() {
 		return this.id;
 	}
@@ -183,4 +195,4 @@ function createWsProxy(ws, request) {
 		return value;
 	} });
 }
-export { toString as i, Message as n, toBufferLike as r, Peer as t };
+export { Message, Peer };

package/dist/_chunks/sse.d.mts

@@ -1,4 +1,4 @@
-import { n as AdapterInstance, r as AdapterOptions, t as Adapter } from "./adapter.mjs";
+import { Adapter, AdapterInstance, AdapterOptions } from "./adapter.mjs";
 interface SSEAdapter extends AdapterInstance {
   fetch(req: Request): Promise<Response>;
 }
@@ -6,4 +6,4 @@ interface SSEOptions extends AdapterOptions {
   bidir?: boolean;
 }
 declare const sseAdapter: Adapter<SSEAdapter, SSEOptions>;
-export { SSEOptions as n, sseAdapter as r, SSEAdapter as t };
+export { SSEAdapter, SSEOptions, sseAdapter };

package/dist/_chunks/web.d.mts

@@ -293,4 +293,4 @@ interface WebSocket extends EventTarget {
   removeEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
   removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
 }
-export { WebSocket as a, MessageEvent as i, Event as n, EventTarget as r, CloseEvent as t };
+export { CloseEvent, Event, EventTarget, MessageEvent, WebSocket };

package/dist/adapters/bun.d.mts

@@ -1,2 +1,2 @@
-import { n as BunOptions, r as bunAdapter, t as BunAdapter } from "../_chunks/bun.mjs";
+import { BunAdapter, BunOptions, bunAdapter } from "../_chunks/bun.mjs";
 export { BunAdapter, BunOptions, bunAdapter as default };

package/dist/adapters/bun.mjs

@@ -1,11 +1,12 @@
-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 { AdapterHookable, adapterUtils, getPeers, toBufferLike } from "../_chunks/adapter.mjs";
+import { Message, Peer } from "../_chunks/peer.mjs";
 const bunAdapter = (options = {}) => {
 	if (typeof Bun === "undefined") throw new Error("[crossws] Using Bun adapter in an incompatible environment.");
 	const hooks = new AdapterHookable(options);
 	const globalPeers = /* @__PURE__ */ new Map();
+	const baseUtils = adapterUtils(globalPeers, options, { nativePubSub: true });
 	return {
-		...adapterUtils(globalPeers),
+		...baseUtils,
 		async handleUpgrade(request, server) {
 			const { upgradeHeaders, endResponse, context, namespace } = await hooks.upgrade(request);
 			if (endResponse) return endResponse;
@@ -21,34 +22,39 @@ const bunAdapter = (options = {}) => {
 		},
 		websocket: {
 			message: (ws, message) => {
-				const peer = getPeer(ws, getPeers(globalPeers, ws.data.namespace));
+				const peer = getPeer(ws, getPeers(globalPeers, ws.data.namespace), baseUtils.sync);
 				hooks.callHook("message", peer, new Message(message, peer));
 			},
 			open: (ws) => {
 				const peers = getPeers(globalPeers, ws.data.namespace);
-				const peer = getPeer(ws, peers);
+				const peer = getPeer(ws, peers, baseUtils.sync);
 				peers.add(peer);
 				hooks.callHook("open", peer);
 			},
 			close: (ws, code, reason) => {
 				const peers = getPeers(globalPeers, ws.data.namespace);
-				const peer = getPeer(ws, peers);
+				const peer = getPeer(ws, peers, baseUtils.sync);
 				peers.delete(peer);
 				hooks.callHook("close", peer, {
 					code,
 					reason
 				});
+			},
+			drain: (ws) => {
+				const peer = getPeer(ws, getPeers(globalPeers, ws.data.namespace));
+				hooks.callHook("drain", peer);
 			}
 		}
 	};
 };
-function getPeer(ws, peers) {
+function getPeer(ws, peers, sync) {
 	if (ws.data.peer) return ws.data.peer;
 	const peer = new BunPeer({
 		ws,
 		request: ws.data.request,
 		peers,
-		namespace: ws.data.namespace
+		namespace: ws.data.namespace,
+		sync
 	});
 	ws.data.peer = peer;
 	return peer;
@@ -60,10 +66,13 @@ var BunPeer = class extends Peer {
 	get context() {
 		return this._internal.ws.data.context;
 	}
+	get bufferedAmount() {
+		return this._internal.ws.getBufferedAmount();
+	}
 	send(data, options) {
 		return this._internal.ws.send(toBufferLike(data), options?.compress);
 	}
-	publish(topic, data, options) {
+	_publish(topic, data, options) {
 		return this._internal.ws.publish(topic, toBufferLike(data), options?.compress);
 	}
 	subscribe(topic) {

package/dist/adapters/bunny.d.mts

@@ -1,2 +1,2 @@
-import { n as BunnyOptions, r as bunnyAdapter, t as BunnyAdapter } from "../_chunks/bunny.mjs";
+import { BunnyAdapter, BunnyOptions, bunnyAdapter } from "../_chunks/bunny.mjs";
 export { BunnyAdapter, BunnyOptions, bunnyAdapter as default };

package/dist/adapters/bunny.mjs

@@ -1,11 +1,12 @@
-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 bunnyAdapter = (options = {}) => {
 	const hooks = new AdapterHookable(options);
 	const globalPeers = /* @__PURE__ */ new Map();
+	const baseUtils = adapterUtils(globalPeers, options);
 	return {
-		...adapterUtils(globalPeers),
+		...baseUtils,
 		handleUpgrade: async (request) => {
 			if (!request.upgradeWebSocket || typeof request.upgradeWebSocket !== "function") throw new Error("[crossws] Bunny adapter requires the request to have an upgradeWebSocket method.");
 			const { endResponse, context, namespace, upgradeHeaders } = await hooks.upgrade(request);
@@ -23,7 +24,8 @@ const bunnyAdapter = (options = {}) => {
 				namespace,
 				remoteAddress,
 				peers,
-				context
+				context,
+				sync: baseUtils.sync
 			});
 			peers.add(peer);
 			socket.addEventListener("open", () => {
@@ -54,7 +56,7 @@ var BunnyPeer = class extends Peer {
 	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/cloudflare.d.mts

@@ -1,2 +1,2 @@
-import { n as CloudflareOptions, r as cloudflareAdapter, t as CloudflareDurableAdapter } from "../_chunks/cloudflare.mjs";
+import { CloudflareDurableAdapter, CloudflareOptions, cloudflareAdapter } from "../_chunks/cloudflare.mjs";
 export { CloudflareDurableAdapter, CloudflareOptions, cloudflareAdapter as default };

package/dist/adapters/cloudflare.mjs

@@ -1,7 +1,7 @@
-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 { t as StubRequest } from "../_chunks/_request.mjs";
+import { AdapterHookable, adapterUtils, getPeers, toBufferLike } from "../_chunks/adapter.mjs";
+import { Message, Peer } from "../_chunks/peer.mjs";
+import { WSError } from "../_chunks/error.mjs";
+import { StubRequest } from "../_chunks/_request.mjs";
 import { env } from "cloudflare:workers";
 const cloudflareAdapter = (opts = {}) => {
 	const hooks = new AdapterHookable(opts);
@@ -14,7 +14,8 @@ const cloudflareAdapter = (opts = {}) => {
 			return binding.get(instanceId);
 		}
 	});
-	const { publish: durablePublish, ...utils } = adapterUtils(globalPeers);
+	const baseUtils = adapterUtils(globalPeers, opts);
+	const { publish: durablePublish, ...utils } = baseUtils;
 	return {
 		...utils,
 		handleUpgrade: async (request, cfEnv, cfCtx) => {
@@ -65,7 +66,7 @@ const cloudflareAdapter = (opts = {}) => {
 			const pair = new WebSocketPair();
 			const client = pair[0];
 			const server = pair[1];
-			const peer = CloudflareDurablePeer._restore(obj, server, request, namespace);
+			const peer = CloudflareDurablePeer._restore(obj, server, request, namespace, baseUtils.sync);
 			peers.add(peer);
 			obj.ctx.acceptWebSocket(server);
 			await hooks.callHook("open", peer);
@@ -76,11 +77,11 @@ const cloudflareAdapter = (opts = {}) => {
 			});
 		},
 		handleDurableMessage: async (obj, ws, message) => {
-			const peer = CloudflareDurablePeer._restore(obj, ws);
+			const peer = CloudflareDurablePeer._restore(obj, ws, void 0, void 0, baseUtils.sync);
 			await hooks.callHook("message", peer, new Message(message, peer));
 		},
 		handleDurableClose: async (obj, ws, code, reason, wasClean) => {
-			const peer = CloudflareDurablePeer._restore(obj, ws);
+			const peer = CloudflareDurablePeer._restore(obj, ws, void 0, void 0, baseUtils.sync);
 			getPeers(globalPeers, peer.namespace).delete(peer);
 			const details = {
 				code,
@@ -106,7 +107,7 @@ const cloudflareAdapter = (opts = {}) => {
 };
 var CloudflareDurablePeer = class CloudflareDurablePeer extends Peer {
 	get peers() {
-		return new Set(this.#getwebsockets().map((ws) => CloudflareDurablePeer._restore(this._internal.durable, ws)));
+		return new Set(this.#getwebsockets().map((ws) => CloudflareDurablePeer._restore(this._internal.durable, ws, void 0, void 0, this._internal.sync)));
 	}
 	#getwebsockets() {
 		return this._internal.durable.ctx.getWebSockets();
@@ -121,7 +122,7 @@ var CloudflareDurablePeer = class CloudflareDurablePeer extends Peer {
 		state.t.add(topic);
 		setAttachedState(this._internal.ws, state);
 	}
-	publish(topic, data) {
+	_publish(topic, data) {
 		const websockets = this.#getwebsockets();
 		if (websockets.length < 2) return;
 		const dataBuff = toBufferLike(data);
@@ -133,7 +134,7 @@ var CloudflareDurablePeer = class CloudflareDurablePeer extends Peer {
 	close(code, reason) {
 		this._internal.ws.close(code, reason);
 	}
-	static _restore(durable, ws, request, namespace) {
+	static _restore(durable, ws, request, namespace, sync) {
 		let peer = ws._crosswsPeer;
 		if (peer) return peer;
 		const state = ws.deserializeAttachment() || {};
@@ -141,11 +142,13 @@ var CloudflareDurablePeer = class CloudflareDurablePeer extends Peer {
 			ws,
 			request: request || new StubRequest(state.u || ""),
 			namespace: namespace || state.n || "",
-			durable
+			durable,
+			sync
 		});
 		if (state.i) peer._id = state.i;
 		if (request?.url) state.u = request.url;
 		state.i = peer.id;
+		state.n = peer.namespace;
 		setAttachedState(ws, state);
 		return peer;
 	}
@@ -155,7 +158,7 @@ var CloudflareFallbackPeer = class extends Peer {
 		this._internal.wsServer.send(toBufferLike(data));
 		return 0;
 	}
-	publish(_topic, _message) {
+	_publish(_topic, _message) {
 		console.warn("[crossws] [cloudflare] pub/sub support requires Durable Objects.");
 	}
 	close(code, reason) {

package/dist/adapters/deno.d.mts

@@ -1,2 +1,2 @@
-import { n as DenoOptions, r as denoAdapter, t as DenoAdapter } from "../_chunks/deno.mjs";
+import { DenoAdapter, DenoOptions, denoAdapter } from "../_chunks/deno.mjs";
 export { DenoAdapter, DenoOptions, denoAdapter as default };