crossws 0.4.6 → 0.4.8

package/dist/_chunks/_request.mjs

@@ -62,7 +62,7 @@ const StubRequest = /* @__PURE__ */ (() => {
 			return Promise.resolve(new Blob());
 		}
 		bytes() {
-			return Promise.resolve(new Uint8Array());
+			return Promise.resolve(/* @__PURE__ */ new Uint8Array());
 		}
 		formData() {
 			return Promise.resolve(new FormData());

package/dist/_chunks/adapter.d.mts

@@ -2,14 +2,378 @@ import { WebSocket } from "./web.mjs";
 declare class WSError extends Error {
   constructor(...args: any[]);
 }
+/**
+ * A single pub/sub event relayed between crossws instances.
+ *
+ * This is the minimal unit a sync backplane needs to transport so that a
+ * `peer.publish()` (or `adapter.publish()`) on one instance reaches the
+ * subscribers connected to every other instance.
+ */
+interface SyncMessage {
+  /**
+   * Pub/sub namespace (matches {@link Peer.namespace}).
+   *
+   * An empty string means "all namespaces" and mirrors a server-side
+   * `adapter.publish(topic, data)` call without an explicit `namespace`.
+   */
+  namespace: string;
+  /** Channel / topic name. */
+  topic: string;
+  /**
+   * Message payload.
+   *
+   * crossws normalizes payloads to a string or `Uint8Array` before handing
+   * them to the driver. Encoding for the wire (e.g. base64 for binary over a
+   * text transport) is the driver's responsibility.
+   */
+  data: string | Uint8Array;
+}
+/**
+ * A live connection to a sync backplane, scoped to one crossws instance.
+ *
+ * Created by a {@link SyncAdapter}. crossws calls {@link SyncDriver.publish}
+ * for every local publish and expects {@link SyncDriver.subscribe} to invoke
+ * the supplied `deliver` callback for every message originating from *other*
+ * instances.
+ */
+interface SyncDriver {
+  /**
+   * Start receiving messages relayed from other instances.
+   *
+   * The driver MUST call `deliver` for every remote message; crossws then
+   * fans it out to local subscribers. The driver MUST NOT echo this
+   * instance's own publishes back (backplanes like Redis pub/sub echo by
+   * default — use the instance `id` from {@link SyncAdapter} to filter).
+   */
+  subscribe(deliver: (message: SyncMessage) => void): MaybePromise<void>;
+  /** Relay a locally-published message to the other instances. */
+  publish(message: SyncMessage): MaybePromise<void>;
+  /** Optional teardown when the adapter shuts down. */
+  close?(): MaybePromise<void>;
+}
+/**
+ * Factory for a {@link SyncDriver}.
+ *
+ * crossws calls it once per adapter instance and passes a stable random `id`
+ * the driver can use for echo suppression.
+ */
+type SyncAdapter = (ctx: {
+  id: string;
+}) => SyncDriver;
+/**
+ * Zero-dependency sync driver built on [`BroadcastChannel`](https://developer.mozilla.org/en-US/docs/Web/API/BroadcastChannel).
+ *
+ * Bridges instances that share a `BroadcastChannel` registry. On Node.js, Deno
+ * and Bun that registry is scoped to a **single process** (it spans the main
+ * thread and its worker threads), so this is for in-process worker fan-out and
+ * tests — not separate OS processes (e.g. Node `cluster`/PM2 forks), which each
+ * have an isolated registry and will silently not sync. (Deno Deploy is the one
+ * exception: its `BroadcastChannel` spans isolates.)
+ *
+ * For multiple processes, hosts or regions you want a networked driver such as
+ * {@link redis} or {@link pgsql}.
+ *
+ * A `channel` name is required: it scopes the cluster, and a shared default
+ * would risk silently bridging unrelated servers running on the same host.
+ *
+ * @example
+ * ```js
+ * import { broadcastChannel } from "crossws/sync";
+ * const adapter = nodeAdapter({ hooks, sync: broadcastChannel({ channel: "my-app" }) });
+ * ```
+ */
+declare function broadcastChannel(opts: {
+  channel: string;
+}): SyncAdapter;
+/**
+ * Structural subset of a Redis client used by {@link redis}, covering both
+ * [ioredis](https://github.com/redis/ioredis) and
+ * [node-redis](https://github.com/redis/node-redis). Kept structural so crossws
+ * stays dependency-free.
+ *
+ * The two clients shape pub/sub differently and {@link redis} bridges them:
+ * - **ioredis** — `subscribe(channel)` plus a shared `"message"` event whose
+ *   listener receives `(channel, message)`; `duplicate()` returns a ready client.
+ * - **node-redis** — `subscribe(channel, listener)` with an inline listener that
+ *   receives `(message, channel)`; `duplicate()` returns a client you must
+ *   `connect()` first.
+ */
+interface RedisClientLike {
+  publish(channel: string, message: string): unknown;
+  /**
+   * ioredis: `subscribe(channel)`; node-redis: `subscribe(channel, listener)`
+   * (the listener receives `(message, channel)`).
+   */
+  subscribe(channel: string, listener?: (message: string, channel: string) => void): unknown;
+  /** ioredis: shared `"message"` event (listener receives `(channel, message)`). */
+  on?(event: "message", listener: (channel: string, message: string) => void): unknown;
+  /** ioredis: detach the `"message"` listener on {@link SyncDriver.close}. */
+  off?(event: "message", listener: (channel: string, message: string) => void): unknown;
+  /** node-redis: a `duplicate()`d client starts disconnected and must `connect()`. */
+  connect?(): unknown;
+  /** Create a second connection for `SUBSCRIBE` (which blocks the connection). */
+  duplicate(): RedisClientLike;
+  /** Tear down the dedicated subscriber connection on {@link SyncDriver.close}. */
+  quit?(): unknown;
+  /** Present (camelCase) only on node-redis — used for auto-detection. */
+  pSubscribe?: unknown;
+}
+/**
+ * Networked sync driver over Redis pub/sub — the realistic multi-region
+ * backplane. Bring your own client; a dedicated `SUBSCRIBE` connection is
+ * derived from it via `duplicate()` (`SUBSCRIBE` blocks the connection it runs
+ * on, so it can't share the one used for `PUBLISH`).
+ *
+ * Works out of the box with both [ioredis](https://github.com/redis/ioredis)
+ * and [node-redis](https://github.com/redis/node-redis): the flavor is
+ * auto-detected (node-redis exposes camelCase commands such as `pSubscribe`),
+ * with an explicit `connector` escape hatch if detection ever guesses wrong.
+ *
+ * Binary payloads are base64-encoded so they survive Redis's text transport.
+ *
+ * A `channel` name is required: it scopes the cluster, and a shared default
+ * would risk silently bridging unrelated servers on the same Redis instance.
+ *
+ * Reconnect note: ioredis auto-resubscribes its channels after a dropped
+ * connection; node-redis does not restore subscriptions the same way, so a
+ * node-redis-backed instance may stop receiving relayed messages after a
+ * transient outage. Prefer ioredis where connection resilience matters.
+ *
+ * @example
+ * ```js
+ * // ioredis
+ * import Redis from "ioredis";
+ * import { redis } from "crossws/sync";
+ * const adapter = nodeAdapter({ hooks, sync: redis({ client: new Redis(), channel: "my-app" }) });
+ * ```
+ *
+ * @example
+ * ```js
+ * // node-redis
+ * import { createClient } from "redis";
+ * import { redis } from "crossws/sync";
+ * const client = await createClient().connect();
+ * const adapter = nodeAdapter({ hooks, sync: redis({ client, channel: "my-app" }) });
+ * ```
+ */
+declare function redis(opts: {
+  /** Redis client used to `PUBLISH`; a subscriber is `duplicate()`d from it. */client: RedisClientLike; /** Pub/sub channel to relay over. */
+  channel: string;
+  /**
+   * Client flavor. Defaults to auto-detection (node-redis exposes the camelCase
+   * `pSubscribe` command; ioredis does not). Set explicitly to override.
+   */
+  connector?: "ioredis" | "node-redis";
+}): SyncAdapter;
+/**
+ * Structural subset of a PostgreSQL client used by {@link pgsql}, covering
+ * both [node-postgres](https://github.com/brianc/node-postgres) (`pg`) and
+ * [postgres.js](https://github.com/porsager/postgres). Kept structural so
+ * crossws stays dependency-free.
+ *
+ * The two clients shape `LISTEN`/`NOTIFY` differently and {@link pgsql}
+ * bridges them:
+ * - **node-postgres** — issue raw `LISTEN`/`pg_notify` via `query()` and receive
+ *   a shared `"notification"` event whose listener gets `{ channel, payload }`.
+ * - **postgres.js** — dedicated `listen(channel, onnotify)` (resolves to a
+ *   handle with `unlisten()`) and `notify(channel, payload)` helpers.
+ */
+interface PostgresClientLike {
+  /** node-postgres: run `LISTEN` / `SELECT pg_notify(...)` / `UNLISTEN`. */
+  query?(sql: string, values?: unknown[]): unknown;
+  /** node-postgres: shared `"notification"` event for inbound `NOTIFY`s. */
+  on?(event: "notification", listener: (msg: {
+    channel: string;
+    payload?: string;
+  }) => void): unknown;
+  /** node-postgres: detach the `"notification"` listener on {@link SyncDriver.close}. */
+  removeListener?(event: "notification", listener: (msg: {
+    channel: string;
+    payload?: string;
+  }) => void): unknown;
+  /**
+   * postgres.js: subscribe to a channel; resolves to a handle exposing
+   * `unlisten()`. Present only on postgres.js — used for auto-detection.
+   */
+  listen?(channel: string, onnotify: (payload: string) => void): unknown;
+  /** postgres.js: send a `NOTIFY` to a channel. */
+  notify?(channel: string, payload: string): unknown;
+}
+/**
+ * Networked sync driver over PostgreSQL [`LISTEN`/`NOTIFY`](https://www.postgresql.org/docs/current/sql-notify.html)
+ * — a backplane for clusters that already run Postgres and would rather not add
+ * Redis. Bring your own client; unlike Redis `SUBSCRIBE`, Postgres `LISTEN` does
+ * not block the connection, so no `duplicate()` is needed: for node-postgres the
+ * *same* client both listens and notifies. (postgres.js `listen()` internally
+ * reserves its own dedicated connection — that's the client's concern, not ours.)
+ *
+ * Pass a single, dedicated [`Client`](https://node-postgres.com/apis/client), not
+ * a [`Pool`](https://node-postgres.com/apis/pool): pool `query()` runs `LISTEN`
+ * on an arbitrary backend that is then returned to the pool, so notifications
+ * would never reach a stable listener. A `Pool` is detected and rejected. For the
+ * same reason, don't share one client across two `pgsql()` drivers on the same
+ * channel — `close()` issues a single `UNLISTEN` that would silence the others.
+ *
+ * Works out of the box with both [node-postgres](https://github.com/brianc/node-postgres)
+ * (`pg`) and [postgres.js](https://github.com/porsager/postgres): the flavor is
+ * auto-detected (postgres.js exposes a `listen()` helper; node-postgres does
+ * not), with an explicit `connector` escape hatch if detection ever guesses
+ * wrong.
+ *
+ * Binary payloads are base64-encoded so they survive the text `NOTIFY` payload.
+ * Note Postgres caps a `NOTIFY` payload at 8000 bytes — keep relayed messages
+ * small (this is a transport limit, not a crossws one).
+ *
+ * A `channel` name is required: it scopes the cluster, so unrelated servers
+ * don't silently bridge through the same database. It is used verbatim as the
+ * notification channel name.
+ *
+ * @example
+ * ```js
+ * // node-postgres (pg)
+ * import { Client } from "pg";
+ * import { pgsql } from "crossws/sync";
+ * const client = new Client();
+ * await client.connect();
+ * const adapter = nodeAdapter({ hooks, sync: pgsql({ client, channel: "my-app" }) });
+ * ```
+ *
+ * @example
+ * ```js
+ * // postgres.js
+ * import postgresjs from "postgres";
+ * import { pgsql } from "crossws/sync";
+ * const sql = postgresjs();
+ * const adapter = nodeAdapter({ hooks, sync: pgsql({ client: sql, channel: "my-app" }) });
+ * ```
+ */
+declare function pgsql(opts: {
+  /** Connected Postgres client used to both `LISTEN` and `NOTIFY`. */client: PostgresClientLike; /** Notification channel to relay over. */
+  channel: string;
+  /**
+   * Client flavor. Defaults to auto-detection (postgres.js exposes a `listen()`
+   * helper; node-postgres does not). Set explicitly to override.
+   */
+  connector?: "pg" | "postgres.js";
+}): SyncAdapter;
+/**
+ * Install the cluster relay in the **primary** process.
+ *
+ * Node `cluster` workers can't message each other directly — IPC only flows
+ * between each worker and the primary — so the primary must rebroadcast every
+ * worker's relay message to the others. Call this once in your primary process
+ * (before or after forking) so {@link cluster} drivers running in the workers
+ * can reach one another. It is a no-op when called from a worker, so guarding
+ * with `cluster.isPrimary` is optional.
+ *
+ * `node:cluster` is imported lazily so merely importing `crossws/sync` stays
+ * runtime-agnostic (it never loads in workerd/Deno where the module is unused).
+ *
+ * @example
+ * ```js
+ * import cluster from "node:cluster";
+ * import { availableParallelism } from "node:os";
+ * import { setupPrimaryCluster } from "crossws/sync";
+ *
+ * if (cluster.isPrimary) {
+ *   setupPrimaryCluster();
+ *   for (let i = 0; i < availableParallelism(); i++) cluster.fork();
+ * } else {
+ *   // ... start your server with `sync: cluster({ channel: "my-app" })`
+ * }
+ * ```
+ */
+declare function setupPrimaryCluster(): Promise<void>;
+/**
+ * Zero-dependency sync driver over Node.js [`cluster`](https://nodejs.org/api/cluster.html)
+ * worker IPC — bridges forked processes on a **single host** (e.g. Node
+ * `cluster` or PM2 `instances`) without a network backplane.
+ *
+ * This fills the gap left by {@link broadcastChannel}, whose registry is scoped
+ * to one process and silently won't sync across forks. For multiple hosts or
+ * regions you still want a networked driver such as {@link redis} or
+ * {@link pgsql}.
+ *
+ * Requires the relay to be installed in the primary via
+ * {@link setupPrimaryCluster}; the driver itself runs in the workers. Workers
+ * can't message each other directly, so all relay flows worker → primary →
+ * workers. Binary payloads are base64-encoded so they survive default JSON IPC
+ * serialization (no `serialization: "advanced"` needed).
+ *
+ * A `channel` name is required: it scopes the cluster and lets multiple apps
+ * share one process tree without bridging into each other.
+ *
+ * @example
+ * ```js
+ * import cluster from "node:cluster";
+ * import { setupPrimaryCluster, cluster as clusterSync } from "crossws/sync";
+ *
+ * if (cluster.isPrimary) {
+ *   setupPrimaryCluster();
+ *   cluster.fork();
+ *   cluster.fork();
+ * } else {
+ *   const ws = nodeAdapter({ hooks, sync: clusterSync({ channel: "my-app" }) });
+ *   // ... start the server
+ * }
+ * ```
+ */
+declare function cluster(opts: {
+  channel: string;
+}): SyncAdapter;
+declare function encodeEnvelope(id: string, msg: SyncMessage): string;
+declare function decodeEnvelope(raw: string): {
+  id: string;
+  msg: SyncMessage;
+} | undefined;
+/**
+ * Names of the built-in sync drivers exported from `crossws/sync`.
+ *
+ * Useful for automatic integration (e.g. Nitro) that needs to enumerate the
+ * available drivers without importing each one.
+ */
+declare const syncDrivers: readonly ["broadcastChannel", "redis", "pgsql", "cluster"];
+/** Name of a built-in sync driver (see {@link syncDrivers}). */
+type SyncDriverName = (typeof syncDrivers)[number];
+/**
+ * Map from a {@link SyncDriverName} to the options object its driver factory
+ * accepts — derived from the factory signatures so it stays in sync.
+ */
+type SyncDriverOptions = {
+  broadcastChannel: Parameters<typeof broadcastChannel>[0];
+  redis: Parameters<typeof redis>[0];
+  pgsql: Parameters<typeof pgsql>[0];
+  cluster: Parameters<typeof cluster>[0];
+};
 declare const kNodeInspect: unique symbol;
 interface PeerContext extends Record<string, unknown> {}
+interface WaitForDrainOptions {
+  /**
+   * Resolve once {@link Peer.bufferedAmount} drops to or below this many bytes.
+   *
+   * @default 0
+   */
+  threshold?: number;
+  /**
+   * Polling interval (in milliseconds) used to re-check {@link Peer.bufferedAmount}.
+   *
+   * @default 100
+   */
+  pollInterval?: number;
+  /**
+   * Abort the wait (e.g. `AbortSignal.timeout(ms)`). The returned promise
+   * rejects with the signal's `reason`.
+   */
+  signal?: AbortSignal;
+}
 interface AdapterInternal {
   ws: unknown;
   request: Request;
   namespace: string;
   peers?: Set<Peer>;
   context?: PeerContext;
+  /** Optional sync backplane used to relay publishes to other instances. */
+  sync?: SyncDriver;
 }
 declare abstract class Peer<Internal extends AdapterInternal = AdapterInternal> {
   #private;
@@ -40,6 +404,34 @@ declare abstract class Peer<Internal extends AdapterInternal = AdapterInternal>
   get peers(): Set<Peer>;
   /** All topics, this peer has been subscribed to. */
   get topics(): Set<string>;
+  /**
+   * Number of bytes queued for transmission but not yet flushed to the client.
+   *
+   * Use this to apply backpressure: pause sending while it grows past a high
+   * watermark and resume once it drops (or on the `drain` hook). Returns `0` on
+   * adapters that do not expose a buffer signal. Refer to the
+   * [compatibility table](https://crossws.h3.dev/guide/peer#compatibility).
+   */
+  get bufferedAmount(): number;
+  /**
+   * Wait until the send buffer drains to `threshold` bytes (default `0`).
+   *
+   * Resolves immediately when there is no backpressure (or on adapters that do
+   * not expose {@link Peer.bufferedAmount}). Otherwise it polls every
+   * `pollInterval` milliseconds until the buffer drains, also resolving early if
+   * the connection is no longer open so a send loop never hangs on a dropped
+   * client.
+   *
+   * ```ts
+   * for (const chunk of stream) {
+   *   peer.send(chunk);
+   *   if (peer.bufferedAmount > 1024 * 1024) {
+   *     await peer.waitForDrain({ threshold: 256 * 1024 });
+   *   }
+   * }
+   * ```
+   */
+  waitForDrain(opts?: WaitForDrainOptions): Promise<void>;
   abstract close(code?: number, reason?: string): void;
   /** Abruptly close the connection */
   terminate(): void;
@@ -51,8 +443,23 @@ declare abstract class Peer<Internal extends AdapterInternal = AdapterInternal>
   abstract send(data: unknown, options?: {
     compress?: boolean;
   }): number | void | undefined;
-  /** Send message to subscribes of topic */
-  abstract publish(topic: string, data: unknown, options?: {
+  /**
+   * Send a message to subscribers of a topic.
+   *
+   * When a sync backplane is configured, the message is also relayed to the
+   * other crossws instances so their subscribers receive it too.
+   */
+  publish(topic: string, data: unknown, options?: {
+    compress?: boolean;
+  }): void;
+  /**
+   * Adapter-specific, relay-free local fan-out to subscribers of a topic
+   * (excludes this peer). Implemented by each adapter; used both by
+   * {@link Peer.publish} and by the internal cross-instance delivery path.
+   *
+   * @internal Adapter extension point, not part of the stable public API.
+   */
+  abstract _publish(topic: string, data: unknown, options?: {
     compress?: boolean;
   }): void;
   toString(): string;
@@ -146,6 +553,14 @@ interface Hooks {
     code?: number;
     reason?: string;
   }) => MaybePromise<void>;
+  /**
+   * The send buffer has drained after backpressure, so it is safe to resume
+   * sending. Pair with {@link Peer.bufferedAmount} to throttle senders.
+   *
+   * **Note:** Only emitted by adapters that expose a drain signal. Refer to the
+   * [compatibility table](https://crossws.h3.dev/guide/peer#compatibility).
+   */
+  drain: (peer: Peer) => MaybePromise<void>;
   /** An error occurs */
   error: (peer: Peer, error: WSError) => MaybePromise<void>;
 }
@@ -155,12 +570,51 @@ interface AdapterInstance {
     compress?: boolean;
     namespace?: string;
   }) => void;
+  /**
+   * Gracefully shut the adapter down: close every connected peer (with the
+   * optional `code` / `reason`) and tear down the {@link AdapterInstance.sync}
+   * backplane. Any underlying server you created (e.g. an `http.Server` or a
+   * `WebSocketServer` passed via options) stays yours to close.
+   */
+  readonly close: (code?: number, reason?: string) => Promise<void>;
+  /**
+   * Sync backplane driver, present when an adapter is created with `sync`.
+   *
+   * Closed automatically by {@link AdapterInstance.close}; it leaves any
+   * user-owned client (Redis/Postgres) connected.
+   */
+  readonly sync?: SyncDriver;
+}
+/** Context passed to {@link AdapterOptions.onError} describing what failed. */
+interface SyncErrorContext {
+  /**
+   * Which backplane operation failed:
+   * - `subscribe` — the initial subscription to the backplane.
+   * - `publish` — relaying a local publish out to the other instances.
+   * - `delivery` — fanning an inbound remote message out to local subscribers.
+   */
+  stage: "subscribe" | "publish" | "delivery";
 }
 interface AdapterOptions {
   resolve?: ResolveHooks;
   getNamespace?: (request: Request) => string;
   hooks?: Partial<Hooks>;
+  /**
+   * Optional sync backplane to relay pub/sub between multiple crossws
+   * instances (e.g. across regions/processes). Opt-in: when absent, pub/sub
+   * stays local to the instance, exactly as before.
+   */
+  sync?: SyncAdapter;
+  /**
+   * Called when a {@link AdapterOptions.sync} backplane operation fails.
+   *
+   * Relay is fire-and-forget by design — a flaky backplane never throws into
+   * your `publish` call or crashes the process — so this callback is the only
+   * way to observe a degraded backplane (for logging, metrics or alerting).
+   * Defaults to `console.error`. Has no effect without `sync`.
+   */
+  onError?: (error: unknown, context: SyncErrorContext) => void;
 }
 type Adapter<AdapterT extends AdapterInstance = AdapterInstance, Options extends AdapterOptions = AdapterOptions> = (options?: Options) => AdapterT;
 declare function defineWebSocketAdapter<AdapterT extends AdapterInstance = AdapterInstance, Options extends AdapterOptions = AdapterOptions>(factory: Adapter<AdapterT, Options>): Adapter<AdapterT, Options>;
-export { Adapter, AdapterInstance, AdapterInternal, AdapterOptions, Hooks, Message, Peer, PeerContext, ResolveHooks, WSError, defineHooks, defineWebSocketAdapter };
+export { Adapter, AdapterInstance, AdapterInternal, AdapterOptions, Hooks, Message, Peer, PeerContext, PostgresClientLike, RedisClientLike, ResolveHooks, SyncAdapter, SyncDriver, SyncDriverName, SyncDriverOptions, SyncErrorContext, SyncMessage, WSError, WaitForDrainOptions, broadcastChannel, cluster, decodeEnvelope, defineHooks, defineWebSocketAdapter, encodeEnvelope, pgsql, redis, setupPrimaryCluster, syncDrivers };

package/dist/_chunks/adapter.mjs

@@ -59,21 +59,98 @@ var AdapterHookable = class {
 function defineHooks(hooks) {
 	return hooks;
 }
-function adapterUtils(globalPeers) {
+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 serializeMessage(val) {
+	const data = toBufferLike(val);
+	if (typeof data === "string") return data;
+	return data instanceof Uint8Array ? data : new Uint8Array(data);
+}
+function toString(val) {
+	if (typeof val === "string") return val;
+	const data = toBufferLike(val);
+	if (typeof data === "string") return data;
+	let binary = "";
+	for (const byte of new Uint8Array(data)) binary += String.fromCharCode(byte);
+	return `data:application/octet-stream;base64,${btoa(binary)}`;
+}
+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;
+}
+function adapterUtils(globalPeers, options, caps) {
+	const localPublish = (topic, message, pubOptions) => {
+		for (const peers of pubOptions?.namespace ? [globalPeers.get(pubOptions.namespace) || []] : globalPeers.values()) {
+			let firstPeerWithTopic;
+			for (const peer of peers) if (peer.topics.has(topic)) {
+				firstPeerWithTopic = peer;
+				break;
+			}
+			if (firstPeerWithTopic) {
+				firstPeerWithTopic.send(message, pubOptions);
+				firstPeerWithTopic._publish(topic, message, pubOptions);
+				if (caps?.nativePubSub && !pubOptions?.namespace) break;
+			}
+		}
+	};
+	let sync;
+	if (options?.sync) {
+		const report = (stage, error) => {
+			if (options.onError) options.onError(error, { stage });
+			else console.error(`[crossws] sync ${stage} failed:`, error);
+		};
+		const driver = options.sync({ id: crypto.randomUUID() });
+		const deliver = (msg) => {
+			try {
+				localPublish(msg.topic, msg.data, { namespace: msg.namespace || void 0 });
+			} catch (error) {
+				report("delivery", error);
+			}
+		};
+		try {
+			Promise.resolve(driver.subscribe(deliver)).catch((error) => report("subscribe", error));
+		} catch (error) {
+			report("subscribe", error);
+		}
+		sync = {
+			subscribe: (deliver) => driver.subscribe(deliver),
+			publish: (msg) => {
+				try {
+					return Promise.resolve(driver.publish(msg)).catch((e) => report("publish", e));
+				} catch (error) {
+					report("publish", error);
+				}
+			},
+			close: driver.close ? () => driver.close() : void 0
+		};
+	}
 	return {
 		peers: globalPeers,
+		sync,
 		publish(topic, message, options) {
-			for (const peers of options?.namespace ? [globalPeers.get(options.namespace) || []] : globalPeers.values()) {
-				let firstPeerWithTopic;
-				for (const peer of peers) if (peer.topics.has(topic)) {
-					firstPeerWithTopic = peer;
-					break;
-				}
-				if (firstPeerWithTopic) {
-					firstPeerWithTopic.send(message, options);
-					firstPeerWithTopic.publish(topic, message, options);
-				}
-			}
+			localPublish(topic, message, options);
+			sync?.publish({
+				namespace: options?.namespace || "",
+				topic,
+				data: serializeMessage(message)
+			});
+		},
+		async close(code, reason) {
+			for (const peers of globalPeers.values()) for (const peer of peers) peer.close(code, reason);
+			await sync?.close?.();
 		}
 	};
 }
@@ -89,4 +166,4 @@ function getPeers(globalPeers, namespace) {
 function defineWebSocketAdapter(factory) {
 	return factory;
 }
-export { AdapterHookable, adapterUtils, defineHooks, defineWebSocketAdapter, getPeers };
+export { AdapterHookable, adapterUtils, defineHooks, defineWebSocketAdapter, getPeers, kNodeInspect, serializeMessage, toBufferLike, toString };

package/dist/_chunks/bun.d.mts

@@ -1,4 +1,4 @@
-import { Adapter, AdapterInstance, AdapterOptions, Peer, PeerContext } 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;

package/dist/_chunks/libs/ws.mjs

@@ -1,4 +1,26 @@
-import { __commonJSMin, __require, __toESM } 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",