crossws 0.4.5 → 0.4.7

package/adapters/vercel.d.ts

@@ -0,0 +1,2 @@
+export * from "../dist/adapters/vercel.mjs";
+export { default } from "../dist/adapters/vercel.mjs";

package/dist/THIRD-PARTY-LICENSES.md

@@ -8,7 +8,7 @@ MIT
 ## ws
 
 License: MIT
-By: Einar Otto Stangvik
+By: Einar Otto Stangvik <einaros@gmail.com> (http://2x.io)
 Repository: https://github.com/websockets/ws
 
 > Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>

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());
@@ -77,4 +77,4 @@ const StubRequest = /* @__PURE__ */ (() => {
 	Object.setPrototypeOf(StubRequest.prototype, globalThis.Request.prototype);
 	return StubRequest;
 })();
-export { StubRequest as t };
+export { StubRequest };

package/dist/_chunks/_types.d.mts

@@ -1,10 +1,10 @@
-import { a as Hooks } from "./adapter.mjs";
-import { n as BunOptions } from "./bun.mjs";
-import { n as BunnyOptions } from "./bunny.mjs";
-import { n as CloudflareOptions } from "./cloudflare.mjs";
-import { n as DenoOptions } from "./deno.mjs";
-import { n as NodeOptions } from "./node.mjs";
-import { n as SSEOptions } from "./sse.mjs";
+import { Hooks } from "./adapter.mjs";
+import { BunOptions } from "./bun.mjs";
+import { BunnyOptions } from "./bunny.mjs";
+import { CloudflareOptions } from "./cloudflare.mjs";
+import { DenoOptions } from "./deno.mjs";
+import { NodeOptions } from "./node.mjs";
+import { SSEOptions } from "./sse.mjs";
 import { Server, ServerOptions, ServerPlugin, ServerRequest } from "srvx";
 type WSOptions = Partial<Hooks> & {
   resolve?: (req: ServerRequest) => Partial<Hooks> | Promise<Partial<Hooks>>;
@@ -20,4 +20,4 @@ type WSOptions = Partial<Hooks> & {
 type ServerWithWSOptions = ServerOptions & {
   websocket?: WSOptions;
 };
-export { WSOptions as n, ServerWithWSOptions as t };
+export { ServerWithWSOptions, WSOptions };

package/dist/_chunks/adapter.d.mts

@@ -1,15 +1,379 @@
-import { a as WebSocket } from "./web.mjs";
+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 { Hooks as a, Message as c, PeerContext as d, WSError as f, defineWebSocketAdapter as i, AdapterInternal as l, AdapterInstance as n, ResolveHooks as o, AdapterOptions as r, defineHooks as s, Adapter as t, Peer as u };
+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 { defineHooks as a, AdapterHookable as i, defineWebSocketAdapter as n, getPeers as r, adapterUtils as t };
+export { AdapterHookable, adapterUtils, defineHooks, defineWebSocketAdapter, getPeers, kNodeInspect, serializeMessage, toBufferLike, toString };