@hedystia/ws 2.3.1 → 2.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hedystia/ws",
-  "version": "2.3.1",
+  "version": "2.3.2",
   "description": "Universal WebSocket primitives for Hedystia (Bun, Node.js, Deno)",
   "homepage": "https://docs.hedystia.com/plugins/websocket",
   "devDependencies": {

package/.turbo/turbo-build.log

@@ -1,50 +0,0 @@
-$ tsdown --config-loader unrun
-ℹ tsdown v0.22.0 powered by rolldown v1.0.0
-ℹ config file: /home/runner/actions-runner/_work/Hedystia/Hedystia/Packages/websocket/tsdown.config.ts (unrun)
-ℹ entry: src/index.ts, src/client.ts, src/server.ts
-ℹ tsconfig: tsconfig.json
-ℹ Build start
-ℹ [CJS] dist/server.cjs        7.36 kB │ gzip: 2.69 kB
-ℹ [CJS] dist/client.cjs        4.12 kB │ gzip: 1.53 kB
-ℹ [CJS] dist/index.cjs         0.87 kB │ gzip: 0.34 kB
-ℹ [CJS] dist/server.cjs.map   12.54 kB │ gzip: 4.06 kB
-ℹ [CJS] dist/client.cjs.map    5.86 kB │ gzip: 2.05 kB
-ℹ [CJS] dist/runtime.cjs.map   2.06 kB │ gzip: 0.78 kB
-ℹ [CJS] dist/runtime.cjs       1.36 kB │ gzip: 0.55 kB
-ℹ [CJS] dist/index.cjs.map     0.71 kB │ gzip: 0.33 kB
-ℹ [CJS] 8 files, total: 34.86 kB
-[PLUGIN_TIMINGS] Warning: Your build spent significant time in plugin `tsdown:report`. See https://rolldown.rs/options/checks#plugintimings for more details.
-
-ℹ [CJS] dist/server.d.cts   4.05 kB │ gzip: 1.65 kB
-ℹ [CJS] dist/client.d.cts   3.80 kB │ gzip: 1.40 kB
-ℹ [CJS] dist/index.d.cts    0.73 kB │ gzip: 0.27 kB
-ℹ [CJS] dist/types.d.cts    7.25 kB │ gzip: 2.64 kB
-ℹ [CJS] dist/runtime.d.cts  1.13 kB │ gzip: 0.48 kB
-ℹ [CJS] 5 files, total: 16.96 kB
-[PLUGIN_TIMINGS] Warning: Your build spent significant time in plugins. Here is a breakdown:
-  - rolldown-plugin-dts:generate (63%)
-  - tsdown:deps (28%)
-See https://rolldown.rs/options/checks#plugintimings for more details.
-
-✔ Build complete in 4736ms
-ℹ [ESM] dist/server.mjs                       7.30 kB │ gzip: 2.64 kB
-ℹ [ESM] dist/client.mjs                       4.04 kB │ gzip: 1.50 kB
-ℹ [ESM] dist/index.mjs                        0.47 kB │ gzip: 0.23 kB
-ℹ [ESM] dist/server.mjs.map                  12.53 kB │ gzip: 4.05 kB
-ℹ [ESM] dist/client.mjs.map                   5.86 kB │ gzip: 2.05 kB
-ℹ [ESM] dist/runtime.mjs.map                  2.06 kB │ gzip: 0.78 kB
-ℹ [ESM] dist/runtime.mjs                      1.27 kB │ gzip: 0.53 kB
-ℹ [ESM] dist/index.mjs.map                    0.68 kB │ gzip: 0.32 kB
-ℹ [ESM] dist/_virtual/_rolldown/runtime.mjs   0.18 kB │ gzip: 0.15 kB
-ℹ [ESM] dist/server.d.mts                     4.05 kB │ gzip: 1.65 kB
-ℹ [ESM] dist/client.d.mts                     3.80 kB │ gzip: 1.40 kB
-ℹ [ESM] dist/index.d.mts                      0.73 kB │ gzip: 0.27 kB
-ℹ [ESM] dist/types.d.mts                      7.25 kB │ gzip: 2.64 kB
-ℹ [ESM] dist/runtime.d.mts                    1.13 kB │ gzip: 0.48 kB
-ℹ [ESM] 14 files, total: 51.34 kB
-[PLUGIN_TIMINGS] Warning: Your build spent significant time in plugins. Here is a breakdown:
-  - tsdown:deps (51%)
-  - rolldown-plugin-dts:generate (39%)
-See https://rolldown.rs/options/checks#plugintimings for more details.
-
-✔ Build complete in 4846ms

package/src/client.ts

@@ -1,161 +0,0 @@
-import type { ClientWebSocketOptions } from "./types";
-
-export type { ClientWebSocketOptions } from "./types";
-
-/**
- * Resolve the best `WebSocket` constructor for the current runtime.
- *
- * @remarks
- * - Bun, Deno, browsers and Node ≥ 22 expose `globalThis.WebSocket`.
- * - Older Node falls back to the [`ws`](https://github.com/websockets/ws)
- *   package, which mirrors the WHATWG `WebSocket` API.
- *
- * @returns A `WebSocket` constructor compatible with the WHATWG interface.
- *
- * @example
- * ```ts
- * import { resolveWebSocket } from "@hedystia/ws/client";
- *
- * const WS = resolveWebSocket();
- * const socket = new WS("ws://localhost:3000");
- * ```
- */
-export function resolveWebSocket(): typeof WebSocket {
-  if (typeof globalThis !== "undefined" && (globalThis as any).WebSocket) {
-    return (globalThis as any).WebSocket as typeof WebSocket;
-  }
-  const mod = require("ws");
-  return (mod.WebSocket ?? mod) as typeof WebSocket;
-}
-
-/**
- * Create a `WebSocket` instance using the best available implementation
- * for the current runtime.
- *
- * @remarks
- * Custom request headers are honoured on Node via the `ws` package; on
- * runtimes that ship a WHATWG-compliant global `WebSocket` (Bun, Deno,
- * browsers, Node ≥ 22) headers are ignored — matching standard semantics.
- *
- * @param url - Absolute WebSocket URL (`ws://` or `wss://`)
- * @param options - Optional protocols / headers
- * @returns A connected (or connecting) `WebSocket` instance.
- *
- * @example
- * ```ts
- * import { createWebSocket } from "@hedystia/ws/client";
- *
- * const ws = createWebSocket("ws://localhost:3000", {
- *   protocols: "v1",
- *   headers: { authorization: "Bearer ..." },
- * });
- *
- * ws.onopen = () => ws.send("hi");
- * ws.onmessage = (event) => console.log(event.data);
- * ```
- */
-export function createWebSocket(url: string, options?: ClientWebSocketOptions): WebSocket {
-  const Ctor = resolveWebSocket();
-  const isWhatwg =
-    typeof globalThis !== "undefined" && (globalThis as any).WebSocket === (Ctor as any);
-
-  if (isWhatwg) {
-    return options?.protocols ? new Ctor(url, options.protocols as any) : new Ctor(url);
-  }
-
-  const init: any = {};
-  if (options?.headers) {
-    init.headers = options.headers;
-  }
-  return new (Ctor as any)(url, options?.protocols, init);
-}
-
-/**
- * Lightweight runtime-agnostic wrapper that mirrors a small, predictable
- * subset of the WHATWG WebSocket interface.
- *
- * @remarks
- * Useful for higher-level code that wants to assign event handlers by
- * property (`socket.onmessage = ...`) without caring whether the underlying
- * implementation comes from `globalThis.WebSocket` or the `ws` package.
- *
- * @example
- * ```ts
- * import { WebSocketClient } from "@hedystia/ws/client";
- *
- * const client = new WebSocketClient("ws://localhost:3000");
- * client.onopen = () => client.send("hello");
- * client.onmessage = (event) => console.log(event.data);
- * ```
- */
-export class WebSocketClient {
-  /**
-   * Underlying WebSocket instance produced by {@link createWebSocket}.
-   *
-   * @readonly
-   */
-  readonly socket: WebSocket;
-
-  /**
-   * Create a new client and immediately initiate the connection.
-   *
-   * @param url - Absolute WebSocket URL (`ws://` or `wss://`)
-   * @param options - Optional protocols / headers, see {@link ClientWebSocketOptions}
-   */
-  constructor(url: string, options?: ClientWebSocketOptions) {
-    this.socket = createWebSocket(url, options);
-  }
-
-  /**
-   * Current connection state, mirroring {@link WebSocket.readyState}.
-   *
-   * @returns `0` connecting, `1` open, `2` closing, `3` closed.
-   */
-  get readyState(): number {
-    return this.socket.readyState;
-  }
-
-  /**
-   * Send a payload to the server.
-   *
-   * @param data - WHATWG-compatible payload
-   */
-  send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void {
-    this.socket.send(data as any);
-  }
-
-  /**
-   * Close the underlying socket.
-   *
-   * @param code - Close code (defaults to 1000)
-   * @param reason - Optional human-readable reason
-   */
-  close(code?: number, reason?: string): void {
-    this.socket.close(code, reason);
-  }
-
-  /**
-   * Assign the open-event listener.
-   */
-  set onopen(cb: ((ev: Event) => void) | null) {
-    (this.socket as any).onopen = cb;
-  }
-  /**
-   * Assign the message-event listener.
-   */
-  set onmessage(cb: ((ev: MessageEvent) => void) | null) {
-    (this.socket as any).onmessage = cb;
-  }
-  /**
-   * Assign the close-event listener.
-   */
-  set onclose(cb: ((ev: CloseEvent) => void) | null) {
-    (this.socket as any).onclose = cb;
-  }
-  /**
-   * Assign the error-event listener.
-   */
-  set onerror(cb: ((ev: Event) => void) | null) {
-    (this.socket as any).onerror = cb;
-  }
-}

package/src/index.ts

@@ -1,19 +0,0 @@
-export type { ClientWebSocketOptions } from "./client";
-export { createWebSocket, resolveWebSocket, WebSocketClient } from "./client";
-export type { Runtime } from "./runtime";
-export { detectRuntime, isBrowser, isBun, isDeno, isNode } from "./runtime";
-export type {
-  ServerWebSocket,
-  UpgradeOptions,
-  UpgradeRequest,
-  WebSocketHandlers,
-  WebSocketServerOptions,
-  WSData,
-  WSMessage,
-} from "./server";
-
-import { WebSocketServer } from "./server";
-
-export { WebSocketServer };
-
-export default WebSocketServer;

package/src/runtime.ts

@@ -1,66 +0,0 @@
-/**
- * String identifier of the JavaScript runtime hosting the current process.
- */
-export type Runtime = "bun" | "node" | "deno" | "browser" | "unknown";
-
-/**
- * Detect the host runtime by probing well-known globals.
- *
- * @returns A {@link Runtime} discriminator for the active environment.
- *
- * @example
- * ```ts
- * import { detectRuntime } from "@hedystia/ws";
- *
- * if (detectRuntime() === "bun") {
- *   // ...use Bun-specific APIs
- * }
- * ```
- */
-export function detectRuntime(): Runtime {
-  if (typeof globalThis === "undefined") {
-    return "unknown";
-  }
-  const g = globalThis as any;
-  if (g.Bun?.serve) {
-    return "bun";
-  }
-  if (g.Deno) {
-    return "deno";
-  }
-  if (g.process?.versions?.node) {
-    return "node";
-  }
-  if (typeof g.window !== "undefined" && typeof g.document !== "undefined") {
-    return "browser";
-  }
-  return "unknown";
-}
-
-/**
- * Convenience predicate.
- *
- * @returns `true` when running on Bun.
- */
-export const isBun = (): boolean => detectRuntime() === "bun";
-
-/**
- * Convenience predicate.
- *
- * @returns `true` when running on Node.js.
- */
-export const isNode = (): boolean => detectRuntime() === "node";
-
-/**
- * Convenience predicate.
- *
- * @returns `true` when running on Deno.
- */
-export const isDeno = (): boolean => detectRuntime() === "deno";
-
-/**
- * Convenience predicate.
- *
- * @returns `true` when running inside a browser-like environment.
- */
-export const isBrowser = (): boolean => detectRuntime() === "browser";

package/src/server.ts

@@ -1,313 +0,0 @@
-import { type WebSocket as NodeWebSocket, WebSocketServer as WSServer } from "ws";
-
-import type {
-  ServerWebSocket,
-  UpgradeOptions,
-  UpgradeRequest,
-  WebSocketHandlers,
-  WebSocketServerOptions,
-  WSData,
-  WSMessage,
-} from "./types";
-
-export type {
-  ServerWebSocket,
-  UpgradeOptions,
-  UpgradeRequest,
-  WebSocketHandlers,
-  WebSocketServerOptions,
-  WSData,
-  WSMessage,
-} from "./types";
-
-/**
- * Runtime-agnostic WebSocket server.
- *
- * @remarks
- * Internally backed by the [`ws`](https://github.com/websockets/ws) package
- * which runs on Bun, Node.js and Deno (via `npm:` specifiers). The class
- * does **not** create or own an HTTP server — callers feed it raw upgrade
- * tuples coming from any HTTP runtime they prefer.
- *
- * It implements topic-based pub/sub on top of the per-connection
- * `subscribe` / `unsubscribe` / `publish` API expected by Hedystia,
- * matching the shape of `Bun.ServerWebSocket`.
- *
- * @typeParam Data - Shape of the user-attached `data` field
- *
- * @example
- * ```ts
- * import { createServer } from "node:http";
- * import { WebSocketServer } from "@hedystia/ws/server";
- *
- * const wss = new WebSocketServer({
- *   open: (ws) => ws.send("welcome"),
- *   message: (ws, msg) => ws.publish("room", msg),
- * });
- *
- * const http = createServer((_req, res) => res.end("ok"));
- * http.on("upgrade", (req, socket, head) => {
- *   wss.upgrade({ rawRequest: req, socket, head }, { data: { user: "anon" } });
- * });
- * http.listen(3000);
- * ```
- */
-export class WebSocketServer<Data extends WSData = WSData> {
-  private readonly handlers: WebSocketHandlers<Data>;
-  private readonly wss: WSServer;
-  private readonly topics = new Map<string, Set<NodeWebSocket>>();
-  private readonly socketTopics = new WeakMap<NodeWebSocket, Set<string>>();
-  private readonly allSockets = new Set<NodeWebSocket>();
-
-  /**
-   * Build a new WebSocket server.
-   *
-   * @param handlers - Lifecycle handlers ({@link WebSocketHandlers})
-   * @param options - Optional behavioural overrides ({@link WebSocketServerOptions})
-   *
-   * @example
-   * ```ts
-   * const wss = new WebSocketServer(
-   *   { message: (ws, msg) => ws.send(msg) },
-   *   { maxPayload: 1024 * 1024 },
-   * );
-   * ```
-   */
-  constructor(handlers: WebSocketHandlers<Data>, options: WebSocketServerOptions = {}) {
-    this.handlers = handlers;
-    this.wss = new WSServer({
-      noServer: true,
-      maxPayload: options.maxPayload,
-      perMessageDeflate: (options.perMessageDeflate ?? false) as any,
-    });
-  }
-
-  /**
-   * Upgrade a raw HTTP upgrade tuple to a WebSocket connection.
-   *
-   * @remarks
-   * The returned promise resolves to the connected {@link ServerWebSocket}
-   * once the handshake completes; rejection means the handshake failed.
-   *
-   * @param req - Upgrade tuple emitted by `node:http`'s `'upgrade'` event
-   * @param options - Optional initial `data` for the new connection
-   * @returns Promise that resolves with the established socket wrapper
-   *
-   * @throws {Error} When the underlying handshake throws synchronously
-   *
-   * @example
-   * ```ts
-   * http.on("upgrade", async (req, socket, head) => {
-   *   try {
-   *     await wss.upgrade({ rawRequest: req, socket, head });
-   *   } catch (err) {
-   *     console.error("Upgrade failed", err);
-   *     socket.destroy();
-   *   }
-   * });
-   * ```
-   */
-  upgrade(req: UpgradeRequest, options?: UpgradeOptions<Data>): Promise<ServerWebSocket<Data>> {
-    return new Promise((resolve, reject) => {
-      try {
-        this.wss.handleUpgrade(req.rawRequest, req.socket, req.head as Buffer, (socket) => {
-          const data = (options?.data ?? ({} as Data)) as Data;
-          const wrapped = this.wrap(socket, data, req.rawRequest);
-          this.bind(socket, wrapped);
-          resolve(wrapped);
-        });
-      } catch (err) {
-        reject(err);
-      }
-    });
-  }
-
-  /**
-   * Publish a message to all sockets currently subscribed to `topic`.
-   *
-   * @param topic - Topic name
-   * @param message - Payload to broadcast
-   * @param _compress - Reserved for future use; ignored under the `ws` adapter
-   * @returns Number of sockets that received the message.
-   *
-   * @example
-   * ```ts
-   * wss.publish("room", JSON.stringify({ kind: "ping" }));
-   * ```
-   */
-  publish(topic: string, message: WSMessage, _compress?: boolean): number {
-    const set = this.topics.get(topic);
-    if (!set || set.size === 0) {
-      return 0;
-    }
-    const payload = toSendable(message);
-    let count = 0;
-    for (const socket of set) {
-      if (socket.readyState === 1) {
-        socket.send(payload);
-        count++;
-      }
-    }
-    return count;
-  }
-
-  /**
-   * Close the server and optionally terminate all live sockets.
-   *
-   * @param closeActiveConnections - When `true`, calls `socket.terminate()`
-   *  on every live connection before shutting down.
-   */
-  close(closeActiveConnections = false): void {
-    if (closeActiveConnections) {
-      for (const socket of this.allSockets) {
-        try {
-          socket.terminate();
-        } catch {
-          /* ignore */
-        }
-      }
-      this.allSockets.clear();
-    }
-    this.wss.close();
-  }
-
-  /**
-   * Attach the per-socket lifecycle listeners (`message`, `close`, `error`).
-   *
-   * @internal
-   */
-  private bind(socket: NodeWebSocket, wrapped: ServerWebSocket<Data>): void {
-    this.allSockets.add(socket);
-
-    if (this.handlers.open) {
-      Promise.resolve(this.handlers.open(wrapped)).catch((err) =>
-        console.error("[ws] open handler error:", err),
-      );
-    }
-
-    socket.on("message", (raw, isBinary) => {
-      const message: WSMessage = isBinary
-        ? raw instanceof ArrayBuffer
-          ? new Uint8Array(raw)
-          : Array.isArray(raw)
-            ? Buffer.concat(raw)
-            : (raw as Buffer)
-        : raw.toString();
-      Promise.resolve(this.handlers.message(wrapped, message)).catch((err) =>
-        console.error("[ws] message handler error:", err),
-      );
-    });
-
-    socket.on("close", (code, reason) => {
-      const owned = this.socketTopics.get(socket);
-      if (owned) {
-        for (const topic of owned) {
-          this.topics.get(topic)?.delete(socket);
-        }
-        this.socketTopics.delete(socket);
-      }
-      this.allSockets.delete(socket);
-      if (this.handlers.close) {
-        Promise.resolve(this.handlers.close(wrapped, code, reason?.toString() ?? "")).catch((err) =>
-          console.error("[ws] close handler error:", err),
-        );
-      }
-    });
-
-    socket.on("error", (err) => {
-      if (this.handlers.error) {
-        Promise.resolve(this.handlers.error(wrapped, err)).catch((e) =>
-          console.error("[ws] error handler error:", e),
-        );
-      }
-    });
-  }
-
-  /**
-   * Build the {@link ServerWebSocket} wrapper exposed to user handlers.
-   *
-   * @internal
-   */
-  private wrap(socket: NodeWebSocket, data: Data, rawReq: any): ServerWebSocket<Data> {
-    const remoteAddress: string =
-      (rawReq?.socket?.remoteAddress as string) ||
-      (rawReq?.headers?.["x-forwarded-for"] as string) ||
-      "";
-
-    const subscribe = (topic: string) => {
-      let set = this.topics.get(topic);
-      if (!set) {
-        set = new Set();
-        this.topics.set(topic, set);
-      }
-      set.add(socket);
-      let owned = this.socketTopics.get(socket);
-      if (!owned) {
-        owned = new Set();
-        this.socketTopics.set(socket, owned);
-      }
-      owned.add(topic);
-    };
-
-    const unsubscribe = (topic: string) => {
-      this.topics.get(topic)?.delete(socket);
-      this.socketTopics.get(socket)?.delete(topic);
-    };
-
-    const publishToPeers = (topic: string, message: WSMessage) => {
-      const set = this.topics.get(topic);
-      if (!set) {
-        return;
-      }
-      const payload = toSendable(message);
-      for (const peer of set) {
-        if (peer !== socket && peer.readyState === 1) {
-          peer.send(payload);
-        }
-      }
-    };
-
-    const wrapper: ServerWebSocket<Data> = {
-      data,
-      get readyState() {
-        return socket.readyState;
-      },
-      remoteAddress,
-      send: (message, _compress) => {
-        const payload = toSendable(message);
-        socket.send(payload);
-        return typeof payload === "string"
-          ? Buffer.byteLength(payload)
-          : (payload as Buffer | Uint8Array).byteLength;
-      },
-      close: (code, reason) => {
-        socket.close(code, reason);
-      },
-      subscribe,
-      unsubscribe,
-      publish: publishToPeers,
-      isSubscribed: (topic) => !!this.socketTopics.get(socket)?.has(topic),
-      cork: (cb) => cb(wrapper),
-    };
-
-    return wrapper;
-  }
-}
-
-/**
- * Coerce a {@link WSMessage} into something the `ws` package can transmit.
- *
- * @param message - User-supplied payload
- * @returns A `string`, `Buffer` or `Uint8Array` ready to be sent
- *
- * @internal
- */
-function toSendable(message: WSMessage): string | Buffer | Uint8Array {
-  if (typeof message === "string") {
-    return message;
-  }
-  if (message instanceof ArrayBuffer) {
-    return Buffer.from(message);
-  }
-  return message;
-}

package/src/types.ts

@@ -1,226 +0,0 @@
-/**
- * Payload accepted by every `send`/`publish` method.
- *
- * @remarks
- * Matches the WHATWG `WebSocket.send` signature plus the `Uint8Array`
- * convenience accepted by Bun and the `ws` package.
- */
-export type WSMessage = string | ArrayBuffer | Uint8Array;
-
-/**
- * Bag of arbitrary, user-supplied state attached to a connection on
- * upgrade and exposed to handlers as `ws.data`.
- *
- * @typeParam K - String key
- * @typeParam V - Stored value
- */
-export type WSData = Record<string, any>;
-
-/**
- * The per-connection wrapper passed to every handler.
- *
- * @remarks
- * The interface intentionally mirrors `Bun.ServerWebSocket` so that the
- * same handler code works on Bun (native) and on Node.js (via
- * {@link WebSocketServer}). Topic-based pub/sub is implemented in
- * user-space when running outside Bun.
- *
- * @typeParam Data - Shape of the user-attached `data` field
- *
- * @example
- * ```ts
- * const handlers: WebSocketHandlers<{ user: string }> = {
- *   open: (ws) => ws.subscribe(`user:${ws.data.user}`),
- *   message: (ws, msg) => ws.publish(`user:${ws.data.user}`, msg),
- * };
- * ```
- */
-export interface ServerWebSocket<Data extends WSData = WSData> {
-  /** User-supplied state attached to the socket on upgrade. */
-  readonly data: Data;
-  /** Standard WHATWG ready-state (`0` connecting, `1` open, `2` closing, `3` closed). */
-  readonly readyState: number;
-  /** Remote IP, taken from `X-Forwarded-For` when present. */
-  readonly remoteAddress: string;
-  /**
-   * Send a message to this socket only.
-   *
-   * @param message - Payload to send
-   * @param compress - Whether to compress (honoured on Bun, ignored on Node)
-   * @returns Number of bytes written (best-effort on Node)
-   */
-  send(message: WSMessage, compress?: boolean): number;
-  /**
-   * Close the connection.
-   *
-   * @param code - Close code (defaults to 1000)
-   * @param reason - Optional human-readable reason
-   */
-  close(code?: number, reason?: string): void;
-  /**
-   * Subscribe this socket to a topic so it receives subsequent
-   * {@link ServerWebSocket.publish | publish} or
-   * {@link WebSocketServer.publish | server.publish} broadcasts.
-   *
-   * @param topic - Topic name
-   */
-  subscribe(topic: string): void;
-  /**
-   * Unsubscribe this socket from a previously joined topic.
-   *
-   * @param topic - Topic name
-   */
-  unsubscribe(topic: string): void;
-  /**
-   * Broadcast a message to every other socket subscribed to `topic`.
-   *
-   * @remarks
-   * The sender is excluded by default — matching Bun's default behaviour.
-   *
-   * @param topic - Topic name
-   * @param message - Payload to broadcast
-   * @param compress - Whether to compress (honoured on Bun, ignored on Node)
-   */
-  publish(topic: string, message: WSMessage, compress?: boolean): void;
-  /**
-   * Check whether this socket is currently subscribed to `topic`.
-   *
-   * @param topic - Topic name
-   * @returns `true` when subscribed
-   */
-  isSubscribed(topic: string): boolean;
-  /**
-   * Batch multiple writes inside `cb`.
-   *
-   * @remarks
-   * On Bun this corresponds to `corked()`; on Node it is a no-op alias
-   * that simply invokes `cb(this)` synchronously.
-   *
-   * @param cb - Function invoked with the same socket
-   */
-  cork(cb: (ws: ServerWebSocket<Data>) => void): void;
-}
-
-/**
- * Bun-style compression dictionary identifier.
- *
- * @remarks
- * Used by Bun's `perMessageDeflate` configuration. The `@hedystia/ws`
- * server forwards the value to the underlying implementation, which only
- * Bun interprets natively; Node falls back to defaults when the value is
- * not a recognised `ws` shape.
- */
-export type Compressor =
-  | "disable"
-  | "shared"
-  | "dedicated"
-  | "3KB"
-  | "4KB"
-  | "8KB"
-  | "16KB"
-  | "32KB"
-  | "64KB"
-  | "128KB"
-  | "256KB";
-
-/**
- * Per-message deflate configuration.
- *
- * @remarks
- * Accepts either a boolean (`true` enables defaults, `false` disables it)
- * or a free-form object whose shape is forwarded verbatim to the underlying
- * implementation. Bun's {@link Compressor} strings (`"3KB"`, `"shared"`, …)
- * and the [`ws`](https://github.com/websockets/ws) package's
- * `PerMessageDeflateOptions` (`zlibDeflateOptions`, `threshold`, …) are
- * both supported by simply matching whatever the runtime expects.
- */
-export type PerMessageDeflate =
-  | boolean
-  | (Record<string, any> & {
-      compress?: boolean | Compressor;
-      decompress?: boolean | Compressor;
-    });
-
-/**
- * Construction options for {@link WebSocketServer}.
- */
-export interface WebSocketServerOptions {
-  /** Maximum allowed payload in bytes. Defaults to the underlying library's default. */
-  maxPayload?: number;
-  /** Per-message deflate configuration. */
-  perMessageDeflate?: PerMessageDeflate;
-}
-
-/**
- * Lifecycle handlers passed to {@link WebSocketServer}.
- *
- * @typeParam Data - Shape of the user-attached `data` field
- */
-export interface WebSocketHandlers<Data extends WSData = WSData> {
-  /** Called for every inbound message. */
-  message: (ws: ServerWebSocket<Data>, message: WSMessage) => void | Promise<void>;
-  /** Called once the handshake completes successfully. */
-  open?: (ws: ServerWebSocket<Data>) => void | Promise<void>;
-  /** Called after the connection closes (clean or otherwise). */
-  close?: (ws: ServerWebSocket<Data>, code: number, reason: string) => void | Promise<void>;
-  /** Called when the underlying transport raises an error. */
-  error?: (ws: ServerWebSocket<Data>, error: Error) => void | Promise<void>;
-  /**
-   * Called when back-pressure is relieved.
-   *
-   * @remarks
-   * Only fired by Bun; Node-backed servers never invoke it.
-   */
-  drain?: (ws: ServerWebSocket<Data>) => void | Promise<void>;
-}
-
-/**
- * Options accepted by {@link createWebSocket}.
- */
-export interface ClientWebSocketOptions {
-  /** Sub-protocols negotiated during the handshake. */
-  protocols?: string | string[];
-  /**
-   * Custom request headers.
-   *
-   * @remarks
-   * Honoured on Node via the `ws` package; runtimes that ship a WHATWG
-   * `WebSocket` (Bun, Deno, browsers, Node ≥ 22) ignore them — matching
-   * standard WebSocket semantics.
-   */
-  headers?: Record<string, string>;
-}
-
-/**
- * Raw upgrade tuple consumed by {@link WebSocketServer.upgrade}.
- *
- * @remarks
- * Mirrors what `node:http`'s `'upgrade'` event emits and what the `ws`
- * package's `WebSocketServer.handleUpgrade` consumes.
- */
-export interface UpgradeRequest {
-  /** Raw `IncomingMessage`-like object exposing `headers`, `method`, `url`. */
-  rawRequest: any;
-  /** Raw duplex socket (e.g. `node:net.Socket`). */
-  socket: any;
-  /** Initial buffer captured by the HTTP parser. */
-  head: Buffer | Uint8Array;
-}
-
-/**
- * Options forwarded to {@link WebSocketServer.upgrade}.
- *
- * @typeParam Data - Shape of the user-attached `data` field
- */
-export interface UpgradeOptions<Data extends WSData = WSData> {
-  /** Initial value of `ws.data` for the new connection. */
-  data?: Data;
-  /**
-   * Extra response headers.
-   *
-   * @remarks
-   * Forwarded to the underlying handshake when supported (Bun); ignored on
-   * Node-backed upgrades, which control headers via the `ws` package.
-   */
-  headers?: Record<string, string> | Headers;
-}

package/tsconfig.json

@@ -1,3 +0,0 @@
-{
-  "extends": "../../tsconfig.json"
-}

package/tsdown.config.ts

@@ -1,12 +0,0 @@
-import { defineConfig } from "tsdown";
-
-export default defineConfig({
-  entry: ["src/index.ts", "src/client.ts", "src/server.ts"],
-  format: ["cjs", "esm"],
-  dts: true,
-  sourcemap: true,
-  treeshake: true,
-  clean: true,
-  unbundle: true,
-  outputOptions: { exports: "named" },
-});